[Language]
Name           = Visual Basic .NET
Extension      = vb

Keywords       = AddHandler, AddressOf, Alias, And, AndAlso, As, Boolean, ByRef, Byte, ByVal
               = Call, Case, Catch, CBool, CByte, CChar, CDate, CDec, CDbl, Char
               = CInt, Class, CLng, CObj, Const, Continue, CSByte, CShort, CSng, CStr
               = CType, CUInt, CULng, CUShort, Date, Decimal, Declare, Default, Delegate, Dim
               = DirectCast, Do, Double, Each, Else, ElseIf, End, EndIf, Enum, Erase
               = Error, Event, Exit, False, Finally, For, Friend, Function, Get, GetType
               = Global, GoSub, GoTo, Handles, If, Implements, Imports, In, Inherits, Integer
               = Interface, Is, IsNot, Let, Lib, Like, Long, Loop, Me, Mod
               = Module, MustInherit, MustOverride, MyBase, MyClass, Namespace, Narrowing, New, Next
               = Not, Nothing, NotInheritable, NotOverridable, Object, Of, On, Operator, Option, Optional
               = Or, OrElse, Overloads, Overridable, Overrides, ParamArray, Partial, Private, Property, Protected
               = Public, RaiseEvent, ReadOnly, ReDim, REM, RemoveHandler, Resume, Return, SByte, Select
               = Set, Shadows, Shared, Short, Single, Static, Step, Stop, String, Structure
               = Sub, SyncLock, Then, Throw, To, True, Try, TryCast, TypeOf, Variant
               = Wend, UInteger, ULong, UShort, Using, When, While, Widening, With, WithEvents
               = WriteOnly, Xor
               
Conflicts      = inputText, inputValue, output

Case Sensitive = false
Options        =  
             
; =======================================================
; Literals    
; =======================================================              

[Types]
Integer      = Integer
Real         = Double
Boolean      = Boolean
String       = String 

[Function ID]
Convention = proper
Normal     = {Name}          
Conflict   = [{Name}]

[Variable ID]
Convention = camel
Normal     = {Name}          
Conflict   = [{Name}]

[String Literal]
Text           = "{Characters}"
Replace Char 1 = "
Replace By 1   = ""

[Boolean Literal]
true     =  True
false    =  False

[Integer Literal]
Text     = {Integral}

[Real Literal]
Text     = {Integral}.{Fractional}

[Variable Access]
Precedence = 100
Text       = {Name}               | ~subscript
           = {Name}({Subscript})  | subscript 
           
; =======================================================
; Expressions      
; =======================================================
; VB .NET precedence: 
; 1. or 
; 2. and 
; 3. not
; 4. Relational and equality: =, >, < ...
; 5. Addition 
; 6. Multiply 
; 7. Unary: -
; 8. ^
; 100. Atom, paranthesis
         
[Or]
Precedence   = 1
Needed 1     = 1
Needed 2     = 2
Text         = {1} Or {2}

[And]
Precedence   = 2
Needed 1     = 2
Needed 2     = 3
Text         = {1} And {2}

;=== NOT is precedence 3

[Equals]
Precedence   = 4               
Needed 1     = 5     
Needed 2     = 5
Text         = {1} = {2}        

[Not Equals]
Precedence   = 4               
Needed 1     = 5     
Needed 2     = 5
Text         = {1} <> {2}
             
[Less Than]
Precedence   = 4               
Needed 1     = 5     
Needed 2     = 5     
Text         = {1} < {2}             

[Less Equal Than]
Precedence   = 4               
Needed 1     = 5     
Needed 2     = 5     
Text         = {1} <= {2}             

[Greater Than]
Precedence   = 4               
Needed 1     = 5     
Needed 2     = 5     
Text         = {1} > {2}             

[Greater Equal Than]
Precedence   = 4               
Needed 1     = 5     
Needed 2     = 5     
Text         = {1} >= {2}             

[Concatenate]
Precedence   = 5
Needed 1     = 5
Needed 2     = 6
Text         = {1} & {2}

[Add]
Precedence   = 5
Needed 1     = 5
Needed 2     = 6
Text         = {1} + {2} 

[Subtract]
Precedence   = 5
Needed 1     = 5
Needed 2     = 6
Text         = {1} - {2} 

[Multiply]
Precedence   = 6
Needed 1     = 6
Needed 2     = 7
Text         = {1} * {2}

[Divide]
Precedence   = 6
Needed 1     = 6
Needed 2     = 7
Text         = {1} / {2}
             
[Modulus]
Precedence   = 6
Needed 1     = 6
Needed 2     = 7
Text         = {1} Mod {2}

[Power]
Precedence   = 8
Needed 1     = 9
Needed 2     = 8
Text         = {1} ^ {2}

[Not]
Precedence   = 3
Needed 1     = 3
Text         = Not {1}

[Negate]
Precedence   = 7
Needed 1     = 7
Text         = -{1}

[Subexpression]
Precedence   = 100
Text         = ({Expression})

; =======================================================
; Intrinsic Functions      
; =======================================================

[Abs]
Precedence = 100
Needed 1   = 1 
Text       = Math.Abs({1})

[ArcCos]
Precedence = 100
Needed 1   = 1 
Text       = Math.ACos({1})

[ArcSin]
Precedence = 100
Needed 1   = 1 
Text       = Math.ASin({1})

[ArcTan]
Precedence = 100
Needed 1   = 1 
Text       = Math.Atan({1})

