public LambdaMethodExpression(CsLambdaExpression pStatement, FactoryExpressionCreator pCreator) { Arguments = BaseMethod.getArguments(pStatement.signature.parameters, pCreator); ReturnType = Helpers.GetType(pStatement.best_common_type); //ReturnType = Helpers.GetType(((CsEntityMethod)((CsEntityAnonymousMethod)pStatement.entity).parent.parent).specifier.return_type); CodeBlock = pStatement.body; }
internal TheIndexer(CsIndexer pIndexer, TheClass pMyClass, FactoryExpressionCreator pCreator) { MyClass = pMyClass; _creator = pCreator; Arguments = getArguments(pIndexer.parameters.parameters, pCreator); Signature = getSignature(Arguments); ReturnType = Helpers.GetType(pIndexer.entity.specifier.return_type); Modifiers.AddRange(Helpers.GetModifiers(pIndexer.modifiers)); //Name = Helpers.GetRealName(pIndexer, pIndexer.entity.name); Name = pIndexer.entity.name; FullName = MyClass.FullName + "." + Name; //FullRealName = MyClass.FullRealName + "." + RealName; string sig = Signature.Replace(',', '_').Replace("<", "").Replace(">", ""); if (pIndexer.getter != null) { Getter = processIndexer(pIndexer.getter, false, sig); } if (pIndexer.setter != null) { Setter = processIndexer(pIndexer.setter, true, sig); } }
internal TheMethod(CsMethod pCsMethod, TheClass pMyClass, FactoryExpressionCreator pCreator) { MyClass = pMyClass; Modifiers.AddRange(Helpers.GetModifiers(pCsMethod.modifiers)); Arguments = getArguments(pCsMethod.parameters.parameters, pCreator); Signature = getSignature(Arguments); CodeBlock = pCsMethod.definition; //_sig = Signature.Replace(',', '_').Replace("<", "").Replace(">", ""); //_name = Helpers.GetRealName(pCsMethod, pCsMethod.identifier.identifier); _realName = _name = pCsMethod.identifier.identifier; //FullRealName = MyClass.FullRealName + "." + RealName; ReturnType = Helpers.GetType(pCsMethod.return_type); IsExtensionMethod = pCsMethod.entity.isExtensionMethod(); }
internal static List <TheMethodArgument> getArguments(IEnumerable <CsFormalParameter> pLinkedList, FactoryExpressionCreator pCreator) { List <TheMethodArgument> arguments = new List <TheMethodArgument>(); if (pLinkedList != null) { arguments.AddRange(from param in pLinkedList let e = param.default_argument == null ? null : pCreator.Parse(param.default_argument.expression) select new TheMethodArgument { Name = param.identifier.identifier, Type = param.type == null ? Helpers.GetType(param.entity.type) : Helpers.GetType(param.type), DefaultValue = e }); } return(arguments); }
public TheConstant(CsConstantDeclaration pCsConstantDeclaration, TheClass pTheClass, FactoryExpressionCreator pCreator) { Modifiers.AddRange(Helpers.GetModifiers(pCsConstantDeclaration.modifiers)); foreach (CsConstantDeclarator declarator in pCsConstantDeclaration.declarators) { Constant v = new Constant { //RealName = declarator.identifier.identifier, //Name = Helpers.GetRealName(declarator, declarator.identifier.identifier), Name = declarator.identifier.identifier, Initializer = pCreator.Parse(declarator.expression), ReturnType = Helpers.GetType(declarator.entity.type) }; v.Modifiers.AddRange(Modifiers); Constants.Add(v); } }
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); } }
internal TheMethod(CsEntityMethod pCsMethod, TheClass pMyClass, FactoryExpressionCreator pCreator, bool pIsEvent = false, bool pIsAddEvent = false) { MyClass = pMyClass; //Modifiers.AddRange(Helpers.GetModifiers(pCsMethod.access)); Arguments = getArguments(pCsMethod.parameters, pCreator); Signature = getSignature(Arguments); //_name = Helpers.GetRealName(pCsMethod, pIsEvent ? // pIsAddEvent ? "add" : "remove" : // pCsMethod.name); _name = pIsEvent ? pIsAddEvent ? "add" : "remove" : pCsMethod.name; _realName = pCsMethod.name; //FullRealName = MyClass.FullRealName + "." + RealName; ReturnType = Helpers.GetType(pCsMethod.specifier.return_type); IsExtensionMethod = pCsMethod.isExtensionMethod(); }
public TheProperty(CsProperty pCsProperty, TheClass pTheClass, FactoryExpressionCreator pCreator) { MyClass = pTheClass; Modifiers.AddRange(Helpers.GetModifiers(pCsProperty.modifiers)); Name = pCsProperty.identifier.identifier; FullName = MyClass.FullName + "." + Name; ReturnType = Helpers.GetType(pCsProperty.type); if (pCsProperty.getter != null) { Getter = new Property(pCsProperty.getter, this); } if (pCsProperty.setter != null) { Setter = new Property(pCsProperty.setter, this); } }
internal static List <TheMethodArgument> getArguments(CsEntityFormalParameter[] pCsEntityFormalParameter, FactoryExpressionCreator pCreator) { List <TheMethodArgument> arguments = new List <TheMethodArgument>(); if (pCsEntityFormalParameter != null) { foreach (CsEntityFormalParameter formalParameter in pCsEntityFormalParameter) { CsFormalParameter p = formalParameter.param; arguments.Add(new TheMethodArgument { Name = p == null ? formalParameter.name : p.identifier.identifier, Type = Helpers.GetType(formalParameter.type), DefaultValue = p == null ? null : p.default_argument == null ? null : pCreator.Parse(p.default_argument.expression) }); } } return(arguments); }
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(); }
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)); }
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)); }