Example #1
0
 static void Parse(string text)
 {
     Parser parser = new Parser(text);
     parser.Parse();
 }
Example #2
0
        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;
        }