private void ProcessClassReplicates(IClass parentClass, IWalkCallbacks <ReplicationContext> callbacks, ReplicationContext context)
{
BaseNode.IBlockList ClassReplicateBlocks = (BaseNode.IBlockList)parentClass.ClassReplicateBlocks;
List <BaseNode.INode> ReplicatedNodeList = new List <BaseNode.INode>();
if (ReplicateBlockList(ClassReplicateBlocks, ReplicatedNodeList, callbacks, context))
{
parentClass.FillReplicatedList(nameof(IClass.ClassReplicateBlocks), ReplicatedNodeList);
List <ICompiledReplicate> ReplicateList = new List <ICompiledReplicate>();
foreach (BaseNode.INode Node in ReplicatedNodeList)
{
IClassReplicate ReplicateItem = Node as IClassReplicate;
Debug.Assert(ReplicateItem != null);
ReplicateList.Add(ReplicateItem);
}
context.ReplicateTable.Clear();
foreach (KeyValuePair <string, List <string> > Entry in context.GlobalReplicateTable)
{
context.ReplicateTable.Add(Entry.Key, Entry.Value);
}
CheckReplicates(ReplicateList, context);
}
}
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>
public bool ReplacePhase1Macro(BaseNode.INode node, BaseNode.INode parentNode, string propertyName, IWalkCallbacks <ReplacePhase1MacroContext> callbacks, ReplacePhase1MacroContext context)
{
bool Result = true;
if (node is IClass AsClass)
{
context.CurrentClass = AsClass;
}
else if (node is ILibrary || node is IGlobalReplicate)
{
context.CurrentClass = null;
}
else if (node is IPreprocessorExpression AsPreprocessorExpression)
{
bool IsHandled = false;
switch (AsPreprocessorExpression.Value)
{
case BaseNode.PreprocessorMacro.DateAndTime:
NodeTreeHelperChild.SetChildNode(parentNode, propertyName, CompilationDateTime);
IsHandled = true;
break;
case BaseNode.PreprocessorMacro.CompilationDiscreteIdentifier:
NodeTreeHelperChild.SetChildNode(parentNode, propertyName, CompilationUID);
IsHandled = true;
break;
case BaseNode.PreprocessorMacro.CompilerVersion:
NodeTreeHelperChild.SetChildNode(parentNode, propertyName, CompilerVersion);
IsHandled = true;
break;
case BaseNode.PreprocessorMacro.ConformanceToStandard:
NodeTreeHelperChild.SetChildNode(parentNode, propertyName, ConformanceToStandard);
IsHandled = true;
break;
case BaseNode.PreprocessorMacro.DiscreteClassIdentifier:
Debug.Assert(context.CurrentClass != null);
string GlassGuidDigits = context.CurrentClass.ClassGuid.ToString("N", CultureInfo.InvariantCulture) + ":" + "H";
BaseNode.IIdentifier Operator = NodeHelper.CreateSimpleIdentifier("To UUID");
BaseNode.IManifestNumberExpression NumberExpression = NodeHelper.CreateSimpleManifestNumberExpression(GlassGuidDigits);
BaseNode.IUnaryOperatorExpression Expression = NodeHelper.CreateUnaryOperatorExpression(Operator, NumberExpression);
IExpression ReplacementNode = ToCompilerNode <BaseNode.IUnaryOperatorExpression, IUnaryOperatorExpression>(Expression);
NodeTreeHelperChild.SetChildNode(parentNode, propertyName, ReplacementNode);
IsHandled = true;
break;
case BaseNode.PreprocessorMacro.Debugging:
NodeTreeHelperChild.SetChildNode(parentNode, propertyName, Debugging);
IsHandled = true;
break;
// Processed in phase 2.
case BaseNode.PreprocessorMacro.ClassPath:
case BaseNode.PreprocessorMacro.Counter:
case BaseNode.PreprocessorMacro.RandomInteger:
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
}
return(Result);
}
/// <summary></summary>
protected virtual bool SealAllScopes(BaseNode.INode node, BaseNode.INode parentNode, string propertyName, IWalkCallbacks <object> callbacks, object context)
{
ISource Source = node as ISource;
Debug.Assert(Source != null);
if (Scope.IsScopeHolder(Source))
{
IScopeHolder ScopeHolder = Source as IScopeHolder;
Debug.Assert(ScopeHolder != null);
ScopeHolder.FullScope.Seal();
}
return(true);
}
/// <summary></summary>
protected virtual bool ListAllSources(BaseNode.INode node, BaseNode.INode parentNode, string propertyName, IWalkCallbacks <BuildInferenceSourceList> callbacks, BuildInferenceSourceList context)
{
ISource Source = node as ISource;
Debug.Assert(Source != null);
Source.Reset(context.RuleTemplateList);
#if COVERAGE
Debug.Assert(!Source.IsResolved(context.RuleTemplateList));
Debug.Assert(Source.ToString().Length > 0);
#endif
foreach (IRuleTemplate RuleTemplate in context.RuleTemplateList)
{
if (RuleTemplate.NodeType.IsAssignableFrom(Source.GetType()))
{
context.SourceList.Add(Source);
break;
}
}
return(true);
}
/// <summary></summary>
public static bool InitializeSource(BaseNode.INode node, BaseNode.INode parentNode, string propertyName, IWalkCallbacks <object> callbacks, object context)
{
bool Result = true;
if (node is ISource AsSource)
{
ISource ParentSource = parentNode as ISource;
AsSource.InitializeSource(ParentSource);
}
#if DEBUG
string DebugString = node.ToString();
if (node is ICompiledFeature AsFeature)
{
bool IsDeferredFeature = AsFeature.IsDeferredFeature;
bool HasExternBody = AsFeature.HasExternBody;
bool HasPrecursorBody = AsFeature.HasPrecursorBody;
}
#endif
return(Result);
}
