Ejemplo n.º 1
0
        public override void Compile(Emitter.Emitter emitter)
        {
            var leftType = Left.GetExpressionType(emitter);
              var rightType = Right.GetExpressionType(emitter);

              var type = GetExpressionType(emitter);

              // subtract matrices
              if(type == "matrix")
              {
            Left.Compile(emitter);
            Right.Compile(emitter);

            var matrixType = typeof(MN.Matrix<double>);
            var method = emitter.AssemblyImport(matrixType.GetMethod("Subtract", new [] { matrixType } ));
            emitter.EmitCall(method);
              }

              // subtract dicts
              else if (type == "dict")
              {
            Left.Compile(emitter);
            Right.Compile(emitter);

            var dictType = typeof(Dict);
            var method = emitter.AssemblyImport(dictType.GetMethod("Subtract", new[] { dictType }));
            emitter.EmitCall(method);
              }

              // subtract complex numbers
              else if (type == "complex")
              {
            Left.Compile(emitter);
            if (leftType != "complex")
            {
              emitter.EmitUpcastBasicType(leftType, "float");
              emitter.EmitLoadFloat(0);
              emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
            }

            Right.Compile(emitter);
            if (rightType != "complex")
            {
              emitter.EmitUpcastBasicType(rightType, "float");
              emitter.EmitLoadFloat(0);
              emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
            }

            emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("op_Subtraction", new[] { typeof(SN.Complex), typeof(SN.Complex) })));
              }
              // add floating point numbers or integers
              else if (type.IsAnyOf("int", "float"))
              {
            Left.Compile(emitter);
            emitter.EmitUpcastBasicType(leftType, type);
            Right.Compile(emitter);
            emitter.EmitUpcastBasicType(rightType, type);
            emitter.EmitSub();
              }
        }
Ejemplo n.º 2
0
        public override void Compile(Emitter.Emitter emitter)
        {
            var leftType = Left.GetExpressionType(emitter);
              var rightType = Right.GetExpressionType(emitter);

              var type = GetExpressionType(emitter);

              // divide matrix by a number
              if(type == "matrix")
              {
            Left.Compile(emitter);

            // division is broken, therefore multiply by an inverse value
            emitter.EmitLoadFloat(1);
            Right.Compile(emitter);

            if (rightType != "float")
              emitter.EmitConvertToFloat();

            emitter.EmitDiv();

            var matrixType = typeof(MN.Matrix<double>);
            var method = emitter.AssemblyImport(matrixType.GetMethod("Multiply", new[] { typeof(double) }));
            emitter.EmitCall(method);
              }

              // divide complex numbers
              else if (type == "complex")
              {
            Left.Compile(emitter);
            if (leftType != "complex")
            {
              emitter.EmitUpcastBasicType(leftType, "float");
              emitter.EmitLoadFloat(0);
              emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
            }

            Right.Compile(emitter);
            if (rightType != "complex")
            {
              emitter.EmitUpcastBasicType(rightType, "float");
              emitter.EmitLoadFloat(0);
              emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
            }

            emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("op_Division", new[] { typeof(SN.Complex), typeof(SN.Complex) })));
              }

              // divide floating point numbers or integers
              else if (type.IsAnyOf("int", "float"))
              {
            Left.Compile(emitter);
            emitter.EmitUpcastBasicType(leftType, type);
            Right.Compile(emitter);
            emitter.EmitUpcastBasicType(rightType, type);
            emitter.EmitDiv();
              }
        }
