Ejemplo n.º 1
0
        private PType LvalueToType(PLvalue lvalue, IList dynamicOpList, TLt genericToken, IList genericTypes)
        {
            PType type = LvalueToType(lvalue);

            if (genericToken != null)
            {
                type = new AGenericType(genericToken, type, new ArrayList());
                while (genericTypes.Count > 0)
                {
                    ((AGenericType)type).GetGenericTypes().Add(genericTypes[0]);
                }
            }
            foreach (PShadyDynamicOps op in dynamicOpList)
            {
                if (op is APointerShadyDynamicOps)
                {
                    APointerShadyDynamicOps aop = (APointerShadyDynamicOps)op;
                    type = new APointerType(aop.GetToken(), type);
                }
                else if (op is AArrayShadyDynamicOps)
                {
                    AArrayShadyDynamicOps aop = (AArrayShadyDynamicOps)op;
                    if (aop.GetExp() == null)
                    {
                        type = new ADynamicArrayType(aop.GetToken(), type);
                    }
                    else
                    {
                        type = new AArrayTempType(aop.GetToken(), type, aop.GetExp(), null);
                    }
                }
            }
            return(type);
        }
Ejemplo n.º 2
0
 private PType LvalueToType(PLvalue lvalue)
 {
     if (lvalue is AStructLvalue)
     {
         /*AStructLvalue structLvalue = (AStructLvalue) lvalue;
          * TIdentifier typeName = structLvalue.GetName();
          * if (structLvalue.GetReceiver() is ALvalueExp && ((ALvalueExp)structLvalue.GetReceiver()).GetLvalue() is AAmbiguousNameLvalue)
          * {
          *  AAmbiguousNameLvalue ambiguousNameLvalue = (AAmbiguousNameLvalue) ((ALvalueExp) structLvalue.GetReceiver()).GetLvalue();
          *  return new ANamedType(typeName, ((ASimpleName)ambiguousNameLvalue.GetAmbiguous()).GetIdentifier());
          * }
          * else*/
         {
             //errors.Add(new ErrorCollection.Error(((AStructLvalue)lvalue).GetName(), currentSourceFile, "Invalid type name. Must be \"<namespace>.<struct name>\"."));
             throw new ParserException(null, null);
         }
     }
     if (lvalue is AArrayLvalue)
     {
         AArrayLvalue aLvalue = (AArrayLvalue)lvalue;
         if (!(aLvalue.GetBase() is ALvalueExp))
         {
             //errors.Add(new ErrorCollection.Error(GetToken(lvalue), currentSourceFile, "Whatever that is, it's not allowed in a type"));
             throw new ParserException(null, null);
         }
         PLvalue newLvalue = ((ALvalueExp)aLvalue.GetBase()).GetLvalue();
         return(new AArrayTempType(aLvalue.GetToken(), LvalueToType(newLvalue), aLvalue.GetIndex(), null));
     }
     //it must be an AAmbiguousNameLvalue then
     return(new ANamedType(((AAmbiguousNameLvalue)lvalue).GetAmbiguous()));
 }
        private List <PStm> MakeStatements(PExp exp, int line, int pos)
        {
            List <PStm> list = new List <PStm>();

            if (exp is ASimpleInvokeExp)
            {
                list.Add(new AExpStm(new TSemicolon(";", line, pos), exp));
                return(list);
            }
            if (exp is AAssignmentExp)
            {
                list.Add(new AExpStm(new TSemicolon(";", line, pos), exp));
                return(list);
            }
            if (exp is ANonstaticInvokeExp)
            {
                list.Add(new AExpStm(new TSemicolon(";", line, pos), exp));
                return(list);
            }
            if (exp is ABinopExp)
            {
                ABinopExp aExp = (ABinopExp)exp;
                list.AddRange(MakeStatements(aExp.GetLeft(), line, pos));
                list.AddRange(MakeStatements(aExp.GetRight(), line, pos));
                return(list);
            }
            if (exp is AUnopExp)
            {
                AUnopExp aExp = (AUnopExp)exp;
                list.AddRange(MakeStatements(aExp.GetExp(), line, pos));
                return(list);
            }
            if (exp is AParenExp)
            {
                AParenExp aExp = (AParenExp)exp;
                list.AddRange(MakeStatements(aExp.GetExp(), line, pos));
                return(list);
            }
            if (exp is ALvalueExp)
            {
                ALvalueExp aExp   = (ALvalueExp)exp;
                PLvalue    lvalue = aExp.GetLvalue();
                if (lvalue is AStructLvalue)
                {
                    AStructLvalue aLvalue = (AStructLvalue)lvalue;
                    list.AddRange(MakeStatements(aLvalue.GetReceiver(), line, pos));
                    return(list);
                }
                if (lvalue is AArrayLvalue)
                {
                    AArrayLvalue aLvalue = (AArrayLvalue)lvalue;
                    list.AddRange(MakeStatements(aLvalue.GetBase(), line, pos));
                    list.AddRange(MakeStatements(aLvalue.GetIndex(), line, pos));
                    return(list);
                }
            }
            return(list);
        }
        private int FoldInt(PLvalue lvalue, ref bool valid)
        {
            if (!valid)
            {
                return(-1);
            }

            if (lvalue is ALocalLvalue)
            {
                ALocalLvalue aLvalue = (ALocalLvalue)lvalue;
                AALocalDecl  decl    = data.LocalLinks[aLvalue];
                if (decl.GetConst() == null)
                {
                    valid = false;
                    return(-1);
                }
                return(FoldInt(decl.GetInit(), ref valid));
            }
            if (lvalue is AFieldLvalue)
            {
                AFieldLvalue aLvalue = (AFieldLvalue)lvalue;
                AFieldDecl   decl    = data.FieldLinks[aLvalue];
                if (decl.GetConst() == null)
                {
                    valid = false;
                    return(-1);
                }
                return(FoldInt(decl.GetInit(), ref valid));
            }
            if (lvalue is AStructFieldLvalue)
            {
                AStructFieldLvalue aLvalue = (AStructFieldLvalue)lvalue;
                AALocalDecl        decl    = data.StructMethodFieldLinks[aLvalue];
                if (decl.GetConst() == null)
                {
                    valid = false;
                    return(-1);
                }
                return(FoldInt(decl.GetInit(), ref valid));
            }
            if (lvalue is AStructLvalue)
            {
                AStructLvalue aLvalue = (AStructLvalue)lvalue;
                AALocalDecl   decl    = data.StructFieldLinks[aLvalue];
                if (decl.GetConst() == null)
                {
                    valid = false;
                    return(-1);
                }
                return(FoldInt(decl.GetInit(), ref valid));
            }

            valid = false;
            return(-1);
        }
Ejemplo n.º 5
0
        public static PLvalue MakeClone(PLvalue lvalue, SharedData data)
        {
            if (lvalue == null)
            {
                return(null);
            }
            PLvalue clone = (PLvalue)lvalue.Clone();

            MakeCloneRefferences(clone, lvalue, data);
            return(clone);
        }
Ejemplo n.º 6
0
        public override void CaseAAssignmentExp(AAssignmentExp node)
        {
            if (!(node.Parent() is AExpStm))
            {
                PStm parentStm = Util.GetAncestor <PStm>(node);

                MoveMethodDeclsOut mover = new MoveMethodDeclsOut("multipleAssignmentsVar", finalTrans.data);
                node.GetLvalue().Apply(mover);
                PLvalue    lvalue = Util.MakeClone(node.GetLvalue(), finalTrans.data);
                ALvalueExp exp    = new ALvalueExp(lvalue);
                finalTrans.data.ExpTypes[exp] = finalTrans.data.LvalueTypes[lvalue];
                node.ReplaceBy(exp);

                AExpStm stm = new AExpStm(new TSemicolon(";"), node);



                AABlock block = (AABlock)parentStm.Parent();
                //block.GetStatements().Insert(block.GetStatements().IndexOf(parentStm), localDeclStm);
                block.GetStatements().Insert(block.GetStatements().IndexOf(parentStm), stm);

                //localDeclStm.Apply(this);
                stm.Apply(this);

                if (parentStm is AWhileStm && Util.IsAncestor(exp, ((AWhileStm)parentStm).GetCondition()))
                {
                    AWhileStm aStm = (AWhileStm)parentStm;
                    //Copy assignment before continues
                    //Before each continue in the while, and at the end.

                    //Add continue statement, if not present
                    block = (AABlock)((ABlockStm)aStm.GetBody()).GetBlock();
                    if (block.GetStatements().Count == 0 || !(block.GetStatements()[block.GetStatements().Count - 1] is AContinueStm))
                    {
                        block.GetStatements().Add(new AContinueStm(new TContinue("continue")));
                    }

                    //Get all continue statements in the while
                    ContinueFinder finder = new ContinueFinder();
                    block.Apply(finder);
                    foreach (AContinueStm continueStm in finder.Continues)
                    {
                        stm = new AExpStm(new TSemicolon(";"), Util.MakeClone(node, finalTrans.data));
                        block.GetStatements().Insert(block.GetStatements().IndexOf(continueStm), stm);

                        stm.Apply(this);
                    }
                }
                return;
            }

            base.CaseAAssignmentExp(node);
        }
