Lexicale grammatica

Compilatie van een Visual Basic-programma omvat eerst het vertalen van de onbewerkte stroom Unicode-tekens in een geordende set lexicale tokens. Omdat de Visual Basic-taal geen vrije indeling heeft, wordt de set tokens vervolgens verder onderverdeeld in een reeks logische lijnen. Een logische lijn loopt van het begin van de stroom of een regeleindteken tot aan de volgende regeleindteken dat niet wordt voorafgegaan door een regelvervolging of tot aan het einde van de stroom.

Opmerking. Met de introductie van letterlijke XML-expressies in versie 9.0 van de taal heeft Visual Basic geen duidelijke lexicale grammatica meer in de zin dat Visual Basic-code kan worden tokenn zonder rekening te houden met de syntactische context. Dit komt doordat XML en Visual Basic verschillende lexicale regels hebben en de set lexicale regels die op een bepaald moment worden gebruikt, is afhankelijk van de syntactische constructie die op dat moment wordt verwerkt. Deze specificatie behoudt deze lexicale grammaticasectie als richtlijn voor de lexicale regels van reguliere Visual Basic-code.

LogicalLineStart
    : LogicalLine*
    ;

LogicalLine
    : LogicalLineElement* Comment? LineTerminator
    ;

LogicalLineElement
    : WhiteSpace
    | LineContinuation
    | Token
    ;

Token
    : Identifier
    | Keyword
    | Literal
    | Separator
    | Operator
    ;

Tekens en lijnen

Visual Basic-programma's bestaan uit tekens uit de Unicode-tekenset.

Character:
    '<Any Unicode character except a LineTerminator>'
    ;

Lijneindtekens

Unicode-regeleindetekens scheiden logische regels.

LineTerminator
    : '<Unicode 0x00D>'
    | '<Unicode 0x00A>'
    | '<CR>'
    | '<LF>'
    | '<Unicode 0x2028>'
    | '<Unicode 0x2029>'
    ;

Regelvoortzetting

Een regelvervolging bestaat uit ten minste één spatieteken dat direct voorafgaat aan één onderstrepingsteken als laatste teken (behalve witruimte) in een tekstregel. Met een regelvervolging kan een logische lijn meer dan één fysieke lijn omvatten. Lijnvervolgingen worden behandeld alsof ze witruimte waren, ook al zijn ze dat niet.

LineContinuation
    : WhiteSpace '_' WhiteSpace* LineTerminator
    ;

In het volgende programma ziet u enkele regelvervolgingen:

Module Test
    Sub Print( _
        Param1 As Integer, _
        Param2 As Integer )

        If (Param1 < Param2) Or _
            (Param1 > Param2) Then
            Console.WriteLine("Not equal")
        End If
    End Function
End Module

Op sommige plaatsen in de syntactische grammatica zijn impliciete lijnvervolgingen mogelijk. Wanneer er een regeleindteken wordt aangetroffen

• na een komma (), haakje openen (,(), accolade openen ({) of ingesloten expressie openen (<%=)

• na de kwalificatie van een lid (.of....@), mits er iets wordt gekwalificeerd (dat wil bijvoorbeeld geen impliciete With context gebruiken)

• voor een haakje sluiten (), sluit accolade ()}) of sluit ingesloten expressie (%>)

• na een minder dan (<) in een kenmerkcontext

• vóór een groter dan (>) in een kenmerkcontext

• na een groter dan (>) in een kenmerkcontext op niet-bestandsniveau

• voor en na queryoperators (Where, Order, Selectenzovoort)

• na binaire operatoren (+, -, /, *enzovoort) in een expressiecontext

• na toewijzingsoperatoren (=, :=, +=, -=enzovoort) in elke context.

het lijneindteken wordt behandeld alsof het een lijnvervolging was.

Comma
    : ',' LineTerminator?
    ;

Period
    : '.' LineTerminator?
    ;

OpenParenthesis
    : '(' LineTerminator?
    ;

