Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.c++ > #121995 > unrolled thread

neos Universal Compiler

Back to article view | Back to comp.lang.c++

Contents

  neos Universal Compiler Mr Flibble <flibble@reddwarf.jmc.corp> - 2025-03-17 17:21 +0000
    Re: neos Universal Compiler Mr Flibble <flibble@reddwarf.jmc.corp> - 2025-03-19 04:59 +0000
      Re: neos Universal Compiler Muttley@DastardlyHQ.org - 2025-03-19 08:41 +0000
        Re: neos Universal Compiler Mr Flibble <flibble@reddwarf.jmc.corp> - 2025-03-19 14:35 +0000
          Re: neos Universal Compiler Muttley@DastardlyHQ.org - 2025-03-19 14:41 +0000
            Re: neos Universal Compiler Mr Flibble <flibble@reddwarf.jmc.corp> - 2025-03-19 14:44 +0000
              Re: neos Universal Compiler Richard Heathfield <rjh@cpax.org.uk> - 2025-03-19 15:07 +0000
                Re: neos Universal Compiler Mr Flibble <flibble@reddwarf.jmc.corp> - 2025-03-19 15:16 +0000
                  Re: neos Universal Compiler Muttley@DastardlyHQ.org - 2025-03-19 15:46 +0000
                    Re: neos Universal Compiler Mr Flibble <flibble@reddwarf.jmc.corp> - 2025-03-19 15:48 +0000
                      Re: neos Universal Compiler Muttley@DastardlyHQ.org - 2025-03-19 16:29 +0000
                  Re: neos Universal Compiler Richard Heathfield <rjh@cpax.org.uk> - 2025-03-19 17:20 +0000
                    Re: neos Universal Compiler Mr Flibble <flibble@reddwarf.jmc.corp> - 2025-03-19 17:26 +0000
                      Re: neos Universal Compiler Richard Heathfield <rjh@cpax.org.uk> - 2025-03-19 17:42 +0000
              Re: neos Universal Compiler Muttley@DastardlyHQ.org - 2025-03-19 15:43 +0000

#121995 — neos Universal Compiler

Introducing the universal compiler, neos, that can compile ANY programming 
language.

The following schema (grammar) file is an input to the compiler:

%{
    meta: {
        language: "neoscript"
        description: "Default neoGFX scripting language"
        source.file.extension: ".neo"
        source.package.specification.file.extension: ".neo"
        source.package.implementation.file.extension: ".neo"
        copyright: "Copyright (C) 2024 Leigh Johnston"
        version: "1.0.0"
    }

    stages: {
        tokenizer : {
            text : [ "#{" "}#" ]
        }
        parser : {
            text : [ "*{" "}*" ]
            root : program
        }
    }

    pipeline: [
        tokenizer
        parser
    ]

    libraries: [
        neos.core
        neos.math.universal
    ]

    discard: [ 
        whitespace
        comment
        WS
    ]

    infix: [
        math.operator.add
        math.operator.subtract
        math.operator.multiply
        math.operator.divide
    ]
}%

#{
    character literal ::= 
        ( '\'' , ( ( ' ' .. '\xFF' - ( '\\' | '\"' | '\'' ) ) | escaped 
character ) $ string.utf8.character, '\'' ) ;
    string literal ::= 
        { '\"' , { ( ( ' ' .. '\xFF' - ( '\\' | '\"' | '\'' ) ) | escaped 
character ) } $ string.utf8 , '\"' , [ whitespace ] } + ;
    escaped character $ string.utf8.character.LF ::= "\\n" ;
    escaped character $ string.utf8.character.CR ::= "\\r" ;
    escaped character $ string.utf8.character.tab ::= "\\t" ;
    escaped character $ string.utf8.character.singlequote ::= "\\\'" ;
    escaped character $ string.utf8.character.doublequote ::= "\\\"" ;
    escaped character $ string.utf8.character.backslash ::= "\\\\" ;

    using $ language.keyword ::= potential keyword ::= "using" ;
    import $ language.keyword ::= potential keyword ::= "import" ;
    namespace $ language.keyword ::= potential keyword ::= "namespace" ;
    public $ language.keyword ::= potential keyword ::= "public" ;
    protected $ language.keyword ::= potential keyword ::= "protected" ;
    private $ language.keyword ::= potential keyword ::= "private" ;
    override $ language.keyword ::= potential keyword ::= "override" ;
    final $ language.keyword ::= potential keyword ::= "final" ;
    mutable $ language.keyword ::= potential keyword ::= "mutable" ;
    is $ language.keyword ::= potential keyword ::= "is" ;
    extends $ language.keyword ::= potential keyword ::= "extends" ;
    implements $ language.keyword ::= potential keyword ::= "implements" ;
    struct $ language.keyword ::= potential keyword ::= "struct" ;
    class $ language.keyword ::= potential keyword ::= "class" ;
    interface $ language.keyword ::= potential keyword ::= "interface" ;
    auto $ language.type.auto ::= potential keyword ::= "auto" ;
    def $ language.keyword ::= potential keyword ::= "def" ;
    fn $ language.keyword ::= potential keyword ::= "fn" ;
    proc $ language.keyword ::= potential keyword ::= "proc" ;
    in $ language.keyword $ language.function.parameter.in ::= potential 
keyword ::= "in" ;
    out $ language.keyword $ language.function.parameter.out ::= potential 
keyword ::= "out" ;
    inout $ language.keyword $ language.function.parameter.inout ::= 
potential keyword ::= "inout" ;
    if $ language.keyword ::= potential keyword ::= "if" ;
    else $ language.keyword ::= potential keyword ::= "else" ;
    for $ language.keyword ::= potential keyword ::= "for" ;
    while $ language.keyword ::= potential keyword ::= "while" ;
    do $ language.keyword ::= potential keyword ::= "do" ;
    return $ language.keyword ::= potential keyword ::= "return" ;

    number $ math.universal.number ::= 
        digit sequence , [ '.' , digit sequence , [ ( "e" | "E" ) , [ "+" 
| "-" ] , digit sequence ] ] ;
    digit sequence ::= 
        digit , { digit } ;
    digit ::= 
        "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;

    isize $ language.type.object.size.signed ::= potential keyword ::= 
"isize" ;
    usize $ language.type.object.size.unsigned ::= potential keyword ::= 
"usize" ;
    bool $ language.type.boolean ::= potential keyword ::= "bool" ;
    i8 $ language.type.i8 ::= potential keyword ::= "i8" ;
    u8 $ language.type.u8 ::= potential keyword ::= "u8" ;
    i16 $ language.type.i16 ::= potential keyword ::= "i16" ;
    u16 $ language.type.u16 ::= potential keyword ::= "u16" ;
    i32 $ language.type.i32 ::= potential keyword ::= "i32" ;
    u32 $ language.type.u32 ::= potential keyword ::= "u32" ;
    i64 $ language.type.i64 ::= potential keyword ::= "i64" ;
    u64 $ language.type.u64 ::= potential keyword ::= "u64" ;
    float $ language.type.float ::= potential keyword ::= "float" ;
    double $ language.type.double ::= potential keyword ::= "double" ;
    character $ language.type.character ::= potential keyword ::= "char" ;
    string $ language.type.string ::= potential keyword ::= "string" ;

    true $ language.object.boolean.true ::= potential keyword ::= "true" ;
    false $ language.object.boolean.false ::= potential keyword ::= 
