public SymPreProcessorWorkerEndif(SymParserWorkerContext aContext)
: base(aContext)
{
// When the endif token is reached, we must work back up the tree
// looking for the previous (i.e. most recent) conditional expression
// node.
SymNodeConditionalExpression condExpNode = SymParserWorkerConditionalExpression.FindMostRecentConditionalExpression(aContext.Document.CurrentNode);
if (condExpNode == null)
{
throw new Exception("Unable to locate most recent condition expression during ENDIF handling");
}
// There must always be a positive condition node and some kind of condition
if (condExpNode.ChildTypeExists(typeof(SymNodeCondition)) == false)
{
throw new Exception("No child condition node found during ENDIF handling");
}
// We change the current node to be the parent of the conditional expression.
// Any new tokens will appear as siblings
aContext.Document.CurrentNode = condExpNode.Parent;
// Make sure we tell the parser that it can pop off this conditional expression node.
SymPreProcessorParser parser = (SymPreProcessorParser)aContext.Parser;
SymNodeConditionalExpression poppedExpression = parser.ConditionalExpressionPop();
System.Diagnostics.Debug.Assert(poppedExpression == condExpNode);
// Job done - dequeue
RemoveSelf();
}
private SymParserWorker CreateWorkerByTokenType(SymToken aToken)
{
// Find a worker to handle the token type
SymParserWorkerContext context = new SymParserWorkerContext(WorkerContext.Document.Context, this, aToken);
//
SymParserWorker worker = null;
switch (aToken.Value.ToLower())
{
// Simple preprocessor operations
case "prj_platforms":
break;
case "prj_exports":
break;
case "prj_testexports":
break;
case "prj_mmpfiles":
break;
case "prj_testmmpfiles":
break;
// Skip unhandled preprocessor directives
default:
break;
}
//
return(worker);
}
public SymPreProcessorWorkerElseIf(SymParserWorkerContext aContext)
: base(aContext)
{
// When the else token is reached, we must work back up the tree
// looking for the previous (i.e. most recent) conditional expression
// node.
SymNodeConditionalExpression condExpNode = SymParserWorkerConditionalExpression.FindMostRecentConditionalExpression(aContext.Document.CurrentNode);
if (condExpNode == null)
{
throw new Exception("Unable to locate most recent condition expression during ELSE IF handling");
}
// There must always be a positive condition node and some kind of condition
if (condExpNode.ChildTypeExists(typeof(SymNodeCondition)) == false)
{
throw new Exception("No child condition node found during ELSE IF handling");
}
// Make the conditional expression the current node
aContext.Document.CurrentNode = condExpNode;
// Make a new condition worker. The condition worker creates a new condition node
// which becomes the new current node.
SymParserWorkerContext context = new SymParserWorkerContext(aContext.Document.Context, this);
SymParserWorkerCondition conditionWorker = new SymParserWorkerCondition(context, new SymNodePreProcessorCondition(aContext.CurrentToken.Value));
AddChild(conditionWorker);
}
public SymPreProcessorWorkerInclude(SymParserWorkerContext aContext)
: base(aContext, SymToken.TClass.EClassNewLine, SymParserWorkerConsumer.TDyingAction.EWhenDyingMakeAbsoluteParentNodeCurrent)
{
// Make a new child node for the include
iIncludeNode = new SymNodePreProcessorInclude();
aContext.Document.CurrentNode.Add(iIncludeNode);
aContext.Document.CurrentNode = iIncludeNode;
}
protected override void PrepareInitialWorkers()
{
SymParserWorkerContext context = new SymParserWorkerContext(Document.Context);
SymWorkerBuildFileMain mainWorker = new SymWorkerBuildFileMain(context);
//
QueueWorker(mainWorker);
// Make a base call
base.PrepareInitialWorkers();
}
public SymPreProcessorWorkerIfndef(SymParserWorkerContext aContext)
: base(aContext)
{
// The base class will make a new conditional expression node at the current document position.
// It will change the parent node to be this new node. We must make a new condition worker
// that will handle reading the condition arguments.
SymParserWorkerContext context = new SymParserWorkerContext(WorkerContext.Document.Context, this);
SymParserWorkerCondition conditionWorker = new SymParserWorkerCondition(context, new SymNodePreProcessorCondition(aContext.CurrentToken.Value));
AddChild(conditionWorker);
}
public SymPreProcessorWorkerConditionalExpression(SymParserWorkerContext aContext)
: base(aContext)
{
System.Diagnostics.Debug.Assert(aContext.Document.CurrentNode is SymNodeConditionalExpression);
// Inform the parser about the conditional expression node. It will use this
// as a means of identifying whether to skip tokens until a positive branch is identified.
SymPreProcessorParser parser = (SymPreProcessorParser)aContext.Parser;
parser.ConditionalExpressionPush(aContext.Document.CurrentNode as SymNodeConditionalExpression);
}
private SymParserWorker CreateWorkerByTokenType(SymToken aToken)
{
// Find a worker to handle the token type
SymParserWorker worker = null;
SymParserWorkerContext context = new SymParserWorkerContext(WorkerContext, this, aToken);
//
switch (aToken.Value)
{
// Simple preprocessor operations
case "define":
worker = new SymPreProcessorWorkerDefine(context);
break;
case "undef":
break;
case "include":
worker = new SymPreProcessorWorkerInclude(context);
break;
// Conditionality
case "if":
worker = new SymPreProcessorWorkerIf(context);
break;
case "ifdef":
worker = new SymPreProcessorWorkerIfdef(context);
break;
case "ifndef":
worker = new SymPreProcessorWorkerIfndef(context);
break;
case "else":
worker = new SymPreProcessorWorkerElse(context);
break;
case "elif":
worker = new SymPreProcessorWorkerElseIf(context);
break;
case "endif":
worker = new SymPreProcessorWorkerEndif(context);
break;
// Skip unhandled preprocessor directives
default:
worker = new SymParserWorkerConsumer(context, SymToken.TClass.EClassNewLine);
break;
}
//
return(worker);
}
protected override void PrepareInitialWorkers()
{
SymParserWorkerContext context = new SymParserWorkerContext(Document.Context);
iMainWorker = new SymPreProcessorWorker(context);
//
QueueWorker(iMainWorker);
// Make a base call
base.PrepareInitialWorkers();
}
public SymPreProcessorWorkerDefine(SymParserWorkerContext aContext)
: base(aContext, SymToken.TClass.EClassNewLine)
{
iFunctionParser.RegisterFunctionParserTokens();
// Set up event handlers
iFunctionParser.EventArgumentAvailableHandler += new SymBuildParsingLib.Parser.Framework.Utils.SymFunctionParser.ArgumentAvailable(FunctionParserEventArgumentAvailableHandler);
iFunctionParser.EventLevelStarted += new SymBuildParsingLib.Token.SymTokenBalancer.LevelChangeEventHandler(TokenBalancerEventLevelStarted);
iFunctionParser.EventLevelFinished += new SymBuildParsingLib.Token.SymTokenBalancer.LevelChangeEventHandler(TokenBalancerEventLevelFinished);
iFunctionParser.EventLevelsBalanced += new SymBuildParsingLib.Token.SymTokenBalancer.LevelsBalancedEventHandler(TokenBalancerEventLevelsBalanced);
iFunctionParser.EventLevelsImbalanced += new SymBuildParsingLib.Token.SymTokenBalancer.LevelsImbalancedEventHandler(TokenBalancerEventLevelsImbalanced);
}
public SymWorkerBuildFileMain(SymParserWorkerContext aContext)
: base(aContext)
{
}
public SymWorkerBuildFilePlatforms(SymParserWorkerContext aContext)
: base(aContext, SymToken.TClass.EClassNewLine)
{
}
public SymPreProcessorWorker(SymParserWorkerContext aContext)
: base(aContext, 1000)
{
}
