What are Lexical Operators

Lexical grammarLexical grammar

  • 11 minutes to read

Compilation of a Visual Basic program first involves translating the raw stream of Unicode characters into an ordered set of lexical tokens.Da es Because the Visual Basic language is not free-format, the set of tokens is then further divided into a series of logical lines. One logical line extends from the beginning of the stream or a line termination character to the next line termination character preceded by no line continuation or the end of the stream logical line spans from either the start of the stream or a line terminator through to the next line terminator that is not preceded by a line continuation or through to the end of the stream.

Note:Grade.With the introduction of XML literal expressions in version 9.0 of the language, Visual Basic no longer has a clear lexical grammar in the sense that Visual Basic code can be tokenized without considering the syntactic context 9.0 of the language, Visual Basic no longer has a distinct lexical grammar in the sense that Visual Basic code can be tokenized without regard to the syntactic context. This is because XML and Visual Basic have different lexical rules and the set of lexical This is due to the fact that XML and Visual Basic have different lexical rules and the set of lexical rules in use at any particular time depends on what syntactic construct is being processed at that moment. This specification retains d This specification retains this lexical grammar section as a guide to the lexical rules of regular Visual Basic code.

Characters and Lines. Characters and Lines

Visual Basic programs are composed of characters from the Unicode character set.

Line terminators

Unicode line break characters separate logical lines.

Line continuation

A Lines continuation consists of at least one space immediately before a single underscore as the last character (excluding space) in a line of text line continuation consists of at least one white-space character that immediately precedes a single underscore character as the last character (other than white space) in a text line continuation allows a logical line to span more than one physical line. Line continuations are treated as if they were white space, even though they are not.

The following program shows some line continuations:

Leave some places in the syntactic grammar implicit line continuations Some places in the syntactic grammar allow for implicit line continuationsWhen a line terminator is encountered

  • After a comma (), open parenthesis (), open curly brace (), or open embedded expression ()

  • after a member qualifier (or or), provided that something is being qualified (i.e. is not using an implicit context)

  • before a close parenthesis (), close curly brace (), or close embedded expression ()

  • after a less-than () in an attribute context

  • before a greater-than () in an attribute context

  • after a greater-than () in a non-file-level attribute context

  • before and after query operators (,,, etc.)

  • after binary operators (,,,, etc.) in an expression context

  • after assignment operators (,,,, etc.) in any context.

the line terminator is treated as if it was a line continuation.

The previous example could e.g. b. can also be written as: For example, the previous example could also be written as:

Implicit line continuations will only ever be inferred directly before or after the specified token.They will not be inferred before or after a line continuation.Example: For example:

