void GenenrateSubject(EmitExpContext context)
{
ILGenerator il = context.ILout;
bool isgen = false;
if ((SubjectExp is VarExp))
{
VarExp varexp = SubjectExp as VarExp;
if (ReflectionUtil.IsStruct(varexp.RetType))
{
if (varexp.VarSymbol is SymbolVar)
{
il.Emit(OpCodes.Ldloca, (varexp.VarSymbol as SymbolVar).VarBuilder);
isgen = true;
}
else if (varexp.VarSymbol is SymbolArg)
{
il.Emit(OpCodes.Ldarga, (varexp.VarSymbol as SymbolArg).ArgIndex);
isgen = true;
}
}
}
if (!isgen)
{
SubjectExp.Generate(context);
}
}
private void AnalyRight()
{
propertyName = RightToken.Text;
if (SubjectExp.RetType is ZLEnumInfo)
{
Errorf(SubjectExp.Position, "约定没有属性");
return;
}
else if (SubjectExp.RetType is ZLClassInfo)
{
AnalyMember(SubjectExp.RetType as ZLClassInfo);
}
else if (SubjectExp.RetType is ZCClassInfo)
{
AnalyMember(SubjectExp.RetType as ZCClassInfo);
}
if (memberSymbol == null)
{
Errorf(SubjectExp.Position, "{0}不存在成员'{1}'", SubjectExp.ToString(), propertyName);
}
else if (IsNeedTempLocal())
{
AnalyPropertyTempLocal();
}
}
public override void Emit()
{
SubjectExp.Emit();
EmitHelper.StormVar(IL, ListSymbol.VarBuilder);
EmitHelper.LoadInt(IL, START_INDEX);
EmitHelper.StormVar(IL, IndexSymbol.VarBuilder);
EmitHelper.LoadVar(IL, ListSymbol.VarBuilder);
EmitHelper.CallDynamic(IL, getCountMethod);
EmitHelper.StormVar(IL, CountSymbol.VarBuilder);
var True_Label = IL.DefineLabel();
var False_Label = IL.DefineLabel();
EmitCondition();
IL.Emit(OpCodes.Brfalse, False_Label);
//定义一个标签，表示从下面开始进入循环体
IL.MarkLabel(True_Label);
BodyExp.Emit();
if (ZTypeUtil.IsBool(BodyExp.RetType))//(BodyExp.RetType.SharpType != typeof(void))
{
IL.Emit(OpCodes.Pop);
}
EmitHelper.Inc(IL, IndexSymbol.VarBuilder);
EmitCondition();
IL.Emit(OpCodes.Brtrue, True_Label);
IL.MarkLabel(False_Label);
}
public override Exp Analy()
{
if (this.IsAnalyed)
{
return(this);
}
if (this.ExpContext == null)
{
throw new CCException();
}
SubjectExp = AnalyLeft();
if (RightToken == null)
{
Errorf(SubjectExp.Position, "'{0}'的后面缺少属性", SubjectExp.ToString());
return(SubjectExp);
}
if (RightToken.IsKind(TokenKindKeyword.Each))
{
var eachItemExp = AnalyEach();
Exp newExp = eachItemExp.Analy();
return(newExp);
}
else
{
AnalyRight();
}
IsAnalyed = true;
return(this);
}
public override string ToCode()
{
StringBuilder buf = new StringBuilder();
buf.Append(SubjectExp != null ? SubjectExp.ToCode() : "");
buf.Append("的");
buf.Append(MemberToken != null ? MemberToken.GetText() : "");
return(buf.ToString());
}
public void EmitGet( )
{
MethodInfo getMethod = Property.GetGetMethod();
SubjectExp.Emit();
ArgExp.RequireType = ZTypeManager.GetBySharpType(getMethod.ReturnType) as ZType;
ArgExp.Emit();
EmitHelper.CallDynamic(IL, getMethod);
}
public override string ToString()
{
StringBuilder buf = new StringBuilder();
buf.Append(SubjectExp != null ? SubjectExp.ToString() : "");
buf.Append("的");
buf.Append(RightToken != null ? RightToken.Text : "");
return(buf.ToString());
}
public void GenerateGet(EmitExpContext context)
{
ILGenerator il = context.ILout;
MethodInfo getMethod = ExProperty.Property.GetGetMethod();
SubjectExp.Generate(context);
ArgExp.RequireType = getMethod.ReturnType;
ArgExp.Generate(context);
EmitHelper.CallDynamic(il, getMethod, ExProperty.IsSelf);
}
public void EmitSet(Exp valueExp)
{
MethodInfo setMethod = Property.GetSetMethod();
SubjectExp.Emit();
ArgExp.RequireType = ZTypeManager.GetBySharpType(setMethod.GetParameters()[0].ParameterType) as ZType;
ArgExp.Emit();
//EmitHelper.Box(il, ArgExp.RetType, setMethod.GetParameters()[0].ParameterType);
valueExp.RequireType = ZTypeManager.GetBySharpType(setMethod.GetParameters()[1].ParameterType) as ZType;
valueExp.Emit();
EmitHelper.CallDynamic(IL, setMethod);
}
public void GenerateSet(EmitExpContext context, Exp valueExpr)
{
ILGenerator il = context.ILout;
MethodInfo setMethod = ExProperty.Property.GetSetMethod();
SubjectExp.Generate(context);
ArgExp.RequireType = setMethod.GetParameters()[0].ParameterType;
ArgExp.Generate(context);
//EmitHelper.Box(il, ArgExp.RetType, setMethod.GetParameters()[0].ParameterType);
valueExpr.RequireType = setMethod.GetParameters()[1].ParameterType;
valueExpr.Generate(context);
EmitHelper.CallDynamic(il, setMethod, ExProperty.IsSelf);
}
/*
* public void GenerateArgILBox(EmitExpContext context,int i)
* {
* ILGenerator il = context.ILout;
* var arg = ExpProcDesc.GetArg(i);
* var exp = (arg.Value as Exp);
* var rettype = exp.RetType;
* TKTProcArg procArg = searchedProcDesc.GetArg(i);
* Type callArgType = procArg.ArgType;
* EmitHelper.Box(il, rettype, callArgType);
* }*/
public void GenerateSubject(EmitExpContext context)
{
ILGenerator il = context.ILout;
if (SubjectExp != null)
{
SubjectExp.Generate(context);
}
else
{
if (!CallExMethod.Method.IsStatic)
{
il.Emit(OpCodes.Ldarg_0);
}
}
}
private void EmitLeft()
{
if (SubjectExp.RetType.IsStruct)
{
if (IsNeedTempLocal())
{
SubjectExp.Emit();
EmitSymbolHelper.EmitStorm(IL, this.tempLocal);
EmitSymbolHelper.EmitLoada(IL, this.tempLocal);
}
else
{
if (SubjectExp is ExpLocalVar)
{
((ExpLocalVar)SubjectExp).EmitLoadLocala();
}
else if (SubjectExp is ExpArg)
{
((ExpArg)SubjectExp).EmitLoadArga();
}
else if (SubjectExp is ExpFieldDef)
{
((ExpFieldDef)SubjectExp).EmitLoadFielda();
}
else if (SubjectExp is ExpFieldSuper)
{
((ExpFieldSuper)SubjectExp).EmitLoadFielda();
}
else if (SubjectExp is ExpUseField)
{
((ExpUseField)SubjectExp).EmitLoadFielda();
}
else
{
SubjectExp.Emit();
}
}
}
else
{
SubjectExp.Emit();
}
}
public override Exp Analy()
{
if (this.IsAnalyed)
{
return(this);
}
SubjectExp = SubjectExp.Analy();
if (SubjectExp.RetType == null)
{
//Type newType =typeof(列表<>).MakeGenericType(typeof(object));
//ZType newZtype = ZTypeManager.RegNewGenericType(newType);
ZLClassInfo newZClass = ZTypeManager.MakeGenericType(ZLangBasicTypes.ZLIST, ZLangBasicTypes.ZOBJECT);
SubjectExp.RetType = newZClass;
}
CreateEachSymbols();
AnalyCountMethod();
ItemExp = new ExpEachItem(this.ExpContext, this.ListSymbol, this.IndexSymbol);
this.RetType = ZLangBasicTypes.ZVOID;
IsAnalyed = true;
return(this);
}
private Exp AnalyLeft()
{
var newExp = AnalySubExp(SubjectExp);
if (newExp is ExpTypeBase)
{
var leftTypeExp = (SubjectExp as ExpTypeBase);
ZType ltype = leftTypeExp.RetType;
if (ltype is ZLEnumInfo)
{
Errorf(SubjectExp.Position, "约定类型'{0}'取值不能用'的'", SubjectExp.ToString());
}
else if (ltype is ZLClassInfo)
{
ExpStaticClassName escn = new ExpStaticClassName(this.ExpContext, leftTypeExp.GetMainToken(), (ltype as ZLClassInfo));
//escn.SetContextExp(this.ExpContext);
newExp = escn.Analy();
}
}
return(newExp);
//else if (LeftExp is ExpLocalVar)
//{
// memberSymbol = (LeftExp as ExpLocalVar).LocalVarSymbol;
//}
//else if (LeftExp is ExpArg)
//{
// memberSymbol = (LeftExp as ExpArg).ArgSymbol;
//}
//else
//{
// //isNeedEmitLeft = true;
// //var VarName = "LocalDStructIndex_" + LocalDStructIndex;
// //ZCLocalVar localVarSymbol = new ZCLocalVar(VarName, LeftExp.RetType);
// //localVarSymbol.LoacalVarIndex = this.ExpContext.ProcContext.CreateLocalVarIndex(VarName);
// //this.ProcContext.AddLocalVar(localVarSymbol);
// //memberSymbol = localVarSymbol;
// //LocalDStructIndex++;
//}
}
public override Exp Analy(AnalyExpContext context)
{
base.Analy(context);
var symbols = this.AnalyExpContext.Symbols;
SubjectExp = SubjectExp.Analy(context); // AnalyExp(SubjectExp);
ArgExp = ArgExp.Analy(context); //AnalyExp(ArgExp);
var propertyName = "Item";
var subjType = SubjectExp.RetType;
ExProperty = GclUtil.SearchExProperty(propertyName, subjType); //subjType.GetExProperty(propertyName);
if (ExProperty == null)
{
error(SubjectExp.Postion, "不存在索引");
return(null);
}
else
{
RetType = ExProperty.Property.PropertyType;
}
return(this);
}
public override void SetParent(Exp parentExp)
{
ParentExp = parentExp;
SubjectExp.SetParent(this);
BodyExp.SetParent(this);
}
public override string ToString()
{
return(string.Format("{0}第{1}", SubjectExp.ToString(), ArgExp.ToString()));
}
public override void GetNestedFields(Dictionary <string, VarExp> nestedField)
{
SubjectExp.GetNestedFields(nestedField);
}
public override Exp Analy(AnalyExpContext context)
{
base.Analy(context);
if (MemberToken == null)
{
error("'的'字前面没有对象");
return(null);
}
if (MemberToken == null)
{
error("'的'字后面没有属性名称");
return(null);
}
var symbols = this.AnalyExpContext.Symbols;
SubjectExp.IsAssignedBy = this.IsAssignedBy;
SubjectExp.IsAssignedValue = this.IsAssignedValue;
SubjectExp = SubjectExp.Analy(context);
propertyName = MemberToken.GetText();
var subjType = SubjectExp.RetType;
if (subjType == null)
{
return(null);
}
if (propertyName == "每一个" && subjType.IsGenericType && subjType.GetGenericTypeDefinition() == typeof(Z语言系统.列表 <>))
{
EveryOneExp eoexp = new EveryOneExp();
eoexp.ListExp = this.SubjectExp;
eoexp.MemberToken = this.MemberToken;
Exp eoExp = eoexp.Analy(context);
return(eoExp);
}
else
{
if (!(subjType is TypeBuilder))
{
IGcl obj = context.StmtContext.MethodContext.ClassContext.ImportContext.SearchGCL(subjType);
if (obj == null)
{
//ExProperty = subjType.GetExProperty(propertyName);
ExProperty = GclUtil.SearchExProperty(propertyName, subjType);
}
else
{
ExProperty = obj.SearchExProperty(propertyName);
}
}
else
{
string name = subjType.Name;
SymbolInfo symbol = symbols.Get(name);
if (symbol is SymbolDefClass)
{
ExProperty = (symbol as SymbolDefClass).GetExProperty(propertyName);
//ExProperty = GclUtil.SearchExProperty(propertyName, symbol as SymbolDefClass);
}
}
}
if (ExProperty == null)
{
error(SubjectExp.Postion, "不存在" + propertyName + "属性");
return(null);
}
else
{
RetType = ExProperty.Property.PropertyType;
}
return(this);
}