Ejemplo n.º 7
0
        private void MakeAssignments(AABlock block, PType type, PLvalue leftSide, bool onEnhritedFields)
        {
            if (type is ANamedType && data.StructTypeLinks.ContainsKey((ANamedType)type))
            {
                AStructDecl str = data.StructTypeLinks[(ANamedType)type];
                foreach (AALocalDecl field in str.GetLocals().OfType <AALocalDecl>())
                {
                    if (!onEnhritedFields && data.EnheritanceLocalMap.ContainsKey(field))
                    {
                        continue;
                    }

                    ALvalueExp lvalueExp = new ALvalueExp(Util.MakeClone(leftSide, data));
                    data.ExpTypes[lvalueExp] = data.LvalueTypes[leftSide];
                    AStructLvalue newLeftSide = new AStructLvalue(lvalueExp, new ADotDotType(new TDot(".")), new TIdentifier(field.GetName().Text));
                    data.StructFieldLinks[newLeftSide] = field;
                    data.LvalueTypes[newLeftSide]      = field.GetType();

                    if (field.GetInit() != null)
                    {
                        AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), newLeftSide,
                                                                       Util.MakeClone(field.GetInit(), data));
                        data.ExpTypes[assignment] = data.LvalueTypes[newLeftSide];

                        block.GetStatements().Add(new AExpStm(new TSemicolon(";"),
                                                              assignment));
                    }
                    else
                    {
                        MakeAssignments(block, field.GetType(), newLeftSide, onEnhritedFields);
                    }
                }
            }
            else if (type is AArrayTempType)
            {
                AArrayTempType aType = (AArrayTempType)type;
                for (int i = 0; i < int.Parse(aType.GetIntDim().Text); i++)
                {
                    AIntConstExp index = new AIntConstExp(new TIntegerLiteral(i.ToString()));
                    data.ExpTypes[index] = new ANamedType(new TIdentifier("int"), null);

                    ALvalueExp lvalueExp = new ALvalueExp(Util.MakeClone(leftSide, data));
                    data.ExpTypes[lvalueExp] = data.LvalueTypes[leftSide];
                    AArrayLvalue newLeftSide = new AArrayLvalue(new TLBracket("["), lvalueExp, index);
                    data.LvalueTypes[newLeftSide] = aType.GetType();

                    MakeAssignments(block, aType.GetType(), newLeftSide, onEnhritedFields);
                }
            }
        }
Ejemplo n.º 8
0
 public static bool ReturnsTheSame(PLvalue left, PLvalue right, SharedData data)
 {
     if (left.GetType() != right.GetType())
     {
         return(false);
     }
     if (left is ALocalLvalue)
     {
         ALocalLvalue aLeft  = (ALocalLvalue)left;
         ALocalLvalue aRight = (ALocalLvalue)right;
         return(data.LocalLinks[aLeft] == data.LocalLinks[aRight]);
     }
     if (left is AFieldLvalue)
     {
         AFieldLvalue aLeft  = (AFieldLvalue)left;
         AFieldLvalue aRight = (AFieldLvalue)right;
         return(data.FieldLinks[aLeft] == data.FieldLinks[aRight]);
     }
     if (left is AStructLvalue)
     {
         AStructLvalue aLeft  = (AStructLvalue)left;
         AStructLvalue aRight = (AStructLvalue)right;
         if (data.StructFieldLinks[aLeft] != data.StructFieldLinks[aRight])
         {
             return(false);
         }
         return(ReturnsTheSame(aLeft.GetReceiver(), aRight.GetReceiver(), data));
     }
     if (left is AArrayLvalue)
     {
         AArrayLvalue aLeft  = (AArrayLvalue)left;
         AArrayLvalue aRight = (AArrayLvalue)right;
         return(ReturnsTheSame(aLeft.GetIndex(), aRight.GetIndex(), data) &&
                ReturnsTheSame(aLeft.GetBase(), aRight.GetBase(), data));
     }
     throw new Exception("Util.ReturnsTheSame. Unexpected type, got " + left.GetType());
 }
Ejemplo n.º 9
0
            public override void DefaultIn(Node node)
            {
                //
                int index = 0;
                GetChildTypeIndex getChildTypeIndex = new GetChildTypeIndex()
                {
                    Parent = node.Parent(), Child = node
                };

                node.Parent().Apply(getChildTypeIndex);
                index = getChildTypeIndex.Index;
                GetChildTypeByIndex getChildTypeByIndex = new GetChildTypeByIndex()
                {
                    Child = node, Index = index, Parent = currentCloneNode
                };

                currentCloneNode.Apply(getChildTypeByIndex);
                currentCloneNode = getChildTypeByIndex.Child;

                //currentCloneNode should now be the clone corrosponding to node.

                /*finalTrans.data.ExpTypes
                 * finalTrans.data.FieldLinks
                 * finalTrans.data.LocalLinks
                 * finalTrans.data.Locals//Lets forget about this one
                 * finalTrans.data.LvalueTypes
                 * finalTrans.data.SimpleMethodLinks
                 * finalTrans.data.StructFieldLinks
                 * finalTrans.data.StructMethodLinks
                 * finalTrans.data.StructTypeLinks*/
                if (node is ANewExp && finalTrans.data.ConstructorLinks.ContainsKey((ANewExp)node))
                {
                    finalTrans.data.ConstructorLinks[(ANewExp)currentCloneNode] = finalTrans.data.ConstructorLinks[(ANewExp)node];
                }

                if (node is PExp)
                {
                    finalTrans.data.ExpTypes[(PExp)currentCloneNode] = finalTrans.data.ExpTypes[(PExp)node];
                }

                if (node is AStringConstExp && finalTrans.data.TriggerDeclarations.Any(p => p.Value.Contains(((AStringConstExp)node).GetStringLiteral())))
                {
                    finalTrans.data.TriggerDeclarations.First(
                        p => p.Value.Contains(((AStringConstExp)node).GetStringLiteral())).Value.Add(
                        ((AStringConstExp)currentCloneNode).GetStringLiteral());
                }
                if (node is AFieldLvalue)
                {
                    finalTrans.data.FieldLinks[(AFieldLvalue)currentCloneNode] = finalTrans.data.FieldLinks[(AFieldLvalue)node];
                }
                if (node is ALocalLvalue)
                {
                    AALocalDecl originalFormal = finalTrans.data.LocalLinks[(ALocalLvalue)node];

                    PLvalue replacer = Util.MakeClone(localMap[originalFormal],
                                                      finalTrans.data);
                    currentCloneNode.ReplaceBy(replacer);
                    currentCloneNode = replacer;

                    if (localExpMap.ContainsKey(originalFormal))
                    {
                        ReplaceUsAfter[replacer] = localExpMap[originalFormal];
                    }
                }
                if (node is AALocalDecl)
                {
                    ALocalLvalue replacer = new ALocalLvalue(new TIdentifier("IwillGetRenamedLater"));
                    finalTrans.data.LvalueTypes[replacer] = ((AALocalDecl)currentCloneNode).GetType();
                    finalTrans.data.LocalLinks[replacer]  = (AALocalDecl)currentCloneNode;
                    localMap.Add((AALocalDecl)node, replacer);
                }
                if (node is PLvalue)
                {
                    finalTrans.data.LvalueTypes[(PLvalue)currentCloneNode] = finalTrans.data.LvalueTypes[(PLvalue)node];
                }
                if (node is ASimpleInvokeExp)
                {
                    finalTrans.data.SimpleMethodLinks[(ASimpleInvokeExp)currentCloneNode] = finalTrans.data.SimpleMethodLinks[(ASimpleInvokeExp)node];
                }
                if (node is AStructLvalue)
                {
                    finalTrans.data.StructFieldLinks[(AStructLvalue)currentCloneNode] = finalTrans.data.StructFieldLinks[(AStructLvalue)node];
                }
                if (node is ANonstaticInvokeExp)
                {
                    finalTrans.data.StructMethodLinks[(ANonstaticInvokeExp)currentCloneNode] = finalTrans.data.StructMethodLinks[(ANonstaticInvokeExp)node];
                }
                if (node is ANamedType && finalTrans.data.StructTypeLinks.Keys.Contains(node))
                {
                    finalTrans.data.StructTypeLinks[(ANamedType)currentCloneNode] = finalTrans.data.StructTypeLinks[(ANamedType)node];
                }
                if (node is ANamedType && finalTrans.data.DelegateTypeLinks.Keys.Contains(node))
                {
                    finalTrans.data.DelegateTypeLinks[(ANamedType)currentCloneNode] = finalTrans.data.DelegateTypeLinks[(ANamedType)node];
                }
                if (node is APropertyLvalue && finalTrans.data.PropertyLinks.ContainsKey((APropertyLvalue)node))
                {
                    finalTrans.data.PropertyLinks[(APropertyLvalue)currentCloneNode] = finalTrans.data.PropertyLinks[(APropertyLvalue)node];
                }
            }
Ejemplo n.º 10
0
 private void RegiseterUse(PLvalue lvalue, List<AALocalDecl> tail)
 {
     if (tail == null) tail = new List<AALocalDecl>();
     if (lvalue.Parent().Parent() is AStructLvalue)
     {
         AStructLvalue parent = (AStructLvalue)lvalue.Parent().Parent();
         AALocalDecl local = data.StructFieldLinks[parent];
         AALocalDecl baseLocal = local;
         if (data.EnheritanceLocalMap.ContainsKey(baseLocal))
             baseLocal = data.EnheritanceLocalMap[baseLocal];
         AStructDecl pStruct = (AStructDecl) local.Parent();
         List<AALocalDecl> localsToTail = new List<AALocalDecl>();
         localsToTail.AddRange(
             data.EnheritanceLocalMap.Where(
                 pair =>
                 pair.Value == baseLocal && Util.Extends(pStruct, (AStructDecl) pair.Key.Parent(), data))
                 .Select(pair => pair.Key));
         //If local == baseLocal, nothing is stored in enhritancelocalmap for them.
         if (local == baseLocal)
             localsToTail.Add(local);
         foreach (AALocalDecl l in localsToTail)
         {
             List<AALocalDecl> newTail = new List<AALocalDecl>();
             newTail.AddRange(tail);
             newTail.Add(l);
             RegiseterUse(parent, newTail);
         }
         return;
     }
     UsedParameters.Add(tail);
 }
Ejemplo n.º 11
0
 public ADelegateExp(
         TDelegate _token_,
         PType _type_,
         PLvalue _lvalue_
 )
 {
     SetToken(_token_);
     SetType(_type_);
     SetLvalue(_lvalue_);
 }
