示例#1
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));
        }
示例#2
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));
		}