/// <summary>
/// COPY a ctx (I'm deliberately not using copy constructor) to avoid
/// confusion with creating node with parent.
/// </summary>
/// <remarks>
/// COPY a ctx (I'm deliberately not using copy constructor) to avoid
/// confusion with creating node with parent. Does not copy children.
/// </remarks>
public virtual void CopyFrom(Antlr4.Runtime.ParserRuleContext ctx)
{
this.parent = ctx.parent;
this.invokingState = ctx.invokingState;
this.start = ctx.start;
this.stop = ctx.stop;
}
public override void CopyFrom(Antlr4.Runtime.ParserRuleContext ctx)
{
base.CopyFrom(ctx);
if (ctx is ParserRuleContextWithDiagnostics)
{
this._diagnostics = ((ParserRuleContextWithDiagnostics)ctx)._diagnostics;
}
}
public void ExitEveryRule(Antlr4.Runtime.ParserRuleContext ctx)
{
Console.WriteLine("Exiting rule {0}", ctx);
if (Definitions.ContainsKey(ctx))
{
var definition = Definitions[ctx];
definition.Exit();
}
}
public override void CopyFrom(Antlr4.Runtime.ParserRuleContext ctx)
{
base.CopyFrom(ctx);
var diagnostics = ctx as ParserRuleContextWithDiagnostics;
if (diagnostics != null)
{
this._diagnostics = diagnostics._diagnostics;
}
}
private LLVMRegister VisitFunctionDeclarationBody
(
Antlr4.Runtime.ParserRuleContext context,
ClepsType clepsReturnType,
ClepsParser.FunctionParametersListContext parametersContext,
string functionName,
bool isStatic
)
{
string className = String.Join(".", CurrentNamespaceAndClass);
if (!ClassManager.DoesClassContainMember(className, functionName, isStatic))
{
//if the member was not found in the loaded member stage, then this is probably due to an earlier parsing error, just stop processing this member
return(null);
}
FunctionHierarchy.Add(functionName);
string fullyQualifiedName = String.Join(".", CurrentNamespaceAndClass.Union(FunctionHierarchy).ToList());
LLVMValueRef currFunc = LLVM.GetNamedFunction(Module, fullyQualifiedName);
LLVMBasicBlockRef basicBlock = LLVM.GetFirstBasicBlock(currFunc);
LLVM.PositionBuilderAtEnd(Builder, basicBlock);
VariableManager.AddBlock();
List <string> paramNames = parametersContext._FunctionParameterNames.Select(p => p.VariableName.Text).ToList();
List <ClepsType> clepsParameterTypes = parametersContext._FunctionParameterTypes.Select(t => ClepsType.GetBasicType(t)).ToList();
if (!isStatic)
{
ClepsType thisClassType = ClepsType.GetBasicType(className, 1);
paramNames.Insert(0, "this");
clepsParameterTypes.Insert(0, thisClassType);
}
List <LLVMValueRef> paramValueRegisters = currFunc.GetParams().ToList();
paramNames.Zip(clepsParameterTypes, (ParamName, ParamType) => new { ParamName, ParamType })
.Zip(paramValueRegisters, (ParamNameAndType, ParamRegister) => new { ParamNameAndType.ParamName, ParamNameAndType.ParamType, ParamRegister })
.ToList()
.ForEach(p => {
LLVMValueRef functionParamPtr = LLVM.BuildAlloca(Builder, LLVM.TypeOf(p.ParamRegister), p.ParamName);
LLVM.BuildStore(Builder, p.ParamRegister, functionParamPtr);
VariableManager.AddLocalVariable(p.ParamName, p.ParamType, functionParamPtr);
});
var ret = VisitChildren(context);
VariableManager.RemoveBlock();
FunctionHierarchy.RemoveAt(FunctionHierarchy.Count - 1);
return(ret);
}
private void AddGlobalsInlineDef(Antlr4.Runtime.ParserRuleContext ruleContext)
{
// CONSTANTS
var allConsts = ruleContext.GetRuleContexts <DaedalusParser.ConstDefContext>();
foreach (var c in allConsts)
{
foreach (var cv in c.constValueDef())
{
GlobalConsts.Add(new Constant
{
Column = cv.Start.Column,
Line = cv.Start.Line,
Name = cv.nameNode().GetText(),
Type = c.typeReference().GetText(),
Value = cv.constValueAssignment().expressionBlock().GetText(),
});
}
}
// VARIABLES
var allVarDecls = ruleContext.GetRuleContexts <DaedalusParser.VarDeclContext>();
foreach (var v in allVarDecls)
{
foreach (var vals in v.varValueDecl())
{
GlobalVars.Add(new Variable
{
Name = vals.nameNode().GetText(),
Type = v.typeReference().GetText(),
Line = vals.nameNode().Start.Line,
Column = vals.nameNode().Start.Column
});
}
foreach (var innerVarDecl in v.varDecl())
{
foreach (var vals in v.varValueDecl())
{
GlobalVars.Add(new Variable
{
Name = vals.nameNode().GetText(),
Type = v.typeReference().GetText(),
Line = vals.nameNode().Start.Line,
Column = vals.nameNode().Start.Column
});
}
}
}
}
/// <summary>
/// COPY a ctx (I'm deliberately not using copy constructor) to avoid
/// confusion with creating node with parent. Does not copy children.
///
/// This is used in the generated parser code to flip a generic XContext
/// node for rule X to a YContext for alt label Y. In that sense, it is
/// not really a generic copy function.
///
/// If we do an error sync() at start of a rule, we might add error nodes
/// to the generic XContext so this function must copy those nodes to
/// the YContext as well else they are lost!
/// </summary>
public virtual void CopyFrom(Antlr4.Runtime.ParserRuleContext ctx)
{
// from RuleContext
this.Parent = ctx.Parent;
this.invokingState = ctx.invokingState;
this._start = ctx._start;
this._stop = ctx._stop;
// copy any error nodes to alt label node
if (ctx.children != null)
{
children = new List <IParseTree>();
// reset parent pointer for any error nodes
foreach (var child in ctx.children)
{
var errorChildNode = child as ErrorNodeImpl;
if (errorChildNode != null)
{
children.Add(errorChildNode);
errorChildNode.Parent = this;
}
}
}
}
public virtual void ExitEveryRule(ParserRuleContext ctx)
{
_output.WriteLine("exit " + this._enclosing.RuleNames[ctx.RuleIndex] + ", LT(1)=" + this._enclosing._input.LT(1).Text);
}
public ParserRuleContext(Antlr4.Runtime.ParserRuleContext parent, int invokingStateNumber)
: base(parent, invokingStateNumber)
{
}
/// <inheritdoc/>
/// <remarks>The default implementation does nothing.</remarks>
public virtual void ExitEveryRule([NotNull] ParserRuleContext context)
{
}
public XSharpParserRuleContext(Antlr4.Runtime.ParserRuleContext parent, int state) : base(parent, state)
{
}
/// <summary>
/// Method that encapsulates how to get the coordenate of the node in the AST
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
private Coord GetCoord(Antlr4.Runtime.ParserRuleContext context)
{
return(new Coord(context.Start.Line, context.Start.Column));
//return new Coord(((dynamic)context).Depth(), ((dynamic)context).getAltNumber());
}
public SemanticException(Antlr4.Runtime.ParserRuleContext context, string message) : base(message)
{
Context = context;
}
public override void ExitEveryRule(ParserRuleContext context)
{
Logger.writeLog("{end rule: " + this.parser.RuleNames[context.RuleIndex] + " : " + context.Start.Text + "}\n");
}
public virtual void EnterRecursionRule(ParserRuleContext localctx, int ruleIndex)
{
EnterRecursionRule(localctx, Atn.ruleToStartState[ruleIndex].stateNumber, ruleIndex, 0);
}
private void AddGlobalsBlockDef(Antlr4.Runtime.ParserRuleContext ruleContext)
{
// Classes
var allClassDefs = ruleContext.GetRuleContexts <DaedalusParser.ClassDefContext>();
foreach (var cd in allClassDefs)
{
var classVars = new List <Variable>();
var allVarDecls = cd.varDecl();
if (allVarDecls != null)
{
foreach (var v in allVarDecls)
{
foreach (var vals in v.varValueDecl())
{
classVars.Add(new Variable
{
Name = vals.nameNode().GetText(),
Type = v.typeReference().GetText(),
Line = vals.nameNode().Start.Line,
Column = vals.nameNode().Start.Column
});
}
}
}
GlobalClasses.Add(new Class
{
Fields = classVars,
Name = cd.nameNode().GetText(),
Line = cd.nameNode().Start.Line,
Column = cd.nameNode().Start.Column,
});
}
// Prototypes
var allPrototypeDefs = ruleContext.GetRuleContexts <DaedalusParser.PrototypeDefContext>();
foreach (var pd in allPrototypeDefs)
{
GlobalPrototypes.Add(new Prototype
{
Name = pd.nameNode().GetText(),
Column = pd.nameNode().Start.Column,
Line = pd.nameNode().Start.Line,
Parent = pd.parentReference().Identifier().GetText(),
});
}
// INSTANCES
var allInsts = ruleContext.GetRuleContexts <DaedalusParser.InstanceDefContext>();
foreach (var inst in allInsts)
{
GlobalInstances.Add(new Instance
{
Column = inst.nameNode().Start.Column,
Line = inst.nameNode().Start.Line,
Name = inst.nameNode().GetText(),
Parent = inst.parentReference().GetText(),
});
}
}
public virtual void ExitEveryRule(ParserRuleContext ctx)
{
System.Console.Out.WriteLine("exit " + this._enclosing.RuleNames[ctx.GetRuleIndex
()] + ", LT(1)=" + this._enclosing._input.Lt(1).Text);
}
public RecognitionException(string message, IRecognizer recognizer, IIntStream input, ParserRuleContext ctx)
: base(message)
{
this.recognizer = recognizer;
this.input = input;
this.ctx = ctx;
if (recognizer != null)
{
this.offendingState = recognizer.State;
}
}
public virtual void EnterEveryRule(ParserRuleContext ctx)
{
}