Ejemplo n.º 3
0
        public override void Compile(Emitter.Emitter emitter)
        {
            var type = Expression.GetExpressionType(emitter);
              if (type.IsAnyOf("int", "float", "complex"))
              {
            if(type == "complex")
            {
              // simple case: the complex is a constant
              if(Expression is ComplexNode)
              {
            (Expression as ComplexNode).Imaginary *= -1;
            Expression.Compile(emitter);
              }
              // complex case: complex is an expression result
              else
              {
            Expression.Compile(emitter);

            // tmp = ...
            var tmpVar = emitter.CurrentMethod.Scope.Introduce("complex", emitter.FindType("complex").Type);
            emitter.EmitSaveVariable(tmpVar);

            // tmp.real
            emitter.EmitLoadVariableAddress(tmpVar);
            emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("get_Real")));

            // tmp.imaginary * -1
            emitter.EmitLoadVariableAddress(tmpVar);
            emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("get_Imaginary")));
            emitter.EmitLoadFloat(-1);
            emitter.EmitMul();

            // new complex
            emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
              }
            }
            else
            {
              // multiply by -1
              Expression.Compile(emitter);
              if (type == "int")
            emitter.EmitLoadInt(-1);
              else
            emitter.EmitLoadFloat(-1);
              emitter.EmitMul();
            }
              }
              else
            Error(String.Format(Resources.errInvertType, type));
        }
Ejemplo n.º 4
0
        public override void Compile(Emitter.Emitter emitter)
        {
            // retrieve matrix dimensions
              var height = MatrixItems.Count;
              var width = MatrixItems[0].Count;

              // retrieve info about matrices
              var matrixType = typeof(MN.DenseMatrix);
              var matrixCtor = emitter.AssemblyImport(matrixType.GetConstructor(new[] { typeof(int), typeof(int) }));
              var matrixSet = emitter.AssemblyImport(matrixType.GetMethod("At", new[] { typeof(int), typeof(int), typeof(double) }));

              var tmpVar = emitter.CurrentMethod.Scope.Introduce("matrix", emitter.AssemblyImport(matrixType));

              // create matrix
              emitter.EmitLoadInt(height);
              emitter.EmitLoadInt(width);
              emitter.EmitNewObj(matrixCtor);
              emitter.EmitSaveVariable(tmpVar);

              // set items
              for(var idx1 = 0; idx1 < MatrixItems.Count; idx1++)
              {
            // ensure all lines have the same number of items
            if (idx1 > 0 && MatrixItems[0].Count != MatrixItems[idx1].Count)
              Error(String.Format(Resources.errMatrixLineLengthMismatch, MatrixItems[0].Count, idx1+1, MatrixItems[idx1].Count));

            for(var idx2 = 0; idx2 < MatrixItems[idx1].Count; idx2++)
            {
              var item = MatrixItems[idx1][idx2];
              var itemType = item.GetExpressionType(emitter);
              if (!itemType.IsAnyOf("int", "float"))
            Error(Resources.errMatrixItemTypeMismatch, item.Lexem);

              emitter.EmitLoadVariable(tmpVar);

              emitter.EmitLoadInt(idx1);
              emitter.EmitLoadInt(idx2);
              item.Compile(emitter);

              if (itemType != "float")
            emitter.EmitConvertToFloat();

              emitter.EmitCall(matrixSet);
            }
              }

              emitter.EmitLoadVariable(tmpVar);
        }
Ejemplo n.º 5
0
        public override void Compile(Emitter.Emitter emitter)
        {
            var numTypes = new[] { "int", "float" };

              var fromType = From.GetExpressionType(emitter);
              var toType = To.GetExpressionType(emitter);
              var stepType = Step.GetExpressionType(emitter);

              // validate parameters
              if (!fromType.IsAnyOf(numTypes) || !toType.IsAnyOf(numTypes) || !stepType.IsAnyOf(numTypes))
            Error(Resources.errIntFloatExpected);

              // from, to, step
              From.Compile(emitter);
              if (fromType != "float")
            emitter.EmitConvertToFloat();

              To.Compile(emitter);
              if (toType != "float")
            emitter.EmitConvertToFloat();

              Step.Compile(emitter);
              if (stepType != "float")
            emitter.EmitConvertToFloat();

              // invoke method
              var method = typeof(MirelleStdlib.ArrayHelper).GetMethod("CreateRangedArray", new[] { typeof(double), typeof(double), typeof(double) });
              emitter.EmitCall(emitter.AssemblyImport(method));
        }