Ejemplo n.º 12
0
 public AAsyncInvokeStm(
         TAsyncInvoke _token_,
         PLvalue _name_,
         IList _args_
 )
 {
     SetToken(_token_);
     SetName(_name_);
     this._args_ = new TypedList(new Args_Cast(this));
     this._args_.Clear();
     this._args_.AddAll(_args_);
 }
Ejemplo n.º 13
0
 internal override void RemoveChild(Node child)
 {
     if (_const_ == child)
     {
         _const_ = null;
         return;
     }
     if (_pre_pointers_.Contains(child))
     {
         _pre_pointers_.Remove(child);
         return;
     }
     if (_lvalue_ == child)
     {
         _lvalue_ = null;
         return;
     }
     if (_generic_token_ == child)
     {
         _generic_token_ = null;
         return;
     }
     if (_generic_types_.Contains(child))
     {
         _generic_types_.Remove(child);
         return;
     }
     if (_post_pointers_.Contains(child))
     {
         _post_pointers_.Remove(child);
         return;
     }
     if (_local_decl_right_.Contains(child))
     {
         _local_decl_right_.Remove(child);
         return;
     }
 }
Ejemplo n.º 14
0
 internal override void RemoveChild(Node child)
 {
     if (_assignop_ == child)
     {
         _assignop_ = null;
         return;
     }
     if (_lvalue_ == child)
     {
         _lvalue_ = null;
         return;
     }
     if (_exp_ == child)
     {
         _exp_ = null;
         return;
     }
 }
Ejemplo n.º 15
0
 public ALvalueExp(
         PLvalue _lvalue_
 )
 {
     SetLvalue(_lvalue_);
 }
Ejemplo n.º 16
0
            private void CheckDynamicLvalue(PLvalue node)
            {
                if (node.Parent() is ALvalueExp)
                {
                    ALvalueExp parent = (ALvalueExp)node.Parent();
                    if (parent.Parent() is AAssignmentExp)
                        return;
                    if (!(parent.Parent() is PLvalue))
                    {//Then this should be a data table get
                        //If this is a bulk copy type, move it out to a new variable.
                        //var pointerVar;
                        //pointerVar = dataTableGet(...)
                        //...
                        PType type = data.ExpTypes[parent];
                        if (Util.IsBulkCopy(type))
                        {
                            PStm pStm = Util.GetAncestor<PStm>(node);
                            AABlock pBlock = (AABlock)pStm.Parent();
                            AAssignmentExp assignment;
                            if (parent.Parent() is AALocalDecl)
                            {
                                //Turn into assignment
                                ALocalLvalue leftSide = new ALocalLvalue(new TIdentifier("tempName"));
                                data.LocalLinks[leftSide] = (AALocalDecl) parent.Parent();
                                assignment = new AAssignmentExp(new TAssign("="), leftSide, parent);

                                pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(pStm) + 1, new AExpStm(new TSemicolon(";"), assignment));

                                data.ExpTypes[assignment] =  data.LvalueTypes[leftSide] = data.LocalLinks[leftSide].GetType();
                                assignment.Apply(this);
                                return;
                            }

                            pStm = Util.GetAncestor<PStm>(node);
                            AALocalDecl localDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, Util.MakeClone(type, data), new TIdentifier("pointerVar"), null);
                            ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier("pointerVar"));
                            ALocalLvalue lvalue2 = new ALocalLvalue(new TIdentifier("pointerVar"));
                            ALvalueExp lvalue2Exp = new ALvalueExp(lvalue2);
                            parent.ReplaceBy(lvalue2Exp);
                            assignment = new AAssignmentExp(new TAssign("="), lvalue, parent);
                            pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(pStm), new ALocalDeclStm(new TSemicolon(";"), localDecl));
                            pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(pStm), new AExpStm(new TSemicolon(";"), assignment));

                            data.LocalLinks[lvalue] = localDecl;
                            data.LocalLinks[lvalue2] = localDecl;
                            data.ExpTypes[assignment] = data.ExpTypes[lvalue2Exp] = data.LvalueTypes[lvalue] = data.LvalueTypes[lvalue2] = type;

                            assignmentRightSideSet = true;
                            assignment.Apply(this);
                        }
                        else
                        {
                            string s = "string";
                            if (type is ANamedType)
                                s = ((ANamedType) type).AsIdentifierString();
                            else if (type is APointerType && Util.IsIntPointer(node, ((APointerType)type).GetType(), data))
                            {
                                s = "int";
                            }
                            parent.ReplaceBy(CreateDynaicGetStm(s));
                        }
                        hadPointer = false;
                    }
                }
            }
Ejemplo n.º 17
0
 bool IsConstant(PLvalue lvalue)
 {
     if (lvalue is ALocalLvalue)
     {
         ALocalLvalue aLvalue = (ALocalLvalue)lvalue;
         AALocalDecl  decl    = data.LocalLinks[aLvalue];
         if (decl == initialLocalDecl)
         {
             return(false);
         }
         return(decl.GetConst() != null && IsConstant(decl.GetInit()));
     }
     if (lvalue is AFieldLvalue)
     {
         AFieldLvalue aLvalue = (AFieldLvalue)lvalue;
         AFieldDecl   decl    = data.FieldLinks[aLvalue];
         if (decl == initialFieldDecl)
         {
             return(false);
         }
         return(decl.GetConst() != null && IsConstant(decl.GetInit()));
     }
     if (lvalue is APropertyLvalue)
     {
         return(false);
     }
     if (lvalue is ANamespaceLvalue)
     {
         return(true);
     }
     if (lvalue is AStructFieldLvalue)
     {
         AStructFieldLvalue aLvalue = (AStructFieldLvalue)lvalue;
         AALocalDecl        decl    = data.StructMethodFieldLinks[aLvalue];
         if (decl == initialLocalDecl)
         {
             return(false);
         }
         return(decl.GetConst() != null && IsConstant(decl.GetInit()));
     }
     if (lvalue is AStructLvalue)
     {
         AStructLvalue aLvalue = (AStructLvalue)lvalue;
         AALocalDecl   decl    = data.StructFieldLinks[aLvalue];
         if (decl == initialLocalDecl)
         {
             return(false);
         }
         return(decl.GetConst() != null && IsConstant(decl.GetInit()));
     }
     if (lvalue is AArrayLvalue)
     {
         AArrayLvalue aLvalue = (AArrayLvalue)lvalue;
         return(IsConstant(aLvalue.GetIndex()) && IsConstant(aLvalue.GetBase()));
     }
     if (lvalue is APointerLvalue)
     {
         APointerLvalue aLvalue = (APointerLvalue)lvalue;
         return(IsConstant(aLvalue.GetBase()));
     }
     if (lvalue is APArrayLengthLvalue)
     {
         APArrayLengthLvalue aLvalue = (APArrayLengthLvalue)lvalue;
         return(data.ExpTypes[aLvalue.GetBase()] is AArrayTempType);
     }
     if (lvalue is AThisLvalue)
     {
         return(false);
     }
     if (lvalue is AValueLvalue)
     {
         return(false);
     }
     throw new Exception("Unexpected lvalue. Got " + lvalue);
 }
        private List<PStm> AssignDefault(PLvalue lvalue)
        {
            List<PStm> returner = new List<PStm>();
            PType type = data.LvalueTypes[lvalue];
            PExp rightSide = null;
            if (type is ANamedType)
            {
                ANamedType aType = (ANamedType)type;
                if (aType.IsPrimitive("string"))//aType.GetName().Text == "string")
                {
                    rightSide = new AStringConstExp(new TStringLiteral("\"\""));
                    data.ExpTypes[rightSide] = new ANamedType(new TIdentifier("string"), null);
                }
                else if (aType.IsPrimitive(GalaxyKeywords.NullablePrimitives.words)) //GalaxyKeywords.NullablePrimitives.words.Contains(aType.GetName().Text))
                {
                    rightSide = new ANullExp();
                    data.ExpTypes[rightSide] = new ANamedType(new TIdentifier("null"), null);
                }
                else if (aType.IsPrimitive(new []{"int", "byte", "fixed"}))
                    /*aType.GetName().Text == "int" ||
                    aType.GetName().Text == "byte" ||
                    aType.GetName().Text == "fixed")*/
                {
                    rightSide = new AIntConstExp(new TIntegerLiteral("0"));
                    data.ExpTypes[rightSide] = type;
                }
                else if (aType.IsPrimitive("bool"))//aType.GetName().Text == "bool")
                {
                    rightSide = new ABooleanConstExp(new AFalseBool());
                    data.ExpTypes[rightSide] = type;
                }
                else if (aType.IsPrimitive("color"))//aType.GetName().Text == "color")
                {
                    PExp arg1 = new AIntConstExp(new TIntegerLiteral("0"));
                    PExp arg2 = new AIntConstExp(new TIntegerLiteral("0"));
                    PExp arg3 = new AIntConstExp(new TIntegerLiteral("0"));
                    ASimpleInvokeExp invoke = new ASimpleInvokeExp(new TIdentifier("Color"), new ArrayList() { arg1, arg2, arg3 });
                    rightSide = invoke;
                    data.ExpTypes[rightSide] = type;
                    data.ExpTypes[arg1] =
                        data.ExpTypes[arg2] =
                        data.ExpTypes[arg3] = new ANamedType(new TIdentifier("int"), null);
                    data.SimpleMethodLinks[invoke] =
                        data.Libraries.Methods.First(func => func.GetName().Text == invoke.GetName().Text);
                }
                else if (aType.IsPrimitive("char"))//aType.GetName().Text == "char")
                {
                    //Dunno?!
                    rightSide = new ACharConstExp(new TCharLiteral("'\0'"));
                    data.ExpTypes[rightSide] = type;
                }
                else //Struct
                {
                    AStructDecl str = data.StructTypeLinks[aType];
                    foreach (AALocalDecl localDecl in str.GetLocals())
                    {
                        ALvalueExp reciever = new ALvalueExp(Util.MakeClone(lvalue, data));
                        AStructLvalue newLvalue = new AStructLvalue(reciever, new ADotDotType(new TDot(".")), new TIdentifier(localDecl.GetName().Text));
                        data.StructFieldLinks[newLvalue] = localDecl;
                        data.ExpTypes[reciever] = type;
                        data.LvalueTypes[newLvalue] = localDecl.GetType();
                        returner.AddRange(AssignDefault(newLvalue));
                    }
                    return returner;
                }
                AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), Util.MakeClone(lvalue, data), rightSide);
                data.ExpTypes[assignment] = type;
                return new List<PStm>() { new AExpStm(new TSemicolon(";"), assignment) };
            }
            if (type is AArrayTempType)
            {
                AArrayTempType aType = (AArrayTempType)type;
                for (int i = 0; i < int.Parse(aType.GetIntDim().Text); i++)
                {
                    ALvalueExp reciever = new ALvalueExp(Util.MakeClone(lvalue, data));
                    AArrayLvalue newLvalue = new AArrayLvalue(new TLBracket("["), reciever, new AIntConstExp(new TIntegerLiteral(i.ToString())));
                    data.ExpTypes[reciever] = type;
                    data.LvalueTypes[newLvalue] = aType.GetType();
                    data.ExpTypes[newLvalue.GetIndex()] = new ANamedType(new TIdentifier("int"), null);
                    returner.AddRange(AssignDefault(newLvalue));
                }
                return returner;
            }

            throw new Exception("Unexpected type. (LivenessAnalasys.AssignDefault), got " + type);
        }
