1
0

shell_tinyxml_read.cpp 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658
  1. ////////////////////////////////////////
  2. // shell_tinyxml_read.cpp
  3. //
  4. // This file implements the means to read an XML encoded file and populate the
  5. // CLI tree based on the contents.
  6. ////////////////////////////////////////
  7. extern "C" {
  8. #include "private.h"
  9. #include "lub/string.h"
  10. #include "lub/ctype.h"
  11. }
  12. /*lint +libh(tinyxml/tinyxml.h) Add this to the library file list */
  13. #include "tinyxml/tinyxml.h"
  14. #include <string.h>
  15. #include <assert.h>
  16. typedef void (PROCESS_FN) (clish_shell_t * instance,
  17. TiXmlElement * element, void *parent);
  18. // Define a control block for handling the decode of an XML file
  19. typedef struct clish_xml_cb_s clish_xml_cb_t;
  20. struct clish_xml_cb_s {
  21. const char *element;
  22. PROCESS_FN *handler;
  23. };
  24. // forward declare the handler functions
  25. static PROCESS_FN
  26. process_clish_module,
  27. process_startup,
  28. process_view,
  29. process_command,
  30. process_param,
  31. process_action,
  32. process_ptype,
  33. process_overview, process_detail, process_namespace, process_config;
  34. static clish_xml_cb_t xml_elements[] = {
  35. {"CLISH_MODULE", process_clish_module},
  36. {"STARTUP", process_startup},
  37. {"VIEW", process_view},
  38. {"COMMAND", process_command},
  39. {"PARAM", process_param},
  40. {"ACTION", process_action},
  41. {"PTYPE", process_ptype},
  42. {"OVERVIEW", process_overview},
  43. {"DETAIL", process_detail},
  44. {"NAMESPACE", process_namespace},
  45. {"CONFIG", process_config},
  46. {NULL, NULL}
  47. };
  48. ///////////////////////////////////////
  49. // This function reads an element from the XML stream and processes it.
  50. ///////////////////////////////////////
  51. static void process_node(clish_shell_t * shell, TiXmlNode * node, void *parent)
  52. {
  53. switch (node->Type()) {
  54. case TiXmlNode::DOCUMENT:
  55. break;
  56. case TiXmlNode::ELEMENT:
  57. clish_xml_cb_t * cb;
  58. for (cb = &xml_elements[0]; cb->element; cb++) {
  59. if (0 == strcmp(node->Value(), cb->element)) {
  60. TiXmlElement *element = (TiXmlElement *) node;
  61. #ifdef DEBUG
  62. fprintf(stderr, "NODE:");
  63. element->Print(stderr, 0);
  64. fprintf(stderr, "\n***\n");
  65. #endif
  66. // process the elements at this level
  67. cb->handler(shell, element, parent);
  68. break;
  69. }
  70. }
  71. break;
  72. case TiXmlNode::COMMENT:
  73. case TiXmlNode::TEXT:
  74. case TiXmlNode::DECLARATION:
  75. case TiXmlNode::TYPECOUNT:
  76. case TiXmlNode::UNKNOWN:
  77. default:
  78. break;
  79. }
  80. }
  81. ///////////////////////////////////////
  82. static void
  83. process_children(clish_shell_t * shell,
  84. TiXmlElement * element, void *parent = NULL)
  85. {
  86. for (TiXmlNode * node = element->FirstChild();
  87. node; node = element->IterateChildren(node)) {
  88. // Now deal with all the contained elements
  89. process_node(shell, node, parent);
  90. }
  91. }
  92. ///////////////////////////////////////
  93. static void
  94. process_clish_module(clish_shell_t * shell, TiXmlElement * element, void *)
  95. {
  96. // create the global view
  97. if (!shell->global)
  98. shell->global = clish_shell_find_create_view(shell,
  99. "global", "");
  100. process_children(shell, element, shell->global);
  101. }
  102. ///////////////////////////////////////
  103. static void process_view(clish_shell_t * shell, TiXmlElement * element, void *)
  104. {
  105. clish_view_t *view;
  106. const char *name = element->Attribute("name");
  107. const char *prompt = element->Attribute("prompt");
  108. const char *depth = element->Attribute("depth");
  109. const char *restore = element->Attribute("restore");
  110. // re-use a view if it already exists
  111. view = clish_shell_find_create_view(shell, name, prompt);
  112. if (depth && (*depth != '\0') && (lub_ctype_isdigit(*depth))) {
  113. unsigned res = atoi(depth);
  114. clish_view__set_depth(view, res);
  115. }
  116. if (restore) {
  117. if (!lub_string_nocasecmp(restore, "depth"))
  118. clish_view__set_restore(view, CLISH_RESTORE_DEPTH);
  119. else if (!lub_string_nocasecmp(restore, "view"))
  120. clish_view__set_restore(view, CLISH_RESTORE_VIEW);
  121. else
  122. clish_view__set_restore(view, CLISH_RESTORE_NONE);
  123. }
  124. process_children(shell, element, view);
  125. }
  126. ///////////////////////////////////////
  127. static void process_ptype(clish_shell_t * shell, TiXmlElement * element, void *)
  128. {
  129. clish_ptype_method_e method;
  130. clish_ptype_preprocess_e preprocess;
  131. clish_ptype_t *ptype;
  132. const char *name = element->Attribute("name");
  133. const char *help = element->Attribute("help");
  134. const char *pattern = element->Attribute("pattern");
  135. const char *method_name = element->Attribute("method");
  136. const char *preprocess_name = element->Attribute("preprocess");
  137. assert(name);
  138. assert(pattern);
  139. method = clish_ptype_method_resolve(method_name);
  140. preprocess = clish_ptype_preprocess_resolve(preprocess_name);
  141. ptype = clish_shell_find_create_ptype(shell,
  142. name, help, pattern, method, preprocess);
  143. assert(ptype);
  144. }
  145. ///////////////////////////////////////
  146. static void
  147. process_overview(clish_shell_t * shell, TiXmlElement * element, void *)
  148. {
  149. // read the following text element
  150. TiXmlNode *text = element->FirstChild();
  151. if (text) {
  152. assert(TiXmlNode::TEXT == text->Type());
  153. // set the overview text for this view
  154. assert(NULL == shell->overview);
  155. // store the overview
  156. shell->overview = lub_string_dup(text->Value());
  157. }
  158. }
  159. ////////////////////////////////////////
  160. static void
  161. process_command(clish_shell_t * shell, TiXmlElement * element, void *parent)
  162. {
  163. clish_view_t *v = (clish_view_t *) parent;
  164. clish_command_t *cmd = NULL;
  165. bool allowed = true;
  166. clish_command_t *old;
  167. char *alias_name = NULL;
  168. clish_view_t *alias_view = NULL;
  169. const char *access = element->Attribute("access");
  170. const char *name = element->Attribute("name");
  171. const char *help = element->Attribute("help");
  172. const char *view = element->Attribute("view");
  173. const char *viewid = element->Attribute("viewid");
  174. const char *escape_chars = element->Attribute("escape_chars");
  175. const char *args_name = element->Attribute("args");
  176. const char *args_help = element->Attribute("args_help");
  177. const char *lock = element->Attribute("lock");
  178. const char *interrupt = element->Attribute("interrupt");
  179. const char *ref = element->Attribute("ref");
  180. if (access) {
  181. allowed = false; // err on the side of caution
  182. if (shell->client_hooks->access_fn) {
  183. // get the client to authenticate
  184. allowed = shell->client_hooks->access_fn(shell,
  185. access) ? true : false;
  186. }
  187. }
  188. if (!allowed)
  189. return;
  190. old = clish_view_find_command(v, name, BOOL_FALSE);
  191. // check this command doesn't already exist
  192. if (old) {
  193. // flag the duplication then ignore further definition
  194. printf("DUPLICATE COMMAND: %s\n",
  195. clish_command__get_name(old));
  196. return;
  197. }
  198. assert(name);
  199. assert(help);
  200. /* Reference 'ref' field */
  201. if (ref) {
  202. char *saveptr;
  203. const char *delim = "@";
  204. char *view_name = NULL;
  205. char *cmd = NULL;
  206. char *str = lub_string_dup(ref);
  207. cmd = strtok_r(str, delim, &saveptr);
  208. if (!cmd) {
  209. printf("EMPTY REFERENCE COMMAND: %s\n", name);
  210. lub_string_free(str);
  211. return;
  212. }
  213. alias_name = lub_string_dup(cmd);
  214. view_name = strtok_r(NULL, delim, &saveptr);
  215. if (!view_name)
  216. alias_view = v;
  217. else
  218. alias_view = clish_shell_find_create_view(shell,
  219. view_name, NULL);
  220. lub_string_free(str);
  221. }
  222. /* create a command */
  223. cmd = clish_view_new_command(v, name, help);
  224. assert(cmd);
  225. clish_command__set_pview(cmd, v);
  226. /* define some specialist escape characters */
  227. if (escape_chars)
  228. clish_command__set_escape_chars(cmd, escape_chars);
  229. if (args_name) {
  230. /* define a "rest of line" argument */
  231. clish_param_t *param;
  232. clish_ptype_t *tmp = NULL;
  233. assert(args_help);
  234. tmp = clish_shell_find_create_ptype(shell,
  235. "internal_ARGS",
  236. "Arguments", "[^\\]+",
  237. CLISH_PTYPE_REGEXP,
  238. CLISH_PTYPE_NONE);
  239. assert(tmp);
  240. param = clish_param_new(args_name, args_help, tmp);
  241. clish_command__set_args(cmd, param);
  242. }
  243. // define the view which this command changes to
  244. if (view) {
  245. clish_view_t *next = clish_shell_find_create_view(shell, view,
  246. NULL);
  247. // reference the next view
  248. clish_command__set_view(cmd, next);
  249. }
  250. // define the view id which this command changes to
  251. if (viewid)
  252. clish_command__set_viewid(cmd, viewid);
  253. /* lock field */
  254. if (lock && (lub_string_nocasecmp(lock, "false") == 0))
  255. clish_command__set_lock(cmd, BOOL_FALSE);
  256. else
  257. clish_command__set_lock(cmd, BOOL_TRUE);
  258. /* interrupt field */
  259. if (interrupt && (lub_string_nocasecmp(interrupt, "true") == 0))
  260. clish_command__set_interrupt(cmd, BOOL_TRUE);
  261. else
  262. clish_command__set_interrupt(cmd, BOOL_FALSE);
  263. /* Set alias */
  264. if (alias_name) {
  265. clish_command__set_alias(cmd, alias_name);
  266. assert(alias_view);
  267. clish_command__set_alias_view(cmd, alias_view);
  268. lub_string_free(alias_name);
  269. }
  270. process_children(shell, element, cmd);
  271. }
  272. ///////////////////////////////////////
  273. static void
  274. process_startup(clish_shell_t * shell, TiXmlElement * element, void *parent)
  275. {
  276. clish_view_t *v = (clish_view_t *) parent;
  277. clish_command_t *cmd = NULL;
  278. const char *view = element->Attribute("view");
  279. const char *viewid = element->Attribute("viewid");
  280. const char *default_shebang = element->Attribute("default_shebang");
  281. assert(!shell->startup);
  282. assert(view);
  283. /* create a command with NULL help */
  284. cmd = clish_view_new_command(v, "startup", NULL);
  285. clish_command__set_lock(cmd, BOOL_FALSE);
  286. // define the view which this command changes to
  287. clish_view_t *next = clish_shell_find_create_view(shell, view, NULL);
  288. // reference the next view
  289. clish_command__set_view(cmd, next);
  290. // define the view id which this command changes to
  291. if (viewid)
  292. clish_command__set_viewid(cmd, viewid);
  293. if (default_shebang)
  294. clish_shell__set_default_shebang(shell, default_shebang);
  295. // remember this command
  296. shell->startup = cmd;
  297. process_children(shell, element, cmd);
  298. }
  299. ///////////////////////////////////////
  300. static void
  301. process_param(clish_shell_t * shell, TiXmlElement * element, void *parent)
  302. {
  303. clish_command_t *cmd = NULL;
  304. clish_param_t *p_param = NULL;
  305. if (0 == lub_string_nocasecmp(element->Parent()->Value(), "PARAM"))
  306. p_param = (clish_param_t *) parent;
  307. else
  308. cmd = (clish_command_t *) parent;
  309. if (cmd || p_param) {
  310. assert((!cmd) || (cmd != shell->startup));
  311. const char *name = element->Attribute("name");
  312. const char *help = element->Attribute("help");
  313. const char *ptype = element->Attribute("ptype");
  314. const char *prefix = element->Attribute("prefix");
  315. const char *defval = element->Attribute("default");
  316. const char *mode = element->Attribute("mode");
  317. const char *optional = element->Attribute("optional");
  318. const char *value = element->Attribute("value");
  319. const char *hidden = element->Attribute("hidden");
  320. const char *test = element->Attribute("test");
  321. clish_param_t *param;
  322. clish_ptype_t *tmp = NULL;
  323. // create a command
  324. assert(name);
  325. assert(help);
  326. assert(ptype);
  327. if (ptype && *ptype) {
  328. tmp = clish_shell_find_create_ptype(shell, ptype,
  329. NULL, NULL,
  330. CLISH_PTYPE_REGEXP,
  331. CLISH_PTYPE_NONE);
  332. assert(tmp);
  333. }
  334. param = clish_param_new(name, help, tmp);
  335. /* If prefix is set clish will emulate old optional
  336. * command syntax over newer optional command mechanism.
  337. * It will create nested PARAM.
  338. */
  339. if (prefix) {
  340. const char *ptype_name = "__SUBCOMMAND";
  341. clish_param_t *opt_param = NULL;
  342. /* Create a ptype for prefix-named subcommand that
  343. * will contain the nested optional parameter. The
  344. * name of ptype is hardcoded. It's not good but
  345. * it's only the service ptype.
  346. */
  347. tmp = (clish_ptype_t *)lub_bintree_find(
  348. &shell->ptype_tree, ptype_name);
  349. if (!tmp)
  350. tmp = clish_shell_find_create_ptype(shell,
  351. ptype_name, "Option", "[^\\]+",
  352. CLISH_PTYPE_REGEXP, CLISH_PTYPE_NONE);
  353. assert(tmp);
  354. opt_param = clish_param_new(prefix, help, tmp);
  355. clish_param__set_mode(opt_param,
  356. CLISH_PARAM_SUBCOMMAND);
  357. clish_param__set_optional(opt_param, BOOL_TRUE);
  358. if (test)
  359. clish_param__set_test(opt_param, test);
  360. if (cmd)
  361. // add the parameter to the command
  362. clish_command_insert_param(cmd, opt_param);
  363. if (p_param)
  364. // add the parameter to the param
  365. clish_param_insert_param(p_param, opt_param);
  366. /* Unset cmd and set parent param to opt_param */
  367. cmd = NULL;
  368. p_param = opt_param;
  369. }
  370. if (defval)
  371. clish_param__set_default(param, defval);
  372. if (hidden && (lub_string_nocasecmp(hidden, "true") == 0))
  373. clish_param__set_hidden(param, BOOL_TRUE);
  374. else
  375. clish_param__set_hidden(param, BOOL_FALSE);
  376. if (mode) {
  377. if (!lub_string_nocasecmp(mode, "switch")) {
  378. clish_param__set_mode(param,
  379. CLISH_PARAM_SWITCH);
  380. /* Force hidden attribute */
  381. clish_param__set_hidden(param, BOOL_TRUE);
  382. } else if (!lub_string_nocasecmp(mode, "subcommand"))
  383. clish_param__set_mode(param,
  384. CLISH_PARAM_SUBCOMMAND);
  385. else
  386. clish_param__set_mode(param,
  387. CLISH_PARAM_COMMON);
  388. }
  389. if (optional && (lub_string_nocasecmp(optional, "true") == 0))
  390. clish_param__set_optional(param, BOOL_TRUE);
  391. else
  392. clish_param__set_optional(param, BOOL_FALSE);
  393. if (value) {
  394. clish_param__set_value(param, value);
  395. /* Force mode to subcommand */
  396. clish_param__set_mode(param,
  397. CLISH_PARAM_SUBCOMMAND);
  398. }
  399. if (test && !prefix)
  400. clish_param__set_test(param, test);
  401. if (cmd)
  402. // add the parameter to the command
  403. clish_command_insert_param(cmd, param);
  404. if (p_param)
  405. // add the parameter to the param
  406. clish_param_insert_param(p_param, param);
  407. process_children(shell, element, param);
  408. }
  409. }
  410. ////////////////////////////////////////
  411. static void
  412. process_action(clish_shell_t * shell, TiXmlElement * element, void *parent)
  413. {
  414. clish_command_t *cmd = (clish_command_t *) parent;
  415. if (cmd) {
  416. // read the following text element
  417. TiXmlNode *text = element->FirstChild();
  418. const char *builtin = element->Attribute("builtin");
  419. const char *shebang = element->Attribute("shebang");
  420. if (text) {
  421. assert(TiXmlNode::TEXT == text->Type());
  422. // store the action
  423. clish_command__set_action(cmd, text->Value());
  424. }
  425. // store the action
  426. if (builtin)
  427. clish_command__set_builtin(cmd, builtin);
  428. if (shebang)
  429. clish_command__set_shebang(cmd, shebang);
  430. }
  431. }
  432. ////////////////////////////////////////
  433. static void
  434. process_detail(clish_shell_t * shell, TiXmlElement * element, void *parent)
  435. {
  436. clish_command_t *cmd = (clish_command_t *) parent;
  437. // read the following text element
  438. TiXmlNode *text = element->FirstChild();
  439. if (cmd && text) {
  440. assert(TiXmlNode::TEXT == text->Type());
  441. // store the action
  442. clish_command__set_detail(cmd, text->Value());
  443. }
  444. }
  445. ///////////////////////////////////////
  446. static void
  447. process_namespace(clish_shell_t * shell, TiXmlElement * element, void *parent)
  448. {
  449. clish_view_t *v = (clish_view_t *) parent;
  450. clish_nspace_t *nspace = NULL;
  451. const char *view = element->Attribute("ref");
  452. const char *prefix = element->Attribute("prefix");
  453. const char *prefix_help = element->Attribute("prefix_help");
  454. const char *help = element->Attribute("help");
  455. const char *completion = element->Attribute("completion");
  456. const char *context_help = element->Attribute("context_help");
  457. const char *inherit = element->Attribute("inherit");
  458. assert(view);
  459. clish_view_t *ref_view = clish_shell_find_create_view(shell,
  460. view, NULL);
  461. assert(ref_view);
  462. nspace = clish_nspace_new(ref_view);
  463. assert(nspace);
  464. clish_view_insert_nspace(v, nspace);
  465. if (prefix) {
  466. clish_nspace__set_prefix(nspace, prefix);
  467. if (prefix_help)
  468. clish_nspace_create_prefix_cmd(nspace,
  469. "prefix",
  470. prefix_help);
  471. else
  472. clish_nspace_create_prefix_cmd(nspace,
  473. "prefix",
  474. "Prefix for the imported commands.");
  475. }
  476. if (help && (lub_string_nocasecmp(help, "true") == 0))
  477. clish_nspace__set_help(nspace, BOOL_TRUE);
  478. else
  479. clish_nspace__set_help(nspace, BOOL_FALSE);
  480. if (completion && (lub_string_nocasecmp(completion, "false") == 0))
  481. clish_nspace__set_completion(nspace, BOOL_FALSE);
  482. else
  483. clish_nspace__set_completion(nspace, BOOL_TRUE);
  484. if (context_help && (lub_string_nocasecmp(context_help, "true") == 0))
  485. clish_nspace__set_context_help(nspace, BOOL_TRUE);
  486. else
  487. clish_nspace__set_context_help(nspace, BOOL_FALSE);
  488. if (inherit && (lub_string_nocasecmp(inherit, "false") == 0))
  489. clish_nspace__set_inherit(nspace, BOOL_FALSE);
  490. else
  491. clish_nspace__set_inherit(nspace, BOOL_TRUE);
  492. }
  493. ////////////////////////////////////////
  494. static void
  495. process_config(clish_shell_t * shell, TiXmlElement * element, void *parent)
  496. {
  497. clish_command_t *cmd = (clish_command_t *) parent;
  498. if (!cmd)
  499. return;
  500. // read the following text element
  501. const char *operation = element->Attribute("operation");
  502. const char *priority = element->Attribute("priority");
  503. const char *pattern = element->Attribute("pattern");
  504. const char *file = element->Attribute("file");
  505. const char *splitter = element->Attribute("splitter");
  506. const char *seq = element->Attribute("sequence");
  507. const char *unique = element->Attribute("unique");
  508. const char *cfg_depth = element->Attribute("depth");
  509. if (operation && !lub_string_nocasecmp(operation, "unset"))
  510. clish_command__set_cfg_op(cmd, CLISH_CONFIG_UNSET);
  511. else if (operation && !lub_string_nocasecmp(operation, "none"))
  512. clish_command__set_cfg_op(cmd, CLISH_CONFIG_NONE);
  513. else if (operation && !lub_string_nocasecmp(operation, "dump"))
  514. clish_command__set_cfg_op(cmd, CLISH_CONFIG_DUMP);
  515. else {
  516. clish_command__set_cfg_op(cmd, CLISH_CONFIG_SET);
  517. /* The priority if no clearly specified */
  518. clish_command__set_priority(cmd, 0x7f00);
  519. }
  520. if (priority && (*priority != '\0')) {
  521. long val = 0;
  522. char *endptr;
  523. unsigned short pri;
  524. val = strtol(priority, &endptr, 0);
  525. if (endptr == priority)
  526. pri = 0;
  527. else if (val > 0xffff)
  528. pri = 0xffff;
  529. else if (val < 0)
  530. pri = 0;
  531. else
  532. pri = (unsigned short)val;
  533. clish_command__set_priority(cmd, pri);
  534. }
  535. if (pattern)
  536. clish_command__set_pattern(cmd, pattern);
  537. else
  538. clish_command__set_pattern(cmd, "^${__cmd}");
  539. if (file)
  540. clish_command__set_file(cmd, file);
  541. if (splitter && (lub_string_nocasecmp(splitter, "false") == 0))
  542. clish_command__set_splitter(cmd, BOOL_FALSE);
  543. else
  544. clish_command__set_splitter(cmd, BOOL_TRUE);
  545. if (unique && (lub_string_nocasecmp(unique, "false") == 0))
  546. clish_command__set_unique(cmd, BOOL_FALSE);
  547. else
  548. clish_command__set_unique(cmd, BOOL_TRUE);
  549. if (seq)
  550. clish_command__set_seq(cmd, seq);
  551. else
  552. /* The entries without sequence cannot be non-unique */
  553. clish_command__set_unique(cmd, BOOL_TRUE);
  554. if (cfg_depth)
  555. clish_command__set_cfg_depth(cmd, cfg_depth);
  556. }
  557. ///////////////////////////////////////
  558. int clish_shell_xml_read(clish_shell_t * shell, const char *filename)
  559. {
  560. int ret = -1;
  561. TiXmlDocument doc;
  562. // keep the white space
  563. TiXmlBase::SetCondenseWhiteSpace(false);
  564. if (doc.LoadFile(filename)) {
  565. TiXmlNode *child = 0;
  566. while ((child = doc.IterateChildren(child))) {
  567. process_node(shell, child, NULL);
  568. }
  569. ret = 0;
  570. } else {
  571. printf("Unable to open %s\n", filename);
  572. }
  573. return ret;
  574. }
  575. ///////////////////////////////////////