Ejemplo n.º 6
0
        public override void Compile(Emitter.Emitter emitter)
        {
            var method = emitter.AssemblyImport(typeof(MirelleStdlib.Events.Simulation).GetMethod("Process", new[] { typeof(int), typeof(int) }));

              // processor count
              if(Processors == null)
            emitter.EmitLoadInt(1);
              else
              {
            if(Processors.GetExpressionType(emitter) != "int")
              Error(Resources.errSimulateProcessorsInt);

            Processors.Compile(emitter);
              }

              // queue length
              if(MaxQueue == null)
            emitter.EmitLoadInt(0);
              else
              {
            if(MaxQueue.GetExpressionType(emitter) != "int")
              Error(Resources.errSimulateQueueInt);

            MaxQueue.Compile(emitter);
              }

              emitter.EmitCall(method);
        }
Ejemplo n.º 7
0
        public override void Compile(Emitter.Emitter emitter)
        {
            var leftType = Left.GetExpressionType(emitter);
              var rightType = Right.GetExpressionType(emitter);

              // an array of values
              if (rightType == leftType + "[]")
              {
            Right.Compile(emitter);
            Left.Compile(emitter);
            if (leftType.IsAnyOf("int", "bool", "float", "complex"))
              emitter.EmitBox(emitter.ResolveType(leftType));

            var method = typeof(MirelleStdlib.ArrayHelper).GetMethod("Has", new[] { typeof(object), typeof(object) });
            emitter.EmitCall(emitter.AssemblyImport(method));
              }

              // an object has a "has" method that accepts the lefthand expression
              else
              {
            try
            {
              Expr.IdentifierInvoke("has", Right, Left).Compile(emitter);
              return;
            }
            catch { }

            Error(String.Format(Resources.errOperatorTypesMismatch, "in", leftType, rightType));
              }
        }
Ejemplo n.º 8
0
        public override void Compile(Emitter.Emitter emitter)
        {
            // declare variables and methods
              var tmpVar = emitter.CurrentMethod.Scope.Introduce("dict", emitter.ResolveType("dict"));
              var ctor = emitter.AssemblyImport(typeof(MirelleStdlib.Dict).GetConstructor(new Type[] { }));
              var set = emitter.FindMethod("dict", "set", "string", "string");

              // var tmp = new dict
              emitter.EmitNewObj(ctor);
              emitter.EmitSaveVariable(tmpVar);

              // tmp[key] = value
              foreach(var curr in Data)
              {
            var keyType = curr.Item1.GetExpressionType(emitter);
            var valueType = curr.Item2.GetExpressionType(emitter);

            if (keyType != "string")
              Error(Resources.errDictItemTypeMismatch, curr.Item1.Lexem);

            if (valueType != "string")
              Error(Resources.errDictItemTypeMismatch, curr.Item2.Lexem);

            emitter.EmitLoadVariable(tmpVar);
            curr.Item1.Compile(emitter);
            curr.Item2.Compile(emitter);
            emitter.EmitCall(set);
              }

              emitter.EmitLoadVariable(tmpVar);
        }
Ejemplo n.º 9
0
        public override void Compile(Emitter.Emitter emitter)
        {
            // ensure this is a matrix
              if (ExpressionPrefix.GetExpressionType(emitter) != "matrix")
            Error(Resources.errIndexingNotAMatrix);

              // ensure indexes are integers
              if (Index1.GetExpressionType(emitter) != "int")
            Error(Resources.errIntIndexExpected, Index1.Lexem);

              if (Index2.GetExpressionType(emitter) != "int")
            Error(Resources.errIntIndexExpected, Index2.Lexem);

              // ensure assigned value is either int or float
              var exprType = Expression.GetExpressionType(emitter);
              if (!exprType.IsAnyOf("int", "float"))
            Error(Resources.errMatrixItemTypeMismatch);

              ExpressionPrefix.Compile(emitter);

              Index1.Compile(emitter);
              Index2.Compile(emitter);

              Expression.Compile(emitter);
              if(exprType != "float")
            emitter.EmitConvertToFloat();

              var method = emitter.AssemblyImport(typeof(MN.DenseMatrix).GetMethod("At", new[] { typeof(int), typeof(int), typeof(double) }));
              emitter.EmitCall(method);
        }