Ejemplo n.º 19
0
            private List<PStm> MakeAssignments(PLvalue lvalue, PExp exp, List<AALocalDecl> declChain)
            {
                PType type = data.LvalueTypes[lvalue]; //data.ExpTypes[exp];
                PType oldType = data.ExpTypes[exp];
                List<PStm> returner = new List<PStm>();
                if (type is ADynamicArrayType ||type is AArrayTempType)
                {
                    AArrayTempType aType;
                    if (type is ADynamicArrayType)
                        aType = (AArrayTempType) data.LvalueTypes[lvalue];
                    else
                        aType = (AArrayTempType) type;
                    for (int j = 0; j < int.Parse(aType.GetIntDim().Text); j++)
                    {
                        ALvalueExp bulkCopyRefExp = new ALvalueExp(Util.MakeClone(lvalue, data));
                        AIntConstExp index1 = new AIntConstExp(new TIntegerLiteral(j.ToString()));
                        AArrayLvalue leftSideIndex = new AArrayLvalue(new TLBracket("{"), bulkCopyRefExp, index1);

                        AIntConstExp index2 = new AIntConstExp(new TIntegerLiteral(j.ToString()));
                        AArrayLvalue rightSideIndex = new AArrayLvalue(new TLBracket("{"), Util.MakeClone(exp, data), index2);
                        ALvalueExp rightSideExp = new ALvalueExp(rightSideIndex);
                        data.ExpTypes[bulkCopyRefExp] = data.LvalueTypes[lvalue];
                        data.ExpTypes[index1] =
                            data.ExpTypes[index2] = new ANamedType(new TIdentifier("int"), null);
                        data.LvalueTypes[leftSideIndex] =
                            data.LvalueTypes[rightSideIndex] =
                            data.ExpTypes[rightSideExp] = aType.GetType();
                        returner.AddRange(MakeAssignments(leftSideIndex, rightSideExp, declChain));
                    }
                }
                else if (type is ANamedType)
                {
                    ANamedType aType = (ANamedType) type;
                    if (Util.IsBulkCopy(type))
                    {
                        AStructDecl str = data.StructTypeLinks[aType];
                        foreach (AALocalDecl localDecl in str.GetLocals())
                        {
                            ALvalueExp bulkCopyRefExp = new ALvalueExp(Util.MakeClone(lvalue, data));
                            AStructLvalue leftSide = new AStructLvalue(bulkCopyRefExp, new ADotDotType(new TDot(".")),
                                                                       new TIdentifier(localDecl.GetName().Text));

                            AStructLvalue rightSide = new AStructLvalue(Util.MakeClone(exp, data), new ADotDotType(new TDot(".")),
                                                                       new TIdentifier(localDecl.GetName().Text));
                            ALvalueExp rightSideExp = new ALvalueExp(rightSide);
                            List<AALocalDecl> newDeclChain = new List<AALocalDecl>();
                            newDeclChain.AddRange(declChain);
                            newDeclChain.Add(localDecl);
                            data.StructFieldLinks[leftSide] =
                                data.StructFieldLinks[rightSide] = localDecl;
                            data.ExpTypes[bulkCopyRefExp] = data.LvalueTypes[lvalue];
                            data.LvalueTypes[leftSide] =
                                data.LvalueTypes[rightSide] =
                                data.ExpTypes[rightSideExp] = localDecl.GetType();
                            returner.AddRange(MakeAssignments(leftSide, rightSideExp, newDeclChain));
                        }
                    }
                    else
                    {
                        //Primitive, find out if it is used
                        if (declChain[0] == null || UsedParameters[Util.GetAncestor<AMethodDecl>(declChain[0])].Where(usedParameter => usedParameter.Count <= declChain.Count).Any(
                                usedParameter => !usedParameter.Where((t, i) => t != declChain[i]).Any()))
                        {
                            AAssignmentExp assignment = new AAssignmentExp(new TAssign("="),
                                                                           Util.MakeClone(lvalue, data),
                                                                           Util.MakeClone(exp, data));
                            data.ExpTypes[assignment] = data.LvalueTypes[lvalue];
                            returner.Add(new AExpStm(new TSemicolon(";"), assignment));
                        }
                    }
                }
                else if (type is APointerType)
                {
                    //Assign as primitive, find out if it is used
                    if (declChain[0] == null || UsedParameters[Util.GetAncestor<AMethodDecl>(declChain[0])].Where(usedParameter => usedParameter.Count <= declChain.Count).Any(
                            usedParameter => !usedParameter.Where((t, i) => t != declChain[i]).Any()))
                    {
                        AAssignmentExp assignment = new AAssignmentExp(new TAssign("="),
                                                                       Util.MakeClone(lvalue, data),
                                                                       Util.MakeClone(exp, data));
                        data.ExpTypes[assignment] = data.LvalueTypes[lvalue];
                        returner.Add(new AExpStm(new TSemicolon(";"), assignment));
                    }
                }
                else
                {
                    throw new Exception("Unexpected type. Got " + (type == null ? "null" : type.ToString()));
                }
                return returner;
            }
 private PType LvalueToType(PLvalue lvalue)
 {
     if (lvalue is AStructLvalue)
     {
         /*AStructLvalue structLvalue = (AStructLvalue) lvalue;
         TIdentifier typeName = structLvalue.GetName();
         if (structLvalue.GetReceiver() is ALvalueExp && ((ALvalueExp)structLvalue.GetReceiver()).GetLvalue() is AAmbiguousNameLvalue)
         {
             AAmbiguousNameLvalue ambiguousNameLvalue = (AAmbiguousNameLvalue) ((ALvalueExp) structLvalue.GetReceiver()).GetLvalue();
             return new ANamedType(typeName, ((ASimpleName)ambiguousNameLvalue.GetAmbiguous()).GetIdentifier());
         }
         else*/
         {
             //errors.Add(new ErrorCollection.Error(((AStructLvalue)lvalue).GetName(), currentSourceFile, "Invalid type name. Must be \"<namespace>.<struct name>\"."));
             throw new ParserException(null, null);
         }
     }
     if (lvalue is AArrayLvalue)
     {
         AArrayLvalue aLvalue = (AArrayLvalue)lvalue;
         if (!(aLvalue.GetBase() is ALvalueExp))
         {
             //errors.Add(new ErrorCollection.Error(GetToken(lvalue), currentSourceFile, "Whatever that is, it's not allowed in a type"));
             throw new ParserException(null, null);
         }
         PLvalue newLvalue = ((ALvalueExp)aLvalue.GetBase()).GetLvalue();
         return new AArrayTempType(aLvalue.GetToken(), LvalueToType(newLvalue), aLvalue.GetIndex(), null);
     }
     //it must be an AAmbiguousNameLvalue then
     return new ANamedType(((AAmbiguousNameLvalue)lvalue).GetAmbiguous());
 }