CloseParenthesis
    : LineTerminator? ')'
    ;

OpenCurlyBrace
    : '{' LineTerminator?
    ;

CloseCurlyBrace
    : LineTerminator? '}'
    ;

Equals
    : '=' LineTerminator?
    ;

ColonEquals
    : ':' '=' LineTerminator?
    ;

Het vorige voorbeeld kan bijvoorbeeld ook worden geschreven als:

Module Test
    Sub Print(
        Param1 As Integer,
        Param2 As Integer)

        If (Param1 < Param2) Or
            (Param1 > Param2) Then
            Console.WriteLine("Not equal")
        End If
    End Function
End Module

Impliciete regelvervolgingen worden alleen direct voor of na het opgegeven token afgeleid. Ze worden niet uitgesteld voor of na een regelvervolging. Voorbeeld:

Dim y = 10
' Error: Expression expected for assignment to x
Dim x = _

y

Regelvervolgingen worden niet afgeleid in voorwaardelijke compilatiecontexten. (Opmerking. Deze laatste beperking is vereist omdat tekst in voorwaardelijke compilatieblokken die niet zijn gecompileerd, niet syntactisch geldig hoeven te zijn. Tekst in het blok kan dus per ongeluk worden 'opgehaald' door de voorwaardelijke compilatie-instructie, met name omdat de taal in de toekomst wordt uitgebreid.)

Witruimte

Witruimte dient alleen om tokens te scheiden en wordt anders genegeerd. Logische lijnen met alleen witruimte worden genegeerd. (Opmerking. Regeleindtekens worden niet beschouwd als witruimte.)

WhiteSpace
    : '<Unicode class Zs>'
    | '<Unicode Tab 0x0009>'
    ;

Opmerkingen

Een opmerking begint met een enkel aanhalingsteken of het trefwoord REM. Een enkel aanhalingsteken is een ASCII-teken met één aanhalingsteken, een Unicode-teken met één aanhalingsteken of een Unicode-teken met één aanhalingsteken. Opmerkingen kunnen overal op een bronregel beginnen en het einde van de fysieke regel eindigt de opmerking. De compiler negeert de tekens tussen het begin van de opmerking en het regeleindteken. Opmerkingen kunnen daarom niet over meerdere regels worden uitgebreid met behulp van regelvervolgingen.

Comment
    : CommentMarker Character*
    ;

CommentMarker
    : SingleQuoteCharacter
    | 'REM'
    ;

SingleQuoteCharacter
    : '\''
    | '<Unicode 0x2018>'
    | '<Unicode 0x2019>'
    ;

Identifiers

Een id is een naam. Visual Basic-id's voldoen aan de Unicode Standard-bijlage 15 met één uitzondering: id's kunnen beginnen met een onderstrepingsteken (verbindingslijn). Als een id begint met een onderstrepingsteken, moet deze ten minste één ander geldig id-teken bevatten om deze te onderscheiden van een regelvervolging.

Identifier
    : NonEscapedIdentifier TypeCharacter?
    | Keyword TypeCharacter
    | EscapedIdentifier
    ;

NonEscapedIdentifier
    : '<Any IdentifierName but not Keyword>'
    ;

EscapedIdentifier
    : '[' IdentifierName ']'
    ;

IdentifierName
    : IdentifierStart IdentifierCharacter*
    ;

IdentifierStart
    : AlphaCharacter
    | UnderscoreCharacter IdentifierCharacter
    ;

IdentifierCharacter
    : UnderscoreCharacter
    | AlphaCharacter
    | NumericCharacter
    | CombiningCharacter
    | FormattingCharacter
    ;

AlphaCharacter
    : '<Unicode classes Lu,Ll,Lt,Lm,Lo,Nl>'
    ;

NumericCharacter
    : '<Unicode decimal digit class Nd>'
    ;

CombiningCharacter
    : '<Unicode combining character classes Mn, Mc>'
    ;

FormattingCharacter
    : '<Unicode formatting character class Cf>'
    ;

