示例#1
0
        Function CreateFunction(AST parent, FunctionType func_type, string name)
        {
            Function func;
            Location location = new Location (ts.SourceName, ts.LineNumber);

            if (func_type == FunctionType.Statement)
                func = new FunctionDeclaration (parent, name, location);
            else if (func_type == FunctionType.Expression)
                func = new FunctionExpression (parent, name, location);
            else if (func_type == FunctionType.ExpressionStatement)
                throw new NotImplementedException ();
            else
                throw new Exception ("Unknown FunctionType");
            return func;
        }
 private bool CheckIfTargetOK(object caType)
 {
     if (caType != null)
     {
         AttributeTargets validOn = 0;
         Type             target  = caType as Type;
         if (target != null)
         {
             validOn = ((AttributeUsageAttribute)GetCustomAttributes(target, typeof(AttributeUsageAttribute), true)[0]).ValidOn;
         }
         else
         {
             validOn = ((ClassScope)caType).owner.validOn;
         }
         object obj2   = this.target;
         Class  class2 = obj2 as Class;
         if (class2 != null)
         {
             if (class2.isInterface)
             {
                 if ((validOn & AttributeTargets.Interface) != 0)
                 {
                     return(true);
                 }
             }
             else if (class2 is EnumDeclaration)
             {
                 if ((validOn & AttributeTargets.Enum) != 0)
                 {
                     return(true);
                 }
             }
             else
             {
                 if ((validOn & AttributeTargets.Class) != 0)
                 {
                     if (target == typeof(AttributeUsageAttribute))
                     {
                         if (this.positionalArgValues.Count > 0)
                         {
                             object obj3 = this.positionalArgValues[0];
                             if (obj3 is AttributeTargets)
                             {
                                 class2.validOn = (AttributeTargets)obj3;
                             }
                         }
                         int num   = 0;
                         int count = this.namedArgProperties.Count;
                         while (num < count)
                         {
                             PropertyInfo info = this.namedArgProperties[num] as PropertyInfo;
                             if (info.Name == "AllowMultiple")
                             {
                                 class2.allowMultiple = (bool)this.namedArgPropertyValues[num];
                             }
                             num++;
                         }
                     }
                     return(true);
                 }
                 if (target.FullName == "System.NonSerializedAttribute")
                 {
                     class2.attributes &= ~TypeAttributes.Serializable;
                     return(false);
                 }
             }
             base.context.HandleError(JSError.InvalidCustomAttributeTarget, GetTypeName(caType));
             return(false);
         }
         FunctionDeclaration declaration = obj2 as FunctionDeclaration;
         if (declaration != null)
         {
             if (((validOn & AttributeTargets.Property) != 0) && (declaration.enclosingProperty != null))
             {
                 if ((declaration.enclosingProperty.getter == null) || (((JSFieldMethod)declaration.enclosingProperty.getter).func == declaration.func))
                 {
                     this.raiseToPropertyLevel = true;
                     return(true);
                 }
                 base.context.HandleError(JSError.PropertyLevelAttributesMustBeOnGetter);
                 return(false);
             }
             if (((validOn & AttributeTargets.Method) != 0) && declaration.isMethod)
             {
                 return(true);
             }
             if (((validOn & AttributeTargets.Constructor) != 0) && declaration.func.isConstructor)
             {
                 return(true);
             }
             base.context.HandleError(JSError.InvalidCustomAttributeTarget, GetTypeName(caType));
             return(false);
         }
         if ((obj2 is VariableDeclaration) || (obj2 is Constant))
         {
             if ((validOn & AttributeTargets.Field) != 0)
             {
                 return(true);
             }
             base.context.HandleError(JSError.InvalidCustomAttributeTarget, GetTypeName(caType));
             return(false);
         }
         if ((obj2 is AssemblyCustomAttributeList) && ((validOn & AttributeTargets.Assembly) != 0))
         {
             return(true);
         }
         if ((obj2 == null) && ((validOn & AttributeTargets.Parameter) != 0))
         {
             return(true);
         }
         base.context.HandleError(JSError.InvalidCustomAttributeTarget, GetTypeName(caType));
     }
     return(false);
 }
