コード例 #1
0
ファイル: TheClass.cs プロジェクト: kevinmiles/cstoas3
        public TheMethod GetMethod(CsEntityMethod pMethod, FactoryExpressionCreator pCreator)
        {
            if (pMethod.decl != null)
            {
                return(GetMethod((CsMethod)pMethod.decl));
            }

            TheMethod c;

            if (_entityMethods.TryGetValue(pMethod, out c))
            {
                return(c);
            }

            c = new TheMethod(pMethod, this, pCreator);
            Dictionary <string, bool> methodNames = new Dictionary <string, bool>();

            foreach (KeyValuePair <CsEntityMethod, TheMethod> entityMethod in
                     _entityMethods.Where(pEntityMethod => methodNames.ContainsKey(pEntityMethod.Value.Name)))
            {
                entityMethod.Value._isUnique = false;
                c._isUnique = false;
            }

            _entityMethods.Add(pMethod, c);
            return(c);
        }
コード例 #2
0
ファイル: TheEvent.cs プロジェクト: gamificationvn/cstoas3
		public TheEvent(CsEvent pCsEvent, TheClass pTheClass, FactoryExpressionCreator pCreator) {
			MyClass = pTheClass;

			if (pCsEvent.declarators.Count > 1) throw new Exception("No more than one event declaration per handler is supported");

			_declarator = pCsEvent.declarators.First.Value;

			Name = _declarator.identifier.identifier;//RealName = 
			//FullRealName = MyClass.FullRealName + "." + RealName;
			FullName = MyClass.FullName + "." + Name;
			Modifiers.AddRange(Helpers.GetModifiers(pCsEvent.modifiers));

			string eventName = Helpers.GetEventFromAttr(pCsEvent.attributes, pCreator);
			IsFlashEvent = !string.IsNullOrEmpty(eventName);

			Add = new TheMethod(_declarator.entity.add, pTheClass, pCreator, true, true);
			Remove = new TheMethod(_declarator.entity.remove, pTheClass, pCreator, true);
			EventName = Helpers.GetEventFromAttr(pCsEvent.attributes, pCreator);
		}
コード例 #3
0
ファイル: TheClass.cs プロジェクト: kevinmiles/cstoas3
        public TheClass(CsEntity pCsEntity, FactoryExpressionCreator pCreator)
        {
            IsEntity = true;
            List <string> name   = new List <string>();
            CsEntity      parent = pCsEntity.parent;

            while (parent != null && parent is CsEntityNamespace)
            {
                if (!string.IsNullOrEmpty(parent.name))
                {
                    name.Add(parent.name);
                }
                parent = parent.parent;
            }

            name.Reverse();

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

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

            CsEntityClass klass = pCsEntity as CsEntityClass;

            if (klass != null)
            {
                _baseEntityTyperef = klass.base_type;

                if (klass.base_type.type != cs_entity_type.et_object)
                {
                    Extends.Add(Helpers.GetType(klass.base_type));
                }

                if (klass.interfaces != null)
                {
                    foreach (CsEntityTypeRef @interface in klass.interfaces)
                    {
                        Implements.Add(Helpers.GetType(@interface));
                    }
                }

                Dictionary <string, int> methodNames = new Dictionary <string, int>();
                //bool constructorsDone = false;
                bool methodsDone = false;
                if (klass.method_implementations == null)
                {
                    return;
                }

                foreach (CsEntityMethodImplementation methodImplementation in klass.method_implementations)
                {
                    CsEntityMethod m  = methodImplementation.implementation_method;
                    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;
                    }

                    _entityMethods.Add(m, tm);
                }

                return;
            }

            CsEntityInterface entityInterface = pCsEntity as CsEntityInterface;

            if (entityInterface != null)
            {
                _baseEntityTyperef = entityInterface.base_type;

                if (entityInterface.base_type.type != cs_entity_type.et_object)
                {
                    Extends.Add(Helpers.GetType(entityInterface.base_type));
                }

                if (entityInterface.interfaces != null)
                {
                    foreach (CsEntityTypeRef @interface in entityInterface.interfaces)
                    {
                        Implements.Add(Helpers.GetType(@interface));
                    }
                }

                Dictionary <string, int> methodNames = new Dictionary <string, int>();
                bool methodsDone = false;
                if (entityInterface.method_implementations == null)
                {
                    return;
                }

                foreach (CsEntityMethodImplementation methodImplementation in entityInterface.method_implementations)
                {
                    CsEntityMethod m  = methodImplementation.implementation_method;
                    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;
                    }

                    _entityMethods.Add(m, tm);
                }

                return;
            }

            CsEntityStruct entityStruct = pCsEntity as CsEntityStruct;

            if (entityStruct != null)
            {
                _baseEntityTyperef = entityStruct.base_type;

                if (entityStruct.base_type.type != cs_entity_type.et_object)
                {
                    Extends.Add(Helpers.GetType(entityStruct.base_type));
                }

                if (entityStruct.interfaces != null)
                {
                    foreach (CsEntityTypeRef @interface in entityStruct.interfaces)
                    {
                        Implements.Add(Helpers.GetType(@interface));
                    }
                }

                Dictionary <string, int> methodNames = new Dictionary <string, int>();
                bool methodsDone = false;
                if (entityStruct.method_implementations == null)
                {
                    return;
                }

                foreach (CsEntityMethodImplementation methodImplementation in entityStruct.method_implementations)
                {
                    CsEntityMethod m  = methodImplementation.implementation_method;
                    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;
                    }

                    _entityMethods.Add(m, tm);
                }

                return;
            }

            throw new NotImplementedException();
        }
