PascalCs.par

// Grammar taken from here
// https://www.moorecad.com/standardpascal/pascal.y
// https://www.moorecad.com/standardpascal/pascal.l
// adjusted with
// https://www.standardpascal.org/iso7185.pdf
// and adapted to Parol format
%start PascalCs
%title "ISO Pascal LALR(1) grammar"
%comment "Readable EBNF-style ISO 7185 grammar in parol format"
%block_comment '(*' '*)'
%block_comment '{' '}'
%grammar_type 'LALR(1)'

%%

PascalCs
    : Program
    | Module
    ;

Program
    : ProgramHeading SEMICOLON Block DOT
    ;

ProgramHeading
    : PROGRAM IDENTIFIER
    | PROGRAM IDENTIFIER LPAREN IdentifierList RPAREN
    ;

IdentifierList
    : IdentifierList COMMA IDENTIFIER
    | IDENTIFIER
    ;

Block
    : LabelDeclarationPart ConstantDefinitionPart TypeDefinitionPart VariableDeclarationPart
      ProcedureAndFunctionDeclarationPart StatementPart
    ;

Module
    : ConstantDefinitionPart TypeDefinitionPart VariableDeclarationPart
      ProcedureAndFunctionDeclarationPart
    ;

LabelDeclarationPart
    : LABEL LabelList SEMICOLON
    |
    ;

LabelList
    : LabelList COMMA Label
    | Label
    ;

Label
    : DIGSEQ
    ;

ConstantDefinitionPart
    : CONST ConstantList
    |
    ;

ConstantList
    : ConstantList ConstantDefinition
    | ConstantDefinition
    ;

ConstantDefinition
    : IDENTIFIER EQUAL CExpression SEMICOLON
    ;

/*Constant : CExpression ;  /* good stuff! */
CExpression
    : CSimpleExpression
    | CSimpleExpression RelOp CSimpleExpression
    ;

CSimpleExpression
    : CTerm
    | CSimpleExpression AddOp CTerm
    ;

CTerm
    : CFactor
    | CTerm MulOp CFactor
    ;

CFactor
    : Sign CFactor
    | CExponentiation
    ;

CExponentiation
    : CPrimary
    | CPrimary STARSTAR CExponentiation
    ;

CPrimary
    : IDENTIFIER
    | LPAREN CExpression RPAREN
    | UnsignedConstant
    | NOT CPrimary
    ;

Constant
    : NonString
    | Sign NonString
    | CHARACTER_STRING
    ;

Sign: PLUS
    | MINUS
    ;

NonString
    : DIGSEQ
    | IDENTIFIER
    | REALNUMBER
    ;

TypeDefinitionPart
    : TYPE TypeDefinitionList
    |
    ;

TypeDefinitionList
    : TypeDefinitionList TypeDefinition
    | TypeDefinition
    ;

TypeDefinition
    : IDENTIFIER EQUAL TypeDenoter SEMICOLON
    ;

TypeDenoter
    : IDENTIFIER
    | NewType
    ;

NewType
    : NewOrdinalType
    | NewStructuredType
    | NewPointerType
    ;

NewOrdinalType
    : EnumeratedType
    | SubrangeType
    ;

EnumeratedType
    : LPAREN IdentifierList RPAREN
    ;

SubrangeType
    : Constant DOTDOT Constant
    ;

NewStructuredType
    : StructuredType
    | PACKED StructuredType
    ;

StructuredType
    : ArrayType
    | RecordType
    | SetType
    | FileType
    ;

ArrayType
    : ARRAY LBRAC IndexList RBRAC OF ComponentType
    ;

IndexList
    : IndexList COMMA IndexType
    | IndexType
    ;

IndexType
    : OrdinalType
    ;

OrdinalType
    : NewOrdinalType
    | IDENTIFIER
    ;

ComponentType
    : TypeDenoter
    ;

RecordType
    : RECORD RecordSectionList END
    | RECORD RecordSectionList SEMICOLON VariantPart END
    | RECORD VariantPart END
    ;

RecordSectionList
    : RecordSectionList SEMICOLON RecordSection
    | RecordSection
    ;

RecordSection
    : IdentifierList COLON TypeDenoter
    ;

