internal LLVMBackendEventArgs(
CompileUnit compileUnit,
LLVMModuleRef moduleRef)
{
CompileUnit = compileUnit;
ModuleRef = moduleRef;
}
public void RunTestCase(string testFile)
{
try
{
string testFilePath = this.ResolvePath(testFile);
CompileUnit[] array = CSharpAssertModule.Convert(new FileInput(testFilePath));
CompileUnit resultingCSharpNode = array[0];
CompileUnit resultingBooNode = array[1];
string[] expectedOutput = this.GetExpectedOutput(testFilePath);
string expectedCSharpOutput = expectedOutput[0];
string expectedBooOutput = expectedOutput[1];
string inputJSCode = expectedOutput[2];
Debug.WriteLine("JavaScript:\n" + inputJSCode);
var output = new StringWriter();
resultingCSharpNode.Accept(new CSharpPrinter(output));
Debug.WriteLine("Generated C#:\n" + output.ToString().TrimEnd());
Debug.WriteLine("Generated Boo:\n" + resultingBooNode.ToCodeString());
CSharpAssertModule.AssertCSharpCode(expectedCSharpOutput, resultingCSharpNode);
StringsModule.AssertAreEqualIgnoringNewLineDifferences(expectedBooOutput, resultingBooNode.ToCodeString());
}
catch (CompilationErrorsException x)
{
Assert.Fail(x.Errors.ToString(true));
}
}
/// <summary>
/// Constructs a default LLVM-based ABI specification.
/// </summary>
/// <param name="unit">The compile unit used for ABI generation.</param>
public DefaultLLVMABI(CompileUnit unit)
: base(unit)
{
var backend = unit.Backend as LLVMBackend;
if (backend == null)
{
throw new NotSupportedException(ErrorMessages.NotSupportedBackend);
}
LLVMTargetData = CreateTargetDataLayout(backend.LLVMTargetMachine);
foreach (var managedAlignment in ManagedAlignments)
{
var managedType = managedAlignment.Key;
var llvmType = unit.GetType(managedType);
var alignment = ABIAlignmentOfType(LLVMTargetData, llvmType);
// We need a special case for the builtin mapping of 64bit floats
// to 32bit floats since this mapping changes the alignment logic.
if (unit.Force32BitFloats && managedType == typeof(double))
{
managedType = typeof(float);
}
if (ManagedAlignments[managedType] != alignment)
{
throw new NotSupportedException(string.Format(
ErrorMessages.CustomABIImplementationRequired, managedAlignment.Key));
}
Alignments.Add(managedAlignment.Key, alignment);
}
AddNonBlittableTypes();
AddPtrAlignment(ABIAlignmentOfType(
LLVMTargetData,
unit.LLVMContext.VoidPtrType));
}
/// <summary>
/// Builds a warp-shuffle mask.
/// </summary>
/// <param name="unit">The current unit.</param>
/// <param name="builder">The current builder.</param>
/// <param name="width">The width that was passed by the user.</param>
/// <param name="addOrMask">True, to add an or mask consisting of (WarpSize - 1).</param>
/// <returns>A value that represents the desired warp-shuffle mask.</returns>
private LLVMValueRef BuildWarpShuffleMask(
CompileUnit unit,
LLVMBuilderRef builder,
LLVMValueRef width,
bool addOrMask)
{
var warpSize = MakeWarpSize(builder);
var warpDiff = BuildSub(builder, warpSize, width, string.Empty);
var result = BuildShl(
builder,
warpDiff,
ConstInt(unit.GetType(BasicValueType.Int32), 8, false),
string.Empty);
if (addOrMask)
{
var orMask = BuildSub(
builder,
warpSize,
ConstInt(unit.GetType(BasicValueType.Int32), 1, false),
string.Empty);
result = BuildOr(
builder,
result,
orMask,
string.Empty);
}
return(result);
}
static CompileUnit SyntaxTreeFor(IFile file)
{
var compileUnit = new CompileUnit();
UnityScriptParser.ParseReader(file.OpenText(), "", new CompilerContext(), compileUnit);
return(compileUnit);
}
/// <summary>
/// Creates an <see cref="Index3"/> in the LLVM world containing the current group-thread indices.
/// </summary>
/// <param name="unit">The target unit.</param>
/// <param name="entryPoint">The entry point.</param>
/// <param name="builder">The LLVM builder.</param>
/// <param name="cudaDeviceFunctions">A reference to the cuda device functions.</param>
/// <returns>An <see cref="Index3"/> in the LLVM world containg the current group-thread indices.</returns>
private static LLVMValueRef CreateGroupIndexValue(
CompileUnit unit,
EntryPoint entryPoint,
LLVMBuilderRef builder,
PTXDeviceFunctions cudaDeviceFunctions)
{
var indexType = unit.GetType(entryPoint.UngroupedIndexType);
var threadIndexValue = GetUndef(indexType);
Debug.Assert(entryPoint.Type >= IndexType.Index1D);
var isGroupedIndex = entryPoint.IsGroupedIndexEntry;
threadIndexValue = BuildInsertValue(builder, threadIndexValue, BuildCall(
builder, cudaDeviceFunctions.GetThreadIdxX.Value), 0, "TIdx1");
if (entryPoint.Type >= IndexType.Index2D && !isGroupedIndex || entryPoint.Type >= IndexType.GroupedIndex2D)
{
threadIndexValue = BuildInsertValue(builder, threadIndexValue, BuildCall(
builder, cudaDeviceFunctions.GetThreadIdxY.Value), 1, "TIdx2");
}
if (entryPoint.Type >= IndexType.Index3D && !isGroupedIndex || entryPoint.Type >= IndexType.GroupedIndex3D)
{
threadIndexValue = BuildInsertValue(builder, threadIndexValue, BuildCall(
builder, cudaDeviceFunctions.GetThreadIdxZ.Value), 2, "TIdx3");
}
return(threadIndexValue);
}
/// <summary>
/// Creates a comparison of the current global index to the custom desired number of user threads.
/// </summary>
/// <param name="unit">The target unit.</param>
/// <param name="entryPoint">The entry point.</param>
/// <param name="builder">The LLVM builder.</param>
/// <param name="cudaDeviceFunctions">A reference to the cuda device functions.</param>
/// <param name="globalIndexValue">The current global index values.</param>
/// <param name="userIndexRange">The user given custom launcher range.</param>
/// <returns>An instance of an <see cref="IGroupedIndex{TIndex}"/> in the LLVM world.</returns>
private static LLVMValueRef CreateGlobalIndexRangeComparison(
CompileUnit unit,
EntryPoint entryPoint,
LLVMBuilderRef builder,
PTXDeviceFunctions cudaDeviceFunctions,
LLVMValueRef globalIndexValue,
LLVMValueRef userIndexRange)
{
Debug.Assert(entryPoint.Type >= IndexType.Index1D && entryPoint.Type < IndexType.GroupedIndex1D);
LLVMValueRef comparisonValue = ConstInt(unit.LLVMContext.Int1Type, 1, false);
for (int i = 0, e = (int)entryPoint.Type; i <= e; ++i)
{
var compareResult = BuildICmp(
builder,
LLVMIntPredicate.LLVMIntSLT,
BuildExtractValue(builder, globalIndexValue, 0, "GlobalIdx_" + i),
BuildExtractValue(builder, userIndexRange, 0, "UserRange_" + i),
"InRange_" + i);
comparisonValue = BuildAnd(
builder,
comparisonValue,
compareResult,
"RangeOr_" + i);
}
return(comparisonValue);
}
/// <summary>
/// Creates a signature for the actual kernel entry point.
/// </summary>
/// <param name="unit">The target unit.</param>
/// <param name="entryPoint">The target entry point.</param>
/// <param name="parameterOffset">The parameter offset for the actual kernel parameters.</param>
/// <returns>A signature for the actual kernel entry point.</returns>
private LLVMTypeRef CreatePTXKernelFunctionType(
CompileUnit unit,
EntryPoint entryPoint,
out int parameterOffset)
{
parameterOffset = entryPoint.IsGroupedIndexEntry ? 0 : 1;
var numUniformVariables = entryPoint.NumUniformVariables;
var argTypes = new LLVMTypeRef[parameterOffset + numUniformVariables + entryPoint.NumDynamicallySizedSharedMemoryVariables];
// Custom dispatch-size information for implicitly grouped kernels
if (parameterOffset > 0)
{
argTypes[0] = unit.GetType(entryPoint.UngroupedIndexType);
}
Debug.Assert(parameterOffset >= 0 && parameterOffset < 2);
for (int i = 0, e = numUniformVariables; i < e; ++i)
{
argTypes[i + parameterOffset] = unit.GetType(entryPoint.UniformVariables[i].VariableType);
}
// Attach length information to dynamically sized variables using runtime information
for (int i = 0, e = entryPoint.NumDynamicallySizedSharedMemoryVariables; i < e; ++i)
{
argTypes[i + parameterOffset + numUniformVariables] = unit.GetType(typeof(int));
}
return(FunctionType(Context.LLVMContext.VoidType, argTypes));
}
/// <summary>
/// Creates an <see cref="Index3"/> in the LLVM world containing the current grid indices.
/// </summary>
/// <param name="unit">The target unit.</param>
/// <param name="entryPoint">The entry point.</param>
/// <param name="builder">The LLVM builder.</param>
/// <param name="cudaDeviceFunctions">A reference to the cuda device functions.</param>
/// <returns>An <see cref="Index3"/> in the LLVM world containg the current grid indices.</returns>
private static LLVMValueRef CreateIndexValue(
CompileUnit unit,
EntryPoint entryPoint,
LLVMBuilderRef builder,
PTXDeviceFunctions cudaDeviceFunctions)
{
var indexType = unit.GetType(entryPoint.UngroupedIndexType);
var indexValue = GetUndef(indexType);
Debug.Assert(entryPoint.Type >= IndexType.Index1D);
indexValue = BuildInsertValue(builder, indexValue, BuildCall(
builder, cudaDeviceFunctions.GetBlockIdxX.Value), 0, "Idx1");
if (entryPoint.Type >= IndexType.Index2D && entryPoint.Type <= IndexType.Index3D ||
entryPoint.Type >= IndexType.GroupedIndex2D)
{
indexValue = BuildInsertValue(builder, indexValue, BuildCall(
builder, cudaDeviceFunctions.GetBlockIdxY.Value), 1, "Idx2");
}
if (entryPoint.Type == IndexType.Index3D || entryPoint.Type == IndexType.GroupedIndex3D)
{
indexValue = BuildInsertValue(builder, indexValue, BuildCall(
builder, cudaDeviceFunctions.GetBlockIdxZ.Value), 2, "Idx3");
}
return(indexValue);
}
public static CompileUnit ParseReader(string readerName, TextReader reader)
{
CompileUnit cu = new CompileUnit();
cu.Modules.Add(ParseModule(readerName, reader, null));
return(cu);
}
/// <summary cref="Backend.TargetUnit(CompileUnit)"/>
internal override void TargetUnit(CompileUnit unit)
{
var module = unit.LLVMModule;
var dataLayout = GetLLVMLayout(Platform);
var targetTriple = GetLLVMTriple(Platform);
SetDataLayout(module, dataLayout);
SetTarget(module, targetTriple);
if (CreateMemoryBufferWithContentsOfFile(LibDevicePath, out LLVMMemoryBufferRef libDeviceBuffer, out IntPtr errorMessage))
{
throw new InvalidOperationException(string.Format(
ErrorMessages.CouldNotReadLibDevice, Marshal.PtrToStringAnsi(errorMessage)));
}
if (GetBitcodeModuleInContext(unit.LLVMContext, libDeviceBuffer, out LLVMModuleRef libDeviceModule, out errorMessage))
{
throw new InvalidOperationException(string.Format(
ErrorMessages.CouldNotLoadLibDevice, Marshal.PtrToStringAnsi(errorMessage)));
}
SetDataLayout(libDeviceModule, dataLayout);
SetTarget(libDeviceModule, targetTriple);
LinkModules2(module, libDeviceModule);
var functions = new PTXDeviceFunctions(unit);
ptxDeviceFunctions.Add(unit, functions);
unit.RegisterDeviceFunctions(functions);
}
public void Run()
{
CompileUnit cu = _context.CompileUnit;
new XmlSerializer(cu.GetType()).Serialize(Console.Out, cu);
Console.WriteLine();
}
public CompilerContext(CompilerParameters parameters, CompileUnit compileUnit)
{
Parameters = parameters;
CompileUnit = compileUnit;
Errors = new SortedSet <CompilerError>();
NamespaceResolver = new NamespaceResolver(this);
}
/// <summary>
/// Constructs a new code generator that targets the given unit.
/// </summary>
/// <param name="unit">The target unit.</param>
/// <param name="method">The source method for code generation.</param>
/// <param name="disassembledMethod">The disassembled method for code generation.</param>
public CodeGenerator(
CompileUnit unit,
Method method,
DisassembledMethod disassembledMethod = null)
{
Debug.Assert(unit != null, "Invalid unit");
Debug.Assert(method != null, "Invalid method");
Unit = unit;
Method = method;
disassembledMethod = disassembledMethod ??
DisassembledMethod.Disassemble(method.MethodBase, CompilationContext.NotSupportedILInstructionHandler);
if (disassembledMethod.Method.GetMethodBody().ExceptionHandlingClauses.Count > 0)
{
throw CompilationContext.GetNotSupportedException(
ErrorMessages.CustomExceptionSemantics, method.Name);
}
Debug.Assert(
method.MethodBase == disassembledMethod.Method,
"The provided disassembled method does not match the given method for code generation");
this.disassembledMethod = disassembledMethod;
Builder = CreateBuilderInContext(unit.LLVMContext);
InitCFG();
InitArgsAndLocals();
}
public override void OnCompileUnit(CompileUnit node)
{
foreach (Module m in node.Modules)
{
m.Accept(this);
}
}
/// <summary>
/// Creates instance of <see cref="CompilerContext"/>.
/// </summary>
/// <param name="parameters">Compiler parameters of the session</param>
/// <param name="compileUnit">Compiler unit of the session.</param>
public CompilerContext(CompilerParameters parameters, CompileUnit compileUnit)
{
Parameters = parameters;
CompileUnit = compileUnit;
Properties = new Hashtable();
Errors = new SortedSet <CompilerError>();
}
public static CompileUnit ParseReader(int tabSize, string readerName, TextReader reader)
{
CompileUnit cu = new CompileUnit();
ParseModule(tabSize, cu, readerName, reader, null);
return(cu);
}
override public void Run()
{
CompileUnit cu = Context.CompileUnit;
new XmlSerializer(cu.GetType()).Serialize(OutputWriter, cu);
Console.WriteLine();
}
public void La()
{
string templateStr = @"
#<laconf>
compiler
{
base-class-name=""NFX.NUnit.Templatization.TeztTemplate""
namespace=""TestWebApp.Templates""
summary=""Test master page""
using {ns=""NFX.Web"" }
using {ns=""NFX.RecordModel"" }
using {ns=""BusinessLogic"" }
attribute {decl=""BusinessLogic.SultanPermission(4)"" }
}
#</laconf>";
TemplateStringContentSource templateSrc = new TemplateStringContentSource(templateStr);
TextCSTemplateCompiler compiler = new TextCSTemplateCompiler(templateSrc);
compiler.Compile();
Assert.AreEqual(1, compiler.Count());
CompileUnit unit = compiler.First();
Assert.IsNull(unit.CompilationException);
Assert.IsNull(unit.CompiledTemplateType);
Assert.IsNotNullOrEmpty(unit.CompiledTemplateTypeName);
Assert.AreSame(templateSrc, unit.TemplateSource);
Assert.AreEqual(templateStr, templateSrc.Content);
}
protected IEnumerator BuildCompileUnits_Internal(BuildTarget target, DirectoryInfo sourceDir)
{
ClearCompileUnits();
var c = kernels.Count;
var s = 1f / Mathf.Max(1, c - 1);
for (var i = 0; i < c; i++)
{
var kernel = kernels[i];
progress.SetNormalizedProgress(s * i, "Building compile units {0:D3} / {1:D3}", i + 1, c);
var compileOptions = ShaderAnalysisUtils.DefaultCompileOptions(kernel.defines, kernel.name, sourceDir);
compileOptions.defines.Add(ShaderAnalysisUtils.DefineCompute);
compileOptions.defines.Add(ShaderAnalysisUtils.DefineCompute);
var unit = new CompileUnit
{
sourceCodeFile = sourceCodeFile,
compileOptions = compileOptions,
compileProfile = ShaderProfile.ComputeProgram,
compileTarget = ShaderTarget.CS_5,
compiledFile = ShaderAnalysisUtils.GetTemporaryProgramCompiledFile(sourceCodeFile, temporaryDirectory, kernel.name)
};
AddCompileUnit(unit);
yield return(null);
}
}
public void NotAbstract()
{
const string CLASS_NAMESPACE = "NFX.NUnit.Templatization";
const string BASE_CLASS_FULLNAME = "NFX.NUnit.Templatization.TeztTemplate";
string templateStr = @"
#<conf><compiler
base-class-name=""{0}""
namespace=""{1}""
abstract=""false""
summary=""Test master page""/>
#</conf>".Args(BASE_CLASS_FULLNAME, CLASS_NAMESPACE);
TemplateStringContentSource src = new TemplateStringContentSource(templateStr);
TextCSTemplateCompiler compiler = new TextCSTemplateCompiler(src)
{
CompileCode = true
};
compiler.ReferenceAssembly(NFX_NUNIT_DLL);
compiler.Compile();
CompileUnit cu = compiler.First();
Assert.IsFalse(cu.CompiledTemplateType.IsAbstract);
}
public void AutoGeneratedNamespace()
{
const string CLASS_NAMESPACE = "";
const string BASE_CLASS_FULLNAME = "NFX.NUnit.Templatization.TeztTemplate";
string templateSrc = @"
#<conf><compiler
base-class-name=""{0}""
namespace=""{1}""
abstract=""true""
summary=""Test master page""/>
#</conf>".Args(BASE_CLASS_FULLNAME, CLASS_NAMESPACE);
TemplateStringContentSource src = new TemplateStringContentSource(templateSrc);
TextCSTemplateCompiler compiler = new TextCSTemplateCompiler(src)
{
CompileCode = true
};
compiler.ReferenceAssembly(NFX_NUNIT_DLL);
compiler.Compile();
CompileUnit cu = compiler.First();
compiler.CodeCompilerErrors.ForEach(e => Console.WriteLine(e.ToMessageWithType()));
Assert.IsNotNullOrEmpty(cu.CompiledTemplateType.Namespace);
}
public void TestForContinue()
{
string compileTest = @"
module Program
{
function main(array : int[]) : int
{
var val : int = 0;
for(i in array)
{
if(i == 1) continue;
val = val + i;
}
return val;
}
}
";
var lexResults = lexer.Lex(new Document(compileTest, "")).GetAwaiter().GetResult();
var parseResults = parser.Parse(lexResults).GetAwaiter().GetResult();
var compileUnit = new CompileUnit(new [] { parseResults });
var compileResults = compileUnit.Compile();
System.Console.WriteLine();
foreach (var err in compileResults.Errors)
{
System.Console.WriteLine($"ERROR: {err.Message}");
}
Assert.IsTrue(compileResults.Errors.Length == 0);
byte[] image = compileResults.Output.Serialize();
System.Console.WriteLine($"Compiled Cozi IL image - {image.Length} byte(s)");
ILContext context = new ILContext(image);
CoziVM vm = new CoziVM(context);
foreach (var m in context.Modules)
{
System.Console.WriteLine(m.ToString());
}
var intType = context.GlobalTypes.GetType("int");
var intArrayRef = vm.NewArray(intType, 6);
vm.Pin(intArrayRef.SrcPointer);
vm.SetElement <int>(intArrayRef, 0, 24);
vm.SetElement <int>(intArrayRef, 1, 1);
vm.SetElement <int>(intArrayRef, 2, 49);
vm.SetElement <int>(intArrayRef, 3, 1);
vm.SetElement <int>(intArrayRef, 4, 7);
vm.SetElement <int>(intArrayRef, 5, 1);
Assert.IsTrue(vm.BeginInvoke("Program", "main", out var ctx));
ctx.PushArg <VMSlice>(intArrayRef, 0);
Assert.IsTrue(ctx.Invoke <int>() == (24 + 49 + 7));
}
protected CompileUnit CompileUnitFor(TypeDefinition node)
{
CompileUnit unit = new CompileUnit();
GetModuleFor(unit, node);
return(unit);
}
public override void OnCompileUnit(CompileUnit node)
{
this._codeDomUnit = new CodeCompileUnit();
this._defaultNS = new CodeNamespace();
this._codeDomUnit.Namespaces.Add(this._defaultNS);
base.OnCompileUnit(node);
}
/// <summary>
/// Checks the given call target for compatibility.
/// </summary>
/// <param name="unit">The current compilation unit.</param>
/// <param name="target">The call target to test for compatiblity.</param>
/// <param name="entryPoint">The entry point.</param>
private static void CheckCall(
CompileUnit unit,
MethodBase target,
EntryPoint entryPoint)
{
var compilationContext = unit.CompilationContext;
if (target.IsAbstract)
{
throw compilationContext.GetNotSupportedException(
ErrorMessages.NotSupportedVirtualMethodCall, target.Name);
}
CodeGenerator.VerifyAccessToMethodInImplicitlyGroupedKernel(
compilationContext,
target,
entryPoint);
var declaringType = target.DeclaringType;
if (declaringType.IsGenericType)
{
declaringType = declaringType.GetGenericTypeDefinition();
}
if (IntrinsicTypes.Contains(declaringType))
{
return;
}
if (VerifyActivatorCall(unit, target))
{
return;
}
CodeGenerator.VerifyNotRuntimeMethod(
compilationContext,
target);
CheckMethod(unit, target, entryPoint);
}
public static Assembly compile(CompileUnit unit, params Assembly[] references)
{
CompilerContext result = compile_(unit, references);
AssertNoErrors(result);
return(result.GeneratedAssembly);
}
public void RunStringTestCase(string message, string expected, string actual)
{
CompileUnit cu = RunCompiler(new StringInput("<actual>", actual));
cu.Modules[0].Name = BooParser.CreateModuleName("<expected>");
AssertEquals(message, ParseString("<expected>", expected), cu);
}
public void RunTestCase(string expectedFile, string actualFile)
{
CompileUnit cu = RunCompiler(new FileInput(GetTestCasePath(actualFile)));
cu.Modules[0].Name = BooParser.CreateModuleName(expectedFile);
AssertEquals("[required]", ParseTestCase(expectedFile), cu);
}
public static CompileUnit ParseReader(ParserSettings settings, string readerName, TextReader reader)
{
var cu = new CompileUnit();
ParseModule(settings, cu, readerName, reader);
return(cu);
}
protected override void DoCompileTemplateSource(CompileUnit unit)
{
var text = unit.TemplateSource.GetSourceContent().ToString().Trim();
var icname = unit.TemplateSource.InferClassName();
Configuration conf = new MemoryConfiguration();
var confLineCount = 0;
if (text.StartsWith(CONFIG_START))
{
var i = text.IndexOf(CONFIG_END);
if (i<CONFIG_START.Length) throw new TemplateParseException(StringConsts.TEMPLATE_CS_COMPILER_CONFIG_CLOSE_TAG_ERROR);
var confText = text.Substring(CONFIG_START.Length, i - CONFIG_START.Length);
confLineCount = confText.Count(c=>c=='\n');
//cut configuration out of template
text = text.Substring(i + CONFIG_END.Length);
try
{
conf = XMLConfiguration.CreateFromXML("<config>"+confText+"</config>");
}
catch(Exception error)
{
throw new TemplateParseException(StringConsts.TEMPLATE_CS_COMPILER_CONFIG_ERROR + error.Message, error);
}
}else//20140103 DKh add Laconic support
if (text.StartsWith(LACONFIG_START))
{
var i = text.IndexOf(LACONFIG_END);
if (i<LACONFIG_START.Length) throw new TemplateParseException(StringConsts.TEMPLATE_CS_COMPILER_CONFIG_CLOSE_TAG_ERROR);
var confText = text.Substring(LACONFIG_START.Length, i - LACONFIG_START.Length);
confLineCount = confText.Count(c=>c=='\n');
//cut configuration out of template
text = text.Substring(i + LACONFIG_END.Length);
try
{
conf = LaconicConfiguration.CreateFromString("config{"+confText+"}");
}
catch(Exception error)
{
throw new TemplateParseException(StringConsts.TEMPLATE_CS_COMPILER_CONFIG_ERROR + error.Message, error);
}
}
var compilerNode = conf.Root[CONFIG_COMPILER_SECTION];
//add referenced assemblies
foreach(var anode in compilerNode.Children.Where(cn=> cn.IsSameName(CONFIG_REF_ASSEMBLY_SECTION)))
this.ReferenceAssembly(anode.AttrByName(CONFIG_REF_ASSEMBLY_NAME_ATTR).Value);
//add usings
var usings = new HashSet<string>();
RegisterDefaultUsings(usings);
foreach(var unode in compilerNode.Children.Where(cn=> cn.IsSameName(CONFIG_USING_SECTION)))
usings.Add(unode.AttrByName(CONFIG_USING_NS_ATTR).Value);
//add attributes
var attributes = new List<string>();
foreach(var anode in compilerNode.Children.Where(cn=> cn.IsSameName(CONFIG_ATTRIBUTE_SECTION)))
attributes.Add(anode.AttrByName(CONFIG_ATTRIBUTE_DECL_ATTR).Value);
unit.CompiledSource = new FSM(){Compiler = this,
Unit = unit,
InferredClassName = icname,
ConfigNode = conf.Root,
Source = text,
Usings = usings,
Attributes = attributes,
LineNo = confLineCount+1}.Build().ToString();
}
