#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/paths.h"
#include "asterisk/linkedlists.h"
#include "asterisk/strings.h"
#include "asterisk/config.h"
#include "asterisk/term.h"
#include "asterisk/xmldoc.h"
Go to the source code of this file.
Data Structures | |
struct | documentation_tree |
XML documentation tree. More... | |
struct | strcolorized_tags |
struct | strspecial_tags |
struct | strsyntaxtype |
Mapping between type of node and type of syntax to generate. More... | |
struct | xmldoc_tree |
Container of documentation trees. More... | |
Defines | |
#define | GOTONEXT(__rev, __a) (__rev ? ast_xml_node_get_prev(__a) : ast_xml_node_get_next(__a)) |
#define | ISLAST(__rev, __a) (__rev == 1 ? (ast_xml_node_get_prev(__a) ? 0 : 1) : (ast_xml_node_get_next(__a) ? 0 : 1)) |
#define | MP(__a) ((multiple ? __a : "")) |
Enumerations | |
enum | syntaxtype { FUNCTION_SYNTAX, MANAGER_SYNTAX, COMMAND_SYNTAX } |
Types of syntax that we are able to generate. More... | |
Functions | |
char * | ast_xmldoc_build_arguments (const char *type, const char *name, const char *module) |
char * | ast_xmldoc_build_description (const char *type, const char *name, const char *module) |
char * | ast_xmldoc_build_seealso (const char *type, const char *name, const char *module) |
char * | ast_xmldoc_build_synopsis (const char *type, const char *name, const char *module) |
char * | ast_xmldoc_build_syntax (const char *type, const char *name, const char *module) |
char * | ast_xmldoc_printable (const char *bwinput, int withcolors) |
static int | xmldoc_attribute_match (struct ast_xml_node *node, const char *attr, const char *value) |
static char * | xmldoc_build_field (const char *type, const char *name, const char *module, const char *var, int raw) |
Get the content of a field (synopsis, description, etc) from an asterisk document tree. | |
static int | xmldoc_foundspace_backward (const char *text, int currentpos, int maxdiff) |
static struct ast_str * | xmldoc_get_formatted (struct ast_xml_node *node, int raw_output, int raw_wrap) |
static struct ast_xml_node * | xmldoc_get_node (const char *type, const char *name, const char *module, const char *language) |
static char * | xmldoc_get_syntax_cmd (struct ast_xml_node *fixnode, const char *name, int printname) |
static char * | xmldoc_get_syntax_fun (struct ast_xml_node *rootnode, const char *rootname, const char *childname, int printparenthesis, int printrootname) |
static char * | xmldoc_get_syntax_manager (struct ast_xml_node *fixnode, const char *name) |
static enum syntaxtype | xmldoc_get_syntax_type (const char *type) |
static int | xmldoc_has_inside (struct ast_xml_node *fixnode, const char *what) |
static int | xmldoc_has_nodes (struct ast_xml_node *fixnode) |
static int | xmldoc_has_specialtags (struct ast_xml_node *fixnode) |
static int | xmldoc_parse_argument (struct ast_xml_node *fixnode, int insideparameter, const char *paramtabs, const char *tabs, struct ast_str **buffer) |
static char * | xmldoc_parse_cmd_enumlist (struct ast_xml_node *fixnode) |
static int | xmldoc_parse_enum (struct ast_xml_node *fixnode, const char *tabs, struct ast_str **buffer) |
static int | xmldoc_parse_enumlist (struct ast_xml_node *fixnode, const char *tabs, struct ast_str **buffer) |
static int | xmldoc_parse_option (struct ast_xml_node *fixnode, const char *tabs, struct ast_str **buffer) |
static void | xmldoc_parse_optionlist (struct ast_xml_node *fixnode, const char *tabs, struct ast_str **buffer) |
static int | xmldoc_parse_para (struct ast_xml_node *node, const char *tabs, const char *posttabs, struct ast_str **buffer) |
static void | xmldoc_parse_parameter (struct ast_xml_node *fixnode, const char *tabs, struct ast_str **buffer) |
static int | xmldoc_parse_specialtags (struct ast_xml_node *fixnode, const char *tabs, const char *posttabs, struct ast_str **buffer) |
static int | xmldoc_parse_variable (struct ast_xml_node *node, const char *tabs, struct ast_str **buffer) |
static int | xmldoc_parse_variablelist (struct ast_xml_node *node, const char *tabs, struct ast_str **buffer) |
static int | xmldoc_postbrlen (const char *postbr) |
static void | xmldoc_reverse_helper (int reverse, int *len, char **syntax, const char *fmt,...) |
static void | xmldoc_setpostbr (char *postbr, size_t len, const char *text) |
static void | xmldoc_string_cleanup (const char *text, struct ast_str **output, int lastspaces) |
static char * | xmldoc_string_wrap (const char *text, int columns, int maxdiff) |
static int | xmldoc_wait_nextspace (const char *text, int currentpos, int maxdiff) |
Variables | |
static struct strcolorized_tags | colorized_tags [] |
static const char | default_documentation_language [] = "en_US" |
Default documentation language. | |
static char | documentation_language [6] |
XML documentation language. | |
static struct strspecial_tags | special_tags [] |
static struct strsyntaxtype | stxtype [] |
Mapping between type of node and type of syntax to generate. | |
static const int | xmldoc_max_diff = 5 |
This is a value that we will use to let the wrapping mechanism move the cursor backward and forward xmldoc_max_diff positions before cutting the middle of a word, trying to find a space or a . | |
static const int | xmldoc_text_columns = 74 |
Number of columns to print when showing the XML documentation with a 'core show application/function *' CLI command. Used in text wrapping. |
Definition in file xmldoc.c.
#define GOTONEXT | ( | __rev, | |||
__a | ) | (__rev ? ast_xml_node_get_prev(__a) : ast_xml_node_get_next(__a)) |
Referenced by xmldoc_get_syntax_fun().
#define ISLAST | ( | __rev, | |||
__a | ) | (__rev == 1 ? (ast_xml_node_get_prev(__a) ? 0 : 1) : (ast_xml_node_get_next(__a) ? 0 : 1)) |
Referenced by xmldoc_get_syntax_fun().
#define MP | ( | __a | ) | ((multiple ? __a : "")) |
Referenced by xmldoc_get_syntax_fun().
enum syntaxtype |
Types of syntax that we are able to generate.
Definition at line 1096 of file xmldoc.c.
01096 { 01097 FUNCTION_SYNTAX, 01098 MANAGER_SYNTAX, 01099 COMMAND_SYNTAX 01100 };
char* ast_xmldoc_build_arguments | ( | const char * | type, | |
const char * | name, | |||
const char * | module | |||
) |
Definition at line 1730 of file xmldoc.c.
References ast_free, ast_str_buffer(), ast_str_create(), ast_str_strlen(), ast_str_truncate(), ast_strdup, ast_strlen_zero(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), xmldoc_get_node(), and xmldoc_parse_parameter().
Referenced by acf_retrieve_docs(), ast_manager_register2(), and ast_register_application2().
01731 { 01732 struct ast_xml_node *node; 01733 struct ast_str *ret = ast_str_create(128); 01734 char *retstr = NULL; 01735 01736 if (ast_strlen_zero(type) || ast_strlen_zero(name)) { 01737 return NULL; 01738 } 01739 01740 node = xmldoc_get_node(type, name, module, documentation_language); 01741 01742 if (!node || !ast_xml_node_get_children(node)) { 01743 return NULL; 01744 } 01745 01746 /* Find the syntax field. */ 01747 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 01748 if (!strcasecmp(ast_xml_node_get_name(node), "syntax")) { 01749 break; 01750 } 01751 } 01752 01753 if (!node || !ast_xml_node_get_children(node)) { 01754 /* We couldn't find the syntax node. */ 01755 return NULL; 01756 } 01757 01758 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 01759 xmldoc_parse_parameter(node, "", &ret); 01760 } 01761 01762 if (ast_str_strlen(ret) > 0) { 01763 /* remove last '\n' */ 01764 char *buf = ast_str_buffer(ret); 01765 if (buf[ast_str_strlen(ret) - 1] == '\n') { 01766 ast_str_truncate(ret, -1); 01767 } 01768 retstr = ast_strdup(ast_str_buffer(ret)); 01769 } 01770 ast_free(ret); 01771 01772 return retstr; 01773 }
char* ast_xmldoc_build_description | ( | const char * | type, | |
const char * | name, | |||
const char * | module | |||
) |
Definition at line 1864 of file xmldoc.c.
References xmldoc_build_field().
Referenced by acf_retrieve_docs(), ast_agi_register(), ast_manager_register2(), and ast_register_application2().
01865 { 01866 return xmldoc_build_field(type, name, module, "description", 0); 01867 }
char* ast_xmldoc_build_seealso | ( | const char * | type, | |
const char * | name, | |||
const char * | module | |||
) |
Definition at line 1436 of file xmldoc.c.
References ast_free, ast_str_append(), ast_str_buffer(), ast_str_create(), ast_strdup, ast_strlen_zero(), ast_xml_free_attr(), ast_xml_free_text(), ast_xml_get_attribute(), ast_xml_get_text(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), first, and xmldoc_get_node().
Referenced by acf_retrieve_docs(), ast_agi_register(), ast_manager_register2(), and ast_register_application2().
01437 { 01438 struct ast_str *outputstr; 01439 char *output; 01440 struct ast_xml_node *node; 01441 const char *typename; 01442 const char *content; 01443 int first = 1; 01444 01445 if (ast_strlen_zero(type) || ast_strlen_zero(name)) { 01446 return NULL; 01447 } 01448 01449 /* get the application/function root node. */ 01450 node = xmldoc_get_node(type, name, module, documentation_language); 01451 if (!node || !ast_xml_node_get_children(node)) { 01452 return NULL; 01453 } 01454 01455 /* Find the <see-also> node. */ 01456 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 01457 if (!strcasecmp(ast_xml_node_get_name(node), "see-also")) { 01458 break; 01459 } 01460 } 01461 01462 if (!node || !ast_xml_node_get_children(node)) { 01463 /* we couldnt find a <see-also> node. */ 01464 return NULL; 01465 } 01466 01467 /* prepare the output string. */ 01468 outputstr = ast_str_create(128); 01469 if (!outputstr) { 01470 return NULL; 01471 } 01472 01473 /* get into the <see-also> node. */ 01474 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 01475 if (strcasecmp(ast_xml_node_get_name(node), "ref")) { 01476 continue; 01477 } 01478 01479 /* parse the <ref> node. 'type' attribute is required. */ 01480 typename = ast_xml_get_attribute(node, "type"); 01481 if (!typename) { 01482 continue; 01483 } 01484 content = ast_xml_get_text(node); 01485 if (!content) { 01486 ast_xml_free_attr(typename); 01487 continue; 01488 } 01489 if (!strcasecmp(typename, "application")) { 01490 ast_str_append(&outputstr, 0, "%s%s()", (first ? "" : ", "), content); 01491 } else if (!strcasecmp(typename, "function")) { 01492 ast_str_append(&outputstr, 0, "%s%s", (first ? "" : ", "), content); 01493 } else if (!strcasecmp(typename, "astcli")) { 01494 ast_str_append(&outputstr, 0, "%s<astcli>%s</astcli>", (first ? "" : ", "), content); 01495 } else { 01496 ast_str_append(&outputstr, 0, "%s%s", (first ? "" : ", "), content); 01497 } 01498 first = 0; 01499 ast_xml_free_text(content); 01500 ast_xml_free_attr(typename); 01501 } 01502 01503 output = ast_strdup(ast_str_buffer(outputstr)); 01504 ast_free(outputstr); 01505 01506 return output; 01507 }
char* ast_xmldoc_build_synopsis | ( | const char * | type, | |
const char * | name, | |||
const char * | module | |||
) |
Definition at line 1859 of file xmldoc.c.
References xmldoc_build_field().
Referenced by acf_retrieve_docs(), ast_agi_register(), ast_manager_register2(), and ast_register_application2().
01860 { 01861 return xmldoc_build_field(type, name, module, "synopsis", 1); 01862 }
char* ast_xmldoc_build_syntax | ( | const char * | type, | |
const char * | name, | |||
const char * | module | |||
) |
Definition at line 1130 of file xmldoc.c.
References ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), COMMAND_SYNTAX, FUNCTION_SYNTAX, MANAGER_SYNTAX, xmldoc_get_node(), xmldoc_get_syntax_cmd(), xmldoc_get_syntax_fun(), xmldoc_get_syntax_manager(), and xmldoc_get_syntax_type().
Referenced by acf_retrieve_docs(), ast_agi_register(), ast_manager_register2(), and ast_register_application2().
01131 { 01132 struct ast_xml_node *node; 01133 char *syntax = NULL; 01134 01135 node = xmldoc_get_node(type, name, module, documentation_language); 01136 if (!node) { 01137 return NULL; 01138 } 01139 01140 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 01141 if (!strcasecmp(ast_xml_node_get_name(node), "syntax")) { 01142 break; 01143 } 01144 } 01145 01146 if (node) { 01147 switch (xmldoc_get_syntax_type(type)) { 01148 case FUNCTION_SYNTAX: 01149 syntax = xmldoc_get_syntax_fun(node, name, "parameter", 1, 1); 01150 break; 01151 case COMMAND_SYNTAX: 01152 syntax = xmldoc_get_syntax_cmd(node, name, 1); 01153 break; 01154 case MANAGER_SYNTAX: 01155 syntax = xmldoc_get_syntax_manager(node, name); 01156 break; 01157 default: 01158 syntax = xmldoc_get_syntax_fun(node, name, "parameter", 1, 1); 01159 } 01160 } 01161 return syntax; 01162 }
char* ast_xmldoc_printable | ( | const char * | bwinput, | |
int | withcolors | |||
) |
Definition at line 311 of file xmldoc.c.
References ARRAY_LEN, ast_copy_string(), ast_free, ast_str_append(), ast_str_buffer(), ast_str_create(), ast_term_color_code(), COLOR_CYAN, colorized_tags, len(), strcasestr(), term_end(), and xmldoc_string_wrap().
Referenced by handle_cli_agi_show(), handle_show_function(), handle_showmancmd(), print_app_docs(), and write_htmldump().
00312 { 00313 struct ast_str *colorized; 00314 char *wrapped = NULL; 00315 int i, c, len, colorsection; 00316 char *tmp; 00317 size_t bwinputlen; 00318 static const int base_fg = COLOR_CYAN; 00319 00320 if (!bwinput) { 00321 return NULL; 00322 } 00323 00324 bwinputlen = strlen(bwinput); 00325 00326 if (!(colorized = ast_str_create(256))) { 00327 return NULL; 00328 } 00329 00330 if (withcolors) { 00331 ast_term_color_code(&colorized, base_fg, 0); 00332 if (!colorized) { 00333 return NULL; 00334 } 00335 } 00336 00337 for (i = 0; i < bwinputlen; i++) { 00338 colorsection = 0; 00339 /* Check if we are at the beginning of a tag to be colorized. */ 00340 for (c = 0; c < ARRAY_LEN(colorized_tags); c++) { 00341 if (strncasecmp(bwinput + i, colorized_tags[c].inittag, strlen(colorized_tags[c].inittag))) { 00342 continue; 00343 } 00344 00345 if (!(tmp = strcasestr(bwinput + i + strlen(colorized_tags[c].inittag), colorized_tags[c].endtag))) { 00346 continue; 00347 } 00348 00349 len = tmp - (bwinput + i + strlen(colorized_tags[c].inittag)); 00350 00351 /* Setup color */ 00352 if (withcolors) { 00353 ast_term_color_code(&colorized, colorized_tags[c].colorfg, 0); 00354 if (!colorized) { 00355 return NULL; 00356 } 00357 } 00358 00359 /* copy initial string replace */ 00360 ast_str_append(&colorized, 0, "%s", colorized_tags[c].init); 00361 if (!colorized) { 00362 return NULL; 00363 } 00364 { 00365 char buf[len + 1]; 00366 ast_copy_string(buf, bwinput + i + strlen(colorized_tags[c].inittag), sizeof(buf)); 00367 ast_str_append(&colorized, 0, "%s", buf); 00368 } 00369 if (!colorized) { 00370 return NULL; 00371 } 00372 00373 /* copy the ending string replace */ 00374 ast_str_append(&colorized, 0, "%s", colorized_tags[c].end); 00375 if (!colorized) { 00376 return NULL; 00377 } 00378 00379 /* Continue with the last color. */ 00380 if (withcolors) { 00381 ast_term_color_code(&colorized, base_fg, 0); 00382 if (!colorized) { 00383 return NULL; 00384 } 00385 } 00386 00387 i += len + strlen(colorized_tags[c].endtag) + strlen(colorized_tags[c].inittag) - 1; 00388 colorsection = 1; 00389 break; 00390 } 00391 00392 if (!colorsection) { 00393 ast_str_append(&colorized, 0, "%c", bwinput[i]); 00394 if (!colorized) { 00395 return NULL; 00396 } 00397 } 00398 } 00399 00400 if (withcolors) { 00401 ast_str_append(&colorized, 0, "%s", term_end()); 00402 if (!colorized) { 00403 return NULL; 00404 } 00405 } 00406 00407 /* Wrap the text, notice that string wrap will avoid cutting an ESC sequence. */ 00408 wrapped = xmldoc_string_wrap(ast_str_buffer(colorized), xmldoc_text_columns, xmldoc_max_diff); 00409 00410 ast_free(colorized); 00411 00412 return wrapped; 00413 }
static int xmldoc_attribute_match | ( | struct ast_xml_node * | node, | |
const char * | attr, | |||
const char * | value | |||
) | [static] |
Definition at line 466 of file xmldoc.c.
References ast_xml_free_attr(), ast_xml_get_attribute(), and match().
Referenced by xmldoc_get_node().
00467 { 00468 const char *attr_value = ast_xml_get_attribute(node, attr); 00469 int match = attr_value && !strcmp(attr_value, value); 00470 ast_xml_free_attr(attr_value); 00471 return match; 00472 }
static char* xmldoc_build_field | ( | const char * | type, | |
const char * | name, | |||
const char * | module, | |||
const char * | var, | |||
int | raw | |||
) | [static] |
Get the content of a field (synopsis, description, etc) from an asterisk document tree.
type | Type of element (application, function, ...). | |
name | Name of element (Dial, Echo, Playback, ...). | |
var | Name of field to return (synopsis, description, etc). | |
raw | Field only contains text, no other elements inside it. |
NULL | On error. | |
Field | text content on success. |
Definition at line 1825 of file xmldoc.c.
References ast_free, ast_log(), ast_str_buffer(), ast_str_strlen(), ast_strdup, ast_strlen_zero(), ast_xml_find_element(), ast_xml_node_get_children(), LOG_DEBUG, LOG_ERROR, LOG_WARNING, xmldoc_get_formatted(), and xmldoc_get_node().
Referenced by ast_xmldoc_build_description(), and ast_xmldoc_build_synopsis().
01826 { 01827 struct ast_xml_node *node; 01828 char *ret = NULL; 01829 struct ast_str *formatted; 01830 01831 if (ast_strlen_zero(type) || ast_strlen_zero(name)) { 01832 ast_log(LOG_ERROR, "Tried to look in XML tree with faulty values.\n"); 01833 return ret; 01834 } 01835 01836 node = xmldoc_get_node(type, name, module, documentation_language); 01837 01838 if (!node) { 01839 ast_log(LOG_WARNING, "Couldn't find %s %s in XML documentation\n", type, name); 01840 return ret; 01841 } 01842 01843 node = ast_xml_find_element(ast_xml_node_get_children(node), var, NULL, NULL); 01844 01845 if (!node || !ast_xml_node_get_children(node)) { 01846 ast_log(LOG_DEBUG, "Cannot find variable '%s' in tree '%s'\n", var, name); 01847 return ret; 01848 } 01849 01850 formatted = xmldoc_get_formatted(node, raw, raw); 01851 if (ast_str_strlen(formatted) > 0) { 01852 ret = ast_strdup(ast_str_buffer(formatted)); 01853 } 01854 ast_free(formatted); 01855 01856 return ret; 01857 }
static int xmldoc_foundspace_backward | ( | const char * | text, | |
int | currentpos, | |||
int | maxdiff | |||
) | [static] |
Definition at line 205 of file xmldoc.c.
Referenced by xmldoc_string_wrap().
00206 { 00207 int i; 00208 00209 for (i = currentpos; i > 0; i--) { 00210 if (text[i] == ' ' || text[i] == '\n') { 00211 return (currentpos - i); 00212 } else if (text[i] == 'm' && (text[i - 1] >= '0' || text[i - 1] <= '9')) { 00213 /* give up, we found the end of a possible ESC sequence. */ 00214 return 0; 00215 } else if (currentpos - i > maxdiff) { 00216 /* give up, we can't move anymore. */ 00217 return 0; 00218 } 00219 } 00220 00221 /* we found the beginning of the text */ 00222 00223 return 0; 00224 }
static struct ast_str* xmldoc_get_formatted | ( | struct ast_xml_node * | node, | |
int | raw_output, | |||
int | raw_wrap | |||
) | [static] |
Definition at line 1783 of file xmldoc.c.
References ast_skip_blanks(), ast_str_buffer(), ast_str_create(), ast_str_strlen(), ast_str_truncate(), ast_xml_free_text(), ast_xml_get_text(), ast_xml_node_get_children(), ast_xml_node_get_next(), xmldoc_parse_enumlist(), xmldoc_parse_para(), xmldoc_parse_specialtags(), xmldoc_parse_variablelist(), and xmldoc_string_cleanup().
Referenced by xmldoc_build_field().
01784 { 01785 struct ast_xml_node *tmp; 01786 const char *notcleanret, *tmpstr; 01787 struct ast_str *ret = ast_str_create(128); 01788 01789 if (raw_output) { 01790 notcleanret = ast_xml_get_text(node); 01791 tmpstr = notcleanret; 01792 xmldoc_string_cleanup(ast_skip_blanks(notcleanret), &ret, 0); 01793 ast_xml_free_text(tmpstr); 01794 } else { 01795 for (tmp = ast_xml_node_get_children(node); tmp; tmp = ast_xml_node_get_next(tmp)) { 01796 /* if found, parse a <para> element. */ 01797 if (xmldoc_parse_para(tmp, "", "\n", &ret)) { 01798 continue; 01799 } else if (xmldoc_parse_specialtags(tmp, "", "\n", &ret)) { 01800 continue; 01801 } 01802 /* if found, parse a <variablelist> element. */ 01803 xmldoc_parse_variablelist(tmp, "", &ret); 01804 xmldoc_parse_enumlist(tmp, " ", &ret); 01805 } 01806 /* remove last '\n' */ 01807 /* XXX Don't modify ast_str internals manually */ 01808 tmpstr = ast_str_buffer(ret); 01809 if (tmpstr[ast_str_strlen(ret) - 1] == '\n') { 01810 ast_str_truncate(ret, -1); 01811 } 01812 } 01813 return ret; 01814 }
static struct ast_xml_node* xmldoc_get_node | ( | const char * | type, | |
const char * | name, | |||
const char * | module, | |||
const char * | language | |||
) | [static] |
Definition at line 485 of file xmldoc.c.
References AST_LIST_TRAVERSE, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_strlen_zero(), ast_xml_find_element(), ast_xml_get_root(), ast_xml_node_get_children(), ast_xml_node_get_next(), documentation_tree::doc, documentation_tree::entry, and xmldoc_attribute_match().
Referenced by ast_xmldoc_build_arguments(), ast_xmldoc_build_seealso(), ast_xmldoc_build_syntax(), and xmldoc_build_field().
00486 { 00487 struct ast_xml_node *node = NULL; 00488 struct ast_xml_node *first_match = NULL; 00489 struct ast_xml_node *lang_match = NULL; 00490 struct documentation_tree *doctree; 00491 00492 AST_RWLIST_RDLOCK(&xmldoc_tree); 00493 AST_LIST_TRAVERSE(&xmldoc_tree, doctree, entry) { 00494 /* the core xml documents have priority over thirdparty document. */ 00495 node = ast_xml_get_root(doctree->doc); 00496 if (!node) { 00497 break; 00498 } 00499 00500 node = ast_xml_node_get_children(node); 00501 while ((node = ast_xml_find_element(node, type, "name", name))) { 00502 if (!ast_xml_node_get_children(node)) { 00503 /* ignore empty nodes */ 00504 node = ast_xml_node_get_next(node); 00505 continue; 00506 } 00507 00508 if (!first_match) { 00509 first_match = node; 00510 } 00511 00512 /* Check language */ 00513 if (xmldoc_attribute_match(node, "language", language)) { 00514 if (!lang_match) { 00515 lang_match = node; 00516 } 00517 00518 /* if module is empty we have a match */ 00519 if (ast_strlen_zero(module)) { 00520 break; 00521 } 00522 00523 /* Check module */ 00524 if (xmldoc_attribute_match(node, "module", module)) { 00525 break; 00526 } 00527 } 00528 00529 node = ast_xml_node_get_next(node); 00530 } 00531 00532 /* if we matched lang and module return this match */ 00533 if (node) { 00534 break; 00535 } 00536 00537 /* we didn't match lang and module, just return the first 00538 * result with a matching language if we have one */ 00539 if (lang_match) { 00540 node = lang_match; 00541 break; 00542 } 00543 00544 /* we didn't match with only the language, just return the 00545 * first match */ 00546 if (first_match) { 00547 node = first_match; 00548 break; 00549 } 00550 } 00551 AST_RWLIST_UNLOCK(&xmldoc_tree); 00552 00553 return node; 00554 }
static char * xmldoc_get_syntax_cmd | ( | struct ast_xml_node * | fixnode, | |
const char * | name, | |||
int | printname | |||
) | [static] |
Definition at line 950 of file xmldoc.c.
References ast_free, ast_str_append(), ast_str_buffer(), ast_str_create(), ast_strdup, ast_true(), ast_xml_free_attr(), ast_xml_get_attribute(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), first, xmldoc_has_inside(), and xmldoc_parse_cmd_enumlist().
Referenced by ast_xmldoc_build_syntax(), and xmldoc_parse_cmd_enumlist().
00951 { 00952 struct ast_str *syntax; 00953 struct ast_xml_node *tmpnode, *node = fixnode; 00954 char *ret, *paramname; 00955 const char *paramtype, *attrname, *literal; 00956 int required, isenum, first = 1, isliteral; 00957 00958 syntax = ast_str_create(128); 00959 if (!syntax) { 00960 /* at least try to return something... */ 00961 return ast_strdup(name); 00962 } 00963 00964 /* append name to output string. */ 00965 if (printname) { 00966 ast_str_append(&syntax, 0, "%s", name); 00967 first = 0; 00968 } 00969 00970 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 00971 if (strcasecmp(ast_xml_node_get_name(node), "parameter")) { 00972 continue; 00973 } 00974 00975 if (xmldoc_has_inside(node, "parameter")) { 00976 /* is this a recursive parameter. */ 00977 paramname = xmldoc_get_syntax_cmd(node, "", 0); 00978 isenum = 1; 00979 } else if (!xmldoc_has_inside(node, "enumlist")) { 00980 /* this is a simple parameter. */ 00981 attrname = ast_xml_get_attribute(node, "name"); 00982 if (!attrname) { 00983 /* ignore this bogus parameter and continue. */ 00984 continue; 00985 } 00986 paramname = ast_strdup(attrname); 00987 ast_xml_free_attr(attrname); 00988 isenum = 0; 00989 } else { 00990 /* parse enumlist (note that this is a special enumlist 00991 that is used to describe a syntax like {<param1>|<param2>|...} */ 00992 for (tmpnode = ast_xml_node_get_children(node); tmpnode; tmpnode = ast_xml_node_get_next(tmpnode)) { 00993 if (!strcasecmp(ast_xml_node_get_name(tmpnode), "enumlist")) { 00994 break; 00995 } 00996 } 00997 paramname = xmldoc_parse_cmd_enumlist(tmpnode); 00998 isenum = 1; 00999 } 01000 01001 /* Is this parameter required? */ 01002 required = 0; 01003 paramtype = ast_xml_get_attribute(node, "required"); 01004 if (paramtype) { 01005 required = ast_true(paramtype); 01006 ast_xml_free_attr(paramtype); 01007 } 01008 01009 /* Is this a replaceable value or a fixed parameter value? */ 01010 isliteral = 0; 01011 literal = ast_xml_get_attribute(node, "literal"); 01012 if (literal) { 01013 isliteral = ast_true(literal); 01014 ast_xml_free_attr(literal); 01015 } 01016 01017 /* if required="false" print with [...]. 01018 * if literal="true" or is enum print without <..>. 01019 * if not first print a space at the beginning. 01020 */ 01021 ast_str_append(&syntax, 0, "%s%s%s%s%s%s", 01022 (first ? "" : " "), 01023 (required ? "" : "["), 01024 (isenum || isliteral ? "" : "<"), 01025 paramname, 01026 (isenum || isliteral ? "" : ">"), 01027 (required ? "" : "]")); 01028 first = 0; 01029 ast_free(paramname); 01030 } 01031 01032 /* return a common string. */ 01033 ret = ast_strdup(ast_str_buffer(syntax)); 01034 ast_free(syntax); 01035 01036 return ret; 01037 }
static char* xmldoc_get_syntax_fun | ( | struct ast_xml_node * | rootnode, | |
const char * | rootname, | |||
const char * | childname, | |||
int | printparenthesis, | |||
int | printrootname | |||
) | [static] |
Definition at line 672 of file xmldoc.c.
References ast_asprintf, ast_free, ast_log(), ast_strdup, ast_strdupa, ast_strlen_zero(), ast_true(), ast_xml_free_attr(), ast_xml_get_attribute(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), GOTONEXT, ISLAST, len(), LOG_WARNING, MP, xmldoc_has_inside(), and xmldoc_reverse_helper().
Referenced by ast_xmldoc_build_syntax(), and xmldoc_parse_optionlist().
00673 { 00674 #define GOTONEXT(__rev, __a) (__rev ? ast_xml_node_get_prev(__a) : ast_xml_node_get_next(__a)) 00675 #define ISLAST(__rev, __a) (__rev == 1 ? (ast_xml_node_get_prev(__a) ? 0 : 1) : (ast_xml_node_get_next(__a) ? 0 : 1)) 00676 #define MP(__a) ((multiple ? __a : "")) 00677 struct ast_xml_node *node = NULL, *firstparam = NULL, *lastparam = NULL; 00678 const char *paramtype, *multipletype, *paramnameattr, *attrargsep, *parenthesis, *argname; 00679 int reverse, required, paramcount = 0, openbrackets = 0, len = 0, hasparams=0; 00680 int reqfinode = 0, reqlanode = 0, optmidnode = 0, prnparenthesis, multiple; 00681 char *syntax = NULL, *argsep, *paramname; 00682 00683 if (ast_strlen_zero(rootname) || ast_strlen_zero(childname)) { 00684 ast_log(LOG_WARNING, "Tried to look in XML tree with faulty rootname or childname while creating a syntax.\n"); 00685 return NULL; 00686 } 00687 00688 if (!rootnode || !ast_xml_node_get_children(rootnode)) { 00689 /* If the rootnode field is not found, at least print name. */ 00690 ast_asprintf(&syntax, "%s%s", (printrootname ? rootname : ""), (printparenthesis ? "()" : "")); 00691 return syntax; 00692 } 00693 00694 /* Get the argument separator from the root node attribute name 'argsep', if not found 00695 defaults to ','. */ 00696 attrargsep = ast_xml_get_attribute(rootnode, "argsep"); 00697 if (attrargsep) { 00698 argsep = ast_strdupa(attrargsep); 00699 ast_xml_free_attr(attrargsep); 00700 } else { 00701 argsep = ast_strdupa(","); 00702 } 00703 00704 /* Get order of evaluation. */ 00705 for (node = ast_xml_node_get_children(rootnode); node; node = ast_xml_node_get_next(node)) { 00706 if (strcasecmp(ast_xml_node_get_name(node), childname)) { 00707 continue; 00708 } 00709 required = 0; 00710 hasparams = 1; 00711 if ((paramtype = ast_xml_get_attribute(node, "required"))) { 00712 if (ast_true(paramtype)) { 00713 required = 1; 00714 } 00715 ast_xml_free_attr(paramtype); 00716 } 00717 00718 lastparam = node; 00719 reqlanode = required; 00720 00721 if (!firstparam) { 00722 /* first parameter node */ 00723 firstparam = node; 00724 reqfinode = required; 00725 } 00726 } 00727 00728 if (!hasparams) { 00729 /* This application, function, option, etc, doesn't have any params. */ 00730 ast_asprintf(&syntax, "%s%s", (printrootname ? rootname : ""), (printparenthesis ? "()" : "")); 00731 return syntax; 00732 } 00733 00734 if (reqfinode && reqlanode) { 00735 /* check midnode */ 00736 for (node = ast_xml_node_get_children(rootnode); node; node = ast_xml_node_get_next(node)) { 00737 if (strcasecmp(ast_xml_node_get_name(node), childname)) { 00738 continue; 00739 } 00740 if (node != firstparam && node != lastparam) { 00741 if ((paramtype = ast_xml_get_attribute(node, "required"))) { 00742 if (!ast_true(paramtype)) { 00743 optmidnode = 1; 00744 break; 00745 } 00746 ast_xml_free_attr(paramtype); 00747 } 00748 } 00749 } 00750 } 00751 00752 if ((!reqfinode && reqlanode) || (reqfinode && reqlanode && optmidnode)) { 00753 reverse = 1; 00754 node = lastparam; 00755 } else { 00756 reverse = 0; 00757 node = firstparam; 00758 } 00759 00760 /* init syntax string. */ 00761 if (reverse) { 00762 xmldoc_reverse_helper(reverse, &len, &syntax, 00763 (printrootname ? (printrootname == 2 ? ")]" : ")"): "")); 00764 } else { 00765 xmldoc_reverse_helper(reverse, &len, &syntax, "%s%s", (printrootname ? rootname : ""), 00766 (printrootname ? (printrootname == 2 ? "[(" : "(") : "")); 00767 } 00768 00769 for (; node; node = GOTONEXT(reverse, node)) { 00770 if (strcasecmp(ast_xml_node_get_name(node), childname)) { 00771 continue; 00772 } 00773 00774 /* Get the argument name, if it is not the leaf, go inside that parameter. */ 00775 if (xmldoc_has_inside(node, "argument")) { 00776 parenthesis = ast_xml_get_attribute(node, "hasparams"); 00777 prnparenthesis = 0; 00778 if (parenthesis) { 00779 prnparenthesis = ast_true(parenthesis); 00780 if (!strcasecmp(parenthesis, "optional")) { 00781 prnparenthesis = 2; 00782 } 00783 ast_xml_free_attr(parenthesis); 00784 } 00785 argname = ast_xml_get_attribute(node, "name"); 00786 if (argname) { 00787 paramname = xmldoc_get_syntax_fun(node, argname, "argument", prnparenthesis, prnparenthesis); 00788 ast_xml_free_attr(argname); 00789 } else { 00790 /* Malformed XML, print **UNKOWN** */ 00791 paramname = ast_strdup("**unknown**"); 00792 } 00793 } else { 00794 paramnameattr = ast_xml_get_attribute(node, "name"); 00795 if (!paramnameattr) { 00796 ast_log(LOG_WARNING, "Malformed XML %s: no %s name\n", rootname, childname); 00797 if (syntax) { 00798 /* Free already allocated syntax */ 00799 ast_free(syntax); 00800 } 00801 /* to give up is ok? */ 00802 ast_asprintf(&syntax, "%s%s", (printrootname ? rootname : ""), (printparenthesis ? "()" : "")); 00803 return syntax; 00804 } 00805 paramname = ast_strdup(paramnameattr); 00806 ast_xml_free_attr(paramnameattr); 00807 } 00808 00809 /* Defaults to 'false'. */ 00810 multiple = 0; 00811 if ((multipletype = ast_xml_get_attribute(node, "multiple"))) { 00812 if (ast_true(multipletype)) { 00813 multiple = 1; 00814 } 00815 ast_xml_free_attr(multipletype); 00816 } 00817 00818 required = 0; /* Defaults to 'false'. */ 00819 if ((paramtype = ast_xml_get_attribute(node, "required"))) { 00820 if (ast_true(paramtype)) { 00821 required = 1; 00822 } 00823 ast_xml_free_attr(paramtype); 00824 } 00825 00826 /* build syntax core. */ 00827 00828 if (required) { 00829 /* First parameter */ 00830 if (!paramcount) { 00831 xmldoc_reverse_helper(reverse, &len, &syntax, "%s%s%s%s", paramname, MP("["), MP(argsep), MP("...]")); 00832 } else { 00833 /* Time to close open brackets. */ 00834 while (openbrackets > 0) { 00835 xmldoc_reverse_helper(reverse, &len, &syntax, (reverse ? "[" : "]")); 00836 openbrackets--; 00837 } 00838 if (reverse) { 00839 xmldoc_reverse_helper(reverse, &len, &syntax, "%s%s", paramname, argsep); 00840 } else { 00841 xmldoc_reverse_helper(reverse, &len, &syntax, "%s%s", argsep, paramname); 00842 } 00843 xmldoc_reverse_helper(reverse, &len, &syntax, "%s%s%s", MP("["), MP(argsep), MP("...]")); 00844 } 00845 } else { 00846 /* First parameter */ 00847 if (!paramcount) { 00848 xmldoc_reverse_helper(reverse, &len, &syntax, "[%s%s%s%s]", paramname, MP("["), MP(argsep), MP("...]")); 00849 } else { 00850 if (ISLAST(reverse, node)) { 00851 /* This is the last parameter. */ 00852 if (reverse) { 00853 xmldoc_reverse_helper(reverse, &len, &syntax, "[%s%s%s%s]%s", paramname, 00854 MP("["), MP(argsep), MP("...]"), argsep); 00855 } else { 00856 xmldoc_reverse_helper(reverse, &len, &syntax, "%s[%s%s%s%s]", argsep, paramname, 00857 MP("["), MP(argsep), MP("...]")); 00858 } 00859 } else { 00860 if (reverse) { 00861 xmldoc_reverse_helper(reverse, &len, &syntax, "%s%s%s%s%s]", paramname, argsep, 00862 MP("["), MP(argsep), MP("...]")); 00863 } else { 00864 xmldoc_reverse_helper(reverse, &len, &syntax, "[%s%s%s%s%s", argsep, paramname, 00865 MP("["), MP(argsep), MP("...]")); 00866 } 00867 openbrackets++; 00868 } 00869 } 00870 } 00871 ast_free(paramname); 00872 00873 paramcount++; 00874 } 00875 00876 /* Time to close open brackets. */ 00877 while (openbrackets > 0) { 00878 xmldoc_reverse_helper(reverse, &len, &syntax, (reverse ? "[" : "]")); 00879 openbrackets--; 00880 } 00881 00882 /* close syntax string. */ 00883 if (reverse) { 00884 xmldoc_reverse_helper(reverse, &len, &syntax, "%s%s", (printrootname ? rootname : ""), 00885 (printrootname ? (printrootname == 2 ? "[(" : "(") : "")); 00886 } else { 00887 xmldoc_reverse_helper(reverse, &len, &syntax, (printrootname ? (printrootname == 2 ? ")]" : ")") : "")); 00888 } 00889 00890 return syntax; 00891 #undef ISLAST 00892 #undef GOTONEXT 00893 #undef MP 00894 }
static char* xmldoc_get_syntax_manager | ( | struct ast_xml_node * | fixnode, | |
const char * | name | |||
) | [static] |
Definition at line 1046 of file xmldoc.c.
References ast_free, ast_str_append(), ast_str_buffer(), ast_str_create(), ast_strdup, ast_true(), ast_xml_free_attr(), ast_xml_get_attribute(), ast_xml_node_get_children(), ast_xml_node_get_name(), and ast_xml_node_get_next().
Referenced by ast_xmldoc_build_syntax().
01047 { 01048 struct ast_str *syntax; 01049 struct ast_xml_node *node = fixnode; 01050 const char *paramtype, *attrname; 01051 int required; 01052 char *ret; 01053 01054 syntax = ast_str_create(128); 01055 if (!syntax) { 01056 return ast_strdup(name); 01057 } 01058 01059 ast_str_append(&syntax, 0, "Action: %s", name); 01060 01061 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 01062 if (strcasecmp(ast_xml_node_get_name(node), "parameter")) { 01063 continue; 01064 } 01065 01066 /* Is this parameter required? */ 01067 required = 0; 01068 paramtype = ast_xml_get_attribute(node, "required"); 01069 if (paramtype) { 01070 required = ast_true(paramtype); 01071 ast_xml_free_attr(paramtype); 01072 } 01073 01074 attrname = ast_xml_get_attribute(node, "name"); 01075 if (!attrname) { 01076 /* ignore this bogus parameter and continue. */ 01077 continue; 01078 } 01079 01080 ast_str_append(&syntax, 0, "\n%s%s:%s <value>", 01081 (required ? "" : "["), 01082 attrname, 01083 (required ? "" : "]")); 01084 01085 ast_xml_free_attr(attrname); 01086 } 01087 01088 /* return a common string. */ 01089 ret = ast_strdup(ast_str_buffer(syntax)); 01090 ast_free(syntax); 01091 01092 return ret; 01093 }
static enum syntaxtype xmldoc_get_syntax_type | ( | const char * | type | ) | [static] |
Definition at line 1118 of file xmldoc.c.
References ARRAY_LEN, FUNCTION_SYNTAX, strsyntaxtype::stxtype, and stxtype.
Referenced by ast_xmldoc_build_syntax().
01119 { 01120 int i; 01121 for (i=0; i < ARRAY_LEN(stxtype); i++) { 01122 if (!strcasecmp(stxtype[i].type, type)) { 01123 return stxtype[i].stxtype; 01124 } 01125 } 01126 01127 return FUNCTION_SYNTAX; 01128 }
static int xmldoc_has_inside | ( | struct ast_xml_node * | fixnode, | |
const char * | what | |||
) | [static] |
Definition at line 611 of file xmldoc.c.
References ast_xml_node_get_children(), ast_xml_node_get_name(), and ast_xml_node_get_next().
Referenced by xmldoc_get_syntax_cmd(), xmldoc_get_syntax_fun(), xmldoc_parse_argument(), and xmldoc_parse_parameter().
00612 { 00613 struct ast_xml_node *node = fixnode; 00614 00615 for (node = ast_xml_node_get_children(fixnode); node; node = ast_xml_node_get_next(node)) { 00616 if (!strcasecmp(ast_xml_node_get_name(node), what)) { 00617 return 1; 00618 } 00619 } 00620 return 0; 00621 }
static int xmldoc_has_nodes | ( | struct ast_xml_node * | fixnode | ) | [static] |
Definition at line 629 of file xmldoc.c.
References ast_xml_node_get_children(), ast_xml_node_get_name(), and ast_xml_node_get_next().
Referenced by xmldoc_parse_parameter().
00630 { 00631 struct ast_xml_node *node = fixnode; 00632 00633 for (node = ast_xml_node_get_children(fixnode); node; node = ast_xml_node_get_next(node)) { 00634 if (strcasecmp(ast_xml_node_get_name(node), "text")) { 00635 return 1; 00636 } 00637 } 00638 return 0; 00639 }
static int xmldoc_has_specialtags | ( | struct ast_xml_node * | fixnode | ) | [static] |
Definition at line 647 of file xmldoc.c.
References ARRAY_LEN, ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), and special_tags.
Referenced by xmldoc_parse_argument().
00648 { 00649 struct ast_xml_node *node = fixnode; 00650 int i; 00651 00652 for (node = ast_xml_node_get_children(fixnode); node; node = ast_xml_node_get_next(node)) { 00653 for (i = 0; i < ARRAY_LEN(special_tags); i++) { 00654 if (!strcasecmp(ast_xml_node_get_name(node), special_tags[i].tagname)) { 00655 return 1; 00656 } 00657 } 00658 } 00659 return 0; 00660 }
static int xmldoc_parse_argument | ( | struct ast_xml_node * | fixnode, | |
int | insideparameter, | |||
const char * | paramtabs, | |||
const char * | tabs, | |||
struct ast_str ** | buffer | |||
) | [static] |
Definition at line 1280 of file xmldoc.c.
References ast_str_append(), ast_xml_free_attr(), ast_xml_get_attribute(), ast_xml_node_get_children(), ast_xml_node_get_next(), xmldoc_has_inside(), xmldoc_has_specialtags(), xmldoc_parse_para(), and xmldoc_parse_specialtags().
Referenced by xmldoc_parse_option(), and xmldoc_parse_parameter().
01281 { 01282 struct ast_xml_node *node = fixnode; 01283 const char *argname; 01284 int count = 0, ret = 0; 01285 01286 if (!node || !ast_xml_node_get_children(node)) { 01287 return ret; 01288 } 01289 01290 /* Print the argument names */ 01291 argname = ast_xml_get_attribute(node, "name"); 01292 if (!argname) { 01293 return 0; 01294 } 01295 if (xmldoc_has_inside(node, "para") || xmldoc_has_specialtags(node)) { 01296 ast_str_append(buffer, 0, "%s%s%s", tabs, argname, (insideparameter ? "\n" : "")); 01297 ast_xml_free_attr(argname); 01298 } else { 01299 ast_xml_free_attr(argname); 01300 return 0; 01301 } 01302 01303 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 01304 if (xmldoc_parse_para(node, (insideparameter ? paramtabs : (!count ? " - " : tabs)), "\n", buffer) == 2) { 01305 count++; 01306 ret = 1; 01307 } else if (xmldoc_parse_specialtags(node, (insideparameter ? paramtabs : (!count ? " - " : tabs)), "\n", buffer) == 2) { 01308 count++; 01309 ret = 1; 01310 } 01311 } 01312 01313 return ret; 01314 }
static char* xmldoc_parse_cmd_enumlist | ( | struct ast_xml_node * | fixnode | ) | [static] |
Definition at line 903 of file xmldoc.c.
References ast_free, ast_str_append(), ast_str_buffer(), ast_str_create(), ast_strdup, ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), first, and xmldoc_get_syntax_cmd().
Referenced by xmldoc_get_syntax_cmd().
00904 { 00905 struct ast_xml_node *node = fixnode; 00906 struct ast_str *paramname; 00907 char *enumname, *ret; 00908 int first = 1; 00909 00910 paramname = ast_str_create(128); 00911 if (!paramname) { 00912 return ast_strdup("{<unkown>}"); 00913 } 00914 00915 ast_str_append(¶mname, 0, "{"); 00916 00917 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 00918 if (strcasecmp(ast_xml_node_get_name(node), "enum")) { 00919 continue; 00920 } 00921 00922 enumname = xmldoc_get_syntax_cmd(node, "", 0); 00923 if (!enumname) { 00924 continue; 00925 } 00926 if (!first) { 00927 ast_str_append(¶mname, 0, "|"); 00928 } 00929 ast_str_append(¶mname, 0, "%s", enumname); 00930 first = 0; 00931 ast_free(enumname); 00932 } 00933 00934 ast_str_append(¶mname, 0, "}"); 00935 00936 ret = ast_strdup(ast_str_buffer(paramname)); 00937 ast_free(paramname); 00938 00939 return ret; 00940 }
static int xmldoc_parse_enum | ( | struct ast_xml_node * | fixnode, | |
const char * | tabs, | |||
struct ast_str ** | buffer | |||
) | [static] |
Definition at line 1516 of file xmldoc.c.
References ast_asprintf, ast_free, ast_xml_node_get_children(), ast_xml_node_get_next(), xmldoc_parse_enumlist(), xmldoc_parse_para(), and xmldoc_parse_specialtags().
Referenced by xmldoc_parse_enumlist().
01517 { 01518 struct ast_xml_node *node = fixnode; 01519 int ret = 0; 01520 char *optiontabs; 01521 01522 ast_asprintf(&optiontabs, "%s ", tabs); 01523 01524 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 01525 if ((xmldoc_parse_para(node, (ret ? tabs : " - "), "\n", buffer))) { 01526 ret = 1; 01527 } else if ((xmldoc_parse_specialtags(node, (ret ? tabs : " - "), "\n", buffer))) { 01528 ret = 1; 01529 } 01530 01531 xmldoc_parse_enumlist(node, optiontabs, buffer); 01532 } 01533 01534 ast_free(optiontabs); 01535 01536 return ret; 01537 }
static int xmldoc_parse_enumlist | ( | struct ast_xml_node * | fixnode, | |
const char * | tabs, | |||
struct ast_str ** | buffer | |||
) | [static] |
Definition at line 1546 of file xmldoc.c.
References ast_str_append(), ast_xml_free_attr(), ast_xml_get_attribute(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), and xmldoc_parse_enum().
Referenced by xmldoc_get_formatted(), xmldoc_parse_enum(), xmldoc_parse_option(), and xmldoc_parse_parameter().
01547 { 01548 struct ast_xml_node *node = fixnode; 01549 const char *enumname; 01550 int ret = 0; 01551 01552 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 01553 if (strcasecmp(ast_xml_node_get_name(node), "enum")) { 01554 continue; 01555 } 01556 01557 enumname = ast_xml_get_attribute(node, "name"); 01558 if (enumname) { 01559 ast_str_append(buffer, 0, "%s<enum>%s</enum>", tabs, enumname); 01560 ast_xml_free_attr(enumname); 01561 01562 /* parse only enum elements inside a enumlist node. */ 01563 if ((xmldoc_parse_enum(node, tabs, buffer))) { 01564 ret = 1; 01565 } else { 01566 ast_str_append(buffer, 0, "\n"); 01567 } 01568 } 01569 } 01570 return ret; 01571 }
static int xmldoc_parse_option | ( | struct ast_xml_node * | fixnode, | |
const char * | tabs, | |||
struct ast_str ** | buffer | |||
) | [static] |
Definition at line 1582 of file xmldoc.c.
References ast_asprintf, ast_free, ast_str_append(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), xmldoc_parse_argument(), xmldoc_parse_enumlist(), xmldoc_parse_para(), xmldoc_parse_specialtags(), and xmldoc_parse_variablelist().
Referenced by xmldoc_parse_optionlist().
01583 { 01584 struct ast_xml_node *node; 01585 int ret = 0; 01586 char *optiontabs; 01587 01588 ast_asprintf(&optiontabs, "%s ", tabs); 01589 if (!optiontabs) { 01590 return ret; 01591 } 01592 for (node = ast_xml_node_get_children(fixnode); node; node = ast_xml_node_get_next(node)) { 01593 if (!strcasecmp(ast_xml_node_get_name(node), "argument")) { 01594 /* if this is the first data appended to buffer, print a \n*/ 01595 if (!ret && ast_xml_node_get_children(node)) { 01596 /* print \n */ 01597 ast_str_append(buffer, 0, "\n"); 01598 } 01599 if (xmldoc_parse_argument(node, 0, NULL, optiontabs, buffer)) { 01600 ret = 1; 01601 } 01602 continue; 01603 } 01604 01605 if (xmldoc_parse_para(node, (ret ? tabs : ""), "\n", buffer)) { 01606 ret = 1; 01607 } else if (xmldoc_parse_specialtags(node, (ret ? tabs : ""), "\n", buffer)) { 01608 ret = 1; 01609 } 01610 01611 xmldoc_parse_variablelist(node, optiontabs, buffer); 01612 01613 xmldoc_parse_enumlist(node, optiontabs, buffer); 01614 } 01615 ast_free(optiontabs); 01616 01617 return ret; 01618 }
static void xmldoc_parse_optionlist | ( | struct ast_xml_node * | fixnode, | |
const char * | tabs, | |||
struct ast_str ** | buffer | |||
) | [static] |
Definition at line 1627 of file xmldoc.c.
References ast_str_append(), ast_xml_free_attr(), ast_xml_get_attribute(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), xmldoc_get_syntax_fun(), and xmldoc_parse_option().
Referenced by xmldoc_parse_parameter().
01628 { 01629 struct ast_xml_node *node; 01630 const char *optname, *hasparams; 01631 char *optionsyntax; 01632 int optparams; 01633 01634 for (node = ast_xml_node_get_children(fixnode); node; node = ast_xml_node_get_next(node)) { 01635 /* Start appending every option tag. */ 01636 if (strcasecmp(ast_xml_node_get_name(node), "option")) { 01637 continue; 01638 } 01639 01640 /* Get the option name. */ 01641 optname = ast_xml_get_attribute(node, "name"); 01642 if (!optname) { 01643 continue; 01644 } 01645 01646 optparams = 1; 01647 hasparams = ast_xml_get_attribute(node, "hasparams"); 01648 if (hasparams && !strcasecmp(hasparams, "optional")) { 01649 optparams = 2; 01650 } 01651 01652 optionsyntax = xmldoc_get_syntax_fun(node, optname, "argument", 0, optparams); 01653 if (!optionsyntax) { 01654 ast_xml_free_attr(optname); 01655 ast_xml_free_attr(hasparams); 01656 continue; 01657 } 01658 01659 ast_str_append(buffer, 0, "%s%s: ", tabs, optionsyntax); 01660 01661 if (!xmldoc_parse_option(node, tabs, buffer)) { 01662 ast_str_append(buffer, 0, "\n"); 01663 } 01664 ast_str_append(buffer, 0, "\n"); 01665 ast_xml_free_attr(optname); 01666 ast_xml_free_attr(hasparams); 01667 } 01668 }
static int xmldoc_parse_para | ( | struct ast_xml_node * | node, | |
const char * | tabs, | |||
const char * | posttabs, | |||
struct ast_str ** | buffer | |||
) | [static] |
Definition at line 1176 of file xmldoc.c.
References ast_free, ast_str_append(), ast_str_buffer(), ast_xml_free_text(), ast_xml_get_text(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), and xmldoc_string_cleanup().
Referenced by xmldoc_get_formatted(), xmldoc_parse_argument(), xmldoc_parse_enum(), xmldoc_parse_option(), xmldoc_parse_parameter(), xmldoc_parse_specialtags(), xmldoc_parse_variable(), and xmldoc_parse_variablelist().
01177 { 01178 const char *tmptext; 01179 struct ast_xml_node *tmp; 01180 int ret = 0; 01181 struct ast_str *tmpstr; 01182 01183 if (!node || !ast_xml_node_get_children(node)) { 01184 return ret; 01185 } 01186 01187 if (strcasecmp(ast_xml_node_get_name(node), "para")) { 01188 return ret; 01189 } 01190 01191 ast_str_append(buffer, 0, "%s", tabs); 01192 01193 ret = 1; 01194 01195 for (tmp = ast_xml_node_get_children(node); tmp; tmp = ast_xml_node_get_next(tmp)) { 01196 /* Get the text inside the <para> element and append it to buffer. */ 01197 tmptext = ast_xml_get_text(tmp); 01198 if (tmptext) { 01199 /* Strip \n etc. */ 01200 xmldoc_string_cleanup(tmptext, &tmpstr, 0); 01201 ast_xml_free_text(tmptext); 01202 if (tmpstr) { 01203 if (strcasecmp(ast_xml_node_get_name(tmp), "text")) { 01204 ast_str_append(buffer, 0, "<%s>%s</%s>", ast_xml_node_get_name(tmp), 01205 ast_str_buffer(tmpstr), ast_xml_node_get_name(tmp)); 01206 } else { 01207 ast_str_append(buffer, 0, "%s", ast_str_buffer(tmpstr)); 01208 } 01209 ast_free(tmpstr); 01210 ret = 2; 01211 } 01212 } 01213 } 01214 01215 ast_str_append(buffer, 0, "%s", posttabs); 01216 01217 return ret; 01218 }
static void xmldoc_parse_parameter | ( | struct ast_xml_node * | fixnode, | |
const char * | tabs, | |||
struct ast_str ** | buffer | |||
) | [static] |
Definition at line 1677 of file xmldoc.c.
References ast_asprintf, ast_free, ast_str_append(), ast_xml_free_attr(), ast_xml_get_attribute(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), xmldoc_has_inside(), xmldoc_has_nodes(), xmldoc_parse_argument(), xmldoc_parse_enumlist(), xmldoc_parse_optionlist(), xmldoc_parse_para(), and xmldoc_parse_specialtags().
Referenced by ast_xmldoc_build_arguments().
01678 { 01679 const char *paramname; 01680 struct ast_xml_node *node = fixnode; 01681 int hasarguments, printed = 0; 01682 char *internaltabs; 01683 01684 if (strcasecmp(ast_xml_node_get_name(node), "parameter")) { 01685 return; 01686 } 01687 01688 hasarguments = xmldoc_has_inside(node, "argument"); 01689 if (!(paramname = ast_xml_get_attribute(node, "name"))) { 01690 /* parameter MUST have an attribute name. */ 01691 return; 01692 } 01693 01694 ast_asprintf(&internaltabs, "%s ", tabs); 01695 if (!internaltabs) { 01696 return; 01697 } 01698 01699 if (!hasarguments && xmldoc_has_nodes(node)) { 01700 ast_str_append(buffer, 0, "%s\n", paramname); 01701 ast_xml_free_attr(paramname); 01702 printed = 1; 01703 } 01704 01705 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 01706 if (!strcasecmp(ast_xml_node_get_name(node), "optionlist")) { 01707 xmldoc_parse_optionlist(node, internaltabs, buffer); 01708 } else if (!strcasecmp(ast_xml_node_get_name(node), "enumlist")) { 01709 xmldoc_parse_enumlist(node, internaltabs, buffer); 01710 } else if (!strcasecmp(ast_xml_node_get_name(node), "argument")) { 01711 xmldoc_parse_argument(node, 1, internaltabs, (!hasarguments ? " " : ""), buffer); 01712 } else if (!strcasecmp(ast_xml_node_get_name(node), "para")) { 01713 if (!printed) { 01714 ast_str_append(buffer, 0, "%s\n", paramname); 01715 ast_xml_free_attr(paramname); 01716 printed = 1; 01717 } 01718 xmldoc_parse_para(node, internaltabs, "\n", buffer); 01719 continue; 01720 } else if ((xmldoc_parse_specialtags(node, internaltabs, "\n", buffer))) { 01721 continue; 01722 } 01723 } 01724 if (!printed) { 01725 ast_xml_free_attr(paramname); 01726 } 01727 ast_free(internaltabs); 01728 }
static int xmldoc_parse_specialtags | ( | struct ast_xml_node * | fixnode, | |
const char * | tabs, | |||
const char * | posttabs, | |||
struct ast_str ** | buffer | |||
) | [static] |
Definition at line 1230 of file xmldoc.c.
References ARRAY_LEN, ast_str_append(), ast_strlen_zero(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), special_tags, and xmldoc_parse_para().
Referenced by xmldoc_get_formatted(), xmldoc_parse_argument(), xmldoc_parse_enum(), xmldoc_parse_option(), xmldoc_parse_parameter(), xmldoc_parse_variable(), and xmldoc_parse_variablelist().
01231 { 01232 struct ast_xml_node *node = fixnode; 01233 int ret = 0, i, count = 0; 01234 01235 if (!node || !ast_xml_node_get_children(node)) { 01236 return ret; 01237 } 01238 01239 for (i = 0; i < ARRAY_LEN(special_tags); i++) { 01240 if (strcasecmp(ast_xml_node_get_name(node), special_tags[i].tagname)) { 01241 continue; 01242 } 01243 01244 ret = 1; 01245 /* This is a special tag. */ 01246 01247 /* concat data */ 01248 if (!ast_strlen_zero(special_tags[i].init)) { 01249 ast_str_append(buffer, 0, "%s%s", tabs, special_tags[i].init); 01250 } 01251 01252 /* parse <para> elements inside special tags. */ 01253 for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { 01254 /* first <para> just print it without tabs at the begining. */ 01255 if (xmldoc_parse_para(node, (!count ? "" : tabs), posttabs, buffer) == 2) { 01256 ret = 2; 01257 } 01258 } 01259 01260 if (!ast_strlen_zero(special_tags[i].end)) { 01261 ast_str_append(buffer, 0, "%s%s", special_tags[i].end, posttabs); 01262 } 01263 01264 break; 01265 } 01266 01267 return ret; 01268 }
static int xmldoc_parse_variable | ( | struct ast_xml_node * | node, | |
const char * | tabs, | |||
struct ast_str ** | buffer | |||
) | [static] |
Definition at line 1327 of file xmldoc.c.
References ast_free, ast_str_append(), ast_str_buffer(), ast_str_strlen(), ast_xml_free_attr(), ast_xml_free_text(), ast_xml_get_attribute(), ast_xml_get_text(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), xmldoc_parse_para(), xmldoc_parse_specialtags(), and xmldoc_string_cleanup().
Referenced by xmldoc_parse_variablelist().
01328 { 01329 struct ast_xml_node *tmp; 01330 const char *valname; 01331 const char *tmptext; 01332 struct ast_str *cleanstr; 01333 int ret = 0, printedpara=0; 01334 01335 for (tmp = ast_xml_node_get_children(node); tmp; tmp = ast_xml_node_get_next(tmp)) { 01336 if (xmldoc_parse_para(tmp, (ret ? tabs : ""), "\n", buffer)) { 01337 printedpara = 1; 01338 continue; 01339 } else if (xmldoc_parse_specialtags(tmp, (ret ? tabs : ""), "\n", buffer)) { 01340 printedpara = 1; 01341 continue; 01342 } 01343 01344 if (strcasecmp(ast_xml_node_get_name(tmp), "value")) { 01345 continue; 01346 } 01347 01348 /* Parse a <value> tag only. */ 01349 if (!printedpara) { 01350 ast_str_append(buffer, 0, "\n"); 01351 printedpara = 1; 01352 } 01353 /* Parse each <value name='valuename'>desciption</value> */ 01354 valname = ast_xml_get_attribute(tmp, "name"); 01355 if (valname) { 01356 ret = 1; 01357 ast_str_append(buffer, 0, "%s<value>%s</value>", tabs, valname); 01358 ast_xml_free_attr(valname); 01359 } 01360 tmptext = ast_xml_get_text(tmp); 01361 /* Check inside this node for any explanation about its meaning. */ 01362 if (tmptext) { 01363 /* Cleanup text. */ 01364 xmldoc_string_cleanup(tmptext, &cleanstr, 1); 01365 ast_xml_free_text(tmptext); 01366 if (cleanstr && ast_str_strlen(cleanstr) > 0) { 01367 ast_str_append(buffer, 0, ":%s", ast_str_buffer(cleanstr)); 01368 } 01369 ast_free(cleanstr); 01370 } 01371 ast_str_append(buffer, 0, "\n"); 01372 } 01373 01374 return ret; 01375 }
static int xmldoc_parse_variablelist | ( | struct ast_xml_node * | node, | |
const char * | tabs, | |||
struct ast_str ** | buffer | |||
) | [static] |
Definition at line 1388 of file xmldoc.c.
References ast_asprintf, ast_free, ast_str_append(), ast_xml_free_attr(), ast_xml_get_attribute(), ast_xml_node_get_children(), ast_xml_node_get_name(), ast_xml_node_get_next(), xmldoc_parse_para(), xmldoc_parse_specialtags(), and xmldoc_parse_variable().
Referenced by xmldoc_get_formatted(), and xmldoc_parse_option().
01389 { 01390 struct ast_xml_node *tmp; 01391 const char *varname; 01392 char *vartabs; 01393 int ret = 0; 01394 01395 if (!node || !ast_xml_node_get_children(node)) { 01396 return ret; 01397 } 01398 01399 if (strcasecmp(ast_xml_node_get_name(node), "variablelist")) { 01400 return ret; 01401 } 01402 01403 /* use this spacing (add 4 spaces) inside a variablelist node. */ 01404 ast_asprintf(&vartabs, "%s ", tabs); 01405 if (!vartabs) { 01406 return ret; 01407 } 01408 for (tmp = ast_xml_node_get_children(node); tmp; tmp = ast_xml_node_get_next(tmp)) { 01409 /* We can have a <para> element inside the variable list */ 01410 if ((xmldoc_parse_para(tmp, (ret ? tabs : ""), "\n", buffer))) { 01411 ret = 1; 01412 continue; 01413 } else if ((xmldoc_parse_specialtags(tmp, (ret ? tabs : ""), "\n", buffer))) { 01414 ret = 1; 01415 continue; 01416 } 01417 01418 if (!strcasecmp(ast_xml_node_get_name(tmp), "variable")) { 01419 /* Store the variable name in buffer. */ 01420 varname = ast_xml_get_attribute(tmp, "name"); 01421 if (varname) { 01422 ast_str_append(buffer, 0, "%s<variable>%s</variable>: ", tabs, varname); 01423 ast_xml_free_attr(varname); 01424 /* Parse the <variable> possible values. */ 01425 xmldoc_parse_variable(tmp, vartabs, buffer); 01426 ret = 1; 01427 } 01428 } 01429 } 01430 01431 ast_free(vartabs); 01432 01433 return ret; 01434 }
static int xmldoc_postbrlen | ( | const char * | postbr | ) | [static] |
Definition at line 111 of file xmldoc.c.
Referenced by xmldoc_string_wrap().
00112 { 00113 int postbrreallen = 0, i; 00114 size_t postbrlen; 00115 00116 if (!postbr) { 00117 return 0; 00118 } 00119 postbrlen = strlen(postbr); 00120 for (i = 0; i < postbrlen; i++) { 00121 if (postbr[i] == '\t') { 00122 postbrreallen += 8 - (postbrreallen % 8); 00123 } else { 00124 postbrreallen++; 00125 } 00126 } 00127 return postbrreallen; 00128 }
static void xmldoc_reverse_helper | ( | int | reverse, | |
int * | len, | |||
char ** | syntax, | |||
const char * | fmt, | |||
... | ||||
) | [static] |
Definition at line 565 of file xmldoc.c.
References ast_free, ast_realloc, and ast_vasprintf.
Referenced by xmldoc_get_syntax_fun().
00566 { 00567 int totlen, tmpfmtlen; 00568 char *tmpfmt, tmp; 00569 va_list ap; 00570 00571 va_start(ap, fmt); 00572 if (ast_vasprintf(&tmpfmt, fmt, ap) < 0) { 00573 va_end(ap); 00574 return; 00575 } 00576 va_end(ap); 00577 00578 tmpfmtlen = strlen(tmpfmt); 00579 totlen = *len + tmpfmtlen + 1; 00580 00581 *syntax = ast_realloc(*syntax, totlen); 00582 00583 if (!*syntax) { 00584 ast_free(tmpfmt); 00585 return; 00586 } 00587 00588 if (reverse) { 00589 memmove(*syntax + tmpfmtlen, *syntax, *len); 00590 /* Save this char, it will be overwritten by the \0 of strcpy. */ 00591 tmp = (*syntax)[0]; 00592 strcpy(*syntax, tmpfmt); 00593 /* Restore the already saved char. */ 00594 (*syntax)[tmpfmtlen] = tmp; 00595 (*syntax)[totlen - 1] = '\0'; 00596 } else { 00597 strcpy(*syntax + *len, tmpfmt); 00598 } 00599 00600 *len = totlen - 1; 00601 ast_free(tmpfmt); 00602 }
static void xmldoc_setpostbr | ( | char * | postbr, | |
size_t | len, | |||
const char * | text | |||
) | [static] |
Definition at line 137 of file xmldoc.c.
Referenced by xmldoc_string_wrap().
00138 { 00139 int c, postbrlen = 0; 00140 00141 if (!text) { 00142 return; 00143 } 00144 00145 for (c = 0; c < len; c++) { 00146 if (text[c] == '\t' || text[c] == ' ') { 00147 postbr[postbrlen++] = text[c]; 00148 } else { 00149 break; 00150 } 00151 } 00152 postbr[postbrlen] = '\0'; 00153 }
static void xmldoc_string_cleanup | ( | const char * | text, | |
struct ast_str ** | output, | |||
int | lastspaces | |||
) | [static] |
Definition at line 421 of file xmldoc.c.
References ast_log(), ast_str_append(), ast_str_create(), ast_str_trim_blanks(), and LOG_ERROR.
Referenced by xmldoc_get_formatted(), xmldoc_parse_para(), and xmldoc_parse_variable().
00422 { 00423 int i; 00424 size_t textlen; 00425 00426 if (!text) { 00427 *output = NULL; 00428 return; 00429 } 00430 00431 textlen = strlen(text); 00432 00433 *output = ast_str_create(textlen); 00434 if (!(*output)) { 00435 ast_log(LOG_ERROR, "Problem allocating output buffer\n"); 00436 return; 00437 } 00438 00439 for (i = 0; i < textlen; i++) { 00440 if (text[i] == '\n' || text[i] == '\r') { 00441 /* remove spaces/tabs/\n after a \n. */ 00442 while (text[i + 1] == '\t' || text[i + 1] == '\r' || text[i + 1] == '\n') { 00443 i++; 00444 } 00445 ast_str_append(output, 0, " "); 00446 continue; 00447 } else { 00448 ast_str_append(output, 0, "%c", text[i]); 00449 } 00450 } 00451 00452 /* remove last spaces (we don't want always to remove the trailing spaces). */ 00453 if (lastspaces) { 00454 ast_str_trim_blanks(*output); 00455 } 00456 }
static char* xmldoc_string_wrap | ( | const char * | text, | |
int | columns, | |||
int | maxdiff | |||
) | [static] |
Definition at line 234 of file xmldoc.c.
References ast_free, ast_log(), ast_str_append(), ast_str_buffer(), ast_str_create(), ast_str_truncate(), ast_strdup, ESC, LOG_WARNING, xmldoc_foundspace_backward(), xmldoc_postbrlen(), xmldoc_setpostbr(), and xmldoc_wait_nextspace().
Referenced by ast_xmldoc_printable().
00235 { 00236 struct ast_str *tmp; 00237 char *ret, postbr[160]; 00238 int count = 1, i, backspace, needtobreak = 0, colmax, textlen; 00239 00240 /* sanity check */ 00241 if (!text || columns <= 0 || maxdiff < 0) { 00242 ast_log(LOG_WARNING, "Passing wrong arguments while trying to wrap the text\n"); 00243 return NULL; 00244 } 00245 00246 tmp = ast_str_create(strlen(text) * 3); 00247 00248 if (!tmp) { 00249 return NULL; 00250 } 00251 00252 /* Check for blanks and tabs and put them in postbr. */ 00253 xmldoc_setpostbr(postbr, sizeof(postbr), text); 00254 colmax = columns - xmldoc_postbrlen(postbr); 00255 00256 textlen = strlen(text); 00257 for (i = 0; i < textlen; i++) { 00258 if (needtobreak || !(count % colmax)) { 00259 if (text[i] == ' ') { 00260 ast_str_append(&tmp, 0, "\n%s", postbr); 00261 needtobreak = 0; 00262 count = 1; 00263 } else if (text[i] != '\n') { 00264 needtobreak = 1; 00265 if (xmldoc_wait_nextspace(text, i, maxdiff)) { 00266 /* wait for the next space */ 00267 ast_str_append(&tmp, 0, "%c", text[i]); 00268 continue; 00269 } 00270 /* Try to look backwards */ 00271 backspace = xmldoc_foundspace_backward(text, i, maxdiff); 00272 if (backspace) { 00273 needtobreak = 1; 00274 ast_str_truncate(tmp, -backspace); 00275 i -= backspace + 1; 00276 continue; 00277 } 00278 ast_str_append(&tmp, 0, "\n%s", postbr); 00279 needtobreak = 0; 00280 count = 1; 00281 } 00282 /* skip blanks after a \n */ 00283 while (text[i] == ' ') { 00284 i++; 00285 } 00286 } 00287 if (text[i] == '\n') { 00288 xmldoc_setpostbr(postbr, sizeof(postbr), &text[i] + 1); 00289 colmax = columns - xmldoc_postbrlen(postbr); 00290 needtobreak = 0; 00291 count = 1; 00292 } 00293 if (text[i] == ESC) { 00294 /* Ignore Escape sequences. */ 00295 do { 00296 ast_str_append(&tmp, 0, "%c", text[i]); 00297 i++; 00298 } while (i < textlen && text[i] != 'm'); 00299 } else { 00300 count++; 00301 } 00302 ast_str_append(&tmp, 0, "%c", text[i]); 00303 } 00304 00305 ret = ast_strdup(ast_str_buffer(tmp)); 00306 ast_free(tmp); 00307 00308 return ret; 00309 }
static int xmldoc_wait_nextspace | ( | const char * | text, | |
int | currentpos, | |||
int | maxdiff | |||
) | [static] |
Definition at line 165 of file xmldoc.c.
References ESC.
Referenced by xmldoc_string_wrap().
00166 { 00167 int i, textlen; 00168 00169 if (!text) { 00170 return 0; 00171 } 00172 00173 textlen = strlen(text); 00174 for (i = currentpos; i < textlen; i++) { 00175 if (text[i] == ESC) { 00176 /* Move to the end of the escape sequence */ 00177 while (i < textlen && text[i] != 'm') { 00178 i++; 00179 } 00180 } else if (text[i] == ' ' || text[i] == '\n') { 00181 /* Found the next space or linefeed */ 00182 return 1; 00183 } else if (i - currentpos > maxdiff) { 00184 /* We have looked the max distance and didn't find it */ 00185 return 0; 00186 } 00187 } 00188 00189 /* Reached the end and did not find it */ 00190 00191 return 0; 00192 }
struct strcolorized_tags colorized_tags[] [static] |
Referenced by ast_xmldoc_printable().
const char default_documentation_language[] = "en_US" [static] |
char documentation_language[6] [static] |
struct strspecial_tags special_tags[] [static] |
Referenced by xmldoc_has_specialtags(), and xmldoc_parse_specialtags().
struct strsyntaxtype stxtype[] [static] |
Mapping between type of node and type of syntax to generate.
Referenced by xmldoc_get_syntax_type().
const int xmldoc_max_diff = 5 [static] |
const int xmldoc_text_columns = 74 [static] |