VariantPart
    : CASE VariantSelector OF VariantList SEMICOLON
    | CASE VariantSelector OF VariantList
    |
    ;

VariantSelector
    : TagField COLON TagType
    | TagType
    ;

VariantList
    : VariantList SEMICOLON Variant
    | Variant
    ;

Variant
    : CaseConstantList COLON LPAREN RecordSectionList RPAREN
    | CaseConstantList COLON LPAREN RecordSectionList SEMICOLON VariantPart RPAREN
    | CaseConstantList COLON LPAREN VariantPart RPAREN
    ;

CaseConstantList
    : CaseConstantList COMMA CaseConstant
    | CaseConstant
    ;

CaseConstant
    : Constant
    | Constant DOTDOT Constant
    ;

TagField
    : IDENTIFIER
    ;

TagType
    : IDENTIFIER
    ;

SetType
    : SET OF OrdinalType
    ;

FileType
    : PFILE OF ComponentType
    ;

NewPointerType
    : UPARROW DomainType
    ;

DomainType
    : IDENTIFIER
    ;

VariableDeclarationPart
    : VAR VariableDeclarationList SEMICOLON
    |
    ;

VariableDeclarationList
    : VariableDeclarationList SEMICOLON VariableDeclaration
    | VariableDeclaration
    ;

VariableDeclaration
    : IdentifierList COLON TypeDenoter
    ;

ProcedureAndFunctionDeclarationPart
    : ProcOrFuncDeclarationList SEMICOLON
    |
    ;

ProcOrFuncDeclarationList
    : ProcOrFuncDeclarationList SEMICOLON ProcOrFuncDeclaration
    | ProcOrFuncDeclaration
    ;

ProcOrFuncDeclaration
    : ProcedureDeclaration
    | FunctionDeclaration
    ;

ProcedureDeclaration
    : ProcedureHeading SEMICOLON Directive
    | ProcedureHeading SEMICOLON ProcedureBlock
    ;

ProcedureHeading
    : ProcedureIdentification
    | ProcedureIdentification FormalParameterList
    ;

Directive
    : FORWARD
    | EXTERNAL
    ;

FormalParameterList
    : LPAREN FormalParameterSectionList RPAREN
    ;

FormalParameterSectionList
    : FormalParameterSectionList SEMICOLON FormalParameterSection
    | FormalParameterSection
    ;

FormalParameterSection
    : ValueParameterSpecification
    | VariableParameterSpecification
    | ProceduralParameterSpecification
    | FunctionalParameterSpecification
    ;

ValueParameterSpecification
    : IdentifierList COLON IDENTIFIER
    ;

VariableParameterSpecification
    : VAR IdentifierList COLON IDENTIFIER
    ;

ProceduralParameterSpecification
    : ProcedureHeading
    ;

FunctionalParameterSpecification
    : FunctionHeading
    ;

ProcedureIdentification
    : PROCEDURE IDENTIFIER
    ;

ProcedureBlock
    : Block
    ;

FunctionDeclaration
    : FunctionHeading SEMICOLON Directive
    | FunctionIdentification SEMICOLON FunctionBlock
    | FunctionHeading SEMICOLON FunctionBlock
    ;

FunctionHeading
    : FUNCTION IDENTIFIER COLON ResultType
    | FUNCTION IDENTIFIER FormalParameterList COLON ResultType
    ;

ResultType
    : IDENTIFIER
    ;

FunctionIdentification
    : FUNCTION IDENTIFIER
    ;

FunctionBlock
    : Block
    ;

StatementPart
    : CompoundStatement
    ;

CompoundStatement
    : PBEGIN StatementSequence END
    ;

StatementSequence
    : StatementSequence SEMICOLON Statement
    | Statement
    ;

Statement
    : OpenStatement
    | ClosedStatement
    ;

OpenStatement
    : Label COLON NonLabeledOpenStatement
    | NonLabeledOpenStatement
    ;

ClosedStatement
    : Label COLON NonLabeledClosedStatement
    | NonLabeledClosedStatement
    ;