Ejemplo n.º 10
0
        public override void Compile(Emitter.Emitter emitter)
        {
            var args = new[] { Parameters.Count == 1 ? typeof(object) : typeof(IEnumerable<dynamic>), typeof(bool) };
              var printMethod = emitter.AssemblyImport(typeof(MirelleStdlib.Printer).GetMethod("Print", args));

              if (Parameters.Count == 1)
              {
            var currType = Parameters[0].GetExpressionType(emitter);
            Parameters[0].Compile(emitter);
            if (currType.IsAnyOf("int", "bool", "float", "complex"))
              emitter.EmitBox(emitter.ResolveType(currType));
              }
              else
              {
            var objType = emitter.AssemblyImport(typeof(object));
            var arrType = new ArrayType(objType);

            var tmpVariable = emitter.CurrentMethod.Scope.Introduce("object[]", arrType);

            // load count & create
            emitter.EmitLoadInt(Parameters.Count);
            emitter.EmitNewArray(objType);
            emitter.EmitSaveVariable(tmpVariable);

            int idx = 0;
            foreach (var curr in Parameters)
            {
              var currType = curr.GetExpressionType(emitter);
              emitter.EmitLoadVariable(tmpVariable);
              emitter.EmitLoadInt(idx);
              curr.Compile(emitter);

              if (currType.IsAnyOf("int", "bool", "float", "complex"))
            emitter.EmitBox(emitter.ResolveType(currType));

              emitter.EmitSaveIndex("object");

              idx++;
            }

            // return the created array
            emitter.EmitLoadVariable(tmpVariable);
              }

              emitter.EmitLoadBool(PrintLine);
              emitter.EmitCall(printMethod);
        }
Ejemplo n.º 11
0
        public override void Compile(Emitter.Emitter emitter)
        {
            Resolve(emitter);

              // operands
              Left.Compile(emitter);
              emitter.EmitConvertToFloat();
              Right.Compile(emitter);
              emitter.EmitConvertToFloat();

              // magic method
              var method = emitter.AssemblyImport(typeof(Math).GetMethod("Pow", new[] { typeof(double), typeof(double) }));
              emitter.EmitCall(method);

              // convert back
              if (IsInt)
            emitter.EmitConvertToInt();
              else
            emitter.EmitConvertToFloat();
        }
Ejemplo n.º 12
0
        public override void Compile(Emitter.Emitter emitter)
        {
            // ensure this is a matrix
              if (ExpressionPrefix.GetExpressionType(emitter) != "matrix")
            Error(Resources.errIndexingNotAMatrix);

              // ensure indexes are integers
              if (Index1.GetExpressionType(emitter) != "int")
            Error(Resources.errIntIndexExpected, Index1.Lexem);

              if(Index2.GetExpressionType(emitter) != "int")
            Error(Resources.errIntIndexExpected, Index2.Lexem);

              ExpressionPrefix.Compile(emitter);
              Index1.Compile(emitter);
              Index2.Compile(emitter);

              var method = emitter.AssemblyImport(typeof(MN.DenseMatrix).GetMethod("At", new[] { typeof(int), typeof(int) }));
              emitter.EmitCall(method);
        }
