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));
}