private int FoldInt(PExp exp, ref bool valid)
        {
            if (!valid) return -1;
            if (exp is AIntConstExp)
            {
                return int.Parse(((AIntConstExp) exp).GetIntegerLiteral().Text);
            }
            if (exp is ABinopExp)
            {
                ABinopExp aExp = (ABinopExp)exp;
                int left = FoldInt(aExp.GetLeft(), ref valid);
                int right = FoldInt(aExp.GetLeft(), ref valid);
                if (!valid) return -1;
                PBinop binop = aExp.GetBinop();
                if (binop is APlusBinop)
                    return left + right;
                if (binop is AMinusBinop)
                    return left - right;
                if (binop is ATimesBinop)
                    return left * right;
                if ((binop is AModuloBinop || binop is ADivideBinop) && right == 0)
                {
                    Token token = binop is AModuloBinop
                                      ? (Token)((AModuloBinop) binop).GetToken()
                                      : ((ADivideBinop) binop).GetToken();
                    errors.Add(new ErrorCollection.Error(token, LocRM.GetString("ErrorText57")));
                    throw new ParserException(null, null);
                }
                if (binop is AModuloBinop)
                    return left % right;
                if (binop is ADivideBinop)
                    return left / right;
                if (binop is AAndBinop)
                    return left & right;
                if (binop is AOrBinop)
                    return left | right;
                if (binop is AXorBinop)
                    return left ^ right;
                if (binop is ALBitShiftBinop)
                    return left << right;
                if (binop is ARBitShiftBinop)
                    return left >> right;
            }
            if (exp is ALvalueExp)
                return FoldInt(((ALvalueExp) exp).GetLvalue(), ref valid);

            valid = false;
            return -1;
        }

 static bool IsConst(PExp exp, out bool value)
 {
     if (exp is ABooleanConstExp)
     {
         value = ((ABooleanConstExp)exp).GetBool() is ATrueBool;
         return true;
     }
     if (exp is AIntConstExp)
     {
         value = ((AIntConstExp)exp).GetIntegerLiteral().Text != "0";
         return true;
     }
     if (exp is ANullExp)
     {
         value = false;
         return true;
     }
     value = false;
     return false;
 }

        public void SetInit(PExp node)
        {
            if (_init_ != null)
            {
                _init_.Parent(null);
            }

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

                node.Parent(this);
            }

            _init_ = node;
        }

        public void SetCondition(PExp node)
        {
            if (_condition_ != null)
            {
                _condition_.Parent(null);
            }

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

                node.Parent(this);
            }

            _condition_ = node;
        }

 public AIfThenStm(
         TLParen _token_,
         PExp _condition_,
         PStm _body_
 )
 {
     SetToken(_token_);
     SetCondition(_condition_);
     SetBody(_body_);
 }

        public void SetElse(PExp node)
        {
            if (_else_ != null)
            {
                _else_.Parent(null);
            }

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

                node.Parent(this);
            }

            _else_ = node;
        }

        public void SetReceiver(PExp node)
        {
            if (_receiver_ != null)
            {
                _receiver_.Parent(null);
            }

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

                node.Parent(this);
            }

            _receiver_ = node;
        }

 public ADelegateInvokeExp(
         TIdentifier _token_,
         PExp _receiver_,
         IList _args_
 )
 {
     SetToken(_token_);
     SetReceiver(_receiver_);
     this._args_ = new TypedList(new Args_Cast(this));
     this._args_.Clear();
     this._args_.AddAll(_args_);
 }

 public AALocalDecl(
         PVisibilityModifier _visibility_modifier_,
         TStatic _static_,
         TRef _ref_,
         TOut _out_,
         TConst _const_,
         PType _type_,
         TIdentifier _name_,
         PExp _init_
 )
 {
     SetVisibilityModifier(_visibility_modifier_);
     SetStatic(_static_);
     SetRef(_ref_);
     SetOut(_out_);
     SetConst(_const_);
     SetType(_type_);
     SetName(_name_);
     SetInit(_init_);
 }

 public ACastExp(
         TLParen _token_,
         PType _type_,
         PExp _exp_
 )
 {
     SetToken(_token_);
     SetType(_type_);
     SetExp(_exp_);
 }

 public AForStm(
         TLParen _token_,
         PStm _init_,
         PExp _cond_,
         PStm _update_,
         PStm _body_
 )
 {
     SetToken(_token_);
     SetInit(_init_);
     SetCond(_cond_);
     SetUpdate(_update_);
     SetBody(_body_);
 }

 public AIfExp(
         TQuestionmark _token_,
         PExp _cond_,
         PExp _then_,
         PExp _else_
 )
 {
     SetToken(_token_);
     SetCond(_cond_);
     SetThen(_then_);
     SetElse(_else_);
 }

 public ADeleteStm(
         TDelete _token_,
         PExp _exp_
 )
 {
     SetToken(_token_);
     SetExp(_exp_);
 }

        public void SetThen(PExp node)
        {
            if (_then_ != null)
            {
                _then_.Parent(null);
            }

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

                node.Parent(this);
            }

            _then_ = node;
        }

 public AEnrichmentDecl(
         TEnrichment _token_,
         PExp _dimention_,
         TIntegerLiteral _int_dim_,
         TRBrace _end_token_,
         PType _type_,
         IList _decl_
 )
 {
     SetToken(_token_);
     SetDimention(_dimention_);
     SetIntDim(_int_dim_);
     SetEndToken(_end_token_);
     SetType(_type_);
     this._decl_ = new TypedList(new Decl_Cast(this));
     this._decl_.Clear();
     this._decl_.AddAll(_decl_);
 }

 public AIfThenElseStm(
         TLParen _token_,
         PExp _condition_,
         PStm _then_body_,
         PStm _else_body_
 )
 {
     SetToken(_token_);
     SetCondition(_condition_);
     SetThenBody(_then_body_);
     SetElseBody(_else_body_);
 }

 public AALocalDeclRight(
         TIdentifier _name_,
         PAssignop _assignop_,
         PExp _init_
 )
 {
     SetName(_name_);
     SetAssignop(_assignop_);
     SetInit(_init_);
 }

 public AExpStm(
         TSemicolon _token_,
         PExp _exp_
 )
 {
     SetToken(_token_);
     SetExp(_exp_);
 }

            private void MoveOut(PExp exp, PType type)
            {
                PStm pStm = Util.GetAncestor<PStm>(exp);
                AABlock pBlock = (AABlock)pStm.Parent();

                ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier("gppVar"));
                ALvalueExp lvalueExp = new ALvalueExp(lvalue);
                exp.ReplaceBy(lvalueExp);
                AALocalDecl decl = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, Util.MakeClone(type, data), new TIdentifier("gppVar"), exp);
                pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(pStm), new ALocalDeclStm(new TSemicolon(";"), decl));

                data.LvalueTypes[lvalue] =
                    data.ExpTypes[lvalueExp] = decl.GetType();
                data.LocalLinks[lvalue] = decl;
            }

 public AFieldDecl(
         PVisibilityModifier _visibility_modifier_,
         TStatic _static_,
         TConst _const_,
         PType _type_,
         TIdentifier _name_,
         PExp _init_
 )
 {
     SetVisibilityModifier(_visibility_modifier_);
     SetStatic(_static_);
     SetConst(_const_);
     SetType(_type_);
     SetName(_name_);
     SetInit(_init_);
 }