private bool is_getter_or_setter(ICommonMethodNode meth, ICommonPropertyNode[] props) { foreach (ICommonPropertyNode p in props) { if (p.get_function == meth || p.set_function == meth) { return(true); } } return(false); }
internal bool is_event_special_method(ICommonMethodNode meth) { if (meth.common_comprehensive_type != null) { ICommonEventNode[] events = meth.common_comprehensive_type.events; foreach (ICommonEventNode e in events) { if (e.AddMethod == meth || e.RaiseMethod == meth || e.RemoveMethod == meth) { return(true); } } } return(false); }
internal bool is_getter_or_setter(ICommonMethodNode meth) { if (meth.common_comprehensive_type != null) { ICommonPropertyNode[] props = GetProperties(meth.common_comprehensive_type); foreach (ICommonPropertyNode p in props) { if (p.get_function == meth || p.set_function == meth) { return(true); } } } return(false); }
public bool is_overloaded_constructor(ICommonMethodNode meth) { int count = 1; if (meth.common_comprehensive_type != null) { foreach (ICommonMethodNode m in meth.common_comprehensive_type.methods) { if (m.is_constructor && meth != m) { count++; } } } return(count > 1); }
public List <ICommonMethodNode> GetOverloadsList(ICommonTypeNode t, ICommonMethodNode meth) { List <ICommonMethodNode> lst = new List <ICommonMethodNode>(); while (t != null) { foreach (ICommonMethodNode m in t.methods) { if (string.Compare(m.name, meth.name, true) == 0 && meth.overrided_method != m) { lst.Add(m); } } t = t.base_type as ICommonTypeNode; } return(lst); }
public bool is_overload(ICommonMethodNode meth, ICommonTypeNode ctn) { int count = 1; while (ctn != null) { foreach (ICommonMethodNode m in ctn.methods) { if (string.Compare(meth.name, m.name, true) == 0 && meth != m && meth.overrided_method != m) { count++; } } ctn = ctn.base_type as ICommonTypeNode; } return(count > 1); }
public int GetConstructorIndex(ICommonMethodNode cmn) { if (cmn.common_comprehensive_type != null) { ICommonMethodNode[] meths = cmn.common_comprehensive_type.methods; int i = 1; foreach (ICommonMethodNode m in meths) { if (m == cmn) { return(i); } else if (m.is_constructor) { i++; } } } return(1); }
public int GetMethodIndex(ICommonMethodNode cmn, ICommonTypeNode ctn) { int i = 1; while (ctn != null) { ICommonMethodNode[] meths = ctn.methods; foreach (ICommonMethodNode m in meths) { if (m == cmn) { return(i); } else if (string.Compare(m.name, cmn.name, true) == 0 && cmn.overrided_method != m) { i++; } } ctn = ctn.base_type as ICommonTypeNode; } return(1); }
private bool IsPropertyAccessor(ICommonMethodNode value) { return comp_opt.target == TargetType.Dll && prop_accessors.ContainsKey(value); }
private Type[] GetParamTypes(ICommonMethodNode func) { Type[] tt = null; int num = 0; IParameterNode[] parameters = func.parameters; tt = new Type[parameters.Length]; for (int i = 0; i < parameters.Length; i++) { Type tp = helper.GetTypeReference(parameters[i].type).tp; if (parameters[i].parameter_type == parameter_type.value) tt[i + num] = tp; else { tt[i + num] = tp.MakeByRefType(); //Type t = tp.Module.GetType(tp.FullName + "&"); //if (t != null) // tt[i + num] = t; //else // tt[i + num] = mb.GetType(tp.FullName + "&"); } } return tt; }
public static bool can_write(ICommonMethodNode t) { return !(string.IsNullOrEmpty(t.Documentation) && !builder.options.ShowNoCommentedElements || t.name.Contains("$") || builder.parser.is_getter_or_setter(t) || t.name.StartsWith("op_") || builder.parser.is_event_special_method(t) || user_doc_disabled(t.Documentation)); }
private void ConvertConstructorParameters(ICommonMethodNode value, ConstructorBuilder methb) { ParameterBuilder pb = null; IParameterNode[] parameters = value.parameters; for (int i = 0; i < parameters.Length; i++) { object default_value = null; if (parameters[i].default_value != null) default_value = helper.GetConstantForExpression(parameters[i].default_value); ParameterAttributes pa = ParameterAttributes.None; if (parameters[i].parameter_type == parameter_type.var) pa = ParameterAttributes.Retval; if (default_value != null) pa |= ParameterAttributes.Optional; pb = methb.DefineParameter(i + 1, pa, parameters[i].name); if (default_value != null) pb.SetConstant(default_value); helper.AddParameter(parameters[i], pb); if (parameters[i].is_params) pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeConstructor, new byte[] { 0x1, 0x0, 0x0, 0x0 }); } }
public void visit(ICommonMethodNode value) { string s = value.GetType().Name + "."; prepare_string_node(value.name, s + "name"); prepare_up_link_node(value.comperehensive_type.name.ToString(), s + "comperehensive_type", value.comperehensive_type); myTreeNode from = treeView.SelectedNode.Nodes[1] as myTreeNode; myTreeNode to = table_subnodes[value.comperehensive_type] as myTreeNode; table_for_up_links.Add(from, to); prepare_base_node_collection(value.constants, s + "constants", "constants", value.constants.Length); prepare_string_node(value.field_access_level.ToString(), s + "field_access_level"); prepare_node(value.function_code, s + "function_code"); prepare_base_node_collection(value.functions_nodes, s + "function_nodes", "function_nodes", value.functions_nodes.Length); prepare_string_node(value.is_constructor.ToString(), s + "is_constructor"); prepare_string_node(value.is_final.ToString(), s + "is_final"); prepare_string_node(value.newslot_awaited.ToString(), s + "newslot_awaited"); prepare_string_node(value.node_kind.ToString(), s + "node_kind"); prepare_string_node(value.node_location_kind.ToString(), s + "node_location_kind"); //prepare_node(value.overrided_method, s + "overrided_method"); prepare_base_node_collection(value.parameters, s + "parametrs", "parametrs", value.parameters.Length); prepare_string_node(value.polymorphic_state.ToString(), s + "polymorphic_state"); prepare_node(value.return_value_type, s + "return_value_type"); //prepare_node(value.return_variable, s + "return_variable"); //prepare_up_link_node(value.return_variable.name, s + "return_variable", value.return_variable); prepare_string_node(value.SpecialFunctionKind.ToString(), s + "SpecialFunctionKind"); prepare_base_node_collection(value.var_definition_nodes, s + "var_definition_nodes", "var_definition_nodes", value.var_definition_nodes.Length); }
public virtual void visit(ICommonMethodNode value) { }
public void visit(ICommonMethodNode value) { throw new System.NotSupportedException(value.GetType().ToString()); }
public static string get_meth_name(ICommonMethodNode f) { return HelpUtils.get_type_name(f.comperehensive_type) + "." + (f.is_constructor?"Create":f.name); }
public static string possible_overload_symbol(ICommonMethodNode f) { if (builder.parser.is_overload(f,f.common_comprehensive_type)) { int ind = builder.parser.GetMethodIndex(f,f.common_comprehensive_type); if (ind != 1) return "$"+builder.parser.GetMethodIndex(f,f.common_comprehensive_type); else return ""; } return ""; }
public static string possible_overload_constructor_symbol(ICommonMethodNode f) { if (builder.parser.is_overloaded_constructor(f)) { int ind = builder.parser.GetConstructorIndex(f); if (ind != 1) return "$"+builder.parser.GetConstructorIndex(f); else return ""; } return ""; }
public virtual void visit(ICommonMethodNode value) { }
public static string get_meth_header(ICommonMethodNode f) { StringBuilder sb = new StringBuilder(); string hdr = HelpUtils.extract_user_defined_header(f.Documentation); if (!string.IsNullOrEmpty(hdr)) { sb.Append("<div>"+hdr+"</div>"); return sb.ToString(); } sb.Append("<div>"); sb.Append(get_span_for_keyword(get_text_for_access_level(f.field_access_level))+" "); if (f.polymorphic_state == polymorphic_state.ps_static) sb.Append(get_span_for_keyword("class")+" "); if (f.is_constructor) sb.Append(get_span_for_keyword("constructor")+" "); else if (f.return_value_type == null) sb.Append(get_span_for_keyword("procedure")+" "); else sb.Append(get_span_for_keyword("function")+" "); sb.Append(get_span_for_identifier(f.name)); sb.Append(get_generic_string(f.generic_params)); sb.Append(get_parameters(f.parameters)); if (f.return_value_type != null && !f.is_constructor) sb.Append(": "+get_type_html_text(f.return_value_type)); if (f.polymorphic_state == polymorphic_state.ps_virtual) if (f.overrided_method == null) sb.Append("; "+get_span_for_keyword("virtual")); else sb.Append("; "+get_span_for_keyword("override")); else if (f.polymorphic_state == polymorphic_state.ps_virtual_abstract && f.common_comprehensive_type != null && !f.common_comprehensive_type.IsInterface) sb.Append("; "+get_span_for_keyword("abstract")); sb.Append("</div>"); return sb.ToString(); }