public ContextMethod(ContextClass classContext) : base(classContext)
{
ZCClassInfo cclass = this.ClassContext.GetZCompilingType();
ZMethodInfo = new ZCMethodInfo(cclass);
cclass.AddMethod(ZMethodInfo);
}
//private void EmitGetNested()
//{
// if (this.NestedFieldSymbol != null)
// {
// EmitHelper.EmitThis(IL, false);
// EmitSymbolHelper.EmitLoad(IL, this.NestedFieldSymbol);
// base.EmitConv();
// }
// else
// {
// throw new CCException();
// }
//}
public override void EmitSet(Exp valueExp)
{
if (this.ClassContext is ContextNestedClass)
{
FieldBuilder fieldBuilder = this.ProcContext.ClassContext.GetZCompilingType()
.SearchDeclaredZField(VarName).FieldBuilder;
EmitHelper.EmitThis(IL, false);
EmitValueExp(valueExp);
EmitHelper.StormField(IL, fieldBuilder);
}
else if (LocalVarSymbol.IsReplaceToNestedFiled)
{
ZCClassInfo classType = this.ProcContext.GetNestedClassContext().GetZCompilingType();
FieldBuilder fieldBuilder = classType.SearchDeclaredZField(VarName).FieldBuilder;
ZCLocalVar instanceVar = this.ProcContext.NestedInstance;
EmitSymbolHelper.EmitLoad(IL, instanceVar);
EmitValueExp(valueExp);
EmitHelper.StormField(IL, fieldBuilder);
base.EmitConv();
}
else
{
EmitValueExp(valueExp);
EmitSymbolHelper.EmitStorm(IL, LocalVarSymbol);
}
}
public void ImportZCompiling(ZCClassInfo zclassype)
{
string zname = zclassype.ZTypeName;
CompilingClassDict.Add(zname, zclassype);
FileSegementer.AddWord(zname);
ArgSegementer.AddWord(zname);
}
private void AnalyMember(ZCClassInfo zclass)
{
memberSymbol = zclass.SearchProperty(propertyName);
if (memberSymbol != null)
{
RetType = ((ZAPropertyInfo)memberSymbol).GetZPropertyType();
}
}
public void Analy(ClassAST ast)
{
ClassTree = ast;
base.AnalyRaw(ast);
this.ClassTree.ClassContext.SetClassName(TypeName);
ZCClassInfo cclass = this.ClassTree.ClassContext.GetZCompilingType();
this.FileContext.ImportUseContext.ImportZCompiling(cclass);
}
public ContextNestedClass CreateNestedClassContext()
{
if (_NestedClassContext == null)
{
_NestedClassContext = new ContextNestedClass(this);
_NestedClassContext.SetClassName(this.CreateNestedClassName());
var nestedClassInstanceName = _NestedClassContext.ClassName + "_0";
var packageName = this.ClassContext.FileContext.ProjectContext.ProjectModel.ProjectPackageName;
string fullName = packageName + "." + _NestedClassContext.ClassName;
TypeAttributes typeAttrs = TypeAttributes.NestedPrivate | TypeAttributes.Sealed;
TypeBuilder NestedClassBuilder = this.ClassContext.SelfCompilingType.ClassBuilder.DefineNestedType(fullName, typeAttrs);
_NestedClassContext.SetTypeBuilder(NestedClassBuilder);
ZCClassInfo ztype = _NestedClassContext.SelfCompilingType;
if (NestedInstance == null)
{
NestedInstance = new ZCLocalVar(nestedClassInstanceName, ztype, true)
{
IsNestedClassInstance = true
};
this.LocalManager.Add(NestedInstance);
}
if (!this.IsStatic())
{
ZCFieldInfo zf2 = _NestedClassContext.SelfCompilingType.DefineFieldPublic
(ContextNestedClass.MasterClassFieldName, this.ClassContext.SelfCompilingType);
_NestedClassContext.MasterClassField = zf2;
}
if (this.ArgList.Count > 0)
{
foreach (var arg in this.ArgList)
{
ZCParamInfo zp = this.GetParameter(arg);
ZCFieldInfo zf3 = _NestedClassContext.SelfCompilingType.DefineFieldPublic
(arg, zp.GetZClass());
_NestedClassContext.MasterArgDict.Add(arg, zf3);
}
}
/* 生成内部类默认构造函数 */
{
ConstructorBuilder NewBuilder = NestedClassBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { });
var il = NewBuilder.GetILGenerator();
il.Emit(OpCodes.Ret);
ZCConstructorInfo zcc = new ZCConstructorInfo(this._NestedClassContext.SelfCompilingType)
{
ConstructorBuilder = NewBuilder
};
this._NestedClassContext.SelfCompilingType.AddConstructord(zcc);
this._NestedClassContext.DefaultConstructorBuilder = NewBuilder;
}
}
return(_NestedClassContext);
}
public override Exp Analy()
{
if (this.IsAnalyed)
{
return(this);
}
VarName = VarToken.Text;
CompilingType = SearchValue(VarName);
RetType = CompilingType;
IsAnalyed = true;
return(this);
}
public bool IsThisProperty(string name)
{
ZCClassInfo zct = this.ClassContext.GetZCompilingType();//.ThisCompilingType;
foreach (ZCPropertyInfo member in zct.ZPropertys)
{
if (member.HasZName(name))
{
return(true);
}
}
return(false);
}
private static ZTypeCompareEnum Compare(ZLClassInfo z1, ZCClassInfo z2)
{
ZTypeCompareEnum result = Compare(z1, z2.BaseZClass);
if (result == ZTypeCompareEnum.EQ)
{
return(ZTypeCompareEnum.SuperOf);
}
else if (result == ZTypeCompareEnum.SuperOf)
{
return(ZTypeCompareEnum.SuperOf);
}
else
{
return(ZTypeCompareEnum.NEQ);
}
}
public void ImportStruct(ZCClassInfo zclassype)
{
/* Z语言程序生成的库没有field,所以不需要导入field */
foreach (ZCPropertyInfo memberItem in zclassype.ZPropertys)
{
string[] itemNames = memberItem.GetZPropertyZNames();
foreach (var name in itemNames)
{
//ZLPropertyDict.Add(name, memberItem);
FileSegementer.AddWord(name);
}
}
foreach (ZCMethodInfo item in zclassype.ZMethods)
{
ImportZMethod(item);
}
}
protected ContextClass( )
{
EmitContext = new ClassEmitContext();
SelfCompilingType = new ZCClassInfo();
}
public void ImportZCompiling(ZCClassInfo classCompilingType)
{
ContextFileManager.ImportZCompiling(classCompilingType);
}
private static ZTypeCompareEnum Compare(ZCClassInfo z1, ZCClassInfo z2)
{
return(ZTypeCompareEnum.NEQ);
}
