private Expression GetInitialValue()
{
VccArrayTypeExpression /*?*/
arrayTypeExpression = this.ContainingLocalDeclarationsStatement.TypeExpression as VccArrayTypeExpression;
var baseInit = base.InitialValue;
if (baseInit == null && arrayTypeExpression != null && arrayTypeExpression.Size != null)
{
VccLocalDefinition loc = this.LocalVariable as VccLocalDefinition;
var isSpec = loc != null ? loc.IsSpec : false;
var result = new VccCreateStackArray(arrayTypeExpression.ElementType, arrayTypeExpression.Size, isSpec,
SourceDummy.SourceLocation);
var containingExpression = new DummyExpression(this.ContainingLocalDeclarationsStatement.ContainingBlock, SourceDummy.SourceLocation);
result.SetContainingExpression(containingExpression);
return(result);
}
else if (baseInit == null)
{
return(new DummyExpression(this.Name.SourceLocation));
}
else
{
return(baseInit);
}
}
public override void SetContainingBlock(BlockStatement containingBlock)
{
base.SetContainingBlock(containingBlock);
foreach (var cs in this.cases)
{
cs.SetContainingMatchStatement(this);
}
DummyExpression containingExpression = new DummyExpression(containingBlock, SourceDummy.SourceLocation);
this.expression.SetContainingExpression(containingExpression);
}
public override void SetContainingBlock(BlockStatement containingBlock)
{
base.SetContainingBlock(containingBlock);
this.body.SetContainingBlock(containingBlock);
DummyExpression containingExpression = new DummyExpression(containingBlock, SourceDummy.SourceLocation);
foreach (var expr in this.Expressions)
{
expr.SetContainingExpression(containingExpression);
}
}
private static void CheckOptions(MetadataHostEnvironment hostEnvironment, VccOptions options)
{
if (options.RunTestSuite &&
options.RunTestSuiteMultiThreaded != -1 &&
!String.IsNullOrEmpty(options.XmlLogFile))
{
DummyExpression dummyExpression = new DummyExpression(SourceDummy.SourceLocation);
hostEnvironment.ReportError(new AstErrorMessage(dummyExpression,
Microsoft.Cci.Ast.Error.InvalidCompilerOption,
"Cannot combine /xml with /suite /smt")); // XML logger is sequential
}
}
/// <summary>
/// Completes the two stage construction of this object. This allows bottom up parsers to construct an Expression before constructing the containing Expression.
/// This method should be called once only and must be called before this object is made available to client code. The construction code itself should also take
/// care not to call any other methods or property/event accessors on the object until after this method has been called.
/// </summary>
public void SetContainingType(TypeDeclaration containingType)
{
this.containingType = containingType;
Expression containingExpression = new DummyExpression(containingType.DummyBlock, SourceDummy.SourceLocation);
foreach (FieldDeclaration contractField in this.contractFields)
{
contractField.SetContainingTypeDeclaration(containingType, true);
}
foreach (TypeInvariant typeInvariant in this.invariants)
{
typeInvariant.SetContainingExpression(containingExpression);
}
}
public override void SetContainingBlock(BlockStatement containingBlock)
{
base.SetContainingBlock(containingBlock);
IEnumerable <IEnumerable <Expression> > /*?*/ triggers = this.Compilation.ContractProvider.GetTriggersFor(this);
if (triggers != null)
{
Expression dummyExpression = new DummyExpression(containingBlock, this.SourceLocation);
foreach (IEnumerable <Expression> trigger in triggers)
{
foreach (Expression e in trigger)
{
e.SetContainingExpression(dummyExpression);
}
}
}
}
/// <summary>
/// Completes the two stage construction of this object. This allows bottom up parsers to construct an Expression before constructing the containing Expression.
/// This method should be called once only and must be called before this object is made available to client code. The construction code itself should also take
/// care not to call any other methods or property/event accessors on the object until after this method has been called.
/// </summary>
public virtual void SetContainingBlock(BlockStatement containingBlock)
{
this.containingBlock = containingBlock;
Expression containingExpression = new DummyExpression(containingBlock, SourceDummy.SourceLocation);
foreach (Expression allocation in this.allocates)
allocation.SetContainingExpression(containingExpression);
foreach (Expression free in this.frees)
free.SetContainingExpression(containingExpression);
foreach (AddressableExpression tgtExpr in this.modifiedVariables)
tgtExpr.SetContainingExpression(containingExpression);
foreach (Postcondition postCond in this.postconditions)
postCond.SetContainingExpression(containingExpression);
foreach (Precondition preCond in this.preconditions)
preCond.SetContainingExpression(containingExpression);
foreach (Expression read in this.reads)
read.SetContainingExpression(containingExpression);
foreach (ThrownException except in this.thrownExceptions)
except.SetContainingExpression(containingExpression);
foreach (Expression write in this.writes)
write.SetContainingExpression(containingExpression);
foreach (Expression variant in this.variants)
variant.SetContainingExpression(containingExpression);
}
/// <summary>
/// Completes the two stage construction of this object. This allows bottom up parsers to construct an Expression before constructing the containing Expression.
/// This method should be called once only and must be called before this object is made available to client code. The construction code itself should also take
/// care not to call any other methods or property/event accessors on the object until after this method has been called.
/// </summary>
public virtual void SetContainingBlock(BlockStatement containingBlock)
{
this.containingBlock = containingBlock;
Expression containingExpression = new DummyExpression(containingBlock, SourceDummy.SourceLocation);
foreach (LoopInvariant loopInvariant in this.invariants)
loopInvariant.SetContainingExpression(containingExpression);
foreach (Expression writes in this.writes)
writes.SetContainingExpression(containingExpression);
foreach (var variant in this.variants)
variant.SetContainingExpression(containingExpression);
}
/// <summary>
/// Completes the two stage construction of this object. This allows bottom up parsers to construct an Expression before constructing the containing Expression.
/// This method should be called once only and must be called before this object is made available to client code. The construction code itself should also take
/// care not to call any other methods or property/event accessors on the object until after this method has been called.
/// </summary>
public virtual void SetContainingType(TypeDeclaration containingType)
{
this.containingType = containingType;
Expression containingExpression = new DummyExpression(containingType.DummyBlock, SourceDummy.SourceLocation);
foreach (FieldDeclaration contractField in this.contractFields)
contractField.SetContainingTypeDeclaration(containingType, true);
foreach (MethodDeclaration contractMethod in this.contractMethods)
contractMethod.SetContainingTypeDeclaration(containingType, true);
foreach (TypeInvariant typeInvariant in this.invariants)
typeInvariant.SetContainingExpression(containingExpression);
}
/// <summary>
///
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
protected string LocalizedNoSuchFile(string fileName)
{
DummyExpression dummyExpression = new DummyExpression(SourceDummy.SourceLocation);
return(new AstErrorMessage(dummyExpression, Error.NoSuchFile, fileName).Message);
}
/// <summary>
///
/// </summary>
/// <param name="error"></param>
/// <param name="messageArguments"></param>
protected void ReportError(Error error, params string[] messageArguments)
{
DummyExpression dummyExpression = new DummyExpression(SourceDummy.SourceLocation);
this.hostEnvironment.ReportError(new AstErrorMessage(dummyExpression, error, messageArguments));
}
/// <summary>
/// Completes the two stage construction of this object. This allows bottom up parsers to construct a Statement before constructing the containing Block.
/// This method should be called once only and must be called before this object is made available to client code. The construction code itself should also take
/// care not to call any other methods or property/event accessors on the object until after this method has been called.
/// </summary>
public override void SetContainingBlock(BlockStatement containingBlock) {
base.SetContainingBlock(containingBlock);
DummyExpression containingExpression = new DummyExpression(containingBlock, SourceDummy.SourceLocation);
this.TargetLabel.SetContainingExpression(containingExpression);
}
