예제 #1
0
        /// <summary>
        /// Initializes a new instance of <see cref="Case"/> AST node.
        /// </summary>
        /// <param name="expression">The target expression of the case node.</param>
        /// <param name="caseList">Series of cases for the case node.</param>
        public Case(Node expression, ExpressionList caseList)
        {
            this.expression = expression;
            this.caseList = caseList;

            NormalizeCases();
        }
예제 #2
0
 /// <summary>
 /// Initializes a new instance of <see cref="UserDefFunction"/> AST node.
 /// </summary>
 /// <param name="name">The name of the user defined function.</param>
 /// <param name="parameters">The parameters for the user defined function.</param>
 /// <param name="codeblock">The codeblock for the user defined function.</param>
 /// <param name="code">The string representation of the user defined function.</param>
 public UserDefFunction(Identifier name, ExpressionList parameters, Node codeblock, string code)
 {
     this.name = name;
     this.parameters = parameters;
     this.codeblock = codeblock;
     this.code = code;
 }
예제 #3
0
 /// <summary>
 /// Initializes a new instance of <see cref="Dependency"/> AST node.
 /// </summary>
 /// <param name="variable">The name of the dependency definition.</param>
 /// <param name="functionBody">The body of the dependency definition.</param>
 /// <param name="codeText">The string representation of the dependency defintion.</param>
 /// <param name="variables">The variables associated with the dependency definition.</param>
 public Dependency(Identifier variable, Node functionBody, string codeText, Variables variables)
 {
     this.variable = variable;
     this.functionBody = functionBody;
     this.codeText = codeText;
     this.variables = variables;
 }
예제 #4
0
        /// <summary>
        /// Initializes a new instance of <see cref="DyadicFunction"/> AST node.
        /// </summary>
        /// <param name="token">The <see cref="Token"/> to use for the dyadic function.</param>
        /// <param name="leftExpression">The left hand argument of the dyadic function.</param>
        /// <param name="rightExpression">The right hand argument of the dyadic function.</param>
        public DyadicFunction(Token token, Node leftExpression, Node rightExpression)
        {
            this.token = token;
            this.leftExpression = leftExpression;
            this.rightExpression = rightExpression;

            MethodChooser.ConvertToDyadicToken(this.token);
        }
예제 #5
0
        public static void CreateDotFile(Node input, string outputFileName)
        {
            text.Append("digraph APlus {\n");
            ToDot("", input);
            text.Append("\n}");

            using (StreamWriter writer = new StreamWriter(new FileStream(outputFileName, FileMode.Create)))
            {
                writer.Write(text);
            }
        }
예제 #6
0
        public static AST.Node ASCIIString(string input, FunctionInformation functionInfo)
        {
            Antlr.Runtime.Lexer lexer  = new Grammar.Ascii.AplusLexer(new ANTLRStringStream(input ?? ""));
            Grammar.AplusParser parser = new Grammar.AplusParser(new CommonTokenStream(lexer));
            parser.FunctionInfo = functionInfo;

            bool parseOk = parser.Parse();

            AST.Node tree = parser.Tree;

            return(tree);
        }
예제 #7
0
        public DLR.Expression <System.Func <Runtime.Aplus, AType> > ParseToLambda(string code)
        {
            AplusScope scope = new AplusScope(null, "__top__", this.aplus,
                                              DLR.Expression.Parameter(typeof(Aplus), "__aplusRuntime__"),
                                              DLR.Expression.Parameter(typeof(DYN.IDynamicMetaObjectProvider), "__module__")
                                              );

            FunctionInformation funcionInfo = new FunctionInformation(this.aplus.CurrentContext);

            if (this.aplus.Context != null)
            {
                funcionInfo.LoadInfo((this.aplus.Context as Scope).Storage as ScopeStorage);
            }

            DLR.Expression codebody = null;
            AST.Node       tree     = Compiler.Parse.String(code, this.aplus.LexerMode, funcionInfo);

            if (tree == null)
            {
                codebody = DLR.Expression.Constant(null);
            }
            else
            {
                codebody = DLR.Expression.Block(
                    new DLR.ParameterExpression[] { scope.ModuleExpression },
                    DLR.Expression.Assign(
                        scope.ModuleExpression, DLR.Expression.PropertyOrField(scope.RuntimeExpression, "Context")
                        ),
                    tree.Generate(scope)
                    );
            }

            DLR.Expression <System.Func <Aplus, AType> > method =
                DLR.Expression.Lambda <Func <Aplus, AType> >(
                    codebody,
                    scope.RuntimeExpression
                    );
            return(method);
        }
