{
/*
 pll.syn  -- Syntax for the baseline Pascal-like language used by XIDEK:
 the Extensible Script Language Development Kit

 Copyright (c) 2002 Parsifal Software. All Rights Reserved.

 This file represents the underlying syntax used to describe the scripts
 interpreted by the baseline pll examples in the kit. It is easier to read and
 understand than the actual .syn files because reduction procedures and type
 declarations for tokens on the left side of productions have been stripped,
 along with some comments, configuration parameters, and definitions which
 pertain to individual examples.

 .syn files are compiled with the AnaGram parser generator, which creates a
 corresponding parser file and header file.

 This grammar describes a language that is somewhat similar to Pascal.

 The language consists of Pascal like statements and expressions. The
 language also implements Fortran-style exponentiation and simple dump and
 print statements. The syntax below uses "open" and "closed" statements to
 eliminate the traditional "dangling else" or "if-else" ambiguity problem.
 See http://www.parsifalsoft.com/ifelse.html or doc/ifelse.htm for a more
 detailed discussion.

 Statement types supported are:
   assignment statements
   compound statements
   if/else statements
   while statements
   repeat/until statements
   for statements
   dump and print statements

 There are no declarations. Scalar values may be explicitly cast to (long) or
 (double). Both integer and floating point values are stored as doubles.

 Scripts may contain any number of statements. White space may be used
 freely, including both C and C++ style comments.

For further information about this program or the AnaGram
parser generator, please contact:
  Parsifal Software
  http://www.parsifalsoft.com
  info@parsifalsoft.com
  +1-800-879-2577, Voice/Fax +1-508-358-2564
  P.O. Box 219
  Wayland, Massachusetts 01778
  USA
*/

#include "comdefs.h"                // Contains definitions of support classes
#include <math.h>
#include <ctype.h>                                     // to declare tolower()

}

/*** CONFIGURATION SECTION **************************************************/
[
  // Grammar adjustments
  case sensitive = OFF                                   // not case sensitive

  disregard white space               // Skip over white space (defined below)
  distinguish lexemes
  lexeme {integer, real, name, string element, character constant}

  distinguish keywords {'a-z' + 'A-Z'}

  wrapper {AgString, Value}                // Special handling on parser stack

  parser file name = "#.cpp"      // # will be replaced by name of syntax file
  test file mask = "*.scf"                            // filter for File Trace
  no cr        //omit carriage returns in output files, for *nix compatibility

  // Operating modes
  pointer input                             // Take input from array in memory
  pointer type = const unsigned char *
  reentrant parser                                    // Make parser reentrant
]


/*** GRAMMAR ****************************************************************/

/*
 "script" is marked with a $ to indicate it is the "grammar token", that is,
 the whole of the input we're intending to parse.
*/
script $
 -> statement list, eof

// Zero or more statements. Note that "statement list" is recursively defined.
statement list
 ->
 -> statement list, statement

/*
 A single statement can be "open" or "closed".

 An "open" statement is a statement that can legally be followed by an "else"
 keyword. A "closed" statement is one that cannot.

 "Open" and "closed" statements are a means for resolving a problem common to
 many programming languages known as the if-then-else ambiguity or "dangling
 else". See www.parsifalsoft.com/ifelse.htm for a discussion of the ambiguity
 and this technique for resolving it.
*/
statement
 -> open statement
 -> closed statement

open statement
 -> if condition, statement
 -> if condition, closed statement, "else", open statement
 -> WHILE, expression, "do", open statement
 -> FOR, lvalue, ":=", expression, for increment,
      "to", expression, "do", open statement

closed statement
 -> if condition, closed statement, "else", closed statement
 -> WHILE, expression, "do", closed statement
 -> FOR, lvalue, ":=", expression, for increment,
      "to", expression, "do", closed statement
 -> simple statement

for increment
 ->
 -> "by", expression

/*
 A "simple statement" is one that does not end with another statement. All
 simple statements are closed statements and are therefore factored out for
 clarity.
*/
simple statement
 -> REPEAT, statement list, UNTIL, expression, ';'
 -> assignment statement, ';'
 -> ';'
 -> compound statement
 -> "return", optional expression, ';'
 -> dump statement, ';'
 -> print statement, ';'

REPEAT
 -> "repeat"

UNTIL
 -> "until"

WHILE
 -> "while"

FOR
 -> "for"

if condition
 -> "if", expression, "then"

assignment statement
 -> lvalue, ":=", expression

compound statement
 -> "begin", statement list, "end"

// The dump statement accepts a comma delimited list of variable names
dump statement
 -> "dump", name
 -> dump statement, ',', name

// The print statement accepts a comma delimited list of expressions
print statement
 -> "print", expression
 -> print statement, ',', expression

(Value) optional expression
 ->
 -> expression

// General expression.
expression
 -> simple expression
 -> simple expression, relational op, simple expression

simple expression
 -> term
 -> simple expression, additive op, term

term
 -> unary expression
 -> term, multiplicative op, unary expression

unary expression
 -> factor                                     // next higher precedence level
 -> '+', unary expression
 -> unary op, unary expression

/*
 Syntactically, we can use ** for exponentiation because we don't have
 pointers. (In C, ** could be confused with pointer indirection.)
*/
factor
 -> primary                                    // next higher precedence level
 -> primary, "**", unary expression

