Example #1
0
		override public void OnStructDefinition(StructDefinition node)
		{
			ClassDefinition cd = new ClassDefinition(node.LexicalInfo);
			cd.Name = node.Name;
			cd.Attributes = node.Attributes;
			cd.Modifiers = node.Modifiers;
			cd.Members = node.Members;
			cd.GenericParameters = node.GenericParameters;
			cd.BaseTypes = node.BaseTypes;
			cd.BaseTypes.Insert(0, CodeBuilder.CreateTypeReference(TypeSystemServices.ValueTypeType));
			foreach (TypeMember member in cd.Members)
			{
				if (member.IsVisibilitySet)
					continue;

				switch (member.NodeType)
				{
					case NodeType.Field:
						member.Visibility = Context.Parameters.DefaultFieldVisibility;
						break;
					case NodeType.Property:
						member.Visibility = Context.Parameters.DefaultPropertyVisibility;
						break;
					case NodeType.Method:
						member.Visibility = Context.Parameters.DefaultMethodVisibility;
						break;
				}

				if (member.IsProtected)
					member.Visibility = TypeMemberModifiers.Public;
			}
			OnClassDefinition(cd);
			ReplaceCurrentNode(cd);
		}
Example #2
0
        override public object Clone()
        {
            StructDefinition clone = (StructDefinition)FormatterServices.GetUninitializedObject(typeof(StructDefinition));

            clone._lexicalInfo       = _lexicalInfo;
            clone._endSourceLocation = _endSourceLocation;
            clone._documentation     = _documentation;
            clone._isSynthetic       = _isSynthetic;
            clone._entity            = _entity;
            if (_annotations != null)
            {
                clone._annotations = (Hashtable)_annotations.Clone();
            }

            clone._modifiers = _modifiers;
            clone._name      = _name;
            if (null != _attributes)
            {
                clone._attributes = _attributes.Clone() as AttributeCollection;
                clone._attributes.InitializeParent(clone);
            }
            if (null != _members)
            {
                clone._members = _members.Clone() as TypeMemberCollection;
                clone._members.InitializeParent(clone);
            }
            if (null != _baseTypes)
            {
                clone._baseTypes = _baseTypes.Clone() as TypeReferenceCollection;
                clone._baseTypes.InitializeParent(clone);
            }
            if (null != _genericParameters)
            {
                clone._genericParameters = _genericParameters.Clone() as GenericParameterDeclarationCollection;
                clone._genericParameters.InitializeParent(clone);
            }
            return(clone);
        }
