XPost: comp.theory
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
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)