protected override void HandleTerminatingConditionMatch(SymToken aToken)
{
// Update the include so that it contains a fully resolved path
iIncludeNode.IncludeDefinition.AdjustRelativeInclude(WorkerContext.Parser.FileName);
// We've now a fully resolved file name which we can parse, should
// we desire...
string includeFile = iIncludeNode.IncludeDefinition.Location;
if (Utils.SymFileSystemUtils.FileExists(includeFile))
{
// Make a new document context
SymParserDocumentContext subDocumentContext = new SymParserDocumentContext(includeFile, WorkerContext);
// Use the existing document, but with a new context
WorkerContext.Document.PushContext(subDocumentContext);
// Make a new carbon copy of this parser (whatever concrete type it may be)
SymParserBase subParser = WorkerContext.Parser.CarbonCopy(new object[] { WorkerContext.Document });
// Make the waiting object
SymParserWaiter waiter = new SymParserWaiter(subParser);
// Now parse the file and wait for the result
subParser.Parse();
waiter.Wait();
// Restore the original context
WorkerContext.Document.PopContext();
}
}
public virtual void Evaluate(SymParserDocumentContext aContext)
{
IsEvaluated = false;
// Evaluate the expression, taking into account the current #define'd
// values. Prepares a new document with these expressions evaluated.
SymTokenDocument evalDoc = BalancedArguments.ExtractTokensAsDocument(false, true);
string expression = evalDoc.ChildrenAsString(false, true);
// Get evaluated result from evaluator
iEvaluationResult = SymExpressionEvaluator.EvaluateAsBoolean(expression);
IsEvaluated = true;
}
public override void Evaluate(SymParserDocumentContext aContext)
{
IsEvaluated = false;
if (Type == TType.ETypeIf || Type == TType.ETypeElseIf)
{
// Evaluate the expression, taking into account the current #define'd
// values. Prepares a new document with these expressions evaluated.
SymTokenDocument evalDoc = new SymTokenDocument();
EvaluateDefineNodes(BalancedArguments, evalDoc, aContext);
string expression = evalDoc.ChildrenAsString(false, true);
EvaluationResult = SymExpressionEvaluator.EvaluateAsBoolean(expression);
}
else if (Type == TType.ETypeIfdef || Type == TType.ETypeIfndef)
{
// Convert the tree to a flat expression
string symbol = BalancedArguments.ChildrenAsString(true, true);
// Check if the symbol is defined
if (Type == TType.ETypeIfdef)
{
EvaluationResult = aContext.DefineDirectory.IsDefined(symbol);
}
else if (Type == TType.ETypeIfndef)
{
EvaluationResult = !aContext.DefineDirectory.IsDefined(symbol);
}
}
else if (Type == TType.ETypeElse)
{
// Else statements always evaluate to true. We let the parent
// conditional expression node decide whether or not this item should
// 'fire'
EvaluationResult = true;
}
IsEvaluated = true;
}
private void EvaluateDefineNodes(SymNode aNode, SymTokenDocument aDocument, SymParserDocumentContext aContext)
{
foreach (SymNode n in aNode)
{
if (n is SymTokenBalancerMarkerLevelNode)
{
bool added = false;
//
SymTokenBalancerMarkerLevelNode levelNode = (SymTokenBalancerMarkerLevelNode)n;
if (levelNode.IsFunction)
{
SymNodeToken functionNameNode = levelNode.FunctionName;
//
if (functionNameNode.Token.Equals(iDefinedNodeToken))
{
SymTokenContainer defineName = levelNode.ChildTokens;
string flattened = defineName.CoalescedTokenValue;
// Get definition result
bool isDefined = aContext.DefineDirectory.IsDefined(flattened);
SymToken isDefinedToken = new SymToken(isDefined.ToString().ToLower(), SymToken.TClass.EClassAlphaNumeric, SymToken.TType.ETypeAlphaNumericNormal);
// Remove already added "defined" text node from output document
if (aDocument.CurrentNode.LastChild is SymNodeToken)
{
SymNodeToken last = (SymNodeToken)aDocument.CurrentNode.LastChild;
if (last.Token.Equals(iDefinedNodeToken))
{
last.Remove();
}
}
// Add result
aDocument.CurrentNode.Add(new SymNodeToken(isDefinedToken));
added = true;
}
}
if (added == false)
{
if (levelNode.HasPrevious && levelNode.Previous is SymTokenBalancerNodeEmittedElement)
{
levelNode.EmittedElementPrevious.AddToDocumentIfEmittable(aDocument);
}
SymNode newLevelNode = new SymNodeAddAsChild();
aDocument.CurrentNode.Add(newLevelNode);
aDocument.CurrentNode = newLevelNode;
EvaluateDefineNodes(n, aDocument, aContext);
aDocument.MakeParentCurrent();
if (levelNode.HasNext && levelNode.Next is SymTokenBalancerNodeEmittedElement)
{
levelNode.EmittedElementNext.AddToDocumentIfEmittable(aDocument);
}
}
}
else if (n is SymNodeToken)
{
SymNodeToken node = (SymNodeToken)n;
SymNodeToken copy = new SymNodeToken(node.Token);
aDocument.CurrentNode.Add(copy);
}
else if (n is SymTokenBalancerNodeEmittedElement)
{
// Handled when the level marker is reached
}
}
}
public SymPreProcessorDocument(SymParserDocumentContext aContext)
: base(aContext)
{
}
public SymBuildFileDocument(SymParserDocumentContext aContext)
: base(aContext)
{
}
public SymParserWorkerContext(SymParserDocumentContext aDocumentContext, SymParserWorker aParent, SymToken aCurrentToken)
: base(aDocumentContext)
{
iParent = aParent;
iCurrentToken = aCurrentToken;
}
public SymParserWorkerContext(SymParserDocumentContext aDocumentContext, SymParserWorker aParent)
: this(aDocumentContext, aParent, SymToken.NullToken())
{
}
public SymParserWorkerContext(SymParserDocumentContext aDocumentContext)
: base(aDocumentContext)
{
}
