예제 #1
0
 public static StackValue ConvertToString(StackValue sv, RuntimeCore runtimeCore, ProtoCore.Runtime.RuntimeMemory rmem)
 {
     StackValue returnSV;
     //TODO: Change Execution mirror class to have static methods, so that an instance does not have to be created
     ProtoCore.DSASM.Mirror.ExecutionMirror mirror = new DSASM.Mirror.ExecutionMirror(new ProtoCore.DSASM.Executive(runtimeCore), runtimeCore);
     returnSV = ProtoCore.DSASM.StackValue.BuildString(mirror.GetStringValue(sv, runtimeCore.RuntimeMemory.Heap, 0, true), runtimeCore.RuntimeMemory.Heap);
     return returnSV;
 }
예제 #2
0
        public static int CompareString(StackValue s1, StackValue s2, RuntimeCore runtimeCore)
        {
            if (!s1.IsString || !s2.IsString)
                return Constants.kInvalidIndex;

            if (s1.Equals(s2))
                return 0;

            string str1 = runtimeCore.RuntimeMemory.Heap.ToHeapObject<DSString>(s1).Value;
            string str2 = runtimeCore.RuntimeMemory.Heap.ToHeapObject<DSString>(s2).Value;
            return string.Compare(str1, str2);
        }
예제 #3
0
        /// <summary>
        /// Returns the number of upcasts that need to be performed to turn a class into another class in its upcast chain
        /// </summary>
        /// <param name="from"></param>
        /// <param name="to"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public static int GetUpcastCountTo(ClassNode from, ClassNode to, RuntimeCore runtimeCore)
        {
            int toID = runtimeCore.DSExecutable.classTable.ClassNodes.IndexOf(to);

            List<int> upcastChain = GetClassUpcastChain(from, runtimeCore);

            if (!upcastChain.Contains(toID))
                return int.MaxValue;

            return upcastChain.IndexOf(toID);


        }
예제 #4
0
        private static List<ElementAtLevel> GetElementsAtLevel(StackValue argument, int level, List<int> indices, bool recordIndices, RuntimeCore runtimeCore)
        {
            var array = runtimeCore.Heap.ToHeapObject<DSArray>(argument);
            if (array == null)
            {
                return new List<ElementAtLevel>();
            }

            int count = array.Values.Count();
            if (level == 0)
            {
                return array.Values.Zip(Enumerable.Range(0, count), (v, i) =>
                {
                    if (recordIndices)
                    {
                        var newIndices = new List<int>(indices);
                        newIndices.Add(i);
                        return new ElementAtLevel(v, newIndices);
                    }
                    else
                    { 
                        return new ElementAtLevel(v);
                    }
               }).ToList();
            }
            else
            {
                return array.Values.Zip(Enumerable.Range(0, count), (v, i) =>
                {
                    if (recordIndices)
                    {
                        var newIndices = new List<int>(indices);
                        newIndices.Add(i);
                        return GetElementsAtLevel(v, level - 1, newIndices, recordIndices, runtimeCore);
                    }
                    else
                    {
                        return GetElementsAtLevel(v, level - 1, new List<int>(), recordIndices, runtimeCore);
                    }
                }).SelectMany(vs => vs).ToList();
            }
        }
예제 #5
0
파일: ClassUtils.cs 프로젝트: sm6srw/Dynamo
        /// <summary>
        /// Returns the list of classes that this can be upcast to
        /// It includes the class itself
        /// </summary>
        /// <param name="cn"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public static List<int> GetClassUpcastChain(ClassNode cn, RuntimeCore runtimeCore)
        {
            List<int> ret = new List<int>();

            //@TODO: Replace this with an ID
            ret.Add(runtimeCore.DSExecutable.classTable.ClassNodes.IndexOf(cn));

            ClassNode target = cn;
            while (target.Base != Constants.kInvalidIndex)
            {
                ret.Add(target.Base);
                target = runtimeCore.DSExecutable.classTable.ClassNodes[target.Base];
            }

            if (!ret.Contains((int)(PrimitiveType.Var)))
                ret.Add((int)PrimitiveType.Var);


            return ret;
        }
예제 #6
0
        /// <summary>
        /// Returns the list of classes that this can be upcast to
        /// It includes the class itself
        /// </summary>
        /// <param name="cn"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public static List<int> GetClassUpcastChain(ClassNode cn, RuntimeCore runtimeCore)
        {
            List<int> ret = new List<int>();

            //@TODO: Replace this with an ID
            ret.Add(runtimeCore.DSExecutable.classTable.ClassNodes.IndexOf(cn));

            ClassNode target = cn;
            while (target.Bases.Count > 0)
            {
                Validity.Assert(target.Bases.Count == 1, "Multiple Inheritence not yet supported, {F5DDC58D-F721-4319-854A-622175AC43F8}");
                ret.Add(target.Bases[0]);

                target = runtimeCore.DSExecutable.classTable.ClassNodes[target.Bases[0]];
            }

            if (!ret.Contains((int)(PrimitiveType.Var)))
                ret.Add((int)PrimitiveType.Var);


            return ret;
        }
예제 #7
0
        public Executive(RuntimeCore runtimeCore, bool isFep = false)
        {
            IsExplicitCall = false;
            Validity.Assert(runtimeCore != null);

            this.runtimeCore = runtimeCore;
            enableLogging = runtimeCore.Options.Verbose;

            exe = runtimeCore.DSExecutable;
            istream = null;

            fepRun = isFep;
            Properties = new InterpreterProperties();

            rmem = runtimeCore.RuntimeMemory;

            // Execute DS View VM Log
            //
            debugFlags = (int)DebugFlags.ENABLE_LOG;

            bounceType = CallingConvention.BounceType.Implicit;

            deferedGraphNodes = new List<AssociativeGraph.GraphNode>();
        }
예제 #8
0
        /// <summary>
        /// Whether sv is double or arrays contains double value.
        /// </summary>
        /// <param name="sv"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public static bool ContainsDoubleElement(StackValue sv, RuntimeCore runtimeCore)
        {
            Executable exe = runtimeCore.DSExecutable;
            if (!sv.IsArray)
                return exe.TypeSystem.GetType(sv) == (int)PrimitiveType.kTypeDouble;

            DSArray array = runtimeCore.Heap.ToHeapObject<DSArray>(sv);
            return array.Values.Any(
                        v => (v.IsArray && ContainsDoubleElement(v, runtimeCore)) ||
                             (exe.TypeSystem.GetType(v) == (int)PrimitiveType.kTypeDouble));
        }
예제 #9
0
 public InjectionExecutive(RuntimeCore runtimeCore, bool isFep = false) : base(runtimeCore, isFep)
 {
 }
예제 #10
0
        public static int GetMaxRankForArray(StackValue array, RuntimeCore runtimeCore)
        {
            return GetMaxRankForArray(array, runtimeCore, 0);

        }