UnderscoreCharacter
    : '<Unicode connection character class Pc>'
    ;

IdentifierOrKeyword
    : Identifier
    | Keyword
    ;

Reguliere id's komen mogelijk niet overeen met trefwoorden, maar escape-id's of id's met een typeteken kunnen. Een escape-id is een id die wordt gescheiden door vierkante haken. Escaped-id's volgen dezelfde regels als reguliere id's, behalve dat ze mogelijk overeenkomen met trefwoorden en mogelijk geen typetekens hebben.

In dit voorbeeld wordt een klasse gedefinieerd met class een gedeelde methode die shared een parameter met de naam boolean gebruikt en vervolgens de methode aanroept.

Class [class]
    Shared Sub [shared]([boolean] As Boolean)
        If [boolean] Then
            Console.WriteLine("true")
        Else
            Console.WriteLine("false")
        End If
    End Sub
End Class

Module [module]
    Sub Main()
        [class].[shared](True)
    End Sub
End Module

Id's zijn niet hoofdlettergevoelig, dus twee id's worden beschouwd als dezelfde id als ze alleen verschillen in het geval. (Opmerking. De Unicode Standard-toewijzingen van één-op-één-case worden gebruikt bij het vergelijken van id's en eventuele landspecifieke casetoewijzingen worden genegeerd.)

Typ tekens

Een typeteken geeft het type van de voorgaande id aan. Het typeteken wordt niet beschouwd als onderdeel van de id.

TypeCharacter
    : IntegerTypeCharacter
    | LongTypeCharacter
    | DecimalTypeCharacter
    | SingleTypeCharacter
    | DoubleTypeCharacter
    | StringTypeCharacter
    ;

IntegerTypeCharacter
    : '%'
    ;

LongTypeCharacter
    : '&'
    ;

DecimalTypeCharacter
    : '@'
    ;

SingleTypeCharacter
    : '!'
    ;

DoubleTypeCharacter
    : '#'
    ;

StringTypeCharacter
    : '$'
    ;

Als een declaratie een typeteken bevat, moet het type teken overeenkomen met het type dat is opgegeven in de declaratie zelf; anders treedt er een compilatietijdfout op. Als in de declaratie het type weglaat (bijvoorbeeld als er geen component wordt opgegeven As ), wordt het type teken impliciet vervangen door het type van de declaratie.

Er mag geen witruimte tussen een id en het bijbehorende type teken komen. Er zijn geen typetekens voor Byte, SByte, UShort, Shortof ULongUInteger , vanwege een gebrek aan geschikte tekens.

Als u een typeteken toevoegt aan een id die conceptueel geen type heeft (bijvoorbeeld een naamruimtenaam) of een id waarvan het type niet overeenkomt met het type van het type, veroorzaakt een compilatiefout.

In het volgende voorbeeld ziet u het gebruik van typetekens:

' The follow line will cause an error: standard modules have no type.
Module Test1#
End Module

Module Test2

    ' This function takes a Long parameter and returns a String.
    Function Func$(Param&)

        ' The following line causes an error because the type character
        ' conflicts with the declared type of Func and Param.
        Func# = CStr(Param@)

        ' The following line is valid.
        Func$ = CStr(Param&)
    End Function
End Module

Het typeteken ! geeft een speciaal probleem aan dat het kan worden gebruikt als een typeteken en als scheidingsteken in de taal. Als u dubbelzinnigheid wilt verwijderen, is een teken een ! typeteken zolang het teken dat volgt, geen id kan starten. Als dat mogelijk is, is het ! teken een scheidingsteken, niet een typeteken.

Zoekwoorden

Een trefwoord is een woord dat speciale betekenis heeft in een taalconstructie. Alle trefwoorden zijn gereserveerd door de taal en kunnen niet als id's worden gebruikt, tenzij de id's zijn ontsnapt. (Opmerking.EndIf, GoSub, Let, Varianten Wend worden bewaard als trefwoorden, hoewel ze niet meer worden gebruikt in Visual Basic.)

Keyword
    : 'AddHandler'      | 'AddressOf'      | 'Alias'       | 'And'
    | 'AndAlso'         | 'As'             | 'Boolean'     | 'ByRef'
	| 'Byte'            | 'ByVal'          | 'Call'        | 'Case'        
	| 'Catch'           | 'CBool'          | 'CByte'       | 'CChar'       
	| 'CDate'           | 'CDbl'           | 'CDec'        | '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'     
	| 'GetXmlNamespace' | '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'      | 'UInteger'    
	| 'ULong'           | 'UShort'         | 'Using'       | 'Variant'     
	| 'Wend'            | 'When'           | 'While'       | 'Widening'    
	| 'With'            | 'WithEvents'     | 'WriteOnly'   | 'Xor'         
    ;

Letterlijke waarden

Een letterlijke waarde is een tekstuele weergave van een bepaalde waarde van een type. Letterlijke typen zijn booleaanse waarde, geheel getal, drijvende komma, tekenreeks, teken en datum.

Literal
    : BooleanLiteral
    | IntegerLiteral
    | FloatingPointLiteral
    | StringLiteral
    | CharacterLiteral
    | DateLiteral
    | Nothing
    ;

Booleaanse letterlijke waarden

True en False letterlijke gegevens zijn van het Boolean type dat respectievelijk is toegewezen aan de status Waar en Onwaar.

BooleanLiteral
    : 'True' | 'False'
    ;

Letterlijke waarden voor gehele getallen

Letterlijke waarden voor gehele getallen kunnen decimaal zijn (grondtal 10), hexadecimaal (grondtal 16) of octaal (grondtal 8). Een letterlijke decimaal geheel getal is een tekenreeks met decimale cijfers (0-9). Een hexadecimale letterlijke waarde wordt &H gevolgd door een reeks hexadecimale cijfers (0-9, A-F). Een octale letterlijke tekst wordt &O gevolgd door een tekenreeks met octale cijfers (0-7). Letterlijke decimalen vertegenwoordigen rechtstreeks de decimale waarde van de integrale letterlijke waarde, terwijl octale en hexadecimale letterlijke waarden de binaire waarde van de letterlijke geheel getal vertegenwoordigen (dus &H8000S -32768, geen overloopfout).

IntegerLiteral
    : IntegralLiteralValue IntegralTypeCharacter?
    ;

IntegralLiteralValue
    : IntLiteral
    | HexLiteral
    | OctalLiteral
    ;

IntegralTypeCharacter
    : ShortCharacter
    | UnsignedShortCharacter
    | IntegerCharacter
    | UnsignedIntegerCharacter
    | LongCharacter
    | UnsignedLongCharacter
    | IntegerTypeCharacter
    | LongTypeCharacter
    ;

ShortCharacter
    : 'S'
    ;

UnsignedShortCharacter
    : 'US'
    ;

IntegerCharacter
    : 'I'
    ;

UnsignedIntegerCharacter
    : 'UI'
    ;

LongCharacter
    : 'L'
    ;

UnsignedLongCharacter
    : 'UL'
    ;

IntLiteral
    : Digit+
    ;

HexLiteral
    : '&' 'H' HexDigit+
    ;

OctalLiteral
    : '&' 'O' OctalDigit+
    ;

Digit
    : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
    ;

HexDigit
    : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
    | 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
    ;

OctalDigit
    : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'
    ;

Het type van een letterlijke waarde wordt bepaald door de waarde of door het volgende type teken. Als er geen typeteken is opgegeven, worden waarden in het bereik van het Integer type getypt als Integer; waarden buiten het bereik Integer worden getypt als Long. Als het type van een letterlijke waarde van een geheel getal onvoldoende is om de letterlijke waarde van het gehele getal te bevatten, wordt er een fout met een compilatietijd weergegeven. (Opmerking. Er is geen typeteken voor Byte omdat het meest natuurlijke teken zou zijn B, wat een juridisch teken is in een hexadecimale letterlijke waarde.)

letterlijke Floating-Point

Een letterlijke drijvende komma is een letterlijk geheel getal, gevolgd door een optioneel decimaalteken (het ASCII-puntteken) en mantissa en een optionele basis 10 exponent. Standaard is een letterlijke drijvende komma van het type Double. Als het Single, Doubleof Decimal het type teken is opgegeven, is de letterlijke waarde van dat type. Als het type van een letterlijke drijvende komma onvoldoende grootte heeft om de letterlijke drijvende komma te bevatten, treedt er een compilatiefout op.

Opmerking. Het is de moeite waard om te vermelden dat het Decimal gegevenstype volgnullen in een waarde kan coderen. De specificatie geeft momenteel geen commentaar over of volgnullen in een Decimal letterlijke plaats door een compiler moeten worden gehonoreerd.

FloatingPointLiteral
    : FloatingPointLiteralValue FloatingPointTypeCharacter?
    | IntLiteral FloatingPointTypeCharacter
    ;

FloatingPointTypeCharacter
    : SingleCharacter
    | DoubleCharacter
    | DecimalCharacter
    | SingleTypeCharacter
    | DoubleTypeCharacter
    | DecimalTypeCharacter
    ;

SingleCharacter
    : 'F'
    ;

DoubleCharacter
    : 'R'
    ;

DecimalCharacter
    : 'D'
    ;

FloatingPointLiteralValue
    : IntLiteral '.' IntLiteral Exponent?
    | '.' IntLiteral Exponent?
    | IntLiteral Exponent
    ;

Exponent
    : 'E' Sign? IntLiteral
    ;

Sign
    : '+'
    | '-'
    ;

Letterlijke tekenreeksen

Een letterlijke tekenreeks is een reeks nul of meer Unicode-tekens die beginnen en eindigen met een ASCII-teken met dubbele aanhalingstekens, een Unicode-teken links dubbel aanhalingsteken of een Unicode-teken met dubbele aanhalingstekens. Binnen een tekenreeks is een reeks van twee dubbele aanhalingstekens een escapereeks die een dubbele aanhalingsteken in de tekenreeks vertegenwoordigt.

StringLiteral
    : DoubleQuoteCharacter StringCharacter* DoubleQuoteCharacter
    ;

DoubleQuoteCharacter
    : '"'
    | '<unicode left double-quote 0x201c>'
    | '<unicode right double-quote 0x201D>'
    ;

StringCharacter
    : '<Any character except DoubleQuoteCharacter>'
    | DoubleQuoteCharacter DoubleQuoteCharacter
    ;

Een tekenreeksconstante is van het String type.

Module Test
    Sub Main()

        ' This prints out: ".
        Console.WriteLine("""")

        ' This prints out: a"b.
        Console.WriteLine("a""b")

        ' This causes a compile error due to mismatched double-quotes.
        Console.WriteLine("a"b")
    End Sub
End Module

De compiler mag een constante tekenreeksexpressie vervangen door een letterlijke tekenreeks. Niet elke string literal resulteert noodzakelijkerwijs in een nieuwe tekenreeks. Wanneer twee of meer letterlijke tekenreeksen die equivalent zijn volgens de operator voor gelijkheid van tekenreeksen met behulp van binaire vergelijkingssemantiek in hetzelfde programma worden weergegeven, kunnen deze letterlijke tekenreeksen verwijzen naar hetzelfde tekenreeksexemplaren. De uitvoer van het volgende programma kan bijvoorbeeld worden geretourneerd True omdat de twee letterlijke waarden naar hetzelfde tekenreeksexemplaren verwijzen.

Module Test
    Sub Main()
        Dim a As Object = "he" & "llo"
        Dim b As Object = "hello"
        Console.WriteLine(a Is b)
    End Sub
End Module

Letterlijke tekens

Een letterlijk teken vertegenwoordigt één Unicode-teken van het Char type. Twee dubbele aanhalingstekens zijn een escapereeks die het dubbele aanhalingsteken weergeeft.

CharacterLiteral
    : DoubleQuoteCharacter StringCharacter DoubleQuoteCharacter 'C'
    ;

Module Test
    Sub Main()

        ' This prints out: a.
        Console.WriteLine("a"c)

        ' This prints out: ".
        Console.WriteLine(""""c)
    End Sub
End Module

Letterlijke datum

Een letterlijke datum vertegenwoordigt een bepaald tijdstip dat wordt uitgedrukt als een waarde van het Date type.

DateLiteral
    : '#' WhiteSpace* DateOrTime WhiteSpace* '#'
    ;

DateOrTime
    : DateValue WhiteSpace+ TimeValue
    | DateValue
    | TimeValue
    ;

DateValue
    : MonthValue '/' DayValue '/' YearValue
    | MonthValue '-' DayValue '-' YearValue
    ;

TimeValue
    : HourValue ':' MinuteValue ( ':' SecondValue )? WhiteSpace* AMPM?
    | HourValue WhiteSpace* AMPM
    ;

MonthValue
    : IntLiteral
    ;

DayValue
    : IntLiteral
    ;

YearValue
    : IntLiteral
    ;

HourValue
    : IntLiteral
    ;

MinuteValue
    : IntLiteral
    ;

SecondValue
    : IntLiteral
    ;

AMPM
    : 'AM' | 'PM'
    ;    

De letterlijke waarde kan zowel een datum als een tijd, alleen een datum of slechts een tijd opgeven. Als de datumwaarde wordt weggelaten, wordt uitgegaan van 1 januari van het jaar 1 in de Gregoriaanse kalender. Als de tijdwaarde wordt weggelaten, wordt ervan uitgegaan dat 12:00:00 uur.

Om problemen met het interpreteren van de jaarwaarde in een datumwaarde te voorkomen, mag de jaarwaarde geen twee cijfers zijn. Bij het uitdrukken van een datum in de eerste eeuw AD/CE, moeten voorloopnullen worden opgegeven.

Een tijdwaarde kan worden opgegeven met een waarde van 24 uur of een waarde van 12 uur; tijdwaarden die een AM waarde van 24 uur weglaten of PM worden verondersteld. Als een tijdwaarde de minuten weglaat, wordt de letterlijke waarde 0 standaard gebruikt. Als een tijdwaarde de seconden weglaat, wordt de letterlijke waarde 0 standaard gebruikt. Als zowel minuten als seconde worden weggelaten, AM moet of PM worden opgegeven. Als de opgegeven datumwaarde buiten het bereik van het Date type valt, treedt er een compilatietijdfout op.

Het volgende voorbeeld bevat verschillende letterlijke datums.

Dim d As Date

d = # 8/23/1970 3:45:39AM #
d = # 8/23/1970 #              ' Date value: 8/23/1970 12:00:00AM.
d = # 3:45:39AM #              ' Date value: 1/1/1 3:45:39AM.
d = # 3:45:39 #                ' Date value: 1/1/1 3:45:39AM.
d = # 13:45:39 #               ' Date value: 1/1/1 1:45:39PM.
d = # 1AM #                    ' Date value: 1/1/1 1:00:00AM.
d = # 13:45:39PM #             ' This date value is not valid.

Niets

Nothing is een speciale letterlijke; het heeft geen type en is converteerbaar naar alle typen in het typesysteem, inclusief typeparameters. Wanneer het wordt geconverteerd naar een bepaald type, is dit het equivalent van de standaardwaarde van dat type.

Nothing
    : 'Nothing'
    ;

Scheidingsmiddelen

De volgende ASCII-tekens zijn scheidingstekens:

Separator
    : '(' | ')' | '{' | '}' | '!' | '#' | ',' | '.' | ':' | '?'
    ;

Operatortekens

De volgende ASCII-tekens of tekenreeksen geven operators aan:

Operator
    : '&' | '*' | '+' | '-' | '/' | '\\' | '^' | '<' | '=' | '>'
    ;