예제 #8
0
 /// <summary>
 /// Builds a <see cref="While"/> node.
 /// </summary>
 /// <param name="expression">The expression for the <see cref="While"/> node.</param>
 /// <param name="codeBlock">The codeblock for the node.</param>
 /// <returns>Returns a <see cref="While"/> AST node.</returns>
 public static While While(Node expression, Node codeBlock)
 {
     return new While(expression, codeBlock);
 }
예제 #9
0
 /// <summary>
 /// Builds a <see cref="MonadicDo"/> node.
 /// </summary>
 /// <param name="codeblock">The codeblock for the monadic do.</param>
 /// <returns>Returns a <see cref="MonadicDo"/> node.</returns>
 public static MonadicDo MonadicDo(Node codeblock)
 {
     return new MonadicDo(codeblock);
 }
예제 #10
0
 /// <summary>
 /// Build a AST node representing an assignment.
 /// </summary>
 /// <param name="target">The target of the assignment.</param>
 /// <param name="expression">The value of the assignment.</param>
 /// <returns><see cref="Assign">Assignment</see> AST node.</returns>
 public static Assign Assign(Node target, Node expression)
 {
     return new Assign(target, expression);
 }
예제 #11
0
 /// <summary>
 /// Initializes a new instance of <see cref="DyadicDo"/> AST node.
 /// </summary>
 /// <param name="expression">The start expression of the dyadic do.</param>
 /// <param name="codeblock">The codeblock of the dyadic do.</param>
 public DyadicDo(Node expression, Node codeblock)
 {
     this.expression = expression;
     this.codeblock = codeblock;
 }
예제 #12
0
 /// <summary>
 /// Normalizes the cases. Sets the default case based on the number of cases.
 /// </summary>
 private void NormalizeCases()
 {
     if (this.caseList.Length % 2 == 1)
     {
         // odd number of cases, the last one is the default case
         this.defaultCase = this.caseList.Items.Last.Value;
         this.caseList.Items.RemoveLast();
     }
     else
     {
         // there is no default case, add a Null (by definition) as default
         this.defaultCase = Node.NullConstant();
     }
 }
 public static UserDefOperatorInvoke UserDefOperatorInvoke(Identifier name, Node condition)
 {
     UserDefOperatorInvoke userOp = new UserDefOperatorInvoke(name);
     userOp.Condition = condition;
     return userOp;
 }
예제 #14
0
 /// <summary>
 /// Test if the <see cref="Node"/> is a <see cref="MonadicFunction"/> node with the specified token type.
 /// </summary>
 /// <param name="node">The <see cref="Node"/> to check.</param>
 /// <param name="tokenType">The <see cref="Tokens">token type</see> to check for.</param>
 /// <remarks>
 /// True if the <see cref="Node"/> is a 
 /// <see cref="MonadicFunction"/> with the given <see cref="Tokens">token type</see>.
 /// Otherwise false.
 /// </remarks>
 internal static bool TestMonadicToken(Node node, Tokens tokenType)
 {
     return (node is MonadicFunction) && (((MonadicFunction)node).Token.Type == tokenType);
 }
예제 #15
0
 /// <summary>
 /// Add the <see cref="Node"/> as the last item to the <see cref="ExpressionList"/>.
 /// </summary>
 /// <param name="item">The <see cref="Node"/> to add.</param>
 public void AddLast(Node item)
 {
     this.nodeList.AddLast(item);
 }