Ejemplo n.º 21
0
        public override void DefaultIn(Node node)
        {
            //
            int index = 0;
            GetChildTypeIndex getChildTypeIndex = new GetChildTypeIndex()
            {
                Parent = node.Parent(), Child = node
            };

            node.Parent().Apply(getChildTypeIndex);
            index = getChildTypeIndex.Index;
            GetChildTypeByIndex getChildTypeByIndex = new GetChildTypeByIndex()
            {
                Child = node, Index = index, Parent = currentCloneNode
            };

            currentCloneNode.Apply(getChildTypeByIndex);
            currentCloneNode = getChildTypeByIndex.Child;

            //currentCloneNode should now be the clone corrosponding to node.

            /*finalTrans.data.ExpTypes
             * finalTrans.data.FieldLinks
             * finalTrans.data.LocalLinks
             * finalTrans.data.Locals//Lets not forget about this one
             * finalTrans.data.LvalueTypes
             * finalTrans.data.SimpleMethodLinks
             * finalTrans.data.StructFieldLinks
             * finalTrans.data.StructMethodLinks
             * finalTrans.data.StructTypeLinks*/
            if (node is AABlock)
            {
                data.Locals[(AABlock)currentCloneNode] = new List <AALocalDecl>();
            }
            if (node is PExp)
            {
                data.ExpTypes[(PExp)currentCloneNode] = data.ExpTypes[(PExp)node];
            }
            if (node is AFieldLvalue)
            {
                data.FieldLinks[(AFieldLvalue)currentCloneNode] = data.FieldLinks[(AFieldLvalue)node];
            }
            if (node is ALocalLvalue)
            {
                PLvalue replacer = Util.MakeClone(localMap[data.LocalLinks[(ALocalLvalue)node]],
                                                  data);
                currentCloneNode.ReplaceBy(replacer);
                currentCloneNode = replacer;
            }
            if (node is AALocalDecl)
            {
                ALocalLvalue replacer = new ALocalLvalue(new TIdentifier("IwillGetRenamedLater"));
                data.LvalueTypes[replacer] = ((AALocalDecl)currentCloneNode).GetType();
                data.LocalLinks[replacer]  = (AALocalDecl)currentCloneNode;
                AABlock pBlock = Util.GetAncestor <AABlock>(currentCloneNode) ??
                                 (AABlock)Util.GetAncestor <AMethodDecl>(currentCloneNode).GetBlock();
                data.Locals[Util.GetAncestor <AABlock>(currentCloneNode)].Add((AALocalDecl)currentCloneNode);
                localMap.Add((AALocalDecl)node, replacer);
            }
            if (node is PLvalue)
            {
                data.LvalueTypes[(PLvalue)currentCloneNode] = data.LvalueTypes[(PLvalue)node];
            }
            if (node is ASimpleInvokeExp)
            {
                data.SimpleMethodLinks[(ASimpleInvokeExp)currentCloneNode] = data.SimpleMethodLinks[(ASimpleInvokeExp)node];
            }
            if (node is AStructLvalue)
            {
                data.StructFieldLinks[(AStructLvalue)currentCloneNode] = data.StructFieldLinks[(AStructLvalue)node];
            }
            if (node is ANonstaticInvokeExp)
            {
                data.StructMethodLinks[(ANonstaticInvokeExp)currentCloneNode] = data.StructMethodLinks[(ANonstaticInvokeExp)node];
            }
            if (node is ANamedType && data.StructTypeLinks.Keys.Contains(node))
            {
                data.StructTypeLinks[(ANamedType)currentCloneNode] = data.StructTypeLinks[(ANamedType)node];
            }
            if (extraCheck != null)
            {
                extraCheck(node, currentCloneNode);
            }
            if (node is PType && data.EnrichmentTypeLinks.ContainsKey((PType)node))
            {
                data.EnrichmentTypeLinks[(PType)currentCloneNode] = data.EnrichmentTypeLinks[(PType)node];
            }
            if (node is AStringConstExp)
            {
                if (data.StringsDontJoinRight.Contains(node))
                {
                    data.StringsDontJoinRight.Add((AStringConstExp)currentCloneNode);
                }
            }
        }
        private void MakeAssignments(AABlock block, PType type, PLvalue leftSide, bool onEnhritedFields)
        {
            if (type is ANamedType && data.StructTypeLinks.ContainsKey((ANamedType) type))
            {
                AStructDecl str = data.StructTypeLinks[(ANamedType) type];
                foreach (AALocalDecl field in str.GetLocals().OfType<AALocalDecl>())
                {
                    if (!onEnhritedFields && data.EnheritanceLocalMap.ContainsKey(field))
                        continue;

                    ALvalueExp lvalueExp = new ALvalueExp(Util.MakeClone(leftSide, data));
                    data.ExpTypes[lvalueExp] = data.LvalueTypes[leftSide];
                    AStructLvalue newLeftSide = new AStructLvalue(lvalueExp, new ADotDotType(new TDot(".")), new TIdentifier(field.GetName().Text));
                    data.StructFieldLinks[newLeftSide] = field;
                    data.LvalueTypes[newLeftSide] = field.GetType();

                    if (field.GetInit() != null)
                    {
                        AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), newLeftSide,
                                                                       Util.MakeClone(field.GetInit(), data));
                        data.ExpTypes[assignment] = data.LvalueTypes[newLeftSide];

                        block.GetStatements().Add(new AExpStm(new TSemicolon(";"),
                                                              assignment));
                    }
                    else
                    {
                        MakeAssignments(block, field.GetType(), newLeftSide, onEnhritedFields);
                    }
                }
            }
            else if (type is AArrayTempType)
            {
                AArrayTempType aType = (AArrayTempType) type;
                for (int i = 0; i < int.Parse(aType.GetIntDim().Text); i++)
                {
                    AIntConstExp index = new AIntConstExp(new TIntegerLiteral(i.ToString()));
                    data.ExpTypes[index] = new ANamedType(new TIdentifier("int"), null);

                    ALvalueExp lvalueExp = new ALvalueExp(Util.MakeClone(leftSide, data));
                    data.ExpTypes[lvalueExp] = data.LvalueTypes[leftSide];
                    AArrayLvalue newLeftSide = new AArrayLvalue(new TLBracket("["), lvalueExp, index);
                    data.LvalueTypes[newLeftSide] = aType.GetType();

                    MakeAssignments(block, aType.GetType(), newLeftSide, onEnhritedFields);
                }
            }
        }
Ejemplo n.º 23
0
 private static void MakeCloneRefferences(PLvalue clone, PLvalue lvalue, SharedData data)
 {
     data.LvalueTypes[clone] = data.LvalueTypes[lvalue];
     if (lvalue is ALocalLvalue)
     {
         data.LocalLinks[(ALocalLvalue)clone] = data.LocalLinks[(ALocalLvalue)lvalue];
     }
     else if (lvalue is AFieldLvalue)
     {
         data.FieldLinks[(AFieldLvalue)clone] = data.FieldLinks[(AFieldLvalue)lvalue];
     }
     else if (lvalue is AStructLvalue)
     {
         AStructLvalue aLvalue = (AStructLvalue)lvalue;
         AStructLvalue aClone  = (AStructLvalue)clone;
         if (data.StructFieldLinks.ContainsKey(aLvalue))
         {
             data.StructFieldLinks[aClone] =
                 data.StructFieldLinks[aLvalue];
         }
         else
         {
             data.StructPropertyLinks[aClone] =
                 data.StructPropertyLinks[aLvalue];
         }
         MakeCloneRefferences(aClone.GetReceiver(), aLvalue.GetReceiver(), data);
     }
     else if (lvalue is AStructFieldLvalue)
     {
         AStructFieldLvalue aLvalue = (AStructFieldLvalue)lvalue;
         AStructFieldLvalue aClone  = (AStructFieldLvalue)clone;
         if (data.StructMethodFieldLinks.ContainsKey(aLvalue))
         {
             data.StructMethodFieldLinks[aClone] = data.StructMethodFieldLinks[aLvalue];
         }
         if (data.StructMethodPropertyLinks.ContainsKey(aLvalue))
         {
             data.StructMethodPropertyLinks[aClone] = data.StructMethodPropertyLinks[aLvalue];
         }
     }
     else if (lvalue is AArrayLvalue)
     {
         AArrayLvalue aLvalue = (AArrayLvalue)lvalue;
         AArrayLvalue aClone  = (AArrayLvalue)clone;
         MakeCloneRefferences(aClone.GetBase(), aLvalue.GetBase(), data);
         MakeCloneRefferences(aClone.GetIndex(), aLvalue.GetIndex(), data);
     }
     else if (lvalue is APointerLvalue)
     {
         APointerLvalue aLvalue = (APointerLvalue)lvalue;
         APointerLvalue aClone  = (APointerLvalue)clone;
         MakeCloneRefferences(aClone.GetBase(), aLvalue.GetBase(), data);
     }
     else if (lvalue is AThisLvalue || lvalue is AValueLvalue)
     {
         //AThisLvalue aLvalue = (AThisLvalue)lvalue;
         //Do nothing more
     }
     else if (lvalue is APropertyLvalue)
     {
         APropertyLvalue aLvalue = (APropertyLvalue)lvalue;
         APropertyLvalue aClone  = (APropertyLvalue)clone;
         data.PropertyLinks[aClone] = data.PropertyLinks[aLvalue];
     }
     else
     {
         throw new Exception("Unexpect lvalue. Got " + lvalue.GetType());
     }
 }