Ejemplo n.º 13
0
        public override void Compile(Emitter.Emitter emitter)
        {
            if (!BuiltIn)
              {
            emitter.CurrentMethod = this;

            // special cases for constructors
            if(Name == ".ctor")
            {
              // invoke base constructor
              emitter.EmitLoadThis();
              if(emitter.CurrentType.Parent != "")
            emitter.EmitCall(emitter.FindMethod(emitter.CurrentType.Parent, ".ctor"));
              else
            emitter.EmitCall(emitter.AssemblyImport(typeof(object).GetConstructor(new Type[] { } )));

              // invoke initializer
              if (emitter.MethodNameExists(emitter.CurrentType.Name, ".init"))
              {
            emitter.EmitLoadThis();
            emitter.EmitCall(emitter.FindMethod(emitter.CurrentType.Name, ".init"));
              }
            }

            Body.Compile(emitter);
            if (!Body.AllPathsReturn)
            {
              if (Type.Signature == "void")
            emitter.EmitReturn();
              else
            Error(String.Format(Resources.errNotAllPathsReturn, Name));
            }

            emitter.CurrentMethod = null;
              }
        }
Ejemplo n.º 14
0
        public override void Compile(Emitter.Emitter emitter)
        {
            var leftType = Left.GetExpressionType(emitter);
              var rightType = Right.GetExpressionType(emitter);

              var type = GetExpressionType(emitter);

              // concat strings
              if (type == "string")
              {
            Left.Compile(emitter);
            Right.Compile(emitter);
            emitter.EmitCall(emitter.FindMethod("string", "concat", "string", "string"));
              }

              // add matrices
              else if(type == "matrix")
              {
            Left.Compile(emitter);
            Right.Compile(emitter);

            var matrixType = typeof(MN.Matrix<double>);
            var method = emitter.AssemblyImport(matrixType.GetMethod("Add", new [] { matrixType } ));
            emitter.EmitCall(method);
              }

              // add dicts
              else if (type == "dict")
              {
            Left.Compile(emitter);
            Right.Compile(emitter);

            var dictType = typeof(Dict);
            var method = emitter.AssemblyImport(dictType.GetMethod("Add", new[] { dictType }));
            emitter.EmitCall(method);
              }

              // add complex numbers
              else if(type == "complex")
              {
            Left.Compile(emitter);
            if(leftType != "complex")
            {
              emitter.EmitUpcastBasicType(leftType, "float");
              emitter.EmitLoadFloat(0);
              emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
            }

            Right.Compile(emitter);
            if (rightType != "complex")
            {
              emitter.EmitUpcastBasicType(rightType, "float");
              emitter.EmitLoadFloat(0);
              emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
            }

            emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("op_Addition", new[] { typeof(SN.Complex), typeof(SN.Complex) })));
              }

              // add floating point numbers or integers
              else if(type.IsAnyOf("int", "float"))
              {
            Left.Compile(emitter);
            emitter.EmitUpcastBasicType(leftType, type);
            Right.Compile(emitter);
            emitter.EmitUpcastBasicType(rightType, type);
            emitter.EmitAdd();
              }

              // array addition
              else if(type.Contains("[]"))
              {
            Left.Compile(emitter);
            Right.Compile(emitter);

            var method = emitter.AssemblyImport(typeof(ArrayHelper).GetMethod("AddArrays", new[] { typeof(object), typeof(object) } ));
            emitter.EmitCall(method);
              }
        }
Ejemplo n.º 15
0
        /// <summary>
        /// Compare two values for their relative order: less and greater
        /// </summary>
        /// <param name="emitter">Emitter link</param>
        /// <param name="leftType">Left-hand argument type</param>
        /// <param name="rightType">Left-hand argument type</param>
        private void CompileRelation(Emitter.Emitter emitter, string leftType, string rightType)
        {
            if(leftType == "string")
              {
            var method = emitter.AssemblyImport(typeof(string).GetMethod("Compare", new[] { typeof(string), typeof(string) }));
            emitter.EmitCall(method);
            emitter.EmitLoadBool(false);
              }

              switch (ComparisonType)
              {
            case LexemType.Less: emitter.EmitCompareLess(); break;

            case LexemType.LessEqual: emitter.EmitCompareGreater();
              emitter.EmitLoadBool(false);
              emitter.EmitCompareEqual(); break;

            case LexemType.Greater: emitter.EmitCompareGreater(); break;

            case LexemType.GreaterEqual: emitter.EmitCompareLess();
              emitter.EmitLoadBool(false);
              emitter.EmitCompareEqual(); break;
              }
        }
