public override void Generate()
{
string ns = Larvae.GetElement(ElementType.Namespace);
AddDeclarationText(Larvae.GetElement(ElementType.IncludeDeclarationTop));
foreach (string importName in Larvae.Imports)
{
string n = Program.RemoveExtension(importName);
AddDeclarationText(Larvae.GetElement(ElementType.ImportInclude));
}
AddDeclarationText(Larvae.GetElement(ElementType.UserIncludeDeclarationTop));
if (ns != null)
{
AddDeclarationText("namespace " + ns + Environment.NewLine + "{");
}
WriteLarvae(Larvae.Items);
if (ns != null)
{
AddDeclarationText(Environment.NewLine + "}");
}
SaveToFile();
}
public void WriteLarvae(Dictionary <string, Larva> items)
{
string ns = Larvae.GetElement(ElementType.Namespace);
foreach (KeyValuePair <string, Larva> pair in items)
{
Larva l = pair.Value;
if (l.Mode == LarvaMode.Skip || l.Declaration.Count == 0)
{
continue;
}
SetOutputFile(l.Name);
if (ns != null)
{
AddDeclarationText("package " + ns + ";");
}
AddDeclarationText(Larvae.GetElement(ElementType.IncludeDeclarationTop));
AddDeclarationText(Larvae.GetElement(ElementType.UserIncludeDeclarationTop));
// output declaration
foreach (string d in l.Declaration)
{
AddDeclarationText(d);
}
SaveToFile();
}
}
public string GetDeclaration(Larva larva)
{
string m = larva.Type == LarvaType.Struct ? Larvae.GetElement(ElementType.MethodDeclaration) : Larvae.GetElement(ElementType.StaticMethodDeclaration);
// check does this method need to be virtual
// check does base class contain the same method
bool fromBase = false;
Larva b = Larvae.GetLarva(larva.BaseName, true);
while (b != null)
{
if (b.Methods.Contains(Name))
{
fromBase = true;
}
b = Larvae.GetLarva(b.BaseName, true);
}
bool toChild = false;
foreach (KeyValuePair <string, Larva> p in Larvae.Items)
{
if (p.Value.BaseName == larva.Name && p.Value.Methods.Contains(Name))
{
toChild = true;
break;
}
}
m = Generator.Current.GetVirtualModificator(fromBase, toChild) + m;
m = Variables.ReplaceAll(m, larva).Replace("%larva%", larva.Name).Replace("%method%", Name);
return(m);
}
public bool Parse()
{
while (true)
{
ElementType t = Next();
switch (t)
{
case ElementType.Enum:
case ElementType.Struct:
//Larva l = GetElement() as Larva;
//Larvae.Items[l.Name] = l;
break;
case ElementType.EOF:
return(true);
case ElementType.None:
Log.Error(GetElement().ToString(), Error.UnknownToken, "Unknown input");
return(false);
case ElementType.Error:
return(false);
case ElementType.Import:
break;
case ElementType.Namespace:
Larvae.SetElement(t, GetElement() as string);
break;
default:
break;
}
}
}
public override void Generate()
{
string[] namespaces = Larvae.GetElement(ElementType.Namespace).Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
AddDeclarationText(Larvae.GetElement(ElementType.IncludeDeclarationTop));
foreach (string importName in Larvae.Imports)
{
string n = Program.RemoveExtension(importName);
AddDeclarationText(Larvae.GetElement(ElementType.ImportInclude).Replace("%name%", n));
}
AddDeclarationText(Larvae.GetElement(ElementType.UserIncludeDeclarationTop));
AddDefinitionText(Larvae.GetElement(ElementType.IncludeDefinitionTop));
foreach (string ns in namespaces)
{
AddDeclarationText("namespace " + ns + Environment.NewLine + "{");
AddDefinitionText("namespace " + ns + Environment.NewLine + "{");
}
WriteLarvae(Larvae.Items);
foreach (string ns in namespaces)
{
AddDeclarationText(Environment.NewLine + "}");
AddDefinitionText(Environment.NewLine + "}");
}
SaveToFile();
}
public string GetEnumFieldDefinition()
{
string d = InitialValue == null?
Larvae.GetElement(ElementType.EnumFieldDeclaration) :
Larvae.GetElement(ElementType.EnumFieldWithValueDeclaration);
return(TextHelper.ReplaceExpressions(ref d, this));
}
public string GetDefinition(Larva larva)
{
string m = larva.Type == LarvaType.Struct ? Larvae.GetElement(ElementType.MethodDefinition) : Larvae.GetElement(ElementType.StaticMethodDefinition);
m = Variables.ReplaceAll(m, larva).Replace("%larva%", larva.Name).Replace("%method%", Name);
return(m);
}
public static string ReplaceExpressions(ref string text, object obj)
{
if (obj != null)
{
while (true)
{
// check for owner expression
Match match = Regex.Match(text, @"%![^%]+%", RegexOptions.IgnoreCase);
// Here we check the Match instance.
if (match.Success)
{
string v = match.Captures[0].Value;
string n = v.Substring(2, v.Length - 3);
string r = ObjectHelper.GetValue(obj, n);
if (r == null)
{
Log.Error(n, Error.WrongFormat, "Can't parse expression");
}
text = text.Replace(v, r);
}
else
{
break;
}
}
}
while (true)
{
// check for variable expression
Match match = Regex.Match(text, @"%@[^%]+%", RegexOptions.IgnoreCase);
// Here we check the Match instance.
if (match.Success)
{
string v = match.Captures[0].Value;
string n = v.Substring(2, v.Length - 3);
ElementType t = Parser.ConvertToElementType(n);
n = Larvae.GetElement(t);
text = text.Replace(v, n);
}
else
{
break;
}
}
return(text);
}
public string GetConstructorDeclaration()
{
string d = BaseName == null?
Larvae.GetElement(ElementType.ConstructorDeclaration) :
Larvae.GetElement(ElementType.ConstructorWithBaseDeclaration);
TextHelper.ReplaceExpressions(ref d, this);
string body = GetConstructorBody();
TextHelper.ReplaceField(ref d, "%body%", body);
return(d);
}
public Larva GetLarva()
{
Larva l;
string type = GetNextToken();
TypeInfo td = TypeFactory.Get(type, true);
if (td == null)
{
if (!type.Contains('.'))
{
type = Larvae.GetFullName(type);
}
l = Larvae.GetLarva(type, true);
if (l == null)
{
Console.WriteLine("Error! Type '" + type + "' not found");
return(null);
}
return(l);
}
else
{
string fullType = type;
List <Larva> subLarvae = null;
if (td.Length > 1)
{
subLarvae = new List <Larva>();
for (int i = 1; i < td.Length; i++)
{
Larva sl = GetLarva();
fullType += "." + sl.FullName;
subLarvae.Add(sl);
}
}
l = Larvae.GetLarva(fullType);
l.Type = LarvaType.Custom;
l.TypeInfo = td;
l.SubLarvae = subLarvae;
}
return(l);
}
public string GetVariable(string name)
{
PartVariable pv = variables.Find(x => x.Name == name);
if (pv == null)
{
pv = new PartVariable()
{
Name = name
};
pv.Value = name.Substring(2, name.Length - 3) + "_" + Larvae.GetId();
variables.Add(pv);
}
return(pv.Value);
}
public string GetStaticFieldDefinition()
{
string d = null;
if (InitialValue == null)
{
d = Larvae.GetElement(ElementType.StaticFieldDefinition);
}
else
{
d = Larvae.GetElement(ElementType.StaticFieldDefinitionWithValue);
if (d == "")
{
d = Larvae.GetElement(ElementType.StaticFieldDefinition);
}
}
return(TextHelper.ReplaceExpressions(ref d, this));
}
public static string Process(string command)
{
string[] p = command.Split(new char[] { '#' }, StringSplitOptions.RemoveEmptyEntries);
string[] v = p[0].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (v[0] == "method")
{
if (v.Length < 3)
{
return("");
}
VariableList vl = MethodFactory.GetMethod(v[1]).Variables;
//Variable variable = vl.GetVariable(v[2]);
for (int i = 2; i < v.Length; i++)
{
Variable nv = vl.GetVariable(v[i], true);
if (nv == null)
{
return("");
}
vl = nv.Variables;
}
Larva l = Larvae.GetLarva(p[2], true);
if (l == null)
{
return("<error:larva not found with name " + p[2] + ">");
}
Part part = new Part(null);
part.Name = p[1];
part.Larva = l;
string value = vl.ReplacePart(part);
return(value);
}
return("");
}
static void Main(string[] args)
{
string a = AppDomain.CurrentDomain.FriendlyName;
if (args.Length == 0)
{
Console.WriteLine("Usage: " + a + " metafile [-op output_path_prefix] -ol language" + Environment.NewLine + "example: " + a + @" data.met -op Generated -ol C#");
return;
}
string fileName = args[0];
string path = @"Generated";
for (int i = 1; i < args.Length; i++)
{
string next = (i + 1) < args.Length ? args[i + 1] : "";
switch (args[i])
{
case "-op":
path = next;
i++;
break;
case "-ol":
Larvae.SetElement(ElementType.OutputLanguage, next);
i++;
break;
case "-df":
Larvae.SetElement(ElementType.DefinitionFile, next);
i++;
break;
case "-id":
Directory.SetCurrentDirectory(next);
i++;
break;
case "-on":
Larvae.SetElement(ElementType.OutputName, next);
i++;
break;
}
}
if (Larvae.GetElement(ElementType.OutputLanguage) == "")
{
Console.WriteLine("Error: output language is not set. Use -ol to set it. Example: -ol C++");
return;
}
if (Larvae.GetElement(ElementType.OutputName) == "")
{
Console.WriteLine("Error: output name is not set. Use -ol to set it. Example: -on generated_from_meta");
return;
}
string name = Larvae.GetElement(ElementType.OutputName);
Larvae.ParseLanguageDefinition();
Generator.SetGenerator(Larvae.GetElement(ElementType.OutputLanguage));
Directory.CreateDirectory(path);
Generator.Current.SetOutputPath(path);
path = Path.Combine(path, name);
Generator.Current.SetOutputFile(path);
Larvae.SetElement(ElementType.OutputName, name);
string larvaeDefinition = ReadAllText(fileName);
Larvae.ParseMetaDefinition(larvaeDefinition);
Larvae.Generate(path);
}
public string GetFieldInitialisation()
{
string d = Larvae.GetElement(ElementType.FieldInitialisation);
return(TextHelper.ReplaceExpressions(ref d, this));
}
public ElementType Next()
{
element = null;
string token = GetNextToken();
if (token == null)
{
return(ElementType.EOF);
}
// check is it global variable
ElementType et = ConvertToElementType(token);
if (et != ElementType.None)
{
string operation = GetNextToken();
string value = GetNextToken();
if (Mode == ParserMode.Normal || Mode == ParserMode.ImportRules)
{
switch (operation)
{
case "=":
Larvae.SetElement(et, value);
break;
case "+=":
value = Larvae.GetElement(et) + value;
Larvae.SetElement(et, value);
break;
default:
Log.Error(operation, Error.UnexpectedToken, " expected for \"=\" or \"+=\"");
break;
}
}
element = value;
return(et);
}
switch (token)
{
case "static":
case "struct":
{
LarvaType larvaType = token == "struct" ? LarvaType.Struct : LarvaType.Static;
// parse struct data
string larvaName = GetNextToken();
string fullName = Larvae.GetFullName(larvaName);
Larva larva = Larvae.GetLarva(fullName);
larva.Name = larvaName;
larva.Namespace = Larvae.GetElement(ElementType.Namespace);
larva.TypeInfo = larvaType == LarvaType.Struct ? TypeFactory.Get("struct", true) : TypeFactory.Get("static", true);
switch (Mode)
{
case ParserMode.Normal:
case ParserMode.ImportLarva:
larva.Mode = LarvaMode.Generate;
break;
default:
larva.Mode = LarvaMode.Skip;
break;
}
larva.Type = larvaType;
token = GetNextToken();
if (token == ":")
{
token = GetNextToken();
larva.BaseName = token;
token = GetNextToken();
if (token == "base")
{
token = GetNextToken();
// read base field initialisation
if (token != "{")
{
Log.Error(token, Error.UnexpectedToken, "Expected symbol '{' after base " + larva.Name + " defenition");
return(ElementType.Error);
}
token = GetNextToken();
while (token != "}")
{
Part p = new Part(larva);
larva.BaseParts.Add(p);
p.Name = token;
token = GetNextToken();
if (token != "=")
{
Console.WriteLine("Error: Expected symbol '=' in base " + larva.Name + " defenition");
return(ElementType.Error);
}
// initial value
token = GetNextToken();
p.InitialValue = token;
// must be ended with , or }
token = GetNextToken();
if (token != "," && token != "}")
{
Console.WriteLine("Error: Expected symbol ',' in base " + larva.Name + " defenition");
return(ElementType.Error);
}
// skip ,
if (token == ",")
{
token = GetNextToken();
}
}
token = GetNextToken();
}
}
if (token != "{")
{
Log.Error(token, Error.UnexpectedToken, "Expected symbol '{' after struct " + larva.Name + " defenition");
return(ElementType.Error);
}
int ie = GetNextTokenIndex("}");
if (ie == -1)
{
Log.Error("}", Error.NotFound, "struct closing symbol '}' not found");
return(ElementType.Error);
}
while (currentToken < ie)
{
Part p = new Part(larva);
Larva l = GetLarva();
string t = GetNextToken();
p.Larva = l;
p.Name = t;
t = GetNextToken();
if (t == "=")
{
p.InitialValue = GetNextToken();
t = GetNextToken();
}
if (t == ":")
{
t = GetNextToken(); // read modificator
if (t == "skip")
{
p.Mode = PartMode.Skip;
}
t = GetNextToken();
}
if (t != ";")
{
Log.Error(token, Error.UnexpectedToken, "Unexpected token '" + token + "' field name not found");
return(ElementType.Error);
}
larva.Parts.Add(p);
}
GetNextToken(); // read !}
// check for methods name that we will need to generate
if (IsNextToken(":"))
{
token = GetNextToken(); // read :
while (true)
{
token = GetNextToken();
if (token == ";")
{
break;
}
larva.Methods.Add(token);
}
}
element = larva;
return(ElementType.Struct);
}
case "enum":
{
// parse struct data
string larvaName = GetNextToken();
string fullName = Larvae.GetFullName(larvaName);
Larva larva = Larvae.GetLarva(fullName);
larva.Name = larvaName;
larva.Namespace = Larvae.GetElement(ElementType.Namespace);
larva.TypeInfo = TypeFactory.Get("enum", true);
switch (Mode)
{
case ParserMode.Normal:
case ParserMode.ImportLarva:
larva.Mode = LarvaMode.Generate;
break;
default:
larva.Mode = LarvaMode.Skip;
break;
}
larva.Type = LarvaType.Enum;
token = GetNextToken();
if (token != "{")
{
Log.Error(token, Error.UnexpectedToken, "Expected symbol '{' after enum " + larva.Name + " defenition");
return(ElementType.Error);
}
while (true)
{
string t = GetNextToken();
if (t == "}")
{
break;
}
Part p = new Part(larva);
p.Name = t;
p.Larva = larva;
larva.Parts.Add(p);
t = GetNextToken();
if (t == "=")
{
p.InitialValue = GetNextToken();
t = GetNextToken();
}
if (t == ":")
{
p.Description = GetNextToken();
t = GetNextToken();
}
if (t == "}")
{
break;
}
if (t != ",")
{
Log.Error(token, Error.UnexpectedToken, "Unexpected token '" + token + "' field name not found");
return(ElementType.Error);
}
}
element = larva;
return(ElementType.Enum);
}
case "import":
{
token = GetNextToken();
ParserMode parserMode = ParserMode.Unknown;
switch (token.ToLower())
{
case "larva":
parserMode = ParserMode.ImportLarva;
break;
case "rules":
parserMode = ParserMode.ImportRules;
break;
default:
Console.WriteLine("Error. Unknown parser mode: " + token);
return(ElementType.Error);
break;
}
string fileName = GetNextToken();
if (parserMode == ParserMode.ImportLarva)
{
Larvae.AddImport(fileName);
}
// save current namespace
string ns = Larvae.GetElement(ElementType.Namespace);
Parser p = new Parser(Program.ReadAllText(fileName), parserMode);
p.Parse();
// restore namespace
Larvae.SetElement(ElementType.Namespace, ns);
return(ElementType.Import);
}
case "type":
{
token = GetNextToken();
int length = 0;
try
{
length = Convert.ToInt32(token);
}
catch (Exception e)
{
Console.WriteLine("Can't parse type length: " + e.ToString());
return(ElementType.Error);
}
string group = GetNextToken();
string name = GetNextToken();
token = GetNextToken();
if (token != "=")
{
Console.WriteLine("Unexpected token '" + token + "'. Expected '='");
return(ElementType.Error);
}
string definition = GetNextToken();
TypeInfo td = TypeFactory.Get(name);
td.Length = length;
td.Group = group;
td.Definition = definition;
return(ElementType.Type);
}
case "method":
{
string methodName = GetNextToken();
Method m = MethodFactory.GetMethod(methodName);
VariableList vl = m.Variables;
Variable v = null;
while (true)
{
token = GetNextToken();
if (token == "=")
{
break;
}
v = vl.GetVariable(token);
vl = v.Variables;
}
token = GetNextToken(); // read variable value
v.Value = token;
return(ElementType.Method);
}
}
element = token;
return(ElementType.None);
}
public string GetStructFieldDeclaration()
{
string tpd = Larvae.GetElement(ElementType.StructFieldDeclaration);
return(TextHelper.ReplaceExpressions(ref tpd, this));
}