Line continuations will not be inferred in conditional compilation contexts. (Note:(Grade.This last restriction is required because text in conditional compilation blocks that are not compiled do not have to be syntactically valid Thus, text in the block might accidentally get "picked up" by the conditional compilation statement, especially as the language gets extended in the future.)

White space

White space is only used to separate tokens and is otherwise ignored.White space serves only to separate tokens and is otherwise ignored. Logical lines containing only white space are ignored. (Note:(Grade.Line terminators are not considered white space.)

CommentsComments

A comment begins with a single quotation mark or the keyword .A comment begins with a single-quote character or the keyword. A single-quote character is either an ASCII single-quote character, a Unicode left single-quote character, or a Unicode right single-quote character. Comments can begin anywhere on a source line, and the end of the physical line ends the comment. The compiler ignores the characters between the beginning of the comment and the line terminator. As a result, comments cannot be expanded across lines Subsequently, comments cannot extend across multiple lines by using line continuations.

Identifiers

A Identifier is a name.An identifier is a name.Visual Basic identifiers conform to the Unicode Standard Annex 15 with one exception: identifiers may begin with an underscore (connector ) character. If an identifier begins with an underscore, it must contain at least one other valid identifier character to disambiguate it from a line continuation.

Regular identifiers may not match keywords, but escaped identifiers or identifiers with a type character can is an identifier separated by square brackets escaped identifier is an identifier delimited by square brackets. Escape identifiers follow the same rules as regular identifiers except that they may match keywords and may not have type characters.

This example defines a class named with a shared method named that takes a parameter named and then calls the method.

Identifiers are case insensitive, so two identifiers are considered to be the same identifier if they differ only in case. (Note:(Grade.The Unicode Standard one-to-one case mappings are used when comparing identifiers and any locale-specific case mappings are ignored.)

Type Characters

A Type character indicates the type of the preceding identifier A. type character denotes the type of the preceding identifier. The type character is not considered part of the identifier.

If a declaration contains a type character, the type character must match the type specified in the declaration itself. Otherwise, a compile-time error occurs. If a declaration includes a type character, the type character must agree with the type specified in the declaration itself; otherwise, a compile-time error occurs. If the declaration omits the type (for example, if it does not specify an clause), the type character is implicitly substituted as the type of the declaration.

No white space may come between an identifier and its type character.There are no type characters for,, ,, or, due to a lack of suitable characters.

Appending a type character to an identifier that conceptually does not have a type (for example, a namespace name) or to an identifier whose type disagrees with the type of the type character causes a compile-time error.

The following example shows the use of type characters:

The type character presents a special problem in that it can be used both as a type character and as a separator in the language. To remove ambiguity, a character is a type character as long as the character that follows it cannot start an identifier. If this is possible, is If it can, then the character is a separator, not a type character.

KeywordsKeywords

A key Word is a word that has a special meaning in a language construct A. keyword is a word that has special meaning in a language construct. All keywords are reserved by the language and may not be used as identifiers unless the identifiers are escaped. (Note:(Grade.,,, and are retained as keywords, although they are no longer used in Visual Basic.)

Literals

At a LiteralText is a textual representation of a specific value of a type A. literal is a textual representation of a particular value of a type. Literal types include Boolean, integer, floating point, string, character, and date.

Boolean literals

and are literals of the type that are assigned the status true or false. and are literals of the type that map to the true and false state, respectively.

Integer literals

Integer literals can be decimal (base 10), hexadecimal (base 16), or octal (base 8). A decimal integer literal is A decimal integer literal is a string of decimal digits (0-9). A hexadecimal literal is followed by a string of hexadecimal digits (0-9, aF) .A hexadecimal literal is followed by a string of hexadecimal digits (0-9, AF). An octal literal is followed by a string of octal digits (0-7). Decimal literals directly represent the Decimal literals directly represent the decimal value of the integral literal, whereas octal and hexadecimal literals represent the binary va lue of the integer literal (thus, is -32768, not an overflow error).

The type of a literal is determined by its value or by the following type character. If no type character is specified, values ​​in the range of the type are typed as; If no type character is specified, values ​​in the range of the type are typed as; values ​​outside the range for are typed as. If an integer literal's type is of insufficient size to hold the integer literal, a compile-time error results. (Note:(Grade.There isn't a type character for because the most natural character would be, which is a legal character in a hexadecimal literal.)

Floating-point literalsFloating-point literals

A floating-point literal is an integer literal followed by an optional decimal point (the ASCII period character) and mantissa, and an optional base 10 exponent. By default, a floating-point literal is of type. If the-, - or- type character is specified, the literal is of this Typ.If the,, or type character is specified, the literal is of that type. If a floating-point value is not large enough to hold the floating-point literal, a compile-time error is issued literal's type is of insufficient size to hold the floating-point literal, a compile-time error results.

Note:Grade.Note that the data type can encode trailing zeros in a value. It is worth noting that the data type can encode trailing zeros in a value. The specification does not currently comment on whether a compiler should consider trailing zeros in a literal character The specification currently makes no comment about whether trailing zeros in a literal should be honored by a compiler.

String Literals

A string literal is a sequence of zero or more Unicode characters that begins and ends with an ASCII double quote, a Unicode left double quote, or a Unicode all double quote beginning and ending with an ASCII double-quote character, a Unicode left double-quote character, or a Unicode right double-quote character. Within a string, a sequence of two double-quote characters is an escape sequence representing a double quote in the string.

A string constant is of the type.

The compiler is allowed to replace a constant string expression with a string literal. Any string literal does not necessarily result in a new string instance. Each string literal does not necessarily result in a new string instance. When two or more string literals that are equivalent according to the string equality operator using binary comparison semantics appear in the same program, these string literals may refer to the same string instance. For example, the output of the following program may return because the two literals may refer to the same string instance. For instance, t he output of the following program may return because the two literals may refer to the same string instance.

Character literals

A character literal represents a single Unicode character of the type. quote character.

Date Literals

A date literal represents a particular moment in time expressed as a value of the type.

The literal may specify both a date and a time, just a date, or just a time. If the date value is omitted, it becomes January 1st If the date value is omitted, then January 1 of the year 1 in the Gregorian calendar is assumed. If the time value is omitted , then 12:00:00 AM is assumed.

To avoid problems with interpreting the year value in a date value, the year value cannot be two digits When expressing a date in the first century AD / CE, leading zeros must be specified.

A time of day value can be specified using either a 24-hour value or a 12-hour value. A time value may be specified either using a 24-hour value or a 12-hour value; time values ​​that omit an or are assumed to be 24-hour values. If a time value omits the minutes, the literal is used by default. If a time value omits the seconds If a time value omits the seconds, the literal is used by default. If both minutes and second are omitted, then or must be specified. If the date value specified is outside the range of the type, a compile-time error occurs.

The following example contains several date literals.

Nothing

is a special literal character. It has no type and can be converted to any type in the type system, including type parameters. is a special literal; it does not have a type and is convertible to all types in the type system, including type parameters. When converted to a particular type, it is the equivalent of the default value of that type.

Separators

The following ASCII characters are separators:

Operator Characters. Operator Characters

The following ASCII characters or character sequences denote operators: