void parseBracket()
{
i++;
List <TKTProcArg> bracketargs = new List <TKTProcArg>();
//Dictionary<string, TKTProcArg> dict = new Dictionary<string, TKTProcArg>();
for (; i < Code.Length; i++)
{
TKTProcArg arg = parseArg();
if (arg != null)
{
bracketargs.Add(arg);
}
//dict.Add(arg.ArgName, arg);
if (ch == '\0')
{
break;
}
if (ch == ')')
{
i++;
break;
}
}
//TKTProcBracket bracket = new TKTProcBracket(bracketargs,dict);
desc.Add(bracketargs);
}
public static TKTConstructorDesc SearchConstructor(TKTConstructorDesc desc, CnEnDict WordDict, Type ForType)
{
TKTConstructorDesc bracket2 = desc;
if (WordDict != null && desc.Bracket.IsNameValue)
{
List <TKTProcArg> args = new List <TKTProcArg>();
foreach (var arg in desc.Bracket.ListArgs)
{
string newArgName = WordDict.Get(arg.ArgName);
TKTProcArg newArg = new TKTProcArg(newArgName, arg.ArgType, arg.ArgType.IsGenericType);
args.Add(newArg);
}
bracket2 = new TKTConstructorDesc(args);
}
ConstructorInfo[] constructorInfoArray = ForType.GetConstructors();
foreach (ConstructorInfo ci in constructorInfoArray)
{
if (ci.IsPublic)
{
TKTConstructorDesc bracketCi = ProcDescHelper.CreateProcBracket(ci);
if (bracketCi.Eq(bracket2))
{
return(bracketCi);
}
}
}
return(null);
}
public static TKTProcDesc CreateProcDesc(ExMethodInfo exMethod)
{
var method = exMethod.Method;
TKTProcDesc desc = new TKTProcDesc();
desc.Add(method.Name);
if (method.IsGenericMethod)
{
foreach (Type paramType in method.GetGenericArguments())
{
TKTProcArg arg = new TKTProcArg(paramType, true);
desc.Add(arg);
}
}
if (method.GetParameters().Length > 0)
{
List <TKTProcArg> args = new List <TKTProcArg>();
foreach (ParameterInfo param in method.GetParameters())
{
TKTProcArg arg = new TKTProcArg(param.Name, param.ParameterType, false);
args.Add(arg);
}
desc.Add(args);
}
desc.ExMethod = exMethod;
return(desc);
}
static TKTProcArg TestProcArg()
{
TKTProcArg arg = new TKTProcArg("GET", typeof(string), true);
TKTProcArg arg2 = new TKTProcArg("GET", typeof(string), false);
return(arg);
}
public List <TKTProcArg> GetDimArgs()
{
List <TKTProcArg> args = new List <TKTProcArg>();
foreach (var exp in this.InneExps)
{
bool isGeneric = false;
Type type = exp.RetType;
string argName = null;
TKTProcArg arg = null;
if (exp is TypeExp)
{
var idExp = exp as TypeExp;
isGeneric = idExp.RetType.IsGenericType;
arg = new TKTProcArg(type, isGeneric);
}
else if (exp is NameValueExp)
{
argName = (exp as NameValueExp).NameToken.GetText();
arg = new TKTProcArg(argName, type, isGeneric);
}
else
{
arg = new TKTProcArg(type, isGeneric);
}
arg.Value = exp;
args.Add(arg);
}
return(args);
}
public InvokeEveryoneBaseExp(InvokeExp srcExp)
: base(srcExp)
{
invokeExp = srcExp;
TKTProcArg arg = invokeExp.ExpProcDesc.GetArg(0);
//everyoneExp = (arg.Value as EveryOneExp);
}
protected void GenerateArgsExp(EmitExpContext context, TKTProcDesc expProcDesc, TKTProcDesc searchedProcDesc, int size)
{
for (int i = 0; i < size; i++)
{
var arg = expProcDesc.GetArg(i);
var exp = (arg.Value as Exp);
TKTProcArg procArg = searchedProcDesc.GetArg(i);
exp.RequireType = procArg.ArgType;
exp.Generate(context);
}
}
public static TKTConstructorDesc CreateProcBracket(ConstructorInfo ci)
{
List <TKTProcArg> args = new List <TKTProcArg>();
foreach (ParameterInfo param in ci.GetParameters())
{
TKTProcArg arg = new TKTProcArg(param.Name, param.ParameterType, false);
args.Add(arg);
}
TKTConstructorDesc desc = new TKTConstructorDesc(args);
desc.Constructor = ci;
return(desc);
}
bool isObjectEveryOneExp()
{
int argsCount = searchedProcDesc.ArgCount;
if (argsCount == 1)
{
TKTProcArg arg = ExpProcDesc.GetArg(0);
Exp exp = (arg.Value as Exp);
if (exp is EveryOneExp)
{
return(true);
}
}
return(false);
}
List <Type> findGenericTypes()
{
List <Type> types = new List <Type>();
for (int i = 0; i < ExpProcDesc.Count; i++)
{
if (searchedProcDesc.GetArg(i).IsGenericArg)
{
TKTProcArg procArg = ExpProcDesc.GetArg(i);
Type type = (procArg.Value as Exp).RetType;
types.Add(type);
}
}
return(types);
}
void analyArgLanmbda(AnalyExpContext context)
{
for (int i = 0; i < ExpProcDesc.ArgCount; i++)
{
TKTProcArg procArg = searchedProcDesc.GetArg(i);
if (procArg.ArgType == TKTLambda.ActionType || procArg.ArgType == TKTLambda.CondtionType)
{
TKTProcArg expArg = ExpProcDesc.GetArg(i);
Exp exp = expArg.Value as Exp;
NewLambdaExp newLambdaExp = new NewLambdaExp(this, exp, procArg.ArgType);
expArg.Value = newLambdaExp;
newLambdaExp.Analy(context);
}
}
}
TKTProcArg parseArg()
{
string argtypename = parseIdent();
movenext();
string argname = parseIdent();
string realArgName = argname;
if (string.IsNullOrEmpty(argname))
{
return(null);
}
if (this.WordDict != null)
{
realArgName = this.WordDict.Get(argname);
}
TKTProcArg arg = null;
if (argtypename == "类型")
{
Type type = typeof(object);
arg = new TKTProcArg(realArgName, type, true);
}
else if (ArgTypeDict.ContainsKey(argtypename))
{
Type type = ArgTypeDict[argtypename];
arg = new TKTProcArg(realArgName, type, false);
}
else if (argtypename == "Func<bool>")//(argtypename.IndexOf("<") > 0 && argtypename.IndexOf(">") > 0)
{
//if(argtypename=="Func<bool>")
//{
arg = new TKTProcArg(realArgName, typeof(Func <bool>), false);
//}
}
else if (argtypename == "Action")
{
arg = new TKTProcArg(realArgName, typeof(Action), false);
}
else
{
throw new RTException("没有导入'" + argtypename + "'类型");
}
return(arg);
}
bool AnlayNameBody(int startArgIndex)
{
var symbols = MethodAST.MethodContext.Symbols;
ProcDesc = new TKTProcDesc();
int argIndex = startArgIndex;
for (int i = 0; i < NameTerms.Count; i++)
{
var term = NameTerms[i];
if (term is FnText)
{
var textterm = term as FnText;
textterm.Analy(this);
ProcDesc.Add(textterm.TextContent);
}
else if (term is FnBracket)
{
var argterm = term as FnBracket;
List <TKTProcArg> procArgs = new List <TKTProcArg>();
foreach (var arg in argterm.Args)
{
bool b = arg.Analy(this, argIndex);
if (b)
{
TKTProcArg procArg = new TKTProcArg(arg.ArgName, arg.ArgType, arg.IsGenericArg);
procArgs.Add(procArg);
argIndex++;
}
else
{
return(false);
}
}
ProcDesc.Add(procArgs);
}
}
if (!checkName())
{
return(false);
}
MethodAST.MethodContext.ProcDesc = ProcDesc;
MethodAST.MethodContext.ClassContext.ClassSymbol.AddMethod(MethodAST.MethodContext);
return(true);
}
