Class BaseParser

TO DO: Complete

NOTE: Attributes and comments right before the start of a definition are associated with that definition. However, if the comments or attributes are in the middle, they may be lost, or assigned to the next construction that is associated with attributes...

Pure attributes are supposed to be just before definitions... However, comments are also assigned to the program, and their behavior has to be better designed. Currently it is not too consistent. :(

Implements

Parser

Index

Constructors

constructor

new BaseParser(lexer): BaseParser
A new Gobstones parser for a given lexer.
Parameters
- lexer: Lexer
  defining the lexer from where to obtain the tokens.
Returns BaseParser

Methods

parse

parse(input): AST
TO DO: Complete
Parameters
- input: SourceInput
Returns AST
Implementation of Parser.parse

Auxiliaries for parsing constructions

`Private` _elementForTokenTag

_elementForTokenTag(tag): GErrorElement
Private
Return the concrete element corresponding to the given token tag, depending of the concrete word in the language words definition.
Parameters
- tag: symbol
Returns GErrorElement

`Private` _functionNameForOpAtLevel

_functionNameForOpAtLevel(op, level): Token
Private
Return the token corresponding to the function name for the given operator, using for it the name of the abstract word for the operator.

PRECONDITION:
- the operator op is one of the operators at the given level
Parameters
- op: Token
- level: number
Returns Token

Implementation: Auxiliaries

`Private` _expectTokenInConstruction

_expectTokenInConstruction(expectedTokenTag, construction, name?): void
Private
Confirm that the current token has the expected tag, or fail if it is not. Its use is to fail with a controlled error in case the precondition of this._match is not satisfied. So, it usually will appear before the use of this._match with the same expectedTokenTag. Consider also using _matchTokenInConstruction for a combination of both.

PRECONDITION:
- the current token tag is the same as the one expected
Parameters
- expectedTokenTag: symbol
- construction: string
- Optional name: string
Returns void

`Private` _loadNextGToken

_loadNextGToken(): void
Private
TO DO: Complete

** PRECONDITION:**
- this._lexer.hasNextGToken()
THE TRY-CATCH HAS TO BE REVISITED AND THOUGHT WITH MORE PRECISION NOTE: the precondition is tested because this operations is meant to be used a lot during parsing, and it will be cumbersome to test on each call for its error. If some token is expected, but there are no more of them, a Parser error should be thrown -- not a Lexer error.
Returns void
Throws
GErrors.NoMoreInputErrorIn is there are no more GTokens

`Private` _match

_match(expectedTokenTag): void
Private
Confirm that the current token has the expected tag, or fail if it is not. If the tag is correct, advance to the next token, if there is one. It is not supposed to be used to match EOD.

PRECONDITION: (not verified)
- the current token tag is the same as the one expected
- the expected token tag is a SymbolicKeyword or a Keyword
- the expected token tag is NOT EOD (so, there is no need to check for hasNextGToken)
Parameters
- expectedTokenTag: symbol
Returns void

`Private` _matchTokenInConstruction

_matchTokenInConstruction(expectedTokenTag, construction, name?): void
Private
Combines the actions of _expectTokenInConstruction and _match, for the cases where they must be used one after the other.

PRECONDITION:
- the current token tag is the same as the one expected
- the expected token tag is a SymbolicKeyword or a Keyword
- the expected token tag is NOT EOD (so, there is no need to check for hasNextGToken)
Parameters
- expectedTokenTag: symbol
- construction: string
- Optional name: string
Returns void

`Private` _optionallyMatch

_optionallyMatch(expectedTokenTag): void
Private
Match the current GToken if its tag is the one given, or do nothing if it is not. It implements the possibility to have an optional token. It is not supposed to be used to match EOD.

PRECONDITION:
- the expected token tag is NOT EOD (so, there is no need to check for hasNextGToken)
Parameters
- expectedTokenTag: symbol
Returns void

`Private` _parseToken

_parseToken(expectedTokenTag): Token
Private
Return the next token, if it is the one expected, or fail if it is not. If the tag is correct, advance to the next token, if there is one. It is not supposed to be used to expect for EOD.

PRECONDITION:
- the current token tag is the same as the one expected
- the expected token tag is NOT EOD (so, there is no need to check for hasNextGToken)
Parameters
- expectedTokenTag: symbol
Returns Token

`Private` _skipEODsIfCurrentIsEOD

_skipEODsIfCurrentIsEOD(): void
Private
Load the next token if there is one, when the current token is an EOD. It does nothing if the current token is not an EOD, or if there are no more tokens.

** PRECONDITION:**
- this._currentGToken has EOD tag
Returns void

Implementation: Parsing constructions

`Private` _parseAll

_parseAll(): AST
Private
Parse the sequence of Definitions forming the source code, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := *

** PRECOND:**
- the current GToken is one starting a Definition or its tag is EOD
- the described element starting here and all its parts are well formed
Returns AST

`Private` _parseDefinition

_parseDefinition(): ASTDef
Private
Parse a Definition, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed. It is not supposed to be used when the current GToken is EOD.

Grammar rule: := | | | |

** PRECOND:**
- the current GToken is one of those starting a Definition
- the described element starting here and all its parts are well formed
- the current GToken tag is not EOD, even when the previous preconditions does not hold
Returns ASTDef

`Private` _parseExprOperator

_parseExprOperator(level): ASTExpr
Private
Parses an Expression at the given fixity level, if there is a well formed one starting at the curren GToken. It fails if current GToken does not start the described element, if it or any of its parts are not well formed, if the fixity of the level is not correct in the language declaration, or if the fixity of the level is not respected.

Grammar rule: (level) := (level) | (level) | (level) | (level) |

PRECONDITION:
- the current GToken is one of those starting an Expression
- the described element starting here and all its parts are well formed
- the fixities of operator levels declared in this._langWords are in BaseFixities
- the fixity of the level is respected
Parameters
- level: number
Returns ASTExpr

`Private` _parseExprOperatorInfix

_parseExprOperatorInfix(level): ASTExpr
Private
Parses an Expression at non-associative fixity level, if there is a well formed one starting at the curren GToken. It fails if current GToken does not start the described element, if it or any of its parts are not well formed, or if the fixity of the level is not respected.

Grammar rule: (level) := (level + 1) (level) (level + 1) | (level + 1)

PRECONDITION:
- the current GToken is one of those starting an Expression
- the described element starting here and all its parts are well formed
- the fixity of the level is respected
Parameters
- level: number
Returns ASTExpr

`Private` _parseExprOperatorInfixL

_parseExprOperatorInfixL(level): ASTExpr
Private
Parses an Expression at a left associative fixity level, if there is a well formed one starting at the curren GToken. It fails if current GToken does not start the described element, if it or any of its parts are not well formed, or if the fixity of the level is not respected.

Grammar rule: (level) := (level + 1) ((level) (level + 1))*

PRECONDITION:
- the current GToken is one of those starting an Expression
- the described element starting here and all its parts are well formed
- the fixity of the level is respected
Parameters
- level: number
Returns ASTExpr

`Private` _parseExprOperatorInfixR

_parseExprOperatorInfixR(level): ASTExpr
Private
Parses an Expression at a right associative fixity level, if there is a well formed one starting at the curren GToken. It fails if current GToken does not start the described element, if it or any of its parts are not well formed, or if the fixity of the level is not respected.

Grammar rule: (level) := (level + 1) ((level) (level))*

PRECONDITION:
- the current GToken is one of those starting an Expression
- the described element starting here and all its parts are well formed
- the fixity of the level is respected
Parameters
- level: number
Returns ASTExpr

`Private` _parseExprOperatorPrefix

_parseExprOperatorPrefix(level): ASTExpr
Private
Parses an Expression at a prefix fixity level, if there is a well formed one starting at the curren GToken. It fails if current GToken does not start the described element, if it or any of its parts are not well formed, or if the fixity of the level is not respected.

Grammar rule: (level) := (level) (level) | (level + 1)

PRECONDITION:
- the current GToken is one of those starting an Expression
- the described element starting here and all its parts are well formed
- the fixity of the level is respected
Parameters
- level: number
Returns ASTExpr

`Private` _parseExpression

_parseExpression(): ASTExpr
Private
Parses an Expression at top level, if there is a well formed one starting at the curren GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := (0)

PRECONDITION:
- the current GToken is one of those starting an Expression
- the described element starting here and all its parts are well formed
Returns ASTExpr

`Private` _parseStatement

_parseStatement(): ASTStmt
Private
Parse a Statment, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := | | | | | | | | | |

PRECONDITION:
- the current GToken is one of those starting a Statement
- the described element starting here and all its parts are well formed
Returns ASTStmt

Implementation: Parsing constructions (Auxiliary elements)

`Private` _parseArgumentListFor

_parseArgumentListFor(construction, name): ASTExpr[]
Private
Parse the argument list of a procedure or function definition, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: --> ( (COMMA )*)?

** PRECOND:**
- the described element starting here and all its parts are well formed
Parameters
- construction: string
- name: string
Returns ASTExpr[]

`Private` _parseDefProcedureOrDefFunctionEnding

_parseDefProcedureOrDefFunctionEnding(start, attrs, construction, name): ASTDefProcedure | ASTDefFunction
Private
Parse the remainder of a procedure or function definition, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: --> LPAREN ( (COMMA )*)? RPAREN RBRACK

** PRECOND:**
- the current GToken tag is LPAREN
- the name tag is either UPPERID or LOWERID
- the described element starting here and all its parts are well formed
Parameters
- start: SourcePosition
- attrs: OptionsTable
- construction: string
- name: Token
Returns ASTDefProcedure | ASTDefFunction

`Private` _parseDelimitedSeqFor

_parseDelimitedSeqFor<T>(rightDelimiter, separator, parseElement, constructionElement): T[]
Private
Parse a sequence of elements given by parseElement, separated by the separator and ending in the rightDelimiter (not parsed), if there is a well formed one starting at the current token. It fails if current token does not start the described element, or if it or any of its parts are not well formed.

OBSERVATIONS:
- The closing token, rightDelimiter, is NOT parsed to allow better structure at the caller
Grammar rule: (rightDelimiter, separator, element) --> (element (separator element)*)? rightDelimiter

** PRECOND:**
- the current GToken tag is either one of elementStarters or rightDelimiter
- the described element starting here and all its parts are well formed
Type Parameters
- T
Parameters
- rightDelimiter: symbol
- separator: symbol
- parseElement: (() => T)
  - - (): T
    - Returns T
- constructionElement: GErrorElement
Returns T[]

`Private` _parseExprListRangeEnding

_parseExprListRangeEnding(start, attrs, firstElem, secondElem?): ASTExprListRange
Private
Parse the final part of a Range, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

OBSERVATION: The closing token, RBRACK, is parsed to allow better structure at the caller.

Grammar rule: --> RANGE RBRACK

** PRECOND:**
- the current GToken tag is RANGE
- the described element starting here and all its parts are well formed
Parameters
- start: SourcePosition
- attrs: OptionsTable
- firstElem: ASTExpr
- Optional secondElem: ASTExpr
Returns ASTExprListRange

`Private` _parseExprLiteralListEnding

_parseExprLiteralListEnding(start, attrs, prefix): ASTExprLiteralList
Private
Parse a sequence of Expressions, starting and separated by commas and ending in a right bracket, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

OBSERVATION: The closing token, RBRACK, is parsed to allow better structure at the caller.

Grammar rule: --> (COMMA )* RBRACK

** PRECOND:**
- the current GToken tag is COMMA or RBRACK
- the described element starting here and all its parts are well formed
Parameters
- start: SourcePosition
- attrs: OptionsTable
- prefix: ASTExpr[]
Returns ASTExprLiteralList

`Private` _parseNamesListFor

_parseNamesListFor(construction, name?): Token[]
Private
Parse the name list (a parameter list of a procedure or function definition, or a tuple of variables on a let assignment), if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: --> ( (COMMA )*)?

** PRECOND:**
- the current GToken tag is LPAREN
- the name tag is either UPPERID or LOWERID
- the described element starting here and all its parts are well formed
Parameters
- construction: string
- name: string = ''
Returns Token[]

`Private` _parseSeparatedSequence

_parseSeparatedSequence<T>(separator, prefix, parseElement): T[]
Private
Parse a sequence of elements given by parseElement, starting and separated by the separator, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: (separator, element) --> (separator element)*

** PRECOND:**
- the current GToken tag is separator
- the described element starting here and all its parts are well formed
Type Parameters
- T
Parameters
- separator: symbol
- prefix: T[]
- parseElement: (() => T)
  - - (): T
    - Returns T
Returns T[]

`Private` _parseSwitchBranchFor

_parseSwitchBranchFor(construction, name?): ASTStmtBranch
Private
Parse a switch branch if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: --> ARROW

** PRECOND:**
- the described element starting here and all its parts are well formed
Parameters
- construction: string
- name: string = ''
Returns ASTStmtBranch

`Private` _parseSwitchBranchesFor

_parseSwitchBranchesFor(construction, name?): ASTStmtBranch[]
Private
Parse a sequence of switch branches if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: --> ( ARROW )*

** PRECOND:**
- the described element starting here and all its parts are well formed
Parameters
- construction: string
- name: string = ''
Returns ASTStmtBranch[]

Implementation: Parsing constructions (Definitions)

`Private` _parseDefFunction

_parseDefFunction(): ASTDefFunction
Private
Parse a FUNTION definition, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := FUNTION LPAREN ( (, )*)? RPAREN

** PRECOND:**
- the current GToken tag is FUNCTION
- the described element starting here and all its parts are well formed
Returns ASTDefFunction

`Private` _parseDefInteractiveProgram

_parseDefInteractiveProgram(): ASTDefInteractiveProgram
Private
TO DO: Complete ** PRECOND:**
- this._currentGToken has INTERACTIVE tag
Returns ASTDefInteractiveProgram

`Private` _parseDefProcedure

_parseDefProcedure(): ASTDefProcedure
Private
Parse a PROCEDURE definition, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := PROCEDURE LPAREN ( (, )*)? RPAREN

** PRECOND:**
- the current GToken tag is PROCEDURE
- the described element starting here and all its parts are well formed
Returns ASTDefProcedure

`Private` _parseDefProgram

_parseDefProgram(): ASTDefProgram
Private
Parse a PROGRAM definition, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := PROGRAM

** PRECOND:**
- the current GToken tag is PROGRAM
- the described element starting here and all its parts are well formed
Returns ASTDefProgram

`Private` _parseDefType

_parseDefType(): ASTDefType
Private
TO DO: Complete ** PRECOND:**
- this._currentGToken has TYPE tag
Returns ASTDefType

Implementation: Parsing constructions (Expressions)

`Private` _parseExprAtom

_parseExprAtom(): ASTExpr
Private
Parse an Expression atom, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := | | | | | | | | | LPAREN RPAREN | | |

PRECONDITION:
- the current GToken is one of those starting an Expression atom
- the described element starting here and all its parts are well formed
Returns ASTExpr

`Private` _parseExprChoose

_parseExprChoose(): ASTExprChoose
Private
TO DO: Complete ** PRECOND:**
- this._currentGToken has CHOOSE tag
Returns ASTExprChoose

`Private` _parseExprEllipsis

_parseExprEllipsis(): ASTExprFunctionCall
Private
Parse an Ellipsis for Expressions, if there is one starting at the current GToken. It fails if current GToken does not start the described element.

Grammar rule: := ELLIPSIS

** PRECOND:**
- the current GToken tag is ELLIPSIS
Returns ASTExprFunctionCall

`Private` _parseExprLiteralListOrListRange

_parseExprLiteralListOrListRange(): ASTExprLiteralList | ASTExprListRange
Private
Parse a Literal List or a List Range, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rules: := LBRACK ( (COMMA )*)? RBRACK := LBRACK (COMMA )? RANGE RBRACK

OBSERVATION: The closing token, RBRACK, is parsed in the endings operations to allow better code structure.

** PRECOND:**
- the current GToken tag is LBRACK
- the described element starting here and all its parts are well formed
Returns ASTExprLiteralList | ASTExprListRange

`Private` _parseExprLiteralNumber

_parseExprLiteralNumber(): ASTExprLiteralNumber
Private
Parse a Literal Number expression, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: :=

** PRECOND:**
- the current GToken tag is NUM
- the described element starting here and all its parts are well formed
Returns ASTExprLiteralNumber

`Private` _parseExprLiteralString

_parseExprLiteralString(): ASTExprLiteralString
Private
Parse a Literal String expression, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: :=

** PRECOND:**
- the current GToken tag is STRING
- the described element starting here and all its parts are well formed
Returns ASTExprLiteralString

`Private` _parseExprMatching

_parseExprMatching(): ASTExprMatching
Private
TO DO: Complete ** PRECOND:**
- this._currentGToken has MATCHING tag
Returns ASTExprMatching

`Private` _parseExprStructureOrStructureUpdate

_parseExprStructureOrStructureUpdate(): ASTExprStructure | ASTExprStructureUpdate
Private
TO DO: Complete ** PRECOND:**
- this._currentGToken has UPPERID tag
Returns ASTExprStructure | ASTExprStructureUpdate

`Private` _parseExprTupleOrParentisizedExpr

_parseExprTupleOrParentisizedExpr(mayBeEmpty?): ASTExpr | ASTExprTuple
Private
Parse a Tuple or a single Expression surrounded by parentheses, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rules: --> LPAREN RPAREN := LPAREN ( (COMMA <Expr)+)? RPAREN

** PRECOND:**
- the current GToken tag is LPAREN
- the described element starting here and all its parts are well formed
Parameters
- mayBeEmpty: boolean = true
Returns ASTExpr | ASTExprTuple

`Private` _parseExprVariableOrFunctionCall

_parseExprVariableOrFunctionCall(): ASTExprFunctionCall | ASTExprVariable
Private
Parse a Function Call expression, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := := LPAREN ( (COMMA )*)? RPAREN

** PRECOND:**
- the current GToken tag is LOWERID
- the described element starting here and all its parts are well formed
Returns ASTExprFunctionCall | ASTExprVariable

Implementation: Parsing constructions (Parts)

`Private` _parsePattern

_parsePattern(): ASTPattern
Private
TO DO: Complete Parse a pattern, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := | | <<>>

** PRECOND:**
- the current GToken is one of those starting a Pattern
- the described element starting here and all its parts are well formed
Returns ASTPattern

`Private` _parsePatternVariable

_parsePatternVariable(): ASTPatternVariable
Private
Parse a pattern variable, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element.

Grammar rule: :=

** PRECOND:**
- the current GToken tag is LOWERID
- the described element starting here and all its parts are well formed
Returns ASTPatternVariable

`Private` _parsePatternWildcard

_parsePatternWildcard(): ASTPatternWildcard
Private
Parse a pattern wildcard, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element.

Grammar rule: := UNDERSCORE

** PRECOND:**
- the current GToken tag is UNDERSCORE
- the described element starting here and all its parts are well formed
Returns ASTPatternWildcard

`Private` _parseStmtConditional

_parseStmtConditional(construction): ASTStmtConditional
Private
Parse a conditional statement part of an if-then-else construct, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := LPAREN RPAREN (THEN)?

** PRECOND:**
- the current GToken tag is LPAREN
- the described element starting here and all its parts are well formed
Parameters
- construction: string
Returns ASTStmtConditional

Implementation: Parsing constructions (Statements)

`Private` _parseStmtAssignVariable

_parseStmtAssignVariable(): ASTStmtAssignVariable
Private
Parse an Assign Variable statement, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := ASSIGN

** PRECOND:**
- the current GToken tag is LOWERID
- the described element starting here and all its parts are well formed
Returns ASTStmtAssignVariable

`Private` _parseStmtBlock

_parseStmtBlock(): ASTStmtBlock
Private
Parse a block of statements, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := LBRACE * RBRACE

** PRECOND:**
- the current GToken tag is LBRACE
- the described element starting here and all its parts are well formed
Returns ASTStmtBlock

`Private` _parseStmtEllipsis

_parseStmtEllipsis(): ASTStmtProcedureCall
Private
Parse an Ellipsis for Statements, if there is one starting at the current GToken. It fails if current GToken does not start the described element.

Grammar rule: := ELLIPSIS

** PRECOND:**
- the current GToken tag is ELLIPSIS
Returns ASTStmtProcedureCall

`Private` _parseStmtForeach

_parseStmtForeach(): ASTStmtForeach
Private
Parse a FOREACH statement, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := FOREACH IN

** PRECOND:**
- the current GToken tag is FOREACH
- the described element starting here and all its parts are well formed
Returns ASTStmtForeach

`Private` _parseStmtIf

_parseStmtIf(): ASTStmtIf
Private
Parse a IF-THEN-ELSE statement, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := IF (ELSEIF )+ (ELSE )?

** PRECOND:**
- the current GToken tag is IF
Returns ASTStmtIf

`Private` _parseStmtLet

_parseStmtLet(): ASTStmtAssignTuple
Private
Parse a LET statement, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := LET LPAREN (COMMA )* RPAREN ASSIGN

** PRECOND:**
- the current GToken tag is LET
- the described element starting here and all its parts are well formed
Returns ASTStmtAssignTuple

`Private` _parseStmtProcedureCall

_parseStmtProcedureCall(): ASTStmtProcedureCall
Private
Parse a Procedure Call statement, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := LPAREN ( (COMMA )*)? RPAREN

** PRECOND:**
- the current GToken tag is UPPERID
- the described element starting here and all its parts are well formed
Returns ASTStmtProcedureCall

`Private` _parseStmtRepeat

_parseStmtRepeat(): ASTStmtRepeat
Private
Parse a REPEAT statement, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := REPEAT LPAREN RPAREN

** PRECOND:**
- the current GToken tag is REPEAT
- the described element starting here and all its parts are well formed
Returns ASTStmtRepeat

`Private` _parseStmtReturn

_parseStmtReturn(): ASTStmtReturn
Private
Parse a RETURN statement, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := RETURN LPAREN (COMMA )* RPAREN

** PRECOND:**
- the current GToken tag is RETURN
- the described element starting here and all its parts are well formed
Returns ASTStmtReturn

`Private` _parseStmtSwitch

_parseStmtSwitch(): ASTStmtSwitch
Private
Parse a SWITCH statement, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := SWITCH LPAREN RPAREN TO? LBRACE ( ARROW <Stmt-Block)* RBRACE

** PRECOND:**
- the current GToken tag is SWITCH
- the described element starting here and all its parts are well formed
Returns ASTStmtSwitch

`Private` _parseStmtWhile

_parseStmtWhile(): ASTStmtWhile
Private
Parse a WHILE statement, if there is a well formed one starting at the current GToken. It fails if current GToken does not start the described element, or if it or any of its parts are not well formed.

Grammar rule: := WHILE LPAREN RPAREN

** PRECOND:**
- the current GToken tag is WHILE
- the described element starting here and all its parts are well formed
Returns ASTStmtWhile

Implementation: Properties -- State

`Private` _currentGToken

_currentGToken: Token

TO DO: Complete

`Private` _langWords

_langWords: Words

TO DO: Complete

`Private` _lexer

_lexer: Lexer

TO DO: Complete

Class BaseParser

Implements

Index

Constructors

Methods

Auxiliaries for parsing constructions

Implementation: Auxiliaries

Implementation: Parsing constructions

Implementation: Parsing constructions (Auxiliary elements)

Implementation: Parsing constructions (Definitions)

Implementation: Parsing constructions (Expressions)

Implementation: Parsing constructions (Parts)

Implementation: Parsing constructions (Statements)

Implementation: Properties -- State

Constructors

constructor

Parameters

Returns BaseParser

Methods

parse

Parameters

Returns AST

Auxiliaries for parsing constructions

Private _elementForTokenTag

Parameters

Returns GErrorElement

Private _functionNameForOpAtLevel

Parameters

Returns Token

Implementation: Auxiliaries

Private _expectTokenInConstruction

Parameters

Returns void

Private _loadNextGToken

Returns void

Throws

Private _match

Parameters

Returns void

Private _matchTokenInConstruction

Parameters

Returns void

Private _optionallyMatch

Parameters

Returns void

Private _parseToken

Parameters

Returns Token

Private _skipEODsIfCurrentIsEOD

Returns void

Implementation: Parsing constructions

Private _parseAll

Returns AST

Private _parseDefinition

Returns ASTDef

Private _parseExprOperator

Parameters

Returns ASTExpr

Private _parseExprOperatorInfix

Parameters

Returns ASTExpr

Private _parseExprOperatorInfixL

Parameters

Returns ASTExpr

Private _parseExprOperatorInfixR

Parameters

Returns ASTExpr

Private _parseExprOperatorPrefix

Parameters

Returns ASTExpr

Private _parseExpression

Returns ASTExpr

Private _parseStatement

Returns ASTStmt

Implementation: Parsing constructions (Auxiliary elements)

Private _parseArgumentListFor

Parameters

Returns ASTExpr[]

Private _parseDefProcedureOrDefFunctionEnding

Parameters

`Private` _elementForTokenTag

`Private` _functionNameForOpAtLevel

`Private` _expectTokenInConstruction

`Private` _loadNextGToken

`Private` _match

`Private` _matchTokenInConstruction

`Private` _optionallyMatch

`Private` _parseToken

`Private` _skipEODsIfCurrentIsEOD

`Private` _parseAll

`Private` _parseDefinition

`Private` _parseExprOperator

`Private` _parseExprOperatorInfix

`Private` _parseExprOperatorInfixL

`Private` _parseExprOperatorInfixR

`Private` _parseExprOperatorPrefix

`Private` _parseExpression

`Private` _parseStatement

`Private` _parseArgumentListFor

`Private` _parseDefProcedureOrDefFunctionEnding

`Private` _parseDelimitedSeqFor

`Private` _parseExprListRangeEnding

`Private` _parseExprLiteralListEnding

`Private` _parseNamesListFor

`Private` _parseSeparatedSequence

`Private` _parseSwitchBranchFor

`Private` _parseSwitchBranchesFor

`Private` _parseDefFunction

`Private` _parseDefInteractiveProgram

`Private` _parseDefProcedure

`Private` _parseDefProgram

`Private` _parseDefType

`Private` _parseExprAtom

`Private` _parseExprChoose

`Private` _parseExprEllipsis

`Private` _parseExprLiteralListOrListRange

`Private` _parseExprLiteralNumber

`Private` _parseExprLiteralString

`Private` _parseExprMatching

`Private` _parseExprStructureOrStructureUpdate

`Private` _parseExprTupleOrParentisizedExpr

`Private` _parseExprVariableOrFunctionCall

`Private` _parsePattern

`Private` _parsePatternVariable

`Private` _parsePatternWildcard

`Private` _parseStmtConditional