private WasmFunctionDefinition MakeInterpreterThunk(int index, FunctionBody body, ILGenerator generator)
{
var signature = types[index];
// Create an interpreted function definition.
var func = new WasmFunctionDefinition(signature, body, module);
// Call it.
EmitExternalCall(
generator,
signature.ParameterTypes.Count,
func,
signature.ParameterTypes
.Select <WasmValueType, Func <ILGenerator, Type> >(
(p, i) => gen =>
{
gen.Emit(OpCodes.Ldarg, i);
return(ValueHelpers.ToClrType(p));
})
.ToArray());
// Return.
generator.Emit(OpCodes.Ret);
return(func);
}
private string PrepareSinglePayload(int i)
{
var serializerSettings = new JsonSerializerSettings();
serializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
string json = JsonConvert.SerializeObject(ValueHelpers.GenerateUser(i.ToString()), serializerSettings);
return(json);
}
public override void Add(CimProperty newProperty)
{
if (newProperty == null)
{
throw new ArgumentNullException("newProperty");
}
MI_Result result = this._instance.InstanceHandle.AddElement(
newProperty.Name,
ValueHelpers.ConvertToNativeLayer(newProperty.Value, newProperty.CimType),
newProperty.CimType.FromCimType(),
newProperty.Flags.FromCimFlags());
CimException.ThrowIfMiResultFailure(result);
}
private CimPropertyStandalone GetProperty()
{
string name;
MI_Value value;
MI_Type type;
MI_Flags flags;
MI_Result result = this._instance.InstanceHandle.GetElementAt((uint)this._index,
out name,
out value,
out type,
out flags);
CimException.ThrowIfMiResultFailure(result);
var convertedValue = ValueHelpers.ConvertFromNativeLayer(value, type, flags);
return(new CimPropertyStandalone(name, convertedValue, type.ToCimType(), flags.ToCimFlags()));
}
/// <inheritdoc/>
public override void Initialize(ModuleInstance module, int offset, IReadOnlyList <FunctionType> types)
{
this.module = module;
this.offset = offset;
this.types = types;
this.helperFieldIndex = 0;
this.constFieldValues = new Dictionary <FieldInfo, object>();
this.functionDefinitions = new List <CompiledFunctionDefinition>();
this.assembly = AssemblyBuilder.DefineDynamicAssembly(
new AssemblyName("wasm"),
AssemblyBuilderAccess.RunAndCollect);
var wasmModule = assembly.DefineDynamicModule("main");
this.wasmType = wasmModule.DefineType("CompiledWasm", TypeAttributes.Public | TypeAttributes.Sealed);
var builderList = new List <MethodBuilder>();
var wrapperList = new List <Func <IReadOnlyList <object>, IReadOnlyList <object> > >();
foreach (var signature in types)
{
var methodDef = wasmType.DefineMethod(
$"func_{builderList.Count}",
MethodAttributes.Public | MethodAttributes.Static);
methodDef.SetParameters(
signature.ParameterTypes.Select(ValueHelpers.ToClrType)
.Concat(new[] { typeof(uint) })
.ToArray());
if (signature.ReturnTypes.Count == 0)
{
methodDef.SetReturnType(typeof(void));
}
else if (signature.ReturnTypes.Count == 1)
{
methodDef.SetReturnType(ValueHelpers.ToClrType(signature.ReturnTypes[0]));
}
else
{
throw new WasmException("Cannot compile functions with more than one return value.");
}
builderList.Add(methodDef);
}
this.builders = builderList;
this.wrappers = wrapperList;
}
/// <summary>
/// Sets a custom server or CIM provider option
/// </summary>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="optionName"/> is <c>null</c></exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="optionName"/> or <paramref name="optionValue"/> is <c>null</c></exception>
public void SetCustomOption(string optionName, object optionValue, CimType cimType, bool mustComply)
{
if (string.IsNullOrWhiteSpace(optionName))
{
throw new ArgumentNullException("optionName");
}
if (optionValue == null)
{
throw new ArgumentNullException("optionValue");
}
this.AssertNotDisposed();
MI_Value nativeLayerValue;
try
{
nativeLayerValue = ValueHelpers.ConvertToNativeLayer(optionValue, cimType);
ValueHelpers.ThrowIfMismatchedType(cimType.FromCimType(), nativeLayerValue);
}
catch (InvalidCastException e)
{
throw new ArgumentException(e.Message, "optionValue", e);
}
catch (FormatException e)
{
throw new ArgumentException(e.Message, "optionValue", e);
}
catch (ArgumentException e)
{
throw new ArgumentException(e.Message, "optionValue", e);
}
MI_OperationOptionsFlags flags = MI_OperationOptionsFlags.Unused;
MI_Result result = this.OperationOptionsHandleOnDemand.SetCustomOption(
optionName,
cimType.FromCimType(),
nativeLayerValue,
mustComply,
flags);
CimException.ThrowIfMiResultFailure(result);
}
private static InstructionImpl ImplementAsCall(MethodInfo callee)
{
return((context, gen) =>
{
var parameterTypes = callee.GetParameters().Select(p => ValueHelpers.ToWasmValueType(p.ParameterType)).ToArray();
var paramTypesOnStack = context.Pop(parameterTypes.Length);
for (int i = 0; i < parameterTypes.Length; i++)
{
if (parameterTypes[i] != paramTypesOnStack[i])
{
throw new InvalidOperationException($"Expected type '{parameterTypes[i]}' on stack for argument {i} of method '{callee}', but got type '{paramTypesOnStack[i]}' instead.");
}
}
gen.Emit(OpCodes.Call, callee);
if (callee.ReturnType != null && callee.ReturnType != typeof(void))
{
context.Push(ValueHelpers.ToWasmValueType(callee.ReturnType));
}
});
}
private string PrepareBulkPayload(int size)
{
var serializerSettings = new JsonSerializerSettings();
serializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var indexJson = new { Index = new object() };
var serializedIndexJson = JsonConvert.SerializeObject(indexJson, serializerSettings);
var payload = new StringBuilder();
for (int i = 1; i <= size; i++)
{
var user = ValueHelpers.GenerateUser(i.ToString());
string userJson = JsonConvert.SerializeObject(user, serializerSettings);
payload.Append(serializedIndexJson);
payload.Append(Environment.NewLine);
payload.Append(userJson);
payload.Append(Environment.NewLine);
}
return(payload.ToString());
}
private bool TryCompile(FunctionType signature, FunctionBody body, ILGenerator generator)
{
var impl = GetImplementationOrNull(body.BodyInstructions);
if (impl == null)
{
return(false);
}
else
{
var locals = new Dictionary <uint, LocalBuilder>();
var localTypes = new List <WasmValueType>(signature.ParameterTypes);
uint localIndex = (uint)signature.ParameterTypes.Count;
foreach (var item in body.Locals)
{
for (uint i = 0; i < item.LocalCount; i++)
{
locals[localIndex++] = generator.DeclareLocal(ValueHelpers.ToClrType(item.LocalType));
localTypes.Add(item.LocalType);
}
}
var context = new CompilerContext(this, localTypes, signature.ParameterTypes.Count, locals);
// Increment the call stack depth.
generator.Emit(OpCodes.Ldarg, signature.ParameterTypes.Count);
generator.Emit(OpCodes.Ldc_I4_1);
generator.Emit(OpCodes.Add);
generator.Emit(OpCodes.Starg, signature.ParameterTypes.Count);
// Emit the method body.
impl(context, generator);
// Return.
generator.Emit(OpCodes.Ret);
return(true);
}
}
/// <summary>
/// Compiles a 'select' instruction.
/// </summary>
/// <param name="instruction">The instruction to compile to an implementation.</param>
public static InstructionImpl Select(Instruction instruction)
{
return((context, gen) =>
{
context.Pop();
var rhsType = context.Pop();
var lhsType = context.Pop();
var ifLabel = gen.DefineLabel();
var endLabel = gen.DefineLabel();
gen.Emit(OpCodes.Brtrue, ifLabel);
var rhsLocal = gen.DeclareLocal(ValueHelpers.ToClrType(rhsType));
gen.Emit(OpCodes.Stloc, rhsLocal);
gen.Emit(OpCodes.Pop);
gen.Emit(OpCodes.Ldloc, rhsLocal);
gen.Emit(OpCodes.Br, endLabel);
gen.MarkLabel(ifLabel);
gen.Emit(OpCodes.Pop);
gen.MarkLabel(endLabel);
context.Push(lhsType);
});
}
private object EvaluateConstExpr(SExpression expression, Type resultType)
{
return(EvaluateConstExpr(expression, ValueHelpers.ToWasmValueType(resultType)));
}
/// <summary>
/// Creates a filter using the given generic filter operator
/// </summary>
/// <param name="where"></param>
/// <param name="columnName"></param>
/// <param name="operator"></param>
/// <param name="value"></param>
/// <param name="valueType"></param>
/// <param name="valueTypeSize"></param>
/// <param name="stringMatchType"></param>
/// <param name="performDataTypeConversion"></param>
/// <param name="valueConverter"></param>
public static void AddFilter(this Csg.Data.IDbQueryWhereClause where, string columnName, ListFilterOperator @operator, object value, System.Data.DbType valueType, int?valueTypeSize = null, SqlWildcardDecoration stringMatchType = SqlWildcardDecoration.BeginsWith, bool performDataTypeConversion = true, Func <object, object> valueConverter = null)
{
var root = where.Root;
IEnumerable <object> values = ValueHelpers.GetFilterValues(value, valueType, shouldPerformDataTypeConversion: performDataTypeConversion, valueConverter: valueConverter);
bool isMutliValued = values != null && values.Count() > 1;
var firstValue = values.Count() > 0 ? values.First() : null;
var hasValues = values != null && values.Count() > 0;
var dataType = valueType;
int? dataTypeSize = valueTypeSize;
if (!hasValues)
{
return;
}
//handle LIKE or EQUALS filtering against nchar and char data types
if (dataType == DbType.AnsiStringFixedLength)
{
dataType = DbType.AnsiString;
dataTypeSize = null;
}
else if (dataType == DbType.StringFixedLength)
{
dataType = DbType.String;
dataTypeSize = null;
}
if (@operator == ListFilterOperator.Like)
{
if (isMutliValued)
{
var filterCollection = new Csg.Data.Sql.SqlFilterCollection();
filterCollection.Logic = Csg.Data.Sql.SqlLogic.Or;
foreach (var filterValue in values)
{
filterCollection.Add(new Csg.Data.Sql.SqlStringMatchFilter(root, columnName, stringMatchType, filterValue.ToString())
{
DataType = dataType,
Size = dataTypeSize
});
}
where.AddFilter(filterCollection);
}
else if (firstValue == null)
{
where.AddFilter(new Csg.Data.Sql.SqlNullFilter(root, columnName, true));
}
else
{
where.AddFilter(new Csg.Data.Sql.SqlStringMatchFilter(root, columnName, stringMatchType, firstValue.ToString())
{
DataType = dataType,
Size = dataTypeSize
});
}
}
else if (@operator == ListFilterOperator.Between)
{
if (!isMutliValued || values.Count() != 2)
{
throw new Exception(string.Format("Error while processing the filter values for column '{0}': A between filter must have exactly two values.", columnName));
}
var valueArray = values.ToArray();
if (valueArray[0] != null)
{
where.AddFilter(new Csg.Data.Sql.SqlCompareFilter(root, columnName, Csg.Data.Sql.SqlOperator.GreaterThanOrEqual, dataType, valueArray[0])
{
Size = dataTypeSize
});
}
if (valueArray[1] != null)
{
where.AddFilter(new Csg.Data.Sql.SqlCompareFilter(root, columnName, Csg.Data.Sql.SqlOperator.LessThanOrEqual, dataType, valueArray[1])
{
Size = dataTypeSize
});
}
}
else if (@operator == ListFilterOperator.IsNull)
{
var filterCollection = new Csg.Data.Sql.SqlFilterCollection();
filterCollection.Logic = Csg.Data.Sql.SqlLogic.Or;
foreach (var filterValue in values)
{
filterCollection.Add(new Csg.Data.Sql.SqlNullFilter(root, columnName, Convert.ToBoolean(filterValue))
{
DataType = dataType
});
}
where.AddFilter(filterCollection);
}
else
{
var nativeOperator = @operator.ToSqlOperator();
// Handle filtering on a list for exact matches
if (isMutliValued && nativeOperator == Csg.Data.Sql.SqlOperator.Equal)
{
where.AddFilter(new Csg.Data.Sql.SqlListFilter(root, columnName, dataType, values)
{
Size = dataTypeSize
});
}
// or not-in
else if (isMutliValued && nativeOperator == Csg.Data.Sql.SqlOperator.NotEqual)
{
where.AddFilter(new Csg.Data.Sql.SqlListFilter(root, columnName, dataType, values)
{
Size = dataTypeSize, NotInList = true
});
}
// handle filtering on a list for other operators (rare case)
else if (isMutliValued)
{
var filterCollection = new Csg.Data.Sql.SqlFilterCollection();
filterCollection.Logic = Csg.Data.Sql.SqlLogic.Or;
foreach (var filterValue in values)
{
filterCollection.Add(root, columnName, nativeOperator, dataType, filterValue);
}
where.AddFilter(filterCollection);
}
// handle filtering on NULL
else if (firstValue == null)
{
//TODO: Should we handle filtering on null this way, or add an explicit IsNull on the filter object?
where.AddFilter(new Csg.Data.Sql.SqlNullFilter(root, columnName, @operator == ListFilterOperator.Equal ? true : false));
}
// handle filtering on exactly one value
else
{
where.AddFilter(new Csg.Data.Sql.SqlCompareFilter(root, columnName, nativeOperator, dataType, firstValue)
{
Size = dataTypeSize
});
}
}
}
/// <summary>
/// Compiles a 'call' instruction.
/// </summary>
/// <param name="instruction">The instruction to compile to an implementation.</param>
public static InstructionImpl Call(Instruction instruction)
{
var callInsn = Operators.Call.CastInstruction(instruction);
var index = (int)callInsn.Immediate;
return((context, gen) =>
{
// Check for stack overflow.
var successLabel = gen.DefineLabel();
gen.Emit(OpCodes.Ldarg, context.ParameterCount);
gen.Emit(OpCodes.Ldc_I4, (int)context.Compiler.module.Policy.MaxCallStackDepth);
gen.Emit(OpCodes.Blt_Un, successLabel);
gen.Emit(OpCodes.Ldstr, "A stack overflow occurred: the max call stack depth was exceeded");
gen.Emit(OpCodes.Ldstr, TrapException.SpecMessages.CallStackExhausted);
gen.Emit(OpCodes.Newobj, typeof(TrapException).GetConstructor(new[] { typeof(string), typeof(string) }));
gen.Emit(OpCodes.Throw);
gen.MarkLabel(successLabel);
FunctionType signature;
if (index < context.Compiler.offset)
{
// If we're calling an import, then things get interesting. Basically, we have to emit
// a call to the import's Invoke method instead of calling the import directly as
// we can do with compiled methods.
var callee = context.Compiler.module.Functions[index];
signature = new FunctionType(callee.ParameterTypes, callee.ReturnTypes);
var args = new List <Func <ILGenerator, Type> >();
foreach (var item in callee.ParameterTypes.Reverse())
{
var loc = gen.DeclareLocal(ValueHelpers.ToClrType(item));
gen.Emit(OpCodes.Stloc, loc);
args.Add(generator =>
{
generator.Emit(OpCodes.Ldloc, loc);
return loc.LocalType;
});
}
args.Reverse();
context.Compiler.EmitExternalCall(gen, context.ParameterCount, callee, args);
}
else
{
// Push the call stack depth onto the evaluation stack.
gen.Emit(OpCodes.Ldarg, context.ParameterCount);
// Emit the call.
signature = context.Compiler.types[index - context.Compiler.offset];
var callee = context.Compiler.builders[index - context.Compiler.offset];
gen.Emit(OpCodes.Call, callee);
}
// Pop and check argument types.
var parameterTypes = signature.ParameterTypes;
var paramTypesOnStack = context.Pop(parameterTypes.Count);
for (int i = 0; i < parameterTypes.Count; i++)
{
if (parameterTypes[i] != paramTypesOnStack[i])
{
throw new InvalidOperationException($"Expected type '{parameterTypes[i]}' on stack for function call, but got type '{paramTypesOnStack[i]}' instead.");
}
}
// Update the type stack.
foreach (var item in signature.ReturnTypes)
{
context.Push(item);
}
});
}
