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