Exemple #1
0
        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("");
        }
Exemple #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);
        }