Ejemplo n.º 16
0
        /// <summary>
        /// Compare two values for their equality
        /// </summary>
        /// <param name="emitter">Emitter link</param>
        /// <param name="leftType">Left-hand argument type</param>
        /// <param name="rightType">Left-hand argument type</param>
        private void CompileEquality(Emitter.Emitter emitter, string leftType, string rightType)
        {
            var basicTypes = new[] { "bool", "int", "float", "string" };
              if (leftType.IsAnyOf(basicTypes))
              {
            // compare strings
            if (leftType == "string")
            {
              var method = emitter.AssemblyImport(typeof(string).GetMethod("Compare", new[] { typeof(string), typeof(string) }));
              emitter.EmitCall(method);
              emitter.EmitLoadBool(false);
            }

            emitter.EmitCompareEqual();
              }

              // long, complex and others
              else
              {
            System.Reflection.MethodInfo method;
            if(leftType.IsAnyOf("long", "complex"))
            {
              var type = (leftType == "long" ? typeof(System.Numerics.BigInteger) : typeof(System.Numerics.Complex));
              method = type.GetMethod("op_Equality", new[] { type, type });
            }
            else
              method = typeof(MirelleStdlib.Compare).GetMethod("Equal", new[] { typeof(object), typeof(object) });

            emitter.EmitCall(emitter.AssemblyImport(method));
              }

              // invert ?
              if (ComparisonType == LexemType.NotEqual)
              {
            emitter.EmitLoadBool(false);
            emitter.EmitCompareEqual();
              }
        }
Ejemplo n.º 17
0
 public override void Compile(Emitter.Emitter emitter)
 {
     var method = typeof(Environment).GetMethod("Exit", new[] { typeof(int) });
       emitter.EmitLoadInt(0);
       emitter.EmitCall(emitter.AssemblyImport(method));
 }
Ejemplo n.º 18
0
        /// <summary>
        /// Generate code to setup the currently defined emitter
        /// </summary>
        /// <param name="emitter"></param>
        private void CompileInitiation(Emitter.Emitter emitter)
        {
            var emitterType = emitter.FindType(EmitterID);
              var tmpVar = emitter.CurrentMethod.Scope.Introduce(EmitterID, emitterType.Type);

              // tmp = new emitterN()
              emitter.EmitNewObj(emitter.FindMethod(EmitterID, ".ctor"));
              emitter.EmitSaveVariable(tmpVar);

              // step
              if (Step != null)
              {
            // validate step
            var stepType = Step.GetExpressionType(emitter);
            if (!stepType.IsAnyOf("int", "float"))
              Error(Resources.errEmitStepExpected);

            // tmp.Step = step
            emitter.EmitLoadVariable(tmpVar);
            Step.Compile(emitter);
            if (stepType == "int")
              emitter.EmitConvertToFloat();
            emitter.EmitSaveField(emitter.FindField(EmitterID, "step"));
              }

              // distribution
              if (Distribution != null)
              {
            // validate distr
            if (Distribution.GetExpressionType(emitter) != "distr")
              Error(Resources.errEmitDistributionExpected);

            // tmp.Distr = distr
            emitter.EmitLoadVariable(tmpVar);
            Distribution.Compile(emitter);
            emitter.EmitSaveField(emitter.FindField(EmitterID, "distr"));
              }

              // limit
              if (Limit != null)
              {
            // validate distr
            if (Limit.GetExpressionType(emitter) != "int")
              Error(Resources.errEmitLimitExpected);

            // tmp.Distr = distr
            emitter.EmitLoadVariable(tmpVar);
            Limit.Compile(emitter);
            emitter.EmitSaveField(emitter.FindField(EmitterID, "limit"));
              }

              SaveClosuredVariables(emitter, tmpVar);

              // register emitter in the system
              emitter.EmitLoadVariable(tmpVar);
              var registerMethod = emitter.AssemblyImport(typeof(Simulation).GetMethod("RegisterEmitter", new[] { typeof(EventEmitter) }));
              emitter.EmitCall(registerMethod);
        }