예제 #11
0
        public static bool CompareFromDifferentCore(DSArray array1, DSArray array2, RuntimeCore rtCore1, RuntimeCore rtCore2, Context context = null)
        {
            if (array1.Count != array2.Count)
            {
                return(false);
            }

            for (int i = 0; i < array1.Count; i++)
            {
                if (!StackUtils.CompareStackValues(array1.GetValueAt(i), array2.GetValueAt(i), rtCore1, rtCore2, context))
                {
                    return(false);
                }
            }

            foreach (var key in array1.Dict.Keys)
            {
                StackValue value1 = array1.Dict[key];
                StackValue value2 = StackValue.Null;
                if (!array2.Dict.TryGetValue(key, out value2))
                {
                    return(false);
                }

                if (!StackUtils.CompareStackValues(value1, value2, rtCore1, rtCore2))
                {
                    return(false);
                }
            }

            return(true);
        }
예제 #12
0
        /// <summary>
        /// This computes the max depth to which the element can be reduced
        /// It contains a protected envelope 
        /// </summary>
        /// <param name="sv"></param>
        /// <param name="core"></param>
        /// <param name="depthCount"></param>
        /// <returns></returns>
        private static int RecursiveProtectGetMaxReductionDepth(StackValue sv, RuntimeCore runtimeCore, int depthCount)
        {
            Validity.Assert(depthCount < 1000, 
                "StackOverflow protection trap. This is almost certainly a VM cycle-in-array bug. {0B530165-2E38-431D-88D9-56B0636364CD}");

            //PERF(Luke): Could be non-recursive
            if (!sv.IsArray)
                return 0;

            int maxReduction = 0;

            //De-ref the sv
            var array = runtimeCore.Heap.ToHeapObject<DSArray>(sv);
            foreach (var subSv in array.VisibleItems)
            {
                maxReduction = Math.Max(maxReduction, RecursiveProtectGetMaxReductionDepth(subSv, runtimeCore, depthCount + 1));
            }

            return 1 + maxReduction;   
        }
예제 #13
0
        /// <summary>
        /// Retrieve the first non-array element in an array 
        /// </summary>
        /// <param name="svArray"></param>
        /// <param name="sv"></param>
        /// <param name="core"></param>
        /// <returns> true if the element was found </returns>
        public static bool GetFirstNonArrayStackValue(StackValue svArray, ref StackValue sv, RuntimeCore runtimeCore)
        {
            RuntimeMemory rmem = runtimeCore.RuntimeMemory;
            if (!svArray.IsArray)
            {
                return false;
            }

            var array = rmem.Heap.ToHeapObject<DSArray>(svArray);
            if (!array.Values.Any())
            {
                return false;
            }

            while (array.GetValueFromIndex(0, runtimeCore).IsArray)
            {
                array = rmem.Heap.ToHeapObject<DSArray>(array.GetValueFromIndex(0, runtimeCore));

                // Handle the case where the array is valid but empty
                if (!array.Values.Any())
                {
                    return false;
                }
            }

            sv = array.GetValueFromIndex(0, runtimeCore).ShallowClone();
            return true;
        }
예제 #14
0
        /// <summary>
        /// For an array we supporting zipped replicaiton for array indexing as 
        /// well. I.e., for the following expression:
        /// 
        ///     a[1..3][2..4] = x;
        /// 
        /// It will be expanded to 
        /// 
        ///     a[1][2] = x;
        ///     a[2][3] = x;
        ///     a[3][4] = x;
        ///     
        /// So here we need to calculate zipped indices. The length of returned 
        /// indices is decided by the shortest length of index that used in 
        /// array indexing. E.g.,
        /// 
        /// For array indexing
        /// 
        ///     [{1, 2, 3}][{"x", "y"}][{6, 7, 8}], i.e., 
        ///     
        ///     1 -> "x" -> 6
        ///     2 -> "y" -> 7
        ///     3 ->     -> 8
        /// 
        /// The shortest length of index is 2 ({"x", "y"}), so function will 
        /// returns:
        /// 
        ///     {{1, "x", 6}, {2, "y", 7}}
        ///     
        /// </summary>
        /// <param name="indices"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public static StackValue[][] GetZippedIndices(List<StackValue> indices, RuntimeCore runtimeCore)
        {
            List<StackValue[]> allFlattenValues = new List<StackValue[]>();

            int zipLength = System.Int32.MaxValue;
            foreach (var index in indices)
            {
                int length = 1;
                if (index.IsArray)
                {
                    StackValue[] flattenValues = GetFlattenValue(index, runtimeCore);
                    allFlattenValues.Add(flattenValues);
                    length = flattenValues.Count();
                }
                else
                {
                    allFlattenValues.Add(null);
                }

                if (zipLength > length)
                {
                    zipLength = length;
                }
            }

            if (zipLength == 0)
            {
                return null;
            }
            else
            {
                int dims = indices.Count;
                StackValue[][] zippedIndices = new StackValue[zipLength][];
                for (int i = 0; i < zipLength; ++i)
                {
                    zippedIndices[i] = new StackValue[dims];
                }

                for (int i = 0; i < dims; ++i)
                {
                    StackValue index = indices[i];
                    StackValue[] values = null;
                    if (index.IsArray)
                    {
                        values = allFlattenValues[i];
                    }

                    if (1 == zipLength)
                    {
                        if (index.IsArray)
                        {
                            zippedIndices[0][i] = values[0];
                        }
                        else
                        {
                            zippedIndices[0][i] = index;
                        }
                    }
                    else
                    {
                        for (int j = 0; j < zipLength; ++j)
                        {
                            zippedIndices[j][i] = values[j];
                        }
                    }
                }

                return zippedIndices;
            }
        }
예제 #15
0
        /// <summary>
        /// Performs addition on 2 StackValues
        /// This is used by the VM when adding strings
        /// </summary>
        /// <param name="sv1"></param>
        /// <param name="sv2"></param>
        /// <returns></returns>
        public static StackValue AddStackValueString(StackValue sv1, StackValue sv2, RuntimeCore runtimeCore)
        {
            Validity.Assert(sv1.IsString || sv2.IsString);

            if (sv1.IsString && sv2.IsString)
            {
                return StringUtils.ConcatString(sv2, sv1, runtimeCore);
            }
            else if (sv1.IsString || sv2.IsString)
            {
                StackValue newSV;
                if (sv1.IsNull || sv2.IsNull)
                {
                    return StackValue.BuildNull();
                }
                else if (sv1.IsString)
                {
                    newSV = StringUtils.ConvertToString(sv2, runtimeCore, runtimeCore.RuntimeMemory);
                    return StringUtils.ConcatString(newSV, sv1, runtimeCore);
                }
                else if (sv2.IsString)
                {
                    newSV = StringUtils.ConvertToString(sv1, runtimeCore, runtimeCore.RuntimeMemory);
                    return StringUtils.ConcatString(sv2, newSV, runtimeCore);
                }
            }
            return StackValue.BuildNull();
        }