"false" ;

    identifier ::= { namespace , namespace separator } , ( alpha , 
{ alphanumeric | '_' } ) $ language.identifier ;
    namespace $ language.namespace ::= alpha , { alphanumeric | '_' } ;
    package name ::= alpha , { alpha | ( "." , alpha ) } ; 
    potential keyword ::= { alphanumeric } + ;

    alpha ::= 'A' .. 'Z' | 'a' .. 'z' ;
    alphanumeric ::= alpha | '0' .. '9' ;

    open expression ::= "(" ;
    close expression ::= ")" ;
    open scope $ language.scope.open ::= "{" ;
    close scope $ language.scope.close ::= "}" ;
    comma ::= "," ;
    colon ::= ":" ;
    semicolon ::= ";" ;
    arrow ::= "->" ; 
    namespace separator ::= "::" ;
    
    assign ::= "=" ;

    not ::= "!" ;
    or ::= "||" ;
    and ::= "&&" ;

    equal ::= "==" ;
    notequal ::= "!=" ;
    lessthan ::= "<" ;
    greaterthan ::= ">" ;
    lessthanorequal ::= "<=" ;
    greaterthanorequal ::= ">=" ;

    plus ::= "+" ;
    minus ::= "-" ;
    multiply ::= "*" ;
    divide ::= "/" ;

    comment $ language.comment ::= "--" , { ! '\n' .. '\n' } , ( '\n' | ? 
eof ? ) ;
    whitespace $ language.whitespace ::= { ' ' | '\n' | '\r' | '\t' | 
comment | ? eof ? } + ;
}#

*{
    program $ language.program ::= { WS , ( using directive | import 
directive | namespace scope ) , WS } ;
    using directive $ source.package.import ::= ( using , WS , 
( identifier | package name ) $ source.package.name , WS , semicolon ) ;
    import directive $ language.function.import ::= ( import , WS , fn , 
WS , fn sig , WS , semicolon ) ;
    import directive $ language.function.import ::= ( import , WS , proc , 
WS , proc sig , WS , semicolon ) ;

    namespace scope $ language.namespace.scope ::= 
        { comment | function | procedure | namespace def } ;
    namespace def $ language.namespace ::= 
        identifier $ language.namespace.name , WS , open scope , WS , 
namespace scope , WS , close scope ;

    function $ language.function ::= ( fn , WS , fn sig , WS , fn body ) ;
    procedure $ language.function ::= ( proc , WS , proc sig , WS , proc 
locals , WS , proc body ) ;
    fn sig $ language.function.signature ::= ( identifier , WS , open 
expression , WS , fn parameters , WS , close expression , WS , arrow , 
WS , type ) ;
    proc sig $ language.function.signature ::= ( identifier , WS , open 
expression , WS , proc parameters , WS , close expression ) ;
    fn parameters $ language.function.parameters ::= [ fn parameter 
block , { WS , semicolon , WS , fn parameter block } ] ;
    proc parameters $ language.function.parameters ::= [ proc parameter 
block , { WS , semicolon , WS , proc parameter block } ] ;
    fn parameter block ::= [ parameter , { WS , comma , WS , parameter } , 
WS , colon , WS , type ] ;
    proc parameter block ::= [ parameter , { WS , comma , WS , 
parameter } , WS , colon , WS , ( in | out | inout ) , WS , type ] ;
    parameter $ language.function.parameter ::= identifier ;
    proc locals ::= ( proc local block , { WS , semicolon , WS , proc 
local block } ) ;
    proc local block ::= [ local , { WS , comma , WS , local } , WS , 
colon , WS , type ] ;
    local $ language.function.local ::= identifier ;
    fn body $ language.function.body ::= scope ;
    proc body $ language.function.body ::= scope ;
    scope $ language.function.scope ::= ( open scope , { WS , 
statement } , WS , close scope ) ; 

    statement $ language.statement ::= 
        ( expression , WS , semicolon ) | ( assignment , WS , semicolon ) 
| return statement | if statement | for loop | while loop | do while loop ;

    assignment $ language.assignment ::= 
        ( object , WS , assign , WS , expression ) ;

    expression $ language.expression ::= 
        function call | numeric expression | boolean expression ;

    function call $ language.expression.call ::= 
        identifier $ language.function.name , WS , open expression , WS , 
arguments , WS , close expression ;

    arguments ::= [ expression , { WS , comma , WS , expression } ] ;

    boolean expression $ language.expression.boolean ::= 
          boolean term , { WS , or , WS , boolean term } $ 
boolean.logic.operator.or ;
    boolean term ::= 
          boolean factor , { WS , and , WS , boolean factor } $ 
boolean.logic.operator.and ;
    boolean factor ::= 
          true 
        | false 
        | ( not , WS , boolean factor ) $ boolean.logic.operator.not
        | ( open expression , WS , boolean expression , WS , close 
expression )
        | comparison expression ;
    comparison expression ::= 
          numeric expression , WS , comparison operator , WS , numeric 
expression ;
    comparison operator ::= 
          equal $ boolean.operator.relational.equal
        | notequal $ boolean.operator.relational.notequal
        | lessthan $ boolean.operator.relational.lessthan
        | greaterthan $ boolean.operator.relational.greaterthan
        | lessthanorequal $ boolean.operator.relational.lessthanorequal
        | greaterthanorequal $ 
boolean.operator.relational.greaterthanorequal ;

    numeric expression $ math.expression ::= 
        term , { WS , ( plus $ math.operator.add | minus $ 
math.operator.subtract ) , WS , term } ;
    term ::= 
        factor , { WS , ( multiply $ math.operator.multiply | divide $ 
math.operator.divide ) , WS , factor } ;
    factor ::= 
        [ minus $ math.operator.negate , WS ] , primary ;
    primary ::= 
        ( open expression , WS , expression , WS , close expression ) | 
function call | number | identifier | character literal | string literal ;

    return statement $ language.statement.return ::= 
        ( return , WS , expression , WS , semicolon ) ;

    if statement $ language.statement.if ::= 
        if , ( WS , open expression , WS , boolean expression , WS , close 
expression , WS , ( scope | statement ) ) $ logic.operator.if , { WS , 
else if statement } , [ WS , else statement ] ;
    else if statement $ language.statement.elseif ::= 
        else if , ( WS , open expression , WS , boolean expression , WS , 
close expression , WS , ( scope | statement ) ) $ logic.operator.elseif ;
    else statement $ language.statement.else ::= 
        else , WS , ( scope | statement ) $ logic.operator.else ;

    for loop $ language.statement.loop ::= 
        for clause , WS , scope ;
    for clause ::=
        for , WS , open expression , WS , [ local , WS , colon , WS , 
type , WS , assign , WS , expression ] $ language.assignment , WS ,
        semicolon , WS , boolean expression , WS , semicolon , WS , 
( expression | assignment ) , WS , close expression ;

    while loop $ language.statement.loop ::= 
        while clause , WS , scope ;
    while clause ::=
        while , WS , open expression , WS , boolean expression , WS , 
close expression ;

    do while loop $ language.statement.loop ::= 
        do , WS , scope, WS , while clause ;

    type ::= bool | i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64 | float | 
double | character | string | object ;

    WS ::= [ whitespace ] ;
}*

which is used to compile the following program:

-- neoscript example: Fibonacci

using neo.string;
using neo.stream;

-- functions are pure
fn add(x, y : i32) -> i32
{
    return x + y;
}
fn fib(x : i32) -> i32 
{
    if (x < 2) 
        return 1; 
    else
        return add(fib(x-1), fib(x-2));
}

