/// <summary>
/// Converts a generic value to a strongly typed value
/// </summary>
/// <param name="value">The value to convert</param>
/// <param name="schema">The schema of the value</param>
/// <returns>The strongly typed vlaue</returns>
private T _valueAs <T>(GenericValue value)
{
var schema = Value <T> .Schema;
var stream = value.Provider.CreateStream(value, schema);
return(Value <T> .Loader(stream));
}
public int Execute()
{
ExecutionEngine executionEngine = (ExecutionEngine)_input.GetVMModuleArtifact();
Value mainFunc = executionEngine.FindFunction(_job._entry);
if (!mainFunc.IsValid)
{
throw Diagnostics.ThrowError($"Unable to find '{_job._entry}' function in VM modules");
}
GenericValue[] args = new GenericValue[_job._argsToPass.Count];
for (int i = 0, iend = _job._argsToPass.Count; i < iend; ++i)
{
args[i] = _toolchain.CreateIntGenericValue(_job._argsToPass[i]);
}
using GenericValue retVal = executionEngine.RunFunction(mainFunc, args);
foreach (GenericValue arg in args)
{
arg.Dispose();
}
return((int)retVal.IntValue(true));
}
public ListOfSelectionCriteriaType(PropertyIdentifier propertyIdentifier, Option <uint> propertyArrayIndex, RelationSpecifierType relationSpecifier, GenericValue comparisonValue)
{
this.PropertyIdentifier = propertyIdentifier;
this.PropertyArrayIndex = propertyArrayIndex;
this.RelationSpecifier = relationSpecifier;
this.ComparisonValue = comparisonValue;
}
public AddListElementRequest(ObjectId objectIdentifier, PropertyIdentifier propertyIdentifier, Option<uint> propertyArrayIndex, GenericValue listOfElements)
{
this.ObjectIdentifier = objectIdentifier;
this.PropertyIdentifier = propertyIdentifier;
this.PropertyArrayIndex = propertyArrayIndex;
this.ListOfElements = listOfElements;
}
public AddListElementRequest(ObjectId objectIdentifier, PropertyIdentifier propertyIdentifier, Option <uint> propertyArrayIndex, GenericValue listOfElements)
{
this.ObjectIdentifier = objectIdentifier;
this.PropertyIdentifier = propertyIdentifier;
this.PropertyArrayIndex = propertyArrayIndex;
this.ListOfElements = listOfElements;
}
public ReadPropertyAck(ObjectId objectIdentifier, PropertyIdentifier propertyIdentifier, Option<uint> propertyArrayIndex, GenericValue propertyValue)
{
this.ObjectIdentifier = objectIdentifier;
this.PropertyIdentifier = propertyIdentifier;
this.PropertyArrayIndex = propertyArrayIndex;
this.PropertyValue = propertyValue;
}
public ReadPropertyAck(ObjectId objectIdentifier, PropertyIdentifier propertyIdentifier, Option <uint> propertyArrayIndex, GenericValue propertyValue)
{
this.ObjectIdentifier = objectIdentifier;
this.PropertyIdentifier = propertyIdentifier;
this.PropertyArrayIndex = propertyArrayIndex;
this.PropertyValue = propertyValue;
}
public PropertyValue(PropertyIdentifier propertyIdentifier, Option<uint> propertyArrayIndex, GenericValue value, Option<uint> priority)
{
this.PropertyIdentifier = propertyIdentifier;
this.PropertyArrayIndex = propertyArrayIndex;
this.Value = value;
this.Priority = priority;
}
public IntegratorVariable(NxtRobot owner, int noOfSamples, Variable yVar, Variable xVar = null)
{
Enabled = true;
// set owner
Owner = owner;
// set number of samples to hold
NoOfSamples = noOfSamples;
// set independant variable if not 'sample count'
XVar = xVar;
// set dependant/measured variable
YVar = yVar;
// initialize 'x' and 'y' stacks for sampled values
XVarValues = new Stack <int>(NoOfSamples);
YVarValues = new Stack <int>(NoOfSamples);
// update name of object to describe the interpolation
if (XVar != null)
{
Name = "Distance of '" + YVar.Name + "' over distance of '" + XVar.Name + "' over last " + NoOfSamples + " samples.";
}
else
{
Name = "Distance of '" + YVar.Name + "' over last " + NoOfSamples + " samples.";
}
// create value obj with appropriate min and max limits
Value = new GenericValue(YVar.Value.MinimumAllowableValue, yVar.Value.MaximumAllowableValue * NoOfSamples, YVar.Value.Units);
}
/// <summary>
/// Attempts to interpret a TaggedGenericType instance as
/// a specific type
/// </summary>
/// <param name="value">The value to interpet</param>
/// <param name="schema">The type to interpret as</param>
/// <param name="output">The output type</param>
/// <returns>True if the interpretation succeeds, false otherwise</returns>
public IValueStream CreateStream(GenericValue value, ISchema schema)
{
var tagged = (TaggedGenericValue)value;
MemoryStream ms = new MemoryStream(tagged.tag, tagged.offset, tagged.end - tagged.offset);
TagReader reader = new TagReader(ms);
TagReaderStream stream = new TagReaderStream(reader, schema);
return stream;
}
public Variable(string name, GenericValue value, NxtRobot owner)
{
Enabled = true;
Name = name;
_value = value;
value.ValueHasBeenUpdated += InformOfValueChange;
Owner = owner;
}
public DeviceObjectPropertyValue(ObjectId deviceIdentifier, ObjectId objectIdentifier, PropertyIdentifier propertyIdentifier, Option <uint> arrayIndex, GenericValue value)
{
this.DeviceIdentifier = deviceIdentifier;
this.ObjectIdentifier = objectIdentifier;
this.PropertyIdentifier = propertyIdentifier;
this.ArrayIndex = arrayIndex;
this.Value = value;
}
public WritePropertyRequest(ObjectId objectIdentifier, PropertyIdentifier propertyIdentifier, Option<uint> propertyArrayIndex, GenericValue propertyValue, Option<byte> priority)
{
this.ObjectIdentifier = objectIdentifier;
this.PropertyIdentifier = propertyIdentifier;
this.PropertyArrayIndex = propertyArrayIndex;
this.PropertyValue = propertyValue;
this.Priority = priority;
}
public Variable(string name, GenericValue value, NxtRobot owner)
{
Enabled = true;
Name = name;
Value = value;
value.ValueHasBeenUpdated += _ValueHasBeenUpdated;
Owner = owner;
}
public DeviceObjectPropertyValue(ObjectId deviceIdentifier, ObjectId objectIdentifier, PropertyIdentifier propertyIdentifier, Option<uint> arrayIndex, GenericValue value)
{
this.DeviceIdentifier = deviceIdentifier;
this.ObjectIdentifier = objectIdentifier;
this.PropertyIdentifier = propertyIdentifier;
this.ArrayIndex = arrayIndex;
this.Value = value;
}
/// <summary>
/// Attempts to interpret a TaggedGenericType instance as
/// a specific type
/// </summary>
/// <param name="value">The value to interpet</param>
/// <param name="schema">The type to interpret as</param>
/// <param name="output">The output type</param>
/// <returns>True if the interpretation succeeds, false otherwise</returns>
public IValueStream CreateStream(GenericValue value, ISchema schema)
{
var tagged = (TaggedGenericValue)value;
MemoryStream ms = new MemoryStream(tagged.tag, tagged.offset, tagged.end - tagged.offset);
TagReader reader = new TagReader(ms);
TagReaderStream stream = new TagReaderStream(reader, schema);
return(stream);
}
public ActionCommand(Option<ObjectId> deviceIdentifier, ObjectId objectIdentifier, PropertyIdentifier propertyIdentifier, Option<uint> propertyArrayIndex, GenericValue propertyValue, Option<uint> priority, Option<uint> postDelay, bool quitOnFailure, bool writeSuccessful)
{
this.DeviceIdentifier = deviceIdentifier;
this.ObjectIdentifier = objectIdentifier;
this.PropertyIdentifier = propertyIdentifier;
this.PropertyArrayIndex = propertyArrayIndex;
this.PropertyValue = propertyValue;
this.Priority = priority;
this.PostDelay = postDelay;
this.QuitOnFailure = quitOnFailure;
this.WriteSuccessful = writeSuccessful;
}
public IJoinOperation JoinOperationFactory(ActivityContext context)
{
InArgument expr_06 = this.Operand;
object obj = (expr_06 != null) ? expr_06.Get(context) : null;
GenericValue value;
if ((value = (obj as GenericValue)) != (GenericValue)null)
{
obj = GenericValue.GetRawValue(value);
}
if (this.Operator == JoinOperator.EQ)
{
return(new EqualsOperation
{
Operand = obj
});
}
if (this.Operator == JoinOperator.NOTEQ)
{
return(new NotEqualsOperation
{
Operand = obj
});
}
IComparable operand = obj as IComparable;
switch (this.Operator)
{
//case JoinOperator.LT:
// return new LessThanOperation
// {
// Operand = operand
// };
//case JoinOperator.GT:
// return new GreaterThanOperation
// {
// Operand = operand
// };
//case JoinOperator.LTE:
// return new LessThanOrEqualOperation
// {
// Operand = operand
// };
//case JoinOperator.GTE:
// return new GreaterThanOrEqualOperation
// {
// Operand = operand
// };
default:
return(null);
}
}
/// <summary>
/// Writes a generic value to the stream
/// </summary>
/// <param name="value">The value to write</param>
/// <param name="tag">The wrapper tag number, or 255 for no wrapper tag</param>
public void WriteGeneric(GenericValue value, byte tag = 255)
{
var tvalue = value as TaggedGenericValue;
if (tvalue == null)
{
throw new Exception("Can only write TaggedGenericValue instances");
}
_writeTypeHeader(tag, TagType.Open);
_writer.Write(tvalue.tag, 0, tvalue.tag.Length);
_writeTypeHeader(tag, TagType.Close);
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (value != null && value.GetType().IsAssignableFrom(destinationType))
{
return(value);
}
GenericValue genericValue = (GenericValue)value;
if (genericValue != null as GenericValue && genericValue.RawValue != null && genericValue.RawValue.GetType().IsAssignableFrom(destinationType))
{
return(genericValue.RawValue);
}
return(base.ConvertTo(context, culture, value, destinationType));
}
public override Value Process(Node n)
{
InitTypeMap();
LLVM.Native.LinkInJIT();
//LLVM.Native.InitializeNativeTarget(); // Declared in bindings but not exported from the shared library.
LLVM.Native.InitializeX86TargetInfo();
LLVM.Native.InitializeX86Target();
LLVM.Native.InitializeX86TargetMC();
using (module = new Module("llvm compiler"))
using (builder = new IRBuilder())
{
execEngine = new ExecutionEngine(module);
passManager = new PassManager(module);
passManager.AddTargetData(execEngine.GetTargetData());
// optimizations
#if false
passManager.AddBasicAliasAnalysisPass();
passManager.AddPromoteMemoryToRegisterPass();
passManager.AddInstructionCombiningPass();
passManager.AddReassociatePass();
passManager.AddGVNPass();
passManager.AddCFGSimplificationPass();
#endif
passManager.Initialize();
// main = EmitTestLLVMIR();
Value valRet = traverse(n);
module.Dump();
// if (valRet.Equals(Value.Null))
// return Value.Null;
GenericValue val = execEngine.RunFunction(evalCtx.main, new GenericValue[0]);
Console.WriteLine("Evaluated to " + val.ToUInt());
}
return(default(Value));
}
public static int?GetColumnIndex(this DataTable dt, object argumentValue, bool throwIfNotFound = false)
{
int?result = null;
if (dt == null || argumentValue == null)
{
result = null;
}
if (argumentValue != null)
{
GenericValue value = argumentValue as GenericValue;
argumentValue = GenericValue.GetRawValue(value);
}
int? num = argumentValue as int?;
DataColumn dataColumn = argumentValue as DataColumn;
string text = argumentValue as string;
text = (string.IsNullOrEmpty(text) ? null : text);
if (dataColumn != null)
{
num = new int?(dt.Columns.IndexOf(dataColumn));
}
if (text != null)
{
num = new int?(dt.Columns.IndexOf(text));
}
if (num.HasValue)
{
result = ((num < 0 || dt.Columns.Count <= num) ? null : num);
}
if (!result.HasValue & throwIfNotFound)
{
string text2 = (argumentValue is string) ?
string.Format("ValueNotSetForArgument", "ColumnName") : ((argumentValue is int) ?
string.Format("ValueNotSetForArgument", "ColumnIndex") : string.Format("ValueNotSetForArgument", "Column"));
text2 = char.ToLowerInvariant(text2[0]).ToString() + text2.Substring(1);
throw new ArgumentException(text2);
}
return(result);
}
public AnyValueWrapper(GenericValue item)
{
this.Item = item;
}
public WritePropertyRequest(ObjectId objectIdentifier, PropertyIdentifier propertyIdentifier, Option <uint> propertyArrayIndex, GenericValue propertyValue, Option <byte> priority)
{
this.ObjectIdentifier = objectIdentifier;
this.PropertyIdentifier = propertyIdentifier;
this.PropertyArrayIndex = propertyArrayIndex;
this.PropertyValue = propertyValue;
this.Priority = priority;
}
public ConstructedValueWrapper(GenericValue item)
{
this.Item = item;
}
public static NotificationParameters NewCommandFailure(GenericValue commandValue, StatusFlags statusFlags, GenericValue feedbackValue)
{
return(new CommandFailure(commandValue, statusFlags, feedbackValue));
}
public static PriorityValue NewConstructedValue(GenericValue constructedValue)
{
return new ConstructedValueWrapper(constructedValue);
}
public IFilterOperation FilterOperationFactory(DataTable datatable, ActivityContext context)
{
InArgument expr_06 = this.Operand;
object obj = (expr_06 != null) ? expr_06.Get(context) : null;
if (obj != null)
{
GenericValue genericValue = obj as GenericValue;
obj = GenericValue.GetRawValue(genericValue);
}
if (this.Operator == FilterOperator.EQ)
{
return(new EqualsOperation
{
Operand = obj
});
}
if (this.Operator == FilterOperator.NOTEQ)
{
return(new NotEqualsOperation
{
Operand = obj
});
}
if (this.IsStringOperation)
{
string operand = obj as string;
switch (this.Operator)
{
case FilterOperator.EMPTY:
return(new IsEmptyOperation());
case FilterOperator.NOTEMPTY:
return(new IsEmptyOperation
{
IsNegation = true
});
case FilterOperator.STARTSWITH:
return(new StartsWithOperation
{
Operand = operand
});
case FilterOperator.ENDSWITH:
return(new EndsWithOperation
{
Operand = operand
});
case FilterOperator.CONTAINS:
return(new ContainsOperation
{
Operand = operand
});
case FilterOperator.NOTSTARTSWITH:
return(new StartsWithOperation
{
Operand = operand,
IsNegation = true
});
case FilterOperator.NOTENDSWITH:
return(new EndsWithOperation
{
Operand = operand,
IsNegation = true
});
case FilterOperator.NOTCONTAINS:
return(new ContainsOperation
{
Operand = operand,
IsNegation = true
});
default:
return(null);
}
}
else
{
IComparable operand2 = obj as IComparable;
switch (this.Operator)
{
case FilterOperator.LT:
return(new LessThanOperation
{
Operand = operand2
});
case FilterOperator.GT:
return(new GreaterThanOperation
{
Operand = operand2
});
case FilterOperator.LTE:
return(new LessThanOrEqualOperation
{
Operand = operand2
});
case FilterOperator.GTE:
return(new GreaterThanOrEqualOperation
{
Operand = operand2
});
default:
return(null);
}
}
}
public TimeValue(Time time, GenericValue value)
{
this.Time = time;
this.Value = value;
}
public static NotificationParameters NewCommandFailure(GenericValue commandValue, StatusFlags statusFlags, GenericValue feedbackValue)
{
return new CommandFailure(commandValue, statusFlags, feedbackValue);
}
//---------------------------------------------------------------------
public GenericValue(GenericValue src)
{
this.value = src.value;
}
/// <summary>
/// Puts a value into the sink
/// </summary>
/// <param name="value">The value to put</param>
public void PutGeneric(GenericValue value)
{
_require(StreamOp.Generic);
_writer.WriteGeneric(value, _state.Tag);
_moveNext();
}
/// <summary>
/// Puts a value into the sink
/// </summary>
/// <param name="value">The value to put</param>
public void PutGeneric(GenericValue value)
{
_require(StreamOp.Generic);
_writer.WriteGeneric(value, _state.Tag);
_moveNext();
}
/// <summary>
/// Writes a generic value to the stream
/// </summary>
/// <param name="value">The value to write</param>
/// <param name="tag">The wrapper tag number, or 255 for no wrapper tag</param>
public void WriteGeneric(GenericValue value, byte tag = 255)
{
var tvalue = value as TaggedGenericValue;
if (tvalue == null)
throw new Exception("Can only write TaggedGenericValue instances");
_writeTypeHeader(tag, TagType.Open);
_writer.Write(tvalue.tag, 0, tvalue.tag.Length);
_writeTypeHeader(tag, TagType.Close);
}
public WritePropertyRequest(ObjectId objectIdentifier, PropertyIdentifier propertyIdentifier, Option <uint> propertyArrayIndex, GenericValue propertyValue)
: this(objectIdentifier, propertyIdentifier, propertyArrayIndex, propertyValue, Option <byte> .None)
{
}
public static ReadResultType NewPropertyValue(GenericValue propertyValue)
{
return new PropertyValueWrapper(propertyValue);
}
public ConstructedValueWrapper(GenericValue item)
{
this.Item = item;
}
public static LogDatumType NewAnyValue(GenericValue anyValue)
{
return(new AnyValueWrapper(anyValue));
}
public static PriorityValue NewConstructedValue(GenericValue constructedValue)
{
return(new ConstructedValueWrapper(constructedValue));
}
public AnyValueWrapper(GenericValue item)
{
this.Item = item;
}
public CommandFailure(GenericValue commandValue, StatusFlags statusFlags, GenericValue feedbackValue)
{
this.CommandValue = commandValue;
this.StatusFlags = statusFlags;
this.FeedbackValue = feedbackValue;
}
public PropertyValue(PropertyIdentifier propertyIdentifier, Option <uint> propertyArrayIndex, GenericValue value, Option <uint> priority)
{
this.PropertyIdentifier = propertyIdentifier;
this.PropertyArrayIndex = propertyArrayIndex;
this.Value = value;
this.Priority = priority;
}
public ListOfSelectionCriteriaType(PropertyIdentifier propertyIdentifier, Option<uint> propertyArrayIndex, RelationSpecifierType relationSpecifier, GenericValue comparisonValue)
{
this.PropertyIdentifier = propertyIdentifier;
this.PropertyArrayIndex = propertyArrayIndex;
this.RelationSpecifier = relationSpecifier;
this.ComparisonValue = comparisonValue;
}
public PropertyValueWrapper(GenericValue item)
{
this.Item = item;
}
public WritePropertyRequest(ObjectId objectIdentifier, PropertyIdentifier propertyIdentifier, Option<uint> propertyArrayIndex, GenericValue propertyValue)
: this(objectIdentifier, propertyIdentifier, propertyArrayIndex, propertyValue, Option<byte>.None)
{
}
internal GenericValue CreateIntGenericValue(int val) => GenericValue.FromInt(_context.Int32Type, (ulong)val, true);
public static ReadResultType NewPropertyValue(GenericValue propertyValue)
{
return(new PropertyValueWrapper(propertyValue));
}
public static LogDatumType NewAnyValue(GenericValue anyValue)
{
return new AnyValueWrapper(anyValue);
}
public CommandFailure(GenericValue commandValue, StatusFlags statusFlags, GenericValue feedbackValue)
{
this.CommandValue = commandValue;
this.StatusFlags = statusFlags;
this.FeedbackValue = feedbackValue;
}
public PropertyValueWrapper(GenericValue item)
{
this.Item = item;
}
