public override void LeaveDeclaration(Declaration node)
{
// Special exemption made for anonymous exception handlers
if(!(node.ParentNode is ExceptionHandler) ||
((node.ParentNode as ExceptionHandler).Flags
& ExceptionHandlerFlags.Anonymous) == ExceptionHandlerFlags.None)
{
CheckName(node,node.Name);
}
}
public static Statement read (Expression expression){
Declaration declaraion = new Declaration();
declaraion.Name = "readedContent";
Expression arg = null;
if (expression is BinaryExpression){
var ass = expression as BinaryExpression;
declaraion.Name=ass.Left.LiftToString();
arg = ass.Right;
}else{
arg = expression;
}
MethodInvocationExpression assign = AstUtil.CreateMethodInvocationExpression(AstUtil.CreateReferenceExpression("System.IO.File.ReadAllText"), arg);
var result = new DeclarationStatement(declaraion, assign);
return result;
}
void DeclareLocal(Declaration d, bool privateScope)
{
AssertIdentifierName(d, d.Name);
var local = DeclareLocal(d, d.Name, GetType(d.Type), privateScope);
d.Entity = local;
var internalLocal = local as InternalLocal;
if (internalLocal != null)
internalLocal.OriginalDeclaration = d;
}
protected void ProcessDeclarationForIterator(Declaration d, IType defaultDeclType)
{
var local = LocalToReuseFor(d);
if (local != null)
{
var localType = ((InternalLocal)GetEntity(local)).Type;
AssertTypeCompatibility(d, localType, defaultDeclType);
d.Type = CodeBuilder.CreateTypeReference(localType);
d.Entity = local.Entity;
return;
}
GetDeclarationType(defaultDeclType, d);
DeclareLocal(d, true);
}
protected bool AssertUniqueLocal(Declaration d)
{
if (null == _currentMethod.ResolveLocal(d.Name) &&
null == _currentMethod.ResolveParameter(d.Name))
return true;
Error(CompilerErrorFactory.LocalAlreadyExists(d, d.Name));
return false;
}
protected Declaration declaration() //throws RecognitionException, TokenStreamException
{
Declaration d;
IToken id = null;
d = null;
TypeReference tr = null;
try { // for error handling
id = LT(1);
match(ID);
{
switch ( LA(1) )
{
case AS:
{
match(AS);
tr=type_reference();
break;
}
case IN:
case ASSIGN:
case COMMA:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
d = new Declaration(ToLexicalInfo(id));
d.Name = id.getText();
d.Type = tr;
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "declaration");
recover(ex,tokenSet_94_);
}
else
{
throw ex;
}
}
return d;
}
public override void OnDeclaration(Declaration node)
{
if (!_skippedReferences.ContainsKey(node.Name))
{
_skippedReferences.Add(node.Name, node);
}
base.OnDeclaration(node);
}
public DeclarationsNamespace(INamespace parent, Declaration declaration)
{
_parent = parent;
_declarations = new DeclarationCollection { declaration };
}
override public object Clone()
{
Declaration clone = new Declaration();
clone._lexicalInfo = _lexicalInfo;
clone._endSourceLocation = _endSourceLocation;
clone._documentation = _documentation;
clone._isSynthetic = _isSynthetic;
clone._entity = _entity;
if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
clone._name = _name;
if (null != _type)
{
clone._type = _type.Clone() as TypeReference;
clone._type.InitializeParent(clone);
}
return clone;
}
public Local(Declaration declaration, bool privateScope)
{
_name = declaration.Name;
LexicalInfo = declaration.LexicalInfo;
_privateScope = privateScope;
}
public override void OnDeclaration(Declaration d)
{
Write(d.Name);
WriteTypeReference(d.Type);
}
public void try_statement(Block container)
{
IToken token = null;
IToken token2 = null;
IToken token3 = null;
try
{
TryStatement statement;
Block block;
token = this.LT(1);
this.match(0x2b);
if (base.inputState.guessing == 0)
{
statement = new TryStatement(ToLexicalInfo(token));
block = statement.get_ProtectedBlock();
container.Add(statement);
}
this.compound_or_single_stmt(block);
while (true)
{
TypeReference reference;
if ((this.LA(1) != 7) || (this.LA(2) != 0x3f))
{
break;
}
token2 = this.LT(1);
this.match(7);
this.match(0x3f);
token3 = this.LT(1);
this.match(0x3b);
switch (this.LA(1))
{
case 0x42:
this.match(0x42);
reference = this.type_reference();
break;
case 0x40:
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
this.match(0x40);
if (base.inputState.guessing == 0)
{
Declaration declaration;
ExceptionHandler handler;
if (reference == null)
{
reference = new SimpleTypeReference(ToLexicalInfo(token3), "System.Exception");
}
ExceptionHandler handler1 = handler = new ExceptionHandler(ToLexicalInfo(token2));
Declaration declaration1 = declaration = new Declaration(ToLexicalInfo(token3));
declaration.set_Name(token3.getText());
declaration.set_Type(reference);
handler.set_Declaration(declaration);
ExceptionHandler handler2 = handler;
statement.get_ExceptionHandlers().Add(handler2);
block = handler2.get_Block();
reference = null;
}
this.compound_or_single_stmt(block);
}
if ((this.LA(1) != 0x11) || !tokenSet_2_.member(this.LA(2)))
{
if (!tokenSet_15_.member(this.LA(1)) || !tokenSet_20_.member(this.LA(2)))
{
throw new NoViableAltException(this.LT(1), this.getFilename());
}
}
else
{
this.finally_block(statement);
}
}
catch (RecognitionException exception)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception);
this.recover(exception, tokenSet_15_);
}
}
public Expression array_literal()
{
Expression expression = null;
IToken token = null;
try
{
token = this.LT(1);
this.match(0x44);
bool flag = false;
if (tokenSet_16_.member(this.LA(1)) && tokenSet_59_.member(this.LA(2)))
{
int num = this.mark();
flag = true;
base.inputState.guessing++;
try
{
this.expression();
this.match(0x12);
}
catch (RecognitionException)
{
flag = false;
}
this.rewind(num);
base.inputState.guessing--;
}
if (flag)
{
IToken token2;
Declaration declaration;
Expression expression4;
Expression projection = this.expression();
this.match(0x12);
this.match(0x3f);
int num2 = this.LA(1);
switch (num2)
{
case 12:
case 0x10:
case 0x21:
case 0x3b:
token2 = this.identifier();
break;
default:
if (num2 != 0x2d)
{
throw new NoViableAltException(this.LT(1), this.getFilename());
}
declaration = this.declaration();
break;
}
this.match(0x18);
Expression expression3 = this.expression();
this.match(0x40);
switch (this.LA(1))
{
case 0x15:
this.match(0x15);
expression4 = this.expression();
break;
case 0x45:
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
if (base.inputState.guessing == 0)
{
if (token2 != null)
{
Declaration declaration2;
Declaration declaration1 = declaration2 = new Declaration(ToLexicalInfo(token2));
declaration2.set_Name(token2.getText());
declaration = declaration2;
}
expression = CodeFactory.NewArrayComprehension(ToLexicalInfo(token), projection, declaration, expression3, expression4);
}
}
else
{
ExpressionCollection expressions;
if (!tokenSet_60_.member(this.LA(1)) || !tokenSet_20_.member(this.LA(2)))
{
throw new NoViableAltException(this.LT(1), this.getFilename());
}
if (base.inputState.guessing == 0)
{
ArrayLiteralExpression expression5;
expression = expression5 = new ArrayLiteralExpression(ToLexicalInfo(token));
expressions = expression5.get_Items();
}
this.expression_list(expressions);
}
this.match(0x45);
}
catch (RecognitionException exception2)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception2);
this.recover(exception2, tokenSet_20_);
return expression;
}
return expression;
}
public Statement for_in(Block container)
{
Statement stmt = null;
try
{
Declaration declaration2;
Block block;
int num = this.LA(1);
switch (num)
{
case 12:
case 0x10:
case 0x21:
case 0x3b:
{
IToken token = this.identifier();
if (base.inputState.guessing == 0)
{
Declaration declaration;
Declaration declaration1 = declaration = new Declaration(ToLexicalInfo(token));
declaration.set_Name(token.getText());
declaration2 = declaration;
}
break;
}
default:
if (num != 0x2d)
{
throw new NoViableAltException(this.LT(1), this.getFilename());
}
declaration2 = this.declaration();
if (base.inputState.guessing == 0)
{
DeclarationAnnotations.ForceNewVariable(declaration2);
}
break;
}
this.match(0x18);
Expression expression = this.expression();
if (base.inputState.guessing == 0)
{
ForStatement statement2;
ForStatement statement1 = statement2 = new ForStatement();
statement2.set_Iterator(expression);
ForStatement statement3 = statement2;
statement3.get_Declarations().Add(declaration2);
block = statement3.get_Block();
stmt = statement3;
container.Add(stmt);
this.EnterLoop(stmt);
}
this.match(0x40);
this.compound_or_single_stmt(block);
if (base.inputState.guessing == 0)
{
this.LeaveLoop(stmt);
}
}
catch (RecognitionException exception)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception);
this.recover(exception, tokenSet_15_);
return stmt;
}
return stmt;
}
public Declaration declaration()
{
Declaration declaration = null;
try
{
TypeReference reference;
this.match(0x2d);
IToken token = this.identifier();
switch (this.LA(1))
{
case 0x42:
this.match(0x42);
reference = this.type_reference();
break;
case 1:
case 5:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 15:
case 0x10:
case 0x11:
case 0x12:
case 0x13:
case 20:
case 0x15:
case 0x18:
case 0x19:
case 0x1b:
case 0x1d:
case 30:
case 0x1f:
case 0x20:
case 0x21:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 40:
case 0x29:
case 0x2a:
case 0x2b:
case 0x2c:
case 0x2d:
case 0x2e:
case 0x2f:
case 0x30:
case 0x31:
case 50:
case 0x33:
case 0x3b:
case 60:
case 0x3d:
case 0x3e:
case 0x3f:
case 0x44:
case 0x4d:
case 0x4e:
case 0x4f:
case 80:
case 0x52:
case 0x58:
case 0x63:
case 0x67:
case 0x69:
case 0x6a:
case 0x6b:
case 0x6c:
case 0x6d:
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
if (base.inputState.guessing == 0)
{
Declaration declaration2;
Declaration declaration1 = declaration2 = new Declaration(ToLexicalInfo(token));
declaration2.set_Name(token.getText());
declaration2.set_Type(reference);
declaration = declaration2;
}
}
catch (RecognitionException exception)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception);
this.recover(exception, tokenSet_50_);
return declaration;
}
return declaration;
}
IEntity DeclareLocal(Declaration d, bool privateScope)
{
AssertIdentifierName(d, d.Name);
IEntity local = DeclareLocal(d, d.Name, GetType(d.Type), privateScope);
d.Entity = local;
InternalLocal internalLocal = local as InternalLocal;
if (null != internalLocal)
internalLocal.OriginalDeclaration = d;
return local;
}
public Local(Declaration declaration, bool privateScope)
{
_name = declaration.Name;
LexicalInfo = declaration.LexicalInfo;
_privateScope = privateScope;
}
//throws RecognitionException, TokenStreamException
protected DeclarationStatement declaration_stmt()
{
DeclarationStatement s;
IToken id = null;
s = null;
TypeReference tr = null;
Expression initializer = null;
StatementModifier m = null;
try { // for error handling
id = LT(1);
match(ID);
match(AS);
tr=type_reference();
{
switch ( LA(1) )
{
case ASSIGN:
{
{
match(ASSIGN);
initializer=declaration_initializer();
}
break;
}
case EOF:
case IF:
case UNLESS:
case WHILE:
case EOS:
case NEWLINE:
{
{
{
switch ( LA(1) )
{
case IF:
case UNLESS:
case WHILE:
{
m=stmt_modifier();
break;
}
case EOF:
case EOS:
case NEWLINE:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
eos();
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
Declaration d = new Declaration(SourceLocationFactory.ToLexicalInfo(id));
d.Name = id.getText();
d.Type = tr;
s = new DeclarationStatement(d.LexicalInfo);
s.Declaration = d;
s.Initializer = initializer;
s.Modifier = m;
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_79_);
}
else
{
throw ex;
}
}
return s;
}
void DeclareLocal(Declaration d, bool privateScope)
{
if (AssertIdentifierName(d, d.Name))
{
d.Entity = DeclareLocal(d, d.Name, GetType(d.Type), privateScope);
}
}
public DeclarationsNamespace(INamespace parent, TypeSystemServices tagManager, Declaration declaration)
{
_parent = parent;
_declarations = new DeclarationCollection();
_declarations.Add(declaration);
}
public static void ForceNewVariable(Declaration d)
{
d.Annotate(NewVariableAnnotation);
}
protected DeclarationStatement declaration_stmt() //throws RecognitionException, TokenStreamException
{
DeclarationStatement s;
IToken id = null;
s = null;
TypeReference tr = null;
Expression initializer = null;
StatementModifier m = null;
try { // for error handling
id = LT(1);
match(ID);
match(AS);
tr=type_reference();
{
switch ( LA(1) )
{
case ASSIGN:
{
{
match(ASSIGN);
{
if (((tokenSet_95_.member(LA(1))) && (tokenSet_96_.member(LA(2))))&&(_compact))
{
initializer=simple_initializer();
}
else if ((tokenSet_95_.member(LA(1))) && (tokenSet_97_.member(LA(2)))) {
initializer=declaration_initializer();
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case EOL:
case IF:
case UNLESS:
case WHILE:
case EOS:
{
{
if (!(!_compact))
throw new SemanticException("!_compact");
{
switch ( LA(1) )
{
case IF:
case UNLESS:
case WHILE:
{
m=stmt_modifier();
break;
}
case EOL:
case EOS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
eos();
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
Declaration d = new Declaration(ToLexicalInfo(id));
d.Name = id.getText();
d.Type = tr;
s = new DeclarationStatement(d.LexicalInfo);
s.Declaration = d;
s.Initializer = initializer;
s.Modifier = m;
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "declaration_stmt");
recover(ex,tokenSet_22_);
}
else
{
throw ex;
}
}
return s;
}
public static bool ShouldForceNewVariableFor(Declaration d)
{
return d.ContainsAnnotation(NewVariableAnnotation);
}
protected bool AssertDeclarationName(Declaration d)
{
if (AssertIdentifierName(d, d.Name))
return AssertUniqueLocal(d);
return false;
}
public DeclarationStatement(Declaration declaration, Expression initializer) : this(LexicalInfo.Empty, declaration, initializer)
{
}
protected virtual Local LocalToReuseFor(Declaration d)
{
return d.Type != null ? null : LocalByName(d.Name);
}
public DeclarationStatement(LexicalInfo token, Declaration declaration, Expression initializer) : base(token)
{
this.Declaration = declaration;
this.Initializer = initializer;
}
public override void LeaveDeclaration(Declaration node)
{
if (null == node.Type) return;
CheckDeclarationType(node.Type);
}
protected virtual Local LocalToReuseFor(Declaration d)
{
if (d.Type != null)
return null;
return LocalByName(d.Name);
}
void GetDeclarationType(IType defaultDeclarationType, Declaration d)
{
if (null != d.Type)
{
Visit(d.Type);
AssertTypeCompatibility(d, GetType(d.Type), defaultDeclarationType);
}
else
{
d.Type = CodeBuilder.CreateTypeReference(defaultDeclarationType);
}
}
protected void ProcessDeclarationForIterator(Declaration d, IType defaultDeclType)
{
GetDeclarationType(defaultDeclType, d);
DeclareLocal(d, true);
}
