From 1fee23186626746cbbf1b29a1790afb82012eeee Mon Sep 17 00:00:00 2001 From: totoro Date: Wed, 25 Jan 2017 17:28:26 +0100 Subject: [PATCH] add the generation of messages collections --- .gitmodules | 3 +++ calexium_lib | 1 + densaku.aproj | 130 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- densaku_lib | 2 +- src/generation/files.anubis | 17 +++++++++-------- src/generation/message_header.anubis | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/generation/message_messages.anubis | 224 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/generation/messages.anubis | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/generation/types_header.anubis | 2 +- src/generation/types_messages.anubis | 59 +++++++++++++++++++++++++++++++---------------------------- src/main.anubis | 20 +++++++++++++++++++- 11 files changed, 526 insertions(+), 40 deletions(-) create mode 160000 calexium_lib create mode 100644 src/generation/message_header.anubis create mode 100644 src/generation/message_messages.anubis create mode 100644 src/generation/messages.anubis diff --git a/.gitmodules b/.gitmodules index 715cee1..a617799 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,6 @@ [submodule "densaku_lib"] path = densaku_lib url = git@gitlab.anubis-language.com:totoro/densaku_lib.git +[submodule "calexium_lib"] + path = calexium_lib + url = ssh://git@gitlab.calexium.com:33022/calexium/calexium_lib.git diff --git a/calexium_lib b/calexium_lib new file mode 160000 index 0000000..a3acb34 --- /dev/null +++ b/calexium_lib @@ -0,0 +1 @@ +Subproject commit a3acb343c746388ec4fb76fceabc1f22e9f3c37d diff --git a/densaku.aproj b/densaku.aproj index 51e6f59..2aae46e 100644 --- a/densaku.aproj +++ b/densaku.aproj @@ -5,7 +5,7 @@ AnyCPU Exe takaden - takaden + densaku src\main.anubis False False @@ -27,6 +27,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + @@ -76,6 +101,100 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -440,11 +559,20 @@ + + + + + + + + + diff --git a/densaku_lib b/densaku_lib index 7e96578..5c7cd86 160000 --- a/densaku_lib +++ b/densaku_lib @@ -1 +1 @@ -Subproject commit 7e96578325b591652558fe6bdc0364f830f186e3 +Subproject commit 5c7cd864b6cc8232c2e719fe3a1e3740288cc0e2 diff --git a/src/generation/files.anubis b/src/generation/files.anubis index 15f86c4..8bc4b1b 100644 --- a/src/generation/files.anubis +++ b/src/generation/files.anubis @@ -10,27 +10,28 @@ read densaku_lib/types/densaku.anubis read densaku_lib/ds_generator.anubis read tools/basis.anubis read types_checking.anubis -read generation/types.anubis +read generation/types.anubis //generate all types and the message for these types +read generation/messages.anubis //generate all messages collection public define Maybe(One) generate_message_files ( List(DS_Type) types, //Types description -// DS_Messages messages, - String destination_dir + List(DS_Message) messages, + String destination_dir )= if check_types(types) is { failure then failure, success(_) then - //since _types is hk_database(name, apps), + println("Generating types and message files"); make_all_types(types, destination_dir); - //make_vtm(apps, destination_dir); - //if generate_create_table(apps, destination_dir) is failure then println("failure");failure else - //println("Generating message collection"); - //if generate_menus(apps, destination_dir) is failure then println("failure");failure else + + println("Generating messages collection"); + make_all_messages(messages, destination_dir); + success(unique) }. diff --git a/src/generation/message_header.anubis b/src/generation/message_header.anubis new file mode 100644 index 0000000..175c340 --- /dev/null +++ b/src/generation/message_header.anubis @@ -0,0 +1,50 @@ +/* + * Created by PyramIDE. + * User: フランスのトトロ aka (David RENÉ) + * Date: 23/01/2017 + * Time: 22:37 + * © Calexium + */ + +read tools/basis.anubis +read tools/streams.anubis +read tools/ISO-8601.anubis +read system/string.anubis +read densaku_lib/types/ds_types.anubis +read densaku_lib/types/ds_message.anubis + + +public define String + insert_read_foreign_type + ( + DS_Message ds_message //type description + )= + with foreign_type_list = get_all_extern_type(ds_message), + join("", map((Extern_type ext_type) |-> since ext_type is extern(_, read_file), "read "+read_file+"\n", foreign_type_list)) +. + +public define Maybe(One) + generate_message_header + ( + Stream stream, + DS_Message ds_message //type description + )= + write_string(stream, +"/* + * Created by 伝作 (Densaku) + * Types & Messages generator written by フランスのトトロ aka (David RENÉ) + * Date: "+_Int_to_ISO_8601_date(now)+" + * Time: "+_Int_to_ISO_8601_time(now)+" + * + */ + +transmit system/muscle.anubis +transmit system/convert.anubis +transmit tools/basis.anubis + +" + + insert_read_foreign_type(ds_message)+ +"\n" + ) + . + diff --git a/src/generation/message_messages.anubis b/src/generation/message_messages.anubis new file mode 100644 index 0000000..936e7b5 --- /dev/null +++ b/src/generation/message_messages.anubis @@ -0,0 +1,224 @@ +/* + * Created by PyramIDE. + * User: フランスのトトロ aka (David RENÉ) + * Date: 23/01/2017 + * Time: 23:00 + * © Calexium + */ + +read tools/basis.anubis +read tools/streams.anubis +read tools/ISO-8601.anubis +read system/string.anubis +read densaku_lib/types/ds_message.anubis +read types_messages.anubis + +public define Maybe(One) + generate_message_message_description + ( + Stream stream, + DS_Message ds_message //type description + )= + since ds_message is ds_message(message_name, _, fields), + with title = message_name+" message format", + write_string(stream, +"\n"+ +" "+title+"\n"+ +" "+fill(length(title), '=')+"\n\n"+ +// insert_type_message_description(ds_type)+ +"\n" + ) +. + + public define String + anb_type_to_message + ( + String type_msg, + DS_Anubis_Type anb_type, + String name + )= + with arg_name = "_"+to_lower(name), + if anb_type is + { + one then + "add_string("+type_msg+", \""+name+"\", "+arg_name+")", + bool then + "add_bool("+type_msg+", \""+name+"\", "+arg_name+")", + int then + "add_string("+type_msg+", \""+name+"\", to_String("+arg_name+"))", + string then + "add_string("+type_msg+", \""+name+"\", "+arg_name+")", + float then + "add_float("+type_msg+", \""+name+"\", "+arg_name+")", + ds_type(type_name) then + "add_message("+type_msg+", \""+name+"\", to_Message("+arg_name+"))", + extern_type(type_name, _) then //external type. No need to check + "add_message("+type_msg+", \""+name+"\", to_Message("+arg_name+"))", + } +. + +define String + generate_fields_to_message + ( + String indent, + String message_msg, + List(DS_Field) fields + )= + if fields is + { + [] then "\n", + [h . t] then + since h is field(field_name, b_list, anb_type, comment), + with name = to_lower(field_name), + indent +"// [type = "+(if b_list is list then "List(" else "")+dump(anb_type)+(if b_list is list then ")" else "")+"] "+name+"\n"+ + (if b_list is list then + indent +"map_forget(("+dump(anb_type)+ " _"+name+") |-> "+anb_type_to_message(message_msg, anb_type, field_name, name)+", __"+name+")" + else + indent +"forget("+anb_type_to_message(message_msg, anb_type, field_name, name)+")") + + ";\n" + + generate_fields_to_message(indent, message_msg, t) + } +. + +define String + argument_list_from_fields + ( + String indent, + List(DS_Field) fields + )= + if fields is + { + [] then "", + [h . t] then + since h is field(name, b_list, anb_type, comment), + indent+(if b_list is list then "List(" else "")+dump(anb_type)+(if b_list is list then ")" else "")+" _"+to_lower(name)+ + (if is_empty(t) then "" else ",")+ + (if comment is comment(comment_str) then " //"+comment_str else "")+"\n"+ + argument_list_from_fields(indent, t) + } +. + +public define Maybe(One) + generate_to_message + ( + Stream stream, + DS_Message ds_message //type description + )= + since ds_message is ds_message(message_name, what_code, fields), + + with lower_message_name = "_"+to_lower(message_name), + message_msg = lower_message_name+"_message", + write_string(stream, + +"public define Message\n"+ +" make_"+message_name+"\n"+ +" (\n"+ +argument_list_from_fields(" ", fields)+ +" )=\n"+ +" with "+message_msg+" = message("+what_code+"), //\n"+ +" forget(add_string("+message_msg+", \"__MSG__\", \""+what_code+"\"));\n\n"+ +//" if "+lower_message_name+" is\n"+ +generate_fields_to_message(" ", message_msg, fields) + +//" };\n"+ +" "+message_msg+"\n"+ +".\n\n" + ) +. + +/****************************** FROM MESSAGE ***********************************/ + + +define String + generate_fields_from_message + ( + String indent, + String type_msg, + List(DS_Field) fields, + Var(Int) brace_counter + )= + if fields is + { + [] then "", + [h . t] then + since h is field(field_name, b_list, anb_type, comment), + with name = "_"+to_lower(field_name), + indent + "// [Field's type = "+(if b_list is list then "List(" else "")+dump(anb_type)+(if b_list is list then ")" else "")+"] Field's name '"+field_name+"'\n"+ + (if b_list is list then + anb_type_list_from_message(indent, type_msg, anb_type, field_name, name, brace_counter) + else + anb_type_from_message(indent, type_msg, anb_type, field_name, name, brace_counter)) + + + generate_fields_from_message(indent, type_msg, t, brace_counter) + + } +. + +define String + anonymous_aggregat_from_fields + ( + List(DS_Field) fields + )= + if fields is + { + [] then "", + [h . t] then + since h is field(name, b_list, anb_type, comment), + (if b_list is list then "List(" else "")+dump(anb_type)+(if b_list is list then ")" else "")+" _"+to_lower(name)+ + (if is_empty(t) then "" else ", ")+ + //(if comment is comment(comment_str) then " //"+comment_str else "")+"\n"+ + anonymous_aggregat_from_fields(t) + } +. + +define String + anonymous_aggregat_value_from_fields + ( + List(DS_Field) fields + )= + join(", ", map((DS_Field field) |-> "_"+to_lower(field.field_name), fields)). + + if fields is + { + [] then "", + [h . t] then + since h is field(name, b_list, anb_type, comment), + (if b_list is list then "List(" else "")+dump(anb_type)+(if b_list is list then ")" else "")+" _"+to_lower(name)+ + (if is_empty(t) then "" else ", ")+ + //(if comment is comment(comment_str) then " //"+comment_str else "")+"\n"+ + anonymous_aggregat_from_fields(t) + } +. +public define Maybe(One) +/* generate the function which return Maybe(anonymous aggregat) from message. + * the aggregat contain all types used to construct the message + */ + + generate_from_message + ( + Stream stream, //the file in which we write + DS_Message ds_message //type description + )= + + since ds_message is ds_message(message_name, what_code, fields), + with brace_counter = (Var(Int))var(0), + lower_message_name = "_"+to_lower(message_name), + message_msg = lower_message_name+"_message", + + write_string(stream, +"public define Maybe(("+anonymous_aggregat_from_fields(fields)+"))\n"+ +" get_"+message_name+"\n"+ +" (\n"+ +" Message "+message_msg+"\n"+ +" )=\n"+ +" if find_string("+message_msg+", \"__MSG__\") is {failure then failure, success(__msg__) then\n"+ +" if __msg__ = \""+what_code+"\" then \n"+ +with fields_from_message = generate_fields_from_message(" ",message_msg, fields, brace_counter), +fields_from_message+ +" success(("+anonymous_aggregat_value_from_fields(fields)+"))\n"+ +" "+fill(*brace_counter, '}') +"\n"+ +" else\n"+ +" failure //No valid message found !\n"+ +" }\n"+ +".\n\n" + ) +. diff --git a/src/generation/messages.anubis b/src/generation/messages.anubis new file mode 100644 index 0000000..8c0c2a6 --- /dev/null +++ b/src/generation/messages.anubis @@ -0,0 +1,58 @@ +/* + * Created by PyramIDE. + * User: フランスのトトロ aka (David RENÉ) + * Date: 23/01/2017 + * Time: 10:09 + * © Calexium + */ + +read generation/message_header.anubis +read generation/message_messages.anubis + +read system/files.anubis +read system/string.anubis +read tools/streams.anubis +read tools/basis.anubis +read densaku_lib/types/ds_message.anubis + + +define Maybe(One) + make_message_file + ( + DS_Message ds_message, //type description + String dest_dir + ) + = + since ds_message is ds_message(name, _, fields), + println("Generating file for message ["+name+"]"); + //TODO here replace all files by one with collection name + with file_name = dest_dir+"messages/generated/"+to_lower(name)+".anubis", + + //create all necessary directories if doesn't exist. + make_directories(file_name); + + if file(file_name, new) is + { + failure then println("can't create file "+file_name);failure, + success(fd) then + with strm = make_stream(fd), + if generate_message_header(strm, ds_message) is { failure then failure, success(_) then +// if generate_type(strm, ds_message) is { failure then failure, success(_) then + if generate_message_message_description(strm, ds_message) is { failure then failure, success(_) then + if generate_to_message(strm, ds_message) is { failure then failure, success(_) then + if generate_from_message(strm, ds_message) is { failure then failure, success(_) then + + success(unique)}}}}//} + } +. + +public define One + make_all_messages + ( + List(DS_Message) messages, + String destination_dir + )= + map_forget((DS_Message message) |-> since message is ds_message(message_name, what_code, ds_fields), + println("generating message file for Message ["+message_name+"]"); + make_message_file(message, destination_dir), messages) +. diff --git a/src/generation/types_header.anubis b/src/generation/types_header.anubis index dc4f853..c9c0795 100644 --- a/src/generation/types_header.anubis +++ b/src/generation/types_header.anubis @@ -16,7 +16,6 @@ read densaku_lib/types/ds_types.anubis public define String insert_read_foreign_type ( -// Stream stream, DS_Type sd_type //type description )= with foreign_type_list = get_all_extern_type(sd_type), @@ -41,6 +40,7 @@ public define Maybe(One) transmit system/muscle.anubis transmit system/convert.anubis transmit tools/basis.anubis + " + insert_read_foreign_type(sd_type)+ "\n" diff --git a/src/generation/types_messages.anubis b/src/generation/types_messages.anubis index 8af018b..20aa311 100644 --- a/src/generation/types_messages.anubis +++ b/src/generation/types_messages.anubis @@ -40,29 +40,30 @@ public define Maybe(One) ) . -define String +public define String anb_type_to_message ( String type_msg, DS_Anubis_Type anb_type, + String field_name, String name )= if anb_type is { one then - "add_string("+type_msg+", \""+name+"\", _"+name+")", + "add_string("+type_msg+", \""+field_name+"\", _"+name+")", bool then - "add_bool("+type_msg+", \""+name+"\", _"+name+")", + "add_bool("+type_msg+", \""+field_name+"\", _"+name+")", int then - "add_string("+type_msg+", \""+name+"\", to_String(_"+name+"))", + "add_string("+type_msg+", \""+field_name+"\", to_String(_"+name+"))", string then - "add_string("+type_msg+", \""+name+"\", _"+name+")", + "add_string("+type_msg+", \""+field_name+"\", _"+name+")", float then - "add_float("+type_msg+", \""+name+"\", _"+name+")", + "add_float("+type_msg+", \""+field_name+"\", _"+name+")", ds_type(type_name) then - "add_message("+type_msg+", \""+name+"\", to_Message(_"+name+"))", + "add_message("+type_msg+", \""+field_name+"\", to_Message(_"+name+"))", extern_type(type_name, _) then //external type. No need to check - "add_message("+type_msg+", \""+name+"\", to_Message(_"+name+"))", + "add_message("+type_msg+", \""+field_name+"\", to_Message(_"+name+"))", } . @@ -82,9 +83,9 @@ define String ";\n"+ prefix +"// [type = "+(if b_list is list then "List(" else "")+dump(anb_type)+(if b_list is list then ")" else "")+"] "+alt_name+"."+name+"\n"+ (if b_list is list then - prefix +"map_forget(("+dump(anb_type)+ " _"+name+") |-> "+anb_type_to_message(type_msg, anb_type, name)+", __"+name+")" + prefix +"map_forget(("+dump(anb_type)+ " _"+name+") |-> "+anb_type_to_message(type_msg, anb_type, name, name)+", __"+name+")" else - prefix +"forget("+anb_type_to_message(type_msg, anb_type, name)+")") + prefix +"forget("+anb_type_to_message(type_msg, anb_type, name, name)+")") + generate_component_to_message(prefix, type_msg, alt_name, t) } @@ -165,7 +166,7 @@ public define Maybe(One) /****************************** FROM MESSAGE ***********************************/ -define String +public define String /* anb_type_list_from_message * Generate the function which get the list of the target type ie. Bool, complex type, etc. * To do so, we get in the given Message, all fields with the name and encoded type of expected type. @@ -181,6 +182,7 @@ define String String indent, String type_msg, DS_Anubis_Type anb_type, + String field_name, String name, Var(Int) brace_counter )= @@ -189,32 +191,33 @@ define String //empty then indent + "with " + name + " = map_escape(( String str ) |-> (Maybe(String)) from_Message(msg), find_strings("+type_msg+", \""+name+"\")),\n", one then brace_counter <- *brace_counter + 1; - indent + "with mb_" + name + " = map_escape((Message msg) |-> (Maybe("+dump(anb_type)+ ")) from_Message(msg), find_messages("+type_msg+", \""+name+"\")),\n"+ + indent + "with mb_" + name + " = map_escape((Message msg) |-> (Maybe("+dump(anb_type)+ ")) from_Message(msg), find_messages("+type_msg+", \""+field_name+"\")),\n"+ indent + " if mb_" + name + " is {failure then failure, success("+ name + ") then \n", - bool then indent + "with " + name + " = find_bool_list("+type_msg+", \""+name+"\"),\n", + bool then indent + "with " + name + " = find_bool_list("+type_msg+", \""+field_name+"\"),\n", int then brace_counter <- *brace_counter + 1; - indent + "with mb_" + name + " = map_escape((String int_str) |-> decimal_scan(int_str), find_string_list("+type_msg+", \""+name+"\")),\n"+ + indent + "with mb_" + name + " = map_escape((String int_str) |-> decimal_scan(int_str), find_string_list("+type_msg+", \""+field_name+"\")),\n"+ indent + " if mb_" + name + " is {failure then failure, success("+ name + ") then \n", - string then indent + "with " + name + " = find_string_list("+type_msg+", \""+name+"\"),\n", - float then indent + "with " + name + " = find_float_list("+type_msg+", \""+name+"\"),\n", + string then indent + "with " + name + " = find_string_list("+type_msg+", \""+field_name+"\"),\n", + float then indent + "with " + name + " = find_float_list("+type_msg+", \""+field_name+"\"),\n", ds_type(type_name) then brace_counter <- *brace_counter + 1; - indent +"with mb_"+name+" = map_escape(( Message msg ) |-> (Maybe("+dump(anb_type)+ ")) from_Message(msg), find_message_list("+type_msg+", \""+name+"\")),\n"+ + indent +"with mb_"+name+" = map_escape(( Message msg ) |-> (Maybe("+dump(anb_type)+ ")) from_Message(msg), find_message_list("+type_msg+", \""+field_name+"\")),\n"+ indent +" if mb_"+name+" is {failure then failure, success("+name+") then\n", extern_type(type_name, _) then brace_counter <- *brace_counter + 1; - indent +"with mb_"+name+" = map_escape(( Message msg ) |-> (Maybe("+dump(anb_type)+ ")) from_Message(msg), find_message_list("+type_msg+", \""+name+"\")),\n"+ + indent +"with mb_"+name+" = map_escape(( Message msg ) |-> (Maybe("+dump(anb_type)+ ")) from_Message(msg), find_message_list("+type_msg+", \""+field_name+"\")),\n"+ indent +" if mb_"+name+" is {failure then failure, success("+name+") then\n" } . -define String +public define String anb_type_from_message ( String indent, String type_msg, DS_Anubis_Type anb_type, + String field_name, String name, Var(Int) brace_counter )= @@ -222,27 +225,27 @@ define String { one then brace_counter <- (*brace_counter + 1); - indent + "if find_string("+type_msg+", \""+name+"\")"+" is {failure then failure, success(_) then with "+name+" = unique,\n", + indent + "if find_string("+type_msg+", \""+field_name+"\")"+" is {failure then failure, success(_) then with "+name+" = unique,\n", bool then brace_counter <- (*brace_counter + 1); - indent + "if find_bool("+type_msg+", \""+name+"\")"+" is {failure then failure, success("+name+") then\n", + indent + "if find_bool("+type_msg+", \""+field_name+"\")"+" is {failure then failure, success("+name+") then\n", int then brace_counter <- (*brace_counter + 2); - indent + "if find_string("+type_msg+", \""+name+"\")"+" is {failure then failure, success(_"+name+") then\n"+ + indent + "if find_string("+type_msg+", \""+field_name+"\")"+" is {failure then failure, success(_"+name+") then\n"+ indent + " if decimal_scan(_"+name+") is { failure then failure, success("+name+") then\n", string then brace_counter <- (*brace_counter + 1); - indent + "if find_string("+type_msg+", \""+name+"\")"+" is {failure then failure, success("+name+") then\n", + indent + "if find_string("+type_msg+", \""+field_name+"\")"+" is {failure then failure, success("+name+") then\n", float then brace_counter <- (*brace_counter + 1); - indent + "if find_float("+type_msg+", \""+name+"\)"+" is {failure then failure, success("+name+") then\n", + indent + "if find_float("+type_msg+", \""+field_name+"\)"+" is {failure then failure, success("+name+") then\n", ds_type(type_name) then brace_counter <- (*brace_counter + 2); - indent + "if find_message("+type_msg+", \""+name+"\")"+" is {failure then failure, success("+name+"_msg) then\n"+ + indent + "if find_message("+type_msg+", \""+field_name+"\")"+" is {failure then failure, success("+name+"_msg) then\n"+ indent + " if (Maybe("+type_name+"))from_Message("+name+"_msg)"+" is {failure then failure, success("+name+") then\n", extern_type(type_name, _) then //external type. No need to check brace_counter <- (*brace_counter + 2); - indent + "if find_message("+type_msg+", \""+name+"\")"+" is {failure then failure, success("+name+"_msg) then\n"+ + indent + "if find_message("+type_msg+", \""+field_name+"\")"+" is {failure then failure, success("+name+"_msg) then\n"+ indent + " if (Maybe("+type_name+"))from_Message("+name+"_msg)"+" is {failure then failure, success("+name+") then\n", } . @@ -271,9 +274,9 @@ define String since h is component(b_list, anb_type, name, comment), indent + "// [type = "+(if b_list is list then "List(" else "")+dump(anb_type)+(if b_list is list then ")" else "")+"] "+alt_name+"."+name+"\n"+ (if b_list is list then - anb_type_list_from_message(indent, type_msg, anb_type, name, brace_counter) + anb_type_list_from_message(indent, type_msg, anb_type, name, name, brace_counter) else - anb_type_from_message(indent, type_msg, anb_type, name, brace_counter)) + anb_type_from_message(indent, type_msg, anb_type, name, name, brace_counter)) + generate_component_from_message(indent, type_msg, alt_name, t, brace_counter) diff --git a/src/main.anubis b/src/main.anubis index 4c4fed9..d81c8f2 100644 --- a/src/main.anubis +++ b/src/main.anubis @@ -22,7 +22,16 @@ read densaku_lib/types/densaku.anubis read generation/files.anubis +read calexium_lib/CXM_message_constants.anubis +public define List(DS_Message) the_messages_list = + [ + ds_message("Get_Domain_Name", "_CXM_DOMAIN_GET_NAME", [ + field("SERIAL", string, comment("MF Serial number")), + field("CXM_Key", string, comment("Calexium Key provided during the order process")), + ]) + ]. + public define List(DS_Type) the_types_list = [ ds_type("User_Account", [ @@ -60,6 +69,13 @@ public define List(DS_Type) the_types_list = component(list, ds_type("HK_Table"),"hk_tables") ]) ]), + ds_type("HK_Database", [ + alternative("hk_database", [ + component(string, "name", comment("name of the database")), + component(list, ds_type("HK_App"), "apps", comment("list of applications")) + ]) + ]), + ds_type("HK_Help_Text", [ enum("no_help_text", comment("no help text available")), alternative("help_text_TAG", [component(string, "tag_name", comment("TAG use with Anubis translation tool /locale/L3.anubis"))]), @@ -70,6 +86,8 @@ public define List(DS_Type) the_types_list = alternative("icon16", [component(string, "name")]) ]), ]. + + global define One takaden @@ -88,5 +106,5 @@ global define One List(String) args )= //print(dump_TK_Type_list(the_types_list)). - forget(generate_message_files(the_types_list, "")). + forget(generate_message_files(the_types_list, the_messages_list, "")). -- libgit2 0.21.4