Пример #1
0
		internal TheVariable(CsVariableDeclaration pCsVariableDeclaration, TheClass pTheClass, FactoryExpressionCreator pCreator) {
			Modifiers.AddRange(Helpers.GetModifiers(pCsVariableDeclaration.modifiers));

			foreach (CsVariableDeclarator declarator in pCsVariableDeclaration.declarators) {
				Variable v = new Variable {
					//RealName = declarator.identifier.identifier,
					//Name = Helpers.GetRealName(declarator, declarator.identifier.identifier),
					Name = declarator.identifier.identifier,
					Initializer =
						declarator.initializer == null ? null : pCreator.Parse(declarator.initializer as CsExpression),
					ReturnType = Helpers.GetType(declarator.entity.type)
				};

				v.Modifiers.AddRange(Modifiers);
				Variables.Add(v);
			}
		}
Пример #2
0
        internal TheVariable(CsVariableDeclaration pCsVariableDeclaration, TheClass pTheClass, FactoryExpressionCreator pCreator)
        {
            Modifiers.AddRange(Helpers.GetModifiers(pCsVariableDeclaration.modifiers));

            foreach (CsVariableDeclarator declarator in pCsVariableDeclaration.declarators)
            {
                Variable v = new Variable {
                    //RealName = declarator.identifier.identifier,
                    //Name = Helpers.GetRealName(declarator, declarator.identifier.identifier),
                    Name        = declarator.identifier.identifier,
                    Initializer =
                        declarator.initializer == null ? null : pCreator.Parse(declarator.initializer as CsExpression),
                    ReturnType = Helpers.GetType(declarator.entity.type)
                };

                v.Modifiers.AddRange(Modifiers);
                Variables.Add(v);
            }
        }
Пример #3
0
        public TheVariable GetVariable(CsVariableDeclaration pMemberDeclaration)
        {
            TheVariable c;

            return(_variables.TryGetValue(pMemberDeclaration, out c) ? c : null);
        }
Пример #4
0
        public TheClass(CsInterface pCsInterface, FactoryExpressionCreator pCreator)
        {
            IsInterface = true;
            List <string> name   = new List <string>();
            CsNamespace   parent = pCsInterface.parent as CsNamespace;

            if (parent != null)
            {
                name.AddRange(parent.qualified_identifier.Select(pArt => pArt.identifier.identifier));
            }

            NameSpace = string.Join(".", name.ToArray());
            Name      = pCsInterface.identifier.identifier;
            FullName  = NameSpace + "." + Name;

            if (pCsInterface.type_base != null && pCsInterface.type_base.base_list.Count != 0)
            {
                foreach (CsTypeRef typeRef in pCsInterface.type_base.base_list)
                {
                    object u = typeRef.entity_typeref.u;
                    if (u == null)
                    {
                        continue;
                    }

                    if (u is CsEntityClass)
                    {
                        Extends.Add(Helpers.GetType(typeRef.type_name));
                        _baseTyperef = typeRef;
                    }
                    else if (u is CsEntityInterface)
                    {
                        Implements.Add(Helpers.GetType(typeRef.type_name));
                    }
                    else if (u is CsEntityInstanceSpecifier)
                    {
                        Implements.Add(Helpers.GetType(typeRef.type_name));
                    }
                    else
                    {
                        throw new NotSupportedException();
                    }
                }
            }

            Dictionary <string, int> methodNames = new Dictionary <string, int>();
            bool methodsDone = false;

            if (pCsInterface.member_declarations != null)
            {
                foreach (CsNode memberDeclaration in pCsInterface.member_declarations)
                {
                    CsMethod m = memberDeclaration as CsMethod;
                    if (m != null)
                    {
                        if (m.interface_type != null)
                        {
                            continue;
                        }

                        TheMethod tm = new TheMethod(m, this, pCreator);
                        if (methodNames.ContainsKey(tm.Name))
                        {
                            methodNames[tm.Name]++;
                            int index = tm._index = methodNames[tm.Name];

                            if (!methodsDone)
                            {
                                methodsDone = true;
                                foreach (KeyValuePair <CsMethod, TheMethod> method in _methods)
                                {
                                    method.Value._isUnique = false;
                                    method.Value._index    = --index;
                                }
                            }

                            tm._isUnique = false;
                        }
                        else
                        {
                            methodNames[tm.Name] = tm._index = 1;
                        }

                        _methods.Add(m, tm);
                        continue;
                    }

                    CsIndexer i = memberDeclaration as CsIndexer;
                    if (i != null)
                    {
                        _indexers.Add(i, new TheIndexer(i, this, pCreator));
                        continue;
                    }

                    CsVariableDeclaration v = memberDeclaration as CsVariableDeclaration;
                    if (v != null)
                    {
                        _variables.Add(v, new TheVariable(v, this, pCreator));
                        continue;
                    }

                    CsProperty p = memberDeclaration as CsProperty;
                    if (p != null)
                    {
                        if (p.interface_type == null)
                        {
                            _properties.Add(p, new TheProperty(p, this, pCreator));
                        }
                        continue;
                    }

                    throw new NotImplementedException("Unknown type not implemented");
                }
            }

            Modifiers.AddRange(Helpers.GetModifiers(pCsInterface.modifiers));
        }
