Question

I have been working through the tutorial at http://bkiers.blogspot.de/2011/03/creating-your-own-programming-language.html. In short, a small language is developed that has a minimal set of arithmetic operations. “println” and “print” are directly mapped functions that call System.out.print().

From this I am trying to implement my own DSL by changing some properties of the language that has been developed in that article series. I want to make java.lang.Math accessible from within my DSL, but can’t think of a good way without having to map each function manually.

The language does not support imports whatsoever. I could introduce a new grammar rule to match Math.<function>(<parameters>).

Answer 1

You could do that by making Math a reserved word and make the following changes:

grammar additions

functionCall
  :  Identifier '(' exprList? ')'         -> ^(FUNC_CALL Identifier exprList?)
  |  Println '(' expression? ')'          -> ^(FUNC_CALL Println expression?)
  |  Print '(' expression ')'             -> ^(FUNC_CALL Print expression)
  |  Assert '(' expression ')'            -> ^(FUNC_CALL Assert expression)
  |  Size '(' expression ')'              -> ^(FUNC_CALL Size expression)
  |  Math '.' Identifier '(' exprList ')' -> ^(FUNC_CALL Math Identifier exprList) // added
  ;

// ...

Math : 'Math'; // added

tree grammar addition

functionCall returns [TLNode node]
  :  ^(FUNC_CALL Identifier exprList?)     {node = new FunctionCallNode($Identifier.text, $exprList.e, functions);}
  |  ^(FUNC_CALL Println expression?)      {node = new PrintlnNode($expression.node);}
  |  ^(FUNC_CALL Print expression)         {node = new PrintNode($expression.node);}
  |  ^(FUNC_CALL Assert expression)        {node = new AssertNode($expression.node);}
  |  ^(FUNC_CALL Size expression)          {node = new SizeNode($expression.node);}
  |  ^(FUNC_CALL Math Identifier exprList) {node = new MathCallNode($Identifier.text, $exprList.e);} // added
  ;

new Math-node class

package tl.tree;

import tl.TLValue;
import java.util.ArrayList;
import java.util.List;

public class MathCallNode implements TLNode {

    private String methodName;
    private List<TLNode> params;

    public MathCallNode(String nm, List<TLNode> ps) {
        methodName = nm;
        params = ps;
    }

    @Override
    public TLValue evaluate() {
        if(methodName.equals("sqrt")) 
            return new TLValue(Math.sqrt(params.get(0).evaluate().asDouble()));
        else if(methodName.equals("min")) 
            return new TLValue(Math.min(params.get(0).evaluate().asDouble(), params.get(1).evaluate().asDouble()));  
        // TODO implement more Math-methods
        else
            throw new RuntimeException("unknown method: Math." + methodName + "(...)");
    }
}

Now you don’t need to implement all the separate method in their own class, but will still need to check which method is invoked in the evaluate() method of MathCallNode, of course.

If you now evaluate:

println(Math.sqrt(9));
println(Math.min(9, -42));

the following will be printed:

3.0
-42.0