src/src/Guile/Glue/glue_basic.cpp

   1
   2 /******************************************************************************
   3 *
   4 * This file has been generated automatically using build-glue.scm
   5 * from build-glue-basic.scm. Please do not edit its contents.
   6 * Copyright (C) 2000 Joris van der Hoeven
   7 *
   8 * This software falls under the GNU general public license version 3 or later.
   9 * It comes WITHOUT ANY WARRANTY WHATSOEVER. For details, see the file LICENSE
  10 * in the root directory or <http://www.gnu.org/licenses/gpl-3.0.html>.
  11 *
  12 ******************************************************************************/
  13
  14 SCM
  15 tmg_texmacs_version_release (SCM arg1) {
  16   SCM_ASSERT_STRING (arg1, SCM_ARG1, "texmacs-version-release");
  17
  18   string in1= scm_to_string (arg1);
  19
  20   // SCM_DEFER_INTS;
  21   string out= texmacs_version (in1);
  22   // SCM_ALLOW_INTS;
  23
  24   return string_to_scm (out);
  25 }
  26
  27 SCM
  28 tmg_version_beforeP (SCM arg1, SCM arg2) {
  29   SCM_ASSERT_STRING (arg1, SCM_ARG1, "version-before?");
  30   SCM_ASSERT_STRING (arg2, SCM_ARG2, "version-before?");
  31
  32   string in1= scm_to_string (arg1);
  33   string in2= scm_to_string (arg2);
  34
  35   // SCM_DEFER_INTS;
  36   bool out= version_inf (in1, in2);
  37   // SCM_ALLOW_INTS;
  38
  39   return bool_to_scm (out);
  40 }
  41
  42 SCM
  43 tmg_os_win32P () {
  44   // SCM_DEFER_INTS;
  45   bool out= os_win32 ();
  46   // SCM_ALLOW_INTS;
  47
  48   return bool_to_scm (out);
  49 }
  50
  51 SCM
  52 tmg_os_mingwP () {
  53   // SCM_DEFER_INTS;
  54   bool out= os_mingw ();
  55   // SCM_ALLOW_INTS;
  56
  57   return bool_to_scm (out);
  58 }
  59
  60 SCM
  61 tmg_os_macosP () {
  62   // SCM_DEFER_INTS;
  63   bool out= os_macos ();
  64   // SCM_ALLOW_INTS;
  65
  66   return bool_to_scm (out);
  67 }
  68
  69 SCM
  70 tmg_x_guiP () {
  71   // SCM_DEFER_INTS;
  72   bool out= gui_is_x ();
  73   // SCM_ALLOW_INTS;
  74
  75   return bool_to_scm (out);
  76 }
  77
  78 SCM
  79 tmg_qt_guiP () {
  80   // SCM_DEFER_INTS;
  81   bool out= gui_is_qt ();
  82   // SCM_ALLOW_INTS;
  83
  84   return bool_to_scm (out);
  85 }
  86
  87 SCM
  88 tmg_tm_output (SCM arg1) {
  89   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tm-output");
  90
  91   string in1= scm_to_string (arg1);
  92
  93   // SCM_DEFER_INTS;
  94   tm_output (in1);
  95   // SCM_ALLOW_INTS;
  96
  97   return SCM_UNSPECIFIED;
  98 }
  99
 100 SCM
 101 tmg_tm_errput (SCM arg1) {
 102   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tm-errput");
 103
 104   string in1= scm_to_string (arg1);
 105
 106   // SCM_DEFER_INTS;
 107   tm_errput (in1);
 108   // SCM_ALLOW_INTS;
 109
 110   return SCM_UNSPECIFIED;
 111 }
 112
 113 SCM
 114 tmg_win32_display (SCM arg1) {
 115   SCM_ASSERT_STRING (arg1, SCM_ARG1, "win32-display");
 116
 117   string in1= scm_to_string (arg1);
 118
 119   // SCM_DEFER_INTS;
 120   win32_display (in1);
 121   // SCM_ALLOW_INTS;
 122
 123   return SCM_UNSPECIFIED;
 124 }
 125
 126 SCM
 127 tmg_scheme_dialect () {
 128   // SCM_DEFER_INTS;
 129   string out= scheme_dialect ();
 130   // SCM_ALLOW_INTS;
 131
 132   return string_to_scm (out);
 133 }
 134
 135 SCM
 136 tmg_get_texmacs_path () {
 137   // SCM_DEFER_INTS;
 138   string out= get_texmacs_path ();
 139   // SCM_ALLOW_INTS;
 140
 141   return string_to_scm (out);
 142 }
 143
 144 SCM
 145 tmg_plugin_list () {
 146   // SCM_DEFER_INTS;
 147   scheme_tree out= plugin_list ();
 148   // SCM_ALLOW_INTS;
 149
 150   return scheme_tree_to_scm (out);
 151 }
 152
 153 SCM
 154 tmg_get_font_type () {
 155   // SCM_DEFER_INTS;
 156   int out= get_font_type ();
 157   // SCM_ALLOW_INTS;
 158
 159   return int_to_scm (out);
 160 }
 161
 162 SCM
 163 tmg_set_font_type (SCM arg1) {
 164   SCM_ASSERT_INT (arg1, SCM_ARG1, "set-font-type");
 165
 166   int in1= scm_to_int (arg1);
 167
 168   // SCM_DEFER_INTS;
 169   set_font_type (in1);
 170   // SCM_ALLOW_INTS;
 171
 172   return SCM_UNSPECIFIED;
 173 }
 174
 175 SCM
 176 tmg_font_exists_in_ttP (SCM arg1) {
 177   SCM_ASSERT_STRING (arg1, SCM_ARG1, "font-exists-in-tt?");
 178
 179   string in1= scm_to_string (arg1);
 180
 181   // SCM_DEFER_INTS;
 182   bool out= tt_font_exists (in1);
 183   // SCM_ALLOW_INTS;
 184
 185   return bool_to_scm (out);
 186 }
 187
 188 SCM
 189 tmg_eval_system (SCM arg1) {
 190   SCM_ASSERT_STRING (arg1, SCM_ARG1, "eval-system");
 191
 192   string in1= scm_to_string (arg1);
 193
 194   // SCM_DEFER_INTS;
 195   string out= eval_system (in1);
 196   // SCM_ALLOW_INTS;
 197
 198   return string_to_scm (out);
 199 }
 200
 201 SCM
 202 tmg_var_eval_system (SCM arg1) {
 203   SCM_ASSERT_STRING (arg1, SCM_ARG1, "var-eval-system");
 204
 205   string in1= scm_to_string (arg1);
 206
 207   // SCM_DEFER_INTS;
 208   string out= var_eval_system (in1);
 209   // SCM_ALLOW_INTS;
 210
 211   return string_to_scm (out);
 212 }
 213
 214 SCM
 215 tmg_get_locale_language () {
 216   // SCM_DEFER_INTS;
 217   string out= get_locale_language ();
 218   // SCM_ALLOW_INTS;
 219
 220   return string_to_scm (out);
 221 }
 222
 223 SCM
 224 tmg_texmacs_time () {
 225   // SCM_DEFER_INTS;
 226   int out= texmacs_time ();
 227   // SCM_ALLOW_INTS;
 228
 229   return int_to_scm (out);
 230 }
 231
 232 SCM
 233 tmg_texmacs_memory () {
 234   // SCM_DEFER_INTS;
 235   int out= mem_used ();
 236   // SCM_ALLOW_INTS;
 237
 238   return int_to_scm (out);
 239 }
 240
 241 SCM
 242 tmg_bench_print (SCM arg1) {
 243   SCM_ASSERT_STRING (arg1, SCM_ARG1, "bench-print");
 244
 245   string in1= scm_to_string (arg1);
 246
 247   // SCM_DEFER_INTS;
 248   bench_print (in1);
 249   // SCM_ALLOW_INTS;
 250
 251   return SCM_UNSPECIFIED;
 252 }
 253
 254 SCM
 255 tmg_bench_print_all () {
 256   // SCM_DEFER_INTS;
 257   bench_print ();
 258   // SCM_ALLOW_INTS;
 259
 260   return SCM_UNSPECIFIED;
 261 }
 262
 263 SCM
 264 tmg_system_wait (SCM arg1, SCM arg2) {
 265   SCM_ASSERT_STRING (arg1, SCM_ARG1, "system-wait");
 266   SCM_ASSERT_STRING (arg2, SCM_ARG2, "system-wait");
 267
 268   string in1= scm_to_string (arg1);
 269   string in2= scm_to_string (arg2);
 270
 271   // SCM_DEFER_INTS;
 272   system_wait (in1, in2);
 273   // SCM_ALLOW_INTS;
 274
 275   return SCM_UNSPECIFIED;
 276 }
 277
 278 SCM
 279 tmg_set_bibtex_command (SCM arg1) {
 280   SCM_ASSERT_STRING (arg1, SCM_ARG1, "set-bibtex-command");
 281
 282   string in1= scm_to_string (arg1);
 283
 284   // SCM_DEFER_INTS;
 285   set_bibtex_command (in1);
 286   // SCM_ALLOW_INTS;
 287
 288   return SCM_UNSPECIFIED;
 289 }
 290
 291 SCM
 292 tmg_math_symbol_group (SCM arg1) {
 293   SCM_ASSERT_STRING (arg1, SCM_ARG1, "math-symbol-group");
 294
 295   string in1= scm_to_string (arg1);
 296
 297   // SCM_DEFER_INTS;
 298   string out= math_symbol_group (in1);
 299   // SCM_ALLOW_INTS;
 300
 301   return string_to_scm (out);
 302 }
 303
 304 SCM
 305 tmg_math_group_members (SCM arg1) {
 306   SCM_ASSERT_STRING (arg1, SCM_ARG1, "math-group-members");
 307
 308   string in1= scm_to_string (arg1);
 309
 310   // SCM_DEFER_INTS;
 311   array_string out= math_group_members (in1);
 312   // SCM_ALLOW_INTS;
 313
 314   return array_string_to_scm (out);
 315 }
 316
 317 SCM
 318 tmg_math_symbol_type (SCM arg1) {
 319   SCM_ASSERT_STRING (arg1, SCM_ARG1, "math-symbol-type");
 320
 321   string in1= scm_to_string (arg1);
 322
 323   // SCM_DEFER_INTS;
 324   string out= math_symbol_type (in1);
 325   // SCM_ALLOW_INTS;
 326
 327   return string_to_scm (out);
 328 }
 329
 330 SCM
 331 tmg_object_2command (SCM arg1) {
 332   SCM_ASSERT_OBJECT (arg1, SCM_ARG1, "object->command");
 333
 334   object in1= scm_to_object (arg1);
 335
 336   // SCM_DEFER_INTS;
 337   command out= as_command (in1);
 338   // SCM_ALLOW_INTS;
 339
 340   return command_to_scm (out);
 341 }
 342
 343 SCM
 344 tmg_exec_delayed (SCM arg1) {
 345   SCM_ASSERT_OBJECT (arg1, SCM_ARG1, "exec-delayed");
 346
 347   object in1= scm_to_object (arg1);
 348
 349   // SCM_DEFER_INTS;
 350   exec_delayed (in1);
 351   // SCM_ALLOW_INTS;
 352
 353   return SCM_UNSPECIFIED;
 354 }
 355
 356 SCM
 357 tmg_exec_delayed_pause (SCM arg1) {
 358   SCM_ASSERT_OBJECT (arg1, SCM_ARG1, "exec-delayed-pause");
 359
 360   object in1= scm_to_object (arg1);
 361
 362   // SCM_DEFER_INTS;
 363   exec_delayed_pause (in1);
 364   // SCM_ALLOW_INTS;
 365
 366   return SCM_UNSPECIFIED;
 367 }
 368
 369 SCM
 370 tmg_set_input_language (SCM arg1) {
 371   SCM_ASSERT_STRING (arg1, SCM_ARG1, "set-input-language");
 372
 373   string in1= scm_to_string (arg1);
 374
 375   // SCM_DEFER_INTS;
 376   set_input_language (in1);
 377   // SCM_ALLOW_INTS;
 378
 379   return SCM_UNSPECIFIED;
 380 }
 381
 382 SCM
 383 tmg_get_input_language () {
 384   // SCM_DEFER_INTS;
 385   string out= get_input_language ();
 386   // SCM_ALLOW_INTS;
 387
 388   return string_to_scm (out);
 389 }
 390
 391 SCM
 392 tmg_set_output_language (SCM arg1) {
 393   SCM_ASSERT_STRING (arg1, SCM_ARG1, "set-output-language");
 394
 395   string in1= scm_to_string (arg1);
 396
 397   // SCM_DEFER_INTS;
 398   gui_set_output_language (in1);
 399   // SCM_ALLOW_INTS;
 400
 401   return SCM_UNSPECIFIED;
 402 }
 403
 404 SCM
 405 tmg_get_output_language () {
 406   // SCM_DEFER_INTS;
 407   string out= get_output_language ();
 408   // SCM_ALLOW_INTS;
 409
 410   return string_to_scm (out);
 411 }
 412
 413 SCM
 414 tmg_translate (SCM arg1, SCM arg2, SCM arg3) {
 415   SCM_ASSERT_STRING (arg1, SCM_ARG1, "translate");
 416   SCM_ASSERT_STRING (arg2, SCM_ARG2, "translate");
 417   SCM_ASSERT_STRING (arg3, SCM_ARG3, "translate");
 418
 419   string in1= scm_to_string (arg1);
 420   string in2= scm_to_string (arg2);
 421   string in3= scm_to_string (arg3);
 422
 423   // SCM_DEFER_INTS;
 424   string out= translate (in1, in2, in3);
 425   // SCM_ALLOW_INTS;
 426
 427   return string_to_scm (out);
 428 }
 429
 430 SCM
 431 tmg_color (SCM arg1) {
 432   SCM_ASSERT_STRING (arg1, SCM_ARG1, "color");
 433
 434   string in1= scm_to_string (arg1);
 435
 436   // SCM_DEFER_INTS;
 437   int out= named_color (in1);
 438   // SCM_ALLOW_INTS;
 439
 440   return int_to_scm (out);
 441 }
 442
 443 SCM
 444 tmg_new_author () {
 445   // SCM_DEFER_INTS;
 446   double out= new_author ();
 447   // SCM_ALLOW_INTS;
 448
 449   return double_to_scm (out);
 450 }
 451
 452 SCM
 453 tmg_set_author (SCM arg1) {
 454   SCM_ASSERT_DOUBLE (arg1, SCM_ARG1, "set-author");
 455
 456   double in1= scm_to_double (arg1);
 457
 458   // SCM_DEFER_INTS;
 459   set_author (in1);
 460   // SCM_ALLOW_INTS;
 461
 462   return SCM_UNSPECIFIED;
 463 }
 464
 465 SCM
 466 tmg_get_author () {
 467   // SCM_DEFER_INTS;
 468   double out= get_author ();
 469   // SCM_ALLOW_INTS;
 470
 471   return double_to_scm (out);
 472 }
 473
 474 SCM
 475 tmg_debug_set (SCM arg1, SCM arg2) {
 476   SCM_ASSERT_STRING (arg1, SCM_ARG1, "debug-set");
 477   SCM_ASSERT_BOOL (arg2, SCM_ARG2, "debug-set");
 478
 479   string in1= scm_to_string (arg1);
 480   bool in2= scm_to_bool (arg2);
 481
 482   // SCM_DEFER_INTS;
 483   debug_set (in1, in2);
 484   // SCM_ALLOW_INTS;
 485
 486   return SCM_UNSPECIFIED;
 487 }
 488
 489 SCM
 490 tmg_debug_get (SCM arg1) {
 491   SCM_ASSERT_STRING (arg1, SCM_ARG1, "debug-get");
 492
 493   string in1= scm_to_string (arg1);
 494
 495   // SCM_DEFER_INTS;
 496   bool out= debug_get (in1);
 497   // SCM_ALLOW_INTS;
 498
 499   return bool_to_scm (out);
 500 }
 501
 502 SCM
 503 tmg_cout_buffer () {
 504   // SCM_DEFER_INTS;
 505   cout_buffer ();
 506   // SCM_ALLOW_INTS;
 507
 508   return SCM_UNSPECIFIED;
 509 }
 510
 511 SCM
 512 tmg_cout_unbuffer () {
 513   // SCM_DEFER_INTS;
 514   string out= cout_unbuffer ();
 515   // SCM_ALLOW_INTS;
 516
 517   return string_to_scm (out);
 518 }
 519
 520 SCM
 521 tmg_image_2psdoc (SCM arg1) {
 522   SCM_ASSERT_URL (arg1, SCM_ARG1, "image->psdoc");
 523
 524   url in1= scm_to_url (arg1);
 525
 526   // SCM_DEFER_INTS;
 527   string out= image_to_psdoc (in1);
 528   // SCM_ALLOW_INTS;
 529
 530   return string_to_scm (out);
 531 }
 532
 533 SCM
 534 tmg_tree_2stree (SCM arg1) {
 535   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree->stree");
 536
 537   tree in1= scm_to_tree (arg1);
 538
 539   // SCM_DEFER_INTS;
 540   scheme_tree out= tree_to_scheme_tree (in1);
 541   // SCM_ALLOW_INTS;
 542
 543   return scheme_tree_to_scm (out);
 544 }
 545
 546 SCM
 547 tmg_stree_2tree (SCM arg1) {
 548   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "stree->tree");
 549
 550   scheme_tree in1= scm_to_scheme_tree (arg1);
 551
 552   // SCM_DEFER_INTS;
 553   tree out= scheme_tree_to_tree (in1);
 554   // SCM_ALLOW_INTS;
 555
 556   return tree_to_scm (out);
 557 }
 558
 559 SCM
 560 tmg_tree_2string (SCM arg1) {
 561   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree->string");
 562
 563   tree in1= scm_to_tree (arg1);
 564
 565   // SCM_DEFER_INTS;
 566   string out= coerce_tree_string (in1);
 567   // SCM_ALLOW_INTS;
 568
 569   return string_to_scm (out);
 570 }
 571
 572 SCM
 573 tmg_string_2tree (SCM arg1) {
 574   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string->tree");
 575
 576   string in1= scm_to_string (arg1);
 577
 578   // SCM_DEFER_INTS;
 579   tree out= coerce_string_tree (in1);
 580   // SCM_ALLOW_INTS;
 581
 582   return tree_to_scm (out);
 583 }
 584
 585 SCM
 586 tmg_tm_2tree (SCM arg1) {
 587   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "tm->tree");
 588
 589   content in1= scm_to_content (arg1);
 590
 591   // SCM_DEFER_INTS;
 592   tree out= tree (in1);
 593   // SCM_ALLOW_INTS;
 594
 595   return tree_to_scm (out);
 596 }
 597
 598 SCM
 599 tmg_tree_atomicP (SCM arg1) {
 600   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-atomic?");
 601
 602   tree in1= scm_to_tree (arg1);
 603
 604   // SCM_DEFER_INTS;
 605   bool out= is_atomic (in1);
 606   // SCM_ALLOW_INTS;
 607
 608   return bool_to_scm (out);
 609 }
 610
 611 SCM
 612 tmg_tree_compoundP (SCM arg1) {
 613   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-compound?");
 614
 615   tree in1= scm_to_tree (arg1);
 616
 617   // SCM_DEFER_INTS;
 618   bool out= is_compound (in1);
 619   // SCM_ALLOW_INTS;
 620
 621   return bool_to_scm (out);
 622 }
 623
 624 SCM
 625 tmg_tree_label (SCM arg1) {
 626   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-label");
 627
 628   tree in1= scm_to_tree (arg1);
 629
 630   // SCM_DEFER_INTS;
 631   tree_label out= L (in1);
 632   // SCM_ALLOW_INTS;
 633
 634   return tree_label_to_scm (out);
 635 }
 636
 637 SCM
 638 tmg_tree_children (SCM arg1) {
 639   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-children");
 640
 641   tree in1= scm_to_tree (arg1);
 642
 643   // SCM_DEFER_INTS;
 644   array_tree out= A (in1);
 645   // SCM_ALLOW_INTS;
 646
 647   return array_tree_to_scm (out);
 648 }
 649
 650 SCM
 651 tmg_tree_arity (SCM arg1) {
 652   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-arity");
 653
 654   tree in1= scm_to_tree (arg1);
 655
 656   // SCM_DEFER_INTS;
 657   int out= N (in1);
 658   // SCM_ALLOW_INTS;
 659
 660   return int_to_scm (out);
 661 }
 662
 663 SCM
 664 tmg_tree_child_ref (SCM arg1, SCM arg2) {
 665   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-child-ref");
 666   SCM_ASSERT_INT (arg2, SCM_ARG2, "tree-child-ref");
 667
 668   tree in1= scm_to_tree (arg1);
 669   int in2= scm_to_int (arg2);
 670
 671   // SCM_DEFER_INTS;
 672   tree out= tree_ref (in1, in2);
 673   // SCM_ALLOW_INTS;
 674
 675   return tree_to_scm (out);
 676 }
 677
 678 SCM
 679 tmg_tree_child_setS (SCM arg1, SCM arg2, SCM arg3) {
 680   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-child-set!");
 681   SCM_ASSERT_INT (arg2, SCM_ARG2, "tree-child-set!");
 682   SCM_ASSERT_CONTENT (arg3, SCM_ARG3, "tree-child-set!");
 683
 684   tree in1= scm_to_tree (arg1);
 685   int in2= scm_to_int (arg2);
 686   content in3= scm_to_content (arg3);
 687
 688   // SCM_DEFER_INTS;
 689   tree out= tree_set (in1, in2, in3);
 690   // SCM_ALLOW_INTS;
 691
 692   return tree_to_scm (out);
 693 }
 694
 695 SCM
 696 tmg_tree_child_insert (SCM arg1, SCM arg2, SCM arg3) {
 697   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "tree-child-insert");
 698   SCM_ASSERT_INT (arg2, SCM_ARG2, "tree-child-insert");
 699   SCM_ASSERT_CONTENT (arg3, SCM_ARG3, "tree-child-insert");
 700
 701   content in1= scm_to_content (arg1);
 702   int in2= scm_to_int (arg2);
 703   content in3= scm_to_content (arg3);
 704
 705   // SCM_DEFER_INTS;
 706   tree out= tree_child_insert (in1, in2, in3);
 707   // SCM_ALLOW_INTS;
 708
 709   return tree_to_scm (out);
 710 }
 711
 712 SCM
 713 tmg_tree_ip (SCM arg1) {
 714   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-ip");
 715
 716   tree in1= scm_to_tree (arg1);
 717
 718   // SCM_DEFER_INTS;
 719   path out= obtain_ip (in1);
 720   // SCM_ALLOW_INTS;
 721
 722   return path_to_scm (out);
 723 }
 724
 725 SCM
 726 tmg_tree_activeP (SCM arg1) {
 727   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-active?");
 728
 729   tree in1= scm_to_tree (arg1);
 730
 731   // SCM_DEFER_INTS;
 732   bool out= tree_active (in1);
 733   // SCM_ALLOW_INTS;
 734
 735   return bool_to_scm (out);
 736 }
 737
 738 SCM
 739 tmg_tree_eqP (SCM arg1, SCM arg2) {
 740   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-eq?");
 741   SCM_ASSERT_TREE (arg2, SCM_ARG2, "tree-eq?");
 742
 743   tree in1= scm_to_tree (arg1);
 744   tree in2= scm_to_tree (arg2);
 745
 746   // SCM_DEFER_INTS;
 747   bool out= strong_equal (in1, in2);
 748   // SCM_ALLOW_INTS;
 749
 750   return bool_to_scm (out);
 751 }
 752
 753 SCM
 754 tmg_subtree (SCM arg1, SCM arg2) {
 755   SCM_ASSERT_TREE (arg1, SCM_ARG1, "subtree");
 756   SCM_ASSERT_PATH (arg2, SCM_ARG2, "subtree");
 757
 758   tree in1= scm_to_tree (arg1);
 759   path in2= scm_to_path (arg2);
 760
 761   // SCM_DEFER_INTS;
 762   tree out= subtree (in1, in2);
 763   // SCM_ALLOW_INTS;
 764
 765   return tree_to_scm (out);
 766 }
 767
 768 SCM
 769 tmg_tree_range (SCM arg1, SCM arg2, SCM arg3) {
 770   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-range");
 771   SCM_ASSERT_INT (arg2, SCM_ARG2, "tree-range");
 772   SCM_ASSERT_INT (arg3, SCM_ARG3, "tree-range");
 773
 774   tree in1= scm_to_tree (arg1);
 775   int in2= scm_to_int (arg2);
 776   int in3= scm_to_int (arg3);
 777
 778   // SCM_DEFER_INTS;
 779   tree out= tree_range (in1, in2, in3);
 780   // SCM_ALLOW_INTS;
 781
 782   return tree_to_scm (out);
 783 }
 784
 785 SCM
 786 tmg_tree_copy (SCM arg1) {
 787   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-copy");
 788
 789   tree in1= scm_to_tree (arg1);
 790
 791   // SCM_DEFER_INTS;
 792   tree out= copy (in1);
 793   // SCM_ALLOW_INTS;
 794
 795   return tree_to_scm (out);
 796 }
 797
 798 SCM
 799 tmg_tree_append (SCM arg1, SCM arg2) {
 800   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-append");
 801   SCM_ASSERT_TREE (arg2, SCM_ARG2, "tree-append");
 802
 803   tree in1= scm_to_tree (arg1);
 804   tree in2= scm_to_tree (arg2);
 805
 806   // SCM_DEFER_INTS;
 807   tree out= tree_append (in1, in2);
 808   // SCM_ALLOW_INTS;
 809
 810   return tree_to_scm (out);
 811 }
 812
 813 SCM
 814 tmg_tree_right_index (SCM arg1) {
 815   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-right-index");
 816
 817   tree in1= scm_to_tree (arg1);
 818
 819   // SCM_DEFER_INTS;
 820   int out= right_index (in1);
 821   // SCM_ALLOW_INTS;
 822
 823   return int_to_scm (out);
 824 }
 825
 826 SCM
 827 tmg_tree_label_extensionP (SCM arg1) {
 828   SCM_ASSERT_TREE_LABEL (arg1, SCM_ARG1, "tree-label-extension?");
 829
 830   tree_label in1= scm_to_tree_label (arg1);
 831
 832   // SCM_DEFER_INTS;
 833   bool out= is_extension (in1);
 834   // SCM_ALLOW_INTS;
 835
 836   return bool_to_scm (out);
 837 }
 838
 839 SCM
 840 tmg_tree_multi_paragraphP (SCM arg1) {
 841   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-multi-paragraph?");
 842
 843   tree in1= scm_to_tree (arg1);
 844
 845   // SCM_DEFER_INTS;
 846   bool out= is_multi_paragraph (in1);
 847   // SCM_ALLOW_INTS;
 848
 849   return bool_to_scm (out);
 850 }
 851
 852 SCM
 853 tmg_tree_simplify (SCM arg1) {
 854   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-simplify");
 855
 856   tree in1= scm_to_tree (arg1);
 857
 858   // SCM_DEFER_INTS;
 859   tree out= simplify_correct (in1);
 860   // SCM_ALLOW_INTS;
 861
 862   return tree_to_scm (out);
 863 }
 864
 865 SCM
 866 tmg_tree_accessible_childP (SCM arg1, SCM arg2) {
 867   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-accessible-child?");
 868   SCM_ASSERT_INT (arg2, SCM_ARG2, "tree-accessible-child?");
 869
 870   tree in1= scm_to_tree (arg1);
 871   int in2= scm_to_int (arg2);
 872
 873   // SCM_DEFER_INTS;
 874   bool out= is_accessible_child (in1, in2);
 875   // SCM_ALLOW_INTS;
 876
 877   return bool_to_scm (out);
 878 }
 879
 880 SCM
 881 tmg_tree_accessible_children (SCM arg1) {
 882   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-accessible-children");
 883
 884   tree in1= scm_to_tree (arg1);
 885
 886   // SCM_DEFER_INTS;
 887   array_tree out= accessible_children (in1);
 888   // SCM_ALLOW_INTS;
 889
 890   return array_tree_to_scm (out);
 891 }
 892
 893 SCM
 894 tmg_tree_load_inclusion (SCM arg1) {
 895   SCM_ASSERT_URL (arg1, SCM_ARG1, "tree-load-inclusion");
 896
 897   url in1= scm_to_url (arg1);
 898
 899   // SCM_DEFER_INTS;
 900   tree out= load_inclusion (in1);
 901   // SCM_ALLOW_INTS;
 902
 903   return tree_to_scm (out);
 904 }
 905
 906 SCM
 907 tmg_tree_as_string (SCM arg1) {
 908   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-as-string");
 909
 910   tree in1= scm_to_tree (arg1);
 911
 912   // SCM_DEFER_INTS;
 913   string out= var_as_string (in1);
 914   // SCM_ALLOW_INTS;
 915
 916   return string_to_scm (out);
 917 }
 918
 919 SCM
 920 tmg_tree_extents (SCM arg1) {
 921   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "tree-extents");
 922
 923   content in1= scm_to_content (arg1);
 924
 925   // SCM_DEFER_INTS;
 926   tree out= tree_extents (in1);
 927   // SCM_ALLOW_INTS;
 928
 929   return tree_to_scm (out);
 930 }
 931
 932 SCM
 933 tmg_tree_emptyP (SCM arg1) {
 934   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "tree-empty?");
 935
 936   content in1= scm_to_content (arg1);
 937
 938   // SCM_DEFER_INTS;
 939   bool out= is_empty (in1);
 940   // SCM_ALLOW_INTS;
 941
 942   return bool_to_scm (out);
 943 }
 944
 945 SCM
 946 tmg_tree_assign (SCM arg1, SCM arg2) {
 947   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-assign");
 948   SCM_ASSERT_CONTENT (arg2, SCM_ARG2, "tree-assign");
 949
 950   tree in1= scm_to_tree (arg1);
 951   content in2= scm_to_content (arg2);
 952
 953   // SCM_DEFER_INTS;
 954   tree out= tree_assign (in1, in2);
 955   // SCM_ALLOW_INTS;
 956
 957   return tree_to_scm (out);
 958 }
 959
 960 SCM
 961 tmg_tree_var_insert (SCM arg1, SCM arg2, SCM arg3) {
 962   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-var-insert");
 963   SCM_ASSERT_INT (arg2, SCM_ARG2, "tree-var-insert");
 964   SCM_ASSERT_CONTENT (arg3, SCM_ARG3, "tree-var-insert");
 965
 966   tree in1= scm_to_tree (arg1);
 967   int in2= scm_to_int (arg2);
 968   content in3= scm_to_content (arg3);
 969
 970   // SCM_DEFER_INTS;
 971   tree out= tree_insert (in1, in2, in3);
 972   // SCM_ALLOW_INTS;
 973
 974   return tree_to_scm (out);
 975 }
 976
 977 SCM
 978 tmg_tree_remove (SCM arg1, SCM arg2, SCM arg3) {
 979   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-remove");
 980   SCM_ASSERT_INT (arg2, SCM_ARG2, "tree-remove");
 981   SCM_ASSERT_INT (arg3, SCM_ARG3, "tree-remove");
 982
 983   tree in1= scm_to_tree (arg1);
 984   int in2= scm_to_int (arg2);
 985   int in3= scm_to_int (arg3);
 986
 987   // SCM_DEFER_INTS;
 988   tree out= tree_remove (in1, in2, in3);
 989   // SCM_ALLOW_INTS;
 990
 991   return tree_to_scm (out);
 992 }
 993
 994 SCM
 995 tmg_tree_split (SCM arg1, SCM arg2, SCM arg3) {
 996   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-split");
 997   SCM_ASSERT_INT (arg2, SCM_ARG2, "tree-split");
 998   SCM_ASSERT_INT (arg3, SCM_ARG3, "tree-split");
 999
1000   tree in1= scm_to_tree (arg1);
1001   int in2= scm_to_int (arg2);
1002   int in3= scm_to_int (arg3);
1003
1004   // SCM_DEFER_INTS;
1005   tree out= tree_split (in1, in2, in3);
1006   // SCM_ALLOW_INTS;
1007
1008   return tree_to_scm (out);
1009 }
1010
1011 SCM
1012 tmg_tree_join (SCM arg1, SCM arg2) {
1013   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-join");
1014   SCM_ASSERT_INT (arg2, SCM_ARG2, "tree-join");
1015
1016   tree in1= scm_to_tree (arg1);
1017   int in2= scm_to_int (arg2);
1018
1019   // SCM_DEFER_INTS;
1020   tree out= tree_join (in1, in2);
1021   // SCM_ALLOW_INTS;
1022
1023   return tree_to_scm (out);
1024 }
1025
1026 SCM
1027 tmg_tree_assign_node (SCM arg1, SCM arg2) {
1028   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-assign-node");
1029   SCM_ASSERT_TREE_LABEL (arg2, SCM_ARG2, "tree-assign-node");
1030
1031   tree in1= scm_to_tree (arg1);
1032   tree_label in2= scm_to_tree_label (arg2);
1033
1034   // SCM_DEFER_INTS;
1035   tree out= tree_assign_node (in1, in2);
1036   // SCM_ALLOW_INTS;
1037
1038   return tree_to_scm (out);
1039 }
1040
1041 SCM
1042 tmg_tree_insert_node (SCM arg1, SCM arg2, SCM arg3) {
1043   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-insert-node");
1044   SCM_ASSERT_INT (arg2, SCM_ARG2, "tree-insert-node");
1045   SCM_ASSERT_CONTENT (arg3, SCM_ARG3, "tree-insert-node");
1046
1047   tree in1= scm_to_tree (arg1);
1048   int in2= scm_to_int (arg2);
1049   content in3= scm_to_content (arg3);
1050
1051   // SCM_DEFER_INTS;
1052   tree out= tree_insert_node (in1, in2, in3);
1053   // SCM_ALLOW_INTS;
1054
1055   return tree_to_scm (out);
1056 }
1057
1058 SCM
1059 tmg_tree_remove_node (SCM arg1, SCM arg2) {
1060   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree-remove-node");
1061   SCM_ASSERT_INT (arg2, SCM_ARG2, "tree-remove-node");
1062
1063   tree in1= scm_to_tree (arg1);
1064   int in2= scm_to_int (arg2);
1065
1066   // SCM_DEFER_INTS;
1067   tree out= tree_remove_node (in1, in2);
1068   // SCM_ALLOW_INTS;
1069
1070   return tree_to_scm (out);
1071 }
1072
1073 SCM
1074 tmg_path_infP (SCM arg1, SCM arg2) {
1075   SCM_ASSERT_PATH (arg1, SCM_ARG1, "path-inf?");
1076   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-inf?");
1077
1078   path in1= scm_to_path (arg1);
1079   path in2= scm_to_path (arg2);
1080
1081   // SCM_DEFER_INTS;
1082   bool out= path_inf (in1, in2);
1083   // SCM_ALLOW_INTS;
1084
1085   return bool_to_scm (out);
1086 }
1087
1088 SCM
1089 tmg_path_inf_eqP (SCM arg1, SCM arg2) {
1090   SCM_ASSERT_PATH (arg1, SCM_ARG1, "path-inf-eq?");
1091   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-inf-eq?");
1092
1093   path in1= scm_to_path (arg1);
1094   path in2= scm_to_path (arg2);
1095
1096   // SCM_DEFER_INTS;
1097   bool out= path_inf_eq (in1, in2);
1098   // SCM_ALLOW_INTS;
1099
1100   return bool_to_scm (out);
1101 }
1102
1103 SCM
1104 tmg_path_lessP (SCM arg1, SCM arg2) {
1105   SCM_ASSERT_PATH (arg1, SCM_ARG1, "path-less?");
1106   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-less?");
1107
1108   path in1= scm_to_path (arg1);
1109   path in2= scm_to_path (arg2);
1110
1111   // SCM_DEFER_INTS;
1112   bool out= path_less (in1, in2);
1113   // SCM_ALLOW_INTS;
1114
1115   return bool_to_scm (out);
1116 }
1117
1118 SCM
1119 tmg_path_less_eqP (SCM arg1, SCM arg2) {
1120   SCM_ASSERT_PATH (arg1, SCM_ARG1, "path-less-eq?");
1121   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-less-eq?");
1122
1123   path in1= scm_to_path (arg1);
1124   path in2= scm_to_path (arg2);
1125
1126   // SCM_DEFER_INTS;
1127   bool out= path_less_eq (in1, in2);
1128   // SCM_ALLOW_INTS;
1129
1130   return bool_to_scm (out);
1131 }
1132
1133 SCM
1134 tmg_path_start (SCM arg1, SCM arg2) {
1135   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-start");
1136   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-start");
1137
1138   content in1= scm_to_content (arg1);
1139   path in2= scm_to_path (arg2);
1140
1141   // SCM_DEFER_INTS;
1142   path out= start (in1, in2);
1143   // SCM_ALLOW_INTS;
1144
1145   return path_to_scm (out);
1146 }
1147
1148 SCM
1149 tmg_path_end (SCM arg1, SCM arg2) {
1150   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-end");
1151   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-end");
1152
1153   content in1= scm_to_content (arg1);
1154   path in2= scm_to_path (arg2);
1155
1156   // SCM_DEFER_INTS;
1157   path out= end (in1, in2);
1158   // SCM_ALLOW_INTS;
1159
1160   return path_to_scm (out);
1161 }
1162
1163 SCM
1164 tmg_path_next (SCM arg1, SCM arg2) {
1165   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-next");
1166   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-next");
1167
1168   content in1= scm_to_content (arg1);
1169   path in2= scm_to_path (arg2);
1170
1171   // SCM_DEFER_INTS;
1172   path out= next_valid (in1, in2);
1173   // SCM_ALLOW_INTS;
1174
1175   return path_to_scm (out);
1176 }
1177
1178 SCM
1179 tmg_path_previous (SCM arg1, SCM arg2) {
1180   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-previous");
1181   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-previous");
1182
1183   content in1= scm_to_content (arg1);
1184   path in2= scm_to_path (arg2);
1185
1186   // SCM_DEFER_INTS;
1187   path out= previous_valid (in1, in2);
1188   // SCM_ALLOW_INTS;
1189
1190   return path_to_scm (out);
1191 }
1192
1193 SCM
1194 tmg_path_next_word (SCM arg1, SCM arg2) {
1195   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-next-word");
1196   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-next-word");
1197
1198   content in1= scm_to_content (arg1);
1199   path in2= scm_to_path (arg2);
1200
1201   // SCM_DEFER_INTS;
1202   path out= next_word (in1, in2);
1203   // SCM_ALLOW_INTS;
1204
1205   return path_to_scm (out);
1206 }
1207
1208 SCM
1209 tmg_path_previous_word (SCM arg1, SCM arg2) {
1210   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-previous-word");
1211   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-previous-word");
1212
1213   content in1= scm_to_content (arg1);
1214   path in2= scm_to_path (arg2);
1215
1216   // SCM_DEFER_INTS;
1217   path out= previous_word (in1, in2);
1218   // SCM_ALLOW_INTS;
1219
1220   return path_to_scm (out);
1221 }
1222
1223 SCM
1224 tmg_path_next_node (SCM arg1, SCM arg2) {
1225   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-next-node");
1226   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-next-node");
1227
1228   content in1= scm_to_content (arg1);
1229   path in2= scm_to_path (arg2);
1230
1231   // SCM_DEFER_INTS;
1232   path out= next_node (in1, in2);
1233   // SCM_ALLOW_INTS;
1234
1235   return path_to_scm (out);
1236 }
1237
1238 SCM
1239 tmg_path_previous_node (SCM arg1, SCM arg2) {
1240   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-previous-node");
1241   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-previous-node");
1242
1243   content in1= scm_to_content (arg1);
1244   path in2= scm_to_path (arg2);
1245
1246   // SCM_DEFER_INTS;
1247   path out= previous_node (in1, in2);
1248   // SCM_ALLOW_INTS;
1249
1250   return path_to_scm (out);
1251 }
1252
1253 SCM
1254 tmg_path_next_tag (SCM arg1, SCM arg2, SCM arg3) {
1255   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-next-tag");
1256   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-next-tag");
1257   SCM_ASSERT_SCHEME_TREE (arg3, SCM_ARG3, "path-next-tag");
1258
1259   content in1= scm_to_content (arg1);
1260   path in2= scm_to_path (arg2);
1261   scheme_tree in3= scm_to_scheme_tree (arg3);
1262
1263   // SCM_DEFER_INTS;
1264   path out= next_tag (in1, in2, in3);
1265   // SCM_ALLOW_INTS;
1266
1267   return path_to_scm (out);
1268 }
1269
1270 SCM
1271 tmg_path_previous_tag (SCM arg1, SCM arg2, SCM arg3) {
1272   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-previous-tag");
1273   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-previous-tag");
1274   SCM_ASSERT_SCHEME_TREE (arg3, SCM_ARG3, "path-previous-tag");
1275
1276   content in1= scm_to_content (arg1);
1277   path in2= scm_to_path (arg2);
1278   scheme_tree in3= scm_to_scheme_tree (arg3);
1279
1280   // SCM_DEFER_INTS;
1281   path out= previous_tag (in1, in2, in3);
1282   // SCM_ALLOW_INTS;
1283
1284   return path_to_scm (out);
1285 }
1286
1287 SCM
1288 tmg_path_next_tag_same_argument (SCM arg1, SCM arg2, SCM arg3) {
1289   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-next-tag-same-argument");
1290   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-next-tag-same-argument");
1291   SCM_ASSERT_SCHEME_TREE (arg3, SCM_ARG3, "path-next-tag-same-argument");
1292
1293   content in1= scm_to_content (arg1);
1294   path in2= scm_to_path (arg2);
1295   scheme_tree in3= scm_to_scheme_tree (arg3);
1296
1297   // SCM_DEFER_INTS;
1298   path out= next_tag_same_argument (in1, in2, in3);
1299   // SCM_ALLOW_INTS;
1300
1301   return path_to_scm (out);
1302 }
1303
1304 SCM
1305 tmg_path_previous_tag_same_argument (SCM arg1, SCM arg2, SCM arg3) {
1306   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-previous-tag-same-argument");
1307   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-previous-tag-same-argument");
1308   SCM_ASSERT_SCHEME_TREE (arg3, SCM_ARG3, "path-previous-tag-same-argument");
1309
1310   content in1= scm_to_content (arg1);
1311   path in2= scm_to_path (arg2);
1312   scheme_tree in3= scm_to_scheme_tree (arg3);
1313
1314   // SCM_DEFER_INTS;
1315   path out= previous_tag_same_argument (in1, in2, in3);
1316   // SCM_ALLOW_INTS;
1317
1318   return path_to_scm (out);
1319 }
1320
1321 SCM
1322 tmg_path_next_argument (SCM arg1, SCM arg2) {
1323   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-next-argument");
1324   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-next-argument");
1325
1326   content in1= scm_to_content (arg1);
1327   path in2= scm_to_path (arg2);
1328
1329   // SCM_DEFER_INTS;
1330   path out= next_argument (in1, in2);
1331   // SCM_ALLOW_INTS;
1332
1333   return path_to_scm (out);
1334 }
1335
1336 SCM
1337 tmg_path_previous_argument (SCM arg1, SCM arg2) {
1338   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "path-previous-argument");
1339   SCM_ASSERT_PATH (arg2, SCM_ARG2, "path-previous-argument");
1340
1341   content in1= scm_to_content (arg1);
1342   path in2= scm_to_path (arg2);
1343
1344   // SCM_DEFER_INTS;
1345   path out= previous_argument (in1, in2);
1346   // SCM_ALLOW_INTS;
1347
1348   return path_to_scm (out);
1349 }
1350
1351 SCM
1352 tmg_tree_2ids (SCM arg1) {
1353   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree->ids");
1354
1355   tree in1= scm_to_tree (arg1);
1356
1357   // SCM_DEFER_INTS;
1358   list_string out= get_ids (in1);
1359   // SCM_ALLOW_INTS;
1360
1361   return list_string_to_scm (out);
1362 }
1363
1364 SCM
1365 tmg_id_2trees (SCM arg1) {
1366   SCM_ASSERT_STRING (arg1, SCM_ARG1, "id->trees");
1367
1368   string in1= scm_to_string (arg1);
1369
1370   // SCM_DEFER_INTS;
1371   list_tree out= get_trees (in1);
1372   // SCM_ALLOW_INTS;
1373
1374   return list_tree_to_scm (out);
1375 }
1376
1377 SCM
1378 tmg_vertex_2links (SCM arg1) {
1379   SCM_ASSERT_CONTENT (arg1, SCM_ARG1, "vertex->links");
1380
1381   content in1= scm_to_content (arg1);
1382
1383   // SCM_DEFER_INTS;
1384   list_tree out= get_links (in1);
1385   // SCM_ALLOW_INTS;
1386
1387   return list_tree_to_scm (out);
1388 }
1389
1390 SCM
1391 tmg_tree_2tree_pointer (SCM arg1) {
1392   SCM_ASSERT_TREE (arg1, SCM_ARG1, "tree->tree-pointer");
1393
1394   tree in1= scm_to_tree (arg1);
1395
1396   // SCM_DEFER_INTS;
1397   observer out= tree_pointer_new (in1);
1398   // SCM_ALLOW_INTS;
1399
1400   return observer_to_scm (out);
1401 }
1402
1403 SCM
1404 tmg_tree_pointer_detach (SCM arg1) {
1405   SCM_ASSERT_OBSERVER (arg1, SCM_ARG1, "tree-pointer-detach");
1406
1407   observer in1= scm_to_observer (arg1);
1408
1409   // SCM_DEFER_INTS;
1410   tree_pointer_delete (in1);
1411   // SCM_ALLOW_INTS;
1412
1413   return SCM_UNSPECIFIED;
1414 }
1415
1416 SCM
1417 tmg_tree_pointer_2tree (SCM arg1) {
1418   SCM_ASSERT_OBSERVER (arg1, SCM_ARG1, "tree-pointer->tree");
1419
1420   observer in1= scm_to_observer (arg1);
1421
1422   // SCM_DEFER_INTS;
1423   tree out= obtain_tree (in1);
1424   // SCM_ALLOW_INTS;
1425
1426   return tree_to_scm (out);
1427 }
1428
1429 SCM
1430 tmg_current_link_types () {
1431   // SCM_DEFER_INTS;
1432   list_string out= all_link_types ();
1433   // SCM_ALLOW_INTS;
1434
1435   return list_string_to_scm (out);
1436 }
1437
1438 SCM
1439 tmg_get_locus_rendering (SCM arg1) {
1440   SCM_ASSERT_STRING (arg1, SCM_ARG1, "get-locus-rendering");
1441
1442   string in1= scm_to_string (arg1);
1443
1444   // SCM_DEFER_INTS;
1445   string out= get_locus_rendering (in1);
1446   // SCM_ALLOW_INTS;
1447
1448   return string_to_scm (out);
1449 }
1450
1451 SCM
1452 tmg_set_locus_rendering (SCM arg1, SCM arg2) {
1453   SCM_ASSERT_STRING (arg1, SCM_ARG1, "set-locus-rendering");
1454   SCM_ASSERT_STRING (arg2, SCM_ARG2, "set-locus-rendering");
1455
1456   string in1= scm_to_string (arg1);
1457   string in2= scm_to_string (arg2);
1458
1459   // SCM_DEFER_INTS;
1460   set_locus_rendering (in1, in2);
1461   // SCM_ALLOW_INTS;
1462
1463   return SCM_UNSPECIFIED;
1464 }
1465
1466 SCM
1467 tmg_declare_visited (SCM arg1) {
1468   SCM_ASSERT_STRING (arg1, SCM_ARG1, "declare-visited");
1469
1470   string in1= scm_to_string (arg1);
1471
1472   // SCM_DEFER_INTS;
1473   declare_visited (in1);
1474   // SCM_ALLOW_INTS;
1475
1476   return SCM_UNSPECIFIED;
1477 }
1478
1479 SCM
1480 tmg_has_been_visitedP (SCM arg1) {
1481   SCM_ASSERT_STRING (arg1, SCM_ARG1, "has-been-visited?");
1482
1483   string in1= scm_to_string (arg1);
1484
1485   // SCM_DEFER_INTS;
1486   bool out= has_been_visited (in1);
1487   // SCM_ALLOW_INTS;
1488
1489   return bool_to_scm (out);
1490 }
1491
1492 SCM
1493 tmg_string_numberP (SCM arg1) {
1494   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string-number?");
1495
1496   string in1= scm_to_string (arg1);
1497
1498   // SCM_DEFER_INTS;
1499   bool out= is_double (in1);
1500   // SCM_ALLOW_INTS;
1501
1502   return bool_to_scm (out);
1503 }
1504
1505 SCM
1506 tmg_string_search_forwards (SCM arg1, SCM arg2, SCM arg3) {
1507   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string-search-forwards");
1508   SCM_ASSERT_INT (arg2, SCM_ARG2, "string-search-forwards");
1509   SCM_ASSERT_STRING (arg3, SCM_ARG3, "string-search-forwards");
1510
1511   string in1= scm_to_string (arg1);
1512   int in2= scm_to_int (arg2);
1513   string in3= scm_to_string (arg3);
1514
1515   // SCM_DEFER_INTS;
1516   int out= search_forwards (in1, in2, in3);
1517   // SCM_ALLOW_INTS;
1518
1519   return int_to_scm (out);
1520 }
1521
1522 SCM
1523 tmg_string_search_backwards (SCM arg1, SCM arg2, SCM arg3) {
1524   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string-search-backwards");
1525   SCM_ASSERT_INT (arg2, SCM_ARG2, "string-search-backwards");
1526   SCM_ASSERT_STRING (arg3, SCM_ARG3, "string-search-backwards");
1527
1528   string in1= scm_to_string (arg1);
1529   int in2= scm_to_int (arg2);
1530   string in3= scm_to_string (arg3);
1531
1532   // SCM_DEFER_INTS;
1533   int out= search_backwards (in1, in2, in3);
1534   // SCM_ALLOW_INTS;
1535
1536   return int_to_scm (out);
1537 }
1538
1539 SCM
1540 tmg_string_replace (SCM arg1, SCM arg2, SCM arg3) {
1541   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string-replace");
1542   SCM_ASSERT_STRING (arg2, SCM_ARG2, "string-replace");
1543   SCM_ASSERT_STRING (arg3, SCM_ARG3, "string-replace");
1544
1545   string in1= scm_to_string (arg1);
1546   string in2= scm_to_string (arg2);
1547   string in3= scm_to_string (arg3);
1548
1549   // SCM_DEFER_INTS;
1550   string out= replace (in1, in2, in3);
1551   // SCM_ALLOW_INTS;
1552
1553   return string_to_scm (out);
1554 }
1555
1556 SCM
1557 tmg_string_locase_alphaP (SCM arg1) {
1558   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string-locase-alpha?");
1559
1560   string in1= scm_to_string (arg1);
1561
1562   // SCM_DEFER_INTS;
1563   bool out= is_locase_alpha (in1);
1564   // SCM_ALLOW_INTS;
1565
1566   return bool_to_scm (out);
1567 }
1568
1569 SCM
1570 tmg_upcase_first (SCM arg1) {
1571   SCM_ASSERT_STRING (arg1, SCM_ARG1, "upcase-first");
1572
1573   string in1= scm_to_string (arg1);
1574
1575   // SCM_DEFER_INTS;
1576   string out= upcase_first (in1);
1577   // SCM_ALLOW_INTS;
1578
1579   return string_to_scm (out);
1580 }
1581
1582 SCM
1583 tmg_locase_first (SCM arg1) {
1584   SCM_ASSERT_STRING (arg1, SCM_ARG1, "locase-first");
1585
1586   string in1= scm_to_string (arg1);
1587
1588   // SCM_DEFER_INTS;
1589   string out= locase_first (in1);
1590   // SCM_ALLOW_INTS;
1591
1592   return string_to_scm (out);
1593 }
1594
1595 SCM
1596 tmg_upcase_all (SCM arg1) {
1597   SCM_ASSERT_STRING (arg1, SCM_ARG1, "upcase-all");
1598
1599   string in1= scm_to_string (arg1);
1600
1601   // SCM_DEFER_INTS;
1602   string out= upcase_all (in1);
1603   // SCM_ALLOW_INTS;
1604
1605   return string_to_scm (out);
1606 }
1607
1608 SCM
1609 tmg_locase_all (SCM arg1) {
1610   SCM_ASSERT_STRING (arg1, SCM_ARG1, "locase-all");
1611
1612   string in1= scm_to_string (arg1);
1613
1614   // SCM_DEFER_INTS;
1615   string out= locase_all (in1);
1616   // SCM_ALLOW_INTS;
1617
1618   return string_to_scm (out);
1619 }
1620
1621 SCM
1622 tmg_string_union (SCM arg1, SCM arg2) {
1623   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string-union");
1624   SCM_ASSERT_STRING (arg2, SCM_ARG2, "string-union");
1625
1626   string in1= scm_to_string (arg1);
1627   string in2= scm_to_string (arg2);
1628
1629   // SCM_DEFER_INTS;
1630   string out= string_union (in1, in2);
1631   // SCM_ALLOW_INTS;
1632
1633   return string_to_scm (out);
1634 }
1635
1636 SCM
1637 tmg_string_minus (SCM arg1, SCM arg2) {
1638   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string-minus");
1639   SCM_ASSERT_STRING (arg2, SCM_ARG2, "string-minus");
1640
1641   string in1= scm_to_string (arg1);
1642   string in2= scm_to_string (arg2);
1643
1644   // SCM_DEFER_INTS;
1645   string out= string_minus (in1, in2);
1646   // SCM_ALLOW_INTS;
1647
1648   return string_to_scm (out);
1649 }
1650
1651 SCM
1652 tmg_string_encode (SCM arg1) {
1653   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string-encode");
1654
1655   string in1= scm_to_string (arg1);
1656
1657   // SCM_DEFER_INTS;
1658   string out= tm_encode (in1);
1659   // SCM_ALLOW_INTS;
1660
1661   return string_to_scm (out);
1662 }
1663
1664 SCM
1665 tmg_string_decode (SCM arg1) {
1666   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string-decode");
1667
1668   string in1= scm_to_string (arg1);
1669
1670   // SCM_DEFER_INTS;
1671   string out= tm_decode (in1);
1672   // SCM_ALLOW_INTS;
1673
1674   return string_to_scm (out);
1675 }
1676
1677 SCM
1678 tmg_escape_generic (SCM arg1) {
1679   SCM_ASSERT_STRING (arg1, SCM_ARG1, "escape-generic");
1680
1681   string in1= scm_to_string (arg1);
1682
1683   // SCM_DEFER_INTS;
1684   string out= escape_generic (in1);
1685   // SCM_ALLOW_INTS;
1686
1687   return string_to_scm (out);
1688 }
1689
1690 SCM
1691 tmg_escape_verbatim (SCM arg1) {
1692   SCM_ASSERT_STRING (arg1, SCM_ARG1, "escape-verbatim");
1693
1694   string in1= scm_to_string (arg1);
1695
1696   // SCM_DEFER_INTS;
1697   string out= escape_verbatim (in1);
1698   // SCM_ALLOW_INTS;
1699
1700   return string_to_scm (out);
1701 }
1702
1703 SCM
1704 tmg_escape_shell (SCM arg1) {
1705   SCM_ASSERT_STRING (arg1, SCM_ARG1, "escape-shell");
1706
1707   string in1= scm_to_string (arg1);
1708
1709   // SCM_DEFER_INTS;
1710   string out= escape_sh (in1);
1711   // SCM_ALLOW_INTS;
1712
1713   return string_to_scm (out);
1714 }
1715
1716 SCM
1717 tmg_string_convert (SCM arg1, SCM arg2, SCM arg3) {
1718   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string-convert");
1719   SCM_ASSERT_STRING (arg2, SCM_ARG2, "string-convert");
1720   SCM_ASSERT_STRING (arg3, SCM_ARG3, "string-convert");
1721
1722   string in1= scm_to_string (arg1);
1723   string in2= scm_to_string (arg2);
1724   string in3= scm_to_string (arg3);
1725
1726   // SCM_DEFER_INTS;
1727   string out= convert (in1, in2, in3);
1728   // SCM_ALLOW_INTS;
1729
1730   return string_to_scm (out);
1731 }
1732
1733 SCM
1734 tmg_utf8_2cork (SCM arg1) {
1735   SCM_ASSERT_STRING (arg1, SCM_ARG1, "utf8->cork");
1736
1737   string in1= scm_to_string (arg1);
1738
1739   // SCM_DEFER_INTS;
1740   string out= utf8_to_cork (in1);
1741   // SCM_ALLOW_INTS;
1742
1743   return string_to_scm (out);
1744 }
1745
1746 SCM
1747 tmg_cork_2utf8 (SCM arg1) {
1748   SCM_ASSERT_STRING (arg1, SCM_ARG1, "cork->utf8");
1749
1750   string in1= scm_to_string (arg1);
1751
1752   // SCM_DEFER_INTS;
1753   string out= cork_to_utf8 (in1);
1754   // SCM_ALLOW_INTS;
1755
1756   return string_to_scm (out);
1757 }
1758
1759 SCM
1760 tmg_utf8_2html (SCM arg1) {
1761   SCM_ASSERT_STRING (arg1, SCM_ARG1, "utf8->html");
1762
1763   string in1= scm_to_string (arg1);
1764
1765   // SCM_DEFER_INTS;
1766   string out= utf8_to_html (in1);
1767   // SCM_ALLOW_INTS;
1768
1769   return string_to_scm (out);
1770 }
1771
1772 SCM
1773 tmg_tm_2xml_name (SCM arg1) {
1774   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tm->xml-name");
1775
1776   string in1= scm_to_string (arg1);
1777
1778   // SCM_DEFER_INTS;
1779   string out= tm_to_xml_name (in1);
1780   // SCM_ALLOW_INTS;
1781
1782   return string_to_scm (out);
1783 }
1784
1785 SCM
1786 tmg_old_tm_2xml_cdata (SCM arg1) {
1787   SCM_ASSERT_STRING (arg1, SCM_ARG1, "old-tm->xml-cdata");
1788
1789   string in1= scm_to_string (arg1);
1790
1791   // SCM_DEFER_INTS;
1792   string out= old_tm_to_xml_cdata (in1);
1793   // SCM_ALLOW_INTS;
1794
1795   return string_to_scm (out);
1796 }
1797
1798 SCM
1799 tmg_tm_2xml_cdata (SCM arg1) {
1800   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tm->xml-cdata");
1801
1802   string in1= scm_to_string (arg1);
1803
1804   // SCM_DEFER_INTS;
1805   object out= tm_to_xml_cdata (in1);
1806   // SCM_ALLOW_INTS;
1807
1808   return object_to_scm (out);
1809 }
1810
1811 SCM
1812 tmg_xml_name_2tm (SCM arg1) {
1813   SCM_ASSERT_STRING (arg1, SCM_ARG1, "xml-name->tm");
1814
1815   string in1= scm_to_string (arg1);
1816
1817   // SCM_DEFER_INTS;
1818   string out= xml_name_to_tm (in1);
1819   // SCM_ALLOW_INTS;
1820
1821   return string_to_scm (out);
1822 }
1823
1824 SCM
1825 tmg_old_xml_cdata_2tm (SCM arg1) {
1826   SCM_ASSERT_STRING (arg1, SCM_ARG1, "old-xml-cdata->tm");
1827
1828   string in1= scm_to_string (arg1);
1829
1830   // SCM_DEFER_INTS;
1831   string out= old_xml_cdata_to_tm (in1);
1832   // SCM_ALLOW_INTS;
1833
1834   return string_to_scm (out);
1835 }
1836
1837 SCM
1838 tmg_xml_unspace (SCM arg1, SCM arg2, SCM arg3) {
1839   SCM_ASSERT_STRING (arg1, SCM_ARG1, "xml-unspace");
1840   SCM_ASSERT_BOOL (arg2, SCM_ARG2, "xml-unspace");
1841   SCM_ASSERT_BOOL (arg3, SCM_ARG3, "xml-unspace");
1842
1843   string in1= scm_to_string (arg1);
1844   bool in2= scm_to_bool (arg2);
1845   bool in3= scm_to_bool (arg3);
1846
1847   // SCM_DEFER_INTS;
1848   string out= xml_unspace (in1, in2, in3);
1849   // SCM_ALLOW_INTS;
1850
1851   return string_to_scm (out);
1852 }
1853
1854 SCM
1855 tmg_define_grammar_rule (SCM arg1, SCM arg2) {
1856   SCM_ASSERT_TREE (arg1, SCM_ARG1, "define-grammar-rule");
1857   SCM_ASSERT_TREE (arg2, SCM_ARG2, "define-grammar-rule");
1858
1859   tree in1= scm_to_tree (arg1);
1860   tree in2= scm_to_tree (arg2);
1861
1862   // SCM_DEFER_INTS;
1863   define_grammar_rule (in1, in2);
1864   // SCM_ALLOW_INTS;
1865
1866   return SCM_UNSPECIFIED;
1867 }
1868
1869 SCM
1870 tmg_grammar_parse (SCM arg1, SCM arg2) {
1871   SCM_ASSERT_TREE (arg1, SCM_ARG1, "grammar-parse");
1872   SCM_ASSERT_STRING (arg2, SCM_ARG2, "grammar-parse");
1873
1874   tree in1= scm_to_tree (arg1);
1875   string in2= scm_to_string (arg2);
1876
1877   // SCM_DEFER_INTS;
1878   int out= grammar_parse (in1, in2);
1879   // SCM_ALLOW_INTS;
1880
1881   return int_to_scm (out);
1882 }
1883
1884 SCM
1885 tmg_parse_texmacs (SCM arg1) {
1886   SCM_ASSERT_STRING (arg1, SCM_ARG1, "parse-texmacs");
1887
1888   string in1= scm_to_string (arg1);
1889
1890   // SCM_DEFER_INTS;
1891   tree out= texmacs_document_to_tree (in1);
1892   // SCM_ALLOW_INTS;
1893
1894   return tree_to_scm (out);
1895 }
1896
1897 SCM
1898 tmg_serialize_texmacs (SCM arg1) {
1899   SCM_ASSERT_TREE (arg1, SCM_ARG1, "serialize-texmacs");
1900
1901   tree in1= scm_to_tree (arg1);
1902
1903   // SCM_DEFER_INTS;
1904   string out= tree_to_texmacs (in1);
1905   // SCM_ALLOW_INTS;
1906
1907   return string_to_scm (out);
1908 }
1909
1910 SCM
1911 tmg_parse_texmacs_snippet (SCM arg1) {
1912   SCM_ASSERT_STRING (arg1, SCM_ARG1, "parse-texmacs-snippet");
1913
1914   string in1= scm_to_string (arg1);
1915
1916   // SCM_DEFER_INTS;
1917   tree out= texmacs_to_tree (in1);
1918   // SCM_ALLOW_INTS;
1919
1920   return tree_to_scm (out);
1921 }
1922
1923 SCM
1924 tmg_serialize_texmacs_snippet (SCM arg1) {
1925   SCM_ASSERT_TREE (arg1, SCM_ARG1, "serialize-texmacs-snippet");
1926
1927   tree in1= scm_to_tree (arg1);
1928
1929   // SCM_DEFER_INTS;
1930   string out= tree_to_texmacs (in1);
1931   // SCM_ALLOW_INTS;
1932
1933   return string_to_scm (out);
1934 }
1935
1936 SCM
1937 tmg_texmacs_2stm (SCM arg1) {
1938   SCM_ASSERT_TREE (arg1, SCM_ARG1, "texmacs->stm");
1939
1940   tree in1= scm_to_tree (arg1);
1941
1942   // SCM_DEFER_INTS;
1943   string out= tree_to_scheme (in1);
1944   // SCM_ALLOW_INTS;
1945
1946   return string_to_scm (out);
1947 }
1948
1949 SCM
1950 tmg_stm_2texmacs (SCM arg1) {
1951   SCM_ASSERT_STRING (arg1, SCM_ARG1, "stm->texmacs");
1952
1953   string in1= scm_to_string (arg1);
1954
1955   // SCM_DEFER_INTS;
1956   tree out= scheme_document_to_tree (in1);
1957   // SCM_ALLOW_INTS;
1958
1959   return tree_to_scm (out);
1960 }
1961
1962 SCM
1963 tmg_stm_snippet_2texmacs (SCM arg1) {
1964   SCM_ASSERT_STRING (arg1, SCM_ARG1, "stm-snippet->texmacs");
1965
1966   string in1= scm_to_string (arg1);
1967
1968   // SCM_DEFER_INTS;
1969   tree out= scheme_to_tree (in1);
1970   // SCM_ALLOW_INTS;
1971
1972   return tree_to_scm (out);
1973 }
1974
1975 SCM
1976 tmg_cpp_texmacs_2verbatim (SCM arg1, SCM arg2, SCM arg3) {
1977   SCM_ASSERT_TREE (arg1, SCM_ARG1, "cpp-texmacs->verbatim");
1978   SCM_ASSERT_BOOL (arg2, SCM_ARG2, "cpp-texmacs->verbatim");
1979   SCM_ASSERT_STRING (arg3, SCM_ARG3, "cpp-texmacs->verbatim");
1980
1981   tree in1= scm_to_tree (arg1);
1982   bool in2= scm_to_bool (arg2);
1983   string in3= scm_to_string (arg3);
1984
1985   // SCM_DEFER_INTS;
1986   string out= tree_to_verbatim (in1, in2, in3);
1987   // SCM_ALLOW_INTS;
1988
1989   return string_to_scm (out);
1990 }
1991
1992 SCM
1993 tmg_cpp_verbatim_snippet_2texmacs (SCM arg1, SCM arg2, SCM arg3) {
1994   SCM_ASSERT_STRING (arg1, SCM_ARG1, "cpp-verbatim-snippet->texmacs");
1995   SCM_ASSERT_BOOL (arg2, SCM_ARG2, "cpp-verbatim-snippet->texmacs");
1996   SCM_ASSERT_STRING (arg3, SCM_ARG3, "cpp-verbatim-snippet->texmacs");
1997
1998   string in1= scm_to_string (arg1);
1999   bool in2= scm_to_bool (arg2);
2000   string in3= scm_to_string (arg3);
2001
2002   // SCM_DEFER_INTS;
2003   tree out= verbatim_to_tree (in1, in2, in3);
2004   // SCM_ALLOW_INTS;
2005
2006   return tree_to_scm (out);
2007 }
2008
2009 SCM
2010 tmg_cpp_verbatim_2texmacs (SCM arg1, SCM arg2, SCM arg3) {
2011   SCM_ASSERT_STRING (arg1, SCM_ARG1, "cpp-verbatim->texmacs");
2012   SCM_ASSERT_BOOL (arg2, SCM_ARG2, "cpp-verbatim->texmacs");
2013   SCM_ASSERT_STRING (arg3, SCM_ARG3, "cpp-verbatim->texmacs");
2014
2015   string in1= scm_to_string (arg1);
2016   bool in2= scm_to_bool (arg2);
2017   string in3= scm_to_string (arg3);
2018
2019   // SCM_DEFER_INTS;
2020   tree out= verbatim_document_to_tree (in1, in2, in3);
2021   // SCM_ALLOW_INTS;
2022
2023   return tree_to_scm (out);
2024 }
2025
2026 SCM
2027 tmg_parse_latex (SCM arg1) {
2028   SCM_ASSERT_STRING (arg1, SCM_ARG1, "parse-latex");
2029
2030   string in1= scm_to_string (arg1);
2031
2032   // SCM_DEFER_INTS;
2033   tree out= parse_latex (in1);
2034   // SCM_ALLOW_INTS;
2035
2036   return tree_to_scm (out);
2037 }
2038
2039 SCM
2040 tmg_parse_latex_document (SCM arg1) {
2041   SCM_ASSERT_STRING (arg1, SCM_ARG1, "parse-latex-document");
2042
2043   string in1= scm_to_string (arg1);
2044
2045   // SCM_DEFER_INTS;
2046   tree out= parse_latex_document (in1);
2047   // SCM_ALLOW_INTS;
2048
2049   return tree_to_scm (out);
2050 }
2051
2052 SCM
2053 tmg_latex_2texmacs (SCM arg1) {
2054   SCM_ASSERT_TREE (arg1, SCM_ARG1, "latex->texmacs");
2055
2056   tree in1= scm_to_tree (arg1);
2057
2058   // SCM_DEFER_INTS;
2059   tree out= latex_to_tree (in1);
2060   // SCM_ALLOW_INTS;
2061
2062   return tree_to_scm (out);
2063 }
2064
2065 SCM
2066 tmg_parse_xml (SCM arg1) {
2067   SCM_ASSERT_STRING (arg1, SCM_ARG1, "parse-xml");
2068
2069   string in1= scm_to_string (arg1);
2070
2071   // SCM_DEFER_INTS;
2072   scheme_tree out= parse_xml (in1);
2073   // SCM_ALLOW_INTS;
2074
2075   return scheme_tree_to_scm (out);
2076 }
2077
2078 SCM
2079 tmg_parse_html (SCM arg1) {
2080   SCM_ASSERT_STRING (arg1, SCM_ARG1, "parse-html");
2081
2082   string in1= scm_to_string (arg1);
2083
2084   // SCM_DEFER_INTS;
2085   scheme_tree out= parse_html (in1);
2086   // SCM_ALLOW_INTS;
2087
2088   return scheme_tree_to_scm (out);
2089 }
2090
2091 SCM
2092 tmg_parse_bib (SCM arg1) {
2093   SCM_ASSERT_STRING (arg1, SCM_ARG1, "parse-bib");
2094
2095   string in1= scm_to_string (arg1);
2096
2097   // SCM_DEFER_INTS;
2098   tree out= parse_bib (in1);
2099   // SCM_ALLOW_INTS;
2100
2101   return tree_to_scm (out);
2102 }
2103
2104 SCM
2105 tmg_upgrade_tmml (SCM arg1) {
2106   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "upgrade-tmml");
2107
2108   scheme_tree in1= scm_to_scheme_tree (arg1);
2109
2110   // SCM_DEFER_INTS;
2111   tree out= tmml_upgrade (in1);
2112   // SCM_ALLOW_INTS;
2113
2114   return tree_to_scm (out);
2115 }
2116
2117 SCM
2118 tmg_string_2url (SCM arg1) {
2119   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string->url");
2120
2121   string in1= scm_to_string (arg1);
2122
2123   // SCM_DEFER_INTS;
2124   url out= url (in1);
2125   // SCM_ALLOW_INTS;
2126
2127   return url_to_scm (out);
2128 }
2129
2130 SCM
2131 tmg_url (SCM arg1, SCM arg2) {
2132   SCM_ASSERT_STRING (arg1, SCM_ARG1, "url");
2133   SCM_ASSERT_STRING (arg2, SCM_ARG2, "url");
2134
2135   string in1= scm_to_string (arg1);
2136   string in2= scm_to_string (arg2);
2137
2138   // SCM_DEFER_INTS;
2139   url out= url (in1, in2);
2140   // SCM_ALLOW_INTS;
2141
2142   return url_to_scm (out);
2143 }
2144
2145 SCM
2146 tmg_url_system (SCM arg1) {
2147   SCM_ASSERT_STRING (arg1, SCM_ARG1, "url-system");
2148
2149   string in1= scm_to_string (arg1);
2150
2151   // SCM_DEFER_INTS;
2152   url out= url_system (in1);
2153   // SCM_ALLOW_INTS;
2154
2155   return url_to_scm (out);
2156 }
2157
2158 SCM
2159 tmg_url_none () {
2160   // SCM_DEFER_INTS;
2161   url out= url_none ();
2162   // SCM_ALLOW_INTS;
2163
2164   return url_to_scm (out);
2165 }
2166
2167 SCM
2168 tmg_url_any () {
2169   // SCM_DEFER_INTS;
2170   url out= url_wildcard ();
2171   // SCM_ALLOW_INTS;
2172
2173   return url_to_scm (out);
2174 }
2175
2176 SCM
2177 tmg_url_wildcard (SCM arg1) {
2178   SCM_ASSERT_STRING (arg1, SCM_ARG1, "url-wildcard");
2179
2180   string in1= scm_to_string (arg1);
2181
2182   // SCM_DEFER_INTS;
2183   url out= url_wildcard (in1);
2184   // SCM_ALLOW_INTS;
2185
2186   return url_to_scm (out);
2187 }
2188
2189 SCM
2190 tmg_url_parent () {
2191   // SCM_DEFER_INTS;
2192   url out= url_parent ();
2193   // SCM_ALLOW_INTS;
2194
2195   return url_to_scm (out);
2196 }
2197
2198 SCM
2199 tmg_url_append (SCM arg1, SCM arg2) {
2200   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-append");
2201   SCM_ASSERT_URL (arg2, SCM_ARG2, "url-append");
2202
2203   url in1= scm_to_url (arg1);
2204   url in2= scm_to_url (arg2);
2205
2206   // SCM_DEFER_INTS;
2207   url out= url_concat (in1, in2);
2208   // SCM_ALLOW_INTS;
2209
2210   return url_to_scm (out);
2211 }
2212
2213 SCM
2214 tmg_url_or (SCM arg1, SCM arg2) {
2215   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-or");
2216   SCM_ASSERT_URL (arg2, SCM_ARG2, "url-or");
2217
2218   url in1= scm_to_url (arg1);
2219   url in2= scm_to_url (arg2);
2220
2221   // SCM_DEFER_INTS;
2222   url out= url_or (in1, in2);
2223   // SCM_ALLOW_INTS;
2224
2225   return url_to_scm (out);
2226 }
2227
2228 SCM
2229 tmg_url_2string (SCM arg1) {
2230   SCM_ASSERT_URL (arg1, SCM_ARG1, "url->string");
2231
2232   url in1= scm_to_url (arg1);
2233
2234   // SCM_DEFER_INTS;
2235   string out= as_string (in1);
2236   // SCM_ALLOW_INTS;
2237
2238   return string_to_scm (out);
2239 }
2240
2241 SCM
2242 tmg_url_noneP (SCM arg1) {
2243   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-none?");
2244
2245   url in1= scm_to_url (arg1);
2246
2247   // SCM_DEFER_INTS;
2248   bool out= is_none (in1);
2249   // SCM_ALLOW_INTS;
2250
2251   return bool_to_scm (out);
2252 }
2253
2254 SCM
2255 tmg_url_rooted_webP (SCM arg1) {
2256   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-rooted-web?");
2257
2258   url in1= scm_to_url (arg1);
2259
2260   // SCM_DEFER_INTS;
2261   bool out= is_rooted_web (in1);
2262   // SCM_ALLOW_INTS;
2263
2264   return bool_to_scm (out);
2265 }
2266
2267 SCM
2268 tmg_url_concatP (SCM arg1) {
2269   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-concat?");
2270
2271   url in1= scm_to_url (arg1);
2272
2273   // SCM_DEFER_INTS;
2274   bool out= is_concat (in1);
2275   // SCM_ALLOW_INTS;
2276
2277   return bool_to_scm (out);
2278 }
2279
2280 SCM
2281 tmg_url_orP (SCM arg1) {
2282   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-or?");
2283
2284   url in1= scm_to_url (arg1);
2285
2286   // SCM_DEFER_INTS;
2287   bool out= is_or (in1);
2288   // SCM_ALLOW_INTS;
2289
2290   return bool_to_scm (out);
2291 }
2292
2293 SCM
2294 tmg_url_ref (SCM arg1, SCM arg2) {
2295   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-ref");
2296   SCM_ASSERT_INT (arg2, SCM_ARG2, "url-ref");
2297
2298   url in1= scm_to_url (arg1);
2299   int in2= scm_to_int (arg2);
2300
2301   // SCM_DEFER_INTS;
2302   url out= url_ref (in1, in2);
2303   // SCM_ALLOW_INTS;
2304
2305   return url_to_scm (out);
2306 }
2307
2308 SCM
2309 tmg_url_tail (SCM arg1) {
2310   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-tail");
2311
2312   url in1= scm_to_url (arg1);
2313
2314   // SCM_DEFER_INTS;
2315   url out= tail (in1);
2316   // SCM_ALLOW_INTS;
2317
2318   return url_to_scm (out);
2319 }
2320
2321 SCM
2322 tmg_url_suffix (SCM arg1) {
2323   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-suffix");
2324
2325   url in1= scm_to_url (arg1);
2326
2327   // SCM_DEFER_INTS;
2328   string out= suffix (in1);
2329   // SCM_ALLOW_INTS;
2330
2331   return string_to_scm (out);
2332 }
2333
2334 SCM
2335 tmg_url_glue (SCM arg1, SCM arg2) {
2336   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-glue");
2337   SCM_ASSERT_STRING (arg2, SCM_ARG2, "url-glue");
2338
2339   url in1= scm_to_url (arg1);
2340   string in2= scm_to_string (arg2);
2341
2342   // SCM_DEFER_INTS;
2343   url out= glue (in1, in2);
2344   // SCM_ALLOW_INTS;
2345
2346   return url_to_scm (out);
2347 }
2348
2349 SCM
2350 tmg_url_unglue (SCM arg1, SCM arg2) {
2351   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-unglue");
2352   SCM_ASSERT_INT (arg2, SCM_ARG2, "url-unglue");
2353
2354   url in1= scm_to_url (arg1);
2355   int in2= scm_to_int (arg2);
2356
2357   // SCM_DEFER_INTS;
2358   url out= unglue (in1, in2);
2359   // SCM_ALLOW_INTS;
2360
2361   return url_to_scm (out);
2362 }
2363
2364 SCM
2365 tmg_url_relative (SCM arg1, SCM arg2) {
2366   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-relative");
2367   SCM_ASSERT_URL (arg2, SCM_ARG2, "url-relative");
2368
2369   url in1= scm_to_url (arg1);
2370   url in2= scm_to_url (arg2);
2371
2372   // SCM_DEFER_INTS;
2373   url out= relative (in1, in2);
2374   // SCM_ALLOW_INTS;
2375
2376   return url_to_scm (out);
2377 }
2378
2379 SCM
2380 tmg_url_expand (SCM arg1) {
2381   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-expand");
2382
2383   url in1= scm_to_url (arg1);
2384
2385   // SCM_DEFER_INTS;
2386   url out= expand (in1);
2387   // SCM_ALLOW_INTS;
2388
2389   return url_to_scm (out);
2390 }
2391
2392 SCM
2393 tmg_url_factor (SCM arg1) {
2394   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-factor");
2395
2396   url in1= scm_to_url (arg1);
2397
2398   // SCM_DEFER_INTS;
2399   url out= factor (in1);
2400   // SCM_ALLOW_INTS;
2401
2402   return url_to_scm (out);
2403 }
2404
2405 SCM
2406 tmg_url_delta (SCM arg1, SCM arg2) {
2407   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-delta");
2408   SCM_ASSERT_URL (arg2, SCM_ARG2, "url-delta");
2409
2410   url in1= scm_to_url (arg1);
2411   url in2= scm_to_url (arg2);
2412
2413   // SCM_DEFER_INTS;
2414   url out= delta (in1, in2);
2415   // SCM_ALLOW_INTS;
2416
2417   return url_to_scm (out);
2418 }
2419
2420 SCM
2421 tmg_url_secureP (SCM arg1) {
2422   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-secure?");
2423
2424   url in1= scm_to_url (arg1);
2425
2426   // SCM_DEFER_INTS;
2427   bool out= is_secure (in1);
2428   // SCM_ALLOW_INTS;
2429
2430   return bool_to_scm (out);
2431 }
2432
2433 SCM
2434 tmg_url_descendsP (SCM arg1, SCM arg2) {
2435   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-descends?");
2436   SCM_ASSERT_URL (arg2, SCM_ARG2, "url-descends?");
2437
2438   url in1= scm_to_url (arg1);
2439   url in2= scm_to_url (arg2);
2440
2441   // SCM_DEFER_INTS;
2442   bool out= descends (in1, in2);
2443   // SCM_ALLOW_INTS;
2444
2445   return bool_to_scm (out);
2446 }
2447
2448 SCM
2449 tmg_url_complete (SCM arg1, SCM arg2) {
2450   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-complete");
2451   SCM_ASSERT_STRING (arg2, SCM_ARG2, "url-complete");
2452
2453   url in1= scm_to_url (arg1);
2454   string in2= scm_to_string (arg2);
2455
2456   // SCM_DEFER_INTS;
2457   url out= complete (in1, in2);
2458   // SCM_ALLOW_INTS;
2459
2460   return url_to_scm (out);
2461 }
2462
2463 SCM
2464 tmg_url_resolve (SCM arg1, SCM arg2) {
2465   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-resolve");
2466   SCM_ASSERT_STRING (arg2, SCM_ARG2, "url-resolve");
2467
2468   url in1= scm_to_url (arg1);
2469   string in2= scm_to_string (arg2);
2470
2471   // SCM_DEFER_INTS;
2472   url out= resolve (in1, in2);
2473   // SCM_ALLOW_INTS;
2474
2475   return url_to_scm (out);
2476 }
2477
2478 SCM
2479 tmg_url_resolve_in_path (SCM arg1) {
2480   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-resolve-in-path");
2481
2482   url in1= scm_to_url (arg1);
2483
2484   // SCM_DEFER_INTS;
2485   url out= resolve_in_path (in1);
2486   // SCM_ALLOW_INTS;
2487
2488   return url_to_scm (out);
2489 }
2490
2491 SCM
2492 tmg_url_existsP (SCM arg1) {
2493   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-exists?");
2494
2495   url in1= scm_to_url (arg1);
2496
2497   // SCM_DEFER_INTS;
2498   bool out= exists (in1);
2499   // SCM_ALLOW_INTS;
2500
2501   return bool_to_scm (out);
2502 }
2503
2504 SCM
2505 tmg_url_exists_in_pathP (SCM arg1) {
2506   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-exists-in-path?");
2507
2508   url in1= scm_to_url (arg1);
2509
2510   // SCM_DEFER_INTS;
2511   bool out= exists_in_path (in1);
2512   // SCM_ALLOW_INTS;
2513
2514   return bool_to_scm (out);
2515 }
2516
2517 SCM
2518 tmg_url_exists_in_texP (SCM arg1) {
2519   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-exists-in-tex?");
2520
2521   url in1= scm_to_url (arg1);
2522
2523   // SCM_DEFER_INTS;
2524   bool out= exists_in_tex (in1);
2525   // SCM_ALLOW_INTS;
2526
2527   return bool_to_scm (out);
2528 }
2529
2530 SCM
2531 tmg_url_concretize (SCM arg1) {
2532   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-concretize");
2533
2534   url in1= scm_to_url (arg1);
2535
2536   // SCM_DEFER_INTS;
2537   string out= concretize (in1);
2538   // SCM_ALLOW_INTS;
2539
2540   return string_to_scm (out);
2541 }
2542
2543 SCM
2544 tmg_url_materialize (SCM arg1, SCM arg2) {
2545   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-materialize");
2546   SCM_ASSERT_STRING (arg2, SCM_ARG2, "url-materialize");
2547
2548   url in1= scm_to_url (arg1);
2549   string in2= scm_to_string (arg2);
2550
2551   // SCM_DEFER_INTS;
2552   string out= materialize (in1, in2);
2553   // SCM_ALLOW_INTS;
2554
2555   return string_to_scm (out);
2556 }
2557
2558 SCM
2559 tmg_url_testP (SCM arg1, SCM arg2) {
2560   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-test?");
2561   SCM_ASSERT_STRING (arg2, SCM_ARG2, "url-test?");
2562
2563   url in1= scm_to_url (arg1);
2564   string in2= scm_to_string (arg2);
2565
2566   // SCM_DEFER_INTS;
2567   bool out= is_of_type (in1, in2);
2568   // SCM_ALLOW_INTS;
2569
2570   return bool_to_scm (out);
2571 }
2572
2573 SCM
2574 tmg_url_regularP (SCM arg1) {
2575   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-regular?");
2576
2577   url in1= scm_to_url (arg1);
2578
2579   // SCM_DEFER_INTS;
2580   bool out= is_regular (in1);
2581   // SCM_ALLOW_INTS;
2582
2583   return bool_to_scm (out);
2584 }
2585
2586 SCM
2587 tmg_url_directoryP (SCM arg1) {
2588   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-directory?");
2589
2590   url in1= scm_to_url (arg1);
2591
2592   // SCM_DEFER_INTS;
2593   bool out= is_directory (in1);
2594   // SCM_ALLOW_INTS;
2595
2596   return bool_to_scm (out);
2597 }
2598
2599 SCM
2600 tmg_url_linkP (SCM arg1) {
2601   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-link?");
2602
2603   url in1= scm_to_url (arg1);
2604
2605   // SCM_DEFER_INTS;
2606   bool out= is_symbolic_link (in1);
2607   // SCM_ALLOW_INTS;
2608
2609   return bool_to_scm (out);
2610 }
2611
2612 SCM
2613 tmg_url_newerP (SCM arg1, SCM arg2) {
2614   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-newer?");
2615   SCM_ASSERT_URL (arg2, SCM_ARG2, "url-newer?");
2616
2617   url in1= scm_to_url (arg1);
2618   url in2= scm_to_url (arg2);
2619
2620   // SCM_DEFER_INTS;
2621   bool out= is_newer (in1, in2);
2622   // SCM_ALLOW_INTS;
2623
2624   return bool_to_scm (out);
2625 }
2626
2627 SCM
2628 tmg_url_last_modified (SCM arg1) {
2629   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-last-modified");
2630
2631   url in1= scm_to_url (arg1);
2632
2633   // SCM_DEFER_INTS;
2634   int out= last_modified (in1);
2635   // SCM_ALLOW_INTS;
2636
2637   return int_to_scm (out);
2638 }
2639
2640 SCM
2641 tmg_url_temp () {
2642   // SCM_DEFER_INTS;
2643   url out= url_temp ();
2644   // SCM_ALLOW_INTS;
2645
2646   return url_to_scm (out);
2647 }
2648
2649 SCM
2650 tmg_url_scratch (SCM arg1, SCM arg2, SCM arg3) {
2651   SCM_ASSERT_STRING (arg1, SCM_ARG1, "url-scratch");
2652   SCM_ASSERT_STRING (arg2, SCM_ARG2, "url-scratch");
2653   SCM_ASSERT_INT (arg3, SCM_ARG3, "url-scratch");
2654
2655   string in1= scm_to_string (arg1);
2656   string in2= scm_to_string (arg2);
2657   int in3= scm_to_int (arg3);
2658
2659   // SCM_DEFER_INTS;
2660   url out= url_scratch (in1, in2, in3);
2661   // SCM_ALLOW_INTS;
2662
2663   return url_to_scm (out);
2664 }
2665
2666 SCM
2667 tmg_url_scratchP (SCM arg1) {
2668   SCM_ASSERT_URL (arg1, SCM_ARG1, "url-scratch?");
2669
2670   url in1= scm_to_url (arg1);
2671
2672   // SCM_DEFER_INTS;
2673   bool out= is_scratch (in1);
2674   // SCM_ALLOW_INTS;
2675
2676   return bool_to_scm (out);
2677 }
2678
2679 SCM
2680 tmg_string_save (SCM arg1, SCM arg2) {
2681   SCM_ASSERT_STRING (arg1, SCM_ARG1, "string-save");
2682   SCM_ASSERT_URL (arg2, SCM_ARG2, "string-save");
2683
2684   string in1= scm_to_string (arg1);
2685   url in2= scm_to_url (arg2);
2686
2687   // SCM_DEFER_INTS;
2688   string_save (in1, in2);
2689   // SCM_ALLOW_INTS;
2690
2691   return SCM_UNSPECIFIED;
2692 }
2693
2694 SCM
2695 tmg_string_load (SCM arg1) {
2696   SCM_ASSERT_URL (arg1, SCM_ARG1, "string-load");
2697
2698   url in1= scm_to_url (arg1);
2699
2700   // SCM_DEFER_INTS;
2701   string out= string_load (in1);
2702   // SCM_ALLOW_INTS;
2703
2704   return string_to_scm (out);
2705 }
2706
2707 SCM
2708 tmg_system_move (SCM arg1, SCM arg2) {
2709   SCM_ASSERT_URL (arg1, SCM_ARG1, "system-move");
2710   SCM_ASSERT_URL (arg2, SCM_ARG2, "system-move");
2711
2712   url in1= scm_to_url (arg1);
2713   url in2= scm_to_url (arg2);
2714
2715   // SCM_DEFER_INTS;
2716   move (in1, in2);
2717   // SCM_ALLOW_INTS;
2718
2719   return SCM_UNSPECIFIED;
2720 }
2721
2722 SCM
2723 tmg_system_copy (SCM arg1, SCM arg2) {
2724   SCM_ASSERT_URL (arg1, SCM_ARG1, "system-copy");
2725   SCM_ASSERT_URL (arg2, SCM_ARG2, "system-copy");
2726
2727   url in1= scm_to_url (arg1);
2728   url in2= scm_to_url (arg2);
2729
2730   // SCM_DEFER_INTS;
2731   copy (in1, in2);
2732   // SCM_ALLOW_INTS;
2733
2734   return SCM_UNSPECIFIED;
2735 }
2736
2737 SCM
2738 tmg_system_remove (SCM arg1) {
2739   SCM_ASSERT_URL (arg1, SCM_ARG1, "system-remove");
2740
2741   url in1= scm_to_url (arg1);
2742
2743   // SCM_DEFER_INTS;
2744   remove (in1);
2745   // SCM_ALLOW_INTS;
2746
2747   return SCM_UNSPECIFIED;
2748 }
2749
2750 SCM
2751 tmg_system_mkdir (SCM arg1) {
2752   SCM_ASSERT_URL (arg1, SCM_ARG1, "system-mkdir");
2753
2754   url in1= scm_to_url (arg1);
2755
2756   // SCM_DEFER_INTS;
2757   mkdir (in1);
2758   // SCM_ALLOW_INTS;
2759
2760   return SCM_UNSPECIFIED;
2761 }
2762
2763 SCM
2764 tmg_system_search_score (SCM arg1, SCM arg2) {
2765   SCM_ASSERT_URL (arg1, SCM_ARG1, "system-search-score");
2766   SCM_ASSERT_ARRAY_STRING (arg2, SCM_ARG2, "system-search-score");
2767
2768   url in1= scm_to_url (arg1);
2769   array_string in2= scm_to_array_string (arg2);
2770
2771   // SCM_DEFER_INTS;
2772   int out= search_score (in1, in2);
2773   // SCM_ALLOW_INTS;
2774
2775   return int_to_scm (out);
2776 }
2777
2778 SCM
2779 tmg_system_1 (SCM arg1, SCM arg2) {
2780   SCM_ASSERT_STRING (arg1, SCM_ARG1, "system-1");
2781   SCM_ASSERT_URL (arg2, SCM_ARG2, "system-1");
2782
2783   string in1= scm_to_string (arg1);
2784   url in2= scm_to_url (arg2);
2785
2786   // SCM_DEFER_INTS;
2787   system (in1, in2);
2788   // SCM_ALLOW_INTS;
2789
2790   return SCM_UNSPECIFIED;
2791 }
2792
2793 SCM
2794 tmg_system_2 (SCM arg1, SCM arg2, SCM arg3) {
2795   SCM_ASSERT_STRING (arg1, SCM_ARG1, "system-2");
2796   SCM_ASSERT_URL (arg2, SCM_ARG2, "system-2");
2797   SCM_ASSERT_URL (arg3, SCM_ARG3, "system-2");
2798
2799   string in1= scm_to_string (arg1);
2800   url in2= scm_to_url (arg2);
2801   url in3= scm_to_url (arg3);
2802
2803   // SCM_DEFER_INTS;
2804   system (in1, in2, in3);
2805   // SCM_ALLOW_INTS;
2806
2807   return SCM_UNSPECIFIED;
2808 }
2809
2810 SCM
2811 tmg_tmfs_set (SCM arg1, SCM arg2) {
2812   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-set");
2813   SCM_ASSERT_COLLECTION (arg2, SCM_ARG2, "tmfs-set");
2814
2815   string in1= scm_to_string (arg1);
2816   collection in2= scm_to_collection (arg2);
2817
2818   // SCM_DEFER_INTS;
2819   tmfs_set (in1, in2);
2820   // SCM_ALLOW_INTS;
2821
2822   return SCM_UNSPECIFIED;
2823 }
2824
2825 SCM
2826 tmg_tmfs_reset (SCM arg1, SCM arg2) {
2827   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-reset");
2828   SCM_ASSERT_COLLECTION (arg2, SCM_ARG2, "tmfs-reset");
2829
2830   string in1= scm_to_string (arg1);
2831   collection in2= scm_to_collection (arg2);
2832
2833   // SCM_DEFER_INTS;
2834   tmfs_reset (in1, in2);
2835   // SCM_ALLOW_INTS;
2836
2837   return SCM_UNSPECIFIED;
2838 }
2839
2840 SCM
2841 tmg_tmfs_get (SCM arg1) {
2842   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-get");
2843
2844   string in1= scm_to_string (arg1);
2845
2846   // SCM_DEFER_INTS;
2847   collection out= tmfs_get (in1);
2848   // SCM_ALLOW_INTS;
2849
2850   return collection_to_scm (out);
2851 }
2852
2853 SCM
2854 tmg_tmfs_new_save (SCM arg1, SCM arg2) {
2855   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-new-save");
2856   SCM_ASSERT_STRING (arg2, SCM_ARG2, "tmfs-new-save");
2857
2858   string in1= scm_to_string (arg1);
2859   string in2= scm_to_string (arg2);
2860
2861   // SCM_DEFER_INTS;
2862   tmfs_save (in1, in2);
2863   // SCM_ALLOW_INTS;
2864
2865   return SCM_UNSPECIFIED;
2866 }
2867
2868 SCM
2869 tmg_tmfs_new_remove (SCM arg1) {
2870   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-new-remove");
2871
2872   string in1= scm_to_string (arg1);
2873
2874   // SCM_DEFER_INTS;
2875   tmfs_remove (in1);
2876   // SCM_ALLOW_INTS;
2877
2878   return SCM_UNSPECIFIED;
2879 }
2880
2881 SCM
2882 tmg_tmfs_new_load (SCM arg1) {
2883   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-new-load");
2884
2885   string in1= scm_to_string (arg1);
2886
2887   // SCM_DEFER_INTS;
2888   string out= tmfs_load (in1);
2889   // SCM_ALLOW_INTS;
2890
2891   return string_to_scm (out);
2892 }
2893
2894 SCM
2895 tmg_tmfs_create_ressource () {
2896   // SCM_DEFER_INTS;
2897   string out= tmfs_create_ressource ();
2898   // SCM_ALLOW_INTS;
2899
2900   return string_to_scm (out);
2901 }
2902
2903 SCM
2904 tmg_tmfs_ressource_head (SCM arg1) {
2905   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-ressource-head");
2906
2907   string in1= scm_to_string (arg1);
2908
2909   // SCM_DEFER_INTS;
2910   string out= tmfs_get_head (in1);
2911   // SCM_ALLOW_INTS;
2912
2913   return string_to_scm (out);
2914 }
2915
2916 SCM
2917 tmg_tmfs_ressource_versions (SCM arg1) {
2918   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-ressource-versions");
2919
2920   string in1= scm_to_string (arg1);
2921
2922   // SCM_DEFER_INTS;
2923   collection out= tmfs_get_versions (in1);
2924   // SCM_ALLOW_INTS;
2925
2926   return collection_to_scm (out);
2927 }
2928
2929 SCM
2930 tmg_tmfs_save_ressource (SCM arg1, SCM arg2, SCM arg3) {
2931   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-save-ressource");
2932   SCM_ASSERT_STRING (arg2, SCM_ARG2, "tmfs-save-ressource");
2933   SCM_ASSERT_PROPERTIES (arg3, SCM_ARG3, "tmfs-save-ressource");
2934
2935   string in1= scm_to_string (arg1);
2936   string in2= scm_to_string (arg2);
2937   properties in3= scm_to_properties (arg3);
2938
2939   // SCM_DEFER_INTS;
2940   tmfs_save_ressource (in1, in2, in3);
2941   // SCM_ALLOW_INTS;
2942
2943   return SCM_UNSPECIFIED;
2944 }
2945
2946 SCM
2947 tmg_tmfs_load_ressource_file (SCM arg1) {
2948   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-load-ressource-file");
2949
2950   string in1= scm_to_string (arg1);
2951
2952   // SCM_DEFER_INTS;
2953   string out= tmfs_load_ressource_file (in1);
2954   // SCM_ALLOW_INTS;
2955
2956   return string_to_scm (out);
2957 }
2958
2959 SCM
2960 tmg_tmfs_load_ressource_properties (SCM arg1) {
2961   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-load-ressource-properties");
2962
2963   string in1= scm_to_string (arg1);
2964
2965   // SCM_DEFER_INTS;
2966   properties out= tmfs_load_ressource_properties (in1);
2967   // SCM_ALLOW_INTS;
2968
2969   return properties_to_scm (out);
2970 }
2971
2972 SCM
2973 tmg_tmfs_create_user (SCM arg1) {
2974   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-create-user");
2975
2976   string in1= scm_to_string (arg1);
2977
2978   // SCM_DEFER_INTS;
2979   string out= tmfs_create_user (in1);
2980   // SCM_ALLOW_INTS;
2981
2982   return string_to_scm (out);
2983 }
2984
2985 SCM
2986 tmg_tmfs_search_user (SCM arg1) {
2987   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-search-user");
2988
2989   string in1= scm_to_string (arg1);
2990
2991   // SCM_DEFER_INTS;
2992   collection out= tmfs_search_user (in1);
2993   // SCM_ALLOW_INTS;
2994
2995   return collection_to_scm (out);
2996 }
2997
2998 SCM
2999 tmg_tmfs_set_user (SCM arg1) {
3000   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-set-user");
3001
3002   string in1= scm_to_string (arg1);
3003
3004   // SCM_DEFER_INTS;
3005   tmfs_set_user (in1);
3006   // SCM_ALLOW_INTS;
3007
3008   return SCM_UNSPECIFIED;
3009 }
3010
3011 SCM
3012 tmg_tmfs_get_user () {
3013   // SCM_DEFER_INTS;
3014   string out= tmfs_get_user ();
3015   // SCM_ALLOW_INTS;
3016
3017   return string_to_scm (out);
3018 }
3019
3020 SCM
3021 tmg_tmfs_allowsP (SCM arg1, SCM arg2) {
3022   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-allows?");
3023   SCM_ASSERT_STRING (arg2, SCM_ARG2, "tmfs-allows?");
3024
3025   string in1= scm_to_string (arg1);
3026   string in2= scm_to_string (arg2);
3027
3028   // SCM_DEFER_INTS;
3029   bool out= tmfs_allows (in1, in2);
3030   // SCM_ALLOW_INTS;
3031
3032   return bool_to_scm (out);
3033 }
3034
3035 SCM
3036 tmg_tmfs_set_attributes (SCM arg1, SCM arg2) {
3037   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-set-attributes");
3038   SCM_ASSERT_PROPERTIES (arg2, SCM_ARG2, "tmfs-set-attributes");
3039
3040   string in1= scm_to_string (arg1);
3041   properties in2= scm_to_properties (arg2);
3042
3043   // SCM_DEFER_INTS;
3044   tmfs_set_attributes (in1, in2);
3045   // SCM_ALLOW_INTS;
3046
3047   return SCM_UNSPECIFIED;
3048 }
3049
3050 SCM
3051 tmg_tmfs_get_attributes (SCM arg1) {
3052   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-get-attributes");
3053
3054   string in1= scm_to_string (arg1);
3055
3056   // SCM_DEFER_INTS;
3057   properties out= tmfs_get_attributes (in1);
3058   // SCM_ALLOW_INTS;
3059
3060   return properties_to_scm (out);
3061 }
3062
3063 SCM
3064 tmg_tmfs_add_attributes (SCM arg1, SCM arg2) {
3065   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-add-attributes");
3066   SCM_ASSERT_PROPERTIES (arg2, SCM_ARG2, "tmfs-add-attributes");
3067
3068   string in1= scm_to_string (arg1);
3069   properties in2= scm_to_properties (arg2);
3070
3071   // SCM_DEFER_INTS;
3072   tmfs_add_attributes (in1, in2);
3073   // SCM_ALLOW_INTS;
3074
3075   return SCM_UNSPECIFIED;
3076 }
3077
3078 SCM
3079 tmg_tmfs_remove_attributes (SCM arg1, SCM arg2) {
3080   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-remove-attributes");
3081   SCM_ASSERT_PROPERTIES (arg2, SCM_ARG2, "tmfs-remove-attributes");
3082
3083   string in1= scm_to_string (arg1);
3084   properties in2= scm_to_properties (arg2);
3085
3086   // SCM_DEFER_INTS;
3087   tmfs_remove_attributes (in1, in2);
3088   // SCM_ALLOW_INTS;
3089
3090   return SCM_UNSPECIFIED;
3091 }
3092
3093 SCM
3094 tmg_tmfs_change_attributes (SCM arg1, SCM arg2) {
3095   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-change-attributes");
3096   SCM_ASSERT_PROPERTIES (arg2, SCM_ARG2, "tmfs-change-attributes");
3097
3098   string in1= scm_to_string (arg1);
3099   properties in2= scm_to_properties (arg2);
3100
3101   // SCM_DEFER_INTS;
3102   tmfs_change_attributes (in1, in2);
3103   // SCM_ALLOW_INTS;
3104
3105   return SCM_UNSPECIFIED;
3106 }
3107
3108 SCM
3109 tmg_tmfs_query (SCM arg1) {
3110   SCM_ASSERT_PROPERTIES (arg1, SCM_ARG1, "tmfs-query");
3111
3112   properties in1= scm_to_properties (arg1);
3113
3114   // SCM_DEFER_INTS;
3115   solutions out= tmfs_query (in1);
3116   // SCM_ALLOW_INTS;
3117
3118   return solutions_to_scm (out);
3119 }
3120
3121 SCM
3122 tmg_solutions_2collection (SCM arg1, SCM arg2) {
3123   SCM_ASSERT_SOLUTIONS (arg1, SCM_ARG1, "solutions->collection");
3124   SCM_ASSERT_STRING (arg2, SCM_ARG2, "solutions->collection");
3125
3126   solutions in1= scm_to_solutions (arg1);
3127   string in2= scm_to_string (arg2);
3128
3129   // SCM_DEFER_INTS;
3130   collection out= as_collection (in1, in2);
3131   // SCM_ALLOW_INTS;
3132
3133   return collection_to_scm (out);
3134 }
3135
3136 SCM
3137 tmg_tmfs_create_file (SCM arg1, SCM arg2) {
3138   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-create-file");
3139   SCM_ASSERT_STRING (arg2, SCM_ARG2, "tmfs-create-file");
3140
3141   string in1= scm_to_string (arg1);
3142   string in2= scm_to_string (arg2);
3143
3144   // SCM_DEFER_INTS;
3145   string out= tmfs_create_file (in1, in2);
3146   // SCM_ALLOW_INTS;
3147
3148   return string_to_scm (out);
3149 }
3150
3151 SCM
3152 tmg_tmfs_create_file_in (SCM arg1, SCM arg2, SCM arg3) {
3153   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-create-file-in");
3154   SCM_ASSERT_STRING (arg2, SCM_ARG2, "tmfs-create-file-in");
3155   SCM_ASSERT_STRING (arg3, SCM_ARG3, "tmfs-create-file-in");
3156
3157   string in1= scm_to_string (arg1);
3158   string in2= scm_to_string (arg2);
3159   string in3= scm_to_string (arg3);
3160
3161   // SCM_DEFER_INTS;
3162   string out= tmfs_create_file (in1, in2, in3);
3163   // SCM_ALLOW_INTS;
3164
3165   return string_to_scm (out);
3166 }
3167
3168 SCM
3169 tmg_tmfs_search_file (SCM arg1) {
3170   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-search-file");
3171
3172   string in1= scm_to_string (arg1);
3173
3174   // SCM_DEFER_INTS;
3175   collection out= tmfs_search_file (in1);
3176   // SCM_ALLOW_INTS;
3177
3178   return collection_to_scm (out);
3179 }
3180
3181 SCM
3182 tmg_tmfs_save_file (SCM arg1, SCM arg2) {
3183   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-save-file");
3184   SCM_ASSERT_STRING (arg2, SCM_ARG2, "tmfs-save-file");
3185
3186   string in1= scm_to_string (arg1);
3187   string in2= scm_to_string (arg2);
3188
3189   // SCM_DEFER_INTS;
3190   tmfs_save_file (in1, in2);
3191   // SCM_ALLOW_INTS;
3192
3193   return SCM_UNSPECIFIED;
3194 }
3195
3196 SCM
3197 tmg_tmfs_load_file (SCM arg1) {
3198   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-load-file");
3199
3200   string in1= scm_to_string (arg1);
3201
3202   // SCM_DEFER_INTS;
3203   string out= tmfs_load_file (in1);
3204   // SCM_ALLOW_INTS;
3205
3206   return string_to_scm (out);
3207 }
3208
3209 SCM
3210 tmg_tmfs_create_project (SCM arg1) {
3211   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-create-project");
3212
3213   string in1= scm_to_string (arg1);
3214
3215   // SCM_DEFER_INTS;
3216   string out= tmfs_create_project (in1);
3217   // SCM_ALLOW_INTS;
3218
3219   return string_to_scm (out);
3220 }
3221
3222 SCM
3223 tmg_tmfs_search_project (SCM arg1) {
3224   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-search-project");
3225
3226   string in1= scm_to_string (arg1);
3227
3228   // SCM_DEFER_INTS;
3229   collection out= tmfs_search_project (in1);
3230   // SCM_ALLOW_INTS;
3231
3232   return collection_to_scm (out);
3233 }
3234
3235 SCM
3236 tmg_tmfs_get_file_projects (SCM arg1) {
3237   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-get-file-projects");
3238
3239   string in1= scm_to_string (arg1);
3240
3241   // SCM_DEFER_INTS;
3242   collection out= tmfs_get_file_projects (in1);
3243   // SCM_ALLOW_INTS;
3244
3245   return collection_to_scm (out);
3246 }
3247
3248 SCM
3249 tmg_tmfs_get_project_files (SCM arg1) {
3250   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-get-project-files");
3251
3252   string in1= scm_to_string (arg1);
3253
3254   // SCM_DEFER_INTS;
3255   collection out= tmfs_get_project_files (in1);
3256   // SCM_ALLOW_INTS;
3257
3258   return collection_to_scm (out);
3259 }
3260
3261 SCM
3262 tmg_tmfs_create_branch (SCM arg1, SCM arg2) {
3263   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-create-branch");
3264   SCM_ASSERT_STRING (arg2, SCM_ARG2, "tmfs-create-branch");
3265
3266   string in1= scm_to_string (arg1);
3267   string in2= scm_to_string (arg2);
3268
3269   // SCM_DEFER_INTS;
3270   string out= tmfs_create_branch (in1, in2);
3271   // SCM_ALLOW_INTS;
3272
3273   return string_to_scm (out);
3274 }
3275
3276 SCM
3277 tmg_tmfs_set_root (SCM arg1, SCM arg2) {
3278   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-set-root");
3279   SCM_ASSERT_URL (arg2, SCM_ARG2, "tmfs-set-root");
3280
3281   string in1= scm_to_string (arg1);
3282   url in2= scm_to_url (arg2);
3283
3284   // SCM_DEFER_INTS;
3285   tmfs_set_root (in1, in2);
3286   // SCM_ALLOW_INTS;
3287
3288   return SCM_UNSPECIFIED;
3289 }
3290
3291 SCM
3292 tmg_tmfs_get_root (SCM arg1) {
3293   SCM_ASSERT_STRING (arg1, SCM_ARG1, "tmfs-get-root");
3294
3295   string in1= scm_to_string (arg1);
3296
3297   // SCM_DEFER_INTS;
3298   url out= tmfs_get_root (in1);
3299   // SCM_ALLOW_INTS;
3300
3301   return url_to_scm (out);
3302 }
3303
3304 SCM
3305 tmg_tmfs_import (SCM arg1) {
3306   SCM_ASSERT_URL (arg1, SCM_ARG1, "tmfs-import");
3307
3308   url in1= scm_to_url (arg1);
3309
3310   // SCM_DEFER_INTS;
3311   tmfs_import (in1);
3312   // SCM_ALLOW_INTS;
3313
3314   return SCM_UNSPECIFIED;
3315 }
3316
3317 SCM
3318 tmg_tmfs_export (SCM arg1) {
3319   SCM_ASSERT_URL (arg1, SCM_ARG1, "tmfs-export");
3320
3321   url in1= scm_to_url (arg1);
3322
3323   // SCM_DEFER_INTS;
3324   tmfs_export (in1);
3325   // SCM_ALLOW_INTS;
3326
3327   return SCM_UNSPECIFIED;
3328 }
3329
3330 SCM
3331 tmg_server_start () {
3332   // SCM_DEFER_INTS;
3333   server_start ();
3334   // SCM_ALLOW_INTS;
3335
3336   return SCM_UNSPECIFIED;
3337 }
3338
3339 SCM
3340 tmg_server_stop () {
3341   // SCM_DEFER_INTS;
3342   server_stop ();
3343   // SCM_ALLOW_INTS;
3344
3345   return SCM_UNSPECIFIED;
3346 }
3347
3348 SCM
3349 tmg_server_read (SCM arg1) {
3350   SCM_ASSERT_INT (arg1, SCM_ARG1, "server-read");
3351
3352   int in1= scm_to_int (arg1);
3353
3354   // SCM_DEFER_INTS;
3355   string out= server_read (in1);
3356   // SCM_ALLOW_INTS;
3357
3358   return string_to_scm (out);
3359 }
3360
3361 SCM
3362 tmg_server_write (SCM arg1, SCM arg2) {
3363   SCM_ASSERT_INT (arg1, SCM_ARG1, "server-write");
3364   SCM_ASSERT_STRING (arg2, SCM_ARG2, "server-write");
3365
3366   int in1= scm_to_int (arg1);
3367   string in2= scm_to_string (arg2);
3368
3369   // SCM_DEFER_INTS;
3370   server_write (in1, in2);
3371   // SCM_ALLOW_INTS;
3372
3373   return SCM_UNSPECIFIED;
3374 }
3375
3376 SCM
3377 tmg_client_start (SCM arg1) {
3378   SCM_ASSERT_STRING (arg1, SCM_ARG1, "client-start");
3379
3380   string in1= scm_to_string (arg1);
3381
3382   // SCM_DEFER_INTS;
3383   client_start (in1);
3384   // SCM_ALLOW_INTS;
3385
3386   return SCM_UNSPECIFIED;
3387 }
3388
3389 SCM
3390 tmg_client_stop () {
3391   // SCM_DEFER_INTS;
3392   client_stop ();
3393   // SCM_ALLOW_INTS;
3394
3395   return SCM_UNSPECIFIED;
3396 }
3397
3398 SCM
3399 tmg_client_read () {
3400   // SCM_DEFER_INTS;
3401   string out= client_read ();
3402   // SCM_ALLOW_INTS;
3403
3404   return string_to_scm (out);
3405 }
3406
3407 SCM
3408 tmg_client_write (SCM arg1) {
3409   SCM_ASSERT_STRING (arg1, SCM_ARG1, "client-write");
3410
3411   string in1= scm_to_string (arg1);
3412
3413   // SCM_DEFER_INTS;
3414   client_write (in1);
3415   // SCM_ALLOW_INTS;
3416
3417   return SCM_UNSPECIFIED;
3418 }
3419
3420 SCM
3421 tmg_enter_secure_mode () {
3422   // SCM_DEFER_INTS;
3423   enter_secure_mode ();
3424   // SCM_ALLOW_INTS;
3425
3426   return SCM_UNSPECIFIED;
3427 }
3428
3429 SCM
3430 tmg_connection_start (SCM arg1, SCM arg2) {
3431   SCM_ASSERT_STRING (arg1, SCM_ARG1, "connection-start");
3432   SCM_ASSERT_STRING (arg2, SCM_ARG2, "connection-start");
3433
3434   string in1= scm_to_string (arg1);
3435   string in2= scm_to_string (arg2);
3436
3437   // SCM_DEFER_INTS;
3438   string out= connection_start (in1, in2);
3439   // SCM_ALLOW_INTS;
3440
3441   return string_to_scm (out);
3442 }
3443
3444 SCM
3445 tmg_connection_status (SCM arg1, SCM arg2) {
3446   SCM_ASSERT_STRING (arg1, SCM_ARG1, "connection-status");
3447   SCM_ASSERT_STRING (arg2, SCM_ARG2, "connection-status");
3448
3449   string in1= scm_to_string (arg1);
3450   string in2= scm_to_string (arg2);
3451
3452   // SCM_DEFER_INTS;
3453   int out= connection_status (in1, in2);
3454   // SCM_ALLOW_INTS;
3455
3456   return int_to_scm (out);
3457 }
3458
3459 SCM
3460 tmg_connection_write_string (SCM arg1, SCM arg2, SCM arg3) {
3461   SCM_ASSERT_STRING (arg1, SCM_ARG1, "connection-write-string");
3462   SCM_ASSERT_STRING (arg2, SCM_ARG2, "connection-write-string");
3463   SCM_ASSERT_STRING (arg3, SCM_ARG3, "connection-write-string");
3464
3465   string in1= scm_to_string (arg1);
3466   string in2= scm_to_string (arg2);
3467   string in3= scm_to_string (arg3);
3468
3469   // SCM_DEFER_INTS;
3470   connection_write (in1, in2, in3);
3471   // SCM_ALLOW_INTS;
3472
3473   return SCM_UNSPECIFIED;
3474 }
3475
3476 SCM
3477 tmg_connection_write (SCM arg1, SCM arg2, SCM arg3) {
3478   SCM_ASSERT_STRING (arg1, SCM_ARG1, "connection-write");
3479   SCM_ASSERT_STRING (arg2, SCM_ARG2, "connection-write");
3480   SCM_ASSERT_CONTENT (arg3, SCM_ARG3, "connection-write");
3481
3482   string in1= scm_to_string (arg1);
3483   string in2= scm_to_string (arg2);
3484   content in3= scm_to_content (arg3);
3485
3486   // SCM_DEFER_INTS;
3487   connection_write (in1, in2, in3);
3488   // SCM_ALLOW_INTS;
3489
3490   return SCM_UNSPECIFIED;
3491 }
3492
3493 SCM
3494 tmg_connection_cmd (SCM arg1, SCM arg2, SCM arg3) {
3495   SCM_ASSERT_STRING (arg1, SCM_ARG1, "connection-cmd");
3496   SCM_ASSERT_STRING (arg2, SCM_ARG2, "connection-cmd");
3497   SCM_ASSERT_STRING (arg3, SCM_ARG3, "connection-cmd");
3498
3499   string in1= scm_to_string (arg1);
3500   string in2= scm_to_string (arg2);
3501   string in3= scm_to_string (arg3);
3502
3503   // SCM_DEFER_INTS;
3504   tree out= connection_cmd (in1, in2, in3);
3505   // SCM_ALLOW_INTS;
3506
3507   return tree_to_scm (out);
3508 }
3509
3510 SCM
3511 tmg_connection_eval (SCM arg1, SCM arg2, SCM arg3) {
3512   SCM_ASSERT_STRING (arg1, SCM_ARG1, "connection-eval");
3513   SCM_ASSERT_STRING (arg2, SCM_ARG2, "connection-eval");
3514   SCM_ASSERT_CONTENT (arg3, SCM_ARG3, "connection-eval");
3515
3516   string in1= scm_to_string (arg1);
3517   string in2= scm_to_string (arg2);
3518   content in3= scm_to_content (arg3);
3519
3520   // SCM_DEFER_INTS;
3521   tree out= connection_eval (in1, in2, in3);
3522   // SCM_ALLOW_INTS;
3523
3524   return tree_to_scm (out);
3525 }
3526
3527 SCM
3528 tmg_connection_interrupt (SCM arg1, SCM arg2) {
3529   SCM_ASSERT_STRING (arg1, SCM_ARG1, "connection-interrupt");
3530   SCM_ASSERT_STRING (arg2, SCM_ARG2, "connection-interrupt");
3531
3532   string in1= scm_to_string (arg1);
3533   string in2= scm_to_string (arg2);
3534
3535   // SCM_DEFER_INTS;
3536   connection_interrupt (in1, in2);
3537   // SCM_ALLOW_INTS;
3538
3539   return SCM_UNSPECIFIED;
3540 }
3541
3542 SCM
3543 tmg_connection_stop (SCM arg1, SCM arg2) {
3544   SCM_ASSERT_STRING (arg1, SCM_ARG1, "connection-stop");
3545   SCM_ASSERT_STRING (arg2, SCM_ARG2, "connection-stop");
3546
3547   string in1= scm_to_string (arg1);
3548   string in2= scm_to_string (arg2);
3549
3550   // SCM_DEFER_INTS;
3551   connection_stop (in1, in2);
3552   // SCM_ALLOW_INTS;
3553
3554   return SCM_UNSPECIFIED;
3555 }
3556
3557 SCM
3558 tmg_widget_hmenu (SCM arg1) {
3559   SCM_ASSERT_ARRAY_WIDGET (arg1, SCM_ARG1, "widget-hmenu");
3560
3561   array_widget in1= scm_to_array_widget (arg1);
3562
3563   // SCM_DEFER_INTS;
3564   widget out= horizontal_menu (in1);
3565   // SCM_ALLOW_INTS;
3566
3567   return widget_to_scm (out);
3568 }
3569
3570 SCM
3571 tmg_widget_vmenu (SCM arg1) {
3572   SCM_ASSERT_ARRAY_WIDGET (arg1, SCM_ARG1, "widget-vmenu");
3573
3574   array_widget in1= scm_to_array_widget (arg1);
3575
3576   // SCM_DEFER_INTS;
3577   widget out= vertical_menu (in1);
3578   // SCM_ALLOW_INTS;
3579
3580   return widget_to_scm (out);
3581 }
3582
3583 SCM
3584 tmg_widget_tmenu (SCM arg1, SCM arg2) {
3585   SCM_ASSERT_ARRAY_WIDGET (arg1, SCM_ARG1, "widget-tmenu");
3586   SCM_ASSERT_INT (arg2, SCM_ARG2, "widget-tmenu");
3587
3588   array_widget in1= scm_to_array_widget (arg1);
3589   int in2= scm_to_int (arg2);
3590
3591   // SCM_DEFER_INTS;
3592   widget out= tile_menu (in1, in2);
3593   // SCM_ALLOW_INTS;
3594
3595   return widget_to_scm (out);
3596 }
3597
3598 SCM
3599 tmg_widget_separator (SCM arg1) {
3600   SCM_ASSERT_BOOL (arg1, SCM_ARG1, "widget-separator");
3601
3602   bool in1= scm_to_bool (arg1);
3603
3604   // SCM_DEFER_INTS;
3605   widget out= menu_separator (in1);
3606   // SCM_ALLOW_INTS;
3607
3608   return widget_to_scm (out);
3609 }
3610
3611 SCM
3612 tmg_widget_menu_group (SCM arg1, SCM arg2) {
3613   SCM_ASSERT_STRING (arg1, SCM_ARG1, "widget-menu-group");
3614   SCM_ASSERT_STRING (arg2, SCM_ARG2, "widget-menu-group");
3615
3616   string in1= scm_to_string (arg1);
3617   string in2= scm_to_string (arg2);
3618
3619   // SCM_DEFER_INTS;
3620   widget out= menu_group (in1, in2);
3621   // SCM_ALLOW_INTS;
3622
3623   return widget_to_scm (out);
3624 }
3625
3626 SCM
3627 tmg_widget_pulldown_button (SCM arg1, SCM arg2) {
3628   SCM_ASSERT_WIDGET (arg1, SCM_ARG1, "widget-pulldown-button");
3629   SCM_ASSERT_PROMISE_WIDGET (arg2, SCM_ARG2, "widget-pulldown-button");
3630
3631   widget in1= scm_to_widget (arg1);
3632   promise_widget in2= scm_to_promise_widget (arg2);
3633
3634   // SCM_DEFER_INTS;
3635   widget out= pulldown_button (in1, in2);
3636   // SCM_ALLOW_INTS;
3637
3638   return widget_to_scm (out);
3639 }
3640
3641 SCM
3642 tmg_widget_pullright_button (SCM arg1, SCM arg2) {
3643   SCM_ASSERT_WIDGET (arg1, SCM_ARG1, "widget-pullright-button");
3644   SCM_ASSERT_PROMISE_WIDGET (arg2, SCM_ARG2, "widget-pullright-button");
3645
3646   widget in1= scm_to_widget (arg1);
3647   promise_widget in2= scm_to_promise_widget (arg2);
3648
3649   // SCM_DEFER_INTS;
3650   widget out= pullright_button (in1, in2);
3651   // SCM_ALLOW_INTS;
3652
3653   return widget_to_scm (out);
3654 }
3655
3656 SCM
3657 tmg_widget_menu_button (SCM arg1, SCM arg2, SCM arg3, SCM arg4, SCM arg5) {
3658   SCM_ASSERT_WIDGET (arg1, SCM_ARG1, "widget-menu-button");
3659   SCM_ASSERT_COMMAND (arg2, SCM_ARG2, "widget-menu-button");
3660   SCM_ASSERT_STRING (arg3, SCM_ARG3, "widget-menu-button");
3661   SCM_ASSERT_STRING (arg4, SCM_ARG4, "widget-menu-button");
3662   SCM_ASSERT_BOOL (arg5, SCM_ARG5, "widget-menu-button");
3663
3664   widget in1= scm_to_widget (arg1);
3665   command in2= scm_to_command (arg2);
3666   string in3= scm_to_string (arg3);
3667   string in4= scm_to_string (arg4);
3668   bool in5= scm_to_bool (arg5);
3669
3670   // SCM_DEFER_INTS;
3671   widget out= menu_button (in1, in2, in3, in4, in5);
3672   // SCM_ALLOW_INTS;
3673
3674   return widget_to_scm (out);
3675 }
3676
3677 SCM
3678 tmg_widget_balloon (SCM arg1, SCM arg2) {
3679   SCM_ASSERT_WIDGET (arg1, SCM_ARG1, "widget-balloon");
3680   SCM_ASSERT_WIDGET (arg2, SCM_ARG2, "widget-balloon");
3681
3682   widget in1= scm_to_widget (arg1);
3683   widget in2= scm_to_widget (arg2);
3684
3685   // SCM_DEFER_INTS;
3686   widget out= balloon_widget (in1, in2);
3687   // SCM_ALLOW_INTS;
3688
3689   return widget_to_scm (out);
3690 }
3691
3692 SCM
3693 tmg_widget_empty () {
3694   // SCM_DEFER_INTS;
3695   widget out= empty_widget ();
3696   // SCM_ALLOW_INTS;
3697
3698   return widget_to_scm (out);
3699 }
3700
3701 SCM
3702 tmg_widget_text (SCM arg1, SCM arg2, SCM arg3, SCM arg4) {
3703   SCM_ASSERT_STRING (arg1, SCM_ARG1, "widget-text");
3704   SCM_ASSERT_INT (arg2, SCM_ARG2, "widget-text");
3705   SCM_ASSERT_BOOL (arg3, SCM_ARG3, "widget-text");
3706   SCM_ASSERT_STRING (arg4, SCM_ARG4, "widget-text");
3707
3708   string in1= scm_to_string (arg1);
3709   int in2= scm_to_int (arg2);
3710   bool in3= scm_to_bool (arg3);
3711   string in4= scm_to_string (arg4);
3712
3713   // SCM_DEFER_INTS;
3714   widget out= text_widget (in1, in2, in3, in4);
3715   // SCM_ALLOW_INTS;
3716
3717   return widget_to_scm (out);
3718 }
3719
3720 SCM
3721 tmg_widget_xpm (SCM arg1) {
3722   SCM_ASSERT_URL (arg1, SCM_ARG1, "widget-xpm");
3723
3724   url in1= scm_to_url (arg1);
3725
3726   // SCM_DEFER_INTS;
3727   widget out= xpm_widget (in1);
3728   // SCM_ALLOW_INTS;
3729
3730   return widget_to_scm (out);
3731 }
3732
3733 SCM
3734 tmg_widget_box (SCM arg1, SCM arg2, SCM arg3, SCM arg4, SCM arg5) {
3735   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "widget-box");
3736   SCM_ASSERT_STRING (arg2, SCM_ARG2, "widget-box");
3737   SCM_ASSERT_INT (arg3, SCM_ARG3, "widget-box");
3738   SCM_ASSERT_BOOL (arg4, SCM_ARG4, "widget-box");
3739   SCM_ASSERT_BOOL (arg5, SCM_ARG5, "widget-box");
3740
3741   scheme_tree in1= scm_to_scheme_tree (arg1);
3742   string in2= scm_to_string (arg2);
3743   int in3= scm_to_int (arg3);
3744   bool in4= scm_to_bool (arg4);
3745   bool in5= scm_to_bool (arg5);
3746
3747   // SCM_DEFER_INTS;
3748   widget out= box_widget (in1, in2, in3, in4, in5);
3749   // SCM_ALLOW_INTS;
3750
3751   return widget_to_scm (out);
3752 }
3753
3754 SCM
3755 tmg_object_2promise_widget (SCM arg1) {
3756   SCM_ASSERT_OBJECT (arg1, SCM_ARG1, "object->promise-widget");
3757
3758   object in1= scm_to_object (arg1);
3759
3760   // SCM_DEFER_INTS;
3761   promise_widget out= as_promise_widget (in1);
3762   // SCM_ALLOW_INTS;
3763
3764   return promise_widget_to_scm (out);
3765 }
3766
3767 SCM
3768 tmg_bib_add_period (SCM arg1) {
3769   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "bib-add-period");
3770
3771   scheme_tree in1= scm_to_scheme_tree (arg1);
3772
3773   // SCM_DEFER_INTS;
3774   scheme_tree out= bib_add_period (in1);
3775   // SCM_ALLOW_INTS;
3776
3777   return scheme_tree_to_scm (out);
3778 }
3779
3780 SCM
3781 tmg_bib_upcase_first (SCM arg1) {
3782   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "bib-upcase-first");
3783
3784   scheme_tree in1= scm_to_scheme_tree (arg1);
3785
3786   // SCM_DEFER_INTS;
3787   scheme_tree out= bib_upcase_first (in1);
3788   // SCM_ALLOW_INTS;
3789
3790   return scheme_tree_to_scm (out);
3791 }
3792
3793 SCM
3794 tmg_bib_locase (SCM arg1) {
3795   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "bib-locase");
3796
3797   scheme_tree in1= scm_to_scheme_tree (arg1);
3798
3799   // SCM_DEFER_INTS;
3800   scheme_tree out= bib_locase (in1);
3801   // SCM_ALLOW_INTS;
3802
3803   return scheme_tree_to_scm (out);
3804 }
3805
3806 SCM
3807 tmg_bib_upcase (SCM arg1) {
3808   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "bib-upcase");
3809
3810   scheme_tree in1= scm_to_scheme_tree (arg1);
3811
3812   // SCM_DEFER_INTS;
3813   scheme_tree out= bib_upcase (in1);
3814   // SCM_ALLOW_INTS;
3815
3816   return scheme_tree_to_scm (out);
3817 }
3818
3819 SCM
3820 tmg_bib_default (SCM arg1) {
3821   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "bib-default");
3822
3823   scheme_tree in1= scm_to_scheme_tree (arg1);
3824
3825   // SCM_DEFER_INTS;
3826   scheme_tree out= bib_default (in1);
3827   // SCM_ALLOW_INTS;
3828
3829   return scheme_tree_to_scm (out);
3830 }
3831
3832 SCM
3833 tmg_bib_purify (SCM arg1) {
3834   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "bib-purify");
3835
3836   scheme_tree in1= scm_to_scheme_tree (arg1);
3837
3838   // SCM_DEFER_INTS;
3839   string out= bib_purify (in1);
3840   // SCM_ALLOW_INTS;
3841
3842   return string_to_scm (out);
3843 }
3844
3845 SCM
3846 tmg_bib_text_length (SCM arg1) {
3847   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "bib-text-length");
3848
3849   scheme_tree in1= scm_to_scheme_tree (arg1);
3850
3851   // SCM_DEFER_INTS;
3852   int out= bib_text_length (in1);
3853   // SCM_ALLOW_INTS;
3854
3855   return int_to_scm (out);
3856 }
3857
3858 SCM
3859 tmg_bib_prefix (SCM arg1, SCM arg2) {
3860   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "bib-prefix");
3861   SCM_ASSERT_INT (arg2, SCM_ARG2, "bib-prefix");
3862
3863   scheme_tree in1= scm_to_scheme_tree (arg1);
3864   int in2= scm_to_int (arg2);
3865
3866   // SCM_DEFER_INTS;
3867   string out= bib_prefix (in1, in2);
3868   // SCM_ALLOW_INTS;
3869
3870   return string_to_scm (out);
3871 }
3872
3873 SCM
3874 tmg_bib_emptyP (SCM arg1, SCM arg2) {
3875   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "bib-empty?");
3876   SCM_ASSERT_STRING (arg2, SCM_ARG2, "bib-empty?");
3877
3878   scheme_tree in1= scm_to_scheme_tree (arg1);
3879   string in2= scm_to_string (arg2);
3880
3881   // SCM_DEFER_INTS;
3882   bool out= bib_empty (in1, in2);
3883   // SCM_ALLOW_INTS;
3884
3885   return bool_to_scm (out);
3886 }
3887
3888 SCM
3889 tmg_bib_field (SCM arg1, SCM arg2) {
3890   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "bib-field");
3891   SCM_ASSERT_STRING (arg2, SCM_ARG2, "bib-field");
3892
3893   scheme_tree in1= scm_to_scheme_tree (arg1);
3894   string in2= scm_to_string (arg2);
3895
3896   // SCM_DEFER_INTS;
3897   scheme_tree out= bib_field (in1, in2);
3898   // SCM_ALLOW_INTS;
3899
3900   return scheme_tree_to_scm (out);
3901 }
3902
3903 SCM
3904 tmg_bib_abbreviate (SCM arg1, SCM arg2, SCM arg3) {
3905   SCM_ASSERT_SCHEME_TREE (arg1, SCM_ARG1, "bib-abbreviate");
3906   SCM_ASSERT_SCHEME_TREE (arg2, SCM_ARG2, "bib-abbreviate");
3907   SCM_ASSERT_SCHEME_TREE (arg3, SCM_ARG3, "bib-abbreviate");
3908
3909   scheme_tree in1= scm_to_scheme_tree (arg1);
3910   scheme_tree in2= scm_to_scheme_tree (arg2);
3911   scheme_tree in3= scm_to_scheme_tree (arg3);
3912
3913   // SCM_DEFER_INTS;
3914   scheme_tree out= bib_abbreviate (in1, in2, in3);
3915   // SCM_ALLOW_INTS;
3916
3917   return scheme_tree_to_scm (out);
3918 }
3919
3920 void
3921 initialize_glue_basic () {
3922   scm_new_procedure ("texmacs-version-release", (FN) tmg_texmacs_version_release, 1, 0, 0);
3923   scm_new_procedure ("version-before?", (FN) tmg_version_beforeP, 2, 0, 0);
3924   scm_new_procedure ("os-win32?", (FN) tmg_os_win32P, 0, 0, 0);
3925   scm_new_procedure ("os-mingw?", (FN) tmg_os_mingwP, 0, 0, 0);
3926   scm_new_procedure ("os-macos?", (FN) tmg_os_macosP, 0, 0, 0);
3927   scm_new_procedure ("x-gui?", (FN) tmg_x_guiP, 0, 0, 0);
3928   scm_new_procedure ("qt-gui?", (FN) tmg_qt_guiP, 0, 0, 0);
3929   scm_new_procedure ("tm-output", (FN) tmg_tm_output, 1, 0, 0);
3930   scm_new_procedure ("tm-errput", (FN) tmg_tm_errput, 1, 0, 0);
3931   scm_new_procedure ("win32-display", (FN) tmg_win32_display, 1, 0, 0);
3932   scm_new_procedure ("scheme-dialect", (FN) tmg_scheme_dialect, 0, 0, 0);
3933   scm_new_procedure ("get-texmacs-path", (FN) tmg_get_texmacs_path, 0, 0, 0);
3934   scm_new_procedure ("plugin-list", (FN) tmg_plugin_list, 0, 0, 0);
3935   scm_new_procedure ("get-font-type", (FN) tmg_get_font_type, 0, 0, 0);
3936   scm_new_procedure ("set-font-type", (FN) tmg_set_font_type, 1, 0, 0);
3937   scm_new_procedure ("font-exists-in-tt?", (FN) tmg_font_exists_in_ttP, 1, 0, 0);
3938   scm_new_procedure ("eval-system", (FN) tmg_eval_system, 1, 0, 0);
3939   scm_new_procedure ("var-eval-system", (FN) tmg_var_eval_system, 1, 0, 0);
3940   scm_new_procedure ("get-locale-language", (FN) tmg_get_locale_language, 0, 0, 0);
3941   scm_new_procedure ("texmacs-time", (FN) tmg_texmacs_time, 0, 0, 0);
3942   scm_new_procedure ("texmacs-memory", (FN) tmg_texmacs_memory, 0, 0, 0);
3943   scm_new_procedure ("bench-print", (FN) tmg_bench_print, 1, 0, 0);
3944   scm_new_procedure ("bench-print-all", (FN) tmg_bench_print_all, 0, 0, 0);
3945   scm_new_procedure ("system-wait", (FN) tmg_system_wait, 2, 0, 0);
3946   scm_new_procedure ("set-bibtex-command", (FN) tmg_set_bibtex_command, 1, 0, 0);
3947   scm_new_procedure ("math-symbol-group", (FN) tmg_math_symbol_group, 1, 0, 0);
3948   scm_new_procedure ("math-group-members", (FN) tmg_math_group_members, 1, 0, 0);
3949   scm_new_procedure ("math-symbol-type", (FN) tmg_math_symbol_type, 1, 0, 0);
3950   scm_new_procedure ("object->command", (FN) tmg_object_2command, 1, 0, 0);
3951   scm_new_procedure ("exec-delayed", (FN) tmg_exec_delayed, 1, 0, 0);
3952   scm_new_procedure ("exec-delayed-pause", (FN) tmg_exec_delayed_pause, 1, 0, 0);
3953   scm_new_procedure ("set-input-language", (FN) tmg_set_input_language, 1, 0, 0);
3954   scm_new_procedure ("get-input-language", (FN) tmg_get_input_language, 0, 0, 0);
3955   scm_new_procedure ("set-output-language", (FN) tmg_set_output_language, 1, 0, 0);
3956   scm_new_procedure ("get-output-language", (FN) tmg_get_output_language, 0, 0, 0);
3957   scm_new_procedure ("translate", (FN) tmg_translate, 3, 0, 0);
3958   scm_new_procedure ("color", (FN) tmg_color, 1, 0, 0);
3959   scm_new_procedure ("new-author", (FN) tmg_new_author, 0, 0, 0);
3960   scm_new_procedure ("set-author", (FN) tmg_set_author, 1, 0, 0);
3961   scm_new_procedure ("get-author", (FN) tmg_get_author, 0, 0, 0);
3962   scm_new_procedure ("debug-set", (FN) tmg_debug_set, 2, 0, 0);
3963   scm_new_procedure ("debug-get", (FN) tmg_debug_get, 1, 0, 0);
3964   scm_new_procedure ("cout-buffer", (FN) tmg_cout_buffer, 0, 0, 0);
3965   scm_new_procedure ("cout-unbuffer", (FN) tmg_cout_unbuffer, 0, 0, 0);
3966   scm_new_procedure ("image->psdoc", (FN) tmg_image_2psdoc, 1, 0, 0);
3967   scm_new_procedure ("tree->stree", (FN) tmg_tree_2stree, 1, 0, 0);
3968   scm_new_procedure ("stree->tree", (FN) tmg_stree_2tree, 1, 0, 0);
3969   scm_new_procedure ("tree->string", (FN) tmg_tree_2string, 1, 0, 0);
3970   scm_new_procedure ("string->tree", (FN) tmg_string_2tree, 1, 0, 0);
3971   scm_new_procedure ("tm->tree", (FN) tmg_tm_2tree, 1, 0, 0);
3972   scm_new_procedure ("tree-atomic?", (FN) tmg_tree_atomicP, 1, 0, 0);
3973   scm_new_procedure ("tree-compound?", (FN) tmg_tree_compoundP, 1, 0, 0);
3974   scm_new_procedure ("tree-label", (FN) tmg_tree_label, 1, 0, 0);
3975   scm_new_procedure ("tree-children", (FN) tmg_tree_children, 1, 0, 0);
3976   scm_new_procedure ("tree-arity", (FN) tmg_tree_arity, 1, 0, 0);
3977   scm_new_procedure ("tree-child-ref", (FN) tmg_tree_child_ref, 2, 0, 0);
3978   scm_new_procedure ("tree-child-set!", (FN) tmg_tree_child_setS, 3, 0, 0);
3979   scm_new_procedure ("tree-child-insert", (FN) tmg_tree_child_insert, 3, 0, 0);
3980   scm_new_procedure ("tree-ip", (FN) tmg_tree_ip, 1, 0, 0);
3981   scm_new_procedure ("tree-active?", (FN) tmg_tree_activeP, 1, 0, 0);
3982   scm_new_procedure ("tree-eq?", (FN) tmg_tree_eqP, 2, 0, 0);
3983   scm_new_procedure ("subtree", (FN) tmg_subtree, 2, 0, 0);
3984   scm_new_procedure ("tree-range", (FN) tmg_tree_range, 3, 0, 0);
3985   scm_new_procedure ("tree-copy", (FN) tmg_tree_copy, 1, 0, 0);
3986   scm_new_procedure ("tree-append", (FN) tmg_tree_append, 2, 0, 0);
3987   scm_new_procedure ("tree-right-index", (FN) tmg_tree_right_index, 1, 0, 0);
3988   scm_new_procedure ("tree-label-extension?", (FN) tmg_tree_label_extensionP, 1, 0, 0);
3989   scm_new_procedure ("tree-multi-paragraph?", (FN) tmg_tree_multi_paragraphP, 1, 0, 0);
3990   scm_new_procedure ("tree-simplify", (FN) tmg_tree_simplify, 1, 0, 0);
3991   scm_new_procedure ("tree-accessible-child?", (FN) tmg_tree_accessible_childP, 2, 0, 0);
3992   scm_new_procedure ("tree-accessible-children", (FN) tmg_tree_accessible_children, 1, 0, 0);
3993   scm_new_procedure ("tree-load-inclusion", (FN) tmg_tree_load_inclusion, 1, 0, 0);
3994   scm_new_procedure ("tree-as-string", (FN) tmg_tree_as_string, 1, 0, 0);
3995   scm_new_procedure ("tree-extents", (FN) tmg_tree_extents, 1, 0, 0);
3996   scm_new_procedure ("tree-empty?", (FN) tmg_tree_emptyP, 1, 0, 0);
3997   scm_new_procedure ("tree-assign", (FN) tmg_tree_assign, 2, 0, 0);
3998   scm_new_procedure ("tree-var-insert", (FN) tmg_tree_var_insert, 3, 0, 0);
3999   scm_new_procedure ("tree-remove", (FN) tmg_tree_remove, 3, 0, 0);
4000   scm_new_procedure ("tree-split", (FN) tmg_tree_split, 3, 0, 0);
4001   scm_new_procedure ("tree-join", (FN) tmg_tree_join, 2, 0, 0);
4002   scm_new_procedure ("tree-assign-node", (FN) tmg_tree_assign_node, 2, 0, 0);
4003   scm_new_procedure ("tree-insert-node", (FN) tmg_tree_insert_node, 3, 0, 0);
4004   scm_new_procedure ("tree-remove-node", (FN) tmg_tree_remove_node, 2, 0, 0);
4005   scm_new_procedure ("path-inf?", (FN) tmg_path_infP, 2, 0, 0);
4006   scm_new_procedure ("path-inf-eq?", (FN) tmg_path_inf_eqP, 2, 0, 0);
4007   scm_new_procedure ("path-less?", (FN) tmg_path_lessP, 2, 0, 0);
4008   scm_new_procedure ("path-less-eq?", (FN) tmg_path_less_eqP, 2, 0, 0);
4009   scm_new_procedure ("path-start", (FN) tmg_path_start, 2, 0, 0);
4010   scm_new_procedure ("path-end", (FN) tmg_path_end, 2, 0, 0);
4011   scm_new_procedure ("path-next", (FN) tmg_path_next, 2, 0, 0);
4012   scm_new_procedure ("path-previous", (FN) tmg_path_previous, 2, 0, 0);
4013   scm_new_procedure ("path-next-word", (FN) tmg_path_next_word, 2, 0, 0);
4014   scm_new_procedure ("path-previous-word", (FN) tmg_path_previous_word, 2, 0, 0);
4015   scm_new_procedure ("path-next-node", (FN) tmg_path_next_node, 2, 0, 0);
4016   scm_new_procedure ("path-previous-node", (FN) tmg_path_previous_node, 2, 0, 0);
4017   scm_new_procedure ("path-next-tag", (FN) tmg_path_next_tag, 3, 0, 0);
4018   scm_new_procedure ("path-previous-tag", (FN) tmg_path_previous_tag, 3, 0, 0);
4019   scm_new_procedure ("path-next-tag-same-argument", (FN) tmg_path_next_tag_same_argument, 3, 0, 0);
4020   scm_new_procedure ("path-previous-tag-same-argument", (FN) tmg_path_previous_tag_same_argument, 3, 0, 0);
4021   scm_new_procedure ("path-next-argument", (FN) tmg_path_next_argument, 2, 0, 0);
4022   scm_new_procedure ("path-previous-argument", (FN) tmg_path_previous_argument, 2, 0, 0);
4023   scm_new_procedure ("tree->ids", (FN) tmg_tree_2ids, 1, 0, 0);
4024   scm_new_procedure ("id->trees", (FN) tmg_id_2trees, 1, 0, 0);
4025   scm_new_procedure ("vertex->links", (FN) tmg_vertex_2links, 1, 0, 0);
4026   scm_new_procedure ("tree->tree-pointer", (FN) tmg_tree_2tree_pointer, 1, 0, 0);
4027   scm_new_procedure ("tree-pointer-detach", (FN) tmg_tree_pointer_detach, 1, 0, 0);
4028   scm_new_procedure ("tree-pointer->tree", (FN) tmg_tree_pointer_2tree, 1, 0, 0);
4029   scm_new_procedure ("current-link-types", (FN) tmg_current_link_types, 0, 0, 0);
4030   scm_new_procedure ("get-locus-rendering", (FN) tmg_get_locus_rendering, 1, 0, 0);
4031   scm_new_procedure ("set-locus-rendering", (FN) tmg_set_locus_rendering, 2, 0, 0);
4032   scm_new_procedure ("declare-visited", (FN) tmg_declare_visited, 1, 0, 0);
4033   scm_new_procedure ("has-been-visited?", (FN) tmg_has_been_visitedP, 1, 0, 0);
4034   scm_new_procedure ("string-number?", (FN) tmg_string_numberP, 1, 0, 0);
4035   scm_new_procedure ("string-search-forwards", (FN) tmg_string_search_forwards, 3, 0, 0);
4036   scm_new_procedure ("string-search-backwards", (FN) tmg_string_search_backwards, 3, 0, 0);
4037   scm_new_procedure ("string-replace", (FN) tmg_string_replace, 3, 0, 0);
4038   scm_new_procedure ("string-locase-alpha?", (FN) tmg_string_locase_alphaP, 1, 0, 0);
4039   scm_new_procedure ("upcase-first", (FN) tmg_upcase_first, 1, 0, 0);
4040   scm_new_procedure ("locase-first", (FN) tmg_locase_first, 1, 0, 0);
4041   scm_new_procedure ("upcase-all", (FN) tmg_upcase_all, 1, 0, 0);
4042   scm_new_procedure ("locase-all", (FN) tmg_locase_all, 1, 0, 0);
4043   scm_new_procedure ("string-union", (FN) tmg_string_union, 2, 0, 0);
4044   scm_new_procedure ("string-minus", (FN) tmg_string_minus, 2, 0, 0);
4045   scm_new_procedure ("string-encode", (FN) tmg_string_encode, 1, 0, 0);
4046   scm_new_procedure ("string-decode", (FN) tmg_string_decode, 1, 0, 0);
4047   scm_new_procedure ("escape-generic", (FN) tmg_escape_generic, 1, 0, 0);
4048   scm_new_procedure ("escape-verbatim", (FN) tmg_escape_verbatim, 1, 0, 0);
4049   scm_new_procedure ("escape-shell", (FN) tmg_escape_shell, 1, 0, 0);
4050   scm_new_procedure ("string-convert", (FN) tmg_string_convert, 3, 0, 0);
4051   scm_new_procedure ("utf8->cork", (FN) tmg_utf8_2cork, 1, 0, 0);
4052   scm_new_procedure ("cork->utf8", (FN) tmg_cork_2utf8, 1, 0, 0);
4053   scm_new_procedure ("utf8->html", (FN) tmg_utf8_2html, 1, 0, 0);
4054   scm_new_procedure ("tm->xml-name", (FN) tmg_tm_2xml_name, 1, 0, 0);
4055   scm_new_procedure ("old-tm->xml-cdata", (FN) tmg_old_tm_2xml_cdata, 1, 0, 0);
4056   scm_new_procedure ("tm->xml-cdata", (FN) tmg_tm_2xml_cdata, 1, 0, 0);
4057   scm_new_procedure ("xml-name->tm", (FN) tmg_xml_name_2tm, 1, 0, 0);
4058   scm_new_procedure ("old-xml-cdata->tm", (FN) tmg_old_xml_cdata_2tm, 1, 0, 0);
4059   scm_new_procedure ("xml-unspace", (FN) tmg_xml_unspace, 3, 0, 0);
4060   scm_new_procedure ("define-grammar-rule", (FN) tmg_define_grammar_rule, 2, 0, 0);
4061   scm_new_procedure ("grammar-parse", (FN) tmg_grammar_parse, 2, 0, 0);
4062   scm_new_procedure ("parse-texmacs", (FN) tmg_parse_texmacs, 1, 0, 0);
4063   scm_new_procedure ("serialize-texmacs", (FN) tmg_serialize_texmacs, 1, 0, 0);
4064   scm_new_procedure ("parse-texmacs-snippet", (FN) tmg_parse_texmacs_snippet, 1, 0, 0);
4065   scm_new_procedure ("serialize-texmacs-snippet", (FN) tmg_serialize_texmacs_snippet, 1, 0, 0);
4066   scm_new_procedure ("texmacs->stm", (FN) tmg_texmacs_2stm, 1, 0, 0);
4067   scm_new_procedure ("stm->texmacs", (FN) tmg_stm_2texmacs, 1, 0, 0);
4068   scm_new_procedure ("stm-snippet->texmacs", (FN) tmg_stm_snippet_2texmacs, 1, 0, 0);
4069   scm_new_procedure ("cpp-texmacs->verbatim", (FN) tmg_cpp_texmacs_2verbatim, 3, 0, 0);
4070   scm_new_procedure ("cpp-verbatim-snippet->texmacs", (FN) tmg_cpp_verbatim_snippet_2texmacs, 3, 0, 0);
4071   scm_new_procedure ("cpp-verbatim->texmacs", (FN) tmg_cpp_verbatim_2texmacs, 3, 0, 0);
4072   scm_new_procedure ("parse-latex", (FN) tmg_parse_latex, 1, 0, 0);
4073   scm_new_procedure ("parse-latex-document", (FN) tmg_parse_latex_document, 1, 0, 0);
4074   scm_new_procedure ("latex->texmacs", (FN) tmg_latex_2texmacs, 1, 0, 0);
4075   scm_new_procedure ("parse-xml", (FN) tmg_parse_xml, 1, 0, 0);
4076   scm_new_procedure ("parse-html", (FN) tmg_parse_html, 1, 0, 0);
4077   scm_new_procedure ("parse-bib", (FN) tmg_parse_bib, 1, 0, 0);
4078   scm_new_procedure ("upgrade-tmml", (FN) tmg_upgrade_tmml, 1, 0, 0);
4079   scm_new_procedure ("string->url", (FN) tmg_string_2url, 1, 0, 0);
4080   scm_new_procedure ("url", (FN) tmg_url, 2, 0, 0);
4081   scm_new_procedure ("url-system", (FN) tmg_url_system, 1, 0, 0);
4082   scm_new_procedure ("url-none", (FN) tmg_url_none, 0, 0, 0);
4083   scm_new_procedure ("url-any", (FN) tmg_url_any, 0, 0, 0);
4084   scm_new_procedure ("url-wildcard", (FN) tmg_url_wildcard, 1, 0, 0);
4085   scm_new_procedure ("url-parent", (FN) tmg_url_parent, 0, 0, 0);
4086   scm_new_procedure ("url-append", (FN) tmg_url_append, 2, 0, 0);
4087   scm_new_procedure ("url-or", (FN) tmg_url_or, 2, 0, 0);
4088   scm_new_procedure ("url->string", (FN) tmg_url_2string, 1, 0, 0);
4089   scm_new_procedure ("url-none?", (FN) tmg_url_noneP, 1, 0, 0);
4090   scm_new_procedure ("url-rooted-web?", (FN) tmg_url_rooted_webP, 1, 0, 0);
4091   scm_new_procedure ("url-concat?", (FN) tmg_url_concatP, 1, 0, 0);
4092   scm_new_procedure ("url-or?", (FN) tmg_url_orP, 1, 0, 0);
4093   scm_new_procedure ("url-ref", (FN) tmg_url_ref, 2, 0, 0);
4094   scm_new_procedure ("url-tail", (FN) tmg_url_tail, 1, 0, 0);
4095   scm_new_procedure ("url-suffix", (FN) tmg_url_suffix, 1, 0, 0);
4096   scm_new_procedure ("url-glue", (FN) tmg_url_glue, 2, 0, 0);
4097   scm_new_procedure ("url-unglue", (FN) tmg_url_unglue, 2, 0, 0);
4098   scm_new_procedure ("url-relative", (FN) tmg_url_relative, 2, 0, 0);
4099   scm_new_procedure ("url-expand", (FN) tmg_url_expand, 1, 0, 0);
4100   scm_new_procedure ("url-factor", (FN) tmg_url_factor, 1, 0, 0);
4101   scm_new_procedure ("url-delta", (FN) tmg_url_delta, 2, 0, 0);
4102   scm_new_procedure ("url-secure?", (FN) tmg_url_secureP, 1, 0, 0);
4103   scm_new_procedure ("url-descends?", (FN) tmg_url_descendsP, 2, 0, 0);
4104   scm_new_procedure ("url-complete", (FN) tmg_url_complete, 2, 0, 0);
4105   scm_new_procedure ("url-resolve", (FN) tmg_url_resolve, 2, 0, 0);
4106   scm_new_procedure ("url-resolve-in-path", (FN) tmg_url_resolve_in_path, 1, 0, 0);
4107   scm_new_procedure ("url-exists?", (FN) tmg_url_existsP, 1, 0, 0);
4108   scm_new_procedure ("url-exists-in-path?", (FN) tmg_url_exists_in_pathP, 1, 0, 0);
4109   scm_new_procedure ("url-exists-in-tex?", (FN) tmg_url_exists_in_texP, 1, 0, 0);
4110   scm_new_procedure ("url-concretize", (FN) tmg_url_concretize, 1, 0, 0);
4111   scm_new_procedure ("url-materialize", (FN) tmg_url_materialize, 2, 0, 0);
4112   scm_new_procedure ("url-test?", (FN) tmg_url_testP, 2, 0, 0);
4113   scm_new_procedure ("url-regular?", (FN) tmg_url_regularP, 1, 0, 0);
4114   scm_new_procedure ("url-directory?", (FN) tmg_url_directoryP, 1, 0, 0);
4115   scm_new_procedure ("url-link?", (FN) tmg_url_linkP, 1, 0, 0);
4116   scm_new_procedure ("url-newer?", (FN) tmg_url_newerP, 2, 0, 0);
4117   scm_new_procedure ("url-last-modified", (FN) tmg_url_last_modified, 1, 0, 0);
4118   scm_new_procedure ("url-temp", (FN) tmg_url_temp, 0, 0, 0);
4119   scm_new_procedure ("url-scratch", (FN) tmg_url_scratch, 3, 0, 0);
4120   scm_new_procedure ("url-scratch?", (FN) tmg_url_scratchP, 1, 0, 0);
4121   scm_new_procedure ("string-save", (FN) tmg_string_save, 2, 0, 0);
4122   scm_new_procedure ("string-load", (FN) tmg_string_load, 1, 0, 0);
4123   scm_new_procedure ("system-move", (FN) tmg_system_move, 2, 0, 0);
4124   scm_new_procedure ("system-copy", (FN) tmg_system_copy, 2, 0, 0);
4125   scm_new_procedure ("system-remove", (FN) tmg_system_remove, 1, 0, 0);
4126   scm_new_procedure ("system-mkdir", (FN) tmg_system_mkdir, 1, 0, 0);
4127   scm_new_procedure ("system-search-score", (FN) tmg_system_search_score, 2, 0, 0);
4128   scm_new_procedure ("system-1", (FN) tmg_system_1, 2, 0, 0);
4129   scm_new_procedure ("system-2", (FN) tmg_system_2, 3, 0, 0);
4130   scm_new_procedure ("tmfs-set", (FN) tmg_tmfs_set, 2, 0, 0);
4131   scm_new_procedure ("tmfs-reset", (FN) tmg_tmfs_reset, 2, 0, 0);
4132   scm_new_procedure ("tmfs-get", (FN) tmg_tmfs_get, 1, 0, 0);
4133   scm_new_procedure ("tmfs-new-save", (FN) tmg_tmfs_new_save, 2, 0, 0);
4134   scm_new_procedure ("tmfs-new-remove", (FN) tmg_tmfs_new_remove, 1, 0, 0);
4135   scm_new_procedure ("tmfs-new-load", (FN) tmg_tmfs_new_load, 1, 0, 0);
4136   scm_new_procedure ("tmfs-create-ressource", (FN) tmg_tmfs_create_ressource, 0, 0, 0);
4137   scm_new_procedure ("tmfs-ressource-head", (FN) tmg_tmfs_ressource_head, 1, 0, 0);
4138   scm_new_procedure ("tmfs-ressource-versions", (FN) tmg_tmfs_ressource_versions, 1, 0, 0);
4139   scm_new_procedure ("tmfs-save-ressource", (FN) tmg_tmfs_save_ressource, 3, 0, 0);
4140   scm_new_procedure ("tmfs-load-ressource-file", (FN) tmg_tmfs_load_ressource_file, 1, 0, 0);
4141   scm_new_procedure ("tmfs-load-ressource-properties", (FN) tmg_tmfs_load_ressource_properties, 1, 0, 0);
4142   scm_new_procedure ("tmfs-create-user", (FN) tmg_tmfs_create_user, 1, 0, 0);
4143   scm_new_procedure ("tmfs-search-user", (FN) tmg_tmfs_search_user, 1, 0, 0);
4144   scm_new_procedure ("tmfs-set-user", (FN) tmg_tmfs_set_user, 1, 0, 0);
4145   scm_new_procedure ("tmfs-get-user", (FN) tmg_tmfs_get_user, 0, 0, 0);
4146   scm_new_procedure ("tmfs-allows?", (FN) tmg_tmfs_allowsP, 2, 0, 0);
4147   scm_new_procedure ("tmfs-set-attributes", (FN) tmg_tmfs_set_attributes, 2, 0, 0);
4148   scm_new_procedure ("tmfs-get-attributes", (FN) tmg_tmfs_get_attributes, 1, 0, 0);
4149   scm_new_procedure ("tmfs-add-attributes", (FN) tmg_tmfs_add_attributes, 2, 0, 0);
4150   scm_new_procedure ("tmfs-remove-attributes", (FN) tmg_tmfs_remove_attributes, 2, 0, 0);
4151   scm_new_procedure ("tmfs-change-attributes", (FN) tmg_tmfs_change_attributes, 2, 0, 0);
4152   scm_new_procedure ("tmfs-query", (FN) tmg_tmfs_query, 1, 0, 0);
4153   scm_new_procedure ("solutions->collection", (FN) tmg_solutions_2collection, 2, 0, 0);
4154   scm_new_procedure ("tmfs-create-file", (FN) tmg_tmfs_create_file, 2, 0, 0);
4155   scm_new_procedure ("tmfs-create-file-in", (FN) tmg_tmfs_create_file_in, 3, 0, 0);
4156   scm_new_procedure ("tmfs-search-file", (FN) tmg_tmfs_search_file, 1, 0, 0);
4157   scm_new_procedure ("tmfs-save-file", (FN) tmg_tmfs_save_file, 2, 0, 0);
4158   scm_new_procedure ("tmfs-load-file", (FN) tmg_tmfs_load_file, 1, 0, 0);
4159   scm_new_procedure ("tmfs-create-project", (FN) tmg_tmfs_create_project, 1, 0, 0);
4160   scm_new_procedure ("tmfs-search-project", (FN) tmg_tmfs_search_project, 1, 0, 0);
4161   scm_new_procedure ("tmfs-get-file-projects", (FN) tmg_tmfs_get_file_projects, 1, 0, 0);
4162   scm_new_procedure ("tmfs-get-project-files", (FN) tmg_tmfs_get_project_files, 1, 0, 0);
4163   scm_new_procedure ("tmfs-create-branch", (FN) tmg_tmfs_create_branch, 2, 0, 0);
4164   scm_new_procedure ("tmfs-set-root", (FN) tmg_tmfs_set_root, 2, 0, 0);
4165   scm_new_procedure ("tmfs-get-root", (FN) tmg_tmfs_get_root, 1, 0, 0);
4166   scm_new_procedure ("tmfs-import", (FN) tmg_tmfs_import, 1, 0, 0);
4167   scm_new_procedure ("tmfs-export", (FN) tmg_tmfs_export, 1, 0, 0);
4168   scm_new_procedure ("server-start", (FN) tmg_server_start, 0, 0, 0);
4169   scm_new_procedure ("server-stop", (FN) tmg_server_stop, 0, 0, 0);
4170   scm_new_procedure ("server-read", (FN) tmg_server_read, 1, 0, 0);
4171   scm_new_procedure ("server-write", (FN) tmg_server_write, 2, 0, 0);
4172   scm_new_procedure ("client-start", (FN) tmg_client_start, 1, 0, 0);
4173   scm_new_procedure ("client-stop", (FN) tmg_client_stop, 0, 0, 0);
4174   scm_new_procedure ("client-read", (FN) tmg_client_read, 0, 0, 0);
4175   scm_new_procedure ("client-write", (FN) tmg_client_write, 1, 0, 0);
4176   scm_new_procedure ("enter-secure-mode", (FN) tmg_enter_secure_mode, 0, 0, 0);
4177   scm_new_procedure ("connection-start", (FN) tmg_connection_start, 2, 0, 0);
4178   scm_new_procedure ("connection-status", (FN) tmg_connection_status, 2, 0, 0);
4179   scm_new_procedure ("connection-write-string", (FN) tmg_connection_write_string, 3, 0, 0);
4180   scm_new_procedure ("connection-write", (FN) tmg_connection_write, 3, 0, 0);
4181   scm_new_procedure ("connection-cmd", (FN) tmg_connection_cmd, 3, 0, 0);
4182   scm_new_procedure ("connection-eval", (FN) tmg_connection_eval, 3, 0, 0);
4183   scm_new_procedure ("connection-interrupt", (FN) tmg_connection_interrupt, 2, 0, 0);
4184   scm_new_procedure ("connection-stop", (FN) tmg_connection_stop, 2, 0, 0);
4185   scm_new_procedure ("widget-hmenu", (FN) tmg_widget_hmenu, 1, 0, 0);
4186   scm_new_procedure ("widget-vmenu", (FN) tmg_widget_vmenu, 1, 0, 0);
4187   scm_new_procedure ("widget-tmenu", (FN) tmg_widget_tmenu, 2, 0, 0);
4188   scm_new_procedure ("widget-separator", (FN) tmg_widget_separator, 1, 0, 0);
4189   scm_new_procedure ("widget-menu-group", (FN) tmg_widget_menu_group, 2, 0, 0);
4190   scm_new_procedure ("widget-pulldown-button", (FN) tmg_widget_pulldown_button, 2, 0, 0);
4191   scm_new_procedure ("widget-pullright-button", (FN) tmg_widget_pullright_button, 2, 0, 0);
4192   scm_new_procedure ("widget-menu-button", (FN) tmg_widget_menu_button, 5, 0, 0);
4193   scm_new_procedure ("widget-balloon", (FN) tmg_widget_balloon, 2, 0, 0);
4194   scm_new_procedure ("widget-empty", (FN) tmg_widget_empty, 0, 0, 0);
4195   scm_new_procedure ("widget-text", (FN) tmg_widget_text, 4, 0, 0);
4196   scm_new_procedure ("widget-xpm", (FN) tmg_widget_xpm, 1, 0, 0);
4197   scm_new_procedure ("widget-box", (FN) tmg_widget_box, 5, 0, 0);
4198   scm_new_procedure ("object->promise-widget", (FN) tmg_object_2promise_widget, 1, 0, 0);
4199   scm_new_procedure ("bib-add-period", (FN) tmg_bib_add_period, 1, 0, 0);
4200   scm_new_procedure ("bib-upcase-first", (FN) tmg_bib_upcase_first, 1, 0, 0);
4201   scm_new_procedure ("bib-locase", (FN) tmg_bib_locase, 1, 0, 0);
4202   scm_new_procedure ("bib-upcase", (FN) tmg_bib_upcase, 1, 0, 0);
4203   scm_new_procedure ("bib-default", (FN) tmg_bib_default, 1, 0, 0);
4204   scm_new_procedure ("bib-purify", (FN) tmg_bib_purify, 1, 0, 0);
4205   scm_new_procedure ("bib-text-length", (FN) tmg_bib_text_length, 1, 0, 0);
4206   scm_new_procedure ("bib-prefix", (FN) tmg_bib_prefix, 2, 0, 0);
4207   scm_new_procedure ("bib-empty?", (FN) tmg_bib_emptyP, 2, 0, 0);
4208   scm_new_procedure ("bib-field", (FN) tmg_bib_field, 2, 0, 0);
4209   scm_new_procedure ("bib-abbreviate", (FN) tmg_bib_abbreviate, 3, 0, 0);
4210 }