1705 lines
56 KiB
C#
1705 lines
56 KiB
C#
using System;
|
|
using System.Windows.Forms;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using PascalABCCompiler.SyntaxTree;
|
|
using System.Threading;
|
|
using System.Diagnostics;
|
|
using System.Xml;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.IO;
|
|
using PascalABCCompiler.SemanticTree;
|
|
using System.Reflection;
|
|
|
|
namespace VisualPascalABCPlugins
|
|
{
|
|
public class HelpUtils
|
|
{
|
|
public static HelpBuilder builder;
|
|
|
|
public static string HTMLSpace = Convert.ToString(((char)0xA0));
|
|
|
|
public static string get_meth_name(ICommonNamespaceFunctionNode f)
|
|
{
|
|
return f.comprehensive_namespace.namespace_name + "." + f.name;
|
|
}
|
|
|
|
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 get_meth_name(MethodInfo f)
|
|
{
|
|
return HelpUtils.get_type_name(f.DeclaringType) + "." + (f.IsConstructor ? "Create" : f.Name);
|
|
}
|
|
|
|
public static string get_meth_name(ConstructorInfo f)
|
|
{
|
|
return HelpUtils.get_type_name(f.DeclaringType) + "." + "Create";
|
|
}
|
|
|
|
public static string get_type_name(ITypeSynonym t)
|
|
{
|
|
return builder.parser.main_ns.namespace_name+"."+t.name;
|
|
}
|
|
|
|
public static string get_type_name(ITypeNode t)
|
|
{
|
|
if (t is ICommonTypeNode)
|
|
{
|
|
return (t as ICommonTypeNode).comprehensive_namespace.namespace_name + "." + t.name;
|
|
}
|
|
else if (t is ICompiledTypeNode)
|
|
return (t as ICompiledTypeNode).name;
|
|
return t.name;
|
|
}
|
|
|
|
public static string get_type_name(Type t)
|
|
{
|
|
return t.Name;
|
|
//return get_compiled_type_text(t);
|
|
}
|
|
|
|
public static string get_var_name(ICommonNamespaceVariableNode v)
|
|
{
|
|
return v.comprehensive_namespace.namespace_name + "." + v.name;
|
|
}
|
|
|
|
public static string get_prop_name(ICommonPropertyNode p)
|
|
{
|
|
return get_type_name(p.comperehensive_type) + "." + p.name;
|
|
}
|
|
|
|
public static string get_prop_name(PropertyInfo p)
|
|
{
|
|
return get_type_name(p.DeclaringType) + "." + p.Name;
|
|
}
|
|
|
|
public static string get_const_name(INamespaceConstantDefinitionNode c)
|
|
{
|
|
return c.comprehensive_namespace.namespace_name + "." + c.name;
|
|
}
|
|
|
|
public static string get_const_name(IClassConstantDefinitionNode c)
|
|
{
|
|
return get_type_name(c.comperehensive_type) + "." + c.name;
|
|
}
|
|
|
|
public static string get_field_name(ICommonClassFieldNode f)
|
|
{
|
|
return get_type_name(f.comperehensive_type) + "." + f.name;
|
|
}
|
|
|
|
public static string get_field_name(FieldInfo f)
|
|
{
|
|
return get_type_name(f.DeclaringType) + "." + f.Name;
|
|
}
|
|
|
|
public static string get_event_name(ICommonEventNode e)
|
|
{
|
|
return get_type_name(e.comperehensive_type) + "." + e.Name;
|
|
}
|
|
|
|
public static string get_event_name(EventInfo e)
|
|
{
|
|
return get_type_name(e.DeclaringType) + "." + e.Name;
|
|
}
|
|
|
|
public static bool is_pascal_type(ITypeNode t)
|
|
{
|
|
return
|
|
t.type_special_kind == type_special_kind.set_type
|
|
|| t.type_special_kind == type_special_kind.short_string
|
|
|| t.type_special_kind == type_special_kind.typed_file
|
|
|| t.type_special_kind == type_special_kind.binary_file
|
|
|| t.type_special_kind == type_special_kind.diap_type && t.name.Contains("..");
|
|
}
|
|
|
|
public static bool can_show_members(ICommonTypeNode t)
|
|
{
|
|
switch (t.type_special_kind)
|
|
{
|
|
case type_special_kind.array_wrapper:
|
|
case type_special_kind.set_type:
|
|
case type_special_kind.typed_file:
|
|
case type_special_kind.text_file:
|
|
case type_special_kind.binary_file:
|
|
case type_special_kind.diap_type:
|
|
return false;
|
|
}
|
|
if (t.IsDelegate /*|| t.IsEnum*/)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
public static bool can_show_members(Type t)
|
|
{
|
|
if (t.BaseType == typeof(Delegate) || t.BaseType == typeof(MulticastDelegate))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
public static bool can_write(ICommonTypeNode t)
|
|
{
|
|
return !(string.IsNullOrEmpty(t.Documentation) && !builder.options.ShowNoCommentedElements || t.name.Contains("$")
|
|
|| is_pascal_type(t) || user_doc_disabled(t.Documentation));
|
|
}
|
|
|
|
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));
|
|
}
|
|
|
|
public static bool can_write(ICommonEventNode t)
|
|
{
|
|
return !(string.IsNullOrEmpty(t.Documentation) && !builder.options.ShowNoCommentedElements || t.Name.Contains("$")
|
|
|| user_doc_disabled(t.Documentation));
|
|
}
|
|
|
|
public static bool can_write(ICommonClassFieldNode t)
|
|
{
|
|
return !(string.IsNullOrEmpty(t.Documentation) && !builder.options.ShowNoCommentedElements || t.name.Contains("$")
|
|
|| user_doc_disabled(t.Documentation));
|
|
}
|
|
|
|
public static bool can_write(ICommonNamespaceVariableNode t)
|
|
{
|
|
return !(string.IsNullOrEmpty(t.Documentation) && !builder.options.ShowNoCommentedElements || t.name.Contains("$")
|
|
|| user_doc_disabled(t.Documentation));
|
|
}
|
|
|
|
public static bool can_write(ICommonParameterNode t)
|
|
{
|
|
return !(string.IsNullOrEmpty(t.Documentation) && !builder.options.ShowNoCommentedElements || t.name.Contains("$")
|
|
|| user_doc_disabled(t.Documentation));
|
|
}
|
|
|
|
public static bool can_write(INamespaceConstantDefinitionNode t)
|
|
{
|
|
return !(string.IsNullOrEmpty(t.Documentation) && !builder.options.ShowNoCommentedElements || t.name.Contains("$")
|
|
|| user_doc_disabled(t.Documentation));
|
|
}
|
|
|
|
public static bool can_write(ICommonPropertyNode t)
|
|
{
|
|
return !(string.IsNullOrEmpty(t.Documentation) && !builder.options.ShowNoCommentedElements || t.name.Contains("$")
|
|
|| user_doc_disabled(t.Documentation));
|
|
}
|
|
|
|
public static bool can_write(ICommonNamespaceFunctionNode t)
|
|
{
|
|
return !(string.IsNullOrEmpty(t.Documentation) && !builder.options.ShowNoCommentedElements || t.name.Contains("$")
|
|
|| user_doc_disabled(t.Documentation) || !Regex.Match(t.name,@"(\w)+", RegexOptions.ECMAScript).Success);
|
|
}
|
|
|
|
public static bool can_write(IClassConstantDefinitionNode t)
|
|
{
|
|
return !(string.IsNullOrEmpty(t.Documentation) && !builder.options.ShowNoCommentedElements || t.name.Contains("$")
|
|
|| user_doc_disabled(t.Documentation));
|
|
}
|
|
|
|
public static bool can_write(Type t)
|
|
{
|
|
if (!t.IsNested)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public static bool can_write(MethodInfo t)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public static bool can_write(FieldInfo t)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public static bool can_write(PropertyInfo t)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public static bool can_write(EventInfo t)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public static bool can_write(ConstructorInfo t)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
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 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_symbol(ICommonNamespaceFunctionNode f)
|
|
{
|
|
if (builder.parser.is_overload(f))
|
|
return "$"+builder.parser.GetMethodIndex(f);
|
|
return "";
|
|
}
|
|
|
|
public static string get_span_for_type(string name)
|
|
{
|
|
return "<span style=\"color=#0000ff;\">"+name+"</span>";
|
|
}
|
|
|
|
public static string get_compiled_type_text(Type ctn)
|
|
{
|
|
TypeCode tc = Type.GetTypeCode(ctn);
|
|
if (ctn.FullName == null && !ctn.IsArray && !ctn.IsGenericTypeDefinition && ctn.IsGenericParameter)
|
|
return get_span_for_type("T");
|
|
if (!ctn.IsEnum)
|
|
{
|
|
switch (tc)
|
|
{
|
|
case TypeCode.Int32 : return "integer";
|
|
case TypeCode.Double : return "real";
|
|
case TypeCode.Boolean : return "boolean";
|
|
case TypeCode.String : return "string";
|
|
case TypeCode.Char : return "char";
|
|
case TypeCode.Byte : return "byte";
|
|
case TypeCode.SByte : return "shortint";
|
|
case TypeCode.Int16 : return "smallint";
|
|
case TypeCode.Int64 : return "int64";
|
|
case TypeCode.UInt16 : return "word";
|
|
case TypeCode.UInt32 : return "longword";
|
|
case TypeCode.UInt64 : return "uint64";
|
|
case TypeCode.Single : return "single";
|
|
}
|
|
if (ctn.Name.Contains("`"))
|
|
{
|
|
int len = ctn.GetGenericArguments().Length;
|
|
Type[] gen_ps = ctn.GetGenericArguments();
|
|
System.Text.StringBuilder sb = new System.Text.StringBuilder();
|
|
sb.Append(ctn.Namespace+"."+ctn.Name.Substring(0,ctn.Name.IndexOf('`')));
|
|
sb.Append('<');
|
|
for (int i=0; i<len; i++)
|
|
{
|
|
sb.Append(gen_ps[i].Name);
|
|
if (i<len-1)
|
|
sb.Append(',');
|
|
}
|
|
sb.Append('>');
|
|
return sb.ToString();
|
|
}
|
|
if (ctn.IsPointer)
|
|
if (ctn.FullName == "System.Void*")
|
|
return "pointer";
|
|
else
|
|
return "^"+get_compiled_type_text(ctn.GetElementType());
|
|
if (ctn.IsArray)
|
|
return "array of "+get_compiled_type_text(ctn.GetElementType());
|
|
else
|
|
return ctn.Name;
|
|
}
|
|
return ctn.Name;
|
|
}
|
|
|
|
public static string get_compiled_type_html_text(Type ctn)
|
|
{
|
|
TypeCode tc = Type.GetTypeCode(ctn);
|
|
if (ctn.FullName == null && !ctn.IsArray && !ctn.IsGenericTypeDefinition && ctn.IsGenericParameter)
|
|
return get_span_for_type("T");
|
|
if (!ctn.IsEnum)
|
|
{
|
|
switch (tc)
|
|
{
|
|
case TypeCode.Int32 : return get_span_for_type("integer");
|
|
case TypeCode.Double : return get_span_for_type("real");
|
|
case TypeCode.Boolean : return get_span_for_type("boolean");
|
|
case TypeCode.String : return get_span_for_type("string");
|
|
case TypeCode.Char : return get_span_for_type("char");
|
|
case TypeCode.Byte : return get_span_for_type("byte");
|
|
case TypeCode.SByte : return get_span_for_type("shortint");
|
|
case TypeCode.Int16 : return get_span_for_type("smallint");
|
|
case TypeCode.Int64 : return get_span_for_type("int64");
|
|
case TypeCode.UInt16 : return get_span_for_type("word");
|
|
case TypeCode.UInt32 : return get_span_for_type("longword");
|
|
case TypeCode.UInt64 : return get_span_for_type("uint64");
|
|
case TypeCode.Single : return get_span_for_type("single");
|
|
}
|
|
if (ctn.Name.Contains("`"))
|
|
{
|
|
int len = ctn.GetGenericArguments().Length;
|
|
Type[] gen_ps = ctn.GetGenericArguments();
|
|
System.Text.StringBuilder sb = new System.Text.StringBuilder();
|
|
sb.Append(ctn.Namespace+"."+ctn.Name.Substring(0,ctn.Name.IndexOf('`')));
|
|
sb.Append('<');
|
|
for (int i=0; i<len; i++)
|
|
{
|
|
sb.Append(gen_ps[i].Name);
|
|
if (i<len-1)
|
|
sb.Append(',');
|
|
}
|
|
sb.Append('>');
|
|
return sb.ToString();
|
|
}
|
|
if (ctn.IsPointer)
|
|
if (ctn.FullName == "System.Void*")
|
|
return get_span_for_type("pointer");
|
|
else
|
|
return "^"+get_compiled_type_html_text(ctn.GetElementType());
|
|
if (ctn.IsArray)
|
|
return get_span_for_keyword("array")+" "+ get_span_for_keyword("of")+" "+get_compiled_type_html_text(ctn.GetElementType());
|
|
else
|
|
return "<a href=\"http://msdn.microsoft.com/ru-ru/library/"+ctn.FullName.ToLower()+"(en-us,VS.80).aspx\">"+ctn.Name+"</a>";
|
|
}
|
|
return "<a href=\"http://msdn.microsoft.com/ru-ru/library/"+ctn.FullName.ToLower()+"(en-us,VS.80).aspx\">"+ctn.Name+"</a>";
|
|
}
|
|
|
|
public static string get_type_text(ITypeNode t)
|
|
{
|
|
if (t is ICompiledTypeNode)
|
|
return get_compiled_type_text((t as ICompiledTypeNode).compiled_type);
|
|
else if (is_pascal_type(t) || t.name.Contains("$"))
|
|
return get_pascal_type(t,false);
|
|
return build_name_with_possible_generic(t,true);
|
|
}
|
|
|
|
private static string get_pascal_type(ITypeNode t, bool use_tags)
|
|
{
|
|
switch (t.type_special_kind)
|
|
{
|
|
case type_special_kind.array_kind : return get_dynamic_array_type(t,use_tags);
|
|
case type_special_kind.array_wrapper : return get_static_array_type(t,use_tags);
|
|
case type_special_kind.diap_type : return get_diap_type(t,use_tags);
|
|
case type_special_kind.binary_file :
|
|
if (use_tags)
|
|
return get_span_for_keyword("file");
|
|
else return "file";
|
|
case type_special_kind.set_type : return get_set_type(t,use_tags);
|
|
case type_special_kind.short_string : return get_short_string(t,use_tags);
|
|
case type_special_kind.typed_file : return get_typed_file(t,use_tags);
|
|
case type_special_kind.record :
|
|
if (use_tags)
|
|
return get_span_for_keyword("record");
|
|
else return "record";
|
|
}
|
|
if (t.IsEnum)
|
|
return get_enum(t,use_tags);
|
|
if (t.IsDelegate && t is ICommonTypeNode)
|
|
return get_delegate(t as ICommonTypeNode,use_tags);
|
|
return t.name;
|
|
}
|
|
|
|
public static string build_name_with_possible_generic(MethodInfo f, bool use_lt)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append(f.Name);
|
|
if (f.GetGenericArguments().Length > 0)
|
|
{
|
|
if (use_lt)
|
|
sb.Append("<");
|
|
else
|
|
sb.Append("<");
|
|
Type[] generic_params = f.GetGenericArguments();
|
|
for (int i = 0; i < generic_params.Length; i++)
|
|
{
|
|
sb.Append(generic_params[i].Name);
|
|
if (i < generic_params.Length - 1)
|
|
sb.Append(',');
|
|
}
|
|
if (use_lt)
|
|
sb.Append(">");
|
|
else sb.Append(">");
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string build_name_with_possible_generic(ICommonFunctionNode f, bool use_lt)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append(f.name);
|
|
if (f.generic_params != null)
|
|
{
|
|
if (use_lt)
|
|
sb.Append("<");
|
|
else
|
|
sb.Append("<");
|
|
for (int i = 0; i < f.generic_params.Count; i++)
|
|
{
|
|
sb.Append(f.generic_params[i].name);
|
|
if (i < f.generic_params.Count - 1)
|
|
sb.Append(',');
|
|
}
|
|
if (use_lt)
|
|
sb.Append(">");
|
|
else sb.Append(">");
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string build_name_with_possible_generic(ITypeNode t, bool use_lt)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
if (t.is_generic_type_definition)
|
|
{
|
|
ICommonTypeNode ctn = t as ICommonTypeNode;
|
|
sb.Append(ctn.name.Substring(0,ctn.name.IndexOf('`')));
|
|
if (use_lt)
|
|
sb.Append("<");
|
|
else
|
|
sb.Append("<");
|
|
for (int i=0; i<ctn.generic_params.Count; i++)
|
|
{
|
|
sb.Append(ctn.generic_params[i].name);
|
|
if (i<ctn.generic_params.Count-1)
|
|
sb.Append(',');
|
|
}
|
|
if (use_lt)
|
|
sb.Append(">");
|
|
else sb.Append(">");
|
|
}
|
|
else if (t.is_generic_type_instance)
|
|
{
|
|
IGenericTypeInstance ctn = t as IGenericTypeInstance;
|
|
sb.Append(ctn.name);
|
|
if (use_lt)
|
|
sb.Append("<");
|
|
else sb.Append("<");
|
|
for (int i=0; i<ctn.generic_parameters.Count; i++)
|
|
{
|
|
sb.Append(ctn.generic_parameters[i].name);
|
|
if (i<ctn.generic_parameters.Count-1)
|
|
sb.Append(',');
|
|
}
|
|
if (use_lt)
|
|
sb.Append(">");
|
|
else sb.Append(">");
|
|
}
|
|
else
|
|
sb.Append(t.name);
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string build_name_with_possible_generic(Type t, bool use_lt)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
if (t.IsGenericTypeDefinition)
|
|
{
|
|
int ind = t.Name.IndexOf('`');
|
|
sb.Append(t.Name.Substring(0, t.Name.IndexOf('`')));
|
|
if (use_lt)
|
|
sb.Append("<");
|
|
else
|
|
sb.Append("<");
|
|
for (int i = 0; i < t.GetGenericArguments().Length; i++)
|
|
{
|
|
sb.Append(t.GetGenericArguments()[i].Name);
|
|
if (i < t.GetGenericArguments().Length - 1)
|
|
sb.Append(',');
|
|
}
|
|
if (use_lt)
|
|
sb.Append(">");
|
|
else sb.Append(">");
|
|
}
|
|
else if (t.IsGenericType)
|
|
{
|
|
sb.Append(t.Name);
|
|
if (use_lt)
|
|
sb.Append("<");
|
|
else sb.Append("<");
|
|
for (int i = 0; i < t.GetGenericArguments().Length; i++)
|
|
{
|
|
sb.Append(t.GetGenericArguments()[i].Name);
|
|
if (i < t.GetGenericArguments().Length - 1)
|
|
sb.Append(',');
|
|
}
|
|
if (use_lt)
|
|
sb.Append(">");
|
|
else sb.Append(">");
|
|
}
|
|
else
|
|
sb.Append(t.Name);
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_type_html_text(ITypeNode t)
|
|
{
|
|
if (builder.parser.InTree(t))
|
|
{
|
|
if (!t.name.Contains("$"))
|
|
{
|
|
if (t is ICommonTypeNode && is_pascal_type(t))
|
|
return get_pascal_type(t,true);
|
|
else
|
|
return "<a href=\""+HelpUtils.get_type_name(t)+".html"+"\">"+build_name_with_possible_generic(t,true)+"</a>";
|
|
}
|
|
else
|
|
return get_pascal_type(t,true);
|
|
}
|
|
else if (t is ICompiledTypeNode)
|
|
return get_compiled_type_html_text((t as ICompiledTypeNode).compiled_type);
|
|
else
|
|
if (t is IShortStringTypeNode)
|
|
return get_short_string(t,true);
|
|
else
|
|
return get_span_for_type(build_name_with_possible_generic(t,true));
|
|
}
|
|
|
|
public static string get_type_html_text(Type t)
|
|
{
|
|
if (t.FullName == null)
|
|
return t.Name;
|
|
return get_compiled_type_html_text(t);
|
|
}
|
|
|
|
public static string get_const_value(IConstantNode c)
|
|
{
|
|
if (c is IIntConstantNode)
|
|
return (c as IIntConstantNode).constant_value.ToString();
|
|
else
|
|
if (c is IDoubleConstantNode)
|
|
return (c as IDoubleConstantNode).constant_value.ToString();
|
|
else if (c is IFloatConstantNode)
|
|
return (c as IFloatConstantNode).constant_value.ToString();
|
|
else
|
|
if (c is IStringConstantNode)
|
|
return "'"+(c as IStringConstantNode).constant_value.ToString()+"'";
|
|
else
|
|
if (c is ICharConstantNode)
|
|
return "'"+(c as ICharConstantNode).constant_value.ToString()+"'";
|
|
else
|
|
if (c is IByteConstantNode)
|
|
return (c as IByteConstantNode).constant_value.ToString();
|
|
else
|
|
if (c is ISByteConstantNode)
|
|
return (c as ISByteConstantNode).constant_value.ToString();
|
|
else
|
|
if (c is IShortConstantNode)
|
|
return (c as IShortConstantNode).constant_value.ToString();
|
|
else
|
|
if (c is IUShortConstantNode)
|
|
return (c as IUShortConstantNode).constant_value.ToString();
|
|
else
|
|
if (c is IUIntConstantNode)
|
|
return (c as IUIntConstantNode).constant_value.ToString();
|
|
else
|
|
if (c is ILongConstantNode)
|
|
return (c as ILongConstantNode).constant_value.ToString();
|
|
else
|
|
if (c is IULongConstantNode)
|
|
return (c as IULongConstantNode).constant_value.ToString();
|
|
else
|
|
if (c is IEnumConstNode)
|
|
return (c as IEnumConstNode).constant_value.ToString();
|
|
else
|
|
if (c is IArrayConstantNode)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
IArrayConstantNode arr = c as IArrayConstantNode;
|
|
sb.Append('(');
|
|
for (int i=0; i<arr.ElementValues.Length; i++)
|
|
{
|
|
sb.Append(get_const_value(arr.ElementValues[i]));
|
|
if (i<arr.ElementValues.Length-1)
|
|
sb.Append(", ");
|
|
}
|
|
sb.Append(')');
|
|
return sb.ToString();
|
|
}
|
|
else
|
|
if (c is IRecordConstantNode && c.type is ICommonTypeNode)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
IRecordConstantNode rec = c as IRecordConstantNode;
|
|
sb.Append('(');
|
|
ICommonTypeNode ctn = c.type as ICommonTypeNode;
|
|
ICommonClassFieldNode[] fields = builder.parser.GetDefinedFields(ctn);
|
|
for (int i=0; i<rec.FieldValues.Length; i++)
|
|
{
|
|
if (i<fields.Length)
|
|
sb.Append(fields[i].name+": ");
|
|
sb.Append(get_const_value(rec.FieldValues[i]));
|
|
if (i<rec.FieldValues.Length-1)
|
|
sb.Append(", ");
|
|
}
|
|
sb.Append(')');
|
|
return sb.ToString();
|
|
}
|
|
return "value";
|
|
}
|
|
|
|
public static string get_var_header(ICommonNamespaceVariableNode v)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append("<div>");
|
|
sb.Append(get_span_for_keyword("var")+" "+get_span_for_identifier(v.name)+": "+get_type_html_text(v.type));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_const_header(INamespaceConstantDefinitionNode c)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append("<div>");
|
|
sb.Append(get_span_for_keyword("const")+" "+get_span_for_identifier(c.name)+": "+get_type_html_text(c.type)+" = "+get_const_value(c.constant_value));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_span_for_keyword(string keyw)
|
|
{
|
|
return "<span class=\"keyword\">"+keyw+"</span>";
|
|
}
|
|
|
|
private static string get_enum(ITypeNode tt, bool use_tags)
|
|
{
|
|
ICommonTypeNode t = tt as ICommonTypeNode;
|
|
IClassConstantDefinitionNode[] consts = t.constants;
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append('(');
|
|
for (int i=0; i<consts.Length; i++)
|
|
{
|
|
sb.Append(consts[i].name);
|
|
if (i<consts.Length-1)
|
|
sb.Append(", ");
|
|
}
|
|
sb.Append(')');
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_enum(Type t, bool use_tags)
|
|
{
|
|
FieldInfo[] consts = t.GetFields();
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append('(');
|
|
for (int i = 0; i < consts.Length; i++)
|
|
{
|
|
sb.Append(consts[i].Name);
|
|
if (i < consts.Length - 1)
|
|
sb.Append(", ");
|
|
}
|
|
sb.Append(')');
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_delegate(ICommonTypeNode t, bool use_tags)
|
|
{
|
|
ICommonMethodNode f = builder.parser.GetMethods(t,"Invoke")[0];
|
|
StringBuilder sb = new StringBuilder();
|
|
if (f.return_value_type == null)
|
|
sb.Append(use_tags?get_span_for_keyword("procedure"):"procedure");
|
|
else
|
|
sb.Append(use_tags?get_span_for_keyword("function"):"function");
|
|
if (f.parameters.Length > 0)
|
|
{
|
|
sb.Append('(');
|
|
for (int i = 0; i < f.parameters.Length; i++)
|
|
{
|
|
IParameterNode prm = f.parameters[i];
|
|
if (prm.parameter_type == parameter_type.var)
|
|
sb.Append((use_tags ? get_span_for_keyword("var") : "var") + " ");
|
|
else if (prm.is_params)
|
|
sb.Append((use_tags ? get_span_for_keyword("params") : "params") + " ");
|
|
if (use_tags)
|
|
sb.Append(get_span_for_param(prm.name));
|
|
else
|
|
sb.Append(prm.name);
|
|
sb.Append(" : ");
|
|
if (use_tags)
|
|
sb.Append(get_type_html_text(prm.type));
|
|
else
|
|
sb.Append(get_type_text(prm.type));
|
|
if (i < f.parameters.Length - 1)
|
|
sb.Append("; ");
|
|
}
|
|
sb.Append(')');
|
|
}
|
|
|
|
if (f.return_value_type != null && !f.is_constructor)
|
|
sb.Append(": "+(use_tags?get_type_html_text(f.return_value_type):get_type_text(f.return_value_type)));
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_set_type(ITypeNode t, bool use_tags)
|
|
{
|
|
if (use_tags)
|
|
return get_span_for_keyword("set")+ " "+get_span_for_keyword("of")+" " + get_type_html_text(t.element_type);
|
|
else return "set of "+get_type_text(t.element_type);
|
|
}
|
|
|
|
private static string get_typed_file(ITypeNode t, bool use_tags)
|
|
{
|
|
if (use_tags)
|
|
return get_span_for_keyword("file") + " "+get_span_for_keyword("of")+" " + get_type_html_text(t.element_type);
|
|
else
|
|
return "file of "+get_type_text(t.element_type);
|
|
}
|
|
|
|
private static string get_short_string(ITypeNode t, bool use_tags)
|
|
{
|
|
return (use_tags?get_span_for_type("string"):"string")+ "["+ (t as IShortStringTypeNode).Length.ToString() + "]";
|
|
}
|
|
|
|
private static string get_static_array_type(ITypeNode t, bool use_tags)
|
|
{
|
|
ICommonTypeNode ctn = t as ICommonTypeNode;
|
|
IClassConstantDefinitionNode low_val = builder.parser.GetConstants(ctn,"LowerIndex")[0];
|
|
IClassConstantDefinitionNode upper_val = builder.parser.GetConstants(ctn,"UpperIndex")[0];
|
|
StringBuilder sb = new StringBuilder();
|
|
if (use_tags)
|
|
sb.Append(get_span_for_keyword("array"));
|
|
else sb.Append("array");
|
|
sb.Append('[');
|
|
sb.Append(get_const_value(low_val.constant_value));
|
|
sb.Append("..");
|
|
sb.Append(get_const_value(upper_val.constant_value));
|
|
sb.Append(']');
|
|
if (use_tags)
|
|
sb.Append(" "+get_span_for_keyword("of")+" ");
|
|
else sb.Append(" of ");
|
|
sb.Append(get_type_html_text(t.element_type));
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_dynamic_array_type(ITypeNode t, bool use_tags)
|
|
{
|
|
ICommonTypeNode ctn = t as ICommonTypeNode;
|
|
StringBuilder sb = new StringBuilder();
|
|
if (use_tags)
|
|
sb.Append(get_span_for_keyword("array")+" "+get_span_for_keyword("of")+" ");
|
|
else sb.Append("array of ");
|
|
sb.Append(get_type_html_text(t.element_type));
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_inherited_and_implement(ITypeNode t)
|
|
{
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
if (t.base_type != null && string.Compare(t.base_type.name,"object",true)!=0)
|
|
{
|
|
sb.Append('(');
|
|
sb.Append(get_type_html_text(t.base_type));
|
|
for (int i=0; i<t.ImplementingInterfaces.Count; i++)
|
|
{
|
|
sb.Append(", ");
|
|
sb.Append(get_type_html_text(t.ImplementingInterfaces[i]));
|
|
}
|
|
sb.Append(')');
|
|
}
|
|
else
|
|
{
|
|
if (t.ImplementingInterfaces.Count > 0)
|
|
{
|
|
sb.Append('(');
|
|
for (int i=0; i<t.ImplementingInterfaces.Count; i++)
|
|
{
|
|
sb.Append(get_type_html_text(t.ImplementingInterfaces[i]));
|
|
if (i<t.ImplementingInterfaces.Count-1)
|
|
sb.Append(", ");
|
|
}
|
|
sb.Append(')');
|
|
}
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_inherited_and_implement(Type t)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
Type[] interfaces = t.GetInterfaces();
|
|
if (t.BaseType != null && t.BaseType != typeof(object))
|
|
{
|
|
sb.Append('(');
|
|
sb.Append(get_type_html_text(t.BaseType));
|
|
|
|
for (int i = 0; i < interfaces.Length; i++)
|
|
{
|
|
sb.Append(", ");
|
|
sb.Append(get_type_html_text(interfaces[i]));
|
|
}
|
|
sb.Append(')');
|
|
}
|
|
else
|
|
{
|
|
if (interfaces.Length > 0)
|
|
{
|
|
sb.Append('(');
|
|
for (int i = 0; i < interfaces.Length; i++)
|
|
{
|
|
sb.Append(get_type_html_text(interfaces[i]));
|
|
if (i < interfaces.Length - 1)
|
|
sb.Append(", ");
|
|
}
|
|
sb.Append(')');
|
|
}
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_diap_type(ITypeNode t, bool use_tags)
|
|
{
|
|
ICommonTypeNode ctn = t as ICommonTypeNode;
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append(get_const_value(ctn.lower_value));
|
|
sb.Append("..");
|
|
sb.Append(get_const_value(ctn.upper_value));
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_type_header(ITypeSynonym t)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(t.Documentation);
|
|
if (!string.IsNullOrEmpty(hdr))
|
|
{
|
|
sb.Append("<div>"+hdr+"</div>");
|
|
return sb.ToString();
|
|
}
|
|
sb.Append("<div>");
|
|
sb.Append(get_span_for_keyword("type")+" "+get_span_for_identifier(t.name)+" = "+get_type_html_text(t.original_type));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_type_header(ICommonTypeNode t)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(t.Documentation);
|
|
if (!string.IsNullOrEmpty(hdr))
|
|
{
|
|
sb.Append("<div>"+hdr+"</div>");
|
|
return sb.ToString();
|
|
}
|
|
sb.Append("<div>");
|
|
sb.Append(get_span_for_keyword("type")+" "+get_span_for_identifier(HelpUtils.build_name_with_possible_generic(t,true))+" = ");
|
|
if (t.type_special_kind == type_special_kind.set_type)
|
|
sb.Append(get_set_type(t,true));
|
|
else
|
|
if (t.type_special_kind == type_special_kind.typed_file)
|
|
sb.Append(get_typed_file(t,true));
|
|
else
|
|
if (t.type_special_kind == type_special_kind.binary_file)
|
|
sb.Append(get_span_for_keyword("file"));
|
|
else
|
|
if (t.type_special_kind == type_special_kind.diap_type)
|
|
sb.Append(get_diap_type(t,true));
|
|
else if (t.type_special_kind == type_special_kind.array_wrapper)
|
|
sb.Append(get_static_array_type(t,true));
|
|
else
|
|
if (t.IsInterface)
|
|
sb.Append(get_span_for_keyword("interface"));
|
|
else if (t.is_class)
|
|
{
|
|
sb.Append(get_span_for_keyword("class"));
|
|
sb.Append(get_inherited_and_implement(t));
|
|
}
|
|
else if (t.IsEnum)
|
|
sb.Append(get_enum(t,true));
|
|
else if (t.IsDelegate)
|
|
sb.Append(get_delegate(t,true));
|
|
else if (t.is_value_type)
|
|
sb.Append(get_span_for_keyword("record"));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_type_header(Type t)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(GetDocumentation(t));
|
|
if (!string.IsNullOrEmpty(hdr))
|
|
{
|
|
sb.Append("<div>" + hdr + "</div>");
|
|
return sb.ToString();
|
|
}
|
|
sb.Append("<div>");
|
|
sb.Append(get_span_for_keyword("type") + " " + get_span_for_identifier(HelpUtils.build_name_with_possible_generic(t, true)) + " = ");
|
|
if (t.IsInterface)
|
|
sb.Append(get_span_for_keyword("interface"));
|
|
else if (t.IsClass)
|
|
{
|
|
sb.Append(get_span_for_keyword("class"));
|
|
sb.Append(get_inherited_and_implement(t));
|
|
}
|
|
else if (t.IsEnum)
|
|
sb.Append(get_enum(t, true));
|
|
/*else if (t.BaseType == typeof(Delegate) && t.BaseType == typeof(MulticastDelegate))
|
|
sb.Append(get_delegate(t, true));*/
|
|
else if (t.IsValueType)
|
|
sb.Append(get_span_for_keyword("record"));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_text_for_access_level(field_access_level fal)
|
|
{
|
|
switch(fal)
|
|
{
|
|
case field_access_level.fal_public : return "public";
|
|
case field_access_level.fal_protected : return "protected";
|
|
case field_access_level.fal_private : return "private";
|
|
case field_access_level.fal_internal : return "internal";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public static string get_text_for_access_level(Type t)
|
|
{
|
|
if (t.IsPublic)
|
|
return "public";
|
|
if (t.IsNotPublic)
|
|
return "private";
|
|
return "";
|
|
}
|
|
|
|
public static string get_text_for_access_level(MethodInfo t)
|
|
{
|
|
if (t.IsPublic)
|
|
return "public";
|
|
if (t.IsPrivate)
|
|
return "private";
|
|
if (t.IsFamily || t.IsFamilyOrAssembly)
|
|
return "protected";
|
|
if (t.IsAssembly || t.IsFamilyAndAssembly)
|
|
return "internal";
|
|
return "";
|
|
}
|
|
|
|
public static string get_text_for_access_level(FieldInfo t)
|
|
{
|
|
if (t.IsPublic)
|
|
return "public";
|
|
if (t.IsPrivate)
|
|
return "private";
|
|
if (t.IsFamily || t.IsFamilyOrAssembly)
|
|
return "protected";
|
|
if (t.IsAssembly || t.IsFamilyAndAssembly)
|
|
return "internal";
|
|
return "";
|
|
}
|
|
|
|
public static string get_text_for_access_level(PropertyInfo t)
|
|
{
|
|
MethodInfo mi = t.GetGetMethod(true);
|
|
if (mi != null)
|
|
{
|
|
if (mi.IsPublic)
|
|
return "public";
|
|
if (mi.IsPrivate)
|
|
return "private";
|
|
if (mi.IsFamily || mi.IsFamilyOrAssembly)
|
|
return "protected";
|
|
if (mi.IsAssembly || mi.IsFamilyAndAssembly)
|
|
return "internal";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public static string get_text_for_access_level(EventInfo t)
|
|
{
|
|
MethodInfo mi = t.GetAddMethod(true);
|
|
if (mi != null)
|
|
{
|
|
if (mi.IsPublic)
|
|
return "public";
|
|
if (mi.IsPrivate)
|
|
return "private";
|
|
if (mi.IsFamily || mi.IsFamilyOrAssembly)
|
|
return "protected";
|
|
if (mi.IsAssembly || mi.IsFamilyAndAssembly)
|
|
return "internal";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public static string get_field_header(ICommonClassFieldNode 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")+" ");
|
|
sb.Append(get_span_for_identifier(f.name));
|
|
sb.Append(" : "+get_type_html_text(f.type));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_field_header(FieldInfo f)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(GetDocumentation(f));
|
|
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)) + " ");
|
|
if (f.IsStatic)
|
|
sb.Append(get_span_for_keyword("class") + " ");
|
|
sb.Append(get_span_for_identifier(f.Name));
|
|
sb.Append(" : " + get_type_html_text(f.FieldType));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_event_header(ICommonEventNode 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")+" ");
|
|
sb.Append(get_span_for_keyword("event")+" ");
|
|
sb.Append(get_span_for_identifier(f.Name));
|
|
sb.Append(" : "+get_type_html_text(f.DelegateType));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_event_header(EventInfo f)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(GetDocumentation(f));
|
|
if (!string.IsNullOrEmpty(hdr))
|
|
{
|
|
sb.Append("<div>" + hdr + "</div>");
|
|
return sb.ToString();
|
|
}
|
|
sb.Append("<div>");
|
|
MethodInfo add_meth = f.GetAddMethod(true);
|
|
sb.Append(get_span_for_keyword(get_text_for_access_level(f)) + " ");
|
|
if (add_meth.IsStatic)
|
|
sb.Append(get_span_for_keyword("class") + " ");
|
|
sb.Append(get_span_for_keyword("event") + " ");
|
|
sb.Append(get_span_for_identifier(f.Name));
|
|
sb.Append(" : " + get_type_html_text(f.EventHandlerType));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_const_header(IClassConstantDefinitionNode c)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(c.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(c.field_access_level))+" ");
|
|
if (c.polymorphic_state == polymorphic_state.ps_static)
|
|
sb.Append(get_span_for_keyword("class")+" ");
|
|
sb.Append(get_span_for_keyword("const")+" "+get_span_for_identifier(c.name)+" : "+get_type_html_text(c.type)+" = "+get_const_value(c.constant_value));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_property_header(ICommonPropertyNode p)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(p.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(p.field_access_level))+" ");
|
|
if (p.polymorphic_state == polymorphic_state.ps_static)
|
|
sb.Append(get_span_for_keyword("class")+" ");
|
|
sb.Append(get_span_for_keyword("property")+" ");
|
|
sb.Append(get_span_for_identifier(p.name));
|
|
sb.Append(get_property_parameters(p.parameters));
|
|
sb.Append(" : "+get_type_html_text(p.property_type));
|
|
if (p.get_function != null)
|
|
sb.Append(" read");
|
|
if (p.set_function != null)
|
|
sb.Append(" write");
|
|
if (p.polymorphic_state == polymorphic_state.ps_virtual)
|
|
sb.Append("; "+get_span_for_keyword("virtual"));
|
|
else if (p.polymorphic_state == polymorphic_state.ps_virtual_abstract)
|
|
sb.Append("; "+get_span_for_keyword("abstract"));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_property_header(PropertyInfo p)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(GetDocumentation(p));
|
|
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(p)) + " ");
|
|
MethodInfo get_meth = p.GetGetMethod(true);
|
|
MethodInfo set_meth = p.GetSetMethod(true);
|
|
if (get_meth != null && get_meth.IsStatic || set_meth != null && set_meth.IsStatic)
|
|
sb.Append(get_span_for_keyword("class") + " ");
|
|
sb.Append(get_span_for_keyword("property") + " ");
|
|
sb.Append(get_span_for_identifier(p.Name));
|
|
sb.Append(get_property_parameters(p.GetIndexParameters()));
|
|
sb.Append(" : " + get_type_html_text(p.PropertyType));
|
|
if (get_meth != null && AssemblyHelpBuilder.is_not_private(get_meth))
|
|
sb.Append(" read");
|
|
if (set_meth != null && AssemblyHelpBuilder.is_not_private(set_meth))
|
|
sb.Append(" write");
|
|
if (get_meth != null && get_meth.IsVirtual)
|
|
sb.Append("; " + get_span_for_keyword("virtual"));
|
|
else if (get_meth != null && get_meth.IsAbstract)
|
|
sb.Append("; " + get_span_for_keyword("abstract"));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_func_header(ICommonNamespaceFunctionNode 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>");
|
|
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));
|
|
if (f.parameters.Length > 0)
|
|
{
|
|
sb.Append('(');
|
|
for (int i = 0; i < f.parameters.Length; i++)
|
|
{
|
|
IParameterNode prm = f.parameters[i];
|
|
if (prm.parameter_type == parameter_type.var)
|
|
sb.Append(get_span_for_keyword("var") + " ");
|
|
else if (prm.is_params)
|
|
sb.Append(get_span_for_keyword("params") + " ");
|
|
sb.Append(get_span_for_param(prm.name));
|
|
sb.Append(" : ");
|
|
sb.Append(get_type_html_text(prm.type));
|
|
if (i < f.parameters.Length - 1)
|
|
sb.Append("; ");
|
|
}
|
|
sb.Append(')');
|
|
}
|
|
if (f.return_value_type != null)
|
|
sb.Append(": "+get_type_html_text(f.return_value_type));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_simple_meth_header(ICommonFunctionNode f)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(f.Documentation);
|
|
if (!string.IsNullOrEmpty(hdr))
|
|
{
|
|
sb.Append(hdr);
|
|
return sb.ToString();
|
|
}
|
|
sb.Append(f.name);
|
|
sb.Append(get_generic_string(f.generic_params));
|
|
if (f.parameters.Length > 0)
|
|
{
|
|
sb.Append('(');
|
|
for (int i = 0; i < f.parameters.Length; i++)
|
|
{
|
|
sb.Append(get_type_text(f.parameters[i].type));
|
|
if (i < f.parameters.Length - 1)
|
|
sb.Append(", ");
|
|
}
|
|
sb.Append(')');
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_simple_meth_header(MethodInfo f)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(GetDocumentation(f));
|
|
if (!string.IsNullOrEmpty(hdr))
|
|
{
|
|
sb.Append(hdr);
|
|
return sb.ToString();
|
|
}
|
|
sb.Append(f.Name);
|
|
sb.Append(get_generic_string(f.GetGenericArguments()));
|
|
ParameterInfo[] parameters = f.GetParameters();
|
|
if (parameters.Length > 0)
|
|
{
|
|
sb.Append('(');
|
|
for (int i = 0; i < parameters.Length; i++)
|
|
{
|
|
sb.Append(get_compiled_type_text(parameters[i].ParameterType));
|
|
if (i < parameters.Length - 1)
|
|
sb.Append(", ");
|
|
}
|
|
sb.Append(')');
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string get_simple_meth_header(ConstructorInfo f)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(GetDocumentation(f));
|
|
if (!string.IsNullOrEmpty(hdr))
|
|
{
|
|
sb.Append(hdr);
|
|
return sb.ToString();
|
|
}
|
|
sb.Append("Create");
|
|
ParameterInfo[] parameters = f.GetParameters();
|
|
if (parameters.Length > 0)
|
|
{
|
|
sb.Append('(');
|
|
for (int i = 0; i < parameters.Length; i++)
|
|
{
|
|
sb.Append(get_compiled_type_text(parameters[i].ParameterType));
|
|
if (i < parameters.Length - 1)
|
|
sb.Append(", ");
|
|
}
|
|
sb.Append(')');
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_generic_string(List<ICommonTypeNode> generics)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
if (generics != null && generics.Count > 0)
|
|
{
|
|
sb.Append("<");
|
|
for (int i=0; i<generics.Count; i++)
|
|
{
|
|
sb.Append(generics[i].name);
|
|
if (i<generics.Count-1)
|
|
sb.Append(',');
|
|
}
|
|
sb.Append(">");
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_generic_string(Type[] generics)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
if (generics != null && generics.Length > 0)
|
|
{
|
|
sb.Append("<");
|
|
for (int i = 0; i < generics.Length; i++)
|
|
{
|
|
sb.Append(generics[i].Name);
|
|
if (i < generics.Length - 1)
|
|
sb.Append(',');
|
|
}
|
|
sb.Append(">");
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_property_parameters(IParameterNode[] prms)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
if (prms.Length > 0)
|
|
{
|
|
sb.Append('[');
|
|
for (int i=0; i<prms.Length; i++)
|
|
{
|
|
IParameterNode prm = prms[i];
|
|
if (prm.parameter_type == parameter_type.var)
|
|
sb.Append(get_span_for_keyword("var")+" ");
|
|
else if (prm.is_params)
|
|
sb.Append(get_span_for_keyword("params")+" ");
|
|
sb.Append(get_span_for_param(prm.name));
|
|
sb.Append(" : ");
|
|
sb.Append(get_type_html_text(prm.type));
|
|
if (i<prms.Length-1)
|
|
sb.Append("; ");
|
|
}
|
|
sb.Append(']');
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_property_parameters(ParameterInfo[] prms)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
if (prms.Length > 0)
|
|
{
|
|
sb.Append('[');
|
|
for (int i = 0; i < prms.Length; i++)
|
|
{
|
|
ParameterInfo prm = prms[i];
|
|
if (prm.ParameterType.IsByRef)
|
|
sb.Append(get_span_for_keyword("var") + " ");
|
|
else if (PascalABCCompiler.NetHelper.NetHelper.IsParamsParameter(prm))
|
|
sb.Append(get_span_for_keyword("params") + " ");
|
|
sb.Append(get_span_for_param(prm.Name));
|
|
sb.Append(" : ");
|
|
sb.Append(get_type_html_text(prm.ParameterType));
|
|
if (i < prms.Length - 1)
|
|
sb.Append("; ");
|
|
}
|
|
sb.Append(']');
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_parameters(IParameterNode[] prms)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
if (prms.Length > 0)
|
|
{
|
|
sb.Append('(');
|
|
for (int i=0; i<prms.Length; i++)
|
|
{
|
|
IParameterNode prm = prms[i];
|
|
if (prm.parameter_type == parameter_type.var)
|
|
sb.Append(get_span_for_keyword("var")+" ");
|
|
else if (prm.is_params)
|
|
sb.Append(get_span_for_keyword("params")+" ");
|
|
sb.Append(get_span_for_param(prm.name));
|
|
sb.Append(" : ");
|
|
sb.Append(get_type_html_text(prm.type));
|
|
if (i<prms.Length-1)
|
|
sb.Append("; ");
|
|
}
|
|
sb.Append(')');
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static string get_parameters(ParameterInfo[] prms)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
if (prms.Length > 0)
|
|
{
|
|
sb.Append('(');
|
|
for (int i = 0; i < prms.Length; i++)
|
|
{
|
|
ParameterInfo prm = prms[i];
|
|
if (prm.ParameterType.IsByRef)
|
|
sb.Append(get_span_for_keyword("var") + " ");
|
|
else if (PascalABCCompiler.NetHelper.NetHelper.IsParamsParameter(prm))
|
|
sb.Append(get_span_for_keyword("params") + " ");
|
|
sb.Append(get_span_for_param(prm.Name));
|
|
sb.Append(" : ");
|
|
sb.Append(get_type_html_text(prm.ParameterType));
|
|
if (i < prms.Length - 1)
|
|
sb.Append("; ");
|
|
}
|
|
sb.Append(')');
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
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();
|
|
}
|
|
|
|
public static string get_meth_header(MethodInfo f)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string hdr = HelpUtils.extract_user_defined_header(GetDocumentation(f));
|
|
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)) + " ");
|
|
if (f.IsStatic)
|
|
sb.Append(get_span_for_keyword("class") + " ");
|
|
if (f.IsConstructor)
|
|
sb.Append(get_span_for_keyword("constructor") + " ");
|
|
else
|
|
if (f.ReturnType == typeof(void))
|
|
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.GetGenericArguments()));
|
|
sb.Append(get_parameters(f.GetParameters()));
|
|
if (f.ReturnType != typeof(void) && !f.IsConstructor)
|
|
sb.Append(": " + get_type_html_text(f.ReturnType));
|
|
if (f.IsVirtual)
|
|
if (!is_override(f))
|
|
sb.Append("; " + get_span_for_keyword("virtual"));
|
|
else
|
|
sb.Append("; " + get_span_for_keyword("override"));
|
|
else if (f.IsAbstract && !f.DeclaringType.IsInterface)
|
|
sb.Append("; " + get_span_for_keyword("abstract"));
|
|
sb.Append("</div>");
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static bool is_override(MethodInfo mi)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public static string get_localization(string name)
|
|
{
|
|
return PascalABCCompiler.StringResources.Get(HelpBuilder_VisualPascalABCPlugin.StringsPrefix+name);
|
|
}
|
|
|
|
public static string get_return_value_description(string doc)
|
|
{
|
|
string s = null;
|
|
if (doc == null)
|
|
return null;
|
|
int ind = doc.IndexOf("<returns>");
|
|
if (ind == -1)
|
|
return null;
|
|
int end_ind = doc.IndexOf("</returns>",ind);
|
|
if (ind != -1)
|
|
{
|
|
if (end_ind != -1)
|
|
s = doc.Substring(ind+9,end_ind-ind-9).Trim(' ','\n','\t');
|
|
else
|
|
s = doc.Substring(ind+10).Trim(' ','\n','\t');
|
|
}
|
|
return s;
|
|
}
|
|
|
|
public static List<NameInfo> get_parameters(string doc)
|
|
{
|
|
List<NameInfo> lst = new List<NameInfo>();
|
|
if (doc == null)
|
|
return lst;
|
|
int ind = doc.IndexOf("<param");
|
|
|
|
while (ind != -1)
|
|
{
|
|
ind = doc.IndexOf("\"",ind);
|
|
if (ind == -1)
|
|
return lst;
|
|
int end_ind = doc.IndexOf("\"",ind+1);
|
|
if (end_ind == -1)
|
|
return lst;
|
|
string name = doc.Substring(ind+1,end_ind-ind-1).Trim(' ','\n','\t');
|
|
ind = doc.IndexOf(">",end_ind);
|
|
if (ind == -1)
|
|
return lst;
|
|
end_ind = doc.IndexOf("</param>",ind);
|
|
if (end_ind == -1)
|
|
return lst;
|
|
string desc = doc.Substring(ind+1,end_ind-ind-1).Trim(' ','\n','\t');
|
|
ind = doc.IndexOf("<param",end_ind);
|
|
lst.Add(new NameInfo(name,desc));
|
|
}
|
|
return lst;
|
|
}
|
|
|
|
private static bool user_doc_disabled(string doc)
|
|
{
|
|
if (doc == null) return false;
|
|
if (doc.Length >= 2 && doc[0] == '-' && doc[1] == '-')
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public static string extract_user_defined_header(string doc)
|
|
{
|
|
if (doc == null) return null;
|
|
if (doc.Length >= 2 && doc[0] == '-' && doc[1] != '-')
|
|
{
|
|
int ind = doc.IndexOf("<summary>");
|
|
if (ind != -1)
|
|
return doc.Substring(1,ind-1).Trim(' ','\t','\n');
|
|
ind = doc.IndexOf('\n');
|
|
if (ind != -1)
|
|
return doc.Substring(1,ind-1);
|
|
return null;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static string get_summary(string doc)
|
|
{
|
|
if (doc == null) return Convert.ToString(((char)0xA0));
|
|
string res = doc;
|
|
int ind = doc.IndexOf("<summary>");
|
|
if (ind != -1)
|
|
{
|
|
int end_ind = doc.IndexOf("</summary>");
|
|
if (end_ind != -1)
|
|
res = doc.Substring(ind+9,end_ind-ind-9).Trim(' ','\t','\n');
|
|
else
|
|
res = doc.Substring(ind+9).Trim(' ','\t','\n');
|
|
}
|
|
else if (doc.Length >= 1 && doc[0] == '-')
|
|
{
|
|
ind = doc.IndexOf('\n');
|
|
if (ind != -1 && ind+1 < doc.Length)
|
|
res = doc.Substring(ind+1);
|
|
else
|
|
res = "";
|
|
}
|
|
res = Regex.Replace(res,"<see(\\s)*cref(\\s)*=(\\s)*\"(?<type_name>[\\w\\.]+)\"(\\s)*/>(?<text>(.)*)</see>","<a href=\"${type_name}.html\"/>${text}</a>");
|
|
return res;
|
|
}
|
|
|
|
public static string get_example(string doc)
|
|
{
|
|
if (doc == null) return null;
|
|
string res = null;
|
|
int ind = doc.IndexOf("<example>");
|
|
if (ind != -1)
|
|
{
|
|
int end_ind = doc.IndexOf("</example>");
|
|
if (end_ind != -1)
|
|
res = doc.Substring(ind+9,end_ind-ind-9).Trim(' ','\t','\n');
|
|
else
|
|
res = doc.Substring(ind+9).Trim(' ','\t','\n');
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public static string get_example_comment(string doc)
|
|
{
|
|
int ind = doc.IndexOf("<code>");
|
|
if (ind != -1)
|
|
{
|
|
return doc.Substring(0,ind).Trim(' ','\n','\t');
|
|
}
|
|
else
|
|
return doc;
|
|
}
|
|
|
|
public static string get_example_code(string doc)
|
|
{
|
|
int ind = doc.IndexOf("<code>");
|
|
if (ind != -1)
|
|
{
|
|
int end_ind = doc.IndexOf("</code>",ind);
|
|
if (end_ind != -1)
|
|
return doc.Substring(ind+6,end_ind-ind-6).Trim(' ','\n','\t');
|
|
else
|
|
return doc.Substring(ind+6).Trim(' ','\n','\t');
|
|
}
|
|
else
|
|
return null;
|
|
}
|
|
|
|
private static string get_span_for_identifier(string s)
|
|
{
|
|
return "<span class=\"ident\">"+s+"</span>";
|
|
}
|
|
|
|
private static string get_span_for_param(string s)
|
|
{
|
|
return "<span class=\"paramname\">"+s+"</span>";
|
|
}
|
|
|
|
public static string GetDocumentation(Type t)
|
|
{
|
|
return CodeCompletion.AssemblyDocCache.GetFullDocumentation(t);
|
|
}
|
|
|
|
public static string GetDocumentation(MethodInfo t)
|
|
{
|
|
return CodeCompletion.AssemblyDocCache.GetFullDocumentation(t);
|
|
}
|
|
|
|
public static string GetDocumentation(ConstructorInfo t)
|
|
{
|
|
return CodeCompletion.AssemblyDocCache.GetFullDocumentation(t);
|
|
}
|
|
|
|
public static string GetDocumentation(PropertyInfo t)
|
|
{
|
|
return CodeCompletion.AssemblyDocCache.GetFullDocumentation(t);
|
|
}
|
|
|
|
public static string GetDocumentation(FieldInfo t)
|
|
{
|
|
return CodeCompletion.AssemblyDocCache.GetFullDocumentation(t);
|
|
}
|
|
|
|
public static string GetDocumentation(EventInfo t)
|
|
{
|
|
return CodeCompletion.AssemblyDocCache.GetFullDocumentation(t);
|
|
}
|
|
}
|
|
}
|
|
|