예제 #16
0
        /*internal static void VerifyWatch_Run(int lineAtPrevBreak, string symbolName, Core core, StreamReader log,
         *  bool watchNestedMode = false)
         * {
         *  //bool check = true;
         *
         *  // search for the line and LHS string in the log file
         *  // verify that the LHS identifier name equals 'symbolName'
         *  // pass the LHS string to GetWatchValue() and inspect it
         *  // verify the watch values with the log output
         *  string line = null;
         *  while ((line = log.ReadLine()) != null)
         *  {
         *      // Get line no.
         *      Match m = Regex.Match(line, @"At line, (\d+)");
         *      if (m.Success)
         *      {
         *          int lineNo = int.Parse(m.Groups[1].Value);
         *          if (lineNo == lineAtPrevBreak)
         *          {
         *              // Get lhs string
         *              // m = Regex.Match(line, @"(\d+), (\w+)");
         *              m = Regex.Match(line, @"(\d+), (.*)([^\s]+)");
         *              if (m.Success)
         *              {
         *                  string lhsString = m.Groups[2].Value;
         *
         *                  // Get lhs symbol name
         *                  m = Regex.Match(lhsString, @"(\w+)");
         *                  if (m.Success)
         *                  {
         *                      string lhsName = m.Groups[1].Value;
         *                      if (lhsName.Equals(symbolName))
         *                      {
         *                          ExpressionInterpreterRunner watchRunner = new ExpressionInterpreterRunner(core);
         *                          ProtoCore.DSASM.Mirror.ExecutionMirror mirror = watchRunner.Execute(lhsString);
         *                          Obj obj = mirror.GetWatchValue();
         *
         *                          if (!watchNestedMode)
         *                          {
         *                              // Cheat by peeking into heap etc. to dump output string
         *                              // match string with log output to verify
         *                              string result = mirror.GetStringValue(obj.DsasmValue, core.Heap, 0, true);
         *                              line = log.ReadLine();
         *
         *                              m = Regex.Match(line, @"Info: (.*)");
         *                              if (m.Success)
         *                              {
         *                                  string output = m.Groups[1].Value;
         *                                  if (!output.Equals(result))
         *                                  {
         *                                      Assert.Fail(string.Format("\tThe value of expression \"{0}\" doesn't match in run mode and in watch.\n", lhsString));
         *                                      return;
         *                                  }
         *                              }
         *                          }
         *                          else
         *                          {
         *                              // TODO: Implement this - pratapa
         *                              // if obj is a class pointer, handle separately
         *                              // if obj is an array pointer, handle separately
         *                              // if obj is a literal, verify watch value with log output directly
         *                              GetStringValue(obj, mirror);
         *                          }
         *                          break;
         *                      }
         *                  }
         *              }
         *          }
         *      }
         *  }
         * }*/

        internal static void VerifyWatch_Run(int lineAtPrevBreak, string symbolName, Core core, RuntimeCore runtimeCore,
                                             Dictionary <int, List <string> > map, bool watchNestedMode = false, int ci = Constants.kInvalidIndex, string defectID = "")
        {
            //bool check = true;

            // search for the line and LHS string in the map
            // verify that the LHS identifier name equals 'symbolName'
            // pass the LHS string to GetWatchValue() and inspect it
            // verify the watch values with the log output
            if (!map.ContainsKey(lineAtPrevBreak))
            {
                return;
            }

            List <string> expressions = map[lineAtPrevBreak];

            foreach (string exp in expressions)
            {
                // Get line no.
                // Get lhs symbol name
                string lhsName = null;
                int    index   = exp.IndexOf('.');
                if (index != -1)
                {
                    string[] parts = exp.Split('.');
                    lhsName = parts[parts.Length - 1];
                }
                else
                {
                    Match m = Regex.Match(exp, @"(\w+)");
                    if (m.Success)
                    {
                        lhsName = m.Groups[1].Value;
                    }
                }
                if (lhsName.Equals(symbolName))
                {
                    ExpressionInterpreterRunner            watchRunner = new ExpressionInterpreterRunner(core, runtimeCore);
                    ProtoCore.DSASM.Mirror.ExecutionMirror mirror      = watchRunner.Execute(exp);
                    Obj obj = mirror.GetWatchValue();

                    if (!watchNestedMode)
                    {
                        // Cheat by peeking into heap etc. to dump output string
                        // match string with map output to verify
                        string result = mirror.GetStringValue(obj.DsasmValue, runtimeCore.RuntimeMemory.Heap, 0, true);

                        Expression expr = new Expression(lineAtPrevBreak, exp, ci);
                        if (!InjectionExecutive.ExpressionMap.ContainsKey(expr))
                        {
                            return;
                        }

                        List <string> values = InjectionExecutive.ExpressionMap[expr];

                        if (!values.Contains(result))
                        {
                            Assert.Fail(string.Format("\tThe value of expression \"{0}\" doesn't match in run mode and in watch.\nTracked by Defect: {1}", exp, defectID));
                            return;
                        }
                    }
                    else
                    {
                        // TODO: Implement this! - pratapa
                        // if obj is a class pointer, handle separately
                        // if obj is an array pointer, handle separately
                        // if obj is a literal, verify watch value with log output directly
                        GetStringValue(obj, mirror);
                    }
                    //break;
                }
            }
        }
예제 #17
0
        /// <summary>
        /// Try to get value for key from nested dictionaries. This function is
        /// used in the case that indexing into dictionaries that returned from
        /// a replicated function whose return type is dictionary.
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public bool TryGetValueFromNestedDictionaries(StackValue key, out StackValue value, RuntimeCore runtimeCore)
        {
            if (Dict != null && Dict.TryGetValue(key, out value))
            {
                return(true);
            }

            var  values   = new List <StackValue>();
            bool hasValue = false;

            foreach (var element in Values)
            {
                if (!(element.IsArray))
                {
                    continue;
                }

                StackValue valueInElement;
                DSArray    subArray = heap.ToHeapObject <DSArray>(element);
                if (subArray.TryGetValueFromNestedDictionaries(key, out valueInElement, runtimeCore))
                {
                    hasValue = true;
                    values.Add(valueInElement);
                }
            }

            if (hasValue)
            {
                try
                {
                    value = heap.AllocateArray(values.ToArray());
                    return(true);
                }
                catch (RunOutOfMemoryException)
                {
                    value = StackValue.Null;
                    runtimeCore.RuntimeStatus.LogWarning(WarningID.RunOutOfMemory, Resources.RunOutOfMemory);
                    return(false);
                }
            }
            else
            {
                value = StackValue.Null;
                return(false);
            }
        }
예제 #18
0
        //@TODO(Luke): Add in the methods here that correspond to each of the internal datastructures in use by the executive
        //@TODO(Jun): if this method stays static, then the Heap needs to be referenced from a parameter
        /// <summary>
        /// Do the recursive unpacking of the data structure into mirror objects
        /// </summary>
        /// <param name="val"></param>
        /// <returns></returns>
        public static Obj Unpack(StackValue val, Heap heap, RuntimeCore runtimeCore, int type = (int)PrimitiveType.Pointer)
        {
            Executable exe = runtimeCore.DSExecutable;

            switch (val.optype)
            {
            case AddressType.ArrayPointer:
            {
                DsasmArray ret = new DsasmArray();

                //Pull the item out of the heap


                var array = heap.ToHeapObject <DSArray>(val);

                StackValue[] nodes = array.Values.ToArray();
                ret.members = new Obj[array.Count];
                for (int i = 0; i < ret.members.Length; i++)
                {
                    ret.members[i] = Unpack(nodes[i], heap, runtimeCore, type);
                }

                // TODO Jun: ret.members[0] is hardcoded  and means we are assuming a homogenous collection
                // How to handle mixed-type arrays?
                Obj retO = new Obj(val)
                {
                    Payload = ret,
                };

                return(retO);
            }

            case AddressType.String:
            {
                string str = heap.ToHeapObject <DSString>(val).Value;
                Obj    o   = new Obj(val)
                {
                    Payload = str,
                };
                return(o);
            }

            case AddressType.Int:
            {
                Obj o = new Obj(val)
                {
                    Payload = val.IntegerValue,
                };
                return(o);
            }

            case AddressType.Boolean:
            {
                Obj o = new Obj(val)
                {
                    Payload = val.BooleanValue,
                };
                return(o);
            }

            case AddressType.Null:
            {
                Obj o = new Obj(val)
                {
                    Payload = null,
                };
                return(o);
            }

            case AddressType.Char:
            {
                Obj o = new Obj(val)
                {
                    Payload = val.CharValue,
                };
                return(o);
            }

            case AddressType.Double:
            {
                Obj o = new Obj(val)
                {
                    Payload = val.DoubleValue,
                };
                return(o);
            }

            case AddressType.Pointer:
            {
                Obj o = new Obj(val)
                {
                    Payload = val.Pointer,
                };
                return(o);
            }

            case AddressType.FunctionPointer:
            {
                Obj o = new Obj(val)
                {
                    Payload = val.FunctionPointer,
                };
                return(o);
            }

            case AddressType.Invalid:
            {
                return(new Obj(val)
                    {
                        Payload = null
                    });
            }

            default:
            {
                throw new NotImplementedException(string.Format("unknown datatype {0}", val.optype.ToString()));
            }
            }
        }
