{
/*
 dci.syn -- Direct Compilation of Bytecode
 Copyright (c) 2002 Parsifal Software. All Rights Reserved.

 The grammar contained in this file describes the same language as the
 grammar in pll.syn. The differences can be categorized as follows:
   . Rules rewritten to make computation easier. In pll.syn all of the
     arithmetic operators have been factored out. Here the arithmetic
     operators have been substituted back into the rules for expressions to
     make computation more straightforward.
   . Rules rewritten to handle looping. The rules for loop constructs have
     been rewritten to handle repetitive parsing of loops.
   . Semantically determined rules (true, false) added to support parse time
     implementation of loops and if-else statements.

 The actual parser modules, dci.h and dci.cpp are created from
 dci.syn by the AnaGram parser generator using the Build Parser command.

 To build a demonstration program for this parser, compile and link as a
 single project:
   demo.cpp                // Demo program
   comdefs.cpp             // Common script definitions
   bcidefs.cpp             // Bytecode interpreter definitions
   dci.cpp                 // Direct execution parser
   agclib1.lib             // Supporting class library
 Include files describing the class library are in agclib1\include

 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>
#include "bcidefs.h"                       // Bytecode interpreter definitions

}

/*** CONFIGURATION SECTION **************************************************/
[
  // Grammar adjustments
  case sensitive = OFF
  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
  wrapper {CodeFragment, AgStack<CodeFragment>, Constant}

  context type = FileLocation                           // track file location
  parser name = dci                                    // name parser function

  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

  // Put the following into the parser control block for use during parsing
  extend pcb {
    // Maps symbol names to variables
    AgDictionary<AgString> &dictionary;                        // symbol table

    // table of constants
    AgDictionary<Constant> constants;

    // Constructor for pcb
    dci_pcb_struct(AgDictionary<AgString> &d, const char *text);

    // Functions used during parsing
    void reportError();
    void reportError(const char *msg);
    int idName(const AgString &);
    CodeFragment code(Opcode, const AgString &);
    CodeFragment code(Opcode, const Constant &);
    CodeFragment codeCall(const AgString &, AgStack<CodeFragment> &);
  }
]

/*** 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.

 Append HLT (halt) to the bytecode we've got so far, so it stops when it's
 run.
*/
(CodeFragment) script $
 -> statement list:x, eof                                      =x.append(HLT);

// Zero or more statements. Note that "statement list" is recursively defined.
(CodeFragment) statement list
 ->                                                           =CodeFragment();
 -> statement list:x, statement:y                                =x.concat(y);

/*
 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.
*/
(CodeFragment) statement
 -> open statement
 -> closed statement

(CodeFragment) open statement
 -> if condition:x, statement:s              =CodeFragment::ifStatement(x, s);
 -> if condition:x, closed statement:s1,
      "else", open statement:s2                =CodeFragment::ifElse(x,s1,s2);
 -> WHILE, expression:x, "do", open statement:s =CodeFragment::whileLoop(x,s);
 -> FOR, lvalue:lv, ":=", expression:b, for increment:i,
      "to", expression:e, "do", open statement:s =
                                      CodeFragment::simpleForLoop(lv,b,i,e,s);

(CodeFragment) closed statement
 -> if condition:x, closed statement:s1,
      "else", closed statement:s2              =CodeFragment::ifElse(x,s1,s2);
 -> WHILE, expression:x, "do", closed statement:s =
                                                 CodeFragment::whileLoop(x,s);
 -> FOR, lvalue:lv, ":=", expression:b, for increment:i,
      "to", expression:e, "do", closed statement:s   =
                                      CodeFragment::simpleForLoop(lv,b,i,e,s);
 -> simple statement:x                                                     =x;

(CodeFragment) for increment
 ->                                                =PCB.code(PUSHC, Value(1));
 -> "by", expression:x                                                     =x;

/*
 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.

 The simple expression statement appends a pop instruction so that the
 resulting bytecode will discard the expression's value. (This is not an
 optimizing compiler.)
*/
(CodeFragment) simple statement
 ->REPEAT, statement list:s, "until", expression:x, ';' =
                                                CodeFragment::repeatLoop(s,x);
 -> lvalue:lv, ":=", expression:x, ';'              =lv.concat(x).append(SAP);
 -> ';'                                                       =CodeFragment();
 -> compound statement
 -> "return", ';'                                 =CodeFragment().append(HLT);
 -> "return", expression:x, ';'                             =x.append(RETURN);
 -> dump statement, ';'
 -> print statement, ';'

REPEAT
 -> "repeat"

WHILE
 -> "while"

FOR
 -> "for"

(CodeFragment) if condition
 -> "if", expression:x, "then"                                             =x;

(CodeFragment) compound statement
 -> "begin", statement list:s, "end"                                       =s;

// The dump statement accepts a comma delimited list of variable names
(CodeFragment) dump statement
 -> "dump", name:n                                          =PCB.code(DUMP,n);
 -> dump statement:code, ',', name:n        =code.append(DUMP, PCB.idName(n));

// The print statement accepts a comma delimited list of expressions
(CodeFragment) print statement
 -> "print", expression:code                              =code.append(PRINT);
 -> print statement:code, ',', expression:x     =code.concat(x).append(PRINT);

// General expression
(CodeFragment) expression
 -> simple expression
 -> simple expression:x, relational op:op, simple expression:y =
                                                       x.concat(y).append(op);

(CodeFragment) simple expression
 -> term
 -> simple expression:x, additive op:op, term:y       =x.concat(y).append(op);

(CodeFragment) term
 -> unary expression
 -> term:x, multiplicative op:op, unary expression:y  =x.concat(y).append(op);


(CodeFragment) unary expression
 -> factor                                     // next higher precedence level
 -> '+', unary expression:x                                                =x;
 -> unary op:op, unary expression:x                             =x.append(op);

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

/*
 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.)
*/
(CodeFragment) primary
 -> '(', expression:x, ')'                                                 =x;
 -> constant:x                                            =PCB.code(PUSHC, x);
 -> lvalue:x                                                 =x.append(FETCH);
 -> function call
 -> '(', "long", ')', primary:x                          =x.append(CAST_LONG);
 -> '(', "double", ')', primary:x                      =x.append(CAST_DOUBLE);

(CodeFragment) lvalue
 -> name:n                                               =PCB.code(LOCATE, n);

(CodeFragment) function call
 -> name:n, '(', optional arg list:args, ')'           =PCB.codeCall(n, args);

(AgStack<CodeFragment>) optional arg list
 ->                                                  =AgStack<CodeFragment>();
 -> arg list

(AgStack<CodeFragment>) arg list
 -> expression:code                       =AgStack<CodeFragment>().push(code);
 -> arg list:stack, ',', expression:x                          =stack.push(x);

(Constant) constant
 -> integer:x                                                    =Constant(x);
 -> real:x                                                       =Constant(x);
 -> string
 -> character constant:x                                         =Constant(x);

// Operator definitions
(Opcode) relational op
 -> '='                     =EQ;
 -> "<>"                    =NE;
 -> '<'                     =LT;
 -> "<="                    =LE;
 -> '>'                     =GT;
 -> ">="                    =GE;

(Opcode) additive op
 -> '+'                     =ADD;
 -> '-'                     =SUB;
 -> "or"                    =IOR;
 -> "xor"                   =XOR;

(Opcode) multiplicative op
 -> '*'                     =MUL;
 -> '/'                     =RDIV;
 -> "div"                   =IDIV;
 -> "mod"                   =MOD;
 -> "and"                   =AND;
 -> "shl"                   =LS;
 -> "shr"                   =RS;

(Opcode) unary op
 -> '-'                     =NEG;
 -> "not"                   =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

(Constant) string
 -> string element:s                                             =Constant(s);
 -> string:s, string element:e                                =Constant(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

/*** SUPPORT CODE ***********************************************************/

{ // Begin embedded C++

// Don't use default error handling.
#define SYNTAX_ERROR PCB.reportError()

// implement context tracking
#define GET_CONTEXT CONTEXT = FileLocation(PCB.pointer, PCB.line, PCB.column)

void dci_pcb_struct::reportError() {
  ag_delete_wrappers(this);
  char buf[100];
  sprintf(buf, "Error(%d,%d): %s", line, column, error_message);
  throw ErrorDiagnostic(buf);
}

void dci_pcb_struct::reportError(const char *msg) {
  ag_delete_wrappers(this);
  char buf[100];
  FileLocation &context = PCONTEXT(*this);
  sprintf(buf, "Error(%d,%d): %s", context.line, context.column, msg);
  throw ErrorDiagnostic(buf);
}

// Constructor for parser control block
// Initializes dictionary, input pointer, and loopDepth

dci_pcb_struct::dci_pcb_struct(AgDictionary<AgString> &d, const char *text)
  : pointer((unsigned char *) text),
    dictionary(d)
{
  // Nothing else to do
}

int dci_pcb_struct::idName(const AgString &name) {
  return dictionary.intern(name);
}

CodeFragment dci_pcb_struct::code(Opcode op, const AgString &name) {
  return CodeFragment().append(op,dictionary.intern(name));
}

CodeFragment dci_pcb_struct::code(Opcode op, const Constant &x) {
  int n = constants.intern(x);
  return CodeFragment().append(op,n);
}

CodeFragment dci_pcb_struct::codeCall(
    const AgString &name,
    AgStack<CodeFragment> &argStack)
{
  int argCount = argStack.size();
  CodeFragment argCode;
  for (int i = 0; i < argCount; i++) argCode.concat(argStack[i]);
  argCode.append(CALL, idFunction(name, argCount));
  return argCode;
}


ScriptMethod::ScriptMethod(const char *text, AgDictionary<AgString> &d)
: dictionary(d),
  bytecode(),
  constantList()
{
  // Create a parser using the dictionary specified by the dataset
  dci_pcb_type pcb(dictionary, text);

  // run the parser
  try {
    dci(&pcb);
  }
  catch(ErrorMessage e) {
    pcb.reportError(e.message());
  }

  //Use dci_value() to retrieve the generated code
  bytecode = dci_value(&pcb).getBytecode();

  constantList = pcb.constants.contents();
}

// Apply script to a dataset
Value interpret(const char *text, Dataset &d) {
  ScriptMethod method(text, d.dictionary);

  // List the generated code
  //method.list(cout);

  // Execute the generated code
  return method.apply(d);
}

} // End of embedded C++

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