Ejemplo n.º 24
0
        private List <PStm> AssignDefault(PLvalue lvalue)
        {
            List <PStm> returner  = new List <PStm>();
            PType       type      = data.LvalueTypes[lvalue];
            PExp        rightSide = null;

            if (type is ANamedType)
            {
                ANamedType aType = (ANamedType)type;
                if (aType.IsPrimitive("string"))//aType.GetName().Text == "string")
                {
                    rightSide = new AStringConstExp(new TStringLiteral("\"\""));
                    data.ExpTypes[rightSide] = new ANamedType(new TIdentifier("string"), null);
                }
                else if (aType.IsPrimitive(GalaxyKeywords.NullablePrimitives.words)) //GalaxyKeywords.NullablePrimitives.words.Contains(aType.GetName().Text))
                {
                    rightSide = new ANullExp();
                    data.ExpTypes[rightSide] = new ANamedType(new TIdentifier("null"), null);
                }
                else if (aType.IsPrimitive(new [] { "int", "byte", "fixed" }))

                /*aType.GetName().Text == "int" ||
                *  aType.GetName().Text == "byte" ||
                *  aType.GetName().Text == "fixed")*/
                {
                    rightSide = new AIntConstExp(new TIntegerLiteral("0"));
                    data.ExpTypes[rightSide] = type;
                }
                else if (aType.IsPrimitive("bool"))//aType.GetName().Text == "bool")
                {
                    rightSide = new ABooleanConstExp(new AFalseBool());
                    data.ExpTypes[rightSide] = type;
                }
                else if (aType.IsPrimitive("color"))//aType.GetName().Text == "color")
                {
                    PExp             arg1   = new AIntConstExp(new TIntegerLiteral("0"));
                    PExp             arg2   = new AIntConstExp(new TIntegerLiteral("0"));
                    PExp             arg3   = new AIntConstExp(new TIntegerLiteral("0"));
                    ASimpleInvokeExp invoke = new ASimpleInvokeExp(new TIdentifier("Color"), new ArrayList()
                    {
                        arg1, arg2, arg3
                    });
                    rightSide = invoke;
                    data.ExpTypes[rightSide]       = type;
                    data.ExpTypes[arg1]            =
                        data.ExpTypes[arg2]        =
                            data.ExpTypes[arg3]    = new ANamedType(new TIdentifier("int"), null);
                    data.SimpleMethodLinks[invoke] =
                        data.Libraries.Methods.First(func => func.GetName().Text == invoke.GetName().Text);
                }
                else if (aType.IsPrimitive("char"))//aType.GetName().Text == "char")
                {
                    //Dunno?!
                    rightSide = new ACharConstExp(new TCharLiteral("'\0'"));
                    data.ExpTypes[rightSide] = type;
                }
                else //Struct
                {
                    AStructDecl str = data.StructTypeLinks[aType];
                    foreach (AALocalDecl localDecl in str.GetLocals())
                    {
                        ALvalueExp    reciever  = new ALvalueExp(Util.MakeClone(lvalue, data));
                        AStructLvalue newLvalue = new AStructLvalue(reciever, new ADotDotType(new TDot(".")), new TIdentifier(localDecl.GetName().Text));
                        data.StructFieldLinks[newLvalue] = localDecl;
                        data.ExpTypes[reciever]          = type;
                        data.LvalueTypes[newLvalue]      = localDecl.GetType();
                        returner.AddRange(AssignDefault(newLvalue));
                    }
                    return(returner);
                }
                AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), Util.MakeClone(lvalue, data), rightSide);
                data.ExpTypes[assignment] = type;
                return(new List <PStm>()
                {
                    new AExpStm(new TSemicolon(";"), assignment)
                });
            }
            if (type is AArrayTempType)
            {
                AArrayTempType aType = (AArrayTempType)type;
                for (int i = 0; i < int.Parse(aType.GetIntDim().Text); i++)
                {
                    ALvalueExp   reciever  = new ALvalueExp(Util.MakeClone(lvalue, data));
                    AArrayLvalue newLvalue = new AArrayLvalue(new TLBracket("["), reciever, new AIntConstExp(new TIntegerLiteral(i.ToString())));
                    data.ExpTypes[reciever]             = type;
                    data.LvalueTypes[newLvalue]         = aType.GetType();
                    data.ExpTypes[newLvalue.GetIndex()] = new ANamedType(new TIdentifier("int"), null);
                    returner.AddRange(AssignDefault(newLvalue));
                }
                return(returner);
            }

            throw new Exception("Unexpected type. (LivenessAnalasys.AssignDefault), got " + type);
        }
        private int FoldInt(PLvalue lvalue, ref bool valid)
        {
            if (!valid) return -1;

            if (lvalue is ALocalLvalue)
            {
                ALocalLvalue aLvalue = (ALocalLvalue) lvalue;
                AALocalDecl decl = data.LocalLinks[aLvalue];
                if (decl.GetConst() == null)
                {
                    valid = false;
                    return -1;
                }
                return FoldInt(decl.GetInit(), ref valid);
            }
            if (lvalue is AFieldLvalue)
            {
                AFieldLvalue aLvalue = (AFieldLvalue) lvalue;
                AFieldDecl decl = data.FieldLinks[aLvalue];
                if (decl.GetConst() == null)
                {
                    valid = false;
                    return -1;
                }
                return FoldInt(decl.GetInit(), ref valid);
            }
            if (lvalue is AStructFieldLvalue)
            {
                AStructFieldLvalue aLvalue = (AStructFieldLvalue)lvalue;
                AALocalDecl decl = data.StructMethodFieldLinks[aLvalue];
                if (decl.GetConst() == null)
                {
                    valid = false;
                    return -1;
                }
                return FoldInt(decl.GetInit(), ref valid);
            }
            if (lvalue is AStructLvalue)
            {
                AStructLvalue aLvalue = (AStructLvalue)lvalue;
                AALocalDecl decl = data.StructFieldLinks[aLvalue];
                if (decl.GetConst() == null)
                {
                    valid = false;
                    return -1;
                }
                return FoldInt(decl.GetInit(), ref valid);
            }

            valid = false;
            return -1;
        }
Ejemplo n.º 26
0
 public ASAssignmentExp(
         PAssignop _assignop_,
         PLvalue _lvalue_,
         PExp _exp_
 )
 {
     SetAssignop(_assignop_);
     SetLvalue(_lvalue_);
     SetExp(_exp_);
 }
Ejemplo n.º 27
0
 public AIncDecExp(
         PLvalue _lvalue_,
         PIncDecOp _inc_dec_op_
 )
 {
     SetLvalue(_lvalue_);
     SetIncDecOp(_inc_dec_op_);
 }
Ejemplo n.º 28
0
 public AShadySAssignmentExp(
         TConst _const_,
         IList _pre_pointers_,
         PLvalue _lvalue_,
         TLt _generic_token_,
         IList _generic_types_,
         IList _post_pointers_,
         IList _local_decl_right_
 )
 {
     SetConst(_const_);
     this._pre_pointers_ = new TypedList(new PrePointers_Cast(this));
     this._pre_pointers_.Clear();
     this._pre_pointers_.AddAll(_pre_pointers_);
     SetLvalue(_lvalue_);
     SetGenericToken(_generic_token_);
     this._generic_types_ = new TypedList(new GenericTypes_Cast(this));
     this._generic_types_.Clear();
     this._generic_types_.AddAll(_generic_types_);
     this._post_pointers_ = new TypedList(new PostPointers_Cast(this));
     this._post_pointers_.Clear();
     this._post_pointers_.AddAll(_post_pointers_);
     this._local_decl_right_ = new TypedList(new LocalDeclRight_Cast(this));
     this._local_decl_right_.Clear();
     this._local_decl_right_.AddAll(_local_decl_right_);
 }
Ejemplo n.º 29
0
 internal override void RemoveChild(Node child)
 {
     if (_lvalue_ == child)
     {
         _lvalue_ = null;
         return;
     }
     if (_inc_dec_op_ == child)
     {
         _inc_dec_op_ = null;
         return;
     }
 }
Ejemplo n.º 30
0
 public AAssignmentExp(
         TAssign _token_,
         PLvalue _lvalue_,
         PExp _exp_
 )
 {
     SetToken(_token_);
     SetLvalue(_lvalue_);
     SetExp(_exp_);
 }
Ejemplo n.º 31
0
 private static Token GetToken(PLvalue lvalue)
 {
     if (lvalue is AStructLvalue)
         return ((AStructLvalue)lvalue).GetName();
     if (lvalue is AArrayLvalue)
         return ((AArrayLvalue)lvalue).GetToken();
     return (TIdentifier)((AAName)((AAmbiguousNameLvalue)lvalue).GetAmbiguous()).GetIdentifier()[0];
 }
Ejemplo n.º 32
0
 internal override void RemoveChild(Node child)
 {
     if (_token_ == child)
     {
         _token_ = null;
         return;
     }
     if (_name_ == child)
     {
         _name_ = null;
         return;
     }
     if (_args_.Contains(child))
     {
         _args_.Remove(child);
         return;
     }
 }
