private ClassSyntax BuildMethod_GetParserAction(ClassSyntax context)
{
var generator = new ReadOnlyTableGenerator(
data.ParserActionTable,
il => il.Ldarg(0),
il => il.Ldarg(1));
var args = context.Method()
.Private.Static
.Returning(context.Types.Int32)
.Named(GetParserActionMethodName)
.BeginArgs();
return(args
.Argument(context.Types.Int32, args.Args.Generate())
.Argument(context.Types.Int32, args.Args.Generate())
.EndArgs()
.NoOptimization
.BeginBody()
.Do(generator.Build)
.Ret()
.EndBody());
}
public void ClassSyntax_GetInheritance_WhenFlagsNotSet_ShouldReturnDefault()
{
TypeDef typeDef = new TypeDef();
ClassSyntax syntax = new ClassSyntax(typeDef);
Assert.AreEqual(Inheritance.Default, syntax.GetInheritance());
}
/// <summary>
/// Foramts the class base portion of a class decleration.
/// </summary>
/// <param name="syntax">The syntax details for the class.</param>
/// <returns>The string representing the class base.</returns>
public List <SyntaxToken> FormatClassBase(ClassSyntax syntax)
{
List <SyntaxToken> tokens = new List <SyntaxToken>();
bool hasBaseType = false;
// Create the list of types and interfaces
List <SyntaxToken> baseTypesAndInterfaces = new List <SyntaxToken>();
if (syntax.Class.InheritsFrom != null && syntax.Class.InheritsFrom.GetFullyQualifiedName() != "System.Object")
{
tokens.Add(new SyntaxToken(" : ", SyntaxTokens.Text));
tokens.AddRange(FormatTypeDetails(syntax.GetBaseClass()));
hasBaseType = true;
}
Signatures.TypeDetails[] details = syntax.GetInterfaces();
for (int i = 0; i < details.Length; i++)
{
if (!hasBaseType && i == 0)
{
tokens.Add(new SyntaxToken(": ", SyntaxTokens.Text));
}
else if (hasBaseType && i == 0 || i != 0)
{
tokens.Add(new SyntaxToken($",\n\t", SyntaxTokens.Text));
}
tokens.AddRange(FormatTypeDetails(details[i]));
}
return(tokens);
}
private ClassSyntax BuildMethod_CreateStateToSymbol(ClassSyntax context)
{
var emit = context
.Method()
.Private.Static
.Returning(context.Types.Import(typeof(int[])))
.Named(CreateStateToSymbolMethodName)
.BeginArgs()
.EndArgs()
.BeginBody();
var resultLoc = emit.Locals.Generate().GetRef();
var stateToSymbol = data.StateToToken;
emit = emit
.Local(resultLoc.Def, context.Types.Import(typeof(int[])))
.Ldc_I4(stateToSymbol.Length)
.Newarr(context.Types.Import(typeof(int)))
.Stloc(resultLoc);
for (int i = 0; i != stateToSymbol.Length; ++i)
{
emit = emit
.Ldloc(resultLoc)
.Ldc_I4(i)
.Ldc_I4(stateToSymbol[i])
.Stelem_I4();
}
return(emit
.Ldloc(resultLoc)
.Ret()
.EndBody());
}
public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data)
{
var args = context.Method()
.Static
.Returning(context.Types.Object)
.Named(methodName)
.BeginArgs();
Def <Args> tokenId = args.Args.Generate("token");
Def <Args> oldValue = args.Args.Generate("oldValue");
Def <Args> newValue = args.Args.Generate("newValue");
Def <Args> ctx = args.Args.Generate("rootContext");
Def <Args> stackLookback = args.Args.Generate("startLookback");
var emit = args
.Argument(context.Types.Int32, tokenId)
.Argument(context.Types.Object, oldValue)
.Argument(context.Types.Object, newValue)
.Argument(context.Types.Object, ctx)
.Argument(context.Types.Import(typeof(IStackLookback <Msg>)), stackLookback)
.EndArgs()
.BeginBody();
BuildBody(
emit,
data,
tokenId.GetRef(),
oldValue.GetRef(),
newValue.GetRef(),
ctx.GetRef(),
stackLookback.GetRef());
return(emit.EndBody());
}
private ClassSyntax BuildMethod_TermFactory(ClassSyntax context)
{
var args = context
.Method()
.Static
.Returning(context.Types.Int32)
.Named(TermFactoryMethodName)
.BeginArgs();
var cursorArg = args.Args.Generate("cursor");
var tokenArg = args.Args.Generate("token");
var emit = args
.Argument(context.Types.Import(typeof(ScanCursor)), cursorArg) // ruleId
.Out.Argument(context.Types.Import(typeof(object).MakeByRefType()), tokenArg)
.EndArgs()
.BeginBody();
var generator = new TermFactoryGenerator(data, declaringTypeRef);
generator.Build(
emit,
il => il.Ldarg(cursorArg.GetRef()),
il => il.Ldarg(tokenArg.GetRef()));
return(emit.EndBody());
}
/// <summary>
/// Formats the provided <paramref name="syntax"/> instance based on a
/// c# class decleration.
/// </summary>
/// <param name="syntax">The syntax for format.</param>
/// <returns>A fully formatted c# class decleration.</returns>
public SyntaxTokenCollection Format(ClassSyntax syntax)
{
SyntaxTokenCollection tokens = new SyntaxTokenCollection();
SyntaxToken inheritanceModifier = FormatInheritance(syntax);
tokens.AddRange(FormatVisibility(syntax));
if (inheritanceModifier != null)
{
tokens.Add(Constants.Space);
tokens.Add(inheritanceModifier);
}
tokens.Add(Constants.Space);
tokens.Add(Constants.KeywordClass);
tokens.Add(Constants.Space);
tokens.Add(new SyntaxToken(syntax.GetIdentifier(), SyntaxTokens.Text));
if (_syntax.Class.IsGeneric)
{
List <GenericTypeRef> genericTypes = _syntax.GetGenericParameters();
tokens.AddRange(FormatGenericParameters(genericTypes));
}
tokens.AddRange(FormatClassBase(syntax));
return(tokens);
}
private ClassSyntax BuildMethod_MergeAction(ClassSyntax context)
{
var generator = new MergeActionGenerator();
generator.BuildMethod(context, MergeActionMethodName, data);
return(context);
}
public ClassDeclaration(ClassSyntax syntax)
: base(syntax.Name.ValueText)
{
Syntax = new List <ClassSyntax>(1)
{
syntax
};
}
public void ClassSyntax_GetInheritance_WhenFlagsAbstract_ShouldReturnAbstract()
{
TypeDef typeDef = new TypeDef();
ClassSyntax syntax = new ClassSyntax(typeDef);
typeDef.Flags = Reflection.Core.COFF.TypeAttributes.Abstract;
Assert.AreEqual(Inheritance.Abstract, syntax.GetInheritance());
}
public void ClassSyntax_GetInheritance_WhenFlagsSealed_ShouldReturnSealed()
{
TypeDef typeDef = new TypeDef();
ClassSyntax syntax = new ClassSyntax(typeDef);
typeDef.Flags = Reflection.Core.COFF.TypeAttributes.Sealed;
Assert.AreEqual(Inheritance.Sealed, syntax.GetInheritance());
}
public BoundType(string name, ClassSyntax syntax)
: base(syntax)
{
Name = name;
Type = new TypeCompilerGeneratedType();
FieldsInternal = new List<BoundField>();
ConstructorsInternal = new List<BoundConstructor>();
FunctionsInternal = new List<BoundFunction>();
}
public void ClassSyntax_GetIdentifier(string name, bool isGeneric, string expectedResult)
{
TypeDef typeDef = new TypeDef();
ClassSyntax syntax = new ClassSyntax(typeDef);
typeDef.IsGeneric = isGeneric;
typeDef.Name = name;
string result = syntax.GetIdentifier();
Assert.AreEqual(expectedResult, result);
}
public void ClassSyntax_GetInterfaces_WhenTypeImplementsNothing_ShouldReturnNoEntries()
{
TypeDef typeDef = new TypeDef();
ClassSyntax syntax = new ClassSyntax(typeDef);
typeDef.Implements = new System.Collections.Generic.List <TypeRef>();
Array result = syntax.GetInterfaces();
Assert.IsNotNull(result);
Assert.AreEqual(0, result.Length);
}
public virtual void Visit(ClassSyntax classSyntax)
{
foreach (var fieldSyntax in classSyntax.Fields)
{
Visit(fieldSyntax);
}
foreach (var constructorSyntax in classSyntax.Constructors)
{
Visit(constructorSyntax);
}
foreach (var functionSyntax in classSyntax.Functions)
{
Visit(functionSyntax);
}
}
private ClassSyntax BuildMethod_CreateTokenIdentities(ClassSyntax context)
{
var generator = new TokenIdentitiesSerializer(data.Grammar);
return(context
.Method().Private.Static
.Returning(context.Types.Import(LanguageBase.Fields.tokenKeyToId.FieldType))
.Named(CreateTokenKeyToIdMethodName)
.BeginArgs()
.EndArgs()
.BeginBody()
.Do(generator.Build)
.Ret()
.EndBody());
}
private ClassSyntax BuildMethod_CreateDefaultContext(ClassSyntax context)
{
return(context
.Method()
.Private.Static
.Returning(context.Types.Object)
.Named(CreateDefaultContextMethodName)
.BeginArgs()
.EndArgs()
.BeginBody()
// Plan implementation of abstraction as needed
.Do(il => implementationGenerator
.EmitFactoryCode(il, languageName.DefinitionType))
.Ret()
.EndBody());
}
private ClassSyntax BuildMethod_CreateGrammar(ClassSyntax context)
{
var grammarSerializer = new GrammarSerializer(data.Grammar);
return(context
.Method()
.Private.Static
.Returning(context.Types.Import(typeof(Grammar)))
.Named(CreateGrammarMethodName)
.BeginArgs()
.EndArgs()
.BeginBody()
.Do(grammarSerializer.Build)
.Ret()
.EndBody());
}
private ClassSyntax BuildMethod_Scan1(ClassSyntax context)
{
logging.Write(
new LogEntry
{
Severity = Severity.Verbose,
Message = string.Format("Started compiling Scan1 modes for {0} language", languageName.LanguageName)
});
foreach (var condition in data.Grammar.Conditions)
{
ITdfaData dfa = condition.Joint.The <ITdfaData>();
var dfaSerialization = new DfaSerialization(dfa);
var generator = new ScannerGenerator(dfaSerialization);
var methodName = ConditionMethods.GetMethodName(condition.Index);
var args = context
.Method()
.Static
.Returning(context.Types.Int32)
.Named(methodName)
.BeginArgs();
var emit = args
.Argument(
context.Types.Import(typeof(ScanCursor)),
args.Args.Generate("cursor")) // input
.EndArgs()
.NoInlining
.NoOptimization
.BeginBody();
generator.Build(emit);
context = emit.EndBody();
}
logging.Write(
new LogEntry
{
Severity = Severity.Verbose,
Message = string.Format("Done compiling Scan1 modes for {0} language", languageName.LanguageName)
});
return(context);
}
public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data)
{
var args = context.Method()
.Static
.Returning(context.Types.Object)
.Named(methodName)
.BeginArgs();
Def <Args> ruleId = args.Args.Generate("ruleId");
Def <Args> ruleArgs = args.Args.Generate("ruleArgs");
Def <Args> argsStart = args.Args.Generate("argsStart");
Def <Args> ctx = args.Args.Generate("rootContext");
Def <Args> stackLookback = args.Args.Generate("startLookback");
var emit = args
.Argument(context.Types.Int32, ruleId)
.Argument(context.Types.Import(typeof(Msg[])), ruleArgs)
.Argument(context.Types.Int32, argsStart)
.Argument(context.Types.Object, ctx)
.Argument(context.Types.Import(typeof(IStackLookback <Msg>)), stackLookback)
.EndArgs()
.BeginBody();
ruleId.Name = "ruleId";
ruleArgs.Name = "args";
argsStart.Name = "argsStart";
ctx.Name = "ctx";
stackLookback.Name = "stackLookback";
BuildBody(
emit,
data,
ruleId.GetRef(),
ruleArgs.GetRef(),
argsStart.GetRef(),
ctx.GetRef(),
stackLookback.GetRef());
return(emit.EndBody());
}
public void ClassSyntax_GetInterfaces_WhenTypeImplementsNonTypeSpecEntries_ShouldReturnEntries()
{
TypeDef typeDef = new TypeDef();
ClassSyntax syntax = new ClassSyntax(typeDef);
typeDef.Implements = new System.Collections.Generic.List <TypeRef>()
{
new TypeRef {
Name = "First"
},
new TypeRef {
Name = "Second"
}
};
// cant test this with typespec entries yet as there is an internal load which requires us to be
// able to set private variables.
Array result = syntax.GetInterfaces();
Assert.AreEqual(2, result.Length);
}
public List <SyntaxToken> FormatClassBase(ClassSyntax syntax)
{
List <SyntaxToken> tokens = new List <SyntaxToken>();
bool hasBaseType = false;
// Create the list of types and interfaces
if (syntax.Class.InheritsFrom != null && syntax.Class.InheritsFrom.GetFullyQualifiedName() != "System.Object")
{
hasBaseType = true;
}
if (hasBaseType)
{
tokens.Add(new SyntaxToken("Derives", SyntaxTokens.Keyword));
tokens.Add(Constants.Space);
tokens.AddRange(FormatTypeDetails(syntax.GetBaseClass()));
}
Signatures.TypeDetails[] interfaces = syntax.GetInterfaces();
for (int i = 0; i < interfaces.Length; i++)
{
if (i == 0)
{
tokens.Add(new SyntaxToken(" _\n\t", SyntaxTokens.Text));
tokens.Add(new SyntaxToken("Implements", SyntaxTokens.Keyword));
tokens.Add(Constants.Space);
}
else if (hasBaseType && i == 0 || i != 0)
{
tokens.Add(new SyntaxToken(", _\n\t\t", SyntaxTokens.Text));
}
tokens.AddRange(FormatTypeDetails(interfaces[i]));
}
return(tokens);
}
private ClassSyntax BuildMethod_CreateParserActionConflicts(ClassSyntax context)
{
var emit = context
.Method()
.Private.Static
.Returning(context.Types.Import(typeof(int[])))
.Named(CreateParserActionConflictsMethodName)
.BeginArgs()
.EndArgs()
.BeginBody();
var resultLoc = emit.Locals.Generate().GetRef();
var itemLoc = emit.Locals.Generate().GetRef();
var conflicts = data.ParserConflictActionTable;
emit = emit
.Local(resultLoc.Def, emit.Types.Import(typeof(int[])))
.Ldc_I4(conflicts.Length)
.Newarr(emit.Types.Import(typeof(int)))
.Stloc(resultLoc)
;
for (int i = 0; i != conflicts.Length; ++i)
{
emit
.Ldloc(resultLoc)
.Ldc_I4(i)
.Ldc_I4(conflicts[i])
.Stelem_I4();
}
return(emit
.Ldloc(resultLoc)
.Ret()
.EndBody());
}
private ClassSyntax BuildMethod_CreateTokenComplexityTable(ClassSyntax context)
{
var emit = context
.Method()
.Private.Static
.Returning(context.Types.Import(typeof(int[])))
.Named(CreateTokenComplexityTableMethodName)
.BeginArgs()
.EndArgs()
.BeginBody();
var resultLoc = emit.Locals.Generate().GetRef();
var itemLoc = emit.Locals.Generate().GetRef();
var table = data.TokenComplexity;
emit = emit
.Local(resultLoc.Def, emit.Types.Import(typeof(int[])))
.Ldc_I4(table.Length)
.Newarr(emit.Types.Import(typeof(int)))
.Stloc(resultLoc)
;
for (int i = 0; i != table.Length; ++i)
{
emit
.Ldloc(resultLoc)
.Ldc_I4(i)
.Ldc_I4(table[i])
.Stelem_I4();
}
return(emit
.Ldloc(resultLoc)
.Ret()
.EndBody());
}
private CilDocumentSyntax GenerateImpl(PlannedClass entry, CilDocumentSyntax cil)
{
ClassExtendsSyntax wantBaseClass =
cil.Class_()
.Public
.Named(entry.ClassName)
;
var baseClassRef = cil.Types.Import(entry.BaseClass);
ClassImplementsSyntax wantContract =
wantBaseClass
.Extends(baseClassRef);
var baseCtor = entry.BaseClass.GetConstructor(Type.EmptyTypes);
Ref <Methods> baseCtorRef;
if (baseCtor != null)
{
baseCtorRef = cil.Methods.Import(baseCtor);
}
else
{
baseCtorRef = null;
}
foreach (Type c in entry.Contracts)
{
wantContract = wantContract.Implements(cil.Types.Import(c));
}
ClassSyntax classCode = wantContract;
classCode = classCode
.Method()
.Public.Instance
.Returning(classCode.Types.Void)
.Named(".ctor")
.BeginArgs().EndArgs()
.BeginBody()
.Do(il =>
{
if (baseCtorRef != null)
{
il = il
.Ldarg(0)
.Callvirt(baseCtorRef);
}
return(il);
})
.Ret()
.EndBody()
;
foreach (var method in entry.Methods)
{
WantArgsBase wantArgs =
classCode.Method()
.Private.Hidebysig.Newslot
.Virtual.Final.Instance
.Returning(classCode.Types.Import(method.ReturnType))
.Named(method.DeclaringType + "." + method.Name)
.BeginArgs();
foreach (var parameter in method.GetParameters())
{
wantArgs = wantArgs.Argument(
classCode.Types.Import(parameter.ParameterType),
wantArgs.Args.Generate(parameter.Name));
}
var emit = wantArgs.EndArgs().BeginBody();
emit = emit.Override(emit.Methods.Import(method));
emit = EmitFactoryCode(
emit,
entry,
method.ReturnType,
!forceNonNullResult(method));
classCode = emit.Ret().EndBody();
}
return(classCode.EndClass());
}
public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data)
{
var args = context.Method()
.Static
.Returning(context.Types.Object)
.Named(methodName)
.BeginArgs();
Def<Args> tokenId = args.Args.Generate("token");
Def<Args> oldValue = args.Args.Generate("oldValue");
Def<Args> newValue = args.Args.Generate("newValue");
Def<Args> ctx = args.Args.Generate("rootContext");
Def<Args> stackLookback = args.Args.Generate("startLookback");
var emit = args
.Argument(context.Types.Int32, tokenId)
.Argument(context.Types.Object, oldValue)
.Argument(context.Types.Object, newValue)
.Argument(context.Types.Object, ctx)
.Argument(context.Types.Import(typeof(IStackLookback<Msg>)), stackLookback)
.EndArgs()
.BeginBody();
BuildBody(
emit,
data,
tokenId.GetRef(),
oldValue.GetRef(),
newValue.GetRef(),
ctx.GetRef(),
stackLookback.GetRef());
return emit.EndBody();
}
public VBClassFormatter(ClassSyntax syntax)
{
_syntax = syntax;
}
private ClassSyntax Build_Ctor(ClassSyntax context)
{
var emit = context
.Method()
.Public.Instance
.Returning(context.Types.Void)
.Named(".ctor")
.BeginArgs()
.Do(args =>
{
var type = context.Types.Import(typeof(CilGrammarSource));
var arg = args.Args.Generate();
args.Argument(type, arg);
return(args);
})
.EndArgs()
.BeginBody();
// Call base constructor:
// this:
emit = emit
.Ldarg(0) // this
.Ldarg(1) // LanguageName
.Call(emit.Methods.Import(typeof(LanguageBase).GetConstructor(new[] { typeof(CilGrammarSource) })))
;
emit
.Ldarg(0)
.Ldc_I4(data.IsDeterministic ? 1 : 0)
.Stfld(LanguageBase.Fields.isDeterministic);
return(emit
// Init grammar
.Ldarg(0)
.Call(emit.Methods.Method(
_ => _
.StartSignature
.Returning(emit.Types.Import(typeof(Grammar)))
.DecaringType(declaringTypeRef)
.Named(CreateGrammarMethodName)
.BeginArgs()
.EndArgs()
))
.Stfld(LanguageBase.Fields.grammar)
// Init state->token table
.Ldarg(0)
.Call(emit.Methods.Method(
_ => _
.StartSignature
.Returning(emit.Types.Import(typeof(int[])))
.DecaringType(declaringTypeRef)
.Named(CreateStateToSymbolMethodName)
.BeginArgs()
.EndArgs()
))
.Stfld(LanguageBase.Fields.stateToSymbol)
// Init parser action conflicts table
.Ldarg(0)
.Call(emit.Methods.Method(
_ => _
.StartSignature
.Returning(emit.Types.Import(typeof(int[])))
.DecaringType(declaringTypeRef)
.Named(CreateParserActionConflictsMethodName)
.BeginArgs()
.EndArgs()
))
.Stfld(LanguageBase.Fields.parserConflictActions)
// Init token complexity table
.Ldarg(0)
.Call(emit.Methods.Method(
_ => _
.StartSignature
.Returning(emit.Types.Import(typeof(int[])))
.DecaringType(declaringTypeRef)
.Named(CreateTokenComplexityTableMethodName)
.BeginArgs()
.EndArgs()
))
.Stfld(LanguageBase.Fields.tokenComplexity)
// Init grammarAction field
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
RuleActionMethodName,
typeof(ProductionActionDelegate))
.Stfld(LanguageBase.Fields.grammarAction)
// Init grammarAction field
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
MergeActionMethodName,
typeof(MergeDelegate))
.Stfld(LanguageBase.Fields.merge)
// Init tokenIdentities
.Ldarg(0)
.Call(emit
.Methods.Method(
_ => _
.StartSignature
.Returning(emit.Types.Import(LanguageBase.Fields.tokenKeyToId.FieldType))
.DecaringType(declaringTypeRef)
.Named(CreateTokenKeyToIdMethodName)
.BeginArgs()
.EndArgs()))
.Stfld(LanguageBase.Fields.tokenKeyToId)
// Init scan field
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
ConditionMethods.GetMethodName(0),
typeof(Scan1Delegate))
.Stfld(LanguageBase.Fields.scan1)
// Init termFactory field
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
TermFactoryMethodName,
typeof(ScanActionDelegate))
.Stfld(LanguageBase.Fields.termFactory)
// Init getParserAction field
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
GetParserActionMethodName,
typeof(TransitionDelegate))
.Stfld(LanguageBase.Fields.getParserAction)
// Init defaul context factory
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
CreateDefaultContextMethodName,
typeof(Func <object>))
.Stfld(LanguageBase.Fields.createDefaultContext)
.Ret()
.EndBody());
}
public CSharpClassFormatter(ClassSyntax syntax)
{
_syntax = syntax;
}
/// <summary>
/// Foramts the visibility modifier for a c# class.
/// </summary>
/// <param name="syntax">The syntax to format.</param>
/// <returns>A formatted string representing the syntax of the class.</returns>
/// <remarks>
/// The visibility of a class is part of the modifiers section of the
/// decleration. The modifiers are defined as:
/// </remarks>
public List <SyntaxToken> FormatVisibility(ClassSyntax syntax)
{
return(FormatVisibility(syntax.GetVisibility()));
}
/// <summary>
/// Formats the inheritance modifier for a c# class.
/// </summary>
/// <param name="syntax">The syntax to format.</param>
/// <returns>The formatted string representing the syntax of the class.</returns>
/// <remarks>
/// The inheritance of a class is part of the modifiers section of the
/// decleration. The modifiers are defined as:
/// </remarks>
public SyntaxToken FormatInheritance(ClassSyntax syntax)
{
return(FormatInheritance(syntax.GetInheritance()));
}
public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data)
{
var args = context.Method()
.Static
.Returning(context.Types.Object)
.Named(methodName)
.BeginArgs();
Def<Args> ruleId = args.Args.Generate("ruleId");
Def<Args> ruleArgs = args.Args.Generate("ruleArgs");
Def<Args> argsStart = args.Args.Generate("argsStart");
Def<Args> ctx = args.Args.Generate("rootContext");
Def<Args> stackLookback = args.Args.Generate("startLookback");
var emit = args
.Argument(context.Types.Int32, ruleId)
.Argument(context.Types.Import(typeof(Msg[])), ruleArgs)
.Argument(context.Types.Int32, argsStart)
.Argument(context.Types.Object, ctx)
.Argument(context.Types.Import(typeof(IStackLookback<Msg>)), stackLookback)
.EndArgs()
.BeginBody();
ruleId.Name = "ruleId";
ruleArgs.Name = "args";
argsStart.Name = "argsStart";
ctx.Name = "ctx";
stackLookback.Name = "stackLookback";
BuildBody(
emit,
data,
ruleId.GetRef(),
ruleArgs.GetRef(),
argsStart.GetRef(),
ctx.GetRef(),
stackLookback.GetRef());
return emit.EndBody();
}
public ClassBinder(Binder containingScope, ClassSyntax @class)
: base(containingScope)
{
}
private ClassSyntax BuildMethod_GrammarAction(ClassSyntax context)
{
var generator = new ProductionActionGenerator();
return(generator.BuildMethod(context, RuleActionMethodName, data));
}
private void BindClass(BoundType @class, ClassSyntax syntax)
{
_contextService.EnterClass(@class);
foreach (var boundField in @class.FieldsInternal)
{
BindField(boundField, (FieldSyntax)boundField.Syntax);
}
foreach (var boundFunction in @class.FunctionsInternal)
{
_contextService.EnterScope();
BindFunction(boundFunction, (FunctionSyntax)boundFunction.Syntax);
_contextService.ExitScope();
}
@class.ConstructorsInternal.AddRange(syntax.Constructors.Select(BindConstructor).ToList());
_contextService.ExitClass();
}
