public LexClass Clone()
{
LexClass copy = MemberwiseClone() as LexClass;
copy.functions = new List <LexFunction>();
foreach (var fnc in functions)
{
var cloned = fnc.Clone();
cloned.ownSection = copy;
copy.functions.Add(cloned);
}
copy.variables = new List <LexVariable>();
foreach (var vr in variables)
{
var cloned = vr.Clone();
vr.ownSection = copy;
copy.variables.Add(vr);
}
copy.classes = new List <LexClass>();
copy.childSections = new List <LexSection>();
foreach (var cls in classes)
{
var cloned = cls.Clone();
copy.classes.Add(cloned);
copy.childSections.Add(cloned);
cloned.parentLexSection = copy;
}
return(copy);
}
string GetBaseClassSetting(LexClass lexClass, List <LexClass> processed)
{
if (!reflectableClasses.Contains(lexClass))
{
return("");
}
if (processed.Contains(lexClass))
{
return("");
}
processed.Add(lexClass);
string res = "";
foreach (var cls in lexClass.baseClasses)
{
if (cls.lexClass == null || cls.lexClass == iobjectClass || !cls.lexClass.IsBasedOn(iobjectClass))
{
continue;
}
res += GetBaseClassSetting(cls.lexClass, processed);
res += "\tTypeInitializer::AddBaseType(&" + lexClass.name + "::type, &" + cls.lexClass.name + "::type);\n";
}
return(res);
}
void SpecializeClassName(LexClass cls, string specialize, string tempClassName, List <LexClass> newClasses, List <LexClass> allClasses)
{
cls.isTemplate = false;
int pos = cls.name.IndexOf(tempClassName);
if (pos >= 0)
{
pos += tempClassName.Length;
cls.name = cls.name.Insert(pos, "<" + specialize + ">");
}
string[] templates = new string[0];
if (cls.templates != null)
{
templates = cls.templates.Split(',');
}
for (int i = 0; i < templates.Count(); i++)
{
int x = templates[i].IndexOf("typename");
if (x >= 0)
{
templates[i] = templates[i].Remove(x, "typename".Length).Trim(' ');
}
}
for (int i = 0; i < cls.functions.Count(); i++)
{
var func = cls.functions[i];
if (func.returnType.definition != null)
{
foreach (var templ in templates)
{
func.returnType.definition = func.returnType.definition.Replace(templ, specialize);
}
}
foreach (var param in func.parameters)
{
foreach (var templ in templates)
{
param.type.definition = param.type.definition.Replace(templ, specialize);
}
}
}
var fnd = allClasses.Find(x => x.name == cls.name);
if (fnd != null)
{
fnd.isTemplate = false;
}
else
{
newClasses.Add(cls);
}
cls.classes.ForEach(x => SpecializeClassName(x, specialize, tempClassName, newClasses, allClasses));
}
void SearchSpecializations(List <string> specializations, SourceFile src, LexClass cls)
{
int caret = 0;
while (caret < src.data.Length)
{
caret = src.data.IndexOf(cls.shortName, caret);
if (caret < 0)
{
break;
}
caret += cls.shortName.Length;
string spec = ReadWord(src.data, ref caret).Trim(' ', '\n', '\t', '\r');
if (spec.Length > 0 && spec[0] == '<' && spec[spec.Length - 1] == '>')
{
string sspec = spec.Substring(1, spec.Length - 2).Trim(' ', '\n', '\t', '\r');
if (!specializations.Contains(sspec) && !cls.templates.Contains(sspec))
{
specializations.Add(sspec);
}
}
}
}
public void Generate(string outputPath, string directoriesCut, SrcMap map)
{
this.directoriesCut = directoriesCut;
iobjectClass = map.allClasses.Find(x => x.name == "::IObject");
reflectableClasses = map.allClasses.FindAll(x =>
{
return(x.IsBasedOn(iobjectClass) && !x.isTemplate && !x.isTypedef);
}).ToList();
GenerateHeader(outputPath);
GenerateSource(outputPath);
}
void RenameClass(LexClass cls, string oldName, string newName)
{
cls.isTypedef = true;
int pos = cls.name.IndexOf(oldName);
if (pos >= 0)
{
cls.name = cls.name.Remove(pos, oldName.Length).Insert(pos, newName);
}
cls.classes.ForEach(x => RenameClass(x, oldName, newName));
}
public void Generate(string outputPath, string directoriesCut, SrcMap map)
{
this.directoriesCut = directoriesCut;
iobjectClass = map.allClasses.Find(x => x.name == "::IObject");
reflectableClasses = map.allClasses.FindAll(x =>
{
return x.IsBasedOn(iobjectClass) && !x.isTemplate && !x.isTypedef;
}).ToList();
GenerateHeader(outputPath);
GenerateSource(outputPath);
}
public bool IsBasedOn(LexClass baseClass)
{
foreach (var bs in baseClasses)
{
if (bs.lexClass == baseClass)
{
return(true);
}
if (bs.lexClass != null && bs.lexClass.IsBasedOn(baseClass))
{
return(true);
}
}
return(false);
}
void ProcessTypedefs(LexSection section)
{
foreach (var tpd in section.typedefs)
{
LexClass defClass = section.FindLexSection(tpd.value) as LexClass;
if (defClass == null)
{
continue;
}
LexClass newClass = defClass.Clone();
string oldName = newClass.shortName;
newClass.shortName = tpd.name;
RenameClass(newClass, newClass.name, section.name + "::" + newClass.shortName);
section.classes.Add(newClass);
section.childSections.Add(newClass);
}
section.childSections.ForEach(x => ProcessTypedefs(x));
}
void SpecializeTemplates(SrcMap srcMap)
{
List <LexClass> newClasses = new List <LexClass>();
foreach (var cls in srcMap.allClasses)
{
if (!cls.isTemplate)
{
continue;
}
if (cls.shortName[cls.shortName.Length - 1] == '>')
{
continue;
}
List <string> specializations = new List <string>();
foreach (var src in srcMap.headers)
{
SearchSpecializations(specializations, src, cls);
}
/*foreach (var src in srcMap.sources)
* SearchSpecializations(specializations, src, cls);*/
//Console.Write("Found " + specializations.Count() + " specializations for " + cls.name + "\n");
foreach (var spec in specializations)
{
LexClass newClass = cls.Clone();
newClass.shortName += "<" + spec + ">";
newClass.isTemplate = false;
SpecializeClassName(newClass, spec, cls.shortName, newClasses, srcMap.allClasses);
cls.parentLexSection.classes.Add(newClass);
cls.parentLexSection.childSections.Add(newClass);
}
}
newClasses.ForEach(x => srcMap.allClasses.Add(x));
}
string GetBaseClassSetting(LexClass lexClass, List<LexClass> processed)
{
if (!reflectableClasses.Contains(lexClass))
return "";
if (processed.Contains(lexClass))
return "";
processed.Add(lexClass);
string res = "";
foreach (var cls in lexClass.baseClasses)
{
if (cls.lexClass == null || cls.lexClass == iobjectClass || !cls.lexClass.IsBasedOn(iobjectClass))
continue;
res += GetBaseClassSetting(cls.lexClass, processed);
res += "\tTypeInitializer::AddBaseType(&" + lexClass.name + "::type, &" + cls.lexClass.name + "::type);\n";
}
return res;
}
static void PrintClass(LexClass cls, string indent)
{
Console.Write(indent + "-----------------\n" + indent + "//" + (cls.comment != null ? cls.comment.comment : "") + "\n" + indent + "class: " + cls.name + ":");
cls.baseClasses.ForEach(x => Console.Write(x.type + " " + x.className + ", "));
Console.Write("\n" + indent + "{\n");
// Console.Write(indent + " Classes: \n");
// cls.classes.ForEach(x => PrintClass(x, indent + " "));
Console.Write("\n" + indent + " Variables: \n");
cls.variables.ForEach(x => Console.Write(indent + " //" + (x.comment != null ? x.comment.comment:"") + "\n" + indent + " " + x.protectLevel + " " + x.type.definition + " " + x.name + "\n"));
Console.Write("\n" + indent + " Functions: \n");
cls.functions.ForEach(x =>
{
Console.Write(indent + " //" + (x.comment != null ? x.comment.comment : "") + "\n" + indent + " " + x.protectLevel + " " + x.returnType.definition + " " + x.name + "(");
x.parameters.ForEach(y => Console.Write(y.type.definition + " " + y.name + ", "));
Console.Write(")\n");
});
Console.Write(indent + "}\n");
}
static void PrintClass(LexClass cls, string indent)
{
Console.Write(indent + "-----------------\n" + indent + "//" + (cls.comment !=null ? cls.comment.comment : "") + "\n" + indent + "class: " + cls.name + ":");
cls.baseClasses.ForEach(x => Console.Write(x.type + " " + x.className + ", "));
Console.Write("\n" + indent + "{\n");
// Console.Write(indent + " Classes: \n");
// cls.classes.ForEach(x => PrintClass(x, indent + " "));
Console.Write("\n" + indent + " Variables: \n");
cls.variables.ForEach(x => Console.Write(indent + " //" + (x.comment !=null ? x.comment.comment:"") + "\n" + indent + " " + x.protectLevel + " " + x.type.definition + " " + x.name + "\n"));
Console.Write("\n" + indent + " Functions: \n");
cls.functions.ForEach(x =>
{
Console.Write(indent + " //" + (x.comment !=null ? x.comment.comment : "") + "\n" + indent + " " + x.protectLevel + " " + x.returnType.definition + " " + x.name + "(");
x.parameters.ForEach(y => Console.Write(y.type.definition + " " + y.name + ", "));
Console.Write(")\n");
});
Console.Write(indent + "}\n");
}
void ParseClassOrStruct(LexSection section, ref int caret, ref ProtectLevel protectionLevel, bool isstruct)
{
int begin = caret;
if (isstruct) caret += "struct".Length;
else caret += "class".Length;
string className = ReadWord(section.data, ref caret, " \n\t\r:;/");
string afterName = ReadWord(section.data, ref caret, ";{/").Trim(' ', ':', '\r', '\n', '\t');
string shortClassName = className;
if (section.GetType() == typeof(LexClass))
className = (section as LexClass).name + "::" + className;
else
className = (section as LexNamespace).name + "::" + className;
LexClass newClass = new LexClass()
{
begin = begin,
end = caret,
data = section.data.Substring(begin, caret - begin),
name = className,
shortName = shortClassName,
source = source,
parentLexSection = section,
protectLevel = protectionLevel,
haveBody = false,
isTemplate = isNextLexTemplate
};
if (isNextLexTemplate)
newClass.templates = templatesBuffer;
isNextLexTemplate = false;
if (afterName.Length > 0)
{
var baseClasses = Split(afterName, ',');
foreach (var baseClass in baseClasses)
{
string trimmedBaseClass = baseClass.Trim();
int spacePos = trimmedBaseClass.IndexOf(' ');
if (spacePos < 0)
{
newClass.baseClasses.Add(new LexClass.BaseClassDef()
{
type = ProtectLevel.Private,
className = trimmedBaseClass
});
}
else
{
string sectionTypeName = trimmedBaseClass.Substring(0, spacePos);
string baseClassName = trimmedBaseClass.Substring(spacePos + 1);
if (baseClassName.StartsWith("virtual"))
baseClassName = baseClassName.Substring("virtual".Length + 1);
ProtectLevel sectionType = ProtectLevel.Private;
if (sectionTypeName == "public")
sectionType = ProtectLevel.Public;
else if (sectionTypeName == "protected")
sectionType = ProtectLevel.Protected;
newClass.baseClasses.Add(new LexClass.BaseClassDef()
{
type = sectionType,
className = baseClassName
});
}
}
}
if (caret < section.data.Length && section.data[caret] == '/')
{
string comment = ReadWord(section.data, ref caret, "\n");
ReadWord(section.data, ref caret, ";{/");
newClass.comment = new LexComment() { comment = comment };
}
if (caret < section.data.Length && section.data[caret] == '{')
{
int sectionBegin = caret;
newClass.data = ReadBlock(section.data, ref caret).Trim('{', '}', ' ', '\n', '\r', '\t');
newClass.haveBody = true;
section.classes.Add(newClass);
section.childSections.Add(newClass);
ParseLexSection(newClass, isstruct ? ProtectLevel.Public : ProtectLevel.Private);
}
}
void SpecializeClassName(LexClass cls, string specialize, string tempClassName, List<LexClass> newClasses, List<LexClass> allClasses)
{
cls.isTemplate = false;
int pos = cls.name.IndexOf(tempClassName);
if (pos >= 0)
{
pos += tempClassName.Length;
cls.name = cls.name.Insert(pos, "<" + specialize + ">");
}
string[] templates = new string[0];
if (cls.templates != null)
templates = cls.templates.Split(',');
for (int i = 0; i < templates.Count(); i++)
{
int x = templates[i].IndexOf("typename");
if (x >= 0)
templates[i] = templates[i].Remove(x, "typename".Length).Trim(' ');
}
for (int i = 0; i < cls.functions.Count(); i++)
{
var func = cls.functions[i];
if (func.returnType.definition != null)
{
foreach (var templ in templates)
func.returnType.definition = func.returnType.definition.Replace(templ, specialize);
}
foreach (var param in func.parameters)
{
foreach (var templ in templates)
param.type.definition = param.type.definition.Replace(templ, specialize);
}
}
var fnd = allClasses.Find(x => x.name == cls.name);
if (fnd != null)
fnd.isTemplate = false;
else
newClasses.Add(cls);
cls.classes.ForEach(x => SpecializeClassName(x, specialize, tempClassName, newClasses, allClasses));
}
void SearchSpecializations(List<string> specializations, SourceFile src, LexClass cls)
{
int caret = 0;
while (caret < src.data.Length)
{
caret = src.data.IndexOf(cls.shortName, caret);
if (caret < 0)
break;
caret += cls.shortName.Length;
string spec = ReadWord(src.data, ref caret).Trim(' ', '\n', '\t', '\r');
if (spec.Length > 0 && spec[0] == '<' && spec[spec.Length - 1] == '>')
{
string sspec = spec.Substring(1, spec.Length - 2).Trim(' ', '\n', '\t', '\r');
if (!specializations.Contains(sspec) && !cls.templates.Contains(sspec))
specializations.Add(sspec);
}
}
}
void RenameClass(LexClass cls, string oldName, string newName)
{
cls.isTypedef = true;
int pos = cls.name.IndexOf(oldName);
if (pos >= 0)
cls.name = cls.name.Remove(pos, oldName.Length).Insert(pos, newName);
cls.classes.ForEach(x => RenameClass(x, oldName, newName));
}
public bool IsBasedOn(LexClass baseClass)
{
foreach (var bs in baseClasses)
{
if (bs.lexClass == baseClass)
return true;
if (bs.lexClass != null && bs.lexClass.IsBasedOn(baseClass))
return true;
}
return false;
}
void ParseClassOrStruct(LexSection section, ref int caret, ref ProtectLevel protectionLevel, bool isstruct)
{
int begin = caret;
if (isstruct)
{
caret += "struct".Length;
}
else
{
caret += "class".Length;
}
string className = ReadWord(section.data, ref caret, " \n\t\r:;/");
string afterName = ReadWord(section.data, ref caret, ";{/").Trim(' ', ':', '\r', '\n', '\t');
string shortClassName = className;
if (section.GetType() == typeof(LexClass))
{
className = (section as LexClass).name + "::" + className;
}
else
{
className = (section as LexNamespace).name + "::" + className;
}
LexClass newClass = new LexClass()
{
begin = begin,
end = caret,
data = section.data.Substring(begin, caret - begin),
name = className,
shortName = shortClassName,
source = source,
parentLexSection = section,
protectLevel = protectionLevel,
haveBody = false,
isTemplate = isNextLexTemplate
};
if (isNextLexTemplate)
{
newClass.templates = templatesBuffer;
}
isNextLexTemplate = false;
if (afterName.Length > 0)
{
var baseClasses = Split(afterName, ',');
foreach (var baseClass in baseClasses)
{
string trimmedBaseClass = baseClass.Trim();
int spacePos = trimmedBaseClass.IndexOf(' ');
if (spacePos < 0)
{
newClass.baseClasses.Add(new LexClass.BaseClassDef()
{
type = ProtectLevel.Private,
className = trimmedBaseClass
});
}
else
{
string sectionTypeName = trimmedBaseClass.Substring(0, spacePos);
string baseClassName = trimmedBaseClass.Substring(spacePos + 1);
if (baseClassName.StartsWith("virtual"))
{
baseClassName = baseClassName.Substring("virtual".Length + 1);
}
ProtectLevel sectionType = ProtectLevel.Private;
if (sectionTypeName == "public")
{
sectionType = ProtectLevel.Public;
}
else if (sectionTypeName == "protected")
{
sectionType = ProtectLevel.Protected;
}
newClass.baseClasses.Add(new LexClass.BaseClassDef()
{
type = sectionType,
className = baseClassName
});
}
}
}
if (caret < section.data.Length && section.data[caret] == '/')
{
string comment = ReadWord(section.data, ref caret, "\n");
ReadWord(section.data, ref caret, ";{/");
newClass.comment = new LexComment()
{
comment = comment
};
}
if (caret < section.data.Length && section.data[caret] == '{')
{
int sectionBegin = caret;
newClass.data = ReadBlock(section.data, ref caret).Trim('{', '}', ' ', '\n', '\r', '\t');
newClass.haveBody = true;
section.classes.Add(newClass);
section.childSections.Add(newClass);
ParseLexSection(newClass, isstruct ? ProtectLevel.Public : ProtectLevel.Private);
}
}