/*
 Primary expression - bottom level of expression syntax. Variable references,
 constants, the builtin functions. Also, another expression in parentheses.
 (This is how you make parentheses work the way they're supposed to.)
*/
primary
 -> '(', expression, ')'
 -> constant
 -> lvalue
 -> function call
 -> '(', "long", ')', primary
 -> '(', "double", ')', primary

lvalue
 -> name

function call
 -> name, '(', optional arg list, ')'

optional arg list
 ->
 -> arg list

arg list
 -> expression
 -> arg list, ',', expression

constant
 -> integer
 -> real
 -> string
 -> character constant

// Operator definitions
relational op
 -> '='
 -> "<>"
 -> '<'
 -> "<="
 -> '>'
 -> ">="

additive op
 -> '+'
 -> '-'
 -> "or"
 -> "xor"

multiplicative op
 -> '*'
 -> '/'
 -> "div"
 -> "mod"
 -> "and"
 -> "shl"
 -> "shr"

unary op
 -> '-'
 -> "not"

/*** LEXICAL UNITS **********************************************************/
digit   = '0-9'
eof     = 0                                          // string null terminator
letter  = 'a-z' + 'A-Z' + '_'
space   =  ' ' + '\t' + '\f' + '\v' + '\r' + '\n'          // blank, tab, etc.

(void) white space
 -> space
 -> "/*", ~eof?..., "*/"                                    // C style comment
 -> "//", ~(eof+'\n')?..., '\n'                           // C++ style comment

/*
	Identifying variable names
  Characters in a name are accumulated in an AgString structure.
*/
(AgString) name
 -> letter:c                                   =AgString().append(tolower(c));
 -> name:ns, letter+digit:c                            =ns.append(tolower(c));

// Parsing and evaluating numeric constants

(double) real
 -> simple real
 -> simple real:x, 'e'+'E', signed exponent:e                    =x*pow(10,e);
 -> integer part:x, 'e'+'E', signed exponent:e                   =x*pow(10,e);

(double) simple real
 -> integer part:i, '.', fraction part:f                                 =i+f;
 -> integer part:i, '.'                                                    =i;
 -> '.', fraction part:f                                                   =f;

(double) integer part
 -> decimal integer:x                                                      =x;
 -> hybrid integer:x                                                       =x;
 -> octal integer:x                                           =makeDecimal(x);

(long) signed exponent
 -> '+'?, exponent:x                                                 =(long)x;
 -> '-', exponent:x                                                 =-(long)x;

(double) fraction part
 -> digit:d                                                     =(d-'0')/10.0;
 -> digit:d, fraction part:f                                =(d-'0' + f)/10.0;

(long) integer
 -> decimal integer
 -> octal integer
 -> hex integer

(long) decimal integer
 -> '1-9':d                                                            =d-'0';
 -> decimal integer:x, digit:d                                  =10*x + d-'0';

(long) exponent
 -> '0-9':d                                                            =d-'0';
 -> exponent:x, digit:d                                         =10*x + d-'0';

(long) hybrid integer
 -> octal integer:x, '8-9':d                     =10*makeDecimal(x) + d - '0';
 -> hybrid integer:x, digit:d                                   =10*x + d-'0';

(long) octal integer
 -> '0'                                                                    =0;
 -> octal integer:n, '0-7':d                                   =8*n + d - '0';

(long) hex integer
 -> "0x"                                                                   =0;
 -> hex integer:n, hex digit:d                                      =16*n + d;

(int) hex digit
 -> '0-9':x                                                          =x - '0';
 -> 'a-f' + 'A-F':d                                              =(d & 7) + 9;

// string constant

(Value) string
 -> string element
 -> string:s, string element:e                                          =s+=e;

(Value) string element
 -> '"', s char sequence:b, '"'                                     =Value(b);


(AgString) s char sequence
 ->                                                               =AgString();
 -> s char sequence:s, s char:c                                  =s.append(c);

(int) s char
 -> ~(eof + '"' + '\n' + '\\')
 -> escape sequence

(int) escape sequence
  -> simple escape sequence
  -> octal escape sequence
  -> hexadecimal escape sequence

(int) simple escape sequence
  -> "\\'"   ='\'';
  -> "\\\""  ='"';
  -> "\\?"   = '\?';
  -> "\\\\"  ='\\';
  -> "\\a"   ='\a';
  -> "\\b"   ='\b';
  -> "\\f"   ='\f';
  -> "\\n"   ='\n';
  -> "\\r"   ='\r';
  -> "\\t"   ='\t';
  -> "\\v"   ='\v';

(int) octal escape sequence
  -> one octal | two octal | three octal

(int) one octal
  -> '\\', '0-7':d                                                     =d-'0';

(int) two octal
  -> one octal:n, '0-7':d                                        =8*n + d-'0';

(int) three octal
  -> two octal:n, '0-7':d                                        =8*n + d-'0';

(int) hexadecimal escape sequence
  -> "\\x", hexadecimal digit:d                                            =d;
  -> hexadecimal escape sequence:n, hexadecimal digit:d             =16*n + d;

(int) hexadecimal digit
 -> '0-9':d                                                            =d-'0';
 -> 'A-F' + 'a-f':d                                              =9 + (d & 7);

[
  sticky {one octal, two octal, hexadecimal escape sequence}
]

 // character constant

(int) character constant
 -> '\'', c char:c, '\''                                                   =c;

(int) c char
 -> ~(eof + '\'' + '\n' + '\\')
 -> escape sequence

/*** End of syntax file *****************************************************/