예제 #16
0
        private static string ToDot(string parent, Node node)
        {
            string result;

            switch (node.NodeType)
            {
                case NodeTypes.Assign:
                    result = ToDot(parent, (Assign)node);
                    break;
                case NodeTypes.BuiltInFunction:
                    result = ToDot(parent, (BuiltInFunction)node);
                    break;
                case NodeTypes.BuiltInOperator:
                    result = ToDot(parent, (BuiltInOperator)node);
                    break;
                case NodeTypes.Case:
                    result = ToDot(parent, (Case)node);
                    break;
                case NodeTypes.Constant:
                    result = ToDot(parent, (Constant)node);
                    break;
                case NodeTypes.ConstantList:
                    result = ToDot(parent, (ConstantList)node);
                    break;
                case NodeTypes.Dependency:
                    result = ToDot(parent, (Dependency)node);
                    break;
                case NodeTypes.DyadicDo:
                    result = ToDot(parent, (DyadicDo)node);
                    break;
                case NodeTypes.DyadicFunction:
                    result = ToDot(parent, (DyadicFunction)node);
                    break;
                case NodeTypes.EachOperator:
                    result = ToDot(parent, (EachOperator)node);
                    break;
                case NodeTypes.ExpressionList:
                    result = ToDot(parent, (ExpressionList)node);
                    break;
                case NodeTypes.Identifier:
                    result = ToDot(parent, (Identifier)node);
                    break;
                case NodeTypes.If:
                    result = ToDot(parent, (If)node);
                    break;
                case NodeTypes.Indexing:
                    result = ToDot(parent, (Indexing)node);
                    break;
                case NodeTypes.MonadicDo:
                    result = ToDot(parent, (MonadicDo)node);
                    break;
                case NodeTypes.MonadicFunction:
                    result = ToDot(parent, (MonadicFunction)node);
                    break;
                case NodeTypes.RankOperator:
                    result = ToDot(parent, (RankOperator)node);
                    break;
                case NodeTypes.Strand:
                    result = ToDot(parent, (Strand)node);
                    break;
                case NodeTypes.SystemCommand:
                    result = ToDot(parent, (SystemCommand)node);
                    break;
                case NodeTypes.Token:
                    result = ToDot(parent, (Token)node);
                    break;
                case NodeTypes.UserDefFunction:
                    result = ToDot(parent, (UserDefFunction)node);
                    break;
                case NodeTypes.UserDefOperator:
                    result = ToDot(parent, (UserDefOperator)node);
                    break;
                case NodeTypes.UserDefInvoke:
                    result = ToDot(parent, (UserDefInvoke)node);
                    break;
                case NodeTypes.While:
                    result = ToDot(parent, (While)node);
                    break;
                default:
                    throw new Exception("Type");
            }

            return result;
        }
예제 #17
0
 /// <summary>
 ///  Initializes a new instance of <see cref="While"/> AST Node.
 /// </summary>
 /// <param name="expression">The expression for the node.</param>
 /// <param name="codeBlock">The codeblock of the node.</param>
 public While(Node expression, Node codeBlock)
 {
     this.expression = expression;
     this.codeBlock = codeBlock;
 }
예제 #18
0
 /// <summary>
 /// Builds a <see cref="Case"/> node.
 /// </summary>
 /// <param name="expression">The target expression of the <see cref="Case"/> node.</param>
 /// <param name="caseList">Series of cases for the <see cref="Case"/> node.</param>
 /// <returns>Returns the <see cref="Case"/> node.</returns>
 public static Case Case(Node expression, ExpressionList caseList)
 {
     return new Case(expression, caseList);
 }
예제 #19
0
 /// <summary>
 /// Build a <see cref="DyadicFunction"/> using the given arguments.
 /// </summary>
 /// <param name="token">The <see cref="Token"/> to use for the dyadic function.</param>
 /// <param name="leftExpression">The left hand argument of the dyadic function.</param>
 /// <param name="rightExpression">The right hand argument of the dyadic function.</param>
 /// <returns>Returns a <see cref="DyadicFunction"/> representing a built-in function.</returns>
 public static Node DyadicFunction(Token token, Node leftExpression, Node rightExpression)
 {
     return new DyadicFunction(token, leftExpression, rightExpression);
 }