Пример #5
0
        public TheClass(CsClassStruct pCsClass, FactoryExpressionCreator pCreator)
        {
            CsNamespace csNamespace;

            _creator = pCreator;
            List <string> name = new List <string>();

            if (pCsClass.parent is CsClass)
            {
                IsPrivate   = true;
                csNamespace = (CsNamespace)pCsClass.parent.parent;
            }
            else
            {
                csNamespace = (CsNamespace)pCsClass.parent;
            }

            CsQualifiedIdentifier list = csNamespace.qualified_identifier;

            name.AddRange(list.Select(pIdentifier => pIdentifier.identifier.identifier));

            if (IsPrivate)
            {
                name.Add(((CsClass)pCsClass.parent).identifier.identifier);
            }

            NameSpace = string.Join(".", name.ToArray());
            //RealName = pCsClass.identifier.identifier;
            //Name = Helpers.GetRealName(pCsClass, RealName);
            Name = pCsClass.identifier.identifier;

            FullName = NameSpace + "." + Name;
            //FullRealName = NameSpace + "." + RealName;

            if (pCsClass.type_base != null && pCsClass.type_base.base_list.Count != 0)
            {
                foreach (CsTypeRef typeRef in pCsClass.type_base.base_list)
                {
                    object u = typeRef.entity_typeref.u;
                    if (u == null)
                    {
                        continue;
                    }

                    if (u is CsEntityClass)
                    {
                        Extends.Add(Helpers.GetType(typeRef.type_name));
                        _baseTyperef = typeRef;
                    }
                    else if (u is CsEntityInterface)
                    {
                        Implements.Add(Helpers.GetType(typeRef.type_name));
                    }
                    else if (u is CsEntityInstanceSpecifier)
                    {
                        Implements.Add(Helpers.GetType(typeRef.type_name));

                        //CsEntityInstanceSpecifier specifier = (CsEntityInstanceSpecifier)typeRef.entity_typeref.u;
                    }
                    else
                    {
                        throw new NotSupportedException();
                    }
                }
            }

            Dictionary <string, int> methodNames = new Dictionary <string, int>();
            bool constructorsDone = false;
            bool methodsDone      = false;

            if (pCsClass.member_declarations != null)
            {
                foreach (CsNode memberDeclaration in pCsClass.member_declarations)
                {
                    CsConstructor c = memberDeclaration as CsConstructor;
                    if (c != null)
                    {
                        TheConstructor tm = new TheConstructor(c, this, pCreator);

                        if (methodNames.ContainsKey(tm.Name))
                        {
                            methodNames[tm.Name]++;
                            int index = tm._index = methodNames[tm.Name];

                            if (!constructorsDone)
                            {
                                constructorsDone = true;
                                foreach (KeyValuePair <CsConstructor, TheConstructor> constructor in _constructors)
                                {
                                    constructor.Value._isUnique = false;
                                    constructor.Value._index    = --index;
                                }
                            }

                            tm._isUnique = false;
                        }
                        else
                        {
                            methodNames[tm.Name] = tm._index = 1;
                        }

                        _constructors.Add(c, tm);
                        continue;
                    }

                    CsMethod m = memberDeclaration as CsMethod;
                    if (m != null)
                    {
                        if (m.interface_type != null)
                        {
                            continue;
                        }

                        TheMethod tm = new TheMethod(m, this, pCreator);
                        if (methodNames.ContainsKey(tm.Name))
                        {
                            methodNames[tm.Name]++;
                            int index = tm._index = methodNames[tm.Name];

                            if (!methodsDone)
                            {
                                methodsDone = true;
                                foreach (KeyValuePair <CsMethod, TheMethod> method in _methods)
                                {
                                    method.Value._isUnique = false;
                                    method.Value._index    = --index;
                                }
                            }

                            tm._isUnique = false;
                        }
                        else
                        {
                            methodNames[tm.Name] = tm._index = 1;
                        }

                        _methods.Add(m, tm);
                        continue;
                    }

                    CsIndexer i = memberDeclaration as CsIndexer;
                    if (i != null)
                    {
                        _indexers.Add(i, new TheIndexer(i, this, pCreator));
                        continue;
                    }

                    CsVariableDeclaration v = memberDeclaration as CsVariableDeclaration;
                    if (v != null)
                    {
                        _variables.Add(v, new TheVariable(v, this, pCreator));
                        continue;
                    }

                    CsConstantDeclaration k = memberDeclaration as CsConstantDeclaration;
                    if (k != null)
                    {
                        _constants.Add(k, new TheConstant(k, this, pCreator));
                        continue;
                    }

                    CsProperty p = memberDeclaration as CsProperty;
                    if (p != null)
                    {
                        if (p.interface_type == null)
                        {
                            _properties.Add(p, new TheProperty(p, this, pCreator));
                        }
                        continue;
                    }

                    CsDelegate d = memberDeclaration as CsDelegate;
                    if (d != null)
                    {
                        _delegates.Add(d, new TheDelegate(d, this, pCreator));
                        continue;
                    }

                    CsEvent e = memberDeclaration as CsEvent;
                    if (e != null)
                    {
                        TheEvent theEvent = new TheEvent(e, this, pCreator);
                        _events.Add(theEvent.Name, theEvent);
                        continue;
                    }

                    CsClass csClass = memberDeclaration as CsClass;
                    if (csClass != null)
                    {
                        continue;
                    }

                    throw new NotImplementedException("Unknown type not implemented");
                }
            }

            Modifiers.AddRange(Helpers.GetModifiers(pCsClass.modifiers));
        }
Пример #6
0
		public TheVariable GetVariable(CsVariableDeclaration pMemberDeclaration) {
			TheVariable c;
			return _variables.TryGetValue(pMemberDeclaration, out c) ? c : null;
		}