static Upper()
{
string description = "Converts text to uppercase.";
IEnumerable<ArgumentInfo> requiredArguments = new ArgumentInfo[]
{
new ArgumentInfo("Text", "Text is the text you want converted to uppercase. Text can be a reference or text string.", ArgumentType.Text)
};
Info = new FunctionInfo(FunctionName, FunctionCategory.Text, description, requiredArguments);
}
static Nand()
{
string description = "Returns the Sheffer stroke (or also known as the NAND operator) of two booleans.";
IEnumerable<ArgumentInfo> requiredArguments = new ArgumentInfo[]
{
new ArgumentInfo("Logical", "The first logical argument.", ArgumentType.Logical),
new ArgumentInfo("Logical", "The second logical argument.", ArgumentType.Logical)
};
Info = new FunctionInfo(FunctionName, FunctionCategory.Text, description, requiredArguments);
}
static Indirect()
{
string description = "Returns the reference of the cell specified by a text string.";
IEnumerable<ArgumentInfo> requiredArguments = new ArgumentInfo[]
{
new ArgumentInfo("Text",
"A reference to a cell that contains an A1-style reference, a name defined as a reference, or a reference to a cell as a text string.",
ArgumentType.Text),
};
Info = new FunctionInfo(FunctionName,FunctionCategory.LookupReference, description, requiredArguments);
}
/// <summary>
/// Generates stub to receive the CLR call and then call the dynamic language code.
/// </summary>
public static void EmitClrCallStub(CodeGen cg, Slot callTarget, int firstArg, CallType functionAttributes) {
List<ReturnFixer> fixers = new List<ReturnFixer>(0);
IList<Slot> args = cg.ArgumentSlots;
int nargs = args.Count - firstArg;
CallAction action;
if ((functionAttributes & CallType.ArgumentList) != 0) {
ArgumentInfo[] infos = CompilerHelpers.MakeRepeatedArray(ArgumentInfo.Simple, nargs);
infos[nargs - 1] = new ArgumentInfo(ArgumentKind.List);
action = CallAction.Make(new CallSignature(infos));
} else {
action = CallAction.Make(nargs);
}
bool fast;
Slot site = cg.CreateDynamicSite(action,
CompilerHelpers.MakeRepeatedArray(typeof(object), nargs + 2),
out fast);
site.EmitGet(cg);
if (!fast) cg.EmitCodeContext();
if (DynamicSiteHelpers.IsBigTarget(site.Type)) {
cg.EmitTuple(site.Type.GetGenericArguments()[0], args.Count + 1, delegate(int index) {
if (index == 0) {
callTarget.EmitGet(cg);
} else {
ReturnFixer rf = ReturnFixer.EmitArgument(cg, args[index - 1]);
if (rf != null) fixers.Add(rf);
}
});
} else {
callTarget.EmitGet(cg);
for (int i = firstArg; i < args.Count; i++) {
ReturnFixer rf = ReturnFixer.EmitArgument(cg, args[i]);
if (rf != null) fixers.Add(rf);
}
}
cg.EmitCall(site.Type, "Invoke");
foreach (ReturnFixer rf in fixers) {
rf.FixReturn(cg);
}
cg.EmitReturnFromObject();
}
static GeoMean()
{
string description = "Returns the geometric mean of a sequance of numbers.";
IEnumerable<ArgumentInfo> requiredArguments = new ArgumentInfo[]
{
new ArgumentInfo("Number", "Positive number", ArgumentType.Number),
};
IEnumerable<ArgumentInfo> optionalArguments = new ArgumentInfo[]
{
new ArgumentInfo("Number", "Positive number", ArgumentType.Number)
};
info = new FunctionInfo(FunctionName, FunctionCategory.Statistical, description, requiredArguments, optionalArguments, optionalArgumentsRepeatCount:255);
}
static RepeatString()
{
IEnumerable<ArgumentInfo> requiredArguments = new ArgumentInfo[]
{
new ArgumentInfo("Text", "Text is the text you want to repeat.", ArgumentType.Text)
};
IEnumerable<ArgumentInfo> optionalArguments = new ArgumentInfo[]
{
new ArgumentInfo("NumberTimes", "NumberTimes is a positive number specifying the number of times to repeat text.", ArgumentType.Number)
};
string description = "REPEAT.STRING repeats some text a desired number of times.";
Info = new FunctionInfo(FunctionName, FunctionCategory.Text, description, requiredArguments, optionalArguments, 1, false);
}
/// <summary>
/// Serializes a navigational filtering argument info into an XML file.
/// </summary>
/// <param name="writer">XMLWriter where the argument is stored.</param>
/// <param name="argument">Argument to serialize.</param>
/// <returns>Returns the XMLWriter with the argument.</returns>
public static XmlWriter Serialize(XmlWriter writer, ArgumentInfo argument)
{
writer.WriteStartElement(DTD.Request.ServiceRequest.Arguments.TagArgument);
writer.WriteAttributeString(DTD.Request.ServiceRequest.Arguments.Argument.TagName, argument.Name);
if (argument.Type == ModelType.Oid)
{
writer.WriteAttributeString(DTD.Request.ServiceRequest.Arguments.Argument.TagType, argument.ClassName);
}
else
{
writer.WriteAttributeString(DTD.Request.ServiceRequest.Arguments.Argument.TagType, Convert.MODELTypeToStringType(argument.Type));
}
if (argument.Value != null)
{
if (argument.Value is Oids.AlternateKey)
{
XMLAlternateKeySerializer.Serialize(writer, (Oids.AlternateKey)argument.Value);
}
else if (argument.Value is Oids.Oid)
{
XMLAdaptorOIDSerializer.Serialize(writer, argument.Value as Oids.Oid);
}
else
{
string lvalue = Convert.TypeToXml(argument.Type, argument.Value); //<-- Convert TypeToXML()!!!!
if (lvalue.Length > 0)
{
writer.WriteStartElement(DTD.Request.ServiceRequest.Arguments.Argument.TagLiteral);
writer.WriteValue(lvalue);
writer.WriteEndElement();
}
else // Is <NULL>
{
writer.WriteElementString(DTD.Request.ServiceRequest.Arguments.Argument.TagNull, string.Empty);
}
}
}
else // Is <NULL>
{
writer.WriteElementString(DTD.Request.ServiceRequest.Arguments.Argument.TagNull, string.Empty);
}
writer.WriteEndElement();
return writer;
}
static Arguments()
{
string description = "Returns number of used arguments.";
IEnumerable<ArgumentInfo> requiredArguments = new ArgumentInfo[]
{
new ArgumentInfo("First", "First argument.", ArgumentType.Any),
new ArgumentInfo("Second", "Second argument.", ArgumentType.Any),
new ArgumentInfo("Third", "Third argument.", ArgumentType.Any),
};
IEnumerable<ArgumentInfo> optionalArguments = new ArgumentInfo[]
{
new ArgumentInfo("First", "First argument.", ArgumentType.Any),
new ArgumentInfo("Second", "Second argument.", ArgumentType.Any),
new ArgumentInfo("Third", "Third argument.", ArgumentType.Any),
};
Info = new FunctionInfo(FunctionName, FunctionCategory.MathTrig, description, requiredArguments, optionalArguments, optionalArgumentsRepeatCount: 3);
}
static Add()
{
#region FunctionInfo
string description = "Adds all the numbers in range of cells.";
IEnumerable<ArgumentInfo> requiredArguments = new ArgumentInfo[]
{
new ArgumentInfo("Number", "number1, number2,... are the numbers to sum. Logical values and text are ignored in cells, included if typed as arguments.", ArgumentType.Number),
};
IEnumerable<ArgumentInfo> optionalArguments = new ArgumentInfo[]
{
new ArgumentInfo("Number", "number1, number2,... are the numbers to sum. Logical values and text are ignored in cells, included if typed as arguments.", ArgumentType.Number),
};
Info = new FunctionInfo(FunctionName, FunctionCategory.MathTrig, description, requiredArguments, optionalArguments, 254, true);
#endregion
}
public static ArgumentInfo <T> IfNull <T>(this ArgumentInfo <T> arg, in string type = ValidationType.IfNull, in string message = null)
internal DecorateActorStructure(ZDTextParser zdparser, DecorateCategoryInfo catinfo)
{
this.catinfo = catinfo; //mxd
DecorateParser parser = (DecorateParser)zdparser;
bool done = false; //mxd
// First next token is the class name
parser.SkipWhitespace(true);
classname = parser.StripTokenQuotes(parser.ReadToken(ACTOR_CLASS_SPECIAL_TOKENS));
if (string.IsNullOrEmpty(classname))
{
parser.ReportError("Expected actor class name");
return;
}
//mxd. Fail on duplicates // [ZZ] archived +zscript
if (parser.GetArchivedActorByName(classname) != null)
{
parser.ReportError("Actor \"" + classname + "\" is double-defined");
return;
}
// Parse tokens before entering the actor scope
while (parser.SkipWhitespace(true))
{
string token = parser.ReadToken();
if (!string.IsNullOrEmpty(token))
{
token = token.ToLowerInvariant();
switch (token)
{
case ":":
// The next token must be the class to inherit from
parser.SkipWhitespace(true);
inheritclass = parser.StripTokenQuotes(parser.ReadToken());
if (string.IsNullOrEmpty(inheritclass))
{
parser.ReportError("Expected class name to inherit from");
return;
}
// Find the actor to inherit from
baseclass = parser.GetArchivedActorByName(inheritclass);
break;
case "replaces":
// The next token must be the class to replace
parser.SkipWhitespace(true);
replaceclass = parser.StripTokenQuotes(parser.ReadToken());
if (string.IsNullOrEmpty(replaceclass))
{
parser.ReportError("Expected class name to replace");
return;
}
break;
case "native":
// Igore this token
break;
case "{":
// Actor scope begins here,
// break out of this parse loop
done = true;
break;
case "-":
// This could be a negative doomednum (but our parser sees the - as separate token)
// So read whatever is after this token and ignore it (negative doomednum indicates no doomednum)
parser.ReadToken();
break;
default:
//mxd. Property begins with $? Then the whole line is a single value
if (token.StartsWith("$"))
{
// This is for editor-only properties such as $sprite and $category
props[token] = new List <string> {
(parser.SkipWhitespace(false) ? parser.ReadLine() : "")
};
continue;
}
if (!int.TryParse(token, NumberStyles.Integer, CultureInfo.InvariantCulture, out doomednum)) // Check if numeric
{
// Not numeric!
parser.ReportError("Expected editor number or start of actor scope while parsing \"" + classname + "\"");
return;
}
//mxd. Range check
if ((doomednum < General.Map.FormatInterface.MinThingType) || (doomednum > General.Map.FormatInterface.MaxThingType))
{
// Out of bounds!
parser.ReportError("Actor \"" + classname + "\" has invalid editor number. Editor number must be between "
+ General.Map.FormatInterface.MinThingType + " and " + General.Map.FormatInterface.MaxThingType);
return;
}
break;
}
if (done)
{
break; //mxd
}
}
else
{
parser.ReportError("Unexpected end of structure");
return;
}
}
// Now parse the contents of actor structure
string previoustoken = "";
done = false; //mxd
while (parser.SkipWhitespace(true))
{
string token = parser.ReadToken();
token = token.ToLowerInvariant();
switch (token)
{
case "+":
case "-":
// Next token is a flag (option) to set or remove
bool flagvalue = (token == "+");
parser.SkipWhitespace(true);
string flagname = parser.ReadToken();
if (!string.IsNullOrEmpty(flagname))
{
// Add the flag with its value
flagname = flagname.ToLowerInvariant();
flags[flagname] = flagvalue;
}
else
{
parser.ReportError("Expected flag name");
return;
}
break;
case "action":
case "native":
// We don't need this, ignore up to the first next ;
while (parser.SkipWhitespace(true))
{
string t = parser.ReadToken();
if (string.IsNullOrEmpty(t) || t == ";")
{
break;
}
}
break;
case "skip_super":
skipsuper = true;
break;
case "states":
if (!parser.NextTokenIs("{", true))
{
return;
}
// Now parse actor states until we reach the end of the states structure
while (parser.SkipWhitespace(true))
{
string statetoken = parser.ReadToken();
if (!string.IsNullOrEmpty(statetoken))
{
// End of scope?
if (statetoken == "}")
{
// Done with the states,
// break out of this parse loop
break;
}
// State label?
else if (statetoken == ":")
{
if (!string.IsNullOrEmpty(previoustoken))
{
// Parse actor state
StateStructure st = new DecorateStateStructure(this, parser);
if (parser.HasError)
{
return;
}
states[previoustoken.ToLowerInvariant()] = st;
}
else
{
parser.ReportError("Expected actor state name");
return;
}
}
else
{
// Keep token
previoustoken = statetoken;
}
}
else
{
parser.ReportError("Unexpected end of structure");
return;
}
}
break;
case "var": //mxd
// Type
parser.SkipWhitespace(true);
string typestr = parser.ReadToken().ToUpperInvariant();
UniversalType type = UniversalType.EnumOption; // There is no Unknown type, so let's use something impossiburu...
switch (typestr)
{
case "INT": type = UniversalType.Integer; break;
case "FLOAT": type = UniversalType.Float; break;
default: parser.LogWarning("Unknown user variable type"); break;
}
// Name
parser.SkipWhitespace(true);
string name = parser.ReadToken();
if (string.IsNullOrEmpty(name))
{
parser.ReportError("Expected User Variable name");
return;
}
if (!name.StartsWith("user_", StringComparison.OrdinalIgnoreCase))
{
parser.ReportError("User Variable name must start with \"user_\" prefix");
return;
}
if (uservars.ContainsKey(name))
{
parser.ReportError("User Variable \"" + name + "\" is double defined");
return;
}
if (!skipsuper && baseclass != null && baseclass.uservars.ContainsKey(name))
{
parser.ReportError("User variable \"" + name + "\" is already defined in one of the parent classes");
return;
}
// Rest
parser.SkipWhitespace(true);
string next = parser.ReadToken();
if (next == "[") // that's User Array. Let's skip it...
{
int arrlen = -1;
if (!parser.ReadSignedInt(ref arrlen))
{
parser.ReportError("Expected User Array length");
return;
}
if (arrlen < 1)
{
parser.ReportError("User Array length must be a positive value");
return;
}
if (!parser.NextTokenIs("]") || !parser.NextTokenIs(";"))
{
return;
}
}
else if (next != ";")
{
parser.ReportError("Expected \";\", but got \"" + next + "\"");
return;
}
else
{
// Add to collection
uservars.Add(name, type);
}
break;
case "}":
//mxd. Get user vars from the BaseClass, if we have one
if (!skipsuper && baseclass != null && baseclass.uservars.Count > 0)
{
foreach (var group in baseclass.uservars)
{
uservars.Add(group.Key, group.Value);
}
}
// Actor scope ends here, break out of this parse loop
done = true;
break;
// Monster property?
case "monster":
// This sets certain flags we are interested in
flags["shootable"] = true;
flags["countkill"] = true;
flags["solid"] = true;
flags["canpushwalls"] = true;
flags["canusewalls"] = true;
flags["activatemcross"] = true;
flags["canpass"] = true;
flags["ismonster"] = true;
break;
// Projectile property?
case "projectile":
// This sets certain flags we are interested in
flags["noblockmap"] = true;
flags["nogravity"] = true;
flags["dropoff"] = true;
flags["missile"] = true;
flags["activateimpact"] = true;
flags["activatepcross"] = true;
flags["noteleport"] = true;
break;
// Clearflags property?
case "clearflags":
// Clear all flags
flags.Clear();
break;
// Game property?
case "game":
// Include all tokens on the same line
List <string> games = new List <string>();
while (parser.SkipWhitespace(false))
{
string v = parser.ReadToken();
if (string.IsNullOrEmpty(v))
{
parser.ReportError("Expected \"Game\" property value");
return;
}
if (v == "\n")
{
break;
}
if (v == "}")
{
return; //mxd
}
if (v != ",")
{
games.Add(v.ToLowerInvariant());
}
}
props[token] = games;
break;
// Property
default:
// Property begins with $? Then the whole line is a single value
if (token.StartsWith("$"))
{
// This is for editor-only properties such as $sprite and $category
props[token] = new List <string> {
(parser.SkipWhitespace(false) ? parser.ReadLine() : "")
};
}
else
{
// Next tokens up until the next newline are values
List <string> values = new List <string>();
while (parser.SkipWhitespace(false))
{
string v = parser.ReadToken();
if (string.IsNullOrEmpty(v))
{
parser.ReportError("Unexpected end of structure");
return;
}
if (v == "\n")
{
break;
}
if (v == "}")
{
return; //mxd
}
if (v != ",")
{
values.Add(v);
}
}
//mxd. Translate scale to xscale and yscale
if (token == "scale")
{
props["xscale"] = values;
props["yscale"] = values;
}
else
{
props[token] = values;
}
}
break;
}
if (done)
{
break; //mxd
}
// Keep token
previoustoken = token;
}
// parsing done, process thing arguments
ParseCustomArguments();
//mxd. Check if baseclass is valid
if (inheritclass.ToLowerInvariant() != "actor" && doomednum > -1)
{
//check if this class inherits from a class defined in game configuration
Dictionary <int, ThingTypeInfo> things = General.Map.Config.GetThingTypes();
string inheritclasscheck = inheritclass.ToLowerInvariant();
foreach (KeyValuePair <int, ThingTypeInfo> ti in things)
{
if (!string.IsNullOrEmpty(ti.Value.ClassName) && ti.Value.ClassName.ToLowerInvariant() == inheritclasscheck)
{
//states
// [ZZ] allow internal prefix here. it can inherit MapSpot, light, or other internal stuff.
if (states.Count == 0 && !string.IsNullOrEmpty(ti.Value.Sprite))
{
states.Add("spawn", new StateStructure(ti.Value.Sprite.StartsWith(DataManager.INTERNAL_PREFIX) ? ti.Value.Sprite : ti.Value.Sprite.Substring(0, 5)));
}
if (baseclass == null)
{
//flags
if (ti.Value.Hangs && !flags.ContainsKey("spawnceiling"))
{
flags["spawnceiling"] = true;
}
if (ti.Value.Blocking > 0 && !flags.ContainsKey("solid"))
{
flags["solid"] = true;
}
//properties
if (!props.ContainsKey("height"))
{
props["height"] = new List <string> {
ti.Value.Height.ToString()
}
}
;
if (!props.ContainsKey("radius"))
{
props["radius"] = new List <string> {
ti.Value.Radius.ToString()
}
}
;
}
// [ZZ] inherit arguments from game configuration
//
if (!props.ContainsKey("$clearargs"))
{
for (int i = 0; i < 5; i++)
{
if (args[i] != null)
{
continue; // don't touch it if we already have overrides
}
ArgumentInfo arg = ti.Value.Args[i];
if (arg != null && arg.Used)
{
args[i] = arg;
}
}
}
return;
}
}
if (baseclass == null)
{
parser.LogWarning("Unable to find \"" + inheritclass + "\" class to inherit from, while parsing \"" + classname + ":" + doomednum + "\"");
}
}
}
#endregion
}
}
public void Initialize()
{
_argumentInfo = new ArgumentInfo();
_argumentInfo.Name = "actual";
}
public static ArgumentInfo <TFirstType> Member <TFirstType, TSecondType>(
this ArgumentInfo <TFirstType> currentArg,
in Expression <Func <TFirstType, TSecondType> > propertyExpression,
public static ArgumentInfo <T> If <T>(this ArgumentInfo <T> arg, Predicate <T> predicate, in string type = ValidationType.If, in string message = null)
public ValueArgumentHandler(ArgumentInfo argumentInfo)
: base(argumentInfo)
{
}
static ServiceAction BuildAction(MethodInfo method,
object service,
Dictionary <string, StateVariableInfo> stateVariables)
{
var attributes = method.GetCustomAttributes(typeof(UpnpActionAttribute), false);
if (attributes.Length != 0)
{
var attribute = (UpnpActionAttribute)attributes[0];
if (Omit(method.DeclaringType, service, attribute.OmitUnless))
{
return(null);
}
var name = string.IsNullOrEmpty(attribute.Name) ? method.Name : attribute.Name;
var parameters = method.GetParameters();
var arguments = new ArgumentInfo[parameters.Length];
for (var i = 0; i < parameters.Length; i++)
{
arguments[i] = BuildArgumentInfo(parameters[i], name, stateVariables);
}
var return_argument = BuildArgumentInfo(method.ReturnParameter, name, stateVariables, true);
return(new ServiceAction(name, Combine(arguments, return_argument), args => {
Trace(name, args.Values);
var argument_array = new object[arguments.Length];
for (var i = 0; i < arguments.Length; i++)
{
var argument = arguments[i];
if (argument.Argument.Direction == ArgumentDirection.Out)
{
continue;
}
string value;
if (args.TryGetValue(argument.Argument.Name, out value))
{
var parameter_type = argument.ParameterInfo.ParameterType;
if (parameter_type.IsEnum)
{
// TODO handle attributes
foreach (var enum_value in Enum.GetValues(parameter_type))
{
if (Enum.GetName(parameter_type, enum_value) == value)
{
argument_array[i] = enum_value;
break;
}
}
}
else
{
argument_array[i] = Convert.ChangeType(value, parameter_type);
}
}
else
{
// TODO throw
}
}
object result;
try {
result = method.Invoke(service, argument_array);
} catch (TargetInvocationException e) {
if (e.InnerException is UpnpControlException)
{
throw e.InnerException;
}
else
{
throw new UpnpControlException(
UpnpError.Unknown(), "Unexpected exception.", e.InnerException);
}
}
var out_arguments = new Dictionary <string, string> ();
for (var i = 0; i < arguments.Length; i++)
{
if (arguments[i].Argument.Direction == ArgumentDirection.In)
{
continue;
}
var value = argument_array[i];
out_arguments.Add(arguments[i].Argument.Name, value != null ? value.ToString() : "");
}
if (return_argument != null)
{
out_arguments.Add(return_argument.Argument.Name, result.ToString());
}
Trace(name, out_arguments);
return out_arguments;
}));
}
else
{
return(null);
}
}
public static ArgumentInfo <T> IfGreaterThan <T>(this ArgumentInfo <T> arg, T value, in string type = ValidationType.IfGreaterThan, in string message = null)
public static ArgumentInfo <string> IfNullOrWhiteSpace(this ArgumentInfo <string> arg, in string type = ValidationType.IfNullOrWhiteSpace, in string message = null)
public dynamic Parse(ArgumentInfo argumentInfo)
{
var value = argumentInfo.ValueInfo.Value;
return(ParseString(argumentInfo, value));
}
IDictionary <string, ArgumentInfo> GetSymbolNameMapper(Compilation compilation, INamedTypeSymbol classSymbol)
{
var nameMapper = new Dictionary <string, ArgumentInfo>();
foreach (var baseParam in GetBaseTypeParameters())
{
var newName = NewArgumentName(baseParam.Name.ToCamelCase(), nameMapper);
nameMapper[newName] = new ArgumentInfo
{
ArgName = newName,
ArgTypeSymbol = baseParam.Type,
MemberName = baseParam.Name,
MemberTypeSymbol = baseParam.Type,
Source = ArgumentSource.BaseCtor
};
}
foreach (var field in GetInstanceFields())
{
var newName = NewArgumentName(field.Name.ToCamelCase(), nameMapper);
nameMapper[newName] = new ArgumentInfo
{
ArgName = newName,
ArgTypeSymbol = field.Type,
MemberName = field.Name,
MemberTypeSymbol = field.Type,
Source = ArgumentSource.Field
};
}
foreach (var property in GetInstanceProperties())
{
var newName = NewArgumentName(property.Name.ToCamelCase(), nameMapper);
nameMapper[newName] = new ArgumentInfo
{
ArgName = newName,
ArgTypeSymbol = property.Type,
MemberName = property.Name,
MemberTypeSymbol = property.Type,
Source = ArgumentSource.Property
};
}
return(nameMapper);
IEnumerable <IFieldSymbol> GetInstanceFields()
{
return(classSymbol.GetMembers().OfType <IFieldSymbol>()
.Where(p => !p.IsStatic && !p.IsConst && p.CanBeReferencedByName && !p.HasAttribute(typeof(AutoConstructorIgnoreAttribute))));
}
IEnumerable <IPropertySymbol> GetInstanceProperties()
{
return(classSymbol.GetMembers().OfType <IPropertySymbol>()
.Where(p => !p.IsStatic && !p.IsIndexer && p.CanBeReferencedByName && p.IsAutoProperty() && !p.HasAttribute(typeof(AutoConstructorIgnoreAttribute))));
}
ImmutableArray <IParameterSymbol> GetBaseTypeParameters()
{
if (classSymbol.BaseType == null)
{
return(ImmutableArray <IParameterSymbol> .Empty);
}
// if found Microsoft.Extensions.DependencyInjection.ActivatorUtilitiesConstructorAttribute, use it first
var primaryCtor = classSymbol.BaseType.Constructors
.FirstOrDefault(p => p.HasAttribute(
"Microsoft.Extensions.DependencyInjection.ActivatorUtilitiesConstructorAttribute"));
if (primaryCtor != null)
{
return(primaryCtor.Parameters);
}
// use first minimum parameters
var ctor = classSymbol.BaseType.Constructors.OrderBy(method => method.Parameters.Length)
.FirstOrDefault();
if (ctor == null)
{
return(ImmutableArray <IParameterSymbol> .Empty);
}
return(ctor.Parameters);
}
string NewArgumentName(string baseName, IDictionary <string, ArgumentInfo> ctx)
{
if (string.IsNullOrEmpty(baseName))
{
baseName = "args";
}
string newName = baseName;
int index = 1;
while (ctx.ContainsKey(newName))
{
newName = baseName + index++;
}
return(newName);
}
}
private char GetChar(ArgumentInfo argumentInfo, string value)
{
if (string.IsNullOrEmpty(value))
{
return(default);
public DynamicInvokeInfo(MethodBase method, IntPtr invokeThunk)
{
Method = method;
InvokeThunk = invokeThunk;
_isStatic = method.IsStatic;
// _isValueTypeInstanceMethod = method.DeclaringType?.IsValueType ?? false;
ParameterInfo[] parameters = method.GetParametersNoCopy();
_argumentCount = parameters.Length;
if (_argumentCount != 0)
{
ArgumentInfo[] arguments = new ArgumentInfo[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
Transform transform = default;
Type argumentType = parameters[i].ParameterType;
if (argumentType.IsByRef)
{
_needsCopyBack = true;
transform |= Transform.ByRef;
argumentType = argumentType.GetElementType() !;
}
Debug.Assert(!argumentType.IsByRef);
EETypePtr eeArgumentType = argumentType.GetEEType();
if (eeArgumentType.IsValueType)
{
Debug.Assert(argumentType.IsValueType);
if (eeArgumentType.IsByRefLike)
{
_argumentCount = ArgumentCount_NotSupported_ByRefLike;
}
if (eeArgumentType.IsNullable)
{
transform |= Transform.Nullable;
}
}
else if (eeArgumentType.IsPointer)
{
Debug.Assert(argumentType.IsPointer);
transform |= Transform.Pointer;
}
else
{
transform |= Transform.Reference;
}
arguments[i] = new ArgumentInfo(transform, eeArgumentType);
}
_arguments = arguments;
}
if (method is MethodInfo methodInfo)
{
Transform transform = default;
Type returnType = methodInfo.ReturnType;
if (returnType.IsByRef)
{
transform |= Transform.ByRef;
returnType = returnType.GetElementType() !;
}
Debug.Assert(!returnType.IsByRef);
EETypePtr eeReturnType = returnType.GetEEType();
if (eeReturnType.IsValueType)
{
Debug.Assert(returnType.IsValueType);
if (returnType != typeof(void))
{
if (eeReturnType.IsByRefLike)
{
_argumentCount = ArgumentCount_NotSupported_ByRefLike;
}
if ((transform & Transform.ByRef) == 0)
{
transform |= Transform.AllocateReturnBox;
}
if (eeReturnType.IsNullable)
{
transform |= Transform.Nullable;
}
}
else
{
if ((transform & Transform.ByRef) != 0)
{
_argumentCount = ArgumentCount_NotSupported; // ByRef to void return
}
}
}
else if (eeReturnType.IsPointer)
{
Debug.Assert(returnType.IsPointer);
transform |= Transform.Pointer;
if ((transform & Transform.ByRef) == 0)
{
transform |= Transform.AllocateReturnBox;
}
}
else
{
transform |= Transform.Reference;
}
_returnTransform = transform;
_returnType = eeReturnType;
}
}
private int defaultvalue; //mxd
#endregion
#region ================== Properties
#endregion
#region ================== Methods
//mxd
public override void SetupArgument(TypeHandlerAttribute attr, ArgumentInfo arginfo)
{
defaultvalue = (int)arginfo.DefaultValue;
base.SetupArgument(attr, arginfo);
}
public IntArgumentHandler(ArgumentInfo argumentInfo)
: base(argumentInfo)
{
}
// This sets up the control for a specific argument
public void Setup(ArgumentInfo arginfo)
{
int oldvalue = 0;
// Get the original value
if (typehandler != null)
{
oldvalue = typehandler.GetIntValue();
}
// Get the type handler
typehandler = General.Types.GetArgumentHandler(arginfo);
// Clear combobox
combobox.SelectedItem = null;
combobox.Items.Clear();
// Check if this supports enumerated options
if (typehandler.IsEnumerable)
{
// Show the combobox
button.Visible = false;
scrollbuttons.Visible = false;
combobox.DropDownStyle = ComboBoxStyle.DropDown;
combobox.Items.AddRange(typehandler.GetEnumList().ToArray());
combobox.DropDownWidth = Tools.GetDropDownWidth(combobox); //mxd
}
// Check if browsable
else if (typehandler.IsBrowseable)
{
// Show the button
button.Visible = true;
button.Image = typehandler.BrowseImage;
scrollbuttons.Visible = false;
combobox.DropDownStyle = ComboBoxStyle.Simple;
}
else
{
// Show textbox with scroll buttons
button.Visible = false;
scrollbuttons.Visible = true;
combobox.DropDownStyle = ComboBoxStyle.Simple;
}
//mxd
if (typehandler.IsEnumerable)
{
combobox.AutoCompleteMode = AutoCompleteMode.Suggest;
combobox.AutoCompleteSource = AutoCompleteSource.ListItems;
}
else
{
combobox.AutoCompleteMode = AutoCompleteMode.None;
combobox.AutoCompleteSource = AutoCompleteSource.None;
}
// Setup layout
ArgumentBox_Resize(this, EventArgs.Empty);
//mxd. If not mixed values, re-apply the old value
if (!string.IsNullOrEmpty(combobox.Text))
{
SetValue(oldvalue);
}
}
protected override void RunInstruction(ComputerInstruction instruction, ArgumentInfo arg0, ArgumentInfo arg1, ref int instructionOffset)
{
switch (instruction.Operator)
{
case ComputerOperator.Send:
long message = arg0.Value;
LinkedProgram.messageQueue.Enqueue(message);
HaltRequested = ValueSent?.Invoke(message) ?? false;
break;
case ComputerOperator.Receive:
bool received = messageQueue.TryDequeue(out long value);
if (!received)
{
// Reattempt receiving the value when continuing execution, halt until rerun
instructionOffset = 0;
HaltRequested = true;
break;
}
Registers[arg0.RegisterName] = value;
break;
default:
base.RunInstruction(instruction, arg0, arg1, ref instructionOffset);
return;
}
}
public static ArgumentInfo <List <TItem> > Every <TItem>(this ArgumentInfo <List <TItem> > arg, in Action <ArgumentInfo <TItem> > action) =>
public bool Finalize()
{
ClearError();
// parse class data
foreach (ZScriptClassStructure cls in allclasseslist)
{
if (!cls.Process())
{
return(false);
}
}
// set datastream to null so that log messages aren't output using incorrect line numbers
Stream odatastream = datastream;
datastream = null;
// inject superclasses, since everything is parsed by now
Dictionary <int, ThingTypeInfo> things = General.Map.Config.GetThingTypes();
foreach (ZScriptClassStructure cls in allclasseslist)
{
ActorStructure actor = cls.Actor;
if (actor != null && cls.ParentName != null && cls.ParentName.ToLowerInvariant() != "thinker") // don't try to inherit this one
{
actor.baseclass = GetArchivedActorByName(cls.ParentName, true);
string inheritclass = cls.ParentName;
//check if this class inherits from a class defined in game configuration
string inheritclasscheck = inheritclass.ToLowerInvariant();
// inherit args from base class
if (actor.baseclass != null)
{
for (int i = 0; i < 5; i++)
{
if (actor.args[i] == null)
{
actor.args[i] = actor.baseclass.args[i];
}
}
}
bool thingfound = false;
foreach (KeyValuePair <int, ThingTypeInfo> ti in things)
{
if (!string.IsNullOrEmpty(ti.Value.ClassName) && ti.Value.ClassName.ToLowerInvariant() == inheritclasscheck)
{
//states
// [ZZ] allow internal prefix here. it can inherit MapSpot, light, or other internal stuff.
if (actor.states.Count == 0 && !string.IsNullOrEmpty(ti.Value.Sprite))
{
actor.states.Add("spawn", new StateStructure(ti.Value.Sprite.StartsWith(DataManager.INTERNAL_PREFIX) ? ti.Value.Sprite : ti.Value.Sprite.Substring(0, 5)));
}
if (actor.baseclass == null)
{
//flags
if (ti.Value.Hangs && !actor.flags.ContainsKey("spawnceiling"))
{
actor.flags["spawnceiling"] = true;
}
if (ti.Value.Blocking > 0 && !actor.flags.ContainsKey("solid"))
{
actor.flags["solid"] = true;
}
//properties
if (!actor.props.ContainsKey("height"))
{
actor.props["height"] = new List <string> {
ti.Value.Height.ToString()
}
}
;
if (!actor.props.ContainsKey("radius"))
{
actor.props["radius"] = new List <string> {
ti.Value.Radius.ToString()
}
}
;
}
// [ZZ] inherit arguments from game configuration
//
if (!actor.props.ContainsKey("$clearargs"))
{
for (int i = 0; i < 5; i++)
{
if (actor.args[i] != null)
{
continue; // don't touch it if we already have overrides
}
ArgumentInfo arg = ti.Value.Args[i];
if (arg != null && arg.Used)
{
actor.args[i] = arg;
}
}
}
thingfound = true;
break;
}
if (actor.baseclass == null && !thingfound)
{
LogWarning("Unable to find \"" + inheritclass + "\" class to inherit from, while parsing \"" + cls.ClassName + "\"");
}
}
}
}
// validate user variables (no variables should shadow parent variables)
foreach (ZScriptClassStructure cls in allclasseslist)
{
ActorStructure actor = cls.Actor;
if (actor == null)
{
continue;
}
ActorStructure actorbase = actor.baseclass;
while (actorbase != null)
{
foreach (string uservar in actor.uservars.Keys)
{
if (actorbase.uservars.ContainsKey(uservar))
{
actor.uservars.Clear();
ReportError("Variable \"" + uservar + "\" in class \"" + actor.classname + "\" shadows variable \"" + uservar + "\" in base class \"" + actorbase.classname + "\". This is not supported");
goto stopValidatingCompletely;
}
}
actorbase = actorbase.baseclass;
}
}
stopValidatingCompletely:
datastream = odatastream;
return(true);
}
private static string GetArgumentFormat(ArgumentInfo argumentInfo)
{
return(!argumentInfo.IsBoolean ? argumentInfo.Name + " " + (string.IsNullOrEmpty(argumentInfo.Type) ? "VALUE" : argumentInfo.Type) : argumentInfo.Name);
}
public ArgumentInfoDto(ArgumentInfo argumentInfo)
{
Name = argumentInfo.Name;
Description = argumentInfo.Description;
ExampleValues = argumentInfo.ExampleValues;
}
public void UpdateAddressSharedEntitiesForParameter(IParameterSymbol parameter, AnalysisEntity analysisEntity, ArgumentInfo <TAbstractAnalysisValue>?assignedValue)
{
if (parameter.RefKind != RefKind.None &&
assignedValue?.AnalysisEntity != null)
{
var addressSharedEntities = ComputeAddressSharedEntities();
var isReferenceCopy = !addressSharedEntities.Any(a => a.Type.IsValueType);
var copyValue = new CopyAbstractValue(addressSharedEntities, isReferenceCopy);
foreach (var entity in copyValue.AnalysisEntities)
{
_addressSharedEntitiesBuilder[entity] = copyValue;
}
}
ImmutableHashSet <AnalysisEntity> ComputeAddressSharedEntities()
{
RoslynDebug.Assert(assignedValue?.AnalysisEntity != null);
var builder = PooledHashSet <AnalysisEntity> .GetInstance();
AddIfHasKnownInstanceLocation(analysisEntity, builder);
AddIfHasKnownInstanceLocation(assignedValue.AnalysisEntity, builder);
// We need to handle multiple ref/out parameters passed the same location.
// For example, "M(ref a, ref a);"
if (_addressSharedEntitiesBuilder.TryGetValue(assignedValue.AnalysisEntity, out var existingValue))
{
foreach (var entity in existingValue.AnalysisEntities)
{
AddIfHasKnownInstanceLocation(entity, builder);
}
}
// Also handle case where the passed in argument is also a ref/out parameter and has address shared entities.
if (_addressSharedEntitiesBuilder.TryGetValue(analysisEntity, out existingValue))
{
foreach (var entity in existingValue.AnalysisEntities)
{
AddIfHasKnownInstanceLocation(entity, builder);
}
}
Debug.Assert(builder.All(e => !e.HasUnknownInstanceLocation));
return(builder.ToImmutableAndFree());
}
public static Options Parse(string[] args)
{
var options = new Options();
var info = ExtractInfo();
ArgumentInfo actions = info.SingleOrDefault(x => x.Definition.IsNameless);
IEnumerable <ArgumentInfo> arguments = info.Where(x => !x.Definition.IsNameless);
var queue = new Queue <string>(args);
while (queue.Count > 0)
{
var token = queue.Dequeue();
if (token.StartsWith("-"))
{
ArgumentInfo argument = null;
if (token.StartsWith("--"))
{
var name = token.Substring(2);
argument = arguments.SingleOrDefault(x => x.Definition.LongName == name);
}
else
{
var name = token.Substring(1).First();
argument = arguments.SingleOrDefault(x => x.Definition.ShortName == name);
}
if (argument == null)
{
throw new PackDmException("Argumento não reconhecido: " + token);
}
argument.Property.SetValue(options, true, null);
if (argument.HasValue)
{
if (queue.Count == 0)
{
throw new PackDmException("O argumento requer um valor: " + token);
}
var value = queue.Dequeue();
var list = argument.ValueProperty.GetValue(options, null) as List <string>;
if (list != null)
{
list.Add(value);
}
else
{
argument.ValueProperty.SetValue(options, value, null);
}
}
}
else
{
actions.Property.SetValue(options, true, null);
var currentValue = actions.ValueProperty.GetValue(options, null);
var newValue = (currentValue + " " + token).Trim();
actions.ValueProperty.SetValue(options, newValue, null);
}
}
return(options);
}
private static object Parse(string[] args, object result, Type resultType)
{
var mapper = new Dictionary <string, ArgumentInfo>();
foreach (var p in resultType.GetProperties())
{
var argAttr = FxExtensions.FirstOrDefault(p.GetCustomAttributes(typeof(ArgumentAttribute), true)) as ArgumentAttribute;
if (argAttr == null)
{
continue;
}
// 未指定TagName，默认使用"--{PropertyName}"作为TagName
string tagName = string.IsNullOrEmpty(argAttr.TagName) ? "--" + p.Name : argAttr.TagName;
tagName = tagName.ToLowerInvariant();
var argInfo = new ArgumentInfo()
{
TagName = tagName,
Optional = argAttr.Optional,
Property = p
};
mapper.Add(tagName, argInfo);
}
int index = 0;
while (index < args.Length)
{
string tmp = args[index];
if (mapper.TryGetValue(tmp.Trim().ToLowerInvariant(), out var argInfo))
{
if (argInfo.IsSet)
{
throw new ParserException($"指定了重复参数：参数名={tmp}");
}
var prop = argInfo.Property;
// 布尔参数不需要读取值
if (prop.PropertyType == typeof(bool) ||
prop.PropertyType == typeof(bool?))
{
prop.SetValue(result, true, null);
}
else
{
if (++index >= args.Length)
{
throw new ParserException($"缺少参数值: 参数名={tmp}");
}
try
{
object value = ConvertData(args[index], prop.PropertyType);
prop.SetValue(result, value, null);
}
catch (Exception)
{
throw new ParserException($"参数值转换错误: 参数名={tmp}");
}
}
argInfo.IsSet = true;
}
index++;
}
foreach (var item in mapper.Values)
{
if (!item.Optional && !item.IsSet)
{
throw new ParserException($"缺少必须的参数：参数名={item.TagName}");
}
}
return(result);
}
static BlackCard ( )
{
ArgumentInfo stock = new ArgumentInfo ( "" , "" , typeof ( Stock ) , new StockTransactDefineDomain ( true ) ) ;
Arguments = new List <ArgumentInfo> { stock } ;
}
public dynamic Parse(ArgumentInfo argumentInfo)
{
return(ParseString(argumentInfo.ValueInfo.Value, argumentInfo.IsImplicit, argumentInfo.TypeDisplayName));
}
private static ISignatureInfo ParseSignature(string functionName, ParseContext context)
{
SignatureInfo info = new SignatureInfo(functionName);
List <IArgumentInfo> signatureArguments = new List <IArgumentInfo>();
// RD data may contain function name(s) without braces
if (context.Tokens.CurrentToken.TokenType == RTokenType.OpenBrace)
{
FunctionCall functionCall = new FunctionCall();
functionCall.Parse(context, context.AstRoot);
for (int i = 0; i < functionCall.Arguments.Count; i++)
{
IAstNode arg = functionCall.Arguments[i];
string argName = null;
string argDefaultValue = null;
bool isEllipsis = false;
bool isOptional = false;
ExpressionArgument expArg = arg as ExpressionArgument;
if (expArg != null)
{
argName = context.TextProvider.GetText(expArg.ArgumentValue);
}
else
{
NamedArgument nameArg = arg as NamedArgument;
if (nameArg != null)
{
argName = context.TextProvider.GetText(nameArg.NameRange);
argDefaultValue = nameArg.DefaultValue != null?
RdText.CleanRawRdText(context.TextProvider.GetText(nameArg.DefaultValue)) : string.Empty;
}
else
{
MissingArgument missingArg = arg as MissingArgument;
if (missingArg != null)
{
argName = string.Empty;
}
else
{
EllipsisArgument ellipsisArg = arg as EllipsisArgument;
if (ellipsisArg != null)
{
argName = "...";
isEllipsis = true;
}
}
}
}
ArgumentInfo argInfo = new ArgumentInfo(argName);
argInfo.DefaultValue = argDefaultValue;
argInfo.IsEllipsis = isEllipsis;
argInfo.IsOptional = isOptional; // TODO: actually parse
signatureArguments.Add(argInfo);
}
}
info.Arguments = signatureArguments;
return(info);
}
public string GetDisplayName(ArgumentInfo argumentInfo)
{
return(argumentInfo.UnderlyingType.Name);
}
protected override void SetValueForParameterOnEntry(IParameterSymbol parameter, AnalysisEntity analysisEntity, ArgumentInfo<CopyAbstractValue>? assignedValueOpt)
{
CopyAbstractValue copyValue;
if (assignedValueOpt != null)
{
var assignedEntities = assignedValueOpt.Value.AnalysisEntities;
if (assignedValueOpt.AnalysisEntityOpt != null && !assignedEntities.Contains(assignedValueOpt.AnalysisEntityOpt))
{
assignedEntities = assignedEntities.Add(assignedValueOpt.AnalysisEntityOpt);
}
var newAnalysisEntities = assignedEntities;
CopyAbstractValueKind newKind;
if (assignedValueOpt.Value.Kind.IsKnown())
{
newKind = assignedValueOpt.Value.Kind;
}
else if (assignedValueOpt.AnalysisEntityOpt == null || assignedValueOpt.AnalysisEntityOpt.Type.IsValueType)
{
newKind = CopyAbstractValueKind.KnownValueCopy;
}
else
{
newKind = CopyAbstractValueKind.KnownReferenceCopy;
}
foreach (var entity in assignedEntities)
{
if (CurrentAnalysisData.TryGetValue(entity, out var existingValue))
{
newAnalysisEntities = newAnalysisEntities.Union(existingValue.AnalysisEntities);
newKind = newKind.MergeIfBothKnown(existingValue.Kind);
}
}
copyValue = assignedValueOpt.Value.AnalysisEntities.Count == newAnalysisEntities.Count ?
assignedValueOpt.Value :
new CopyAbstractValue(newAnalysisEntities, newKind);
}
else
{
copyValue = GetDefaultCopyValue(analysisEntity);
}
SetAbstractValue(CurrentAnalysisData, analysisEntity, copyValue, TryGetAddressSharedCopyValue, initializingParameters: true);
}
private IIriTemplateMapping BuildTemplateMapping(DescriptionContext context, Uri templateUri, OperationInfo <Verb> operation, ArgumentInfo mapping)
{
IIriTemplateMapping templateMapping = context.ApiDocumentation.Context.Create <IIriTemplateMapping>(templateUri.AddFragment(mapping.VariableName));
templateMapping.Variable = mapping.VariableName;
templateMapping.Required = (mapping.Parameter.ParameterType.IsValueType) && (!mapping.Parameter.HasDefaultValue);
templateMapping.Description = _xmlDocProvider.GetDescription(operation.UnderlyingMethod, mapping.Parameter);
var linqBehaviors = mapping.Parameter.GetCustomAttributes <LinqServerBehaviorAttribute>(true);
if (linqBehaviors.Any())
{
foreach (var visitor in _serverBehaviorAttributeVisitors)
{
linqBehaviors.Accept(mapping.Parameter.ParameterType, visitor, templateMapping, context);
}
}
else if (context.Type != typeof(object))
{
templateMapping.Property = GetMappingProperty(context, mapping.Parameter);
}
return(templateMapping);
}
private bool ParseTypeMember()
{
var identifier = ParseGenericIdentifier();
if (identifier == null)
return false;
if (IsWhitespace())
SkipWhitespace();
var member = new MemberInfo
{
Modifiers = new List<string>(modifiers),
Arguments = new List<ArgumentInfo>(),
Name = identifier,
IsFunction = false,
Decorators = new List<DecoratorInfo>(),
Type = ""
};
modifiers.Clear();
typeStack.Peek().Members.Add(member);
if (Is(TokenType.Char, "?"))
{
member.IsOptional = true;
SkipWhitespace();
}
if (Is(TokenType.Char, ":"))
{
SkipWhitespace();
string defaultValue;
member.Type = ParseTypeExpressionAndDefault(out defaultValue, () =>
Is(TokenType.Char, ";") || type == TokenType.EndOfLine);
if (member.Type == null)
return false;
member.InitialValue = defaultValue ?? "";
}
else if (Is(TokenType.Char, "("))
{
member.IsFunction = true;
while (true)
{
SkipWhitespace();
if (type == TokenType.Char &&
text == ")")
break;
if (type != TokenType.Identifier)
return false;
var argument = new ArgumentInfo()
{
Name = text,
Modifier = "",
Decorators = new List<DecoratorInfo>(),
InitialValue = "",
Type = ""
};
member.Arguments.Add(argument);
if (text == "private" ||
text == "public" ||
text == "protected")
{
argument.Modifier = text;
SkipWhitespace();
if (type != TokenType.Identifier)
return false;
argument.Name = text;
}
SkipWhitespace();
if (Is(TokenType.Char, "?"))
{
argument.IsOptional = true;
SkipWhitespace();
}
if (Is(TokenType.Char, ":"))
{
SkipWhitespace();
string defaultValue;
argument.Type = ParseTypeExpressionAndDefault(out defaultValue, () =>
Is(TokenType.Char, ",") ||
Is(TokenType.Char, ")"));
if (argument.Type == null)
return false;
}
else if (Is(TokenType.Char, "="))
{
argument.InitialValue = ParseExpression(() =>
Is(TokenType.Char, ",") ||
Is(TokenType.Char, ")"));
if (argument.InitialValue == null)
return false;
}
if (IsWhitespace())
SkipWhitespace();
if (Is(TokenType.Char, ","))
continue;
if (!Is(TokenType.Char, ")"))
return false;
break;
}
SkipWhitespace();
if (Is(TokenType.Char, ":"))
{
SkipWhitespace();
member.Type = ParseExpression(() =>
Is(TokenType.Char, ";") ||
Is(TokenType.Char, "{"));
if (member.Type == null)
return false;
}
if (IsWhitespace())
SkipWhitespace();
if (Is(TokenType.Char, "{"))
{
braceStack.Push("{");
return true;
}
else if (Is(TokenType.Char, ";"))
{
return true;
}
else
return false;
}
else if (Is(TokenType.Char, "="))
{
SkipWhitespace();
member.InitialValue = ParseExpression(() =>
Is(TokenType.Char, ";") ||
type == TokenType.EndOfLine);
if (member.InitialValue == null)
return false;
}
else
return true;
return true;
}
public EnumArgumentHandler(ArgumentInfo argumentInfo)
: base(argumentInfo)
{
}
protected ArgumentHandler(ArgumentInfo argumentInfo)
{
ArgumentName = argumentInfo.Name;
ArgumentProperty = argumentInfo.PropertyInfo;
DefaultValue = argumentInfo.DefaultValue;
}
public override void Execute(JoinPointContext context)
{
if (context == null)
{
TraceBuffer.WriteLine("OUT Tracing: Context not set!");
return;
}
// Sender, Target, Methodname
String sender = "unknown";
if (context.Sender != null)
{
sender = context.Sender.GetType().FullName;
}
Type target = null;
if (context.StartTarget != null)
{
target = context.StartTarget.GetType();
}
TraceBuffer.WriteLine("OUT Tracing: Sender={0}, Target={1}, MethodName={2} ", sender, target, context.StartSelector);
System.Reflection.MethodInfo mi = target.GetMethod(context.StartSelector, BindingFlags.Public
| BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Instance);
if (mi != null && context.ArgumentCount > 0)
{
System.Reflection.ParameterInfo[] pi = mi.GetParameters();
for (int j = 0; j < pi.Length; j++)
{
if (pi[j].IsOut)
{
ArgumentInfo argumentInfo = context.GetArgumentInfo((short)(j + 1));
if (argumentInfo.Value == null)
{
TraceBuffer.WriteLine(" argument {0} (out) -> {1} = null", j + 1, pi[j].ParameterType.FullName);
continue;
}
String argvalue;
try
{
argvalue = argumentInfo.Value.ToString();
}
catch (Exception)
{
argvalue = "<exception>";
}
TraceBuffer.WriteLine(" argument {0} (out) -> {1} = {2}", j + 1, pi[j].ParameterType.FullName, argvalue);
}
}
}
// Returnvalue
if (context.HasReturnValue)
{
if (context.ReturnType == null)
{
TraceBuffer.WriteLine(" return type = null");
}
else if (context.ReturnValue == null)
{
TraceBuffer.WriteLine(" return type = {0}, return value = null", context.ReturnType.FullName);
}
else if (context.StartSelector != "ToString")
{
TraceBuffer.WriteLine(" return type = {0}, return value = ", context.ReturnType.FullName);
}
else
{
String returnValue;
try
{
returnValue = context.ReturnValue.ToString();
}
catch (Exception)
{
returnValue = "<exception>";
}
TraceBuffer.WriteLine(" return type = {0}, return value = (1)", context.ReturnType.FullName, returnValue);
}
}
//Type t = context.GetProperty("target").GetType();
////Console.WriteLine("Tracing IN method: "+t.get_Name() + "." + rm.getSelector());
//System.Reflection.MethodInfo[] mi = t.GetMethods(BindingFlags.Public
// | BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Instance);
//for (int i = 0; i < mi.Length; i++)
//{
// //Console.WriteLine("\tSearching for method: "+rm.getSelector()+" == "+mi[i].get_Name());
// if (mi[i].Name == (string)context.GetProperty("selector"))
// {
// if (((object[])context.GetProperty("args")).Length == 0)
// {
// Object[] obj = new Object[0];
// Console.WriteLine("TracingOUT: " + t.Name + "." + (string)context.GetProperty("selector"));
// break;
// }
// int k = 0;
// ArrayList list = new ArrayList();
// System.Reflection.ParameterInfo[] pi = mi[i].GetParameters();
// for (int j = 0; j < pi.Length; j++)
// {
// if (pi[j].IsOut)
// {
// list.Add(context.GetProperty("Arg[" + k + "]"));
// }
// k++;
// }
// Console.WriteLine("TracingOUT[" + context.GetProperty("returnvalue") + "][" + list.ToArray().Length + "]: " + list.ToString());
// break;
// }
//}
}
public static ArgumentHandler GetArgumentHandler(ArgumentInfo argumentInfo)
{
var argumentType = argumentInfo.PropertyInfo.PropertyType;
if (argumentType == typeof(int))
{
return new IntArgumentHandler(argumentInfo);
}
if (argumentType == typeof(string))
{
return new ValueArgumentHandler(argumentInfo);
}
if (argumentType.IsSubclassOf(typeof(Enum)))
{
return new EnumArgumentHandler(argumentInfo);
}
throw new InvalidOperationException(string.Format("Unhandled type for argument {0}", argumentInfo.Name));
}
protected override void RunInstruction(ComputerInstruction instruction, ArgumentInfo arg0, ArgumentInfo arg1, ref int instructionOffset)
{
switch (instruction.Operator)
{
case ComputerOperator.Send:
lastSound = arg0.Value32;
break;
case ComputerOperator.Add:
Registers[arg0.RegisterName] += arg1.Value;
break;
case ComputerOperator.Subtract:
Registers[arg0.RegisterName] -= arg1.Value;
break;
case ComputerOperator.Multiply:
Registers[arg0.RegisterName] *= arg1.Value;
break;
case ComputerOperator.Modulo:
Registers[arg0.RegisterName] %= arg1.Value;
break;
case ComputerOperator.Receive:
if (lastSound is 0)
{
break;
}
HaltRequested = SoundRecoveredHandler(lastSound);
break;
default:
base.RunInstruction(instruction, arg0, arg1, ref instructionOffset);
return;
}
}