예제 #20
0
 /// <summary>
 /// Builds a <see cref="Node"/> representing an indexing expression.
 /// </summary>
 /// <param name="item">The target of the indexing.</param>
 /// <param name="indexExpression">The indexer expressions.</param>
 /// <returns>Returns a <see cref="Indexing"/> AST node.</returns>
 public static Indexing Indexing(Node item, ExpressionList indexExpression)
 {
     return new Indexing(item, indexExpression);
 }
예제 #21
0
 /// <summary>
 /// Builds a <see cref="DyadicDo"/> node.
 /// </summary>
 /// <param name="expression">The start expression for the dyadic do.</param>
 /// <param name="codeblock">The codeblock for the dyadic do.</param>
 /// <returns>Returns the <see cref="DyadicDo"/> node.</returns>
 public static DyadicDo DyadicDo(Node expression, Node codeblock)
 {
     return new DyadicDo(expression, codeblock);
 }
예제 #22
0
 public static RankOperator RankOperator(Node function, Node condition)
 {
     return new RankOperator(function, condition);
 }
예제 #23
0
        public override DLR.Expression Generate(AplusScope scope)
        {
            Aplus runtime = scope.GetRuntime();

            LinkedList<DLR.Expression> result = new LinkedList<DLR.Expression>();

            DLR.ParameterExpression scalar = DLR.Expression.Parameter(typeof(AType), "_ScalarResult_");
            DLR.ParameterExpression counter = DLR.Expression.Parameter(typeof(int), "COUNTER");
            DLR.ParameterExpression exitValue = DLR.Expression.Parameter(typeof(int), "EXITVALUE");

            DLR.LabelTarget exitLabel = DLR.Expression.Label(typeof(AType), "EXIT");
            DLR.ParameterExpression returnValue = DLR.Expression.Parameter(typeof(AType), "RETURN");

            bool incrementMode = true;
            if (this.expression is MonadicFunction &&
                ((MonadicFunction)this.expression).Token.Type == Tokens.EXPONENTIAL)
            {
                // Change the counter's 'way'
                incrementMode = false;
                // Remove the Exponential function
                this.expression = ((MonadicFunction)this.expression).Expression;
            }

            if (this.expression is Assign && ((Assign)this.expression).Target is Identifier)
            {
                scope.IsAssignment = true;
                result.AddFirst(this.expression.Generate(scope));
                scope.IsAssignment = false;

                // Remove the assignment and leave the identifier only
                this.expression = ((Assign)this.expression).Target;
            }

            // Save the previous return target
            DLR.LabelTarget oldTarget = scope.ReturnTarget;

            // Add an return target for the scope
            // this will allow the usage of the Result monadic function
            scope.ReturnTarget = exitLabel;

            if (this.expression is Identifier)
            {
                // Found a case like: VAR do { ... }

                Identifier variable = (Identifier)this.expression;
                // Generate a .Dynamic.Get DLR tree (used multiple times so this saves time)
                DLR.Expression variableGenerated = variable.Generate(scope);
                DLR.Expression variableAsFloat = DLR.Expression.Property(scalar, "asFloat");

                result.AddLast(DLR.Expression.Block(
                    new DLR.ParameterExpression[] { counter, exitValue, returnValue, scalar },
                    // Test if the constant is an integer
                    DomainTest(variableGenerated, scalar),

                    DLR.Expression.Assign(exitValue,
                        (incrementMode ?
                    // EXITVALUE = round(variable.asFloat)
                        (DLR.Expression)FloatRounding(variableAsFloat) :
                    // EXITVALUE = 0
                        (DLR.Expression)DLR.Expression.Constant(0, typeof(int))
                        )
                    ),
                    DLR.Expression.Assign(
                        counter,
                        (incrementMode ?
                        (DLR.Expression)DLR.Expression.Constant(0, typeof(int)) :
                        (DLR.Expression)DLR.Expression.Decrement(FloatRounding(variableAsFloat))
                        )
                    ),

                    // Start the loop
                    DLR.Expression.Loop(
                        DLR.Expression.Block(
                            AST.Assign.GenerateIdentifierAssign(
                                scope,
                                variable,
                                DLR.Expression.Call(typeof(LocalAInteger).GetMethod("Create"), counter),
                                false,
                                false
                            ),
                            DLR.Expression.IfThen(
                                (incrementMode ?
                    // Check if  variable >= EXITVALUE  is true
                                    DLR.Expression.GreaterThanOrEqual(
                                        counter,
                    //DLR.Expression.Property(variableGenerated, "asInteger"),
                                        exitValue
                                    ) :
                    // Check if  EXITVALUE(0) > variable  is true
                                    DLR.Expression.GreaterThan(
                                        exitValue,
                    //DLR.Expression.Property(variableGenerated, "asInteger")
                                        counter
                                    )
                                ),
                    // The expression was true, exit from the loop with the last value of the expression block
                                DLR.Expression.Break(exitLabel, returnValue)
                            ),

                    // Otherwise run the inner codeblock
                            DLR.Expression.Assign(returnValue, this.codeblock.Generate(scope)),

                    // Update counter
                            (incrementMode ?
                    // ++counter
                                DLR.Expression.PreIncrementAssign(counter) :
                    // --counter
                                DLR.Expression.PreDecrementAssign(counter)
                            )

                        ),
                        exitLabel
                    )
                ));

            }
            else
            {

                // Simple Iteration
                DLR.ParameterExpression temp = DLR.Expression.Parameter(typeof(AType), "TMP");

                result.AddLast(DLR.Expression.Block(
                    new DLR.ParameterExpression[] { temp, counter, exitValue, returnValue, scalar },
                    // Save the iteration count into a temporaly variable
                    DLR.Expression.Assign(temp, this.expression.Generate(scope)),
                    // Test if the constant is an integer
                    DomainTest(temp, scalar),
                    // MAXVALUE = temp.asInteger
                    DLR.Expression.Assign(exitValue, FloatRounding(DLR.Expression.Property(scalar, "asFloat"))),
                    // counter = 0
                    DLR.Expression.Assign(counter, DLR.Expression.Constant(0, typeof(int))),
                    // Start the loop
                    DLR.Expression.Loop(
                        DLR.Expression.Block(
                    // Check if  counter >= MAXVALUE  is true
                            DLR.Expression.IfThen(
                                DLR.Expression.GreaterThanOrEqual(counter, exitValue),
                    // The expression was true, exit from the loop with the last calculated value
                                DLR.Expression.Break(exitLabel, returnValue)
                            ),
                    // Otherwise run the inner codeblock, save the block's result
                            DLR.Expression.Assign(returnValue, this.codeblock.Generate(scope)),
                    // Increment the counter
                            DLR.Expression.PreIncrementAssign(counter)
                        ),
                        exitLabel
                    )
                ));
            }

            // Restore the return target
            scope.ReturnTarget = oldTarget;

            return DLR.Expression.Block(result);
        }
