Lib/txml.c File Reference

Tiny XML ライブラリ. More...

#include "txml.h"
#include "jbxl_state.h"
Include dependency graph for txml.c:

Go to the source code of this file.

Functions

tXML * xml_parse (char *pp)
 文字列のXMLデータを解釈して，tXMLのツリーを生成する．
tXML * xml_parse_file (const char *fn)
 ファイルから読み込んでパースする．
tXML * xml_parse_seq (tXML *xml, char *pp)
 部分的な XMLデータを解釈して，tXMLのツリー構造に格納する．断片的にXMLデータを入力する場合に使用する．
tXML * xml_main_parse (tXML *xml, char *pp, int skip)
 部分的な XMLデータを解釈して，tXMLのツリー構造に格納する．パーサの内部的なメイン関数．
int xml_parse_start_node (char *pp, char **node_name, char **node_attr, int *node_end)
 XMLの開始ノードを処理する．.
int xml_parse_end_node (char *pp, char **node_name)
 XMLの終了ノードを処理する．.
int xml_parse_content (char *pp, char **content)
 XMLのコンテントを処理する．.
tList * xml_parse_attr (char *pp)
 XMLのノード属性を解釈して，リスト(tList)にする．.
int xml_parse_processing_node (char *pp, char **node_name, char **node_attr)
 XMLのプロセッシングノードを処理する.
int xml_parse_comment_node (char *pp, char **comment)
 XMLのコメントノードを処理する．.
int xml_parse_data_node (char *pp, char **data)
 XMLのデータノード（その他エレメントノードなど）を処理する．.
int isnot_xml_name (unsigned char *pp)
 XML名として不適切かどうかを大まかに判断する．.
void close_xml (tXML *pp)
 パースエラーを起こしたツリーを強制的に正常化する．
Buffer xml_inverse_parse (tXML *pp, int mode)
 ppに格納された XMLデータを元の書式に戻して Bufferに格納する．xml_parse() の逆．
void xml_to_Buffer (tXML *pp, Buffer *buf, int mode, int indent)
 xml_inverse_parse()用の補助関数．
void xml_open_node_Buffer (tXML *pp, Buffer *buf, int mode, int indent)
 ツリー中のXMLのオープンノードのデータを元の書式に戻して Bufferに格納する．
void xml_close_node_Buffer (tXML *pp, Buffer *buf, int mode, int indent)
 ツリー中のXMLのクローズノードのデータを元の書式に戻して Bufferに格納する．
void xml_attr_to_Buffer (tList *pp, Buffer *buf)
 リストに保存されたノードの属性をテキストへ戻す．
tXML * init_xml_doc ()
 XML のドキュメントヘッダを作成する．.
tXML * add_xml_node (tXML *xml, const char *name)
 XMLツリーのxml の直下（姉妹の一番下：末っ子）にノード（属性は指定しない）を挿入する．.
tXML * insert_xml_node (tXML *xml, const char *name)
 XMLツリーのxml の直下（姉妹の一番上：長子）にノード（属性は指定しない）を挿入する．.
tXML * add_xml_content (tXML *xml, const char *content)
 XMLツリーのxml の直下にコンテントを挿入する．.
tXML * append_xml_content (tXML *xml, const char *content)
 XMLツリーのxml の直下のコンテントノードにコンテンツを追加する．.
int add_xml_content_area (tXML *xml, int len)
 xml に空のコンテントノードを追加する．
tXML * add_xml_attr (tXML *xml, const char *attr)
 xml に属性（attr）を追加する．
tXML * add_xml_attr_str (tXML *xml, const char *name, const char *value)
 xml に属性名 name, 文字列の属性値 value を持つノードを追加する．
tXML * add_xml_attr_int (tXML *xml, const char *name, int value)
 xml に属性名 name, 整数の属性値 value を持つノードを追加する．
tXML * add_xml_attr_float (tXML *xml, const char *name, float value)
 xml に属性名 name, float型実数の属性値 value を持つノードを追加する．
tXML * add_xml_attr_double (tXML *xml, const char *name, double value)
 xml に属性名 name, double型実数の属性値 value を持つノードを追加する．
char * get_first_xml_nodename (tXML *xml)
 XMLツリーの最初のノードの名前を返す．.
Buffer make_xml_attr_bystr (const char *name, const char *value)
 属性名 name, 文字列の属性値 value を持つ Buffer型変数を作成する．
Buffer make_xml_attr_byint (const char *name, int value)
 属性名 name, 整数の属性値 value を持つ Buffer型変数を作成する．
Buffer make_xml_attr_byfloat (const char *name, float value)
 属性名 name, float型実数の属性値 value を持つ Buffer型変数を作成する．
Buffer make_xml_attr_bydouble (const char *name, double value)
 属性名 name, double型実数の属性値 value を持つ Buffer型変数を作成する．
char * xml_get_node_content (tXML *node)
 コンテントへのポインタを返す．free() してはいけない．
char * xml_get_node_attr (tXML *node, const char *attr)
 属性値を持つノードのポインタから，指定された属性値へのポインタを返す．free() してはいけない．
tXML * dup_merge_xml (tXML *pp, tXML *tp)
 XMLツリー ppの直下にXMLツリー tpを複製する．.
void print_xml (FILE *fp, tXML *pp, int mode)
 XMLの表示（出力）．.
void print_xml_node (FILE *fp, tXML *pp)
 MLのノード情報を表示する．デバッグ用．.
void print_xml_tree (FILE *fp, tXML *pp, const char *space)
 XMLツリーをそのままツリー表示する．デバッグ用．.
void print_sister_xml_tree (FILE *fp, tXML *pp, const char *space)
 XMLツリーの表示．ppの姉妹ノードも出力する．.
tXML * get_xml_node (tXML *pp, tXML *pt)
 同じパターンの枝を探し，ptに最初に一致した枝の，ptの最後のノードに対応したノードへのポインタを返す．
int set_xml_node (tXML *pp, tXML *pt, const char *name)
 同じパターンの枝を探し，ptに最初に一致した枝の，ptの最後のノード対応したノードにノード名をコピーする．
int set_xml_end_node (tXML *pp, tXML *pt)
 同じパターンの枝を探し，ptに最初に一致した枝の，
tXML * get_xml_content (tXML *pp, tXML *pt)
 同じパターンの枝を探し，ptに最初に一致した枝の，ptの最後のノードに対応したノードのコンテントへのポインタを返す．
int set_xml_content (tXML *pp, tXML *pt, const char *content)
 同じパターンの枝を探し，ptに最初に一致した枝の，ptの最後ノードに対応したのノードのコンテントを contentで置き換える．
int get_xml_int_content (tXML *pp, tXML *pt)
 get_xml_content() を使用し，XML コンテンツの内容を int型で返す．
float get_xml_float_content (tXML *pp, tXML *pt)
 get_xml_content() を使用し，XML コンテンツの内容を float型で返す．
double get_xml_double_content (tXML *pp, tXML *pt)
 get_xml_content() を使用し，XML コンテンツの内容を double型で返す．
char * get_xml_char_content (tXML *pp, tXML *pt)
 get_xml_content() を使用し，XML コンテンツの内容を char*型で返す．free() してはいけない．
tList * get_xml_attr (tXML *pp, tXML *pt)
 同じパターンの枝を探し，ptに最初に一致した枝の，ptの最後のノードに対応したノードのノード属性値へのリストを返す．
char * get_xml_char_attr (tXML *pp, tXML *pt, const char *attr)
 get_xml_node() で検索したノードから，属性値 attrの値を char*型で取り出す．free() してはいけない．
int get_xml_int_attr (tXML *pp, tXML *pt, const char *attr)
 get_xml_node() で検索したノードから，属性値 attrの値を int型で取り出す．
double get_xml_double_attr (tXML *pp, tXML *pt, const char *attr)
 get_xml_node() で検索したノードから，属性値 attrの値を double型で取り出す．
int set_xml_attr (tXML *pp, tXML *pt, tList *at)
 同じパターンの枝を探し，ptに最初に一致した枝の，ptの最後のノードに対応したノードのノードの属性としてatの値をコピーする．
int replace_xml_content (tXML *pp, tXML *pt, const char *src, const char *dst)
 get_xml_content() を使用し，XMLキーの src部分を dstで書き換える．
tXML * get_xml_node_bystr (tXML *pp, const char *str)
 get_xml_node(tXML* pp, tXML* pt) の _bystr バージョン
int set_xml_node_bystr (tXML *pp, const char *str, const char *val)
 set_xml_node(tXML* pp, tXML* pt, const char* val) の _bystr バージョン
int set_xml_end_node_bystr (tXML *pp, const char *str)
 set_xml_end_node(tXML* pp, tXML* pt) の _bystr バージョン
tXML * get_xml_content_bystr (tXML *pp, const char *str)
 get_xml_content(tXML* pp, tXML* pt) の _bystr バージョン
int get_xml_int_content_bystr (tXML *pp, const char *str)
 get_xml_int_content(tXML* pp, tXML* pt) の _bystr バージョン
float get_xml_float_content_bystr (tXML *pp, const char *str)
 get_xml_float_content(tXML* pp, tXML* pt) の _bystr バージョン．
double get_xml_double_content_bystr (tXML *pp, const char *str)
 get_xml_double_content(tXML* pp, tXML* pt) の _bystr バージョン．
char * get_xml_char_content_bystr (tXML *pp, const char *str)
 get_xml_char_content(tXML* pp, tXML* pt) の _bystr バージョン．free() してはいけない．
int set_xml_content_bystr (tXML *pp, const char *str, const char *val)
 set_xml_content(tXML* pp, tXML* pt, char* val) の _bystr バージョン
tList * get_xml_attr_bystr (tXML *pp, const char *str)
 get_xml_attr(tXML* pp, tXML* pt, tList* at) の _bystr バージョン．
char * get_xml_char_attr_bystr (tXML *pp, const char *str, const char *attr)
 get_xml_char_attr() の _bystr バージョン．free() してはいけない．
int get_xml_int_attr_bystr (tXML *pp, const char *str, const char *attr)
 get_xml_int_attr() の _bystr バージョン．
double get_xml_double_attr_bystr (tXML *pp, const char *str, const char *attr)
 get_xml_double_attr() の _bystr バージョン．
int set_xml_attr_bystr (tXML *pp, const char *str, tList *at)
 set_xml_attr(tXML* pp, tXML* pt, tList* at) の _bystr バージョン．
int replace_xml_content_bystr (tXML *pp, const char *str, const char *src, const char *dst)
 replace_xml_content(tXML*pp, tXML* pt, char* src, char* dst) の _bystr バージョン．
tList * get_xml_node_list (tXML *pp, tXML *pt)
 XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptに一致した枝の，ptの最後のノードに対応するノードへのポインタをリストに格納して返す．.
tList * get_xml_content_list (tXML *pp, tXML *pt)
 XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptに一致した枝の，ptの最後のノードに対応するノードのコンテントへのポインタをリストに格納して返す．.
int set_xml_content_list (tXML *pp, tXML *pt, const char *content)
 get_xml_content_list() で検出したコンテントを, content で置き換える．
tList * get_xml_node_list_bystr (tXML *pp, const char *str)
 get_xml_node_list() の _bystr バージョン．
tList * get_xml_content_list_bystr (tXML *pp, const char *str)
 get_xml_conetnt_list_bystr() の _bystr バージョン．
int set_xml_content_list_bystr (tXML *pp, const char *str, const char *content)
 set_xml_content_list_bystr() の _bystr バージョン．
int find_match_xml (tXML *pp, tXML *pt)
 ツリー pp内で ツリー ptと同じパターンの枝を探す．姉妹ツリーも検索するので注意．
tXML * find_match_xml_endlist (tXML *pp, tXML *pt)
 ツリー pp内で ツリー ptと同じパターンの枝を全て探して，その枝のptの最後のノードに対応するノードの情報をリストにして返す．
tList * find_match_xml_endlist_rcsv (tXML *pp, tXML *pt, tXML *te)
 find_match_xml_endlist() の補助関数
tXML * find_match_xml_end_node (tXML *pp, tXML *pt)
 XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptの最後のノードに対応する pp内のノードへのポインタを返す．.
int check_match_xml (tXML *tp, tXML *tr)
 XMLツリー tpが XMLツリー trと同じかどうかを検査する．.
tXML * cmp_sisters_xml (tXML *tp, tXML *tr)
 XMLノード tpの姉妹ノードが trの姉妹ノードと同じ XMLノードまたはコンテントであるかを比較する．.
Buffer get_node_content (tXML *tp, const char *name, int no)
 tp中のXMLデータから no番目のノード '<name>node_content</name>' のnode_contentのコピーを得る．
int get_node_integer (tXML *tp, const char *name, int no)
 tp中のXMLデータから no番目のノード '<node_name>node_content(整数)</node_name>' の node_content(整数)を得る．
int return_exist_node (tXML *tp, const char *name, int no, Buffer *content)
 bufの中に ノード '<name>content</name>' が存在するかどうかチェックする．
int replace_all_node_integer (tXML *tp, const char *name, int src, int dst)
 XMLツリー pp内で ノード名が nameである全てのノードのコンテント（整数）を，srcから dstに書き換える．.
int replace_all_node_contents (tXML *pp, const char *name, const char *src, const char *dst)
 XMLツリー pp内で ノード名が nameである全てのノードのコンテントを，srcから dstに書き換える．.
int replace_all_node_contents_rcsv (tXML *pp, const char *name, const char *src, const char *dst)
 replace_all_node_content() の補助関数
int replace_all_node_byid (tXML *pp, const char *src, const char *dst, int id)
 XMLツリー pp内で ノードの種別が idである全てのノードの内容を srcから dstに書き換える．.
int replace_all_node_byid_rcsv (tXML *pp, const char *src, const char *dst, int id)
 replace_all_node_byid() の補助関数
Buffer xml_rpc_request_pack (const char *name, tXML *xml)
 XML-RPC用のデータを生成する．.
tXML * xml_rpc_add_member (tXML *xml, char *name, char *value, char *kind)
 XML-RPC の <member> データを作って，繋げていく．.
tXML * xml_rpc_end_member (tXML *xml)
 <struct><member> データを閉じて，<value> データを作り出す．
tXML * xml_rpc_add_array (tXML *xml, tXML *array)
 <value><struct> データから 配列データ <data>...</data> を作って繋げていく．
tXML * xml_rpc_end_array (tXML *xml)
 配列データを閉じて，送信用データを生成する．

Detailed Description

Version:
1.0
Author:
Fumi.Iseki (C)
Date:
2009 2/10
タイトル
サブセット版 整形式XML 簡易パーサ
Attention:
全てのパターンのパース可能性は保障しない．
複雑な XMLはパースできない．
<?xml ... ?> 以外の <? ..... ?> と <! ..... > は処理しない（読み込みは行う）
エンティティは処理しない．
See also:
tXML

Definition in file txml.c.

Function Documentation

tXML* add_xml_attr ( tXML *  xml,
const char *  attr 
)

tXML* add_xml_attr(tXML* xml, const char* attr)

xml に属性ノード（attr）を追加する．

Definition at line 1358 of file txml.c.

References add_tList_end(), XML_NAME_NODE, and xml_parse_attr().

Referenced by add_xml_attr_double(), add_xml_attr_float(), add_xml_attr_int(), and add_xml_attr_str().