[Char]
Precedence = 100
Needed 1   = 100
Needed 2   = 1
Text       = {1}.CharAt({2})

[Cos]
Precedence = 100
Needed 1   = 1 
Text       = Math.Cos({1})

[Int]
Precedence = 100
Needed 1   = 1 
Text       = Math.Floor({1})

[Len]
Precedence = 100
Needed 1   = 100
Text       = {1}.Length

[Log]
Precedence = 100
Needed 1   = 1 
Text       = Math.Log({1})

[Log10]
Precedence = 100
Needed 1   = 1 
Text       = Math.Log10({1})

[Pi]
Precedence = 100
Text       = Math.PI

[Random]
Precedence = 100
Needed 1   = 1 
Text       = random.Next({1})

[Sin]
Precedence = 100
Needed 1   = 1 
Text       = Math.Sin({1})

[Sgn]
Precedence = 100
Needed 1   = 1 
Text       = Math.Sign({1})

[Size]
Precedence = 100
Needed 1   = 100 
Text       = {1}.Length

[Sqrt]
Precedence = 100
Needed 1   = 1 
Text       = Math.Sqrt({1})

[Tan]
Precedence = 100
Needed 1   = 1 
Text       = Math.Tan({1})

[ToChar]
Precedence = 100
Needed 1   = 1
Text       = Strings.ChrW({1})

[ToCode]
Precedence = 100
Needed 1   = 1 
Text       = String.AscW({1})

[ToFixed]
Precedence = 100
Needed 1   = 1 
Needed 2   = 1 
Text       = ToFixed({1}, {2})

[ToInteger]
Precedence = 100
Needed 1   = 1 
Text       = Convert.ToInt32({1})

[ToReal]
Precedence = 100
Needed 1   = 1
Text       = Convert.ToDouble({1})

[ToString]
Precedence = 100
Needed 1   = 100
Text       = {1}.ToString()

; =======================================================
; Function call      
; =======================================================

[Function Call]
Precedence = 100
Text       = {name}({arguments}) 
          
[Argument]
Separator  = ,{space}
Text       = {expression}

; =======================================================
; Program
; =======================================================

[Program]
Text      = Imports System
          = 
          = Public Module MyProgram          
          = Private random as new Random()       | Random | 1
          =                                      | Random | 1
              
          = -->MAIN                                | | 1
          = -->FUNCTIONS                           | | 1

          =                                                                    | tofixed | 1 
          = Function ToFixed(value As Double, digits As Integer) As String     | tofixed | 1
          = Return value.ToString("f" & digits)                                | tofixed | 2
          = End Function                                                       | tofixed | 1   
         
          =                                                                           | input | 1 
          = ' .NET can only read single characters or entire lines from the console.  | input | 1
          = ' The following functions are designed to help input specific data types. | input | 1
          = Private Function inputValue() As Double                     | input | 1   
          = Dim result As Double                                        | input | 2
          = While Not Double.TryParse(Console.ReadLine(), result)       | input | 2
          = ' No code in the loop                                       | input | 3
          = End While                                                   | input | 2
          = Return result                                               | input | 2
          = End Function                                                | input | 1
          =                                                             | input | 1    
          = Private Function inputText() As String                      | input | 1
          = return Console.ReadLine()                                   | input | 2    
          = End Function                                                | input | 1

          =                                                             | output | 1
          = Private Sub output(text As String)                          | output | 1
          = Console.WriteLine(text)                                     | output | 2    
          = End Sub                                                     | output | 1
          
          = End Module
          
[Main]
Text      = Sub Main                     | |                              
          = -->BLOCK                       | | 1
          = End Sub                      | |  

; =======================================================
; Function  
; =======================================================

[Parameter]
Separator = ,{space}
Text      = {name} As {type}             | ~array  
          = ByRef {name}() As {type}     | array  

[Function]
Text      = 
          = Private Sub {name} ({parameters})        | ~return   
          = -->BLOCK                                 | ~return | 1 
          = End Sub                                  | ~return          

          = Private Function {name} ({parameters})   | return   
          = -->BLOCK                                 | return | 1 
          =                                          | return | 1
          = Return {return  }                        | return | 1          
          = End Function                             | return                                                  
                           
; =======================================================
; Statements      
; =======================================================

[Assign]         
Text      = {Variable} = {Expression}           
            
[Call]
Text      = {Name}({Arguments})

[Comment]
Text      = ' {Text} 

[Declare Name] 
Separator = ,{space}          
Text      = {name} As {Type}              | ~array
          = {name}({Size}) As {Type}      | array
           
[Declare]
Text      = Dim {Variables}                      

[Do]
Text      = Do                               
          = -->BLOCK                    | | 1    
          = Loop While {condition}

[For]
Text      = For {Variable} = {Start} To {End}               | ~step
          = For {Variable} = {Start} To {End} Step {step}   | step
          = -->BLOCK                                        |       | 1                          
          = Next                                                                   
          
[Input]
Text      = {Variable} = inputText()      | ~string          
          = {Variable} = inputValue()     | String   

[If]
Text      = If {condition} Then 
          = -->TRUEBLOCK                    |       | 1
          = Else                            | else 
          = -->FALSEBLOCK                   | else  | 1
          = End If
                 
[Output]
Text      = output({Expression})

[While]
Text      = Do While {condition}
          = -->BLOCK                            | | 1
          = Loop