For those that love formal language definitions, I've got a grammar for Daedalus, it's in BNF:
"Name" = 'Daedalus 2'
"Author" = 'Lehona'
"Version" = '0.1'
"About" = 'This is basically Daedalus extended (not yet, though)'
"Start Symbol" = <Program>
! -------------------------------------------------
! Character Sets
! -------------------------------------------------
{ID Head} = {Letter} + [_] + [ü] + [Ü] + [ä] + [Ä] + [ö] + [Ö] + [ß]
{ID Tail} = {Alphanumeric} + [_]+[^]+[@] + [ü] + [Ü] + [ä] + [Ä] + [ö] + [Ö] + [ß]
{String Chars} = {Printable} - ["] + [´] + [`]
! -------------------------------------------------
! Terminals
! -------------------------------------------------
Comment Start = '/*'
Comment End = '*/'
Comment Line = '//'
ID = {ID Head}{ID Tail}*
!keywords = 'class' | 'func' | 'instance' | 'prototype' | 'const' | 'var' | 'return'
StringLiteral = '"' ({String Chars}|ü|Ü|ä|Ä|ö|Ö|ß)* '"'
Integer = {Number}+
Float = {Number}+ '.' {Number}+
<Number> ::= Integer | Float
! -------------------------------------------------
! Rules
! -------------------------------------------------
! The grammar starts below
<Program> ::= <type decl> <Program>
| <function decl> <Program>
| <var decl> <Program>
| <glob decl> <Program>
|
<identifier> ::= ID | 'class' | 'func' | 'instance' | 'prototype' | 'const' | 'var' !| 'return'
<Expression List> ::= <Expression> <Expression List Tail>
|
<Expression List Tail> ::= ',' <Expression> <Expression List Tail>
|
<Expression> ::= <Logic And> '||' <Expression>
| <Logic And>
<Logic And> ::= <Bit Or> '&&' <Logic And>
| <Bit Or>
<Bit Or> ::= <Bit And> '|' <Bit Or>
| <Bit And> !<Bit Xor>
!<Bit Xor> ::= <Bit And> '^' <Bit Xor> NB. Currently not supported
! | <Bit And>
<Bit And> ::= <Equal> '&' <Bit And>
| <Equal>
<Equal> ::= <Comparison> '==' <Equal>
| <Comparison> '!=' <Equal>
| <Comparison>
<Comparison> ::= <Bit Shift> '<' <Comparison>
| <Bit Shift> '>' <Comparison>
| <Bit Shift> '<=' <Comparison>
| <Bit Shift> '>=' <Comparison>
| <Bit Shift>
<Bit Shift> ::= <Add> '<<' <Bit Shift>
| <Add> '>>' <Bit Shift>
| <Add>
<Add> ::= <Mult> '+' <Add>
| <Mult> '-' <Add>
| <Mult>
<Mult> ::= <Mult> '*' <Unary>
| <Mult> '/' <Unary>
| <Mult> '%' <Unary>
| <Unary>
<Unary> ::= '-' <Unary>
| '!' <Unary>
| '~' <Unary>
| '+' <Unary>
| <Value>
<Value> ::= <Var>
| '(' <Expression> ')'
| <Number>
| StringLiteral
| <call exp>
<Var> ::= <Array>
| <identifier> '.' <Array>
<Array> ::= <identifier> '[' <Num> ']'
| <identifier>
<Num> ::= <identifier>
| <Number>
<call exp> ::= <identifier> '(' <expression list> ')'
<statement list> ::= <statement> <statement list>
|
<statement> ::= <assignment> ';'
| <if block>
| ';'
| <jump statement> ';'
| <call exp> ';'
| <Var> ';'
| <declaration>';'
<assignment> ::= <Var> '=' <expression>
| <Var> '+=' <expression>
| <Var> '-=' <expression>
| <Var> '*=' <expression>
| <Var> '/=' <expression>
<statement block> ::= '{' <statement list> '}'
<if block> ::= if <Expression> <Statement block>
| if <Expression> <Statement block> else <Statement Block>
| if <Expression> <Statement block> else <if block>
<jump statement> ::= 'return'
| 'return' <expression>
<declaration list> ::= <var decl> <declaration tail>
|
<declaration tail> ::= ',' <var decl> <declaration tail>
|
<declaration block> ::= '{' <var decl list> '}' ';'
<var decl list> ::= <var decl sublist> ';' <var decl list>
|
<var decl sublist> ::= <var decl> <var decl sublist tail>
|
<var decl sublist tail> ::= ',' <identifier> <var decl sublist tail>
|
<declaration> ::= <var decl>
| <const decl>
<var decl> ::= 'var' <identifier> <var decl sub>
| 'var' <identifier> <identifier> ',' <var decl>
| 'var' <identifier> <identifier> '[' <Value> ']' ',' <var decl>
<var decl sub> ::= <identifier>
| <identifier> '[' <Value> ']'
| <identifier> ',' <var decl sub>
| <identifier> '[' <Value> ']' ',' <var decl sub>
<const decl> ::= 'const' <identifier> <identifier> '=' <Expression>
| 'const' <identifier> <identifier> '[' <Value> ']' '=' '{' <Expression List> '}'
<type decl> ::= <class decl>
| <prototype decl>
| <instance decl>
<class decl> ::= 'class' <identifier> <declaration block> !Gothic kann var int a1,a2; in Klassen und nutzt das auch standardmäßig, ich darf es also nicht einfach ignorieren.
<prototype decl> ::= 'prototype' <identifier>'(' <identifier> ')' <statement block> ';'
<instance decl> ::= 'instance' <identifier> <var decl sublist tail> '(' <identifier> ')' <statement block> ';'
| 'instance' <identifier> <var decl sublist tail> '(' <identifier> ')' ';'
<function decl> ::= 'func' <identifier> <identifier> '(' <declaration list> ')' <statement block> ';'
<glob decl> ::= <declaration> ';' Every script I've tested so far (including all of the original G2NotR scripts) has been successfully parsed, though I'm quite sure that this grammar allows some constructs the parser will not allow (If anyone finds or sees one feel free to mention it to me).
I will update the grammar as I continue with the development of my parser, an up-to-date version can always be found here:
https://www.assembla.com/code/daedalus-parser/subversion/nodes/Daedalus.grm