Ejemplo n.º 33
0
        public static List <AABlock> Inline(ASimpleInvokeExp node, FinalTransformations finalTrans)
        {
            /*if (Util.GetAncestor<AMethodDecl>(node) != null && Util.GetAncestor<AMethodDecl>(node).GetName().Text == "UIChatFrame_LeaveChannel")
             *  node = node;*/

            SharedData data = finalTrans.data;
            //If this node is inside the condition of a while, replace it with a new local var,
            //make a clone before the while, one before each continue in the while, and one at the end of the while
            //(unless the end is a return or break)
            AABlock pBlock;

            if (Util.HasAncestor <AWhileStm>(node))
            {
                AWhileStm whileStm = Util.GetAncestor <AWhileStm>(node);
                if (Util.IsAncestor(node, whileStm.GetCondition()))
                {
                    List <ASimpleInvokeExp> toInline = new List <ASimpleInvokeExp>();
                    //Above while
                    AALocalDecl replaceVarDecl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null,
                                                                 Util.MakeClone(data.ExpTypes[node], data),
                                                                 new TIdentifier("whileVar"), null);
                    ALocalLvalue replaceVarRef    = new ALocalLvalue(new TIdentifier("whileVar"));
                    ALvalueExp   replaceVarRefExp = new ALvalueExp(replaceVarRef);
                    data.LocalLinks[replaceVarRef]  = replaceVarDecl;
                    data.ExpTypes[replaceVarRefExp] = data.LvalueTypes[replaceVarRef] = replaceVarDecl.GetType();
                    node.ReplaceBy(replaceVarRefExp);
                    replaceVarDecl.SetInit(node);
                    pBlock = (AABlock)whileStm.Parent();
                    pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(whileStm), new ALocalDeclStm(new TSemicolon(";"), replaceVarDecl));
                    toInline.Add(node);


                    //In the end of the while
                    PStm lastStm = whileStm.GetBody();
                    while (lastStm is ABlockStm)
                    {
                        AABlock block = (AABlock)((ABlockStm)lastStm).GetBlock();
                        if (block.GetStatements().Count == 0)
                        {
                            lastStm = null;
                            break;
                        }
                        lastStm = (PStm)block.GetStatements()[block.GetStatements().Count - 1];
                    }
                    if (lastStm == null || !(lastStm is AValueReturnStm || lastStm is AVoidReturnStm || lastStm is ABreakStm))
                    {
                        lastStm = whileStm.GetBody();
                        AABlock block;
                        if (lastStm is ABlockStm)
                        {
                            block = (AABlock)((ABlockStm)lastStm).GetBlock();
                        }
                        else
                        {
                            block = new AABlock(new ArrayList(), new TRBrace("}"));
                            block.GetStatements().Add(lastStm);
                            whileStm.SetBody(new ABlockStm(new TLBrace("{"), block));
                        }

                        replaceVarRef = new ALocalLvalue(new TIdentifier("whileVar"));
                        ASimpleInvokeExp clone = (ASimpleInvokeExp)Util.MakeClone(node, data);
                        toInline.Add(clone);
                        AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), replaceVarRef, clone);
                        data.LocalLinks[replaceVarRef] = replaceVarDecl;
                        data.ExpTypes[assignment]      = data.LvalueTypes[replaceVarRef] = replaceVarDecl.GetType();
                        block.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment));
                    }

                    //After each continue
                    CloneBeforeContinue cloner = new CloneBeforeContinue(node, replaceVarDecl, data);
                    whileStm.GetBody().Apply(cloner);
                    toInline.AddRange(cloner.replacementExpressions);
                    List <AABlock> visitBlocks = new List <AABlock>();
                    foreach (ASimpleInvokeExp invoke in toInline)
                    {
                        visitBlocks.AddRange(Inline(invoke, finalTrans));
                    }
                    return(visitBlocks);
                }
            }



            AMethodDecl           decl = finalTrans.data.SimpleMethodLinks[node];
            FindAssignedToFormals assignedToFormalsFinder = new FindAssignedToFormals(finalTrans.data);

            decl.Apply(assignedToFormalsFinder);
            List <AALocalDecl> assignedToFormals = assignedToFormalsFinder.AssignedFormals;


            /*
             * inline int foo(int a)
             * {
             *      int b = 2;
             *      int c;
             *      ...
             *      while(...)
             *      {
             *          ...
             *          break;
             *          ...
             *          return c;
             *      }
             *      ...
             *      return 2;
             * }
             *
             * bar(foo(<arg for a>));
             * ->
             *
             * {
             *      bool inlineMethodReturned = false;
             *      int inlineReturner;
             *      int a = <arg for a>;
             *      while (!inlineMethodReturned)
             *      {
             *          int b = 2;
             *          int c;
             *          ...
             *          while(...)
             *          {
             *              ...
             *              break
             *              ...
             *              inlineReturner = c;
             *              inlineMethodReturned = true;
             *              break;
             *          }
             *          if (inlineMethodReturned)
             *          {
             *              break;
             *          }
             *          ...
             *          inlineReturner = 2;
             *          inlineMethodReturned = true;
             *          break;
             *          break;
             *      }
             *      bar(inlineReturner);
             * }
             *
             *
             */


            AABlock outerBlock = new AABlock();
            PExp    exp        = new ABooleanConstExp(new AFalseBool());

            finalTrans.data.ExpTypes[exp] = new ANamedType(new TIdentifier("bool"), null);
            AALocalDecl hasMethodReturnedVar = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, new ANamedType(new TIdentifier("bool"), null),
                                                               new TIdentifier("hasInlineReturned"), exp);

            finalTrans.data.GeneratedVariables.Add(hasMethodReturnedVar);
            PStm stm = new ALocalDeclStm(new TSemicolon(";"), hasMethodReturnedVar);

            outerBlock.GetStatements().Add(stm);

            AALocalDecl methodReturnerVar = null;

            if (!(decl.GetReturnType() is AVoidType))
            {
                methodReturnerVar = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, Util.MakeClone(decl.GetReturnType(), finalTrans.data),
                                                    new TIdentifier("inlineReturner"), null);
                stm = new ALocalDeclStm(new TSemicolon(";"), methodReturnerVar);
                outerBlock.GetStatements().Add(stm);
            }

            AABlock afterBlock = new AABlock();

            //A dictionary from the formals of the inline method to a cloneable replacement lvalue
            Dictionary <AALocalDecl, PLvalue> Parameters    = new Dictionary <AALocalDecl, PLvalue>();
            Dictionary <AALocalDecl, PExp>    ParameterExps = new Dictionary <AALocalDecl, PExp>();

            for (int i = 0; i < decl.GetFormals().Count; i++)
            {
                AALocalDecl formal = (AALocalDecl)decl.GetFormals()[i];
                PExp        arg    = (PExp)node.GetArgs()[0];
                PLvalue     lvalue;
                //if ref, dont make a new var
                if (formal.GetRef() != null && arg is ALvalueExp)
                {
                    arg.Apply(new MoveMethodDeclsOut("inlineVar", finalTrans.data));
                    arg.Parent().RemoveChild(arg);
                    lvalue = ((ALvalueExp)arg).GetLvalue();
                }
                else if (!assignedToFormals.Contains(formal) && Util.IsLocal(arg, finalTrans.data))
                {
                    lvalue = new ALocalLvalue(new TIdentifier("I hope I dont make it"));
                    finalTrans.data.LvalueTypes[lvalue] = formal.GetType();
                    finalTrans.data.LocalLinks[(ALocalLvalue)lvalue] = formal;
                    ParameterExps[formal] = arg;
                    arg.Parent().RemoveChild(arg);
                }
                else
                {
                    AAssignmentExp assExp = null;
                    if (formal.GetOut() != null)
                    {
                        //Dont initialize with arg, but assign arg after
                        arg.Apply(new MoveMethodDeclsOut("inlineVar", finalTrans.data));
                        lvalue = ((ALvalueExp)arg).GetLvalue();
                        assExp = new AAssignmentExp(new TAssign("="), lvalue, null);
                        finalTrans.data.ExpTypes[assExp] = finalTrans.data.LvalueTypes[lvalue];
                        arg.Parent().RemoveChild(arg);
                        arg = null;
                    }
                    AALocalDecl parameter = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, Util.MakeClone(formal.GetType(), finalTrans.data),
                                                            new TIdentifier(formal.GetName().Text),
                                                            arg);
                    stm = new ALocalDeclStm(new TSemicolon(";"), parameter);
                    outerBlock.GetStatements().Add(stm);

                    lvalue = new ALocalLvalue(new TIdentifier(parameter.GetName().Text));
                    finalTrans.data.LvalueTypes[lvalue] = parameter.GetType();
                    finalTrans.data.LocalLinks[(ALocalLvalue)lvalue] = parameter;


                    if (formal.GetOut() != null)
                    {
                        //Dont initialize with arg, but assign arg after
                        ALvalueExp lvalueExp = new ALvalueExp(Util.MakeClone(lvalue, finalTrans.data));
                        finalTrans.data.ExpTypes[lvalueExp] = finalTrans.data.LvalueTypes[lvalue];
                        assExp.SetExp(lvalueExp);
                        afterBlock.GetStatements().Add(new AExpStm(new TSemicolon(";"), assExp));
                    }
                }
                Parameters.Add(formal, lvalue);
            }

            AABlock innerBlock = (AABlock)decl.GetBlock().Clone();

            exp = new ABooleanConstExp(new ATrueBool());
            finalTrans.data.ExpTypes[exp] = new ANamedType(new TIdentifier("bool"), null);
            ABlockStm innerBlockStm = new ABlockStm(new TLBrace("{"), innerBlock);

            bool needWhile = CheckIfWhilesIsNeeded.IsWhileNeeded(decl.GetBlock());

            if (needWhile)
            {
                stm = new AWhileStm(new TLParen("("), exp, innerBlockStm);
            }
            else
            {
                stm = innerBlockStm;
            }
            outerBlock.GetStatements().Add(stm);

            outerBlock.GetStatements().Add(new ABlockStm(new TLBrace("{"), afterBlock));

            //Clone method contents to inner block.
            CloneMethod cloneFixer = new CloneMethod(finalTrans, Parameters, ParameterExps, innerBlockStm);

            decl.GetBlock().Apply(cloneFixer);
            foreach (KeyValuePair <PLvalue, PExp> pair in cloneFixer.ReplaceUsAfter)
            {
                PLvalue    lvalue       = pair.Key;
                PExp       replacement  = Util.MakeClone(pair.Value, finalTrans.data);
                ALvalueExp lvalueParent = (ALvalueExp)lvalue.Parent();
                lvalueParent.ReplaceBy(replacement);
            }
            innerBlockStm.Apply(new FixTypes(finalTrans.data));

            innerBlock.Apply(new FixReturnsAndWhiles(hasMethodReturnedVar, methodReturnerVar, finalTrans.data, needWhile));

            GetNonBlockStm stmFinder = new GetNonBlockStm(false);

            innerBlock.Apply(stmFinder);
            if (needWhile && (stmFinder.Stm == null || !(stmFinder.Stm is ABreakStm)))
            {
                innerBlock.GetStatements().Add(new ABreakStm(new TBreak("break")));
            }

            //Insert before current statement
            ABlockStm outerBlockStm = new ABlockStm(new TLBrace("{"), outerBlock);

            PStm pStm = Util.GetAncestor <PStm>(node);

            pBlock = (AABlock)pStm.Parent();

            pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(pStm), outerBlockStm);

            if (node.Parent() == pStm && pStm is AExpStm)
            {
                pBlock.RemoveChild(pStm);
            }
            else
            {
                PLvalue lvalue = new ALocalLvalue(new TIdentifier(methodReturnerVar.GetName().Text));
                finalTrans.data.LvalueTypes[lvalue] = methodReturnerVar.GetType();
                finalTrans.data.LocalLinks[(ALocalLvalue)lvalue] = methodReturnerVar;
                exp = new ALvalueExp(lvalue);
                finalTrans.data.ExpTypes[exp] = methodReturnerVar.GetType();

                node.ReplaceBy(exp);
            }
            return(new List <AABlock>()
            {
                outerBlock
            });
        }
Ejemplo n.º 34
0
 internal override void RemoveChild(Node child)
 {
     if (_token_ == child)
     {
         _token_ = null;
         return;
     }
     if (_type_ == child)
     {
         _type_ = null;
         return;
     }
     if (_lvalue_ == child)
     {
         _lvalue_ = null;
         return;
     }
 }
