public override IList <AltAST> GetUnlabeledAltASTs()
{
IList <AltAST> alts = new List <AltAST>();
foreach (LeftRecursiveRuleAltInfo altInfo in recPrimaryAlts)
{
if (altInfo.altLabel == null)
{
alts.Add(altInfo.originalAltAST);
}
}
for (int i = 0; i < recOpAlts.Count; i++)
{
LeftRecursiveRuleAltInfo altInfo = recOpAlts.GetElement(i);
if (altInfo.altLabel == null)
{
alts.Add(altInfo.originalAltAST);
}
}
if (alts.Count == 0)
{
return(null);
}
return(alts);
}
public AltAST(AltAST node)
: base(node)
{
this.alt = node.alt;
this.altLabel = node.altLabel;
this.leftRecursiveAltInfo = node.leftRecursiveAltInfo;
}
/** Get -> labels from those alts we deleted for left-recursive rules. */
public override IDictionary <string, IList <System.Tuple <int, AltAST> > > GetAltLabels()
{
IDictionary <string, IList <System.Tuple <int, AltAST> > > labels = new Dictionary <string, IList <System.Tuple <int, AltAST> > >();
IDictionary <string, IList <System.Tuple <int, AltAST> > > normalAltLabels = base.GetAltLabels();
if (normalAltLabels != null)
{
foreach (var pair in normalAltLabels)
{
labels[pair.Key] = pair.Value;
}
}
if (recPrimaryAlts != null)
{
foreach (LeftRecursiveRuleAltInfo altInfo in recPrimaryAlts)
{
if (altInfo.altLabel != null)
{
IList <System.Tuple <int, AltAST> > pairs;
if (!labels.TryGetValue(altInfo.altLabel, out pairs) || pairs == null)
{
pairs = new List <System.Tuple <int, AltAST> >();
labels[altInfo.altLabel] = pairs;
}
pairs.Add(Tuple.Create(altInfo.altNum, altInfo.originalAltAST));
}
}
}
if (recOpAlts != null)
{
for (int i = 0; i < recOpAlts.Count; i++)
{
LeftRecursiveRuleAltInfo altInfo = recOpAlts.GetElement(i);
if (altInfo.altLabel != null)
{
IList <System.Tuple <int, AltAST> > pairs;
if (!labels.TryGetValue(altInfo.altLabel, out pairs) || pairs == null)
{
pairs = new List <System.Tuple <int, AltAST> >();
labels[altInfo.altLabel] = pairs;
}
pairs.Add(Tuple.Create(altInfo.altNum, altInfo.originalAltAST));
}
}
}
if (labels.Count == 0)
{
return(null);
}
return(labels);
}
/** Return an array that maps predicted alt from primary decision
* to original alt of rule. For following rule, return [0, 2, 4]
*
* e : e '*' e
| INT
| e '+' e
| ID
| ;
|
* That maps predicted alt 1 to original alt 2 and predicted 2 to alt 4.
*
* @since 4.5.1
*/
public virtual int[] GetPrimaryAlts()
{
if (recPrimaryAlts.Count == 0)
{
return(null);
}
int[] alts = new int[recPrimaryAlts.Count + 1];
for (int i = 0; i < recPrimaryAlts.Count; i++)
{ // recPrimaryAlts is a List not Map like recOpAlts
LeftRecursiveRuleAltInfo altInfo = recPrimaryAlts[i];
alts[i + 1] = altInfo.altNum;
}
return(alts);
}
public virtual void BuildLeftRecursiveRuleFunction(LeftRecursiveRule r, LeftRecursiveRuleFunction function)
{
BuildNormalRuleFunction(r, function);
// now inject code to start alts
AbstractTarget target = @delegate.GetTarget();
TemplateGroup codegenTemplates = target.GetTemplates();
// pick out alt(s) for primaries
CodeBlockForOuterMostAlt outerAlt = (CodeBlockForOuterMostAlt)function.code[0];
IList <CodeBlockForAlt> primaryAltsCode = new List <CodeBlockForAlt>();
SrcOp primaryStuff = outerAlt.ops[0];
if (primaryStuff is Choice)
{
Choice primaryAltBlock = (Choice)primaryStuff;
foreach (var alt in primaryAltBlock.alts)
{
primaryAltsCode.Add(alt);
}
}
else
{ // just a single alt I guess; no block
primaryAltsCode.Add((CodeBlockForAlt)primaryStuff);
}
// pick out alt(s) for op alts
StarBlock opAltStarBlock = (StarBlock)outerAlt.ops[1];
CodeBlockForAlt altForOpAltBlock = opAltStarBlock.alts[0];
IList <CodeBlockForAlt> opAltsCode = new List <CodeBlockForAlt>();
SrcOp opStuff = altForOpAltBlock.ops[0];
if (opStuff is AltBlock)
{
AltBlock opAltBlock = (AltBlock)opStuff;
foreach (var alt in opAltBlock.alts)
{
opAltsCode.Add(alt);
}
}
else
{ // just a single alt I guess; no block
opAltsCode.Add((CodeBlockForAlt)opStuff);
}
// Insert code in front of each primary alt to create specialized context if there was a label
for (int i = 0; i < primaryAltsCode.Count; i++)
{
LeftRecursiveRuleAltInfo altInfo = r.recPrimaryAlts[i];
if (altInfo.altLabel == null)
{
continue;
}
Template altActionST = codegenTemplates.GetInstanceOf("recRuleReplaceContext");
altActionST.Add("ctxName", Utils.Capitalize(altInfo.altLabel));
AltLabelStructDecl ctx = null;
if (altInfo.altLabel != null)
{
function.altLabelCtxs.TryGetValue(altInfo.altLabel, out ctx);
}
Action altAction = new Action(@delegate, ctx, altActionST);
CodeBlockForAlt alt = primaryAltsCode[i];
alt.InsertOp(0, altAction);
}
// Insert code to set ctx.stop after primary block and before op * loop
Template setStopTokenAST = codegenTemplates.GetInstanceOf("recRuleSetStopToken");
Action setStopTokenAction = new Action(@delegate, function.ruleCtx, setStopTokenAST);
outerAlt.InsertOp(1, setStopTokenAction);
// Insert code to set _prevctx at start of * loop
Template setPrevCtx = codegenTemplates.GetInstanceOf("recRuleSetPrevCtx");
Action setPrevCtxAction = new Action(@delegate, function.ruleCtx, setPrevCtx);
opAltStarBlock.AddIterationOp(setPrevCtxAction);
// Insert code in front of each op alt to create specialized context if there was an alt label
for (int i = 0; i < opAltsCode.Count; i++)
{
Template altActionST;
LeftRecursiveRuleAltInfo altInfo = r.recOpAlts.GetElement(i);
string templateName;
if (altInfo.altLabel != null)
{
templateName = "recRuleLabeledAltStartAction";
altActionST = codegenTemplates.GetInstanceOf(templateName);
altActionST.Add("currentAltLabel", altInfo.altLabel);
}
else
{
templateName = "recRuleAltStartAction";
altActionST = codegenTemplates.GetInstanceOf(templateName);
altActionST.Add("ctxName", Utils.Capitalize(r.name));
}
altActionST.Add("ruleName", r.name);
// add label of any LR ref we deleted
altActionST.Add("label", altInfo.leftRecursiveRuleRefLabel);
if (altActionST.impl.FormalArguments.Any(x => x.Name == "isListLabel"))
{
altActionST.Add("isListLabel", altInfo.isListLabel);
}
else if (altInfo.isListLabel)
{
@delegate.GetGenerator().tool.errMgr.ToolError(ErrorType.CODE_TEMPLATE_ARG_ISSUE, templateName, "isListLabel");
}
AltLabelStructDecl ctx = null;
if (altInfo.altLabel != null)
{
function.altLabelCtxs.TryGetValue(altInfo.altLabel, out ctx);
}
Action altAction = new Action(@delegate, ctx, altActionST);
CodeBlockForAlt alt = opAltsCode[i];
alt.InsertOp(0, altAction);
}
}
