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