示例#3
0
      private AST ParseFunction(FieldAttributes visibilitySpec,
                                bool inExpression,
                                Context fncCtx,
                                bool isMethod,
                                bool isAbstract,
                                bool isFinal,
                                bool isInterface,
                                CustomAttributeList customAttributes,
                                Call function){
        IdentifierLiteral name = null;
        AST interfaceName = null;
        ArrayList formalParameters = null;
        TypeExpression returnType = null;
        Block body = null;
        bool isGetter = false;
        bool isSetter = false;

        if (function == null){
          GetNextToken();
          if (isMethod)
            if (JSToken.Get == this.currentToken.token){
              isGetter = true;
              GetNextToken();
            }else if (JSToken.Set == this.currentToken.token){
              isSetter = true;
              GetNextToken();
            }

          // get the function name or make an anonymous function if in expression "position"
          if (JSToken.Identifier == this.currentToken.token){
            name = new IdentifierLiteral(this.scanner.GetIdentifier(), this.currentToken.Clone());
            GetNextToken();
            if (JSToken.AccessField == this.currentToken.token){
              if (isInterface) // "function IBar.foo()" is illegal in an interface declaration
                ReportError(JSError.SyntaxError, true);
              GetNextToken();
              if (JSToken.Identifier == this.currentToken.token){
                interfaceName = new Lookup(name.context);
                name = new IdentifierLiteral(this.scanner.GetIdentifier(), this.currentToken.Clone());
                GetNextToken();
                while (JSToken.AccessField == this.currentToken.token){
                  GetNextToken();
                  if (JSToken.Identifier == this.currentToken.token){
                    interfaceName = new Member(interfaceName.context.CombineWith(this.currentToken), interfaceName,
                      new ConstantWrapper(name.ToString(), name.context));
                    name = new IdentifierLiteral(this.scanner.GetIdentifier(), this.currentToken.Clone());
                    GetNextToken();
                  }else
                    ReportError(JSError.NoIdentifier, true);
                }
              }else
                ReportError(JSError.NoIdentifier, true);
            }
          }else{
            string identifier = JSKeyword.CanBeIdentifier(this.currentToken.token);
            if (null != identifier){
              ForceReportInfo(JSError.KeywordUsedAsIdentifier, isMethod);
              name = new IdentifierLiteral(identifier, this.currentToken.Clone());
              GetNextToken();
            }else{
              if (!inExpression){
                identifier = this.currentToken.GetCode();
                ReportError(JSError.NoIdentifier, true);
                GetNextToken();
              }else
                identifier = "";
              name = new IdentifierLiteral(identifier, CurrentPositionContext());
            }
          }
        }else{ // function was passed in, this is an error condition
          name = function.GetName();
        }

        // make a new state and save the old one
        ArrayList blockType = this.blockType;
        this.blockType = new ArrayList(16);
        SimpleHashtable labelTable = this.labelTable;
        this.labelTable = new SimpleHashtable(16);
        FunctionScope fscope = new FunctionScope(Globals.ScopeStack.Peek(), isMethod);
        Globals.ScopeStack.Push(fscope); //Give declarations a place to go while building AST

        try{
          formalParameters = new ArrayList();
          Context paramArrayContext = null;
          if (function == null){
            // get the formal parameters
            if (JSToken.LeftParen != this.currentToken.token)
              ReportError(JSError.NoLeftParen);
            GetNextToken();
            // create the list of arguments and update the context
            while (JSToken.RightParen != this.currentToken.token){
              if (paramArrayContext != null){
                ReportError(JSError.ParamListNotLast, paramArrayContext, true);
                paramArrayContext = null;
              }
              String id = null;
              TypeExpression typeExpr = null;
              this.noSkipTokenSet.Add(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet);
              try{
                if (JSToken.ParamArray == this.currentToken.token){
                  paramArrayContext = this.currentToken.Clone();
                  GetNextToken();
                }
                if (JSToken.Identifier != this.currentToken.token && (id = JSKeyword.CanBeIdentifier(this.currentToken.token)) == null){
                  if (JSToken.LeftCurly == this.currentToken.token){
                    ReportError(JSError.NoRightParen);
                    break;
                  }else if (JSToken.Comma == this.currentToken.token){
                    // We're missing an argument (or previous argument was malformed and
                    // we skipped to the comma.)  Keep trying to parse the argument list --
                    // we will skip the comma below.
                    ReportError(JSError.SyntaxError, true);
                  }else{
                    ReportError(JSError.SyntaxError, true);
                    SkipTokensAndThrow();
                  }
                }else{
                  if (null == id)
                    id = this.scanner.GetIdentifier();
                  else
                    ForceReportInfo(JSError.KeywordUsedAsIdentifier);
                  Context paramCtx = this.currentToken.Clone();
                  GetNextToken();
                  if (JSToken.Colon == this.currentToken.token){
                    typeExpr = ParseTypeExpression();
                    if (null != typeExpr)
                      paramCtx.UpdateWith(typeExpr.context);
                  }
                  
                  
                  CustomAttributeList custAttrs = null;
                  if (paramArrayContext != null){
                    custAttrs = new CustomAttributeList(paramArrayContext);
                    custAttrs.Append(new CustomAttribute(paramArrayContext, new Lookup("...", paramArrayContext), new ASTList(null)));
                  }
                  formalParameters.Add(new ParameterDeclaration(paramCtx, id, typeExpr, custAttrs));
                }

                // got an arg, it should be either a ',' or ')'
                if (JSToken.RightParen == this.currentToken.token)
                  break;
                else if (JSToken.Comma != this.currentToken.token){
                  // deal with error in some "intelligent" way
                  if (JSToken.LeftCurly == this.currentToken.token){
                    ReportError(JSError.NoRightParen);
                    break;
                  }else{
                    if (JSToken.Identifier == this.currentToken.token && typeExpr == null){
                      // it's possible that the guy was writing the type in C/C++ style (i.e. int x)
                      ReportError(JSError.NoCommaOrTypeDefinitionError);
                    }else
                      ReportError(JSError.NoComma);
                  }
                }
                GetNextToken();
              }catch(RecoveryTokenException exc){
                if (IndexOfToken(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet, exc) == -1)
                  throw exc;
              }finally{
                this.noSkipTokenSet.Remove(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet);
              }
            }
            fncCtx.UpdateWith(this.currentToken);
            // if it is a getter/setter must have 0/1 arg only
            if (isGetter && formalParameters.Count != 0){
              ReportError(JSError.BadPropertyDeclaration, true);
              isGetter = false;
            }else if (isSetter && formalParameters.Count != 1){
              ReportError(JSError.BadPropertyDeclaration, true);
              isSetter = false;
            }
            GetNextToken();

            // check the return type
            if (JSToken.Colon == this.currentToken.token){
              if (isSetter)
                ReportError(JSError.SyntaxError);
              this.noSkipTokenSet.Add(NoSkipTokenSet.s_StartBlockNoSkipTokenSet);
              try{
                returnType = ParseTypeExpression();
              }catch(RecoveryTokenException exc){
                if (IndexOfToken(NoSkipTokenSet.s_StartBlockNoSkipTokenSet, exc) == -1){
                  exc._partiallyComputedNode = null;
                  throw exc;
                }else{
                  if (exc._partiallyComputedNode != null)
                    returnType = (TypeExpression)exc._partiallyComputedNode;
                }
              }finally{
                this.noSkipTokenSet.Remove(NoSkipTokenSet.s_StartBlockNoSkipTokenSet);
              }
              if (isSetter)
                returnType = null;
            }
          }else{ // function was passed in, this is an error condition
            function.GetParameters(formalParameters);
          }

          // read the function body of non-abstract functions.

          if (JSToken.LeftCurly != this.currentToken.token && (isAbstract || (isMethod && GuessIfAbstract()))){
            if (!isAbstract){
              isAbstract = true;
              ReportError(JSError.ShouldBeAbstract, fncCtx, true);
            }
            body = new Block(this.currentToken.Clone());
          }else{
            if (JSToken.LeftCurly != this.currentToken.token)
              ReportError(JSError.NoLeftCurly, true);
            else if (isAbstract)
              ReportError(JSError.AbstractWithBody, fncCtx, true);

            this.blockType.Add(BlockType.Block);
            this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet);
            this.noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
            try{
              // parse the block locally to get the exact end of function
              body = new Block(this.currentToken.Clone());
              GetNextToken();

              while (JSToken.RightCurly != this.currentToken.token){
                try{
                  body.Append(ParseStatement());
                }catch(RecoveryTokenException exc){
                  if (exc._partiallyComputedNode != null){
                    body.Append(exc._partiallyComputedNode);
                  }
                  if (IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc) == -1)
                    throw exc;
                }
              }

              body.context.UpdateWith(this.currentToken);
              fncCtx.UpdateWith(this.currentToken);
            }catch(RecoveryTokenException exc){
              if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1){
                Globals.ScopeStack.Pop(); //Pop current scope so that FunctionDeclaration sees proper scope stack
                try{
                  ParameterDeclaration[] foParameters = new ParameterDeclaration[formalParameters.Count]; formalParameters.CopyTo(foParameters);
                  if (inExpression)
                    exc._partiallyComputedNode =
                      new FunctionExpression(fncCtx, name, foParameters, returnType, body, fscope, visibilitySpec);
                  else
                    exc._partiallyComputedNode =
                      new FunctionDeclaration(fncCtx, interfaceName, name, foParameters, returnType, body, fscope, visibilitySpec,
                      isMethod, isGetter, isSetter, isAbstract, isFinal, customAttributes);
                  if (customAttributes != null) customAttributes.SetTarget(exc._partiallyComputedNode);
                }finally{
                  Globals.ScopeStack.Push(fscope); //Push it back so that the next finally can pop it
                }
                throw exc;
              }
            }finally{
              this.blockType.RemoveAt(this.blockType.Count - 1);
              this.noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
              this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet);
            }

            GetNextToken();
          }
        }finally{
          // restore state
          this.blockType = blockType;
          this.labelTable = labelTable;
          Globals.ScopeStack.Pop();
        }

        ParameterDeclaration[] fParameters = new ParameterDeclaration[formalParameters.Count]; formalParameters.CopyTo(fParameters);
        AST func;
        if (inExpression)
          func = new FunctionExpression(fncCtx, name, fParameters, returnType, body, fscope, visibilitySpec);
        else
          func = new FunctionDeclaration(fncCtx, interfaceName, name, fParameters, returnType, body, fscope, visibilitySpec,
                                         isMethod, isGetter, isSetter, isAbstract, isFinal, customAttributes);

        if (customAttributes != null) customAttributes.SetTarget(func);
        return func;

      }