01359 {
01360     if (xml==NULL || attr==NULL) return NULL;
01361     if (xml->ldat.id!=XML_NAME_NODE) return NULL;
01362 
01363     tList* lp = xml_parse_attr((char*)attr);
01364 
01365     if (xml->ldat.lst==NULL) xml->ldat.lst = lp;
01366     else add_tList_end(xml->ldat.lst, lp);
01367 
01368     return xml;
01369 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* add_xml_attr_double ( tXML *  xml,
const char *  name,
double  value 
)

tXML* add_xml_attr_double(tXML* xml, const char* name, double value)

xml に属性名 name, double型実数の属性値 value を持つノードを追加する．

Definition at line 1428 of file txml.c.

References add_xml_attr(), Buffer::buf, free_Buffer(), and make_xml_attr_double.

01429 {
01430     if (xml==NULL || name==NULL) return NULL;
01431     //
01432     Buffer attr = make_xml_attr_double(name, value);
01433     add_xml_attr(xml, (char*)attr.buf);
01434     free_Buffer(&attr);
01435 
01436     return xml;
01437 }

Here is the call graph for this function:

tXML* add_xml_attr_float ( tXML *  xml,
const char *  name,
float  value 
)

tXML* add_xml_attr_float(tXML* xml, const char* name, float value)

xml に属性名 name, float型実数の属性値 value を持つノードを追加する．

Definition at line 1411 of file txml.c.

References add_xml_attr(), Buffer::buf, free_Buffer(), and make_xml_attr_float.

01412 {
01413     if (xml==NULL || name==NULL) return NULL;
01414     //
01415     Buffer attr = make_xml_attr_float(name, value);
01416     add_xml_attr(xml, (char*)attr.buf);
01417     free_Buffer(&attr);
01418 
01419     return xml;
01420 }

Here is the call graph for this function:

tXML* add_xml_attr_int ( tXML *  xml,
const char *  name,
int  value 
)

tXML* add_xml_attr_int(tXML* xml, const char* name, int value)

xml に属性名 name, 整数の属性値 value を持つノードを追加する．

Definition at line 1394 of file txml.c.

References add_xml_attr(), Buffer::buf, free_Buffer(), and make_xml_attr_int.

01395 {
01396     if (xml==NULL || name==NULL) return NULL;
01397     //
01398     Buffer attr = make_xml_attr_int(name, value);
01399     add_xml_attr(xml, (char*)attr.buf);
01400     free_Buffer(&attr);
01401 
01402     return xml;
01403 }

Here is the call graph for this function:

tXML* add_xml_attr_str ( tXML *  xml,
const char *  name,
const char *  value 
)

tXML* add_xml_attr_str(tXML* xml, const char* name, const char* value)

xml に属性名 name, 文字列の属性値 value を持つノードを追加する．

Definition at line 1377 of file txml.c.

References add_xml_attr(), Buffer::buf, free_Buffer(), and make_xml_attr_str.

01378 {
01379     if (xml==NULL || name==NULL) return NULL;
01380 
01381     Buffer attr = make_xml_attr_str(name, value);
01382     add_xml_attr(xml, (char*)attr.buf);
01383     free_Buffer(&attr);
01384 
01385     return xml;
01386 }

Here is the call graph for this function:

tXML* add_xml_content ( tXML *  xml,
const char *  content 
)

tXML* add_xml_content(tXML* xml, const char* content)

XMLツリーのxml の直下にコンテントを挿入する．
コンテントが複数ある場合は末っ子のノードとして挿入する．
xmlがノード名ノードでなければエラー（NULLが返る）

Definition at line 1280 of file txml.c.

References add_tTree_node_bystr(), JBXL_XML_NODE_CLOSED, XML_CONTENT_NODE, and XML_NAME_NODE.

Referenced by add_xml_content_area(), append_xml_content(), get_xml_content(), get_xml_content_list(), xml_rpc_add_member(), and xml_rpc_request_pack().

01281 {
01282     tList* pp;
01283 
01284     if (xml==NULL || content==NULL) return NULL;
01285     if (xml->ldat.id!=XML_NAME_NODE) return NULL;
01286 
01287     pp = add_tTree_node_bystr(xml, XML_CONTENT_NODE, 0, content, NULL, NULL, 0);
01288     pp->state = JBXL_XML_NODE_CLOSED;
01289     if (pp->prev!=NULL) pp->prev->ldat.lv++;
01290   
01291     return pp;
01292 }

Here is the call graph for this function:

Here is the caller graph for this function:

int add_xml_content_area ( tXML *  xml,
int  len 
)

int add_xml_content_area(tXML* xml, int len)

xml に空のコンテントノードを追加する．

Parameters:
xml コンテントノードを追加するノード．
len コンテンツノードの大きさ（バイト）
Returns:
TRUE: 成功，FALSE: 失敗

Definition at line 1333 of file txml.c.

References add_xml_content(), FALSE, and TRUE.

01334 {
01335     if (xml==NULL || len<=0) return FALSE;
01336     
01337     char* area = (char*)malloc(len);
01338     if (area==NULL) return FALSE;
01339     memset(area, (int)' ', len-1);
01340     area[len-1] = '\0';
01341 
01342     tXML* pp = add_xml_content(xml, area);
01343     if (pp!=NULL) {
01344         pp->ldat.key.buf[0] = '\0';
01345         pp->ldat.key.vldsz  = 0;
01346     }
01347     free(area);
01348 
01349     return TRUE;
01350 }

Here is the call graph for this function:

tXML* add_xml_node ( tXML *  xml,
const char *  name 
)

tXML* add_xml_node(tXML* xml, const char* name)

XMLツリーのxml の直下（姉妹の一番下：末っ子）にノード（属性は指定しない）を挿入する．

Parameters:
xml 挿入するポイント
name 挿入するノードの名前
Returns:
挿入したノードへのポインタ

Definition at line 1234 of file txml.c.

References add_tTree_node_bystr(), JBXL_XML_NODE_EMPTY, and XML_NAME_NODE.

Referenced by xml_rpc_add_array(), xml_rpc_add_member(), xml_rpc_end_array(), xml_rpc_end_member(), and xml_rpc_request_pack().

01235 {
01236     tXML* pp;
01237 
01238     if (name==NULL) return NULL;
01239 
01240     pp = add_tTree_node_bystr(xml, XML_NAME_NODE, 0, name, NULL, NULL, 0);
01241     pp->state = JBXL_XML_NODE_EMPTY;
01242     if (pp->prev!=NULL) pp->prev->ldat.lv++;
01243 
01244     return pp;
01245 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* append_xml_content ( tXML *  xml,
const char *  content 
)

tXML* append_xml_content(tXML* xml, const char* content)

XMLツリーのxml の直下のコンテントノードにコンテンツを追加する．
コンテントノードが無ければ，末っ子のノードにとしてコンテントノードを追加する．

Definition at line 1302 of file txml.c.

References add_xml_content(), cat_s2Buffer, XML_CONTENT_NODE, and XML_NAME_NODE.

01303 {
01304     tList* pp;
01305 
01306     if (xml==NULL || content==NULL) return NULL;
01307     if (xml->ldat.id!=XML_NAME_NODE) return NULL;
01308     
01309     pp = xml->next;
01310     while (pp!=NULL && pp->ldat.id!=XML_CONTENT_NODE) pp = pp->ysis;
01311 
01312     if (pp==NULL) {
01313         pp = add_xml_content(xml, content);
01314     }
01315     else {
01316         if (pp->ldat.key.vldsz!=0) cat_s2Buffer(" ", &(pp->ldat.key));
01317         cat_s2Buffer(content, &(pp->ldat.key));
01318     }
01319 
01320     return pp;
01321 }

Here is the call graph for this function:

int check_match_xml ( tXML *  tp,
tXML *  tr 
)

int check_match_xml(tXML* tp, tXML* tr)

XMLツリー tpが XMLツリー trと同じかどうかを検査する．

tp のトップと tr のトップはキー値が一致している必要がある．一致していなければ，同じパターンは無しとする．
ただし，tr->ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE のノードは比べない(常に一致とする)．

一度見つけた tpの枝の最後のノードに対しては ctrlを TREE_ALREADY_FOUND_NODE を設定するので，続けてチェックする 場合などは ctrl をクリアする必要がある．

もし同じツリーパターンがある場合，trの各ノードの altpには，一番最初に見つかった対応する tpの各ノードへのポインタが格納される．

Parameters:
tp 検索対象のツリー
tr 検索パターンのツリー
Return values:
TRUE tp中に trと同じいツリーパターンが存在する．
TRUE trの各ノードの altpには，一番最初に見つかった対応する tpの各ノードへのポインタが格納される．
FALSE tpに同じツリーパターンは無い．この場合，trの altpの値は不定となる．

Definition at line 2941 of file txml.c.

References check_match_xml(), cmp_sisters_xml(), FALSE, find_tList_end(), TREE_ALREADY_FOUND_NODE, and TRUE.

Referenced by check_match_xml(), find_match_xml(), and find_match_xml_endlist_rcsv().

02942 {
02943     int   ret;
02944     tXML* te;
02945     tXML* ts;
02946 
02947     tXML* tt;
02948     tXML* ta;
02949     tXML* tb;
02950 
02951     if (tp==NULL || tr==NULL) return FALSE;
02952 
02953     te = find_tList_end(tr);
02954 
02955     ts = tp;
02956     while (ts!=NULL) {
02957         tt = cmp_sisters_xml(ts, tr);        // その階層で trと全て一致している部分があるかを確認
02958         if (tt==NULL) return FALSE;          // 一致していなければ，FALSE
02959         
02960         ta  = tt;                            // 比べられるツリー
02961         tb  = tr;                            // 比べるパターン
02962         ret = TRUE;
02963         while (tb!=NULL && ret) {
02964             if (tb->next==NULL) ret = TRUE;
02965             // ->ta, ->tb->tx: FALSE
02966             else if (tb->next!=NULL && ta->next==NULL) ret = FALSE;
02967             // ->ta->xa, ->tb->xb: xaとxbをチェック
02968             else ret = check_match_xml(ta->next, tb->next);
02969 
02970             ta = ta->ysis;
02971             tb = tb->ysis;
02972         }
02973 
02974         if (ret) {
02975             if (tr==te) tt->ctrl = TREE_ALREADY_FOUND_NODE;
02976             return TRUE;
02977         }
02978 
02979         ts = tt->ysis;
02980     }
02981 
02982     return FALSE;
02983 }

Here is the call graph for this function:

Here is the caller graph for this function:

void close_xml ( tXML *  pp  ) 

void close_xml(tXML* pp)

パースエラーを起こしたツリーを強制的に正常化する．

Parameters:
pp 正常化するツリーへのポインタ．

Definition at line 845 of file txml.c.

References adjust_tTree_depth(), close_xml(), JBXL_XML_NODE_CLOSED, JBXL_XML_NODE_EMPTY, JBXL_XML_PARSED, and XML_ANCHOR_NODE.

Referenced by close_xml().

00846 {
00847     if (pp!=NULL) {
00848 
00849         // アンカー
00850          if (pp->ldat.id==XML_ANCHOR_NODE) {
00851             pp->state = JBXL_XML_PARSED;
00852             pp->depth = -1;
00853             if (pp->next!=NULL) {
00854                 pp->next->depth = 0;
00855                 adjust_tTree_depth(pp->next);
00856                 close_xml(pp->next);
00857             }
00858             return;
00859         }
00860 
00861         while(pp->esis!=NULL) pp = pp->esis;
00862         do {
00863             if (pp->next==NULL) pp->state = JBXL_XML_NODE_EMPTY;
00864             //
00865             if (pp->state!=JBXL_XML_NODE_EMPTY) pp->state = JBXL_XML_NODE_CLOSED;
00866             //if (pp->ldat.lst!=NULL) {
00867             //    if ((pp->ldat.lst)->state!=JBXL_XML_NODE_EMPTY) (pp->ldat.lst)->state = JBXL_XML_NODE_CLOSED;
00868             //}
00869             //
00870             if (pp->next!=NULL) close_xml(pp->next);
00871        
00872             pp = pp->ysis;
00873         } while(pp!=NULL);
00874     }  
00875        
00876     return;
00877 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* cmp_sisters_xml ( tXML *  tp,
tXML *  tr 
)

tXML* cmp_sisters_xml(tXML* tp, tXML* tr)

XMLノード tpの姉妹ノードが trの姉妹ノードと同じ XMLノードまたはコンテントであるかを比較する．

ただし，tr->ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE のノードは比べない(常に一致とする)．
また tp->ctrl が TREE_ALREADY_FOUND_NODE の場合は，常に一致しない．

もし同じノードパターンがある場合，trの各ノードの altpには対応する tpの各ノードへのポインタが格納される．
また tpの各ノードの ctrlには TREE_ALREADY_FOUND_NODE が設定される．

Parameters:
tp 比べる姉妹ノードの長女ノード
tr 探す姉妹ノードパターンの長女ノード
Returns:
tp中で trと同じパターンが始まるノードへのポインタ． trの各ノードの altpには対応する tpの各ノードへのポインタが格納される．
Return values:
NULL tpに同じ姉妹パターンは無い．
例
以下の場合，cmp_sisters_xml(tp, tr) は (3)へのポインタを返す．
また trの Aノードの altp には (3) へのポインタが，trの Xノードのaltpには(4)へのポインタが格納される．
最初に見つかったパターンのみ評価される． 
      tp                 tr
      --> A (1)          --> A         A, B, X は キー値(ldat.key.buf)
      --> B (2)          --> X
      --> A (3)
      --> X (4)
      --> A (5)
      --> X (6)

Definition at line 3019 of file txml.c.

References TREE_ALREADY_FOUND_NODE, TREE_NOCMP_COPY_NODE, and TREE_NOCMP_NODE.

Referenced by check_match_xml().

03020 {
03021     tXML* ta;
03022     tXML* tb = NULL;
03023     tXML* ts;
03024 
03025     ts = tp;
03026     while (ts!=NULL){
03027         ta = ts;
03028         tb = tr;
03029         while (ta!=NULL && tb!=NULL) {
03030             // 一致しない場合 break
03031             if (ta->ctrl==TREE_ALREADY_FOUND_NODE) break;
03032             if (tb->ctrl!=TREE_NOCMP_NODE && tb->ctrl!=TREE_NOCMP_COPY_NODE) {
03033                 if ((ta->ldat).key.buf!=NULL && (tb->ldat).key.buf!=NULL) {
03034                     if (ta->ldat.id!=tb->ldat.id || strcmp((char*)((ta->ldat).key.buf), (char*)((tb->ldat).key.buf))) break;
03035                 }
03036                 else break;
03037             }
03038 
03039             // ta と tb は一致
03040             tb->altp = ta;
03041             ta = ta->ysis;
03042             tb = tb->ysis;
03043         }
03044 
03045         // ts と tr は完全に一致
03046         if (tb==NULL) return ts;
03047 
03048         ts = ts->ysis;
03049     }
03050 
03051     return NULL;
03052 }

Here is the caller graph for this function:

tXML* dup_merge_xml ( tXML *  pp,
tXML *  tp 
)

tXML* dup_merge_xml(tXML* pp, tXML* tp)

XMLツリー ppの直下に（Yunger Sister として）XMLツリー tpを複製する．

Parameters:
pp 複製されたツリーのトップとなるノード
tp 複製するツリー
Returns:
複製された XMLツリーへのポインタ．
pp がNULLでない場合は pp．pp がNULLの場合は，tpを複製したツリーのトップ．

Definition at line 1593 of file txml.c.

References dup_merge_tTree(), and XML_ANCHOR_NODE.

01594 {
01595     if (tp==NULL) return pp;
01596 
01597     if (tp->ldat.id==XML_ANCHOR_NODE) {
01598         if (tp->next!=NULL) tp = tp->next;
01599         else return pp;
01600     }
01601 
01602     pp = dup_merge_tTree(pp, tp);
01603 
01604 /*
01605     tXML* pt;
01606     if (pp->ldat.id!=XML_ANCHOR_NODE) {
01607         pt = new_tTree_node();
01608         pt->ldat.id = XML_ANCHOR_NODE;
01609         pt->depth = -1;
01610         add_tTree(pt, pp);
01611         close_xml(pt);
01612         return pt;
01613     }
01614 */
01615 
01616     return pp;
01617 }

Here is the call graph for this function:

int find_match_xml ( tXML *  pp,
tXML *  pt 
)

int find_match_xml(tXML* pp, tXML* pt)

ツリー pp内で ツリー ptと同じパターンの枝を探す．姉妹ツリーも検索するので注意．

同じパターンの探索では キー値のみを比較し，ノード値は比較しない．
ただし，pt->ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE のノードは比べない(常に一致とする)．

もし同じツリーパターンがある場合，trの各ノードの altpには，一番最初に見つかった対応する ppの各ノードへ のポインタが格納される．

check_match_xml() との違い．

Parameters:
pp 検索対象のツリー．姉妹ツリーも検索する．
pt 検索パターンのツリー
Return values:
TRUE pp中に pt同じいツリーパターンが存在する． ptの各ノードの altpには，一番最初に見つかった対応する ppの各ノードへのポインタが格納される．
FALSE ppに同じツリーパターンは無い．この場合，ptのaltpの値は不定となる．

Definition at line 2794 of file txml.c.

References check_match_xml(), clear_tTree_ctrl(), FALSE, find_match_xml(), and TRUE.

Referenced by find_match_xml(), get_xml_content(), get_xml_node(), and set_xml_end_node().

02795 {
02796     int   ret;
02797     tXML* pm;
02798 
02799     pm = pp;
02800     while(pp!=NULL) {
02801         ret = check_match_xml(pp, pt);
02802         if (ret) return TRUE;
02803 
02804         if (pp->next!=NULL) {
02805             ret = find_match_xml(pp->next, pt);
02806             if (ret) {
02807                 clear_tTree_ctrl(pm);
02808                 return TRUE;
02809             }
02810         }
02811         pp = pp->ysis;
02812     }
02813 
02814     return FALSE;
02815 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* find_match_xml_end_node ( tXML *  pp,
tXML *  pt 
)

tXML* find_match_xml_end_node(tXML* pp, tXML* pt)

XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptの最後のノードに対応する pp内のノードへのポインタを返す．
ノードは ノード名，コンテントのどちらでも可．

Parameters:
pp 検索対象のXML
pt 検索パターンの文字列．
Returns:
strの最後のノードに対応する pp内のノード．

Definition at line 2897 of file txml.c.

References clear_tTree_ctrl(), find_match_tTree(), and find_xml_end.

02898 {
02899     int    ret;
02900     tXML*  tt = NULL;
02901     tXML*  pm;
02902 
02903     if (pp==NULL || pt==NULL) return NULL;
02904 
02905     pm  = pp;
02906     ret = find_match_tTree(pp, pt);
02907     if (ret) {
02908         tt = find_xml_end(pt);
02909         if (tt!=NULL) {
02910             tt = tt->altp;
02911         }
02912     }
02913 
02914     clear_tTree_ctrl(pm);
02915 
02916     return tt;
02917 }

Here is the call graph for this function:

tXML* find_match_xml_endlist ( tXML *  pp,
tXML *  pt 
)

tXML* find_match_xml_endlist(tXML* pp, tXML* pt)

ツリー pp内で ツリー ptと同じパターンの枝を全て探して，その枝のptの最後のノードに対応するノードの情報をリストにして返す．
該当ノードへのポインタは 返された各リストのaltp が保持している．

比較では キー値のみを比較し，ノード値は比較しない．
また，pt->ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE のノードは比べない(常に一致とする)．

Parameters:
pp 検索対象のツリー．姉妹ツリーも検索する．
pt 検索パターンのツリー
Returns:
該当ノードへのポインタを保持するリスト．

Definition at line 2833 of file txml.c.

References clear_tTree_ctrl(), find_match_xml_endlist_rcsv(), and find_xml_end.

Referenced by get_xml_content_list(), and get_xml_node_list().

02834 {
02835     tXML*  te;
02836     tList* lp;
02837 
02838     te = find_xml_end(pt);
02839     while(pp->esis!=NULL) pp = pp->esis;
02840 
02841     lp = find_match_xml_endlist_rcsv(pp, pt, te);
02842     if (lp!=NULL) clear_tTree_ctrl(pp);
02843     
02844     return lp;
02845 }

Here is the call graph for this function:

Here is the caller graph for this function:

tList* find_match_xml_endlist_rcsv ( tXML *  pp,
tXML *  pt,
tXML *  te 
)

tList* find_match_xml_endlist_rcsv(tXML* pp, tXML* pt, tXML* te)

find_match_xml_endlist() の補助関数

Definition at line 2855 of file txml.c.

References check_match_xml(), clear_tTree_ctrl(), find_match_xml_endlist_rcsv(), insert_tList(), and new_tList_node().

Referenced by find_match_xml_endlist(), and find_match_xml_endlist_rcsv().

02856 {
02857     tList* lt = NULL;
02858     tList* lp = NULL;
02859                     
02860     while(pp!=NULL) {             
02861         int ret = check_match_xml(pp, pt);
02862         if (ret && te->altp!=NULL) {
02863             tList* lm = new_tList_node();
02864             lm->altp = te->altp;  
02865             lt = insert_tList(lt, lm);
02866             if (lp==NULL) lp = lt;
02867             te->altp = NULL;
02868         }  
02869                             
02870         if (pp->next!=NULL) {     
02871             tList* lm = find_match_xml_endlist_rcsv(pp->next, pt, te);
02872             if (lm!=NULL) {       
02873                 lt = insert_tList(lt, lm);
02874                 if (lp==NULL) lp = lt;
02875                 clear_tTree_ctrl(pp->next);
02876             }
02877         }
02878                                    
02879         if (!ret) pp = pp->ysis;    // 見つかった場合はもう一度．見つからなかった場合へ次へ．
02880     }
02881 
02882     return lp;
02883 }

Here is the call graph for this function:

Here is the caller graph for this function:

char* get_first_xml_nodename ( tXML *  xml  ) 

char* get_first_xml_nodename(tXML* xml)

XMLツリーの最初のノードの名前を返す．

Parameters:
xml XMLツリー
Returns:
XMLツリーの最初のノードの名前．free() してはいけない．

Definition at line 1449 of file txml.c.

References XML_ANCHOR_NODE, and XML_NAME_NODE.

01450 {  
01451     char* nodename = NULL;
01452    
01453     if (xml==NULL) return NULL;
01454     tList* lp = xml;
01455     if (lp->ldat.id==XML_ANCHOR_NODE) lp = lp->next;
01456    
01457     while (lp!=NULL) {
01458         if (lp->ldat.id==XML_NAME_NODE) {
01459             if (lp->ldat.key.buf!=NULL) {
01460                 nodename = (char*)lp->ldat.key.buf;
01461                 break;
01462             }
01463         }
01464         lp = lp->ysis;
01465     }
01466     return nodename;
01467 }

Buffer get_node_content ( tXML *  tp,
const char *  name,
int  no 
)

Buffer get_node_content(tXML* tp, const char* name, int no)

tp 中のXMLデータから no番目のノード '<name>node_content</name>' のnode_contentのコピーを得る．
ノードが複数のコンテントを持つ場合は，最初のコンテントのみを返す．

Parameters:
tp 探索を行う XMLデータ
name ノード名
no 一致した物の中で何番目の物を返すか指定する．1から数える．

Definition at line 3071 of file txml.c.

References dup_Buffer(), init_Buffer(), strncmp_tTree(), and XML_CONTENT_NODE.

Referenced by get_node_integer(), and return_exist_node().

03072 {
03073     Buffer content;
03074     tXML*  tt;
03075     
03076     content = init_Buffer();
03077     if (tp==NULL || name==NULL) return content;
03078 
03079     if (no<=0) no = 1;
03080     tt = strncmp_tTree(tp, name, 0, no);
03081     if (tt!=NULL) {
03082         if (tt->next!=NULL) {
03083             tt = tt->next;
03084             while (tt!=NULL && tt->ldat.id!=XML_CONTENT_NODE) tt = tt->ysis;
03085             if (tt==NULL) return content;
03086             content = dup_Buffer(tt->ldat.key);
03087         }
03088     }
03089 
03090     return content;
03091 }

Here is the call graph for this function:

Here is the caller graph for this function:

int get_node_integer ( tXML *  tp,
const char *  name,
int  no 
)

int get_node_integer(tXML* tp, const char* name, int no)

tp中のXMLデータから no番目のノード '<node_name>node_content(整数)</node_name>' の node_content(整数)を得る．

Definition at line 3100 of file txml.c.

References Buffer::buf, free_Buffer(), and get_node_content().

03101 {
03102     int       ret;
03103     Buffer content;
03104 
03105     content = get_node_content(tp, name, no);
03106 
03107     if (content.buf==NULL) ret = 0;
03108     else                   ret = atoi((const char*)content.buf);
03109     free_Buffer(&content);
03110 
03111     return  ret;
03112 }

Here is the call graph for this function:

tList* get_xml_attr ( tXML *  pp,
tXML *  pt 
)

tList* get_xml_attr(tXML* pp, tXML* pt)

XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptに最初に一致した枝の， ptの最後のノードに対応したノードのノード属性値へのリストを返す．
pp の姉妹ツリーも検索するので注意．

pt の中で ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE となっているノードは 比較されない．これらのノードは必ず一致する．

Parameters:
pp 検索対象のツリー．姉妹ツリーも検索する．
pt 検索するパターン
Returns:
ptの最後のノード対応にする，ppのノードの属性値（リスト）

Definition at line 2131 of file txml.c.

References get_xml_node().

Referenced by get_xml_attr_bystr().

02132 {
02133     tList* lp = NULL;
02134     tXML*  tt;
02135 
02136     if (pp==NULL || pt==NULL) return NULL;
02137 
02138     tt  = get_xml_node(pp, pt);
02139     if (tt!=NULL) lp = tt->ldat.lst;    
02140     return lp;
02141 }

Here is the call graph for this function:

Here is the caller graph for this function:

tList* get_xml_attr_bystr ( tXML *  pp,
const char *  str 
)

tList* get_xml_attr_bystr(tXML* pp, const char* str)

get_xml_attr(tXML* pp, tXML* pt) の _bystr バージョン

Definition at line 2452 of file txml.c.

References del_xml, get_xml_attr(), and xml_parse().

02453 {
02454     tXML*  tx;
02455     tList* tt;
02456 
02457     if (pp==NULL || str==NULL) return NULL;
02458 
02459     tx = xml_parse((char*)str);
02460     tt = get_xml_attr(pp, tx);
02461     del_xml(&tx);
02462     return tt;
02463 }

Here is the call graph for this function:

char* get_xml_char_attr ( tXML *  pp,
tXML *  pt,
const char *  attr 
)

char* get_xml_char_attr(tXML* pp, tXML* pt, const char* attr)

get_xml_node() で検索したノードから，属性値 attrの値を char*型で取り出す．free() してはいけない．

Definition at line 2150 of file txml.c.

References get_xml_node(), and xml_get_node_attr().

02151 {
02152     char* ret = NULL;
02153     if (pp==NULL || pt==NULL || attr==NULL) return ret;
02154 
02155     tXML* node = get_xml_node(pp, pt);
02156     if (node!=NULL) ret = xml_get_node_attr(node, attr);
02157     return ret;
02158 }

Here is the call graph for this function:

char* get_xml_char_attr_bystr ( tXML *  pp,
const char *  str,
const char *  attr 
)

char* get_xml_char_attr_bystr(tXML* pp, const char* str, const char* attr)

get_xml_char_attr() の _bystr バージョン．
get_xml_node_bystr() で検索したノードから，属性値 attrの値を char*型で取り出す．free() してはいけない．

Definition at line 2473 of file txml.c.

References get_xml_node_bystr(), and xml_get_node_attr().

02474 {
02475     char* ret = NULL;
02476     if (pp==NULL || str==NULL || attr==NULL) return ret;
02477 
02478     tXML* node = get_xml_node_bystr(pp, str);
02479     if (node!=NULL) ret = xml_get_node_attr(node, attr);
02480     return ret;
02481 }

Here is the call graph for this function:

char* get_xml_char_content ( tXML *  pp,
tXML *  pt 
)

int get_xml_char_content(tXML* pp, tXML* pt)

get_xml_content() を使用し，XML コンテンツの内容を char*型で返す．free() してはいけない

Definition at line 2106 of file txml.c.

References get_xml_content().

02107 {
02108     char* ret = NULL;
02109 
02110     tXML* node = get_xml_content(pp, pt);
02111     if (node!=NULL) ret = (char*)(node->ldat.key.buf);
02112     return ret;
02113 }

Here is the call graph for this function:

char* get_xml_char_content_bystr ( tXML *  pp,
const char *  str 
)

char* get_xml_char_content_bystr(tXML* pp, const char* str);

get_xml_char_content(tXML* pp, tXML* pt) の _bystr バージョン．
get_xml_content_bystr() を使用し，XML コンテンツの内容を char*型で返す．
free() してはいけない．

Definition at line 2416 of file txml.c.

References get_xml_content_bystr().

Referenced by llsd_xml_get_content_bin(), and llsd_xml_get_content_str().

02417 {
02418     char* ret = NULL;
02419 
02420     tXML* node = get_xml_content_bystr(pp, str);
02421     if (node!=NULL) ret = (char*)(node->ldat.key.buf);
02422     return ret;
02423 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* get_xml_content ( tXML *  pp,
tXML *  pt 
)

tXML* get_xml_content(tXML* pp, tXML* pt)

XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptに最初に一致した枝の， ptの最後のノードに対応したノードのコンテントへのポインタを返す．
pp の姉妹ツリーも検索するので注意．

pt の中で ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE となっているノードは比較されない．
これらのノードは必ず一致する．

返ってきた tXML* は free() してはいけない．

Parameters:
pp 検索対象のXMLツリー．姉妹ツリーも検索する．
pt 検索するパターン
Returns:
ptの最後のノードの次のノードに対応するコンテントへのポインタ．free() してはいけない．
例
以下の場合，Z へのポインタが返る． 
    pp                            pt
    A --> B --> M                 C --> M --> Y
      --> C --> M --> X               
                  --> Y --> Z   
            --> N

Definition at line 1982 of file txml.c.

References add_xml_content(), clear_tTree_ctrl(), del_xml, find_match_xml(), find_xml_end, TREE_NOCMP_NODE, and XML_ANCHOR_NODE.

Referenced by get_xml_char_content(), get_xml_content_bystr(), get_xml_double_content(), get_xml_float_content(), get_xml_int_content(), replace_xml_content(), and set_xml_content().

01983 {
01984     int fnd;
01985     tXML* tt = NULL;
01986     tXML* pm;
01987     tXML* dm;
01988 
01989     if (pp==NULL || pt==NULL) return NULL;
01990 
01991     pm = pp;
01992     if (pp->ldat.id==XML_ANCHOR_NODE) {
01993         if (pp->next!=NULL) pp = pp->next;
01994         else return NULL;
01995     }
01996     if (pt->ldat.id==XML_ANCHOR_NODE) {
01997         if (pt->next!=NULL) pt = pt->next;
01998         else return NULL;
01999     }
02000 
02001     tt = find_xml_end(pt);
02002     if (tt==NULL) return NULL;
02003     dm = add_xml_content(tt, (char*)"DUMMY");
02004     if (dm==NULL) return NULL;
02005     dm->ctrl = TREE_NOCMP_NODE;
02006 
02007     while(pp->esis!=NULL) pp = pp->esis;
02008 
02009     fnd = find_match_xml(pp, pt);
02010     if (fnd) tt = dm->altp;
02011     else     tt = NULL;
02012 
02013     del_xml(&dm);
02014     clear_tTree_ctrl(pm);
02015 
02016     return tt;
02017 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* get_xml_content_bystr ( tXML *  pp,
const char *  str 
)

tXML* get_xml_content_bystr(tXML* pp, const char* str)

get_xml_content(tXML* pp, tXML* pt) の _bystr バージョン

Definition at line 2343 of file txml.c.

References del_xml, FALSE, get_xml_content(), and xml_parse().

Referenced by get_xml_char_content_bystr(), get_xml_double_content_bystr(), get_xml_float_content_bystr(), and get_xml_int_content_bystr().

02344 {
02345     tXML* tx;
02346     tXML* tt;
02347 
02348     if (pp==NULL || str==NULL) return FALSE;
02349 
02350     tx = xml_parse((char*)str);
02351     tt = get_xml_content(pp, tx);
02352     del_xml(&tx);
02353     return tt;
02354 }

Here is the call graph for this function:

Here is the caller graph for this function:

tList* get_xml_content_list ( tXML *  pp,
tXML *  pt 
)

tList* get_xml_content_list(tXML* pp, tXML* pt)

XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptに一致した枝の，ptの最後のノードに対応するノードの コンテントへのポインタをリストに格納して返す．ポインタはリストの altpに格納される．

pt の中で ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE となっているノードは比較されない．
これらのノードは必ず一致する．

Parameters:
pp 検索対象のツリー
pt 検索するパターン
Returns:
該当ノードへのポインタ情報(altp)を含んだリストへのポインタ

Definition at line 2637 of file txml.c.

References add_xml_content(), del_xml, find_match_xml_endlist(), find_xml_end, TREE_NOCMP_NODE, and XML_ANCHOR_NODE.

Referenced by get_xml_content_list_bystr(), and set_xml_content_list().

02638 {
02639     tList* lp;
02640     tList* dm;
02641 
02642     if (pp==NULL || pt==NULL) return NULL;
02643 
02644     if (pp->ldat.id==XML_ANCHOR_NODE) {
02645         if (pp->next!=NULL) pp = pp->next;
02646         else return NULL;
02647     }
02648     if (pt->ldat.id==XML_ANCHOR_NODE) {
02649         if (pt->next!=NULL) pt = pt->next;
02650         else return NULL;
02651     }
02652 
02653     dm = find_xml_end(pt);
02654     if (dm==NULL) return NULL;
02655     dm = add_xml_content(dm, (char*)"DUMMY");
02656     if (dm==NULL) return NULL;
02657     dm->ctrl = TREE_NOCMP_NODE;
02658 
02659     lp = find_match_xml_endlist(pp, pt);
02660     del_xml(&dm);
02661 
02662     return lp;
02663 }

Here is the call graph for this function:

Here is the caller graph for this function:

tList* get_xml_content_list_bystr ( tXML *  pp,
const char *  str 
)

tList* get_xml_conetnt_list_bystr(tXML* pp, const char* str)

get_xml_conetnt_list_bystr() の _bystr バージョン．

Definition at line 2729 of file txml.c.

References del_xml, get_xml_content_list(), and xml_parse().

02730 {
02731     tXML*  tx;
02732     tList* tt;
02733 
02734     if (pp==NULL || str==NULL) return NULL;
02735 
02736     tx = xml_parse((char*)str);
02737     tt = get_xml_content_list(pp, tx);
02738     del_xml(&tx);
02739 
02740     return tt;
02741 }

Here is the call graph for this function:

double get_xml_double_attr ( tXML *  pp,
tXML *  pt,
const char *  attr 
)

double get_xml_double_attr(tXML* pp, tXML* pt, const char* attr)

get_xml_node() で検索したノードから，属性値 attrの値を double型で取り出す．
値は " " で括られていても良い．

Definition at line 2196 of file txml.c.

References Buffer::buf, free_Buffer(), get_xml_node(), make_Buffer_bystr, and xml_get_node_attr().

02197 {
02198     double ret = 0.0;
02199     if (pp==NULL || pt==NULL || attr==NULL) return ret;
02200 
02201     tXML* node = get_xml_node(pp, pt);
02202     if (node!=NULL) {
02203         char* val = xml_get_node_attr(node, attr);
02204         if (val!=NULL) {
02205             Buffer buf = make_Buffer_bystr(val);
02206             char* ptr  = (char*)buf.buf;
02207             if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
02208             if (ptr[0]=='"') ptr++; 
02209             ret = atof(ptr);
02210             free_Buffer(&buf);
02211         }
02212     }
02213     return ret;
02214 }

Here is the call graph for this function:

double get_xml_double_attr_bystr ( tXML *  pp,
const char *  str,
const char *  attr 
)

double get_xml_double_attr_bystr(tXML* pp, const char* str, const char* attr)

get_xml_double_attr() の _bystr バージョン．
get_xml_node_bystr() で検索したノードから，属性値 attrの値を double型で取り出す．
値は クォーテーションで括られていても良い．

Definition at line 2521 of file txml.c.

References Buffer::buf, free_Buffer(), get_xml_node_bystr(), make_Buffer_bystr, and xml_get_node_attr().

02522 {
02523     double ret = 0.0;
02524     if (pp==NULL || str==NULL || attr==NULL) return ret;
02525 
02526     tXML* node = get_xml_node_bystr(pp, str);
02527     if (node!=NULL) {
02528         char* val = xml_get_node_attr(node, attr);
02529         if (val!=NULL) {
02530             Buffer buf = make_Buffer_bystr(val);
02531             char* ptr  = (char*)buf.buf;
02532             if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
02533             if (ptr[0]=='"') ptr++; 
02534             ret = atof(ptr);
02535             free_Buffer(&buf);
02536         }
02537     }
02538     return ret;
02539 }

Here is the call graph for this function:

double get_xml_double_content ( tXML *  pp,
tXML *  pt 
)

double get_xml_double_content(tXML* pp, tXML* pt)

get_xml_content() を使用し，XML コンテンツの内容を double型で返す．

Definition at line 2090 of file txml.c.

References get_xml_content().

02091 {
02092     double ret = 0.0;
02093 
02094     tXML* node = get_xml_content(pp, pt);
02095     if (node!=NULL) ret = atof((char*)(node->ldat.key.buf));
02096     return ret;
02097 }

Here is the call graph for this function:

double get_xml_double_content_bystr ( tXML *  pp,
const char *  str 
)

double get_xml_double_content_bystr(tXML* pp, const char* str);

get_xml_double_content(tXML* pp, tXML* pt) の _bystr バージョン．
get_xml_content_bystr() を使用し，XML コンテンツの内容を double型で返す．

Definition at line 2398 of file txml.c.

References get_xml_content_bystr().

Referenced by llsd_xml_get_content_real().

02399 {
02400     double ret = 0.0;
02401 
02402     tXML* node = get_xml_content_bystr(pp, str);
02403     if (node!=NULL) ret = atof((char*)(node->ldat.key.buf));
02404     return ret;
02405 }

Here is the call graph for this function:

Here is the caller graph for this function:

float get_xml_float_content ( tXML *  pp,
tXML *  pt 
)

float get_xml_float_content(tXML* pp, tXML* pt)

get_xml_content() を使用し，XML コンテンツの内容を float型で返す．

Definition at line 2074 of file txml.c.

References get_xml_content().

02075 {
02076     float ret = 0.0;
02077 
02078     tXML* node = get_xml_content(pp, pt);
02079     if (node!=NULL) ret = (float)atof((char*)(node->ldat.key.buf));
02080     return ret;
02081 }

Here is the call graph for this function:

float get_xml_float_content_bystr ( tXML *  pp,
const char *  str 
)

float get_xml_float_content_bystr(tXML* pp, const char* str)

get_xml_float_content(tXML* pp, tXML* pt) の _bystr バージョン．
get_xml_content_bystr() を使用し，XML コンテンツの内容を float型で返す．

Definition at line 2381 of file txml.c.

References get_xml_content_bystr().

02382 {
02383     float ret = 0.0;
02384 
02385     tXML* node = get_xml_content_bystr(pp, str);
02386     if (node!=NULL) ret = (float)atof((char*)(node->ldat.key.buf));
02387     return ret;
02388 }

Here is the call graph for this function:

int get_xml_int_attr ( tXML *  pp,
tXML *  pt,
const char *  attr 
)

int get_xml_int_attr(tXML* pp, tXML* pt, const char* attr)

get_xml_node() で検索したノードから，属性値 attrの値を int型で取り出す．
値は " " で括られていても良い．

Definition at line 2168 of file txml.c.

References Buffer::buf, free_Buffer(), get_xml_node(), make_Buffer_bystr, and xml_get_node_attr().

02169 {
02170     int ret = 0;
02171     if (pp==NULL || pt==NULL || attr==NULL) return ret;
02172 
02173     tXML* node = get_xml_node(pp, pt);
02174     if (node!=NULL) {
02175         char* val = xml_get_node_attr(node, attr);
02176         if (val!=NULL) {
02177             Buffer buf = make_Buffer_bystr(val);
02178             char* ptr  = (char*)buf.buf;
02179             if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
02180             if (ptr[0]=='"') ptr++; 
02181             ret = atoi(ptr);
02182             free_Buffer(&buf);
02183         }
02184     }
02185     return ret;
02186 }

Here is the call graph for this function:

int get_xml_int_attr_bystr ( tXML *  pp,
const char *  str,
const char *  attr 
)

int get_xml_int_attr_bystr(tXML* pp, const char* str, const char* attr)

get_xml_int_attr() の _bystr バージョン．
get_xml_node_bystr() で検索したノードから，属性値 attrの値を int型で取り出す．
値は " " で括られていても良い．

Definition at line 2492 of file txml.c.

References Buffer::buf, free_Buffer(), get_xml_node_bystr(), make_Buffer_bystr, and xml_get_node_attr().

02493 {
02494     int ret = 0;
02495     if (pp==NULL || str==NULL || attr==NULL) return ret;
02496 
02497     tXML* node = get_xml_node_bystr(pp, str);
02498     if (node!=NULL) {
02499         char* val = xml_get_node_attr(node, attr);
02500         if (val!=NULL) {
02501             Buffer buf = make_Buffer_bystr(val);
02502             char* ptr  = (char*)buf.buf;
02503             if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
02504             if (ptr[0]=='"') ptr++; 
02505             ret = atoi(ptr);
02506             free_Buffer(&buf);
02507         }
02508     }
02509     return ret;
02510 }

Here is the call graph for this function:

int get_xml_int_content ( tXML *  pp,
tXML *  pt 
)

int get_xml_int_content(tXML* pp, tXML* pt)

get_xml_content() を使用し，XML コンテンツの内容を int型で返す．

Definition at line 2058 of file txml.c.

References get_xml_content().

02059 {
02060     int ret = 0;
02061 
02062     tXML* node = get_xml_content(pp, pt);
02063     if (node!=NULL) ret = atoi((char*)(node->ldat.key.buf));
02064     return ret;
02065 }

Here is the call graph for this function:

int get_xml_int_content_bystr ( tXML *  pp,
const char *  str 
)

int get_xml_int_content_bystr(tXML* pp, const char* str)

get_xml_int_content(tXML* pp, tXML* pt) の _bystr バージョン．
get_xml_content()_bystr を使用し，XML コンテンツの内容を int型で返す．

Definition at line 2364 of file txml.c.

References get_xml_content_bystr().

Referenced by llsd_xml_get_content_int().

02365 {
02366     int ret = 0;
02367 
02368     tXML* node = get_xml_content_bystr(pp, str);
02369     if (node!=NULL) ret = atoi((char*)(node->ldat.key.buf));
02370     return ret;
02371 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* get_xml_node ( tXML *  pp,
tXML *  pt 
)

tXML* get_xml_node(tXML* pp, tXML* pt)

XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptに最初に一致した枝の，ptの最後のノードに対応したノードへのポインタを返す．
pp の姉妹ツリーも検索するので注意．

また，pt の中で ctrl が TREE_NOCMP_NODE または TREE_NOCMP_NODE となっているノードは比較されない．
返ってきた tXML* は free() してはいけない．

Parameters:
pp 検索対象のXMLツリー．姉妹ツリーも検索する．
pt 検索するパターン
Returns:
ptの最後のノードに対応するノードへのポインタ．free() してはいけない．
例
以下の場合，pp の A->C->M->X の Xへのポインタが返る． 
    pp                         pt
    A --> B --> M              C --> M --> X
      --> C --> M --> X               
      --> Y --> Z   
            --> N

Definition at line 1835 of file txml.c.

References clear_tTree_ctrl(), FALSE, find_match_xml(), find_xml_end, and XML_ANCHOR_NODE.

Referenced by get_xml_attr(), get_xml_char_attr(), get_xml_double_attr(), get_xml_int_attr(), get_xml_node_bystr(), set_xml_attr(), and set_xml_node().

01836 {
01837     int fnd;
01838     tXML* tt;
01839     tXML* pm;
01840 
01841     if (pp==NULL || pt==NULL) return NULL;
01842 
01843     pm = pp;
01844     if (pp->ldat.id==XML_ANCHOR_NODE) {
01845         if (pp->next!=NULL) pp = pp->next;
01846         else return NULL;
01847     }
01848     if (pt->ldat.id==XML_ANCHOR_NODE) {
01849         if (pt->next!=NULL) pt = pt->next;
01850         else return NULL;
01851     }
01852 
01853     tt = find_xml_end(pt);
01854     if (tt==NULL) return FALSE;
01855 
01856     while(pp->esis!=NULL) pp = pp->esis;
01857     fnd = find_match_xml(pp, pt);
01858     if (fnd) tt = tt->altp;
01859     else     tt = NULL;
01860 
01861     clear_tTree_ctrl(pm);
01862 
01863     return tt;
01864 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* get_xml_node_bystr ( tXML *  pp,
const char *  str 
)

tXML* get_xml_node_bystr(tXML* pp, const char* str)

get_xml_node(tXML* pp, tXML* pt) の _bystr バージョン

Definition at line 2283 of file txml.c.

References del_xml, FALSE, get_xml_node(), and xml_parse().

Referenced by get_xml_char_attr_bystr(), get_xml_double_attr_bystr(), get_xml_int_attr_bystr(), and llsd_xml_contain_key().

02284 {
02285     tXML* tx;
02286     tXML* tt;
02287 
02288     if (pp==NULL || str==NULL) return FALSE;
02289 
02290     tx = xml_parse((char*)str);
02291     tt = get_xml_node(pp, tx);
02292     del_xml(&tx);
02293     return tt;
02294 }

Here is the call graph for this function:

Here is the caller graph for this function:

tList* get_xml_node_list ( tXML *  pp,
tXML *  pt 
)

tList* get_xml_node_list(tXML* pp, tXML* pt)

XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptに一致した枝の，ptの最後のノードに対応するノードへの ポインタをリストに格納して返す．ポインタはリストの altpに格納される．

pt の中で ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE となっているノードは 比較されない．これらのノードは必ず一致する．

Parameters:
pp 検索対象のツリー
pt 検索するパターン
Returns:
該当ノードへのポインタ情報(altp)を含んだリストへのポインタ

Definition at line 2601 of file txml.c.

References find_match_xml_endlist(), and XML_ANCHOR_NODE.

Referenced by get_xml_node_list_bystr().

02602 {
02603     tList* lp;
02604 
02605     if (pp==NULL || pt==NULL) return NULL;
02606 
02607     if (pp->ldat.id==XML_ANCHOR_NODE) {
02608         if (pp->next!=NULL) pp = pp->next;
02609         else return NULL;
02610     }
02611     if (pt->ldat.id==XML_ANCHOR_NODE) {
02612         if (pt->next!=NULL) pt = pt->next;
02613         else return NULL;
02614     }
02615 
02616     lp = find_match_xml_endlist(pp, pt);
02617 
02618     return lp;
02619 }

Here is the call graph for this function:

Here is the caller graph for this function:

tList* get_xml_node_list_bystr ( tXML *  pp,
const char *  str 
)

tList* get_xml_node_list_bystr(tXML* pp, const char* str)

get_xml_node_list() の _bystr バージョン．

Definition at line 2708 of file txml.c.

References del_xml, get_xml_node_list(), and xml_parse().

02709 {
02710     tXML*  tx;
02711     tList* tt;
02712 
02713     if (pp==NULL || str==NULL) return NULL;
02714 
02715     tx = xml_parse((char*)str);
02716     tt = get_xml_node_list(pp, tx);
02717     del_xml(&tx);
02718 
02719     return tt;
02720 }

Here is the call graph for this function:

tXML* init_xml_doc ( void   ) 

tXML* init_xml_doc()

XML のドキュメントヘッダを作成する

Definition at line 1217 of file txml.c.

References xml_parse().

Referenced by xml_rpc_request_pack().

01218 {
01219     tXML* xml = xml_parse((char*)"<?xml version=\"1.0\" encoding=\"utf-8\"?>");
01220     return xml;
01221 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* insert_xml_node ( tXML *  xml,
const char *  name 
)

tXML* insert_xml_node(tXML* xml, const char* name)

XMLツリーのxml の直下（姉妹の一番上：長子）にノード（属性は指定しない）を挿入する．

Parameters:
xml 挿入するポイント
name 挿入するノードの名前
Returns:
挿入したノードへのポインタ

Definition at line 1258 of file txml.c.

References insert_tTree_node_bystr(), JBXL_XML_NODE_EMPTY, and XML_NAME_NODE.

01259 {
01260     tList* pp;
01261 
01262     if (xml==NULL || name==NULL) return NULL;
01263 
01264     pp = insert_tTree_node_bystr(xml, XML_NAME_NODE, 0, name, NULL, NULL, 0);
01265     pp->state = JBXL_XML_NODE_EMPTY;
01266     if (pp->prev!=NULL) pp->prev->ldat.lv++;
01267 
01268     return pp;
01269 }

Here is the call graph for this function:

int isnot_xml_name ( unsigned char *  pp  ) 

int isnot_xml_name(unsigned char* pp)

XML名として不適切かどうかを大まかに判断する．
かなりいい加減なので，FALSEだからといって，厳密にXML名として適切であるとは限らない．

Parameters:
pp 検査する XML名へのポインタ
Return values:
TRUE XML名として不適切
FALSE XML名として適切かもしれない

Definition at line 818 of file txml.c.

References FALSE, and TRUE.

Referenced by xml_parse_processing_node(), and xml_parse_start_node().

00819 {
00820     if (pp==NULL)  return TRUE;
00821     if (*pp=='\0') return TRUE;
00822 
00823     while (*pp!='\0') {
00824         if (*pp<=0x2c) return TRUE;                 //  !"#$%&'()*+,
00825         if (*pp==0x2f) return TRUE;                 // /
00826         if (*pp>=0x3b && *pp<=0x40) return TRUE;    // ;<=>?@
00827         if (*pp>=0x5b && *pp<=0x5e) return TRUE;    // [\]^
00828         if (*pp==0x60) return TRUE;                 // `
00829         if (*pp>=0x7b && *pp<=0x7f) return TRUE;    // {|}~DEL
00830         pp++;
00831     }
00832     
00833     return FALSE;
00834 }

Here is the caller graph for this function:

Buffer make_xml_attr_bydouble ( const char *  name,
double  value 
)

Buffer make_xml_attr_bydouble(const char* name, double value)

属性名 name, double型実数の属性値 value を持つ Buffer型変数を作成する．

Definition at line 1529 of file txml.c.

References cat_s2Buffer, dtostr_ts(), freeNull, and make_Buffer_bystr.

01530 {
01531     char* str = dtostr_ts(value);
01532 
01533     Buffer buf = make_Buffer_bystr(name);
01534     cat_s2Buffer("=\"", &buf);
01535     cat_s2Buffer(str, &buf);
01536     cat_s2Buffer("\"",  &buf);
01537 
01538     freeNull(str);
01539     return buf;
01540 }

Here is the call graph for this function:

Buffer make_xml_attr_byfloat ( const char *  name,
float  value 
)

Buffer make_xml_attr_byfloat(const char* name, float value)

属性名 name, float型実数の属性値 value を持つ Buffer型変数を作成する．

Definition at line 1510 of file txml.c.

References cat_s2Buffer, freeNull, ftostr_ts(), and make_Buffer_bystr.

01511 {
01512     char* str = ftostr_ts(value);
01513 
01514     Buffer buf = make_Buffer_bystr(name);
01515     cat_s2Buffer("=\"", &buf);
01516     cat_s2Buffer(str, &buf);
01517     cat_s2Buffer("\"",  &buf);
01518 
01519     freeNull(str);
01520     return buf;
01521 }

Here is the call graph for this function:

Buffer make_xml_attr_byint ( const char *  name,
int  value 
)

Buffer make_xml_attr_byint(const char* name, int value)

属性名 name, 整数の属性値 value を持つ Buffer型変数を作成する．

Definition at line 1491 of file txml.c.

References cat_s2Buffer, freeNull, itostr_ts(), and make_Buffer_bystr.

01492 {
01493     char* str = itostr_ts(value);
01494 
01495     Buffer buf = make_Buffer_bystr(name);
01496     cat_s2Buffer("=\"", &buf);
01497     cat_s2Buffer(str, &buf);
01498     cat_s2Buffer("\"",  &buf);
01499 
01500     freeNull(str);
01501     return buf;
01502 }

Here is the call graph for this function:

Buffer make_xml_attr_bystr ( const char *  name,
const char *  value 
)

Buffer make_xml_attr_bystr(const char* name, const char* value)

属性名 name, 文字列の属性値 value を持つ Buffer型変数を作成する．

Definition at line 1475 of file txml.c.

References cat_s2Buffer, and make_Buffer_bystr.

01476 {
01477     Buffer buf = make_Buffer_bystr(name);
01478     cat_s2Buffer("=\"", &buf);
01479     cat_s2Buffer(value, &buf);
01480     cat_s2Buffer("\"",  &buf);
01481 
01482     return buf;
01483 }

void print_sister_xml_tree ( FILE *  fp,
tXML *  pp,
const char *  space 
)

void print_sister_xml_tree(FILE* fp, tXML* pp, const char* space)

XMLツリーの表示．ppの姉妹ノードも出力する．
ポインタ pp以降の全てのノードのキー部のバッファを標準エラー出力に表示する．
表示：入れ子の深さ，ID, ノード状態, ノード名(ノード値)，ノード属性の個数

Parameters:
fp 出力するファイルへのポインタ．NULLの場合は stderr
pp 表示を開始するノードへのポインタ．(姉妹ノードも出力する）
space 出力の書式を揃えるための空白（インデント）を指定する．例 " "

Definition at line 1766 of file txml.c.

References count_tList(), print_sister_xml_tree(), and XML_ANCHOR_NODE.

Referenced by print_sister_xml_tree(), and print_xml_tree().

01767 {
01768     if (fp==NULL) fp = stderr;
01769 
01770     if (pp!=NULL) {
01771         if (pp->ldat.id==XML_ANCHOR_NODE) {
01772             if (pp->next!=NULL) pp = pp->next;
01773         }
01774 
01775         while(pp->esis!=NULL) pp = pp->esis;
01776         //
01777         while(pp!=NULL) {
01778             int i;
01779             tList_data ld = pp->ldat;
01780 
01781             if (pp->depth>=0) {
01782                 if (pp->esis!=NULL || pp->depth>=0) fprintf(fp, "\n");
01783                 if (pp->depth>0) {
01784                     for(i=0; i<pp->depth; i++) fprintf(fp, "%s", space);
01785                     //for(i=0; i<pp->depth-1; i++) fprintf(fp, "%s", "   ");
01786                     fprintf(fp, "-> ");
01787                 }
01788             }
01789             int num = count_tList((tList*)ld.lst);
01790             fprintf(fp, "%d: %d [%d] %s (%d)", pp->depth, ld.id, pp->state, ld.key.buf, num);
01791 
01792             if (pp->next!=NULL) print_sister_xml_tree(fp, pp->next, space);
01793        
01794             pp = pp->ysis;
01795         };
01796     }  
01797     else {
01798         fprintf(fp, "(XML is NULL)\n");
01799     } 
01800     fflush(fp);
01801        
01802     return;
01803 }

Here is the call graph for this function:

Here is the caller graph for this function:

void print_xml ( FILE *  fp,
tXML *  pp,
int  mode 
)

void print_xml(FILE* fp, tXML* pp, int mode)

XMLの表示（出力）．

Parameters:
fp 出力するファイルへのポインタ．NULLの場合は stderr
pp 表示を開始するXMLノードへのポインタ．
mode XML_ONELINE_FORMAT, XML_CRLF_FORMAT, XML_INDENT_FORMAT

Definition at line 1658 of file txml.c.

References Buffer::buf, free_Buffer(), XML_ANCHOR_NODE, and xml_inverse_parse().

01659 {
01660     if (fp==NULL) fp = stderr;
01661 
01662     if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;
01663 
01664     if (pp!=NULL) {
01665         Buffer buf = xml_inverse_parse(pp, mode);
01666         if (buf.buf!=NULL) {
01667             fprintf(fp, "%s", buf.buf);
01668             free_Buffer(&buf);
01669         }
01670         else fprintf(fp, "(XML is NULL)\n");
01671     }  
01672     else {
01673         fprintf(fp, "(XML is NULL)\n");
01674     } 
01675     fflush(fp);
01676        
01677     return;
01678 }

Here is the call graph for this function:

void print_xml_node ( FILE *  fp,
tXML *  pp 
)

void print_xml_node(FILE* fp, tXML* pp)

XMLのノード情報を表示する．デバッグ用．

Definition at line 1687 of file txml.c.

References count_tList(), and XML_ANCHOR_NODE.

01688 {
01689     if (fp==NULL) fp = stderr;
01690 
01691     //fprintf(fp, "深さ: ノード種別 [状態] ノード名 (属性数)\n");
01692 
01693     if (pp!=NULL) {
01694         if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;
01695         if (pp!=NULL) {
01696             int num = count_tList((tList*)pp->ldat.lst);
01697             fprintf(fp, "%d: %d [%d] %s (%d)", pp->depth, pp->ldat.id, pp->state, pp->ldat.key.buf, num);
01698             fprintf(fp, "\n");
01699         }
01700         else {
01701             fprintf(fp, "(XML is ANCHOR only)\n");
01702         }
01703     }  
01704     else {
01705         fprintf(fp, "(XML is NULL)\n");
01706     }  
01707     fflush(fp);
01708 
01709     return;
01710 }

Here is the call graph for this function:

void print_xml_tree ( FILE *  fp,
tXML *  pp,
const char *  space 
)

void print_xml_tree(FILE* fp, tXML* pp, const char* space)

XMLツリーをそのままツリー表示する．デバッグ用．
ポインタ pp以降の全てのノードのキー部のバッファを標準エラー出力に表示する．

表示：入れ子の深さ: ノード種別 [ノード状態] ノード名 (属性の個数)

Parameters:
fp 出力するファイルへのポインタ．NULLの場合は stderr
pp 表示を開始するノードへのポインタ．
space 出力の書式を揃えるための空白（インデント）を指定する．例 " "

Definition at line 1726 of file txml.c.

References print_sister_xml_tree(), and XML_ANCHOR_NODE.

01727 {
01728     int i;
01729     if (fp==NULL) fp = stderr;
01730 
01731     //fprintf(fp, "深さ: ノード種別 [状態] ノード名 (属性数)\n");
01732 
01733     if (pp!=NULL) {
01734         if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;
01735         if (pp!=NULL) {
01736             for(i=0; i<pp->depth; i++)   fprintf(fp, "%s", space);
01737             for(i=0; i<pp->depth-1; i++) fprintf(fp, "%s", "   ");       // for "-> "
01738             print_sister_xml_tree(fp, pp, space);
01739             fprintf(fp, "\n");
01740         }
01741         else {
01742             fprintf(fp, "(XML is ANCHOR only)\n");
01743         }
01744     }  
01745     else {
01746         fprintf(fp, "(XML is NULL)\n");
01747     }  
01748     fflush(fp);
01749 
01750     return;
01751 }

Here is the call graph for this function:

int replace_all_node_byid ( tXML *  pp,
const char *  src,
const char *  dst,
int  id 
)

int replace_all_node_byid(tXML* pp, const char* src, const char* dst, int id)

XMLツリー pp内で ノードの種別が idである全てのノードの内容を srcから dstに書き換える．

Parameters:
pp 置換対象のツリー
src 置換対象のノードのコンテント（の一部でも可）． NULL の場合は全ての文字列
dst 置換後のノードのコンテント
id 置き換え対象のノードのID．id<0 なら全てのノード
Returns:
置き換えたノードの数

Definition at line 3249 of file txml.c.

References replace_all_node_byid_rcsv(), and XML_ANCHOR_NODE.

03250 {
03251     int  n;
03252 
03253     if (pp==NULL || dst==NULL) return 0;
03254 
03255     if (pp->ldat.id==XML_ANCHOR_NODE) {
03256         if (pp->next!=NULL) pp = pp->next;
03257         else return 0;
03258     }
03259     while(pp->esis!=NULL) pp = pp->esis;
03260 
03261     n = replace_all_node_byid_rcsv(pp, src, dst, id);
03262 
03263     return n;
03264 }

Here is the call graph for this function:

int replace_all_node_byid_rcsv ( tXML *  pp,
const char *  src,
const char *  dst,
int  id 
)

int replace_all_node_byid_rcsv(tXML* pp, const char* src, const char* dst, int id)

replace_all_node_byid() の補助関数

Definition at line 3273 of file txml.c.

References copy_s2Buffer, free_Buffer(), replace_all_node_byid_rcsv(), and replace_sBuffer_bystr().

Referenced by replace_all_node_byid(), and replace_all_node_byid_rcsv().

03274 {
03275     int  n = 0;
03276 
03277     while(pp!=NULL) {
03278         if (id<0 || pp->ldat.id==id) {
03279             if (src==NULL) {
03280                 copy_s2Buffer(dst, &(pp->ldat.key));
03281                 n++;
03282             }
03283             else if (pp->ldat.key.buf!=NULL && strstr((const char*)pp->ldat.key.buf, src)!=NULL) {
03284                 Buffer buf = replace_sBuffer_bystr(pp->ldat.key, src, dst);
03285                 free_Buffer(&(pp->ldat.key));
03286                 pp->ldat.key = buf;    
03287                 n++;
03288             }
03289         }
03290 
03291         if (pp->next!=NULL) n += replace_all_node_byid_rcsv(pp->next, src, dst, id);
03292 
03293         pp = pp->ysis;
03294     }
03295 
03296     return n;
03297 }

Here is the call graph for this function:

Here is the caller graph for this function:

int replace_all_node_contents ( tXML *  pp,
const char *  name,
const char *  src,
const char *  dst 
)

int replace_all_node_contents(tXML* pp, const char* name, const char* src, const char* dst)

XMLツリー pp内で ノード名が nameである全てのノードのコンテントを，srcから dstに書き換える．
一つのノードに複数のコンテントがある場合にも対応．

Parameters:
pp 置換対象のツリー
name 置き換えを行うノードのノード名．NULLの場合は全ての文字列．
src 置換対象のノードのコンテント（の一部でも可）． NULL の場合は全ての文字列
dst 置換後のノードのコンテント
Returns:
置き換えたノードの数

Definition at line 3175 of file txml.c.

References replace_all_node_contents_rcsv(), and XML_ANCHOR_NODE.

Referenced by replace_all_node_integer().

03176 {
03177     int  n;
03178 
03179     if (pp==NULL || dst==NULL) return 0;
03180 
03181     if (pp->ldat.id==XML_ANCHOR_NODE) {
03182         if (pp->next!=NULL) pp = pp->next;
03183         else return 0;
03184     }
03185     while(pp->esis!=NULL) pp = pp->esis;
03186 
03187     n = replace_all_node_contents_rcsv(pp, name, src, dst);
03188 
03189     return n;
03190 }

Here is the call graph for this function:

Here is the caller graph for this function:

int replace_all_node_contents_rcsv ( tXML *  pp,
const char *  name,
const char *  src,
const char *  dst 
)

int replace_all_node_contents_rcsv(tXML* pp, const char* name, const char* src, const char* dst)

replace_all_node_content() の補助関数

Definition at line 3199 of file txml.c.

References copy_s2Buffer, free_Buffer(), replace_all_node_contents_rcsv(), replace_sBuffer_bystr(), XML_CONTENT_NODE, and XML_NAME_NODE.

Referenced by replace_all_node_contents(), and replace_all_node_contents_rcsv().

03200 {
03201     int  n = 0;
03202 
03203     while(pp!=NULL) {
03204         if (pp->ldat.key.buf!=NULL && pp->ldat.id==XML_NAME_NODE && pp->ldat.lv>0) {
03205             if (name==NULL || !strcmp(name, (const char*)(pp->ldat.key.buf))) {
03206                 tXML* tt = pp->next;
03207 
03208                 // 複数のコンテント
03209                 while (tt!=NULL) {
03210                     if (tt->ldat.id==XML_CONTENT_NODE) {
03211                         if (src==NULL) {
03212                             copy_s2Buffer(dst, &(tt->ldat.key));
03213                             n++;
03214                         }
03215                         else if (tt->ldat.key.buf!=NULL && strstr((const char*)tt->ldat.key.buf, src)!=NULL) {
03216                             Buffer buf = replace_sBuffer_bystr(tt->ldat.key, src, dst);
03217                             free_Buffer(&(tt->ldat.key));
03218                             tt->ldat.key = buf;
03219                             n++;
03220                         }
03221                     }
03222                     tt = tt->ysis;
03223                 }
03224             }
03225         }
03226 
03227         if (pp->next!=NULL) n += replace_all_node_contents_rcsv(pp->next, name, src, dst);
03228 
03229         pp = pp->ysis;
03230     }
03231 
03232     return n;
03233 }

Here is the call graph for this function:

Here is the caller graph for this function:

int replace_all_node_integer ( tXML *  tp,
const char *  name,
int  src,
int  dst 
)

int replace_all_node_integer(tXML* tp, const char* name, int src, int dst)

XMLツリー pp内で ノード名が nameである全てのノードのコンテント（整数）を，srcから dstに書き換える．

Parameters:
tp 置換対象のツリー
name 置き換えを行うノードのノード名
src 置換対象のノードのコンテント（整数）
dst 置換後のノードのコンテント（整数）
Returns:
置き換えたノードの数

Definition at line 3147 of file txml.c.

References replace_all_node_contents().

03148 {
03149     int  n;
03150     char nums[20], numd[20];
03151 
03152     snprintf(nums, 10, "%d", src);
03153     snprintf(numd, 10, "%d", dst);
03154 
03155     n = replace_all_node_contents(tp, name, nums, numd);
03156 
03157     return n;
03158 }

Here is the call graph for this function:

int replace_xml_content ( tXML *  pp,
tXML *  pt,
const char *  src,
const char *  dst 
)

int replace_xml_content(tXML* pp, tXML* pt, const char* src, const char* dst)

get_xml_content() を使用し，XMLキーの src部分を dstで書き換える．

Definition at line 2257 of file txml.c.

References Buffer::buf, FALSE, free_Buffer(), get_xml_content(), replace_sBuffer_bystr(), and TRUE.

Referenced by replace_xml_content_bystr().

02258 {
02259     tXML*  tt;
02260     Buffer tg;
02261 
02262     if (pp==NULL || pt==NULL || src==NULL || dst==NULL) return FALSE;
02263 
02264     tt = get_xml_content(pp, pt);
02265     if (tt==NULL) return FALSE;
02266 
02267     tg = replace_sBuffer_bystr(tt->ldat.key, src, dst);
02268     if (tg.buf==NULL) return FALSE;
02269 
02270     free_Buffer(&(tt->ldat.key));
02271     tt->ldat.key = tg;
02272     
02273     return TRUE;
02274 }

Here is the call graph for this function:

Here is the caller graph for this function:

int replace_xml_content_bystr ( tXML *  pp,
const char *  str,
const char *  src,
const char *  dst 
)

int replace_xml_content_bystr(tXML*pp, const char* str, const char* src, const char* dst)

replace_xml_content() の _bystr バージョン．

Definition at line 2568 of file txml.c.

References del_xml, FALSE, replace_xml_content(), and xml_parse().

02569 {
02570     tXML* tx;
02571     int   rt;
02572 
02573     if (pp==NULL || src==NULL || src==NULL || dst==NULL) return FALSE;
02574 
02575     tx = xml_parse((char*)str);
02576     rt = replace_xml_content(pp, tx, src, dst);
02577     del_xml(&tx);
02578     return rt;
02579 }

Here is the call graph for this function:

int return_exist_node ( tXML *  tp,
const char *  name,
int  no,
Buffer *  content 
)

int return_exist_node(tXML* tp, const char* name, int no, Buffer* content)

bufの中に ノード '<name>content</name>' が存在するかどうかチェックする．
存在する場合はそのノードのコンテントのコピーを content に格納し，TRUE を返す．

Definition at line 3122 of file txml.c.

References Buffer::buf, FALSE, get_node_content(), and TRUE.

03123 {
03124     Buffer buf;
03125     
03126     buf = get_node_content(tp, name, no);
03127     if (buf.buf==NULL) return FALSE;
03128 
03129     if (content!=NULL) *content = buf;
03130     return TRUE;
03131 }

Here is the call graph for this function:

int set_xml_attr ( tXML *  pp,
tXML *  pt,
tList *  at 
)

int set_xml_attr(tXML* pp, tXML* pt, tList* at)

XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptに最初に一致した枝の， ptの最後のノードに対応したノードのノードの属性として atの値をコピーする．
pp の姉妹ツリーも検索するので注意．

pt の中で ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE となっているノードは 比較されない．これらのノードは必ず一致する．

Parameters:
pp 検索対象のツリー．姉妹ツリーも検索する．
pt 検索パターン
at 設定する属性の格納されたリスト．ldat.key に属性名，ldat.val に属性値("",''付き)
Return values:
TRUE 設定する枝を見つけた．正常に設置されたかどうかは不明．
FALSE 設定する枝を見つけられなかった．

Definition at line 2235 of file txml.c.

References del_all_tList(), dup_tList(), FALSE, get_xml_node(), and TRUE.

Referenced by set_xml_attr_bystr().

02236 {
02237     tXML* tt;
02238 
02239     if (pp==NULL || pt==NULL || at==NULL) return FALSE;
02240 
02241     tt  = get_xml_node(pp, pt);
02242     if (tt!=NULL) {
02243         del_all_tList(&(tt->ldat.lst));
02244         tt->ldat.lst = dup_tList(at);
02245     }
02246     else return FALSE;
02247     return TRUE;
02248 }

Here is the call graph for this function:

Here is the caller graph for this function:

int set_xml_attr_bystr ( tXML *  pp,
const char *  str,
tList *  at 
)

int set_xml_attr_bystr(tXML* pp, const char* str, tList* at)

set_xml_attr() の _bystr バージョン．

Definition at line 2548 of file txml.c.

References del_xml, FALSE, set_xml_attr(), and xml_parse().

02549 {
02550     tXML* tx;
02551     int   rt;
02552 
02553     if (pp==NULL || str==NULL || at==NULL) return FALSE;
02554 
02555     tx = xml_parse((char*)str);
02556     rt = set_xml_attr(pp, tx, at);
02557     del_xml(&tx);
02558     return rt;
02559 }

Here is the call graph for this function:

int set_xml_content ( tXML *  pp,
tXML *  pt,
const char *  content 
)

int set_xml_content(tXML* pp, tXML* pt, const char* content)

XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptに最初に一致した枝の， ptの最後ノードに対応したのノードのコンテントを contentで置き換える．
pp の姉妹ツリーも検索するので注意．

pt の中で ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE となっているノードは 比較されない．これらのノードは必ず一致する．

Parameters:
pp 検索対象のツリー．姉妹ツリーも検索する．
pt 検索パターン
content ptの最後のノードに対応するノードにコピーするノード値．
Return values:
TRUE 設定する枝を見つけた．正常に設定れたかどうかは不明．
FALSE 設定する枝を見つけられなかった．

Definition at line 2038 of file txml.c.

References copy_s2Buffer, FALSE, get_xml_content(), and TRUE.

Referenced by set_xml_content_bystr().

02039 {
02040     tXML* tt;
02041 
02042     if (pp==NULL || pt==NULL || content==NULL) return FALSE;
02043 
02044     tt = get_xml_content(pp, pt);
02045     if (tt==NULL) return FALSE;
02046     
02047     copy_s2Buffer(content, &(tt->ldat.key));
02048     return TRUE;
02049 }

Here is the call graph for this function:

Here is the caller graph for this function:

int set_xml_content_bystr ( tXML *  pp,
const char *  str,
const char *  val 
)

int set_xml_content_bystr(tXML* pp, const char* str, const char* val)

set_xml_content(tXML* pp, tXML* pt, char* val) の _bystr バージョン

Definition at line 2432 of file txml.c.

References del_xml, FALSE, set_xml_content(), and xml_parse().

02433 {
02434     tXML*  tx;
02435     int    rt;
02436 
02437     if (pp==NULL || str==NULL || val==NULL) return FALSE;
02438 
02439     tx = xml_parse((char*)str);
02440     rt = set_xml_content(pp, tx, val);
02441     del_xml(&tx);
02442     return rt;
02443 }

Here is the call graph for this function:

int set_xml_content_list ( tXML *  pp,
tXML *  pt,
const char *  content 
)

int set_xml_content_list(tXML* pp, tXML* pt, const char* content)

get_xml_content_list() で検出したコンテントを, content で置き換える．

Parameters:
pp 対象のXMLツリー
pt 検索パターン
content 書き換えのノード値
Returns:
書き換えたノードの個数

Definition at line 2678 of file txml.c.

References copy_s2Buffer, del_tList(), and get_xml_content_list().

Referenced by set_xml_content_list_bystr().

02679 {
02680     int    num = 0;
02681     tList* lt;
02682     tList* lp;
02683 
02684     if (pp==NULL  || pt==NULL || content==NULL)  return 0;
02685 
02686     lp = lt = get_xml_content_list(pp, pt);
02687     if (lt==NULL) return 0;
02688 
02689     while (lt!=NULL) {
02690         if (lt->altp!=NULL) {
02691             copy_s2Buffer(content, &(lt->altp->ldat.key));
02692             num++;
02693         }
02694         lt = lt->next;
02695     }
02696     del_tList(&lp);
02697 
02698     return num;
02699 }

Here is the call graph for this function:

Here is the caller graph for this function:

int set_xml_content_list_bystr ( tXML *  pp,
const char *  str,
const char *  content 
)

int set_xml_content_list_bystr(tXML* pp, const char* str, const char* content)

set_xml_content_list_bystr() の _bystr バージョン．

Definition at line 2750 of file txml.c.

References del_xml, set_xml_content_list(), and xml_parse().

02751 {
02752     tXML* tx;
02753     int   rt;
02754 
02755     if (pp==NULL  || str==NULL || content==NULL) return 0;
02756 
02757     tx = xml_parse((char*)str);
02758     rt = set_xml_content_list(pp, tx, content);
02759     del_xml(&tx);
02760 
02761     return rt;
02762 }

Here is the call graph for this function:

int set_xml_end_node ( tXML *  pp,
tXML *  pt 
)

int set_xml_end_node(tXML* pp, tXML* pt)

XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptに最初に一致した枝の， ptの最後のノードに対応したノードに ptの最後のノードの値（含む属性）をコピーする．
pp の姉妹ツリーも検索するので注意．

ただし，ptの最後のノードに関しては比較されない(コピー用だから)．
pt の中で ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE となっているノードは比較されない．
これらのノードは必ず一致する．コピーを行うのは ptの最後のノードのみである．

コピーする属性は ldat.id, ldat.lv, ldat.sz, ldat.key, ldat.val, ldat.ptr, ldat.lst
ldat.val, ldat.ptr, ldat.lst については，ptで値が設定されていなければ，置き換えを行わない．

Parameters:
pp 検索対象のXMLツリー．姉妹ツリーも検索する．
pt 検索パターン
Return values:
TRUE 設定する枝を見つけた．正常に設定れたかどうかは不明．
FALSE 設定する枝を見つけられなかった．

Definition at line 1919 of file txml.c.

References adjust_tTree_depth(), clear_tTree_ctrl(), copy_tTree_byctrl(), FALSE, find_match_xml(), find_xml_end, TREE_NOCMP_COPY_NODE, and XML_ANCHOR_NODE.

Referenced by set_xml_end_node_bystr().

01920 {
01921     int      ret;
01922     tXML* tt;
01923     tXML* pm;
01924 
01925 
01926     if (pp==NULL || pt==NULL) return FALSE;
01927 
01928     pm = pp;
01929     if (pp->ldat.id==XML_ANCHOR_NODE) {
01930         if (pp->next!=NULL) pp = pp->next;
01931         else return FALSE;
01932     }
01933     if (pt->ldat.id==XML_ANCHOR_NODE) {
01934         if (pt->next!=NULL) pt = pt->next;
01935         else return FALSE;
01936     }
01937 
01938     tt = find_xml_end(pt);
01939     if (tt==NULL) return FALSE;
01940     tt->ctrl = TREE_NOCMP_COPY_NODE;        // 比べない．最後にコピー．
01941 
01942     while(pp->esis!=NULL) pp = pp->esis;
01943     ret = find_match_xml(pp, pt);
01944     if (ret) {
01945         copy_tTree_byctrl(pt);
01946         adjust_tTree_depth(pp);
01947     }
01948 
01949     clear_tTree_ctrl(pm);
01950 
01951     return ret;
01952 }

Here is the call graph for this function:

Here is the caller graph for this function:

int set_xml_end_node_bystr ( tXML *  pp,
const char *  str 
)

int set_xml_end_node_bystr(tXML* pp, const char* str)

set_xml_end_node(tXML* pp, tXML* pt) の _bystr バージョン

Definition at line 2323 of file txml.c.

References del_xml, FALSE, set_xml_end_node(), and xml_parse().

02324 {
02325     tXML*  tx;
02326     int    rt;
02327 
02328     if (pp==NULL || str==NULL) return FALSE;
02329 
02330     tx = xml_parse((char*)str);
02331     rt = set_xml_end_node(pp, tx);
02332     del_xml(&tx);
02333     return rt;
02334 }

Here is the call graph for this function:

int set_xml_node ( tXML *  pp,
tXML *  pt,
const char *  name 
)

int set_xml_node(tXML* pp, tXML* pt, const char* name)

XMLツリー pp内で XMLツリー ptと同じパターンの枝を探し，ptに最初に一致した枝の，ptの最後のノード対応したノードにノード名をコピーする．
pp の姉妹ツリーも検索するので注意．

pt の中で ctrl が TREE_NOCMP_NODE または TREE_NOCMP_COPY_NODE となっている ノードは比較されない．

Parameters:
pp 検索対象のXMLツリー．姉妹ツリーも検索する．
pt 検索パターン
name ptの最後のノードに対応するノードにコピーするノード名．
Return values:
TRUE 設定するノードノードを見つけた．正常に設定れたかどうかは不明．
FALSE 設定するノードノードを見つけられなかった．

Definition at line 1883 of file txml.c.

References copy_s2Buffer, FALSE, get_xml_node(), and TRUE.

Referenced by set_xml_node_bystr().

01884 {
01885     tXML* tt;
01886 
01887     if (pp==NULL || pt==NULL || name==NULL) return FALSE;
01888 
01889     tt = get_xml_node(pp, pt);
01890     if (tt==NULL) return FALSE;
01891     
01892     copy_s2Buffer(name, &(tt->ldat.key));
01893 
01894     return TRUE;
01895 }

Here is the call graph for this function:

Here is the caller graph for this function:

int set_xml_node_bystr ( tXML *  pp,
const char *  str,
const char *  val 
)

int set_xml_node_bystr(tXML* pp, const char* str, const char* val)

set_xml_node(tXML* pp, tXML* pt, const char* val) の _bystr バージョン

Definition at line 2303 of file txml.c.

References del_xml, FALSE, set_xml_node(), and xml_parse().

02304 {
02305     tXML*  tx;
02306     int    rt;
02307 
02308     if (pp==NULL || str==NULL || val==NULL) return FALSE;
02309 
02310     tx = xml_parse((char*)str);
02311     rt = set_xml_node(pp, tx, val);
02312     del_xml(&tx);
02313     return rt;
02314 }

Here is the call graph for this function:

void xml_attr_to_Buffer ( tList *  pp,
Buffer *  buf 
)

void xml_attr_to_Buffer(tList* pp, Buffer* buf)

リストに保存されたノードの属性をテキストへ戻す．

Parameters:
pp 属性データが格納されたリストへのポインタ．
buf 変換した属性データを格納する Buffer変数．

Definition at line 1191 of file txml.c.

References cat_Buffer(), and cat_s2Buffer.

Referenced by xml_open_node_Buffer().

01192 {
01193     while (pp!=NULL) {
01194         cat_s2Buffer(" ", buf);
01195         cat_Buffer(&(pp->ldat.key), buf);
01196 
01197         if (pp->ldat.val.buf!=NULL) {
01198             cat_s2Buffer("=", buf);
01199             cat_Buffer(&(pp->ldat.val), buf);
01200         }
01201         pp = pp->next;
01202     }
01203 }

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_close_node_Buffer ( tXML *  pp,
Buffer *  buf,
int  mode,
int  indent 
)

void xml_close_node_Buffer(tXML* pp, Buffer* buf, int mode, int indent)

ツリー中のXMLのクローズノードのデータを元の書式に戻して Bufferに格納する．

Parameters:
pp XMLデータの格納されたツリーのノードへのポインタ
buf 変換したXMLデータを格納した Buffer変数．
mode 元のXMLへ戻す時の書式
mode XML_ONELINE_FORMAT 改行なしの一行にする．
mode XML_CRLF_FORMAT ノードの終わりを CR(0x0d), LF(0x0a)で改行する．
mode XML_INDENT_FORMAT 先頭にインデント(TAB)をつけ，ノードごとに改行する．
indent インデントを付け始める深さ．modeが XML_INDENT_MODE のときのみ有効．

Definition at line 1152 of file txml.c.

References cat_Buffer(), cat_s2Buffer, XML_CONTENT_NODE, XML_CRLF_FORMAT, XML_INDENT_FORMAT, and XML_NAME_NODE.

Referenced by xml_to_Buffer().

01153 {
01154     int i;
01155 
01156     if (pp->ldat.id==XML_NAME_NODE) {
01157         if (pp->next!=NULL) {
01158             if (mode==XML_INDENT_FORMAT) {
01159                 if (pp->next->ldat.id!=XML_CONTENT_NODE || pp->next->ysis!=NULL) {
01160                     char* tabs = (char*)malloc(pp->depth-indent+1);
01161                     if (tabs!=NULL) {
01162                         for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01163                         tabs[pp->depth-indent] = '\0';
01164                         cat_s2Buffer(tabs, buf);
01165                         free(tabs);
01166                     }
01167                 }
01168             }
01169 
01170             cat_s2Buffer("</", buf);
01171             cat_Buffer(&(pp->ldat.key), buf);
01172             cat_s2Buffer(">", buf);
01173 
01174             if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
01175         }
01176     }
01177 
01178     return;
01179 }

Here is the call graph for this function:

Here is the caller graph for this function:

char* xml_get_node_attr ( tXML *  node,
const char *  attr 
)

char* xml_get_node_attr(tXML* node, const char* attr)

属性値を持つノードのポインタから，指定された属性値へのポインタを返す．free() してはいけない．

Definition at line 1566 of file txml.c.

References XML_NAME_NODE.

Referenced by get_xml_char_attr(), get_xml_char_attr_bystr(), get_xml_double_attr(), get_xml_double_attr_bystr(), get_xml_int_attr(), and get_xml_int_attr_bystr().

01567 {
01568     if (node==NULL) return NULL;
01569 
01570     if (node->ldat.id==XML_NAME_NODE) {
01571         tList* lt = node->ldat.lst;
01572         while (lt!=NULL) {
01573             if (!strcmp((const char*)lt->ldat.key.buf, attr)) return (char*)(lt->ldat.val.buf);
01574             lt = lt->next;
01575         }
01576     }
01577     return NULL;
01578 }

Here is the caller graph for this function:

char* xml_get_node_content ( tXML *  node  ) 

char* xml_get_node_content(tXML* node)

コンテントへのポインタを返す．free() してはいけない．

Definition at line 1549 of file txml.c.

References XML_CONTENT_NODE, and XML_NAME_NODE.

01550 {
01551     if (node==NULL || node->next==NULL) return NULL;
01552 
01553     if (node->ldat.id==XML_NAME_NODE) {
01554         if (node->next->ldat.id==XML_CONTENT_NODE) return (char*)(node->next->ldat.key.buf);
01555     }
01556     return NULL;
01557 }

Buffer xml_inverse_parse ( tXML *  pp,
int  mode 
)

Buffer xml_inverse_parse(tXML* pp, int mode)

ppに格納された XMLデータを元の書式に戻して Bufferに格納する．xml_parse() の逆．
XML_CRLF_FORMAT, XML_INDENT_FORMAT でノード値がある場合は，値を囲むノードは改行しない．

Parameters:
pp XMLデータの格納されたツリーへのポインタ
mode 元のXMLへ戻す時の書式
mode XML_ONELINE_FORMAT 改行なしの一行にする．
mode XML_CRLF_FORMAT ノードの終わりを CR(0x0d), LF(0x0a)で改行する．
mode XML_INDENT_FORMAT 先頭にインデント(TAB)をつけ，ノードごとに改行 CR LF (0x0d,0x0a)する．
Returns:
変換したXMLデータを格納した Buffer変数．

Definition at line 900 of file txml.c.

References Buffer::buf, count_tTree(), init_Buffer(), LMDATA, make_Buffer(), XML_ANCHOR_NODE, and xml_to_Buffer().

Referenced by print_xml(), and xml_rpc_request_pack().

00901 {
00902     int cnt;
00903     Buffer buf;
00904 
00905     buf = init_Buffer();
00906     if (pp==NULL) return buf;
00907     if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;
00908     if (pp==NULL) return buf;
00909 
00910     cnt = count_tTree(pp);
00911     buf = make_Buffer(cnt*LMDATA);
00912     if (buf.buf==NULL) return buf;
00913 
00914     while (pp->esis!=NULL) pp = pp->esis;
00915     xml_to_Buffer(pp, &buf, mode, pp->depth);
00916 
00917     return buf;
00918 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* xml_main_parse ( tXML *  xml,
char *  pp,
int  skip 
)

tXML* xml_main_parse(tXML* xml, char* pp, int skip)

部分的な XMLデータを解釈して，tXMLのツリー構造に格納する．
完全な XMLデータでなくても解釈できるところまでは解釈する．
パーサの内部的なメイン関数．ただし，ユーザが直接この関数を使用することは多分無い．

Parameters:
xml XMLデータを格納するツリー構造体の先頭へのポインタ．
pp XMLデータへのポインタ．
skip 最初のデータ（タイトルなど）をスキップするか？ TRUE or FLASE
Returns:
最後に処理したノードノードへのポインタ．ppがNULLの場合は xml, xmlが NULLの場合は NULLが返る．
Return values:
負数 state エラーの場合は stateに 負数の値が入る．

Definition at line 193 of file txml.c.

References add_tTree_node_bystr(), CHAR_CR, CHAR_LF, CHAR_TAB, freeNull, JBXL_XML_NODE_CLOSED, JBXL_XML_NODE_EMPTY, JBXL_XML_NODE_OPENED, JBXL_XML_PARSE_ERROR, JBXL_XML_SEQUENCE_ERROR, XML_COMMENT_NODE, XML_COMMENT_NODE_KEY, XML_CONTENT_NODE, XML_DATA_NODE, XML_DATA_NODE_KEY, XML_DOC_NODE, XML_NAME_NODE, xml_parse_attr(), xml_parse_comment_node(), xml_parse_content(), xml_parse_data_node(), xml_parse_end_node(), xml_parse_processing_node(), xml_parse_start_node(), and XML_PROCESS_NODE.

Referenced by xml_parse(), and xml_parse_seq().

00194 {
00195     int   n, node_end;
00196     char* node_name = NULL;
00197     char* node_attr = NULL;
00198     char* value     = NULL;
00199     
00200     if (pp ==NULL) return xml;
00201     if (xml==NULL) return NULL;
00202 
00203     if (skip) while (*pp!='\0' && *pp!='<') pp++;
00204 
00205     while (*pp!='\0') {
00206         n = 1;
00207 
00208         if (*pp=='<') {
00209             // End TAG        </   >
00210             if (*(pp+1)=='/') {
00211                 if (xml->state==JBXL_XML_NODE_OPENED) {
00212                     n = xml_parse_end_node(pp, &node_name);
00213                     if (n>0) {
00214                         if (node_name!=NULL && xml->ldat.key.buf!=NULL) {
00215                             if (!strcmp((const char*)node_name, (const char*)(xml->ldat.key.buf))) {
00216                                 if (xml->next!=NULL) {
00217                                     xml->state = JBXL_XML_NODE_CLOSED;
00218                                 }
00219                                 else {
00220                                     xml->state = JBXL_XML_NODE_EMPTY;
00221                                 }
00222                                 //
00223                                 if (xml->prev!=NULL) xml = xml->prev;
00224                                 else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00225                             }
00226                             else n = xml->state = JBXL_XML_PARSE_ERROR;
00227                         }
00228                         else n = xml->state = JBXL_XML_PARSE_ERROR;
00229                     }
00230                     else xml->state = n;                    // エラー
00231                 }
00232                 else n = xml->state = JBXL_XML_PARSE_ERROR;
00233             }
00234 
00235             // Comment TAG        <!--   -->
00236             else if (!strncmp(pp+1, "!--", 3)) {
00237                 n = xml_parse_comment_node(pp, &value);
00238                 if (n>0) {
00239                     xml = add_tTree_node_bystr(xml, XML_COMMENT_NODE, 0, (char*)XML_COMMENT_NODE_KEY, value, NULL, 0);
00240                     xml->state = JBXL_XML_NODE_EMPTY;
00241                     if (xml->prev!=NULL) xml = xml->prev;
00242                     else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00243                 }
00244             }
00245 
00246             // Data TAG            <!     >
00247             else if (*(pp+1)=='!') {
00248                 n = xml_parse_data_node(pp, &value);
00249                 if (n>0) {
00250                     xml = add_tTree_node_bystr(xml, XML_DATA_NODE, 0, (char*)XML_DATA_NODE_KEY, value, NULL, 0);
00251                     xml->state = JBXL_XML_NODE_EMPTY;
00252                     if (xml->prev!=NULL) xml = xml->prev;
00253                     else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00254                 }
00255             }
00256 
00257             // Processing TAG      <?   ?>
00258             else if (*(pp+1)=='?') {
00259                 n = xml_parse_processing_node(pp, &node_name, &node_attr);
00260                 if (n>0) {
00261                     if (!strncasecmp("xml", node_name, 3)) {
00262                         tList* lp = xml_parse_attr(node_attr);
00263                         xml = add_tTree_node_bystr(xml, XML_DOC_NODE, 0, node_name, NULL, NULL, 0);
00264                         xml->ldat.lst = lp;
00265                     }
00266                     else {
00267                         xml = add_tTree_node_bystr(xml, XML_PROCESS_NODE, 0, node_name, node_attr, NULL, 0);
00268                     }
00269                     xml->state = JBXL_XML_NODE_EMPTY;
00270                     if (xml->prev!=NULL) xml = xml->prev;
00271                     else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00272                 }
00273             }
00274 
00275             // Start TAG  <   > 
00276             else {
00277                 n = xml_parse_start_node(pp, &node_name, &node_attr, &node_end);
00278 
00279                 if (n>0) {
00280                     tList* lp = xml_parse_attr(node_attr);
00281                     xml = add_tTree_node_bystr(xml, XML_NAME_NODE, 0, node_name, NULL, NULL, 0);
00282                     xml->ldat.lst = lp;
00283 
00284                     if (node_end) {
00285                         xml->state = JBXL_XML_NODE_EMPTY;
00286                         if (xml->prev!=NULL) xml = xml->prev;
00287                         else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00288                     }
00289                     else {
00290                         int m;
00291                         xml->state = JBXL_XML_NODE_OPENED;
00292                         // ノード値
00293                         m = xml_parse_content(pp+n, &value);            // 0 が返る可能性がある
00294                         if (m>=0) {
00295                             n += m;
00296                             if (value!=NULL) {
00297                                 xml = add_tTree_node_bystr(xml, XML_CONTENT_NODE, 0, value, NULL, NULL, 0);
00298                                 xml->state = JBXL_XML_NODE_CLOSED;
00299                                 if (xml->prev!=NULL) {
00300                                     xml = xml->prev;
00301                                     xml->ldat.lv++;
00302                                 }
00303                                 else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00304                             }
00305                         }
00306                         else n = xml->state = m;                    // エラー
00307                     }
00308                 }
00309             }
00310 
00311             freeNull(node_name);
00312             freeNull(node_attr);
00313             freeNull(value);
00314         }
00315 
00316         // Content        (断片的に入力したXMLが content の途中で終わっている場合など)
00317         else {
00318             if (xml->state==JBXL_XML_NODE_OPENED) {
00319                 n = xml_parse_content(pp, &value);
00320                 if (n>0) {
00321                     if (value!=NULL) {
00322                         xml = add_tTree_node_bystr(xml, XML_CONTENT_NODE, 0, value, NULL, NULL, 0);
00323                         xml->state = JBXL_XML_NODE_CLOSED;
00324                         if (xml->prev!=NULL) {
00325                             xml = xml->prev;
00326                             xml->ldat.lv++;
00327                         }
00328                         else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00329                     }
00330                 }
00331                 else n = xml->state = JBXL_XML_PARSE_ERROR;
00332                 freeNull(value);
00333             }
00334             else n = xml->state = JBXL_XML_PARSE_ERROR;
00335         }
00336 
00337         // エラー
00338         if (n<=0) return xml;
00339 
00340         pp += n;
00341         while (*pp==' ' || *pp==CHAR_TAB || *pp==CHAR_LF || *pp==CHAR_CR) pp++;
00342     }
00343 
00344     return xml;
00345 }

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_open_node_Buffer ( tXML *  pp,
Buffer *  buf,
int  mode,
int  indent 
)

void xml_open_node_Buffer(tXML* pp, Buffer* buf, int mode, int indent)

ツリー中のXMLのオープンノードのデータを元の書式に戻して Bufferに格納する．

Parameters:
pp XMLデータの格納されたツリーのノードへのポインタ
buf 変換したXMLデータを格納した Buffer変数．
mode 元のXMLへ戻す時の書式
mode XML_ONELINE_FORMAT 改行なしの一行にする．
mode XML_CRLF_FORMAT ノードの終わりを CR(0x0d), LF(0x0a)で改行する．
mode XML_INDENT_FORMAT 先頭にインデント(TAB)をつけ，ノードごとに改行する．
indent インデントを付け始める深さ．modeが XML_INDENT_MODE のときのみ有効．

Definition at line 966 of file txml.c.

References Buffer::buf, cat_Buffer(), cat_s2Buffer, JBXL_XML_NODE_EMPTY, Buffer::vldsz, xml_attr_to_Buffer(), XML_COMMENT_NODE, XML_CONTENT_NODE, XML_CRLF_FORMAT, XML_DATA_NODE, XML_DOC_NODE, XML_INDENT_FORMAT, XML_NAME_NODE, and XML_PROCESS_NODE.

Referenced by xml_to_Buffer().

00967 {
00968     int i;
00969 
00970     // Name TAG
00971     if (pp->ldat.id==XML_NAME_NODE) {
00972         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
00973             if (buf->vldsz>0 && buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
00974         }
00975         //
00976         if (mode==XML_INDENT_FORMAT) {
00977             char* tabs = (char*)malloc(pp->depth-indent+1);
00978             if (tabs!=NULL) {
00979                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
00980                 tabs[pp->depth-indent] = '\0';
00981                 cat_s2Buffer(tabs, buf);
00982                 free(tabs);
00983             }
00984         }
00985 
00986         cat_s2Buffer("<", buf);
00987         cat_Buffer(&(pp->ldat.key), buf);
00988         if (pp->ldat.lst!=NULL) {
00989             xml_attr_to_Buffer(pp->ldat.lst, buf);
00990         }
00991         if (pp->next==NULL) {
00992             if (pp->state==JBXL_XML_NODE_EMPTY) {
00993                 cat_s2Buffer(" />", buf);
00994             }
00995             else {
00996                 cat_s2Buffer("></", buf);
00997                 cat_Buffer(&(pp->ldat.key), buf);
00998                 cat_s2Buffer(">", buf);
00999             }
01000             if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
01001                 cat_s2Buffer("\r\n", buf);
01002             }
01003         }
01004         else {
01005             cat_s2Buffer(">", buf);
01006         }
01007     }
01008     
01009     // Content
01010     else if (pp->ldat.id==XML_CONTENT_NODE) {
01011         if (buf->buf[buf->vldsz-1]=='\n') {
01012             buf->buf[buf->vldsz-2] = '\0';
01013             buf->vldsz -= 2;
01014         }
01015         //
01016         if (pp->esis!=NULL || pp->ysis!=NULL) {
01017             cat_s2Buffer("\r\n", buf); 
01018             char* tabs = (char*)malloc(pp->depth-indent+1);
01019             if (tabs!=NULL) {
01020                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01021                 tabs[pp->depth-indent] = '\0';
01022                 cat_s2Buffer(tabs, buf);
01023                 free(tabs);
01024             }
01025         }
01026         //
01027         cat_Buffer(&(pp->ldat.key), buf);
01028         //
01029         if (pp->esis!=NULL) cat_s2Buffer("\r\n", buf); 
01030     }
01031 
01032     // xml TAG
01033     else if (pp->ldat.id==XML_DOC_NODE) {
01034         if (mode==XML_INDENT_FORMAT) {
01035             char* tabs = (char*)malloc(pp->depth-indent+1);
01036             if (tabs!=NULL) {
01037                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01038                 tabs[pp->depth-indent] = '\0';
01039                 cat_s2Buffer(tabs, buf);
01040                 free(tabs);
01041             }
01042         }
01043 
01044         cat_s2Buffer("<?", buf);
01045         if (pp->ldat.key.buf!=NULL) {
01046             cat_Buffer(&(pp->ldat.key), buf);
01047         }
01048         if (pp->ldat.lst!=NULL) {
01049             xml_attr_to_Buffer(pp->ldat.lst, buf);
01050         }
01051         cat_s2Buffer("?>", buf);
01052 
01053         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
01054     }
01055 
01056     // Comment TAG
01057     else if (pp->ldat.id==XML_COMMENT_NODE) {
01058         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
01059             if (buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
01060         }
01061 
01062         if (mode==XML_INDENT_FORMAT) {
01063             char* tabs = (char*)malloc(pp->depth-indent+1);
01064             if (tabs!=NULL) {
01065                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01066                 tabs[pp->depth-indent] = '\0';
01067                 cat_s2Buffer(tabs, buf);
01068                 free(tabs);
01069             }
01070         }
01071 
01072         cat_s2Buffer("<!--", buf);
01073         if (pp->ldat.val.buf!=NULL) {
01074             cat_Buffer(&(pp->ldat.val), buf);
01075         }
01076         cat_s2Buffer("-->", buf);
01077 
01078         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
01079     }
01080 
01081     // Data TAG
01082     else if (pp->ldat.id==XML_DATA_NODE) {
01083         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
01084             if (buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
01085         }
01086         //
01087         if (mode==XML_INDENT_FORMAT) {
01088             char* tabs = (char*)malloc(pp->depth-indent+1);
01089             if (tabs!=NULL) {
01090                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01091                 tabs[pp->depth-indent] = '\0';
01092                 cat_s2Buffer(tabs, buf);
01093                 free(tabs);
01094             }
01095         }
01096 
01097         cat_s2Buffer("<!", buf);
01098         if (pp->ldat.val.buf!=NULL) {
01099             cat_Buffer(&(pp->ldat.val), buf);
01100         }
01101         cat_s2Buffer(">", buf);
01102 
01103         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
01104     }
01105 
01106     // Processing TAG
01107     else if (pp->ldat.id==XML_PROCESS_NODE) {
01108         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
01109             if (buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
01110         }
01111         //
01112         if (mode==XML_INDENT_FORMAT) {
01113             char* tabs = (char*)malloc(pp->depth-indent+1);
01114             if (tabs!=NULL) {
01115                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01116                 tabs[pp->depth-indent] = '\0';
01117                 cat_s2Buffer(tabs, buf);
01118                 free(tabs);
01119             }
01120         }
01121 
01122         cat_s2Buffer("<?", buf);
01123         if (pp->ldat.key.buf!=NULL) {
01124             cat_Buffer(&(pp->ldat.key), buf);
01125         }
01126         if (pp->ldat.lst!=NULL) {
01127             xml_attr_to_Buffer(pp->ldat.lst, buf);
01128         }
01129         cat_s2Buffer(" ?>", buf);
01130 
01131         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
01132     }
01133 
01134     return;
01135 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* xml_parse ( char *  pp  ) 

tXML* xml_parse(char* pp)

文字列のXMLデータを解釈して，tXMLのツリーを生成する．

Parameters:
pp 文字列の XMLデータへのポインタ．
Returns:
XMLデータを格納した tXMLのアンカーへのポインタ．
エラーの場合，next以下のノードにはエラーを起こす直前までの内容が保存される
Return values:
負数 エラーを起こした場合 stateに JBXL_XML_PARSED以外の値（0以下）が入る．
    tXML* xml = xml_parse("<a t=\"x\"><b>aaaa<d>bbbb</d>cccc<xxxi/>ddddd</b><c><e></e></c></a>");

Definition at line 49 of file txml.c.

References JBXL_STATE_ANCHOR, JBXL_XML_DEFAULT_STATE, JBXL_XML_MULTI_ROOT, JBXL_XML_NOT_CLOSED, JBXL_XML_PARSED, new_xml_node, TRUE, XML_ANCHOR_NODE, xml_main_parse(), and XML_NAME_NODE.

Referenced by get_xml_attr_bystr(), get_xml_content_bystr(), get_xml_content_list_bystr(), get_xml_node_bystr(), get_xml_node_list_bystr(), init_xml_doc(), replace_xml_content_bystr(), set_xml_attr_bystr(), set_xml_content_bystr(), set_xml_content_list_bystr(), set_xml_end_node_bystr(), set_xml_node_bystr(), and xml_parse_file().

00050 {
00051     tXML* xml;
00052     tXML* node;
00053 
00054     xml = new_xml_node();                    // アンカー
00055     xml->ldat.id = XML_ANCHOR_NODE;
00056     xml->state   = JBXL_STATE_ANCHOR;
00057     xml->depth   = -1;
00058 
00059     // パース
00060     node = xml_main_parse(xml, pp, TRUE);
00061     if (node->state<0) return xml;
00062 
00063     // 元に戻ったか？
00064     if (xml==node) {
00065         xml->state = JBXL_XML_PARSED;
00066     }
00067     else {
00068         xml->state = JBXL_XML_NOT_CLOSED;
00069     }
00070 
00071     // XML rootの数
00072     if (xml->next!=NULL) {
00073         int n = 0;
00074         node = xml->next;
00075         while(node!=NULL) {
00076             if (node->ldat.id==XML_NAME_NODE) n++;
00077             node = node->ysis;
00078         }
00079         if (n!=1) xml->state = JBXL_XML_MULTI_ROOT;
00080     }
00081     else xml->state = JBXL_XML_DEFAULT_STATE;
00082 
00083     return xml;
00084 }

Here is the call graph for this function:

Here is the caller graph for this function:

tList* xml_parse_attr ( char *  pp  ) 

tList* xml_parse_attr(char* pp)

XMLのノード属性を解釈して，リスト(tList)にする． 解釈する形式は AAA="GGG" xxxx="1234"

Parameters:
pp テキストで保存されている属性へのポインタ．
Returns:
生成したリストの先頭へのポインタ．
Return values:
JBXL_XML_PARSE_ERR state パースエラーの場合は state に JBXL_XML_PARSE_ERROR が設定される．
JBXL_XML_NODE_CLOSED state 正常に終了した場合は JBXL_XML_NODE_CLOSED が設定される．

Definition at line 566 of file txml.c.

References add_tList_node_str, JBXL_XML_NODE_CLOSED, and JBXL_XML_PARSE_ERROR.

Referenced by add_xml_attr(), and xml_main_parse().

00567 {
00568     int    sz;
00569     char*  nm;
00570     char*  vl;
00571     char*  pt;
00572     char   qt;
00573     tList* lp = NULL;
00574     tList* lt = NULL;
00575 
00576     // 作業メモリの確保
00577     if (pp==NULL) return NULL;
00578     sz = (int)strlen((const char*)pp) + 1;
00579     nm = (char*)malloc(sz);
00580     if (nm==NULL) return NULL;
00581     vl = (char*)malloc(sz);
00582     if (vl==NULL) {
00583         free(nm);
00584         return NULL;
00585     }
00586 
00587     // Parse for AAA="BBB" CCC="DDDD"
00588     while (*pp==' ' && *pp!='\0') pp++;
00589     while (*pp!='\0') {
00590         pt = pp;
00591         while (*pt!='=' && *pt!='\0') pt++;
00592         if (*pt=='\0') {
00593             if (lt!=NULL) lt->state = JBXL_XML_PARSE_ERROR;
00594             break;
00595         }
00596 
00597         sz = (int)(pt - pp);
00598         memcpy(nm, pp, (size_t)sz);
00599         nm[sz] = '\0';
00600 
00601         pt++;
00602         if (*pt!='"' && *pt!='\'') {
00603             if (lt!=NULL) lt->state = JBXL_XML_PARSE_ERROR;
00604             break;
00605         }
00606         else qt = *pt;
00607 
00608         pt++;
00609         pp = pt;
00610         while(*pt!=qt && *pt!='\0') pt++;
00611         if (*pt=='\0') {
00612             if (lt!=NULL) lt->state = JBXL_XML_PARSE_ERROR;
00613             break;
00614         }
00615 
00616         sz = (int)(pt - pp);
00617         memcpy(vl+1, pp, (size_t)sz);
00618         vl[0]     = qt;
00619         vl[sz+1] = qt;
00620         vl[sz+2] = '\0';
00621 
00622         lp = add_tList_node_str(lp, nm, vl);
00623         if (lt==NULL) lt = lp;
00624         pp = pt + 1;
00625 
00626         if (*pp!=' ' && *pp!='\0') {
00627             lt->state = JBXL_XML_PARSE_ERROR;
00628             break;
00629         }
00630         while (*pp==' ' && *pp!='\0') pp++;
00631     }
00632 
00633     //
00634     free(nm);
00635     free(vl);
00636 
00637     if (lt!=NULL) {
00638         if (lt->state!=JBXL_XML_PARSE_ERROR) lt->state = JBXL_XML_NODE_CLOSED;
00639     }
00640     return lt;
00641 }

Here is the caller graph for this function:

int xml_parse_comment_node ( char *  pp,
char **  comment 
)

int xml_parse_comment_node(char* pp, char** comment)

XMLのコメントノードを処理する．処理できるノードの型は ''
xml_parse_data_node() に先立って適用させる必要がある．

Parameters:
pp ノードへのポインタ．'<' を指すポインタ．
[out] *comment コメント部分がそのまま格納される．要 free
Return values:
1以上 ノード全体の長さ．0 が返ることは無い．
JBXL_XML_PARSE_ERROR パースエラー
JBXL_MALLOC_ERROR メモリエラー

Definition at line 736 of file txml.c.

References JBXL_MALLOC_ERROR, JBXL_XML_PARSE_ERROR, and skip_chars().

Referenced by xml_main_parse().

00737 {
00738     int   nn, mm;
00739     char* pt;
00740 
00741     *comment = NULL;
00742     if (pp==NULL) return JBXL_XML_PARSE_ERROR;
00743     if (strncmp(pp, "<!--", 4)) return JBXL_XML_PARSE_ERROR;
00744 
00745     pt = pp = pp + 4;
00746     pt = skip_chars(pt, ">");
00747     if (pt==NULL) return JBXL_XML_PARSE_ERROR;
00748 
00749     pt -= 2;
00750     if (strncmp(pt, "-->", 3)) return JBXL_XML_PARSE_ERROR;
00751 
00752     nn = mm = (int)(pt - pp);
00753     if (mm==0) return JBXL_XML_PARSE_ERROR;
00754 
00755     nn += 4;
00756     *comment = (char*)malloc((size_t)(mm+1));
00757     if (*comment==NULL) return JBXL_MALLOC_ERROR;
00758     memcpy(*comment, pp, mm);
00759     (*comment)[mm] = '\0';
00760     //PRINT_MESG("COMMENT-> %s  %d\n", *comment, (int)strlen(*comment));
00761 
00762     return nn + 3;
00763 }

Here is the call graph for this function:

Here is the caller graph for this function:

int xml_parse_content ( char *  pp,
char **  content 
)

int xml_parse_content(char* pp, char** content)

XMLのコンテントを処理する． <node_name attr="node_attr">content</node_name>
値の前後の空白，TAB, LF, CRは削除される．

Parameters:
pp コンテントの先頭へのポインタ．Start Tagの '>' の次を指すポインタ．
[in] *content コンテントを格納するポインタ．コンテントがない場合は NULLでも可．
[out] *content コンテントが格納される．前後の 空白, TAB, LF, CRは削除されている．要 free
Return values:
0以上 ノード値部の全体の長さ．0 が返る可能性もある（<x></x>の場合）
JBXL_XML_PARSE_ERROR パースエラー
JBXL_MALLOC_ERROR メモリエラー

Definition at line 519 of file txml.c.

References CHAR_CR, CHAR_LF, CHAR_TAB, JBXL_MALLOC_ERROR, JBXL_XML_PARSE_ERROR, and pack_head_tail_char().

Referenced by xml_main_parse().

00520 {
00521     int   nn=0, mm;
00522     char* pt;
00523     char* work;
00524 
00525     if (pp==NULL || content==NULL) return JBXL_XML_PARSE_ERROR;
00526     *content = NULL;
00527 
00528     while (*pp==' ' || *pp==CHAR_TAB || *pp==CHAR_LF || *pp==CHAR_CR) {
00529         pp++;
00530         nn++;
00531     }
00532     if (*pp=='<') return nn;            // <node><
00533 
00534     pt = pp;
00535     while (*pt!='<' && *pt!='\0') pt++;
00536 
00537     mm = (int)(pt - pp);
00538     if (mm==0) return nn;
00539     nn += mm;
00540 
00541     work = (char*)malloc((size_t)(mm+1));
00542     if (work==NULL) return JBXL_MALLOC_ERROR;
00543     memcpy(work, pp, mm);
00544     work[mm] = '\0';
00545 
00546     *content = pack_head_tail_char(work, ' ');
00547     free(work);
00548     //PRINT_MESG("VALUE --> %s  %d\n", *content, (int)strlen(*content));
00549 
00550     return nn;
00551 }

Here is the call graph for this function:

Here is the caller graph for this function:

int xml_parse_data_node ( char *  pp,
char **  data 
)

int xml_parse_data_node(char* pp, char** data)

XMLのデータノード（その他エレメントノードなど）を処理する．処理できるノードの型は <!data>
データ部分は解釈せずに，そのまま dataに格納される．

Parameters:
pp ノードへのポインタ．'<' を指すポインタ．
[out] *data データ部分がそのまま格納される．要 free
Return values:
1以上 ノード全体の長さ．0 が返ることは無い．
JBXL_XML_PARSE_ERROR パースエラー
JBXL_MALLOC_ERROR メモリエラー

Definition at line 780 of file txml.c.

References JBXL_MALLOC_ERROR, JBXL_XML_PARSE_ERROR, and skip_chars().

Referenced by xml_main_parse().

00781 {
00782     int   nn, mm;
00783     char* pt;
00784 
00785     *data = NULL;
00786     if (pp==NULL) return JBXL_XML_PARSE_ERROR;
00787     if (strncmp(pp, "<!", 2)) return JBXL_XML_PARSE_ERROR;
00788 
00789     pt = pp = pp + 2;
00790     pt = skip_chars(pt, ">");
00791     if (pt==NULL) return JBXL_XML_PARSE_ERROR;
00792 
00793     nn = mm = (int)(pt - pp);
00794     if (mm==0) return JBXL_XML_PARSE_ERROR;
00795 
00796     nn += 2;
00797     *data = (char*)malloc((size_t)(mm+1));
00798     if (*data==NULL) return JBXL_MALLOC_ERROR;
00799     memcpy(*data, pp, mm);
00800     (*data)[mm] = '\0';
00801     //PRINT_MESG("DATA ---> %s  %d\n", *data, (int)strlen(*data));
00802 
00803     return nn + 1;
00804 }

Here is the call graph for this function:

Here is the caller graph for this function:

int xml_parse_end_node ( char *  pp,
char **  node_name 
)

int xml_parse_end_node(char* pp, char** node_name)

XMLの終了ノードを処理する．処理できるノードの型は </node_name>

Parameters:
pp ノードへのポインタ．'<' を指すポインタ．
[out] *node_name ノードの名前を格納するポインタ．要 free
Return values:
1以上 ノード全体の長さ．0 が返ることは無い．
JBXL_XML_PARSE_ERROR パースエラー
JBXL_MALLOC_ERROR メモリエラー

Definition at line 473 of file txml.c.

References JBXL_MALLOC_ERROR, JBXL_XML_PARSE_ERROR, pack_head_tail_char(), and skip_chars().

Referenced by xml_main_parse().

00474 {
00475     int   nn, mm;
00476     char* pt;
00477     char* work;
00478 
00479     if (pp==NULL) return JBXL_XML_PARSE_ERROR;
00480     *node_name = NULL;
00481 
00482     if (strncmp(pp ,"</", 2)) return JBXL_XML_PARSE_ERROR;
00483 
00484     pt = pp = pp + 2;
00485     pt = skip_chars(pt, ">");
00486     if (pt==NULL) return JBXL_XML_PARSE_ERROR;
00487 
00488     nn = mm = (int)(pt - pp);
00489     if (mm==0) return JBXL_XML_PARSE_ERROR;
00490 
00491     nn += 2;
00492     work = (char*)malloc((size_t)(mm+1));
00493     if (work==NULL) return JBXL_MALLOC_ERROR;
00494     memcpy(work, pp, mm);
00495     work[mm] = '\0';
00496     *node_name = pack_head_tail_char(work, ' ');
00497     free(work);
00498     //PRINT_MESG("END   --> %s  %d\n", *node_name, (int)strlen(*node_name));
00499 
00500     return nn + 1;
00501 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* xml_parse_file ( const char *  fn  ) 

tXML* xml_parse_file(const char* fn)

ファイルから読み込んでパースする．

Parameters:
fn 読み込むファイル名
Returns:
XMLデータを格納した tXMLのアンカーへのポインタ

Definition at line 96 of file txml.c.

References Buffer::buf, free_Buffer(), read_Buffer_file(), and xml_parse().

Referenced by save_http_xml(), and save_https_xml().

00097 {
00098     tXML*  xml = NULL;
00099     Buffer buf;
00100 
00101     buf = read_Buffer_file(fn);
00102     if (buf.buf!=NULL) {
00103         xml = xml_parse((char*)(buf.buf));
00104         free_Buffer(&buf);
00105     }
00106 
00107     return xml;
00108 }

Here is the call graph for this function:

Here is the caller graph for this function:

int xml_parse_processing_node ( char *  pp,
char **  node_name,
char **  node_attr 
)

int xml_parse_processing_node(char* pp, char** node_name, char** node_attr)

XMLのプロセッシングノードを処理する．処理できるノードの型は <?processing?>
プロセッシング部分は解釈せずに，そのまま node_name, node_attrに格納される．

Parameters:
pp ノードへのポインタ．'<' を指すポインタ．
[out] *node_name プロセッシングの名前部分が格納される．要free
[out] *node_attr プロセッシングの属性部分が格納される．要free
Return values:
1以上 ノード全体の長さ．0 が返ることは無い．
JBXL_XML_PARSE_ERROR パースエラー
JBXL_MALLOC_ERROR メモリエラー

Definition at line 659 of file txml.c.

References CHAR_CR, CHAR_LF, CHAR_TAB, freeNull, isnot_xml_name(), JBXL_MALLOC_ERROR, JBXL_XML_PARSE_ERROR, and skip_chars().

Referenced by xml_main_parse().

00660 {
00661     int   nn, mm;
00662     char* pt;
00663 
00664     *node_name = NULL;
00665     *node_attr = NULL;
00666 
00667     if (pp==NULL) return JBXL_XML_PARSE_ERROR;
00668     if (strncmp(pp, "<?", 2)) return JBXL_XML_PARSE_ERROR;
00669 
00670     pt = pp = pp + 2;
00671     pt = skip_chars(pt, " ?");
00672     if (pt==NULL) return JBXL_XML_PARSE_ERROR;
00673 
00674     nn = mm = (int)(pt - pp);
00675     if (mm==0) return JBXL_XML_PARSE_ERROR;
00676 
00677     nn += 2;
00678     *node_name = (char*)malloc((size_t)(mm + 1));
00679     if (*node_name==NULL) return JBXL_MALLOC_ERROR;
00680     memcpy(*node_name, pp, mm);
00681     (*node_name)[mm] = '\0';
00682 
00683     if (isnot_xml_name((unsigned char*)*node_name)) return JBXL_XML_PARSE_ERROR;
00684 
00685     // for attribute
00686     if (*pt==' ') {
00687         pp = pt = pt + 1;
00688         while (*pt==' ' || *pt==CHAR_TAB || *pt==CHAR_LF || *pt==CHAR_CR) pt++;
00689         nn += (int)(pt - pp) + 1;
00690 
00691         pp = pt;
00692         pt = skip_chars(pt, "?");
00693         if (pt==NULL) {
00694             freeNull(*node_name);
00695             return JBXL_XML_PARSE_ERROR;
00696         }
00697 
00698         mm = (int)(pt - pp);
00699         if (mm>0) {
00700             *node_attr = (char*)malloc((size_t)(mm + 1));
00701             if (*node_attr==NULL) {
00702                 freeNull(*node_name);
00703                 return JBXL_MALLOC_ERROR;
00704             }
00705             memcpy(*node_attr, pp, mm);
00706             (*node_attr)[mm] = '\0';
00707             nn += mm;
00708             //PRINT_MESG("ATTR  --> %s  %d\n", *node_attr, (int)strlen(*node_attr));
00709         }
00710     }
00711     
00712     if (strncmp(pt, "?>", 2)) {
00713         freeNull(*node_name);
00714         freeNull(*node_attr);
00715         return JBXL_XML_PARSE_ERROR;
00716     }
00717 
00718     return nn + 2;
00719 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* xml_parse_seq ( tXML *  xml,
char *  pp 
)

tXML* xml_parse_seq(tXML* xml, char* pp)

部分的な XMLデータを解釈して，tXMLのツリー構造に格納する．
完全な XMLデータでなくても解釈できるところまでは解釈する．
xmlが NULLの場合は自動的にツリーを作る．
断片的に XMLデータを入力する場合に使用する．

Parameters:
xml XMLデータを格納するツリー構造体の先頭へのポインタ．ツリーの途中のノードでも可
pp XMLデータへのポインタ．
Returns:
XMLツリーデータのアンカーへのポインタ
altp に最後に処理したノードへのポインタが格納される．
解釈が不完全の場合は state に状態の値が入る．
    tXML* xml;
    xml = xml_parse_seq(NULL, "<A aaa=\"YYY\"><B>");
    xml = xml_parse_seq(xml->altp, "<Z zzz=\"99 9\"/><M>MM</M></B><C><M><X>XX</X><YY yyy=\"888\">XX");
    xml = xml_parse_seq(xml->altp, "YY</YY>MM</M><C bbb=\"777\" xxx=\"000i\" xxxx=\"000\" >");
    xml = xml_parse_seq(xml->altp, "<X></X><M><X></X>YY<Y>oooo");
    xml = xml_parse_seq(xml->altp, "</Y></M></C></C></A>");
    xml = xml_parse_seq(xml->altp, "<M>");
    close_xml(xml);

Definition at line 138 of file txml.c.

References FALSE, find_xml_top, JBXL_NORMAL, JBXL_XML_DEFAULT_STATE, JBXL_XML_MULTI_ROOT, JBXL_XML_PARSED, new_tTree_anchor_node(), TRUE, xml_main_parse(), and XML_NAME_NODE.

00139 {
00140     int   skip = FALSE;
00141     tXML* node;
00142 
00143     if (xml==NULL) {
00144         xml = new_tTree_anchor_node();
00145         //xml->ldat.id = XML_ANCHOR_NODE;
00146         //xml->depth = -1;
00147         skip = TRUE;
00148     }
00149     else {
00150         tXML* top = find_xml_top(xml);
00151         if (top==xml) top->state = JBXL_XML_DEFAULT_STATE;
00152     }
00153 
00154     node = xml_main_parse(xml, pp, skip);
00155     xml = find_xml_top(xml);
00156     xml->altp = node;
00157 
00158     if (xml!=node) return xml;
00159 
00160     if (node->state==JBXL_NORMAL) xml->state = JBXL_XML_PARSED;
00161     else                          xml->state = node->state;
00162 
00163     if (xml->next!=NULL) {
00164         int n = 0;
00165         node = xml->next;
00166         while(node!=NULL) {
00167             if (node->ldat.id==XML_NAME_NODE) n++;
00168             node = node->ysis;
00169         }
00170         if (n!=1) xml->state = JBXL_XML_MULTI_ROOT;
00171     }
00172     else xml->state = JBXL_XML_DEFAULT_STATE;
00173 
00174     return xml;
00175 }

Here is the call graph for this function:

int xml_parse_start_node ( char *  pp,
char **  node_name,
char **  node_attr,
int *  node_end 
)

int xml_parse_start_node(char* pp, char** node_name, char** node_attr, int* node_end)

XMLの開始ノードを処理する．処理できるノードの型は 

<node_name attr1="value1" attr2="value2">
<node_name attr1="value1" attr2="value2" />
Attention:
注）この関数では，属性部分(*node_attr)の解釈は行われないので，それは xml_parse_attr() で行う必要がある．
Parameters:
pp ノードへのポインタ．'<' を指すポインタ．
[out] *node_name ノードの名前を格納するポインタ．要 free
[out] *node_attr ノードの属性部分を格納するポインタ．処理（解釈）は行われない．要 free
[out] *node_end ノードが単独で閉じている場合(Empty Tag)は TRUE, そうでない場合は FALSEが格納される．要 free
Return values:
1以上 ノード全体の長さ．0 が返ることは無い．
JBXL_XML_PARSE_ERROR パースエラー
JBXL_MALLOC_ERROR メモリエラー
JBXL_ARGS_ERROR 引数エラー

Definition at line 375 of file txml.c.

References CHAR_CR, CHAR_LF, CHAR_TAB, FALSE, freeNull, isnot_xml_name(), JBXL_ARGS_ERROR, JBXL_MALLOC_ERROR, JBXL_XML_PARSE_ERROR, skip_chars(), and TRUE.

Referenced by xml_main_parse().

00376 {
00377     int   nn, mm;
00378     char* pt;
00379 
00380     if (node_name==NULL || node_attr==NULL || node_end==NULL) return JBXL_ARGS_ERROR;
00381     *node_end  = FALSE;
00382     *node_name = NULL;
00383     *node_attr = NULL;
00384 
00385     if (*pp!='<') return JBXL_XML_PARSE_ERROR;
00386     pt = pp = pp + 1;
00387     pt = skip_chars(pt, " />");
00388     if (pt==NULL) return JBXL_XML_PARSE_ERROR;
00389 
00390     nn = mm = (int)(pt - pp);
00391     if (mm==0) return JBXL_XML_PARSE_ERROR;
00392 
00393     nn = nn + 1;
00394     *node_name = (char*)malloc((size_t)(mm + 1));
00395     if (*node_name==NULL) return JBXL_MALLOC_ERROR;
00396     memcpy(*node_name, pp, mm);
00397     (*node_name)[mm] = '\0';
00398     //PRINT_MESG("START --> %s  %d\n", *node_name, (int)strlen(*node_name));
00399 
00400     if (isnot_xml_name((unsigned char*)*node_name)) {
00401         freeNull(*node_name);
00402         return JBXL_XML_PARSE_ERROR;
00403     }
00404 
00405     // Empty TAG
00406     if (*pt=='/') {
00407         if (*(pt+1)!='>') {
00408             freeNull(*node_name);
00409             return JBXL_XML_PARSE_ERROR;
00410         }
00411         nn += 1;
00412         *node_end = TRUE;
00413         //PRINT_MESG("END   --> %s  %d\n", *node_name, (int)strlen(*node_name));
00414     }
00415 
00416     // Attribute
00417     else if (*pt==' ') {
00418         pp = pt = pt + 1;
00419         while (*pt==' ' || *pt==CHAR_TAB || *pt==CHAR_LF || *pt==CHAR_CR) pt++;
00420         nn += (int)(pt - pp) + 1;
00421 
00422         pp = pt;
00423         pt = skip_chars(pt, "/>");
00424         if (pt==NULL) {
00425             freeNull(*node_name);
00426             return JBXL_XML_PARSE_ERROR;
00427         }
00428 
00429         mm = (int)(pt - pp);
00430         if (mm>0) {
00431             *node_attr = (char*)malloc((size_t)(mm + 1));
00432             if (*node_attr==NULL) {
00433                 freeNull(*node_name);
00434                 return JBXL_MALLOC_ERROR;
00435             }
00436             memcpy(*node_attr, pp, mm);
00437             (*node_attr)[mm] = '\0';
00438             nn += mm;
00439             //PRINT_MESG("ATTR  --> %s  %d\n", *node_attr, (int)strlen(*node_attr));
00440         }
00441 
00442         if (*pt=='/') {
00443             if (*(pt+1)!='>') {
00444                 freeNull(*node_name);
00445                 freeNull(*node_attr);
00446                 return JBXL_XML_PARSE_ERROR;
00447             }
00448             nn += 1;
00449             *node_end = TRUE;
00450             //PRINT_MESG("END   --> %s  %d\n", *node_name, (int)strlen(*node_name));
00451         }
00452     }
00453     
00454     //else {}   *pt=='>'
00455 
00456     return nn + 1;
00457 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML* xml_rpc_add_array ( tXML *  xml,
tXML *  array 
)

tXML* xml_rpc_add_array(tXML* xml, tXML* array)

Parameters:
xml データを繋げるためのポインタ．
array <value> データ
Returns:
<data> データ

<value><struct> データから 配列データ <data>...</data> を作って繋げていく．

Definition at line 3429 of file txml.c.

References add_xml_node(), and join_xml.

03430 {
03431     if (xml==NULL) xml = add_xml_node(NULL, "data");
03432     join_xml(xml, array);
03433     
03434     return xml;
03435 }

Here is the call graph for this function:

tXML* xml_rpc_add_member ( tXML *  xml,
char *  name,
char *  value,
char *  kind 
)

tXML* xml_rpc_add_member(tXML* xml, char* name, char* value, char* kind)

XML-RPC の <member> データを作って，繋げていく．先頭には <struct> ノードが付く．

Parameters:
xml データを繋げるためのポインタ．
name <name> ノードの値
value <value><...> ノードの値
kind value のデータの種類．NULL または "" の場合は "string" になる．
Returns:
<member> データ
<struct><member><name>name</name><value><kind>value</kind></value></member><member>....</member>

Definition at line 3368 of file txml.c.

References add_xml_content(), and add_xml_node().

03369 {
03370     if (name==NULL) return xml;
03371   
03372     if (xml==NULL) xml = add_xml_node(NULL, "struct");
03373     
03374     tXML* mem = add_xml_node(xml, "member");
03375     tXML* mnm = add_xml_node(mem, "name");
03376     tXML* val = add_xml_node(mem, "value");
03377     tXML* knd;
03378     if (kind==NULL)         knd = add_xml_node(val, "string");
03379     else if (kind[0]=='\0') knd = add_xml_node(val, "string");
03380     else                    knd = add_xml_node(val, kind);
03381 
03382     add_xml_content(mnm, name);
03383     add_xml_content(knd, value);
03384 
03385     return xml;
03386 }

Here is the call graph for this function:

tXML* xml_rpc_end_array ( tXML *  xml  ) 

tXML* xml_rpc_end_array(tXML* xml)

配列データを閉じて，送信用データを生成する．

Parameters:
xml <data> ノードのポンタ
Returns:
<value><arrau> データ
<value><array><data>...</data><data>...</data>....</array></value>

Definition at line 3451 of file txml.c.

References add_xml_node(), and join_xml.

03452 {
03453     tXML* ptr = add_xml_node(NULL, "value");
03454     tXML* val = add_xml_node(ptr,  "array");
03455     join_xml(val, xml);
03456 
03457     return ptr;
03458 }

Here is the call graph for this function:

tXML* xml_rpc_end_member ( tXML *  xml  ) 

tXML* xml_rpc_end_member(tXML* xml)

<struct><member> データを閉じて，<value> データを作り出す．
配列データにしない場合は，このデータを xml_rpc_request_pack() に渡して，送信用データを生成することも可能．

Parameters:
xml <struct> データ
Returns:
<vlue> データ
<value><strcut><member>...</member><member>...</member>...</struct></value>  

    tXML* xml = NULL;
    xml = xml_rpc_add_member(xml, "session",  info->session, "");
    xml = xml_rpc_add_member(xml, "message",  info->message, "");
    ......
    xml = xml_rpc_end_member(xml);
    Buffer buf = xml_rpc_request_pack(Moodle_Service, xml);

Definition at line 3411 of file txml.c.

References add_xml_node(), and join_xml.

03412 {
03413     tXML* ptr = add_xml_node(NULL, "value");
03414     join_xml(ptr, xml);
03415 
03416     return ptr;
03417 }

Here is the call graph for this function:

Buffer xml_rpc_request_pack ( const char *  name,
tXML *  xml 
)

XML-RPC用のデータを生成する．

Parameters:
name XML-RPC のメソッド名
xml 送信用データが格納された XMLデータ．
Returns:
XML-RPC の送信用データ．
    tXML* xml   = NULL;
    tXML* array = NULL;

    xml = xml_rpc_add_member(NULL, "host", "server",      "string");
    xml = xml_rpc_add_member(xml,  "id",   "xyb12265092", "string");
    xml = xml_rpc_end_member(xml);
    array = xml_rpc_add_array(NULL, xml);

    xml = xml_rpc_add_member(NULL, "host", "client",      "string");
    xml = xml_rpc_add_member(xml,  "id",   "abc162aa890", "string");
    xml = xml_rpc_end_member(xml);
    array = xml_rpc_add_array(array, xml);

    xml = xml_rpc_add_member(NULL, "host", "localhost",   "string");
    xml = xml_rpc_add_member(xml,  "id",   "shbR1222201", "string");
    xml = xml_rpc_end_member(xml);
    array = xml_rpc_add_array(array, xml);

    array = xml_rpc_end_array(array);

    Buffer buf = xml_rpc_request_pack("mod_mdlds_write_nbdata", array);

Definition at line 3336 of file txml.c.

References add_xml_content(), add_xml_node(), init_xml_doc(), join_xml, xml_inverse_parse(), and XML_ONELINE_FORMAT.

03337 {
03338     tXML* ptr = init_xml_doc();
03339     tXML* top = add_xml_node(ptr, "methodCall");
03340     tXML* mnm = add_xml_node(top, "methodName");
03341     tXML* prs = add_xml_node(top, "params");
03342     tXML* prm = add_xml_node(prs, "param");
03343     add_xml_content(mnm, name);
03344 
03345     join_xml(prm, xml);
03346     Buffer buf = xml_inverse_parse(ptr, XML_ONELINE_FORMAT);
03347 
03348     return buf;
03349 }

Here is the call graph for this function:

void xml_to_Buffer ( tXML *  pp,
Buffer *  buf,
int  mode,
int  indent 
)

void xml_to_Buffer(tXML* pp, Buffer* buf, int mode, int indent)

xml_inverse_parse()用の補助関数． ppに格納された XMLデータを元の書式に戻して Bufferに格納する．

Parameters:
pp XMLデータの格納されたツリーへのポインタ
buf 変換したXMLデータを格納する Buffer変数．データ格納領域は予め確保しておく.
mode 元のXMLへ戻す時の書式
mode XML_ONELINE_FORMAT 改行なしの一行にする．
mode XML_CRLF_FORMAT ノードの終わりを CR(0x0d), LF(0x0a)で改行する．
mode XML_INDENT_FORMAT 先頭にインデント(TAB)をつけ，ノードごとに改行する．
indent インデントを付け始める深さ．modeが XML_INDENT_MODE のときのみ有効．

Definition at line 936 of file txml.c.

References xml_close_node_Buffer(), xml_open_node_Buffer(), and xml_to_Buffer().

Referenced by xml_inverse_parse(), and xml_to_Buffer().

00937 {
00938     do {
00939         xml_open_node_Buffer(pp, buf, mode, indent);
00940         if (pp->next!=NULL) {
00941             xml_to_Buffer(pp->next, buf, mode, indent);
00942             xml_close_node_Buffer(pp, buf, mode, indent);
00943         }
00944         
00945         pp = pp->ysis;
00946     } while(pp!=NULL);
00947 
00948     return;
00949 }

Here is the call graph for this function:

Here is the caller graph for this function:

Generated on 15 Nov 2023 for JunkBox_Lib by  doxygen 1.6.1