Package ptolemy.cg.kernel.generic.program.procedural

Class ProceduralParseTreeCodeGenerator

  • All Implemented Interfaces:
    ParseTreeCodeGenerator, ParseTreeVisitor
    Direct Known Subclasses:
    CParseTreeCodeGenerator, JavaParseTreeCodeGenerator
    public class ProceduralParseTreeCodeGenerator
extends AbstractParseTreeVisitor
implements ParseTreeCodeGenerator
    A base class visitor for parse trees of the expression language.

    A derived class would Evaluate a parse tree given a reference to its root node and generate C or Java code. It implements a visitor that visits the parse tree in depth-first order, evaluating each node and storing the result as a token in the node. Two exceptions are logic nodes and the ternary if node (the ? : construct), which do not necessarily evaluate all children nodes.

    This class has the following limitations:

    • It is a copy of ParseTreeEvaluator from data/expr and thus has lots of code for evaluating expressions, which we don't need
    • It is not properly converting types: We need to add logic to convert types.
    • The .tcl test has known failures involving nulls.
    • It does not evaluate constants.
    Since:
    Ptolemy II 10.0
    Version:
    $Id$
    Author:
    Man-Kit Leung
    See Also:
    ASTPtRootNode
    Pt.AcceptedRating:
    Red
    Pt.ProposedRating:
    Red

    • Field Detail

      • _evaluatedChildToken

        protected Token _evaluatedChildToken
        Temporary storage for the result of evaluating a child node. This is protected so that derived classes can access it.

      • _childCode

        protected java.lang.String _childCode
        The fire() method code.

      • _initializeCode

        protected java.lang.StringBuffer _initializeCode
        The initialize() method code.

      • _preinitializeCode

        protected java.lang.StringBuffer _preinitializeCode
        The preinitialize() method code.

      • _sharedCode

        protected java.lang.StringBuffer _sharedCode
        Shared code code.

      • _wrapupCode

        protected java.lang.StringBuffer _wrapupCode
        The wrapup() method code.

      • _scope

        protected ParserScope _scope
        The scope for evaluation.

      • _trace

        protected java.lang.StringBuffer _trace
        Used for debugging.

      • _depth

        protected int _depth
        The depth, used for debugging and indenting.

      • _functionMap

        protected static java.util.Map<java.lang.String,​java.lang.String> _functionMap
        The map of functions.

    • Constructor Detail

      • ProceduralParseTreeCodeGenerator

        public ProceduralParseTreeCodeGenerator​(ProgramCodeGenerator generator)
        Create a ProceduralParseTreeCodeGenerator that is used by the given code generator to generate code for expressions.
        Parameters:
        generator - The given code generator.

    • Method Detail

      • generateFireCode

        public java.lang.String generateFireCode()
        Generate code that corresponds with the fire() method.
        Specified by:
        generateFireCode in interface ParseTreeCodeGenerator
        Returns:
        The generated code.

      • generateInitializeCode

        public java.lang.String generateInitializeCode()
        Generate code that corresponds with the initialize() method.
        Returns:
        The generated code.

      • generatePreinitializeCode

        public java.lang.String generatePreinitializeCode()
        Generate code that corresponds with the preinitialize() method.
        Returns:
        The generated code.

      • generateSharedCode

        public java.lang.String generateSharedCode()
        Generate shared code.
        Returns:
        The generated code.

      • generateWrapupCode

        public java.lang.String generateWrapupCode()
        Generate code that corresponds with the wrapup() method.
        Returns:
        The generated code.

      • escapeForTargetLanguage

        public java.lang.String escapeForTargetLanguage​(java.lang.String string)
        Given a string, escape special characters as necessary. For C and Java, we do: 
          \\ becomes \\\\
  which means:
  \{ becomes \\{
  \} becomes \\}
  \( becomes \\(
  \) becomes \\)
  and
  \\" becomes \"
  newline becomes \n
        Specified by:
        escapeForTargetLanguage in interface ParseTreeCodeGenerator
        Parameters:
        string - The string to escape.
        Returns:
        A new string with special characters replaced.
        See Also:
        StringUtilities.escapeForXML(String)

      • visitFunctionApplicationNode

        public void visitFunctionApplicationNode​(ASTPtFunctionApplicationNode node)
                                  throws IllegalActionException
        Apply a function to the children of the specified node. This also handles indexing into matrices and arrays, which look like function calls. In the simplest cases, if the function is being applied to an expression that evaluated to a FunctionToken, an ArrayToken, or a MatrixToken, then the function application is simply applied to the available arguments. More complex is if the function is being applied to an expression that does not evaluate as above, resulting in three cases: Of primary interest is a function node that represents the invocation of a Java method registered with the expression parser. This method uses the reflection mechanism in the CachedMethod class to find the correct method, based on the types of the arguments and invoke it. See that class for information about how method arguments are matched. A second case is the eval() function, which is handled specially in this method. The argument to the function is evaluated, and the parsed as a string using the expression parser. The result is then evaluated *in this evaluator*. This has the effect that any identifiers are evaluated in the same scope as the original expression. A third case is the matlab() function, which is also handled specially in this method, allowing the evaluation of expressions in matlab if matlab is installed. The format of the function is covered in MatlabUtilities.evaluate(String, Set, ParserScope) .
        Specified by:
        visitFunctionApplicationNode in interface ParseTreeVisitor
        Overrides:
        visitFunctionApplicationNode in class AbstractParseTreeVisitor
        Parameters:
        node - The specified node.
        Throws:
        IllegalActionException - If an parse error occurs.

      • _assert

        protected void _assert​(boolean flag,
                       ASTPtRootNode node,
                       java.lang.String message)
        Assert that the given boolean value, which describes the given parse tree node, is true. If it is false, then throw a new InternalErrorException that describes the node and includes the given message.
        Parameters:
        flag - The flag that is asserted to be true.
        node - The node on which the assertion is asserted.
        message - The message to include in the exception.
        Throws:
        InternalErrorException - If the assertion is violated. Note that this is a runtime exception, so it need not be declared explicitly.

      • _codeGenType

        protected java.lang.String _codeGenType​(Type ptType)
        Get the corresponding type in code generation from the given Ptolemy type.
        Parameters:
        ptType - The given Ptolemy type.
        Returns:
        The code generation type.

      • _evaluateAllChildren

        protected Token[] _evaluateAllChildren​(ASTPtRootNode node)
                                throws IllegalActionException
        Loop through all of the children of this node, visiting each one of them; this will cause their token value to be determined.
        Parameters:
        node - The node whose children are evaluated.
        Returns:
        The array of resulting tokens.
        Throws:
        IllegalActionException - If an parse error occurs.

      • _evaluateArrayIndex

        protected void _evaluateArrayIndex​(ASTPtRootNode node,
                                   Token value,
                                   Type type)
                            throws IllegalActionException
        Evaluate the array index operation represented by the given node.
        Parameters:
        node - The node that caused this method to be called.
        value - The token that is being indexed into, which must be an ArrayToken.
        type - The element type.
        Throws:
        IllegalActionException - If an parse error occurs.

      • _evaluateChild

        protected Token _evaluateChild​(ASTPtRootNode node,
                               int i)
                        throws IllegalActionException
        Evaluate the child with the given index of the given node. This is usually called while visiting the given node.
        Parameters:
        node - The given node.
        i - The given index.
        Returns:
        The resulting token.
        Throws:
        IllegalActionException - If an parse error occurs.

      • _powCall

        protected java.lang.String _powCall​(java.lang.String x,
                                    java.lang.String y)
        Return the string for the the pow() call.
        Parameters:
        x - The first argument for pow().
        y - The second argument for pow().
        Returns:
        The string to invoke the pow() function.

      • _specializeArgument

        protected java.lang.String _specializeArgument​(java.lang.String function,
                                               int argumentIndex,
                                               Type argumentType,
                                               java.lang.String argumentCode)
        Specialize an argument of a function. The function "$arrayRepeat" is handled specially here.
        Parameters:
        function - The function
        argumentIndex - The index of the argument to be specialized
        argumentType - The type of the the argument.
        argumentCode - The code for the argument.
        Returns:
        the specialized return value.

      • _specializeReturnValue

        protected java.lang.String _specializeReturnValue​(java.lang.String function,
                                                  Type returnType,
                                                  java.lang.String returnCode)
        Specialize the return value of a function. The function "$arraySum" is handled specially here.
        Parameters:
        function - The function
        returnType - The return type of the function
        returnCode - If the function is "$arraySum", and the return type is primitive, then the value of the returnCode parameter is returned with the payload and codeGen type returned. Otherwise, just the returnCode is returned.
        Returns:
        the specialized return value.

      • _trace

        protected void _trace​(java.lang.String string)
        Add a record to the current trace corresponding to the given message. If the trace is null, do nothing.
        Parameters:
        string - The given message.

      • _traceEnter

        protected void _traceEnter​(ASTPtRootNode node)
        Add a record to the current trace corresponding to the start of the evaluation of the given node. If the trace is null, then do nothing.
        Parameters:
        node - The given node.

      • _traceLeave

        protected void _traceLeave​(ASTPtRootNode node)
        Add a record to the current trace corresponding to the completion of the evaluation of the given node. If the trace is null, then do nothing.
        Parameters:
        node - The given node.