示例#4
0
        //Check that custom attribute is applicable to its target
        private bool CheckIfTargetOK(Object caType)
        {
            if (caType == null)
            {
                return(false);
            }
            AttributeTargets validOn = (AttributeTargets)0;
            Type             caTypeT = caType as Type;

            if (caTypeT != null)
            {
                Object[] usage = caTypeT.GetCustomAttributes(typeof(AttributeUsageAttribute), true);
                validOn = ((AttributeUsageAttribute)usage[0]).ValidOn;
            }
            else
            {
                validOn = ((ClassScope)caType).owner.validOn;
            }
            Object target = this.target;
            Class  c      = target as Class;

            if (c != null)
            {
                if (c.isInterface)
                {
                    if ((validOn & AttributeTargets.Interface) != 0)
                    {
                        return(true);
                    }
                }
                else if (c is EnumDeclaration)
                {
                    if ((validOn & AttributeTargets.Enum) != 0)
                    {
                        return(true);
                    }
                }
                else if ((validOn & AttributeTargets.Class) != 0)
                {
                    if (caTypeT == typeof(AttributeUsageAttribute))
                    {
                        //This is an attribute that describes a new attribute class
                        //Set the validOn field of Class so that it becomes easier to check the usage of the new attribute
                        if (this.positionalArgValues.Count > 0)
                        {
                            Object par0 = this.positionalArgValues[0];
                            if (par0 is AttributeTargets)
                            {
                                c.validOn = (AttributeTargets)par0;
                            }
                        }
                        for (int i = 0, n = this.namedArgProperties.Count; i < n; i++)
                        {
                            PropertyInfo prop = this.namedArgProperties[i] as PropertyInfo;
                            if (prop.Name == "AllowMultiple")
                            {
                                c.allowMultiple = (bool)this.namedArgPropertyValues[i];
                            }
                        }
                    }
                    return(true);
                }
                else if (caTypeT.FullName == "System.NonSerializedAttribute")
                {
                    c.attributes &= ~TypeAttributes.Serializable;
                    return(false);
                }
                this.context.HandleError(JSError.InvalidCustomAttributeTarget, CustomAttribute.GetTypeName(caType));
                return(false);
            }
            FunctionDeclaration fDecl = target as FunctionDeclaration;

            if (fDecl != null)
            {
                if ((validOn & AttributeTargets.Property) != 0 && fDecl.enclosingProperty != null)
                {
                    if (fDecl.enclosingProperty.getter == null || ((JSFieldMethod)fDecl.enclosingProperty.getter).func == fDecl.func)
                    {
                        this.raiseToPropertyLevel = true; return(true);
                    }
                    else
                    {
                        this.context.HandleError(JSError.PropertyLevelAttributesMustBeOnGetter);
                        return(false);
                    }
                }
                if ((validOn & AttributeTargets.Method) != 0 && fDecl.isMethod)
                {
                    return(true);
                }
                if ((validOn & AttributeTargets.Constructor) != 0 && fDecl.func.isConstructor)
                {
                    return(true);
                }
                this.context.HandleError(JSError.InvalidCustomAttributeTarget, CustomAttribute.GetTypeName(caType));
                return(false);
            }
            if (target is VariableDeclaration || target is Constant)
            {
                if ((validOn & AttributeTargets.Field) != 0)
                {
                    return(true);
                }
                this.context.HandleError(JSError.InvalidCustomAttributeTarget, CustomAttribute.GetTypeName(caType));
                return(false);
            }
            if (target is AssemblyCustomAttributeList && (validOn & AttributeTargets.Assembly) != 0)
            {
                return(true);
            }
            if (target == null && (validOn & AttributeTargets.Parameter) != 0)
            {
                return(true);
            }
            this.context.HandleError(JSError.InvalidCustomAttributeTarget, CustomAttribute.GetTypeName(caType));
            return(false);
        }
