Return a*b+7

x = 5
vector.x = 3
obj.life = 100

Print a
If x=1 Then
 Return True
EndIf

Return a*b+7

node->AddNode(GetExpr(parameters));

return CreateXMLTextNode("a*b+7");

<return>
    a * b + 7
</return>

<return>
    <call function="Sin">
        <parameter>
            a * b
        </parameter>
    </call>
    + 7
</return>

%FALSE=0
%TRUE =1
%NUL  =0

%DEBUG = %TRUE

%SYM_NUL          =  0
%SYM_EOL          =  1
%SYM_EOS          =  2
%SYM_LPARA        =  3
%SYM_RPARA        =  4
%SYM_LEPARA       =  5
%SYM_REPARA       =  6
%SYM_KOMMA        =  7
%SYM_NUM          =  8
%SYM_NUM_CONST    =  9
%SYM_META         = 10
%SYM_STRING       = 12
%SYM_STRING_CONST = 13
%SYM_STRING_VAL   = 14

%SYM_EQ           = 15
%SYM_NE           = 16
%SYM_LE           = 17
%SYM_LT           = 18
%SYM_GE           = 19
%SYM_GT           = 20
%SYM_ID           = 21
%SYM_OP_ADD       = 22
%SYM_OP_SUB       = 23
%SYM_OP_MUL       = 24
%SYM_OP_DIV       = 25

FUNCTION COMPILER(FILENAME AS STRING) AS DWORD
 IF LOADFILE(FILENAME) =%FALSE THEN
  FUNCTION=%FALSE
  EXIT FUNCTION
 END IF

 InitParser



 OUTNR=FREEFILE
 OPEN "Test.asm" FOR OUTPUT AS OUTNR
 PRINT#OUTNR,"%include ""win32n.inc"""
 runParser

 CLOSE #OUTNR

 SHELL "nasm.exe "+"Test.asm"+" -fobj"
 SHELL "ALINK.EXE -c -oPE  -subsys gui Test"

END FUNCTION


SUB InitParser
 GetChar
 SkipWhite
END SUB 

SUB runParser
 DIM TXT AS STRING
 DIM X AS INTEGER
 DIM zeile AS STRING

 getsym
 DO UNTIL %SYM_EOS=SYM_TYPE
  SELECT CASE SYM_TYPE
   CASE %SYM_ID
    SELECT CASE SYM_TEXT
     CASE "sub"
      XSUB

     CASE "function"
      XFUNCTION

     CASE "for"
      XFOR

     CASE "if"
      XIF

     CASE "select"
      XSELECT

     CASE "do"
      XDO

     CASE "table"
      XTABLE

     CASE "type"
      XTYPE

     CASE "asm"
      XASM

    END SELECT
   CASE %SYM_STRING_CONST
    STRING_CONST
  END SELECT
  getsym
 LOOP
 CLOSE#1
END SUB                         


SUB SkipWhite
 IF(EOS) THEN
  EXIT SUB
 END IF
 WHILE IsWhite(Look) OR  Look=ASC($VT) OR  Look=ASC($CR) OR Look=ASC($LF)
  GetChar
 WEND
END SUB

SUB MathSkipWhite
 WHILE IsWhite(Look)
  GetChar
 WEND
END SUB


FUNCTION IsAlpha(T AS DWORD) AS DWORD
 IF T>=ASC("a") AND T<=ASC("z") THEN
  FUNCTION =%TRUE
  EXIT FUNCTION

 ELSEIF T>=ASC("A") AND T<=ASC("Z") THEN
  FUNCTION =%TRUE
  EXIT FUNCTION

 ELSE
  FUNCTION =%FALSE
  EXIT FUNCTION

 END IF
END FUNCTION

FUNCTION IsAlpha2(T AS DWORD) AS DWORD
 IF T>=ASC("a") AND T<=ASC("z") THEN
  FUNCTION =%TRUE
  EXIT FUNCTION

 ELSEIF T>=ASC("A") AND T<=ASC("Z") THEN
  FUNCTION =%TRUE
  EXIT FUNCTION

 ELSEIF T=ASC("_") THEN
  FUNCTION =%TRUE
  EXIT FUNCTION

 ELSE
  FUNCTION =%FALSE
  EXIT FUNCTION

 END IF
