Statement CreateBuildError(Source src, bool isError, AstExpression value = null)
{
var type = "build_" + (isError
? "error"
: "warning");
if (!IsFunctionScope)
{
return(Error(src, ErrorCode.E0000, type.Quote() + " can only be used in methods"));
}
var message = value != null
? Compiler.CompileConstant(value, Namescope, Essentials.String).Value as string ??
"<invalid>"
: Function.Quote() + " does not support this build target";
if (isError)
{
/*if (!Compiler.Backend.IsDefault)
* Log.Error(s.Source, ErrorCode.E0000, message);*/
return(new Throw(src,
ILFactory.NewObject(src, Essentials.Exception,
new Constant(src, Essentials.String, type + ": " + message))));
}
if (!Compiler.Backend.IsDefault)
{
Log.Warning(src, ErrorCode.W0000, type + ": " + message);
}
return(new NoOp(src, message));
}
public Compiler(Log log, Backend backend, SourcePackage package, CompilerOptions options)
: base(log)
{
// This is a block of dependency injection to initialize the Compiler
var il = new Namespace();
var extensions = new ExtensionRoot();
Backend = backend;
var disk = Disk = new Disk(log, true);
Shell = new Shell(log);
var essentials = Essentials = new Essentials();
var resolver = NameResolver = new NameResolver(this);
var ilf = ILFactory = new ILFactory(backend, il, essentials, resolver, this);
var data = Data = new BuildData(il, extensions, ilf);
var environment = Environment = new BuildEnvironment(backend, package, options, extensions, ilf, this);
var input = Input = new SourceReader(log, package, environment);
var blockBuilder = BlockBuilder = new BlockBuilder(backend, il, ilf, resolver, this);
var typeBuilder = TypeBuilder = new TypeBuilder(environment, ilf, resolver, this);
var bundle = BundleBuilder = new BundleBuilder(backend, environment, ilf, this);
AstProcessor = new AstProcessor(il, blockBuilder, typeBuilder, resolver, environment);
UxlProcessor = new UxlProcessor(disk, backend.Name, il, extensions, environment, ilf);
Plugins = new PluginCache(log, bundle, ilf, environment);
var pass = Pass = new CompilerPass(disk, data, environment, ilf, backend, input.Package, typeBuilder, resolver);
Utilities = new Utilities(il, pass);
ILVerifier = new ILVerifier(pass);
ConstantFolder = new ConstantFolder(pass);
ILStripper = new ILStripper(pass);
}
public Expression CompileImplicitCast(Source src, string expectedType, Expression value)
{
var result = TryCompileImplicitCast(src, ILFactory.GetType(src, expectedType), value, true);
ImplicitCastStack.RemoveLast();
return(result);
}
public TestSetupTransform(CompilerPass parent)
: base(parent)
{
if (Environment.Options.TestOptions == null)
{
throw new InvalidOperationException("Internal error, could not get test options");
}
_testOptions = Environment.Options.TestOptions.Value;
_testAttributeType = ILFactory.GetType("Uno.Testing.TestAttribute");
_ignoreAttributeType = ILFactory.GetType("Uno.Testing.IgnoreAttribute");
if (_testAttributeType is InvalidType)
{
throw new InvalidOperationException("Did you forget to reference the Uno.Testing package?");
}
_actionType = (DelegateType)ILFactory.GetType("Uno.Action");
_testSetupType = ILFactory.GetType("Uno.Testing.TestSetup");
_appClass = Essentials.Application;
_source = Package.Source;
_testRegistryType = ILFactory.GetType("Uno.Testing.Registry");
_mainClass = new ClassType(_source, Data.IL, null, Modifiers.Generated | Modifiers.Public, "MainClass");
_mainClass.SetBase(_appClass);
_mainConstructor = new Constructor(_source, _mainClass, null, Modifiers.Public, ParameterList.Empty);
_mainClass.Constructors.Add(_mainConstructor);
_testSetupField = new Field(_source, _mainClass, "_testSetup", null, Modifiers.Private, FieldModifiers.ReadOnly, _testSetupType);
_mainClass.Fields.Add(_testSetupField);
Data.IL.Types.Add(_mainClass);
}
internal BuildEnvironment(
Backend backend,
SourcePackage project,
CompilerOptions options,
ExtensionRoot extensions,
ILFactory ilf,
Compiler compiler)
: base(compiler)
{
if (string.IsNullOrEmpty(options.Configuration))
{
options.Configuration = "Debug";
}
if (string.IsNullOrEmpty(options.BuildTarget))
{
throw new ArgumentNullException(nameof(options.BuildTarget));
}
if (string.IsNullOrEmpty(options.OutputDirectory))
{
throw new ArgumentNullException(nameof(options.OutputDirectory));
}
Extensions = extensions;
Options = options;
BundleDirectory = Path.Combine(project.CacheDirectory, "bundle");
CacheDirectory = Path.Combine(project.CacheDirectory, options.BuildTarget, options.Configuration);
Essentials = ilf.Essentials;
MacroExpander = new MacroExpander(backend, this, extensions, ilf, compiler);
Compiler = compiler;
Set("Target", options.BuildTarget);
Set("Configuration", options.Configuration);
Set("OutputDirectory", OutputDirectory = ExpandSingleLine(options.OutputDirectory).UnixToNative());
}
Field GetField(Draw draw)
{
var prog = GetProgram(draw);
var key = Type + ":" + prog;
Field result;
if (!_fields.TryGetValue(key, out result))
{
var src = draw.Source;
var initMethod = Type.TryGetMethod("init_DrawCalls", false);
if (initMethod == null)
{
throw new SourceException(src, "No 'init_DrawCalls()' method was found in " + Type.Quote());
}
var dc = ILFactory.NewObject(src, "Uno.Graphics.OpenGL.GLDrawCall", prog);
result = new Field(src, Type, "_draw_" + draw.State.Path.Suffix, null, Modifiers.Private | Modifiers.Generated, 0, dc.ReturnType);
initMethod.Body.Statements.Add(new StoreField(src, new This(src, Type), result, dc));
Type.Fields.Add(result);
_fields.Add(key, result);
}
return(result);
}
Expression ProcessVertexBuffer(StageValue vertexBuffer)
{
Expression result;
if (!VertexBuffers.TryGetValue(vertexBuffer.Value.ToString(), out result))
{
var src = vertexBuffer.Value.Source;
var type = ILFactory.GetType(src, "Uno.Graphics.VertexBuffer");
if (vertexBuffer.Value.ReturnType.Equals(type))
{
result = ProcessStage(vertexBuffer, MetaStage.Volatile, MetaStage.Volatile).Value;
VertexBuffers.Add(vertexBuffer.Value.ToString(), result);
return(result);
}
var loc = LocationStack.Last();
var mp = GetProperty(loc);
var name = CreateFieldName(mp, loc);
var owner = Path.DrawBlock.Method.DeclaringType;
var field = new Field(src, owner, name, null, Modifiers.Private | Modifiers.Generated, 0, type);
owner.Fields.Add(field);
result = new LoadField(src, new This(src, owner), field);
VertexBuffers.Add(vertexBuffer.Value.ToString(), result);
if (vertexBuffer.MinStage > MetaStage.Volatile)
{
Log.Error(src, ErrorCode.E5025, "Vertex buffer cannot be accessed from " + vertexBuffer.MinStage + " stage");
return(result);
}
else if (vertexBuffer.MinStage == MetaStage.Volatile)
{
InitScope.Statements.Add(
new StoreField(src, new This(src, owner), field,
ILFactory.NewObject(src, "Uno.Graphics.VertexBuffer",
ILFactory.GetExpression(src, "Uno.Graphics.BufferUsage.Dynamic"))));
FrameScope.Statements.Add(
ILFactory.CallMethod(src, new LoadField(src, new This(src, owner), field), "Update",
vertexBuffer.Value));
}
else
{
InitScope.Statements.Add(
new StoreField(src, new This(src, owner), field,
ILFactory.NewObject(src, "Uno.Graphics.VertexBuffer",
vertexBuffer.Value,
ILFactory.GetExpression(src, "Uno.Graphics.BufferUsage.Immutable"))));
}
FreeScope.Statements.Add(
ILFactory.CallMethod(src, new LoadField(src, new This(src, owner), field), "Dispose"));
}
return(result);
}
Expression CreateByteArray(Expression buf)
{
return(ILFactory.CallMethod(
buf.ReturnType.Equals(ILFactory.GetType(buf.Source, "Uno.Buffer")) ?
buf :
ILFactory.CallMethod(buf.Source, "Uno.Runtime.Implementation.Internal.BufferConverters", "ToBuffer", buf),
"GetBytes"));
}
private static FixedList <DeclarationIL> BuildIL(Package package)
{
var ilFactory = new ILFactory();
var declarationBuilder = new DeclarationBuilder(ilFactory);
declarationBuilder.Build(package.AllDeclarations, package.SymbolTree);
return(declarationBuilder.AllDeclarations.ToFixedList());
}
private Expression RegisterTest(TestMethod testMethod, Expression registryArgument, NewDelegate invokeDelegate)
{
var testNameExpr = new Constant(_source, Essentials.String, testMethod.Name);
var ignoreExpr = new Constant(_source, Essentials.Bool, testMethod.Ignored);
var ignoreReasonExpr = new Constant(_source, Essentials.String, testMethod.IgnoreReason);
return ILFactory.CallMethod(_source, registryArgument, "Add", invokeDelegate,
testNameExpr, ignoreExpr, ignoreReasonExpr);
}
public GLGenerator(GLBackend backend, IBundle bundle)
: base(backend)
{
_backend = backend;
_bundle = bundle;
_obfuscator = new ShaderObfuscator(backend);
_stringArray = (RefArrayType)ILFactory.GetType("string[]");
_dumpShaders = Environment.IsDefined("DUMP_SHADERS");
}
public override void Configure()
{
_outputDir = Environment.Combine(
Environment.ExpandSingleLine("@(AssemblyDirectory || '.')")).TrimPath();
_linker = new CilLinker(Log, Essentials);
Scheduler.AddTransform(new CilTransform(this));
EnableReflection = Environment.IsDefined("REFLECTION");
TypeAliasAttribute = EnableReflection
? ILFactory.GetType("Uno.Reflection.TypeAliasAttribute")
: DataType.Invalid;
}
FunctionCompiler(Compiler compiler)
: base(compiler)
{
Environment = compiler.Environment;
Essentials = compiler.Essentials;
ILFactory = compiler.ILFactory;
ILVerifier = compiler.ILVerifier;
TypeBuilder = compiler.TypeBuilder;
NameResolver = compiler.NameResolver;
Compiler = compiler;
}
public TypeBuilder(
BuildEnvironment env,
ILFactory ilf,
NameResolver resolver,
Compiler compiler)
: base(compiler)
{
_env = env;
_ilf = ilf;
_resolver = resolver;
_compiler = compiler;
}
internal BuildData(
Namespace il,
ExtensionRoot extensions,
ILFactory ilf)
: base(ilf)
{
_ilf = ilf;
IL = il;
Extensions = extensions;
MainClass = DataType.Invalid;
StartupCode = new Scope();
}
void EnsureInitialized()
{
if (!_initialized)
{
ExpandInterceptor = new ExpandInterceptor(InterceptEntity);
BoxedJavaObject = ILFactory.GetType("Java.Object");
_initialized = true;
Convert = new Converters.Converter(BoxedJavaObject, Essentials, ILFactory, Helpers);
BlockHost = new Entrypoints(Environment, Disk, ILFactory, Convert);
UnoToJavaBoxingClass = ILFactory.GetType("Uno.Compiler.ExportTargetInterop.Foreign.Android.JavaUnoObject");
}
}
public CompilerPass(CompilerPass parent)
: base(parent)
{
Backend = parent.Backend;
Package = parent.Package;
TypeBuilder = parent.TypeBuilder;
Data = parent.Data;
Environment = parent.Environment;
Essentials = parent.Essentials;
ILFactory = parent.ILFactory;
NameResolver = parent.NameResolver;
}
public BundleBuilder(
Backend backend,
BuildEnvironment env,
ILFactory ilf,
Compiler compiler)
: base(compiler)
{
_backend = backend;
_env = env;
_ilf = ilf;
_compiler = compiler;
}
void EnsureInitialized(Source source, Function f)
{
Helpers.CacheContext(f, source);
if (!_initialized)
{
_initialized = true;
_objCObject = ILFactory.GetType("global::ObjC.Object");
_objCID = ILFactory.GetType("global::ObjC.ID");
_intPtr = ILFactory.GetType("global::Uno.IntPtr");
_getHandle = (Method)ILFactory.GetEntity("global::ObjC.Object.GetHandle(" + Helpers.FullGlobalName(_objCObject) + ")");
_newObjCObject = (Method)ILFactory.GetEntity(Helpers.FullGlobalName(_objCObject) + ".Create(" + Helpers.FullGlobalName(_objCID) + ")");
}
}
public BlockBuilder(
Backend backend,
Namespace il,
ILFactory ilf,
NameResolver resolver,
Compiler compiler)
: base(compiler)
{
_backend = backend;
_il = il;
_ilf = ilf;
_resolver = resolver;
_compiler = compiler;
}
protected override Statement TransformDraw(Draw draw)
{
var src = draw.Source;
var scope = new Scope(src);
var field = GetField(draw);
var obj = new LoadField(src, new This(src, field.DeclaringType).Address, field).Address;
var index = 0;
foreach (var t in TerminalFields)
{
if (t.Value != draw.State.Terminals[t.Key].ToString())
{
scope.Statements.Add(ILFactory.SetProperty(src, obj, t.Key, draw.State.Terminals[t.Key]));
}
}
foreach (var v in draw.State.RuntimeConstants)
{
scope.Statements.Add(CallConst(src, obj, v, index++));
}
scope.Statements.Add(ILFactory.CallMethod(src, obj, "Use"));
foreach (var v in draw.State.VertexAttributes)
{
scope.Statements.Add(CallAttrib(src, obj, v, index++));
}
foreach (var v in draw.State.Uniforms)
{
scope.Statements.Add(CallUniform(src, obj, v, index++));
}
foreach (var v in draw.State.PixelSamplers)
{
scope.Statements.Add(CallSampler(src, obj, v, index++));
}
scope.Statements.Add(draw.State.OptionalIndices == null
? ILFactory.CallMethod(src, obj,
"DrawArrays",
draw.State.Terminals["VertexCount"])
: ILFactory.CallMethod(src, obj,
"Draw",
draw.State.Terminals["VertexCount"],
draw.State.OptionalIndices.IndexType,
draw.State.OptionalIndices.Buffer));
return(draw.State.Terminals.ContainsKey("CullDrawable")
? (Statement) new IfElse(src, ILFactory.CallOperator(src, Essentials.Bool, "!", draw.State.Terminals["CullDrawable"]), scope)
: scope);
}
public ILFactory CreateLFactory()
{
ILFactory factory = null;
try
{
factory = new LFactory();
}
catch (Exception exception)
{
this.Log.Error("Exception message: " + exception.Message + " and stacktrace " + exception.StackTrace);
}
return(factory);
}
public UxlProcessor(
Disk disk,
string backendName,
Namespace il,
ExtensionRoot root,
BuildEnvironment env,
ILFactory ilf)
: base(disk)
{
_disk = disk;
_il = il;
_root = root;
_env = env;
_ilf = ilf;
Enum.TryParse(backendName, true, out _backendType);
}
public ILFactory CreateLFactory()
{
ILFactory factory = null;
try
{
factory = new LFactory();
}
catch (Exception exception)
{
this.Log.Error(
exception.Message,
exception);
}
return(factory);
}
private void OnTwinMethod(ref Method method)
{
Method twin;
if (!_twinMethods.TryGetValue(method, out twin))
{
if (method.HasAttribute(Essentials.DotNetOverrideAttribute) &&
method.DeclaringType.HasAttribute(Essentials.DotNetTypeAttribute))
{
if (method.IsGenericParameterization)
{
var def = method.GenericDefinition;
OnTwinMethod(ref def);
twin = ILFactory.Parameterize(method.Source, def, method.GenericArguments);
}
else
{
var twinClass = GetOrCreateTwinClass(method.DeclaringType);
if (method.IsGenericDefinition)
{
var generic = new ClassType(method.Source, twinClass, method.DocComment, Modifiers.Private | Modifiers.Static | Modifiers.Generated, method.UnoName);
generic.MakeGenericDefinition(method.GenericParameters);
twin = new Method(method.Source, twinClass, method.DocComment, method.Modifiers, method.Name, generic, method.ReturnType, method.Parameters, method.Body);
generic.Methods.Add(twin);
}
else
{
twin = new Method(method.Source, twinClass, method.DocComment, method.Modifiers, method.Name, method.ReturnType, method.Parameters, method.Body);
}
twin.Stats |= method.Stats & EntityStats.ImplicitReturn;
twin.SetPrototype(method);
twinClass.Methods.Add(twin);
}
}
_twinMethods.Add(method, twin);
}
if (twin != null)
{
method = twin;
}
}
public override void Configure()
{
SourceDirectory = Environment.GetOutputPath("SourceDirectory");
HeaderDirectory = Environment.GetOutputPath("HeaderDirectory");
Types.Add(Essentials.Bool, "bool");
Types.Add(Essentials.Byte, "uint8_t");
Types.Add(Essentials.Char, "char16_t");
Types.Add(Essentials.Double, "double");
Types.Add(Essentials.Float, "float");
Types.Add(Essentials.Int, "int");
Types.Add(Essentials.Long, "int64_t");
Types.Add(Essentials.SByte, "int8_t");
Types.Add(Essentials.Short, "int16_t");
Types.Add(Essentials.UInt, "unsigned int");
Types.Add(Essentials.ULong, "uint64_t");
Types.Add(Essentials.UShort, "uint16_t");
Types.Add(ILFactory.GetType("global::Uno.IntPtr"), "void*");
}
public override void End(ref Statement e)
{
if (e.Tag is InvalidExpression)
{
e = new NoOp(e.Source);
}
switch (e.StatementType)
{
case StatementType.DrawDispose:
{
if (!Backend.CanExportDontExports)
{
e = ILFactory.CallMethod(e.Source, new This(e.Source, Type).Address, "free_DrawCalls");
}
break;
}
}
}
public ShaderGenerator(Compiler compiler, Drawable path, Scope initScope, Scope freeScope, Scope drawScope)
: base(compiler)
{
Backend = compiler.Backend;
IL = compiler.Data.IL;
Environment = compiler.Environment;
Essentials = compiler.Essentials;
ILFactory = compiler.ILFactory;
Compiler = compiler;
DrawState = path.DrawState;
Path = path;
InitScope = initScope;
FreeScope = freeScope;
FrameScope = drawScope;
VertexScope = DrawState.VertexShader.Entrypoint.Body;
PixelScope = DrawState.PixelShader.Entrypoint.Body;
InitStart = InitScope.Statements.Count;
FrameStart = FrameScope.Statements.Count;
}
private void RegisterTestMethods()
{
var registryObject = ILFactory.NewObject(_source, _testRegistryType);
var registryVariable = new Variable(_source, _mainConstructor, "registry", _testRegistryType, VariableType.Default, registryObject);
var body = new Scope(_source);
body.Statements.Add(new CallConstructor(_source, _appClass.Constructors[0]));
body.Statements.Add(new VariableDeclaration(registryVariable));
var methods = _methods;
if (_testOptions.Filter != null)
{
var regex = new Regex(_testOptions.Filter, RegexOptions.CultureInvariant);
methods = methods.Where(m => regex.IsMatch(m.FullName)).ToList();
}
methods.Sort((a, b) => string.Compare(a.FullName, b.FullName, StringComparison.InvariantCultureIgnoreCase));
var ret = new List <TestMethod>();
foreach (var method in methods)
{
var testMethod = CreateTestMethod(method);
var invokerMethod = CreateInvoker(method);
var invokerInstance = InstantiateTestFixture(invokerMethod);
var testExpression = RegisterTest(testMethod,
new LoadLocal(_source, registryVariable),
new NewDelegate(_source, _actionType,
invokerInstance, invokerMethod));
body.Statements.Add(testExpression);
ret.Add(testMethod);
}
var registryExpr = new LoadLocal(_source, registryVariable);
var testSetupConstruction = ILFactory.NewObject(_source, _testSetupType, registryExpr);
body.Statements.Add(new StoreField(_source, new This(_source, _mainClass), _testSetupField, testSetupConstruction));
_mainConstructor.SetBody(body);
}
void EnsureInitialized()
{
if (!_initialized)
{
_initialized = true;
IdentityTypes.Add(Essentials.Bool, "bool");
IdentityTypes.Add(Essentials.Byte, "uint8_t");
IdentityTypes.Add(Essentials.Char, "char16_t");
IdentityTypes.Add(Essentials.Double, "double");
IdentityTypes.Add(Essentials.Float, "float");
IdentityTypes.Add(Essentials.Int, "int");
IdentityTypes.Add(Essentials.Long, "int64_t");
IdentityTypes.Add(Essentials.SByte, "int8_t");
IdentityTypes.Add(Essentials.Short, "int16_t");
IdentityTypes.Add(Essentials.UInt, "unsigned int");
IdentityTypes.Add(Essentials.ULong, "uint64_t");
IdentityTypes.Add(Essentials.UShort, "uint16_t");
IdentityTypes.Add(ILFactory.GetType("global::Uno.IntPtr"), "void*");
}
}