コード例 #4
0
ファイル: TheClass.cs プロジェクト: kevinmiles/cstoas3
        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
ファイル: TheClass.cs プロジェクト: kevinmiles/cstoas3
        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
ファイル: TheClass.cs プロジェクト: gamificationvn/cstoas3
		public TheMethod GetMethod(CsEntityMethod pMethod, FactoryExpressionCreator pCreator) {
			if (pMethod.decl != null)
				return GetMethod((CsMethod)pMethod.decl);

			TheMethod c;
			if (_entityMethods.TryGetValue(pMethod, out c))
				return c;

			c = new TheMethod(pMethod, this, pCreator);
			Dictionary<string, bool> methodNames = new Dictionary<string, bool>();

			foreach (KeyValuePair<CsEntityMethod, TheMethod> entityMethod in
				_entityMethods.Where(pEntityMethod => methodNames.ContainsKey(pEntityMethod.Value.Name))) {
				entityMethod.Value._isUnique = false;
				c._isUnique = false;
			}

			_entityMethods.Add(pMethod, c);
			return c;
		}
コード例 #7
0
ファイル: TheClass.cs プロジェクト: gamificationvn/cstoas3
		public TheClass(CsEntity pCsEntity, FactoryExpressionCreator pCreator) {
			IsEntity = true;
			List<string> name = new List<string>();
			CsEntity parent = pCsEntity.parent;

			while (parent != null && parent is CsEntityNamespace) {
				if (!string.IsNullOrEmpty(parent.name))
					name.Add(parent.name);
				parent = parent.parent;
			}

			name.Reverse();

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

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

			CsEntityClass klass = pCsEntity as CsEntityClass;
			if (klass != null) {
				_baseEntityTyperef = klass.base_type;

				if (klass.base_type.type != cs_entity_type.et_object)
					Extends.Add(Helpers.GetType(klass.base_type));

				if (klass.interfaces != null) {
					foreach (CsEntityTypeRef @interface in klass.interfaces) {
						Implements.Add(Helpers.GetType(@interface));
					}
				}

				Dictionary<string, int> methodNames = new Dictionary<string, int>();
				//bool constructorsDone = false;
				bool methodsDone = false;
				if (klass.method_implementations == null) {
					return;
				}

				foreach (CsEntityMethodImplementation methodImplementation in klass.method_implementations) {
					CsEntityMethod m = methodImplementation.implementation_method;
					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;
					}

					_entityMethods.Add(m, tm);
				}

				return;
			}

			CsEntityInterface entityInterface = pCsEntity as CsEntityInterface;

			if (entityInterface != null) {

				_baseEntityTyperef = entityInterface.base_type;

				if (entityInterface.base_type.type != cs_entity_type.et_object)
					Extends.Add(Helpers.GetType(entityInterface.base_type));

				if (entityInterface.interfaces != null) {
					foreach (CsEntityTypeRef @interface in entityInterface.interfaces) {
						Implements.Add(Helpers.GetType(@interface));
					}
				}

				Dictionary<string, int> methodNames = new Dictionary<string, int>();
				bool methodsDone = false;
				if (entityInterface.method_implementations == null) {
					return;
				}

				foreach (CsEntityMethodImplementation methodImplementation in entityInterface.method_implementations) {
					CsEntityMethod m = methodImplementation.implementation_method;
					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;
					}

					_entityMethods.Add(m, tm);
				}

				return;
			}

			CsEntityStruct entityStruct = pCsEntity as CsEntityStruct;
			if (entityStruct != null) {
				_baseEntityTyperef = entityStruct.base_type;

				if (entityStruct.base_type.type != cs_entity_type.et_object)
					Extends.Add(Helpers.GetType(entityStruct.base_type));

				if (entityStruct.interfaces != null) {
					foreach (CsEntityTypeRef @interface in entityStruct.interfaces) {
						Implements.Add(Helpers.GetType(@interface));
					}
				}

				Dictionary<string, int> methodNames = new Dictionary<string, int>();
				bool methodsDone = false;
				if (entityStruct.method_implementations == null) {
					return;
				}

				foreach (CsEntityMethodImplementation methodImplementation in entityStruct.method_implementations) {
					CsEntityMethod m = methodImplementation.implementation_method;
					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;
					}

					_entityMethods.Add(m, tm);
				}

				return;
			}

			throw new NotImplementedException();
		}
コード例 #8
0
ファイル: TheClass.cs プロジェクト: gamificationvn/cstoas3
		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));
		}
コード例 #9
0
ファイル: TheClass.cs プロジェクト: gamificationvn/cstoas3
		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));
		}