NonLabeledClosedStatement
    : AssignmentStatement
    | ProcedureStatement
    | GotoStatement
    | CompoundStatement
    | CaseStatement
    | RepeatStatement
    | ClosedWithStatement
    | ClosedIfStatement
    | ClosedWhileStatement
    | ClosedForStatement
    |
    ;

NonLabeledOpenStatement
    : OpenWithStatement
    | OpenIfStatement
    | OpenWhileStatement
    | OpenForStatement
    ;

RepeatStatement
    : REPEAT StatementSequence UNTIL Expression
    ;

OpenWhileStatement
    : WHILE Expression DO OpenStatement
    ;

ClosedWhileStatement
    : WHILE Expression DO ClosedStatement
    ;

OpenForStatement
    : FOR IDENTIFIER ASSIGNMENT Expression Direction FinalValue DO OpenStatement
    ;

ClosedForStatement
    : FOR IDENTIFIER ASSIGNMENT Expression Direction FinalValue DO ClosedStatement
    ;

OpenWithStatement
    : WITH RecordVariableList DO OpenStatement
    ;

ClosedWithStatement
    : WITH RecordVariableList DO ClosedStatement
    ;

OpenIfStatement
    : IF Expression THEN Statement
    | IF Expression THEN ClosedStatement ELSE OpenStatement
    ;

ClosedIfStatement
    : IF Expression THEN ClosedStatement ELSE ClosedStatement
    ;

AssignmentStatement
    : VariableAccess ASSIGNMENT Expression
    ;

VariableAccess
    : IDENTIFIER
    | IndexedVariable
    | FieldDesignator
    | VariableAccess UPARROW
    ;

IndexedVariable
    : VariableAccess LBRAC IndexExpressionList RBRAC
    ;

IndexExpressionList
    : IndexExpressionList COMMA IndexExpression
    | IndexExpression
    ;

IndexExpression
    : Expression
    ;

FieldDesignator
    : VariableAccess DOT IDENTIFIER
    ;

ProcedureStatement
    : IDENTIFIER Params
    | IDENTIFIER
    ;

Params
    : LPAREN ActualParameterList RPAREN
    ;

ActualParameterList
    : ActualParameterList COMMA ActualParameter
    | ActualParameter
    ;

/*
 * this forces you to check all this to be sure that only write and
 * writeln use the 2nd and 3rd forms, you really can't do it easily in
 * the grammar, especially since write and writeln aren't reserved
 */
ActualParameter
    : Expression
    | Expression COLON Expression
    | Expression COLON Expression COLON Expression
    ;

GotoStatement
    : GOTO Label
    ;

CaseStatement
    : CASE Expression OF CaseListElementList END
    | CASE Expression OF CaseListElementList SEMICOLON END
    | CASE Expression OF CaseListElementList SEMICOLON OtherwisePart Statement END
    | CASE Expression OF CaseListElementList SEMICOLON OtherwisePart Statement SEMICOLON END
    ;

CaseListElementList
    : CaseListElementList SEMICOLON CaseListElement
    | CaseListElement
    ;

CaseListElement
    : CaseConstantList COLON Statement
    ;

OtherwisePart
    : OTHERWISE
    | OTHERWISE COLON
    ;

Direction
    : TO
    | DOWNTO
    ;

FinalValue
    : Expression
    ;

RecordVariableList
    : RecordVariableList COMMA VariableAccess
    | VariableAccess
    ;

Expression
    : SimpleExpression
    | SimpleExpression RelOp SimpleExpression
    ;

SimpleExpression
    : Term
    | SimpleExpression AddOp Term
    ;

Term: Factor
    | Term MulOp Factor
    ;

Factor
    : Sign Factor
    | Exponentiation
    ;

Exponentiation
    : Primary
    | Primary STARSTAR Exponentiation
    ;

Primary
    : VariableAccess
    | UnsignedConstant
    | FunctionDesignator
    | SetConstructor
    | LPAREN Expression RPAREN
    | NOT Primary
    ;

UnsignedConstant
    : UnsignedNumber
    | CHARACTER_STRING
    | NIL
    ;

UnsignedNumber
    : DIGSEQ
    | REALNUMBER
    ;

/* functions with no params will be handled by plain identifier */
FunctionDesignator
    : IDENTIFIER Params
    ;

