Calculator Tutorial

     1: doctype public "-//IDN etl.sf.net//ETL//Grammar 0.2.1";
     2: grammar calculator.CalculatorBasic {
     3:     namespace default t = "http://etl.sf.net/samples/calculator";
     4:     context default Expressions {
     5:         op composite NumberLiteral(f) {
     6:             @ value = float | integer;
     7:         };
     8:         op composite StringValue(f) {
     9:             ^ t:StringLiteral {
    10:                 @ value = string(quote='"');
    11:             };
    12:         };
    13:         statement PrintStatement {
    14:             % print;
    15:             @ values += list , {
    16:                 expression;
    17:             };
    18:         };
    19:         statement ExpressionStatement {
    20:             @ value = expression;
    21:         };
    22:     };
    23: };

     1: doctype "calculator-basic-0_2_1.g.etl";
     2: print "zeroes: ", 24#0#, " ", 0.0; 
     3: print "ones: ", 1, " ", 1.0, " ", 10E-1; 
     4: print "halves: ", 0.5, " ", 5.0E-1, " ", 2#0.001#e2; 
     5: print "dozens: ", 12#10#, " ", 3#1_1_0#, " ", 0.12e2, " ", 36#C#;

     1: // This file demonstrates the error recovery strategy in ETL. 
     2: // Errors here are intentional.
     3: doctype public "-//IDN etl.sf.net//ETL//Grammar 0.2.1";
     4: grammar calculator.CalculatorBasic {
     5:     namespace default t = "http://etl.sf.net/samples/calculator";
     6:     context default Expressions {
     7:         op composite NumberLiteral(f) {
     8:             @ value = float | integer;
     9:         };
    10:         op composite StringValue(f) {
    11:             ^ t:StringLiteral {
    12:                 @ value = string(quote='");
    13:             };
    14:         };
    15:         statement PrintStatement {
    16:             % print
    17:             @ values += list , {
    18:                 expression;
    19:             };
    20:         };
    21:         statement ExpressionStatement {
    22:             @ value = expression
    23:         };
    24:     };
    25: };

• LEXICAL_ERROR: calculator-basic-with-errors.g.etl(12,40,487)-(12,44,491): New line encountered in string. If you want to insert new line use \n syntax
• SEGMENT_ERROR: calculator-basic-with-errors.g.etl(13,13,504)-(13,13,504): Unterminated segment, semicolon expected here
• SYNTAX_ERROR: calculator-basic-with-errors.g.etl(13,13,504)-(13,13,504): Structural error. Expecting tokens "LA[phraseTokens=[];tokens={STRING[quote="]=[null], STRING[quote=']=[null]}]".
• SYNTAX_ERROR: calculator-basic-with-errors.g.etl(17,13,585)-(17,13,585): Syntax error. Expecting end of segment.
• SEGMENT_ERROR: calculator-basic-with-errors.g.etl(23,9,741)-(23,9,741): Unterminated segment, semicolon expected here

     1: // This file demonstrates the error recovery strategy in ETL. 
     2: // Errors here are intentional.
     3: doctype "calculator-basic-with-errors.g.etl";
     4: print "zeroes: ", 24#0, " " , 0.0 , "  '', 0; 
     5: print "ones: ', 1, " ", 1.0, " ", 10E-1 {a;a}; 
     6: print "halves: ", 0.5, " ", 5.0E-1, " ", 2#0.001#e2; 
     7: print "dozens: ", 12#10#, " ", 3#1_1_0#, " ", 0.12e2, " ", 36#C {{

• GRAMMAR_ERROR: calculator-basic-with-errors.g.etl(12,40,487)-(12,44,491): New line encountered in string. If you want to insert new line use \n syntax
• GRAMMAR_ERROR: calculator-basic-with-errors.g.etl(13,13,504)-(13,13,504): Unterminated segment, semicolon expected here
• GRAMMAR_ERROR: calculator-basic-with-errors.g.etl(13,13,504)-(13,13,504): Structural error. Expecting tokens "LA[phraseTokens=[];tokens={STRING[quote="]=[null], STRING[quote=']=[null]}]".
• GRAMMAR_ERROR: calculator-basic-with-errors.g.etl(17,13,585)-(17,13,585): Syntax error. Expecting end of segment.
• GRAMMAR_ERROR: calculator-basic-with-errors.g.etl(23,9,741)-(23,9,741): Unterminated segment, semicolon expected here
• GRAMMAR_ERROR: sample-basic-with-errors.c.etl(3,45,141)-(3,45,141): Unable to parse grammar with public id null and system id file:/C:/projects/sf/etl-java/samples/calculator/src/calculator/grammars/calculator-basic-with-errors.g.etl due to unexpected problem.
• LEXICAL_ERROR: sample-basic-with-errors.c.etl(4,19,162)-(4,23,166): Based number is not terminated
• LEXICAL_ERROR: sample-basic-with-errors.c.etl(4,37,180)-(4,47,190): New line encountered in string. If you want to insert new line use \n syntax
• LEXICAL_ERROR: sample-basic-with-errors.c.etl(5,32,223)-(5,48,239): New line encountered in string. If you want to insert new line use \n syntax
• LEXICAL_ERROR: sample-basic-with-errors.c.etl(7,60,355)-(7,64,359): Based number is not terminated
• SEGMENT_ERROR: sample-basic-with-errors.c.etl(7,66,361)-(7,66,361): Block starting here is not terminated
• SEGMENT_ERROR: sample-basic-with-errors.c.etl(7,67,362)-(7,67,362): Unterminated segment, semicolon expected here
• SEGMENT_ERROR: sample-basic-with-errors.c.etl(7,65,360)-(7,65,360): Block starting here is not terminated
• SEGMENT_ERROR: sample-basic-with-errors.c.etl(7,67,362)-(7,67,362): Unterminated segment, semicolon expected here

  1 package calculator.interpreter.ast;
  2 
  3 import net.sf.etl.parsers.SourceLocation;
  4 
  5 /**
  6  * The basic node class
  7  */
  8 public abstract class Node {
  9   /** the position of the node */
 10   public SourceLocation location;
 11 }
 12 

  1 package calculator.interpreter.ast;
  2 
  3 import calculator.interpreter.Environment;
  4 
  5 /**
  6  * The base class for all expressions.
  7  */
  8 public abstract class Expression extends Node {
  9   /**
 10    * Evaluate the value of the expression.
 11    * 
 12    * @param env the evaluation environment
 13    * @return the resulting value
 14    */
 15   public abstract Object eval(Environment env);
 16 }
 17 

  1 package calculator.interpreter.ast;
  2 
  3 /**
  4  * The literal expression
  5  */
  6 public abstract class Literal extends Expression {
  7   /** The literal value */
  8   public String value;
  9 }
 10 

  1 package calculator.interpreter.ast;
  2 
  3 import net.sf.etl.parsers.LiteralUtils;
  4 import calculator.interpreter.Environment;
  5 
  6 /**
  7  * The string literal
  8  */
  9 public class StringLiteral extends Literal {
 10   @Override
 11   public Object eval(Environment env) {
 12     return LiteralUtils.parseString(value);
 13   }
 14 }
 15 

  1 package calculator.interpreter.ast;
  2 
  3 import net.sf.etl.parsers.LiteralUtils;
  4 import calculator.interpreter.Environment;
  5 
  6 /**
  7  * The number literal
  8  */
  9 public class NumberLiteral extends Literal {
 10   @Override
 11   public Object eval(Environment env) {
 12     return LiteralUtils.parseDouble(value);
 13   }
 14 }
 15 

  1 package calculator.interpreter.ast;
  2 
  3 import java.util.LinkedList;
  4 import calculator.interpreter.Cell;
  5 import calculator.interpreter.Environment;
  6 import calculator.interpreter.ast.meta.Annotation;
  7 import calculator.interpreter.ast.meta.DocumentationLine;
  8 
  9 /**
 10  * The base statement class
 11  */
 12 public abstract class Statement extends Node {
 13   /** the annotations associated with statement */
 14   public final LinkedList<Annotation> annotations = new LinkedList<Annotation>();
 15   /** the documentation lines associated with statement */
 16   public final LinkedList<DocumentationLine> documentation = new LinkedList<DocumentationLine>();
 17 
 18   /**
 19    * @return true if the statement has metadata
 20    */
 21   public boolean hasMetadata() {
 22     return !annotations.isEmpty() || !documentation.isEmpty();
 23   }
 24 
 25   /**
 26    * The evaluate statement
 27    * 
 28    * @param env the evaluation environment
 29    * @param result the evaluation result (the cell might be null, in that case
 30    *          the result must be discarded).
 31    * @return new context (if environment is not changed returns {@code env}
 32    *         argument)
 33    */
 34   public abstract Environment eval(Environment env, Cell result);
 35 }
 36 

  1 package calculator.interpreter.ast;
  2 
  3 import java.util.LinkedList;
  4 import calculator.interpreter.Cell;
  5 import calculator.interpreter.Environment;
  6 
  7 /**
  8  * The print statement
  9  */
 10 public class PrintStatement extends Statement {
 11   /** the values to print */
 12   public final LinkedList<Expression> values = new LinkedList<Expression>();
 13 
 14   @Override
 15   public Environment eval(Environment env, Cell result) {
 16     for (Expression e : values) {
 17       System.out.print(e.eval(env));
 18     }
 19     System.out.println();
 20     return env;
 21   }
 22 }
 23 

  1 package calculator.interpreter.ast;
  2 
  3 import calculator.interpreter.Cell;
  4 import calculator.interpreter.Environment;
  5 
  6 /**
  7  * The expression statement. The result of the statement execution is an value
  8  * of wrapped expression.
  9  */
 10 public class ExpressionStatement extends Statement {
 11   /** the expression to be interpreted */
 12   public Expression value;
 13 
 14   @Override
 15   public Environment eval(Environment env, Cell result) {
 16     Object rc = value.eval(env);
 17     if (result != null) {
 18       result.value = rc;
 19     }
 20     return env;
 21   }
 22 }
 23 

  1 package calculator.interpreter;
  2 
  3 import java.util.LinkedList;
  4 import net.sf.etl.parsers.ErrorInfo;
  5 import net.sf.etl.parsers.StandardGrammars;
  6 import net.sf.etl.parsers.TermParser;
  7 import net.sf.etl.parsers.TermParserFactory;
  8 import net.sf.etl.parsers.TermToken;
  9 import net.sf.etl.parsers.beans.FieldTermParser;
 10 import net.sf.etl.parsers.utils.AbstractTreeParser.PositionPolicy;
 11 import org.xml.sax.InputSource;
 12 import calculator.interpreter.ast.Node;
 13 import calculator.interpreter.ast.Statement;
 14 
 15 /**
 16  * The base class for the interpreter.
 17  */
 18 public class Interpreter {
 19   /**
 20    * The list that contains errors that are accumulated during the parsing
 21    * process.
 22    */
 23   protected final LinkedList<String> errors = new LinkedList<String>();
 24   /**
 25    * If true interpreter runs in interactive mode
 26    */
 27   protected boolean interactive = false;
 28 
 29   /**
 30    * The main interpreter loop it reads a sequence of statements from the AST
 31    * parser {@code statements} and executes them one by one. If an error
 32    * encountered, it is printed and the entire top level statement is skipped
 33    * (it is assumed the user will enter a correct version of the statement after
 34    * it receives an error about previous input).
 35    * 
 36    * @param statements the AST parser that returns a sequence of statements
 37    * @param env the initial environment
 38    * @return the resulting environment of the interpretation
 39    * @see #enlistError(TermToken)
 40    * @see #printErrors()
 41    */
 42   protected Environment interpret(FieldTermParser<Node> statements,
 43       Environment env) {
 44     final Cell lastResult = new Cell();
 45     while (statements.hasNext()) {
 46       Node current = statements.next();
 47       if (printErrors()) {
 48         printPrompt();
 49         continue;
 50       }
 51       if (current instanceof Statement) {
 52         Statement s = (Statement) current;
 53         lastResult.value = null;
 54         try {
 55           env = s.eval(env, lastResult);
 56           processResult(lastResult);
 57         } catch (EvalException ex) {
 58           System.err.println("EVAL ERROR: " + ex.getMessage());
 59         } catch (Exception ex) {
 60           System.err.println("Executing the statement of the type "
 61               + s.getClass().getName() + " at " + s.location.toShortString()
 62               + " resulted in the exception.");
 63           ex.printStackTrace();
 64         } finally {
 65           printPrompt();
 66         }
 67       } else {
 68         throw new IllegalArgumentException(
 69             "The input is not a valid calculator input file: "
 70                 + current.getClass().getName());
 71       }
 72     }
 73     printErrors();
 74     return env;
 75   }
 76 
 77   /**
 78    * Process the last result
 79    * 
 80    * @param lastResult the last result holder
 81    */
 82   protected void processResult(Cell lastResult) {
 83     if (interactive) {
 84       System.out.println("Result: " + lastResult.value);
 85     }
 86   }
 87 
 88   /**
 89    * Print prompt on the console
 90    */
 91   public void printPrompt() {
 92     if (interactive) {
 93       System.out.print("eval> ");
 94       System.out.flush();
 95     }
 96   }
 97 
 98   /**
 99    * Print errors that encountered during parsing
100    * 
101    * @param code the parser
102    * @return true if some errors were detected
103    */
104   protected boolean printErrors() {
105     if (!errors.isEmpty()) {
106       System.err.println("Errors in the input, the statement is skipped.");
107       for (String e : errors) {
108         System.err.println(e);
109       }
110       errors.clear();
111       return true;
112     }
113     return false;
114   }
115 
116   /**
117    * Enlist error that happens during parsing an object or when checking if the
118    * next object exists. The enlisted errors are later printed using
119    * {@link #printErrors()} method in the interpreter loop. This method is
120    * called from the method
121    * {@link FieldTermParser#handleErrorFromParser(TermToken)}.
122    * 
123    * @param errorToken the error token
124    */
125   protected void enlistError(TermToken errorToken) {
126     ErrorInfo ei = errorToken.errorInfo();
127     String text = errorToken.kind().name() + " "
128         + ei.location().toShortString() + ": " + ei.message();
129     errors.add(text);
130   }
131 
132   /**
133    * Create tree parser from event parser. This parser calculator text into a
134    * sequence of {@link Statement}-s located at the top level of the grammar.
135    * 
136    * @param parser the event parser
137    * @return the AST parser
138    */
139   protected FieldTermParser<Node> createTreeParser(TermParser parser) {
140     FieldTermParser<Node> rc = new FieldTermParser<Node>(parser,
141         Interpreter.class.getClassLoader()) {
142       @Override
143       protected void handleErrorFromParser(TermToken errorToken) {
144         enlistError(errorToken);
145       }
146     };
147     rc.mapNamespaceToPackage("http://etl.sf.net/samples/calculator",
148         "calculator.interpreter.ast");
149     rc.mapNamespaceToPackage("http://etl.sf.net/samples/calculator/arith",
150         "calculator.interpreter.ast.arith");
151     rc.mapNamespaceToPackage("http://etl.sf.net/samples/calculator/logic",
152         "calculator.interpreter.ast.logic");
153     rc.mapNamespaceToPackage("http://etl.sf.net/samples/calculator/vars",
154         "calculator.interpreter.ast.vars");
155     rc.mapNamespaceToPackage("http://etl.sf.net/samples/calculator/meta",
156         "calculator.interpreter.ast.meta");
157     rc.mapNamespaceToPackage("http://etl.sf.net/samples/calculator/lambda",
158         "calculator.interpreter.ast.lambda");
159     rc.ignoreNamespace(StandardGrammars.DOCTYPE_NS);
160     rc.setPosPolicy(PositionPolicy.SOURCE_LOCATION);
161     rc.setAbortOnDefaultGrammar(true);
162     return rc;
163   }
164 
165   /**
166    * Interpret the single source (file or stdin)
167    * 
168    * @param factory the preconfigured factory for the term parser
169    * @param source the source to interpret
170    * @param env the initial environment to interpret
171    * @return the resulting environment of the source execution
172    */
173   public Environment interpretSource(TermParserFactory factory,
174       InputSource source, Environment env) {
175     TermParser parser = factory.newTermParser();
176     parser.parse(source);
177     try {
178       parser.advance();
179       FieldTermParser<Node> code = createTreeParser(parser);
180       return interpret(code, env);
181     } finally {
182       parser.close();
183     }
184   }
185 }
186 

     1: doctype public "-//IDN etl.sf.net//ETL//Grammar 0.2.1";
     2: grammar calculator.CalculatorArith {
     3:     include "calculator-basic-0_2_1.g.etl";
     4:     namespace t = "http://etl.sf.net/samples/calculator";
     5:     namespace default a = "http://etl.sf.net/samples/calculator/arith";
     6:     context default Expressions {
     7:         op composite Identity(f) {
     8:             ^t:Identity {
     9:                 % (;
    10:                 @ value = expression;
    11:                 % );
    12:             };
    13:         };
    14:         op UnaryMinus(fy, 200, -) {
    15:             @ value = right;
    16:         };
    17:         op UnaryPlus(fy, 200, +) {
    18:             @ value = right;
    19:         };
    20:         op Power(xfy, 300, **) {
    21:             @ first = left;
    22:             @ second = right;
    23:         };
    24:         op Multiply(yfx, 400, *) {
    25:             @ first = left;
    26:             @ second = right;
    27:         };
    28:         op Divide(yfx, 400, /) {
    29:             @ first = left;
    30:             @ second = right;
    31:         };
    32:         op Remainder(yfx, 400, %) {
    33:             @ first = left;
    34:             @ second = right;
    35:         };
    36:         op Plus(yfx, 500, +) {
    37:             @ first = left;
    38:             @ second = right;
    39:         };
    40:         op Minus(yfx, 500, -) {
    41:             @ first = left;
    42:             @ second = right;
    43:         };
    44:     };
    45: };

     1: doctype "calculator-arith-0_2_1.g.etl";
     2: print "zeroes: ", 2*3#10#-3 * 2 ** 3 / 4, " ", +1 + -1; 
     3: print "dozens: ", 12#100# ** (1/2), " ", 3#1_0# * 16#10000# ** +8#0.1#;

  1 package calculator.interpreter.ast;
  2 
  3 /**
  4  * Base class for infix operators
  5  */
  6 public abstract class InfixOp extends Expression {
  7   /** The first (left) operand of operator */
  8   public Expression first;
  9   /** The second (right) operand of operator */
 10   public Expression second;
 11 }
 12 

  1 package calculator.interpreter.ast;
  2 
  3 /**
  4  * The unary operation
  5  */
  6 public abstract class UnaryOp extends Expression {
  7   /** The operand of unary operation */
  8   public Expression value;
  9 }
 10 

  1 package calculator.interpreter.ast;
  2 
  3 import calculator.interpreter.Environment;
  4 
  5 /**
  6  * The identity operator that just returns what is enclosed.
  7  */
  8 public class Identity extends UnaryOp {
  9 
 10   @Override
 11   public Object eval(Environment env) {
 12     return value.eval(env);
 13   }
 14 }
 15 

  1 package calculator.interpreter;
  2 
  3 import net.sf.etl.parsers.SourceLocation;
  4 import calculator.interpreter.ast.Expression;
  5 import calculator.interpreter.ast.Node;
  6 
  7 /**
  8  * Evaluation utilities
  9  */
 10 public class EvalUtils {
 11   /**
 12    * Evaluate expression to double
 13    * 
 14    * @param owner the owner
 15    * @param env the evaluation environment
 16    * @param ex the expression to evaluate
 17    * @return the double value
 18    */
 19   public static double toDouble(Node owner, Environment env, Expression ex) {
 20     Object o = ex.eval(env);
 21     if (o instanceof Double) {
 22       return ((Double) o).doubleValue();
 23     } else {
 24       throw new EvalException(ex, "The node type "
 25           + owner.getClass().getSimpleName() + " expects expression at "
 26           + ex.location.toShortString()
 27           + " to be of type double, and it evaluated to " + o
 28           + (o != null ? " : " + o.getClass().getName() : ""));
 29     }
 30   }
 31 
 32   /**
 33    * Evaluate expression to boolean
 34    * 
 35    * @param owner the owner
 36    * @param env the evaluation environment
 37    * @param ex the expression to evaluate
 38    * @return the boolean value
 39    */
 40   public static boolean toBoolean(Node owner, Environment env, Expression ex) {
 41     Object o = ex.eval(env);
 42     if (o instanceof Boolean) {
 43       return ((Boolean) o).booleanValue();
 44     } else {
 45       throw new EvalException(ex, "The node type "
 46           + owner.getClass().getSimpleName() + " expects expression at "
 47           + ex.location.toShortString()
 48           + " to be of type boolean, and it evaluated to " + o
 49           + (o != null ? " : " + o.getClass().getName() : ""));
 50     }
 51   }
 52 
 53   /**
 54    * Return value casted to string or throw {@link EvalException}.
 55    * 
 56    * @param location location of expression
 57    * @param role the role of the expression
 58    * @param value the value to cast
 59    * @return the casted value
 60    */
 61   public static String expectString(SourceLocation location, String role,
 62       Object value) {
 63     if (value instanceof String) {
 64       return (String) value;
 65     } else {
 66       throw new EvalException(location, "Expecting " + role + " and found "
 67           + value + " : " + (value == null ? null : value.getClass()));
 68     }
 69   }
 70 }
 71 

  1 package calculator.interpreter.ast.arith;
  2 
  3 import calculator.interpreter.Environment;
  4 import calculator.interpreter.EvalUtils;
  5 import calculator.interpreter.ast.UnaryOp;
  6 
  7 /**
  8  * Unary minus
  9  */
 10 public class UnaryMinus extends UnaryOp {
 11 
 12   @Override
 13   public Object eval(Environment env) {
 14     return -EvalUtils.toDouble(this, env, value);
 15   }
 16 }
 17 

  1 package calculator.interpreter.ast.arith;
  2 
  3 import calculator.interpreter.Environment;
  4 import calculator.interpreter.EvalUtils;
  5 import calculator.interpreter.ast.InfixOp;
  6 
  7 /**
  8  * Power operator
  9  */
 10 public class Power extends InfixOp {
 11 
 12   @Override
 13   public Object eval(Environment env) {
 14     double f = EvalUtils.toDouble(this, env, first);
 15     double s = EvalUtils.toDouble(this, env, second);
 16     return Math.pow(f, s);
 17   }
 18 }
 19 

  1 package calculator.interpreter.ast.arith;
  2 
  3 import calculator.interpreter.Environment;
  4 import calculator.interpreter.EvalException;
  5 import calculator.interpreter.EvalUtils;
  6 import calculator.interpreter.ast.InfixOp;
  7 
  8 /**
  9  * Plus operator
 10  */
 11 public class Plus extends InfixOp {
 12   @Override
 13   public Object eval(Environment env) {
 14     Object f = first.eval(env);
 15     if (f instanceof String) {
 16       return ((String) f) + second.eval(env);
 17     } else if (f instanceof Double) {
 18       double s = EvalUtils.toDouble(this, env, second);
 19       return ((Double) f) + s;
 20     } else {
 21       throw new EvalException(first,
 22           "Unsupported type of operand for plus operator: " + f);
 23     }
 24   }
 25 }
 26 

  1 package calculator.interpreter.ast.arith;
  2 
  3 import calculator.interpreter.Environment;
  4 import calculator.interpreter.EvalException;
  5 import calculator.interpreter.EvalUtils;
  6 import calculator.interpreter.ast.InfixOp;
  7 
  8 /**
  9  * Multiply operation
 10  */
 11 public class Multiply extends InfixOp {
 12   @Override
 13   public Object eval(Environment env) {
 14     Object f = first.eval(env);
 15     if (f instanceof String) {
 16       String str = (String) f;
 17       double s = EvalUtils.toDouble(this, env, second);
 18       if (s > 1024 && s >= 0) {
 19         throw new EvalException(second,
 20             "The string could be multiplied by non-negative "
 21                 + "numbers smaller than 1024 and the second "
 22                 + "argument evaluated to " + s);
 23       }
 24       int n = (int) s;
 25       StringBuilder rc = new StringBuilder(str.length() * n);
 26       for (int i = 0; i < n; i++) {
 27         rc.append(str);
 28       }
 29       return rc.toString();
 30     } else if (f instanceof Double) {
 31       double s = EvalUtils.toDouble(this, env, second);
 32       return ((Double) f) * s;
 33     } else {
 34       throw new EvalException(first,
 35           "Unsupported type of operand for plus operator: " + f);
 36     }
 37   }
 38 }
 39 

     1: doctype public "-//IDN etl.sf.net//ETL//Grammar 0.2.1";
     2: grammar calculator.CalculatorVars {
     3:     include "calculator-arith-0_2_1.g.etl";
     4:     namespace t = "http://etl.sf.net/samples/calculator";
     5:     namespace m = "http://etl.sf.net/samples/calculator/meta";
     6:     namespace default v = "http://etl.sf.net/samples/calculator/vars";
     7:     context abstract MetaInformation {
     8:         def ExpressionDef {
     9:             expression(Expressions); 
    10:         };
    11:         def NameDef {
    12:             ^ v:Name { 
    13:                 {
    14:                     @ literal = identifier;
    15:                 } | {
    16:                     @ quoted = string(prefix=Q|q, quote="'");
    17:                 };
    18:             };
    19:         };
    20:         documentation Documentation {
    21:             @ documentation += doclines wrapper m:DocumentationLine.text;
    22:         };
    23:         attributes Annotations {
    24:             @ annotations += % @ {
    25:                 ^ m:Annotation {
    26:                     @ name = ref(NameDef);
    27:                     % ( {
    28:                         @ arguments += list , {ref(ExpressionDef);}?;
    29:                     } % ) ?;
    30:                 }; 
    31:             } *;
    32:         };
    33:     };
    34:     context default Expressions {
    35:         include MetaInformation;
    36:         def ExpressionDef {
    37:             expression;
    38:         };
    39:         statement VarStatement {
    40:             @ type = token(var) | token(let);
    41:             @ name = ref(NameDef);
    42:             % = {
    43:                 @ value = expression;
    44:             }?;
    45:         };
    46:         op composite Name(f) {
    47:             ref(NameDef);
    48:         };
    49:         def SequenceDef {
    50:             ^ t:Sequence {
    51:                 @ statements += block; 
    52:             };
    53:         };
    54:         op composite Sequence(f) {
    55:             ref(SequenceDef);
    56:         };
    57:         op Assignment(xfy, 2000, =) {
    58:             @ first = left;
    59:             @ second = right;
    60:         };
    61:         statement Help {
    62:             % help;
    63:             @ variable = ref(NameDef);
    64:         };
    65:         statement IncludeStatement {
    66:             ^ t:IncludeStatement {
    67:                 % include;
    68:                 @ systemId = string(quote='"');
    69:             };
    70:         };
    71:     };
    72: };

  1 package calculator.interpreter;
  2 
  3 import net.sf.etl.parsers.SourceLocation;
  4 
  5 /**
  6  * The evaluation environment
  7  */
  8 public class Environment {
  9   /** the previous environment or null for top one */
 10   private final Environment previous;
 11   /** the variable */
 12   private final Variable var;
 13 
 14   /**
 15    *The constructor for the context
 16    * 
 17    * @param previous the previous context (might be null)
 18    * @param var the variable
 19    */
 20   public Environment(Environment previous, Variable var) {
 21     super();
 22     this.previous = previous;
 23     this.var = var;
 24   }
 25 
 26   /**
 27    * The constructor for initial environment
 28    */
 29   public Environment() {
 30     var = null;
 31     previous = null;
 32   }
 33 
 34   /**
 35    * Find a variable
 36    * 
 37    * @param name the name to lookup
 38    * @return the variable or null if it was not found.
 39    */
 40   public Variable find(String name) {
 41     for (Environment env = this; env.previous != null; env = env.previous) {
 42       if (env.var.name.equals(name)) {
 43         return env.var;
 44       }
 45     }
 46     return null;
 47   }
 48 
 49   /**
 50    * Find variable or fail with exception
 51    * 
 52    * @param location the location of the node that requested the the variable
 53    * @param name the name to lookup
 54    * @return the found variable
 55    * @throws EvalException if variable is not found
 56    */
 57   public Variable findDefined(SourceLocation location, String name) {
 58     Variable rc = find(name);
 59     if (rc == null) {
 60       throw new EvalException(location, "No variable with " + name
 61           + " is defined.");
 62     }
 63     return rc;
 64   }
 65 
 66   /**
 67    * Check if the variable is free
 68    * 
 69    * @param location the location of the check
 70    * @param name the name to check
 71    */
 72   public void checkFree(SourceLocation location, String name) {
 73     Variable previousDef = find(name);
 74     if (previousDef != null) {
 75       throw new EvalException(location, "Then name '" + name
 76           + "' has been already defined at "
 77           + previousDef.defineLocation.toShortString());
 78     }
 79   }
 80 }
 81 

  1 package calculator.interpreter;
  2 
  3 import java.util.List;
  4 import calculator.interpreter.ast.Node;
  5 import net.sf.etl.parsers.SourceLocation;
  6 
  7 /**
  8  * The variable
  9  */
 10 public class Variable {
 11   /** the name of variable to be defined */
 12   public final String name;
 13   /** the true value indicate that this name is mutable variable */
 14   public final boolean isVar;
 15   /** the true value indicate that is this name has been bound at least once */
 16   public boolean isBound;
 17   /** the value of the variable */
 18   public Object value;
 19   /** the location where variable is defined */
 20   public final SourceLocation defineLocation;
 21   /** the location where variable is set */
 22   public SourceLocation bindLocation;
 23   /** the documentation associated with binding (might be null) */
 24   public final String documentation;
 25   /** the annotation values (might be null) */
 26   public final List<AnnotationValue> annotations;
 27 
 28   /**
 29    *The constructor for the variable
 30    * 
 31    * @param previous the previous context (might be null)
 32    * @param name the name of variable or constant
 33    * @param isVar if true, the name could be rebound after it was bound
 34    * @param defineLocation the location where the name was defined
 35    * @param documentation the documentation associated with the variable
 36    * @param annotations the list of annotation values
 37    */
 38   public Variable(String name, boolean isVar, SourceLocation defineLocation,
 39       String documentation, List<AnnotationValue> annotations) {
 40     super();
 41     this.name = name;
 42     this.isVar = isVar;
 43     this.defineLocation = defineLocation;
 44     this.documentation = documentation;
 45     this.annotations = annotations;
 46   }
 47 
 48   /**
 49    * Get the value bound to the name
 50    * 
 51    * @param node the node that requested the bind operation
 52    * @return the current value of the binding
 53    */
 54   public Object get(Node node) {
 55     if (!isBound) {
 56       throw new EvalException(node, "The name " + name + " defined at "
 57           + defineLocation.toShortString() + " has not been bound yet.");
 58     }
 59     return value;
 60   }
 61 
 62   /**
 63    * Bind the variable with the value
 64    * 
 65    * @param location the location of the node that requested the bind operation
 66    * @param value the value to bind
 67    * @return the value argument
 68    */
 69   public Object bind(SourceLocation location, Object value) {
 70     if (!isBound) {
 71       isBound = true;
 72     } else if (!isVar) {
 73       throw new EvalException(location,
 74           "The value has been already bound to constant " + name + " at "
 75               + bindLocation);
 76     }
 77     bindLocation = location;
 78     this.value = value;
 79     return value;
 80   }
 81 
 82   /**
 83    * @return the help string for the variable
 84    */
 85   public String help() {
 86     StringBuilder b = new StringBuilder();
 87     b.append("------ ");
 88     b.append(isVar ? "Varaible " : "Constant ").append(name)
 89         .append(" ------\n");
 90     b.append("Defined at ").append(defineLocation.toShortString()).append('\n');
 91     if (isBound) {
 92       b.append("Bound at ").append(bindLocation.toShortString()).append(
 93           " to value ").append(value).append('\n');
 94     }
 95     if (documentation == null) {
 96       b.append("(No documentation defined)\n");
 97     } else {
 98       b.append(documentation);
 99     }
100     if (annotations == null || annotations.size() == 0) {
101       b.append("(No annotations defined)\n");
102     } else {
103       for (AnnotationValue v : annotations) {
104         b.append(v).append('\n');
105       }
106     }
107     return b.toString();
108   }
109 }
110 

  1 package calculator.interpreter;
  2 
  3 import java.util.List;
  4 import net.sf.etl.parsers.SourceLocation;
  5 
  6 /**
  7  * The value of annotation
  8  */
  9 public class AnnotationValue {
 10   /** the location for annotation in the source */
 11   public final SourceLocation location;
 12   /** the annotation name */
 13   public final String name;
 14   /** the annotation arguments */
 15   public final List<Object> arguments;
 16 
 17   /**
 18    * The constructor
 19    * 
 20    * @param location the location of the annotation in the source
 21    * @param name the annotation name
 22    * @param arguments the annotation arguments
 23    */
 24   public AnnotationValue(SourceLocation location, String name,
 25       List<Object> arguments) {
 26     super();
 27     this.location = location;
 28     this.name = name;
 29     this.arguments = arguments;
 30   }
 31 
 32   /**
 33    * Process an annotation
 34    * 
 35    * @param env the processing environment (includes the variable)
 36    * @param var the variable to process
 37    */
 38   @SuppressWarnings("unchecked")
 39   public void process(Environment env, Variable var) {
 40     String className = "calculator.interpreter.annotations." + name
 41         + "Annotation";
 42     try {
 43       Class<? extends Processor> c = (Class<? extends Processor>) Class
 44           .forName(className);
 45       Processor p = c.newInstance();
 46       p.process(this, env, var);
 47     } catch (ClassNotFoundException e) {
 48       // ignore the problem
 49     } catch (Exception e) {
 50       throw new EvalException(location,
 51           "Processor instance failed to be created: " + e);
 52     }
 53   }
 54 
 55   @Override
 56   public String toString() {
 57     StringBuilder rc = new StringBuilder();
 58     rc.append('@').append(name).append('(');
 59     boolean isFirst = true;
 60     for (Object v : arguments) {
 61       if (isFirst) {
 62         isFirst = false;
 63       } else {
 64         rc.append(", ");
 65       }
 66       rc.append(v);
 67     }
 68     rc.append(')');
 69     return rc.toString();
 70   }
 71 
 72   /**
 73    * A processor for annotations on the variables
 74    */
 75   public interface Processor {
 76     /**
 77      * Process annotation (typically by assigning some value to the variable)
 78      * 
 79      * @param annotation an annotation to process
 80      * @param env the environment
 81      * @param var the variable to which annotation is attached
 82      */
 83     void process(AnnotationValue annotation, Environment env, Variable var);
 84   }
 85 }
 86 

  1 package calculator.interpreter.annotations;
  2 
  3 import java.lang.reflect.Field;
  4 import calculator.interpreter.AnnotationValue;
  5 import calculator.interpreter.EvalException;
  6 import calculator.interpreter.EvalUtils;
  7 
  8 /**
  9  * Base class for annotation processors based on reflection
 10  */
 11 public abstract class JavaReflectionProcessor implements
 12     AnnotationValue.Processor {
 13 
 14   /**
 15    * Get class for reflection annotation
 16    * 
 17    * @param annotation the annotation value
 18    * @param pos position within annotation
 19    * @return the loaded class for annotation
 20    */
 21   protected static Class<?> getClass(AnnotationValue annotation, int pos) {
 22     String className = EvalUtils.expectString(annotation.location,
 23         "the class name (the argument " + pos + ")", annotation.arguments
 24             .get(pos));
 25     if ("double".equals(className)) {
 26       return double.class;
 27     } else if ("float".equals(className)) {
 28       return float.class;
 29     } else if ("char".equals(className)) {
 30       return char.class;
 31     } else if ("long".equals(className)) {
 32       return long.class;
 33     } else if ("int".equals(className)) {
 34       return int.class;
 35     } else if ("short".equals(className)) {
 36       return short.class;
 37     } else if ("byte".equals(className)) {
 38       return byte.class;
 39     }
 40     try {
 41       return Class.forName(className);
 42     } catch (ClassNotFoundException e) {
 43       throw new EvalException(annotation.location, "No class found: "
 44           + className);
 45     }
 46   }
 47 
 48   /**
 49    * Get field for the class
 50    * 
 51    * @param annotation the annotation
 52    * @param c the class
 53    * @param pos the position within annotation
 54    * @return the field object
 55    */
 56   protected static Field getField(AnnotationValue annotation, Class<?> c,
 57       int pos) {
 58     String fieldName = EvalUtils.expectString(annotation.location,
 59         "the field name (the argument " + pos + ")", annotation.arguments
 60             .get(pos));
 61     try {
 62       return c.getField(fieldName);
 63     } catch (NoSuchFieldException e) {
 64       throw new EvalException(annotation.location, "No field " + fieldName
 65           + " found in  " + c.getName());
 66     } catch (Exception ex) {
 67       throw new EvalException(annotation.location, "Unable to acces the field "
 68           + fieldName + " in  " + c.getName() + ": " + ex);
 69     }
 70   }
 71 }
 72 

  1 package calculator.interpreter.annotations;
  2 
  3 import java.lang.reflect.Field;
  4 import calculator.interpreter.AnnotationValue;
  5 import calculator.interpreter.Environment;
  6 import calculator.interpreter.EvalException;
  7 import calculator.interpreter.Variable;
  8 
  9 /**
 10  * Annotation that binds value to the static constant defined in some java
 11  * class. The annotation has the following arguments:
 12  * <ol>
 13  * <li>Fully qualified Java class name (like "java.lang.Math")</li>
 14  * <li>A constant name with class (like "PI")</li>
 15  * </ol>
 16  */
 17 public class JavaConstantAnnotation extends JavaReflectionProcessor {
 18   /** {@inheritDoc} */
 19   public void process(AnnotationValue annotation, Environment env, Variable var) {
 20     if (annotation.arguments.size() != 2) {
 21       throw new EvalException(annotation.location,
 22           "Wrong number of the arguments for annotation expected 2 and found "
 23               + annotation.arguments);
 24     }
 25     Class<?> c = getClass(annotation, 0);
 26     Field f = getField(annotation, c, 1);
 27     try {
 28       Object value = f.get(null);
 29       var.bind(annotation.location, value);
 30     } catch (EvalException ex) {
 31       throw ex;
 32     } catch (Exception ex) {
 33       throw new EvalException(annotation.location, "Unable to acces the field "
 34           + f.getName() + " in  " + c.getName() + ": " + ex);
 35     }
 36   }
 37 }
 38 

  1 package calculator.interpreter.ast.vars;
  2 
  3 import java.util.LinkedList;
  4 import calculator.interpreter.AnnotationValue;
  5 import calculator.interpreter.Cell;
  6 import calculator.interpreter.Environment;
  7 import calculator.interpreter.Variable;
  8 import calculator.interpreter.ast.Expression;
  9 import calculator.interpreter.ast.Statement;
 10 import calculator.interpreter.ast.meta.Annotation;
 11 import calculator.interpreter.ast.meta.DocumentationLine;
 12 
 13 /**
 14  * The variable definition statement
 15  */
 16 public class VarStatement extends Statement {
 17   /** the type of the statement ("var" or "let") */
 18   public String type;
 19   /** the definition name */
 20   public Name name;
 21   /** the statement value (optional) */
 22   public Expression value;
 23 
 24   @Override
 25   public Environment eval(Environment env, Cell result) {
 26     env.checkFree(location, name.name());
 27     boolean isVar = "var".equals(type);
 28     String docs;
 29     if (!this.documentation.isEmpty()) {
 30       StringBuilder b = new StringBuilder();
 31       for (DocumentationLine l : this.documentation) {
 32         b.append(l.text).append('\n');
 33       }
 34       docs = b.toString();
 35     } else {
 36       docs = null;
 37     }
 38     LinkedList<AnnotationValue> evaluatedAnnotations = new LinkedList<AnnotationValue>();
 39     for (Annotation a : this.annotations) {
 40       evaluatedAnnotations.add(a.eval(env));
 41     }
 42     Variable var = new Variable(name.name(), isVar, location, docs,
 43         evaluatedAnnotations);
 44     Environment rc = new Environment(env, var);
 45     for (AnnotationValue a1 : var.annotations) {
 46       a1.process(rc, var);
 47     }
 48     if (value != null) {
 49       var.bind(this.location, value.eval(env));
 50     }
 51     if (var.isBound && result != null) {
 52       result.value = var.value;
 53     }
 54     return rc;
 55   }
 56 }
 57 

  1 package calculator.interpreter.ast.vars;
  2 
  3 import calculator.interpreter.Environment;
  4 import calculator.interpreter.EvalException;
  5 import calculator.interpreter.ast.InfixOp;
  6 
  7 /**
  8  * Execute assignment operator
  9  */
 10 public class Assignment extends InfixOp {
 11   @Override
 12   public Object eval(Environment env) {
 13     String name;
 14     if (first instanceof Name) {
 15       name = ((Name) first).name();
 16     } else {
 17       throw new EvalException(first,
 18           "Left hand side of assignment must be an identifier");
 19     }
 20     Object value = second.eval(env);
 21     return env.findDefined(location, name).bind(location, value);
 22   }
 23 }
 24 

  1 package calculator.interpreter.ast;
  2 
  3 import java.util.LinkedList;
  4 import calculator.interpreter.Cell;
  5 import calculator.interpreter.Environment;
  6 
  7 /**
  8  * A sequence of the statements to evaluate
  9  */
 10 public class Sequence extends Expression {
 11   /** statements to evaluate */
 12   public final LinkedList<Statement> statements = new LinkedList<Statement>();
 13 
 14   @Override
 15   public Object eval(Environment env) {
 16     Cell result = new Cell();
 17     for (Statement s : statements) {
 18       result.value = null;
 19       env = s.eval(env, result);
 20     }
 21     return result.value;
 22   }
 23 }
 24 

  1 package calculator.interpreter.ast;
  2 
  3 import java.net.URI;
  4 import java.net.URISyntaxException;
  5 import net.sf.etl.parsers.LiteralUtils;
  6 import net.sf.etl.parsers.ParserException;
  7 import org.xml.sax.InputSource;
  8 import calculator.interpreter.Cell;
  9 import calculator.interpreter.Environment;
 10 import calculator.interpreter.EvalException;
 11 import calculator.interpreter.RunnerVars;
 12 
 13 /**
 14  * The include statement
 15  */
 16 public class IncludeStatement extends Statement {
 17   /** the system identifier to be included */
 18   public String systemId;
 19 
 20   @Override
 21   public Environment eval(Environment env, Cell result) {
 22     RunnerVars r = (RunnerVars) env.findDefined(this.location,
 23         RunnerVars.RUNNER_VAR_NAME).get(this);
 24     InputSource source = createInputSource();
 25     try {
 26       return r.createInterpreter().interpretSource(r.getFactory(), source, env);
 27     } catch (ParserException e) {
 28       throw new EvalException(this, "The soruce " + source.getSystemId()
 29           + "(public '" + source.getPublicId() + "') could not be opened: " + e);
 30     }
 31   }
 32 
 33   /**
 34    * @return a input source for the include directive
 35    */
 36   protected InputSource createInputSource() {
 37     return new InputSource(resolveSystemId());
 38   }
 39 
 40   /**
 41    * @return the system id resolved with respect to the current source location
 42    */
 43   protected String resolveSystemId() {
 44     String mySystemId = location.systemId();
 45     String resolvedSystemId;
 46     if (!mySystemId.startsWith("<")) {
 47       try {
 48         URI myUri = new URI(mySystemId);
 49         resolvedSystemId = myUri.resolve(LiteralUtils.parseString(systemId))
 50             .toString();
 51       } catch (URISyntaxException e) {
 52         throw new EvalException(this, "Problem with parsing URIs " + e);
 53       }
 54     } else {
 55       resolvedSystemId = systemId;
 56     }
 57     return resolvedSystemId;
 58   }
 59 }
 60 

  1 package calculator.interpreter;
  2 
  3 import java.net.URL;
  4 import net.sf.etl.parsers.SourceLocation;
  5 import net.sf.etl.parsers.TermParserFactory;
  6 import net.sf.etl.parsers.TextPos;
  7 import org.xml.sax.InputSource;
  8 
  9 /**
 10  * The runner for language level "vars" and higher.
 11  */
 12 public class RunnerVars extends RunnerBasic {
 13   /** the variable name where runner is stored */
 14   public static final String RUNNER_VAR_NAME = "$runner";
 15   /** If true, the prelude is loaded in the initial context. */
 16   protected boolean loadPrelude = true;
 17   /** If not null, the string will be used as a default language */
 18   protected String defaultLanguage = null;
 19 
 20   @Override
 21   protected String getDefaultLanguageLevel() {
 22     return defaultLanguage != null ? defaultLanguage : "vars";
 23   }
 24 
 25   @Override
 26   protected Environment initialEnvironment() {
 27     Environment context = super.initialEnvironment();
 28     SourceLocation nowhere = new SourceLocation(TextPos.START, TextPos.START,
 29         "<system>");
 30     Variable runnerVar = new Variable(RUNNER_VAR_NAME, false, nowhere, null,
 31         null);
 32     runnerVar.bind(nowhere, this);
 33     context = new Environment(context, runnerVar);
 34     if (loadPrelude) {
 35       String prelude = getPrelude();
 36       if (prelude != null) {
 37         InputSource source = new InputSource(prelude);
 38         context = createInterpreter().interpretSource(factory, source, context);
 39       }
 40     }
 41     return context;
 42   }
 43 
 44   @Override
 45   public Interpreter createInterpreter() {
 46     return new InterpreterVars();
 47   }
 48 
 49   /**
 50    * @return the default grammar to use in the case if the grammar is not
 51    *         specified
 52    */
 53   protected String getPrelude() {
 54     String lang = getLanguageLevel();
 55     URL prelude = getClass().getResource(
 56         "/calculator/grammars/prelude-" + lang + ".c.etl");
 57     return prelude == null ? null : prelude.toString();
 58   }
 59 
 60   @Override
 61   protected void parseArgs(String[] args) {
 62     int i = 0;
 63     while (i < args.length && args[i].startsWith("-")) {
 64       i = parseOption(args, i);
 65     }
 66     if (i < args.length - 1) {
 67       usage();
 68     }
 69     if (i == args.length - 1) {
 70 
 71     }
 72     super.parseArgs(i == args.length - 1 ? new String[] { args[i] }
 73         : new String[0]);
 74   }
 75 
 76   /**
 77    * Parse single option
 78    * 
 79    * @param args the arguments to parse
 80    * @param i the current position
 81    * @return the position after option
 82    */
 83   protected int parseOption(String[] args, int i) {
 84     if (args[i].equals("-e")) {
 85       loadPrelude = false;
 86       i++;
 87     } else if (args[i].equals("-l")) {
 88       if (i == args.length - 1) {
 89         usage();
 90       } else {
 91         defaultLanguage = args[i + 1];
 92         i += 2;
 93       }
 94     } else {
 95       usage();
 96     }
 97     return i;
 98   }
 99 
100   @Override
101   public void usage() {
102     System.err.println("Calculator Interpreter (vars version). "
103         + "(c) Constantine Plotnikov, 2008");
104     System.err.println("Usage: java " + getClass().getName() + " "
105         + optionList() + " [<file>]");
106     System.err.println(" <file> - the file to be interpreted. "
107         + "If absent, stdin will be used.");
108     optionUsage();
109     System.exit(1);
110   }
111 
112   /**
113    * The usage string for options
114    */
115   protected void optionUsage() {
116     System.err.println(" -e - if specified, the prelude is not loaded.");
117     System.err.println(" -l <lang level> - the default language level "
118         + "(the default value is 'vars').");
119   }
120 
121   /**
122    * @return the list of options (for command line usage)
123    */
124   protected String optionList() {
125     return "[-e] [-l <lang level]";
126   }
127 
128   /**
129    * Application entry point.
130    * 
131    * @param args application arguments
132    */
133   public static void main(String[] args) {
134     new RunnerVars().start(args);
135   }
136 
137   /**
138    * @return a factory for term parsers
139    */
140   public TermParserFactory getFactory() {
141     return factory;
142   }
143 }
144 

  1 package calculator.interpreter;
  2 
  3 import net.sf.etl.parsers.SourceLocation;
  4 import net.sf.etl.parsers.TextPos;
  5 import net.sf.etl.parsers.beans.FieldTermParser;
  6 import calculator.interpreter.ast.Node;
  7 
  8 /**
  9  * The var's specific interpreter. The only thing that it does, it ensures that
 10  * files are processed only once using real resolved system identifier.
 11  */
 12 public class InterpreterVars extends Interpreter {
 13   @Override
 14   protected Environment interpret(FieldTermParser<Node> statements,
 15       Environment env) {
 16     String systemId = statements.getSystemId();
 17     String visitedVar = "$interpreted " + systemId;
 18     if (env.find(visitedVar) != null) {
 19       return env;
 20     }
 21     env = new Environment(env, new Variable(visitedVar, false,
 22         new SourceLocation(TextPos.START, TextPos.START, systemId), null, null));
 23     return super.interpret(statements, env);
 24   }
 25 }
 26 

     1: doctype "calculator-vars-0_2_1.g.etl";
     2: // This file contains some useful constants. This file is loaded 
     3: // when language level is "vars".
     4: 
     5: /// The constant PI
     6: @JavaConstant("java.lang.Math","PI") 
     7: let PI;
     8: /// The constant E
     9: @JavaConstant("java.lang.Math","E") 
    10: let E;
    11: /// Not a number
    12: @JavaConstant("java.lang.Double","NaN") 
    13: let NaN;
    14: /// Positive infinity
    15: @JavaConstant("java.lang.Double","POSITIVE_INFINITY") 
    16: let POSITIVE_INFINITY;
    17: /// Negative infinity
    18: @JavaConstant("java.lang.Double","NEGATIVE_INFINITY") 
    19: let NEGATIVE_INFINITY;
    20: /// Maximum positive value
    21: @JavaConstant("java.lang.Double","MAX_VALUE") 
    22: let MAX_NUMBER;
    23: /// Minimum positive value
    24: @Q'JavaConstant'("java.lang.Double","MIN_VALUE") 
    25: let q'MIN_NUMBER';
    26: /// Maximum integer value
    27: let MAX_INTEGER = 16#7FFF_FFFF#;
    28: /// Minimum integer value
    29: let MIN_INTEGER = -16#8000_0000#;
    30: /// The null constant
    31: let null = {};

     1: doctype "calculator-vars-0_2_1.g.etl";
     2: 
     3: print "PI ** E: ", Q'PI' ** E;
     4: print "E ** PI: ", E ** PI;
     5: /// The dozen constant defined in a complex way
     6: let dozen = {let a = {let one = 1; one + one;}; a * a;} * 3;
     7: help dozen;
     8: help PI;
     9: let a;
    10: a = 4;
    11: help a;
    12: // Using keyword as a name. Quoting is only required
    13: // where it could happen as a keyword, but possible everywhere.
    14: let let;
    15: q'let' = 2;
    16: let Q'print';
    17: // quoting of left hand side is required, but in expression
    18: // is not since "let" is not a keyword in the expression context.
    19: // the last in the sum is also "let" but with 
    20: // all unicode escapes used. 
    21: Q'print' = let + q'let' + Q'\x6c\u0065\U000074;';
    22: // in the sample below quoting is not required
    23: // since "print" and "let" are not keywords in this context
    24: print "used keyword vars: ", let * print;  
    25: help let;
    26: help q'print';
    27: // the $runner is the system variable defined by the runner
    28: help q'$runner';
    29: 

     1: doctype public "-//IDN etl.sf.net//ETL//Grammar 0.2.1";
     2: grammar calculator.CalculatorLogic {
     3:     include "calculator-vars-0_2_1.g.etl";
     4:     namespace t = "http://etl.sf.net/samples/calculator";
     5:     namespace default l = "http://etl.sf.net/samples/calculator/logic";
     6:     context default Expressions {
     7:         import matchSelectors = Selectors;
     8:         import selectSelectors = Selectors;
     9:         
    10:         op composite BooleanLiteral(f) {
    11:             ^ t:BooleanLiteral {
    12:                 @ value = token(true) | token(false);
    13:             };
    14:         };
    15:         op LessThen(xfx, 1200, <) {
    16:             @ first = left;
    17:             @ second = right;
    18:         };
    19:         op LessOrEqual(xfx, 1200, <=) {
    20:             @ first = left;
    21:             @ second = right;
    22:         };
    23:         op MoreThen(xfx, 1200, >) {
    24:             @ first = left;
    25:             @ second = right;
    26:         };
    27:         op MoreOrEqual(xfx, 1200, >=) {
    28:             @ first = left;
    29:             @ second = right;
    30:         };
    31:         op Equal(xfx, 1300, ==) {
    32:             @ first = left;
    33:             @ second = right;
    34:         };
    35:         op NotEqual(xfx, 1300, !=) {
    36:             @ first = left;
    37:             @ second = right;
    38:         };
    39:         op composite RegExLiteral(f) {
    40:             ^t:RegExLiteral {
    41:                 @ value = string(prefix=R, quote='"');
    42:             };
    43:         };
    44:         op Matches(xfx, 1300, ==~) {
    45:             @ first = left;
    46:             @ second = right;
    47:         };
    48:         op LogicalNot(fy, 1400, !) {
    49:             @ value = right;
    50:         };
    51:         op ConditionalAnd(yfx, 1500, &&) {
    52:             @ first = left;
    53:             @ second = right;
    54:         };
    55:         op ConditionalOr(yfx, 1600, ||) {
    56:             @ first = left;
    57:             @ second = right;
    58:         };
    59:         op composite IfExpression(f, 1700) {
    60:             % if % (;
    61:             @ condition = expression;
    62:             %);
    63:             @ thenPart = expression(precedence = 1700);
    64:             % else {
    65:                 @ elsePart = expression(precedence = 1700);
    66:             } ?;
    67:         };
    68:         op composite IfExpressionCStyle(xfy,1700) {
    69:             ^ l:IfExpression {
    70:                 @ condition = left;
    71:                 % ?;
    72:                 @ thenPart = expression;
    73:                 % :;
    74:                 @ elsePart = right;
    75:             };
    76:         };
    77:         op composite Match(xf, 1700) {
    78:             @ value = left;
    79:             % match;
    80:             @ selectors += block(matchSelectors);
    81:         };
    82:         op composite Select(f) {
    83:             % select;
    84:             @ selectors += block(selectSelectors);
    85:         };
    86:         statement WhileStatement{
    87:             % while;
    88:             @ label = identifier?;
    89:             % (;
    90:             @ condition = expression;
    91:             % );
    92:             @ body = expression;
    93:         };
    94:         statement BreakStatement {
    95:             % break;
    96:             @ label = identifier?;
    97:         };
    98:         statement ContinueStatement {
    99:             % continue;
   100:             @ label = identifier?;
   101:         };
   102:         statement AssertStatement {
   103:             % assert;
   104:             @ condition = expression;
   105:             % : {
   106:                 @ message = expression;
   107:             } ?;
   108:         };
   109:     };
   110:     context Selectors {
   111:         import expressions = Expressions;
   112:         statement CasePart {
   113:             @ selector = expression(expressions);
   114:             % =>;
   115:             @ value = expression(expressions); 
   116:         };
   117:         statement ElsePart {
   118:             % else;
   119:             @ value = expression(expressions);
   120:         };
   121:     };
   122: };

  1 package calculator.interpreter.ast.logic;
  2 
  3 import calculator.interpreter.Cell;
  4 import calculator.interpreter.Environment;
  5 import calculator.interpreter.EvalUtils;
  6 import calculator.interpreter.Variable;
  7 import calculator.interpreter.ast.Expression;
  8 import calculator.interpreter.ast.Statement;
  9 
 10 /**
 11  * The while loop statement
 12  */
 13 public class WhileStatement extends Statement {
 14   /** The label for the statement (might be null) */
 15   public String label;
 16   /** The condition for the statement */
 17   public Expression condition;
 18   /** The body of the statement */
 19   public Expression body;
 20 
 21   @Override
 22   public Environment eval(Environment env, Cell result) {
 23     final Object token = new Object();
 24     Variable unnamedVar = new Variable(tokenName(null), true, location, null,
 25         null);
 26     unnamedVar.bind(location, token);
 27     Environment bodyContext = new Environment(env, unnamedVar);
 28     Variable namedVar;
 29     if (label != null) {
 30       namedVar = new Variable(tokenName(label), true, location, null, null);
 31       namedVar.bind(location, token);
 32       bodyContext = new Environment(bodyContext, namedVar);
 33     } else {
 34       namedVar = null;
 35     }
 36     try {
 37       while (EvalUtils.toBoolean(this, env, condition)) {
 38         try {
 39           body.eval(bodyContext);
 40         } catch (LoopGotoException ex) {
 41           if (ex.token != token) {
 42             throw ex;
 43           }
 44           if (ex.isBreak) {
 45             break;
 46           }
 47         }
 48       }
 49     } finally {
 50       unnamedVar.bind(location, null);
 51       if (namedVar != null) {
 52         namedVar.bind(location, null);
 53       }
 54     }
 55     return env;
 56   }
 57 
 58   /**
 59    * Generate token name for loop
 60    * 
 61    * @param label the loop label to use (or null for token without label)
 62    * @return the token name
 63    */
 64   public static String tokenName(String label) {
 65     return "$loop token " + (label == null ? "" : label);
 66   }
 67 
 68   /**
 69    * The exception that is used to break or continue the loop
 70    */
 71   @SuppressWarnings("serial")
 72   public static class LoopGotoException extends RuntimeException {
 73     /** the token for exception */
 74     public final Object token;
 75     /** if true, break requested, otherwise continue */
 76     public final boolean isBreak;
 77 
 78     /**
 79      * The constructor
 80      * 
 81      * @param token the token
 82      * @param isBreak the break/continue flag
 83      */
 84     public LoopGotoException(Object token, boolean isBreak) {
 85       super();
 86       this.token = token;
 87       this.isBreak = isBreak;
 88     }
 89   }
 90 }
 91 

  1 package calculator.interpreter.ast.logic;
  2 
  3 import calculator.interpreter.Cell;
  4 import calculator.interpreter.Environment;
  5 import calculator.interpreter.EvalException;
  6 import calculator.interpreter.Variable;
  7 import calculator.interpreter.ast.Statement;
  8 
  9 /**
 10  * The loop goto statement
 11  */
 12 public abstract class LoopGotoStatement extends Statement {
 13   /** the label of loop (may be null) */
 14   public String label;
 15 
 16   @Override
 17   public Environment eval(Environment env, Cell result) {
 18     Variable var = env.find(WhileStatement.tokenName(label));
 19     if (var == null) {
 20       throw new EvalException(this, "The break and continue statements "
 21           + "must happen only in the lexical scope of the loop.");
 22     }
 23     if (var.value == null) {
 24       throw new EvalException(this, "The break and continue statements "
 25           + "must happen only while loop is acitve.");
 26     }
 27     throw new WhileStatement.LoopGotoException(var.value, isBreak());
 28   }
 29 
 30   /**
 31    * @return true if it is break statement, false if continue
 32    */
 33   protected abstract boolean isBreak();
 34 }
 35 

  1 package calculator.interpreter.ast.logic;
  2 
  3 import net.sf.etl.parsers.TermToken;
  4 import net.sf.etl.parsers.beans.TokenCollector;
  5 import calculator.interpreter.Cell;
  6 import calculator.interpreter.Environment;
  7 import calculator.interpreter.EvalException;
  8 import calculator.interpreter.ast.Expression;
  9 import calculator.interpreter.ast.Statement;
 10 
 11 /**
 12  * The assert statement
 13  */
 14 public class AssertStatement extends Statement implements TokenCollector {
 15   /** The condition to assert */
 16   public Expression condition;
 17   /** The message to use in case of assertion failure */
 18   public Expression message;
 19   /** The text of the assert statement */
 20   private StringBuilder textBuilder = new StringBuilder();
 21   /** The text of the condition */
 22   private String conditionText;
 23 
 24   @Override
 25   public Environment eval(Environment env, Cell result) {
 26     Object c = condition.eval(env);
 27     if (!(c instanceof Boolean)) {
 28       throw new EvalException(this, "The condition " + conditionText() + " at "
 29           + condition.location.toShortString()
 30           + " did not evaluated to the boolean: " + c);
 31     }
 32     if (!(Boolean) c) {
 33       throw new EvalException(this, "The assertion " + conditionText()
 34           + " failed" + (message == null ? "." : ": " + message.eval(env)));
 35     }
 36     return env;
 37   }
 38 
 39   /**
 40    * @return the text of condition
 41    */
 42   private String conditionText() {
 43     if (conditionText == null) {
 44       int start = (int) (condition.location.start().offset() - location.start()
 45           .offset());
 46       int end = (int) (condition.location.end().offset() - location.start()
 47           .offset());
 48       conditionText = textBuilder.substring(start, end);
 49       textBuilder = null;
 50     }
 51     return conditionText;
 52   }
 53 
 54   /** {@inheritDoc} */
 55   public void collect(TermToken token) {
 56     if (token.hasLexicalToken()) {
 57       textBuilder.append(token.token().token().text());
 58     }
 59   }
 60 }
 61 

     1: doctype "calculator-logic-0_2_1.g.etl";
     2: include "prelude-vars.c.etl";

     1: doctype "calculator-logic-0_2_1.g.etl";
     2: 
     3: let dozen1 = {
     4:     var rc = 0;
     5:     var n = 12;
     6:     while outer (true) {
     7:         while(true) {
     8:             if(n < 1) {
     9:                 break outer;
    10:             } else {
    11:                 n = n - 1;
    12:                 rc = rc + 1;
    13:                 continue outer;
    14:             }; 
    15:         };
    16:     };
    17:     rc;
    18: };
    19: assert dozen1 == 12;
    20: let dozen2 = {
    21:     var a = 420;
    22:     var b = 96;
    23:     while(a != 0) {
    24:         if(a < b) {
    25:             let t = a;
    26:             a = b;
    27:             b = t;
    28:         };
    29:         a = a - b;
    30:     };
    31:     b;
    32: };
    33: 
    34: assert dozen2 == 12;
    35: assert "\\" ==~ R"\\";
    36: assert "\\abba\\" ==~ R".\w{4,}.";
    37: assert ! "\\a+ba\\" ==~ R".\w{4,}.";
    38: assert "1111" == "\x31\u0031\U31;\U0000031;";
    39: assert (if(1==2)  11) == null;
    40: assert (if(false) 11 else 11 + 11) == 22;
    41: assert (if(true)  11 else 11 + 11) == 11;
    42:  

     1: doctype public "-//IDN etl.sf.net//ETL//Grammar 0.2.1";
     2: grammar abstract calculator.CalculatorLambdaBasic {
     3:     include "calculator-logic-0_2_1.g.etl";
     4:     namespace v = "http://etl.sf.net/samples/calculator/vars";
     5:     namespace default l = "http://etl.sf.net/samples/calculator/lambda";
     6:     context abstract LetRecDefs {
     7:         def EpxressionDef {
     8:             // redefine it to refer to the correct expression
     9:             expression(Expressions);
    10:         };
    11:         def ParameterList {
    12:             @ parameters += list , {
    13:                 ^l:Parameter {
    14:                     modifiers {
    15:                         @ type = modifier var;
    16:                     };
    17:                     @ name = ref(NameDef);
    18:                 };
    19:             } ?;
    20:         };
    21:         def LetRecAssignDef {
    22:             ^v:LetRecPart {
    23:                 @ name = ref(NameDef);
    24:                 % =;
    25:                 @ value = ref(ExpressionDef);
    26:             };
    27:         };
    28:     };
    29:     context default Expressions {
    30:         include LetRecDefs;
    31:         import letRecContent = LetRecContent;
    32:         
    33:         op composite Lambda(fy, 1950) {
    34:             % \;
    35:             ref(ParameterList) | %( { ref(ParameterList); } % );
    36:             % =>;
    37:             @ value = right;
    38:         };
    39:         op composite Apply(yf, 100) {
    40:             @ function = left;
    41:             % (;
    42:             @ arguments += list , {
    43:                 expression;
    44:             } ?;
    45:             % );
    46:         };
    47:         statement LetRec {
    48:             ^ v:LetRec {
    49:                 % letrec;
    50:                 @ definitions += ref(LetRecAssignDef) | {
    51:                     block(letRecContent);
    52:                 };
    53:             };
    54:         };
    55:     };
    56:     context LetRecContent {
    57:         include LetRecDefs;
    58:         include MetaInformation;
    59:         import expressions = Expressions;
    60:         
    61:         def EpxressionDef {
    62:             expression(expressions);
    63:         };        
    64:         statement LetPart {
    65:             ref(LetRecAssignDef);
    66:         };
    67:     };
    68: };

     1: doctype public "-//IDN etl.sf.net//ETL//Grammar 0.2.1";
     2: grammar calculator.CalculatorLambda {
     3:     include "calculator-lambda-basic-0_2_1.g.etl";
     4:     namespace t = "http://etl.sf.net/samples/calculator/vars";
     5:     namespace v = "http://etl.sf.net/samples/calculator/vars";
     6:     namespace default l = "http://etl.sf.net/samples/calculator/lambda";
     7:     context abstract LetRecDefs {
     8:         def LetRecFunctionDef {
     9:             ^ v:LetRecPart {
    10:                 % to;
    11:                 @ name = ref(NameDef);
    12:                 @ value = ^l:Lambda {
    13:                     % (;
    14:                     ref(ParameterList);
    15:                     % ) % =>;
    16:                     @ value = ref(ExpressionDef);
    17:                 };
    18:             };
    19:         };        
    20:     };
    21:     context default Expressions {
    22:         include LetRecDefs;
    23:         import letRecContent = LetRecContent;
    24:         
    25:         op composite LambdaNoArgs(fy, 1950) {
    26:             ^ l:Lambda {
    27:                 % \>;
    28:                 @ value = right;
    29:             };
    30:         };        
    31:         def SequenceDef {
    32:             ^ l:LambdaSequence {
    33:                 @statements += block;
    34:             };
    35:         };
    36:         statement BlockParameters {
    37:             % ?;
    38:             ref(ParameterList);
    39:         };
    40:         statement Function {
    41:             ^v:LetRec {
    42:                 @ definitions += ref(LetRecFunctionDef);
    43:             };
    44:         };
    45:         op composite InfixOperatorAppy(yfx, 1150) {
    46:             ^ l:Apply {
    47:                 @ arguments += left;
    48:                 % #;
    49:                 @ function = expression(precedence = 99);
    50:                 @ arguments += right;
    51:             };
    52:         };        
    53:         op composite PrefixOperatorAppy(fy, 1150) {
    54:             ^ l:Apply {
    55:                 % #;
    56:                 @ function = expression(precedence = 99);
    57:                 @ arguments += right;
    58:             };
    59:         };
    60:         op composite ApplyBlock(xf, 1175) {
    61:             ^ l:Apply {
    62:                 @ function = left;
    63:                 @ arguments += ref(SequenceDef);
    64:             };
    65:         };
    66:         op composite Lazy(f, 1950) {
    67:             ^ l:Apply {
    68:                 @ function = token(&) wrapper t:Name.literal;
    69:                 @ arguments += ^ l:Lambda { 
    70:                     @value = expression(precedence=1949); 
    71:                 };
    72:             };
    73:         };
    74:         op Dereference(fy, 100, *) {
    75:             @ value = right;
    76:         };
    77:         op composite NotEqualDeref(xfx, 1300) {
    78:             ^ l:Apply {
    79:                 @ arguments += left;
    80:                 @ function = token(!*=) wrapper t:Name.literal;
    81:                 @ arguments += right;
    82:             };
    83:         };
    84:         op composite EqualDeref(xfx, 1300) {
    85:             ^ l:Apply {
    86:                 @ arguments += left;
    87:                 @ function = token(=*=) wrapper t:Name.literal;
    88:                 @ arguments += right;
    89:             };
    90:         };
    91:     };
    92:     context LetRecContent {
    93:         statement FunctionPart {
    94:             ref(LetRecFunctionDef);
    95:         };
    96:     };
    97: };

     1: doctype "calculator-lambda-0_2_1.g.etl";
     2: include "prelude-logic.c.etl";
     3: 
     4: /// The construct lazy value from the lambda abstraction
     5: ///
     6: /// @param f the function
     7: /// @return the function that remembers the result invocation of 
     8: ///         the function without arguments 
     9: let q'&' = {? var f;
    10:     assert f != null;
    11:     var value;
    12:     {?;
    13:         if(f != null) {
    14:             value = f();
    15:             f = null;
    16:         };
    17:         value;
    18:     };
    19: };
    20: /// The implementation of NotEqualDeref operator
    21: to q'!*='(x, y) =>  * x != * y;
    22: /// The implementation of EqualDeref operator
    23: to q'=*='(x, y) =>  * x == * y;
    24: 
    25: /// The maximum value (works for comparable objects)
    26: to max(x, y) => x < y ? y : x;
    27: /// The minimum value (works for comparable objects)
    28: to min(x, y) => x < y ? x : y;
    29: 
    30: /// Ensure that the number in the range of integer values.
    31: /// @param x the number to check
    32: /// @return itself (to allows variable arguments) 
    33: to assertIntRange(x) => {
    34:     assert MIN_INTEGER <= x && x <= MAX_INTEGER : "The value is "+x;
    35:     assertIntRange;
    36: };
    37: 
    38: /// Ensure that the number is the integer (there is no fractional pat).
    39: /// @param x the number to check 
    40: /// @return itself (to allows variable arguments) 
    41: to assertInt(x) => {
    42:     assertIntRange(x);
    43:     assert x % 1 == 0 : "The value is "+x;
    44:     assertInt;
    45: };
    46: 
    47: /// Ensure that the number is the non-negative integer.
    48: /// @param x the number to check 
    49: /// @return itself (to allows variable arguments) 
    50: to assertNonNegativeInt(x) => {
    51:     assertInt(x);
    52:     assert x >= 0 : "The value is "+x;
    53:     assertNonNegativeInt;
    54: };
    55: 
    56: /// The factorial value
    57: ///
    58: /// @param n the non-negative integer value
    59: /// @return the factorial result
    60: let factorial = {?n;
    61:     assertNonNegativeInt(n);
    62:     to fac(x) => x match { 0 => 1; else x * fac(x-1); };
    63:     fac(n);
    64: };
    65: 
    66: letrec {
    67:     /// Odd number check
    68:     /// 
    69:     /// @param x a non-negative integer number
    70:     /// @return true for odd numbers, false for even ones
    71:     is_odd = {?x; assertNonNegativeInt(x); x != 0 && !is_even(x-1);};
    72:     /// Even number check
    73:     /// 
    74:     /// @param x a non-negative integer number
    75:     /// @return false for odd numbers, true for even ones
    76:     to is_even(x) => {assertNonNegativeInt(x); x == 0 || is_odd(x-1);};
    77: };
    78: 
    79: /// Repeats execution of the one argument function from low to high
    80: /// adding +1 on each step until the resulting value will be higher then
    81: /// high. The example below will print numbers 1.5, 2.5, 3.5, and 4.5.
    82: /// {@example
    83: ///   1.5 #upto 5 {?i;
    84: ///      print i;
    85: ///   }; }
    86: /// 
    87: /// If the high value is greater then the low value, the cycle is never executed.
    88: ///
    89: /// @param low the start value for the loop (must be in integer range)
    90: /// @param high the limit value for the loop (must be in integer range)
    91: /// @param f the closure to use for the loop. 
    92: ///          If it returns false, the cycle is aborted, 
    93: ///          all other values are ignored.
    94: /// @return null value
    95: to upto(var low, high, f) => {
    96:     assertIntRange(low, high);
    97:     while(low<high && f(low) != false) {
    98:         low = low + 1;
    99:     };
   100: };
   101: 
   102: /// Repeats execution of the one argument function from start to limit
   103: /// adding step on each step until the resulting value will be higher or lower then
   104: /// limit (the direction depends on step's sign). 
   105: /// {@example
   106: ///   for(5,1,-0.125) {?i;
   107: ///      print i;
   108: ///   }; }
   109: /// 
   110: /// If the high value is greater then the low value, the cycle is never executed.
   111: ///
   112: /// @param start the start value for the loop (start/step must be in integer range)
   113: /// @param limit the limit value for the loop (limit/step must be in integer range)
   114: /// @param step the loop step (must ot be 0)
   115: /// @param f the closure to use for the loop. 
   116: ///          If it returns false, the cycle is aborted, 
   117: ///          all other values are ignored.
   118: /// @return null value
   119: to for(var start, limit, step, f) => {
   120:     assert step != 0;
   121:     assertIntRange(start/step, start/step);
   122:     while((step > 0 ? start<limit : start>limit) && f(start) != false) {
   123:         start = start + step;
   124:     };
   125: };
   126: 
   127: /// Convert Java number to integer
   128: @JavaMethod("java.lang.Number", "intValue")
   129: let toInt;
   130: 
   131: /// Convert a value to string
   132: @JavaMethod("java.lang.Object", "toString")
   133: let str;
   134: 
   135: @JavaMethod("java.lang.Math", "abs", "double")
   136: let abs;
   137: 
   138: @JavaMethod("java.lang.Math", "sin", "double")
   139: let sin;
   140: 
   141: @JavaMethod("java.lang.Math", "cos", "double")
   142: let cos;
   143: 
   144: /// Sign of the number
   145: ///
   146: /// @param x the floating point number to check
   147: /// @return -1, 0, or 1 depending on th sing of the number
   148: let sign = \x => select { x < 0 => -1; x > 0 => 1; else 0; };

     1: doctype "calculator-lambda-0_2_1.g.etl";
     2: 
     3: /// The special marker value used to stop computation in sum function
     4: let STOP = \x => x;
     5: /// Sum arguments up to stop marker like {@code sum(0,1,2,3,STOP)}
     6: ///
     7: /// @return the function that accumulates results.
     8: let sum = {?;
     9:     var sum = 0;
    10:     to acc(x) => if( x == STOP) {sum;} else {sum = sum + x; acc;};
    11: };
    12: /// Greatest common divisor
    13: ///
    14: /// @param a the positive integer value
    15: /// @param b the positive integer value
    16: /// @return the greatest common divisor
    17: let gcd = {? var q'a', var b;
    18:     assertInt(a,b);
    19:     assert a > 0 && b > 0;
    20:     if(a < b) {
    21:         let t = a;
    22:         a = Q'b';
    23:         b = t;
    24:     };
    25:     while(b != 0) {
    26:         a = a % b;
    27:         let t = a;
    28:         a = b;
    29:         b = t;
    30:     };
    31:     a;
    32: };
    33: 
    34: 
    35: assert 11 !*= {?; 12;};
    36: assert (\> 12) =*= (& 12);
    37: assert 12 == * (\()=> \> & max(10)(12));
    38: assert 12 == * (\()=> \> #q'&' {?;1+10+1;});
    39: assert 12 == #abs 1-13;
    40: assert 12 == sum(0,1,2,3,3,2,1,0,STOP);
    41: assert 12 == factorial(4) / 2;
    42: assert 12 == 420 #gcd 140 + 4;
    43: assert 12 == {
    44:     var s = 0;
    45:     0 #upto 4 {?i;
    46:         s = s + i;
    47:     };
    48:     s * 2;
    49: }; 
    50: assert 12 == {
    51:     var s = 0;
    52:     var n = 0;
    53:     for(14, 9.9, -0.25) {?i;
    54:         s = s + i;
    55:         n = n + 1;
    56:     };
    57:     s / n;
    58: };
    59: assert  1 == #sign 12;
    60: assert -1 == #sign -MIN_NUMBER;
    61: assert  0 == sign(12-12);
    62: assert   12 ==~ {?n; sign(n) == 1;};
    63: assert ! 12 ==~ (\n => sign(n) == -1);

  1 package calculator.interpreter;
  2 
  3 import java.util.ArrayList;
  4 import java.util.Collections;
  5 import java.util.List;
  6 import net.sf.etl.parsers.SourceLocation;
  7 
  8 /**
  9  * The function abstract class
 10  */
 11 public abstract class Function implements Matcher {
 12   /**
 13    * @return amount of arguments for this function (the function should not
 14    *         change its arity during the lifetime of this object)
 15    */
 16   public abstract int arity();
 17 
 18   /**
 19    * Apply the function, the amount of arguments must match the arity. This
 20    * method should not be invoked directly, use
 21    * {@link Function#apply(SourceLocation, Object, Object[])} instead.
 22    * 
 23    * @param location the location that requested invocation
 24    * @param args the function arguments, the implementers must not change this
 25    *          list.
 26    * @return a result of function invocation
 27    */
 28   public abstract Object apply(SourceLocation location, List<Object> args);
 29 
 30   /** {@inheritDoc} */
 31   public boolean match(SourceLocation location, Object value) {
 32     Object r = Function.apply(location, this, Collections.singletonList(value));
 33     return r instanceof Boolean && ((Boolean) r).booleanValue();
 34   }
 35 
 36   /**
 37    * Apply the function, if the amount of arguments is insufficient, return the
 38    * curried function, otherwise return the invocation result. If there are too
 39    * much of the arguments, it first applies function with available arguments
 40    * and if the result is a function, it tries to apply it with rest of the
 41    * arguments.
 42    * 
 43    * @param location the location of the node that requested evaluation
 44    * @param function the function to invoke (checked to be instance of
 45    *          {@link Function})
 46    * @param args the function arguments
 47    * @return the invocation result
 48    * @throws EvalException if there are too much of the arguments or if the
 49    *           argument {@code f} is not the function.
 50    */
 51   public static Object apply(SourceLocation location, Object function,
 52       List<Object> args) {
 53     int n = args.size();
 54     int i = 0;
 55     boolean firstApply = true;
 56     while ((i < n || n == 0 && firstApply) && function instanceof Function) {
 57       if (firstApply) {
 58         firstApply = false;
 59       }
 60       Function f = (Function) function;
 61       int a = f.arity();
 62       assert a >= 0;
 63       if (i + a > n) {
 64         function = new Function.CurriedFunction(f, args.subList(i, n));
 65       } else {
 66         function = f.apply(location, args.subList(i, i + a));
 67       }
 68       i += a;
 69     }
 70     if (i < n) {
 71       throw new EvalException(location, "The function required since "
 72           + (n - i) + " arguments are remaining "
 73           + "and found the value or the class "
 74           + (function == null ? null : function.getClass().getName()));
 75     }
 76     return function;
 77   }
 78 
 79   /**
 80    * The curried function
 81    */
 82   static class CurriedFunction extends Function {
 83     /** the wrapped function */
 84     final Function wrapped;
 85     /** the fixed arguments of the function */
 86     final List<Object> fixedArguments;
 87 
 88     /**
 89      * The constructor for the curried function
 90      * 
 91      * @param wrapped function
 92      * @param fixedArguments fixed arguments
 93      */
 94     public CurriedFunction(Function wrapped, List<Object> fixedArguments) {
 95       super();
 96       this.wrapped = wrapped;
 97       this.fixedArguments = new ArrayList<Object>(fixedArguments);
 98     }
 99 
100     /** {@inheritDoc} */
101     public Object apply(SourceLocation location, List<Object> args) {
102       ArrayList<Object> a = new ArrayList<Object>(fixedArguments.size()
103           + args.size());
104       a.addAll(fixedArguments);
105       a.addAll(args);
106       return apply(location, wrapped, a);
107     }
108 
109     /** {@inheritDoc} */
110     public int arity() {
111       return wrapped.arity() - fixedArguments.size();
112     }
113   }
114 }
115 

  1 package calculator.interpreter.annotations;
  2 
  3 import java.lang.reflect.Method;
  4 import java.lang.reflect.Modifier;
  5 import java.util.List;
  6 import net.sf.etl.parsers.SourceLocation;
  7 import calculator.interpreter.AnnotationValue;
  8 import calculator.interpreter.Environment;
  9 import calculator.interpreter.EvalException;
 10 import calculator.interpreter.EvalUtils;
 11 import calculator.interpreter.Function;
 12 import calculator.interpreter.Variable;
 13 
 14 /**
 15  * The java method annotation
 16  */
 17 public class JavaMethodAnnotation extends JavaReflectionProcessor {
 18   /** {@inheritDoc} */
 19   public void process(AnnotationValue annotation, Environment env, Variable var) {
 20     if (annotation.arguments.size() < 2) {
 21       throw new EvalException(annotation.location,
 22           "Wrong number of the arguments for annotation expected at least 2 and found "
 23               + annotation.arguments);
 24     }
 25     Class<?> c = getClass(annotation, 0);
 26     String methodName = EvalUtils.expectString(annotation.location,
 27         "the field name (the argument " + 1 + ")", annotation.arguments.get(1));
 28     Class<?>[] parameterTypes = new Class[annotation.arguments.size() - 2];
 29     for (int i = 0; i < annotation.arguments.size() - 2; i++) {
 30       parameterTypes[i] = getClass(annotation, i + 2);
 31     }
 32     try {
 33       Method method = c.getMethod(methodName, parameterTypes);
 34       var.bind(annotation.location, new MethodFunction(method));
 35     } catch (Exception e) {
 36       throw new EvalException(annotation.location, "The method " + methodName
 37           + " cannot be located: " + e);
 38     }
 39   }
 40 
 41   /**
 42    * The method based function
 43    */
 44   private static class MethodFunction extends Function {
 45     /** the method to invoke */
 46     private final Method method;
 47     /** the arity of the method */
 48     private final int arity;
 49     /** the static modifier */
 50     private final boolean isStatic;
 51 
 52     /**
 53      * The constructor
 54      * 
 55      * @param method the wrapped method
 56      */
 57     public MethodFunction(Method method) {
 58       this.method = method;
 59       isStatic = Modifier.isStatic(method.getModifiers());
 60       arity = method.getParameterTypes().length + (isStatic ? 0 : 1);
 61     }
 62 
 63     @Override
 64     public Object apply(SourceLocation location, List<Object> args) {
 65       assert args.size() == arity;
 66       Object[] a = (isStatic ? args : args.subList(1, arity)).toArray();
 67       Object t = isStatic ? null : args.get(0);
 68       try {
 69         return method.invoke(t, a);
 70       } catch (Exception e) {
 71         throw new EvalException(location, "The method " + method
 72             + " cannot be invoked: " + e);
 73       }
 74     }
 75 
 76     @Override
 77     public int arity() {
 78       return arity;
 79     }
 80 
 81   }
 82 }
 83 

  1 package calculator.interpreter.ast.lambda;
  2 
  3 import java.util.Iterator;
  4 import java.util.LinkedList;
  5 import java.util.List;
  6 import net.sf.etl.parsers.SourceLocation;
  7 import calculator.interpreter.Environment;
  8 import calculator.interpreter.Function;
  9 import calculator.interpreter.Variable;
 10 import calculator.interpreter.ast.Expression;
 11 
 12 /**
 13  * Lambda expression
 14  */
 15 public class Lambda extends Expression {
 16   /** the parameters of the lambda abstraction */
 17   public final LinkedList<Parameter> parameters = new LinkedList<Parameter>();
 18   /** the body of the lambda abstraction */
 19   public Expression value;
 20 
 21   @Override
 22   public Object eval(Environment env) {
 23     for (Parameter p : parameters) {
 24       env.checkFree(p.location, p.name.name());
 25     }
 26     return new LambdaFunction(env);
 27   }
 28 
 29   /**
 30    * The function implementation over lambda expression
 31    */
 32   private class LambdaFunction extends Function {
 33     /** The environment where lambda expression was created */
 34     final Environment environment;
 35 
 36     /**
 37      * The constructor for the function
 38      * 
 39      * @param env the environment where expression is created
 40      */
 41     public LambdaFunction(Environment env) {
 42       super();
 43       this.environment = env;
 44     }
 45 
 46     @Override
 47     public Object apply(SourceLocation location, List<Object> args) {
 48       assert arity() == args.size();
 49       Environment env = environment;
 50       Iterator<Object> ia = args.iterator();
 51       for (Iterator<Parameter> i = parameters.iterator(); i.hasNext();) {
 52         Parameter p = i.next();
 53         Object arg = ia.next();
 54         Variable var = new Variable(p.name.name(), "var".equals(p.type),
 55             p.location, null, null);
 56         var.bind(location, arg);
 57         env = new Environment(env, var);
 58       }
 59       return value.eval(env);
 60     }
 61 
 62     @Override
 63     public int arity() {
 64       return parameters.size();
 65     }
 66   }
 67 }
 68 

  1 package calculator.interpreter.ast.lambda;
  2 
  3 import calculator.interpreter.Environment;
  4 import calculator.interpreter.ast.Sequence;
  5 
  6 /**
  7  * The sequence that might include the parameter statement
  8  */
  9 public class LambdaSequence extends Sequence {
 10   /** converted expression */
 11   private Lambda converted;
 12 
 13   @Override
 14   public Object eval(Environment env) {
 15     if (statements.isEmpty() || !(statements.get(0) instanceof BlockParameters)) {
 16       return super.eval(env);
 17     } else {
 18       if (converted == null) {
 19         BlockParameters params = (BlockParameters) statements.get(0);
 20         Lambda l = new Lambda();
 21         l.location = location;
 22         l.parameters.addAll(params.parameters);
 23         Sequence s = new Sequence();
 24         s.location = location;
 25         s.statements.addAll(statements.subList(1, statements.size()));
 26         l.value = s;
 27         converted = l;
 28       }
 29       return converted.eval(env);
 30     }
 31   }
 32 }
 33 

  1 package calculator.interpreter.ast.vars;
  2 
  3 import java.util.LinkedList;
  4 import calculator.interpreter.Cell;
  5 import calculator.interpreter.Environment;
  6 import calculator.interpreter.ast.ExpressionStatement;
  7 import calculator.interpreter.ast.Statement;
  8 
  9 /**
 10  * The letrec allows defining mutually recursive definitions. It is equivalent
 11  * to a sequence of unbounded let statements followed by assignment.
 12  */
 13 public class LetRec extends Statement {
 14   /** definitions from letrec */
 15   public final LinkedList<LetRecPart> definitions = new LinkedList<LetRecPart>();
 16   /** true means that letrec parts has been already transformed */
 17   private boolean converted = false;
 18   /** transformed statements */
 19   private final LinkedList<Statement> statements = new LinkedList<Statement>();
 20 
 21   @Override
 22   public Environment eval(Environment env, Cell result) {
 23     if (!converted) {
 24       for (LetRecPart p : definitions) {
 25         VarStatement s = new VarStatement();
 26         s.location = p.location;
 27         Statement metadataSource = p.hasMetadata() ? p
 28             : this.hasMetadata() ? this : null;
 29         if (metadataSource != null) {
 30           s.annotations.addAll(metadataSource.annotations);
 31           s.documentation.addAll(metadataSource.documentation);
 32         }
 33         s.name = p.name;
 34         statements.add(s);
 35       }
 36       for (LetRecPart p : definitions) {
 37         ExpressionStatement s = new ExpressionStatement();
 38         s.location = p.location;
 39         Assignment a = new Assignment();
 40         a.location = p.location;
 41         a.first = p.name;
 42         a.second = p.value;
 43         s.value = a;
 44         statements.add(s);
 45       }
 46       converted = true;
 47     }
 48     for (Statement s : statements) {
 49       if (result != null)
 50         result.value = null;
 51       env = s.eval(env, result);
 52     }
 53     return env;
 54   }
 55 }
 56 

  1 package calculator.interpreter.ast.vars;
  2 
  3 import calculator.interpreter.Cell;
  4 import calculator.interpreter.Environment;
  5 import calculator.interpreter.EvalException;
  6 import calculator.interpreter.ast.Expression;
  7 import calculator.interpreter.ast.Statement;
  8 
  9 /**
 10  * The part of letrec statement
 11  */
 12 public class LetRecPart extends Statement {
 13   /** the name part */
 14   public Name name;
 15   /** the value part */
 16   public Expression value;
 17 
 18   @Override
 19   public Environment eval(Environment env, Cell result) {
 20     throw new EvalException(this, "This statement is available only as "
 21         + "a part of letrec statement and should not be "
 22         + "evaluated directly");
 23   }
 24 }
 25 

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <!DOCTYPE catalog
  3   PUBLIC "-//OASIS//DTD Entity Resolution XML Catalog V1.0//EN"
  4          "http://www.oasis-open.org/committees/entity/release/1.0/catalog.dtd">
  5 <catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog"
  6          prefer="public">
  7     <public publicId="-//IDN etl.sf.net//Calculator Sample 0.2.1 Grammar basic//EN"
  8             uri="calculator-basic-0_2_1.g.etl"/>
  9     <public publicId="-//IDN etl.sf.net//Calculator Sample 0.2.1 Grammar arith//EN"
 10             uri="calculator-arith-0_2_1.g.etl"/>
 11     <public publicId="-//IDN etl.sf.net//Calculator Sample 0.2.1 Grammar vars//EN"
 12             uri="calculator-vars-0_2_1.g.etl"/>
 13     <public publicId="-//IDN etl.sf.net//Calculator Sample 0.2.1 Grammar logic//EN"
 14             uri="calculator-logic-0_2_1.g.etl"/>
 15     <public publicId="-//IDN etl.sf.net//Calculator Sample 0.2.1 Grammar lambda//EN"
 16             uri="calculator-lambda-0_2_1.g.etl"/>
 17     <public publicId="-//IDN etl.sf.net//Calculator Sample 0.2.1 Grammar catalog//EN"
 18             uri="calculator-catalog-0_2_1.g.etl"/>
 19     <public publicId="-//IDN etl.sf.net//Calculator Sample 0.2.1 Grammar//EN"
 20             uri="calculator-catalog-0_2_1.g.etl"/>
 21     <public publicId="-//IDN etl.sf.net//Calculator Sample Prelude vars//EN"
 22             uri="prelude-vars.c.etl"/>
 23     <public publicId="-//IDN etl.sf.net//Calculator Sample Prelude logic//EN"
 24             uri="prelude-logic.c.etl"/>
 25     <public publicId="-//IDN etl.sf.net//Calculator Sample Prelude lambda//EN"
 26             uri="prelude-lambda.c.etl"/>
 27     <public publicId="-//IDN etl.sf.net//Calculator Sample Prelude catalog//EN"
 28             uri="prelude-catalog.c.etl"/>
 29     <public publicId="-//IDN etl.sf.net//Calculator Sample Prelude//EN"
 30             uri="prelude-catalog.c.etl"/>
 31 </catalog> 

     1: doctype public "-//IDN etl.sf.net//ETL//Grammar 0.2.1";
     2: grammar calculator.CalculatorCatalog {
     3:     include public "-//IDN etl.sf.net//Calculator Sample 0.2.1 Grammar lambda//EN";
     4:     namespace default t = "http://etl.sf.net/samples/calculator";
     5:     context default Expressions {
     6:         statement IncludeStatement {
     7:             ^t:IncludeStatementCatalog {
     8:                 % include;
     9:                 {
    10:                     @ systemId = string(quote='"');
    11:                     % public {
    12:                         @ publicId = string(quote='"');
    13:                     }?;
    14:                 } | {
    15:                     % public {
    16:                         @ publicId = string(quote='"');
    17:                     };
    18:                 };
    19:             };
    20:         };
    21:     };
    22: };
    23: 

     1: doctype "urn:publicid:-:IDN+etl.sf.net:Calculator+Sample+0.2.1+Grammar:EN"; 
     2: include public "-//IDN etl.sf.net//Calculator Sample Prelude lambda//EN";
     3: 

     1: doctype public "-//IDN etl.sf.net//Calculator Sample 0.2.1 Grammar//EN";
     2: // run all samples
     3: include "sample-basic.c.etl";
     4: include "sample-arith.c.etl";
     5: // since vars conflicts with logic over variable name, load it in the separate context
     6: { include "sample-vars.c.etl"; };
     7: include "sample-logic.c.etl";
     8: include "sample-lambda.c.etl";
     9: help is_odd;
    10: help q'!*=';

  1 package calculator.interpreter.ast;
  2 
  3 import net.sf.etl.parsers.LiteralUtils;
  4 import org.xml.sax.InputSource;
  5 
  6 /**
  7  * Redefined include statement that uses public id as well
  8  */
  9 public class IncludeStatementCatalog extends IncludeStatement {
 10   /** The public identifier */
 11   public String publicId;
 12 
 13   @Override
 14   protected InputSource createInputSource() {
 15     String resolvedSystemId = systemId == null ? null : resolveSystemId();
 16     InputSource input = new InputSource();
 17     input.setSystemId(resolvedSystemId);
 18     input.setPublicId(LiteralUtils.parseString(publicId));
 19     return input;
 20   }
 21 }
 22 

  1 package calculator.interpreter;
  2 
  3 import java.net.URL;
  4 import org.apache.xml.resolver.CatalogManager;
  5 import org.apache.xml.resolver.tools.CatalogResolver;
  6 
  7 /**
  8  * The runner that understands XML catalogs using entity resolver library
  9  */
 10 public class RunnerCatalog extends RunnerVars {
 11   /**
 12    * The collection of catalog files.
 13    */
 14   private final StringBuilder catalogs = new StringBuilder();
 15   /**
 16    * if true, the grammars catalog on the class path will be attempted to be
 17    * loaded.
 18    */
 19   private boolean loadSystemCatalog = true;
 20   /**
 21    * if true, only public identifiers will be used for the default grammars.
 22    */
 23   private boolean publicIdOnly = false;
 24   /**
 25    * The catalog resolver
 26    */
 27   private CatalogResolver resolver;
 28 
 29   @Override
 30   protected void parseArgs(String[] args) {
 31     super.parseArgs(args);
 32     // add grammars catalog if it is on classpath and it is the file
 33     if (loadSystemCatalog) {
 34       URL systemCatalog = getClass().getResource(
 35           "/calculator/grammars/catalog.xml");
 36       if (systemCatalog == null) {
 37         System.err.println("The system catalog is not on the classpath");
 38         usage();
 39       }
 40       if (!"file".equals(systemCatalog.getProtocol())) {
 41         System.err.println("Only the file protocol is suported: "
 42             + systemCatalog);
 43         usage();
 44       }
 45       if (catalogs.length() != 0) {
 46         catalogs.append(';');
 47       }
 48       catalogs.append(systemCatalog.getPath());
 49     }
 50     CatalogManager mgr = CatalogManager.getStaticManager();
 51     mgr.setCatalogFiles(catalogs.toString());
 52     mgr.setPreferPublic(true);
 53     resolver = new CatalogResolver(mgr);
 54   }
 55 
 56   @Override
 57   protected String getDefaultGrammar() {
 58     return publicIdOnly ? null : super.getDefaultGrammar();
 59   }
 60 
 61   @Override
 62   protected String getDefaultGrammarPublicId() {
 63     return "-//IDN etl.sf.net//Calculator Sample 0.2.1 Grammar "
 64         + getLanguageLevel() + "//EN";
 65   }
 66 
 67   /**
 68    * @return the resolver for the catalogs
 69    */
 70   public CatalogResolver resolver() {
 71     return resolver;
 72   }
 73 
 74   @Override
 75   protected int parseOption(String[] args, int i) {
 76     if ("-c".equals(args[i])) {
 77       // the catalog file on the command line
 78       if (i + 1 >= args.length) {
 79         System.err.println("Missing argument for -c option");
 80         usage();
 81       }
 82       if (catalogs.length() != 0) {
 83         catalogs.append(';');
 84       }
 85       catalogs.append(args[i + 1]);
 86       return i + 2;
 87     }
 88     if ("--no-system-catalog".equals(args[i])) {
 89       // disable loading of the system grammar catalog
 90       loadSystemCatalog = false;
 91       return i + 1;
 92     }
 93     if ("--no-system-default-grammar".equals(args[i])) {
 94       // disable loading of the system grammar catalog
 95       publicIdOnly = true;
 96       return i + 1;
 97     }
 98     return super.parseOption(args, i);
 99   }
100 
101   @Override
102   protected String getDefaultLanguageLevel() {
103     return "catalog";
104   }
105 
106   @Override
107   protected String optionList() {
108     return super.optionList()
109         + " [-c <catalog file>] [--no-system-catalog] [--no-system-default-grammar]";
110   }
111 
112   @Override
113   protected void optionUsage() {
114     super.optionUsage();
115     System.err.println(" -c <catalog file> - load catalog file");
116     System.err.println(" --no-system-catalog - disable loading"
117         + " system catalog");
118     System.err.println(" --no-system-default-grammar - disable providing "
119         + "system id for the default grammar");
120   }
121 
122   @Override
123   protected void createFactory() {
124     super.createFactory();
125     factory.setEntityResolver(resolver);
126   }
127 
128   /**
129    * Application entry point.
130    * 
131    * @param args application arguments
132    */
133   public static void main(String[] args) {
134     new RunnerCatalog().start(args);
135   }
136 }
137 

  1 #verbosity=10
  2 prefer=public
  3 relative-catalogs=false