public ZLDimInfo CreateZType()
{
Type type = DimBuilder.CreateType();
var EmitedZType = ZTypeManager.CreateZLDimImp(type);
return(EmitedZType);
}
public ZLEnumInfo CreateZType()
{
var EmitedType = EnumTypeBuilder.CreateType();
ZLEnumInfo ztype = ZTypeManager.GetByMarkType(EmitedType) as ZLEnumInfo;
return(ztype);
}
public override Exp Analy( )
{
//SubjectExp.SetContext(this.ExpContext);
//ArgExp.SetContext(this.ExpContext);
SubjectExp = AnalySubExp(SubjectExp); // SubjectExp.Analy();
ArgExp = AnalySubExp(ArgExp); //ArgExp = ArgExp.Analy();
if (!this.AnalyCorrect)
{
return(this);
}
var propertyName = CompileConstant.ZListItemPropertyName;// "Item";
var subjType = SubjectExp.RetType;
if (subjType is ZClassType)
{
ZClassType zclass = subjType as ZClassType;
Property = zclass.SharpType.GetProperty(propertyName);
}
if (Property == null)
{
ErrorE(SubjectExp.Postion, "不存在索引");
}
else
{
RetType = ZTypeManager.GetBySharpType(Property.PropertyType) as ZType;
}
return(this);
}
private ZType GetZTypeByTypeName(string typeName)
{
//if (typeName == "Func<bool>")
//{
// arg = new ZMethodArg(typeName, ZTypeCache.GetByZType(typeof(Func<bool>)));
//}
//else if (argtypename == "Action")
//{
// arg = new ZMethodArg(realArgName, ZTypeCache.GetByZType(typeof(Action)));
//}
//else
//{
var ztypes = ZTypeManager.GetByMarkName(typeName);
if (ztypes.Length == 0)
{
ztypes = ZTypeManager.GetBySharpName(typeName);
}
if (ztypes.Length > 0)
{
ZType ztype = ztypes[0] as ZType;
//arg = new ZMethodArg(typeName, ztype);
return(ztype);
}
else
{
}
return(null);
}
public override Exp Analy( )
{
if (this.IsAnalyed)
{
return(this);
}
SubjectExp = AnalySubExp(SubjectExp);
ArgExp = AnalySubExp(ArgExp);
if (!this.AnalyCorrect)
{
return(this);
}
var propertyName = ZLangUtil.ZListItemPropertyName;
var subjType = SubjectExp.RetType;
if (subjType is ZLClassInfo)
{
ZLClassInfo zclass = subjType as ZLClassInfo;
Type argType = ZTypeUtil.GetTypeOrBuilder(ArgExp.RetType);
Property = zclass.SharpType.GetProperty(propertyName, new Type[] { argType });
}
if (Property == null)
{
Errorf(SubjectExp.Position, "不存在索引");
}
else
{
RetType = ZTypeManager.GetBySharpType(Property.PropertyType) as ZType;
}
IsAnalyed = true;
return(this);
}
public override Exp Analy( )
{
if (this.IsAnalyed)
{
return(this);
}
AnalyCorrect = true;
if (LeftExp == null && RightExp != null)
{
ExpUnary unexp = new ExpUnary(this.ExpContext, OpToken, RightExp);
var exp = unexp.Analy();
return(exp);
}
else if (LeftExp == null && RightExp == null)
{
Errorf(this.OpToken.Position, "运算符'{0}'两边缺少表达式", OpToken.Text);
}
OpKind = OpToken.Kind;
LeftExp = AnalySubExp(LeftExp);
RightExp = AnalySubExp(RightExp);
if (RightExp == null)
{
Errorf(OpToken.Position, "运算符'{0}'右边缺少运算元素", OpToken.Text);
}
else
{
this.AnalyCorrect = this.LeftExp.AnalyCorrect && RightExp.AnalyCorrect && this.AnalyCorrect;
if (LeftExp.AnalyCorrect && RightExp.AnalyCorrect)
{
ZType ltype = LeftExp.RetType;
ZType rtype = RightExp.RetType;
if (ZTypeUtil.IsVoid(ltype) || ZTypeUtil.IsVoid(rtype))
{
Errorf(OpToken.Position, "没有结果的表达式无法进行'{0}'运算", OpToken.ToCode());
}
else
{
OpMethod = ExpBinaryUtil.GetCalcMethod(OpKind, ltype, rtype);
if (OpMethod != null)
{
RetType = ZTypeManager.GetBySharpType(OpMethod.ReturnType) as ZType;
}
else
{
Errorf(OpToken.Position, "两种类型无法进行'{0}'运算", OpToken.ToCode());
}
}
}
else
{
this.RetType = ZLangBasicTypes.ZOBJECT;
}
}
//AnalyResultLocal();
IsAnalyed = true;
return(this);
}
public void EmitGet( )
{
MethodInfo getMethod = Property.GetGetMethod();
SubjectExp.Emit();
ArgExp.RequireType = ZTypeManager.GetBySharpType(getMethod.ReturnType) as ZType;
ArgExp.Emit();
EmitHelper.CallDynamic(IL, getMethod);
}
public ZDimType GetCreatedZType()
{
if (EmitedZType == null)
{
Type type = this.Builder.CreateType();
EmitedZType = ZTypeManager.GetByMarkType(type) as ZDimType;
}
return(EmitedZType);
}
public void Analy()
{
string fileName = this.ASTClass.FileContext.FileModel.GeneratedClassName;
bool IsStatic = false;
ZLClassInfo BaseZType = null;
if (Raw == null)
{
IsStatic = false;
BaseZType = ZLangBasicTypes.ZOBJECT;
}
else if (Raw.BaseTypeToken == null)
{
ExtendsTypeName = null;
IsStatic = false;
BaseZType = ZLangBasicTypes.ZOBJECT;
}
else
{
ExtendsTypeName = Raw.BaseTypeToken.Text;
if (ExtendsTypeName == "唯一类型")
{
IsStatic = true;
}
else if (ExtendsTypeName == "普通类型" || ExtendsTypeName == "一般类型")
{
IsStatic = false;
BaseZType = ZLangBasicTypes.ZOBJECT;
}
else
{
IsStatic = false;
var ztypes = ZTypeManager.GetByMarkName(ExtendsTypeName);
if (ztypes.Length == 0)
{
this.ASTClass.FileContext.Errorf(Raw.BaseTypeToken.Position, "类型'{0}'不存在", ExtendsTypeName);
}
else if (ztypes.Length == 1)
{
BaseZType = ztypes[0] as ZLClassInfo;
}
else if (ztypes.Length == 0)
{
this.ASTClass.FileContext.Errorf(Raw.BaseTypeToken.Position, "'{0}'存在{1}个同名类型", ExtendsTypeName, ztypes.Length.ToString());
}
}
//if (ClassName != fileName)
//{
// this.FileContext.Errorf(BaseTypeToken.Position, "类名称 '" + ClassName + "'和文件名称'" + fileName + "'不一致");
//}
}
this.ASTClass.ClassContext.SetIsStatic(IsStatic);
this.ASTClass.ClassContext.SetSuperClass(BaseZType);
}
public override Exp Analy( )
{
//var propertyName = "Item";
var subjType = ListSymbol.SymbolZType;
ZClassType zclass = subjType as ZClassType;
Property = zclass.SharpType.GetProperty(CompileConstant.ZListItemPropertyName);//propertyName);
RetType = ZTypeManager.GetBySharpType(Property.PropertyType) as ZType;
return(this);
}
public ZType Compile(ModuleBuilder moduleBuilder, string packageName)
{
AnalyName();
EmitName(moduleBuilder, packageName);
AnalyBody();
EmitBody();
var EmitedType = Builder.CreateType();
ZType ztype = ZTypeManager.GetByMarkType(EmitedType) as ZType;
return(ztype);
}
protected void EmitArgsExp(ParameterInfo[] paramInfos, Exp[] args)
{
var size = paramInfos.Length;
for (int i = 0; i < size; i++)
{
Exp argExp = args[i];
ParameterInfo parameter = paramInfos[i];
argExp.RequireType = ZTypeManager.GetBySharpType(parameter.ParameterType) as ZType;
argExp.Emit();
}
}
public void CreateZType()
{
ProjectCompileResult compileResult = this.ProjectContext.CompileResult;
if (!HasError())
{
Type type = this.ClassSection.Builder.CreateType();
IZDescType ztype = ZTypeManager.GetByMarkType(type);
this.FileContext.EmitedZClass = ztype as ZType;
this.ProjectContext.CompileResult.CompiledTypes.Add(ztype);
}
}
private void AnalyGeneric_1()
{
Token genericArgTypeToken = TypeTokens[0];
ZType genericArgZType = SearchZType(genericArgTypeToken);
if (genericArgZType != null)
{
Type newType = mainZType.SharpType.MakeGenericType(genericArgZType.SharpType);
ZType newZtype = ZTypeManager.RegNewGenericType(newType);
RetType = newZtype;
}
}
//public void EmitBody()
//{
// if (Properties != null)
// {
// Properties.EmitBodys();
// }
// foreach (ProcConstructorBase item in Constructors)
// {
// item.EmitBody();
// }
// foreach (ProcMethod item in Methods)
// {
// item.EmitBody();
// }
//}
public ZLClassInfo CreateZType()
{
if (!HasError())
{
Type type = this.ClassContext.GetTypeBuilder().CreateType();
var ztype = ZTypeManager.GetByMarkType(type);
ZLClassInfo zclasstype = (ZLClassInfo)ztype;
this.FileContext.EmitedIZDescType = zclasstype;
return(zclasstype);
}
return(null);
}
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);
}
private void AnalyGeneric_2()
{
Token genericArgTypeToken1 = TypeTokens[0];
Token genericArgTypeToken2 = TypeTokens[1];
ZType genericArgZType1 = SearchZType(genericArgTypeToken1);
ZType genericArgZType2 = SearchZType(genericArgTypeToken2);
if (genericArgZType1 != null && genericArgZType2 != null)
{
Type newType = mainZType.SharpType.MakeGenericType(genericArgZType1.SharpType, genericArgZType2.SharpType);
ZType newZtype = ZTypeManager.RegNewGenericType(newType);
RetType = newZtype;
}
}
private Exp AnalyGeneric_1()
{
LexToken genericArgTypeToken = TypeTokens[0];
ZType genericArgZType = SearchZType(genericArgTypeToken);
if (genericArgZType != null)
{
//Type newType = MakeGenericType(mainZType, genericArgZType);
//ZType newZtype = ZTypeManager.RegNewGenericType(newType);
ZLClassInfo newZClass = ZTypeManager.MakeGenericType((ZLClassInfo)mainZType, genericArgZType);
ExpTypeTwo twoExp = new ExpTypeTwo(this.ExpContext, TypeTokens[0], TypeTokens[1], genericArgZType, mainZType, newZClass);
return(twoExp.Analy());
}
return(noneType);
}
public override Exp Analy( )
{
if (this.IsAnalyed)
{
return(this);
}
var subjType = ListSymbol.GetZType();
ZLClassInfo zclass = subjType as ZLClassInfo;
Property = zclass.SharpType.GetProperty(ZLangUtil.ZListItemPropertyName);
RetType = ZTypeManager.GetBySharpType(Property.PropertyType) as ZType;
IsAnalyed = true;
return(this);
}
private void AddDimWord(ZDimType zdim, WordDictionary wordDictionary)
{
Dictionary <string, string> dims = zdim.Dims;
foreach (string dimName in dims.Keys)
{
string dimTypeName = dims[dimName];
IZDescType[] ztypes = ZTypeManager.GetByMarkName(dimTypeName);
if (ztypes.Length > 0)
{
ZType ztype = ztypes[0] as ZType;
WordInfo word = new WordInfo(dimName, WordKind.DimName, ztype);
wordDictionary.Add(word);
}
}
}
private void AnalyBase(ContextClass context)
{
SuperTable = null;
if (BaseTypeToken == null)
{
IsStatic = false;
BaseZType = ZTypeManager.ZOBJECT;
SuperTable = new SuperSymbolTable("SUPER-唯一", ZTypeManager.ZOBJECT);
}
else
{
BaseTypeName = BaseTypeToken.GetText();
if (BaseTypeName == "唯一")
{
IsStatic = true;
SuperTable = new SuperSymbolTable("SUPER-唯一", null);
}
else
{
IsStatic = false;
var ztypes = ZTypeManager.GetByMarkName(BaseTypeName);
if (ztypes.Length == 0)
{
errorf(BaseTypeToken.Position, "类型'{0}'不存在", BaseTypeName);
}
else if (ztypes.Length == 1)
{
BaseZType = ztypes[0] as ZClassType;
SuperTable = new SuperSymbolTable("SUPER-" + BaseZType.ZName, BaseZType);
}
else if (ztypes.Length == 0)
{
errorf(BaseTypeToken.Position, "'{0}'存在{1}个同名类型", BaseTypeName, ztypes.Length);
SuperTable = new SuperSymbolTable("SUPER", null);
}
}
}
if (SuperTable == null)
{
SuperTable = new SuperSymbolTable("SUPER-STATIC", null);
}
SuperTable.ParentTable = FileContext.UseContext.SymbolTable;
context.SetSuperTable(SuperTable);
context.BaseZType = BaseZType;
}
private Exp AnalyGeneric_2()
{
LexToken genericArgTypeToken1 = TypeTokens[0];
LexToken genericArgTypeToken2 = TypeTokens[1];
ZType genericArgZType1 = SearchZType(genericArgTypeToken1);
ZType genericArgZType2 = SearchZType(genericArgTypeToken2);
if (genericArgZType1 != null && genericArgZType2 != null)
{
//Type newType = MakeGenericType(mainZType, genericArgZType1, genericArgZType2);
//ZType newZtype = ZTypeManager.RegNewGenericType(newType);
//RetType = newZtype;
ZLClassInfo newZClass = ZTypeManager.MakeGenericType((ZLClassInfo)mainZType, genericArgZType1, genericArgZType2);
ExpTypeThree twoExp = new ExpTypeThree(this.ExpContext, TypeTokens[0], TypeTokens[1], TypeTokens[2], genericArgZType1, genericArgZType2, mainZType, newZClass);
return(twoExp.Analy());
}
return(noneType);
}
public override Exp Analy( )
{
if (LeftExp == null && RightExp != null)
{
ExpUnary unexp = new ExpUnary(OpToken, RightExp, this.ExpContext);
//unexp.SetContext(this.ExpContext);
var exp = unexp.Analy();
return(exp);
}
else if (LeftExp == null && RightExp == null)
{
ErrorE(this.OpToken.Position, "运算符'{0}'两边缺少表达式", OpToken.GetText());
//AnalyResult = false;
}
OpKind = OpToken.Kind;
LeftExp = AnalySubExp(LeftExp);
RightExp = AnalySubExp(RightExp);
if (RightExp == null)
{
ErrorE(OpToken.Position, "运算符'{0}'右边缺少运算元素", OpToken.GetText());
//AnalyResult = false;
}
else
{
if (LeftExp.AnalyCorrect && RightExp.AnalyCorrect)
{
ZType ltype = LeftExp.RetType;
ZType rtype = RightExp.RetType;
OpMethod = ExpBinaryUtil.GetCalcMethod(OpKind, ltype.SharpType, rtype.SharpType);
if (OpMethod != null)
{
RetType = ZTypeManager.GetBySharpType(OpMethod.ReturnType) as ZType;
}
else
{
ErrorE(OpToken.Position, "两种类型无法进行'{0}'运算", OpToken.ToCode());
}
}
}
return(this);
}
private ParseResult ParseNameBySegmenter(Token token, IWordDictionary collection)
{
//WordCollection nameManager = this.procContext.ClassContext.FileContext.GetNameDimWordManger();
WordSegmenter segmenter = new WordSegmenter(collection);
Token[] newTokens = segmenter.Split(token);
if (newTokens.Length == 2)
{
string argTypeName = newTokens[0].GetText();
var ArgType = ZTypeManager.GetByMarkName(argTypeName)[0] as ZType;
var result = new ParseResult()
{
TypeName = argTypeName, ZType = ArgType, VarName = newTokens[1].GetText()
};
return(result);
}
else
{
return(null);
}
}
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 void AnalyListExp()
//{
// ListExp = AnalyExpRaw();
// if (ListExp == null)
// {
// Errorf(ForeachToken.Position, "循环每一个语句没有表达式");
// }
// else
// {
// ListExp = ListExp.Analy();
// }
//}
//private Exp AnalyExpRaw()
//{
// ExpRaw rawExp = Raw.ListExp;// (Exp)ListExp;
// ContextExp context = new ContextExp(this.ProcContext, this);
// //rawExp.SetContext(context);
// List<LexToken> tokens = rawExp.Seg();
// ExpParser parser = new ExpParser();
// Exp exp = parser.Parse(tokens, this.ProcContext.ClassContext.FileContext);
// //exp.SetContext(rawExp.ExpContext);
// return exp;
//}
protected void CreateEachSymbols()
{
var procContext = this.ProcContext;
int foreachIndex = procContext.CreateRepeatIndex();
var indexName = "@foreach" + foreachIndex + "_index";
var countName = "@foreach" + foreachIndex + "_count";
var listName = "@foreach" + foreachIndex + "_list";
var itemName = this.Raw.ItemToken.Text;
indexSymbol = new ZCLocalVar(indexName, ZLangBasicTypes.ZINT, true);
//indexSymbol.LoacalVarIndex = procContext.CreateLocalVarIndex(indexName);
this.ProcContext.AddLocalVar(indexSymbol);
countSymbol = new ZCLocalVar(countName, ZLangBasicTypes.ZINT, true);
//countSymbol.LoacalVarIndex = procContext.CreateLocalVarIndex(countName);
this.ProcContext.AddLocalVar(countSymbol);
listSymbol = new ZCLocalVar(listName, this.ForeachListExp.RetType, true);
//listSymbol.LoacalVarIndex = procContext.CreateLocalVarIndex(listName);
this.ProcContext.AddLocalVar(listSymbol);
var listType = ZTypeUtil.GetTypeOrBuilder(this.ForeachListExp.RetType);
Type[] genericTypes = GenericUtil.GetInstanceGenriceType(listType, typeof(列表 <>));
if (genericTypes.Length == 0)
{
genericTypes = GenericUtil.GetInstanceGenriceType(listType, typeof(IList <>));
}
Type ElementType = genericTypes[0];
itemSymbol = new ZCLocalVar(itemName, (ZType)(ZTypeManager.GetBySharpType(ElementType)), true);
//itemSymbol.LoacalVarIndex = procContext.CreateLocalVarIndex(itemName);
this.ProcContext.AddLocalVar(itemSymbol);
}
protected void EmitArgsExp(IEnumerable <Exp> args, IEnumerable <ParameterInfo> paras)
{
var ztypes = paras.Select(p => (ZTypeManager.GetBySharpType(p.ParameterType) as ZType)).ToArray();
EmitArgsExp(args, ztypes);
}
