BNF Syntax

<Unit> ::=

  [<UsesClause>] {<VarSection> | <ConstSection> | <ProcedureDecl>}

  [begin <StmtList> end ";"]

<UsesClause> ::=

  uses <Identifier> {"," <Identifier>} ";"

<VarSection> ::=

  var <VarDecl> ";" {<VarDecl> ";"}

<VarDecl> ::=

  <Identifier> ({"," <Identifier>} | "=" <Expression>)

<ConstSection> ::=

  const <ConstDecl> ";" {<ConstDecl> ";"}

<ConstDecl> ::=

  <Identifier> "=" <Expression>

<ProcedureDecl> ::=

  (procedure | function) <Identifier> ["(" <ParamsDecl> ")"] ";"

  {<VarSection> | <ConstSection>}

  begin <StmtList> end ";"

<ParamsDecl> ::=

  <ParamDecl> {";" <ParamDecl>}

<ParamDecl> ::=

  (var | out | const ) <Identifier>

<Statement> ::=

  <Designator> [":=" <Expression>] |

  <CompoundStmt> |

  <IfStmt> |

  <CaseStmt> |

  <RepeatStmt> |

  <WhileStmt> |

  <ForStmt> |

  <TryStmt> |

  <RaiseStmt> |

  <EmptyStmt>

<StmtList> ::=

  <Statement> ";" {<Statement> ";"}

<EmptyStmt> ::= // Special processing. We look for one of these tokens,

                // but not really skips it.

  ";" |

  else |

  until |

  end

<CompoundStmt> ::=

  begin <StmtList> end

<IfStmt> ::=

  if <Expression> then <Statement> [else <Statement>]

<CaseStmt> ::=

  case <Expression> of <CaseSelector> ";" {<CaseSelector> ";"}

  [else <StmtList>] end

<CaseSelector> ::=

  <CaseLabel> {"," <CaseLabel>} ":" <Statement>

<CaseLabel> ::=

  <Expression> [".." <Expression>]

<RepeatStmt> ::=

  repeat <StmtList> until <Expression>

<WhileStmt> ::=

  while <Expression> do <Statement>

<ForStmt> ::=

  for <Identifier> ":=" <Expression> (to | downto) <Expression> do

  <Statement>

<TryStmt> ::=

  try [<StmtList>] (except (<ExceptionBlock> | <StmtList>) |

                    finally <StmtList>)

  end

<ExceptionBlock> ::=

  {on [<Identifier> ":"] <Expression> do <Statement> ";"}

  [else <StmtList>]

<RaiseStmt> ::=

  raise [<Expression>]

<Expression> ::=

    <SimpleExpression> {<RelOp> <SimpleExpression>}

<SimpleExpression> ::=

    <Term> {<AddOp> <Term>}

<Term> ::=

    <Factor> {<MulOp> <Factor>}

<Factor> ::=

    <Designator> |

    INT_LITERAL |

    FLOAT_LITERAL |

    STRING_LITERAL |

    nil |

    "(" <Expression> ")" |

    not <Factor> |

    "-" <Factor> |

    "+" <Factor> |

    <SetConstructor> |

    array "[" <ArrayDim> {"," <ArrayDim>} "]" [of <Identifier>]

    "@" <Identifier>

<ArrayDim> ::=

  <Expression> [".." <Expression>]

<RelOp> ::=

    ">" |

    "<" |

    "<=" |

    ">=" |

    "<>" |

    "=" |

    in |

    is

<AddOp> ::=

    "+" |

    "-" |

    or |

    xor

<MulOp> ::=

    "*" |

    "/" |

    div |

    mod |

    and |

    shl |

    shr

<Designator> ::=

    <Identifier> {"." <Identifier> |

                  "[" <Expression> {"," <Expression>} "]" |

                  "(" [<Expression> {"," <Expression>}] ")"}

<SetConstructor> ::=

    "[" [<SetElement> {"," <SetElement>}] "]"

<SetElement> ::=

    <Expression> [".." <Expression>]

<Identifier> ::=

  IDENTIFIER