public bool is_overload(ICommonNamespaceFunctionNode func)
{
int count = 1;
if (func.comprehensive_namespace != null)
{
foreach (ICommonNamespaceFunctionNode f in func.comprehensive_namespace.functions)
{
if (string.Compare(f.name, func.name, true) == 0 && f != func)
{
count++;
}
}
}
return(count > 1);
}
public int GetMethodIndex(ICommonNamespaceFunctionNode cmn)
{
if (cmn.comprehensive_namespace != null)
{
ICommonNamespaceFunctionNode[] meths = cmn.comprehensive_namespace.functions;
int i = 1;
foreach (ICommonNamespaceFunctionNode m in meths)
{
if (m == cmn)
{
return(i);
}
else if (m.name == cmn.name)
{
i++;
}
}
}
return(1);
}
public virtual void visit(ICommonNamespaceFunctionNode value)
{
}
//перевод заголовков функций
private void ConvertFunctionHeaders(ICommonNamespaceFunctionNode[] funcs)
{
for (int i = 0; i < funcs.Length; i++)
{
IStatementsListNode sl = (IStatementsListNode)funcs[i].function_code;
IStatementNode[] statements = sl.statements;
if (statements.Length > 0 && statements[0] is IExternalStatementNode)
{
//функция импортируется из dll
ICommonNamespaceFunctionNode func = funcs[i];
Type ret_type = null;
//получаем тип возвр. значения
if (func.return_value_type == null)
ret_type = null;//typeof(void);
else
ret_type = helper.GetTypeReference(funcs[i].return_value_type).tp;
Type[] param_types = GetParamTypes(funcs[i]);//получаем параметры процедуры
IExternalStatementNode esn = (IExternalStatementNode)statements[0];
string module_name = Tools.ReplaceAllKeys(esn.module_name, StandartDirectories);
MethodBuilder methb = cur_type.DefinePInvokeMethod(func.name, module_name, esn.name,
MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.PinvokeImpl | MethodAttributes.HideBySig,
CallingConventions.Standard, ret_type, param_types, CallingConvention.Winapi,
CharSet.Ansi);//определяем PInvoke-метод
methb.SetImplementationFlags(MethodImplAttributes.PreserveSig);
//MethodBuilder methb = cur_type.DefinePInvokeMethod(func.name, esn.module_name, esn.name,
//MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.PinvokeImpl ,
//CallingConventions.Standard, ret_type, param_types, CallingConvention.Winapi,
//CharSet.None);//определяем PInvoke-метод
helper.AddMethod(funcs[i], methb);
IParameterNode[] parameters = funcs[i].parameters;
//определяем параметры с указанием имени
for (int j = 0; j < parameters.Length; j++)
{
ParameterAttributes pars = ParameterAttributes.None;
//if (func.parameters[j].parameter_type == parameter_type.var)
// pars = ParameterAttributes.Out;
methb.DefineParameter(j + 1, pars, parameters[j].name);
}
}
else
if (statements.Length > 0 && statements[0] is IPInvokeStatementNode)
{
//функция импортируется из dll
ICommonNamespaceFunctionNode func = funcs[i];
Type ret_type = null;
//получаем тип возвр. значения
if (func.return_value_type == null)
ret_type = null;//typeof(void);
else
ret_type = helper.GetTypeReference(funcs[i].return_value_type).tp;
Type[] param_types = GetParamTypes(funcs[i]);//получаем параметры процедуры
MethodBuilder methb = cur_type.DefineMethod(func.name, MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.PinvokeImpl | MethodAttributes.HideBySig, ret_type, param_types);//определяем PInvoke-метод
methb.SetImplementationFlags(MethodImplAttributes.PreserveSig);
//MethodBuilder methb = cur_type.DefinePInvokeMethod(func.name, esn.module_name, esn.name,
//MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.PinvokeImpl ,
//CallingConventions.Standard, ret_type, param_types, CallingConvention.Winapi,
//CharSet.None);//определяем PInvoke-метод
helper.AddMethod(funcs[i], methb);
IParameterNode[] parameters = funcs[i].parameters;
//определяем параметры с указанием имени
for (int j = 0; j < parameters.Length; j++)
{
ParameterAttributes pars = ParameterAttributes.None;
//if (func.parameters[j].parameter_type == parameter_type.var)
// pars = ParameterAttributes.Out;
methb.DefineParameter(j + 1, pars, parameters[j].name);
}
}
else
ConvertFunctionHeader(funcs[i]);
}
//(ssyy) 21.05.2008
foreach (ICommonNamespaceFunctionNode ifn in funcs)
{
if (ifn.is_generic_function)
{
ConvertTypeInstancesMembersInFunction(ifn);
}
}
}
public List <ICommonNamespaceFunctionNode> GetOverloadsList(ICommonNamespaceNode ns, ICommonNamespaceFunctionNode f)
{
List <ICommonNamespaceFunctionNode> lst = new List <ICommonNamespaceFunctionNode>();
foreach (ICommonNamespaceFunctionNode m in ns.functions)
{
if (string.Compare(m.name, f.name, true) == 0)
{
lst.Add(m);
}
}
return(lst);
}
public virtual void visit(ICommonNamespaceFunctionNode value)
{
}
public void visit(ICommonNamespaceFunctionNode value)
{
string s = value.GetType().Name + ".";
prepare_string_node(value.name, s + "name");
//if (value.comprehensive_namespace != null)
//{
// prepare_up_link_node(value.comprehensive_namespace.namespace_name.ToString(), s + "comprehensive_namespace", value.comprehensive_namespace);
// myTreeNode from = treeView.SelectedNode.Nodes[treeView.SelectedNode.Nodes.Count - 1] as myTreeNode;
// myTreeNode to = table_subnodes[value.comprehensive_namespace] as myTreeNode;
// table_for_up_links.Add(from, to);
//}
prepare_base_node_collection(value.constants, s + "constants", "constants", value.constants.Length);
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_node(value.namespace_node, s + "namespace_node");
////prepare_up_link_node(value.namespace_node.namespace_name, s + "namespace_node", value.namespace_node);
prepare_string_node(value.node_kind.ToString(), s + "node_kind");
prepare_string_node(value.node_location_kind.ToString(), s + "node_location_kind");
prepare_base_node_collection(value.parameters, s + "parametrs", "parametrs", value.parameters.Length);
prepare_node(value.return_value_type, s + "return_value_type");
prepare_node(value.return_variable, s + "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 void visit(ICommonNamespaceFunctionNode value)
{
StringBuilder bodyBlock = new StringBuilder("");
StringBuilder parameters = new StringBuilder("");
// увеличиваем отступ тела блока перед входом в блок
// тело функции
if (value.var_definition_nodes.Length != 0)
ISemanticNodeConverter.SourceTextBuilder.TextFormatter.Indents.BlockBodyIncrement();
foreach (ILocalVariableNode nodeVariable in value.var_definition_nodes)
{
nodeVariable.visit(this);
bodyBlock.Append(ISemanticNodeConverter.SourceTextBuilder.TextFormatter.Indents.BlockBody);
bodyBlock.Append(ISemanticNodeConverter.SourceTextBuilder.GetNodeFromStack());
bodyBlock.Append(";");
bodyBlock.Append(System.Environment.NewLine);
//bodyBlock.Append(ISemanticNodeConverter.SourceTextBuilder.TextFormatter.Indents.BlockBody);
}
// если блок не пуст - уменьшаем отступ
if (bodyBlock.ToString() != "")
{
//ISemanticNodeConverter.SourceTextBuilder.AddNodeInToStack(bodyBlock.ToString());
ISemanticNodeConverter.SourceTextBuilder.TextFormatter.Indents.BlockBodyDecrement();
}
value.function_code.visit(this);
// на стеке лежит тело функции
//
string funcbody = ISemanticNodeConverter.SourceTextBuilder.GetNodeFromStack();
bodyBlock.Append(funcbody);
if (funcbody == "")
ISemanticNodeConverter.SourceTextBuilder.AddNodeInToStack("%empty%");
else
{
funcbody += System.Environment.NewLine;
ISemanticNodeConverter.SourceTextBuilder.AddNodeInToStack(funcbody);
}
foreach (IParameterNode nodeParameter in value.parameters)
{
nodeParameter.visit(this);
parameters.Append(ISemanticNodeConverter.SourceTextBuilder.GetNodeFromStack());
if (value.parameters[value.parameters.Length-1] != nodeParameter)
parameters.Append(", ");
}
// кладем на стек тело функции
ISemanticNodeConverter.SourceTextBuilder.AddNodeInToStack(bodyBlock.ToString());
// кладем на стек параметры ф-ции
if (parameters.Length == 0)
parameters.Append("%empty%");
ISemanticNodeConverter.SourceTextBuilder.AddNodeInToStack(parameters.ToString());
ISemanticNodeConverter.SourceTextBuilder.AddNodeInToStack(ISemanticNodeConverter.ConvertPABCNETNodeFunction("function", value));
}
public static string possible_overload_symbol(ICommonNamespaceFunctionNode f)
{
if (builder.parser.is_overload(f))
return "$"+builder.parser.GetMethodIndex(f);
return "";
}
public static string get_meth_name(ICommonNamespaceFunctionNode f)
{
return f.comprehensive_namespace.namespace_name + "." + f.name;
}
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 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();
}