Ejemplo n.º 35
0
            private void MakeAssignmentRightDynamic(PLvalue leftSide, PExp rightSide, PType type, AABlock block, ref int index)
            {
                if (Util.IsBulkCopy(type))
                {
                    if (type is ANamedType)
                    {
                        ANamedType aType = (ANamedType)type;
                        AStructDecl structDecl = data.StructTypeLinks[aType];
                        foreach (AALocalDecl localDecl in structDecl.GetLocals())
                        {
                            AStructLvalue newleftSide = new AStructLvalue(new ALvalueExp(leftSide),
                                                                          new ADotDotType(new TDot(".")),
                                                                          new TIdentifier(localDecl.GetName().Text));

                            ABinopExp newrightSide = new ABinopExp(rightSide, new APlusBinop(new TPlus("+")),
                                                     new AStringConstExp(
                                                         new TStringLiteral("\"." + localDecl.GetName().Text + "\"")));

                             data.ExpTypes[newrightSide] =
                                data.ExpTypes[newrightSide.GetRight()] =
                                new ANamedType(new TIdentifier("string"), null);

                            data.ExpTypes[newleftSide.GetReceiver()] = type;
                            data.LvalueTypes[newleftSide] = localDecl.GetType();

                            data.StructFieldLinks[newleftSide] = localDecl;

                            MakeAssignmentRightDynamic(newleftSide, newrightSide, localDecl.GetType(), block, ref index);
                        }
                    }
                    else
                    {//Is array type. Can Only be a constant array type
                        AArrayTempType aType = (AArrayTempType)type;
                        for (int i = 0; i < int.Parse(aType.GetIntDim().Text); i++)
                        {
                            AArrayLvalue newleftSide = new AArrayLvalue(new TLBracket("["), new ALvalueExp(leftSide), new AIntConstExp(new TIntegerLiteral(i.ToString())));

                            ABinopExp newrightSide = new ABinopExp(rightSide, new APlusBinop(new TPlus("+")),
                                                     new AStringConstExp(
                                                         new TStringLiteral("\"[" + i + "]\"")));
                            data.ExpTypes[newrightSide] =
                                data.ExpTypes[newrightSide.GetRight()] =
                                new ANamedType(new TIdentifier("string"), null);

                            data.ExpTypes[newleftSide.GetBase()] = type;
                            data.ExpTypes[newleftSide.GetIndex()] = new ANamedType(new TIdentifier("int"), null);
                            data.LvalueTypes[newleftSide] = aType.GetType();

                            MakeAssignmentRightDynamic(newleftSide, newrightSide, aType.GetType(), block, ref index);

                        }

                    }
                }
                else
                {
                    ANamedType aType;// = type is APointerType ? new ANamedType(new TIdentifier("string"), null) : (ANamedType)type;
                    if (type is APointerType)
                    {
                        if (Util.IsIntPointer(type, ((APointerType)type).GetType(), data))
                            aType = new ANamedType(new TIdentifier("int"), null);
                        else
                            aType = new ANamedType(new TIdentifier("string"), null);
                    }
                    else
                    {
                        aType = (ANamedType) type;
                    }
                    string capitalType = Util.Capitalize(aType.AsIdentifierString());//Char.ToUpper(aType.GetName().Text[0]) + aType.GetName().Text.Substring(1);
                    leftSide = Util.MakeClone(leftSide, data);
                    rightSide = Util.MakeClone(rightSide, data);

                    ABooleanConstExp trueConst1 = new ABooleanConstExp(new ATrueBool());
                    //ABooleanConstExp trueConst2 = new ABooleanConstExp(new ATrueBool());
                    ASimpleInvokeExp innerInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableGet" + capitalType), new ArrayList() { trueConst1, rightSide });
                    //ASimpleInvokeExp outerInvoke = new ASimpleInvokeExp(new TIdentifier("DataTableSet" + capitalType), new ArrayList() { trueConst2, leftSide, innerInvoke });
                    AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), leftSide, innerInvoke);
                    block.GetStatements().Insert(index, new AExpStm(new TSemicolon(";"), assignment));
                    index++;

                    data.ExpTypes[trueConst1] = new ANamedType(new TIdentifier("bool"), null);

                    data.ExpTypes[innerInvoke] = aType;
                    data.ExpTypes[assignment] = aType;

                    data.SimpleMethodLinks[innerInvoke] =
                        data.Libraries.Methods.First(m => m.GetName().Text == innerInvoke.GetName().Text);
                }
            }
Ejemplo n.º 36
0
        public void SetLvalue(PLvalue node)
        {
            if (_lvalue_ != null)
            {
                _lvalue_.Parent(null);
            }

            if (node != null)
            {
                if (node.Parent() != null)
                {
                    node.Parent().RemoveChild(node);
                }

                node.Parent(this);
            }

            _lvalue_ = node;
        }
Ejemplo n.º 37
0
 private PType LvalueToType(PLvalue lvalue, IList dynamicOpList, TLt genericToken, IList genericTypes)
 {
     PType type = LvalueToType(lvalue);
     if (genericToken != null)
     {
         type = new AGenericType(genericToken, type, new ArrayList());
         while (genericTypes.Count > 0)
         {
             ((AGenericType) type).GetGenericTypes().Add(genericTypes[0]);
         }
     }
     foreach (PShadyDynamicOps op in dynamicOpList)
     {
         if (op is APointerShadyDynamicOps)
         {
             APointerShadyDynamicOps aop = (APointerShadyDynamicOps) op;
             type = new APointerType(aop.GetToken(), type);
         }
         else if (op is AArrayShadyDynamicOps)
         {
             AArrayShadyDynamicOps aop = (AArrayShadyDynamicOps)op;
             if (aop.GetExp() == null)
                 type = new ADynamicArrayType(aop.GetToken(), type);
             else
                 type = new AArrayTempType(aop.GetToken(), type, aop.GetExp(), null);
         }
     }
     return type;
 }
Ejemplo n.º 38
0
 private PType LvalueToType(PLvalue lvalue)
 {
     if (lvalue is AStructLvalue)
     {
         /*AStructLvalue structLvalue = (AStructLvalue) lvalue;
         TIdentifier typeName = structLvalue.GetName();
         if (structLvalue.GetReceiver() is ALvalueExp && ((ALvalueExp)structLvalue.GetReceiver()).GetLvalue() is AAmbiguousNameLvalue)
         {
             AAmbiguousNameLvalue ambiguousNameLvalue = (AAmbiguousNameLvalue) ((ALvalueExp) structLvalue.GetReceiver()).GetLvalue();
             return new ANamedType(typeName, ((ASimpleName)ambiguousNameLvalue.GetAmbiguous()).GetIdentifier());
         }
         else*/
         {
             errors.Add(new ErrorCollection.Error(((AStructLvalue)lvalue).GetName(), currentSourceFile, LocRM.GetString("ErrorText177")));
             throw new ParserException(null, null);
         }
     }
     if (lvalue is AArrayLvalue)
     {
         AArrayLvalue aLvalue = (AArrayLvalue)lvalue;
         if (!(aLvalue.GetBase() is ALvalueExp))
         {
             errors.Add(new ErrorCollection.Error(GetToken(lvalue), currentSourceFile, LocRM.GetString("ErrorText176")));
             throw new ParserException(null, null);
         }
         PLvalue newLvalue = ((ALvalueExp)aLvalue.GetBase()).GetLvalue();
         return new AArrayTempType(aLvalue.GetToken(), LvalueToType(newLvalue), aLvalue.GetIndex(), null);
     }
     //it must be an AAmbiguousNameLvalue then
     return new ANamedType(((AAmbiguousNameLvalue)lvalue).GetAmbiguous());
 }
 bool IsConstant(PLvalue lvalue)
 {
     if (lvalue is ALocalLvalue)
     {
         ALocalLvalue aLvalue = (ALocalLvalue) lvalue;
         AALocalDecl decl = data.LocalLinks[aLvalue];
         if (decl == initialLocalDecl) return false;
         return decl.GetConst() != null && IsConstant(decl.GetInit());
     }
     if (lvalue is AFieldLvalue)
     {
         AFieldLvalue aLvalue = (AFieldLvalue)lvalue;
         AFieldDecl decl = data.FieldLinks[aLvalue];
         if (decl == initialFieldDecl) return false;
         return decl.GetConst() != null && IsConstant(decl.GetInit());
     }
     if (lvalue is APropertyLvalue)
     {
         return false;
     }
     if (lvalue is ANamespaceLvalue)
     {
         return true;
     }
     if (lvalue is AStructFieldLvalue)
     {
         AStructFieldLvalue aLvalue = (AStructFieldLvalue)lvalue;
         AALocalDecl decl = data.StructMethodFieldLinks[aLvalue];
         if (decl == initialLocalDecl) return false;
         return decl.GetConst() != null && IsConstant(decl.GetInit());
     }
     if (lvalue is AStructLvalue)
     {
         AStructLvalue aLvalue = (AStructLvalue)lvalue;
         AALocalDecl decl = data.StructFieldLinks[aLvalue];
         if (decl == initialLocalDecl) return false;
         return decl.GetConst() != null && IsConstant(decl.GetInit());
     }
     if (lvalue is AArrayLvalue)
     {
         AArrayLvalue aLvalue = (AArrayLvalue)lvalue;
         return IsConstant(aLvalue.GetIndex()) && IsConstant(aLvalue.GetBase());
     }
     if (lvalue is APointerLvalue)
     {
         APointerLvalue aLvalue = (APointerLvalue)lvalue;
         return IsConstant(aLvalue.GetBase());
     }
     if (lvalue is APArrayLengthLvalue)
     {
         APArrayLengthLvalue aLvalue = (APArrayLengthLvalue)lvalue;
         return data.ExpTypes[aLvalue.GetBase()] is AArrayTempType;
     }
     if (lvalue is AThisLvalue)
     {
         return false;
     }
     if (lvalue is AValueLvalue)
     {
         return false;
     }
     throw new Exception("Unexpected lvalue. Got " + lvalue);
 }