public override void OnEnumDefinition(EnumDefinition node)
{
if (null != node.Entity)
{
return;
}
node.Entity = new InternalEnum(TypeSystemServices, node);
}
override public void LeaveEnumDefinition(EnumDefinition node)
{
_members.Clear();
foreach (TypeMember member in node.Members)
if (_members.ContainsKey(member.Name))
MemberNameConflict(member);
else
_members[member.Name] = new List<TypeMember>() { member };
}
public override void LeaveEnumDefinition(EnumDefinition node)
{
CheckName(node,node.Name);
foreach (EnumMember member in node.Members)
{
if (member.Initializer.NodeType != NodeType.IntegerLiteralExpression)
Errors.Add(
CompilerErrorFactory.EnumMemberMustBeConstant(member));
}
}
public override void LeaveEnumDefinition(EnumDefinition node)
{
_members.Clear();
foreach (TypeMember member in node.Members)
{
if (_members.ContainsKey(member.Name))
{
MemberNameConflict(member);
}
else
{
_members[member.Name] = member;
}
}
}
override public void OnEnumDefinition(EnumDefinition node)
{
long lastValue = 0;
foreach (EnumMember member in node.Members)
{
if (null == member.Initializer)
{
member.Initializer = new IntegerLiteralExpression(lastValue);
}
else if (member.Initializer.NodeType == NodeType.IntegerLiteralExpression)
{
lastValue = ((IntegerLiteralExpression) member.Initializer).Value;
}
++lastValue;
}
}
public override void OnEnumDefinition(EnumDefinition node)
{
long lastValue = 0;
foreach (EnumMember member in node.Members)
{
if (null == member.Initializer)
{
member.Initializer = new IntegerLiteralExpression(lastValue);
}
lastValue = member.Initializer.Value + 1;
if (null == member.Entity)
{
member.Entity = new InternalEnumMember(TypeSystemServices, member);
}
}
}
//throws RecognitionException, TokenStreamException
protected void enum_member(
EnumDefinition container
)
{
IToken id = null;
EnumMember em = null;
Expression initializer = null;
try { // for error handling
attributes();
id = LT(1);
match(ID);
{
switch ( LA(1) )
{
case ASSIGN:
{
match(ASSIGN);
initializer=simple_initializer();
break;
}
case EOL:
case EOS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
em = new EnumMember(ToLexicalInfo(id));
em.Name = id.getText();
em.Initializer = initializer;
AddAttributes(em.Attributes);
container.Members.Add(em);
}
eos();
docstring(em);
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_38_);
}
else
{
throw ex;
}
}
}
//throws RecognitionException, TokenStreamException
protected void enum_definition(
TypeMemberCollection container
)
{
IToken id = null;
EnumDefinition ed = null;
try { // for error handling
match(ENUM);
id = LT(1);
match(ID);
if (0==inputState.guessing)
{
ed = new EnumDefinition(ToLexicalInfo(id));
}
begin_with_doc(ed);
if (0==inputState.guessing)
{
ed.Name = id.getText();
ed.Modifiers = _modifiers;
AddAttributes(ed.Attributes);
container.Add(ed);
}
{
{ // ( ... )+
int _cnt40=0;
for (;;)
{
if ((LA(1)==ID||LA(1)==LBRACK))
{
enum_member(ed);
}
else
{
if (_cnt40 >= 1) { goto _loop40_breakloop; } else { throw new NoViableAltException(LT(1), getFilename());; }
}
_cnt40++;
}
_loop40_breakloop: ;
} // ( ... )+
}
end(ed);
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_20_);
}
else
{
throw ex;
}
}
}
internal InternalEnum(TypeSystemServices tagManager, EnumDefinition enumDefinition)
: base(tagManager, enumDefinition)
{
}
public override void LeaveEnumDefinition(EnumDefinition node)
{
CantBeMarkedAbstract(node);
CantBeMarkedPartialIfNested(node);
CantBeMarkedFinal(node);
CantBeMarkedStatic(node);
}
private Type GetEnumUnderlyingType(EnumDefinition node)
{
return ((InternalEnum) node.Entity).UnderlyingType;
}
public override void LeaveEnumDefinition(EnumDefinition node)
{
LeaveTypeDefinition(node);
}
public override void OnEnumDefinition(EnumDefinition node)
{
VisitTypeDefinition(node);
}
override public void OnEnumDefinition(EnumDefinition node)
{
EnsureEntityFor(node);
}
public override void OnEnumDefinition(EnumDefinition node)
{
AddMember(node);
}
//throws RecognitionException, TokenStreamException
protected void enum_member(
EnumDefinition container
)
{
IToken id = null;
EnumMember em = null;
IntegerLiteralExpression initializer = null;
bool negative = false;
try { // for error handling
attributes();
id = LT(1);
match(ID);
{
switch ( LA(1) )
{
case ASSIGN:
{
match(ASSIGN);
{
if ((LA(1)==SUBTRACT) && (LA(2)==SUBTRACT||LA(2)==LONG||LA(2)==INT))
{
match(SUBTRACT);
if (0==inputState.guessing)
{
negative = true;
}
}
else if ((LA(1)==SUBTRACT||LA(1)==LONG||LA(1)==INT) && (tokenSet_38_.member(LA(2)))) {
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
initializer=integer_literal();
break;
}
case EOF:
case EOS:
case NEWLINE:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
em = new EnumMember(SourceLocationFactory.ToLexicalInfo(id));
em.Name = id.getText();
em.Initializer = initializer;
if (negative && null != initializer)
{
initializer.Value *= -1;
}
AddAttributes(em.Attributes);
container.Members.Add(em);
}
eos();
docstring(em);
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_39_);
}
else
{
throw ex;
}
}
}
public override void OnEnumDefinition(EnumDefinition node)
{
OnCandidatePartialDefinition(node);
}
public override void OnEnumDefinition(EnumDefinition node)
{
TypeBuilder typeBuilder = GetTypeBuilder(node);
foreach (EnumMember member in node.Members)
{
var field = typeBuilder.DefineField(member.Name, typeBuilder,
FieldAttributes.Public |
FieldAttributes.Static |
FieldAttributes.Literal);
field.SetConstant(InitializerValueOf(member, node));
SetBuilder(member, field);
}
}
public override void OnEnumDefinition(EnumDefinition node)
{
var builder = GetBuilder(node) as EnumBuilder;
if (null != builder)
{
foreach (EnumMember member in node.Members)
{
var field = builder.DefineLiteral(member.Name, InitializerValueOf(member, node));
SetBuilder(member, field);
}
}
else //nested enum (have to go through regular TypeBuilder
{ //since there is no DefineNestedEnum in SRE :-/
TypeBuilder typeBuilder = GetTypeBuilder(node);
foreach (EnumMember member in node.Members)
{
var field = typeBuilder.DefineField(member.Name, typeBuilder,
FieldAttributes.Public |
FieldAttributes.Static |
FieldAttributes.Literal);
field.SetConstant(InitializerValueOf(member, node));
SetBuilder(member, field);
}
}
}
public override void OnEnumDefinition(EnumDefinition node)
{
base.OnEnumDefinition(node);
_emitter.EmitTypeAttributes(node);
}
public override void OnEnumDefinition(EnumDefinition node)
{
}
void EmitTypeAttributes(EnumDefinition node)
{
EnumBuilder builder = GetBuilder(node) as EnumBuilder;
if (null != builder)
{
EmitAttributes(node, builder.SetCustomAttribute);
}
else //nested enum
{
TypeBuilder typeBuilder = GetTypeBuilder(node);
EmitAttributes(node, typeBuilder.SetCustomAttribute);
}
}
public override void OnEnumDefinition(EnumDefinition node)
{
TypeBuilder builder = GetTypeBuilder(node);
foreach (EnumMember member in node.Members)
{
FieldBuilder field = builder.DefineField(member.Name, builder,
FieldAttributes.Public |
FieldAttributes.Static |
FieldAttributes.Literal);
field.SetConstant((int)member.Initializer.Value);
SetBuilder(member, field);
}
}
private object InitializerValueOf(EnumMember enumMember, EnumDefinition enumType)
{
return Convert.ChangeType(((IntegerLiteralExpression) enumMember.Initializer).Value,
GetEnumUnderlyingType(enumType));
}
public override void LeaveEnumDefinition(EnumDefinition node)
{
CheckMemberName(node);
CantBeMarkedAbstract(node);
CantBeMarkedFinal(node);
CantBeMarkedStatic(node);
CantBeMarkedPartial(node);
}
public override void LeaveEnumDefinition(EnumDefinition node)
{
_emitter.EmitTypeAttributes(node);
}
public override void OnEnumDefinition(EnumDefinition node)
{
EnterNamespace((INamespace)GetEntity(node));
VisitTypeDefinitionBody(node);
LeaveNamespace();
}
protected void enum_definition(
TypeMemberCollection container
) //throws RecognitionException, TokenStreamException
{
IToken id = null;
EnumDefinition ed = null;
TypeMemberCollection members = null;
try { // for error handling
match(ENUM);
id = LT(1);
match(ID);
if (0==inputState.guessing)
{
ed = new EnumDefinition(ToLexicalInfo(id));
}
begin_with_doc(ed);
if (0==inputState.guessing)
{
ed.Name = id.getText();
ed.Modifiers = _modifiers;
AddAttributes(ed.Attributes);
container.Add(ed);
members = ed.Members;
}
{
switch ( LA(1) )
{
case PASS:
{
{
match(PASS);
eos();
}
break;
}
case ID:
case LBRACK:
case SPLICE_BEGIN:
{
{ // ( ... )+
int _cnt48=0;
for (;;)
{
switch ( LA(1) )
{
case ID:
case LBRACK:
{
enum_member(members);
break;
}
case SPLICE_BEGIN:
{
splice_type_definition_body(members);
break;
}
default:
{
if (_cnt48 >= 1) { goto _loop48_breakloop; } else { throw new NoViableAltException(LT(1), getFilename());; }
}
break; }
_cnt48++;
}
_loop48_breakloop: ;
} // ( ... )+
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
end(ed);
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "enum_definition");
recover(ex,tokenSet_22_);
}
else
{
throw ex;
}
}
}
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 LeaveEnumDefinition(EnumDefinition node)
{
CheckName(node,node.Name);
}
public override bool EnterEnumDefinition(AST.EnumDefinition node)
{
EnterTypeDefinition(node, ClassType.Enum);
return(base.EnterEnumDefinition(node));
}
