public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations)
{
if (localDeclarations == null)
{
return(null);
}
FieldFlags flags = FieldFlags.CompilerControlled | FieldFlags.NotSerialized; //NotSerialized "poisons" the field until Checker clears it
if (localDeclarations.Constant)
{
flags |= FieldFlags.Literal;
}
else if (localDeclarations.InitOnly)
{
flags = FieldFlags.Public | FieldFlags.InitOnly;
}
TypeNode type = localDeclarations.Type;
LocalDeclarationList decls = localDeclarations.Declarations;
for (int i = 0, n = decls.Count; i < n; i++)
{
LocalDeclaration decl = decls[i];
Field f = new Field(this.scope, null, flags, decl.Name, type, null);
f.Initializer = this.VisitExpression(decl.InitialValue);
this.scope.Members.Add(f);
decl.Field = f;
}
return(localDeclarations);
}
/// <summary>
/// Makes a copy of this local declaration, changing the ContainingBlock to the given block.
/// </summary>
//^ [MustOverride]
public override LocalDeclaration MakeCopyFor(LocalDeclarationsStatement containingLocalDeclarationsStatement)
//^^ ensures result.GetType() == this.GetType();
{
if (this.ContainingLocalDeclarationsStatement == containingLocalDeclarationsStatement)
{
return(this);
}
return(new VccLocalDeclaration(containingLocalDeclarationsStatement, this));
}
//^ [MustOverride]
public override LocalDeclaration MakeCopyFor(LocalDeclarationsStatement containingLocalDeclarationsStatement)
{
if (this.ContainingLocalDeclarationsStatement == containingLocalDeclarationsStatement)
{
return(this);
}
else
{
return(new VccLocalFunctionDeclaration(containingLocalDeclarationsStatement, this));
}
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations){
if (localDeclarations == null) return null;
FieldFlags flags = FieldFlags.CompilerControlled|FieldFlags.NotSerialized; //NotSerialized "poisons" the field until Checker clears it
if (localDeclarations.Constant) flags |= FieldFlags.Literal;
else if (localDeclarations.InitOnly) flags = FieldFlags.Public|FieldFlags.InitOnly;
TypeNode type = localDeclarations.Type;
LocalDeclarationList decls = localDeclarations.Declarations;
for (int i = 0, n = decls.Count; i < n; i++){
LocalDeclaration decl = decls[i];
Field f = new Field(this.scope, null, flags, decl.Name, type, null);
f.Initializer = this.VisitExpression(decl.InitialValue);
this.scope.Members.Add(f);
decl.Field = f;
}
return localDeclarations;
}
public virtual Statement VisitResourceUse(ResourceUse resourceUse, Class scope)
{
if (resourceUse == null)
{
return(null);
}
Class savedScope = this.scope;
this.scope = scope;
LocalDeclarationsStatement locDecs = resourceUse.ResourceAcquisition as LocalDeclarationsStatement;
if (locDecs != null)
{
locDecs.InitOnly = true;
resourceUse.ResourceAcquisition = this.VisitLocalDeclarationsStatement(locDecs);
}
resourceUse.Body = this.VisitBlock(resourceUse.Body);
this.scope = savedScope;
return(resourceUse);
}
public virtual Statement VisitAcquire(Acquire @acquire, Class scope)
{
if (@acquire == null)
{
return(null);
}
Class savedScope = this.scope;
this.scope = scope;
LocalDeclarationsStatement locDecs = @acquire.Target as LocalDeclarationsStatement;
if (locDecs != null)
{
locDecs.InitOnly = true;
@acquire.Target = this.VisitLocalDeclarationsStatement(locDecs);
}
@acquire.Body = this.VisitBlock(@acquire.Body);
this.scope = savedScope;
return(@acquire);
}
public virtual Statement VisitFixed(Fixed Fixed, Class scope)
{
if (Fixed == null)
{
return(null);
}
Class savedScope = this.scope;
this.scope = scope;
LocalDeclarationsStatement locDecs = Fixed.Declarators as LocalDeclarationsStatement;
if (locDecs != null)
{
locDecs.InitOnly = true;
Fixed.Declarators = this.VisitLocalDeclarationsStatement(locDecs);
}
Fixed.Body = this.VisitBlock(Fixed.Body);
this.scope = savedScope;
return(Fixed);
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations)
{
if (localDeclarations == null)
{
return(null);
}
TypeNode type = localDeclarations.Type = this.VisitTypeReference(localDeclarations.Type);
if (!localDeclarations.Constant)
{
return(localDeclarations);
}
LocalDeclarationList decls = localDeclarations.Declarations;
for (int i = 0, n = decls.Count; i < n; i++)
{
LocalDeclaration decl = decls[i];
Field f = decl.Field;
f.Type = type;
f.Initializer = this.VisitExpression(f.Initializer);
}
return(localDeclarations);
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations)
{
if (localDeclarations == null)
{
return(null);
}
Statement result = base.VisitLocalDeclarationsStatement(localDeclarations);
if (localDeclarations.Type == null && localDeclarations.TypeExpression is TypeExpression)
{
Identifier id = ((TypeExpression)localDeclarations.TypeExpression).Expression as Identifier;
if (id != null && id.UniqueIdKey == StandardIds.Var.UniqueIdKey)
{
//Use the inferred type of the initializer of the first declaration as the variable type
TypeNode t = null;
LocalDeclarationList decls = localDeclarations.Declarations;
for (int i = 0, n = decls == null ? 0 : decls.Count; i < n; i++)
{
LocalDeclaration decl = decls[i];
if (decl == null || decl.Field == null)
{
continue;
}
if (t == null)
{
if (decl.InitialValue != null)
{
t = decl.InitialValue.Type;
}
}
decl.Field.Type = t;
localDeclarations.Type = t;
}
}
}
return(result);
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations){
if (localDeclarations == null) return null;
TypeNode type = localDeclarations.Type = this.VisitTypeReference(localDeclarations.Type);
if (!localDeclarations.Constant && !localDeclarations.InitOnly) return localDeclarations;
LocalDeclarationList decls = localDeclarations.Declarations;
for (int i = 0, n = decls.Count; i < n; i++){
LocalDeclaration decl = decls[i];
Field f = decl.Field;
if (type != null)
f.Type = type;
f.Initializer = decl.InitialValue = this.VisitExpression(f.Initializer);
Construct c = decl.InitialValue as Construct;
if (c != null && c.Type == null)
c.Type = type;
Identifier id = decl.InitialValue as Identifier;
if (id != null && id.Type == null && type != null && type.IsAssignableTo(SystemTypes.Enum))
id.Type = type;
}
return localDeclarations;
}
/// <summary>
/// A copy constructor that allocates an instance that is the same as the given template, except for its containing block.
/// </summary>
/// <param name="containingLocalDeclarationsStatement">The containing statement. This should be different from the containing statement of the template declaration.</param>
/// <param name="template">The statement to copy.</param>
protected VccLocalDeclaration(LocalDeclarationsStatement containingLocalDeclarationsStatement, VccLocalDeclaration template)
: base(containingLocalDeclarationsStatement, template)
{
this.specifiers = new List<Specifier>(template.specifiers);
this.isSpec = template.isSpec;
}
protected override bool CheckForErrorsAndReturnTrueIfAnyAreFound()
{
if (pattern == null)
return Body.HasErrors;
var hasError = false;
var newStmts = new List<Statement>();
var newBlock = new BlockStatement(newStmts, this.SourceLocation);
var call = pattern as VccMethodCall;
if (call == null) {
this.Helper.ReportError(new VccErrorMessage(pattern.SourceLocation, Error.ExpectedIdentifier));
return true;
}
var args = call.OriginalArguments.ToArray();
var calledMethod = call.MethodExpression as VccSimpleName;
if (calledMethod == null) {
this.Helper.ReportError(new VccErrorMessage(call.MethodExpression.SourceLocation, Error.ExpectedIdentifier));
return true;
}
var methods = call.GetCandidateMethods(true).Where(m => m.ParameterCount == args.Length).ToArray();
if (methods.Length == 0) {
if (!call.MethodExpression.HasErrors)
this.Helper.ReportError(new AstErrorMessage(call, Cci.Ast.Error.BadNumberOfArguments, calledMethod.Name.Value, args.Length.ToString()));
return true;
}
var meth = (MethodDefinition)methods.First();
var decl = (FunctionDefinition)meth.Declaration;
var parms = decl.Parameters.ToArray();
List<Statement> stmts = new List<Statement>();
for (int i = 0; i < args.Length; ++i) {
var name = args[i] as VccSimpleName;
if (name == null) {
this.Helper.ReportError(new VccErrorMessage(args[i].SourceLocation, Error.ExpectedIdentifier));
hasError = true;
} else {
var local = new VccLocalDeclaration(new NameDeclaration(name.Name, name.SourceLocation), null, new List<Specifier>(), true, name.SourceLocation);
var tp = (TypeExpression)parms[i].Type;
//tp = (TypeExpression)tp.MakeCopyFor(newBlock);
var stmt = new LocalDeclarationsStatement(false, true, false, tp, new LocalDeclaration[] { local }.ToList(), name.SourceLocation);
newStmts.Add(stmt);
}
}
newStmts.Add(new ExpressionStatement(call));
if (_body != null)
newStmts.AddRange(_body.Statements);
else
newStmts.AddRange(statements);
_body = newBlock;
newBlock.SetContainingBlock(containingMatchStatement.ContainingBlock);
hasError |= newBlock.HasErrors;
return hasError;
}
//^ [MustOverride]
public override LocalDeclaration MakeCopyFor(LocalDeclarationsStatement containingLocalDeclarationsStatement)
{
if (this.ContainingLocalDeclarationsStatement == containingLocalDeclarationsStatement) return this;
else return new VccLocalFunctionDeclaration(containingLocalDeclarationsStatement, this);
}
/// <summary>
/// A copy constructor that allocates an instance that is the same as the given template, except for its containing block.
/// </summary>
/// <param name="containingLocalDeclarationsStatement">The containing statement. This should be different from the containing statement of the template declaration.</param>
/// <param name="template">The statement to copy.</param>
protected VccLocalFunctionDeclaration(LocalDeclarationsStatement containingLocalDeclarationsStatement, VccLocalFunctionDeclaration template)
: base(containingLocalDeclarationsStatement, template)
{
this.mangledFunctionDeclaration = template.mangledFunctionDeclaration;
}
protected override bool CheckForErrorsAndReturnTrueIfAnyAreFound()
{
if (pattern == null)
{
return(Body.HasErrors);
}
var hasError = false;
var newStmts = new List <Statement>();
var newBlock = new BlockStatement(newStmts, this.SourceLocation);
var call = pattern as VccMethodCall;
if (call == null)
{
this.Helper.ReportError(new VccErrorMessage(pattern.SourceLocation, Error.ExpectedIdentifier));
return(true);
}
var args = call.OriginalArguments.ToArray();
var calledMethod = call.MethodExpression as VccSimpleName;
if (calledMethod == null)
{
this.Helper.ReportError(new VccErrorMessage(call.MethodExpression.SourceLocation, Error.ExpectedIdentifier));
return(true);
}
var methods = call.GetCandidateMethods(true).Where(m => m.ParameterCount == args.Length).ToArray();
if (methods.Length == 0)
{
if (!call.MethodExpression.HasErrors)
{
this.Helper.ReportError(new AstErrorMessage(call, Cci.Ast.Error.BadNumberOfArguments, calledMethod.Name.Value, args.Length.ToString()));
}
return(true);
}
var meth = (MethodDefinition)methods.First();
var decl = (FunctionDefinition)meth.Declaration;
var parms = decl.Parameters.ToArray();
List <Statement> stmts = new List <Statement>();
for (int i = 0; i < args.Length; ++i)
{
var name = args[i] as VccSimpleName;
if (name == null)
{
this.Helper.ReportError(new VccErrorMessage(args[i].SourceLocation, Error.ExpectedIdentifier));
hasError = true;
}
else
{
var local = new VccLocalDeclaration(new NameDeclaration(name.Name, name.SourceLocation), null, new List <Specifier>(), true, name.SourceLocation);
var tp = (TypeExpression)parms[i].Type;
//tp = (TypeExpression)tp.MakeCopyFor(newBlock);
var stmt = new LocalDeclarationsStatement(false, true, false, tp, new LocalDeclaration[] { local }.ToList(), name.SourceLocation);
newStmts.Add(stmt);
}
}
newStmts.Add(new ExpressionStatement(call));
if (_body != null)
{
newStmts.AddRange(_body.Statements);
}
else
{
newStmts.AddRange(statements);
}
_body = newBlock;
newBlock.SetContainingBlock(containingMatchStatement.ContainingBlock);
hasError |= newBlock.HasErrors;
return(hasError);
}
protected virtual LocalDefinition CreateLocalTempForProjection(List<Statement> statements)
{
IName dummyName = this.ContainingBlock.Helper.NameTable.GetNameFor("__temp" + this.SourceLocation.StartIndex);
NameDeclaration tempName = new NameDeclaration(dummyName, this.SourceLocation);
LocalDeclaration temp = new LocalDeclaration(false, false, tempName, null, this.SourceLocation);
List<LocalDeclaration> declarations = new List<LocalDeclaration>(1) {temp};
LocalDeclarationsStatement statement = new LocalDeclarationsStatement(false, false, false, TypeExpression.For(this.structureTypeExpression.ResolvedType), declarations, this.SourceLocation);
statements.Add(statement);
statement.SetContainingBlock(this.ContainingBlock);
temp.SetContainingLocalDeclarationsStatement(statement);
return temp.LocalVariable;
}
public virtual Differences VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations1, LocalDeclarationsStatement localDeclarations2){
Differences differences = new Differences(localDeclarations1, localDeclarations2);
if (localDeclarations1 == null || localDeclarations2 == null){
if (localDeclarations1 != localDeclarations2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
LocalDeclarationsStatement changes = (LocalDeclarationsStatement)localDeclarations2.Clone();
LocalDeclarationsStatement deletions = (LocalDeclarationsStatement)localDeclarations2.Clone();
LocalDeclarationsStatement insertions = (LocalDeclarationsStatement)localDeclarations2.Clone();
if (localDeclarations1.Constant == localDeclarations2.Constant) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
LocalDeclarationList declChanges, declDeletions, declInsertions;
Differences diff = this.VisitLocalDeclarationList(localDeclarations1.Declarations, localDeclarations2.Declarations, out declChanges, out declDeletions, out declInsertions);
if (diff == null){Debug.Assert(false); return differences;}
changes.Declarations = declChanges;
deletions.Declarations = declDeletions;
insertions.Declarations = declInsertions;
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (localDeclarations1.InitOnly == localDeclarations2.InitOnly) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
diff = this.VisitTypeNode(localDeclarations1.Type, localDeclarations2.Type);
if (diff == null){Debug.Assert(false); return differences;}
changes.Type = diff.Changes as TypeNode;
deletions.Type = diff.Deletions as TypeNode;
insertions.Type = diff.Insertions as TypeNode;
//Debug.Assert(diff.Changes == changes.Type && diff.Deletions == deletions.Type && diff.Insertions == insertions.Type);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations) {
if (localDeclarations == null) return null;
localDeclarations.Type = this.VisitTypeReference(localDeclarations.Type);
return localDeclarations;
}
//private ParseFixedPointerDeclarations
private LocalDeclarationsStatement ParseFixedPointerDeclarations(SourceLocationBuilder slb, TypeExpression typeExpression, TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
List<LocalDeclaration> declarations = new List<LocalDeclaration>();
for (; ; ) {
NameDeclaration locName = this.ParseNameDeclaration();
SourceLocationBuilder locSctx = new SourceLocationBuilder(locName.SourceLocation);
if (declarations.Count == 0) locSctx.UpdateToSpan(typeExpression.SourceLocation);
this.Skip(Token.Assign);
Expression/*?*/ locInitialValue = this.ParseExpression(followers|Token.Semicolon|Token.Comma);
locSctx.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken);
slb.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken);
declarations.Add(new FixedPointerDeclaration(locName, locInitialValue, locSctx));
if (this.currentToken != Token.Comma) break;
this.GetNextToken();
}
declarations.TrimExcess();
LocalDeclarationsStatement result = new LocalDeclarationsStatement(false, true, false, typeExpression, declarations, slb);
this.SkipTo(followers);
return result;
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations){
if (localDeclarations == null) return null;
LocalDeclarationList decls = localDeclarations.Declarations;
for (int i = 0, n = decls == null ? 0 : decls.Count; i < n; i++){
LocalDeclaration decl = decls[i];
if (decl == null) continue;
decl.InitialValue = null; // delete the intial value expression so later phases won't get confused in light of comment below.
Field f = decl.Field;
if (f == null) continue;
f.Initializer = this.VisitExpression(f.Initializer);
//If the method scope is captured for a closure,
if (f.Initializer == null && ((BlockScope)f.DeclaringType).CapturedForClosure)
//Force Normalizer to bind it to the current closure class before any nested closures are visited
this.VisitMemberBinding(new MemberBinding(new ImplicitThis(), f));
}
if (this.currentMethod != null && this.currentMethod.Scope != null && this.currentMethod.Scope.CapturedForClosure) return null;
return localDeclarations; // leave it for Writer to use for associating debug info
}
/// <summary>
/// A copy constructor that allocates an instance that is the same as the given template, except for its containing block.
/// </summary>
/// <param name="containingLocalDeclarationsStatement">The containing statement. This should be different from the containing statement of the template declaration.</param>
/// <param name="template">The statement to copy.</param>
protected VccLocalDeclaration(LocalDeclarationsStatement containingLocalDeclarationsStatement, VccLocalDeclaration template)
: base(containingLocalDeclarationsStatement, template)
{
this.specifiers = new List <Specifier>(template.specifiers);
this.isSpec = template.isSpec;
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations){
if (localDeclarations == null) return null;
this.AbstractSealedUsedAsType = Error.AbstractSealedLocalType;
TypeNode type = localDeclarations.Type = this.VisitTypeReference(localDeclarations.Type, true);
if (type == null){
TypeExpression texpr = localDeclarations.TypeExpression as TypeExpression;
if (texpr != null && texpr.ConsolidatedTemplateArguments != null && this.identifierInfos != null &&
texpr.SourceContext.Document != null && texpr.SourceContext.Document.Text != null && texpr.SourceContext.EndPos == texpr.SourceContext.Document.Text.Length-1) {
//Could be a call to a generic method.
TemplateInstance ti = new TemplateInstance(texpr.Expression, texpr.ConsolidatedTemplateArguments);
ti.SourceContext = texpr.SourceContext;
ti.IsMethodTemplate = true;
MethodCall mcall = new MethodCall(ti, new ExpressionList(0));
mcall.SourceContext = texpr.SourceContext;
return (Statement)this.Visit(new ExpressionStatement(mcall, mcall.SourceContext));
}
}
this.AbstractSealedUsedAsType = Error.NotAType;
LocalDeclarationList decls = localDeclarations.Declarations;
int n = decls.Count;
if (localDeclarations.Constant || localDeclarations.InitOnly){
for (int i = 0; i < n; i++){
LocalDeclaration decl = decls[i];
if (decl == null) continue;
decl = this.VisitLocalDeclaration(decl);
Field f = decl.Field;
if (f == null) continue;
f.Type = type;
f.Initializer = decl.InitialValue = this.VisitExpression(f.Initializer);
}
return localDeclarations;
}else{
StatementList statements = new StatementList(n+1);
statements.Add(localDeclarations);
for (int i = 0; i < n; i++){
LocalDeclaration decl = decls[i];
if (decl == null) continue;
decl = this.VisitLocalDeclaration(decl);
Field f = decl.Field;
if (f == null) continue;
f.Type = type;
f.Initializer = null;
MemberBinding mb = new MemberBinding(new ImplicitThis(this.scope, 0), f);
mb.Type = type;
mb.SourceContext = decl.Name.SourceContext;
Expression initVal = decl.InitialValue = this.VisitExpression(decl.InitialValue);
if (initVal == null) continue;
AssignmentStatement aStat = new AssignmentStatement(mb, initVal, decl.AssignmentNodeType);
aStat.SourceContext = localDeclarations.SourceContext;
if (decl.SourceContext.Document != null) {
aStat.SourceContext = decl.SourceContext;
Debug.Assert(aStat.SourceContext.EndPos >= aStat.SourceContext.StartPos);
}
statements.Add(aStat);
}
Block b = new Block(statements);
b.SourceContext = localDeclarations.SourceContext;
return b;
}
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations){
if (localDeclarations == null) return null;
this.VisitResolvedTypeReference(localDeclarations.Type, localDeclarations.TypeExpression);
return base.VisitLocalDeclarationsStatement(localDeclarations);
}
public virtual Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations, LocalDeclarationsStatement changes, LocalDeclarationsStatement deletions, LocalDeclarationsStatement insertions){
this.UpdateSourceContext(localDeclarations, changes);
if (localDeclarations == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return localDeclarations;
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations){
if (localDeclarations == null) return null;
TypeNode type = localDeclarations.Type = this.VisitTypeReference(localDeclarations.Type);
if (!localDeclarations.Constant) return localDeclarations;
LocalDeclarationList decls = localDeclarations.Declarations;
for (int i = 0, n = decls.Count; i < n; i++){
LocalDeclaration decl = decls[i];
Field f = decl.Field;
f.Type = type;
f.Initializer = this.VisitExpression(f.Initializer);
}
return localDeclarations;
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations) {
return localDeclarations;
}
private LocalDeclarationsStatement ParseLocalDeclarations(SourceLocationBuilder slb, TypeExpression typeExpression, bool constant, bool initOnly, bool skipSemicolon, TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
List<LocalDeclaration> declarations = new List<LocalDeclaration>();
for (; ; ) {
NameDeclaration locName = this.ParseNameDeclaration();
SourceLocationBuilder locSctx = new SourceLocationBuilder(locName.SourceLocation);
//if (this.currentToken == Token.LeftBracket) {
// this.HandleError(Error.CStyleArray);
// int endPos = this.scanner.endPos;
// int rank = this.ParseRankSpecifier(true, followers|Token.RightBracket|Parser.IdentifierOrNonReservedKeyword|Token.Assign|Token.Semicolon|Token.Comma);
// if (rank > 0)
// t = result.Type = result.TypeExpression =
// this.ParseArrayType(rank, t, followers|Token.RightBracket|Parser.IdentifierOrNonReservedKeyword|Token.Assign|Token.Semicolon|Token.Comma);
// else {
// this.currentToken = Token.LeftBracket;
// this.scanner.endPos = endPos;
// this.GetNextToken();
// while (!this.scanner.TokenIsFirstAfterLineBreak &&
// this.currentToken != Token.RightBracket && this.currentToken != Token.Assign && this.currentToken != Token.Semicolon)
// this.GetNextToken();
// if (this.currentToken == Token.RightBracket) this.GetNextToken();
// }
//}
//if (this.currentToken == Token.LeftParenthesis) {
// this.HandleError(Error.BadVarDecl);
// int dummy;
// SourceContext lpCtx = this.scanner.CurrentSourceContext;
// this.GetNextToken();
// this.ParseArgumentList(followers|Token.LeftBrace|Token.Semicolon|Token.Comma, lpCtx, out dummy);
//} else
Expression/*?*/ locInitialValue = null;
if (this.currentToken == Token.Assign || constant) {
this.Skip(Token.Assign);
ArrayTypeExpression/*?*/ arrayTypeExpression = typeExpression as ArrayTypeExpression;
if (this.currentToken == Token.LeftBrace && arrayTypeExpression != null)
locInitialValue = this.ParseArrayInitializer(arrayTypeExpression, followers|Token.Semicolon|Token.Comma);
else
locInitialValue = this.ParseExpression(followers|Token.Semicolon|Token.Comma);
}
locSctx.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken);
if (declarations.Count == 0) locSctx.UpdateToSpan(typeExpression.SourceLocation);
slb.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken);
declarations.Add(new LocalDeclaration(false, false, locName, locInitialValue, locSctx));
if (this.currentToken != Token.Comma) break;
this.GetNextToken();
//SourceContext sctx = this.scanner.CurrentSourceContext;
//ScannerState ss = this.scanner.state;
//TypeNode ty = this.ParseTypeExpression(null, followers|Token.Identifier|Token.Comma|Token.Semicolon, true);
//if (ty == null || this.currentToken != Token.Identifier) {
// this.scanner.endPos = sctx.StartPos;
// this.scanner.state = ss;
// this.currentToken = Token.None;
// this.GetNextToken();
//} else
// this.HandleError(sctx, Error.MultiTypeInDeclaration);
}
if (skipSemicolon) this.SkipSemiColon(followers);
declarations.TrimExcess();
LocalDeclarationsStatement result = new LocalDeclarationsStatement(constant, initOnly, !constant, typeExpression, declarations, slb);
this.SkipTo(followers);
return result;
}
/// <summary>
/// A copy constructor that allocates an instance that is the same as the given template, except for its containing block.
/// </summary>
/// <param name="containingLocalDeclarationsStatement">The containing statement. This should be different from the containing statement of the template declaration.</param>
/// <param name="template">The statement to copy.</param>
protected VccLocalFunctionDeclaration(LocalDeclarationsStatement containingLocalDeclarationsStatement, VccLocalFunctionDeclaration template)
: base(containingLocalDeclarationsStatement, template)
{
this.mangledFunctionDeclaration = template.mangledFunctionDeclaration;
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations) {
if (localDeclarations == null) return null;
TypeNode type = localDeclarations.Type = this.VisitTypeReference(localDeclarations.Type);
TypeNode unwrappedType = this.typeSystem.Unwrap(type);
LocalDeclarationList decls = localDeclarations.Declarations;
Pointer declaredPointerType = unwrappedType as Pointer;
if (this.insideFixedDeclarator && declaredPointerType == null) {
this.HandleError(localDeclarations.TypeExpression, Error.BadFixedVariableType);
return null;
}
for (int i = 0, n = decls.Count; i < n; i++) {
LocalDeclaration decl = decls[i];
if (decl == null) continue;
Field f = decl.Field;
if (f == null) continue;
f.Flags &= ~FieldFlags.NotSerialized; //Remove this flag so that subsequent references are OK
if (type != null)
f.Type = type;
if (this.requireInitializer && f.Initializer == null)
this.HandleError(decl.Name, Error.FixedMustInit);
else if (this.insideFixedDeclarator && f.Initializer != null && f.Initializer.NodeType == NodeType.ExplicitCoercion)
this.HandleError(decl, Error.BadExplicitCoercionInFixed);
f.Initializer = this.VisitExpression(f.Initializer);
if (f.Initializer == null || f.Initializer.Type == null) continue;
if (this.insideFixedDeclarator && declaredPointerType != null && f.IsInitOnly) {
Expression source = f.Initializer;
TypeNode unwrappedSource = this.typeSystem.Unwrap(source.Type);
ArrayType arrType = unwrappedSource as ArrayType;
if (arrType != null && arrType.ElementType != null) {
Indexer indexer = new Indexer(source, new ExpressionList(Literal.Int32Zero), arrType.ElementType, source.SourceContext);
indexer.ArgumentListIsIncomplete = true;
source = new UnaryExpression(indexer, NodeType.AddressOf, indexer.Type.GetReferenceType(), source.SourceContext);
} else if (unwrappedSource == SystemTypes.String && declaredPointerType.ElementType == SystemTypes.Char) {
f.Initializer = this.typeSystem.ImplicitCoercion(source, unwrappedSource, this.TypeViewer);
continue;
}
f.Initializer = this.typeSystem.ImplicitCoercion(source, declaredPointerType, this.TypeViewer);
continue;
}
if (!localDeclarations.Constant) continue;
if (!(f.Initializer is Literal) /*&& !(f.Initializer is AnonymousNestedFunction)*/) {
this.HandleError(f.Name, Error.NotConstantExpression, f.Name.ToString());
decls[i] = null;
}
Literal lit = f.Initializer as Literal;
if (lit != null)
f.Initializer = this.VisitExpression(this.typeSystem.ImplicitLiteralCoercion(lit, lit.Type, f.Type, this.TypeViewer));
}
return localDeclarations;
}
public virtual Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations1, LocalDeclarationsStatement localDeclarations2)
{
if (localDeclarations1 == null) return null;
if (localDeclarations2 == null)
{
localDeclarations1.Type = this.VisitTypeReference(localDeclarations1.Type, null);
localDeclarations1.Declarations = this.VisitLocalDeclarationList(localDeclarations1.Declarations, null);
}
else
{
localDeclarations1.Type = this.VisitTypeReference(localDeclarations1.Type, localDeclarations2.Type);
localDeclarations1.Declarations = this.VisitLocalDeclarationList(localDeclarations1.Declarations, localDeclarations2.Declarations);
}
return localDeclarations1;
}
public virtual Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations){
if (localDeclarations == null) return null;
localDeclarations.Type = this.VisitTypeReference(localDeclarations.Type);
localDeclarations.Declarations = this.VisitLocalDeclarationList(localDeclarations.Declarations);
return localDeclarations;
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations)
{
if (localDeclarations == null) return null;
return base.VisitLocalDeclarationsStatement((LocalDeclarationsStatement)localDeclarations.Clone());
}
public static void report(Node node, int shift)
{
if (node == null)
{
indent(shift);
Console.WriteLine("NULL ENTITY");
return;
}
switch (node.NodeType)
{
case NodeType.AliasDefinition:
{
AliasDefinition alias = node as AliasDefinition;
indent(shift);
Console.WriteLine("using {0} = {1};", alias.Alias.Name, alias.AliasedUri.Name);
break;
}
case NodeType.CompilationUnit:
case NodeType.CompilationUnitSnippet:
{
CompilationUnit cu = node as CompilationUnit;
for (int i = 0, n = cu.Nodes.Length; i < n; i++)
{
report(cu.Nodes[i], 0);
}
break;
}
case NodeType.Namespace:
{
Namespace ns = node as Namespace;
if (ns.UsedNamespaces != null && ns.UsedNamespaces.Length != 0)
{
indent(shift);
Console.WriteLine("using ");
for (int i = 0, n = ns.UsedNamespaces.Length; i < n; i++)
{
Console.Write("{0}", ns.UsedNamespaces[i].Namespace.Name);
if (i < n - 1)
{
Console.Write(", ");
}
}
Console.WriteLine();
}
indent(shift);
Console.WriteLine("namespace {0}", ns.FullNameId.Name);
indent(shift);
Console.WriteLine("{");
if (ns.AliasDefinitions != null && ns.AliasDefinitions.Length != 0)
{
for (int i = 0, n = ns.AliasDefinitions.Length; i < n; i++)
{
report(ns.AliasDefinitions[i], shift + ind);
}
}
if (ns.NestedNamespaces != null && ns.NestedNamespaces.Length != 0)
{
for (int i = 0, n = ns.NestedNamespaces.Length; i < n; i++)
{
report(ns.NestedNamespaces[i], shift + ind);
}
}
if (ns.Types != null && ns.Types.Length != 0)
{
for (int i = 0, n = ns.Types.Length; i < n; i++)
{
report(ns.Types[i], shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Class:
{
Class cls = node as Class;
if (cls == SystemTypes.Object)
{
Console.Write(cls.Name);
break;
}
indent(shift);
if (cls.IsAbstract)
{
Console.Write("abstract ");
}
if (cls.IsPrivate)
{
Console.Write("private ");
}
else if (cls.IsPublic)
{
Console.Write("public ");
}
else
{
Console.Write("internal "); // ??????????????
}
if (cls.IsSealed)
{
Console.Write("sealed ");
}
Console.Write("class ");
if (cls.DeclaringType != null)
{
Console.Write("{0}::", cls.DeclaringType.Name.Name);
}
Console.Write("{0}", cls.Name != null?cls.Name.Name:"<NONAME>");
if (cls.BaseClass != null)
{
Console.Write(" : {0}", cls.BaseClass.Name.Name);
}
if (cls.Interfaces != null && cls.Interfaces.Length != 0)
{
if (cls.BaseClass != null)
{
Console.Write(",");
}
else
{
Console.Write(" :");
}
for (int i = 0, n = cls.Interfaces.Length; i < n; i++)
{
Interface interfac = cls.Interfaces[i];
if (interfac != null)
{
Console.Write(" {0}", interfac.Name.Name);
}
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.WriteLine();
indent(shift);
Console.WriteLine("{");
if (cls.Members != null && cls.Members.Length != 0)
{
for (int i = 0, n = cls.Members.Length; i < n; i++)
{
Member member = cls.Members[i];
if (member == null)
{
indent(shift + ind);
Console.WriteLine("<UNRESOLVED MEMBER>");
continue;
}
report(member, shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Struct:
{
Struct struc = node as Struct;
indent(shift);
if (struc.IsAbstract)
{
Console.Write("abstract ");
}
if (struc.IsPrivate)
{
Console.Write("private ");
}
else if (struc.IsPublic)
{
Console.Write("public ");
}
else
{
Console.Write("internal "); // ??????????????
}
if (struc.IsSealed)
{
Console.Write("sealed ");
}
Console.Write("struct ");
if (struc.DeclaringType != null)
{
Console.Write("{0}::", struc.DeclaringType.Name.Name);
}
Console.Write("{0}", struc.Name != null?struc.Name.Name:"<NONAME>");
if (struc.Interfaces != null && struc.Interfaces.Length != 0)
{
Console.Write(" :");
for (int i = 0, n = struc.Interfaces.Length; i < n; i++)
{
Interface interfac = struc.Interfaces[i];
if (interfac != null)
{
Console.Write(" {0}", interfac.Name.Name);
}
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.WriteLine();
indent(shift);
Console.WriteLine("{");
if (struc.Members != null && struc.Members.Length != 0)
{
for (int i = 0, n = struc.Members.Length; i < n; i++)
{
Member member = struc.Members[i];
if (member == null)
{
indent(shift + ind);
Console.WriteLine("<UNRESOLVED MEMBER>");
continue;
}
report(member, shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.EnumNode:
{
EnumNode enume = node as EnumNode;
indent(shift);
if (enume.Name != null && enume.Name.Name != null)
{
Console.Write("enum {0} = ", enume.Name.Name);
}
else
{
Console.Write("enum <NONAME> = ");
}
Console.Write("{");
for (int i = 0, n = enume.Members.Length; i < n; i++)
{
Field enumerator = (Field)enume.Members[i];
Console.Write("{0}", enumerator.Name.Name);
if (enumerator.DefaultValue != null)
{
Console.Write(" = {0}", enumerator.DefaultValue.ToString());
}
if (i < n - 1)
{
Console.Write(", ");
}
}
Console.WriteLine("};");
break;
}
case NodeType.Interface:
{
Interface interfac = node as Interface;
indent(shift);
if (interfac.IsAbstract)
{
Console.Write("abstract ");
}
if (interfac.IsPrivate)
{
Console.Write("private ");
}
else if (interfac.IsPublic)
{
Console.Write("public ");
}
else
{
Console.Write("internal "); // ???????????
}
Console.WriteLine("interface {0}", interfac.Name.Name);
indent(shift);
Console.WriteLine("{");
if (interfac.Members != null && interfac.Members.Length != 0)
{
for (int i = 0, n = interfac.Members.Length; i < n; i++)
{
Member member = interfac.Members[i];
if (member == null)
{
indent(shift + ind);
Console.WriteLine("<UNRESOLVED MEMBER>");
continue;
}
report(member, shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Method:
case NodeType.InstanceInitializer:
{
Method method = node as Method;
indent(shift);
if (method.IsAbstract)
{
Console.Write("abstract ");
}
if (method.IsPublic)
{
Console.Write("public ");
}
if (method.IsStatic)
{
Console.Write("static ");
}
if (method.IsVirtual)
{
Console.Write("virtual ");
}
if (method.IsPrivate)
{
Console.Write("private ");
}
if (method.OverriddenMethod != null)
{
Console.Write("override ");
}
if (method.ReturnType != null && method.ReturnType.Name != null)
{
Console.Write("{0} ", method.ReturnType.Name.Name);
}
if (method.Name != null)
{
if (method.ImplementedInterfaceMethods != null && method.ImplementedInterfaceMethods.Length != 0)
{
Method interf = method.ImplementedInterfaceMethods[0];
if (interf != null)
{
string name = interf.DeclaringType.Name.Name;
Console.Write("{0}.", name);
}
}
Console.Write("{0}", method.Name.Name);
}
Console.Write(" (");
if (method.Parameters != null && method.Parameters.Length != 0)
{
for (int i = 0, n = method.Parameters.Length; i < n; i++)
{
Parameter par = method.Parameters[i];
if (par == null)
{
continue;
}
if ((par.Flags & ParameterFlags.In) != 0)
{
Console.Write("in ");
}
if ((par.Flags & ParameterFlags.Out) != 0)
{
Console.Write("out ");
}
if (par.Type != null && par.Type.Name != null)
{
Console.Write("{0}", par.Type.Name.Name);
}
else
{
report(par.Type, 0);
}
Console.Write(" {0}", par.Name.Name);
if (i < n - 1)
{
Console.Write(", ");
}
}
}
Console.Write(" )");
// method body
if (method.Body != null)
{
Console.WriteLine();
report(method.Body, shift);
}
else
{
Console.WriteLine(";");
}
break;
}
case NodeType.DelegateNode:
{
DelegateNode dn = node as DelegateNode;
indent(shift);
Console.Write("delegate ");
if (dn.ReturnType != null && dn.ReturnType.Name != null)
{
Console.Write("{0} ", dn.ReturnType.Name.Name);
}
if (dn.Name != null)
{
Console.Write("{0}", dn.Name.Name);
}
Console.Write(" (");
if (dn.Parameters != null && dn.Parameters.Length != 0)
{
for (int i = 0, n = dn.Parameters.Length; i < n; i++)
{
Parameter par = dn.Parameters[i];
if (par == null)
{
continue;
}
if ((par.Flags & ParameterFlags.In) != 0)
{
Console.Write("in ");
}
if ((par.Flags & ParameterFlags.Out) != 0)
{
Console.Write("out ");
}
if (par.Type != null && par.Type.Name != null)
{
Console.Write("{0}", par.Type.Name.Name);
}
else
{
report(par.Type, 0);
}
Console.Write(" {0}", par.Name.Name);
if (i < n - 1)
{
Console.Write(", ");
}
}
}
Console.WriteLine(" );");
break;
}
case NodeType.StaticInitializer:
{
StaticInitializer si = node as StaticInitializer;
indent(shift);
Console.WriteLine("static {0} ( )", si.Name.Name);
// body
if (si.Body != null)
{
report(si.Body, shift);
}
else
{
Console.WriteLine("NO BODY");
}
break;
}
case NodeType.FieldInitializerBlock:
{
FieldInitializerBlock initializers = node as FieldInitializerBlock;
indent(shift);
if (initializers.IsStatic)
{
Console.Write("static ");
}
Console.WriteLine("init {");
for (int i = 0, n = initializers.Statements.Length; i < n; i++)
{
report(initializers.Statements[i], shift + ind);
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Base:
{
Console.Write("base");
break;
}
case NodeType.Field:
{
Field field = node as Field;
indent(shift);
if (field.IsPrivate)
{
Console.Write("private ");
}
else if (field.IsPublic)
{
Console.Write("public ");
}
if (field.IsStatic)
{
Console.Write("static ");
}
if (field.IsInitOnly)
{
Console.Write("readonly ");
}
if (field.Type != null)
{
if (field.Type.Name != null)
{
Console.Write("{0}", field.Type.Name.Name);
}
else
{
report(field.Type, 0);
}
}
Console.Write(" {0}", field.Name.Name);
if (field.Initializer != null)
{
Console.Write(" = ");
report(field.Initializer, 0);
}
Console.WriteLine(";");
break;
}
case NodeType.VariableDeclaration:
{
VariableDeclaration variable = node as VariableDeclaration;
indent(shift);
if (variable.Type != null && variable.Type.Name != null)
{
Console.Write("{0}", variable.Type.Name.Name);
}
else
{
report(variable.Type, 0);
}
Console.Write(" {0}", variable.Name.Name);
if (variable.Initializer != null)
{
Console.Write(" = ");
report(variable.Initializer, 0);
}
Console.WriteLine(";");
break;
}
case NodeType.LocalDeclarationsStatement:
{
LocalDeclarationsStatement stmt = node as LocalDeclarationsStatement;
indent(shift);
TypeNode type = stmt.Type;
if (type != null && type.Name != null)
{
Console.Write("{0}", type.Name.Name);
}
else
{
report(type, 0);
}
Console.Write(" ");
LocalDeclarationList list = stmt.Declarations;
for (int i = 0, n = list.Length; i < n; i++)
{
LocalDeclaration local = list[i];
Console.Write("{0}", local.Name.Name);
if (local.InitialValue != null)
{
Console.Write(" = ");
report(local.InitialValue, 0);
}
if (i < n - 1)
{
Console.Write(", ");
}
}
Console.WriteLine(";");
break;
}
case NodeType.Property:
{
Property property = node as Property;
indent(shift);
if (property.IsPrivate)
{
Console.Write("private ");
}
else if (property.IsPublic)
{
Console.Write("public ");
}
if (property.IsStatic)
{
Console.Write("static ");
}
if (property != null)
{
if (property.Type != null && property.Type.Name != null)
{
Console.Write("{0} ", property.Type.Name.Name);
}
if (property.ImplementedTypes != null)
{
TypeNode typ = property.ImplementedTypes[0];
Console.Write("{0}.", typ.Name.Name);
}
if (property.Name != null)
{
Console.WriteLine("{0}", property.Name.Name);
}
}
indent(shift);
Console.WriteLine("{");
if (property.Getter != null)
{
report(property.Getter, shift + ind);
}
if (property.Setter != null)
{
report(property.Setter, shift + ind);
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Lock:
{
Lock _lock = node as Lock;
indent(shift);
Console.Write("lock(");
report(_lock.Guard, shift);
Console.WriteLine(")");
report(_lock.Body, shift + ind);
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Block:
{
Block block = node as Block;
if (block == null || block.Statements == null)
{
break;
}
indent(shift);
Console.WriteLine("{");
for (int i = 0, n = block.Statements.Length; i < n; i++)
{
report(block.Statements[i], shift + ind);
Console.WriteLine();
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.MemberBinding:
{
MemberBinding mb = node as MemberBinding;
if (mb.TargetObject != null)
{
report(mb.TargetObject, 0);
}
else if (mb.BoundMember != null && mb.BoundMember.DeclaringType != null)
{
Console.Write(mb.BoundMember.DeclaringType.Name);
}
Console.Write(".");
if (mb.BoundMember.Name != null)
{
Console.Write(mb.BoundMember.Name.Name);
}
else
{
report(mb.BoundMember, 0);
}
break;
}
case NodeType.AssignmentStatement:
{
AssignmentStatement assignment = node as AssignmentStatement;
indent(shift);
report(assignment.Target, 0);
switch (assignment.Operator)
{
case NodeType.Nop: Console.Write(" = "); break;
case NodeType.Add: Console.Write(" += "); break;
case NodeType.Add_Ovf: Console.Write(" += "); break;
case NodeType.Add_Ovf_Un: Console.Write(" += "); break;
case NodeType.Sub: Console.Write(" -= "); break;
case NodeType.Sub_Ovf: Console.Write(" -= "); break;
case NodeType.Sub_Ovf_Un: Console.Write(" -= "); break;
case NodeType.Mul: Console.Write(" *= "); break;
case NodeType.Mul_Ovf: Console.Write(" *= "); break;
case NodeType.Mul_Ovf_Un: Console.Write(" *= "); break;
}
report(assignment.Source, 0);
Console.Write(";");
break;
}
case NodeType.ExpressionStatement:
{
ExpressionStatement exprStatement = node as ExpressionStatement;
indent(shift);
report(exprStatement.Expression, 0);
Console.Write(";");
break;
}
case NodeType.Return:
{
Return return_stmt = node as Return;
indent(shift);
Console.Write("return");
if (return_stmt.Expression != null)
{
Console.Write(" ");
report(return_stmt.Expression, 0);
}
Console.Write(";");
break;
}
case NodeType.Branch:
{
Branch branch = node as Branch;
indent(shift);
Console.WriteLine("break; (???)");
break;
}
case NodeType.For:
{
For for_stmt = node as For;
indent(shift);
Console.Write("for ( ");
for (int i = 0, n = for_stmt.Initializer.Length; i < n; i++)
{
report(for_stmt.Initializer[i], 0);
}
report(for_stmt.Condition, 0);
Console.Write("; ");
for (int i = 0, n = for_stmt.Incrementer.Length; i < n; i++)
{
report(for_stmt.Incrementer[i], 0);
}
Console.WriteLine(")");
indent(shift);
Console.WriteLine("{");
report(for_stmt.Body, shift + ind);
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.While:
{
While while_loop = node as While;
indent(shift);
Console.Write("while ( ");
report(while_loop.Condition, 0);
Console.WriteLine(" )");
report(while_loop.Body, shift);
break;
}
case NodeType.DoWhile:
{
DoWhile repeat = node as DoWhile;
indent(shift);
Console.WriteLine("do");
report(repeat.Body, shift);
indent(shift);
Console.Write("while (");
report(repeat.Condition, 0);
Console.WriteLine(" );");
break;
}
case NodeType.If:
{
If if_stmt = node as If;
indent(shift);
Console.Write("if ( ");
report(if_stmt.Condition, 0);
Console.WriteLine(" )");
report(if_stmt.TrueBlock, shift);
if (if_stmt.FalseBlock == null ||
if_stmt.FalseBlock.Statements == null ||
if_stmt.FalseBlock.Statements.Length == 0)
{
break;
}
indent(shift);
Console.WriteLine("else");
report(if_stmt.FalseBlock, shift);
break;
}
case NodeType.Switch:
{
Switch swtch = node as Switch;
indent(shift);
Console.Write("switch ( ");
report(swtch.Expression, 0);
Console.WriteLine(" )");
indent(shift);
Console.WriteLine("{");
for (int i = 0, n = swtch.Cases.Length; i < n; i++)
{
indent(shift + ind);
if (swtch.Cases[i].Label != null)
{
Console.Write("case ");
report(swtch.Cases[i].Label, 0);
Console.WriteLine(":");
}
else
{
Console.WriteLine("default:");
}
report(swtch.Cases[i].Body, shift + ind);
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Throw:
{
Throw thro = node as Throw;
indent(shift);
Console.Write("throw (");
report(thro.Expression, 0);
Console.Write(");");
break;
}
case NodeType.Exit:
{
indent(shift);
Console.WriteLine("exit;");
break;
}
case NodeType.Continue:
{
indent(shift);
Console.WriteLine("continue;");
break;
}
case NodeType.Try:
{
Try trys = node as Try;
indent(shift);
Console.WriteLine("try {");
report(trys.TryBlock, shift + ind);
indent(shift);
Console.WriteLine("}");
if (trys.Catchers != null)
{
for (int i = 0, n = trys.Catchers.Length; i < n; i++)
{
indent(shift);
if (trys.Catchers[i].Type != null)
{
Console.Write("catch ( {0} ", trys.Catchers[i].Type.FullName);
}
else
{
Console.Write("catch ( ");
}
if (trys.Catchers[i].Variable != null)
{
report(trys.Catchers[i].Variable, 0);
}
Console.WriteLine(" ) {");
report(trys.Catchers[i].Block, shift + ind);
indent(shift);
Console.WriteLine("}");
}
}
if (trys.Finally != null && trys.Finally.Block != null)
{
indent(shift);
Console.WriteLine("finally");
report(trys.Finally.Block, shift);
}
break;
}
case NodeType.BlockExpression:
{
BlockExpression be = node as BlockExpression;
Console.WriteLine("(");
StatementList sl = be.Block.Statements;
for (int i = 0, n = sl.Length; i < n; i++)
{
report(sl[i], shift + ind);
}
indent(shift);
Console.Write(")");
break;
}
case NodeType.ArrayTypeExpression:
{
ArrayTypeExpression array = node as ArrayTypeExpression;
indent(shift);
if (array.ElementType != null &&
array.ElementType.Name != null &&
array.ElementType.Name.Name != null)
{
Console.Write(array.ElementType.Name.Name);
}
else
{
report(array.ElementType, 0);
}
Console.Write("[");
for (int i = 0, n = array.Rank; i < n; i++)
{
if (array.Sizes != null)
{
Console.Write(array.Sizes[i]);
}
if (i < n - 1)
{
Console.Write(",");
}
}
Console.Write("]");
break;
}
case NodeType.Construct:
{
Construct construct = node as Construct;
indent(shift);
Console.Write("new ");
report(construct.Constructor, 0);
Console.Write("(");
if (construct.Operands != null)
{
for (int i = 0, n = construct.Operands.Length; i < n; i++)
{
report(construct.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.Write(")");
break;
}
case NodeType.ConstructArray:
{
ConstructArray initializer = node as ConstructArray;
Console.Write("new ");
if (initializer.ElementType != null &&
initializer.ElementType.Name != null &&
initializer.ElementType.Name.Name != null)
{
Console.Write(initializer.ElementType.Name.Name);
}
else
{
report(initializer.ElementType, 0);
}
Console.Write("[");
for (int i = 0, n = initializer.Operands.Length; i < n; i++)
{
report(initializer.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
Console.Write("]");
break;
}
case NodeType.ConstructDelegate:
{
ConstructDelegate cd = node as ConstructDelegate;
// Console.Write("new {0}({1})",cd.DelegateType.Name.Name,cd.MethodName.Name);
Console.Write("new {0}(", cd.DelegateType.Name.Name);
report(cd.TargetObject, 0);
Console.Write(".{0})", cd.MethodName.Name);
// cd.Type;
break;
}
default:
{
if (node is ZonnonCompilation)
{
ZonnonCompilation zc = node as ZonnonCompilation;
report(zc.CompilationUnits[0], shift);
}
// Expression?
else if (node is MethodCall)
{
MethodCall call = node as MethodCall;
report(call.Callee, 0);
Console.Write("(");
if (call.Operands != null && call.Operands.Length != 0)
{
for (int i = 0, n = call.Operands.Length; i < n; i++)
{
report(call.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.Write(")");
}
else if (node is Variable)
{
Variable variable = node as Variable;
Console.Write("{0}", variable.Name.Name);
}
else if (node is Identifier)
{
Identifier identifier = node as Identifier;
Console.Write("{0}", identifier.Name);
}
else if (node is QualifiedIdentifier)
{
QualifiedIdentifier qualid = node as QualifiedIdentifier;
report(qualid.Qualifier, 0);
Console.Write(".{0}", qualid.Identifier == null?"<UNRESOLVED>":qualid.Identifier.Name);
}
else if (node is Literal)
{
Literal literal = node as Literal;
if (literal.Value == null)
{
Console.Write("null");
}
else
{
if (literal.Value is string)
{
Console.Write("\"");
}
else if (literal.Value is char)
{
Console.Write("'");
}
Console.Write("{0}", literal.Value.ToString());
if (literal.Value is string)
{
Console.Write("\"");
}
else if (literal.Value is char)
{
Console.Write("'");
}
}
}
else if (node is Indexer)
{
Indexer indexer = node as Indexer;
report(indexer.Object, 0);
Console.Write("[");
for (int i = 0, n = indexer.Operands.Length; i < n; i++)
{
report(indexer.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
Console.Write("]");
}
else if (node is UnaryExpression)
{
UnaryExpression unexpr = node as UnaryExpression;
bool add_pars = unexpr.Operand is BinaryExpression ||
unexpr.Operand is UnaryExpression;
switch (unexpr.NodeType)
{
case NodeType.Add: Console.Write("+"); break;
case NodeType.Sub: Console.Write("-"); break;
case NodeType.Neg: Console.Write("-"); break;
case NodeType.Not: Console.Write("~"); break;
case NodeType.UnaryPlus: Console.Write("+"); break;
case NodeType.LogicalNot: Console.Write("!"); break;
case NodeType.Conv_U2: Console.Write("(UInt16)"); break;
case NodeType.RefAddress: Console.Write("ref "); break;
case NodeType.Ckfinite: Console.Write("(Ckfinite)"); break;
default: Console.Write("???"); break;
}
if (add_pars)
{
Console.Write("(");
}
report(unexpr.Operand, 0);
if (add_pars)
{
Console.Write(")");
}
}
else if (node is BinaryExpression)
{
BinaryExpression binexpr = node as BinaryExpression;
bool add_pars = binexpr.Operand1 is BinaryExpression ||
binexpr.Operand1 is UnaryExpression;
if (binexpr.NodeType == NodeType.Castclass)
{
Console.Write("(");
report(binexpr.Operand2, 0);
Console.Write(")");
if (add_pars)
{
Console.Write("(");
}
report(binexpr.Operand1, 0);
if (add_pars)
{
Console.Write(")");
}
break;
}
if (add_pars)
{
Console.Write("(");
}
report(binexpr.Operand1, 0);
if (add_pars)
{
Console.Write(")");
}
switch (binexpr.NodeType)
{
case NodeType.Add: Console.Write(" + "); break;
case NodeType.Add_Ovf: Console.Write(" + "); break;
case NodeType.Add_Ovf_Un: Console.Write(" + "); break;
case NodeType.Sub: Console.Write(" - "); break;
case NodeType.Sub_Ovf: Console.Write(" - "); break;
case NodeType.Sub_Ovf_Un: Console.Write(" - "); break;
case NodeType.Mul: Console.Write(" * "); break;
case NodeType.Mul_Ovf: Console.Write(" * "); break;
case NodeType.Mul_Ovf_Un: Console.Write(" * "); break;
case NodeType.Div: Console.Write(" / "); break;
// case NodeType.Div : Console.Write(" DIV "); break; // "DIV" ?????
case NodeType.Rem: Console.Write(" % "); break; // "MOD" ?????
case NodeType.Or: Console.Write(" | "); break;
case NodeType.And: Console.Write(" & "); break;
case NodeType.Eq: Console.Write(" == "); break;
case NodeType.Ne: Console.Write(" != "); break;
case NodeType.Lt: Console.Write(" < "); break;
case NodeType.Le: Console.Write(" <= "); break;
case NodeType.Gt: Console.Write(" > "); break;
case NodeType.Ge: Console.Write(" >= "); break;
case NodeType.LogicalOr: Console.Write(" || "); break;
case NodeType.LogicalAnd: Console.Write(" && "); break;
case NodeType.Is: Console.Write(" is "); break;
case NodeType.Comma: Console.Write(","); break;
// case OPERATORS.In : expression.NodeType = NodeType // "IN" break;
// case OPERATORS.Implements : expression.NodeType = NodeType // "IMPLEMENTS" break;
default: Console.Write(" !! "); break;
}
add_pars = binexpr.Operand2 is BinaryExpression ||
binexpr.Operand2 is UnaryExpression;
if (add_pars)
{
Console.Write("(");
}
report(binexpr.Operand2, 0);
if (add_pars)
{
Console.Write(")");
}
}
else if (node is TernaryExpression)
{
TernaryExpression ter = node as TernaryExpression;
if (ter.NodeType == NodeType.Conditional)
{
report(ter.Operand1, 0);
Console.Write(" ? ");
report(ter.Operand2, 0);
Console.Write(" : ");
report(ter.Operand3, 0);
}
}
else if (node is PostfixExpression)
{
PostfixExpression postfixExpr = node as PostfixExpression;
report(postfixExpr.Expression, 0);
switch (postfixExpr.Operator)
{
case NodeType.Increment: Console.Write("++"); break;
case NodeType.Decrement: Console.Write("--"); break;
default: Console.Write("???"); break;
}
}
else if (node is LabeledStatement)
{
LabeledStatement lbst = node as LabeledStatement;
indent(shift);
report(lbst.Label, 0);
Console.Write(" : ");
report(lbst.Statement, 0);
}
else if (node is Goto)
{
Goto gt = node as Goto;
indent(shift);
Console.Write("goto ");
report(gt.TargetLabel, 0);
}
else
{
indent(shift);
Console.WriteLine("No code for reporting {0}:{1}", node.UniqueKey, node.ToString());
}
break;
}
}
}
public virtual void VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations)
{
if (localDeclarations == null) return;
this.VisitTypeReference(localDeclarations.Type);
this.VisitLocalDeclarationList(localDeclarations.Declarations);
}
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations)
{
return(localDeclarations);
}
public static Method GetArrayInitializationMethod(String name, bool isPublic, TypeNode declaringType, ARRAY_TYPE type, SourceContext sourceContext)
{
//Array NewTypeName()
//{
// Array Res;
// Res = new Array[A.GetLength(0), A.GetLength(1)];
// for (int i1 = 0; i1 < A.GetLength(0); i1++)
// Res[i1] = new Array[];
// return Res;
//}
TypeNode returnType = (TypeNode)type.convertAndGetType();
Method method = new Method();
method.Name = Identifier.For("New" + name);
method.DeclaringType = declaringType;
method.Flags = MethodFlags.Static;
if (isPublic)
{
method.Flags |= MethodFlags.Public;
}
else
{
method.Flags |= MethodFlags.Private;
}
method.InitLocals = true;
method.SourceContext = sourceContext;
method.Body = new Block();
method.Body.Checked = false; //???
method.Body.HasLocals = true;
method.Body.Statements = new StatementList();
method.ReturnType = returnType;
method.Parameters = new ParameterList();
int count = 0;
// Add parameters
List <Expression> parameterAccess = new List <Expression>();
ARRAY_TYPE arrayType = type;
while (arrayType != null)
{
for (int i = 0; i < arrayType.dimensions.Length; i++)
{
if (arrayType.dimensions[i] == null || arrayType.dimensions[i].calculate() == null)
{
Identifier paramName = Identifier.For("n" + count.ToString());
Parameter parameter = new Parameter(paramName, SystemTypes.Int32);
method.Parameters.Add(parameter);
parameterAccess.Add(paramName);
count++;
}
}
if (arrayType.base_type is ARRAY_TYPE)
{
arrayType = (ARRAY_TYPE)arrayType.base_type;
}
else
{
arrayType = null;
}
}
Identifier resultName = Identifier.For("res");
LocalDeclarationsStatement loc_stmt = new LocalDeclarationsStatement();
loc_stmt.Constant = false;
loc_stmt.Declarations = new LocalDeclarationList(1);
loc_stmt.InitOnly = false;
loc_stmt.SourceContext = sourceContext;
loc_stmt.Type = returnType;
LocalDeclaration local = new LocalDeclaration();
local.Name = resultName;
local.SourceContext = sourceContext;
loc_stmt.Declarations.Add(local);
method.Body.Statements.Add(loc_stmt);
method.Body.Statements.Add(createElementInitializerInternal(type, resultName, 0, parameterAccess, false, sourceContext));
Return ret = new Return();
ret.Expression = resultName;
method.Body.Statements.Add(ret);
return(method);
}
