RepeatUntil   = 'Repeat'
                {Statement}
                'Until' Expression;

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

SelectCase    = 'Select' Expression
                {'Case' Expression {Statement}}
                ['Default' Expression {Statement}]
                {'Case' Expression {Statement}}
                ('EndSelect' | 'End Select');

Global X%

For X = 1 To 10
   Print "Hallo Welt"
Next

Id         | Content
-----------+------------
Keyword    | Global
Identifier | X%
Keyword    | For
Identifier | X
Symbol     | =
Number     | 1
Keyword    | To
Number     | 10
Identifier | Print
String     | Hallo Welt
Keyword    | Next

                 Program
                    |
           +--------+-----------------------+
           |                                |
VariableDecleration                      ForNext
           |                                |
         +-+-+         +------+------+------+----------+---------------+
         |   |         |      |      |      |          |               |
      Global X%       For Assignment To Expression Statement          Next
                              |             |          |
                          +---+----+        10    FunctionCall
                          |   |    |                   |
                          X%  =    1               +---+------+
                                                   |          |
                                                 Print    Expression
                                                              |
                                                         "Hallo Welt"

Global X%, Y#, Z$

A = X + Y + Z

Function DoSomething(X, Y, Z)
   Local Blub$
End Function

Identifier    | Type    | Scope
--------------+---------+------------
X             | Integer | Global
Y             | Float   | Global
Z             | String  | Global
A             | Integer | Global
F DoSomething | Integer | Global
X             | Integer | DoSomething
Y             | Integer | DoSomething
Z             | Integer | DoSomething
Blub          | String  | DoSomething

Graphics(800, 600, 32, 2);
Image img = LoadImage("spaceship.png");
...

<program>
 <varDecl>
  <global />
  <identifier type="int">x</identifier>
 </varDecl>

 <forNext>
  <for />

  <assignment>
   <identifier type="int">x</identifier>
   <equal />
   <number>1</number>
  </assignment>

  <to />

  <expression>
   <term>
    <factor>
     <number>10</number>
    </factor>
   </term>
  </expression>

  <statement>
   <functionCall>
    <identifier>Print</identifier>
    <expression>
     <term>
      <factor>
       <string>Hallo Welt</string>
      </factor>
     </term>
    </expression>
   </functionCall>
  </statemen>

  <next />
 </forNext>
</program>