예제 #24
0
 public void AddFalseCase(Node falseCase)
 {
     this.falseCase = falseCase;
 }
예제 #25
0
 /// <summary>
 /// Initializes a new instance of <see cref="Indexing"/> AST node.
 /// </summary>
 /// <param name="item">The target of the indexing.</param>
 /// <param name="indexExpression">The indexer expressions.</param>
 public Indexing(Node item, ExpressionList indexExpression)
 {
     this.item = item;
     this.indexExpression = indexExpression;
 }
예제 #26
0
 /// <summary>
 /// Initializes a new instance of <see cref="UserDefOperator"/> AST node.
 /// </summary>
 /// <param name="name">The name of the user defined operator.</param>
 /// <param name="function">The function parameter of the user defined operator.</param>
 /// <param name="codeblock">The code block of the user defined operator.</param>
 /// <param name="codeText">The string representation of the user defined operator.</param>
 public UserDefOperator(Identifier name, Identifier function, Node codeblock, string codeText)
 {
     this.name = name;
     this.function = function;
     this.codeblock = codeblock;
     this.codeText = codeText;
 }
예제 #27
0
 public RankOperator(Node function, Node condition)
     : base(function)
 {
     this.condition = condition;
 }
예제 #28
0
        /// <summary>
        /// Builds a <b>monadic</b> user defined operator with a <b>monadic</b> derived function.
        /// </summary>
        /// <remarks>
        /// Builds a representation of a <see cref="UserDefOperator"/> of the following structure:
        /// <example>
        /// (f OP) b: { ... }
        /// </example>
        /// </remarks>
        /// <param name="name">The name of the user defined operator.</param>
        /// <param name="function">The name of the function in the user defined operator.</param>
        /// <param name="argument">The name of the monadic argument of the user defined operator.</param>
        /// <param name="codeblock">The codeblock of the user defined operator.</param>
        /// <param name="codeText">The string representation of the user defined operator.</param>
        /// <returns>Returns a monadic case of <see cref="UserDefOperator"/> AST node.</returns>
        public static UserDefOperator MonadicUserDefOperator(
            Identifier name,
            Identifier function,
            Identifier argument,
            Node codeblock, string codeText = "")
        {

            UserDefOperator result = new UserDefOperator(name, function, codeblock, codeText)
            {
                RightArgument = argument
            };

            return result;
        }
