void AddTypes(string name_space, IParseModule module)
{
foreach (var type in module.Types)
{
AddTypes_Implements(name_space, type);
}
}
void RemoveTypes_Implements(string prefix, ITypeInfo type, IParseModule module)
{
//判断是否有重复类型定义
if (!Types.ContainsKey(type.FullName))
{
return;
}
if (Types[type.FullName].FileId == module.FileId)
{
Types.Remove(type.FullName);
//如果含有重复定义，则用重复定义类
if (this.RepeatTypes.ContainsKey(type.FullName))
{
var anotherType = this.RepeatTypes[type.FullName].FirstOrDefault(x => x.FileId != type.FileId);
if (anotherType != null)
{
Types.Add(anotherType.FullName, anotherType);
}
else
{
}
}
foreach (var t in type.TypeInfos)
{
RemoveTypes_Implements(type.FullName, t, module);
}
}
}
private void WiseModule(IParseModule module)
{
foreach (var type in module.Types)
{
Wise_Type(type, module);
}
}
public List <ITypeInfo> ParseType(string type, IParseModule ctx, out string error)
{
error = null;
if (string.IsNullOrWhiteSpace(type))
{
return(null);
}
// 泛型处理，目前仅支持List<T>
bool isGenericType = false;
if (type.Count(c => c == '<') > 1)
{
error = "目前泛型定义仅支持List<T>，且一重泛型";
return(null);
}
if (type.IndexOf("<") > 0)
{
if (!type.StartsWith("List<"))
{
error = "目前泛型定义仅支持List<T>，且一重泛型";
return(null);
}
else
{
isGenericType = true;
}
}
//获得GenericParameter
var genericParameter = type.Replace("List<", "").Replace(">", "");
var parameterTypes = ParseGenericType(genericParameter, ctx, out error);
if (!isGenericType)
{
return(parameterTypes);
}
var rslt = new List <ITypeInfo>(4);
parameterTypes.ForEach(x => rslt.Add(new TypeInfoBase()
{
CharPositionInLine = x.CharPositionInLine,
FullName = string.Format("List<{0}>", x.FullName),
GenericParameterType = x,
IsGenericType = true,
IsGenericTypeDefinition = true,
Line =
x.Line,
IsPrimitive = x.IsPrimitive,
Length = x.Length,
Name = type
}));
return(rslt);
}
void OnUpdateModule(Guid fileId, IParseModule module)
{
//模块内重复类型验证
module.Types.ForEach(x => {
if (module.Types.Where(y => x != y && y.Name.Equals(x.Name)).Count() > 0)
{
this.AddError(new ParseErrorInfo()
{
CharPositionInLine = x.TokenPair.BeginToken.CharPositionInLine,
ErrorType = ErrorType.Error,
File = module.File,
FileId = module.FileId,
Line = x.TokenPair.BeginToken.Line,
Message = string.Format("类型{0}在文件内重复", x.Name)
});
}
});
module.Types.ForEach(x => FillTypeInfo(fileId, x));
if (!ParsedModules.ContainsKey(fileId))
{
ParsedModules.Add(fileId, module);
}
else
{
ParsedModules[fileId] = module;
}
var name_space = GetNameSpace(module.NameSpace);
List <IParseModule> ms = null;
AddTypes(module.NameSpace, module);
if (!Namespace_Modules.ContainsKey(name_space))
{
ms = new List <IParseModule>();
ms.Add(module);
Namespace_Modules.Add(name_space, ms);
}
else
{
ms = Namespace_Modules[name_space];
if (ms.Where(x => x.FileId == module.FileId).Count() == 0)
{
ms.Add(module);
//AddTypes(module.NameSpace, module);
}
else
{
var old = ms.Find(x => x.FileId == module.FileId);
ms.Remove(old);
//RemoveTypes(old.NameSpace, old);
ms.Add(module);
//AddTypes(module.NameSpace, module);
}
}
}
void RemoveTypes(string name_space, IParseModule module)
{
RemoveRepeatType(module.FileId);
foreach (var type in module.Types)
{
RemoveTypes_Implements(name_space, type, module);
}
}
public void RegisterModule(IParseModule module) {
if (module == null) {
return;
}
lock (mutex) {
modules.Add(module);
module.OnModuleRegistered();
if (isParseInitialized) {
module.OnParseInitialized();
}
}
}
public void RegisterModule(IParseModule module)
{
if (module == null)
{
return;
}
lock (mutex) {
modules.Add(module);
module.OnModuleRegistered();
if (isParseInitialized)
{
module.OnParseInitialized();
}
}
}
public List <ITypeInfo> ParseGenericType(string type, IParseModule ctx, out string error)
{
error = null;
if (string.IsNullOrWhiteSpace(type))
{
return(null);
}
#region 基础类型
#endregion
var rslt = new List <ITypeInfo>(4);
if (string.IsNullOrWhiteSpace(type) || ctx == null)
{
return(rslt);
}
var list = new List <string>();
list.Add(type);
if (!string.IsNullOrWhiteSpace(ctx.NameSpace))
{
list.Add(ctx.NameSpace + "." + type);
}
if (ctx.UsingNameSpaces != null || ctx.UsingNameSpaces.Count == 0)
{
ctx.UsingNameSpaces.ForEach(x => list.Add(x + "." + type));
}
list.ForEach(x =>
{
if (Types.ContainsKey(x))
{
rslt.Add(Types[x]);
}
}
);
return(rslt);
}
public List<ITypeInfo> ParseGenericType(string type, IParseModule ctx, out string error)
{
error = null;
if (string.IsNullOrWhiteSpace(type))
{
return null;
}
#region 基础类型
#endregion
var rslt = new List<ITypeInfo>(4);
if (string.IsNullOrWhiteSpace(type) || ctx == null)
{
return rslt;
}
var list = new List<string>();
list.Add(type);
if (!string.IsNullOrWhiteSpace(ctx.NameSpace))
{
list.Add(ctx.NameSpace + "." + type);
}
if (ctx.UsingNameSpaces != null || ctx.UsingNameSpaces.Count == 0)
{
ctx.UsingNameSpaces.ForEach(x => list.Add(x + "." + type));
}
list.ForEach(x =>
{
if (Types.ContainsKey(x))
{
rslt.Add(Types[x]);
}
}
);
return rslt;
}
//public OnInvokeParse model_InvokeParse { get; set; }
public List <ITypeInfo> ParseType(string type, IParseModule ctx, out string error)
{
return(this.workEngine.ParseType(type, ctx, out error));
}
public void AddModule(IParseModule module)
{
modules.Add(module.FileId, module);
}
public void AddModule(IParseModule module)
{
modules.Add(module.FileId, module);
}
private void Wise_Type(ITypeInfo type, IParseModule module)
{
string error;
foreach (var p in type.PropertyInfos)
{
var types = ParseType(p.Type, module, out error);
if (!string.IsNullOrWhiteSpace(error))
{
AddError(new ParseErrorInfo()
{
FileId = module.FileId,
File = module.File,
CharPositionInLine = p.TokenPair.BeginToken.CharPositionInLine,
ErrorType = ErrorType.Error,
Line = p.TokenPair.BeginToken.Line,
Message = error
});
}
if (types == null || types.Count == 0)
{
AddError(new ParseErrorInfo()
{
FileId = module.FileId,
File = module.File,
CharPositionInLine = p.TokenPair.BeginToken.CharPositionInLine,
ErrorType = ErrorType.Error,
Line = p.TokenPair.BeginToken.Line,
Message = string.Format("当前上下文无此类型{0}", p.Type)
});
}
else if (types.Count > 1)
{
AddError(new ParseErrorInfo()
{
FileId = module.FileId,
File = module.File,
CharPositionInLine = p.TokenPair.BeginToken.CharPositionInLine,
ErrorType = ErrorType.Error,
Line = p.TokenPair.BeginToken.Line,
Message = string.Format("当前上下文有多个此类型{0}:{1}"
, p.Type
, String.Join(",", types.Select(x => x.FullName).ToArray()))
});
}
else
{
p.TypeInfo = types[0];
}
if (types == null)
return;
types.ForEach(x =>
{
if (x.FileId.HasValue)//说明不是.NET类型
{
var dependence_Fellow = GlobalService.DepencyManager.GetRelation(module.FileId);
if (dependence_Fellow == null)
{
dependence_Fellow = new ModuleRelationBase();
dependence_Fellow.ModuleId = module.FileId;
GlobalService.DepencyManager.AddRelation(dependence_Fellow);
}
IModuleRelation dependence = GlobalService.DepencyManager.GetRelation(x.FileId.Value);
if (dependence == null)
{
dependence = new ModuleRelationBase()
{
ModuleId = x.FileId.Value
};
GlobalService.DepencyManager.AddRelation(dependence);
}
if (!dependence.Follows.Contains(dependence_Fellow.ModuleId.Value))
{
if (dependence.ModuleId != dependence_Fellow.ModuleId)
{
dependence.Follows.Add(dependence_Fellow);
}
}
}
});
}
}
private void WiseModule(IParseModule module)
{
foreach (var type in module.Types)
{
Wise_Type(type, module);
}
}
void RemoveTypes_Implements(string prefix, ITypeInfo type, IParseModule module)
{
//判断是否有重复类型定义
if (!Types.ContainsKey(type.FullName))
{
return;
}
if (Types[type.FullName].FileId == module.FileId)
{
Types.Remove(type.FullName);
//如果含有重复定义，则用重复定义类
if (this.RepeatTypes.ContainsKey(type.FullName))
{
var anotherType = this.RepeatTypes[type.FullName].FirstOrDefault(x => x.FileId != type.FileId);
if (anotherType != null)
{
Types.Add(anotherType.FullName, anotherType);
}
else
{
}
}
foreach (var t in type.TypeInfos)
{
RemoveTypes_Implements(type.FullName, t, module);
}
}
}
void RemoveTypes(string name_space, IParseModule module)
{
RemoveRepeatType(module.FileId);
foreach (var type in module.Types)
{
RemoveTypes_Implements(name_space, type, module);
}
}
void OnUpdateModule(Guid fileId, IParseModule module)
{
//模块内重复类型验证
module.Types.ForEach(x => {
if (module.Types.Where(y => x != y && y.Name.Equals(x.Name)).Count() > 0)
{
this.AddError(new ParseErrorInfo()
{
CharPositionInLine = x.TokenPair.BeginToken.CharPositionInLine,
ErrorType = ErrorType.Error,
File = module.File,
FileId = module.FileId,
Line = x.TokenPair.BeginToken.Line,
Message = string.Format("类型{0}在文件内重复", x.Name)
});
}
});
module.Types.ForEach(x => FillTypeInfo(fileId, x));
if (!ParsedModules.ContainsKey(fileId))
{
ParsedModules.Add(fileId, module);
}
else
{
ParsedModules[fileId] = module;
}
var name_space = GetNameSpace(module.NameSpace);
List<IParseModule> ms = null;
AddTypes(module.NameSpace, module);
if (!Namespace_Modules.ContainsKey(name_space))
{
ms = new List<IParseModule>();
ms.Add(module);
Namespace_Modules.Add(name_space, ms);
}
else
{
ms = Namespace_Modules[name_space];
if (ms.Where(x => x.FileId == module.FileId).Count() == 0)
{
ms.Add(module);
//AddTypes(module.NameSpace, module);
}
else
{
var old = ms.Find(x => x.FileId == module.FileId);
ms.Remove(old);
//RemoveTypes(old.NameSpace, old);
ms.Add(module);
//AddTypes(module.NameSpace, module);
}
}
}
void AddTypes(string name_space, IParseModule module)
{
foreach (var type in module.Types)
{
AddTypes_Implements(name_space, type);
}
}
public List<ITypeInfo> ParseType(string type, IParseModule ctx, out string error)
{
error = null;
if (string.IsNullOrWhiteSpace(type))
{
return null;
}
// 泛型处理，目前仅支持List<T>
bool isGenericType = false;
if (type.Count(c => c == '<') > 1)
{
error = "目前泛型定义仅支持List<T>，且一重泛型";
return null;
}
if (type.IndexOf("<") > 0)
{
if (!type.StartsWith("List<"))
{
error = "目前泛型定义仅支持List<T>，且一重泛型";
return null;
}
else
{
isGenericType = true;
}
}
//获得GenericParameter
var genericParameter = type.Replace("List<", "").Replace(">", "");
var parameterTypes = ParseGenericType(genericParameter, ctx, out error);
if (!isGenericType)
{
return parameterTypes;
}
var rslt = new List<ITypeInfo>(4);
parameterTypes.ForEach(x => rslt.Add(new TypeInfoBase()
{
CharPositionInLine = x.CharPositionInLine,
FullName = string.Format("List<{0}>", x.FullName),
GenericParameterType = x,
IsGenericType = true,
IsGenericTypeDefinition = true,
Line =
x.Line,
IsPrimitive = x.IsPrimitive,
Length = x.Length,
Name = type
}));
return rslt;
}
//public OnInvokeParse model_InvokeParse { get; set; }
public List<ITypeInfo> ParseType(string type, IParseModule ctx, out string error)
{
return this.workEngine.ParseType(type, ctx, out error);
}
public void Parse(IModel model, InputCharInfo inputChar, System.Action callback)
{
var text = model.Content;
try
{
var parseInfo = new ParseInfo();
parseInfo.Content = text;
parseInfo.Index = 0;
parseInfo.Type = model.ParseType;
var parseInfo_json = Newtonsoft.Json.JsonConvert.SerializeObject(parseInfo);
string json = null;
if (!ConnectProxy.Instance().Send(parseInfo_json))
{
model.SetParsed(false);
return;
}
json = ConnectProxy.Instance().Read();
if (json == null)
{
model.SetParsed(false);
return;
}
IParseModule module = null;
try
{
if (model.ParseType == CodeHelper.Core.Parser.ParseType.XmlModel)
{
module = JsonConvert.DeserializeObject <XmModelDB>(json);
//XmModelDB.Current.InputChar = inputChar;
}
else if (model.ParseType == CodeHelper.Core.Parser.ParseType.DataModel)
{
module = JsonConvert.DeserializeObject <DmModelDB>(json);
//DmModelDB.Current.InputChar = inputChar;
}
else if (model.ParseType == Core.Parser.ParseType.DataView)
{
module = JsonConvert.DeserializeObject <DataViewDB>(json);
//DataViewDB.Current.InputChar = inputChar;
}
else if (model.ParseType == Core.Parser.ParseType.ViewModel)
{
module = JsonConvert.DeserializeObject <ViewModelDB>(json);
ViewModelDB.Current = module as ViewModelDB;
ViewModelDB.Current.InputChar = inputChar;
}
else if (model.ParseType == Core.Parser.ParseType.WorkFlow)
{
var program = JsonConvert.DeserializeObject <Program>(json);
module = new WorkflowDB();
((WorkflowDB)module).Program = program;
WorkflowDB.Current = module as WorkflowDB;
WorkflowDB.Current.InputChar = inputChar;
module.Name = System.IO.Path.GetFileNameWithoutExtension(model.File);
}
}
catch (Exception e)
{
this.Errors.Add(new Core.Error.ParseErrorInfo()
{
FileId = model.FileId,
File = model.File,
ErrorType = Core.Error.ErrorType.Error,
Message = "模块解析错误: " + e.Message
});
}
if (module == null)
{
model.SetParsed(false);
return;
}
module.File = model.File;
module.FileId = model.FileId;
module.Initialize();
module.Wise();
module.FileId = model.FileId;
model.SetParsed(true);
module.Errors.ForEach(x => { x.File = model.File; x.FileId = model.FileId; });
if (module.Errors != null)
{
module.Errors.ForEach(x => Errors.Add(x));
}
}
catch (Exception e)
{
this.Errors.Add(new Core.Error.ParseErrorInfo()
{
FileId = model.FileId,
File = model.File,
ErrorType = Core.Error.ErrorType.Error,
Message = "模块解析错误: " + e.Message
});
Console.Out.WriteLine(e.StackTrace);
}
finally
{
if (callback != null)
{
callback();
}
}
}
private void Wise_Type(ITypeInfo type, IParseModule module)
{
string error;
foreach (var p in type.PropertyInfos)
{
var types = ParseType(p.Type, module, out error);
if (!string.IsNullOrWhiteSpace(error))
{
AddError(new ParseErrorInfo()
{
FileId = module.FileId,
File = module.File,
CharPositionInLine = p.TokenPair.BeginToken.CharPositionInLine,
ErrorType = ErrorType.Error,
Line = p.TokenPair.BeginToken.Line,
Message = error
});
}
if (types == null || types.Count == 0)
{
AddError(new ParseErrorInfo()
{
FileId = module.FileId,
File = module.File,
CharPositionInLine = p.TokenPair.BeginToken.CharPositionInLine,
ErrorType = ErrorType.Error,
Line = p.TokenPair.BeginToken.Line,
Message = string.Format("当前上下文无此类型{0}", p.Type)
});
}
else if (types.Count > 1)
{
AddError(new ParseErrorInfo()
{
FileId = module.FileId,
File = module.File,
CharPositionInLine = p.TokenPair.BeginToken.CharPositionInLine,
ErrorType = ErrorType.Error,
Line = p.TokenPair.BeginToken.Line,
Message = string.Format("当前上下文有多个此类型{0}:{1}"
, p.Type
, String.Join(",", types.Select(x => x.FullName).ToArray()))
});
}
else
{
p.TypeInfo = types[0];
}
if (types == null)
{
return;
}
types.ForEach(x =>
{
if (x.FileId.HasValue)//说明不是.NET类型
{
var dependence_Fellow = GlobalService.DepencyManager.GetRelation(module.FileId);
if (dependence_Fellow == null)
{
dependence_Fellow = new ModuleRelationBase();
dependence_Fellow.ModuleId = module.FileId;
GlobalService.DepencyManager.AddRelation(dependence_Fellow);
}
IModuleRelation dependence = GlobalService.DepencyManager.GetRelation(x.FileId.Value);
if (dependence == null)
{
dependence = new ModuleRelationBase()
{
ModuleId = x.FileId.Value
};
GlobalService.DepencyManager.AddRelation(dependence);
}
if (!dependence.Follows.Contains(dependence_Fellow.ModuleId.Value))
{
if (dependence.ModuleId != dependence_Fellow.ModuleId)
{
dependence.Follows.Add(dependence_Fellow);
}
}
}
});
}
}
void Parse(IModel model, int charIndex, System.Action callback)
{
var text = model.Content;
ThreadPool.QueueUserWorkItem(o =>
{
try
{
var parseInfo = new ParseInfo();
parseInfo.Content = text;
parseInfo.Index = charIndex;
parseInfo.Type = model.ParseType;
var parseInfo_json = Newtonsoft.Json.JsonConvert.SerializeObject(parseInfo);
string json = null;
lock (this.syncObj)
{
if (!ConnectProxy.Instance().Send(parseInfo_json))
{
model.SetParsed(false);
return;
}
json = ConnectProxy.Instance().Read();
}
if (json == null)
{
model.SetParsed(false);
return;
}
IParseModule module = null;
try
{
if (model.ParseType == CodeHelper.Core.Parser.ParseType.XmlModel)
{
module = JsonConvert.DeserializeObject <XmModelDB>(json);
}
else if (model.ParseType == CodeHelper.Core.Parser.ParseType.DataModel)
{
var program = JsonConvert.DeserializeObject <DbProgram>(json);
module = new DmModelDB();
((DmModelDB)module).Program = program;
module.Name = System.IO.Path.GetFileNameWithoutExtension(model.File);
}
else if (model.ParseType == Core.Parser.ParseType.DataView)
{
module = JsonConvert.DeserializeObject <DataViewDB>(json);
}
else if (model.ParseType == Core.Parser.ParseType.ViewModel)
{
module = JsonConvert.DeserializeObject <ViewModelDB>(json);
ViewModelDB.Current = module as ViewModelDB;
}
else if (model.ParseType == Core.Parser.ParseType.WorkFlow)
{
var program = JsonConvert.DeserializeObject <Program>(json);
module = new WorkflowDB();
((WorkflowDB)module).Program = program;
WorkflowDB.Current = module as WorkflowDB;
module.Name = System.IO.Path.GetFileNameWithoutExtension(model.File);
}
}
catch (Exception e)
{
this.AddError(new Core.Error.ParseErrorInfo()
{
FileId = model.FileId,
File = model.File,
ErrorType = Core.Error.ErrorType.Error,
Message = "模块解析错误: " + e.Message
});
}
if (module == null)
{
//this.IsWiseCompleted = true;
model.SetParsed(false);
OnRemoveModule(model.FileId);
return;
}
module.Initialize();
module.FileId = model.FileId;
model.SetParsed(true);
module.Errors.ForEach(x => { x.File = model.File; x.FileId = model.FileId; });
//OnUpdateModule(model.FileId, module);
this.waitingWiseModules.Add(module);
if (module.Errors != null)
{
module.Errors.ForEach(x => AddError(x));
}
}
catch (Exception e)
{
this.AddError(new Core.Error.ParseErrorInfo()
{
FileId = model.FileId,
File = model.File,
ErrorType = Core.Error.ErrorType.Error,
Message = "模块解析错误: " + e.Message
});
Console.Out.WriteLine(e.StackTrace);
}
finally
{
if (callback != null)
{
callback();
}
this.waitingParseModels.Take();
if (this.waitingParseModels.Count == 0)
{
parseEvent.Set();
}
else
{
}
}
});
}