-- procedures are impure
proc main()
    s : string;
{
   neo::print("Enter a positive "
           "integer: ");
   neo::input(s);
   neo::print("Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::to_integer(s))) + "\n");
}

which generates the following AST (semantics):

 source.package.import = [using neo.string;]
  language.keyword = [using]
  source.package.name = [neo.string]
 source.package.import = [using neo.stream;]
  language.keyword = [using]
  source.package.name = [neo.stream]
 language.namespace.scope = [fn add(x, y : i32) -> i32\r\n{\r\n    return 
x + y;\r\n}]
  language.function = [fn add(x, y : i32) -> i32\r\n{\r\n    return x + y;
\r\n}]
   language.keyword = [fn]
   language.function.signature = [add(x, y : i32) -> i32]
    language.identifier = [add]
    language.function.parameters = [x, y : i32]
     language.function.parameter = [x]
      language.identifier = [x]
     language.function.parameter = [y]
      language.identifier = [y]
     language.type.i32 = [i32]
    language.type.i32 = [i32]
   language.function.body = [{\r\n    return x + y;\r\n}]
    language.function.scope = [{\r\n    return x + y;\r\n}]
     language.scope.open = [{]
     language.statement = [return x + y;]
      language.statement.return = [return x + y;]
       language.keyword = [return]
       language.expression = [x + y]
        math.expression = [x + y]
         language.identifier = [x]
         math.operator.add = [+]
         language.identifier = [y]
     language.scope.close = [}]
 language.namespace.scope = [fn fib(x : i32) -> i32 \r\n{\r\n    if (x < 
2) \r\n        return 1; \r...]
  language.function = [fn fib(x : i32) -> i32 \r\n{\r\n    if (x < 2) 
\r\n        return 1; \r...]
   language.keyword = [fn]
   language.function.signature = [fib(x : i32) -> i32]
    language.identifier = [fib]
    language.function.parameters = [x : i32]
     language.function.parameter = [x]
      language.identifier = [x]
     language.type.i32 = [i32]
    language.type.i32 = [i32]
   language.function.body = [{\r\n    if (x < 2) \r\n        return 1; 
\r\n    else\r\n        return...]
    language.function.scope = [{\r\n    if (x < 2) \r\n        return 1; 
\r\n    else\r\n        return...]
     language.scope.open = [{]
     language.statement = [if (x < 2) \r\n        return 1; \r\n    
else\r\n        return add(fi...]
      logic.operator.if = [if (x < 2) \r\n        return 1; \r\n    
else\r\n        return add(fi...]
       language.keyword = [if]
       language.expression.boolean = [x < 2]
        math.expression = [x]
         language.identifier = [x]
        boolean.operator.relational.lessthan = [<]
        math.expression = [2]
         math.universal.number = [2]
       language.statement = [return 1;]
        language.statement.return = [return 1;]
         language.keyword = [return]
         language.expression = [1]
          math.expression = [1]
           math.universal.number = [1]
       language.statement.else = [else\r\n        return add(fib(x-1), 
fib(x-2));]
        language.keyword = [else]
        language.statement = [return add(fib(x-1), fib(x-2));]
         language.statement.return = [return add(fib(x-1), fib(x-2));]
          language.keyword = [return]
          language.expression = [add(fib(x-1), fib(x-2))]
           language.expression.call = [add(fib(x-1), fib(x-2))]
            language.function.name = [add]
            language.expression = [fib(x-1)]
             language.expression.call = [fib(x-1)]
              language.function.name = [fib]
              language.expression = [x-1]
               math.expression = [x-1]
                language.identifier = [x]
                math.operator.subtract = [-]
                math.universal.number = [1]
            language.expression = [fib(x-2)]
             language.expression.call = [fib(x-2)]
              language.function.name = [fib]
              language.expression = [x-2]
               math.expression = [x-2]
                language.identifier = [x]
                math.operator.subtract = [-]
                math.universal.number = [2]
     language.scope.close = [}]
 language.namespace.scope = [proc main()\r\n    s : string;\r\n{\r\n   
neo::print("Enter a positive...]
  language.function = [proc main()\r\n    s : string;\r\n{\r\n   
neo::print("Enter a positive...]
   language.keyword = [proc]
   language.function.signature = [main()]
    language.identifier = [main]
    language.function.parameters = []
   language.function.local = [s]
    language.identifier = [s]
   language.type.string = [string]
   language.function.body = [{\r\n   neo::print("Enter a positive 
"\r\n           "integer: ");\r\n...]
    language.function.scope = [{\r\n   neo::print("Enter a positive 
"\r\n           "integer: ");\r\n...]
     language.scope.open = [{]
     language.statement = [neo::print("Enter a positive "\r\n           
"integer: ");]
      language.expression = [neo::print("Enter a positive "\r\n           
"integer: ")]
       language.expression.call = [neo::print("Enter a positive 
"\r\n           "integer: ")]
        language.function.name = [neo::print]
         language.namespace = [neo]
        language.expression = ["Enter a positive "\r\n           "integer: 
"]
         math.expression = ["Enter a positive "\r\n           "integer: "]
          string.utf8 = [Enter a positive ]
          string.utf8 = [integer: ]
     language.statement = [neo::input(s);]
      language.expression = [neo::input(s)]
       language.expression.call = [neo::input(s)]
        language.function.name = [neo::input]
         language.namespace = [neo]
        language.expression = [s]
         math.expression = [s]
          language.identifier = [s]
     language.statement = [neo::print("Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::t...]
      language.expression = [neo::print("Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::t...]
       language.expression.call = [neo::print("Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::t...]
        language.function.name = [neo::print]
         language.namespace = [neo]
        language.expression = ["Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::to_integer(s...]
         math.expression = ["Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::to_integer(s...]
          string.utf8 = [Fibonacci(]
          math.operator.add = [+]
          language.identifier = [s]
          math.operator.add = [+]
          string.utf8 = [) = ]
          math.operator.add = [+]
          language.expression.call = 
[neo::to_string(fib(neo::to_integer(s)))]
           language.function.name = [neo::to_string]
            language.namespace = [neo]
           language.expression = [fib(neo::to_integer(s))]
            language.expression.call = [fib(neo::to_integer(s))]
             language.function.name = [fib]
             language.expression = [neo::to_integer(s)]
              language.expression.call = [neo::to_integer(s)]
               language.function.name = [neo::to_integer]
                language.namespace = [neo]
               language.expression = [s]
                math.expression = [s]
                 language.identifier = [s]
          math.operator.add = [+]
          string.utf8 = [\n]
           string.utf8.character.LF = [\n]
     language.scope.close = [}]
 language.namespace.scope = []
 language.namespace.scope = []

/Flibble

[toc] | [next] | [standalone]

#121998

On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:

> Introducing the universal compiler, neos, that can compile ANY
> programming language.
> 
> The following schema (grammar) file is an input to the compiler:
> 
> %{
>     meta: {
>         language: "neoscript"
>         description: "Default neoGFX scripting language"
>         source.file.extension: ".neo"
>         source.package.specification.file.extension: ".neo"
>         source.package.implementation.file.extension: ".neo"
>         copyright: "Copyright (C) 2024 Leigh Johnston"
>         version: "1.0.0"
>     }
> 
>     stages: {
>         tokenizer : {
>             text : [ "#{" "}#" ]
>         }
>         parser : {
>             text : [ "*{" "}*" ]
>             root : program
>         }
>     }
> 
>     pipeline: [
>         tokenizer parser
>     ]
> 
>     libraries: [
>         neos.core neos.math.universal
>     ]
> 
>     discard: [
>         whitespace comment WS
>     ]
> 
>     infix: [
>         math.operator.add math.operator.subtract math.operator.multiply
>         math.operator.divide
>     ]
> }%
> 
> #{
>     character literal ::=
>         ( '\'' , ( ( ' ' .. '\xFF' - ( '\\' | '\"' | '\'' ) ) | escaped
> character ) $ string.utf8.character, '\'' ) ;
>     string literal ::=
>         { '\"' , { ( ( ' ' .. '\xFF' - ( '\\' | '\"' | '\'' ) ) |
>         escaped
> character ) } $ string.utf8 , '\"' , [ whitespace ] } + ;
>     escaped character $ string.utf8.character.LF ::= "\\n" ;
>     escaped character $ string.utf8.character.CR ::= "\\r" ;
>     escaped character $ string.utf8.character.tab ::= "\\t" ;
>     escaped character $ string.utf8.character.singlequote ::= "\\\'" ;
>     escaped character $ string.utf8.character.doublequote ::= "\\\"" ;
>     escaped character $ string.utf8.character.backslash ::= "\\\\" ;
> 
>     using $ language.keyword ::= potential keyword ::= "using" ;
>     import $ language.keyword ::= potential keyword ::= "import" ;
>     namespace $ language.keyword ::= potential keyword ::= "namespace" ;
>     public $ language.keyword ::= potential keyword ::= "public" ;
>     protected $ language.keyword ::= potential keyword ::= "protected" ;
>     private $ language.keyword ::= potential keyword ::= "private" ;
>     override $ language.keyword ::= potential keyword ::= "override" ;
>     final $ language.keyword ::= potential keyword ::= "final" ;
>     mutable $ language.keyword ::= potential keyword ::= "mutable" ;
>     is $ language.keyword ::= potential keyword ::= "is" ;
>     extends $ language.keyword ::= potential keyword ::= "extends" ;
>     implements $ language.keyword ::= potential keyword ::= "implements"
>     ;
>     struct $ language.keyword ::= potential keyword ::= "struct" ;
>     class $ language.keyword ::= potential keyword ::= "class" ;
>     interface $ language.keyword ::= potential keyword ::= "interface" ;
>     auto $ language.type.auto ::= potential keyword ::= "auto" ;
>     def $ language.keyword ::= potential keyword ::= "def" ;
>     fn $ language.keyword ::= potential keyword ::= "fn" ;
>     proc $ language.keyword ::= potential keyword ::= "proc" ;
>     in $ language.keyword $ language.function.parameter.in ::= potential
> keyword ::= "in" ;
>     out $ language.keyword $ language.function.parameter.out ::=
>     potential
> keyword ::= "out" ;
>     inout $ language.keyword $ language.function.parameter.inout ::=
> potential keyword ::= "inout" ;
>     if $ language.keyword ::= potential keyword ::= "if" ;
>     else $ language.keyword ::= potential keyword ::= "else" ;
>     for $ language.keyword ::= potential keyword ::= "for" ;
>     while $ language.keyword ::= potential keyword ::= "while" ;
>     do $ language.keyword ::= potential keyword ::= "do" ;
>     return $ language.keyword ::= potential keyword ::= "return" ;
> 
>     number $ math.universal.number ::=
>         digit sequence , [ '.' , digit sequence , [ ( "e" | "E" ) , [
>         "+"
> | "-" ] , digit sequence ] ] ;
>     digit sequence ::=
>         digit , { digit } ;
>     digit ::=
>         "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
> 
>     isize $ language.type.object.size.signed ::= potential keyword ::=
> "isize" ;
>     usize $ language.type.object.size.unsigned ::= potential keyword ::=
> "usize" ;
>     bool $ language.type.boolean ::= potential keyword ::= "bool" ;
>     i8 $ language.type.i8 ::= potential keyword ::= "i8" ;
>     u8 $ language.type.u8 ::= potential keyword ::= "u8" ;
>     i16 $ language.type.i16 ::= potential keyword ::= "i16" ;
>     u16 $ language.type.u16 ::= potential keyword ::= "u16" ;
>     i32 $ language.type.i32 ::= potential keyword ::= "i32" ;
>     u32 $ language.type.u32 ::= potential keyword ::= "u32" ;
>     i64 $ language.type.i64 ::= potential keyword ::= "i64" ;
>     u64 $ language.type.u64 ::= potential keyword ::= "u64" ;
>     float $ language.type.float ::= potential keyword ::= "float" ;
>     double $ language.type.double ::= potential keyword ::= "double" ;
>     character $ language.type.character ::= potential keyword ::= "char"
>     ;
>     string $ language.type.string ::= potential keyword ::= "string" ;
> 
>     true $ language.object.boolean.true ::= potential keyword ::= "true"
>     ;
>     false $ language.object.boolean.false ::= potential keyword ::=
> "false" ;
> 
>     identifier ::= { namespace , namespace separator } , ( alpha ,
> { alphanumeric | '_' } ) $ language.identifier ;
>     namespace $ language.namespace ::= alpha , { alphanumeric | '_' } ;
>     package name ::= alpha , { alpha | ( "." , alpha ) } ;
>     potential keyword ::= { alphanumeric } + ;
> 
>     alpha ::= 'A' .. 'Z' | 'a' .. 'z' ;
>     alphanumeric ::= alpha | '0' .. '9' ;
> 
>     open expression ::= "(" ;
>     close expression ::= ")" ;
>     open scope $ language.scope.open ::= "{" ;
>     close scope $ language.scope.close ::= "}" ;
>     comma ::= "," ;
>     colon ::= ":" ;
>     semicolon ::= ";" ;
>     arrow ::= "->" ;
>     namespace separator ::= "::" ;
>     
>     assign ::= "=" ;
> 
>     not ::= "!" ;
>     or ::= "||" ;
>     and ::= "&&" ;
> 
>     equal ::= "==" ;
>     notequal ::= "!=" ;
>     lessthan ::= "<" ;
>     greaterthan ::= ">" ;
>     lessthanorequal ::= "<=" ;
>     greaterthanorequal ::= ">=" ;
> 
>     plus ::= "+" ;
>     minus ::= "-" ;
>     multiply ::= "*" ;
>     divide ::= "/" ;
> 
>     comment $ language.comment ::= "--" , { ! '\n' .. '\n' } , ( '\n' |
>     ?
> eof ? ) ;
>     whitespace $ language.whitespace ::= { ' ' | '\n' | '\r' | '\t' |
> comment | ? eof ? } + ;
> }#
> 
> *{
>     program $ language.program ::= { WS , ( using directive | import
> directive | namespace scope ) , WS } ;
>     using directive $ source.package.import ::= ( using , WS ,
> ( identifier | package name ) $ source.package.name , WS , semicolon ) ;
>     import directive $ language.function.import ::= ( import , WS , fn ,
> WS , fn sig , WS , semicolon ) ;
>     import directive $ language.function.import ::= ( import , WS , proc
>     ,
> WS , proc sig , WS , semicolon ) ;
> 
>     namespace scope $ language.namespace.scope ::=
>         { comment | function | procedure | namespace def } ;
>     namespace def $ language.namespace ::=
>         identifier $ language.namespace.name , WS , open scope , WS ,
> namespace scope , WS , close scope ;
> 
>     function $ language.function ::= ( fn , WS , fn sig , WS , fn body )
>     ;
>     procedure $ language.function ::= ( proc , WS , proc sig , WS , proc
> locals , WS , proc body ) ;
>     fn sig $ language.function.signature ::= ( identifier , WS , open
> expression , WS , fn parameters , WS , close expression , WS , arrow ,
> WS , type ) ;
>     proc sig $ language.function.signature ::= ( identifier , WS , open
> expression , WS , proc parameters , WS , close expression ) ;
>     fn parameters $ language.function.parameters ::= [ fn parameter
> block , { WS , semicolon , WS , fn parameter block } ] ;
>     proc parameters $ language.function.parameters ::= [ proc parameter
> block , { WS , semicolon , WS , proc parameter block } ] ;
>     fn parameter block ::= [ parameter , { WS , comma , WS , parameter }
>     ,
> WS , colon , WS , type ] ;
>     proc parameter block ::= [ parameter , { WS , comma , WS ,
> parameter } , WS , colon , WS , ( in | out | inout ) , WS , type ] ;
>     parameter $ language.function.parameter ::= identifier ;
>     proc locals ::= ( proc local block , { WS , semicolon , WS , proc
> local block } ) ;
>     proc local block ::= [ local , { WS , comma , WS , local } , WS ,
> colon , WS , type ] ;
>     local $ language.function.local ::= identifier ;
>     fn body $ language.function.body ::= scope ;
>     proc body $ language.function.body ::= scope ;
>     scope $ language.function.scope ::= ( open scope , { WS ,
> statement } , WS , close scope ) ;
> 
>     statement $ language.statement ::=
>         ( expression , WS , semicolon ) | ( assignment , WS , semicolon
>         )
> | return statement | if statement | for loop | while loop | do while
> loop ;
> 
>     assignment $ language.assignment ::=
>         ( object , WS , assign , WS , expression ) ;
> 
>     expression $ language.expression ::=
>         function call | numeric expression | boolean expression ;
> 
>     function call $ language.expression.call ::=
>         identifier $ language.function.name , WS , open expression , WS
>         ,
> arguments , WS , close expression ;
> 
>     arguments ::= [ expression , { WS , comma , WS , expression } ] ;
> 
>     boolean expression $ language.expression.boolean ::=
>           boolean term , { WS , or , WS , boolean term } $
> boolean.logic.operator.or ;
>     boolean term ::=
>           boolean factor , { WS , and , WS , boolean factor } $
> boolean.logic.operator.and ;
>     boolean factor ::=
>           true
>         | false | ( not , WS , boolean factor ) $
>         boolean.logic.operator.not | ( open expression , WS , boolean
>         expression , WS , close
> expression )
>         | comparison expression ;
>     comparison expression ::=
>           numeric expression , WS , comparison operator , WS , numeric
> expression ;
>     comparison operator ::=
>           equal $ boolean.operator.relational.equal
>         | notequal $ boolean.operator.relational.notequal | lessthan $
>         boolean.operator.relational.lessthan | greaterthan $
>         boolean.operator.relational.greaterthan | lessthanorequal $
>         boolean.operator.relational.lessthanorequal | greaterthanorequal
>         $
> boolean.operator.relational.greaterthanorequal ;
> 
>     numeric expression $ math.expression ::=
>         term , { WS , ( plus $ math.operator.add | minus $
> math.operator.subtract ) , WS , term } ;
>     term ::=
>         factor , { WS , ( multiply $ math.operator.multiply | divide $
> math.operator.divide ) , WS , factor } ;
>     factor ::=
>         [ minus $ math.operator.negate , WS ] , primary ;
>     primary ::=
>         ( open expression , WS , expression , WS , close expression ) |
> function call | number | identifier | character literal | string literal
> ;
> 
>     return statement $ language.statement.return ::=
>         ( return , WS , expression , WS , semicolon ) ;
> 
>     if statement $ language.statement.if ::=
>         if , ( WS , open expression , WS , boolean expression , WS ,
>         close
> expression , WS , ( scope | statement ) ) $ logic.operator.if , { WS ,
> else if statement } , [ WS , else statement ] ;
>     else if statement $ language.statement.elseif ::=
>         else if , ( WS , open expression , WS , boolean expression , WS
>         ,
> close expression , WS , ( scope | statement ) ) $ logic.operator.elseif
> ;
>     else statement $ language.statement.else ::=
>         else , WS , ( scope | statement ) $ logic.operator.else ;
> 
>     for loop $ language.statement.loop ::=
>         for clause , WS , scope ;
>     for clause ::=
>         for , WS , open expression , WS , [ local , WS , colon , WS ,
> type , WS , assign , WS , expression ] $ language.assignment , WS ,
>         semicolon , WS , boolean expression , WS , semicolon , WS ,
> ( expression | assignment ) , WS , close expression ;
> 
>     while loop $ language.statement.loop ::=
>         while clause , WS , scope ;
>     while clause ::=
>         while , WS , open expression , WS , boolean expression , WS ,
> close expression ;
> 
>     do while loop $ language.statement.loop ::=
>         do , WS , scope, WS , while clause ;
> 
>     type ::= bool | i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64 | float
>     |
> double | character | string | object ;
> 
>     WS ::= [ whitespace ] ;
> }*
> 
> which is used to compile the following program:
> 
> -- neoscript example: Fibonacci
> 
> using neo.string;
> using neo.stream;
> 
> -- functions are pure fn add(x, y : i32) -> i32 {
>     return x + y;
> }
> fn fib(x : i32) -> i32 {
>     if (x < 2)
>         return 1;
>     else
>         return add(fib(x-1), fib(x-2));
> }
> 
> -- procedures are impure proc main()
>     s : string;
> {
>    neo::print("Enter a positive "
>            "integer: ");
>    neo::input(s);
>    neo::print("Fibonacci(" + s + ") = " +
> neo::to_string(fib(neo::to_integer(s))) + "\n");
> }
> 
> which generates the following AST (semantics):
> 
>  source.package.import = [using neo.string;]
>   language.keyword = [using]
>   source.package.name = [neo.string]
>  source.package.import = [using neo.stream;]
>   language.keyword = [using]
>   source.package.name = [neo.stream]
>  language.namespace.scope = [fn add(x, y : i32) -> i32\r\n{\r\n   
>  return
> x + y;\r\n}]
>   language.function = [fn add(x, y : i32) -> i32\r\n{\r\n    return x +
>   y;
> \r\n}]
>    language.keyword = [fn]
>    language.function.signature = [add(x, y : i32) -> i32]
>     language.identifier = [add]
>     language.function.parameters = [x, y : i32]
>      language.function.parameter = [x]
>       language.identifier = [x]
>      language.function.parameter = [y]
>       language.identifier = [y]
>      language.type.i32 = [i32]
>     language.type.i32 = [i32]
>    language.function.body = [{\r\n    return x + y;\r\n}]
>     language.function.scope = [{\r\n    return x + y;\r\n}]
>      language.scope.open = [{]
>      language.statement = [return x + y;]
>       language.statement.return = [return x + y;]
>        language.keyword = [return]
>        language.expression = [x + y]
>         math.expression = [x + y]
>          language.identifier = [x]
>          math.operator.add = [+]
>          language.identifier = [y]
>      language.scope.close = [}]
>  language.namespace.scope = [fn fib(x : i32) -> i32 \r\n{\r\n    if (x <
> 2) \r\n        return 1; \r...]
>   language.function = [fn fib(x : i32) -> i32 \r\n{\r\n    if (x < 2)
> \r\n        return 1; \r...]
>    language.keyword = [fn]
>    language.function.signature = [fib(x : i32) -> i32]
>     language.identifier = [fib]
>     language.function.parameters = [x : i32]
>      language.function.parameter = [x]
>       language.identifier = [x]
>      language.type.i32 = [i32]
>     language.type.i32 = [i32]
>    language.function.body = [{\r\n    if (x < 2) \r\n        return 1;
> \r\n    else\r\n        return...]
>     language.function.scope = [{\r\n    if (x < 2) \r\n        return 1;
> \r\n    else\r\n        return...]
>      language.scope.open = [{]
>      language.statement = [if (x < 2) \r\n        return 1; \r\n
> else\r\n        return add(fi...]
>       logic.operator.if = [if (x < 2) \r\n        return 1; \r\n
> else\r\n        return add(fi...]
>        language.keyword = [if]
>        language.expression.boolean = [x < 2]
>         math.expression = [x]
>          language.identifier = [x]
>         boolean.operator.relational.lessthan = [<]
>         math.expression = [2]
>          math.universal.number = [2]
>        language.statement = [return 1;]
>         language.statement.return = [return 1;]
>          language.keyword = [return]
>          language.expression = [1]
>           math.expression = [1]
>            math.universal.number = [1]
>        language.statement.else = [else\r\n        return add(fib(x-1),
> fib(x-2));]
>         language.keyword = [else]
>         language.statement = [return add(fib(x-1), fib(x-2));]
>          language.statement.return = [return add(fib(x-1), fib(x-2));]
>           language.keyword = [return]
>           language.expression = [add(fib(x-1), fib(x-2))]
>            language.expression.call = [add(fib(x-1), fib(x-2))]
>             language.function.name = [add]
>             language.expression = [fib(x-1)]
>              language.expression.call = [fib(x-1)]
>               language.function.name = [fib] language.expression = [x-1]
>                math.expression = [x-1]
>                 language.identifier = [x] math.operator.subtract = [-]
>                 math.universal.number = [1]
>             language.expression = [fib(x-2)]
>              language.expression.call = [fib(x-2)]
>               language.function.name = [fib] language.expression = [x-2]
>                math.expression = [x-2]
>                 language.identifier = [x] math.operator.subtract = [-]
>                 math.universal.number = [2]
>      language.scope.close = [}]
>  language.namespace.scope = [proc main()\r\n    s : string;\r\n{\r\n
> neo::print("Enter a positive...]
>   language.function = [proc main()\r\n    s : string;\r\n{\r\n
> neo::print("Enter a positive...]
>    language.keyword = [proc]
>    language.function.signature = [main()]
>     language.identifier = [main]
>     language.function.parameters = []
>    language.function.local = [s]
>     language.identifier = [s]
>    language.type.string = [string]
>    language.function.body = [{\r\n   neo::print("Enter a positive
> "\r\n           "integer: ");\r\n...]
>     language.function.scope = [{\r\n   neo::print("Enter a positive
> "\r\n           "integer: ");\r\n...]
>      language.scope.open = [{]
>      language.statement = [neo::print("Enter a positive "\r\n
> "integer: ");]
>       language.expression = [neo::print("Enter a positive "\r\n
> "integer: ")]
>        language.expression.call = [neo::print("Enter a positive
> "\r\n           "integer: ")]
>         language.function.name = [neo::print]
>          language.namespace = [neo]
>         language.expression = ["Enter a positive "\r\n          
>         "integer:
> "]
>          math.expression = ["Enter a positive "\r\n           "integer:
>          "]
>           string.utf8 = [Enter a positive ]
>           string.utf8 = [integer: ]
>      language.statement = [neo::input(s);]
>       language.expression = [neo::input(s)]
>        language.expression.call = [neo::input(s)]
>         language.function.name = [neo::input]
>          language.namespace = [neo]
>         language.expression = [s]
>          math.expression = [s]
>           language.identifier = [s]
>      language.statement = [neo::print("Fibonacci(" + s + ") = " +
> neo::to_string(fib(neo::t...]
>       language.expression = [neo::print("Fibonacci(" + s + ") = " +
> neo::to_string(fib(neo::t...]
>        language.expression.call = [neo::print("Fibonacci(" + s + ") = "
>        +
> neo::to_string(fib(neo::t...]
>         language.function.name = [neo::print]
>          language.namespace = [neo]
>         language.expression = ["Fibonacci(" + s + ") = " +
> neo::to_string(fib(neo::to_integer(s...]
>          math.expression = ["Fibonacci(" + s + ") = " +
> neo::to_string(fib(neo::to_integer(s...]
>           string.utf8 = [Fibonacci(]
>           math.operator.add = [+]
>           language.identifier = [s]
>           math.operator.add = [+]
>           string.utf8 = [) = ]
>           math.operator.add = [+]
>           language.expression.call =
> [neo::to_string(fib(neo::to_integer(s)))]
>            language.function.name = [neo::to_string]
>             language.namespace = [neo]
>            language.expression = [fib(neo::to_integer(s))]
>             language.expression.call = [fib(neo::to_integer(s))]
>              language.function.name = [fib] language.expression =
>              [neo::to_integer(s)]
>               language.expression.call = [neo::to_integer(s)]
>                language.function.name = [neo::to_integer]
>                 language.namespace = [neo]
>                language.expression = [s]
>                 math.expression = [s]
>                  language.identifier = [s]
>           math.operator.add = [+]
>           string.utf8 = [\n]
>            string.utf8.character.LF = [\n]
>      language.scope.close = [}]
>  language.namespace.scope = []
>  language.namespace.scope = []
> 
> /Flibble

Multiplication and addition operators are now handled correctly as infix 
operators as the following AST now shows:

 1|-- neoscript example: Fibonacci
 2|
 3|using neo.string;
 4|using neo.stream;
 5|
 6|-- functions are pure
 7|fn add(x, y : i32) -> i32
 8|{
 9|    return x + y;
10|}
11|fn fib(x : i32) -> i32
12|{
13|    if (x < 2)
14|        return 1;
15|    else
16|        return add(fib(x-1), fib(x-2));
17|}
18|
19|-- procedures are impure
20|proc main()
21|    s : string;
22|{
23|   neo::print("Enter a positive "
24|           "integer: ");
25|   neo::input(s);
26|   neo::print("Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::to_integer(s))) + "\n");
27|}
28|

 source.package.import = [using neo.string;]
  language.keyword = [using]
  source.package.name = [neo.string]
 source.package.import = [using neo.stream;]
  language.keyword = [using]
  source.package.name = [neo.stream]
 language.namespace.scope = [fn add(x, y : i32) -> i32\r\n{\r\n    return 
x + y;\r\n}]
  language.function = [fn add(x, y : i32) -> i32\r\n{\r\n    return x + y;
\r\n}]
   language.keyword = [fn]
   language.function.signature = [add(x, y : i32) -> i32]
    language.identifier = [add]
    language.function.parameters = [x, y : i32]
     language.function.parameter = [x]
      language.identifier = [x]
     language.function.parameter = [y]
      language.identifier = [y]
     language.type.i32 = [i32]
    language.type.i32 = [i32]
   language.function.body = [{\r\n    return x + y;\r\n}]
    language.function.scope = [{\r\n    return x + y;\r\n}]
     language.scope.open = [{]
     language.statement = [return x + y;]
      language.function.return = [return x + y;]
       language.keyword = [return]
       language.expression = [x + y]
        math.expression = [x + y]
         math.operator.add = [+]
          language.identifier = [x]
          language.identifier = [y]
     language.scope.close = [}]
 language.namespace.scope = [fn fib(x : i32) -> i32 \r\n{\r\n    if (x < 
2) \r\n        return 1; \r...]
  language.function = [fn fib(x : i32) -> i32 \r\n{\r\n    if (x < 2) 
\r\n        return 1; \r...]
   language.keyword = [fn]
   language.function.signature = [fib(x : i32) -> i32]
    language.identifier = [fib]
    language.function.parameters = [x : i32]
     language.function.parameter = [x]
      language.identifier = [x]
     language.type.i32 = [i32]
    language.type.i32 = [i32]
   language.function.body = [{\r\n    if (x < 2) \r\n        return 1; 
\r\n    else\r\n        return...]
    language.function.scope = [{\r\n    if (x < 2) \r\n        return 1; 
\r\n    else\r\n        return...]
     language.scope.open = [{]
     language.statement = [if (x < 2) \r\n        return 1; \r\n    
else\r\n        return add(fi...]
      logic.operator.if = [if (x < 2) \r\n        return 1; \r\n    
else\r\n        return add(fi...]
       language.keyword = [if]
       boolean.expression = [x < 2]
        math.expression = [x]
         language.identifier = [x]
        boolean.operator.relational.lessthan = [<]
        math.expression = [2]
         math.universal.number = [2]
       language.statement = [return 1;]
        language.function.return = [return 1;]
         language.keyword = [return]
         language.expression = [1]
          math.expression = [1]
           math.universal.number = [1]
       language.statement.else = [else\r\n        return add(fib(x-1), 
fib(x-2));]
        language.keyword = [else]
        language.statement = [return add(fib(x-1), fib(x-2));]
         language.function.return = [return add(fib(x-1), fib(x-2));]
          language.keyword = [return]
          language.expression = [add(fib(x-1), fib(x-2))]
           language.function.call = [add(fib(x-1), fib(x-2))]
            language.function.name = [add]
            language.expression = [fib(x-1)]
             language.function.call = [fib(x-1)]
              language.function.name = [fib]
              language.expression = [x-1]
               math.expression = [x-1]
                math.operator.subtract = [-]
                 language.identifier = [x]
                 math.universal.number = [1]
            language.expression = [fib(x-2)]
             language.function.call = [fib(x-2)]
              language.function.name = [fib]
              language.expression = [x-2]
               math.expression = [x-2]
                math.operator.subtract = [-]
                 language.identifier = [x]
                 math.universal.number = [2]
     language.scope.close = [}]
 language.namespace.scope = [proc main()\r\n    s : string;\r\n{\r\n   
neo::print("Enter a positive...]
  language.function = [proc main()\r\n    s : string;\r\n{\r\n   
neo::print("Enter a positive...]
   language.keyword = [proc]
   language.function.signature = [main()]
    language.identifier = [main]
    language.function.parameters = []
   language.function.local = [s]
    language.identifier = [s]
   language.type.string = [string]
   language.function.body = [{\r\n   neo::print("Enter a positive 
"\r\n           "integer: ");\r\n...]
    language.function.scope = [{\r\n   neo::print("Enter a positive 
"\r\n           "integer: ");\r\n...]
     language.scope.open = [{]
     language.statement = [neo::print("Enter a positive "\r\n           
"integer: ");]
      language.expression = [neo::print("Enter a positive "\r\n           
"integer: ")]
       language.function.call = [neo::print("Enter a positive 
"\r\n           "integer: ")]
        language.function.name = [neo::print]
         language.namespace = [neo]
        language.expression = ["Enter a positive "\r\n           "integer: 
"]
         math.expression = ["Enter a positive "\r\n           "integer: "]
          string.utf8 = [Enter a positive ]
          string.utf8 = [integer: ]
     language.statement = [neo::input(s);]
      language.expression = [neo::input(s)]
       language.function.call = [neo::input(s)]
        language.function.name = [neo::input]
         language.namespace = [neo]
        language.expression = [s]
         math.expression = [s]
          language.identifier = [s]
     language.statement = [neo::print("Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::t...]
      language.expression = [neo::print("Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::t...]
       language.function.call = [neo::print("Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::t...]
        language.function.name = [neo::print]
         language.namespace = [neo]
        language.expression = ["Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::to_integer(s...]
         math.expression = ["Fibonacci(" + s + ") = " + 
neo::to_string(fib(neo::to_integer(s...]
          math.operator.add = [+]
           math.operator.add = [+]
            math.operator.add = [+]
             math.operator.add = [+]
              string.utf8 = [Fibonacci(]
              language.identifier = [s]
             string.utf8 = [) = ]
            language.function.call = 
[neo::to_string(fib(neo::to_integer(s)))]
             language.function.name = [neo::to_string]
              language.namespace = [neo]
             language.expression = [fib(neo::to_integer(s))]
              language.function.call = [fib(neo::to_integer(s))]
               language.function.name = [fib]
               language.expression = [neo::to_integer(s)]
                language.function.call = [neo::to_integer(s)]
                 language.function.name = [neo::to_integer]
                  language.namespace = [neo]
                 language.expression = [s]
                  math.expression = [s]
                   language.identifier = [s]
           string.utf8 = [\n]
            string.utf8.character.LF = [\n]
     language.scope.close = [}]
 language.namespace.scope = []
 language.namespace.scope = []

Compilation time: 59.936ms

/Flibble

[toc] | [prev] | [next] | [standalone]

#121999

On Wed, 19 Mar 2025 04:59:22 GMT
Mr Flibble <flibble@reddwarf.jmc.corp> wibbled:
>On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
>
>> Introducing the universal compiler, neos, that can compile ANY
>> programming language.

I hope you're going to write a auto generator for that mess possibly based
on written instructions in english/french/whatever. Its unreadable.

[toc] | [prev] | [next] | [standalone]

#122000

On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:

> On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble <flibble@reddwarf.jmc.corp>
> wibbled:
>>On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
>>
>>> Introducing the universal compiler, neos, that can compile ANY
>>> programming language.
> 
> I hope you're going to write a auto generator for that mess possibly
> based on written instructions in english/french/whatever. Its
> unreadable.

eh? the neos grammar is based on EBNF so is human friendly.

/Flibble

[toc] | [prev] | [next] | [standalone]

#122001

On Wed, 19 Mar 2025 14:35:59 GMT
Mr Flibble <flibble@reddwarf.jmc.corp> wibbled:
>On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
>
>> On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble <flibble@reddwarf.jmc.corp>
>> wibbled:
>>>On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
>>>
>>>> Introducing the universal compiler, neos, that can compile ANY
>>>> programming language.
>> 
>> I hope you're going to write a auto generator for that mess possibly
>> based on written instructions in english/french/whatever. Its
>> unreadable.
>
>eh? the neos grammar is based on EBNF so is human friendly.

Its almost a solid slab of text.

[toc] | [prev] | [next] | [standalone]

#122002

On Wed, 19 Mar 2025 14:41:34 +0000, Muttley wrote:

> On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble <flibble@reddwarf.jmc.corp>
> wibbled:
>>On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
>>
>>> On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
>>> <flibble@reddwarf.jmc.corp>
>>> wibbled:
>>>>On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
>>>>
>>>>> Introducing the universal compiler, neos, that can compile ANY
>>>>> programming language.
>>> 
>>> I hope you're going to write a auto generator for that mess possibly
>>> based on written instructions in english/french/whatever. Its
>>> unreadable.
>>
>>eh? the neos grammar is based on EBNF so is human friendly.
> 
> Its almost a solid slab of text.

It is based on EBNF so is human friendly.

/Flibble

[toc] | [prev] | [next] | [standalone]

#122003

On 19/03/2025 14:44, Mr Flibble wrote:
> On Wed, 19 Mar 2025 14:41:34 +0000, Muttley wrote:
> 
>> On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble <flibble@reddwarf.jmc.corp>
>> wibbled:
>>> On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
>>>
>>>> On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
>>>> <flibble@reddwarf.jmc.corp>
>>>> wibbled:
>>>>> On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
>>>>>
>>>>>> Introducing the universal compiler, neos, that can compile ANY
>>>>>> programming language.
>>>>
>>>> I hope you're going to write a auto generator for that mess possibly
>>>> based on written instructions in english/french/whatever. Its
>>>> unreadable.
>>>
>>> eh? the neos grammar is based on EBNF so is human friendly.
>>
>> Its almost a solid slab of text.
> 
> It is based on EBNF so is human friendly.

It's human friendly because Flibber says so. Flibber is never 
wrong, not even when he's wrong.

And because magic, neos can (present tense) compile any 
programming language, even though most languages have no schema 
at present. We know this because Flibber is never wrong.

-- 
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

[toc] | [prev] | [next] | [standalone]

#122004

On Wed, 19 Mar 2025 15:07:09 +0000, Richard Heathfield wrote:

> On 19/03/2025 14:44, Mr Flibble wrote:
>> On Wed, 19 Mar 2025 14:41:34 +0000, Muttley wrote:
>> 
>>> On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble
>>> <flibble@reddwarf.jmc.corp>
>>> wibbled:
>>>> On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
>>>>
>>>>> On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
>>>>> <flibble@reddwarf.jmc.corp>
>>>>> wibbled:
>>>>>> On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
>>>>>>
>>>>>>> Introducing the universal compiler, neos, that can compile ANY
>>>>>>> programming language.
>>>>>
>>>>> I hope you're going to write a auto generator for that mess possibly
>>>>> based on written instructions in english/french/whatever. Its
>>>>> unreadable.
>>>>
>>>> eh? the neos grammar is based on EBNF so is human friendly.
>>>
>>> Its almost a solid slab of text.
>> 
>> It is based on EBNF so is human friendly.
> 
> It's human friendly because Flibber says so. Flibber is never wrong, not
> even when he's wrong.
> 
> And because magic, neos can (present tense) compile any programming
> language, even though most languages have no schema at present. We know
> this because Flibber is never wrong.

I am occassionally wrong but in this instance, dear, it is you that is 
wrong.

Just because a language doesn't yet have a schema it doesn't follow that 
neos couldn't compile it if a schema was created for it.

/Flibble

[toc] | [prev] | [next] | [standalone]

#122006

On Wed, 19 Mar 2025 15:16:50 GMT
Mr Flibble <flibble@reddwarf.jmc.corp> wibbled:
>On Wed, 19 Mar 2025 15:07:09 +0000, Richard Heathfield wrote:
>> And because magic, neos can (present tense) compile any programming
>> language, even though most languages have no schema at present. We know
>> this because Flibber is never wrong.
>
>I am occassionally wrong but in this instance, dear, it is you that is 
>wrong.
>
>Just because a language doesn't yet have a schema it doesn't follow that 
>neos couldn't compile it if a schema was created for it.

Create one for C++ then. Imagine the plaudits, the groupies, the fame,
appearing on Good Morning, the difficult 2nd schema, the drug years, the
comeback. Etc etc.

[toc] | [prev] | [next] | [standalone]

#122007

On Wed, 19 Mar 2025 15:46:01 +0000, Muttley wrote:

> On Wed, 19 Mar 2025 15:16:50 GMT Mr Flibble <flibble@reddwarf.jmc.corp>
> wibbled:
>>On Wed, 19 Mar 2025 15:07:09 +0000, Richard Heathfield wrote:
>>> And because magic, neos can (present tense) compile any programming
>>> language, even though most languages have no schema at present. We
>>> know this because Flibber is never wrong.
>>
>>I am occassionally wrong but in this instance, dear, it is you that is
>>wrong.
>>
>>Just because a language doesn't yet have a schema it doesn't follow that
>>neos couldn't compile it if a schema was created for it.
> 
> Create one for C++ then. Imagine the plaudits, the groupies, the fame,
> appearing on Good Morning, the difficult 2nd schema, the drug years, the
> comeback. Etc etc.

You're good.

/Flibble

[toc] | [prev] | [next] | [standalone]

#122008

On Wed, 19 Mar 2025 15:48:39 GMT
Mr Flibble <flibble@reddwarf.jmc.corp> wibbled:
>On Wed, 19 Mar 2025 15:46:01 +0000, Muttley wrote:
>
>> On Wed, 19 Mar 2025 15:16:50 GMT Mr Flibble <flibble@reddwarf.jmc.corp>
>> wibbled:
>>>On Wed, 19 Mar 2025 15:07:09 +0000, Richard Heathfield wrote:
>>>> And because magic, neos can (present tense) compile any programming
>>>> language, even though most languages have no schema at present. We
>>>> know this because Flibber is never wrong.
>>>
>>>I am occassionally wrong but in this instance, dear, it is you that is
>>>wrong.
>>>
>>>Just because a language doesn't yet have a schema it doesn't follow that
>>>neos couldn't compile it if a schema was created for it.
>> 
>> Create one for C++ then. Imagine the plaudits, the groupies, the fame,
>> appearing on Good Morning, the difficult 2nd schema, the drug years, the
>> comeback. Etc etc.
>
>You're good.

Thanks. I'm here all week.

[toc] | [prev] | [next] | [standalone]

#122009

On 19/03/2025 15:16, Mr Flibble wrote:
> On Wed, 19 Mar 2025 15:07:09 +0000, Richard Heathfield wrote:
> 
>> On 19/03/2025 14:44, Mr Flibble wrote:
>>> On Wed, 19 Mar 2025 14:41:34 +0000, Muttley wrote:
>>>
>>>> On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble
>>>> <flibble@reddwarf.jmc.corp>
>>>> wibbled:
>>>>> On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
>>>>>
>>>>>> On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
>>>>>> <flibble@reddwarf.jmc.corp>
>>>>>> wibbled:
>>>>>>> On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
>>>>>>>
>>>>>>>> Introducing the universal compiler, neos, that can compile ANY
>>>>>>>> programming language.
>>>>>>
>>>>>> I hope you're going to write a auto generator for that mess possibly
>>>>>> based on written instructions in english/french/whatever. Its
>>>>>> unreadable.
>>>>>
>>>>> eh? the neos grammar is based on EBNF so is human friendly.
>>>>
>>>> Its almost a solid slab of text.
>>>
>>> It is based on EBNF so is human friendly.
>>
>> It's human friendly because Flibber says so. Flibber is never wrong, not
>> even when he's wrong.
>>
>> And because magic, neos can (present tense) compile any programming
>> language, even though most languages have no schema at present. We know
>> this because Flibber is never wrong.
> 
> I am occassionally wrong but in this instance, dear, it is you that is
> wrong.

You won't be surprised to hear that I disagree.

> Just because a language doesn't yet have a schema it doesn't follow that
> neos couldn't compile it if a schema was created for it.

I have not made that claim. You, however, made the claim that 
neos can (present tense) compile ANY language. It's still in the 
quoted materials:

>>>>>>> On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble
>>>>>>> wrote:
>>>>>>> 
>>>>>>>> Introducing the universal compiler, neos, that
>>>>>>>> can compile ANY programming language. 
See?

But I note that you are now opting for the subjunctive, which is 
an altogether more sensible claim and perhaps offers a hint that 
you're edging towards realising why your original claim was 
mistaken. Indeed, you put me in mind of the Fonz in Happy Days, 
trying to admit he's wrong but unable to use the word of himself. 
"I was wr... I was wr... I was wrwrwrwrwr... I was, not, right."

The ability to admit error when you're wrong is an important one 
to acquire on the path to adulthood. Keep going as you are, and 
you'll get there... one day.

-- 
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

[toc] | [prev] | [next] | [standalone]

#122010

On Wed, 19 Mar 2025 17:20:31 +0000, Richard Heathfield wrote:

> On 19/03/2025 15:16, Mr Flibble wrote:
>> On Wed, 19 Mar 2025 15:07:09 +0000, Richard Heathfield wrote:
>> 
>>> On 19/03/2025 14:44, Mr Flibble wrote:
>>>> On Wed, 19 Mar 2025 14:41:34 +0000, Muttley wrote:
>>>>
>>>>> On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble
>>>>> <flibble@reddwarf.jmc.corp>
>>>>> wibbled:
>>>>>> On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
>>>>>>
>>>>>>> On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
>>>>>>> <flibble@reddwarf.jmc.corp>
>>>>>>> wibbled:
>>>>>>>> On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
>>>>>>>>
>>>>>>>>> Introducing the universal compiler, neos, that can compile ANY
>>>>>>>>> programming language.
>>>>>>>
>>>>>>> I hope you're going to write a auto generator for that mess
>>>>>>> possibly based on written instructions in english/french/whatever.
>>>>>>> Its unreadable.
>>>>>>
>>>>>> eh? the neos grammar is based on EBNF so is human friendly.
>>>>>
>>>>> Its almost a solid slab of text.
>>>>
>>>> It is based on EBNF so is human friendly.
>>>
>>> It's human friendly because Flibber says so. Flibber is never wrong,
>>> not even when he's wrong.
>>>
>>> And because magic, neos can (present tense) compile any programming
>>> language, even though most languages have no schema at present. We
>>> know this because Flibber is never wrong.
>> 
>> I am occassionally wrong but in this instance, dear, it is you that is
>> wrong.
> 
> You won't be surprised to hear that I disagree.
> 
>> Just because a language doesn't yet have a schema it doesn't follow
>> that neos couldn't compile it if a schema was created for it.
> 
> I have not made that claim. You, however, made the claim that neos can
> (present tense) compile ANY language. It's still in the quoted
> materials:
> 
>>>>>>>> On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
>>>>>>>> 
>>>>>>>>> Introducing the universal compiler, neos, that can compile ANY
>>>>>>>>> programming language.
> See?
> 
> But I note that you are now opting for the subjunctive, which is an
> altogether more sensible claim and perhaps offers a hint that you're
> edging towards realising why your original claim was mistaken. Indeed,
> you put me in mind of the Fonz in Happy Days, trying to admit he's wrong
> but unable to use the word of himself.
> "I was wr... I was wr... I was wrwrwrwrwr... I was, not, right."
> 
> The ability to admit error when you're wrong is an important one to
> acquire on the path to adulthood. Keep going as you are, and you'll get
> there... one day.

The carrot you have got stuck up your arse is getting mouldy, mate, it 
needs replacing.

/Flibble

[toc] | [prev] | [next] | [standalone]

#122011

On 19/03/2025 17:26, Mr Flibble wrote:
> On Wed, 19 Mar 2025 17:20:31 +0000, Richard Heathfield wrote:

<snip>

>>
>> The ability to admit error when you're wrong is an important one to
>> acquire on the path to adulthood. Keep going as you are, and you'll get
>> there... one day.

...

<nonsense snipped>

... or not, as the case may be.

-- 
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

[toc] | [prev] | [next] | [standalone]

#122005

On Wed, 19 Mar 2025 14:44:05 GMT
Mr Flibble <flibble@reddwarf.jmc.corp> wibbled:
>On Wed, 19 Mar 2025 14:41:34 +0000, Muttley wrote:
>
>> On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble <flibble@reddwarf.jmc.corp>
>> wibbled:
>>>On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
>>>
>>>> On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
>>>> <flibble@reddwarf.jmc.corp>
>>>> wibbled:
>>>>>On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
>>>>>
>>>>>> Introducing the universal compiler, neos, that can compile ANY
>>>>>> programming language.
>>>> 
>>>> I hope you're going to write a auto generator for that mess possibly
>>>> based on written instructions in english/french/whatever. Its
>>>> unreadable.
>>>
>>>eh? the neos grammar is based on EBNF so is human friendly.
>> 
>> Its almost a solid slab of text.
>
>It is based on EBNF so is human friendly.

Thats what was claimed for XML originally.

[toc] | [prev] | [standalone]

Back to top | Article view | comp.lang.c++

csiph-web