public void TestStringFieldExpressionsMssql(string expr, string expectedQuery)
{
Setup(expr);
CalcParser.ExpressionContext context = this._calcParser.expression();
DbTranslator translator = new MssqlTranslator();
IMetadataResolver resolver = Substitute.For <IMetadataResolver>();
resolver
.GetField(Arg.Any <string>())
.Returns(callinfo => new FieldInfo
{
Name = callinfo.ArgAt <string>(0),
Type = DFM_FIELD_TYPE.DFM_FT_STRING
});
QueryVisitor visitor = new QueryVisitor(resolver, translator);
string query = visitor.Visit(context);
Assert.AreEqual(expectedQuery, query);
}
public static bool Inherits(this TypeReference self, string @namespace, string name, IMetadataResolver resolver)
{
if (@namespace == null)
{
throw new ArgumentNullException("namespace");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
if (self == null)
{
return(false);
}
TypeReference current = resolver.Resolve(self);
while (current != null)
{
if (current.Is(@namespace, name))
{
return(true);
}
if (current.Is("System", "Object"))
{
return(false);
}
TypeDefinition td = resolver.Resolve(current);
if (td == null)
{
return(false); // could not resolve type
}
current = td.BaseType;
}
return(false);
}
public TypeNameMapGenerator(IEnumerable <string> assemblies, Action <TraceLevel, string> logger, IMetadataResolver resolver)
{
if (assemblies == null)
{
throw new ArgumentNullException("assemblies");
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
Cache = resolver ?? new TypeDefinitionCache();
Log = logger;
var Assemblies = assemblies.ToList();
var rp = new ReaderParameters();
Resolver = new DirectoryAssemblyResolver(Log, loadDebugSymbols: true, loadReaderParameters: rp);
foreach (var assembly in Assemblies)
{
var directory = Path.GetDirectoryName(assembly);
if (string.IsNullOrEmpty(directory))
{
continue;
}
if (!Resolver.SearchDirectories.Contains(directory))
{
Resolver.SearchDirectories.Add(directory);
}
}
foreach (var assembly in Assemblies)
{
Resolver.Load(Path.GetFullPath(assembly));
}
Scanner = new JavaTypeScanner(Log, Cache)
{
ErrorOnCustomJavaObject = false,
};
Types = Scanner.GetJavaTypes(Assemblies, Resolver);
}
public MethodCallExpressionBuilder(IReferenceExpression reference, Expression context, IEnumerable <Expression> arguments, IMetadataResolver metadataResolver)
{
this.reference = reference;
this.context = context;
this.arguments = arguments;
this.metadataResolver = metadataResolver;
}
public virtual void Initialize(LinkContext context, MarkContext markContext)
{
Context = context;
cache = context;
}
public Calculator(IMetadataResolver resolver)
{
this.MetadataResolver = resolver;
this._visitor = new CalcVisitor(resolver);
}
public MemberReferenceExpressionBuilder(IReferenceExpression expression, Expression context, IMetadataResolver metadataResolver)
{
this.expression = expression;
this.context = context;
this.metadataResolver = metadataResolver;
}
public Signature(MethodDefinition method, ExportFieldAttribute exportField, IMetadataResolver cache)
: this(method.Name, GetJniSignature(method, cache), "__export__", null, null, null)
{
if (method.HasParameters)
{
Diagnostic.Error(4205, JavaCallableWrapperGenerator.LookupSource(method), Localization.Resources.JavaCallableWrappers_XA4205);
}
if (method.ReturnType.MetadataType == MetadataType.Void)
{
Diagnostic.Error(4208, JavaCallableWrapperGenerator.LookupSource(method), Localization.Resources.JavaCallableWrappers_XA4208);
}
IsExport = true;
IsStatic = method.IsStatic;
JavaAccess = JavaCallableWrapperGenerator.GetJavaAccess(method.Attributes & MethodAttributes.MemberAccessMask);
// annotations are processed within JavaFieldInfo, not the initializer method. So we don't generate them here.
}
public override Expression VisitLambdaExpression(ILambdaExpression lambdaExpressionParam, IMetadataResolver context)
{
lambdaParameters.AddRange(lambdaExpressionParam.ParameterDeclarations.Select(
declaration => declaration.Accept(this, context) as ParameterExpression));
Expression body = lambdaExpressionParam.BodyExpression.Accept(this, context);
return(Expression.Lambda <TDelegate>(body, lambdaParameters));
}
public override Expression VisitCSharpLiteralExpression(ICSharpLiteralExpression expression, IMetadataResolver context)
{
var declaredType = expression.ConstantValue.Type as IDeclaredType;
if (declaredType != null)
{
Type type = Type.GetType(declaredType.GetClrName().FullName);
Assertion.Assert(type != null, "type != null");
return(Expression.Constant(expression.ConstantValue.Value, type));
}
return(Expression.Constant(expression.ConstantValue.Value));
}
public override Expression VisitUserTypeUsage(IUserTypeUsage userTypeUsageParam, IMetadataResolver context)
{
return(null);
}
public override Expression VisitTypeofExpression(ITypeofExpression typeofExpressionParam, IMetadataResolver context)
{
IDeclaredType declaredType = typeofExpressionParam.ArgumentType.GetScalarType();
if (declaredType == null || !declaredType.IsValid())
{
return(base.VisitTypeofExpression(typeofExpressionParam, context));
}
string assemblyName = GetTypeAssemblyFullName(declaredType);
#if DEBUG
if (string.IsNullOrWhiteSpace(assemblyName))
{
Console.WriteLine(assemblyName);
}
#endif
string fullyQualifiedTypeName = string.Format("{0}, {1}", declaredType.GetClrName().FullName, assemblyName);
Type value = Type.GetType(fullyQualifiedTypeName);
return(Expression.Constant(value, typeof(Type)));
}
public override Expression VisitPrimaryExpression(IPrimaryExpression primaryExpressionParam, IMetadataResolver context)
{
return(null);
}
public override Expression VisitEqualityExpression(IEqualityExpression equalityExpressionParam, IMetadataResolver context)
{
Expression left = equalityExpressionParam.LeftOperand.Accept(this, context);
Expression right = equalityExpressionParam.RightOperand.Accept(this, context);
return(new EqualityExpressionBuilder(equalityExpressionParam, left, right).Build());
}
public override Expression VisitCSharpArgument(ICSharpArgument cSharpArgumentParam, IMetadataResolver context)
{
return(cSharpArgumentParam.Value.Accept(this, context));
}
JavaCallableWrapperGenerator(TypeDefinition type, string outerType, Action <string, object[]> log, IMetadataResolver resolver)
{
this.type = type;
this.log = log;
this.cache = resolver ?? new TypeDefinitionCache();
if (type.IsEnum || type.IsInterface || type.IsValueType)
{
Diagnostic.Error(4200, LookupSource(type), Localization.Resources.JavaCallableWrappers_XA4200, type.FullName);
}
string jniName = JavaNativeTypeManager.ToJniName(type);
if (jniName == null)
{
Diagnostic.Error(4201, LookupSource(type), Localization.Resources.JavaCallableWrappers_XA4201, type.FullName);
}
if (!string.IsNullOrEmpty(outerType))
{
string p;
jniName = jniName.Substring(outerType.Length + 1);
ExtractJavaNames(outerType, out p, out outerType);
}
ExtractJavaNames(jniName, out package, out name);
if (string.IsNullOrEmpty(package) &&
(type.IsSubclassOf("Android.App.Activity", cache) ||
type.IsSubclassOf("Android.App.Application", cache) ||
type.IsSubclassOf("Android.App.Service", cache) ||
type.IsSubclassOf("Android.Content.BroadcastReceiver", cache) ||
type.IsSubclassOf("Android.Content.ContentProvider", cache)))
{
Diagnostic.Error(4203, LookupSource(type), Localization.Resources.JavaCallableWrappers_XA4203, jniName);
}
foreach (MethodDefinition minfo in type.Methods.Where(m => !m.IsConstructor))
{
var baseRegisteredMethod = GetBaseRegisteredMethod(minfo);
if (baseRegisteredMethod != null)
{
AddMethod(baseRegisteredMethod, minfo);
}
else if (GetExportFieldAttributes(minfo).Any())
{
AddMethod(null, minfo);
HasExport = true;
}
else if (GetExportAttributes(minfo).Any())
{
AddMethod(null, minfo);
HasExport = true;
}
}
foreach (MethodDefinition imethod in type.Interfaces.Select(ifaceInfo => ifaceInfo.InterfaceType)
.Select(r => {
var d = r.Resolve();
if (d == null)
{
Diagnostic.Error(4204,
LookupSource(type),
Localization.Resources.JavaCallableWrappers_XA4204,
r.FullName);
}
return(d);
})
.Where(d => GetRegisterAttributes(d).Any())
.SelectMany(d => d.Methods)
.Where(m => !m.IsStatic))
{
AddMethod(imethod, imethod);
}
var ctorTypes = new List <TypeDefinition> ()
{
type,
};
foreach (var bt in type.GetBaseTypes(cache))
{
ctorTypes.Add(bt);
RegisterAttribute rattr = GetRegisterAttributes(bt).FirstOrDefault();
if (rattr != null && rattr.DoNotGenerateAcw)
{
break;
}
}
ctorTypes.Reverse();
var curCtors = new List <MethodDefinition> ();
foreach (MethodDefinition minfo in type.Methods.Where(m => m.IsConstructor))
{
if (GetExportAttributes(minfo).Any())
{
if (minfo.IsStatic)
{
// Diagnostic.Warning (log, "ExportAttribute does not work on static constructor");
}
else
{
AddConstructor(minfo, ctorTypes [0], outerType, null, curCtors, false, true);
HasExport = true;
}
}
}
AddConstructors(ctorTypes [0], outerType, null, curCtors, true);
for (int i = 1; i < ctorTypes.Count; ++i)
{
var baseCtors = curCtors;
curCtors = new List <MethodDefinition> ();
AddConstructors(ctorTypes [i], outerType, baseCtors, curCtors, false);
}
}
public JavaCallableWrapperGenerator(TypeDefinition type, Action <string, object[]> log, IMetadataResolver resolver)
: this(type, null, log, resolver)
{
if (type.HasNestedTypes)
{
children = new List <JavaCallableWrapperGenerator> ();
AddNestedTypes(type);
}
}
public override Expression VisitLambdaParameterDeclaration(ILambdaParameterDeclaration lambdaParameterDeclarationParam, IMetadataResolver context)
{
return(new ParameterExpressionBuilder(lambdaParameterDeclarationParam, context).Build());
}
public InstanceBuilderServiceProvider(object target, object property, IMetadataResolver metadataResolver)
{
this.provideValueTarget = new InstanceBuilderOperations.InstanceBuilderServiceProvider.ProvideValueTarget(target, property);
this.metadataResolver = metadataResolver;
}
public override Expression VisitUnaryOperatorExpression(IUnaryOperatorExpression unaryOperatorExpressionParam, IMetadataResolver context)
{
Expression operandExpression = unaryOperatorExpressionParam.Operand.Accept(this, context);
return(new UnaryOperatorExpressionBuilder(unaryOperatorExpressionParam, operandExpression).Build());
}
public FixAbstractMethodsStep(IMetadataResolver cache)
{
this.cache = cache;
}
public override Expression VisitParenthesizedExpression(IParenthesizedExpression parenthesizedExpressionParam, IMetadataResolver context)
{
return(parenthesizedExpressionParam.Expression.Accept(this, context));
}
public static bool TryGetBaseOrInterfaceRegisterMember(this MethodDefinition method, IMetadataResolver resolver, out string member, out string nativeMethod, out string signature)
{
var type = method.DeclaringType;
member = nativeMethod = signature = null;
if (method.IsConstructor || type == null || !type.HasNestedTypes)
{
return(false);
}
var m = method.GetBaseDefinition(resolver);
while (m != null)
{
if (m == method)
{
break;
}
method = m;
if (m.TryGetRegisterMember(out member, out nativeMethod, out signature))
{
return(true);
}
m = m.GetBaseDefinition(resolver);
}
if (!method.DeclaringType.HasInterfaces || !method.IsNewSlot)
{
return(false);
}
foreach (var iface in method.DeclaringType.Interfaces)
{
if (iface.InterfaceType.IsGenericInstance)
{
continue;
}
var itype = iface.InterfaceType.Resolve();
if (itype == null || !itype.HasMethods)
{
continue;
}
foreach (var im in itype.Methods)
{
if (im.IsEqual(method, resolver))
{
return(im.TryGetRegisterMember(out member, out nativeMethod, out signature));
}
}
}
return(false);
}
public override Expression VisitBinaryExpression(IBinaryExpression binaryExpressionParam, IMetadataResolver context)
{
Expression left = binaryExpressionParam.LeftOperand.Accept(this, context);
Expression right = binaryExpressionParam.RightOperand.Accept(this, context);
return(new BinaryExpressionBuilder(binaryExpressionParam, left, right).Build());
}
internal DllData(string dir, DllConfig config)
{
_config = config;
_dir = dir;
AddSearchDirectory(dir);
_metadataResolver = new MetadataResolver(this);
_readerParams = new ReaderParameters(ReadingMode.Immediate)
{
AssemblyResolver = this,
MetadataResolver = _metadataResolver
};
var modules = new List <ModuleDefinition>();
foreach (var file in Directory.GetFiles(dir))
{
if (file.EndsWith(".dll") && !_config.BlacklistDlls.Contains(file))
{
var assemb = AssemblyDefinition.ReadAssembly(file, _readerParams);
foreach (var module in assemb.Modules)
{
modules.Add(module);
}
}
}
Queue <TypeDefinition> frontier = new Queue <TypeDefinition>();
modules.ForEach(m => m.Types.ToList().ForEach(t =>
{
if (_config.ParseTypes && !_config.BlacklistTypes.Contains(t.Name))
{
frontier.Enqueue(t);
}
}));
while (frontier.Count > 0)
{
var t = frontier.Dequeue();
if (t.Name.StartsWith("<") && t.Namespace.Length == 0 && t.DeclaringType is null)
{
if (!t.Name.StartsWith("<Module>") && !t.Name.StartsWith("<PrivateImplementationDetails>"))
{
Console.Error.WriteLine($"Skipping TypeDefinition {t}");
}
continue;
}
var dllRef = DllTypeRef.From(t);
if (!_types.ContainsKey(dllRef))
{
var type = new DllTypeData(t, _config);
if (dllRef.DeclaringType != null)
{
_types[dllRef.DeclaringType].NestedTypes.AddOrThrow(type);
}
foreach (var nested in t.NestedTypes)
{
frontier.Enqueue(nested);
}
_types.Add(dllRef, type);
}
else
{
Console.Error.WriteLine($"{dllRef} already in _types! Matching item: {_types[dllRef].This}");
}
}
int total = DllTypeRef.Hits + DllTypeRef.Misses;
Console.WriteLine($"{nameof(DllTypeRef)} cache hits: {DllTypeRef.Hits} / {total} = {100.0f * DllTypeRef.Hits / total}");
// Ignore images for now.
}
public override Expression VisitInvocationExpression(IInvocationExpression invocationExpressionParam, IMetadataResolver context)
{
var result = invocationExpressionParam.InvocationExpressionReference.Resolve().Result;
ExtensionInstance <IDeclaredElement> extension = result.ElementAsExtension();
return(invocationExpressionParam.InvokedExpression.Accept(this, context));
}
public TypeNameMapGenerator(IEnumerable <TypeDefinition> types, Action <TraceLevel, string> logger, IMetadataResolver resolver)
{
if (types == null)
{
throw new ArgumentNullException("types");
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
Cache = resolver ?? new TypeDefinitionCache();
Log = logger;
Types = types.ToList();
}
public override Expression VisitReferenceExpression(IReferenceExpression referenceExpressionParam, IMetadataResolver context)
{
if (referenceExpressionParam.QualifierExpression != null)
{
Expression qualifierExpression = referenceExpressionParam.QualifierExpression.Accept(this, context);
var invocationExpression = referenceExpressionParam.Parent as IInvocationExpression;
if (invocationExpression != null)
{
IEnumerable <Expression> arguments = invocationExpression.ArgumentList.Arguments.Select(
argument => argument.Accept(this, context));
return(new MethodCallExpressionBuilder(referenceExpressionParam, qualifierExpression, arguments, context).Build());
}
return(new MemberReferenceExpressionBuilder(referenceExpressionParam, qualifierExpression, context).Build());
}
ResolveResultWithInfo resolve = referenceExpressionParam.Reference.Resolve();
var lambdaParameterDeclaration = resolve.DeclaredElement as ILambdaParameterDeclaration;
if (lambdaParameterDeclaration != null)
{
return(lambdaParameters.First(
parameter => parameter.Name.Equals(lambdaParameterDeclaration.NameIdentifier.GetText())));
}
var parameterDeclaration = resolve.DeclaredElement as IParameterDeclaration;
if (parameterDeclaration != null)
{
return(new ParameterExpressionBuilder(parameterDeclaration, context).Build());
}
return(base.VisitReferenceExpression(referenceExpressionParam, context));
}
public CalcVisitor(IMetadataResolver resolver)
{
this._resolver = resolver;
}
public AddKeepAlivesStep(IMetadataResolver cache)
{
this.cache = cache;
}
