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;
}
}
}
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 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);
}