예제 #19
0
        /// <summary>
        /// <param name="core"></param>
        /// <returns></returns>
        /// </summary>
        public StackValue CopyArray(RuntimeCore runtimeCore)
        {
            Type anyType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var, Constants.kArbitraryRank);

            return(CopyArray(anyType, runtimeCore));
        }
예제 #20
0
        public override StackValue Execute(Runtime.Context c, List <StackValue> formalParameters, StackFrame stackFrame, RuntimeCore runtimeCore)
        {
            StackValue svThisPtr = stackFrame.ThisPtr;

            if (mInterpreter == null)
            {
                Init(runtimeCore);
            }

            if (mFunctionPointer == null)
            {
                return(StackValue.Null);
            }

            // Check if this is a 'this' pointer function overload that was generated by the compiler
            if (null != mFNode && mFNode.IsAutoGeneratedThisProc)
            {
                int  thisPtrIndex = 0;
                bool isStaticCall = svThisPtr.IsPointer && Constants.kInvalidPointer == svThisPtr.Pointer;
                if (isStaticCall)
                {
                    stackFrame.ThisPtr = formalParameters[thisPtrIndex];
                }

                // Comment Jun: Execute() can handle a null this pointer.
                // But since we don't even need to to reach there if we don't have a valid this pointer, then just return null
                if (formalParameters[thisPtrIndex].IsNull)
                {
                    runtimeCore.RuntimeStatus.LogWarning(
                        Runtime.WarningID.DereferencingNonPointer, Resources.kDeferencingNonPointer);
                    return(StackValue.Null);
                }

                // These are the op types allowed.
                Validity.Assert(formalParameters[thisPtrIndex].IsPointer ||
                                formalParameters[thisPtrIndex].IsDefaultArgument);

                // Make sure we to pass a pointer to unmarshal.
                if (formalParameters[thisPtrIndex].IsPointer)
                {
                    svThisPtr = formalParameters[thisPtrIndex];
                }

                formalParameters.RemoveAt(thisPtrIndex);
            }

            formalParameters.Add(svThisPtr);

            Object     ret = mFunctionPointer.Execute(c, mInterpreter, formalParameters);
            StackValue op;

            if (ret == null)
            {
                op = StackValue.Null;
            }
            else if (ret is StackValue)
            {
                op = (StackValue)ret;
            }
            else if (ret is Int64 || ret is int)
            {
                op = StackValue.BuildInt((Int64)ret);
            }
            else if (ret is double)
            {
                op = StackValue.BuildDouble((double)ret);
            }
            else
            {
                throw new ArgumentException(string.Format("FFI: incorrect return type {0} from external function {1}:{2}",
                                                          activation.ReturnType.Name, activation.ModuleName, activation.FunctionName));
            }
            return(op);
        }
예제 #21
0
 public Interpreter(RuntimeCore runtimeCore, bool isFEP = false)
 {
     runtime = runtimeCore.ExecutiveProvider.CreateExecutive(runtimeCore, isFEP);
 }
예제 #22
0
        /// <summary>
        /// If the passed in value is not an array or an empty array or an array which contains only empty arrays, return false.
        /// Otherwise, return true;
        /// </summary>
        /// <param name="sv"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public static bool ContainsNonArrayElement(StackValue sv, RuntimeCore runtimeCore)
        {
            if (!sv.IsArray)
                return true;

            var array = runtimeCore.Heap.ToHeapObject<DSArray>(sv);
            return array.Values.Any(v => ContainsNonArrayElement(v, runtimeCore)); 
        }
예제 #23
0
        internal static void DebugRunnerStepIn(string includePath, string code, /*string logFile*/ Dictionary <int, List <string> > map,
                                               bool watchNestedMode = false, string defectID = "")
        {
            //Internal setup
            ProtoCore.Core core;
            DebugRunner    fsr;

            // Specify some of the requirements of IDE.
            var options = new ProtoCore.Options();

            options.ExecutionMode       = ProtoCore.ExecutionMode.Serial;
            options.SuppressBuildOutput = false;
            options.GCTempVarsOnDebug   = false;

            // Cyclic dependency threshold is lowered from the default (2000)
            // as this causes the test framework to be painfully slow
            options.kDynamicCycleThreshold = 5;

            // Pass the absolute path so that imported filepaths can be resolved
            // in "FileUtils.GetDSFullPathName()"
            if (!String.IsNullOrEmpty(includePath))
            {
                includePath = Path.GetDirectoryName(includePath);
                options.IncludeDirectories.Add(includePath);
            }


            core = new ProtoCore.Core(options);


            core.Compilers.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Compiler(core));
            core.Compilers.Add(ProtoCore.Language.kImperative, new ProtoImperative.Compiler(core));

            fsr = new DebugRunner(core);

            DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());

            //Run
            fsr.PreStart(code);


            RuntimeCore runtimeCore = fsr.runtimeCore;

            //StreamReader log = new StreamReader(logFile);

            //bool isPrevBreakAtPop = false;
            int    lineAtPrevBreak = -1;
            string symbolName      = null;

            DebugRunner.VMState vms = null;

            while (!fsr.isEnded)
            {
                vms = fsr.LastState;

                OpCode    opCode = OpCode.NONE;
                DebugInfo debug  = null;
                if (vms != null)
                {
                    // check if previous break is a POP
                    // if so, get the line no. and LHS
                    opCode = fsr.CurrentInstruction.opCode;
                    debug  = fsr.CurrentInstruction.debug;

                    if (opCode == ProtoCore.DSASM.OpCode.POP)
                    {
                        //isPrevBreakAtPop = true;
                        lineAtPrevBreak = vms.ExecutionCursor.StartInclusive.LineNo;
                    }
                }

                DebugRunner.VMState currentVms = fsr.Step();

                //if (isPrevBreakAtPop)

                if (debug != null)
                {
                    // Do not do the verification for imported DS files, for which the FilePath is non null
                    if (debug.Location.StartInclusive.SourceLocation.FilePath == null)
                    {
                        if (opCode == ProtoCore.DSASM.OpCode.POP)
                        {
                            VerifyWatch_Run(lineAtPrevBreak, runtimeCore.DebugProps.CurrentSymbolName, core, runtimeCore, map, watchNestedMode, defectID: defectID);
                        }
                        // if previous breakpoint was at a CALLR
                        else if (opCode == ProtoCore.DSASM.OpCode.CALLR)
                        {
                            if (runtimeCore.DebugProps.IsPopmCall)
                            {
                                int ci = (int)currentVms.mirror.MirrorTarget.rmem.GetAtRelative(ProtoCore.DSASM.StackFrame.kFrameIndexClass).opdata;
                                VerifyWatch_Run(InjectionExecutive.callrLineNo, runtimeCore.DebugProps.CurrentSymbolName, core, runtimeCore, map, watchNestedMode, ci, defectID);
                            }
                        }
                    }
                }
                //isPrevBreakAtPop = false;
            }
            runtimeCore.Cleanup();
        }
