"
   parameter named "ast". The "VAR (*OUT*)" parameter named "tokenCnt" is set
   to contain the number of tokens parsed and successfully incorporated into
   the result "ast".

   These procedures raise either "Error" if the tokens in their input stream
   do not form a legal syntactic block, command, or expression, respectively.
   They raise "JunoLex.Error" in case of a lexical error in their input. If
   the procedures cannot read from the stream, they raise the "Rd.Failure"
   exception. *)

PROCEDURE Block(
    ip: IterativeParse;
    VAR (*OUT*) ast: JunoAST.Block;
    VAR (*OUT*) tokenCnt: CARDINAL)
  RAISES {Error, JunoLex.Error, Rd.Failure};

Parse the next Block non-terminal from the reader underlying ip. A module is a sequence of top-level blocks. Returns with ast = NIL when ip's token stream is empty.

PROCEDURE GetIndex(
    ip: IterativeParse): INTEGER;

Return the number of characters that occur in the source text for the ASTs that have been returned so far by calls to Block(ip,...), including any trailing whitespace. This is the index of the first character of the first token of the AST that will be returned by the next call to Block(ip,...).

PROCEDURE Command(
    READONLY rd: Rd.T;
    VAR (*OUT*) ast: JunoAST.Cmd;
    VAR (*OUT*) tokenCnt: CARDINAL)
  RAISES {Error, JunoLex.Error, Rd.Failure};

Parse a Cmd non-terminal from rd.

PROCEDURE Expression(
    READONLY rd: Rd.T;
    VAR (*OUT*) ast: JunoAST.Expr;
    VAR (*OUT*) tokenCnt: CARDINAL)
  RAISES {Error, JunoLex.Error, Rd.Failure};

Parse an Expr non-terminal from rd.

PROCEDURE FoldHeader(
    READONLY rd: Rd.T;
    VAR (*OUT*) ast: JunoAST.PredHeader;
    VAR (*OUT*) tokenCnt: CARDINAL)
  RAISES {Error, JunoLex.Error, Rd.Failure};

Parse an Id optionally applied to a list of Ids, and set ast to the result. If rd contains just an id, it will be returned in ast.name and ast.ins will be NIL. Otherwise ast.ins will contain the list of arguments (which may be EmptyIdList).

PROCEDURE IdList(
    READONLY rd: Rd.T;
    VAR (*OUT*) ast: JunoAST.IdList;
    VAR (*OUT*) tokenCnt: CARDINAL)
  RAISES {Error, JunoLex.Error, Rd.Failure};

Parse a comma-separated list of identifiers, and set ast to the result. An empty list is allowed.

TYPE
  ErrorRec = REF RECORD
    found: JunoToken.T;
    expected: JunoToken.Kind;   (* may be "JunoToken.Kind.Unknown" *)
    additional: TEXT;
  END;

EXCEPTION Error(ErrorRec);

The found field contains the token which caused the parser to fail. In some cases, the parse fails because the parser is expecting a single particular token in the token stream. In such cases, expected is the expected token; otherwise, it is JunoToken.Kind.Unknown.

The field additional contains characters which properly follow the found token, but which have been pulled off the underlying reader.

In the event that the Error exception is raised, the ast parameter will contain the partial AST corresponding to the tokens that have been parsed so far; the AST will contain NIL fields for those parts of the input that were not parsed before the error occurred.

END JunoParse.