예제 #29
0
 /// <summary>
 /// Initializes a new instance of <see cref="Assign"/> AST node.
 /// </summary>
 /// <param name="target">The target of the assignment.</param>
 /// <param name="expression">The value of the assignment.</param>
 public Assign(Node target, Node expression)
 {
     this.target = target;
     this.expression = expression;
 }
예제 #30
0
        /// <summary>
        /// Builds a <b>dyadic</b> user defined operator with a <b>monadic</b> derived function.
        /// </summary>
        /// <remarks>
        /// Builds a representation of a <see cref="UserDefOperator"/> of the following structure:
        /// <example>
        /// (f OP h) b: { ... }
        /// </example>
        /// </remarks>
        /// <param name="name">The name of the user defined operator.</param>
        /// <param name="function">The name of the function in the user defined operator.</param>
        /// <param name="condition">The name of the condition in the user defined operator.</param>
        /// <param name="argument">The name of the monadic argument of the user defined operator.</param>
        /// <param name="codeblock">The codeblock of the user defined operator.</param>
        /// <param name="codeText">The string representation of the user defined operator.</param>
        /// <returns>Returns a dyadic case of <see cref="UserDefOperator"/> AST node.</returns>
        public static UserDefOperator DyadicUserDefOperator(
            Identifier name,
            Identifier function, Identifier condition,
            Identifier argument,
            Node codeblock, string codeText = "")
        {
            UserDefOperator result = MonadicUserDefOperator(name, function, argument, codeblock, codeText);
            result.Condition = condition;

            return result;
        }
예제 #31
0
 /// <summary>
 /// Initializes a new instance of <see cref="MonadicDo"/> AST node.
 /// </summary>
 /// <param name="codeblock">The codeblock for the monadic do.</param>
 public MonadicDo(Node codeblock)
 {
     this.codeblock = codeblock;
 }
예제 #32
0
        /// <summary>
        /// Builds a <b>dyadic</b> user defined operator with a <b>dyadic</b> derived function.
        /// </summary>
        /// <remarks>
        /// Builds a representation of a <see cref="UserDefOperator"/> of the following structure:
        /// <example>
        /// a (f OP h) b: { ... }
        /// </example>
        /// </remarks>
        /// <param name="name">The name of the user defined operator.</param>
        /// <param name="function">The name of the function in the user defined operator.</param>
        /// <param name="condition">The name of the condition in the user defined operator.</param>
        /// <param name="leftArgument">The name of left argument of the user defined operator.</param>
        /// <param name="rightArgument">The name of the right argument of the user defined operator.</param>
        /// <param name="codeblock">The codeblock of the user defined operator.</param>
        /// <param name="codeText">The string representation of the user defined operator.</param>
        /// <returns>Returns a dyadic case of <see cref="UserDefOperator"/> AST node.</returns>
        public static UserDefOperator DyadicUserDefOperator(
            Identifier name,
            Identifier function, Identifier condition,
            Identifier leftArgument, Identifier rightArgument,
            Node codeblock, string codeText = "")
        {
            UserDefOperator result = DyadicUserDefOperator(name, function, condition, rightArgument, codeblock, codeText);
            result.LeftArgument = leftArgument;

            return result;
        }