예제 #24
0
        public static bool IsUniform(StackValue sv, RuntimeCore runtimeCore)
        {
            if (!sv.IsArray)
                return false;

            if (Utils.ArrayUtils.GetTypeStatisticsForArray(sv, runtimeCore).Count != 1)
                return false;

            return true;
        }
예제 #25
0
        public static List<List<StackValue>> ComputeReducedParamsSuperset(List<StackValue> formalParams, List<ReplicationInstruction> replicationInstructions, RuntimeCore runtimeCore)
        {
            //Compute the reduced Type args
            List<List<StackValue>> reducedParams = new List<List<StackValue>>();

            List<StackValue> basicList = new List<StackValue>();

            //Copy the types so unaffected ones get copied back directly
            foreach (StackValue sv in formalParams)
                basicList.Add(sv);

            reducedParams.Add(basicList);


            foreach (ReplicationInstruction ri in replicationInstructions)
                if (ri.Zipped)
                {
                    foreach (int index in ri.ZipIndecies)
                    {
                        //This should generally be a collection, so we need to do a one phase unboxing
                        StackValue target = basicList[index];
                        StackValue reducedSV = StackValue.Null;

                        if (target.IsArray)
                        {

                            //Array arr = formalParams[index].Payload as Array;
                            var array = runtimeCore.Heap.ToHeapObject<DSArray>(basicList[index]);

                            //The elements of the array are still type structures
                            if (array.VisibleSize == 0)
                                reducedSV = StackValue.Null;
                            else
                            {
                                var arrayStats = ArrayUtils.GetTypeExamplesForLayer(basicList[index], runtimeCore).Values;

                                List<List<StackValue>> clonedList = new List<List<StackValue>>();

                                foreach (List<StackValue> list in reducedParams)
                                    clonedList.Add(list);

                                reducedParams.Clear();

                                foreach (StackValue sv in arrayStats)
                                {
                                    foreach (List<StackValue> lst in clonedList)
                                    {
                                        List<StackValue> newArgs = new List<StackValue>();
                                        
                                        newArgs.AddRange(lst);
                                        newArgs[index] = sv;

                                        reducedParams.Add(newArgs);
                                    }
                                    
                                }

                            }
                        }
                        else
                        {
                            System.Console.WriteLine("WARNING: Replication unbox requested on Singleton. Trap: 437AD20D-9422-40A3-BFFD-DA4BAD7F3E5F");
                            reducedSV = target;
                        }

                        //reducedType.IsIndexable = false;
                        //reducedParamTypes[index] = reducedSV;
                    }
                }
                else
                {
                    //This should generally be a collection, so we need to do a one phase unboxing
                    int index = ri.CartesianIndex;
                    //This should generally be a collection, so we need to do a one phase unboxing
                    StackValue target = basicList[index];
                    StackValue reducedSV = StackValue.Null;

                    if (target.IsArray)
                    {

                        //Array arr = formalParams[index].Payload as Array;
                        var array = runtimeCore.Heap.ToHeapObject<DSArray>(basicList[index]);



                        //It is a collection, so cast it to an array and pull the type of the first element
                        //@TODO(luke): Deal with sparse arrays, if the first element is null this will explode

                        //The elements of the array are still type structures
                        if (array.VisibleSize == 0)
                            reducedSV = StackValue.Null;
                        else
                        {
                            var arrayStats = ArrayUtils.GetTypeExamplesForLayer(basicList[index], runtimeCore).Values;

                            List<List<StackValue>> clonedList = new List<List<StackValue>>();

                            foreach (List<StackValue> list in reducedParams)
                                clonedList.Add(list);

                            reducedParams.Clear();
                        

                            foreach (StackValue sv in arrayStats)
                            {
                                foreach (List<StackValue> lst in clonedList)
                                {
                                    List<StackValue> newArgs = new List<StackValue>();

                                    newArgs.AddRange(lst);
                                    newArgs[index] = sv;

                                    reducedParams.Add(newArgs);
                                }

                            }

                        }
                    }
                    else
                    {
                        System.Console.WriteLine("WARNING: Replication unbox requested on Singleton. Trap: 437AD20D-9422-40A3-BFFD-DA4BAD7F3E5F");
                        reducedSV = target;
                    }
                }

            return reducedParams;

        }
예제 #26
0
        private static StackValue[] GetFlattenValue(StackValue array, RuntimeCore runtimeCore)
        {
            Queue<StackValue> workingSet = new Queue<StackValue>();
            List<StackValue> flattenValues = new List<StackValue>();

            if (!array.IsArray)
            {
                return null;
            }

            workingSet.Enqueue(array);
            while (workingSet.Count > 0)
            {
                array = workingSet.Dequeue();
                foreach (var value in runtimeCore.Heap.ToHeapObject<DSArray>(array).Values)
                {
                    if (value.IsArray)
                    {
                        workingSet.Enqueue(value);
                    }
                    else
                    {
                        flattenValues.Add(value);
                    }
                }
            }

            return flattenValues.ToArray();
        }
