void ConvertField(TypeReference typeRef, VariableDeclaration variable, FieldDeclaration fieldDeclaration)
{
B.TypeMember m;
if (currentType is B.EnumDefinition)
{
if (variable.Initializer.IsNull)
{
m = new B.EnumMember(GetLexicalInfo(fieldDeclaration));
}
else
{
PrimitiveExpression p = variable.Initializer as PrimitiveExpression;
if (p == null || !(p.Value is int))
{
AddError(fieldDeclaration, "enum member initializer must be integer value");
return;
}
m = new B.EnumMember(GetLexicalInfo(fieldDeclaration), new B.IntegerLiteralExpression((int)p.Value));
}
}
else
{
m = new B.Field(GetLexicalInfo(fieldDeclaration), ConvertTypeReference(typeRef), ConvertExpression(variable.Initializer));
m.Modifiers = ConvertModifier(fieldDeclaration, B.TypeMemberModifiers.Private);
}
m.Name = variable.Name;
ConvertAttributes(fieldDeclaration.Attributes, m.Attributes);
if (currentType != null)
{
currentType.Members.Add(m);
}
}
public override void OnEnumMember(AST.EnumMember node)
{
DefaultField field = new DefaultField(OuterClass.DefaultReturnType, node.Name, ModifierEnum.Const | ModifierEnum.Public, GetRegion(node), OuterClass);
ConvertAttributes(node, field);
OuterClass.Fields.Add(field);
}
void ConvertField(TypeReference typeRef, VariableDeclaration variable, FieldDeclaration fieldDeclaration)
{
B.TypeMember m;
if (currentType is B.EnumDefinition) {
if (variable.Initializer.IsNull) {
m = new B.EnumMember(GetLexicalInfo(fieldDeclaration));
} else {
PrimitiveExpression p = variable.Initializer as PrimitiveExpression;
if (p == null || !(p.Value is int)) {
AddError(fieldDeclaration, "enum member initializer must be integer value");
return;
}
m = new B.EnumMember(GetLexicalInfo(fieldDeclaration), new B.IntegerLiteralExpression((int)p.Value));
}
} else {
m = new B.Field(GetLexicalInfo(fieldDeclaration), ConvertTypeReference(typeRef), ConvertExpression(variable.Initializer));
m.Modifiers = ConvertModifier(fieldDeclaration, B.TypeMemberModifiers.Private);
}
m.Name = variable.Name;
ConvertAttributes(fieldDeclaration.Attributes, m.Attributes);
if (currentType != null) currentType.Members.Add(m);
}
public override void LeaveEnumMember(EnumMember node)
{
CheckName(node,node.Name);
}
protected void enum_member(
TypeMemberCollection container
) //throws RecognitionException, TokenStreamException
{
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.Add(em);
}
eos();
docstring(em);
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "enum_member");
recover(ex,tokenSet_48_);
}
else
{
throw ex;
}
}
}
public InternalEnumMember(TypeSystemServices tagManager, EnumMember member)
{
_member = member;
}
public override void OnEnumMember(EnumMember node)
{
_emitter.EmitFieldAttributes(node);
}
private object InitializerValueOf(EnumMember enumMember, EnumDefinition enumType)
{
return Convert.ChangeType(((IntegerLiteralExpression) enumMember.Initializer).Value,
GetEnumUnderlyingType(enumType));
}
//throws RecognitionException, TokenStreamException
protected void enum_member(
TypeMemberCollection 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_42_.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.Add(em);
}
eos();
docstring(em);
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_43_);
}
else
{
throw ex;
}
}
}
public static CompilerError EnumMemberMustBeConstant(EnumMember member)
{
return Instantiate("BCE0170", member, member.FullName);
}
public override void OnEnumMember(EnumMember node)
{
_emitter.EmitFieldAttributes(node, this._knownTypes);
}
public override void LeaveEnumMember(EnumMember node)
{
if (node.Initializer.NodeType == NodeType.IntegerLiteralExpression)
return;
IType type = node.Initializer.ExpressionType;
if (null != type && (TypeSystemServices.IsIntegerNumber(type) || type.IsEnum))
{
object val = GetLiteralValue(node.Initializer);
if (null != val && val != Error.Default)
node.Initializer = new IntegerLiteralExpression(Convert.ToInt64(val));
}
return;
}
public override void OnEnumMember(EnumMember node)
{
WriteAttributes(node.Attributes, true);
WriteIndented(node.Name);
if (null != node.Initializer)
{
WriteOperator(" = ");
Visit(node.Initializer);
}
WriteLine();
}
override public object Clone()
{
EnumMember clone = new EnumMember();
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 != _initializer)
{
clone._initializer = _initializer.Clone() as Expression;
clone._initializer.InitializeParent(clone);
}
return clone;
}
public void enum_member(EnumDefinition container)
{
try
{
IntegerLiteralExpression expression;
switch (this.LA(1))
{
case 0x63:
this.attributes();
break;
case 12:
case 0x10:
case 0x21:
case 0x3b:
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
IToken token = this.identifier();
switch (this.LA(1))
{
case 0x4e:
this.match(0x4e);
expression = this.integer_literal();
break;
case 0x3e:
case 0x43:
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
if (base.inputState.guessing == 0)
{
EnumMember member;
EnumMember member1 = member = new EnumMember(ToLexicalInfo(token));
member.set_Name(token.getText());
member.set_Initializer(expression);
EnumMember node = member;
this.FlushAttributes(node);
container.get_Members().Add(node);
}
}
catch (RecognitionException exception)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception);
this.recover(exception, tokenSet_40_);
}
}