示例#5
0
        void load_script_func(EmitContext ec, FunctionDeclaration binding)
        {
            object bind = TypeManager.Get (binding.func_obj.name);

            if (bind != null) {
                if (bind is MethodBuilder) {
                    TypeBuilder type = ec.type_builder;
                    if (binding.InFunction) {
                        LocalBuilder local_meth = (LocalBuilder) TypeManager.GetLocalScriptFunction (binding.func_obj.name);
                        ec.ig.Emit (OpCodes.Ldloc, local_meth);
                    } else {
                        FieldInfo method = type.GetField (binding.func_obj.name);
                        ec.ig.Emit (OpCodes.Ldsfld, method);
                    }
                } else if (bind is LocalBuilder)
                    ec.ig.Emit (OpCodes.Ldloc, (LocalBuilder) bind);
                else throw new Exception ("load_script_func");
            }
        }
 private AST ParseFunction(FieldAttributes visibilitySpec, bool inExpression, Context fncCtx, bool isMethod, bool isAbstract, bool isFinal, bool isInterface, CustomAttributeList customAttributes, Call function)
 {
     AST ast2;
     if (this.demandFullTrustOnFunctionCreation)
     {
         new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
     }
     IdentifierLiteral id = null;
     AST rootObject = null;
     ArrayList parameters = null;
     TypeExpression expression = null;
     Block body = null;
     bool isGetter = false;
     bool isSetter = false;
     if (function == null)
     {
         this.GetNextToken();
         if (isMethod)
         {
             if (JSToken.Get == this.currentToken.token)
             {
                 isGetter = true;
                 this.GetNextToken();
             }
             else if (JSToken.Set == this.currentToken.token)
             {
                 isSetter = true;
                 this.GetNextToken();
             }
         }
         if (JSToken.Identifier == this.currentToken.token)
         {
             id = new IdentifierLiteral(this.scanner.GetIdentifier(), this.currentToken.Clone());
             this.GetNextToken();
             if (JSToken.AccessField == this.currentToken.token)
             {
                 if (isInterface)
                 {
                     this.ReportError(JSError.SyntaxError, true);
                 }
                 this.GetNextToken();
                 if (JSToken.Identifier == this.currentToken.token)
                 {
                     rootObject = new Lookup(id.context);
                     id = new IdentifierLiteral(this.scanner.GetIdentifier(), this.currentToken.Clone());
                     this.GetNextToken();
                     while (JSToken.AccessField == this.currentToken.token)
                     {
                         this.GetNextToken();
                         if (JSToken.Identifier == this.currentToken.token)
                         {
                             rootObject = new Member(rootObject.context.CombineWith(this.currentToken), rootObject, new ConstantWrapper(id.ToString(), id.context));
                             id = new IdentifierLiteral(this.scanner.GetIdentifier(), this.currentToken.Clone());
                             this.GetNextToken();
                         }
                         else
                         {
                             this.ReportError(JSError.NoIdentifier, true);
                         }
                     }
                 }
                 else
                 {
                     this.ReportError(JSError.NoIdentifier, true);
                 }
             }
         }
         else
         {
             string identifier = JSKeyword.CanBeIdentifier(this.currentToken.token);
             if (identifier != null)
             {
                 this.ForceReportInfo(JSError.KeywordUsedAsIdentifier, isMethod);
                 id = new IdentifierLiteral(identifier, this.currentToken.Clone());
                 this.GetNextToken();
             }
             else
             {
                 if (!inExpression)
                 {
                     identifier = this.currentToken.GetCode();
                     this.ReportError(JSError.NoIdentifier, true);
                     this.GetNextToken();
                 }
                 else
                 {
                     identifier = "";
                 }
                 id = new IdentifierLiteral(identifier, this.CurrentPositionContext());
             }
         }
     }
     else
     {
         id = function.GetName();
     }
     ArrayList blockType = this.blockType;
     this.blockType = new ArrayList(0x10);
     SimpleHashtable labelTable = this.labelTable;
     this.labelTable = new SimpleHashtable(0x10);
     FunctionScope item = new FunctionScope(this.Globals.ScopeStack.Peek(), isMethod);
     this.Globals.ScopeStack.Push(item);
     try
     {
         parameters = new ArrayList();
         Context context = null;
         if (function == null)
         {
             if (JSToken.LeftParen != this.currentToken.token)
             {
                 this.ReportError(JSError.NoLeftParen);
             }
             this.GetNextToken();
             while (JSToken.RightParen != this.currentToken.token)
             {
                 if (context != null)
                 {
                     this.ReportError(JSError.ParamListNotLast, context, true);
                     context = null;
                 }
                 string str2 = null;
                 TypeExpression type = null;
                 this.noSkipTokenSet.Add(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet);
                 try
                 {
                     try
                     {
                         if (JSToken.ParamArray == this.currentToken.token)
                         {
                             context = this.currentToken.Clone();
                             this.GetNextToken();
                         }
                         if ((JSToken.Identifier != this.currentToken.token) && ((str2 = JSKeyword.CanBeIdentifier(this.currentToken.token)) == null))
                         {
                             if (JSToken.LeftCurly == this.currentToken.token)
                             {
                                 this.ReportError(JSError.NoRightParen);
                                 break;
                             }
                             if (JSToken.Comma == this.currentToken.token)
                             {
                                 this.ReportError(JSError.SyntaxError, true);
                             }
                             else
                             {
                                 this.ReportError(JSError.SyntaxError, true);
                                 this.SkipTokensAndThrow();
                             }
                         }
                         else
                         {
                             if (str2 == null)
                             {
                                 str2 = this.scanner.GetIdentifier();
                             }
                             else
                             {
                                 this.ForceReportInfo(JSError.KeywordUsedAsIdentifier);
                             }
                             Context context2 = this.currentToken.Clone();
                             this.GetNextToken();
                             if (JSToken.Colon == this.currentToken.token)
                             {
                                 type = this.ParseTypeExpression();
                                 if (type != null)
                                 {
                                     context2.UpdateWith(type.context);
                                 }
                             }
                             CustomAttributeList list3 = null;
                             if (context != null)
                             {
                                 list3 = new CustomAttributeList(context);
                                 list3.Append(new Microsoft.JScript.CustomAttribute(context, new Lookup("...", context), new ASTList(null)));
                             }
                             parameters.Add(new ParameterDeclaration(context2, str2, type, list3));
                         }
                         if (JSToken.RightParen == this.currentToken.token)
                         {
                             break;
                         }
                         if (JSToken.Comma != this.currentToken.token)
                         {
                             if (JSToken.LeftCurly == this.currentToken.token)
                             {
                                 this.ReportError(JSError.NoRightParen);
                                 break;
                             }
                             if ((JSToken.Identifier == this.currentToken.token) && (type == null))
                             {
                                 this.ReportError(JSError.NoCommaOrTypeDefinitionError);
                             }
                             else
                             {
                                 this.ReportError(JSError.NoComma);
                             }
                         }
                         this.GetNextToken();
                     }
                     catch (RecoveryTokenException exception)
                     {
                         if (this.IndexOfToken(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet, exception) == -1)
                         {
                             throw exception;
                         }
                     }
                     continue;
                 }
                 finally
                 {
                     this.noSkipTokenSet.Remove(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet);
                 }
             }
             fncCtx.UpdateWith(this.currentToken);
             if (isGetter && (parameters.Count != 0))
             {
                 this.ReportError(JSError.BadPropertyDeclaration, true);
                 isGetter = false;
             }
             else if (isSetter && (parameters.Count != 1))
             {
                 this.ReportError(JSError.BadPropertyDeclaration, true);
                 isSetter = false;
             }
             this.GetNextToken();
             if (JSToken.Colon == this.currentToken.token)
             {
                 if (isSetter)
                 {
                     this.ReportError(JSError.SyntaxError);
                 }
                 this.noSkipTokenSet.Add(NoSkipTokenSet.s_StartBlockNoSkipTokenSet);
                 try
                 {
                     expression = this.ParseTypeExpression();
                 }
                 catch (RecoveryTokenException exception2)
                 {
                     if (this.IndexOfToken(NoSkipTokenSet.s_StartBlockNoSkipTokenSet, exception2) == -1)
                     {
                         exception2._partiallyComputedNode = null;
                         throw exception2;
                     }
                     if (exception2._partiallyComputedNode != null)
                     {
                         expression = (TypeExpression) exception2._partiallyComputedNode;
                     }
                 }
                 finally
                 {
                     this.noSkipTokenSet.Remove(NoSkipTokenSet.s_StartBlockNoSkipTokenSet);
                 }
                 if (isSetter)
                 {
                     expression = null;
                 }
             }
         }
         else
         {
             function.GetParameters(parameters);
         }
         if ((JSToken.LeftCurly != this.currentToken.token) && (isAbstract || (isMethod && this.GuessIfAbstract())))
         {
             if (!isAbstract)
             {
                 isAbstract = true;
                 this.ReportError(JSError.ShouldBeAbstract, fncCtx, true);
             }
             body = new Block(this.currentToken.Clone());
         }
         else
         {
             if (JSToken.LeftCurly != this.currentToken.token)
             {
                 this.ReportError(JSError.NoLeftCurly, true);
             }
             else if (isAbstract)
             {
                 this.ReportError(JSError.AbstractWithBody, fncCtx, true);
             }
             this.blockType.Add(BlockType.Block);
             this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet);
             this.noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
             try
             {
                 body = new Block(this.currentToken.Clone());
                 this.GetNextToken();
                 while (JSToken.RightCurly != this.currentToken.token)
                 {
                     try
                     {
                         body.Append(this.ParseStatement());
                         continue;
                     }
                     catch (RecoveryTokenException exception3)
                     {
                         if (exception3._partiallyComputedNode != null)
                         {
                             body.Append(exception3._partiallyComputedNode);
                         }
                         if (this.IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exception3) == -1)
                         {
                             throw exception3;
                         }
                         continue;
                     }
                 }
                 body.context.UpdateWith(this.currentToken);
                 fncCtx.UpdateWith(this.currentToken);
             }
             catch (RecoveryTokenException exception4)
             {
                 if (this.IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exception4) == -1)
                 {
                     this.Globals.ScopeStack.Pop();
                     try
                     {
                         ParameterDeclaration[] declarationArray = new ParameterDeclaration[parameters.Count];
                         parameters.CopyTo(declarationArray);
                         if (inExpression)
                         {
                             exception4._partiallyComputedNode = new FunctionExpression(fncCtx, id, declarationArray, expression, body, item, visibilitySpec);
                         }
                         else
                         {
                             exception4._partiallyComputedNode = new FunctionDeclaration(fncCtx, rootObject, id, declarationArray, expression, body, item, visibilitySpec, isMethod, isGetter, isSetter, isAbstract, isFinal, customAttributes);
                         }
                         if (customAttributes != null)
                         {
                             customAttributes.SetTarget(exception4._partiallyComputedNode);
                         }
                     }
                     finally
                     {
                         this.Globals.ScopeStack.Push(item);
                     }
                     throw exception4;
                 }
             }
             finally
             {
                 this.blockType.RemoveAt(this.blockType.Count - 1);
                 this.noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
                 this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet);
             }
             this.GetNextToken();
         }
     }
     finally
     {
         this.blockType = blockType;
         this.labelTable = labelTable;
         this.Globals.ScopeStack.Pop();
     }
     ParameterDeclaration[] array = new ParameterDeclaration[parameters.Count];
     parameters.CopyTo(array);
     if (inExpression)
     {
         ast2 = new FunctionExpression(fncCtx, id, array, expression, body, item, visibilitySpec);
     }
     else
     {
         ast2 = new FunctionDeclaration(fncCtx, rootObject, id, array, expression, body, item, visibilitySpec, isMethod, isGetter, isSetter, isAbstract, isFinal, customAttributes);
     }
     if (customAttributes != null)
     {
         customAttributes.SetTarget(ast2);
     }
     return ast2;
 }