예제 #27
0
        public static List<List<ReplicationInstruction>> BuildReplicationCombinations(List<ReplicationInstruction> providedControl, List<StackValue> formalParams, RuntimeCore runtimeCore)
        {

            
            //@TODO: Performance hint - this should really be done with a yield-generator unless the parrallelism is useful
            //@ROSO: This is not generating a minimal set


            //First build a list of reducible parameters

            List<int> reducibles = new List<int>();

            int maxDepth = 0;

            for (int i = 0; i < formalParams.Count; i++)
            {
                int itemMaxDepth = GetMaxReductionDepth(formalParams[i], runtimeCore);

                if (itemMaxDepth > 0)
                    reducibles.Add(i);

                maxDepth = maxDepth + itemMaxDepth;
            }

            if (providedControl.Count > maxDepth)
            {
                throw new ReplicationCaseNotCurrentlySupported(
                    string.Format(Resources.MaxDimensionExceeded, "{1EC8AF3C-48D6-4582-999E-ADBCBF9155D1}"));
            }
            else
            {
                //Reduce the available reducions by the amount that we've been instructed to
                maxDepth -= providedControl.Count;
            }


            List<List<int>> cleanedReductions = new List<List<int>>();

            if (maxDepth > 0)
            {
                List<List<int>> reductions = new List<List<int>>();

                for (int i = 0; i <= maxDepth; i++)
                    reductions.AddRange(BuildAllocation(formalParams.Count, maxDepth));

                if (providedControl.Count > 0)
                {
                    //The add in the reductions associated with the provided controls.
                    //The silly copy-ctoring here is to avoid the issues of modifying a collection with an iterator on it
                    List<List<int>> completedReductions = new List<List<int>>();
                    
                    List<ReplicationInstruction> reversedControl = new List<ReplicationInstruction>();
                    reversedControl.AddRange(providedControl);
                    reversedControl.Reverse();

                    foreach (List<int> reduction in reductions)
                    {
                        List<int> reducitonList = new List<int>();
                        reducitonList.AddRange(reduction);

                        foreach (ReplicationInstruction ri in reversedControl)
                        {
                            if (!ri.Zipped)
                                reducitonList[ri.CartesianIndex] = reducitonList[ri.CartesianIndex] + 1;
                            else
                            {
                                foreach (int i in ri.ZipIndecies)
                                    reducitonList[i] = reducitonList[i] + 1;
                            }

                        }

                        completedReductions.Add(reducitonList);
                    }

                    reductions = completedReductions;

                }
                




                foreach (List<int> list in reductions)
                {
                    bool append = true;
                    for (int i = 0; i < list.Count; i++)
                        if (list[i] > GetMaxReductionDepth(formalParams[i], runtimeCore))
                        {
                            append = false;
                            break;
                        }

                    int acc = 0;
                    for (int i = 0; i < list.Count; i++)
                        acc += list[i];

                    //We must be reducing something
                    if (acc == 0)
                        append = false;

                    if (append)
                        cleanedReductions.Add(list);
                }



            }

            //if (providedControl.Count > 0)
            //    throw new NotImplementedException("begone.");


            List<List<ReplicationInstruction>> ret = new List<List<ReplicationInstruction>>();

            //At this stage cleanedReductions holds the number of times to try and reduce each argument
            //All options being suggested should be possible

            foreach (List<int> reduction in cleanedReductions)
            {

                ////@PERF - unify data formats so we don't have to do this conversion again
                //List<List<int>> partial = new List<List<int>>();
                //foreach (int i in reduction)
                //{
                //    if (i == 0)
                //        partial.Add(new List<int> { });
                //    else
                //        partial.Add(new List<int> { i });

                //}

                //ret.Add(ReductionToInstructions(reduction));//Replicator.Old_ConvertGuidesToInstructions(partial));
                ret.Add(ReductionToInstructions(reduction, providedControl));//Replicator.Old_ConvertGuidesToInstructions(partial));

            }

            return ret;


        }
예제 #28
0
        //@TODO(Luke): Add in the methods here that correspond to each of the internal datastructures in use by the executive
        //@TODO(Jun): if this method stays static, then the Heap needs to be referenced from a parameter
        /// <summary>
        /// Do the recursive unpacking of the data structure into mirror objects
        /// </summary>
        /// <param name="val"></param>
        /// <returns></returns>
        public static Obj Unpack(StackValue val, Heap heap, RuntimeCore runtimeCore, int type = (int)PrimitiveType.Pointer) 
        {
            Executable exe = runtimeCore.DSExecutable;
            switch (val.optype)
            {
                case AddressType.ArrayPointer:
                    {
                        DsasmArray ret = new DsasmArray();

                        //Pull the item out of the heap


                        var array = heap.ToHeapObject<DSArray>(val);

                        StackValue[] nodes = array.Values.ToArray();
                        ret.members = new Obj[array.Count];
                        for (int i = 0; i < ret.members.Length; i++)
                        {
                            ret.members[i] = Unpack(nodes[i], heap, runtimeCore, type);
                        }

                        // TODO Jun: ret.members[0] is hardcoded  and means we are assuming a homogenous collection
                        // How to handle mixed-type arrays?
                        Obj retO = new Obj(val) 
                        { 
                            Payload = ret, 
                        };

                        return retO;
                    }
                case AddressType.String:
                    {
                        string str = heap.ToHeapObject<DSString>(val).Value;
                        Obj o = new Obj(val)
                        {
                            Payload = str,
                        };
                        return o;
                    }
                case AddressType.Int:
                    {
                        Obj o = new Obj(val) 
                        { 
                            Payload = val.IntegerValue, 
                        };
                        return o;
                    }
                case AddressType.Boolean:
                    {
                        Obj o = new Obj(val)
                        {
                            Payload = val.BooleanValue,
                        };
                        return o;
                    }

                case AddressType.Null:
                    {
                        Obj o = new Obj(val) 
                        { 
                            Payload = null, 
                        };
                        return o;
                    }
                case AddressType.Char:
                    {
                        Obj o = new Obj(val) 
                        {
                            Payload = val.CharValue, 
                        };
                        return o;
                    }
                case AddressType.Double:
                    {
                        Obj o = new Obj(val) 
                        { 
                            Payload = val.DoubleValue,
                        };
                        return o;
                    }
                case AddressType.Pointer:
                    {
                        Obj o = new Obj(val) 
                        { 
                            Payload = val.Pointer,
                        };
                        return o;
                    }
                case AddressType.FunctionPointer:
                    {
                        Obj o = new Obj(val) 
                        { 
                            Payload = val.FunctionPointer, 
                        };
                        return o;
                    }
                case AddressType.Invalid:
                    {
                        return new Obj(val) {Payload = null};
                    }
                default:
                    {
                        throw new NotImplementedException(string.Format("unknown datatype {0}", val.optype.ToString()));
                    }
            }

        }
예제 #29
0
        /// <summary>
        /// array[index1][index2][...][indexN] = value, and
        /// indices = {index1, index2, ..., indexN}
        /// </summary>
        /// <param name="indices"></param>
        /// <param name="value"></param>
        /// <param name="t"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public StackValue SetValueForIndices(List <StackValue> indices, StackValue value, RuntimeCore runtimeCore)
        {
            StackValue[][] zippedIndices = ArrayUtils.GetZippedIndices(indices, runtimeCore);
            if (zippedIndices == null || zippedIndices.Length == 0)
            {
                return(StackValue.Null);
            }

            var t = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var);

            if (zippedIndices.Length == 1)
            {
                StackValue coercedData = TypeSystem.Coerce(value, t, runtimeCore);
                return(SetValueForIndices(zippedIndices[0], coercedData, runtimeCore));
            }

            if (value.IsArray)
            {
                // Replication happens on both side.
                DSArray dataElements = heap.ToHeapObject <DSArray>(value);
                int     length       = Math.Min(zippedIndices.Length, dataElements.Count);

                StackValue[] oldValues = new StackValue[length];
                for (int i = 0; i < length; ++i)
                {
                    StackValue coercedData = TypeSystem.Coerce(dataElements.GetValueAt(i), t, runtimeCore);
                    oldValues[i] = SetValueForIndices(zippedIndices[i], coercedData, runtimeCore);
                }

                // The returned old values shouldn't have any key-value pairs
                try
                {
                    return(heap.AllocateArray(oldValues));
                }
                catch (RunOutOfMemoryException)
                {
                    runtimeCore.RuntimeStatus.LogWarning(WarningID.RunOutOfMemory, Resources.RunOutOfMemory);
                    return(StackValue.Null);
                }
            }
            else
            {
                // Replication is only on the LHS, so collect all old values
                // and return them in an array.
                StackValue coercedData = TypeSystem.Coerce(value, t, runtimeCore);

                StackValue[] oldValues = new StackValue[zippedIndices.Length];
                for (int i = 0; i < zippedIndices.Length; ++i)
                {
                    oldValues[i] = SetValueForIndices(zippedIndices[i], coercedData, runtimeCore);
                }

                // The returned old values shouldn't have any key-value pairs
                try
                {
                    return(heap.AllocateArray(oldValues));
                }
                catch (RunOutOfMemoryException)
                {
                    runtimeCore.RuntimeStatus.LogWarning(WarningID.RunOutOfMemory, Resources.RunOutOfMemory);
                    return(StackValue.Null);
                }
            }
        }
