public override object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
        {
            for (int i = 0; i < fieldDeclaration.Fields.Count; ++i) {
                VariableDeclaration field = (VariableDeclaration)fieldDeclaration.Fields[i];

                if ((fieldDeclaration.Modifier & Modifiers.WithEvents) != 0) {
                    //this.withEventsFields.Add(field);
                }
                TypeReference fieldType = fieldDeclaration.GetTypeForField(i);

                if (fieldType.IsNull) {
                    fieldType = new TypeReference(typeDeclarations.Peek().Name);
                }

                CodeMemberField memberField = new CodeMemberField(ConvType(fieldType), field.Name);
                memberField.Attributes = ConvMemberAttributes(fieldDeclaration.Modifier);
                if (!field.Initializer.IsNull) {
                    memberField.InitExpression = (CodeExpression)field.Initializer.AcceptVisitor(this, data);
                }

                typeDeclarations.Peek().Members.Add(memberField);
            }

            return null;
        }
 public virtual object TrackedVisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
 {
     return base.VisitFieldDeclaration(fieldDeclaration, data);
 }
 public override sealed object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
 {
     this.BeginVisit(fieldDeclaration);
     object result = this.TrackedVisitFieldDeclaration(fieldDeclaration, data);
     this.EndVisit(fieldDeclaration);
     return result;
 }
 public virtual object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
 {
     Debug.Assert((fieldDeclaration != null));
     Debug.Assert((fieldDeclaration.Attributes != null));
     Debug.Assert((fieldDeclaration.TypeReference != null));
     Debug.Assert((fieldDeclaration.Fields != null));
     foreach (AttributeSection o in fieldDeclaration.Attributes) {
         Debug.Assert(o != null);
         o.AcceptVisitor(this, data);
     }
     fieldDeclaration.TypeReference.AcceptVisitor(this, data);
     foreach (VariableDeclaration o in fieldDeclaration.Fields) {
         Debug.Assert(o != null);
         o.AcceptVisitor(this, data);
     }
     return null;
 }
 public virtual object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
 {
     throw new global::System.NotImplementedException("FieldDeclaration");
 }