<module>
   <header>
      <title>
         <en>
            3D vector class
         </en>
         <de>
            3D-Vektor-Klasse
         </de>
      </title>
      <version>
         <major>
            1
         </major>
         <minor>
            0
         </minor>
         <revision>
            0
         </revision>
         <build>
            0
         </build>
      </version>
      <license>
         GPL
      </license>
      <authors>
         <person role="developer">
            <name>
               Eduard Urbach
            </name>
            <id>
               2
            </id>
         </person>
      </authors>
      <website>
         http://www.blitzprog.de/Vector3D
      </website>
      <keywords>
         vector, 3d
      </keywords>
      <description>
         <de>
            Eine 3D-Vektor-Klasse, um Positionsdaten im dreidimensionalen Raum zu speichern und ggf. nötige Informationen mit den Funktionen der Vector3D-Klasse zu ermitteln.
         </de>
         <en>
            A 3D vector class for storing position data and getting information about the vector.
         </en>
      </description>
   </header>
   <code>
      <dependencies>
         <import>
            Blitzprog.Math
         </import>
      </dependencies>
      <class name="Vector3D">
         <public>
            <definitions>
               <define name="T">
                  <type callby="value" const="false">
                     Float
                  </type>
               </define>
            </definitions>
            <vars>
               <var name="x">
                  <type callby="value" const="false">
                     T
                  </type>
                  <value>
                     0
                  </value>
               </var>
               <var name="y">
                  <type callby="value" const="false">
                     T
                  </type>
                  <value>
                     0
                  </value>
               </var>
               <var name="z">
                  <type callby="value" const="false">
                     T
                  </type>
                  <value>
                     0
                  </value>
               </var>
            </vars>
            <methods>
               <constructor>
                  <parameters>
                     <parameter>
                        <var name="nX">
                           <type callby="value">
                              T
                           </type>
                        </var>
                     </parameter>
                  </parameters>
                  <code>
                     <var name="f">
                        <type callby="value">
                           T
                        </type>
                        <value>
                           <call from="this" function="GetLength">
                           </call>
                        </value>
                     </var>
                  </code>
               </constructor>
               <todo>
                  Check this function
               </todo>
               <function const="false" name="SetLength">
                  <parameters>
                     <parameter>
                        <var name="nLength">
                           <type callby="value" const="">
                              T
                           </type>
                        </var>
                     </parameter>
                  </parameters>
                  <code>
                     <var name="f">
                        <type callby="value" const="">
                           T
                        </type>
                        <value>
                           nLength /
                           <call from="this" function="GetLength">
                           </call>
                        </value>
                     </var>
                     <if-block>
                        <if>
                           <condition>
                              f != 0
                           </condition>
                           <code>
                              <divide>
                                 <operand>
                                    x
                                 </operand>
                                 <value>
                                    f
                                 </value>
                              </divide>
                              <divide>
                                 <operand>
                                    y
                                 </operand>
                                 <value>
                                    f
                                 </value>
                              </divide>
                              <divide>
                                 <operand>
                                    z
                                 </operand>
                                 <value>
                                    f
                                 </value>
                              </divide>
                           </code>
                        </if>
                     </if-block>
                  </code>
               </function>
               <function const="true" name="GetLength">
                  <type callby="value" const="false">
                     T
                  </type>
                  <code>
                     <return>
                        <call from="" function="Sqr">
                           <parameter>
                              x * x + y * y + z * z
                           </parameter>
                        </call>
                     </return>
                  </code>
               </function>
               <function const="false" name="Normalize">
                  <type callby="reference" const="false">
                     Vector3D
                  </type>
                  <code>
                     <var name="f">
                        <type callby="value" const="">
                           T
                        </type>
                        <value>
                           <call from="this" function="GetLength">
                           </call>
                        </value>
                     </var>
                     <if-block>
                        <if>
                           <condition>
                              f != 0
                           </condition>
                           <code>
                              <divide>
                                 <operand>
                                    x
                                 </operand>
                                 <value>
                                    f
                                 </value>
                              </divide>
                              <divide>
                                 <operand>
                                    y
                                 </operand>
                                 <value>
                                    f
                                 </value>
                              </divide>
                              <divide>
                                 <operand>
                                    z
                                 </operand>
                                 <value>
                                    f
                                 </value>
                              </divide>
                           </code>
                        </if>
                     </if-block>
                     <return>
                        this
                     </return>
                  </code>
               </function>
            </methods>
            <operators>
               <operator sign="=">
                  <type callby="reference" const="true">
                     Vector3D
                  </type>
                  <parameters>
                     <parameter>
                        <var name="vec">
                           <type callby="reference" const="true">
                              T
                           </type>
                        </var>
                     </parameter>
                  </parameters>
                  <code>
                     <assign>
                        <operand>
                           x
                        </operand>
                        <value>
                           <get>
                              <from>
                                 vec
                              </from>
                              <var>
                                 x
                              </var>
                           </get>
                        </value>
                     </assign>
                  </code>
               </operator>
            </operators>
         </public>
      </class>
   </code>
</module>

//---------------------------------------------------------------------------
// Title (en):             3D vector class
//---------------------------------------------------------------------------
// Description (en):       A 3D vector class for storing position data and ge
//                         tting information about the vector.               
//---------------------------------------------------------------------------
// Title (de):             3D-Vektor-Klasse
//---------------------------------------------------------------------------
// Description (de):       Eine 3D-Vektor-Klasse, um Positionsdaten im dreidi
//                         mensionalen Raum zu speichern und ggf. nötige Inf
//                         ormationen mit den Funktionen der Vector3D-Klasse
//                         zu ermitteln.                                     
//---------------------------------------------------------------------------
// Version:                1.0.0.0
// License:                GPL
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// Includes
//---------------------------------------------------------------------------