예제 #30
0
 public static string GetStringValue(StackValue sv, RuntimeCore runtimeCore)
 {
     ProtoCore.DSASM.Mirror.ExecutionMirror mirror = new DSASM.Mirror.ExecutionMirror(new ProtoCore.DSASM.Executive(runtimeCore), runtimeCore);
     return mirror.GetStringValue(sv, runtimeCore.RuntimeMemory.Heap, 0, true);
 }
예제 #31
0
        /// <summary>
        /// For a class node using single inheritence, get the chain of inheritences
        /// </summary>
        /// <param name="cn"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public static List<int> GetConversionChain(ClassNode cn, RuntimeCore runtimeCore)
        {
            List<int> ret = new List<int>();
            /*
            //@TODO: Replace this with an ID
            ret.Add(core.classTable.list.IndexOf(cn));

            ClassNode target = cn;
            while (target.baseList.Count > 0)
            {
                Validity.Assert(target.baseList.Count == 1, "Multiple Inheritence not yet supported, {F5DDC58D-F721-4319-854A-622175AC43F8}");
                ret.Add(cn.baseList[0]);

                target = core.classTable.list[cn.baseList[0]];
            }
            */

            List<int> coercableTypes = new List<int>();

            foreach (int typeID in cn.CoerceTypes.Keys)
            {
                bool inserted = false;

                for (int i = 0; i < coercableTypes.Count; i++)
                {
                    if (cn.CoerceTypes[typeID] < cn.CoerceTypes[coercableTypes[i]])
                    {
                        inserted = true;
                        coercableTypes.Insert(typeID, i);
                        break;
                    }
                }
                if (!inserted)
                    coercableTypes.Add(typeID);
            }
            coercableTypes.Add(runtimeCore.DSExecutable.classTable.ClassNodes.IndexOf(cn));



            ret.AddRange(coercableTypes);
            return ret;

        }
예제 #32
0
 public static StackValue ConcatString(StackValue op1, StackValue op2, RuntimeCore runtimeCore)
 {
     var v1 = runtimeCore.RuntimeMemory.Heap.ToHeapObject<DSString>(op1).Value;
     var v2 = runtimeCore.RuntimeMemory.Heap.ToHeapObject<DSString>(op2).Value;
     return StackValue.BuildString(v1 + v2, runtimeCore.RuntimeMemory.Heap);
 }
예제 #33
0
        public static Dictionary<int, StackValue> GetTypeExamplesForLayer(StackValue array, RuntimeCore runtimeCore)
        {
            if (!array.IsArray)
            {
                Dictionary<int, StackValue> ret = new Dictionary<int, StackValue>();
                ret.Add(array.metaData.type, array);
                return ret;
            }

            Dictionary<int, StackValue> usageFreq = new Dictionary<int, StackValue>();

            //This is the element on the heap that manages the data structure
            var dsArray = runtimeCore.Heap.ToHeapObject<DSArray>(array);
            foreach (var sv in dsArray.Values)
            {
                if (!usageFreq.ContainsKey(sv.metaData.type))
                    usageFreq.Add(sv.metaData.type, sv);
            }

            return usageFreq;
        }
예제 #34
0
        /// <summary>
        /// This function takes a replication instruction set and uses it to compute all of the types that would be called
        /// </summary>
        /// <param name="formalParams"></param>
        /// <param name="replicationInstructions"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public static List<List<StackValue>> ComputeAllReducedParams(List<StackValue> formalParams, List<ReplicationInstruction> replicationInstructions, RuntimeCore runtimeCore)
        {
            List<List<StackValue>> ret; //= new List<List<StackValue>>();

            //First approximation generates possibilities that may never actually exist, due to 

            ret = ComputeReducedParamsSuperset(formalParams, replicationInstructions, runtimeCore);

            return ret;




        }
예제 #35
0
        /// <summary>
        /// If an empty array is passed, the result will be null
        /// if there are instances, but they share no common supertype the result will be var
        /// </summary>
        /// <param name="array"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public static ClassNode GetGreatestCommonSubclassForArray(StackValue array, RuntimeCore runtimeCore)
        {
            if (!array.IsArray)
                throw new ArgumentException("The stack value provided was not an array");

            Dictionary<ClassNode, int> typeStats = GetTypeStatisticsForArray(array, runtimeCore);


            //@PERF: This could be improved with a 
            List<List<int>> chains = new List<List<int>>();
            HashSet<int> commonTypeIDs = new HashSet<int>();

            foreach (ClassNode cn in typeStats.Keys)
            {
                List<int> chain = ClassUtils.GetClassUpcastChain(cn, runtimeCore);

                //Now add in the other conversions - as we don't have a common superclass yet
                //@TODO(Jun): Remove this hack when we have a proper casting structure
                foreach (int id in cn.CoerceTypes.Keys)
                    if (!chain.Contains(id))
                        chain.Add((id));

                chains.Add(chain);

                foreach (int nodeId in chain)
                    commonTypeIDs.Add(nodeId);

 

            }

            //Remove nulls if they exist
            {
 
            if (commonTypeIDs.Contains(
                (int)PrimitiveType.kTypeNull))
                commonTypeIDs.Remove((int)PrimitiveType.kTypeNull);

                List<List<int>> nonNullChains = new List<List<int>>();

                foreach (List<int> chain in chains)
                {
                    if (chain.Contains((int)PrimitiveType.kTypeNull))
                        chain.Remove((int)PrimitiveType.kTypeNull);

                    if (chain.Count > 0)
                        nonNullChains.Add(chain);
                }

                chains = nonNullChains;
                    
            }


            //Contract the hashset so that it contains only the nodes present in all chains
            //@PERF: this is very inefficent
            {
                foreach (List<int> chain in chains)
                {
                    commonTypeIDs.IntersectWith(chain);
                    

                }
            }

            //No common subtypes
            if (commonTypeIDs.Count == 0)
                return null;

            if (commonTypeIDs.Count == 1)
                return runtimeCore.DSExecutable.classTable.ClassNodes[commonTypeIDs.First()];


            List<int> lookupChain = chains[0];

            
            //Insertion sort the IDs, we may only have a partial ordering on them.
            List<int> orderedTypes = new List<int>();

            foreach (int typeToInsert in commonTypeIDs)
            {
                bool inserted = false;

                for (int i = 0; i < orderedTypes.Count; i++)
                {
                    int orderedType = orderedTypes[i];

                    if (lookupChain.IndexOf(typeToInsert) < lookupChain.IndexOf(orderedType))
                    {
                        inserted = true;
                        orderedTypes.Insert(i, typeToInsert);
                        break;
                    }
                }

                if (!inserted)
                    orderedTypes.Add(typeToInsert);
            }

            return runtimeCore.DSExecutable.classTable.ClassNodes[orderedTypes.First()];
        }