Example #3
0
        //throws RecognitionException, TokenStreamException
        protected void class_definition(
            TypeMemberCollection container
            )
        {
            IToken  id = null;

                TypeDefinition td = null;
                TypeReferenceCollection baseTypes = null;
                TypeMemberCollection members = null;
                GenericParameterDeclarationCollection genericParameters = null;

            try {      // for error handling
            {
                switch ( LA(1) )
                {
                case CLASS:
                {
                    match(CLASS);
                    if (0==inputState.guessing)
                    {
                        td = new ClassDefinition();
                    }
                    break;
                }
                case STRUCT:
                {
                    match(STRUCT);
                    if (0==inputState.guessing)
                    {
                        td = new StructDefinition();
                    }
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            id = LT(1);
            match(ID);
            if (0==inputState.guessing)
            {

                        td.LexicalInfo = SourceLocationFactory.ToLexicalInfo(id);
                        td.Name = id.getText();
                        td.Modifiers = _modifiers;
                        AddAttributes(td.Attributes);
                        container.Add(td);
                        baseTypes = td.BaseTypes;
                        members = td.Members;
                        genericParameters = td.GenericParameters;

            }
            {
                switch ( LA(1) )
                {
                case LBRACK:
                {
                    match(LBRACK);
                    {
                        switch ( LA(1) )
                        {
                        case OF:
                        {
                            match(OF);
                            break;
                        }
                        case ID:
                        {
                            break;
                        }
                        default:
                        {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                         }
                    }
                    generic_parameter_declaration_list(genericParameters);
                    match(RBRACK);
                    break;
                }
                case LPAREN:
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            {
                switch ( LA(1) )
                {
                case LPAREN:
                {
                    base_types(baseTypes);
                    break;
                }
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            begin_with_doc(td);
            {    // ( ... )*
                for (;;)
                {
                    switch ( LA(1) )
                    {
                    case SPLICE_BEGIN:
                    {
                        splice_type_definition_body(members);
                        break;
                    }
                    case ABSTRACT:
                    case CALLABLE:
                    case CLASS:
                    case DEF:
                    case ENUM:
                    case EVENT:
                    case FINAL:
                    case INTERFACE:
                    case INTERNAL:
                    case NEW:
                    case OVERRIDE:
                    case PUBLIC:
                    case PROTECTED:
                    case PRIVATE:
                    case SELF:
                    case STATIC:
                    case STRUCT:
                    case TRANSIENT:
                    case VIRTUAL:
                    case PARTIAL:
                    case ID:
                    case LBRACK:
                    {
                        type_definition_member(members);
                        break;
                    }
                    default:
                    {
                        goto _loop67_breakloop;
                    }
                     }
                }
            _loop67_breakloop:				;
            }    // ( ... )*
            end(td);
            }
            catch (RecognitionException ex)
            {
            if (0 == inputState.guessing)
            {
                reportError(ex);
                recover(ex,tokenSet_32_);
            }
            else
            {
                throw ex;
            }
            }
        }
 public override void LeaveStructDefinition(StructDefinition node)
 {
     LeaveTypeDefinition(node);
 }
		public object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
		{
			if (typeDeclaration.Templates.Count > 0) {
				AddError(typeDeclaration, "Generic type definitions are not supported.");
			}
			B.TypeDefinition oldType = currentType;
			B.TypeDefinition typeDef;
			switch (typeDeclaration.Type) {
				case ClassType.Class:
					typeDef = new B.ClassDefinition(GetLexicalInfo(typeDeclaration));
					break;
				case ClassType.Interface:
					typeDef = new B.InterfaceDefinition(GetLexicalInfo(typeDeclaration));
					break;
				case ClassType.Enum:
					typeDef = new B.EnumDefinition(GetLexicalInfo(typeDeclaration));
					break;
				case ClassType.Struct:
					typeDef = new B.StructDefinition(GetLexicalInfo(typeDeclaration));
					break;
				case ClassType.Module:
					typeDef = new B.ClassDefinition(GetLexicalInfo(typeDeclaration));
					typeDeclaration.Modifier |= Modifiers.Static;
					break;
				default:
					AddError(typeDeclaration, "Unknown class type.");
					return null;
			}
			if (currentType != null)
				typeDef.Modifiers = ConvertModifier(typeDeclaration, B.TypeMemberModifiers.Private);
			else
				typeDef.Modifiers = ConvertModifier(typeDeclaration, B.TypeMemberModifiers.Internal);
			typeDef.Name = typeDeclaration.Name;
			typeDef.EndSourceLocation = GetLocation(typeDeclaration.EndLocation);
			ConvertAttributes(typeDeclaration.Attributes, typeDef.Attributes);
			ConvertTypeReferences(typeDeclaration.BaseTypes, typeDef.BaseTypes);
			
			if (currentType != null)
				currentType.Members.Add(typeDef);
			else
				module.Members.Add(typeDef);
			currentType = typeDef;
			typeDeclaration.AcceptChildren(this, data);
			currentType = oldType;
			return typeDef;
		}
 public override void OnStructDefinition(StructDefinition node)
 {
     EnterNamespace((INamespace)GetEntity(node));
     VisitTypeDefinitionBody(node);
     LeaveNamespace();
 }
		public override void OnStructDefinition(StructDefinition node)
		{
			EnterTypeDefinition(node);
			base.OnStructDefinition(node);
			fieldStack.Pop();
		}
Example #8
0
 public override void OnStructDefinition(StructDefinition node)
 {
     WriteTypeDefinition("struct", node);
 }
Example #9
0
 public override void LeaveStructDefinition(StructDefinition node)
 {
     CantBeMarkedAbstract(node);
     CantBeMarkedFinal(node);
     CantBeMarkedStatic(node);
     CantBeMarkedPartial(node);
 }
Example #10
0
 public override void OnStructDefinition(StructDefinition node)
 {
     AddMember(node);
 }
Example #11
0
        //throws RecognitionException, TokenStreamException
        protected void class_definition(
            TypeMemberCollection container
            )
        {
            IToken  id = null;

                TypeDefinition td = null;
                TypeReferenceCollection baseTypes = null;
                TypeMemberCollection members = null;
                GenericParameterDeclarationCollection genericParameters = null;

            try {      // for error handling
            {
                switch ( LA(1) )
                {
                case CLASS:
                {
                    match(CLASS);
                    if (0==inputState.guessing)
                    {
                        td = new ClassDefinition();
                    }
                    break;
                }
                case STRUCT:
                {
                    match(STRUCT);
                    if (0==inputState.guessing)
                    {
                        td = new StructDefinition();
                    }
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            id = LT(1);
            match(ID);
            if (0==inputState.guessing)
            {

                        td.LexicalInfo = SourceLocationFactory.ToLexicalInfo(id);
                        td.Name = id.getText();
                        td.Modifiers = _modifiers;
                        AddAttributes(td.Attributes);
                        container.Add(td);
                        baseTypes = td.BaseTypes;
                        members = td.Members;
                        genericParameters = td.GenericParameters;

            }
            {
                switch ( LA(1) )
                {
                case LBRACK:
                {
                    match(LBRACK);
                    {
                        switch ( LA(1) )
                        {
                        case OF:
                        {
                            match(OF);
                            break;
                        }
                        case ID:
                        {
                            break;
                        }
                        default:
                        {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                         }
                    }
                    generic_parameter_declaration_list(genericParameters);
                    match(RBRACK);
                    break;
                }
                case LPAREN:
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            {
                switch ( LA(1) )
                {
                case LPAREN:
                {
                    base_types(baseTypes);
                    break;
                }
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            begin_with_doc(td);
            {    // ( ... )*
                for (;;)
                {
                    if ((tokenSet_28_.member(LA(1))))
                    {
                        type_definition_member(members);
                    }
                    else
                    {
                        goto _loop61_breakloop;
                    }

                }
            _loop61_breakloop:				;
            }    // ( ... )*
            end(td);
            }
            catch (RecognitionException ex)
            {
            if (0 == inputState.guessing)
            {
                reportError(ex);
                recover(ex,tokenSet_27_);
            }
            else
            {
                throw ex;
            }
            }
        }
Example #12
0
 public override bool EnterStructDefinition(StructDefinition node)
 {
     return false;
 }
Example #13
0
		override public object Clone()
		{
		
			StructDefinition clone = new StructDefinition();
			clone._lexicalInfo = _lexicalInfo;
			clone._endSourceLocation = _endSourceLocation;
			clone._documentation = _documentation;
			clone._isSynthetic = _isSynthetic;
			clone._entity = _entity;
			if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
			clone._modifiers = _modifiers;
			clone._name = _name;
			if (null != _attributes)
			{
				clone._attributes = _attributes.Clone() as AttributeCollection;
				clone._attributes.InitializeParent(clone);
			}
			if (null != _members)
			{
				clone._members = _members.Clone() as TypeMemberCollection;
				clone._members.InitializeParent(clone);
			}
			if (null != _baseTypes)
			{
				clone._baseTypes = _baseTypes.Clone() as TypeReferenceCollection;
				clone._baseTypes.InitializeParent(clone);
			}
			if (null != _genericParameters)
			{
				clone._genericParameters = _genericParameters.Clone() as GenericParameterDeclarationCollection;
				clone._genericParameters.InitializeParent(clone);
			}
			return clone;


		}
Example #14
0
 public override void OnStructDefinition(StructDefinition node)
 {
     ClassDefinition cd = new ClassDefinition(node.LexicalInfo);
     cd.Name = node.Name;
     cd.Attributes = node.Attributes;
     cd.Modifiers = node.Modifiers;
     cd.Members = node.Members;
     cd.GenericParameters = node.GenericParameters;
     cd.BaseTypes = node.BaseTypes;
     cd.BaseTypes.Insert(0, CodeBuilder.CreateTypeReference(TypeSystemServices.ValueTypeType));
     foreach (TypeMember member in cd.Members)
     {
         if (!member.IsVisibilitySet)
         {
             member.Modifiers |= TypeMemberModifiers.Public;
         }
     }
     OnClassDefinition(cd);
     ReplaceCurrentNode(cd);
 }
		public override void OnStructDefinition(StructDefinition node)
		{
			ConvertTypeDefinition(node).IsStruct = true;
		}
Example #16
0
		public override void OnStructDefinition(StructDefinition node)
		{
			OnTypeDefinition(node);
		}
Example #17
0
	protected void class_definition(
		TypeMemberCollection container
	) //throws RecognitionException, TokenStreamException
{
		
		IToken  id = null;
		IToken  begin = null;
		
				TypeDefinition td = null;
				TypeReferenceCollection baseTypes = null;
				TypeMemberCollection members = null;
				GenericParameterDeclarationCollection genericParameters = null;
				Expression nameSplice = null;
			
		
		try {      // for error handling
			{
				switch ( LA(1) )
				{
				case CLASS:
				{
					match(CLASS);
					if (0==inputState.guessing)
					{
						td = new ClassDefinition();
					}
					break;
				}
				case STRUCT:
				{
					match(STRUCT);
					if (0==inputState.guessing)
					{
						td = new StructDefinition();
					}
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			{
				switch ( LA(1) )
				{
				case ID:
				{
					id = LT(1);
					match(ID);
					break;
				}
				case SPLICE_BEGIN:
				{
					begin = LT(1);
					match(SPLICE_BEGIN);
					nameSplice=atom();
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			if (0==inputState.guessing)
			{
						
						IToken token = id ?? begin;
						td.LexicalInfo = ToLexicalInfo(token);
						td.Name = token.getText();
						td.Modifiers = _modifiers;
						AddAttributes(td.Attributes);
						baseTypes = td.BaseTypes;
						members = td.Members;
						genericParameters = td.GenericParameters;
						
						if (id != null) {
							container.Add(td);
						} else {
							container.Add(new SpliceTypeMember(td, nameSplice));
						}
					
			}
			{
				switch ( LA(1) )
				{
				case LBRACK:
				{
					match(LBRACK);
					{
						switch ( LA(1) )
						{
						case OF:
						{
							match(OF);
							break;
						}
						case ID:
						{
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						 }
					}
					generic_parameter_declaration_list(genericParameters);
					match(RBRACK);
					break;
				}
				case LPAREN:
				case COLON:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			{
				switch ( LA(1) )
				{
				case LPAREN:
				{
					base_types(baseTypes);
					break;
				}
				case COLON:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			begin_with_doc(td);
			{
				switch ( LA(1) )
				{
				case PASS:
				{
					{
						match(PASS);
						eos();
					}
					break;
				}
				case EOL:
				case ABSTRACT:
				case CALLABLE:
				case CLASS:
				case CONSTRUCTOR:
				case DEF:
				case DESTRUCTOR:
				case ENUM:
				case EVENT:
				case FINAL:
				case INTERFACE:
				case INTERNAL:
				case NEW:
				case OVERRIDE:
				case PARTIAL:
				case PUBLIC:
				case PROTECTED:
				case PRIVATE:
				case SELF:
				case STATIC:
				case STRUCT:
				case THEN:
				case TRANSIENT:
				case VIRTUAL:
				case EOS:
				case ID:
				case LBRACK:
				case SPLICE_BEGIN:
				{
					{
						{
							switch ( LA(1) )
							{
							case EOL:
							case EOS:
							{
								eos();
								break;
							}
							case ABSTRACT:
							case CALLABLE:
							case CLASS:
							case CONSTRUCTOR:
							case DEF:
							case DESTRUCTOR:
							case ENUM:
							case EVENT:
							case FINAL:
							case INTERFACE:
							case INTERNAL:
							case NEW:
							case OVERRIDE:
							case PARTIAL:
							case PUBLIC:
							case PROTECTED:
							case PRIVATE:
							case SELF:
							case STATIC:
							case STRUCT:
							case THEN:
							case TRANSIENT:
							case VIRTUAL:
							case ID:
							case LBRACK:
							case SPLICE_BEGIN:
							{
								break;
							}
							default:
							{
								throw new NoViableAltException(LT(1), getFilename());
							}
							 }
						}
						{ // ( ... )+
							int _cnt76=0;
							for (;;)
							{
								bool synPredMatched75 = false;
								if (((LA(1)==SPLICE_BEGIN) && (tokenSet_37_.member(LA(2)))))
								{
									int _m75 = mark();
									synPredMatched75 = true;
									inputState.guessing++;
									try {
										{
											splice_expression();
											eos();
										}
									}
									catch (RecognitionException)
									{
										synPredMatched75 = false;
									}
									rewind(_m75);
									inputState.guessing--;
								}
								if ( synPredMatched75 )
								{
									splice_type_definition_body(members);
								}
								else if ((tokenSet_38_.member(LA(1))) && (tokenSet_39_.member(LA(2)))) {
									type_definition_member(members);
								}
								else
								{
									if (_cnt76 >= 1) { goto _loop76_breakloop; } else { throw new NoViableAltException(LT(1), getFilename());; }
								}
								
								_cnt76++;
							}
_loop76_breakloop:							;
						}    // ( ... )+
					}
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			end(td);
		}
		catch (RecognitionException ex)
		{
			if (0 == inputState.guessing)
			{
				reportError(ex, "class_definition");
				recover(ex,tokenSet_22_);
			}
			else
			{
				throw ex;
			}
		}
	}
Example #18
0
        public object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
        {
            if (typeDeclaration.Templates.Count > 0)
            {
                AddError(typeDeclaration, "Generic type definitions are not supported.");
            }
            B.TypeDefinition oldType = currentType;
            B.TypeDefinition typeDef;
            switch (typeDeclaration.Type)
            {
            case ClassType.Class:
                typeDef = new B.ClassDefinition(GetLexicalInfo(typeDeclaration));
                break;

            case ClassType.Interface:
                typeDef = new B.InterfaceDefinition(GetLexicalInfo(typeDeclaration));
                break;

            case ClassType.Enum:
                typeDef = new B.EnumDefinition(GetLexicalInfo(typeDeclaration));
                break;

            case ClassType.Struct:
                typeDef = new B.StructDefinition(GetLexicalInfo(typeDeclaration));
                break;

            case ClassType.Module:
                typeDef = new B.ClassDefinition(GetLexicalInfo(typeDeclaration));
                typeDeclaration.Modifier |= Modifiers.Static;
                break;

            default:
                AddError(typeDeclaration, "Unknown class type.");
                return(null);
            }
            if (currentType != null)
            {
                typeDef.Modifiers = ConvertModifier(typeDeclaration, B.TypeMemberModifiers.Private);
            }
            else
            {
                typeDef.Modifiers = ConvertModifier(typeDeclaration, B.TypeMemberModifiers.Internal);
            }
            typeDef.Name = typeDeclaration.Name;
            typeDef.EndSourceLocation = GetLocation(typeDeclaration.EndLocation);
            ConvertAttributes(typeDeclaration.Attributes, typeDef.Attributes);
            ConvertTypeReferences(typeDeclaration.BaseTypes, typeDef.BaseTypes);

            if (currentType != null)
            {
                currentType.Members.Add(typeDef);
            }
            else
            {
                module.Members.Add(typeDef);
            }
            currentType = typeDef;
            typeDeclaration.AcceptChildren(this, data);
            currentType = oldType;
            return(typeDef);
        }
Example #19
0
 public override void LeaveStructDefinition(StructDefinition node)
 {
     CheckName(node,node.Name);
 }
Example #20
0
		override public void OnStructDefinition(StructDefinition node)
		{
			VisitTypeDefinition(node);
		}