Mon Mar 19 11:30:56 2012

Asterisk developer's documentation


xmldoc.c File Reference

XML Documentation API. More...

#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_strxmldoc_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.


Detailed Description

XML Documentation API.

Author:
Eliel C. Sardanons (LU1ALY) <eliels@gmail.com>
ExtRef:
libxml2 http://www.xmlsoft.org/

Definition in file xmldoc.c.


Define Documentation

#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().


Enumeration Type Documentation

enum syntaxtype

Types of syntax that we are able to generate.

Enumerator:
FUNCTION_SYNTAX 
MANAGER_SYNTAX 
COMMAND_SYNTAX 

Definition at line 1096 of file xmldoc.c.

01096                 {
01097    FUNCTION_SYNTAX,
01098    MANAGER_SYNTAX,
01099    COMMAND_SYNTAX
01100 };


Function Documentation

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.

Parameters:
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.
Return values:
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(&paramname, 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(&paramname, 0, "|");
00928       }
00929       ast_str_append(&paramname, 0, "%s", enumname);
00930       first = 0;
00931       ast_free(enumname);
00932    }
00933 
00934    ast_str_append(&paramname, 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 }


Variable Documentation

struct strcolorized_tags colorized_tags[] [static]

Referenced by ast_xmldoc_printable().

const char default_documentation_language[] = "en_US" [static]

Default documentation language.

Definition at line 41 of file xmldoc.c.

char documentation_language[6] [static]

XML documentation language.

Definition at line 53 of file xmldoc.c.

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]

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
.

Definition at line 50 of file xmldoc.c.

const int xmldoc_text_columns = 74 [static]

Number of columns to print when showing the XML documentation with a 'core show application/function *' CLI command. Used in text wrapping.

Definition at line 45 of file xmldoc.c.


Generated on Mon Mar 19 11:30:56 2012 for Asterisk - The Open Source Telephony Project by  doxygen 1.4.7