Esempio n. 1
0
        private void LoadClassesMethods(BaseSymbol root, AssemblyGen ag)
        {
            root.Symbols.ForEach(s =>
            {
                if (s.GrammarMember == GrammarMemberType.NonTerm)
                {
                    NonTerm nonTerm = s as NonTerm;
                    switch (nonTerm.TypeNonTerm)
                    {
                    case NonTermType.Class:
                        Token termClassId;
                        List <BaseSymbol> declarations;
                        NonTermFactory.GetClassDecl(nonTerm, out termClassId, out declarations);

                        string classId = termClassId.Value;

                        TypeGen cl = _classesTable[classId];
                        Dictionary <string, MethodGen> methodsDictionary = new Dictionary <string, MethodGen>();

                        foreach (var declaration in declarations)
                        {
                            if ((declaration as NonTerm).TypeNonTerm == NonTermType.Method)
                            {
                                KeyValuePair <string, MethodGen> method = GenerateMethodSignature(cl, declaration, ag);
                                methodsDictionary.Add(method.Key, method.Value);
                            }
                        }

                        _methodsTables.Add(cl.Name, methodsDictionary);

                        break;
                    }
                }
            });
        }
Esempio n. 2
0
        /// <summary>
        /// Загрузка всех классов (наследование учитывается).
        /// Допущение - классы-наследники должны располагаться после базовых классов
        /// и иерархий наследования должно быть не более 1.
        /// </summary>
        /// <param name="root">Базовый символ</param>
        /// <param name="ag">Сборка</param>
        private void LoadClassesExtends(BaseSymbol root, AssemblyGen ag)
        {
            root.Symbols.ForEach(s =>
            {
                if (s.GrammarMember == GrammarMemberType.NonTerm)
                {
                    NonTerm nonTerm = s as NonTerm;
                    switch (nonTerm.TypeNonTerm)
                    {
                    case NonTermType.Class:
                        Token termClassId;
                        NonTerm extends;
                        NonTermFactory.GetClassDecl(nonTerm, out termClassId, out extends);
                        string classId = termClassId.Value;
                        if (extends == null)
                        {
                            TypeGen cl = ag.Class(classId);
                            _classesTable.Add(cl.Name, cl);
                        }
                        else
                        {
                            Token baseClassId;
                            NonTermFactory.GetClassId(extends, out baseClassId);
                            TypeGen cl = _classesTable[baseClassId.Value];
                            cl         = ag.Class(classId, cl);
                            _classesTable.Add(cl.Name, cl);
                        }

                        break;
                    }
                }
            });
        }
Esempio n. 3
0
        private void EmitClass(NonTerm nonTerm)
        {
            Token             termClassId;
            List <BaseSymbol> declarations;

            NonTermFactory.GetClassDecl(nonTerm, out termClassId, out declarations);
            _currentClass = _classesTable[termClassId.Value];

            declarations.ForEach(symbol => Generate(symbol));
        }