public static MainFunc Find(string str)
{
Match match = Is.MatchesAll(str);
if (match == null)
{
return(null);
}
var returnIntOrVoid = new MemberName("int");
if (match.Groups["MainFunc_returnInt"].ToString() == "")
{
returnIntOrVoid = new MemberName("void");
}
var statements = Statements.Find(match.Groups["MainFunc_statements"].ToString());
if (statements == null)
{
return(null);
}
return(new MainFunc
{
returnIntOrVoid = returnIntOrVoid,
_statements = statements,
argsName = new LocalVaribleName(match.Groups["MainFunc_argsName"].ToString())
});
}
/// <devdoc>
/// <para>
/// Initializes a new instance of <see cref='System.CodeDom.CodeIterationStatement'/>.
/// </para>
/// </devdoc>
public CodeIterationStatement(CodeStatement initStatement, CodeExpression testExpression, CodeStatement incrementStatement, params CodeStatement[] statements)
{
InitStatement = initStatement;
TestExpression = testExpression;
IncrementStatement = incrementStatement;
Statements.AddRange(statements);
}
private void OnItemClicked(string colName, ScriptStatement command)
{
int index = ScriptService.Current.Statements.IndexOf(command);
switch (colName)
{
case nameof(ScriptStatement.Insert):
Logger.Debug($"Insert ! {index}");
var scriptStatement = new ScriptStatement();
Statements.Insert(index + 1, scriptStatement);
ScriptService.Current.Insert(index + 1, scriptStatement);
break;
case nameof(ScriptStatement.Up):
Logger.Debug($"Up ! {index}");
Statements.Swap(index, index - 1);
ScriptService.Current.Swap(index, index - 1);
break;
case nameof(ScriptStatement.Down):
Logger.Debug($"Down ! {index}");
Statements.Swap(index, index + 1);
ScriptService.Current.Swap(index, index + 1);
break;
case nameof(ScriptStatement.Trash):
Logger.Debug($"Trash ! {index}");
Statements.Remove(index);
ScriptService.Current.Remove(index);
break;
}
}
public IEnumerable <ICodeGeneratable> GetRepositories()
{
var isAsync = IsFunctionAsync();
var arrowClause = Statements.Count > 1 ? null
: Statements.First();
if (arrowClause != null && arrowClause.StartsWith("return "))
{
arrowClause = arrowClause.Replace("return ", string.Empty);
}
var block = arrowClause != null ? null : Statements;
var names = GetTypeAndMethodNames();
var methods = new List <Method>
{
new Method
{
ArrowClauseExpression = arrowClause,
Block = block,
Comment = Description,
Modifiers = isAsync
? "public static async"
: "public static",
Name = names.Last(),
Parameters = Parameters,
Type = ReturnType,
TypeParameters = TypeParameters
}
};
yield return(new StaticFunction(
Name, names.First(), Description, Version, EnvironmentVariables, PackageReferences, SameAccountDependencies, fields: Fields, methods: methods, usingDirectives: UsingDirectives, usingStaticDirectives: UsingStaticDirectives));
}
public JSForLoop(JSStatement initializer, JSExpression condition, JSStatement increment, params JSStatement[] body)
{
_Initializer = initializer;
_Condition = condition;
_Increment = increment;
Statements.AddRange(body);
}
public CaseExpression(Expression value, WhenClause/*!*/[] whenClauses, Statements elseStatements, SourceSpan location)
: base(location)
{
_value = value;
_whenClauses = whenClauses ?? WhenClause.EmptyArray;
_elseStatements = elseStatements;
}
public void UpdateInventoryCategories()
{
Consumables.Clear();
Weapons.Clear();
KeyItems.Clear();
Statements.Clear();
foreach (var gameItemQuantity in _inventory)
{
if (gameItemQuantity.GameItem is Consumable)
{
Consumables.Add(gameItemQuantity);
}
if (gameItemQuantity.GameItem is Weapon)
{
Weapons.Add(gameItemQuantity);
}
if (gameItemQuantity.GameItem is KeyItem)
{
KeyItems.Add(gameItemQuantity);
}
if (gameItemQuantity.GameItem is Statement)
{
Statements.Add(gameItemQuantity);
}
}
}
private Statements ReadIfs(Statements statements)
{
// 1. Find first .IF
var firstIf = statements.FirstOrDefault(statement => statement is Control c && c.Name.ToLower() == "if");
if (firstIf == null)
{
return(statements);
}
var firstIfIndex = statements.IndexOf(firstIf);
var result = (Statements)statements.Clone();
// 2. Find matching .ENDIF
var matchedEndIfIndex = FindFirstMatched(result, firstIfIndex + 1, "endif");
if (matchedEndIfIndex == statements.Count)
{
Validation.Reading.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Error, "Cannot find matched .endif"));
return(result);
}
// 3. Compute result of .if
var ifResultStatements = ComputeIfResult(result, firstIfIndex, matchedEndIfIndex);
// 4.Replace .if statements with its result
result.Replace(firstIfIndex, matchedEndIfIndex, ifResultStatements);
// 5. Do it again.
result = ReadIfs(result);
return(result);
}
/// <summary>
/// Preprocess .ST and .STEP.
/// </summary>
/// <param name="statements">Statements</param>
public Statements Process(Statements statements)
{
if (statements == null)
{
throw new ArgumentNullException(nameof(statements));
}
foreach (var statement in statements.ToArray())
{
if (statement is Control c)
{
if (c.Name.ToLower() == "st")
{
var cloned = (Control)c.Clone();
cloned.Name = "ST_R";
statements.Add(cloned);
}
if (c.Name.ToLower() == "step")
{
var cloned = (Control)c.Clone();
cloned.Name = "STEP_R";
statements.Add(cloned);
}
}
}
return(statements);
}
protected override void GenerateInner(CodeGenerator generator, CodeStatementEmitOptions emitOptions)
{
generator.Indent--;
generator.Write(TokenType.Keyword, "default");
generator.WriteLine(TokenType.Punctuation, ':');
generator.Indent++;
if (!Fallthrough)
{
generator.EnterLocalScope();
Statements.ReserveLocals(generator, default(CodeStatementEmitOptions));
}
Statements.Generate(generator, default(CodeStatementEmitOptions));
if (!Fallthrough)
{
bool needsBreak = true;
if (Statements.Count > 0)
{
var lastStatement = Statements[Statements.Count - 1];
needsBreak = !lastStatement.IsTerminator;
}
if (needsBreak)
{
generator.Write(TokenType.Keyword, "break");
generator.WriteLine(TokenType.Punctuation, ';');
}
generator.ExitLocalScope();
}
}
protected override void GenerateInner(CodeGenerator generator, CodeCompositeTypeDeclaration enclosingType)
{
generator.Write(TokenType.Keyword, "static");
generator.Write(TokenType.Space, ' ');
generator.Write(TokenType.Identifier, enclosingType.Name);
generator.Write(TokenType.Punctuation, "()");
if (Statements.Count > 0)
{
generator.WriteOpeningBrace();
generator.Indent++;
generator.EnterLocalScope();
foreach (var parameter in Parameters)
{
generator.ReserveLocal(parameter.Name);
}
Statements.Generate(generator, default(CodeStatementEmitOptions));
generator.ExitLocalScope();
generator.Indent--;
generator.WriteClosingBrace();
}
else
{
generator.WriteEmptyBlock();
}
}
public bool CheckSemantics(QLContext context, List <Message> messages)
{
return(Statements.TrueForAll((statement) =>
{
return statement.CheckSemantics(context, messages);
}));
}
internal BlockExpression(Statements/*!*/ statements, SourceSpan location)
: base(location) {
Assert.NotNull(statements);
Debug.Assert(statements.Count > 1);
_statements = statements;
}
public override void Visit(DataModificationStatement node)
{
switch (TypeFilter)
{
case ObjectTypeFilter.PermanentOnly:
if (!IsTempNode(node))
{
Statements.Add(node);
}
break;
case ObjectTypeFilter.TempOnly:
if (IsTempNode(node))
{
Statements.Add(node);
}
break;
default:
Statements.Add(node);
break;
}
}
void WalkMethodStatements(Statements statements)
{
foreach (Expression expression in statements)
{
WalkExpression(expression);
}
}
private static int FindFirstMatched(Statements result, int startIndex, string controlToFind)
{
int ifCount = 0;
while (startIndex < result.Count)
{
if (result[startIndex] is Control c && c.Name.ToLower() == controlToFind && ifCount == 0)
{
break;
}
if (result[startIndex] is Control c2 && c2.Name.ToLower() == "endif")
{
ifCount--;
}
if (result[startIndex] is Control c3 && c3.Name.ToLower() == "if")
{
ifCount++;
}
startIndex++;
}
return(startIndex);
}
private static void Week3Examples()
{
Console.WriteLine("----------------------------------------------");
Console.WriteLine("Week3 in-class discussion and testing... ");
Console.WriteLine("----------------------------------------------");
AdditonalExamples ae = new AdditonalExamples();
//ae.CoalescingExample();
//bool first, second, third, fourth;
//first = ae.UseUmbrella(true, false, true);
//second = ae.UseUmbrella(true, true, true);
//third = ae.UseUmbrella(false, false, false);
//fourth = ae.UseUmbrella(false, true, false);
Console.WriteLine(ae.UseUmbrella(true, false, true));
Console.WriteLine(ae.UseUmbrella(true, true, true));
Console.WriteLine(ae.UseUmbrella(false, false, false));
Console.WriteLine(ae.UseUmbrella(false, true, false));
Statements myStatements = new Statements();
myStatements.IfStatementBasicExample(10, 12);
myStatements.IfStatementChainExample("Turkey");
myStatements.SwitchStatemntExample("Friday");
myStatements.ForEachLoopExample();
}
public override void Visit(TSqlFragment node)
{
if (_types.Contains(node.GetType()))
{
Statements.Add(node);
}
}
static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("MusicAnalyzer <SampleMusicPlaylist> <error_file_path>");
Environment.Exit(1);
}
string csvDataFilePath = args[0];
string errorFilePath = args[1];
List <Setup> setupList = null;
try
{
setupList = Configure.Load(csvDataFilePath);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Environment.Exit(2);
}
var report = Statements.GenerateText(setupList);
try
{
System.IO.File.WriteAllText(setupFilePath, report);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Environment.Exit(3);
}
}
public Finalizer(LexicalScope/*!*/ definedScope, Statements statements, SourceSpan location)
: base(location) {
Assert.NotNull(definedScope);
_definedScope = definedScope;
_statements = statements;
}
protected override void GenerateInner(CodeGenerator generator, CodeStatementEmitOptions emitOptions)
{
generator.WriteBlankLineBeforeEnteringBlock();
generator.EnterLocalScope();
generator.Write(TokenType.Keyword, "foreach");
generator.Write(TokenType.Space, ' ');
generator.Write(TokenType.Punctuation, '(');
Declaration.Type.Generate(generator);
generator.Write(TokenType.Space, ' ');
generator.OutputIdentifier(TokenType.Identifier, Declaration.Name);
generator.Write(TokenType.Space, ' ');
generator.Write(TokenType.Keyword, "in");
generator.Write(TokenType.Space, ' ');
Expression.Generate(generator);
generator.Write(TokenType.Punctuation, ')');
if (Statements.Count > 0)
{
generator.WriteOpeningBrace();
generator.Indent++;
generator.EnterLocalScope();
Statements.ReserveLocals(generator, default(CodeStatementEmitOptions));
Statements.Generate(generator, default(CodeStatementEmitOptions));
generator.ExitLocalScope();
generator.Indent--;
generator.WriteClosingBrace();
}
else
{
generator.WriteEmptyBlock();
}
generator.ExitLocalScope();
}
public ElseIfClause(Expression condition, Statements/*!*/ statements, SourceSpan location)
: base(location)
{
Assert.NotNull(statements);
_statements = statements;
_condition = condition;
}
public CodeForeachStatement(CodeVariableDeclarationStatement declaration, CodeExpression expression, IEnumerable <CodeStatement> statements)
{
Debug.Assert(declaration.InitExpression == null, "foreach variable declaration cannot have initializer");
Declaration = declaration;
Expression = expression;
Statements.AddRange(statements);
}
public void Add(Statement instruction)
{
if (instruction != null)
{
Statements.Add(instruction);
}
}
public void Insert(Statement instruction)
{
if (instruction != null)
{
Statements.Insert(0, instruction);
}
}
/// <summary>
/// Creates a new for loop statement. Usage:
/// for 'identifier' in 'firstExpression' .. 'secondExpression' do 'statements' end for;
/// </summary>
/// <param name="identifier">Iterator's identifier</param>
/// <param name="firstExpression">Starting value</param>
/// <param name="secondExpression">Ending value</param>
/// <param name="statements">Statements to execute</param>
public StatementFor(string identifier, Expression firstExpression, Expression secondExpression, Statements statements)
{
Identifier = identifier;
FirstExpression = firstExpression;
SecondExpression = secondExpression;
Statements = statements;
}
protected override void GenerateInner(CodeGenerator generator, CodeStatementEmitOptions emitOptions)
{
generator.WriteBlankLineBeforeEnteringBlock();
generator.Write(TokenType.Keyword, "switch");
generator.Write(TokenType.Space, ' ');
generator.Write(TokenType.Punctuation, '(');
Value.Generate(generator);
generator.Write(TokenType.Punctuation, ')');
if (Statements.Count > 0)
{
generator.WriteOpeningBrace();
generator.Indent++;
generator.Indent++;
generator.EnterLocalScope();
Statements.ReserveLocals(generator, default(CodeStatementEmitOptions));
Statements.Generate(generator, default(CodeStatementEmitOptions));
generator.ExitLocalScope();
generator.Indent--;
generator.Indent--;
generator.WriteClosingBrace();
}
else
{
generator.WriteEmptyBlock();
}
}
public async Task CreateStatementsTest()
{
Statements statements = new Statements();
var response = await instance.CreateStatementsAsync(accessToken, xeroTenantId, statements);
Assert.IsType <Statements>(response);
}
public ForLoopExpression(LexicalScope/*!*/ definedScope, Parameters/*!*/ variables, Expression/*!*/ list, Statements body, SourceSpan location)
: base(location) {
Assert.NotNull(definedScope, variables, list);
_block = new BlockDefinition(definedScope, variables, body, location);
_list = list;
}
public ForLoopExpression(CompoundLeftValue/*!*/ variables, Expression/*!*/ list, Statements body, SourceSpan location)
: base(location) {
Assert.NotNull(variables, list);
_block = new BlockDefinition(null, variables, body, location);
_list = list;
}
public RescueClause(CompoundRightValue type, LeftValue target, Statements statements, SourceSpan location)
: base(location) {
_types = type.RightValues;
_splatType = type.SplattedValue;
_target = target;
_statements = statements;
}
public RescueClause(Expression/*!*/ type, LeftValue target, Statements statements, SourceSpan location)
: base(location) {
Assert.NotNull(type);
_types = new Expression[] { type };
_target = target;
_statements = statements;
}
/// <summary>
/// Reads .include statements.
/// </summary>
/// <param name="statements">Statements.</param>
/// <param name="currentDirectoryPath">Current directory path.</param>
protected Statements Process(Statements statements, string currentDirectoryPath)
{
var subCircuits = statements.OfType <SubCircuit>().ToList();
if (subCircuits.Any())
{
foreach (SubCircuit subCircuit in subCircuits)
{
var subCircuitIncludes = subCircuit.Statements.OfType <Control>()
.Where(statement => statement.Name == "include" || statement.Name.ToLower() == "inc").ToList();
foreach (Control include in subCircuitIncludes)
{
ReadSingleInclude(subCircuit.Statements, currentDirectoryPath, include);
}
}
}
var includes = statements.OfType <Control>().Where(statement =>
statement.Name.ToLower() == "include" || statement.Name.ToLower() == "inc").ToList();
if (includes.Any())
{
foreach (Control include in includes)
{
ReadSingleInclude(statements, currentDirectoryPath, include);
}
}
return(statements);
}
private IEnumerable <Statement> ComputeIfResult(Statements result, int ifIndex, int endIfIndex)
{
var ifControl = (Control)result[ifIndex];
var ifCondition = (Models.Netlist.Spice.Objects.Parameters.ExpressionParameter)ifControl.Parameters[0];
Control elseControl = null;
Control elseIfControl = null;
var elseControlIndex = FindFirstMatched(result, ifIndex + 1, "else");
if (elseControlIndex != result.Count)
{
elseControl = result[elseControlIndex] as Control;
}
var elseIfControlIndex = FindFirstMatched(result, ifIndex + 1, "elseif");
if (elseIfControlIndex != result.Count)
{
elseIfControl = result[elseIfControlIndex] as Control;
}
if (EvaluationContext.Evaluate(ifCondition.Image) >= 1.0)
{
if (elseIfControl != null)
{
return(result.Skip(ifIndex + 1).Take(elseIfControlIndex - ifIndex - 1).ToList());
}
else
{
if (elseControl == null)
{
return(result.Skip(ifIndex + 1).Take(endIfIndex - ifIndex - 1).ToList());
}
else
{
return(result.Skip(ifIndex + 1).Take(elseControlIndex - ifIndex - 1).ToList());
}
}
}
else
{
if (elseIfControl != null)
{
return(ComputeIfResult(result, elseIfControlIndex, endIfIndex));
}
else
{
if (elseControl == null)
{
return(new List <Statement>());
}
else
{
return(result.Skip(elseControlIndex + 1).Take(endIfIndex - elseControlIndex - 1).ToList());
}
}
}
}
protected override void GenerateInner(CodeGenerator generator, CodeCompositeTypeDeclaration enclosingType)
{
generator.GenerateAttributes(ReturnTypeCustomAttributes, "return");
if (ExplicitImplementationType == null)
{
Modifiers.Generate(generator);
}
ReturnType.Generate(generator);
generator.Write(TokenType.Space, ' ');
if (ExplicitImplementationType != null)
{
ExplicitImplementationType.Generate(generator);
generator.Write(TokenType.Punctuation, '.');
}
generator.OutputIdentifier(TokenType.Identifier, Name);
generator.OutputTypeParameters(TypeParameters);
generator.Write(TokenType.Punctuation, '(');
Parameters.GenerateCommaSeparated(generator);
generator.Write(TokenType.Punctuation, ')');
foreach (var typeParameter in TypeParameters)
{
typeParameter.GenerateConstraints(generator);
}
if (enclosingType.IsInterface ||
(Modifiers & CodeMemberModifiers.ScopeMask) == CodeMemberModifiers.Abstract)
{
generator.WriteLine(TokenType.Punctuation, ';');
}
else
{
if (Statements.Count > 0)
{
generator.WriteOpeningBrace();
generator.Indent++;
generator.EnterLocalScope();
foreach (var parameter in Parameters)
{
generator.ReserveLocal(parameter.Name);
}
Statements.Generate(generator, default(CodeStatementEmitOptions));
generator.ExitLocalScope();
generator.Indent--;
generator.WriteClosingBrace();
}
else
{
generator.WriteEmptyBlock();
}
}
}
public CaseExpression(Expression value, List<WhenClause>/*!*/ whenClauses, Statements elseStatements, SourceSpan location)
: base(location) {
ContractUtils.RequiresNotNull(whenClauses, "whenClauses");
_value = value;
_whenClauses = whenClauses;
_elseStatements = elseStatements;
}
public ISchemaBuilderBase AddStatement(string statement)
{
if (!string.IsNullOrEmpty(statement))
{
Statements.Add(statement);
}
return(this);
}
public BlockDefinition(LexicalScope/*!*/ definedScope, CompoundLeftValue/*!*/ parameters, Statements/*!*/ body, SourceSpan location)
: base(location) {
Assert.NotNull(definedScope, parameters, body);
_definedScope = definedScope;
_body = body;
_parameters = parameters;
}
public VariableDeclaration FindDeclaration(string name)
{
var declaration = Statements
.OfType <VariableDeclaration>()
.FirstOrDefault(d => d.Name == name);
return(declaration ?? ParentScope.FindDeclaration(name));
}
/// <summary>
/// Gets the models with given type and with different name than source model.
/// </summary>
/// <param name="statements">The statements.</param>
/// <param name="sourceModelName">The name of source model.</param>
/// <param name="modelType">The type of model to search.</param>
/// <returns>
/// Enumerable of models.
/// </returns>
private IEnumerable <Model> GetModelsOfType(Statements statements, string sourceModelName, string modelType)
{
return(statements
.Where(s =>
s is Model m &&
GetTypeOfModel(m).ToLower() == modelType.ToLower() &&
m.Name != sourceModelName).Cast <Model>());
}
private readonly Expression[] _types; // might be empty, might include SplattedArgument expressions
#endregion Fields
#region Constructors
public RescueClause(Expression/*!*/[]/*!*/ types, LeftValue target, Statements statements, SourceSpan location)
: base(location)
{
Assert.NotNullItems(types);
_types = types;
_target = target;
_statements = statements;
}
public Statement GetStatement(string fullSqlId)
{
if (!Statements.TryGetValue(fullSqlId, out var statement))
{
throw new SmartSqlException($"Can not find Statement.FullSqlId:{fullSqlId}");
}
return(statement);
}
public BlockDefinition(LexicalScope/*!*/ definedScope, Parameters parameters, Statements/*!*/ body, SourceSpan location)
: base(location) {
Assert.NotNull(definedScope, body);
_definedScope = definedScope;
_body = body;
_parameters = parameters ?? Parameters.Empty;
}
public UnlessExpression(Expression/*!*/ condition, Statements/*!*/ statements, ElseIfClause elseClause, SourceSpan location)
: base(location) {
ContractUtils.RequiresNotNull(condition, "condition");
ContractUtils.RequiresNotNull(statements, "statements");
ContractUtils.Requires(elseClause == null || elseClause.Condition == null, "elseClause", "No condition allowed.");
_statements = statements;
_condition = condition;
_elseClause = elseClause;
}
public WhileLoopExpression(Expression/*!*/ condition, bool isWhileLoop, bool isPostTest, Statements/*!*/ statements, SourceSpan location)
: base(location) {
ContractUtils.RequiresNotNull(condition, "condition");
ContractUtils.RequiresNotNull(statements, "statements");
_condition = condition;
_isWhileLoop = isWhileLoop;
_isPostTest = isPostTest;
_statements = statements;
}
public Body(Statements/*!*/ statements, List<RescueClause> rescueClauses, Statements elseStatements,
Statements ensureStatements, SourceSpan location)
: base(location) {
Assert.NotNull(statements);
_statements = statements;
_rescueClauses = rescueClauses;
_elseStatements = elseStatements;
_ensureStatements = ensureStatements;
}
public static void CopyFile(FileInfo source, FileInfo destination,
Statements.FileCopyOptions options, CopyFileHandler callback, object state)
{
if (source == null) throw new ArgumentNullException("source");
if (destination == null) throw new ArgumentNullException("destination");
new FileIOPermission(FileIOPermissionAccess.Read, source.FullName).Demand();
new FileIOPermission(FileIOPermissionAccess.Write, destination.FullName).Demand();
CopyProgressRoutine cpr = (callback == null) ? null : new CopyProgressRoutine(
new CopyProgressData(source, destination, callback, state).CallbackHandler);
bool cancel = false;
if (!NativeMethod.CopyFileEx(source.FullName, destination.FullName, cpr, IntPtr.Zero, ref cancel, (int)options))
throw new IOException(new Win32Exception().Message);
}
public IfExpression(Expression/*!*/ condition, Statements/*!*/ body, List<ElseIfClause>/*!*/ elseIfClauses, SourceSpan location)
: base(location) {
ContractUtils.RequiresNotNull(body, "body");
ContractUtils.RequiresNotNull(condition, "condition");
ContractUtils.RequiresNotNull(elseIfClauses, "elseIfClauses");
// all but the last clause should have non-null conditions:
for (int i = 0; i < elseIfClauses.Count - 1; i++) {
if (elseIfClauses[i].Condition == null) {
throw ExceptionUtils.MakeArgumentItemNullException(i, "elseIfClauses");
}
}
_condition = condition;
_body = body;
_elseIfClauses = elseIfClauses;
}
public bool Resume(Bookmark bookmark, FileInfo source, FileInfo destination, Statements.FileCopyOptions options, int stepIncrement)
{
var context = new CopyFileContext(stepIncrement)
{
Instance = this,
Bookmark = bookmark,
Action = CopyFileAction.Continue
};
if (contexts.TryAdd(bookmark.Name, context))
{
var action = new Action(() => ExecuteCopyFile(context, source, destination, options));
action.BeginInvoke((a) =>
{
try { action.EndInvoke(a); }
catch (Exception ex) { ((CopyFileContext)a.AsyncState).Exception = ex; }
finally { ((CopyFileContext)a.AsyncState).NotifyCompletion(); }
}, context);
return true;
}
return false;
}
public virtual void Visit(Statements.ScopeGuardStatement s)
{
VisitChildren(s);
}
public virtual void Visit(Statements.TemplateMixin s)
{
VisitAbstractStmt(s);
if (s.Qualifier != null)
s.Qualifier.Accept(this);
}
public virtual void Visit(Statements.AsmStatement s)
{
VisitAbstractStmt(s);
}
private BlockExpression()
: base(SourceSpan.None) {
_statements = EmptyStatements;
}
public virtual void Visit(Statements.AssertStatement s)
{
VisitAbstractStmt(s);
if (s.AssertedExpression != null)
s.AssertedExpression.Accept(this);
}
public virtual void Visit(Statements.PragmaStatement s)
{
VisitChildren(s);
s.Pragma.Accept(this);
}
public virtual void Visit(Statements.VolatileStatement s)
{
VisitChildren(s);
}
public virtual void Visit(Statements.DebugSpecification s)
{
VisitAbstractStmt(s);
}
public virtual void Visit(Statements.TryStatement.FinallyStatement s)
{
VisitChildren(s);
}
public virtual void Visit(Statements.DeclarationStatement s)
{
VisitAbstractStmt(s);
if (s.Declarations != null)
foreach (var decl in s.Declarations)
decl.Accept(this);
}
public virtual void Visit(Statements.ExpressionStatement s)
{
VisitAbstractStmt(s);
s.Expression.Accept(this);
}
