private bool ReplicateAllBlocks(IRoot root)
{
Debug.Assert(ErrorList.IsEmpty);
foreach (IBlock <BaseNode.IClass, BaseNode.Class> Block in root.ClassBlocks.NodeBlockList)
{
foreach (IClass Item in Block.NodeList)
{
if (string.IsNullOrEmpty(Item.ClassPath))
{
ErrorList.AddError(new ErrorEmptyClassPath(Item));
}
}
}
ReplicationContext Replication = new ReplicationContext();
IWalkCallbacks <ReplicationContext> Callbacks = new WalkCallbacks <ReplicationContext>()
{
HandlerNode = OnNodeIgnoreReplicates, HandlerBlockList = OnBlockListReplicate, HandlerString = OnStringReplicateText
};
NodeTreeWalk.Walk <ReplicationContext>(root, Callbacks, Replication);
return(ErrorList.IsEmpty);
}
/// <summary></summary>
protected virtual void InitializeSources(IRoot root)
{
Debug.Assert(ErrorList.IsEmpty);
bool Success = NodeTreeWalk.Walk <object>(root, new WalkCallbacks <object>()
{
HandlerNode = InitializeSource, IsRecursive = true, BlockSubstitution = CreateBlockSubstitution()
}, null);
Debug.Assert(Success);
}
/// <summary></summary>
protected virtual void SealScope(IRoot root)
{
object Context = null;
IWalkCallbacks <object> Callbacks = new WalkCallbacks <object>()
{
HandlerNode = SealAllScopes, IsRecursive = true, BlockSubstitution = CreateBlockSubstitution()
};
IList <IClass> ClassList = root.ClassList;
foreach (IClass Class in ClassList)
{
NodeTreeWalk.Walk <object>(Class, Callbacks, Context);
}
}
private static Node DeserializeAndFix(FileStream fs)
{
Serializer Serializer = new Serializer();
Node RootNode;
RootNode = (Node)Serializer.Deserialize(fs);
WalkCallbacks <string> Callbacks = new WalkCallbacks <string>();
Callbacks.IsRecursive = true;
Callbacks.HandlerRoot = OnUpdateRoot;
Callbacks.HandlerNode = OnUpdateNode;
NodeTreeWalk.Walk(RootNode, Callbacks, string.Empty);
return(RootNode);
}
/// <summary></summary>
protected virtual void ReplacePhase1Macroes(IRoot root)
{
Debug.Assert(ErrorList.IsEmpty);
GenerateCompilationDateTime();
GenerateCompilationUID();
GenerateCompilerVersion();
GenerateConformanceToStandard();
GenerateDebugging();
bool Success = NodeTreeWalk.Walk <ReplacePhase1MacroContext>(root, new WalkCallbacks <ReplacePhase1MacroContext>()
{
HandlerNode = ReplacePhase1Macro, IsRecursive = true
}, new ReplacePhase1MacroContext());
Debug.Assert(Success);
}
private bool OnNodeIgnoreReplicates(BaseNode.INode node, BaseNode.INode parentNode, string propertyName, IWalkCallbacks <ReplicationContext> callbacks, ReplicationContext context)
{
if (node is IGlobalReplicate)
{
return(true);
}
else if (node is IRoot AsRoot)
{
ProcessGlobalReplicates(AsRoot, context);
return(ErrorList.IsEmpty);
}
else if (node is IClass AsClass)
{
ProcessClassReplicates(AsClass, callbacks, context);
return(ErrorList.IsEmpty);
}
else
{
return(parentNode == null || NodeTreeWalk.Walk <ReplicationContext>(node, callbacks, context));
}
}
/// <summary></summary>
protected virtual bool Resolve(IRoot root, IRuleTemplateList ruleTemplateList, string passName)
{
BuildInferenceSourceList Context = new BuildInferenceSourceList(ruleTemplateList);
IWalkCallbacks <BuildInferenceSourceList> Callbacks = new WalkCallbacks <BuildInferenceSourceList>()
{
HandlerNode = ListAllSources, IsRecursive = true, BlockSubstitution = CreateBlockSubstitution()
};
IList <IClass> ClassList = root.ClassList;
foreach (IClass Class in ClassList)
{
NodeTreeWalk.Walk <BuildInferenceSourceList>(Class, Callbacks, Context);
}
IList <ISource> SourceList = Context.SourceList;
InferenceEngine Engine = new InferenceEngine(ruleTemplateList, SourceList, ClassList, true, InferenceRetries);
bool Success = Engine.Solve(ErrorList, passName);
Debug.Assert(Success || !ErrorList.IsEmpty);
return(Success);
}