END FUNCTION

FUNCTION ishex(T AS DWORD) AS DWORD
 IF T>=ASC("0") AND T<=ASC("9") THEN
  FUNCTION =%TRUE
  EXIT FUNCTION

 ELSEIF T>=ASC("a") AND T<=ASC("f") THEN
  FUNCTION =%TRUE
  EXIT FUNCTION

 ELSEIF T>=ASC("A") AND T<=ASC("F") THEN
  FUNCTION =%TRUE
  EXIT FUNCTION
 ELSE
  FUNCTION =%FALSE
  EXIT FUNCTION
 END IF
END FUNCTION

FUNCTION h2d(T AS DWORD) AS DWORD
 IF T>=ASC("0") AND T<=ASC("9") THEN
  FUNCTION=T-ASC("0")
  EXIT FUNCTION
 ELSEIF T>=ASC("a") AND T<=ASC("f") THEN
  FUNCTION= T-ASC("a")+10
  EXIT FUNCTION
 ELSEIF T>=ASC("A") AND T<=ASC("F") THEN
  FUNCTION=T-ASC("A")+10
  EXIT FUNCTION
 ELSE
  ERR_OUT "Bad numeric format, nor hex neither decimal"
 END IF
END FUNCTION

FUNCTION IsAlnum(T AS DWORD) AS DWORD
 IF IsAlpha(T) OR IsDigit(T) THEN
  FUNCTION =%TRUE
  EXIT FUNCTION
 ELSE
  FUNCTION =%FALSE
  EXIT FUNCTION
 END IF
END FUNCTION

FUNCTION IsDigit(T AS DWORD) AS DWORD
 IF T=>ASC("0") AND T=<ASC("9") THEN
  FUNCTION =%TRUE
  EXIT FUNCTION
 ELSE
  FUNCTION =%FALSE
  EXIT FUNCTION
 END IF
END FUNCTION
                                             