예제 #36
0
        /// <summary>
        /// Compute the effects of the replication guides on the formal parameter lists
        /// The results of this loose data, and will not be correct on jagged arrays of hetrogenius types
        /// </summary>
        /// <param name="formalParams"></param>
        /// <param name="replicationInstructions"></param>
        /// <returns></returns>
        public static List<StackValue> EstimateReducedParams(List<StackValue> formalParams, List<ReplicationInstruction> replicationInstructions, RuntimeCore runtimeCore)
        {
            //Compute the reduced Type args
            List<StackValue> reducedParamTypes = new List<StackValue>();

            //Copy the types so unaffected ones get copied back directly
            foreach (StackValue sv in formalParams)
                reducedParamTypes.Add(sv);


            foreach (ReplicationInstruction ri in replicationInstructions)
                if (ri.Zipped)
                {
                    foreach (int index in ri.ZipIndecies)
                    {
                        //This should generally be a collection, so we need to do a one phase unboxing
                        StackValue target = reducedParamTypes[index];
                        StackValue reducedSV = StackValue.Null;

                        if (target.IsArray)
                        {

                            //Array arr = formalParams[index].Payload as Array;
                            var array = runtimeCore.Heap.ToHeapObject<DSArray>(reducedParamTypes[index]);


                            //It is a collection, so cast it to an array and pull the type of the first element
                            //The elements of the array are still type structures
                            if (array.VisibleSize == 0)
                                reducedSV = StackValue.Null;
                            else
                                reducedSV = array.GetValueFromIndex(0, runtimeCore);
                        }
                        else
                        {
                            System.Console.WriteLine("WARNING: Replication unbox requested on Singleton. Trap: 437AD20D-9422-40A3-BFFD-DA4BAD7F3E5F");
                            reducedSV = target;
                        }

                        //reducedType.IsIndexable = false;
                        reducedParamTypes[index] = reducedSV;
                    }
                }
                else
                {
                    //This should generally be a collection, so we need to do a one phase unboxing
                    int index = ri.CartesianIndex;
                    StackValue target = reducedParamTypes[index];
                    StackValue reducedSV;

                    if (target.IsArray)
                    {
                        //ProtoCore.DSASM.Mirror.DsasmArray arr = formalParams[index].Payload as ProtoCore.DSASM.Mirror.DsasmArray;
                        var array = runtimeCore.Heap.ToHeapObject<DSArray>(reducedParamTypes[index]);

                        //The elements of the array are still type structures
                        //reducedType = arr.members[0].Type;
                        if (array.VisibleSize == 0)
                            reducedSV = StackValue.Null;
                        else
                            reducedSV = array.GetValueFromIndex(0, runtimeCore);

                    }
                    else
                    {
                        System.Console.WriteLine("WARNING: Replication unbox requested on Singleton. Trap: 437AD20D-9422-40A3-BFFD-DA4BAD7F3E5F");
                        reducedSV = target;
                    }

                    //reducedType.IsIndexable = false;
                    reducedParamTypes[index] = reducedSV;
                }

            return reducedParamTypes;

        }
예제 #37
0
        /// <summary>
        /// Generate type statistics for the whole array
        /// </summary>
        /// <param name="array"></param>
        /// <param name="core"></param>
        /// <returns></returns>
        public static Dictionary<ClassNode, int> GetTypeStatisticsForArray(StackValue array, RuntimeCore runtimeCore)
        {
            if (!array.IsArray)
            {
                Dictionary<ClassNode, int> ret = new Dictionary<ClassNode, int>();
                ret.Add(runtimeCore.DSExecutable.classTable.ClassNodes[array.metaData.type], 1);
                return ret;
            }

            Dictionary<ClassNode, int> usageFreq = new Dictionary<ClassNode, int>();

            //This is the element on the heap that manages the data structure
            var dsArray = runtimeCore.Heap.ToHeapObject<DSArray>(array);
            foreach (var sv in dsArray.Values)
            {
                if (sv.IsArray)
                {
                    //Recurse
                    Dictionary<ClassNode, int> subLayer = GetTypeStatisticsForArray(sv, runtimeCore);
                    foreach (ClassNode cn in subLayer.Keys)
                    {
                        if (!usageFreq.ContainsKey(cn))
                            usageFreq.Add(cn, 0);

                        usageFreq[cn] = usageFreq[cn] + subLayer[cn];

                    }
                }
                else
                {

                    ClassNode cn = runtimeCore.DSExecutable.classTable.ClassNodes[sv.metaData.type];
                    if (!usageFreq.ContainsKey(cn))
                        usageFreq.Add(cn, 0);

                    usageFreq[cn] = usageFreq[cn] + 1;
                }
            }

            return usageFreq;
        }
예제 #38
0
 ///// <summary>
 ///// Get the maximum depth to which an object can be reduced
 ///// </summary>
 ///// <param name="obj"></param>
 ///// <returns></returns>
 //[Obsolete]
 //public static int GetMaxReductionDepth(ProtoCore.Lang.Obj obj)
 //{
 //    if (!obj.Type.IsIndexable)
 //        return 0;
 //    else
 //    {
 //        return 1 + GetMaxReductionDepth((Obj)((DSASM.Mirror.DsasmArray)obj.Payload).members[0]);
 //    }
 //}
 
 /// <summary>
 /// Get the maximum depth to which an element can be reduced
 /// This will include cases where only partial reduction can be performed on jagged arrays
 /// </summary>
 /// <param name="sv"></param>
 /// <param name="core"></param>
 /// <returns></returns>
 public static int GetMaxReductionDepth(StackValue sv, RuntimeCore runtimeCore)
 {
     return RecursiveProtectGetMaxReductionDepth(sv, runtimeCore, 0);
     
 }
예제 #39
0
        private static int GetMaxRankForArray(StackValue array, RuntimeCore runtimeCore, int tracer)
        {
            if (tracer > RECURSION_LIMIT)
                throw new CompilerInternalException("Internal Recursion limit exceeded in Rank Check - Possible heap corruption {3317D4F6-4758-4C19-9680-75B68DA0436D}");

            if (!array.IsArray)
                return 0;
            //throw new ArgumentException("The stack value provided was not an array");

            int ret = 1;

            int largestSub = 0;

            //This is the element on the heap that manages the data structure
            foreach (var sv in runtimeCore.Heap.ToHeapObject<DSArray>(array).Values)
            {
                if (sv.IsArray)
                {
                    int subArrayRank = GetMaxRankForArray(sv, runtimeCore, tracer + 1);
                    largestSub = Math.Max(subArrayRank, largestSub);
                }
            }

            return largestSub + ret;
        }
예제 #40
0
 public Interpreter(RuntimeCore runtimeCore, bool isFEP = false)
 {
     runtime = runtimeCore.ExecutiveProvider.CreateExecutive(runtimeCore, isFEP);
 }
예제 #41
0
 public ProtoCore.DSASM.Executive CreateExecutive(RuntimeCore runtimeCore, bool isFep)
 {
     return(new InjectionExecutive(runtimeCore, isFep));
 }