SetConstructor
    : LBRAC MemberDesignatorList RBRAC
    | LBRAC RBRAC
    ;

MemberDesignatorList
    : MemberDesignatorList COMMA MemberDesignator
    | MemberDesignator
    ;

MemberDesignator
    : MemberDesignator DOTDOT Expression
    | Expression
    ;

AddOp
    : PLUS
    | MINUS
    | OR
    ;

MulOp
    : STAR
    | SLASH
    | DIV
    | MOD
    | AND
    ;

RelOp
    : EQUAL
    | NOTEQUAL
    | LT
    | GT
    | LE
    | GE
    | IN
    ;

AND : /(?i)AND(?-i)/
    ;

ARRAY
    : /(?i)ARRAY(?-i)/
    ;

PBEGIN
    : /(?i)BEGIN(?-i)/
    ;

CASE: /(?i)CASE(?-i)/
    ;

CONST
    : /(?i)CONST(?-i)/
    ;

DIV : /(?i)DIV(?-i)/
    ;

DO  : /(?i)DO(?-i)/
    ;

DOWNTO
    : /(?i)DOWNTO(?-i)/
    ;

ELSE: /(?i)ELSE(?-i)/
    ;

END : /(?i)END(?-i)/
    ;

EXTERNAL
    : /(?i)EXTERN(AL)?(?-i)/
    ;

PFILE
    : /(?i)FILE(?-i)/
    ;

FOR : /(?i)FOR(?-i)/
    ;

FORWARD: /(?i)FORWARD(?-i)/
    ;

FUNCTION
    : /(?i)FUNCTION(?-i)/
    ;

GOTO: /(?i)GOTO(?-i)/
    ;

IF  : /(?i)IF(?-i)/
    ;

IN  : /(?i)IN(?-i)/
    ;

LABEL
    : /(?i)LABEL(?-i)/
    ;

MOD : /(?i)MOD(?-i)/
    ;

NIL : /(?i)NIL(?-i)/
    ;

NOT : /(?i)NOT(?-i)/
    ;

OF  : /(?i)OF(?-i)/
    ;

OR  : /(?i)OR(?-i)/
    ;

OTHERWISE
    : /(?i)OTHERWISE(?-i)/
    ;

PACKED
    : /(?i)PACKED(?-i)/
    ;

PROCEDURE
    : /(?i)PROCEDURE(?-i)/
    ;

PROGRAM
    : /(?i)PROGRAM(?-i)/
    ;

RECORD
    : /(?i)RECORD(?-i)/
    ;

REPEAT
    : /(?i)REPEAT(?-i)/
    ;

SET : /(?i)SET(?-i)/
    ;

THEN: /(?i)THEN(?-i)/
    ;

TO  : /(?i)TO(?-i)/
    ;

TYPE: /(?i)TYPE(?-i)/
    ;

UNTIL
    : /(?i)UNTIL(?-i)/
    ;

VAR : /(?i)VAR(?-i)/
    ;

WHILE
    : /(?i)WHILE(?-i)/
    ;

WITH: /(?i)WITH(?-i)/
    ;

IDENTIFIER
    : /[a-zA-Z_][a-zA-Z0-9_]*/
    ;

ASSIGNMENT
    : ':='
    ;

COLON
    : ':'
    ;

COMMA
    : ','
    ;

DOTDOT
    : '..'
    ;

DOT : '.'
    ;

EQUAL
    : '='
    ;

LPAREN
    : '('
    ;

RPAREN
    : ')'
    ;

LBRAC
    : '['
    ;

RBRAC
    : ']'
    ;

PLUS: '+'
    ;

MINUS
    : '-'
    ;

SLASH
    : '/'
    ;

STARSTAR
    : '**'
    ;

STAR: '*'
    ;

NOTEQUAL
    : '<>'
    ;

LE  : '<='
    ;

LT  : '<'
    ;

GE  : '>='
    ;

GT  : '>'
    ;

SEMICOLON
    : ';'
    ;

UPARROW
    : '^'
    ;

REALNUMBER
    : /[0-9]+\.[0-9]+/
    ;

DIGSEQ
    : /[0-9]+/
    ;

CHARACTER_STRING
    : /'([^']|'')*'/
    ;