public SemanticAtom Visit(MainClass n)
{
var method = new ClassMethod("main", null, n.MainMethodBody.Location);
CurrentMethod = method;
_localPosition = 0;
var argsType = new UtilizedType(Primitive.StringArray.Name, n.Location);
var argsArg = new MethodArgument(n.ArgsName, argsType, method.DeclarationLocation);
AddToGlobalUtilization(argsType, s => { argsArg.RealizedType = s; });
method.Arguments.Add(argsArg.Name, argsArg);
method.RealizedReturnType = Primitive.Void;
method.AstReturnType = null;
BlockStack = new Stack <ClassMethodBlock>();
method.MethodBody = n.MainMethodBody.Accept(this) as ClassMethodBlock;
var c = new Class(n.Name, null, n.Location)
{
IsMainClass = true
};
c.Methods.Add("main", method);
AddToTypeTable(c);
return(c);
}
public async Task <ActionResult <MethodArgument> > PostMethodArgument(MethodArgument methodArgument)
{
_context.MethodArguments.Add(methodArgument);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMethodArgument", new { id = methodArgument.Id }, methodArgument));
}
public async Task <IActionResult> PutMethodArgument(int id, MethodArgument methodArgument)
{
if (id != methodArgument.Id)
{
return(BadRequest());
}
_context.Entry(methodArgument).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MethodArgumentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private MethodArgument GetMethodArgument(NameValueCollection queryString)
{
var ma = new MethodArgument();
return(ma);
}
public SemanticAtom Visit(Argument n)
{
var utilizedType = n.AstType.Accept(this) as UtilizedType;
var methodArg = new MethodArgument(n.Name, utilizedType, n.Location);
AddToGlobalUtilization(utilizedType, s => { methodArg.RealizedType = s; });
return(methodArg);
}
private List <MethodArgument> GetMethodArguments(MethodInfo mi)
{
ParameterInfo[] pi = mi.GetParameters();
List <MethodArgument> args = new List <MethodArgument> ();
foreach (ParameterInfo info in pi)
{
MethodArgument arg = new MethodArgument(info.Name, info.ParameterType.ToString());
args.Add(arg);
}
return(args);
}
private List <MethodArgument> CollectArguments(ParameterListSyntax parameterList)
{
List <MethodArgument> outp = new List <MethodArgument>()
{
};
foreach (var param in parameterList.Parameters)
{
var methArg = new MethodArgument {
Name = param.Identifier.ToString()
};
outp.Add(methArg);
}
return(outp);
}
public string Simulate(string stringArg, SampleClass sample)
{
var del = new DelegateWithArguments();
var args = new MethodArgument[2];
var arg = new MethodArgument();
arg.Index = 0;
arg.Name = "stringArg";
arg.Value = stringArg;
args[0] = arg;
var arg1 = new MethodArgument();
arg1.Index = 1;
arg1.Name = "sample";
arg1.Value = sample;
args[1] = arg1;
return(del.Process(() => "lol", args));
}
public string Simulate(string stringArg, SampleClass sample)
{
var del = new DelegateWithArguments();
var args = new MethodArgument[2];
var arg = new MethodArgument();
arg.Index = 0;
arg.Name = "stringArg";
arg.Value = stringArg;
args[0] = arg;
var arg1 = new MethodArgument();
arg1.Index = 1;
arg1.Name = "sample";
arg1.Value = sample;
args[1] = arg1;
return del.Process(() => "lol", args);
}
private static List <MethodArgument> GetParameters(string expression, DataManager mgr)
{
newExpression = expression;
List <MethodArgument> parameters = new List <MethodArgument>();
foreach (KeyValuePair <string, string> varInfo in mgr.VariablesMap)
{
if (expression.Contains(varInfo.Key))
{
parameters.Add(
new MethodArgument()
{
Name = varInfo.Key,
TypeName = varInfo.Value
});
}
}
foreach (TableManager tbmgr in mgr.Tables.Values)
{
foreach (DataColumn column in tbmgr.Table.Columns)
{
string originalFieldNotation = tbmgr.Table.TableName + "." + column.ColumnName;
if (expression.Contains(originalFieldNotation))
{
MethodArgument arg = new MethodArgument()
{
Name = tbmgr.Table.TableName + column.ColumnName,
TypeName = column.DataType.ToString()
};
parameters.Add(arg);
expression = expression.Replace(originalFieldNotation, arg.Name);
newExpression = expression;
}
}
}
return(parameters);
}
private void ExtractFromMethod(MethodInfo methodInfo, TypeExtraction typExtracted)
{
MethodExtraction mextraction = new MethodExtraction()
{
Name = methodInfo.Name,
ReturnValueType = methodInfo.ReturnType.Name,
Signature = methodInfo.ToString(),
Arguments = new List <MethodArgument>()
{
}
};
var parameters = methodInfo.GetParameters();
foreach (var parameterInfo in parameters)
{
MethodArgument arg = new MethodArgument()
{
Name = parameterInfo.Name,
Type = parameterInfo.ParameterType.ToString()
};
foreach (var parameterInfoCustomAttribute in parameterInfo.CustomAttributes)
{
if (parameterInfoCustomAttribute.AttributeType == typeof(ParamArrayAttribute))
{
arg.IsParams = true;
break;
}
}
mextraction.Arguments.Add(arg);
}
typExtracted.Methods.Add(mextraction);
}
internal static MethodDefinition CreateAssociatedBoolMethod(this PropertyDefinition property, MethodArgument methodArg, bool @return)
{
var method = new MethodDefinition(methodArg.Name, methodArg.Attributes, property.Module.TypeSystem.Boolean);
var body = method.Body;
body.InitLocals = true;
body.Variables.Add(new VariableDefinition(property.Module.TypeSystem.Boolean));
var instructions = body.Instructions;
instructions.Add(Instruction.Create(OpCodes.Nop));
instructions.Add(Instruction.Create(@return ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0));
instructions.Add(Instruction.Create(OpCodes.Stloc_0));
var ldLoc0 = Instruction.Create(OpCodes.Ldloc_0);
instructions.Add(Instruction.Create(OpCodes.Br_S, ldLoc0));
instructions.Add(ldLoc0);
instructions.Add(Instruction.Create(OpCodes.Ret));
return(method);
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
ReturnType = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List)
{
{
Arguments = new List <MethodArgument>();
TList _list30 = iprot.ReadListBegin();
for (int _i31 = 0; _i31 < _list30.Count; ++_i31)
{
MethodArgument _elem32;
_elem32 = new MethodArgument();
_elem32.Read(iprot);
Arguments.Add(_elem32);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
Annotations = new List <Annotation>();
TList _list33 = iprot.ReadListBegin();
for (int _i34 = 0; _i34 < _list33.Count; ++_i34)
{
Annotation _elem35;
_elem35 = new Annotation();
_elem35.Read(iprot);
Annotations.Add(_elem35);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
internal bool IsDelegateMatch(Type parameterType, MethodArgument argument, CompileVisitor visitor)
{
ScriptBlockAst sbAst;
if (argument.Ast is ScriptBlockExpressionAst sbExpression)
{
sbAst = (ScriptBlockAst)sbExpression.ScriptBlock.Visit(
new DelegateSyntaxVisitor(visitor.Errors));
}
else
{
sbAst = (ScriptBlockAst)((ScriptBlockAst)argument.Ast).Visit(
new DelegateSyntaxVisitor(visitor.Errors));
}
argument.Ast = sbAst;
var parameterMethod = parameterType.GetMethod(Strings.DelegateInvokeMethodName);
if (parameterMethod == null && typeof(Expression).IsAssignableFrom(parameterType))
{
parameterMethod = parameterType
.GetGenericArguments()[0]
.GetMethod(Strings.DelegateInvokeMethodName);
}
var astHasExplicitReturn = ExplicitReturnVisitor.TryFindExplicitReturn(
sbAst,
out PipelineBaseAst returnValue);
if (astHasExplicitReturn)
{
if (parameterMethod.ReturnType == typeof(void) &&
returnValue != null)
{
return(false);
}
}
var parameterParameters = parameterMethod.GetParameters();
ParameterAst[] sbParameters;
if (sbAst.ParamBlock != null)
{
sbParameters = new ParameterAst[sbAst.ParamBlock.Parameters.Count];
for (var i = 0; i < sbParameters.Length; i++)
{
sbParameters[i] = sbAst.ParamBlock.Parameters[i];
}
}
else
{
sbParameters = s_emptyParameterAsts;
}
if (parameterParameters.Length != sbParameters.Length)
{
return(false);
}
var expectedParameterTypes = new Type[parameterParameters.Length];
for (var i = 0; i < parameterParameters.Length; i++)
{
if (parameterParameters[i].ParameterType.IsGenericParameter)
{
if (_map.TryGetValue(parameterParameters[i].ParameterType, out Type resolvedType))
{
expectedParameterTypes[i] = resolvedType;
continue;
}
// TODO: Check if parameter is strongly typed in the AST and use that to
// resolve the targ.
return(false);
}
expectedParameterTypes[i] = parameterParameters[i].ParameterType;
}
var expectedReturnType = parameterMethod.ReturnType.IsGenericParameter
? null
: parameterMethod.ReturnType;
if (expectedReturnType == null)
{
_map.TryGetValue(parameterMethod.ReturnType, out expectedReturnType);
}
var oldErrorWriter = visitor.Errors;
try
{
visitor.Errors = ParseErrorWriter.CreateNull();
argument.Expression = visitor.CompileAstImpl(
sbAst,
s_emptyVariables,
expectedParameterTypes,
expectedReturnType,
null);
}
catch (Exception)
{
// TODO: Better reporting here if all method resolution fails.
return(false);
}
finally
{
visitor.Errors = oldErrorWriter;
}
if (parameterMethod.ReturnType.IsGenericParameter &&
!_map.ContainsKey(parameterMethod.ReturnType))
{
_map.Add(parameterMethod.ReturnType, ((LambdaExpression)argument.Expression).ReturnType);
}
if (parameterType.IsGenericType)
{
var genericParameters = parameterType.GetGenericArguments();
var newGenericParameters = new Type[genericParameters.Length];
for (var i = 0; i < genericParameters.Length; i++)
{
if (genericParameters[i].IsGenericParameter)
{
_map.TryGetValue(genericParameters[i], out Type resolvedType);
newGenericParameters[i] = resolvedType;
continue;
}
newGenericParameters[i] = genericParameters[i];
}
parameterType = parameterType
.GetGenericTypeDefinition()
.MakeGenericType(newGenericParameters);
}
argument.Expression = Expression.Lambda(
parameterType,
((LambdaExpression)argument.Expression).Body,
((LambdaExpression)argument.Expression).Parameters);
return(true);
}
private BindingResult BindMethod(
CompileVisitor visitor,
Type sourceType,
string name,
Ast[] arguments,
Expression instance,
Type[] genericArguments)
{
var methodArgs = new MethodArgument[arguments.Length];
for (var i = 0; i < methodArgs.Length; i++)
{
methodArgs[i] = (MethodArgument)arguments[i];
}
var didFindName = false;
var isInstance = instance != null;
var methods = sourceType.GetMethods(isInstance ? _instanceFlags : _staticFlags);
MethodInfo boundMethod;
BindingResult bindingResult = default(BindingResult);
for (var i = 0; i < methods.Length; i++)
{
if (!methods[i].Name.Equals(name, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (!didFindName)
{
didFindName = true;
}
if (genericArguments.Length > 0 &&
(!methods[i].IsGenericMethod ||
!AreGenericArgumentsValid(methods[i], genericArguments)))
{
continue;
}
if (genericArguments.Length > 0)
{
methods[i] = methods[i].MakeGenericMethod(genericArguments);
}
if (ShouldBind(methods[i], methodArgs, visitor, out boundMethod))
{
var expressions = new Expression[methodArgs.Length];
for (var j = 0; j < methodArgs.Length; j++)
{
expressions[j] = methodArgs[j].Expression;
}
bindingResult.Expression = Expression.Call(instance, boundMethod, expressions);
return(bindingResult);
}
}
if (!isInstance)
{
bindingResult.Reason = new ArgumentException(
string.Format(
CultureInfo.CurrentCulture,
ErrorStrings.NoMemberArgumentMatch,
sourceType.FullName,
name));
bindingResult.Id = nameof(ErrorStrings.NoMemberArgumentMatch);
return(bindingResult);
}
var extensionArgs = new MethodArgument[methodArgs.Length + 1];
extensionArgs[0] = (MethodArgument)instance;
for (var i = 1; i < extensionArgs.Length; i++)
{
extensionArgs[i] = methodArgs[i - 1];
}
methods = GetExtensionMethods();
for (var i = 0; i < methods.Length; i++)
{
if (!methods[i].Name.Equals(name, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (!didFindName)
{
didFindName = true;
}
if (genericArguments.Length > 0 &&
(!methods[i].IsGenericMethod ||
!AreGenericArgumentsValid(methods[i], genericArguments)))
{
continue;
}
if (genericArguments.Length > 0)
{
methods[i] = methods[i].MakeGenericMethod(genericArguments);
}
if (ShouldBind(methods[i], extensionArgs, visitor, out boundMethod))
{
var expressions = new Expression[extensionArgs.Length];
for (var j = 0; j < extensionArgs.Length; j++)
{
expressions[j] = extensionArgs[j].Expression;
}
bindingResult.Expression = Expression.Call(boundMethod, expressions);
return(bindingResult);
}
}
if (!didFindName)
{
bindingResult.Reason =
new ArgumentException(
string.Format(
CultureInfo.CurrentCulture,
ErrorStrings.NoMemberNameMatch,
sourceType.FullName,
name));
bindingResult.Id = nameof(ErrorStrings.NoMemberNameMatch);
return(bindingResult);
}
bindingResult.Reason = new ArgumentException(
string.Format(
CultureInfo.CurrentCulture,
ErrorStrings.NoMemberArgumentMatch,
sourceType.FullName,
name));
bindingResult.Id = nameof(ErrorStrings.NoMemberArgumentMatch);
return(bindingResult);
}
private List<MethodArgument> GetMethodArguments(MethodInfo mi){
ParameterInfo[] pi = mi.GetParameters ();
List<MethodArgument> args = new List<MethodArgument> ();
foreach (ParameterInfo info in pi) {
MethodArgument arg= new MethodArgument(info.Name,info.ParameterType.ToString());
args.Add(arg);
}
return args;
}