Ejemplo n.º 19
0
        /// <summary>
        /// Generate code to setup the currently defined emitter
        /// </summary>
        /// <param name="emitter"></param>
        private void CompileInitiation(Emitter.Emitter emitter)
        {
            var flowSimType = emitter.FindType(PlannerID);
              var tmpVar = emitter.CurrentMethod.Scope.Introduce(PlannerID, flowSimType.Type);

              // tmp = new flowsimN()
              emitter.EmitNewObj(emitter.FindMethod(PlannerID, ".ctor"));
              emitter.EmitSaveVariable(tmpVar);

              SaveClosuredVariables(emitter, tmpVar);

              // call FlowSimulation.Start(planner)
              emitter.EmitLoadVariable(tmpVar);
              var method = emitter.AssemblyImport(typeof(FlowSimulation).GetMethod("Start", new[] { typeof(Planner) }));
              emitter.EmitCall(method);
        }
Ejemplo n.º 20
0
        public override void Compile(Emitter.Emitter emitter)
        {
            var leftType = Left.GetExpressionType(emitter);
              var rightType = Right.GetExpressionType(emitter);

              var type = GetExpressionType(emitter);

              // repeat a string
              if (type == "string")
              {
            Left.Compile(emitter);
            Right.Compile(emitter);
            emitter.EmitCall(emitter.FindMethod("string", "repeat", "int"));
              }

              // multiply matrices
              else if(type == "matrix")
              {
            var matrixType = typeof(MN.Matrix<double>);

            // matrix by matrix
            if(leftType == rightType)
            {
              Left.Compile(emitter);
              Right.Compile(emitter);

              var method = emitter.AssemblyImport(matrixType.GetMethod("Multiply", new[] { matrixType }));
              emitter.EmitCall(method);
            }
            else
            {
              // matrix should be the first in stack
              if(leftType == "matrix")
              {
            Left.Compile(emitter);
            Right.Compile(emitter);
            if (rightType != "float")
              emitter.EmitConvertToFloat();
              }
              else
              {
            Right.Compile(emitter);
            Left.Compile(emitter);
            if (leftType != "float")
              emitter.EmitConvertToFloat();
              }

              var method = emitter.AssemblyImport(matrixType.GetMethod("Multiply", new[] { typeof(double) }));
              emitter.EmitCall(method);
            }
              }

              // multiply complex numbers
              else if (type == "complex")
              {
            Left.Compile(emitter);
            if (leftType != "complex")
            {
              emitter.EmitUpcastBasicType(leftType, "float");
              emitter.EmitLoadFloat(0);
              emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
            }

            Right.Compile(emitter);
            if (rightType != "complex")
            {
              emitter.EmitUpcastBasicType(rightType, "float");
              emitter.EmitLoadFloat(0);
              emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
            }

            emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("op_Multiply", new[] { typeof(SN.Complex), typeof(SN.Complex) })));
              }

              // repeat array
              else if (leftType.EndsWith("[]"))
              {
            Left.Compile(emitter);
            Right.Compile(emitter);
            var method = emitter.AssemblyImport(typeof(MirelleStdlib.ArrayHelper).GetMethod("RepeatArray", new[] { typeof(object), typeof(int) }));
            emitter.EmitCall(method);
              }

              // multiply floating point numbers or integers
              else if (type.IsAnyOf("int", "float"))
              {
            Left.Compile(emitter);
            emitter.EmitUpcastBasicType(leftType, type);
            Right.Compile(emitter);
            emitter.EmitUpcastBasicType(rightType, type);
            emitter.EmitMul();
              }
        }