Example #6
0
        void StructureMemberDecl(ModifierList m, List<AttributeSection> attributes)
        {
            TypeReference type = null;
            List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
            Statement stmt = null;
            List<VariableDeclaration> variableDeclarators = new List<VariableDeclaration>();
            List<TemplateDefinition> templates = new List<TemplateDefinition>();

            switch (la.kind) {
            case 84: case 103: case 115: case 142: case 155: case 209: {
            NonModuleDeclaration(m, attributes);
            break;
            }
            case 210: {
            Get();
            Location startPos = t.Location;

            if (StartOf(5)) {
                string name = String.Empty;
                    MethodDeclaration methodDeclaration; List<string> handlesClause = null;
                    List<InterfaceImplementation> implementsClause = null;

                Identifier();
                name = t.val;
                    m.Check(Modifiers.VBMethods);

                TypeParameterList(templates);
                if (la.kind == 37) {
                    Get();
                    if (StartOf(7)) {
                        FormalParameterList(p);
                    }
                    Expect(38);
                }
                if (la.kind == 134 || la.kind == 136) {
                    if (la.kind == 136) {
                        ImplementsClause(out implementsClause);
                    } else {
                        HandlesClause(out handlesClause);
                    }
                }
                Location endLocation = t.EndLocation;
                if (IsMustOverride(m)) {
                    EndOfStmt();
                    methodDeclaration = new MethodDeclaration {
                            Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
                            StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
                            TypeReference = new TypeReference("System.Void", true),
                            Templates = templates,
                            HandlesClause = handlesClause,
                            InterfaceImplementations = implementsClause
                        };
                        AddChild(methodDeclaration);

                } else if (la.kind == 1) {
                    Get();
                    methodDeclaration = new MethodDeclaration {
                            Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
                            StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
                            TypeReference = new TypeReference("System.Void", true),
                            Templates = templates,
                            HandlesClause = handlesClause,
                            InterfaceImplementations = implementsClause
                        };
                        AddChild(methodDeclaration);

                    if (ParseMethodBodies) {
                    Block(out stmt);
                    Expect(113);
                    Expect(210);
                    } else {
                        // don't parse method body
                        lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
                       }

                    methodDeclaration.Body  = (BlockStatement)stmt;
                    methodDeclaration.Body.EndLocation = t.EndLocation;
                    EndOfStmt();
                } else SynErr(257);
            } else if (la.kind == 162) {
                Get();
                if (la.kind == 37) {
                    Get();
                    if (StartOf(7)) {
                        FormalParameterList(p);
                    }
                    Expect(38);
                }
                m.Check(Modifiers.Constructors);
                Location constructorEndLocation = t.EndLocation;
                Expect(1);
                if (ParseMethodBodies) {
                Block(out stmt);
                Expect(113);
                Expect(210);
                } else {
                    // don't parse method body
                    lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
                   }

                Location endLocation = t.EndLocation;
                EndOfStmt();
                ConstructorDeclaration cd = new ConstructorDeclaration("New", m.Modifier, p, attributes);
                    cd.StartLocation = m.GetDeclarationLocation(startPos);
                    cd.EndLocation   = constructorEndLocation;
                    cd.Body = (BlockStatement)stmt;
                    cd.Body.EndLocation   = endLocation;
                    AddChild(cd);

            } else SynErr(258);
            break;
            }
            case 127: {
            Get();
            m.Check(Modifiers.VBMethods);
                string name = String.Empty;
                Location startPos = t.Location;
                MethodDeclaration methodDeclaration;List<string> handlesClause = null;
                List<InterfaceImplementation> implementsClause = null;
                AttributeSection returnTypeAttributeSection = null;

            Identifier();
            name = t.val;
            TypeParameterList(templates);
            if (la.kind == 37) {
                Get();
                if (StartOf(7)) {
                    FormalParameterList(p);
                }
                Expect(38);
            }
            if (la.kind == 63) {
                Get();
                while (la.kind == 40) {
                    AttributeSection(out returnTypeAttributeSection);
                    if (returnTypeAttributeSection != null) {
                            returnTypeAttributeSection.AttributeTarget = "return";
                            attributes.Add(returnTypeAttributeSection);
                        }

                }
                TypeName(out type);
            }
            if(type == null) {
                    type = new TypeReference("System.Object", true);
                }

            if (la.kind == 134 || la.kind == 136) {
                if (la.kind == 136) {
                    ImplementsClause(out implementsClause);
                } else {
                    HandlesClause(out handlesClause);
                }
            }
            Location endLocation = t.EndLocation;
            if (IsMustOverride(m)) {
                EndOfStmt();
                methodDeclaration = new MethodDeclaration {
                        Name = name, Modifier = m.Modifier, TypeReference = type,
                        Parameters = p, Attributes = attributes,
                        StartLocation = m.GetDeclarationLocation(startPos),
                        EndLocation   = endLocation,
                        HandlesClause = handlesClause,
                        Templates     = templates,
                        InterfaceImplementations = implementsClause
                    };

                    AddChild(methodDeclaration);

            } else if (la.kind == 1) {
                Get();
                methodDeclaration = new MethodDeclaration {
                        Name = name, Modifier = m.Modifier, TypeReference = type,
                        Parameters = p, Attributes = attributes,
                        StartLocation = m.GetDeclarationLocation(startPos),
                        EndLocation   = endLocation,
                        Templates     = templates,
                        HandlesClause = handlesClause,
                        InterfaceImplementations = implementsClause
                    };

                    AddChild(methodDeclaration);

                    if (ParseMethodBodies) {
                Block(out stmt);
                Expect(113);
                Expect(127);
                } else {
                        // don't parse method body
                        lexer.SkipCurrentBlock(Tokens.Function); stmt = new BlockStatement();
                    }
                    methodDeclaration.Body = (BlockStatement)stmt;
                    methodDeclaration.Body.StartLocation = methodDeclaration.EndLocation;
                    methodDeclaration.Body.EndLocation   = t.EndLocation;

                EndOfStmt();
            } else SynErr(259);
            break;
            }
            case 101: {
            Get();
            m.Check(Modifiers.VBExternalMethods);
                Location startPos = t.Location;
                CharsetModifier charsetModifer = CharsetModifier.None;
                string library = String.Empty;
                string alias = null;
                string name = String.Empty;

            if (StartOf(16)) {
                Charset(out charsetModifer);
            }
            if (la.kind == 210) {
                Get();
                Identifier();
                name = t.val;
                Expect(149);
                Expect(3);
                library = t.literalValue as string;
                if (la.kind == 59) {
                    Get();
                    Expect(3);
                    alias = t.literalValue as string;
                }
                if (la.kind == 37) {
                    Get();
                    if (StartOf(7)) {
                        FormalParameterList(p);
                    }
                    Expect(38);
                }
                EndOfStmt();
                DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, null, p, attributes, library, alias, charsetModifer);
                    declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
                    declareDeclaration.EndLocation   = t.EndLocation;
                    AddChild(declareDeclaration);

            } else if (la.kind == 127) {
                Get();
                Identifier();
                name = t.val;
                Expect(149);
                Expect(3);
                library = t.literalValue as string;
                if (la.kind == 59) {
                    Get();
                    Expect(3);
                    alias = t.literalValue as string;
                }
                if (la.kind == 37) {
                    Get();
                    if (StartOf(7)) {
                        FormalParameterList(p);
                    }
                    Expect(38);
                }
                if (la.kind == 63) {
                    Get();
                    TypeName(out type);
                }
                EndOfStmt();
                DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, type, p, attributes, library, alias, charsetModifer);
                    declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
                    declareDeclaration.EndLocation   = t.EndLocation;
                    AddChild(declareDeclaration);

            } else SynErr(260);
            break;
            }
            case 119: {
            Get();
            m.Check(Modifiers.VBEvents);
                Location startPos = t.Location;
                EventDeclaration eventDeclaration;
                string name = String.Empty;
                List<InterfaceImplementation> implementsClause = null;

            Identifier();
            name= t.val;
            if (la.kind == 63) {
                Get();
                TypeName(out type);
            } else if (StartOf(17)) {
                if (la.kind == 37) {
                    Get();
                    if (StartOf(7)) {
                        FormalParameterList(p);
                    }
                    Expect(38);
                }
            } else SynErr(261);
            if (la.kind == 136) {
                ImplementsClause(out implementsClause);
            }
            eventDeclaration = new EventDeclaration {
                    Name = name, TypeReference = type, Modifier = m.Modifier,
                    Parameters = p, Attributes = attributes, InterfaceImplementations = implementsClause,
                    StartLocation = m.GetDeclarationLocation(startPos),
                    EndLocation = t.EndLocation
                };
                AddChild(eventDeclaration);

            EndOfStmt();
            break;
            }
            case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
            m.Check(Modifiers.Fields);
                FieldDeclaration fd = new FieldDeclaration(attributes, null, m.Modifier);

            IdentifierForFieldDeclaration();
            string name = t.val;
            fd.StartLocation = m.GetDeclarationLocation(t.Location);
            VariableDeclaratorPartAfterIdentifier(variableDeclarators, name);
            while (la.kind == 22) {
                Get();
                VariableDeclarator(variableDeclarators);
            }
            EndOfStmt();
            fd.EndLocation = t.EndLocation;
                fd.Fields = variableDeclarators;
                AddChild(fd);

            break;
            }
            case 88: {
            m.Check(Modifiers.Fields);
            Get();
            m.Add(Modifiers.Const, t.Location);
            FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
                fd.StartLocation = m.GetDeclarationLocation(t.Location);
                List<VariableDeclaration> constantDeclarators = new List<VariableDeclaration>();

            ConstantDeclarator(constantDeclarators);
            while (la.kind == 22) {
                Get();
                ConstantDeclarator(constantDeclarators);
            }
            fd.Fields = constantDeclarators;
                fd.EndLocation = t.Location;

            EndOfStmt();
            fd.EndLocation = t.EndLocation;
                AddChild(fd);

            break;
            }
            case 186: {
            Get();
            m.Check(Modifiers.VBProperties);
                Location startPos = t.Location;
                List<InterfaceImplementation> implementsClause = null;
                AttributeSection returnTypeAttributeSection = null;
                Expression initializer = null;

            Identifier();
            string propertyName = t.val;
            if (la.kind == 37) {
                Get();
                if (StartOf(7)) {
                    FormalParameterList(p);
                }
                Expect(38);
            }
            if (la.kind == 63) {
                Get();
                while (la.kind == 40) {
                    AttributeSection(out returnTypeAttributeSection);
                    if (returnTypeAttributeSection != null) {
                            returnTypeAttributeSection.AttributeTarget = "return";
                            attributes.Add(returnTypeAttributeSection);
                        }

                }
                if (IsNewExpression()) {
                    ObjectCreateExpression(out initializer);
                    if (initializer is ObjectCreateExpression) {
                            type = ((ObjectCreateExpression)initializer).CreateType.Clone();
                        } else {
                            type = ((ArrayCreateExpression)initializer).CreateType.Clone();
                        }

                } else if (StartOf(9)) {
                    TypeName(out type);
                } else SynErr(262);
            }
            if (la.kind == 20) {
                Get();
                Expr(out initializer);
            }
            if (la.kind == 136) {
                ImplementsClause(out implementsClause);
            }
            EndOfStmt();
            if (IsMustOverride(m) || IsAutomaticProperty()) {
                PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
                    pDecl.StartLocation = m.GetDeclarationLocation(startPos);
                    pDecl.EndLocation   = t.Location;
                    pDecl.TypeReference = type;
                    pDecl.InterfaceImplementations = implementsClause;
                    pDecl.Parameters = p;
                    if (initializer != null)
                        pDecl.Initializer = initializer;
                    AddChild(pDecl);

            } else if (StartOf(18)) {
                PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
                    pDecl.StartLocation = m.GetDeclarationLocation(startPos);
                    pDecl.EndLocation   = t.Location;
                    pDecl.BodyStart   = t.Location;
                    pDecl.TypeReference = type;
                    pDecl.InterfaceImplementations = implementsClause;
                    pDecl.Parameters = p;
                    PropertyGetRegion getRegion;
                    PropertySetRegion setRegion;

                AccessorDecls(out getRegion, out setRegion);
                Expect(113);
                Expect(186);
                EndOfStmt();
                pDecl.GetRegion = getRegion;
                    pDecl.SetRegion = setRegion;
                    pDecl.BodyEnd = t.Location; // t = EndOfStmt; not "Property"
                    AddChild(pDecl);

            } else SynErr(263);
            break;
            }
            case 98: {
            Get();
            Location startPos = t.Location;
            Expect(119);
            m.Check(Modifiers.VBCustomEvents);
                EventAddRemoveRegion eventAccessorDeclaration;
                EventAddRegion addHandlerAccessorDeclaration = null;
                EventRemoveRegion removeHandlerAccessorDeclaration = null;
                EventRaiseRegion raiseEventAccessorDeclaration = null;
                List<InterfaceImplementation> implementsClause = null;

            Identifier();
            string customEventName = t.val;
            Expect(63);
            TypeName(out type);
            if (la.kind == 136) {
                ImplementsClause(out implementsClause);
            }
            EndOfStmt();
            while (StartOf(19)) {
                EventAccessorDeclaration(out eventAccessorDeclaration);
                if(eventAccessorDeclaration is EventAddRegion)
                    {
                        addHandlerAccessorDeclaration = (EventAddRegion)eventAccessorDeclaration;
                    }
                    else if(eventAccessorDeclaration is EventRemoveRegion)
                    {
                        removeHandlerAccessorDeclaration = (EventRemoveRegion)eventAccessorDeclaration;
                    }
                    else if(eventAccessorDeclaration is EventRaiseRegion)
                    {
                        raiseEventAccessorDeclaration = (EventRaiseRegion)eventAccessorDeclaration;
                    }

            }
            Expect(113);
            Expect(119);
            EndOfStmt();
            if(addHandlerAccessorDeclaration == null)
                {
                    Error("Need to provide AddHandler accessor.");
                }

                if(removeHandlerAccessorDeclaration == null)
                {
                    Error("Need to provide RemoveHandler accessor.");
                }

                if(raiseEventAccessorDeclaration == null)
                {
                    Error("Need to provide RaiseEvent accessor.");
                }

                EventDeclaration decl = new EventDeclaration {
                    TypeReference = type, Name = customEventName, Modifier = m.Modifier,
                    Attributes = attributes,
                    StartLocation = m.GetDeclarationLocation(startPos),
                    EndLocation = t.EndLocation,
                    AddRegion = addHandlerAccessorDeclaration,
                    RemoveRegion = removeHandlerAccessorDeclaration,
                    RaiseRegion = raiseEventAccessorDeclaration
                };
                AddChild(decl);

            break;
            }
            case 161: case 172: case 232: {
            ConversionType opConversionType = ConversionType.None;
            if (la.kind == 161 || la.kind == 232) {
                if (la.kind == 232) {
                    Get();
                    opConversionType = ConversionType.Implicit;
                } else {
                    Get();
                    opConversionType = ConversionType.Explicit;
                }
            }
            Expect(172);
            m.Check(Modifiers.VBOperators);
                Location startPos = t.Location;
                TypeReference returnType = NullTypeReference.Instance;
                TypeReference operandType = NullTypeReference.Instance;
                OverloadableOperatorType operatorType;
                AttributeSection section;
                ParameterDeclarationExpression param;
                List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();

            OverloadableOperator(out operatorType);
            Expect(37);
            FormalParameter(out param);
            if (param != null) parameters.Add(param);
            if (la.kind == 22) {
                Get();
                FormalParameter(out param);
                if (param != null) parameters.Add(param);
            }
            Expect(38);
            Location endPos = t.EndLocation;
            if (la.kind == 63) {
                Get();
                while (la.kind == 40) {
                    AttributeSection(out section);
                    if (section != null) {
                        section.AttributeTarget = "return";
                        attributes.Add(section);
                    }
                }
                TypeName(out returnType);
                endPos = t.EndLocation;
            }
            Expect(1);
            Block(out stmt);
            Expect(113);
            Expect(172);
            EndOfStmt();
            OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
                    Modifier = m.Modifier,
                    Attributes = attributes,
                    Parameters = parameters,
                    TypeReference = returnType,
                    OverloadableOperator = operatorType,
                    ConversionType = opConversionType,
                    Body = (BlockStatement)stmt,
                    StartLocation = m.GetDeclarationLocation(startPos),
                    EndLocation = endPos
                };
                operatorDeclaration.Body.StartLocation = startPos;
                operatorDeclaration.Body.EndLocation = t.Location;
                AddChild(operatorDeclaration);

            break;
            }
            default: SynErr(264); break;
            }
        }