//Vector3D
class Vector3D
{
   public:
      //---------------------------------------------------------------------------
      // Definitions
      //---------------------------------------------------------------------------
      
      typedef Float T;
      
      //---------------------------------------------------------------------------
      // Variables
      //---------------------------------------------------------------------------
      
      T x;
      T y;
      T z;
      
      //---------------------------------------------------------------------------
      // Methods
      //---------------------------------------------------------------------------
      
      //SetLength
      inline void SetLength(T nLength)
      {
         T f = nLength / this->GetLength();
         if(f != 0)
         {
            x /= f;
            y /= f;
            z /= f;
         }
      }
      
      //GetLength
      inline T GetLength()
      {
         return Sqr(x * x + y * y + z * z);
      }
      
      //Normalize
      inline Vector3D& Normalize()
      {
         T f = this->GetLength();
         if(f != 0)
         {
            x /= f;
            y /= f;
            z /= f;
         }
         return (*this);
      }
      
      
};

CLASS tube
  LOCAL width:INT
  LOCAL height:INT
  LOCAL blub:BYTE

  count:INT

  SUB NEW()   ;constructor
  END

  SUB DELETE()   ;destructor
  END

  SUB meinemethode ()
  END

  LOCAL SUB sumsum ()
  END
END

CLASS supertube EXTENDS tube
  xyz:SHORT
END


SUB foo:INT (a:BYTE, b:SHORT, c:INT, d:LONG)
  ;declaration
  x:INT

  ;declaration+definition
  y:SINGLE=1.23

  LOOP x=1   ;wie while
  ...
  END
 
  LOOP   ;wie repeat
    IF  ... THEN STOP   ;wie end in bb
    ...
  END x=1

  LOOP   ;endlos
    IF ... THEN EXIT
    IF ... THEN SKIP   ;wie continue
  END

  FOR i, 0, 100[,step]
  END

  FOR i, listname   ;entspicht foreach
  END

  SELECT x
  CASE 1
  CASE 2
  CASE   ;wie default
  END

  IF x=0
  ..
  ELSE x=1
  ..
  ELSE x=2
  ..
  ELSE
  ..
  END

END

BlitzBasic |
BlitzMax   | -> XML -> C++
QBasic     |
FreeBasic  |

(* Parser --------------------------------------------
*)

Program = {ConstantDecleration}
          {VariableDecleration}
          {Statement};

ConstantDecleration = 'Const' DeclerationAssignment
                      {',' DeclerationAssignment};

VariableDecleration = 'Var' DeclerationAssignment
                      {',' DeclerationAssignment};

Statement = FunctionCall
          | Assignment
          | IfThen
          | WhileLoop
          | ForLoop;

DeclerationAssignment = Decleration '=' Expression;

Decleration = Identifier ':' ('Int' | 'String');

Expression = SimpleExpression
             [('==' | '!=' | '<' | '<=' | '>' | '>=')
             SimpleExpression];

SimpleExpr = ['+' | '-'] Term [('+' | '-') Term];

Term = Factor [('*' | '/') Factor];

Factor = Number
       | String
       | FunctionCall
       | Identifier
       | '(' Expression ')';

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

Assignment = Identifier '=' Expression;

IfThen = 'If' Expression 'Then'
         {Statement}
         ['ElseIf' Expression 'Then' {Statement}]
         ['Else' {Statement}]
         'EndIf';

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

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

(* Lexer ---------------------------------------------
*)

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

Comment    = ';' {Characters};
Number     = Digit {Digit};
String     = '"' {CHARACTERS} '"';
Identifier = Letter {'_' | Letter | Digit};

function blubb()
     include "blubb_func.xy";
end function

BlitzBasic |
BlitzMax   | -> XML -> C++
QBasic     |
FreeBasic  |

C++         |
BlitzMax    | -> XML -> C++
Java        |        -> AJAX //Nur GUI-Anwendungen, keine (grafischen) Spiele

BlitzMax    | -> XML -> C++

  =
 / \
x  +
   / \
  *   7
 / \
a  b

Irgendwas
  / \
IF   Bedingung
        |
       =
       / \
      a  0