SUB GetSym
 SELECT CASE AS LONG LOOK
  CASE ASC("'")

  CASE ASC("+")
   SYM_TYPE=%SYM_OP_ADD
   #IF %DEBUG = %TRUE
    SYM_TEXT = "+"
   #ENDIF
   Match ASC("+")
   EXIT SUB

  CASE ASC("-")
   SYM_TYPE=%SYM_OP_SUB
   #IF %DEBUG = %TRUE
    SYM_TEXT = "-"
   #ENDIF
   Match ASC("-")
   EXIT SUB

  CASE ASC("*")
   SYM_TYPE=%SYM_OP_MUL
   #IF %DEBUG = %TRUE
    SYM_TEXT = "*"
   #ENDIF
   Match ASC("*")
   EXIT SUB

  CASE ASC("@")
   Match ASC("@")

  CASE ASC("/")
   SYM_TYPE=%SYM_OP_DIV
   #IF %DEBUG = %TRUE
    SYM_TEXT = "/"
   #ENDIF
   Match ASC("/")
   EXIT SUB

  CASE ASC("<")
   Match ASC("<")

  CASE ASC(">")
   Match ASC(">")
   SELECT CASE AS LONG LOOK
    CASE ASC("=")
     SYM_TYPE=%SYM_GE
     #IF %DEBUG = %TRUE
      SYM_TEXT = ">="
     #ENDIF
     Match ASC("=")
     EXIT SUB

    CASE ASC("<")
     SYM_TYPE=%SYM_NE
     #IF %DEBUG = %TRUE
      SYM_TEXT = "><"
     #ENDIF
     Match ASC("<")
     EXIT SUB

    CASE ELSE
     SYM_TYPE=%SYM_GE
     #IF %DEBUG = %TRUE
      SYM_TEXT = "="
     #ENDIF
     EXIT SUB
   END SELECT

  CASE ASC("=")
   Match ASC("=")
   SELECT CASE AS LONG LOOK
    CASE ASC("<")
     SYM_TYPE=%SYM_LE
     #IF %DEBUG = %TRUE
      SYM_TEXT = "=<"
     #ENDIF
     Match ASC("<")
     EXIT SUB

    CASE ASC(">")
     SYM_TYPE=%SYM_GE
     #IF %DEBUG = %TRUE
      SYM_TEXT = "=>"
     #ENDIF
     Match ASC(">")
     EXIT SUB

    CASE ELSE
     SYM_TYPE=%SYM_EQ
     #IF %DEBUG = %TRUE
      SYM_TEXT = "="
     #ENDIF
     EXIT SUB
   END SELECT


  CASE ASC("%")
   getchar
   IF (ASC("a")=<LOOK AND ASC("z")=>LOOK) OR (ASC("A")=>LOOK AND ASC("Z")=<LOOK) THEN
    SYM_TEXT=""
    DO
     SYM_TEXT = SYM_TEXT+LCASE$(CHR$(LOOK))
     GetChar
    LOOP WHILE (LOOK>=ASC("a") AND LOOK<=ASC("z")) OR (LOOK>=ASC("A") AND LOOK<=ASC("Z")) OR (LOOK>=ASC("0") AND LOOK<=ASC("9")) OR LOOK>=ASC("_")
    SYM_TYPE=%SYM_META
    MathSkipWhite
    EXIT SUB
   ELSE
   END IF

  CASE ASC("#")
   getchar
   IF (ASC("a")=<LOOK AND ASC("z")=>LOOK) OR (ASC("A")=>LOOK AND ASC("Z")=<LOOK) THEN
    SYM_TEXT=""
    DO
     SYM_TEXT = SYM_TEXT+LCASE$(CHR$(LOOK))
     GetChar
    LOOP WHILE (LOOK>=ASC("a") AND LOOK<=ASC("z")) OR (LOOK>=ASC("A") AND LOOK<=ASC("Z")) OR (LOOK>=ASC("0") AND LOOK<=ASC("9")) OR LOOK>=ASC("_")
    SYM_TYPE=%SYM_META
    MathSkipWhite
    EXIT SUB
   ELSE
    SYM_TEXT="#"
    MathSkipWhite
   END IF

  CASE ASC("$")
   getchar
   IF (ASC("a")=<LOOK AND ASC("z")=>LOOK) OR (ASC("A")=>LOOK AND ASC("Z")=<LOOK) THEN
    SYM_TEXT=""
    DO
     SYM_TEXT = SYM_TEXT+LCASE$(CHR$(LOOK))
     GetChar
    LOOP WHILE (LOOK>=ASC("a") AND LOOK<=ASC("z")) OR (LOOK>=ASC("A") AND LOOK<=ASC("Z")) OR (LOOK>=ASC("0") AND LOOK<=ASC("9")) OR LOOK>=ASC("_")
    SYM_TYPE=%SYM_STRING_CONST
    MathSkipWhite
    EXIT SUB
   ELSE
    SYM_TEXT="$"
    Match ASC("$")
   END IF

  CASE ASC("""")
   SYM_TEXT=""
   GetChar
   DO WHILE (LOOK<>ASC("""") AND ASC($CR)<>LOOK AND ASC($LF)<>LOOK)
    SYM_TEXT = SYM_TEXT+CHR$(LOOK)
    GetChar
   LOOP
   SYM_TYPE=%SYM_STRING_VAL

   IF ASC("""")=LOOK THEN
    Match ASC("""")
    MathSkipWhite
   ELSE
    MathSkipWhite
   END IF

  CASE ASC("(")
   SYM_TYPE=%SYM_LPARA
   #IF %DEBUG = %TRUE
    SYM_TEXT="("
   #ENDIF
   Match ASC("(")
   EXIT SUB

  CASE ASC(")")
   SYM_TYPE=%SYM_RPARA
   #IF %DEBUG = %TRUE
    SYM_TEXT=")"
   #ENDIF
   Match ASC(")")
   EXIT SUB

  CASE ASC(",")
   SYM_TYPE=%SYM_KOMMA
   #IF %DEBUG = %TRUE
    SYM_TEXT=","
   #ENDIF
   Match ASC(",")
   EXIT SUB

  CASE ASC("[")
   #IF %DEBUG = %TRUE
    SYM_TEXT="["
   #ENDIF
   SYM_TYPE=%SYM_LEPARA
   Match ASC("[")
   EXIT SUB

  CASE ASC("]")
   #IF %DEBUG = %TRUE
    SYM_TEXT="]"
   #ENDIF
   SYM_TYPE=%SYM_REPARA
   Match ASC("]")
   EXIT SUB


  CASE ASC("0") TO ASC("9")
   SYM_TEXT=""
   DO
    SYM_TEXT = SYM_TEXT+CHR$(LOOK)
    GetChar
   LOOP WHILE (LOOK>=ASC("0") AND LOOK<=ASC("9"))
   SYM_TYPE=%SYM_NUM
   MathSkipWhite
   EXIT SUB

  CASE ASC("a") TO ASC("z"),ASC("A") TO ASC("Z")
   SYM_TEXT=""
   DO
    SYM_TEXT = SYM_TEXT+LCASE$(CHR$(LOOK))
    GetChar
   LOOP WHILE (LOOK>=ASC("a") AND LOOK<=ASC("z")) OR (LOOK>=ASC("A") AND LOOK<=ASC("Z")) OR (LOOK>=ASC("0") AND LOOK<=ASC("9")) OR LOOK>=ASC("_")
   SYM_TYPE=%SYM_ID
   MathSkipWhite
   EXIT SUB

  CASE ASC($CR),ASC($LF)
   SYM_TYPE=%SYM_EOL
   SYM_TEXT =""
   SkipWhite
   EXIT SUB

  CASE %NUL
   SYM_TYPE=%SYM_EOS
   SYM_TEXT =""


  CASE ELSE
   MSGBOX CHR$(LOOK)
   SYM_TYPE=%SYM_NUL
   SYM_TEXT =""
   EXIT SUB

 END SELECT
END SUB


FUNCTION LOADFILE(FILENAME AS STRING) AS DWORD
 DIM FILENR  AS DWORD
 DIM FILELOF AS DWORD
 DIM PUFFER  AS STRING
 DIM MEM     AS DWORD

 FILENR=FREEFILE
 OPEN FILENAME FOR BINARY AS FILENR
 FILELOF=LOF(FILENR)

 GET$ FILENR,FILELOF,PUFFER
 CLOSE#FILENR

 MEM=GetAsciiz(PUFFER)
 IF MEM = %FALSE THEN
  FUNCTION = %FALSE
  EXIT FUNCTION
 END IF

 INCR CURFILE
 FILE(CURFILE).FILE=GetAsciiz(FILENAME)
 FILE(CURFILE).LINENR = 1
 FILE(CURFILE).MEM    = MEM
 FILE(CURFILE).MEMPTR = MEM

 FUNCTION = %TRUE
END FUNCTION               

#define If if(
#define Then ) {
#define Else } else {
#define EndIf }

RETURN{KEYWORD:RETURN}
     |
    +{SYMBOL:PLUS}
   /              \
  *{SYMBOL:MULT}  7{NUMBER:INT}
 /              \
a{VARIABLE:INT}   b{VARIABLE:FLOAT}

Local window:Window = New Window("Hello", -1, -1, 640, 480)
Local button:Button = New Button("Test")
window.Add(button)
button.SetPosition(5, 5)
button.SetSize(96, 24)
button.OnClick(ShowMsg, "Hello World")

Window window = new Window("Hello", -1, -1, 640, 480);
Button button = new Button("Test");
window->Add(button);
button->SetPosition(5, 5);
button->SetSize(96, 24);
button->OnClick(ShowMsg, "Hello World");

Const NUMBER : Int = 10
Var I : Int

For I = 1 To NUMBER
   Print("Hallo Welt " + I)
Next

   Method ParseWhileLoop:TWhileLoop(Match:Int)
      Rem
         WhileLoop = 'While' Expression
                     {Statement}
                     'Wend';
      End Rem

      Local WhileLoop : TWhileLoop

      Self.PushToken()

      ' 'While'
      If Not Self.MatchId(TOKEN_KW_WHILE, Match) Then
         Self.PopToken()
         Return Null
      EndIf
      Self.NextToken()

      WhileLoop = New TWhileLoop

      ' Expression
      WhileLoop.Condition = Self.ParseExpression(True)
      If Not WhileLoop.Condition Then
         Self.PopToken()
         Return Null
      EndIf

      ' {Statement}
      While WhileLoop.AddBody(Self.ParseStatement(False))
      Wend

      ' 'Wend'
      If Not Self.MatchId(TOKEN_KW_WEND, True) Then
         Self.PopToken()
         Return Null
      EndIf
      Self.NextToken()

      Self.PopToken(True)
      Return WhileLoop
   End Method

Const NUMBER : Int = 10
Var I : Int

For I = 1 To NUMBER
   Print("Hallo Welt " + I)
Next

<?xml version="1.0"?>
<ast>
 <program>
  <constantDecleration>
   <constant>
    <decleration name="NUMBER" valueType="Integer" />
    <expression>
     <simpleExpression>
      <term>
       <factor>
        <integer>10</integer>
       </factor>
      </term>
     </simpleExpression>
    </expression>
   </constant>
  </constantDecleration>
  <variableDecleration>
   <variable>
    <decleration name="I" valueType="Integer" />
   </variable>
  </variableDecleration>
  <forLoop>
   <assignment>
    <identifier>I</identifier>
    <expression>
     <simpleExpression>
      <term>
       <factor>
        <integer>1</integer>
       </factor>
      </term>
     </simpleExpression>
    </expression>
   </assignment>
   <to>
    <expression>
     <simpleExpression>
      <term>
       <factor>
        <identifier>NUMBER</identifier>
       </factor>
      </term>
     </simpleExpression>
    </expression>
   </to>
   <functionCall>
    <identifier>Print</identifier>
    <expression>
     <simpleExpression>
      <term>
       <factor>
        <string>Hallo Welt </string>
       </factor>
      </term>
      <plus />
      <simpleExpression>
       <term>
        <factor>
         <identifier>I</identifier>
        </factor>
       </term>
      </simpleExpression>
     </simpleExpression>
    </expression>
   </functionCall>
  </forLoop>
 </program>
</ast>

(* Parser *)
Program             = {ConstantDeclaration
                    | Statement};

IncludeDirective    = 'Include' StringLiteral;

ConstantDeclaration = 'Const'  Constant {',' Constant};
Constant            = Identifier ['%' | '#' | '$'] '=' Expression;

ArrayDeclaration    = 'Dim' Identifier ['%' | '#' | '$' | '.' Identifier]
                      '(' Expression {',' Expression} ')';

LocalDeclaration    = 'Local' Variable {',' Variable};
GlobalDeclaration   = 'Global' Variable {',' Variable};
Variable            = Identifier ['%' | '#' | '$' | '.' Identifier] ['=' Expression];

DataDefinition      = 'Data' Expression {',' Expression};
RestoreStatement    = 'Restore' [Identifier];
ReadStatement       = 'Read' Name {',' Name};

GotoStatement       = 'Goto' Identifier;
GosubStatement      = 'Gosub' Identifier;

IfStatement         = ('If' Expression ['Then'] Statement)
                    | ('If' Expression ['Then']
                      {Statement}
                      {('ElseIf' | 'Else If') Expression ['Then'] {Statement}}
                      ['Else' {Statement}]
                      ('EndIf' | 'End If'));

SelectStatement     = 'Select' Expression
                      {'Case' Expression {Statement}}
                      ['Default' {Statement}]
                      'End Select';

ExitStatement       = 'Exit';
ReturnStatement     = 'Return';

RepeatStatement     = 'Repeat'
                      {Statement}
                      ('Until' Expression | 'Forever');

WhileStatement      = 'While' Expression
                      {Statement}
                      'Wend';

ForStatement        = 'For' Assignment 'To' Expression ['Step' Expression]
                      {Statement}
                      'Next';

EachStatement       = 'For' Name '=' 'Each' Identifier
                      {Statement}
                      'Next';

AssignStatement     = Name '=' (
                    | 'New' Identifier
                    | BeforeExpression
                    | AfterExpression
                    | Expression);

Name                = Identifier ['.' Identifier]
                      ['(' [Expression {',' Expression}] ')']
                      [{'\' Identifier}+ ['%' | '#' | '$']]
                    | Identifier ['%' | '#' | '$' | '.' Identifier];

CallStatement       = Identifier ('(' [Expression {',' Expression}] ')')
                    | Identifier [Expression {',' Expression}];

InsertStatement     = 'Insert' Name (BeforeExpression | AfterExpression);
DeleteStatement     = 'Delete' ('(' Name ')' | Name));
BeforeExpression    = 'Before' ('(' Name ')' | Name));
AfterExpression     = 'After' ('(' Name ')' | Name));

InsertStatement     = 'Insert' Name ('Before' | 'After');

Statement           = IncludeDirective
                    | ArrayDeclaration
                    | LocalDeclaration
                    | GlobalDeclaration
                    | RestoreStatement
                    | ReadStatement
                    | GotoStatement
                    | GosubStatement
                    | ExitStatement
                    | ReturnStatement
                    | IfStatement
                    | SelectStatement
                    | RepeatStatement
                    | WhileStatement
                    | ForStatement
                    | EachStatement
                    | AssignStatement
                    | CallStatement

Function            = 'Function' Identifier ['%' | '#' | '$' | '.' Identifier]
                      '(' [Variable {',' Variable}] ')'
                      {('Return' ('(' Expression ')' | Expression)) | Statement}
                      'End Function';


TypeDeclaration     = 'Type' Identifier
                      {'Field' Identifier ['%' | '#' | '$' | '.' Identifier]}
                      'End Type';

Expression          = ['Not'] BitExpression {'Not' BitExpression};
BitExpression       = Relation {('And' | 'Or' | 'Xor') Relation};
Relation            = AddExpression {RelationOperator AddExpression};
RelationOperator    = '=' | '<>' | '><' | '<' | '<=' | '=<' | '>' | '>=' | '=>';
AddExpression       = Shift {('+' | '-') Shift};
Shift               = Term {('Shl' | 'Shr' |'Sar') Term};
Term                = Power {('*' | '/' | 'Mod') Power};
Power               = Unary {'^' Unary};
Unary               = ['~'] Factor {'~' Factor};
Factor              = IntegerLiteral
                    | FloatLiteral
                    | StringLiteral
                    | '(' Expression ')'
                    | TypeCast
                    | Name;
TypeCast            = 'Int' '(' Expression ')'
                    | 'Float' '(' Expression ')'
                    | 'Str' '(' Expression ')';

(* Lexer *)

Comment        = ';' {CHARACTERS-?EOL?};

Digit          = '0' | '1' | '2' | ... | '9';
BinaryDigit    = '0' | '1';
HexDigit       = Digit
               | 'A' | 'B' | 'C' | ... | 'F'
               | 'a' | 'b' | 'c' | ... | 'f';
Letter         = 'A' | 'B' | 'C' | ... | 'Z'
               | 'a' | 'b' | 'c' | ... | 'z';

FloatLiteral   = {Digit} '.' {Digit};
DecimalNumber  = Digit {Digit};
BinaryNumber   = '%' BinaryDigit {BinaryDigit};
HexNumber      = '$' HexDigit {HexDigit};
IntegerLiteral = DecimalNumber | BinaryNumber | HexNumber;
StringLiteral  = '"' {CHARACTERS-('"' | ?EOL?)} '"';

Identifier     = Letter {'_' | Letter | Digit};
Label          = '.' Identifier;

Local a:Int = 3
Local b:Int = 4
Local c:Int = 5

Local isPythagoreanTriple:Bool = (a^2 + b^2 = c^2)

<?xml version="1.0"?>

<module>
   <header>
   </header>
   <code>
      <local>
         <var name="a">
            <type>
               Int
            </type>
            <value>
               3
            </value>
         </var>
      </local>
      <local>
         <var name="b">
            <type>
               Int
            </type>
            <value>
               4
            </value>
         </var>
      </local>
      <local>
         <var name="c">
            <type>
               Int
            </type>
            <value>
               5
            </value>
         </var>
      </local>
      <local>
         <var name="isPythagoreanTriple">
            <type>
               Bool
            </type>
            <value>
               <compare>
                  <term>
                     <add>
                        <term>
                           <pow>
                              <term>
                                 a
                              </term>
                              <term>
                                 2
                              </term>
                           </pow>
                        </term>
                        <term>
                           <pow>
                              <term>
                                 b
                              </term>
                              <term>
                                 2
                              </term>
                           </pow>
                        </term>
                     </add>
                  </term>
                  <term>
                     <pow>
                        <term>
                           c
                        </term>
                        <term>
                           2
                        </term>
                     </pow>
                  </term>
               </compare>
            </value>
         </var>
      </local>
   </code>
</module>

SuperStrict

Framework BRL.Blitz

Global In       : String, ..
       Position : Int, ..
       Token    : Byte

' Test
In = "10<3^2+~~9/8*(20>2)" ' 10 Shl 3^2 + ~9/8*(20 Shr 2)

Try
   Parse()
Catch Exception:Object
   WriteStdout(Exception.ToString())
End Try

End

Function Parse:Int()
   Local Result:Int

   GetToken()
   Result = Expression()
   WriteStdout("Result: " + Result)
End Function

Function GetToken()
   If Position > In.Length - 1 Then
      Token = Asc("~n")
   Else
      Token = In[Position]
   EndIf
   Position :+ 1
End Function

Function Match(Char:Byte)
   If Token = Char Then
      GetToken()
   Else
      Throw("Expected '" + Chr(Char) + "'")
   EndIf
End Function

Function Expression:Int()
   Local Result:Int

   Result = Shift()
   While Token = Asc("+") Or Token = Asc("-")
      If Token = Asc("+")
         GetToken()
         Result = Result + Shift()
      Else
         GetToken()
         Result = Result - Shift()
      EndIf
   Wend

   Return Result
End Function

Function Shift:Int()
   Local Result:Int

   Result = Term()
   While Token = Asc(">") Or Token = Asc("<")
      If Token = Asc(">") Then
         GetToken()
         Result = Result Shr Term()
      Else
         GetToken()
         Result = Result Shl Term()
      EndIf
   Wend

   Return Result
End Function

Function Term:Int()
   Local Result:Int

   Result = Power()
   While Token = Asc("*") Or Token = Asc("/")
      If Token = Asc("*") Then
         GetToken()
         Result = Result*Power()
      Else
         GetToken()
         Result = Result/Power()
      EndIf
   Wend

   Return Result
End Function

Function Power:Int()
   Local Result:Int

   Result = Unary()
   While Token = Asc("^")
      GetToken()
      Result = Result^Unary()
   Wend

   Return Result
End Function

Function Unary:Int()
   Local Result:Int

   If Token = Asc("~~") Then
      GetToken()
      Result = ~Factor()
   Else
      Result = Factor()
   EndIf

   Return Result
End Function

Function Factor:Int()
   Local Result:Int

   If Token = Asc("(") Then
      Match(Asc("("))
      Result = Expression()
      Match(Asc(")"))
   Else
      Result = Number()
   EndIf

   Return Result
End Function

Function Number:Int()
   Local Result:Int

   While Token => Asc("0") And Token <= Asc("9")
      Result = Result*10 + Digit()
   Wend

   Return Result
End Function

Function Digit:Int()
   Local Result:Int

   If Token => Asc("0") And Token <= Asc("9") Then
      Result = Token - Asc("0")
      Match(Token)
   Else
      Throw("Expected Digit")
   EndIf

   Return Result
End Function

Print 10 Shl 3^2 + ~9/8*(20 Shr 2)

scanner = new Scanner(@"C:\Test.bb");
// scanner = new Scanner(textCode.Text);

token = scanner.NextToken();
while(token.Id != TokenId.EndOfFile)
{
   switch(token.Id)
   {
      case TokenId.IntegerLiteral:
         // token.value
         break;

      case TokenId.StringLiteral:
         // token.value
         break;

      // ...
      case TokenId.EndFunction
      // ...
   }

   token = scanner.NextToken();
}