Example #7
0
        void EnumMemberDecl(out FieldDeclaration f)
        {
            Expression expr = null;List<AttributeSection> attributes = new List<AttributeSection>();
            AttributeSection section = null;
            VariableDeclaration varDecl = null;

            while (la.kind == 40) {
            AttributeSection(out section);
            attributes.Add(section);
            }
            Identifier();
            f = new FieldDeclaration(attributes);
            varDecl = new VariableDeclaration(t.val);
            f.Fields.Add(varDecl);
            f.StartLocation = varDecl.StartLocation = t.Location;

            if (la.kind == 20) {
            Get();
            Expr(out expr);
            varDecl.Initializer = expr;
            }
            f.EndLocation = varDecl.EndLocation = t.EndLocation;
            EndOfStmt();
        }
 public virtual object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
 {
     Debug.Assert((fieldDeclaration != null));
     Debug.Assert((fieldDeclaration.Attributes != null));
     Debug.Assert((fieldDeclaration.TypeReference != null));
     Debug.Assert((fieldDeclaration.Fields != null));
     for (int i = 0; i < fieldDeclaration.Attributes.Count; i++) {
         AttributeSection o = fieldDeclaration.Attributes[i];
         Debug.Assert(o != null);
         nodeStack.Push(o);
         o.AcceptVisitor(this, data);
         o = (AttributeSection)nodeStack.Pop();
         if (o == null)
             fieldDeclaration.Attributes.RemoveAt(i--);
         else
             fieldDeclaration.Attributes[i] = o;
     }
     nodeStack.Push(fieldDeclaration.TypeReference);
     fieldDeclaration.TypeReference.AcceptVisitor(this, data);
     fieldDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
     for (int i = 0; i < fieldDeclaration.Fields.Count; i++) {
         VariableDeclaration o = fieldDeclaration.Fields[i];
         Debug.Assert(o != null);
         nodeStack.Push(o);
         o.AcceptVisitor(this, data);
         o = (VariableDeclaration)nodeStack.Pop();
         if (o == null)
             fieldDeclaration.Fields.RemoveAt(i--);
         else
             fieldDeclaration.Fields[i] = o;
     }
     return null;
 }