Back to index

texmacs  1.0.7.15
glue_basic.cpp
Go to the documentation of this file.
00001 
00002 /******************************************************************************
00003 *
00004 * This file has been generated automatically using build-glue.scm
00005 * from build-glue-basic.scm. Please do not edit its contents.
00006 * Copyright (C) 2000 Joris van der Hoeven
00007 *
00008 * This software falls under the GNU general public license version 3 or later.
00009 * It comes WITHOUT ANY WARRANTY WHATSOEVER. For details, see the file LICENSE
00010 * in the root directory or <http://www.gnu.org/licenses/gpl-3.0.html>.
00011 *
00012 ******************************************************************************/
00013 
00014 tmscm
00015 tmg_texmacs_version_release (tmscm arg1) {
00016   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "texmacs-version-release");
00017 
00018   string in1= tmscm_to_string (arg1);
00019 
00020   // TMSCM_DEFER_INTS;
00021   string out= texmacs_version (in1);
00022   // TMSCM_ALLOW_INTS;
00023 
00024   return string_to_tmscm (out);
00025 }
00026 
00027 tmscm
00028 tmg_version_beforeP (tmscm arg1, tmscm arg2) {
00029   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "version-before?");
00030   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "version-before?");
00031 
00032   string in1= tmscm_to_string (arg1);
00033   string in2= tmscm_to_string (arg2);
00034 
00035   // TMSCM_DEFER_INTS;
00036   bool out= version_inf (in1, in2);
00037   // TMSCM_ALLOW_INTS;
00038 
00039   return bool_to_tmscm (out);
00040 }
00041 
00042 tmscm
00043 tmg_os_win32P () {
00044   // TMSCM_DEFER_INTS;
00045   bool out= os_win32 ();
00046   // TMSCM_ALLOW_INTS;
00047 
00048   return bool_to_tmscm (out);
00049 }
00050 
00051 tmscm
00052 tmg_os_mingwP () {
00053   // TMSCM_DEFER_INTS;
00054   bool out= os_mingw ();
00055   // TMSCM_ALLOW_INTS;
00056 
00057   return bool_to_tmscm (out);
00058 }
00059 
00060 tmscm
00061 tmg_os_macosP () {
00062   // TMSCM_DEFER_INTS;
00063   bool out= os_macos ();
00064   // TMSCM_ALLOW_INTS;
00065 
00066   return bool_to_tmscm (out);
00067 }
00068 
00069 tmscm
00070 tmg_x_guiP () {
00071   // TMSCM_DEFER_INTS;
00072   bool out= gui_is_x ();
00073   // TMSCM_ALLOW_INTS;
00074 
00075   return bool_to_tmscm (out);
00076 }
00077 
00078 tmscm
00079 tmg_qt_guiP () {
00080   // TMSCM_DEFER_INTS;
00081   bool out= gui_is_qt ();
00082   // TMSCM_ALLOW_INTS;
00083 
00084   return bool_to_tmscm (out);
00085 }
00086 
00087 tmscm
00088 tmg_default_look_and_feel () {
00089   // TMSCM_DEFER_INTS;
00090   string out= default_look_and_feel ();
00091   // TMSCM_ALLOW_INTS;
00092 
00093   return string_to_tmscm (out);
00094 }
00095 
00096 tmscm
00097 tmg_default_chinese_font () {
00098   // TMSCM_DEFER_INTS;
00099   string out= default_chinese_font_name ();
00100   // TMSCM_ALLOW_INTS;
00101 
00102   return string_to_tmscm (out);
00103 }
00104 
00105 tmscm
00106 tmg_default_japanese_font () {
00107   // TMSCM_DEFER_INTS;
00108   string out= default_japanese_font_name ();
00109   // TMSCM_ALLOW_INTS;
00110 
00111   return string_to_tmscm (out);
00112 }
00113 
00114 tmscm
00115 tmg_default_korean_font () {
00116   // TMSCM_DEFER_INTS;
00117   string out= default_korean_font_name ();
00118   // TMSCM_ALLOW_INTS;
00119 
00120   return string_to_tmscm (out);
00121 }
00122 
00123 tmscm
00124 tmg_tm_output (tmscm arg1) {
00125   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tm-output");
00126 
00127   string in1= tmscm_to_string (arg1);
00128 
00129   // TMSCM_DEFER_INTS;
00130   tm_output (in1);
00131   // TMSCM_ALLOW_INTS;
00132 
00133   return TMSCM_UNSPECIFIED;
00134 }
00135 
00136 tmscm
00137 tmg_tm_errput (tmscm arg1) {
00138   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tm-errput");
00139 
00140   string in1= tmscm_to_string (arg1);
00141 
00142   // TMSCM_DEFER_INTS;
00143   tm_errput (in1);
00144   // TMSCM_ALLOW_INTS;
00145 
00146   return TMSCM_UNSPECIFIED;
00147 }
00148 
00149 tmscm
00150 tmg_win32_display (tmscm arg1) {
00151   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "win32-display");
00152 
00153   string in1= tmscm_to_string (arg1);
00154 
00155   // TMSCM_DEFER_INTS;
00156   win32_display (in1);
00157   // TMSCM_ALLOW_INTS;
00158 
00159   return TMSCM_UNSPECIFIED;
00160 }
00161 
00162 tmscm
00163 tmg_cpp_error () {
00164   // TMSCM_DEFER_INTS;
00165   cpp_error ();
00166   // TMSCM_ALLOW_INTS;
00167 
00168   return TMSCM_UNSPECIFIED;
00169 }
00170 
00171 tmscm
00172 tmg_scheme_dialect () {
00173   // TMSCM_DEFER_INTS;
00174   string out= scheme_dialect ();
00175   // TMSCM_ALLOW_INTS;
00176 
00177   return string_to_tmscm (out);
00178 }
00179 
00180 tmscm
00181 tmg_get_texmacs_path () {
00182   // TMSCM_DEFER_INTS;
00183   string out= get_texmacs_path ();
00184   // TMSCM_ALLOW_INTS;
00185 
00186   return string_to_tmscm (out);
00187 }
00188 
00189 tmscm
00190 tmg_plugin_list () {
00191   // TMSCM_DEFER_INTS;
00192   scheme_tree out= plugin_list ();
00193   // TMSCM_ALLOW_INTS;
00194 
00195   return scheme_tree_to_tmscm (out);
00196 }
00197 
00198 tmscm
00199 tmg_set_fast_environments (tmscm arg1) {
00200   TMSCM_ASSERT_BOOL (arg1, TMSCM_ARG1, "set-fast-environments");
00201 
00202   bool in1= tmscm_to_bool (arg1);
00203 
00204   // TMSCM_DEFER_INTS;
00205   set_fast_environments (in1);
00206   // TMSCM_ALLOW_INTS;
00207 
00208   return TMSCM_UNSPECIFIED;
00209 }
00210 
00211 tmscm
00212 tmg_font_exists_in_ttP (tmscm arg1) {
00213   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "font-exists-in-tt?");
00214 
00215   string in1= tmscm_to_string (arg1);
00216 
00217   // TMSCM_DEFER_INTS;
00218   bool out= tt_font_exists (in1);
00219   // TMSCM_ALLOW_INTS;
00220 
00221   return bool_to_tmscm (out);
00222 }
00223 
00224 tmscm
00225 tmg_eval_system (tmscm arg1) {
00226   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "eval-system");
00227 
00228   string in1= tmscm_to_string (arg1);
00229 
00230   // TMSCM_DEFER_INTS;
00231   string out= eval_system (in1);
00232   // TMSCM_ALLOW_INTS;
00233 
00234   return string_to_tmscm (out);
00235 }
00236 
00237 tmscm
00238 tmg_var_eval_system (tmscm arg1) {
00239   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "var-eval-system");
00240 
00241   string in1= tmscm_to_string (arg1);
00242 
00243   // TMSCM_DEFER_INTS;
00244   string out= var_eval_system (in1);
00245   // TMSCM_ALLOW_INTS;
00246 
00247   return string_to_tmscm (out);
00248 }
00249 
00250 tmscm
00251 tmg_get_locale_language () {
00252   // TMSCM_DEFER_INTS;
00253   string out= get_locale_language ();
00254   // TMSCM_ALLOW_INTS;
00255 
00256   return string_to_tmscm (out);
00257 }
00258 
00259 tmscm
00260 tmg_texmacs_time () {
00261   // TMSCM_DEFER_INTS;
00262   int out= texmacs_time ();
00263   // TMSCM_ALLOW_INTS;
00264 
00265   return int_to_tmscm (out);
00266 }
00267 
00268 tmscm
00269 tmg_texmacs_memory () {
00270   // TMSCM_DEFER_INTS;
00271   int out= mem_used ();
00272   // TMSCM_ALLOW_INTS;
00273 
00274   return int_to_tmscm (out);
00275 }
00276 
00277 tmscm
00278 tmg_bench_print (tmscm arg1) {
00279   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "bench-print");
00280 
00281   string in1= tmscm_to_string (arg1);
00282 
00283   // TMSCM_DEFER_INTS;
00284   bench_print (in1);
00285   // TMSCM_ALLOW_INTS;
00286 
00287   return TMSCM_UNSPECIFIED;
00288 }
00289 
00290 tmscm
00291 tmg_bench_print_all () {
00292   // TMSCM_DEFER_INTS;
00293   bench_print ();
00294   // TMSCM_ALLOW_INTS;
00295 
00296   return TMSCM_UNSPECIFIED;
00297 }
00298 
00299 tmscm
00300 tmg_system_wait (tmscm arg1, tmscm arg2) {
00301   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "system-wait");
00302   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "system-wait");
00303 
00304   string in1= tmscm_to_string (arg1);
00305   string in2= tmscm_to_string (arg2);
00306 
00307   // TMSCM_DEFER_INTS;
00308   system_wait (in1, in2);
00309   // TMSCM_ALLOW_INTS;
00310 
00311   return TMSCM_UNSPECIFIED;
00312 }
00313 
00314 tmscm
00315 tmg_set_bibtex_command (tmscm arg1) {
00316   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "set-bibtex-command");
00317 
00318   string in1= tmscm_to_string (arg1);
00319 
00320   // TMSCM_DEFER_INTS;
00321   set_bibtex_command (in1);
00322   // TMSCM_ALLOW_INTS;
00323 
00324   return TMSCM_UNSPECIFIED;
00325 }
00326 
00327 tmscm
00328 tmg_math_symbol_group (tmscm arg1) {
00329   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "math-symbol-group");
00330 
00331   string in1= tmscm_to_string (arg1);
00332 
00333   // TMSCM_DEFER_INTS;
00334   string out= math_symbol_group (in1);
00335   // TMSCM_ALLOW_INTS;
00336 
00337   return string_to_tmscm (out);
00338 }
00339 
00340 tmscm
00341 tmg_math_group_members (tmscm arg1) {
00342   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "math-group-members");
00343 
00344   string in1= tmscm_to_string (arg1);
00345 
00346   // TMSCM_DEFER_INTS;
00347   array_string out= math_group_members (in1);
00348   // TMSCM_ALLOW_INTS;
00349 
00350   return array_string_to_tmscm (out);
00351 }
00352 
00353 tmscm
00354 tmg_math_symbol_type (tmscm arg1) {
00355   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "math-symbol-type");
00356 
00357   string in1= tmscm_to_string (arg1);
00358 
00359   // TMSCM_DEFER_INTS;
00360   string out= math_symbol_type (in1);
00361   // TMSCM_ALLOW_INTS;
00362 
00363   return string_to_tmscm (out);
00364 }
00365 
00366 tmscm
00367 tmg_object_2command (tmscm arg1) {
00368   TMSCM_ASSERT_OBJECT (arg1, TMSCM_ARG1, "object->command");
00369 
00370   object in1= tmscm_to_object (arg1);
00371 
00372   // TMSCM_DEFER_INTS;
00373   command out= as_command (in1);
00374   // TMSCM_ALLOW_INTS;
00375 
00376   return command_to_tmscm (out);
00377 }
00378 
00379 tmscm
00380 tmg_exec_delayed (tmscm arg1) {
00381   TMSCM_ASSERT_OBJECT (arg1, TMSCM_ARG1, "exec-delayed");
00382 
00383   object in1= tmscm_to_object (arg1);
00384 
00385   // TMSCM_DEFER_INTS;
00386   exec_delayed (in1);
00387   // TMSCM_ALLOW_INTS;
00388 
00389   return TMSCM_UNSPECIFIED;
00390 }
00391 
00392 tmscm
00393 tmg_exec_delayed_pause (tmscm arg1) {
00394   TMSCM_ASSERT_OBJECT (arg1, TMSCM_ARG1, "exec-delayed-pause");
00395 
00396   object in1= tmscm_to_object (arg1);
00397 
00398   // TMSCM_DEFER_INTS;
00399   exec_delayed_pause (in1);
00400   // TMSCM_ALLOW_INTS;
00401 
00402   return TMSCM_UNSPECIFIED;
00403 }
00404 
00405 tmscm
00406 tmg_notify_preferences_loaded () {
00407   // TMSCM_DEFER_INTS;
00408   notify_preferences_loaded ();
00409   // TMSCM_ALLOW_INTS;
00410 
00411   return TMSCM_UNSPECIFIED;
00412 }
00413 
00414 tmscm
00415 tmg_set_input_language (tmscm arg1) {
00416   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "set-input-language");
00417 
00418   string in1= tmscm_to_string (arg1);
00419 
00420   // TMSCM_DEFER_INTS;
00421   set_input_language (in1);
00422   // TMSCM_ALLOW_INTS;
00423 
00424   return TMSCM_UNSPECIFIED;
00425 }
00426 
00427 tmscm
00428 tmg_get_input_language () {
00429   // TMSCM_DEFER_INTS;
00430   string out= get_input_language ();
00431   // TMSCM_ALLOW_INTS;
00432 
00433   return string_to_tmscm (out);
00434 }
00435 
00436 tmscm
00437 tmg_set_output_language (tmscm arg1) {
00438   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "set-output-language");
00439 
00440   string in1= tmscm_to_string (arg1);
00441 
00442   // TMSCM_DEFER_INTS;
00443   gui_set_output_language (in1);
00444   // TMSCM_ALLOW_INTS;
00445 
00446   return TMSCM_UNSPECIFIED;
00447 }
00448 
00449 tmscm
00450 tmg_get_output_language () {
00451   // TMSCM_DEFER_INTS;
00452   string out= get_output_language ();
00453   // TMSCM_ALLOW_INTS;
00454 
00455   return string_to_tmscm (out);
00456 }
00457 
00458 tmscm
00459 tmg_translate (tmscm arg1) {
00460   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "translate");
00461 
00462   content in1= tmscm_to_content (arg1);
00463 
00464   // TMSCM_DEFER_INTS;
00465   string out= translate (in1);
00466   // TMSCM_ALLOW_INTS;
00467 
00468   return string_to_tmscm (out);
00469 }
00470 
00471 tmscm
00472 tmg_translate_from_to (tmscm arg1, tmscm arg2, tmscm arg3) {
00473   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "translate-from-to");
00474   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "translate-from-to");
00475   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "translate-from-to");
00476 
00477   content in1= tmscm_to_content (arg1);
00478   string in2= tmscm_to_string (arg2);
00479   string in3= tmscm_to_string (arg3);
00480 
00481   // TMSCM_DEFER_INTS;
00482   string out= translate (in1, in2, in3);
00483   // TMSCM_ALLOW_INTS;
00484 
00485   return string_to_tmscm (out);
00486 }
00487 
00488 tmscm
00489 tmg_tree_translate (tmscm arg1) {
00490   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-translate");
00491 
00492   content in1= tmscm_to_content (arg1);
00493 
00494   // TMSCM_DEFER_INTS;
00495   tree out= tree_translate (in1);
00496   // TMSCM_ALLOW_INTS;
00497 
00498   return tree_to_tmscm (out);
00499 }
00500 
00501 tmscm
00502 tmg_tree_translate_from_to (tmscm arg1, tmscm arg2, tmscm arg3) {
00503   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-translate-from-to");
00504   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "tree-translate-from-to");
00505   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "tree-translate-from-to");
00506 
00507   content in1= tmscm_to_content (arg1);
00508   string in2= tmscm_to_string (arg2);
00509   string in3= tmscm_to_string (arg3);
00510 
00511   // TMSCM_DEFER_INTS;
00512   tree out= tree_translate (in1, in2, in3);
00513   // TMSCM_ALLOW_INTS;
00514 
00515   return tree_to_tmscm (out);
00516 }
00517 
00518 tmscm
00519 tmg_color (tmscm arg1) {
00520   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "color");
00521 
00522   string in1= tmscm_to_string (arg1);
00523 
00524   // TMSCM_DEFER_INTS;
00525   int out= named_color (in1);
00526   // TMSCM_ALLOW_INTS;
00527 
00528   return int_to_tmscm (out);
00529 }
00530 
00531 tmscm
00532 tmg_new_author () {
00533   // TMSCM_DEFER_INTS;
00534   double out= new_author ();
00535   // TMSCM_ALLOW_INTS;
00536 
00537   return double_to_tmscm (out);
00538 }
00539 
00540 tmscm
00541 tmg_set_author (tmscm arg1) {
00542   TMSCM_ASSERT_DOUBLE (arg1, TMSCM_ARG1, "set-author");
00543 
00544   double in1= tmscm_to_double (arg1);
00545 
00546   // TMSCM_DEFER_INTS;
00547   set_author (in1);
00548   // TMSCM_ALLOW_INTS;
00549 
00550   return TMSCM_UNSPECIFIED;
00551 }
00552 
00553 tmscm
00554 tmg_get_author () {
00555   // TMSCM_DEFER_INTS;
00556   double out= get_author ();
00557   // TMSCM_ALLOW_INTS;
00558 
00559   return double_to_tmscm (out);
00560 }
00561 
00562 tmscm
00563 tmg_debug_set (tmscm arg1, tmscm arg2) {
00564   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "debug-set");
00565   TMSCM_ASSERT_BOOL (arg2, TMSCM_ARG2, "debug-set");
00566 
00567   string in1= tmscm_to_string (arg1);
00568   bool in2= tmscm_to_bool (arg2);
00569 
00570   // TMSCM_DEFER_INTS;
00571   debug_set (in1, in2);
00572   // TMSCM_ALLOW_INTS;
00573 
00574   return TMSCM_UNSPECIFIED;
00575 }
00576 
00577 tmscm
00578 tmg_debug_get (tmscm arg1) {
00579   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "debug-get");
00580 
00581   string in1= tmscm_to_string (arg1);
00582 
00583   // TMSCM_DEFER_INTS;
00584   bool out= debug_get (in1);
00585   // TMSCM_ALLOW_INTS;
00586 
00587   return bool_to_tmscm (out);
00588 }
00589 
00590 tmscm
00591 tmg_cout_buffer () {
00592   // TMSCM_DEFER_INTS;
00593   cout_buffer ();
00594   // TMSCM_ALLOW_INTS;
00595 
00596   return TMSCM_UNSPECIFIED;
00597 }
00598 
00599 tmscm
00600 tmg_cout_unbuffer () {
00601   // TMSCM_DEFER_INTS;
00602   string out= cout_unbuffer ();
00603   // TMSCM_ALLOW_INTS;
00604 
00605   return string_to_tmscm (out);
00606 }
00607 
00608 tmscm
00609 tmg_mark_new () {
00610   // TMSCM_DEFER_INTS;
00611   double out= new_marker ();
00612   // TMSCM_ALLOW_INTS;
00613 
00614   return double_to_tmscm (out);
00615 }
00616 
00617 tmscm
00618 tmg_glyph_register (tmscm arg1, tmscm arg2) {
00619   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "glyph-register");
00620   TMSCM_ASSERT_ARRAY_ARRAY_ARRAY_DOUBLE (arg2, TMSCM_ARG2, "glyph-register");
00621 
00622   string in1= tmscm_to_string (arg1);
00623   array_array_array_double in2= tmscm_to_array_array_array_double (arg2);
00624 
00625   // TMSCM_DEFER_INTS;
00626   register_glyph (in1, in2);
00627   // TMSCM_ALLOW_INTS;
00628 
00629   return TMSCM_UNSPECIFIED;
00630 }
00631 
00632 tmscm
00633 tmg_glyph_recognize (tmscm arg1) {
00634   TMSCM_ASSERT_ARRAY_ARRAY_ARRAY_DOUBLE (arg1, TMSCM_ARG1, "glyph-recognize");
00635 
00636   array_array_array_double in1= tmscm_to_array_array_array_double (arg1);
00637 
00638   // TMSCM_DEFER_INTS;
00639   string out= recognize_glyph (in1);
00640   // TMSCM_ALLOW_INTS;
00641 
00642   return string_to_tmscm (out);
00643 }
00644 
00645 tmscm
00646 tmg_image_2psdoc (tmscm arg1) {
00647   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "image->psdoc");
00648 
00649   url in1= tmscm_to_url (arg1);
00650 
00651   // TMSCM_DEFER_INTS;
00652   string out= image_to_psdoc (in1);
00653   // TMSCM_ALLOW_INTS;
00654 
00655   return string_to_tmscm (out);
00656 }
00657 
00658 tmscm
00659 tmg_tree_2stree (tmscm arg1) {
00660   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree->stree");
00661 
00662   tree in1= tmscm_to_tree (arg1);
00663 
00664   // TMSCM_DEFER_INTS;
00665   scheme_tree out= tree_to_scheme_tree (in1);
00666   // TMSCM_ALLOW_INTS;
00667 
00668   return scheme_tree_to_tmscm (out);
00669 }
00670 
00671 tmscm
00672 tmg_stree_2tree (tmscm arg1) {
00673   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "stree->tree");
00674 
00675   scheme_tree in1= tmscm_to_scheme_tree (arg1);
00676 
00677   // TMSCM_DEFER_INTS;
00678   tree out= scheme_tree_to_tree (in1);
00679   // TMSCM_ALLOW_INTS;
00680 
00681   return tree_to_tmscm (out);
00682 }
00683 
00684 tmscm
00685 tmg_tree_2string (tmscm arg1) {
00686   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree->string");
00687 
00688   tree in1= tmscm_to_tree (arg1);
00689 
00690   // TMSCM_DEFER_INTS;
00691   string out= coerce_tree_string (in1);
00692   // TMSCM_ALLOW_INTS;
00693 
00694   return string_to_tmscm (out);
00695 }
00696 
00697 tmscm
00698 tmg_string_2tree (tmscm arg1) {
00699   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string->tree");
00700 
00701   string in1= tmscm_to_string (arg1);
00702 
00703   // TMSCM_DEFER_INTS;
00704   tree out= coerce_string_tree (in1);
00705   // TMSCM_ALLOW_INTS;
00706 
00707   return tree_to_tmscm (out);
00708 }
00709 
00710 tmscm
00711 tmg_tm_2tree (tmscm arg1) {
00712   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tm->tree");
00713 
00714   content in1= tmscm_to_content (arg1);
00715 
00716   // TMSCM_DEFER_INTS;
00717   tree out= tree (in1);
00718   // TMSCM_ALLOW_INTS;
00719 
00720   return tree_to_tmscm (out);
00721 }
00722 
00723 tmscm
00724 tmg_tree_atomicP (tmscm arg1) {
00725   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-atomic?");
00726 
00727   tree in1= tmscm_to_tree (arg1);
00728 
00729   // TMSCM_DEFER_INTS;
00730   bool out= is_atomic (in1);
00731   // TMSCM_ALLOW_INTS;
00732 
00733   return bool_to_tmscm (out);
00734 }
00735 
00736 tmscm
00737 tmg_tree_compoundP (tmscm arg1) {
00738   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-compound?");
00739 
00740   tree in1= tmscm_to_tree (arg1);
00741 
00742   // TMSCM_DEFER_INTS;
00743   bool out= is_compound (in1);
00744   // TMSCM_ALLOW_INTS;
00745 
00746   return bool_to_tmscm (out);
00747 }
00748 
00749 tmscm
00750 tmg_tree_label (tmscm arg1) {
00751   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-label");
00752 
00753   tree in1= tmscm_to_tree (arg1);
00754 
00755   // TMSCM_DEFER_INTS;
00756   tree_label out= L (in1);
00757   // TMSCM_ALLOW_INTS;
00758 
00759   return tree_label_to_tmscm (out);
00760 }
00761 
00762 tmscm
00763 tmg_tree_children (tmscm arg1) {
00764   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-children");
00765 
00766   tree in1= tmscm_to_tree (arg1);
00767 
00768   // TMSCM_DEFER_INTS;
00769   array_tree out= A (in1);
00770   // TMSCM_ALLOW_INTS;
00771 
00772   return array_tree_to_tmscm (out);
00773 }
00774 
00775 tmscm
00776 tmg_tree_arity (tmscm arg1) {
00777   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-arity");
00778 
00779   tree in1= tmscm_to_tree (arg1);
00780 
00781   // TMSCM_DEFER_INTS;
00782   int out= N (in1);
00783   // TMSCM_ALLOW_INTS;
00784 
00785   return int_to_tmscm (out);
00786 }
00787 
00788 tmscm
00789 tmg_tree_child_ref (tmscm arg1, tmscm arg2) {
00790   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-child-ref");
00791   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-child-ref");
00792 
00793   tree in1= tmscm_to_tree (arg1);
00794   int in2= tmscm_to_int (arg2);
00795 
00796   // TMSCM_DEFER_INTS;
00797   tree out= tree_ref (in1, in2);
00798   // TMSCM_ALLOW_INTS;
00799 
00800   return tree_to_tmscm (out);
00801 }
00802 
00803 tmscm
00804 tmg_tree_child_setS (tmscm arg1, tmscm arg2, tmscm arg3) {
00805   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-child-set!");
00806   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-child-set!");
00807   TMSCM_ASSERT_CONTENT (arg3, TMSCM_ARG3, "tree-child-set!");
00808 
00809   tree in1= tmscm_to_tree (arg1);
00810   int in2= tmscm_to_int (arg2);
00811   content in3= tmscm_to_content (arg3);
00812 
00813   // TMSCM_DEFER_INTS;
00814   tree out= tree_set (in1, in2, in3);
00815   // TMSCM_ALLOW_INTS;
00816 
00817   return tree_to_tmscm (out);
00818 }
00819 
00820 tmscm
00821 tmg_tree_child_insert (tmscm arg1, tmscm arg2, tmscm arg3) {
00822   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-child-insert");
00823   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-child-insert");
00824   TMSCM_ASSERT_CONTENT (arg3, TMSCM_ARG3, "tree-child-insert");
00825 
00826   content in1= tmscm_to_content (arg1);
00827   int in2= tmscm_to_int (arg2);
00828   content in3= tmscm_to_content (arg3);
00829 
00830   // TMSCM_DEFER_INTS;
00831   tree out= tree_child_insert (in1, in2, in3);
00832   // TMSCM_ALLOW_INTS;
00833 
00834   return tree_to_tmscm (out);
00835 }
00836 
00837 tmscm
00838 tmg_tree_ip (tmscm arg1) {
00839   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-ip");
00840 
00841   tree in1= tmscm_to_tree (arg1);
00842 
00843   // TMSCM_DEFER_INTS;
00844   path out= obtain_ip (in1);
00845   // TMSCM_ALLOW_INTS;
00846 
00847   return path_to_tmscm (out);
00848 }
00849 
00850 tmscm
00851 tmg_tree_activeP (tmscm arg1) {
00852   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-active?");
00853 
00854   tree in1= tmscm_to_tree (arg1);
00855 
00856   // TMSCM_DEFER_INTS;
00857   bool out= tree_active (in1);
00858   // TMSCM_ALLOW_INTS;
00859 
00860   return bool_to_tmscm (out);
00861 }
00862 
00863 tmscm
00864 tmg_tree_eqP (tmscm arg1, tmscm arg2) {
00865   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-eq?");
00866   TMSCM_ASSERT_TREE (arg2, TMSCM_ARG2, "tree-eq?");
00867 
00868   tree in1= tmscm_to_tree (arg1);
00869   tree in2= tmscm_to_tree (arg2);
00870 
00871   // TMSCM_DEFER_INTS;
00872   bool out= strong_equal (in1, in2);
00873   // TMSCM_ALLOW_INTS;
00874 
00875   return bool_to_tmscm (out);
00876 }
00877 
00878 tmscm
00879 tmg_subtree (tmscm arg1, tmscm arg2) {
00880   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "subtree");
00881   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "subtree");
00882 
00883   tree in1= tmscm_to_tree (arg1);
00884   path in2= tmscm_to_path (arg2);
00885 
00886   // TMSCM_DEFER_INTS;
00887   tree out= subtree (in1, in2);
00888   // TMSCM_ALLOW_INTS;
00889 
00890   return tree_to_tmscm (out);
00891 }
00892 
00893 tmscm
00894 tmg_tree_range (tmscm arg1, tmscm arg2, tmscm arg3) {
00895   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-range");
00896   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-range");
00897   TMSCM_ASSERT_INT (arg3, TMSCM_ARG3, "tree-range");
00898 
00899   tree in1= tmscm_to_tree (arg1);
00900   int in2= tmscm_to_int (arg2);
00901   int in3= tmscm_to_int (arg3);
00902 
00903   // TMSCM_DEFER_INTS;
00904   tree out= tree_range (in1, in2, in3);
00905   // TMSCM_ALLOW_INTS;
00906 
00907   return tree_to_tmscm (out);
00908 }
00909 
00910 tmscm
00911 tmg_tree_copy (tmscm arg1) {
00912   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-copy");
00913 
00914   tree in1= tmscm_to_tree (arg1);
00915 
00916   // TMSCM_DEFER_INTS;
00917   tree out= copy (in1);
00918   // TMSCM_ALLOW_INTS;
00919 
00920   return tree_to_tmscm (out);
00921 }
00922 
00923 tmscm
00924 tmg_tree_append (tmscm arg1, tmscm arg2) {
00925   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-append");
00926   TMSCM_ASSERT_TREE (arg2, TMSCM_ARG2, "tree-append");
00927 
00928   tree in1= tmscm_to_tree (arg1);
00929   tree in2= tmscm_to_tree (arg2);
00930 
00931   // TMSCM_DEFER_INTS;
00932   tree out= tree_append (in1, in2);
00933   // TMSCM_ALLOW_INTS;
00934 
00935   return tree_to_tmscm (out);
00936 }
00937 
00938 tmscm
00939 tmg_tree_right_index (tmscm arg1) {
00940   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-right-index");
00941 
00942   tree in1= tmscm_to_tree (arg1);
00943 
00944   // TMSCM_DEFER_INTS;
00945   int out= right_index (in1);
00946   // TMSCM_ALLOW_INTS;
00947 
00948   return int_to_tmscm (out);
00949 }
00950 
00951 tmscm
00952 tmg_tree_label_extensionP (tmscm arg1) {
00953   TMSCM_ASSERT_TREE_LABEL (arg1, TMSCM_ARG1, "tree-label-extension?");
00954 
00955   tree_label in1= tmscm_to_tree_label (arg1);
00956 
00957   // TMSCM_DEFER_INTS;
00958   bool out= is_extension (in1);
00959   // TMSCM_ALLOW_INTS;
00960 
00961   return bool_to_tmscm (out);
00962 }
00963 
00964 tmscm
00965 tmg_tree_multi_paragraphP (tmscm arg1) {
00966   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-multi-paragraph?");
00967 
00968   tree in1= tmscm_to_tree (arg1);
00969 
00970   // TMSCM_DEFER_INTS;
00971   bool out= is_multi_paragraph (in1);
00972   // TMSCM_ALLOW_INTS;
00973 
00974   return bool_to_tmscm (out);
00975 }
00976 
00977 tmscm
00978 tmg_tree_simplify (tmscm arg1) {
00979   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-simplify");
00980 
00981   tree in1= tmscm_to_tree (arg1);
00982 
00983   // TMSCM_DEFER_INTS;
00984   tree out= simplify_correct (in1);
00985   // TMSCM_ALLOW_INTS;
00986 
00987   return tree_to_tmscm (out);
00988 }
00989 
00990 tmscm
00991 tmg_tree_minimal_arity (tmscm arg1) {
00992   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-minimal-arity");
00993 
00994   tree in1= tmscm_to_tree (arg1);
00995 
00996   // TMSCM_DEFER_INTS;
00997   int out= minimal_arity (in1);
00998   // TMSCM_ALLOW_INTS;
00999 
01000   return int_to_tmscm (out);
01001 }
01002 
01003 tmscm
01004 tmg_tree_maximal_arity (tmscm arg1) {
01005   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-maximal-arity");
01006 
01007   tree in1= tmscm_to_tree (arg1);
01008 
01009   // TMSCM_DEFER_INTS;
01010   int out= maximal_arity (in1);
01011   // TMSCM_ALLOW_INTS;
01012 
01013   return int_to_tmscm (out);
01014 }
01015 
01016 tmscm
01017 tmg_tree_possible_arityP (tmscm arg1, tmscm arg2) {
01018   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-possible-arity?");
01019   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-possible-arity?");
01020 
01021   tree in1= tmscm_to_tree (arg1);
01022   int in2= tmscm_to_int (arg2);
01023 
01024   // TMSCM_DEFER_INTS;
01025   bool out= correct_arity (in1, in2);
01026   // TMSCM_ALLOW_INTS;
01027 
01028   return bool_to_tmscm (out);
01029 }
01030 
01031 tmscm
01032 tmg_tree_insert_point (tmscm arg1, tmscm arg2) {
01033   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-insert_point");
01034   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-insert_point");
01035 
01036   tree in1= tmscm_to_tree (arg1);
01037   int in2= tmscm_to_int (arg2);
01038 
01039   // TMSCM_DEFER_INTS;
01040   int out= insert_point (in1, in2);
01041   // TMSCM_ALLOW_INTS;
01042 
01043   return int_to_tmscm (out);
01044 }
01045 
01046 tmscm
01047 tmg_tree_is_dynamicP (tmscm arg1) {
01048   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-is-dynamic?");
01049 
01050   tree in1= tmscm_to_tree (arg1);
01051 
01052   // TMSCM_DEFER_INTS;
01053   bool out= is_dynamic (in1);
01054   // TMSCM_ALLOW_INTS;
01055 
01056   return bool_to_tmscm (out);
01057 }
01058 
01059 tmscm
01060 tmg_tree_accessible_childP (tmscm arg1, tmscm arg2) {
01061   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-accessible-child?");
01062   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-accessible-child?");
01063 
01064   tree in1= tmscm_to_tree (arg1);
01065   int in2= tmscm_to_int (arg2);
01066 
01067   // TMSCM_DEFER_INTS;
01068   bool out= is_accessible_child (in1, in2);
01069   // TMSCM_ALLOW_INTS;
01070 
01071   return bool_to_tmscm (out);
01072 }
01073 
01074 tmscm
01075 tmg_tree_accessible_children (tmscm arg1) {
01076   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-accessible-children");
01077 
01078   tree in1= tmscm_to_tree (arg1);
01079 
01080   // TMSCM_DEFER_INTS;
01081   array_tree out= accessible_children (in1);
01082   // TMSCM_ALLOW_INTS;
01083 
01084   return array_tree_to_tmscm (out);
01085 }
01086 
01087 tmscm
01088 tmg_tree_all_accessibleP (tmscm arg1) {
01089   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-all-accessible?");
01090 
01091   content in1= tmscm_to_content (arg1);
01092 
01093   // TMSCM_DEFER_INTS;
01094   bool out= all_accessible (in1);
01095   // TMSCM_ALLOW_INTS;
01096 
01097   return bool_to_tmscm (out);
01098 }
01099 
01100 tmscm
01101 tmg_tree_none_accessibleP (tmscm arg1) {
01102   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-none-accessible?");
01103 
01104   content in1= tmscm_to_content (arg1);
01105 
01106   // TMSCM_DEFER_INTS;
01107   bool out= none_accessible (in1);
01108   // TMSCM_ALLOW_INTS;
01109 
01110   return bool_to_tmscm (out);
01111 }
01112 
01113 tmscm
01114 tmg_tree_name (tmscm arg1) {
01115   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-name");
01116 
01117   content in1= tmscm_to_content (arg1);
01118 
01119   // TMSCM_DEFER_INTS;
01120   string out= get_name (in1);
01121   // TMSCM_ALLOW_INTS;
01122 
01123   return string_to_tmscm (out);
01124 }
01125 
01126 tmscm
01127 tmg_tree_long_name (tmscm arg1) {
01128   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-long-name");
01129 
01130   content in1= tmscm_to_content (arg1);
01131 
01132   // TMSCM_DEFER_INTS;
01133   string out= get_long_name (in1);
01134   // TMSCM_ALLOW_INTS;
01135 
01136   return string_to_tmscm (out);
01137 }
01138 
01139 tmscm
01140 tmg_tree_child_name (tmscm arg1, tmscm arg2) {
01141   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-child-name");
01142   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-child-name");
01143 
01144   content in1= tmscm_to_content (arg1);
01145   int in2= tmscm_to_int (arg2);
01146 
01147   // TMSCM_DEFER_INTS;
01148   string out= get_child_name (in1, in2);
01149   // TMSCM_ALLOW_INTS;
01150 
01151   return string_to_tmscm (out);
01152 }
01153 
01154 tmscm
01155 tmg_tree_child_long_name (tmscm arg1, tmscm arg2) {
01156   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-child-long-name");
01157   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-child-long-name");
01158 
01159   content in1= tmscm_to_content (arg1);
01160   int in2= tmscm_to_int (arg2);
01161 
01162   // TMSCM_DEFER_INTS;
01163   string out= get_child_long_name (in1, in2);
01164   // TMSCM_ALLOW_INTS;
01165 
01166   return string_to_tmscm (out);
01167 }
01168 
01169 tmscm
01170 tmg_tree_child_type (tmscm arg1, tmscm arg2) {
01171   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-child-type");
01172   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-child-type");
01173 
01174   content in1= tmscm_to_content (arg1);
01175   int in2= tmscm_to_int (arg2);
01176 
01177   // TMSCM_DEFER_INTS;
01178   string out= get_child_type (in1, in2);
01179   // TMSCM_ALLOW_INTS;
01180 
01181   return string_to_tmscm (out);
01182 }
01183 
01184 tmscm
01185 tmg_tree_child_env (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4) {
01186   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-child-env");
01187   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-child-env");
01188   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "tree-child-env");
01189   TMSCM_ASSERT_CONTENT (arg4, TMSCM_ARG4, "tree-child-env");
01190 
01191   content in1= tmscm_to_content (arg1);
01192   int in2= tmscm_to_int (arg2);
01193   string in3= tmscm_to_string (arg3);
01194   content in4= tmscm_to_content (arg4);
01195 
01196   // TMSCM_DEFER_INTS;
01197   tree out= get_env_child (in1, in2, in3, in4);
01198   // TMSCM_ALLOW_INTS;
01199 
01200   return tree_to_tmscm (out);
01201 }
01202 
01203 tmscm
01204 tmg_tree_load_inclusion (tmscm arg1) {
01205   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "tree-load-inclusion");
01206 
01207   url in1= tmscm_to_url (arg1);
01208 
01209   // TMSCM_DEFER_INTS;
01210   tree out= load_inclusion (in1);
01211   // TMSCM_ALLOW_INTS;
01212 
01213   return tree_to_tmscm (out);
01214 }
01215 
01216 tmscm
01217 tmg_tree_as_string (tmscm arg1) {
01218   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-as-string");
01219 
01220   content in1= tmscm_to_content (arg1);
01221 
01222   // TMSCM_DEFER_INTS;
01223   string out= tree_as_string (in1);
01224   // TMSCM_ALLOW_INTS;
01225 
01226   return string_to_tmscm (out);
01227 }
01228 
01229 tmscm
01230 tmg_tree_extents (tmscm arg1) {
01231   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-extents");
01232 
01233   content in1= tmscm_to_content (arg1);
01234 
01235   // TMSCM_DEFER_INTS;
01236   tree out= tree_extents (in1);
01237   // TMSCM_ALLOW_INTS;
01238 
01239   return tree_to_tmscm (out);
01240 }
01241 
01242 tmscm
01243 tmg_tree_emptyP (tmscm arg1) {
01244   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-empty?");
01245 
01246   content in1= tmscm_to_content (arg1);
01247 
01248   // TMSCM_DEFER_INTS;
01249   bool out= is_empty (in1);
01250   // TMSCM_ALLOW_INTS;
01251 
01252   return bool_to_tmscm (out);
01253 }
01254 
01255 tmscm
01256 tmg_tree_is_bufferP (tmscm arg1) {
01257   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-is-buffer?");
01258 
01259   tree in1= tmscm_to_tree (arg1);
01260 
01261   // TMSCM_DEFER_INTS;
01262   bool out= admits_edit_observer (in1);
01263   // TMSCM_ALLOW_INTS;
01264 
01265   return bool_to_tmscm (out);
01266 }
01267 
01268 tmscm
01269 tmg_tree_search_sections (tmscm arg1) {
01270   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-search-sections");
01271 
01272   tree in1= tmscm_to_tree (arg1);
01273 
01274   // TMSCM_DEFER_INTS;
01275   array_tree out= search_sections (in1);
01276   // TMSCM_ALLOW_INTS;
01277 
01278   return array_tree_to_tmscm (out);
01279 }
01280 
01281 tmscm
01282 tmg_tree_assign (tmscm arg1, tmscm arg2) {
01283   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-assign");
01284   TMSCM_ASSERT_CONTENT (arg2, TMSCM_ARG2, "tree-assign");
01285 
01286   tree in1= tmscm_to_tree (arg1);
01287   content in2= tmscm_to_content (arg2);
01288 
01289   // TMSCM_DEFER_INTS;
01290   tree out= tree_assign (in1, in2);
01291   // TMSCM_ALLOW_INTS;
01292 
01293   return tree_to_tmscm (out);
01294 }
01295 
01296 tmscm
01297 tmg_tree_var_insert (tmscm arg1, tmscm arg2, tmscm arg3) {
01298   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-var-insert");
01299   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-var-insert");
01300   TMSCM_ASSERT_CONTENT (arg3, TMSCM_ARG3, "tree-var-insert");
01301 
01302   tree in1= tmscm_to_tree (arg1);
01303   int in2= tmscm_to_int (arg2);
01304   content in3= tmscm_to_content (arg3);
01305 
01306   // TMSCM_DEFER_INTS;
01307   tree out= tree_insert (in1, in2, in3);
01308   // TMSCM_ALLOW_INTS;
01309 
01310   return tree_to_tmscm (out);
01311 }
01312 
01313 tmscm
01314 tmg_tree_remove (tmscm arg1, tmscm arg2, tmscm arg3) {
01315   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-remove");
01316   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-remove");
01317   TMSCM_ASSERT_INT (arg3, TMSCM_ARG3, "tree-remove");
01318 
01319   tree in1= tmscm_to_tree (arg1);
01320   int in2= tmscm_to_int (arg2);
01321   int in3= tmscm_to_int (arg3);
01322 
01323   // TMSCM_DEFER_INTS;
01324   tree out= tree_remove (in1, in2, in3);
01325   // TMSCM_ALLOW_INTS;
01326 
01327   return tree_to_tmscm (out);
01328 }
01329 
01330 tmscm
01331 tmg_tree_split (tmscm arg1, tmscm arg2, tmscm arg3) {
01332   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-split");
01333   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-split");
01334   TMSCM_ASSERT_INT (arg3, TMSCM_ARG3, "tree-split");
01335 
01336   tree in1= tmscm_to_tree (arg1);
01337   int in2= tmscm_to_int (arg2);
01338   int in3= tmscm_to_int (arg3);
01339 
01340   // TMSCM_DEFER_INTS;
01341   tree out= tree_split (in1, in2, in3);
01342   // TMSCM_ALLOW_INTS;
01343 
01344   return tree_to_tmscm (out);
01345 }
01346 
01347 tmscm
01348 tmg_tree_join (tmscm arg1, tmscm arg2) {
01349   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-join");
01350   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-join");
01351 
01352   tree in1= tmscm_to_tree (arg1);
01353   int in2= tmscm_to_int (arg2);
01354 
01355   // TMSCM_DEFER_INTS;
01356   tree out= tree_join (in1, in2);
01357   // TMSCM_ALLOW_INTS;
01358 
01359   return tree_to_tmscm (out);
01360 }
01361 
01362 tmscm
01363 tmg_tree_assign_node (tmscm arg1, tmscm arg2) {
01364   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-assign-node");
01365   TMSCM_ASSERT_TREE_LABEL (arg2, TMSCM_ARG2, "tree-assign-node");
01366 
01367   tree in1= tmscm_to_tree (arg1);
01368   tree_label in2= tmscm_to_tree_label (arg2);
01369 
01370   // TMSCM_DEFER_INTS;
01371   tree out= tree_assign_node (in1, in2);
01372   // TMSCM_ALLOW_INTS;
01373 
01374   return tree_to_tmscm (out);
01375 }
01376 
01377 tmscm
01378 tmg_tree_insert_node (tmscm arg1, tmscm arg2, tmscm arg3) {
01379   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-insert-node");
01380   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-insert-node");
01381   TMSCM_ASSERT_CONTENT (arg3, TMSCM_ARG3, "tree-insert-node");
01382 
01383   tree in1= tmscm_to_tree (arg1);
01384   int in2= tmscm_to_int (arg2);
01385   content in3= tmscm_to_content (arg3);
01386 
01387   // TMSCM_DEFER_INTS;
01388   tree out= tree_insert_node (in1, in2, in3);
01389   // TMSCM_ALLOW_INTS;
01390 
01391   return tree_to_tmscm (out);
01392 }
01393 
01394 tmscm
01395 tmg_tree_remove_node (tmscm arg1, tmscm arg2) {
01396   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-remove-node");
01397   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tree-remove-node");
01398 
01399   tree in1= tmscm_to_tree (arg1);
01400   int in2= tmscm_to_int (arg2);
01401 
01402   // TMSCM_DEFER_INTS;
01403   tree out= tree_remove_node (in1, in2);
01404   // TMSCM_ALLOW_INTS;
01405 
01406   return tree_to_tmscm (out);
01407 }
01408 
01409 tmscm
01410 tmg_cpp_tree_correct_node (tmscm arg1) {
01411   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "cpp-tree-correct-node");
01412 
01413   tree in1= tmscm_to_tree (arg1);
01414 
01415   // TMSCM_DEFER_INTS;
01416   correct_node (in1);
01417   // TMSCM_ALLOW_INTS;
01418 
01419   return TMSCM_UNSPECIFIED;
01420 }
01421 
01422 tmscm
01423 tmg_cpp_tree_correct_downwards (tmscm arg1) {
01424   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "cpp-tree-correct-downwards");
01425 
01426   tree in1= tmscm_to_tree (arg1);
01427 
01428   // TMSCM_DEFER_INTS;
01429   correct_downwards (in1);
01430   // TMSCM_ALLOW_INTS;
01431 
01432   return TMSCM_UNSPECIFIED;
01433 }
01434 
01435 tmscm
01436 tmg_cpp_tree_correct_upwards (tmscm arg1) {
01437   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "cpp-tree-correct-upwards");
01438 
01439   tree in1= tmscm_to_tree (arg1);
01440 
01441   // TMSCM_DEFER_INTS;
01442   correct_upwards (in1);
01443   // TMSCM_ALLOW_INTS;
01444 
01445   return TMSCM_UNSPECIFIED;
01446 }
01447 
01448 tmscm
01449 tmg_concat_tokenize_math (tmscm arg1) {
01450   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "concat-tokenize-math");
01451 
01452   content in1= tmscm_to_content (arg1);
01453 
01454   // TMSCM_DEFER_INTS;
01455   array_tree out= concat_tokenize (in1);
01456   // TMSCM_ALLOW_INTS;
01457 
01458   return array_tree_to_tmscm (out);
01459 }
01460 
01461 tmscm
01462 tmg_concat_decompose (tmscm arg1) {
01463   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "concat-decompose");
01464 
01465   content in1= tmscm_to_content (arg1);
01466 
01467   // TMSCM_DEFER_INTS;
01468   array_tree out= concat_decompose (in1);
01469   // TMSCM_ALLOW_INTS;
01470 
01471   return array_tree_to_tmscm (out);
01472 }
01473 
01474 tmscm
01475 tmg_concat_recompose (tmscm arg1) {
01476   TMSCM_ASSERT_ARRAY_TREE (arg1, TMSCM_ARG1, "concat-recompose");
01477 
01478   array_tree in1= tmscm_to_array_tree (arg1);
01479 
01480   // TMSCM_DEFER_INTS;
01481   tree out= concat_recompose (in1);
01482   // TMSCM_ALLOW_INTS;
01483 
01484   return tree_to_tmscm (out);
01485 }
01486 
01487 tmscm
01488 tmg_with_likeP (tmscm arg1) {
01489   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "with-like?");
01490 
01491   content in1= tmscm_to_content (arg1);
01492 
01493   // TMSCM_DEFER_INTS;
01494   bool out= is_with_like (in1);
01495   // TMSCM_ALLOW_INTS;
01496 
01497   return bool_to_tmscm (out);
01498 }
01499 
01500 tmscm
01501 tmg_with_same_typeP (tmscm arg1, tmscm arg2) {
01502   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "with-same-type?");
01503   TMSCM_ASSERT_CONTENT (arg2, TMSCM_ARG2, "with-same-type?");
01504 
01505   content in1= tmscm_to_content (arg1);
01506   content in2= tmscm_to_content (arg2);
01507 
01508   // TMSCM_DEFER_INTS;
01509   bool out= with_same_type (in1, in2);
01510   // TMSCM_ALLOW_INTS;
01511 
01512   return bool_to_tmscm (out);
01513 }
01514 
01515 tmscm
01516 tmg_with_similar_typeP (tmscm arg1, tmscm arg2) {
01517   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "with-similar-type?");
01518   TMSCM_ASSERT_CONTENT (arg2, TMSCM_ARG2, "with-similar-type?");
01519 
01520   content in1= tmscm_to_content (arg1);
01521   content in2= tmscm_to_content (arg2);
01522 
01523   // TMSCM_DEFER_INTS;
01524   bool out= with_similar_type (in1, in2);
01525   // TMSCM_ALLOW_INTS;
01526 
01527   return bool_to_tmscm (out);
01528 }
01529 
01530 tmscm
01531 tmg_with_correct (tmscm arg1) {
01532   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "with-correct");
01533 
01534   content in1= tmscm_to_content (arg1);
01535 
01536   // TMSCM_DEFER_INTS;
01537   tree out= with_correct (in1);
01538   // TMSCM_ALLOW_INTS;
01539 
01540   return tree_to_tmscm (out);
01541 }
01542 
01543 tmscm
01544 tmg_with_correct_superfluous (tmscm arg1) {
01545   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "with-correct-superfluous");
01546 
01547   content in1= tmscm_to_content (arg1);
01548 
01549   // TMSCM_DEFER_INTS;
01550   tree out= superfluous_with_correct (in1);
01551   // TMSCM_ALLOW_INTS;
01552 
01553   return tree_to_tmscm (out);
01554 }
01555 
01556 tmscm
01557 tmg_invisible_correct_superfluous (tmscm arg1) {
01558   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "invisible-correct-superfluous");
01559 
01560   content in1= tmscm_to_content (arg1);
01561 
01562   // TMSCM_DEFER_INTS;
01563   tree out= superfluous_invisible_correct (in1);
01564   // TMSCM_ALLOW_INTS;
01565 
01566   return tree_to_tmscm (out);
01567 }
01568 
01569 tmscm
01570 tmg_invisible_correct_missing (tmscm arg1, tmscm arg2) {
01571   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "invisible-correct-missing");
01572   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "invisible-correct-missing");
01573 
01574   content in1= tmscm_to_content (arg1);
01575   int in2= tmscm_to_int (arg2);
01576 
01577   // TMSCM_DEFER_INTS;
01578   tree out= missing_invisible_correct (in1, in2);
01579   // TMSCM_ALLOW_INTS;
01580 
01581   return tree_to_tmscm (out);
01582 }
01583 
01584 tmscm
01585 tmg_automatic_correct (tmscm arg1, tmscm arg2) {
01586   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "automatic-correct");
01587   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "automatic-correct");
01588 
01589   content in1= tmscm_to_content (arg1);
01590   string in2= tmscm_to_string (arg2);
01591 
01592   // TMSCM_DEFER_INTS;
01593   tree out= automatic_correct (in1, in2);
01594   // TMSCM_ALLOW_INTS;
01595 
01596   return tree_to_tmscm (out);
01597 }
01598 
01599 tmscm
01600 tmg_manual_correct (tmscm arg1) {
01601   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "manual-correct");
01602 
01603   content in1= tmscm_to_content (arg1);
01604 
01605   // TMSCM_DEFER_INTS;
01606   tree out= manual_correct (in1);
01607   // TMSCM_ALLOW_INTS;
01608 
01609   return tree_to_tmscm (out);
01610 }
01611 
01612 tmscm
01613 tmg_tree_upgrade_brackets (tmscm arg1, tmscm arg2) {
01614   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-upgrade-brackets");
01615   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "tree-upgrade-brackets");
01616 
01617   content in1= tmscm_to_content (arg1);
01618   string in2= tmscm_to_string (arg2);
01619 
01620   // TMSCM_DEFER_INTS;
01621   tree out= upgrade_brackets (in1, in2);
01622   // TMSCM_ALLOW_INTS;
01623 
01624   return tree_to_tmscm (out);
01625 }
01626 
01627 tmscm
01628 tmg_tree_upgrade_big (tmscm arg1) {
01629   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-upgrade-big");
01630 
01631   content in1= tmscm_to_content (arg1);
01632 
01633   // TMSCM_DEFER_INTS;
01634   tree out= upgrade_big (in1);
01635   // TMSCM_ALLOW_INTS;
01636 
01637   return tree_to_tmscm (out);
01638 }
01639 
01640 tmscm
01641 tmg_tree_downgrade_brackets (tmscm arg1, tmscm arg2, tmscm arg3) {
01642   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-downgrade-brackets");
01643   TMSCM_ASSERT_BOOL (arg2, TMSCM_ARG2, "tree-downgrade-brackets");
01644   TMSCM_ASSERT_BOOL (arg3, TMSCM_ARG3, "tree-downgrade-brackets");
01645 
01646   content in1= tmscm_to_content (arg1);
01647   bool in2= tmscm_to_bool (arg2);
01648   bool in3= tmscm_to_bool (arg3);
01649 
01650   // TMSCM_DEFER_INTS;
01651   tree out= downgrade_brackets (in1, in2, in3);
01652   // TMSCM_ALLOW_INTS;
01653 
01654   return tree_to_tmscm (out);
01655 }
01656 
01657 tmscm
01658 tmg_tree_downgrade_big (tmscm arg1) {
01659   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "tree-downgrade-big");
01660 
01661   content in1= tmscm_to_content (arg1);
01662 
01663   // TMSCM_DEFER_INTS;
01664   tree out= downgrade_big (in1);
01665   // TMSCM_ALLOW_INTS;
01666 
01667   return tree_to_tmscm (out);
01668 }
01669 
01670 tmscm
01671 tmg_math_status_print () {
01672   // TMSCM_DEFER_INTS;
01673   math_status_print ();
01674   // TMSCM_ALLOW_INTS;
01675 
01676   return TMSCM_UNSPECIFIED;
01677 }
01678 
01679 tmscm
01680 tmg_math_status_reset () {
01681   // TMSCM_DEFER_INTS;
01682   math_status_reset ();
01683   // TMSCM_ALLOW_INTS;
01684 
01685   return TMSCM_UNSPECIFIED;
01686 }
01687 
01688 tmscm
01689 tmg_path_infP (tmscm arg1, tmscm arg2) {
01690   TMSCM_ASSERT_PATH (arg1, TMSCM_ARG1, "path-inf?");
01691   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-inf?");
01692 
01693   path in1= tmscm_to_path (arg1);
01694   path in2= tmscm_to_path (arg2);
01695 
01696   // TMSCM_DEFER_INTS;
01697   bool out= path_inf (in1, in2);
01698   // TMSCM_ALLOW_INTS;
01699 
01700   return bool_to_tmscm (out);
01701 }
01702 
01703 tmscm
01704 tmg_path_inf_eqP (tmscm arg1, tmscm arg2) {
01705   TMSCM_ASSERT_PATH (arg1, TMSCM_ARG1, "path-inf-eq?");
01706   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-inf-eq?");
01707 
01708   path in1= tmscm_to_path (arg1);
01709   path in2= tmscm_to_path (arg2);
01710 
01711   // TMSCM_DEFER_INTS;
01712   bool out= path_inf_eq (in1, in2);
01713   // TMSCM_ALLOW_INTS;
01714 
01715   return bool_to_tmscm (out);
01716 }
01717 
01718 tmscm
01719 tmg_path_lessP (tmscm arg1, tmscm arg2) {
01720   TMSCM_ASSERT_PATH (arg1, TMSCM_ARG1, "path-less?");
01721   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-less?");
01722 
01723   path in1= tmscm_to_path (arg1);
01724   path in2= tmscm_to_path (arg2);
01725 
01726   // TMSCM_DEFER_INTS;
01727   bool out= path_less (in1, in2);
01728   // TMSCM_ALLOW_INTS;
01729 
01730   return bool_to_tmscm (out);
01731 }
01732 
01733 tmscm
01734 tmg_path_less_eqP (tmscm arg1, tmscm arg2) {
01735   TMSCM_ASSERT_PATH (arg1, TMSCM_ARG1, "path-less-eq?");
01736   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-less-eq?");
01737 
01738   path in1= tmscm_to_path (arg1);
01739   path in2= tmscm_to_path (arg2);
01740 
01741   // TMSCM_DEFER_INTS;
01742   bool out= path_less_eq (in1, in2);
01743   // TMSCM_ALLOW_INTS;
01744 
01745   return bool_to_tmscm (out);
01746 }
01747 
01748 tmscm
01749 tmg_path_start (tmscm arg1, tmscm arg2) {
01750   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-start");
01751   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-start");
01752 
01753   content in1= tmscm_to_content (arg1);
01754   path in2= tmscm_to_path (arg2);
01755 
01756   // TMSCM_DEFER_INTS;
01757   path out= start (in1, in2);
01758   // TMSCM_ALLOW_INTS;
01759 
01760   return path_to_tmscm (out);
01761 }
01762 
01763 tmscm
01764 tmg_path_end (tmscm arg1, tmscm arg2) {
01765   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-end");
01766   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-end");
01767 
01768   content in1= tmscm_to_content (arg1);
01769   path in2= tmscm_to_path (arg2);
01770 
01771   // TMSCM_DEFER_INTS;
01772   path out= end (in1, in2);
01773   // TMSCM_ALLOW_INTS;
01774 
01775   return path_to_tmscm (out);
01776 }
01777 
01778 tmscm
01779 tmg_path_next (tmscm arg1, tmscm arg2) {
01780   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-next");
01781   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-next");
01782 
01783   content in1= tmscm_to_content (arg1);
01784   path in2= tmscm_to_path (arg2);
01785 
01786   // TMSCM_DEFER_INTS;
01787   path out= next_valid (in1, in2);
01788   // TMSCM_ALLOW_INTS;
01789 
01790   return path_to_tmscm (out);
01791 }
01792 
01793 tmscm
01794 tmg_path_previous (tmscm arg1, tmscm arg2) {
01795   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-previous");
01796   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-previous");
01797 
01798   content in1= tmscm_to_content (arg1);
01799   path in2= tmscm_to_path (arg2);
01800 
01801   // TMSCM_DEFER_INTS;
01802   path out= previous_valid (in1, in2);
01803   // TMSCM_ALLOW_INTS;
01804 
01805   return path_to_tmscm (out);
01806 }
01807 
01808 tmscm
01809 tmg_path_next_word (tmscm arg1, tmscm arg2) {
01810   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-next-word");
01811   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-next-word");
01812 
01813   content in1= tmscm_to_content (arg1);
01814   path in2= tmscm_to_path (arg2);
01815 
01816   // TMSCM_DEFER_INTS;
01817   path out= next_word (in1, in2);
01818   // TMSCM_ALLOW_INTS;
01819 
01820   return path_to_tmscm (out);
01821 }
01822 
01823 tmscm
01824 tmg_path_previous_word (tmscm arg1, tmscm arg2) {
01825   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-previous-word");
01826   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-previous-word");
01827 
01828   content in1= tmscm_to_content (arg1);
01829   path in2= tmscm_to_path (arg2);
01830 
01831   // TMSCM_DEFER_INTS;
01832   path out= previous_word (in1, in2);
01833   // TMSCM_ALLOW_INTS;
01834 
01835   return path_to_tmscm (out);
01836 }
01837 
01838 tmscm
01839 tmg_path_next_node (tmscm arg1, tmscm arg2) {
01840   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-next-node");
01841   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-next-node");
01842 
01843   content in1= tmscm_to_content (arg1);
01844   path in2= tmscm_to_path (arg2);
01845 
01846   // TMSCM_DEFER_INTS;
01847   path out= next_node (in1, in2);
01848   // TMSCM_ALLOW_INTS;
01849 
01850   return path_to_tmscm (out);
01851 }
01852 
01853 tmscm
01854 tmg_path_previous_node (tmscm arg1, tmscm arg2) {
01855   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-previous-node");
01856   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-previous-node");
01857 
01858   content in1= tmscm_to_content (arg1);
01859   path in2= tmscm_to_path (arg2);
01860 
01861   // TMSCM_DEFER_INTS;
01862   path out= previous_node (in1, in2);
01863   // TMSCM_ALLOW_INTS;
01864 
01865   return path_to_tmscm (out);
01866 }
01867 
01868 tmscm
01869 tmg_path_next_tag (tmscm arg1, tmscm arg2, tmscm arg3) {
01870   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-next-tag");
01871   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-next-tag");
01872   TMSCM_ASSERT_SCHEME_TREE (arg3, TMSCM_ARG3, "path-next-tag");
01873 
01874   content in1= tmscm_to_content (arg1);
01875   path in2= tmscm_to_path (arg2);
01876   scheme_tree in3= tmscm_to_scheme_tree (arg3);
01877 
01878   // TMSCM_DEFER_INTS;
01879   path out= next_tag (in1, in2, in3);
01880   // TMSCM_ALLOW_INTS;
01881 
01882   return path_to_tmscm (out);
01883 }
01884 
01885 tmscm
01886 tmg_path_previous_tag (tmscm arg1, tmscm arg2, tmscm arg3) {
01887   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-previous-tag");
01888   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-previous-tag");
01889   TMSCM_ASSERT_SCHEME_TREE (arg3, TMSCM_ARG3, "path-previous-tag");
01890 
01891   content in1= tmscm_to_content (arg1);
01892   path in2= tmscm_to_path (arg2);
01893   scheme_tree in3= tmscm_to_scheme_tree (arg3);
01894 
01895   // TMSCM_DEFER_INTS;
01896   path out= previous_tag (in1, in2, in3);
01897   // TMSCM_ALLOW_INTS;
01898 
01899   return path_to_tmscm (out);
01900 }
01901 
01902 tmscm
01903 tmg_path_next_tag_same_argument (tmscm arg1, tmscm arg2, tmscm arg3) {
01904   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-next-tag-same-argument");
01905   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-next-tag-same-argument");
01906   TMSCM_ASSERT_SCHEME_TREE (arg3, TMSCM_ARG3, "path-next-tag-same-argument");
01907 
01908   content in1= tmscm_to_content (arg1);
01909   path in2= tmscm_to_path (arg2);
01910   scheme_tree in3= tmscm_to_scheme_tree (arg3);
01911 
01912   // TMSCM_DEFER_INTS;
01913   path out= next_tag_same_argument (in1, in2, in3);
01914   // TMSCM_ALLOW_INTS;
01915 
01916   return path_to_tmscm (out);
01917 }
01918 
01919 tmscm
01920 tmg_path_previous_tag_same_argument (tmscm arg1, tmscm arg2, tmscm arg3) {
01921   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-previous-tag-same-argument");
01922   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-previous-tag-same-argument");
01923   TMSCM_ASSERT_SCHEME_TREE (arg3, TMSCM_ARG3, "path-previous-tag-same-argument");
01924 
01925   content in1= tmscm_to_content (arg1);
01926   path in2= tmscm_to_path (arg2);
01927   scheme_tree in3= tmscm_to_scheme_tree (arg3);
01928 
01929   // TMSCM_DEFER_INTS;
01930   path out= previous_tag_same_argument (in1, in2, in3);
01931   // TMSCM_ALLOW_INTS;
01932 
01933   return path_to_tmscm (out);
01934 }
01935 
01936 tmscm
01937 tmg_path_next_argument (tmscm arg1, tmscm arg2) {
01938   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-next-argument");
01939   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-next-argument");
01940 
01941   content in1= tmscm_to_content (arg1);
01942   path in2= tmscm_to_path (arg2);
01943 
01944   // TMSCM_DEFER_INTS;
01945   path out= next_argument (in1, in2);
01946   // TMSCM_ALLOW_INTS;
01947 
01948   return path_to_tmscm (out);
01949 }
01950 
01951 tmscm
01952 tmg_path_previous_argument (tmscm arg1, tmscm arg2) {
01953   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-previous-argument");
01954   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-previous-argument");
01955 
01956   content in1= tmscm_to_content (arg1);
01957   path in2= tmscm_to_path (arg2);
01958 
01959   // TMSCM_DEFER_INTS;
01960   path out= previous_argument (in1, in2);
01961   // TMSCM_ALLOW_INTS;
01962 
01963   return path_to_tmscm (out);
01964 }
01965 
01966 tmscm
01967 tmg_path_previous_section (tmscm arg1, tmscm arg2) {
01968   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "path-previous-section");
01969   TMSCM_ASSERT_PATH (arg2, TMSCM_ARG2, "path-previous-section");
01970 
01971   content in1= tmscm_to_content (arg1);
01972   path in2= tmscm_to_path (arg2);
01973 
01974   // TMSCM_DEFER_INTS;
01975   path out= previous_section (in1, in2);
01976   // TMSCM_ALLOW_INTS;
01977 
01978   return path_to_tmscm (out);
01979 }
01980 
01981 tmscm
01982 tmg_tree_2ids (tmscm arg1) {
01983   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree->ids");
01984 
01985   tree in1= tmscm_to_tree (arg1);
01986 
01987   // TMSCM_DEFER_INTS;
01988   list_string out= get_ids (in1);
01989   // TMSCM_ALLOW_INTS;
01990 
01991   return list_string_to_tmscm (out);
01992 }
01993 
01994 tmscm
01995 tmg_id_2trees (tmscm arg1) {
01996   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "id->trees");
01997 
01998   string in1= tmscm_to_string (arg1);
01999 
02000   // TMSCM_DEFER_INTS;
02001   list_tree out= get_trees (in1);
02002   // TMSCM_ALLOW_INTS;
02003 
02004   return list_tree_to_tmscm (out);
02005 }
02006 
02007 tmscm
02008 tmg_vertex_2links (tmscm arg1) {
02009   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "vertex->links");
02010 
02011   content in1= tmscm_to_content (arg1);
02012 
02013   // TMSCM_DEFER_INTS;
02014   list_tree out= get_links (in1);
02015   // TMSCM_ALLOW_INTS;
02016 
02017   return list_tree_to_tmscm (out);
02018 }
02019 
02020 tmscm
02021 tmg_tree_2tree_pointer (tmscm arg1) {
02022   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree->tree-pointer");
02023 
02024   tree in1= tmscm_to_tree (arg1);
02025 
02026   // TMSCM_DEFER_INTS;
02027   observer out= tree_pointer_new (in1);
02028   // TMSCM_ALLOW_INTS;
02029 
02030   return observer_to_tmscm (out);
02031 }
02032 
02033 tmscm
02034 tmg_tree_pointer_detach (tmscm arg1) {
02035   TMSCM_ASSERT_OBSERVER (arg1, TMSCM_ARG1, "tree-pointer-detach");
02036 
02037   observer in1= tmscm_to_observer (arg1);
02038 
02039   // TMSCM_DEFER_INTS;
02040   tree_pointer_delete (in1);
02041   // TMSCM_ALLOW_INTS;
02042 
02043   return TMSCM_UNSPECIFIED;
02044 }
02045 
02046 tmscm
02047 tmg_tree_pointer_2tree (tmscm arg1) {
02048   TMSCM_ASSERT_OBSERVER (arg1, TMSCM_ARG1, "tree-pointer->tree");
02049 
02050   observer in1= tmscm_to_observer (arg1);
02051 
02052   // TMSCM_DEFER_INTS;
02053   tree out= obtain_tree (in1);
02054   // TMSCM_ALLOW_INTS;
02055 
02056   return tree_to_tmscm (out);
02057 }
02058 
02059 tmscm
02060 tmg_current_link_types () {
02061   // TMSCM_DEFER_INTS;
02062   list_string out= all_link_types ();
02063   // TMSCM_ALLOW_INTS;
02064 
02065   return list_string_to_tmscm (out);
02066 }
02067 
02068 tmscm
02069 tmg_get_locus_rendering (tmscm arg1) {
02070   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "get-locus-rendering");
02071 
02072   string in1= tmscm_to_string (arg1);
02073 
02074   // TMSCM_DEFER_INTS;
02075   string out= get_locus_rendering (in1);
02076   // TMSCM_ALLOW_INTS;
02077 
02078   return string_to_tmscm (out);
02079 }
02080 
02081 tmscm
02082 tmg_set_locus_rendering (tmscm arg1, tmscm arg2) {
02083   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "set-locus-rendering");
02084   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "set-locus-rendering");
02085 
02086   string in1= tmscm_to_string (arg1);
02087   string in2= tmscm_to_string (arg2);
02088 
02089   // TMSCM_DEFER_INTS;
02090   set_locus_rendering (in1, in2);
02091   // TMSCM_ALLOW_INTS;
02092 
02093   return TMSCM_UNSPECIFIED;
02094 }
02095 
02096 tmscm
02097 tmg_declare_visited (tmscm arg1) {
02098   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "declare-visited");
02099 
02100   string in1= tmscm_to_string (arg1);
02101 
02102   // TMSCM_DEFER_INTS;
02103   declare_visited (in1);
02104   // TMSCM_ALLOW_INTS;
02105 
02106   return TMSCM_UNSPECIFIED;
02107 }
02108 
02109 tmscm
02110 tmg_has_been_visitedP (tmscm arg1) {
02111   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "has-been-visited?");
02112 
02113   string in1= tmscm_to_string (arg1);
02114 
02115   // TMSCM_DEFER_INTS;
02116   bool out= has_been_visited (in1);
02117   // TMSCM_ALLOW_INTS;
02118 
02119   return bool_to_tmscm (out);
02120 }
02121 
02122 tmscm
02123 tmg_graphics_set (tmscm arg1, tmscm arg2) {
02124   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "graphics-set");
02125   TMSCM_ASSERT_CONTENT (arg2, TMSCM_ARG2, "graphics-set");
02126 
02127   content in1= tmscm_to_content (arg1);
02128   content in2= tmscm_to_content (arg2);
02129 
02130   // TMSCM_DEFER_INTS;
02131   set_graphical_value (in1, in2);
02132   // TMSCM_ALLOW_INTS;
02133 
02134   return TMSCM_UNSPECIFIED;
02135 }
02136 
02137 tmscm
02138 tmg_graphics_hasP (tmscm arg1) {
02139   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "graphics-has?");
02140 
02141   content in1= tmscm_to_content (arg1);
02142 
02143   // TMSCM_DEFER_INTS;
02144   bool out= has_graphical_value (in1);
02145   // TMSCM_ALLOW_INTS;
02146 
02147   return bool_to_tmscm (out);
02148 }
02149 
02150 tmscm
02151 tmg_graphics_ref (tmscm arg1) {
02152   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "graphics-ref");
02153 
02154   content in1= tmscm_to_content (arg1);
02155 
02156   // TMSCM_DEFER_INTS;
02157   tree out= get_graphical_value (in1);
02158   // TMSCM_ALLOW_INTS;
02159 
02160   return tree_to_tmscm (out);
02161 }
02162 
02163 tmscm
02164 tmg_graphics_needs_updateP () {
02165   // TMSCM_DEFER_INTS;
02166   bool out= graphics_needs_update ();
02167   // TMSCM_ALLOW_INTS;
02168 
02169   return bool_to_tmscm (out);
02170 }
02171 
02172 tmscm
02173 tmg_graphics_notify_update (tmscm arg1) {
02174   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "graphics-notify-update");
02175 
02176   content in1= tmscm_to_content (arg1);
02177 
02178   // TMSCM_DEFER_INTS;
02179   graphics_notify_update (in1);
02180   // TMSCM_ALLOW_INTS;
02181 
02182   return TMSCM_UNSPECIFIED;
02183 }
02184 
02185 tmscm
02186 tmg_string_numberP (tmscm arg1) {
02187   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-number?");
02188 
02189   string in1= tmscm_to_string (arg1);
02190 
02191   // TMSCM_DEFER_INTS;
02192   bool out= is_double (in1);
02193   // TMSCM_ALLOW_INTS;
02194 
02195   return bool_to_tmscm (out);
02196 }
02197 
02198 tmscm
02199 tmg_string_occursP (tmscm arg1, tmscm arg2) {
02200   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-occurs?");
02201   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "string-occurs?");
02202 
02203   string in1= tmscm_to_string (arg1);
02204   string in2= tmscm_to_string (arg2);
02205 
02206   // TMSCM_DEFER_INTS;
02207   bool out= occurs (in1, in2);
02208   // TMSCM_ALLOW_INTS;
02209 
02210   return bool_to_tmscm (out);
02211 }
02212 
02213 tmscm
02214 tmg_string_search_forwards (tmscm arg1, tmscm arg2, tmscm arg3) {
02215   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-search-forwards");
02216   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "string-search-forwards");
02217   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "string-search-forwards");
02218 
02219   string in1= tmscm_to_string (arg1);
02220   int in2= tmscm_to_int (arg2);
02221   string in3= tmscm_to_string (arg3);
02222 
02223   // TMSCM_DEFER_INTS;
02224   int out= search_forwards (in1, in2, in3);
02225   // TMSCM_ALLOW_INTS;
02226 
02227   return int_to_tmscm (out);
02228 }
02229 
02230 tmscm
02231 tmg_string_search_backwards (tmscm arg1, tmscm arg2, tmscm arg3) {
02232   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-search-backwards");
02233   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "string-search-backwards");
02234   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "string-search-backwards");
02235 
02236   string in1= tmscm_to_string (arg1);
02237   int in2= tmscm_to_int (arg2);
02238   string in3= tmscm_to_string (arg3);
02239 
02240   // TMSCM_DEFER_INTS;
02241   int out= search_backwards (in1, in2, in3);
02242   // TMSCM_ALLOW_INTS;
02243 
02244   return int_to_tmscm (out);
02245 }
02246 
02247 tmscm
02248 tmg_string_replace (tmscm arg1, tmscm arg2, tmscm arg3) {
02249   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-replace");
02250   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "string-replace");
02251   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "string-replace");
02252 
02253   string in1= tmscm_to_string (arg1);
02254   string in2= tmscm_to_string (arg2);
02255   string in3= tmscm_to_string (arg3);
02256 
02257   // TMSCM_DEFER_INTS;
02258   string out= replace (in1, in2, in3);
02259   // TMSCM_ALLOW_INTS;
02260 
02261   return string_to_tmscm (out);
02262 }
02263 
02264 tmscm
02265 tmg_string_alphaP (tmscm arg1) {
02266   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-alpha?");
02267 
02268   string in1= tmscm_to_string (arg1);
02269 
02270   // TMSCM_DEFER_INTS;
02271   bool out= is_alpha (in1);
02272   // TMSCM_ALLOW_INTS;
02273 
02274   return bool_to_tmscm (out);
02275 }
02276 
02277 tmscm
02278 tmg_string_locase_alphaP (tmscm arg1) {
02279   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-locase-alpha?");
02280 
02281   string in1= tmscm_to_string (arg1);
02282 
02283   // TMSCM_DEFER_INTS;
02284   bool out= is_locase_alpha (in1);
02285   // TMSCM_ALLOW_INTS;
02286 
02287   return bool_to_tmscm (out);
02288 }
02289 
02290 tmscm
02291 tmg_upcase_first (tmscm arg1) {
02292   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "upcase-first");
02293 
02294   string in1= tmscm_to_string (arg1);
02295 
02296   // TMSCM_DEFER_INTS;
02297   string out= upcase_first (in1);
02298   // TMSCM_ALLOW_INTS;
02299 
02300   return string_to_tmscm (out);
02301 }
02302 
02303 tmscm
02304 tmg_locase_first (tmscm arg1) {
02305   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "locase-first");
02306 
02307   string in1= tmscm_to_string (arg1);
02308 
02309   // TMSCM_DEFER_INTS;
02310   string out= locase_first (in1);
02311   // TMSCM_ALLOW_INTS;
02312 
02313   return string_to_tmscm (out);
02314 }
02315 
02316 tmscm
02317 tmg_upcase_all (tmscm arg1) {
02318   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "upcase-all");
02319 
02320   string in1= tmscm_to_string (arg1);
02321 
02322   // TMSCM_DEFER_INTS;
02323   string out= upcase_all (in1);
02324   // TMSCM_ALLOW_INTS;
02325 
02326   return string_to_tmscm (out);
02327 }
02328 
02329 tmscm
02330 tmg_locase_all (tmscm arg1) {
02331   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "locase-all");
02332 
02333   string in1= tmscm_to_string (arg1);
02334 
02335   // TMSCM_DEFER_INTS;
02336   string out= locase_all (in1);
02337   // TMSCM_ALLOW_INTS;
02338 
02339   return string_to_tmscm (out);
02340 }
02341 
02342 tmscm
02343 tmg_string_union (tmscm arg1, tmscm arg2) {
02344   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-union");
02345   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "string-union");
02346 
02347   string in1= tmscm_to_string (arg1);
02348   string in2= tmscm_to_string (arg2);
02349 
02350   // TMSCM_DEFER_INTS;
02351   string out= string_union (in1, in2);
02352   // TMSCM_ALLOW_INTS;
02353 
02354   return string_to_tmscm (out);
02355 }
02356 
02357 tmscm
02358 tmg_string_minus (tmscm arg1, tmscm arg2) {
02359   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-minus");
02360   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "string-minus");
02361 
02362   string in1= tmscm_to_string (arg1);
02363   string in2= tmscm_to_string (arg2);
02364 
02365   // TMSCM_DEFER_INTS;
02366   string out= string_minus (in1, in2);
02367   // TMSCM_ALLOW_INTS;
02368 
02369   return string_to_tmscm (out);
02370 }
02371 
02372 tmscm
02373 tmg_escape_generic (tmscm arg1) {
02374   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "escape-generic");
02375 
02376   string in1= tmscm_to_string (arg1);
02377 
02378   // TMSCM_DEFER_INTS;
02379   string out= escape_generic (in1);
02380   // TMSCM_ALLOW_INTS;
02381 
02382   return string_to_tmscm (out);
02383 }
02384 
02385 tmscm
02386 tmg_escape_verbatim (tmscm arg1) {
02387   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "escape-verbatim");
02388 
02389   string in1= tmscm_to_string (arg1);
02390 
02391   // TMSCM_DEFER_INTS;
02392   string out= escape_verbatim (in1);
02393   // TMSCM_ALLOW_INTS;
02394 
02395   return string_to_tmscm (out);
02396 }
02397 
02398 tmscm
02399 tmg_escape_shell (tmscm arg1) {
02400   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "escape-shell");
02401 
02402   string in1= tmscm_to_string (arg1);
02403 
02404   // TMSCM_DEFER_INTS;
02405   string out= escape_sh (in1);
02406   // TMSCM_ALLOW_INTS;
02407 
02408   return string_to_tmscm (out);
02409 }
02410 
02411 tmscm
02412 tmg_string_convert (tmscm arg1, tmscm arg2, tmscm arg3) {
02413   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-convert");
02414   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "string-convert");
02415   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "string-convert");
02416 
02417   string in1= tmscm_to_string (arg1);
02418   string in2= tmscm_to_string (arg2);
02419   string in3= tmscm_to_string (arg3);
02420 
02421   // TMSCM_DEFER_INTS;
02422   string out= convert (in1, in2, in3);
02423   // TMSCM_ALLOW_INTS;
02424 
02425   return string_to_tmscm (out);
02426 }
02427 
02428 tmscm
02429 tmg_utf8_2cork (tmscm arg1) {
02430   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "utf8->cork");
02431 
02432   string in1= tmscm_to_string (arg1);
02433 
02434   // TMSCM_DEFER_INTS;
02435   string out= utf8_to_cork (in1);
02436   // TMSCM_ALLOW_INTS;
02437 
02438   return string_to_tmscm (out);
02439 }
02440 
02441 tmscm
02442 tmg_cork_2utf8 (tmscm arg1) {
02443   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "cork->utf8");
02444 
02445   string in1= tmscm_to_string (arg1);
02446 
02447   // TMSCM_DEFER_INTS;
02448   string out= cork_to_utf8 (in1);
02449   // TMSCM_ALLOW_INTS;
02450 
02451   return string_to_tmscm (out);
02452 }
02453 
02454 tmscm
02455 tmg_utf8_2html (tmscm arg1) {
02456   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "utf8->html");
02457 
02458   string in1= tmscm_to_string (arg1);
02459 
02460   // TMSCM_DEFER_INTS;
02461   string out= utf8_to_html (in1);
02462   // TMSCM_ALLOW_INTS;
02463 
02464   return string_to_tmscm (out);
02465 }
02466 
02467 tmscm
02468 tmg_tm_2xml_name (tmscm arg1) {
02469   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tm->xml-name");
02470 
02471   string in1= tmscm_to_string (arg1);
02472 
02473   // TMSCM_DEFER_INTS;
02474   string out= tm_to_xml_name (in1);
02475   // TMSCM_ALLOW_INTS;
02476 
02477   return string_to_tmscm (out);
02478 }
02479 
02480 tmscm
02481 tmg_old_tm_2xml_cdata (tmscm arg1) {
02482   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "old-tm->xml-cdata");
02483 
02484   string in1= tmscm_to_string (arg1);
02485 
02486   // TMSCM_DEFER_INTS;
02487   string out= old_tm_to_xml_cdata (in1);
02488   // TMSCM_ALLOW_INTS;
02489 
02490   return string_to_tmscm (out);
02491 }
02492 
02493 tmscm
02494 tmg_tm_2xml_cdata (tmscm arg1) {
02495   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tm->xml-cdata");
02496 
02497   string in1= tmscm_to_string (arg1);
02498 
02499   // TMSCM_DEFER_INTS;
02500   object out= tm_to_xml_cdata (in1);
02501   // TMSCM_ALLOW_INTS;
02502 
02503   return object_to_tmscm (out);
02504 }
02505 
02506 tmscm
02507 tmg_xml_name_2tm (tmscm arg1) {
02508   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "xml-name->tm");
02509 
02510   string in1= tmscm_to_string (arg1);
02511 
02512   // TMSCM_DEFER_INTS;
02513   string out= xml_name_to_tm (in1);
02514   // TMSCM_ALLOW_INTS;
02515 
02516   return string_to_tmscm (out);
02517 }
02518 
02519 tmscm
02520 tmg_old_xml_cdata_2tm (tmscm arg1) {
02521   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "old-xml-cdata->tm");
02522 
02523   string in1= tmscm_to_string (arg1);
02524 
02525   // TMSCM_DEFER_INTS;
02526   string out= old_xml_cdata_to_tm (in1);
02527   // TMSCM_ALLOW_INTS;
02528 
02529   return string_to_tmscm (out);
02530 }
02531 
02532 tmscm
02533 tmg_xml_unspace (tmscm arg1, tmscm arg2, tmscm arg3) {
02534   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "xml-unspace");
02535   TMSCM_ASSERT_BOOL (arg2, TMSCM_ARG2, "xml-unspace");
02536   TMSCM_ASSERT_BOOL (arg3, TMSCM_ARG3, "xml-unspace");
02537 
02538   string in1= tmscm_to_string (arg1);
02539   bool in2= tmscm_to_bool (arg2);
02540   bool in3= tmscm_to_bool (arg3);
02541 
02542   // TMSCM_DEFER_INTS;
02543   string out= xml_unspace (in1, in2, in3);
02544   // TMSCM_ALLOW_INTS;
02545 
02546   return string_to_tmscm (out);
02547 }
02548 
02549 tmscm
02550 tmg_integer_2hexadecimal (tmscm arg1) {
02551   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "integer->hexadecimal");
02552 
02553   int in1= tmscm_to_int (arg1);
02554 
02555   // TMSCM_DEFER_INTS;
02556   string out= as_hexadecimal (in1);
02557   // TMSCM_ALLOW_INTS;
02558 
02559   return string_to_tmscm (out);
02560 }
02561 
02562 tmscm
02563 tmg_integer_2padded_hexadecimal (tmscm arg1, tmscm arg2) {
02564   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "integer->padded-hexadecimal");
02565   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "integer->padded-hexadecimal");
02566 
02567   int in1= tmscm_to_int (arg1);
02568   int in2= tmscm_to_int (arg2);
02569 
02570   // TMSCM_DEFER_INTS;
02571   string out= as_hexadecimal (in1, in2);
02572   // TMSCM_ALLOW_INTS;
02573 
02574   return string_to_tmscm (out);
02575 }
02576 
02577 tmscm
02578 tmg_hexadecimal_2integer (tmscm arg1) {
02579   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "hexadecimal->integer");
02580 
02581   string in1= tmscm_to_string (arg1);
02582 
02583   // TMSCM_DEFER_INTS;
02584   int out= from_hexadecimal (in1);
02585   // TMSCM_ALLOW_INTS;
02586 
02587   return int_to_tmscm (out);
02588 }
02589 
02590 tmscm
02591 tmg_string_2tmstring (tmscm arg1) {
02592   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string->tmstring");
02593 
02594   string in1= tmscm_to_string (arg1);
02595 
02596   // TMSCM_DEFER_INTS;
02597   string out= tm_encode (in1);
02598   // TMSCM_ALLOW_INTS;
02599 
02600   return string_to_tmscm (out);
02601 }
02602 
02603 tmscm
02604 tmg_tmstring_2string (tmscm arg1) {
02605   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmstring->string");
02606 
02607   string in1= tmscm_to_string (arg1);
02608 
02609   // TMSCM_DEFER_INTS;
02610   string out= tm_decode (in1);
02611   // TMSCM_ALLOW_INTS;
02612 
02613   return string_to_tmscm (out);
02614 }
02615 
02616 tmscm
02617 tmg_tmstring_length (tmscm arg1) {
02618   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmstring-length");
02619 
02620   string in1= tmscm_to_string (arg1);
02621 
02622   // TMSCM_DEFER_INTS;
02623   int out= tm_string_length (in1);
02624   // TMSCM_ALLOW_INTS;
02625 
02626   return int_to_tmscm (out);
02627 }
02628 
02629 tmscm
02630 tmg_tmstring_ref (tmscm arg1, tmscm arg2) {
02631   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmstring-ref");
02632   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tmstring-ref");
02633 
02634   string in1= tmscm_to_string (arg1);
02635   int in2= tmscm_to_int (arg2);
02636 
02637   // TMSCM_DEFER_INTS;
02638   string out= tm_forward_access (in1, in2);
02639   // TMSCM_ALLOW_INTS;
02640 
02641   return string_to_tmscm (out);
02642 }
02643 
02644 tmscm
02645 tmg_tmstring_reverse_ref (tmscm arg1, tmscm arg2) {
02646   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmstring-reverse-ref");
02647   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "tmstring-reverse-ref");
02648 
02649   string in1= tmscm_to_string (arg1);
02650   int in2= tmscm_to_int (arg2);
02651 
02652   // TMSCM_DEFER_INTS;
02653   string out= tm_backward_access (in1, in2);
02654   // TMSCM_ALLOW_INTS;
02655 
02656   return string_to_tmscm (out);
02657 }
02658 
02659 tmscm
02660 tmg_tmstring_2list (tmscm arg1) {
02661   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmstring->list");
02662 
02663   string in1= tmscm_to_string (arg1);
02664 
02665   // TMSCM_DEFER_INTS;
02666   array_string out= tm_tokenize (in1);
02667   // TMSCM_ALLOW_INTS;
02668 
02669   return array_string_to_tmscm (out);
02670 }
02671 
02672 tmscm
02673 tmg_list_2tmstring (tmscm arg1) {
02674   TMSCM_ASSERT_ARRAY_STRING (arg1, TMSCM_ARG1, "list->tmstring");
02675 
02676   array_string in1= tmscm_to_array_string (arg1);
02677 
02678   // TMSCM_DEFER_INTS;
02679   string out= tm_recompose (in1);
02680   // TMSCM_ALLOW_INTS;
02681 
02682   return string_to_tmscm (out);
02683 }
02684 
02685 tmscm
02686 tmg_string_next (tmscm arg1, tmscm arg2) {
02687   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-next");
02688   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "string-next");
02689 
02690   string in1= tmscm_to_string (arg1);
02691   int in2= tmscm_to_int (arg2);
02692 
02693   // TMSCM_DEFER_INTS;
02694   int out= tm_char_next (in1, in2);
02695   // TMSCM_ALLOW_INTS;
02696 
02697   return int_to_tmscm (out);
02698 }
02699 
02700 tmscm
02701 tmg_string_previous (tmscm arg1, tmscm arg2) {
02702   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-previous");
02703   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "string-previous");
02704 
02705   string in1= tmscm_to_string (arg1);
02706   int in2= tmscm_to_int (arg2);
02707 
02708   // TMSCM_DEFER_INTS;
02709   int out= tm_char_previous (in1, in2);
02710   // TMSCM_ALLOW_INTS;
02711 
02712   return int_to_tmscm (out);
02713 }
02714 
02715 tmscm
02716 tmg_packrat_define (tmscm arg1, tmscm arg2, tmscm arg3) {
02717   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "packrat-define");
02718   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "packrat-define");
02719   TMSCM_ASSERT_TREE (arg3, TMSCM_ARG3, "packrat-define");
02720 
02721   string in1= tmscm_to_string (arg1);
02722   string in2= tmscm_to_string (arg2);
02723   tree in3= tmscm_to_tree (arg3);
02724 
02725   // TMSCM_DEFER_INTS;
02726   packrat_define (in1, in2, in3);
02727   // TMSCM_ALLOW_INTS;
02728 
02729   return TMSCM_UNSPECIFIED;
02730 }
02731 
02732 tmscm
02733 tmg_packrat_property (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4) {
02734   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "packrat-property");
02735   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "packrat-property");
02736   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "packrat-property");
02737   TMSCM_ASSERT_STRING (arg4, TMSCM_ARG4, "packrat-property");
02738 
02739   string in1= tmscm_to_string (arg1);
02740   string in2= tmscm_to_string (arg2);
02741   string in3= tmscm_to_string (arg3);
02742   string in4= tmscm_to_string (arg4);
02743 
02744   // TMSCM_DEFER_INTS;
02745   packrat_property (in1, in2, in3, in4);
02746   // TMSCM_ALLOW_INTS;
02747 
02748   return TMSCM_UNSPECIFIED;
02749 }
02750 
02751 tmscm
02752 tmg_packrat_inherit (tmscm arg1, tmscm arg2) {
02753   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "packrat-inherit");
02754   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "packrat-inherit");
02755 
02756   string in1= tmscm_to_string (arg1);
02757   string in2= tmscm_to_string (arg2);
02758 
02759   // TMSCM_DEFER_INTS;
02760   packrat_inherit (in1, in2);
02761   // TMSCM_ALLOW_INTS;
02762 
02763   return TMSCM_UNSPECIFIED;
02764 }
02765 
02766 tmscm
02767 tmg_packrat_parse (tmscm arg1, tmscm arg2, tmscm arg3) {
02768   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "packrat-parse");
02769   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "packrat-parse");
02770   TMSCM_ASSERT_CONTENT (arg3, TMSCM_ARG3, "packrat-parse");
02771 
02772   string in1= tmscm_to_string (arg1);
02773   string in2= tmscm_to_string (arg2);
02774   content in3= tmscm_to_content (arg3);
02775 
02776   // TMSCM_DEFER_INTS;
02777   path out= packrat_parse (in1, in2, in3);
02778   // TMSCM_ALLOW_INTS;
02779 
02780   return path_to_tmscm (out);
02781 }
02782 
02783 tmscm
02784 tmg_packrat_correctP (tmscm arg1, tmscm arg2, tmscm arg3) {
02785   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "packrat-correct?");
02786   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "packrat-correct?");
02787   TMSCM_ASSERT_CONTENT (arg3, TMSCM_ARG3, "packrat-correct?");
02788 
02789   string in1= tmscm_to_string (arg1);
02790   string in2= tmscm_to_string (arg2);
02791   content in3= tmscm_to_content (arg3);
02792 
02793   // TMSCM_DEFER_INTS;
02794   bool out= packrat_correct (in1, in2, in3);
02795   // TMSCM_ALLOW_INTS;
02796 
02797   return bool_to_tmscm (out);
02798 }
02799 
02800 tmscm
02801 tmg_packrat_context (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4) {
02802   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "packrat-context");
02803   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "packrat-context");
02804   TMSCM_ASSERT_CONTENT (arg3, TMSCM_ARG3, "packrat-context");
02805   TMSCM_ASSERT_PATH (arg4, TMSCM_ARG4, "packrat-context");
02806 
02807   string in1= tmscm_to_string (arg1);
02808   string in2= tmscm_to_string (arg2);
02809   content in3= tmscm_to_content (arg3);
02810   path in4= tmscm_to_path (arg4);
02811 
02812   // TMSCM_DEFER_INTS;
02813   object out= packrat_context (in1, in2, in3, in4);
02814   // TMSCM_ALLOW_INTS;
02815 
02816   return object_to_tmscm (out);
02817 }
02818 
02819 tmscm
02820 tmg_parse_texmacs (tmscm arg1) {
02821   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "parse-texmacs");
02822 
02823   string in1= tmscm_to_string (arg1);
02824 
02825   // TMSCM_DEFER_INTS;
02826   tree out= texmacs_document_to_tree (in1);
02827   // TMSCM_ALLOW_INTS;
02828 
02829   return tree_to_tmscm (out);
02830 }
02831 
02832 tmscm
02833 tmg_serialize_texmacs (tmscm arg1) {
02834   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "serialize-texmacs");
02835 
02836   tree in1= tmscm_to_tree (arg1);
02837 
02838   // TMSCM_DEFER_INTS;
02839   string out= tree_to_texmacs (in1);
02840   // TMSCM_ALLOW_INTS;
02841 
02842   return string_to_tmscm (out);
02843 }
02844 
02845 tmscm
02846 tmg_parse_texmacs_snippet (tmscm arg1) {
02847   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "parse-texmacs-snippet");
02848 
02849   string in1= tmscm_to_string (arg1);
02850 
02851   // TMSCM_DEFER_INTS;
02852   tree out= texmacs_to_tree (in1);
02853   // TMSCM_ALLOW_INTS;
02854 
02855   return tree_to_tmscm (out);
02856 }
02857 
02858 tmscm
02859 tmg_serialize_texmacs_snippet (tmscm arg1) {
02860   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "serialize-texmacs-snippet");
02861 
02862   tree in1= tmscm_to_tree (arg1);
02863 
02864   // TMSCM_DEFER_INTS;
02865   string out= tree_to_texmacs (in1);
02866   // TMSCM_ALLOW_INTS;
02867 
02868   return string_to_tmscm (out);
02869 }
02870 
02871 tmscm
02872 tmg_texmacs_2stm (tmscm arg1) {
02873   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "texmacs->stm");
02874 
02875   tree in1= tmscm_to_tree (arg1);
02876 
02877   // TMSCM_DEFER_INTS;
02878   string out= tree_to_scheme (in1);
02879   // TMSCM_ALLOW_INTS;
02880 
02881   return string_to_tmscm (out);
02882 }
02883 
02884 tmscm
02885 tmg_stm_2texmacs (tmscm arg1) {
02886   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "stm->texmacs");
02887 
02888   string in1= tmscm_to_string (arg1);
02889 
02890   // TMSCM_DEFER_INTS;
02891   tree out= scheme_document_to_tree (in1);
02892   // TMSCM_ALLOW_INTS;
02893 
02894   return tree_to_tmscm (out);
02895 }
02896 
02897 tmscm
02898 tmg_stm_snippet_2texmacs (tmscm arg1) {
02899   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "stm-snippet->texmacs");
02900 
02901   string in1= tmscm_to_string (arg1);
02902 
02903   // TMSCM_DEFER_INTS;
02904   tree out= scheme_to_tree (in1);
02905   // TMSCM_ALLOW_INTS;
02906 
02907   return tree_to_tmscm (out);
02908 }
02909 
02910 tmscm
02911 tmg_cpp_texmacs_2verbatim (tmscm arg1, tmscm arg2, tmscm arg3) {
02912   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "cpp-texmacs->verbatim");
02913   TMSCM_ASSERT_BOOL (arg2, TMSCM_ARG2, "cpp-texmacs->verbatim");
02914   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "cpp-texmacs->verbatim");
02915 
02916   tree in1= tmscm_to_tree (arg1);
02917   bool in2= tmscm_to_bool (arg2);
02918   string in3= tmscm_to_string (arg3);
02919 
02920   // TMSCM_DEFER_INTS;
02921   string out= tree_to_verbatim (in1, in2, in3);
02922   // TMSCM_ALLOW_INTS;
02923 
02924   return string_to_tmscm (out);
02925 }
02926 
02927 tmscm
02928 tmg_cpp_verbatim_snippet_2texmacs (tmscm arg1, tmscm arg2, tmscm arg3) {
02929   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "cpp-verbatim-snippet->texmacs");
02930   TMSCM_ASSERT_BOOL (arg2, TMSCM_ARG2, "cpp-verbatim-snippet->texmacs");
02931   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "cpp-verbatim-snippet->texmacs");
02932 
02933   string in1= tmscm_to_string (arg1);
02934   bool in2= tmscm_to_bool (arg2);
02935   string in3= tmscm_to_string (arg3);
02936 
02937   // TMSCM_DEFER_INTS;
02938   tree out= verbatim_to_tree (in1, in2, in3);
02939   // TMSCM_ALLOW_INTS;
02940 
02941   return tree_to_tmscm (out);
02942 }
02943 
02944 tmscm
02945 tmg_cpp_verbatim_2texmacs (tmscm arg1, tmscm arg2, tmscm arg3) {
02946   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "cpp-verbatim->texmacs");
02947   TMSCM_ASSERT_BOOL (arg2, TMSCM_ARG2, "cpp-verbatim->texmacs");
02948   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "cpp-verbatim->texmacs");
02949 
02950   string in1= tmscm_to_string (arg1);
02951   bool in2= tmscm_to_bool (arg2);
02952   string in3= tmscm_to_string (arg3);
02953 
02954   // TMSCM_DEFER_INTS;
02955   tree out= verbatim_document_to_tree (in1, in2, in3);
02956   // TMSCM_ALLOW_INTS;
02957 
02958   return tree_to_tmscm (out);
02959 }
02960 
02961 tmscm
02962 tmg_parse_latex (tmscm arg1) {
02963   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "parse-latex");
02964 
02965   string in1= tmscm_to_string (arg1);
02966 
02967   // TMSCM_DEFER_INTS;
02968   tree out= parse_latex (in1);
02969   // TMSCM_ALLOW_INTS;
02970 
02971   return tree_to_tmscm (out);
02972 }
02973 
02974 tmscm
02975 tmg_parse_latex_document (tmscm arg1) {
02976   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "parse-latex-document");
02977 
02978   string in1= tmscm_to_string (arg1);
02979 
02980   // TMSCM_DEFER_INTS;
02981   tree out= parse_latex_document (in1);
02982   // TMSCM_ALLOW_INTS;
02983 
02984   return tree_to_tmscm (out);
02985 }
02986 
02987 tmscm
02988 tmg_latex_2texmacs (tmscm arg1) {
02989   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "latex->texmacs");
02990 
02991   tree in1= tmscm_to_tree (arg1);
02992 
02993   // TMSCM_DEFER_INTS;
02994   tree out= latex_to_tree (in1);
02995   // TMSCM_ALLOW_INTS;
02996 
02997   return tree_to_tmscm (out);
02998 }
02999 
03000 tmscm
03001 tmg_latex_document_2texmacs (tmscm arg1) {
03002   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "latex-document->texmacs");
03003 
03004   string in1= tmscm_to_string (arg1);
03005 
03006   // TMSCM_DEFER_INTS;
03007   tree out= latex_document_to_tree (in1);
03008   // TMSCM_ALLOW_INTS;
03009 
03010   return tree_to_tmscm (out);
03011 }
03012 
03013 tmscm
03014 tmg_latex_class_document_2texmacs (tmscm arg1) {
03015   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "latex-class-document->texmacs");
03016 
03017   string in1= tmscm_to_string (arg1);
03018 
03019   // TMSCM_DEFER_INTS;
03020   tree out= latex_class_document_to_tree (in1);
03021   // TMSCM_ALLOW_INTS;
03022 
03023   return tree_to_tmscm (out);
03024 }
03025 
03026 tmscm
03027 tmg_parse_xml (tmscm arg1) {
03028   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "parse-xml");
03029 
03030   string in1= tmscm_to_string (arg1);
03031 
03032   // TMSCM_DEFER_INTS;
03033   scheme_tree out= parse_xml (in1);
03034   // TMSCM_ALLOW_INTS;
03035 
03036   return scheme_tree_to_tmscm (out);
03037 }
03038 
03039 tmscm
03040 tmg_parse_html (tmscm arg1) {
03041   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "parse-html");
03042 
03043   string in1= tmscm_to_string (arg1);
03044 
03045   // TMSCM_DEFER_INTS;
03046   scheme_tree out= parse_html (in1);
03047   // TMSCM_ALLOW_INTS;
03048 
03049   return scheme_tree_to_tmscm (out);
03050 }
03051 
03052 tmscm
03053 tmg_parse_bib (tmscm arg1) {
03054   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "parse-bib");
03055 
03056   string in1= tmscm_to_string (arg1);
03057 
03058   // TMSCM_DEFER_INTS;
03059   tree out= parse_bib (in1);
03060   // TMSCM_ALLOW_INTS;
03061 
03062   return tree_to_tmscm (out);
03063 }
03064 
03065 tmscm
03066 tmg_upgrade_tmml (tmscm arg1) {
03067   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "upgrade-tmml");
03068 
03069   scheme_tree in1= tmscm_to_scheme_tree (arg1);
03070 
03071   // TMSCM_DEFER_INTS;
03072   tree out= tmml_upgrade (in1);
03073   // TMSCM_ALLOW_INTS;
03074 
03075   return tree_to_tmscm (out);
03076 }
03077 
03078 tmscm
03079 tmg_upgrade_mathml (tmscm arg1) {
03080   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "upgrade-mathml");
03081 
03082   content in1= tmscm_to_content (arg1);
03083 
03084   // TMSCM_DEFER_INTS;
03085   tree out= upgrade_mathml (in1);
03086   // TMSCM_ALLOW_INTS;
03087 
03088   return tree_to_tmscm (out);
03089 }
03090 
03091 tmscm
03092 tmg_string_2url (tmscm arg1) {
03093   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string->url");
03094 
03095   string in1= tmscm_to_string (arg1);
03096 
03097   // TMSCM_DEFER_INTS;
03098   url out= url (in1);
03099   // TMSCM_ALLOW_INTS;
03100 
03101   return url_to_tmscm (out);
03102 }
03103 
03104 tmscm
03105 tmg_url (tmscm arg1, tmscm arg2) {
03106   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "url");
03107   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "url");
03108 
03109   string in1= tmscm_to_string (arg1);
03110   string in2= tmscm_to_string (arg2);
03111 
03112   // TMSCM_DEFER_INTS;
03113   url out= url (in1, in2);
03114   // TMSCM_ALLOW_INTS;
03115 
03116   return url_to_tmscm (out);
03117 }
03118 
03119 tmscm
03120 tmg_url_system (tmscm arg1) {
03121   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "url-system");
03122 
03123   string in1= tmscm_to_string (arg1);
03124 
03125   // TMSCM_DEFER_INTS;
03126   url out= url_system (in1);
03127   // TMSCM_ALLOW_INTS;
03128 
03129   return url_to_tmscm (out);
03130 }
03131 
03132 tmscm
03133 tmg_url_none () {
03134   // TMSCM_DEFER_INTS;
03135   url out= url_none ();
03136   // TMSCM_ALLOW_INTS;
03137 
03138   return url_to_tmscm (out);
03139 }
03140 
03141 tmscm
03142 tmg_url_any () {
03143   // TMSCM_DEFER_INTS;
03144   url out= url_wildcard ();
03145   // TMSCM_ALLOW_INTS;
03146 
03147   return url_to_tmscm (out);
03148 }
03149 
03150 tmscm
03151 tmg_url_wildcard (tmscm arg1) {
03152   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "url-wildcard");
03153 
03154   string in1= tmscm_to_string (arg1);
03155 
03156   // TMSCM_DEFER_INTS;
03157   url out= url_wildcard (in1);
03158   // TMSCM_ALLOW_INTS;
03159 
03160   return url_to_tmscm (out);
03161 }
03162 
03163 tmscm
03164 tmg_url_parent () {
03165   // TMSCM_DEFER_INTS;
03166   url out= url_parent ();
03167   // TMSCM_ALLOW_INTS;
03168 
03169   return url_to_tmscm (out);
03170 }
03171 
03172 tmscm
03173 tmg_url_ancestor () {
03174   // TMSCM_DEFER_INTS;
03175   url out= url_ancestor ();
03176   // TMSCM_ALLOW_INTS;
03177 
03178   return url_to_tmscm (out);
03179 }
03180 
03181 tmscm
03182 tmg_url_append (tmscm arg1, tmscm arg2) {
03183   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-append");
03184   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "url-append");
03185 
03186   url in1= tmscm_to_url (arg1);
03187   url in2= tmscm_to_url (arg2);
03188 
03189   // TMSCM_DEFER_INTS;
03190   url out= url_concat (in1, in2);
03191   // TMSCM_ALLOW_INTS;
03192 
03193   return url_to_tmscm (out);
03194 }
03195 
03196 tmscm
03197 tmg_url_or (tmscm arg1, tmscm arg2) {
03198   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-or");
03199   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "url-or");
03200 
03201   url in1= tmscm_to_url (arg1);
03202   url in2= tmscm_to_url (arg2);
03203 
03204   // TMSCM_DEFER_INTS;
03205   url out= url_or (in1, in2);
03206   // TMSCM_ALLOW_INTS;
03207 
03208   return url_to_tmscm (out);
03209 }
03210 
03211 tmscm
03212 tmg_url_2string (tmscm arg1) {
03213   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url->string");
03214 
03215   url in1= tmscm_to_url (arg1);
03216 
03217   // TMSCM_DEFER_INTS;
03218   string out= as_string (in1);
03219   // TMSCM_ALLOW_INTS;
03220 
03221   return string_to_tmscm (out);
03222 }
03223 
03224 tmscm
03225 tmg_url_noneP (tmscm arg1) {
03226   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-none?");
03227 
03228   url in1= tmscm_to_url (arg1);
03229 
03230   // TMSCM_DEFER_INTS;
03231   bool out= is_none (in1);
03232   // TMSCM_ALLOW_INTS;
03233 
03234   return bool_to_tmscm (out);
03235 }
03236 
03237 tmscm
03238 tmg_url_rooted_webP (tmscm arg1) {
03239   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-rooted-web?");
03240 
03241   url in1= tmscm_to_url (arg1);
03242 
03243   // TMSCM_DEFER_INTS;
03244   bool out= is_rooted_web (in1);
03245   // TMSCM_ALLOW_INTS;
03246 
03247   return bool_to_tmscm (out);
03248 }
03249 
03250 tmscm
03251 tmg_url_concatP (tmscm arg1) {
03252   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-concat?");
03253 
03254   url in1= tmscm_to_url (arg1);
03255 
03256   // TMSCM_DEFER_INTS;
03257   bool out= is_concat (in1);
03258   // TMSCM_ALLOW_INTS;
03259 
03260   return bool_to_tmscm (out);
03261 }
03262 
03263 tmscm
03264 tmg_url_orP (tmscm arg1) {
03265   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-or?");
03266 
03267   url in1= tmscm_to_url (arg1);
03268 
03269   // TMSCM_DEFER_INTS;
03270   bool out= is_or (in1);
03271   // TMSCM_ALLOW_INTS;
03272 
03273   return bool_to_tmscm (out);
03274 }
03275 
03276 tmscm
03277 tmg_url_ref (tmscm arg1, tmscm arg2) {
03278   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-ref");
03279   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "url-ref");
03280 
03281   url in1= tmscm_to_url (arg1);
03282   int in2= tmscm_to_int (arg2);
03283 
03284   // TMSCM_DEFER_INTS;
03285   url out= url_ref (in1, in2);
03286   // TMSCM_ALLOW_INTS;
03287 
03288   return url_to_tmscm (out);
03289 }
03290 
03291 tmscm
03292 tmg_url_head (tmscm arg1) {
03293   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-head");
03294 
03295   url in1= tmscm_to_url (arg1);
03296 
03297   // TMSCM_DEFER_INTS;
03298   url out= head (in1);
03299   // TMSCM_ALLOW_INTS;
03300 
03301   return url_to_tmscm (out);
03302 }
03303 
03304 tmscm
03305 tmg_url_tail (tmscm arg1) {
03306   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-tail");
03307 
03308   url in1= tmscm_to_url (arg1);
03309 
03310   // TMSCM_DEFER_INTS;
03311   url out= tail (in1);
03312   // TMSCM_ALLOW_INTS;
03313 
03314   return url_to_tmscm (out);
03315 }
03316 
03317 tmscm
03318 tmg_url_suffix (tmscm arg1) {
03319   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-suffix");
03320 
03321   url in1= tmscm_to_url (arg1);
03322 
03323   // TMSCM_DEFER_INTS;
03324   string out= suffix (in1);
03325   // TMSCM_ALLOW_INTS;
03326 
03327   return string_to_tmscm (out);
03328 }
03329 
03330 tmscm
03331 tmg_url_glue (tmscm arg1, tmscm arg2) {
03332   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-glue");
03333   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "url-glue");
03334 
03335   url in1= tmscm_to_url (arg1);
03336   string in2= tmscm_to_string (arg2);
03337 
03338   // TMSCM_DEFER_INTS;
03339   url out= glue (in1, in2);
03340   // TMSCM_ALLOW_INTS;
03341 
03342   return url_to_tmscm (out);
03343 }
03344 
03345 tmscm
03346 tmg_url_unglue (tmscm arg1, tmscm arg2) {
03347   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-unglue");
03348   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "url-unglue");
03349 
03350   url in1= tmscm_to_url (arg1);
03351   int in2= tmscm_to_int (arg2);
03352 
03353   // TMSCM_DEFER_INTS;
03354   url out= unglue (in1, in2);
03355   // TMSCM_ALLOW_INTS;
03356 
03357   return url_to_tmscm (out);
03358 }
03359 
03360 tmscm
03361 tmg_url_relative (tmscm arg1, tmscm arg2) {
03362   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-relative");
03363   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "url-relative");
03364 
03365   url in1= tmscm_to_url (arg1);
03366   url in2= tmscm_to_url (arg2);
03367 
03368   // TMSCM_DEFER_INTS;
03369   url out= relative (in1, in2);
03370   // TMSCM_ALLOW_INTS;
03371 
03372   return url_to_tmscm (out);
03373 }
03374 
03375 tmscm
03376 tmg_url_expand (tmscm arg1) {
03377   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-expand");
03378 
03379   url in1= tmscm_to_url (arg1);
03380 
03381   // TMSCM_DEFER_INTS;
03382   url out= expand (in1);
03383   // TMSCM_ALLOW_INTS;
03384 
03385   return url_to_tmscm (out);
03386 }
03387 
03388 tmscm
03389 tmg_url_factor (tmscm arg1) {
03390   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-factor");
03391 
03392   url in1= tmscm_to_url (arg1);
03393 
03394   // TMSCM_DEFER_INTS;
03395   url out= factor (in1);
03396   // TMSCM_ALLOW_INTS;
03397 
03398   return url_to_tmscm (out);
03399 }
03400 
03401 tmscm
03402 tmg_url_delta (tmscm arg1, tmscm arg2) {
03403   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-delta");
03404   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "url-delta");
03405 
03406   url in1= tmscm_to_url (arg1);
03407   url in2= tmscm_to_url (arg2);
03408 
03409   // TMSCM_DEFER_INTS;
03410   url out= delta (in1, in2);
03411   // TMSCM_ALLOW_INTS;
03412 
03413   return url_to_tmscm (out);
03414 }
03415 
03416 tmscm
03417 tmg_url_secureP (tmscm arg1) {
03418   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-secure?");
03419 
03420   url in1= tmscm_to_url (arg1);
03421 
03422   // TMSCM_DEFER_INTS;
03423   bool out= is_secure (in1);
03424   // TMSCM_ALLOW_INTS;
03425 
03426   return bool_to_tmscm (out);
03427 }
03428 
03429 tmscm
03430 tmg_url_descendsP (tmscm arg1, tmscm arg2) {
03431   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-descends?");
03432   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "url-descends?");
03433 
03434   url in1= tmscm_to_url (arg1);
03435   url in2= tmscm_to_url (arg2);
03436 
03437   // TMSCM_DEFER_INTS;
03438   bool out= descends (in1, in2);
03439   // TMSCM_ALLOW_INTS;
03440 
03441   return bool_to_tmscm (out);
03442 }
03443 
03444 tmscm
03445 tmg_url_complete (tmscm arg1, tmscm arg2) {
03446   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-complete");
03447   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "url-complete");
03448 
03449   url in1= tmscm_to_url (arg1);
03450   string in2= tmscm_to_string (arg2);
03451 
03452   // TMSCM_DEFER_INTS;
03453   url out= complete (in1, in2);
03454   // TMSCM_ALLOW_INTS;
03455 
03456   return url_to_tmscm (out);
03457 }
03458 
03459 tmscm
03460 tmg_url_resolve (tmscm arg1, tmscm arg2) {
03461   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-resolve");
03462   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "url-resolve");
03463 
03464   url in1= tmscm_to_url (arg1);
03465   string in2= tmscm_to_string (arg2);
03466 
03467   // TMSCM_DEFER_INTS;
03468   url out= resolve (in1, in2);
03469   // TMSCM_ALLOW_INTS;
03470 
03471   return url_to_tmscm (out);
03472 }
03473 
03474 tmscm
03475 tmg_url_resolve_in_path (tmscm arg1) {
03476   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-resolve-in-path");
03477 
03478   url in1= tmscm_to_url (arg1);
03479 
03480   // TMSCM_DEFER_INTS;
03481   url out= resolve_in_path (in1);
03482   // TMSCM_ALLOW_INTS;
03483 
03484   return url_to_tmscm (out);
03485 }
03486 
03487 tmscm
03488 tmg_url_existsP (tmscm arg1) {
03489   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-exists?");
03490 
03491   url in1= tmscm_to_url (arg1);
03492 
03493   // TMSCM_DEFER_INTS;
03494   bool out= exists (in1);
03495   // TMSCM_ALLOW_INTS;
03496 
03497   return bool_to_tmscm (out);
03498 }
03499 
03500 tmscm
03501 tmg_url_exists_in_pathP (tmscm arg1) {
03502   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-exists-in-path?");
03503 
03504   url in1= tmscm_to_url (arg1);
03505 
03506   // TMSCM_DEFER_INTS;
03507   bool out= exists_in_path (in1);
03508   // TMSCM_ALLOW_INTS;
03509 
03510   return bool_to_tmscm (out);
03511 }
03512 
03513 tmscm
03514 tmg_url_exists_in_texP (tmscm arg1) {
03515   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-exists-in-tex?");
03516 
03517   url in1= tmscm_to_url (arg1);
03518 
03519   // TMSCM_DEFER_INTS;
03520   bool out= exists_in_tex (in1);
03521   // TMSCM_ALLOW_INTS;
03522 
03523   return bool_to_tmscm (out);
03524 }
03525 
03526 tmscm
03527 tmg_url_concretize (tmscm arg1) {
03528   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-concretize");
03529 
03530   url in1= tmscm_to_url (arg1);
03531 
03532   // TMSCM_DEFER_INTS;
03533   string out= concretize (in1);
03534   // TMSCM_ALLOW_INTS;
03535 
03536   return string_to_tmscm (out);
03537 }
03538 
03539 tmscm
03540 tmg_url_materialize (tmscm arg1, tmscm arg2) {
03541   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-materialize");
03542   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "url-materialize");
03543 
03544   url in1= tmscm_to_url (arg1);
03545   string in2= tmscm_to_string (arg2);
03546 
03547   // TMSCM_DEFER_INTS;
03548   string out= materialize (in1, in2);
03549   // TMSCM_ALLOW_INTS;
03550 
03551   return string_to_tmscm (out);
03552 }
03553 
03554 tmscm
03555 tmg_url_testP (tmscm arg1, tmscm arg2) {
03556   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-test?");
03557   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "url-test?");
03558 
03559   url in1= tmscm_to_url (arg1);
03560   string in2= tmscm_to_string (arg2);
03561 
03562   // TMSCM_DEFER_INTS;
03563   bool out= is_of_type (in1, in2);
03564   // TMSCM_ALLOW_INTS;
03565 
03566   return bool_to_tmscm (out);
03567 }
03568 
03569 tmscm
03570 tmg_url_regularP (tmscm arg1) {
03571   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-regular?");
03572 
03573   url in1= tmscm_to_url (arg1);
03574 
03575   // TMSCM_DEFER_INTS;
03576   bool out= is_regular (in1);
03577   // TMSCM_ALLOW_INTS;
03578 
03579   return bool_to_tmscm (out);
03580 }
03581 
03582 tmscm
03583 tmg_url_directoryP (tmscm arg1) {
03584   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-directory?");
03585 
03586   url in1= tmscm_to_url (arg1);
03587 
03588   // TMSCM_DEFER_INTS;
03589   bool out= is_directory (in1);
03590   // TMSCM_ALLOW_INTS;
03591 
03592   return bool_to_tmscm (out);
03593 }
03594 
03595 tmscm
03596 tmg_url_linkP (tmscm arg1) {
03597   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-link?");
03598 
03599   url in1= tmscm_to_url (arg1);
03600 
03601   // TMSCM_DEFER_INTS;
03602   bool out= is_symbolic_link (in1);
03603   // TMSCM_ALLOW_INTS;
03604 
03605   return bool_to_tmscm (out);
03606 }
03607 
03608 tmscm
03609 tmg_url_newerP (tmscm arg1, tmscm arg2) {
03610   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-newer?");
03611   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "url-newer?");
03612 
03613   url in1= tmscm_to_url (arg1);
03614   url in2= tmscm_to_url (arg2);
03615 
03616   // TMSCM_DEFER_INTS;
03617   bool out= is_newer (in1, in2);
03618   // TMSCM_ALLOW_INTS;
03619 
03620   return bool_to_tmscm (out);
03621 }
03622 
03623 tmscm
03624 tmg_url_last_modified (tmscm arg1) {
03625   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-last-modified");
03626 
03627   url in1= tmscm_to_url (arg1);
03628 
03629   // TMSCM_DEFER_INTS;
03630   int out= last_modified (in1);
03631   // TMSCM_ALLOW_INTS;
03632 
03633   return int_to_tmscm (out);
03634 }
03635 
03636 tmscm
03637 tmg_url_temp () {
03638   // TMSCM_DEFER_INTS;
03639   url out= url_temp ();
03640   // TMSCM_ALLOW_INTS;
03641 
03642   return url_to_tmscm (out);
03643 }
03644 
03645 tmscm
03646 tmg_url_scratch (tmscm arg1, tmscm arg2, tmscm arg3) {
03647   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "url-scratch");
03648   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "url-scratch");
03649   TMSCM_ASSERT_INT (arg3, TMSCM_ARG3, "url-scratch");
03650 
03651   string in1= tmscm_to_string (arg1);
03652   string in2= tmscm_to_string (arg2);
03653   int in3= tmscm_to_int (arg3);
03654 
03655   // TMSCM_DEFER_INTS;
03656   url out= url_scratch (in1, in2, in3);
03657   // TMSCM_ALLOW_INTS;
03658 
03659   return url_to_tmscm (out);
03660 }
03661 
03662 tmscm
03663 tmg_url_scratchP (tmscm arg1) {
03664   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "url-scratch?");
03665 
03666   url in1= tmscm_to_url (arg1);
03667 
03668   // TMSCM_DEFER_INTS;
03669   bool out= is_scratch (in1);
03670   // TMSCM_ALLOW_INTS;
03671 
03672   return bool_to_tmscm (out);
03673 }
03674 
03675 tmscm
03676 tmg_string_save (tmscm arg1, tmscm arg2) {
03677   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "string-save");
03678   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "string-save");
03679 
03680   string in1= tmscm_to_string (arg1);
03681   url in2= tmscm_to_url (arg2);
03682 
03683   // TMSCM_DEFER_INTS;
03684   string_save (in1, in2);
03685   // TMSCM_ALLOW_INTS;
03686 
03687   return TMSCM_UNSPECIFIED;
03688 }
03689 
03690 tmscm
03691 tmg_string_load (tmscm arg1) {
03692   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "string-load");
03693 
03694   url in1= tmscm_to_url (arg1);
03695 
03696   // TMSCM_DEFER_INTS;
03697   string out= string_load (in1);
03698   // TMSCM_ALLOW_INTS;
03699 
03700   return string_to_tmscm (out);
03701 }
03702 
03703 tmscm
03704 tmg_system_move (tmscm arg1, tmscm arg2) {
03705   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "system-move");
03706   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "system-move");
03707 
03708   url in1= tmscm_to_url (arg1);
03709   url in2= tmscm_to_url (arg2);
03710 
03711   // TMSCM_DEFER_INTS;
03712   move (in1, in2);
03713   // TMSCM_ALLOW_INTS;
03714 
03715   return TMSCM_UNSPECIFIED;
03716 }
03717 
03718 tmscm
03719 tmg_system_copy (tmscm arg1, tmscm arg2) {
03720   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "system-copy");
03721   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "system-copy");
03722 
03723   url in1= tmscm_to_url (arg1);
03724   url in2= tmscm_to_url (arg2);
03725 
03726   // TMSCM_DEFER_INTS;
03727   copy (in1, in2);
03728   // TMSCM_ALLOW_INTS;
03729 
03730   return TMSCM_UNSPECIFIED;
03731 }
03732 
03733 tmscm
03734 tmg_system_remove (tmscm arg1) {
03735   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "system-remove");
03736 
03737   url in1= tmscm_to_url (arg1);
03738 
03739   // TMSCM_DEFER_INTS;
03740   remove (in1);
03741   // TMSCM_ALLOW_INTS;
03742 
03743   return TMSCM_UNSPECIFIED;
03744 }
03745 
03746 tmscm
03747 tmg_system_mkdir (tmscm arg1) {
03748   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "system-mkdir");
03749 
03750   url in1= tmscm_to_url (arg1);
03751 
03752   // TMSCM_DEFER_INTS;
03753   mkdir (in1);
03754   // TMSCM_ALLOW_INTS;
03755 
03756   return TMSCM_UNSPECIFIED;
03757 }
03758 
03759 tmscm
03760 tmg_system_search_score (tmscm arg1, tmscm arg2) {
03761   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "system-search-score");
03762   TMSCM_ASSERT_ARRAY_STRING (arg2, TMSCM_ARG2, "system-search-score");
03763 
03764   url in1= tmscm_to_url (arg1);
03765   array_string in2= tmscm_to_array_string (arg2);
03766 
03767   // TMSCM_DEFER_INTS;
03768   int out= search_score (in1, in2);
03769   // TMSCM_ALLOW_INTS;
03770 
03771   return int_to_tmscm (out);
03772 }
03773 
03774 tmscm
03775 tmg_system_1 (tmscm arg1, tmscm arg2) {
03776   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "system-1");
03777   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "system-1");
03778 
03779   string in1= tmscm_to_string (arg1);
03780   url in2= tmscm_to_url (arg2);
03781 
03782   // TMSCM_DEFER_INTS;
03783   system (in1, in2);
03784   // TMSCM_ALLOW_INTS;
03785 
03786   return TMSCM_UNSPECIFIED;
03787 }
03788 
03789 tmscm
03790 tmg_system_2 (tmscm arg1, tmscm arg2, tmscm arg3) {
03791   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "system-2");
03792   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "system-2");
03793   TMSCM_ASSERT_URL (arg3, TMSCM_ARG3, "system-2");
03794 
03795   string in1= tmscm_to_string (arg1);
03796   url in2= tmscm_to_url (arg2);
03797   url in3= tmscm_to_url (arg3);
03798 
03799   // TMSCM_DEFER_INTS;
03800   system (in1, in2, in3);
03801   // TMSCM_ALLOW_INTS;
03802 
03803   return TMSCM_UNSPECIFIED;
03804 }
03805 
03806 tmscm
03807 tmg_tmfs_set (tmscm arg1, tmscm arg2) {
03808   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-set");
03809   TMSCM_ASSERT_COLLECTION (arg2, TMSCM_ARG2, "tmfs-set");
03810 
03811   string in1= tmscm_to_string (arg1);
03812   collection in2= tmscm_to_collection (arg2);
03813 
03814   // TMSCM_DEFER_INTS;
03815   tmfs_set (in1, in2);
03816   // TMSCM_ALLOW_INTS;
03817 
03818   return TMSCM_UNSPECIFIED;
03819 }
03820 
03821 tmscm
03822 tmg_tmfs_reset (tmscm arg1, tmscm arg2) {
03823   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-reset");
03824   TMSCM_ASSERT_COLLECTION (arg2, TMSCM_ARG2, "tmfs-reset");
03825 
03826   string in1= tmscm_to_string (arg1);
03827   collection in2= tmscm_to_collection (arg2);
03828 
03829   // TMSCM_DEFER_INTS;
03830   tmfs_reset (in1, in2);
03831   // TMSCM_ALLOW_INTS;
03832 
03833   return TMSCM_UNSPECIFIED;
03834 }
03835 
03836 tmscm
03837 tmg_tmfs_get (tmscm arg1) {
03838   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-get");
03839 
03840   string in1= tmscm_to_string (arg1);
03841 
03842   // TMSCM_DEFER_INTS;
03843   collection out= tmfs_get (in1);
03844   // TMSCM_ALLOW_INTS;
03845 
03846   return collection_to_tmscm (out);
03847 }
03848 
03849 tmscm
03850 tmg_tmfs_new_save (tmscm arg1, tmscm arg2) {
03851   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-new-save");
03852   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "tmfs-new-save");
03853 
03854   string in1= tmscm_to_string (arg1);
03855   string in2= tmscm_to_string (arg2);
03856 
03857   // TMSCM_DEFER_INTS;
03858   tmfs_save (in1, in2);
03859   // TMSCM_ALLOW_INTS;
03860 
03861   return TMSCM_UNSPECIFIED;
03862 }
03863 
03864 tmscm
03865 tmg_tmfs_new_remove (tmscm arg1) {
03866   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-new-remove");
03867 
03868   string in1= tmscm_to_string (arg1);
03869 
03870   // TMSCM_DEFER_INTS;
03871   tmfs_remove (in1);
03872   // TMSCM_ALLOW_INTS;
03873 
03874   return TMSCM_UNSPECIFIED;
03875 }
03876 
03877 tmscm
03878 tmg_tmfs_new_load (tmscm arg1) {
03879   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-new-load");
03880 
03881   string in1= tmscm_to_string (arg1);
03882 
03883   // TMSCM_DEFER_INTS;
03884   string out= tmfs_load (in1);
03885   // TMSCM_ALLOW_INTS;
03886 
03887   return string_to_tmscm (out);
03888 }
03889 
03890 tmscm
03891 tmg_tmfs_create_ressource () {
03892   // TMSCM_DEFER_INTS;
03893   string out= tmfs_create_ressource ();
03894   // TMSCM_ALLOW_INTS;
03895 
03896   return string_to_tmscm (out);
03897 }
03898 
03899 tmscm
03900 tmg_tmfs_ressource_head (tmscm arg1) {
03901   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-ressource-head");
03902 
03903   string in1= tmscm_to_string (arg1);
03904 
03905   // TMSCM_DEFER_INTS;
03906   string out= tmfs_get_head (in1);
03907   // TMSCM_ALLOW_INTS;
03908 
03909   return string_to_tmscm (out);
03910 }
03911 
03912 tmscm
03913 tmg_tmfs_ressource_versions (tmscm arg1) {
03914   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-ressource-versions");
03915 
03916   string in1= tmscm_to_string (arg1);
03917 
03918   // TMSCM_DEFER_INTS;
03919   collection out= tmfs_get_versions (in1);
03920   // TMSCM_ALLOW_INTS;
03921 
03922   return collection_to_tmscm (out);
03923 }
03924 
03925 tmscm
03926 tmg_tmfs_save_ressource (tmscm arg1, tmscm arg2, tmscm arg3) {
03927   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-save-ressource");
03928   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "tmfs-save-ressource");
03929   TMSCM_ASSERT_PROPERTIES (arg3, TMSCM_ARG3, "tmfs-save-ressource");
03930 
03931   string in1= tmscm_to_string (arg1);
03932   string in2= tmscm_to_string (arg2);
03933   properties in3= tmscm_to_properties (arg3);
03934 
03935   // TMSCM_DEFER_INTS;
03936   tmfs_save_ressource (in1, in2, in3);
03937   // TMSCM_ALLOW_INTS;
03938 
03939   return TMSCM_UNSPECIFIED;
03940 }
03941 
03942 tmscm
03943 tmg_tmfs_load_ressource_file (tmscm arg1) {
03944   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-load-ressource-file");
03945 
03946   string in1= tmscm_to_string (arg1);
03947 
03948   // TMSCM_DEFER_INTS;
03949   string out= tmfs_load_ressource_file (in1);
03950   // TMSCM_ALLOW_INTS;
03951 
03952   return string_to_tmscm (out);
03953 }
03954 
03955 tmscm
03956 tmg_tmfs_load_ressource_properties (tmscm arg1) {
03957   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-load-ressource-properties");
03958 
03959   string in1= tmscm_to_string (arg1);
03960 
03961   // TMSCM_DEFER_INTS;
03962   properties out= tmfs_load_ressource_properties (in1);
03963   // TMSCM_ALLOW_INTS;
03964 
03965   return properties_to_tmscm (out);
03966 }
03967 
03968 tmscm
03969 tmg_tmfs_create_user (tmscm arg1) {
03970   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-create-user");
03971 
03972   string in1= tmscm_to_string (arg1);
03973 
03974   // TMSCM_DEFER_INTS;
03975   string out= tmfs_create_user (in1);
03976   // TMSCM_ALLOW_INTS;
03977 
03978   return string_to_tmscm (out);
03979 }
03980 
03981 tmscm
03982 tmg_tmfs_search_user (tmscm arg1) {
03983   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-search-user");
03984 
03985   string in1= tmscm_to_string (arg1);
03986 
03987   // TMSCM_DEFER_INTS;
03988   collection out= tmfs_search_user (in1);
03989   // TMSCM_ALLOW_INTS;
03990 
03991   return collection_to_tmscm (out);
03992 }
03993 
03994 tmscm
03995 tmg_tmfs_set_user (tmscm arg1) {
03996   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-set-user");
03997 
03998   string in1= tmscm_to_string (arg1);
03999 
04000   // TMSCM_DEFER_INTS;
04001   tmfs_set_user (in1);
04002   // TMSCM_ALLOW_INTS;
04003 
04004   return TMSCM_UNSPECIFIED;
04005 }
04006 
04007 tmscm
04008 tmg_tmfs_get_user () {
04009   // TMSCM_DEFER_INTS;
04010   string out= tmfs_get_user ();
04011   // TMSCM_ALLOW_INTS;
04012 
04013   return string_to_tmscm (out);
04014 }
04015 
04016 tmscm
04017 tmg_tmfs_allowsP (tmscm arg1, tmscm arg2) {
04018   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-allows?");
04019   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "tmfs-allows?");
04020 
04021   string in1= tmscm_to_string (arg1);
04022   string in2= tmscm_to_string (arg2);
04023 
04024   // TMSCM_DEFER_INTS;
04025   bool out= tmfs_allows (in1, in2);
04026   // TMSCM_ALLOW_INTS;
04027 
04028   return bool_to_tmscm (out);
04029 }
04030 
04031 tmscm
04032 tmg_tmfs_set_attributes (tmscm arg1, tmscm arg2) {
04033   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-set-attributes");
04034   TMSCM_ASSERT_PROPERTIES (arg2, TMSCM_ARG2, "tmfs-set-attributes");
04035 
04036   string in1= tmscm_to_string (arg1);
04037   properties in2= tmscm_to_properties (arg2);
04038 
04039   // TMSCM_DEFER_INTS;
04040   tmfs_set_attributes (in1, in2);
04041   // TMSCM_ALLOW_INTS;
04042 
04043   return TMSCM_UNSPECIFIED;
04044 }
04045 
04046 tmscm
04047 tmg_tmfs_get_attributes (tmscm arg1) {
04048   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-get-attributes");
04049 
04050   string in1= tmscm_to_string (arg1);
04051 
04052   // TMSCM_DEFER_INTS;
04053   properties out= tmfs_get_attributes (in1);
04054   // TMSCM_ALLOW_INTS;
04055 
04056   return properties_to_tmscm (out);
04057 }
04058 
04059 tmscm
04060 tmg_tmfs_add_attributes (tmscm arg1, tmscm arg2) {
04061   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-add-attributes");
04062   TMSCM_ASSERT_PROPERTIES (arg2, TMSCM_ARG2, "tmfs-add-attributes");
04063 
04064   string in1= tmscm_to_string (arg1);
04065   properties in2= tmscm_to_properties (arg2);
04066 
04067   // TMSCM_DEFER_INTS;
04068   tmfs_add_attributes (in1, in2);
04069   // TMSCM_ALLOW_INTS;
04070 
04071   return TMSCM_UNSPECIFIED;
04072 }
04073 
04074 tmscm
04075 tmg_tmfs_remove_attributes (tmscm arg1, tmscm arg2) {
04076   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-remove-attributes");
04077   TMSCM_ASSERT_PROPERTIES (arg2, TMSCM_ARG2, "tmfs-remove-attributes");
04078 
04079   string in1= tmscm_to_string (arg1);
04080   properties in2= tmscm_to_properties (arg2);
04081 
04082   // TMSCM_DEFER_INTS;
04083   tmfs_remove_attributes (in1, in2);
04084   // TMSCM_ALLOW_INTS;
04085 
04086   return TMSCM_UNSPECIFIED;
04087 }
04088 
04089 tmscm
04090 tmg_tmfs_change_attributes (tmscm arg1, tmscm arg2) {
04091   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-change-attributes");
04092   TMSCM_ASSERT_PROPERTIES (arg2, TMSCM_ARG2, "tmfs-change-attributes");
04093 
04094   string in1= tmscm_to_string (arg1);
04095   properties in2= tmscm_to_properties (arg2);
04096 
04097   // TMSCM_DEFER_INTS;
04098   tmfs_change_attributes (in1, in2);
04099   // TMSCM_ALLOW_INTS;
04100 
04101   return TMSCM_UNSPECIFIED;
04102 }
04103 
04104 tmscm
04105 tmg_tmfs_query (tmscm arg1) {
04106   TMSCM_ASSERT_PROPERTIES (arg1, TMSCM_ARG1, "tmfs-query");
04107 
04108   properties in1= tmscm_to_properties (arg1);
04109 
04110   // TMSCM_DEFER_INTS;
04111   solutions out= tmfs_query (in1);
04112   // TMSCM_ALLOW_INTS;
04113 
04114   return solutions_to_tmscm (out);
04115 }
04116 
04117 tmscm
04118 tmg_solutions_2collection (tmscm arg1, tmscm arg2) {
04119   TMSCM_ASSERT_SOLUTIONS (arg1, TMSCM_ARG1, "solutions->collection");
04120   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "solutions->collection");
04121 
04122   solutions in1= tmscm_to_solutions (arg1);
04123   string in2= tmscm_to_string (arg2);
04124 
04125   // TMSCM_DEFER_INTS;
04126   collection out= as_collection (in1, in2);
04127   // TMSCM_ALLOW_INTS;
04128 
04129   return collection_to_tmscm (out);
04130 }
04131 
04132 tmscm
04133 tmg_tmfs_create_file (tmscm arg1, tmscm arg2) {
04134   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-create-file");
04135   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "tmfs-create-file");
04136 
04137   string in1= tmscm_to_string (arg1);
04138   string in2= tmscm_to_string (arg2);
04139 
04140   // TMSCM_DEFER_INTS;
04141   string out= tmfs_create_file (in1, in2);
04142   // TMSCM_ALLOW_INTS;
04143 
04144   return string_to_tmscm (out);
04145 }
04146 
04147 tmscm
04148 tmg_tmfs_create_file_in (tmscm arg1, tmscm arg2, tmscm arg3) {
04149   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-create-file-in");
04150   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "tmfs-create-file-in");
04151   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "tmfs-create-file-in");
04152 
04153   string in1= tmscm_to_string (arg1);
04154   string in2= tmscm_to_string (arg2);
04155   string in3= tmscm_to_string (arg3);
04156 
04157   // TMSCM_DEFER_INTS;
04158   string out= tmfs_create_file (in1, in2, in3);
04159   // TMSCM_ALLOW_INTS;
04160 
04161   return string_to_tmscm (out);
04162 }
04163 
04164 tmscm
04165 tmg_tmfs_search_file (tmscm arg1) {
04166   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-search-file");
04167 
04168   string in1= tmscm_to_string (arg1);
04169 
04170   // TMSCM_DEFER_INTS;
04171   collection out= tmfs_search_file (in1);
04172   // TMSCM_ALLOW_INTS;
04173 
04174   return collection_to_tmscm (out);
04175 }
04176 
04177 tmscm
04178 tmg_tmfs_save_file (tmscm arg1, tmscm arg2) {
04179   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-save-file");
04180   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "tmfs-save-file");
04181 
04182   string in1= tmscm_to_string (arg1);
04183   string in2= tmscm_to_string (arg2);
04184 
04185   // TMSCM_DEFER_INTS;
04186   tmfs_save_file (in1, in2);
04187   // TMSCM_ALLOW_INTS;
04188 
04189   return TMSCM_UNSPECIFIED;
04190 }
04191 
04192 tmscm
04193 tmg_tmfs_load_file (tmscm arg1) {
04194   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-load-file");
04195 
04196   string in1= tmscm_to_string (arg1);
04197 
04198   // TMSCM_DEFER_INTS;
04199   string out= tmfs_load_file (in1);
04200   // TMSCM_ALLOW_INTS;
04201 
04202   return string_to_tmscm (out);
04203 }
04204 
04205 tmscm
04206 tmg_tmfs_create_project (tmscm arg1) {
04207   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-create-project");
04208 
04209   string in1= tmscm_to_string (arg1);
04210 
04211   // TMSCM_DEFER_INTS;
04212   string out= tmfs_create_project (in1);
04213   // TMSCM_ALLOW_INTS;
04214 
04215   return string_to_tmscm (out);
04216 }
04217 
04218 tmscm
04219 tmg_tmfs_search_project (tmscm arg1) {
04220   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-search-project");
04221 
04222   string in1= tmscm_to_string (arg1);
04223 
04224   // TMSCM_DEFER_INTS;
04225   collection out= tmfs_search_project (in1);
04226   // TMSCM_ALLOW_INTS;
04227 
04228   return collection_to_tmscm (out);
04229 }
04230 
04231 tmscm
04232 tmg_tmfs_get_file_projects (tmscm arg1) {
04233   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-get-file-projects");
04234 
04235   string in1= tmscm_to_string (arg1);
04236 
04237   // TMSCM_DEFER_INTS;
04238   collection out= tmfs_get_file_projects (in1);
04239   // TMSCM_ALLOW_INTS;
04240 
04241   return collection_to_tmscm (out);
04242 }
04243 
04244 tmscm
04245 tmg_tmfs_get_project_files (tmscm arg1) {
04246   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-get-project-files");
04247 
04248   string in1= tmscm_to_string (arg1);
04249 
04250   // TMSCM_DEFER_INTS;
04251   collection out= tmfs_get_project_files (in1);
04252   // TMSCM_ALLOW_INTS;
04253 
04254   return collection_to_tmscm (out);
04255 }
04256 
04257 tmscm
04258 tmg_tmfs_create_branch (tmscm arg1, tmscm arg2) {
04259   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-create-branch");
04260   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "tmfs-create-branch");
04261 
04262   string in1= tmscm_to_string (arg1);
04263   string in2= tmscm_to_string (arg2);
04264 
04265   // TMSCM_DEFER_INTS;
04266   string out= tmfs_create_branch (in1, in2);
04267   // TMSCM_ALLOW_INTS;
04268 
04269   return string_to_tmscm (out);
04270 }
04271 
04272 tmscm
04273 tmg_tmfs_set_root (tmscm arg1, tmscm arg2) {
04274   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-set-root");
04275   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "tmfs-set-root");
04276 
04277   string in1= tmscm_to_string (arg1);
04278   url in2= tmscm_to_url (arg2);
04279 
04280   // TMSCM_DEFER_INTS;
04281   tmfs_set_root (in1, in2);
04282   // TMSCM_ALLOW_INTS;
04283 
04284   return TMSCM_UNSPECIFIED;
04285 }
04286 
04287 tmscm
04288 tmg_tmfs_get_root (tmscm arg1) {
04289   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "tmfs-get-root");
04290 
04291   string in1= tmscm_to_string (arg1);
04292 
04293   // TMSCM_DEFER_INTS;
04294   url out= tmfs_get_root (in1);
04295   // TMSCM_ALLOW_INTS;
04296 
04297   return url_to_tmscm (out);
04298 }
04299 
04300 tmscm
04301 tmg_tmfs_import (tmscm arg1) {
04302   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "tmfs-import");
04303 
04304   url in1= tmscm_to_url (arg1);
04305 
04306   // TMSCM_DEFER_INTS;
04307   tmfs_import (in1);
04308   // TMSCM_ALLOW_INTS;
04309 
04310   return TMSCM_UNSPECIFIED;
04311 }
04312 
04313 tmscm
04314 tmg_tmfs_export (tmscm arg1) {
04315   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "tmfs-export");
04316 
04317   url in1= tmscm_to_url (arg1);
04318 
04319   // TMSCM_DEFER_INTS;
04320   tmfs_export (in1);
04321   // TMSCM_ALLOW_INTS;
04322 
04323   return TMSCM_UNSPECIFIED;
04324 }
04325 
04326 tmscm
04327 tmg_server_start () {
04328   // TMSCM_DEFER_INTS;
04329   server_start ();
04330   // TMSCM_ALLOW_INTS;
04331 
04332   return TMSCM_UNSPECIFIED;
04333 }
04334 
04335 tmscm
04336 tmg_server_stop () {
04337   // TMSCM_DEFER_INTS;
04338   server_stop ();
04339   // TMSCM_ALLOW_INTS;
04340 
04341   return TMSCM_UNSPECIFIED;
04342 }
04343 
04344 tmscm
04345 tmg_server_read (tmscm arg1) {
04346   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "server-read");
04347 
04348   int in1= tmscm_to_int (arg1);
04349 
04350   // TMSCM_DEFER_INTS;
04351   string out= server_read (in1);
04352   // TMSCM_ALLOW_INTS;
04353 
04354   return string_to_tmscm (out);
04355 }
04356 
04357 tmscm
04358 tmg_server_write (tmscm arg1, tmscm arg2) {
04359   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "server-write");
04360   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "server-write");
04361 
04362   int in1= tmscm_to_int (arg1);
04363   string in2= tmscm_to_string (arg2);
04364 
04365   // TMSCM_DEFER_INTS;
04366   server_write (in1, in2);
04367   // TMSCM_ALLOW_INTS;
04368 
04369   return TMSCM_UNSPECIFIED;
04370 }
04371 
04372 tmscm
04373 tmg_client_start (tmscm arg1) {
04374   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "client-start");
04375 
04376   string in1= tmscm_to_string (arg1);
04377 
04378   // TMSCM_DEFER_INTS;
04379   client_start (in1);
04380   // TMSCM_ALLOW_INTS;
04381 
04382   return TMSCM_UNSPECIFIED;
04383 }
04384 
04385 tmscm
04386 tmg_client_stop () {
04387   // TMSCM_DEFER_INTS;
04388   client_stop ();
04389   // TMSCM_ALLOW_INTS;
04390 
04391   return TMSCM_UNSPECIFIED;
04392 }
04393 
04394 tmscm
04395 tmg_client_read () {
04396   // TMSCM_DEFER_INTS;
04397   string out= client_read ();
04398   // TMSCM_ALLOW_INTS;
04399 
04400   return string_to_tmscm (out);
04401 }
04402 
04403 tmscm
04404 tmg_client_write (tmscm arg1) {
04405   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "client-write");
04406 
04407   string in1= tmscm_to_string (arg1);
04408 
04409   // TMSCM_DEFER_INTS;
04410   client_write (in1);
04411   // TMSCM_ALLOW_INTS;
04412 
04413   return TMSCM_UNSPECIFIED;
04414 }
04415 
04416 tmscm
04417 tmg_enter_secure_mode () {
04418   // TMSCM_DEFER_INTS;
04419   enter_secure_mode ();
04420   // TMSCM_ALLOW_INTS;
04421 
04422   return TMSCM_UNSPECIFIED;
04423 }
04424 
04425 tmscm
04426 tmg_connection_start (tmscm arg1, tmscm arg2) {
04427   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "connection-start");
04428   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "connection-start");
04429 
04430   string in1= tmscm_to_string (arg1);
04431   string in2= tmscm_to_string (arg2);
04432 
04433   // TMSCM_DEFER_INTS;
04434   string out= connection_start (in1, in2);
04435   // TMSCM_ALLOW_INTS;
04436 
04437   return string_to_tmscm (out);
04438 }
04439 
04440 tmscm
04441 tmg_connection_status (tmscm arg1, tmscm arg2) {
04442   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "connection-status");
04443   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "connection-status");
04444 
04445   string in1= tmscm_to_string (arg1);
04446   string in2= tmscm_to_string (arg2);
04447 
04448   // TMSCM_DEFER_INTS;
04449   int out= connection_status (in1, in2);
04450   // TMSCM_ALLOW_INTS;
04451 
04452   return int_to_tmscm (out);
04453 }
04454 
04455 tmscm
04456 tmg_connection_write_string (tmscm arg1, tmscm arg2, tmscm arg3) {
04457   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "connection-write-string");
04458   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "connection-write-string");
04459   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "connection-write-string");
04460 
04461   string in1= tmscm_to_string (arg1);
04462   string in2= tmscm_to_string (arg2);
04463   string in3= tmscm_to_string (arg3);
04464 
04465   // TMSCM_DEFER_INTS;
04466   connection_write (in1, in2, in3);
04467   // TMSCM_ALLOW_INTS;
04468 
04469   return TMSCM_UNSPECIFIED;
04470 }
04471 
04472 tmscm
04473 tmg_connection_write (tmscm arg1, tmscm arg2, tmscm arg3) {
04474   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "connection-write");
04475   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "connection-write");
04476   TMSCM_ASSERT_CONTENT (arg3, TMSCM_ARG3, "connection-write");
04477 
04478   string in1= tmscm_to_string (arg1);
04479   string in2= tmscm_to_string (arg2);
04480   content in3= tmscm_to_content (arg3);
04481 
04482   // TMSCM_DEFER_INTS;
04483   connection_write (in1, in2, in3);
04484   // TMSCM_ALLOW_INTS;
04485 
04486   return TMSCM_UNSPECIFIED;
04487 }
04488 
04489 tmscm
04490 tmg_connection_cmd (tmscm arg1, tmscm arg2, tmscm arg3) {
04491   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "connection-cmd");
04492   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "connection-cmd");
04493   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "connection-cmd");
04494 
04495   string in1= tmscm_to_string (arg1);
04496   string in2= tmscm_to_string (arg2);
04497   string in3= tmscm_to_string (arg3);
04498 
04499   // TMSCM_DEFER_INTS;
04500   tree out= connection_cmd (in1, in2, in3);
04501   // TMSCM_ALLOW_INTS;
04502 
04503   return tree_to_tmscm (out);
04504 }
04505 
04506 tmscm
04507 tmg_connection_eval (tmscm arg1, tmscm arg2, tmscm arg3) {
04508   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "connection-eval");
04509   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "connection-eval");
04510   TMSCM_ASSERT_CONTENT (arg3, TMSCM_ARG3, "connection-eval");
04511 
04512   string in1= tmscm_to_string (arg1);
04513   string in2= tmscm_to_string (arg2);
04514   content in3= tmscm_to_content (arg3);
04515 
04516   // TMSCM_DEFER_INTS;
04517   tree out= connection_eval (in1, in2, in3);
04518   // TMSCM_ALLOW_INTS;
04519 
04520   return tree_to_tmscm (out);
04521 }
04522 
04523 tmscm
04524 tmg_connection_interrupt (tmscm arg1, tmscm arg2) {
04525   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "connection-interrupt");
04526   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "connection-interrupt");
04527 
04528   string in1= tmscm_to_string (arg1);
04529   string in2= tmscm_to_string (arg2);
04530 
04531   // TMSCM_DEFER_INTS;
04532   connection_interrupt (in1, in2);
04533   // TMSCM_ALLOW_INTS;
04534 
04535   return TMSCM_UNSPECIFIED;
04536 }
04537 
04538 tmscm
04539 tmg_connection_stop (tmscm arg1, tmscm arg2) {
04540   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "connection-stop");
04541   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "connection-stop");
04542 
04543   string in1= tmscm_to_string (arg1);
04544   string in2= tmscm_to_string (arg2);
04545 
04546   // TMSCM_DEFER_INTS;
04547   connection_stop (in1, in2);
04548   // TMSCM_ALLOW_INTS;
04549 
04550   return TMSCM_UNSPECIFIED;
04551 }
04552 
04553 tmscm
04554 tmg_widget_printer (tmscm arg1, tmscm arg2) {
04555   TMSCM_ASSERT_COMMAND (arg1, TMSCM_ARG1, "widget-printer");
04556   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "widget-printer");
04557 
04558   command in1= tmscm_to_command (arg1);
04559   url in2= tmscm_to_url (arg2);
04560 
04561   // TMSCM_DEFER_INTS;
04562   widget out= printer_widget (in1, in2);
04563   // TMSCM_ALLOW_INTS;
04564 
04565   return widget_to_tmscm (out);
04566 }
04567 
04568 tmscm
04569 tmg_widget_color_picker (tmscm arg1, tmscm arg2, tmscm arg3) {
04570   TMSCM_ASSERT_COMMAND (arg1, TMSCM_ARG1, "widget-color-picker");
04571   TMSCM_ASSERT_BOOL (arg2, TMSCM_ARG2, "widget-color-picker");
04572   TMSCM_ASSERT_ARRAY_TREE (arg3, TMSCM_ARG3, "widget-color-picker");
04573 
04574   command in1= tmscm_to_command (arg1);
04575   bool in2= tmscm_to_bool (arg2);
04576   array_tree in3= tmscm_to_array_tree (arg3);
04577 
04578   // TMSCM_DEFER_INTS;
04579   widget out= color_picker_widget (in1, in2, in3);
04580   // TMSCM_ALLOW_INTS;
04581 
04582   return widget_to_tmscm (out);
04583 }
04584 
04585 tmscm
04586 tmg_widget_extend (tmscm arg1, tmscm arg2) {
04587   TMSCM_ASSERT_WIDGET (arg1, TMSCM_ARG1, "widget-extend");
04588   TMSCM_ASSERT_ARRAY_WIDGET (arg2, TMSCM_ARG2, "widget-extend");
04589 
04590   widget in1= tmscm_to_widget (arg1);
04591   array_widget in2= tmscm_to_array_widget (arg2);
04592 
04593   // TMSCM_DEFER_INTS;
04594   widget out= extend (in1, in2);
04595   // TMSCM_ALLOW_INTS;
04596 
04597   return widget_to_tmscm (out);
04598 }
04599 
04600 tmscm
04601 tmg_widget_hmenu (tmscm arg1) {
04602   TMSCM_ASSERT_ARRAY_WIDGET (arg1, TMSCM_ARG1, "widget-hmenu");
04603 
04604   array_widget in1= tmscm_to_array_widget (arg1);
04605 
04606   // TMSCM_DEFER_INTS;
04607   widget out= horizontal_menu (in1);
04608   // TMSCM_ALLOW_INTS;
04609 
04610   return widget_to_tmscm (out);
04611 }
04612 
04613 tmscm
04614 tmg_widget_vmenu (tmscm arg1) {
04615   TMSCM_ASSERT_ARRAY_WIDGET (arg1, TMSCM_ARG1, "widget-vmenu");
04616 
04617   array_widget in1= tmscm_to_array_widget (arg1);
04618 
04619   // TMSCM_DEFER_INTS;
04620   widget out= vertical_menu (in1);
04621   // TMSCM_ALLOW_INTS;
04622 
04623   return widget_to_tmscm (out);
04624 }
04625 
04626 tmscm
04627 tmg_widget_tmenu (tmscm arg1, tmscm arg2) {
04628   TMSCM_ASSERT_ARRAY_WIDGET (arg1, TMSCM_ARG1, "widget-tmenu");
04629   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "widget-tmenu");
04630 
04631   array_widget in1= tmscm_to_array_widget (arg1);
04632   int in2= tmscm_to_int (arg2);
04633 
04634   // TMSCM_DEFER_INTS;
04635   widget out= tile_menu (in1, in2);
04636   // TMSCM_ALLOW_INTS;
04637 
04638   return widget_to_tmscm (out);
04639 }
04640 
04641 tmscm
04642 tmg_widget_minibar_menu (tmscm arg1) {
04643   TMSCM_ASSERT_ARRAY_WIDGET (arg1, TMSCM_ARG1, "widget-minibar-menu");
04644 
04645   array_widget in1= tmscm_to_array_widget (arg1);
04646 
04647   // TMSCM_DEFER_INTS;
04648   widget out= minibar_menu (in1);
04649   // TMSCM_ALLOW_INTS;
04650 
04651   return widget_to_tmscm (out);
04652 }
04653 
04654 tmscm
04655 tmg_widget_separator (tmscm arg1) {
04656   TMSCM_ASSERT_BOOL (arg1, TMSCM_ARG1, "widget-separator");
04657 
04658   bool in1= tmscm_to_bool (arg1);
04659 
04660   // TMSCM_DEFER_INTS;
04661   widget out= menu_separator (in1);
04662   // TMSCM_ALLOW_INTS;
04663 
04664   return widget_to_tmscm (out);
04665 }
04666 
04667 tmscm
04668 tmg_widget_menu_group (tmscm arg1, tmscm arg2) {
04669   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "widget-menu-group");
04670   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "widget-menu-group");
04671 
04672   string in1= tmscm_to_string (arg1);
04673   int in2= tmscm_to_int (arg2);
04674 
04675   // TMSCM_DEFER_INTS;
04676   widget out= menu_group (in1, in2);
04677   // TMSCM_ALLOW_INTS;
04678 
04679   return widget_to_tmscm (out);
04680 }
04681 
04682 tmscm
04683 tmg_widget_pulldown_button (tmscm arg1, tmscm arg2) {
04684   TMSCM_ASSERT_WIDGET (arg1, TMSCM_ARG1, "widget-pulldown-button");
04685   TMSCM_ASSERT_PROMISE_WIDGET (arg2, TMSCM_ARG2, "widget-pulldown-button");
04686 
04687   widget in1= tmscm_to_widget (arg1);
04688   promise_widget in2= tmscm_to_promise_widget (arg2);
04689 
04690   // TMSCM_DEFER_INTS;
04691   widget out= pulldown_button (in1, in2);
04692   // TMSCM_ALLOW_INTS;
04693 
04694   return widget_to_tmscm (out);
04695 }
04696 
04697 tmscm
04698 tmg_widget_pullright_button (tmscm arg1, tmscm arg2) {
04699   TMSCM_ASSERT_WIDGET (arg1, TMSCM_ARG1, "widget-pullright-button");
04700   TMSCM_ASSERT_PROMISE_WIDGET (arg2, TMSCM_ARG2, "widget-pullright-button");
04701 
04702   widget in1= tmscm_to_widget (arg1);
04703   promise_widget in2= tmscm_to_promise_widget (arg2);
04704 
04705   // TMSCM_DEFER_INTS;
04706   widget out= pullright_button (in1, in2);
04707   // TMSCM_ALLOW_INTS;
04708 
04709   return widget_to_tmscm (out);
04710 }
04711 
04712 tmscm
04713 tmg_widget_menu_button (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4, tmscm arg5) {
04714   TMSCM_ASSERT_WIDGET (arg1, TMSCM_ARG1, "widget-menu-button");
04715   TMSCM_ASSERT_COMMAND (arg2, TMSCM_ARG2, "widget-menu-button");
04716   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "widget-menu-button");
04717   TMSCM_ASSERT_STRING (arg4, TMSCM_ARG4, "widget-menu-button");
04718   TMSCM_ASSERT_INT (arg5, TMSCM_ARG5, "widget-menu-button");
04719 
04720   widget in1= tmscm_to_widget (arg1);
04721   command in2= tmscm_to_command (arg2);
04722   string in3= tmscm_to_string (arg3);
04723   string in4= tmscm_to_string (arg4);
04724   int in5= tmscm_to_int (arg5);
04725 
04726   // TMSCM_DEFER_INTS;
04727   widget out= menu_button (in1, in2, in3, in4, in5);
04728   // TMSCM_ALLOW_INTS;
04729 
04730   return widget_to_tmscm (out);
04731 }
04732 
04733 tmscm
04734 tmg_widget_toggle (tmscm arg1, tmscm arg2, tmscm arg3) {
04735   TMSCM_ASSERT_COMMAND (arg1, TMSCM_ARG1, "widget-toggle");
04736   TMSCM_ASSERT_BOOL (arg2, TMSCM_ARG2, "widget-toggle");
04737   TMSCM_ASSERT_INT (arg3, TMSCM_ARG3, "widget-toggle");
04738 
04739   command in1= tmscm_to_command (arg1);
04740   bool in2= tmscm_to_bool (arg2);
04741   int in3= tmscm_to_int (arg3);
04742 
04743   // TMSCM_DEFER_INTS;
04744   widget out= toggle_widget (in1, in2, in3);
04745   // TMSCM_ALLOW_INTS;
04746 
04747   return widget_to_tmscm (out);
04748 }
04749 
04750 tmscm
04751 tmg_widget_balloon (tmscm arg1, tmscm arg2) {
04752   TMSCM_ASSERT_WIDGET (arg1, TMSCM_ARG1, "widget-balloon");
04753   TMSCM_ASSERT_WIDGET (arg2, TMSCM_ARG2, "widget-balloon");
04754 
04755   widget in1= tmscm_to_widget (arg1);
04756   widget in2= tmscm_to_widget (arg2);
04757 
04758   // TMSCM_DEFER_INTS;
04759   widget out= balloon_widget (in1, in2);
04760   // TMSCM_ALLOW_INTS;
04761 
04762   return widget_to_tmscm (out);
04763 }
04764 
04765 tmscm
04766 tmg_widget_empty () {
04767   // TMSCM_DEFER_INTS;
04768   widget out= empty_widget ();
04769   // TMSCM_ALLOW_INTS;
04770 
04771   return widget_to_tmscm (out);
04772 }
04773 
04774 tmscm
04775 tmg_widget_text (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4) {
04776   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "widget-text");
04777   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "widget-text");
04778   TMSCM_ASSERT_INT (arg3, TMSCM_ARG3, "widget-text");
04779   TMSCM_ASSERT_BOOL (arg4, TMSCM_ARG4, "widget-text");
04780 
04781   string in1= tmscm_to_string (arg1);
04782   int in2= tmscm_to_int (arg2);
04783   int in3= tmscm_to_int (arg3);
04784   bool in4= tmscm_to_bool (arg4);
04785 
04786   // TMSCM_DEFER_INTS;
04787   widget out= text_widget (in1, in2, in3, in4);
04788   // TMSCM_ALLOW_INTS;
04789 
04790   return widget_to_tmscm (out);
04791 }
04792 
04793 tmscm
04794 tmg_widget_input (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4, tmscm arg5) {
04795   TMSCM_ASSERT_COMMAND (arg1, TMSCM_ARG1, "widget-input");
04796   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "widget-input");
04797   TMSCM_ASSERT_ARRAY_STRING (arg3, TMSCM_ARG3, "widget-input");
04798   TMSCM_ASSERT_INT (arg4, TMSCM_ARG4, "widget-input");
04799   TMSCM_ASSERT_STRING (arg5, TMSCM_ARG5, "widget-input");
04800 
04801   command in1= tmscm_to_command (arg1);
04802   string in2= tmscm_to_string (arg2);
04803   array_string in3= tmscm_to_array_string (arg3);
04804   int in4= tmscm_to_int (arg4);
04805   string in5= tmscm_to_string (arg5);
04806 
04807   // TMSCM_DEFER_INTS;
04808   widget out= input_text_widget (in1, in2, in3, in4, in5);
04809   // TMSCM_ALLOW_INTS;
04810 
04811   return widget_to_tmscm (out);
04812 }
04813 
04814 tmscm
04815 tmg_widget_enum (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4, tmscm arg5) {
04816   TMSCM_ASSERT_COMMAND (arg1, TMSCM_ARG1, "widget-enum");
04817   TMSCM_ASSERT_ARRAY_STRING (arg2, TMSCM_ARG2, "widget-enum");
04818   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "widget-enum");
04819   TMSCM_ASSERT_INT (arg4, TMSCM_ARG4, "widget-enum");
04820   TMSCM_ASSERT_STRING (arg5, TMSCM_ARG5, "widget-enum");
04821 
04822   command in1= tmscm_to_command (arg1);
04823   array_string in2= tmscm_to_array_string (arg2);
04824   string in3= tmscm_to_string (arg3);
04825   int in4= tmscm_to_int (arg4);
04826   string in5= tmscm_to_string (arg5);
04827 
04828   // TMSCM_DEFER_INTS;
04829   widget out= enum_widget (in1, in2, in3, in4, in5);
04830   // TMSCM_ALLOW_INTS;
04831 
04832   return widget_to_tmscm (out);
04833 }
04834 
04835 tmscm
04836 tmg_widget_choice (tmscm arg1, tmscm arg2, tmscm arg3) {
04837   TMSCM_ASSERT_COMMAND (arg1, TMSCM_ARG1, "widget-choice");
04838   TMSCM_ASSERT_ARRAY_STRING (arg2, TMSCM_ARG2, "widget-choice");
04839   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "widget-choice");
04840 
04841   command in1= tmscm_to_command (arg1);
04842   array_string in2= tmscm_to_array_string (arg2);
04843   string in3= tmscm_to_string (arg3);
04844 
04845   // TMSCM_DEFER_INTS;
04846   widget out= choice_widget (in1, in2, in3);
04847   // TMSCM_ALLOW_INTS;
04848 
04849   return widget_to_tmscm (out);
04850 }
04851 
04852 tmscm
04853 tmg_widget_choices (tmscm arg1, tmscm arg2, tmscm arg3) {
04854   TMSCM_ASSERT_COMMAND (arg1, TMSCM_ARG1, "widget-choices");
04855   TMSCM_ASSERT_ARRAY_STRING (arg2, TMSCM_ARG2, "widget-choices");
04856   TMSCM_ASSERT_ARRAY_STRING (arg3, TMSCM_ARG3, "widget-choices");
04857 
04858   command in1= tmscm_to_command (arg1);
04859   array_string in2= tmscm_to_array_string (arg2);
04860   array_string in3= tmscm_to_array_string (arg3);
04861 
04862   // TMSCM_DEFER_INTS;
04863   widget out= choice_widget (in1, in2, in3);
04864   // TMSCM_ALLOW_INTS;
04865 
04866   return widget_to_tmscm (out);
04867 }
04868 
04869 tmscm
04870 tmg_widget_xpm (tmscm arg1) {
04871   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "widget-xpm");
04872 
04873   url in1= tmscm_to_url (arg1);
04874 
04875   // TMSCM_DEFER_INTS;
04876   widget out= xpm_widget (in1);
04877   // TMSCM_ALLOW_INTS;
04878 
04879   return widget_to_tmscm (out);
04880 }
04881 
04882 tmscm
04883 tmg_widget_box (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4, tmscm arg5) {
04884   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "widget-box");
04885   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "widget-box");
04886   TMSCM_ASSERT_INT (arg3, TMSCM_ARG3, "widget-box");
04887   TMSCM_ASSERT_BOOL (arg4, TMSCM_ARG4, "widget-box");
04888   TMSCM_ASSERT_BOOL (arg5, TMSCM_ARG5, "widget-box");
04889 
04890   scheme_tree in1= tmscm_to_scheme_tree (arg1);
04891   string in2= tmscm_to_string (arg2);
04892   int in3= tmscm_to_int (arg3);
04893   bool in4= tmscm_to_bool (arg4);
04894   bool in5= tmscm_to_bool (arg5);
04895 
04896   // TMSCM_DEFER_INTS;
04897   widget out= box_widget (in1, in2, in3, in4, in5);
04898   // TMSCM_ALLOW_INTS;
04899 
04900   return widget_to_tmscm (out);
04901 }
04902 
04903 tmscm
04904 tmg_widget_glue (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4) {
04905   TMSCM_ASSERT_BOOL (arg1, TMSCM_ARG1, "widget-glue");
04906   TMSCM_ASSERT_BOOL (arg2, TMSCM_ARG2, "widget-glue");
04907   TMSCM_ASSERT_INT (arg3, TMSCM_ARG3, "widget-glue");
04908   TMSCM_ASSERT_INT (arg4, TMSCM_ARG4, "widget-glue");
04909 
04910   bool in1= tmscm_to_bool (arg1);
04911   bool in2= tmscm_to_bool (arg2);
04912   int in3= tmscm_to_int (arg3);
04913   int in4= tmscm_to_int (arg4);
04914 
04915   // TMSCM_DEFER_INTS;
04916   widget out= glue_widget (in1, in2, in3, in4);
04917   // TMSCM_ALLOW_INTS;
04918 
04919   return widget_to_tmscm (out);
04920 }
04921 
04922 tmscm
04923 tmg_widget_color (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4, tmscm arg5) {
04924   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "widget-color");
04925   TMSCM_ASSERT_BOOL (arg2, TMSCM_ARG2, "widget-color");
04926   TMSCM_ASSERT_BOOL (arg3, TMSCM_ARG3, "widget-color");
04927   TMSCM_ASSERT_INT (arg4, TMSCM_ARG4, "widget-color");
04928   TMSCM_ASSERT_INT (arg5, TMSCM_ARG5, "widget-color");
04929 
04930   content in1= tmscm_to_content (arg1);
04931   bool in2= tmscm_to_bool (arg2);
04932   bool in3= tmscm_to_bool (arg3);
04933   int in4= tmscm_to_int (arg4);
04934   int in5= tmscm_to_int (arg5);
04935 
04936   // TMSCM_DEFER_INTS;
04937   widget out= glue_widget (in1, in2, in3, in4, in5);
04938   // TMSCM_ALLOW_INTS;
04939 
04940   return widget_to_tmscm (out);
04941 }
04942 
04943 tmscm
04944 tmg_widget_hlist (tmscm arg1) {
04945   TMSCM_ASSERT_ARRAY_WIDGET (arg1, TMSCM_ARG1, "widget-hlist");
04946 
04947   array_widget in1= tmscm_to_array_widget (arg1);
04948 
04949   // TMSCM_DEFER_INTS;
04950   widget out= horizontal_list (in1);
04951   // TMSCM_ALLOW_INTS;
04952 
04953   return widget_to_tmscm (out);
04954 }
04955 
04956 tmscm
04957 tmg_widget_vlist (tmscm arg1) {
04958   TMSCM_ASSERT_ARRAY_WIDGET (arg1, TMSCM_ARG1, "widget-vlist");
04959 
04960   array_widget in1= tmscm_to_array_widget (arg1);
04961 
04962   // TMSCM_DEFER_INTS;
04963   widget out= vertical_list (in1);
04964   // TMSCM_ALLOW_INTS;
04965 
04966   return widget_to_tmscm (out);
04967 }
04968 
04969 tmscm
04970 tmg_widget_aligned (tmscm arg1, tmscm arg2) {
04971   TMSCM_ASSERT_ARRAY_WIDGET (arg1, TMSCM_ARG1, "widget-aligned");
04972   TMSCM_ASSERT_ARRAY_WIDGET (arg2, TMSCM_ARG2, "widget-aligned");
04973 
04974   array_widget in1= tmscm_to_array_widget (arg1);
04975   array_widget in2= tmscm_to_array_widget (arg2);
04976 
04977   // TMSCM_DEFER_INTS;
04978   widget out= aligned_widget (in1, in2);
04979   // TMSCM_ALLOW_INTS;
04980 
04981   return widget_to_tmscm (out);
04982 }
04983 
04984 tmscm
04985 tmg_widget_tabs (tmscm arg1, tmscm arg2) {
04986   TMSCM_ASSERT_ARRAY_WIDGET (arg1, TMSCM_ARG1, "widget-tabs");
04987   TMSCM_ASSERT_ARRAY_WIDGET (arg2, TMSCM_ARG2, "widget-tabs");
04988 
04989   array_widget in1= tmscm_to_array_widget (arg1);
04990   array_widget in2= tmscm_to_array_widget (arg2);
04991 
04992   // TMSCM_DEFER_INTS;
04993   widget out= tabs_widget (in1, in2);
04994   // TMSCM_ALLOW_INTS;
04995 
04996   return widget_to_tmscm (out);
04997 }
04998 
04999 tmscm
05000 tmg_widget_scrollable (tmscm arg1, tmscm arg2) {
05001   TMSCM_ASSERT_WIDGET (arg1, TMSCM_ARG1, "widget-scrollable");
05002   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "widget-scrollable");
05003 
05004   widget in1= tmscm_to_widget (arg1);
05005   int in2= tmscm_to_int (arg2);
05006 
05007   // TMSCM_DEFER_INTS;
05008   widget out= user_canvas_widget (in1, in2);
05009   // TMSCM_ALLOW_INTS;
05010 
05011   return widget_to_tmscm (out);
05012 }
05013 
05014 tmscm
05015 tmg_widget_resize (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4, tmscm arg5, tmscm arg6, tmscm arg7, tmscm arg8) {
05016   TMSCM_ASSERT_WIDGET (arg1, TMSCM_ARG1, "widget-resize");
05017   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "widget-resize");
05018   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "widget-resize");
05019   TMSCM_ASSERT_STRING (arg4, TMSCM_ARG4, "widget-resize");
05020   TMSCM_ASSERT_STRING (arg5, TMSCM_ARG5, "widget-resize");
05021   TMSCM_ASSERT_STRING (arg6, TMSCM_ARG6, "widget-resize");
05022   TMSCM_ASSERT_STRING (arg7, TMSCM_ARG7, "widget-resize");
05023   TMSCM_ASSERT_STRING (arg8, TMSCM_ARG8, "widget-resize");
05024 
05025   widget in1= tmscm_to_widget (arg1);
05026   int in2= tmscm_to_int (arg2);
05027   string in3= tmscm_to_string (arg3);
05028   string in4= tmscm_to_string (arg4);
05029   string in5= tmscm_to_string (arg5);
05030   string in6= tmscm_to_string (arg6);
05031   string in7= tmscm_to_string (arg7);
05032   string in8= tmscm_to_string (arg8);
05033 
05034   // TMSCM_DEFER_INTS;
05035   widget out= resize_widget (in1, in2, in3, in4, in5, in6, in7, in8);
05036   // TMSCM_ALLOW_INTS;
05037 
05038   return widget_to_tmscm (out);
05039 }
05040 
05041 tmscm
05042 tmg_widget_hsplit (tmscm arg1, tmscm arg2) {
05043   TMSCM_ASSERT_WIDGET (arg1, TMSCM_ARG1, "widget-hsplit");
05044   TMSCM_ASSERT_WIDGET (arg2, TMSCM_ARG2, "widget-hsplit");
05045 
05046   widget in1= tmscm_to_widget (arg1);
05047   widget in2= tmscm_to_widget (arg2);
05048 
05049   // TMSCM_DEFER_INTS;
05050   widget out= hsplit_widget (in1, in2);
05051   // TMSCM_ALLOW_INTS;
05052 
05053   return widget_to_tmscm (out);
05054 }
05055 
05056 tmscm
05057 tmg_widget_vsplit (tmscm arg1, tmscm arg2) {
05058   TMSCM_ASSERT_WIDGET (arg1, TMSCM_ARG1, "widget-vsplit");
05059   TMSCM_ASSERT_WIDGET (arg2, TMSCM_ARG2, "widget-vsplit");
05060 
05061   widget in1= tmscm_to_widget (arg1);
05062   widget in2= tmscm_to_widget (arg2);
05063 
05064   // TMSCM_DEFER_INTS;
05065   widget out= vsplit_widget (in1, in2);
05066   // TMSCM_ALLOW_INTS;
05067 
05068   return widget_to_tmscm (out);
05069 }
05070 
05071 tmscm
05072 tmg_widget_texmacs_output (tmscm arg1) {
05073   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "widget-texmacs-output");
05074 
05075   content in1= tmscm_to_content (arg1);
05076 
05077   // TMSCM_DEFER_INTS;
05078   widget out= texmacs_output_widget (in1);
05079   // TMSCM_ALLOW_INTS;
05080 
05081   return widget_to_tmscm (out);
05082 }
05083 
05084 tmscm
05085 tmg_widget_texmacs_input (tmscm arg1, tmscm arg2, tmscm arg3) {
05086   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "widget-texmacs-input");
05087   TMSCM_ASSERT_COMMAND (arg2, TMSCM_ARG2, "widget-texmacs-input");
05088   TMSCM_ASSERT_BOOL (arg3, TMSCM_ARG3, "widget-texmacs-input");
05089 
05090   content in1= tmscm_to_content (arg1);
05091   command in2= tmscm_to_command (arg2);
05092   bool in3= tmscm_to_bool (arg3);
05093 
05094   // TMSCM_DEFER_INTS;
05095   widget out= texmacs_input_widget (in1, in2, in3);
05096   // TMSCM_ALLOW_INTS;
05097 
05098   return widget_to_tmscm (out);
05099 }
05100 
05101 tmscm
05102 tmg_widget_ink (tmscm arg1) {
05103   TMSCM_ASSERT_COMMAND (arg1, TMSCM_ARG1, "widget-ink");
05104 
05105   command in1= tmscm_to_command (arg1);
05106 
05107   // TMSCM_DEFER_INTS;
05108   widget out= ink_widget (in1);
05109   // TMSCM_ALLOW_INTS;
05110 
05111   return widget_to_tmscm (out);
05112 }
05113 
05114 tmscm
05115 tmg_widget_refresh (tmscm arg1) {
05116   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "widget-refresh");
05117 
05118   string in1= tmscm_to_string (arg1);
05119 
05120   // TMSCM_DEFER_INTS;
05121   widget out= refresh_widget (in1);
05122   // TMSCM_ALLOW_INTS;
05123 
05124   return widget_to_tmscm (out);
05125 }
05126 
05127 tmscm
05128 tmg_object_2promise_widget (tmscm arg1) {
05129   TMSCM_ASSERT_OBJECT (arg1, TMSCM_ARG1, "object->promise-widget");
05130 
05131   object in1= tmscm_to_object (arg1);
05132 
05133   // TMSCM_DEFER_INTS;
05134   promise_widget out= as_promise_widget (in1);
05135   // TMSCM_ALLOW_INTS;
05136 
05137   return promise_widget_to_tmscm (out);
05138 }
05139 
05140 tmscm
05141 tmg_tree_bounding_rectangle (tmscm arg1) {
05142   TMSCM_ASSERT_TREE (arg1, TMSCM_ARG1, "tree-bounding-rectangle");
05143 
05144   tree in1= tmscm_to_tree (arg1);
05145 
05146   // TMSCM_DEFER_INTS;
05147   array_int out= get_bounding_rectangle (in1);
05148   // TMSCM_ALLOW_INTS;
05149 
05150   return array_int_to_tmscm (out);
05151 }
05152 
05153 tmscm
05154 tmg_show_balloon (tmscm arg1, tmscm arg2, tmscm arg3) {
05155   TMSCM_ASSERT_WIDGET (arg1, TMSCM_ARG1, "show-balloon");
05156   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "show-balloon");
05157   TMSCM_ASSERT_INT (arg3, TMSCM_ARG3, "show-balloon");
05158 
05159   widget in1= tmscm_to_widget (arg1);
05160   int in2= tmscm_to_int (arg2);
05161   int in3= tmscm_to_int (arg3);
05162 
05163   // TMSCM_DEFER_INTS;
05164   show_help_balloon (in1, in2, in3);
05165   // TMSCM_ALLOW_INTS;
05166 
05167   return TMSCM_UNSPECIFIED;
05168 }
05169 
05170 tmscm
05171 tmg_get_style_menu () {
05172   // TMSCM_DEFER_INTS;
05173   object out= get_style_menu ();
05174   // TMSCM_ALLOW_INTS;
05175 
05176   return object_to_tmscm (out);
05177 }
05178 
05179 tmscm
05180 tmg_get_add_package_menu () {
05181   // TMSCM_DEFER_INTS;
05182   object out= get_add_package_menu ();
05183   // TMSCM_ALLOW_INTS;
05184 
05185   return object_to_tmscm (out);
05186 }
05187 
05188 tmscm
05189 tmg_get_remove_package_menu () {
05190   // TMSCM_DEFER_INTS;
05191   object out= get_remove_package_menu ();
05192   // TMSCM_ALLOW_INTS;
05193 
05194   return object_to_tmscm (out);
05195 }
05196 
05197 tmscm
05198 tmg_this_buffer () {
05199   // TMSCM_DEFER_INTS;
05200   url out= get_this_buffer ();
05201   // TMSCM_ALLOW_INTS;
05202 
05203   return url_to_tmscm (out);
05204 }
05205 
05206 tmscm
05207 tmg_all_buffers () {
05208   // TMSCM_DEFER_INTS;
05209   url out= get_all_buffers ();
05210   // TMSCM_ALLOW_INTS;
05211 
05212   return url_to_tmscm (out);
05213 }
05214 
05215 tmscm
05216 tmg_path_2buffer (tmscm arg1) {
05217   TMSCM_ASSERT_PATH (arg1, TMSCM_ARG1, "path->buffer");
05218 
05219   path in1= tmscm_to_path (arg1);
05220 
05221   // TMSCM_DEFER_INTS;
05222   url out= get_name_buffer (in1);
05223   // TMSCM_ALLOW_INTS;
05224 
05225   return url_to_tmscm (out);
05226 }
05227 
05228 tmscm
05229 tmg_set_name_buffer (tmscm arg1) {
05230   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "set-name-buffer");
05231 
05232   url in1= tmscm_to_url (arg1);
05233 
05234   // TMSCM_DEFER_INTS;
05235   set_name_buffer (in1);
05236   // TMSCM_ALLOW_INTS;
05237 
05238   return TMSCM_UNSPECIFIED;
05239 }
05240 
05241 tmscm
05242 tmg_get_name_buffer () {
05243   // TMSCM_DEFER_INTS;
05244   url out= get_name_buffer ();
05245   // TMSCM_ALLOW_INTS;
05246 
05247   return url_to_tmscm (out);
05248 }
05249 
05250 tmscm
05251 tmg_buffer_set_short_name (tmscm arg1, tmscm arg2) {
05252   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "buffer-set-short-name");
05253   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "buffer-set-short-name");
05254 
05255   url in1= tmscm_to_url (arg1);
05256   string in2= tmscm_to_string (arg2);
05257 
05258   // TMSCM_DEFER_INTS;
05259   set_abbr_buffer (in1, in2);
05260   // TMSCM_ALLOW_INTS;
05261 
05262   return TMSCM_UNSPECIFIED;
05263 }
05264 
05265 tmscm
05266 tmg_buffer_get_short_name (tmscm arg1) {
05267   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "buffer-get-short-name");
05268 
05269   url in1= tmscm_to_url (arg1);
05270 
05271   // TMSCM_DEFER_INTS;
05272   string out= get_abbr_buffer (in1);
05273   // TMSCM_ALLOW_INTS;
05274 
05275   return string_to_tmscm (out);
05276 }
05277 
05278 tmscm
05279 tmg_buffer_modifiedP (tmscm arg1) {
05280   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "buffer-modified?");
05281 
05282   url in1= tmscm_to_url (arg1);
05283 
05284   // TMSCM_DEFER_INTS;
05285   bool out= buffer_modified (in1);
05286   // TMSCM_ALLOW_INTS;
05287 
05288   return bool_to_tmscm (out);
05289 }
05290 
05291 tmscm
05292 tmg_buffer_in_menuP (tmscm arg1) {
05293   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "buffer-in-menu?");
05294 
05295   url in1= tmscm_to_url (arg1);
05296 
05297   // TMSCM_DEFER_INTS;
05298   bool out= buffer_in_menu (in1);
05299   // TMSCM_ALLOW_INTS;
05300 
05301   return bool_to_tmscm (out);
05302 }
05303 
05304 tmscm
05305 tmg_buffer_last_visited (tmscm arg1) {
05306   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "buffer-last-visited");
05307 
05308   url in1= tmscm_to_url (arg1);
05309 
05310   // TMSCM_DEFER_INTS;
05311   double out= last_visited (in1);
05312   // TMSCM_ALLOW_INTS;
05313 
05314   return double_to_tmscm (out);
05315 }
05316 
05317 tmscm
05318 tmg_buffer_set_tree (tmscm arg1, tmscm arg2) {
05319   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "buffer-set-tree");
05320   TMSCM_ASSERT_CONTENT (arg2, TMSCM_ARG2, "buffer-set-tree");
05321 
05322   url in1= tmscm_to_url (arg1);
05323   content in2= tmscm_to_content (arg2);
05324 
05325   // TMSCM_DEFER_INTS;
05326   set_buffer_tree (in1, in2);
05327   // TMSCM_ALLOW_INTS;
05328 
05329   return TMSCM_UNSPECIFIED;
05330 }
05331 
05332 tmscm
05333 tmg_buffer_get_tree (tmscm arg1) {
05334   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "buffer-get-tree");
05335 
05336   url in1= tmscm_to_url (arg1);
05337 
05338   // TMSCM_DEFER_INTS;
05339   tree out= get_buffer_tree (in1);
05340   // TMSCM_ALLOW_INTS;
05341 
05342   return tree_to_tmscm (out);
05343 }
05344 
05345 tmscm
05346 tmg_buffer_revert_tree (tmscm arg1, tmscm arg2) {
05347   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "buffer-revert-tree");
05348   TMSCM_ASSERT_CONTENT (arg2, TMSCM_ARG2, "buffer-revert-tree");
05349 
05350   url in1= tmscm_to_url (arg1);
05351   content in2= tmscm_to_content (arg2);
05352 
05353   // TMSCM_DEFER_INTS;
05354   revert_buffer (in1, in2);
05355   // TMSCM_ALLOW_INTS;
05356 
05357   return TMSCM_UNSPECIFIED;
05358 }
05359 
05360 tmscm
05361 tmg_new_buffer () {
05362   // TMSCM_DEFER_INTS;
05363   url out= create_buffer ();
05364   // TMSCM_ALLOW_INTS;
05365 
05366   return url_to_tmscm (out);
05367 }
05368 
05369 tmscm
05370 tmg_switch_to_buffer_path (tmscm arg1) {
05371   TMSCM_ASSERT_PATH (arg1, TMSCM_ARG1, "switch-to-buffer-path");
05372 
05373   path in1= tmscm_to_path (arg1);
05374 
05375   // TMSCM_DEFER_INTS;
05376   bool out= switch_to_buffer (in1);
05377   // TMSCM_ALLOW_INTS;
05378 
05379   return bool_to_tmscm (out);
05380 }
05381 
05382 tmscm
05383 tmg_switch_to_buffer (tmscm arg1) {
05384   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "switch-to-buffer");
05385 
05386   url in1= tmscm_to_url (arg1);
05387 
05388   // TMSCM_DEFER_INTS;
05389   switch_to_buffer (in1);
05390   // TMSCM_ALLOW_INTS;
05391 
05392   return TMSCM_UNSPECIFIED;
05393 }
05394 
05395 tmscm
05396 tmg_switch_to_active_buffer (tmscm arg1) {
05397   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "switch-to-active-buffer");
05398 
05399   url in1= tmscm_to_url (arg1);
05400 
05401   // TMSCM_DEFER_INTS;
05402   switch_to_active_buffer (in1);
05403   // TMSCM_ALLOW_INTS;
05404 
05405   return TMSCM_UNSPECIFIED;
05406 }
05407 
05408 tmscm
05409 tmg_revert_buffer () {
05410   // TMSCM_DEFER_INTS;
05411   revert_buffer ();
05412   // TMSCM_ALLOW_INTS;
05413 
05414   return TMSCM_UNSPECIFIED;
05415 }
05416 
05417 tmscm
05418 tmg_kill_buffer () {
05419   // TMSCM_DEFER_INTS;
05420   kill_buffer ();
05421   // TMSCM_ALLOW_INTS;
05422 
05423   return TMSCM_UNSPECIFIED;
05424 }
05425 
05426 tmscm
05427 tmg_no_nameP () {
05428   // TMSCM_DEFER_INTS;
05429   bool out= no_name ();
05430   // TMSCM_ALLOW_INTS;
05431 
05432   return bool_to_tmscm (out);
05433 }
05434 
05435 tmscm
05436 tmg_help_bufferP () {
05437   // TMSCM_DEFER_INTS;
05438   bool out= help_buffer ();
05439   // TMSCM_ALLOW_INTS;
05440 
05441   return bool_to_tmscm (out);
05442 }
05443 
05444 tmscm
05445 tmg_aux_bufferP (tmscm arg1) {
05446   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "aux-buffer?");
05447 
05448   url in1= tmscm_to_url (arg1);
05449 
05450   // TMSCM_DEFER_INTS;
05451   bool out= is_aux_buffer (in1);
05452   // TMSCM_ALLOW_INTS;
05453 
05454   return bool_to_tmscm (out);
05455 }
05456 
05457 tmscm
05458 tmg_set_aux (tmscm arg1, tmscm arg2) {
05459   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "set-aux");
05460   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "set-aux");
05461 
05462   string in1= tmscm_to_string (arg1);
05463   url in2= tmscm_to_url (arg2);
05464 
05465   // TMSCM_DEFER_INTS;
05466   set_aux (in1, in2);
05467   // TMSCM_ALLOW_INTS;
05468 
05469   return TMSCM_UNSPECIFIED;
05470 }
05471 
05472 tmscm
05473 tmg_set_aux_buffer (tmscm arg1, tmscm arg2, tmscm arg3) {
05474   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "set-aux-buffer");
05475   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "set-aux-buffer");
05476   TMSCM_ASSERT_CONTENT (arg3, TMSCM_ARG3, "set-aux-buffer");
05477 
05478   string in1= tmscm_to_string (arg1);
05479   url in2= tmscm_to_url (arg2);
05480   content in3= tmscm_to_content (arg3);
05481 
05482   // TMSCM_DEFER_INTS;
05483   set_aux_buffer (in1, in2, in3);
05484   // TMSCM_ALLOW_INTS;
05485 
05486   return TMSCM_UNSPECIFIED;
05487 }
05488 
05489 tmscm
05490 tmg_set_help_buffer (tmscm arg1, tmscm arg2) {
05491   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "set-help-buffer");
05492   TMSCM_ASSERT_CONTENT (arg2, TMSCM_ARG2, "set-help-buffer");
05493 
05494   url in1= tmscm_to_url (arg1);
05495   content in2= tmscm_to_content (arg2);
05496 
05497   // TMSCM_DEFER_INTS;
05498   set_help_buffer (in1, in2);
05499   // TMSCM_ALLOW_INTS;
05500 
05501   return TMSCM_UNSPECIFIED;
05502 }
05503 
05504 tmscm
05505 tmg_open_buffer_in_window (tmscm arg1, tmscm arg2, tmscm arg3) {
05506   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "open-buffer-in-window");
05507   TMSCM_ASSERT_CONTENT (arg2, TMSCM_ARG2, "open-buffer-in-window");
05508   TMSCM_ASSERT_CONTENT (arg3, TMSCM_ARG3, "open-buffer-in-window");
05509 
05510   url in1= tmscm_to_url (arg1);
05511   content in2= tmscm_to_content (arg2);
05512   content in3= tmscm_to_content (arg3);
05513 
05514   // TMSCM_DEFER_INTS;
05515   new_buffer_in_new_window (in1, in2, in3);
05516   // TMSCM_ALLOW_INTS;
05517 
05518   return TMSCM_UNSPECIFIED;
05519 }
05520 
05521 tmscm
05522 tmg_open_window () {
05523   // TMSCM_DEFER_INTS;
05524   url out= open_window ();
05525   // TMSCM_ALLOW_INTS;
05526 
05527   return url_to_tmscm (out);
05528 }
05529 
05530 tmscm
05531 tmg_open_window_geometry (tmscm arg1) {
05532   TMSCM_ASSERT_CONTENT (arg1, TMSCM_ARG1, "open-window-geometry");
05533 
05534   content in1= tmscm_to_content (arg1);
05535 
05536   // TMSCM_DEFER_INTS;
05537   url out= open_window (in1);
05538   // TMSCM_ALLOW_INTS;
05539 
05540   return url_to_tmscm (out);
05541 }
05542 
05543 tmscm
05544 tmg_clone_window () {
05545   // TMSCM_DEFER_INTS;
05546   clone_window ();
05547   // TMSCM_ALLOW_INTS;
05548 
05549   return TMSCM_UNSPECIFIED;
05550 }
05551 
05552 tmscm
05553 tmg_kill_window () {
05554   // TMSCM_DEFER_INTS;
05555   kill_window ();
05556   // TMSCM_ALLOW_INTS;
05557 
05558   return TMSCM_UNSPECIFIED;
05559 }
05560 
05561 tmscm
05562 tmg_kill_window_and_buffer () {
05563   // TMSCM_DEFER_INTS;
05564   kill_window_and_buffer ();
05565   // TMSCM_ALLOW_INTS;
05566 
05567   return TMSCM_UNSPECIFIED;
05568 }
05569 
05570 tmscm
05571 tmg_project_attach (tmscm arg1) {
05572   TMSCM_ASSERT_STRING (arg1, TMSCM_ARG1, "project-attach");
05573 
05574   string in1= tmscm_to_string (arg1);
05575 
05576   // TMSCM_DEFER_INTS;
05577   project_attach (in1);
05578   // TMSCM_ALLOW_INTS;
05579 
05580   return TMSCM_UNSPECIFIED;
05581 }
05582 
05583 tmscm
05584 tmg_project_detach () {
05585   // TMSCM_DEFER_INTS;
05586   project_attach ();
05587   // TMSCM_ALLOW_INTS;
05588 
05589   return TMSCM_UNSPECIFIED;
05590 }
05591 
05592 tmscm
05593 tmg_project_attachedP () {
05594   // TMSCM_DEFER_INTS;
05595   bool out= project_attached ();
05596   // TMSCM_ALLOW_INTS;
05597 
05598   return bool_to_tmscm (out);
05599 }
05600 
05601 tmscm
05602 tmg_project_get () {
05603   // TMSCM_DEFER_INTS;
05604   url out= project_get ();
05605   // TMSCM_ALLOW_INTS;
05606 
05607   return url_to_tmscm (out);
05608 }
05609 
05610 tmscm
05611 tmg_window_current () {
05612   // TMSCM_DEFER_INTS;
05613   int out= window_current ();
05614   // TMSCM_ALLOW_INTS;
05615 
05616   return int_to_tmscm (out);
05617 }
05618 
05619 tmscm
05620 tmg_window_list () {
05621   // TMSCM_DEFER_INTS;
05622   path out= windows_list ();
05623   // TMSCM_ALLOW_INTS;
05624 
05625   return path_to_tmscm (out);
05626 }
05627 
05628 tmscm
05629 tmg_buffer_2windows (tmscm arg1) {
05630   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "buffer->windows");
05631 
05632   url in1= tmscm_to_url (arg1);
05633 
05634   // TMSCM_DEFER_INTS;
05635   path out= buffer_to_windows (in1);
05636   // TMSCM_ALLOW_INTS;
05637 
05638   return path_to_tmscm (out);
05639 }
05640 
05641 tmscm
05642 tmg_window_2buffer (tmscm arg1) {
05643   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "window->buffer");
05644 
05645   int in1= tmscm_to_int (arg1);
05646 
05647   // TMSCM_DEFER_INTS;
05648   url out= window_to_buffer (in1);
05649   // TMSCM_ALLOW_INTS;
05650 
05651   return url_to_tmscm (out);
05652 }
05653 
05654 tmscm
05655 tmg_window_set_buffer (tmscm arg1, tmscm arg2) {
05656   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "window-set-buffer");
05657   TMSCM_ASSERT_URL (arg2, TMSCM_ARG2, "window-set-buffer");
05658 
05659   int in1= tmscm_to_int (arg1);
05660   url in2= tmscm_to_url (arg2);
05661 
05662   // TMSCM_DEFER_INTS;
05663   window_set_buffer (in1, in2);
05664   // TMSCM_ALLOW_INTS;
05665 
05666   return TMSCM_UNSPECIFIED;
05667 }
05668 
05669 tmscm
05670 tmg_window_focus (tmscm arg1) {
05671   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "window-focus");
05672 
05673   int in1= tmscm_to_int (arg1);
05674 
05675   // TMSCM_DEFER_INTS;
05676   window_focus (in1);
05677   // TMSCM_ALLOW_INTS;
05678 
05679   return TMSCM_UNSPECIFIED;
05680 }
05681 
05682 tmscm
05683 tmg_pretend_save_buffer () {
05684   // TMSCM_DEFER_INTS;
05685   pretend_save_buffer ();
05686   // TMSCM_ALLOW_INTS;
05687 
05688   return TMSCM_UNSPECIFIED;
05689 }
05690 
05691 tmscm
05692 tmg_buffer_unsavedP () {
05693   // TMSCM_DEFER_INTS;
05694   bool out= buffer_unsaved ();
05695   // TMSCM_ALLOW_INTS;
05696 
05697   return bool_to_tmscm (out);
05698 }
05699 
05700 tmscm
05701 tmg_exists_unsaved_bufferP () {
05702   // TMSCM_DEFER_INTS;
05703   bool out= exists_unsaved_buffer ();
05704   // TMSCM_ALLOW_INTS;
05705 
05706   return bool_to_tmscm (out);
05707 }
05708 
05709 tmscm
05710 tmg_texmacs_load_tree (tmscm arg1, tmscm arg2) {
05711   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "texmacs-load-tree");
05712   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "texmacs-load-tree");
05713 
05714   url in1= tmscm_to_url (arg1);
05715   string in2= tmscm_to_string (arg2);
05716 
05717   // TMSCM_DEFER_INTS;
05718   tree out= load_tree (in1, in2);
05719   // TMSCM_ALLOW_INTS;
05720 
05721   return tree_to_tmscm (out);
05722 }
05723 
05724 tmscm
05725 tmg_texmacs_load_buffer (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4) {
05726   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "texmacs-load-buffer");
05727   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "texmacs-load-buffer");
05728   TMSCM_ASSERT_INT (arg3, TMSCM_ARG3, "texmacs-load-buffer");
05729   TMSCM_ASSERT_BOOL (arg4, TMSCM_ARG4, "texmacs-load-buffer");
05730 
05731   url in1= tmscm_to_url (arg1);
05732   string in2= tmscm_to_string (arg2);
05733   int in3= tmscm_to_int (arg3);
05734   bool in4= tmscm_to_bool (arg4);
05735 
05736   // TMSCM_DEFER_INTS;
05737   load_buffer (in1, in2, in3, in4);
05738   // TMSCM_ALLOW_INTS;
05739 
05740   return TMSCM_UNSPECIFIED;
05741 }
05742 
05743 tmscm
05744 tmg_texmacs_save_buffer (tmscm arg1, tmscm arg2) {
05745   TMSCM_ASSERT_URL (arg1, TMSCM_ARG1, "texmacs-save-buffer");
05746   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "texmacs-save-buffer");
05747 
05748   url in1= tmscm_to_url (arg1);
05749   string in2= tmscm_to_string (arg2);
05750 
05751   // TMSCM_DEFER_INTS;
05752   save_buffer (in1, in2);
05753   // TMSCM_ALLOW_INTS;
05754 
05755   return TMSCM_UNSPECIFIED;
05756 }
05757 
05758 tmscm
05759 tmg_auto_save () {
05760   // TMSCM_DEFER_INTS;
05761   auto_save ();
05762   // TMSCM_ALLOW_INTS;
05763 
05764   return TMSCM_UNSPECIFIED;
05765 }
05766 
05767 tmscm
05768 tmg_window_handle () {
05769   // TMSCM_DEFER_INTS;
05770   int out= window_handle ();
05771   // TMSCM_ALLOW_INTS;
05772 
05773   return int_to_tmscm (out);
05774 }
05775 
05776 tmscm
05777 tmg_window_create (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4) {
05778   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "window-create");
05779   TMSCM_ASSERT_WIDGET (arg2, TMSCM_ARG2, "window-create");
05780   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "window-create");
05781   TMSCM_ASSERT_BOOL (arg4, TMSCM_ARG4, "window-create");
05782 
05783   int in1= tmscm_to_int (arg1);
05784   widget in2= tmscm_to_widget (arg2);
05785   string in3= tmscm_to_string (arg3);
05786   bool in4= tmscm_to_bool (arg4);
05787 
05788   // TMSCM_DEFER_INTS;
05789   window_create (in1, in2, in3, in4);
05790   // TMSCM_ALLOW_INTS;
05791 
05792   return TMSCM_UNSPECIFIED;
05793 }
05794 
05795 tmscm
05796 tmg_window_create_quit (tmscm arg1, tmscm arg2, tmscm arg3, tmscm arg4) {
05797   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "window-create-quit");
05798   TMSCM_ASSERT_WIDGET (arg2, TMSCM_ARG2, "window-create-quit");
05799   TMSCM_ASSERT_STRING (arg3, TMSCM_ARG3, "window-create-quit");
05800   TMSCM_ASSERT_COMMAND (arg4, TMSCM_ARG4, "window-create-quit");
05801 
05802   int in1= tmscm_to_int (arg1);
05803   widget in2= tmscm_to_widget (arg2);
05804   string in3= tmscm_to_string (arg3);
05805   command in4= tmscm_to_command (arg4);
05806 
05807   // TMSCM_DEFER_INTS;
05808   window_create (in1, in2, in3, in4);
05809   // TMSCM_ALLOW_INTS;
05810 
05811   return TMSCM_UNSPECIFIED;
05812 }
05813 
05814 tmscm
05815 tmg_window_delete (tmscm arg1) {
05816   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "window-delete");
05817 
05818   int in1= tmscm_to_int (arg1);
05819 
05820   // TMSCM_DEFER_INTS;
05821   window_delete (in1);
05822   // TMSCM_ALLOW_INTS;
05823 
05824   return TMSCM_UNSPECIFIED;
05825 }
05826 
05827 tmscm
05828 tmg_window_show (tmscm arg1) {
05829   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "window-show");
05830 
05831   int in1= tmscm_to_int (arg1);
05832 
05833   // TMSCM_DEFER_INTS;
05834   window_show (in1);
05835   // TMSCM_ALLOW_INTS;
05836 
05837   return TMSCM_UNSPECIFIED;
05838 }
05839 
05840 tmscm
05841 tmg_window_hide (tmscm arg1) {
05842   TMSCM_ASSERT_INT (arg1, TMSCM_ARG1, "window-hide");
05843 
05844   int in1= tmscm_to_int (arg1);
05845 
05846   // TMSCM_DEFER_INTS;
05847   window_hide (in1);
05848   // TMSCM_ALLOW_INTS;
05849 
05850   return TMSCM_UNSPECIFIED;
05851 }
05852 
05853 tmscm
05854 tmg_bib_add_period (tmscm arg1) {
05855   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "bib-add-period");
05856 
05857   scheme_tree in1= tmscm_to_scheme_tree (arg1);
05858 
05859   // TMSCM_DEFER_INTS;
05860   scheme_tree out= bib_add_period (in1);
05861   // TMSCM_ALLOW_INTS;
05862 
05863   return scheme_tree_to_tmscm (out);
05864 }
05865 
05866 tmscm
05867 tmg_bib_upcase_first (tmscm arg1) {
05868   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "bib-upcase-first");
05869 
05870   scheme_tree in1= tmscm_to_scheme_tree (arg1);
05871 
05872   // TMSCM_DEFER_INTS;
05873   scheme_tree out= bib_upcase_first (in1);
05874   // TMSCM_ALLOW_INTS;
05875 
05876   return scheme_tree_to_tmscm (out);
05877 }
05878 
05879 tmscm
05880 tmg_bib_locase (tmscm arg1) {
05881   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "bib-locase");
05882 
05883   scheme_tree in1= tmscm_to_scheme_tree (arg1);
05884 
05885   // TMSCM_DEFER_INTS;
05886   scheme_tree out= bib_locase (in1);
05887   // TMSCM_ALLOW_INTS;
05888 
05889   return scheme_tree_to_tmscm (out);
05890 }
05891 
05892 tmscm
05893 tmg_bib_upcase (tmscm arg1) {
05894   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "bib-upcase");
05895 
05896   scheme_tree in1= tmscm_to_scheme_tree (arg1);
05897 
05898   // TMSCM_DEFER_INTS;
05899   scheme_tree out= bib_upcase (in1);
05900   // TMSCM_ALLOW_INTS;
05901 
05902   return scheme_tree_to_tmscm (out);
05903 }
05904 
05905 tmscm
05906 tmg_bib_default (tmscm arg1) {
05907   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "bib-default");
05908 
05909   scheme_tree in1= tmscm_to_scheme_tree (arg1);
05910 
05911   // TMSCM_DEFER_INTS;
05912   scheme_tree out= bib_default (in1);
05913   // TMSCM_ALLOW_INTS;
05914 
05915   return scheme_tree_to_tmscm (out);
05916 }
05917 
05918 tmscm
05919 tmg_bib_purify (tmscm arg1) {
05920   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "bib-purify");
05921 
05922   scheme_tree in1= tmscm_to_scheme_tree (arg1);
05923 
05924   // TMSCM_DEFER_INTS;
05925   string out= bib_purify (in1);
05926   // TMSCM_ALLOW_INTS;
05927 
05928   return string_to_tmscm (out);
05929 }
05930 
05931 tmscm
05932 tmg_bib_text_length (tmscm arg1) {
05933   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "bib-text-length");
05934 
05935   scheme_tree in1= tmscm_to_scheme_tree (arg1);
05936 
05937   // TMSCM_DEFER_INTS;
05938   int out= bib_text_length (in1);
05939   // TMSCM_ALLOW_INTS;
05940 
05941   return int_to_tmscm (out);
05942 }
05943 
05944 tmscm
05945 tmg_bib_prefix (tmscm arg1, tmscm arg2) {
05946   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "bib-prefix");
05947   TMSCM_ASSERT_INT (arg2, TMSCM_ARG2, "bib-prefix");
05948 
05949   scheme_tree in1= tmscm_to_scheme_tree (arg1);
05950   int in2= tmscm_to_int (arg2);
05951 
05952   // TMSCM_DEFER_INTS;
05953   string out= bib_prefix (in1, in2);
05954   // TMSCM_ALLOW_INTS;
05955 
05956   return string_to_tmscm (out);
05957 }
05958 
05959 tmscm
05960 tmg_bib_emptyP (tmscm arg1, tmscm arg2) {
05961   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "bib-empty?");
05962   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "bib-empty?");
05963 
05964   scheme_tree in1= tmscm_to_scheme_tree (arg1);
05965   string in2= tmscm_to_string (arg2);
05966 
05967   // TMSCM_DEFER_INTS;
05968   bool out= bib_empty (in1, in2);
05969   // TMSCM_ALLOW_INTS;
05970 
05971   return bool_to_tmscm (out);
05972 }
05973 
05974 tmscm
05975 tmg_bib_field (tmscm arg1, tmscm arg2) {
05976   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "bib-field");
05977   TMSCM_ASSERT_STRING (arg2, TMSCM_ARG2, "bib-field");
05978 
05979   scheme_tree in1= tmscm_to_scheme_tree (arg1);
05980   string in2= tmscm_to_string (arg2);
05981 
05982   // TMSCM_DEFER_INTS;
05983   scheme_tree out= bib_field (in1, in2);
05984   // TMSCM_ALLOW_INTS;
05985 
05986   return scheme_tree_to_tmscm (out);
05987 }
05988 
05989 tmscm
05990 tmg_bib_abbreviate (tmscm arg1, tmscm arg2, tmscm arg3) {
05991   TMSCM_ASSERT_SCHEME_TREE (arg1, TMSCM_ARG1, "bib-abbreviate");
05992   TMSCM_ASSERT_SCHEME_TREE (arg2, TMSCM_ARG2, "bib-abbreviate");
05993   TMSCM_ASSERT_SCHEME_TREE (arg3, TMSCM_ARG3, "bib-abbreviate");
05994 
05995   scheme_tree in1= tmscm_to_scheme_tree (arg1);
05996   scheme_tree in2= tmscm_to_scheme_tree (arg2);
05997   scheme_tree in3= tmscm_to_scheme_tree (arg3);
05998 
05999   // TMSCM_DEFER_INTS;
06000   scheme_tree out= bib_abbreviate (in1, in2, in3);
06001   // TMSCM_ALLOW_INTS;
06002 
06003   return scheme_tree_to_tmscm (out);
06004 }
06005 
06006 void
06007 initialize_glue_basic () {
06008   tmscm_install_procedure ("texmacs-version-release",  tmg_texmacs_version_release, 1, 0, 0);
06009   tmscm_install_procedure ("version-before?",  tmg_version_beforeP, 2, 0, 0);
06010   tmscm_install_procedure ("os-win32?",  tmg_os_win32P, 0, 0, 0);
06011   tmscm_install_procedure ("os-mingw?",  tmg_os_mingwP, 0, 0, 0);
06012   tmscm_install_procedure ("os-macos?",  tmg_os_macosP, 0, 0, 0);
06013   tmscm_install_procedure ("x-gui?",  tmg_x_guiP, 0, 0, 0);
06014   tmscm_install_procedure ("qt-gui?",  tmg_qt_guiP, 0, 0, 0);
06015   tmscm_install_procedure ("default-look-and-feel",  tmg_default_look_and_feel, 0, 0, 0);
06016   tmscm_install_procedure ("default-chinese-font",  tmg_default_chinese_font, 0, 0, 0);
06017   tmscm_install_procedure ("default-japanese-font",  tmg_default_japanese_font, 0, 0, 0);
06018   tmscm_install_procedure ("default-korean-font",  tmg_default_korean_font, 0, 0, 0);
06019   tmscm_install_procedure ("tm-output",  tmg_tm_output, 1, 0, 0);
06020   tmscm_install_procedure ("tm-errput",  tmg_tm_errput, 1, 0, 0);
06021   tmscm_install_procedure ("win32-display",  tmg_win32_display, 1, 0, 0);
06022   tmscm_install_procedure ("cpp-error",  tmg_cpp_error, 0, 0, 0);
06023   tmscm_install_procedure ("scheme-dialect",  tmg_scheme_dialect, 0, 0, 0);
06024   tmscm_install_procedure ("get-texmacs-path",  tmg_get_texmacs_path, 0, 0, 0);
06025   tmscm_install_procedure ("plugin-list",  tmg_plugin_list, 0, 0, 0);
06026   tmscm_install_procedure ("set-fast-environments",  tmg_set_fast_environments, 1, 0, 0);
06027   tmscm_install_procedure ("font-exists-in-tt?",  tmg_font_exists_in_ttP, 1, 0, 0);
06028   tmscm_install_procedure ("eval-system",  tmg_eval_system, 1, 0, 0);
06029   tmscm_install_procedure ("var-eval-system",  tmg_var_eval_system, 1, 0, 0);
06030   tmscm_install_procedure ("get-locale-language",  tmg_get_locale_language, 0, 0, 0);
06031   tmscm_install_procedure ("texmacs-time",  tmg_texmacs_time, 0, 0, 0);
06032   tmscm_install_procedure ("texmacs-memory",  tmg_texmacs_memory, 0, 0, 0);
06033   tmscm_install_procedure ("bench-print",  tmg_bench_print, 1, 0, 0);
06034   tmscm_install_procedure ("bench-print-all",  tmg_bench_print_all, 0, 0, 0);
06035   tmscm_install_procedure ("system-wait",  tmg_system_wait, 2, 0, 0);
06036   tmscm_install_procedure ("set-bibtex-command",  tmg_set_bibtex_command, 1, 0, 0);
06037   tmscm_install_procedure ("math-symbol-group",  tmg_math_symbol_group, 1, 0, 0);
06038   tmscm_install_procedure ("math-group-members",  tmg_math_group_members, 1, 0, 0);
06039   tmscm_install_procedure ("math-symbol-type",  tmg_math_symbol_type, 1, 0, 0);
06040   tmscm_install_procedure ("object->command",  tmg_object_2command, 1, 0, 0);
06041   tmscm_install_procedure ("exec-delayed",  tmg_exec_delayed, 1, 0, 0);
06042   tmscm_install_procedure ("exec-delayed-pause",  tmg_exec_delayed_pause, 1, 0, 0);
06043   tmscm_install_procedure ("notify-preferences-loaded",  tmg_notify_preferences_loaded, 0, 0, 0);
06044   tmscm_install_procedure ("set-input-language",  tmg_set_input_language, 1, 0, 0);
06045   tmscm_install_procedure ("get-input-language",  tmg_get_input_language, 0, 0, 0);
06046   tmscm_install_procedure ("set-output-language",  tmg_set_output_language, 1, 0, 0);
06047   tmscm_install_procedure ("get-output-language",  tmg_get_output_language, 0, 0, 0);
06048   tmscm_install_procedure ("translate",  tmg_translate, 1, 0, 0);
06049   tmscm_install_procedure ("translate-from-to",  tmg_translate_from_to, 3, 0, 0);
06050   tmscm_install_procedure ("tree-translate",  tmg_tree_translate, 1, 0, 0);
06051   tmscm_install_procedure ("tree-translate-from-to",  tmg_tree_translate_from_to, 3, 0, 0);
06052   tmscm_install_procedure ("color",  tmg_color, 1, 0, 0);
06053   tmscm_install_procedure ("new-author",  tmg_new_author, 0, 0, 0);
06054   tmscm_install_procedure ("set-author",  tmg_set_author, 1, 0, 0);
06055   tmscm_install_procedure ("get-author",  tmg_get_author, 0, 0, 0);
06056   tmscm_install_procedure ("debug-set",  tmg_debug_set, 2, 0, 0);
06057   tmscm_install_procedure ("debug-get",  tmg_debug_get, 1, 0, 0);
06058   tmscm_install_procedure ("cout-buffer",  tmg_cout_buffer, 0, 0, 0);
06059   tmscm_install_procedure ("cout-unbuffer",  tmg_cout_unbuffer, 0, 0, 0);
06060   tmscm_install_procedure ("mark-new",  tmg_mark_new, 0, 0, 0);
06061   tmscm_install_procedure ("glyph-register",  tmg_glyph_register, 2, 0, 0);
06062   tmscm_install_procedure ("glyph-recognize",  tmg_glyph_recognize, 1, 0, 0);
06063   tmscm_install_procedure ("image->psdoc",  tmg_image_2psdoc, 1, 0, 0);
06064   tmscm_install_procedure ("tree->stree",  tmg_tree_2stree, 1, 0, 0);
06065   tmscm_install_procedure ("stree->tree",  tmg_stree_2tree, 1, 0, 0);
06066   tmscm_install_procedure ("tree->string",  tmg_tree_2string, 1, 0, 0);
06067   tmscm_install_procedure ("string->tree",  tmg_string_2tree, 1, 0, 0);
06068   tmscm_install_procedure ("tm->tree",  tmg_tm_2tree, 1, 0, 0);
06069   tmscm_install_procedure ("tree-atomic?",  tmg_tree_atomicP, 1, 0, 0);
06070   tmscm_install_procedure ("tree-compound?",  tmg_tree_compoundP, 1, 0, 0);
06071   tmscm_install_procedure ("tree-label",  tmg_tree_label, 1, 0, 0);
06072   tmscm_install_procedure ("tree-children",  tmg_tree_children, 1, 0, 0);
06073   tmscm_install_procedure ("tree-arity",  tmg_tree_arity, 1, 0, 0);
06074   tmscm_install_procedure ("tree-child-ref",  tmg_tree_child_ref, 2, 0, 0);
06075   tmscm_install_procedure ("tree-child-set!",  tmg_tree_child_setS, 3, 0, 0);
06076   tmscm_install_procedure ("tree-child-insert",  tmg_tree_child_insert, 3, 0, 0);
06077   tmscm_install_procedure ("tree-ip",  tmg_tree_ip, 1, 0, 0);
06078   tmscm_install_procedure ("tree-active?",  tmg_tree_activeP, 1, 0, 0);
06079   tmscm_install_procedure ("tree-eq?",  tmg_tree_eqP, 2, 0, 0);
06080   tmscm_install_procedure ("subtree",  tmg_subtree, 2, 0, 0);
06081   tmscm_install_procedure ("tree-range",  tmg_tree_range, 3, 0, 0);
06082   tmscm_install_procedure ("tree-copy",  tmg_tree_copy, 1, 0, 0);
06083   tmscm_install_procedure ("tree-append",  tmg_tree_append, 2, 0, 0);
06084   tmscm_install_procedure ("tree-right-index",  tmg_tree_right_index, 1, 0, 0);
06085   tmscm_install_procedure ("tree-label-extension?",  tmg_tree_label_extensionP, 1, 0, 0);
06086   tmscm_install_procedure ("tree-multi-paragraph?",  tmg_tree_multi_paragraphP, 1, 0, 0);
06087   tmscm_install_procedure ("tree-simplify",  tmg_tree_simplify, 1, 0, 0);
06088   tmscm_install_procedure ("tree-minimal-arity",  tmg_tree_minimal_arity, 1, 0, 0);
06089   tmscm_install_procedure ("tree-maximal-arity",  tmg_tree_maximal_arity, 1, 0, 0);
06090   tmscm_install_procedure ("tree-possible-arity?",  tmg_tree_possible_arityP, 2, 0, 0);
06091   tmscm_install_procedure ("tree-insert_point",  tmg_tree_insert_point, 2, 0, 0);
06092   tmscm_install_procedure ("tree-is-dynamic?",  tmg_tree_is_dynamicP, 1, 0, 0);
06093   tmscm_install_procedure ("tree-accessible-child?",  tmg_tree_accessible_childP, 2, 0, 0);
06094   tmscm_install_procedure ("tree-accessible-children",  tmg_tree_accessible_children, 1, 0, 0);
06095   tmscm_install_procedure ("tree-all-accessible?",  tmg_tree_all_accessibleP, 1, 0, 0);
06096   tmscm_install_procedure ("tree-none-accessible?",  tmg_tree_none_accessibleP, 1, 0, 0);
06097   tmscm_install_procedure ("tree-name",  tmg_tree_name, 1, 0, 0);
06098   tmscm_install_procedure ("tree-long-name",  tmg_tree_long_name, 1, 0, 0);
06099   tmscm_install_procedure ("tree-child-name",  tmg_tree_child_name, 2, 0, 0);
06100   tmscm_install_procedure ("tree-child-long-name",  tmg_tree_child_long_name, 2, 0, 0);
06101   tmscm_install_procedure ("tree-child-type",  tmg_tree_child_type, 2, 0, 0);
06102   tmscm_install_procedure ("tree-child-env",  tmg_tree_child_env, 4, 0, 0);
06103   tmscm_install_procedure ("tree-load-inclusion",  tmg_tree_load_inclusion, 1, 0, 0);
06104   tmscm_install_procedure ("tree-as-string",  tmg_tree_as_string, 1, 0, 0);
06105   tmscm_install_procedure ("tree-extents",  tmg_tree_extents, 1, 0, 0);
06106   tmscm_install_procedure ("tree-empty?",  tmg_tree_emptyP, 1, 0, 0);
06107   tmscm_install_procedure ("tree-is-buffer?",  tmg_tree_is_bufferP, 1, 0, 0);
06108   tmscm_install_procedure ("tree-search-sections",  tmg_tree_search_sections, 1, 0, 0);
06109   tmscm_install_procedure ("tree-assign",  tmg_tree_assign, 2, 0, 0);
06110   tmscm_install_procedure ("tree-var-insert",  tmg_tree_var_insert, 3, 0, 0);
06111   tmscm_install_procedure ("tree-remove",  tmg_tree_remove, 3, 0, 0);
06112   tmscm_install_procedure ("tree-split",  tmg_tree_split, 3, 0, 0);
06113   tmscm_install_procedure ("tree-join",  tmg_tree_join, 2, 0, 0);
06114   tmscm_install_procedure ("tree-assign-node",  tmg_tree_assign_node, 2, 0, 0);
06115   tmscm_install_procedure ("tree-insert-node",  tmg_tree_insert_node, 3, 0, 0);
06116   tmscm_install_procedure ("tree-remove-node",  tmg_tree_remove_node, 2, 0, 0);
06117   tmscm_install_procedure ("cpp-tree-correct-node",  tmg_cpp_tree_correct_node, 1, 0, 0);
06118   tmscm_install_procedure ("cpp-tree-correct-downwards",  tmg_cpp_tree_correct_downwards, 1, 0, 0);
06119   tmscm_install_procedure ("cpp-tree-correct-upwards",  tmg_cpp_tree_correct_upwards, 1, 0, 0);
06120   tmscm_install_procedure ("concat-tokenize-math",  tmg_concat_tokenize_math, 1, 0, 0);
06121   tmscm_install_procedure ("concat-decompose",  tmg_concat_decompose, 1, 0, 0);
06122   tmscm_install_procedure ("concat-recompose",  tmg_concat_recompose, 1, 0, 0);
06123   tmscm_install_procedure ("with-like?",  tmg_with_likeP, 1, 0, 0);
06124   tmscm_install_procedure ("with-same-type?",  tmg_with_same_typeP, 2, 0, 0);
06125   tmscm_install_procedure ("with-similar-type?",  tmg_with_similar_typeP, 2, 0, 0);
06126   tmscm_install_procedure ("with-correct",  tmg_with_correct, 1, 0, 0);
06127   tmscm_install_procedure ("with-correct-superfluous",  tmg_with_correct_superfluous, 1, 0, 0);
06128   tmscm_install_procedure ("invisible-correct-superfluous",  tmg_invisible_correct_superfluous, 1, 0, 0);
06129   tmscm_install_procedure ("invisible-correct-missing",  tmg_invisible_correct_missing, 2, 0, 0);
06130   tmscm_install_procedure ("automatic-correct",  tmg_automatic_correct, 2, 0, 0);
06131   tmscm_install_procedure ("manual-correct",  tmg_manual_correct, 1, 0, 0);
06132   tmscm_install_procedure ("tree-upgrade-brackets",  tmg_tree_upgrade_brackets, 2, 0, 0);
06133   tmscm_install_procedure ("tree-upgrade-big",  tmg_tree_upgrade_big, 1, 0, 0);
06134   tmscm_install_procedure ("tree-downgrade-brackets",  tmg_tree_downgrade_brackets, 3, 0, 0);
06135   tmscm_install_procedure ("tree-downgrade-big",  tmg_tree_downgrade_big, 1, 0, 0);
06136   tmscm_install_procedure ("math-status-print",  tmg_math_status_print, 0, 0, 0);
06137   tmscm_install_procedure ("math-status-reset",  tmg_math_status_reset, 0, 0, 0);
06138   tmscm_install_procedure ("path-inf?",  tmg_path_infP, 2, 0, 0);
06139   tmscm_install_procedure ("path-inf-eq?",  tmg_path_inf_eqP, 2, 0, 0);
06140   tmscm_install_procedure ("path-less?",  tmg_path_lessP, 2, 0, 0);
06141   tmscm_install_procedure ("path-less-eq?",  tmg_path_less_eqP, 2, 0, 0);
06142   tmscm_install_procedure ("path-start",  tmg_path_start, 2, 0, 0);
06143   tmscm_install_procedure ("path-end",  tmg_path_end, 2, 0, 0);
06144   tmscm_install_procedure ("path-next",  tmg_path_next, 2, 0, 0);
06145   tmscm_install_procedure ("path-previous",  tmg_path_previous, 2, 0, 0);
06146   tmscm_install_procedure ("path-next-word",  tmg_path_next_word, 2, 0, 0);
06147   tmscm_install_procedure ("path-previous-word",  tmg_path_previous_word, 2, 0, 0);
06148   tmscm_install_procedure ("path-next-node",  tmg_path_next_node, 2, 0, 0);
06149   tmscm_install_procedure ("path-previous-node",  tmg_path_previous_node, 2, 0, 0);
06150   tmscm_install_procedure ("path-next-tag",  tmg_path_next_tag, 3, 0, 0);
06151   tmscm_install_procedure ("path-previous-tag",  tmg_path_previous_tag, 3, 0, 0);
06152   tmscm_install_procedure ("path-next-tag-same-argument",  tmg_path_next_tag_same_argument, 3, 0, 0);
06153   tmscm_install_procedure ("path-previous-tag-same-argument",  tmg_path_previous_tag_same_argument, 3, 0, 0);
06154   tmscm_install_procedure ("path-next-argument",  tmg_path_next_argument, 2, 0, 0);
06155   tmscm_install_procedure ("path-previous-argument",  tmg_path_previous_argument, 2, 0, 0);
06156   tmscm_install_procedure ("path-previous-section",  tmg_path_previous_section, 2, 0, 0);
06157   tmscm_install_procedure ("tree->ids",  tmg_tree_2ids, 1, 0, 0);
06158   tmscm_install_procedure ("id->trees",  tmg_id_2trees, 1, 0, 0);
06159   tmscm_install_procedure ("vertex->links",  tmg_vertex_2links, 1, 0, 0);
06160   tmscm_install_procedure ("tree->tree-pointer",  tmg_tree_2tree_pointer, 1, 0, 0);
06161   tmscm_install_procedure ("tree-pointer-detach",  tmg_tree_pointer_detach, 1, 0, 0);
06162   tmscm_install_procedure ("tree-pointer->tree",  tmg_tree_pointer_2tree, 1, 0, 0);
06163   tmscm_install_procedure ("current-link-types",  tmg_current_link_types, 0, 0, 0);
06164   tmscm_install_procedure ("get-locus-rendering",  tmg_get_locus_rendering, 1, 0, 0);
06165   tmscm_install_procedure ("set-locus-rendering",  tmg_set_locus_rendering, 2, 0, 0);
06166   tmscm_install_procedure ("declare-visited",  tmg_declare_visited, 1, 0, 0);
06167   tmscm_install_procedure ("has-been-visited?",  tmg_has_been_visitedP, 1, 0, 0);
06168   tmscm_install_procedure ("graphics-set",  tmg_graphics_set, 2, 0, 0);
06169   tmscm_install_procedure ("graphics-has?",  tmg_graphics_hasP, 1, 0, 0);
06170   tmscm_install_procedure ("graphics-ref",  tmg_graphics_ref, 1, 0, 0);
06171   tmscm_install_procedure ("graphics-needs-update?",  tmg_graphics_needs_updateP, 0, 0, 0);
06172   tmscm_install_procedure ("graphics-notify-update",  tmg_graphics_notify_update, 1, 0, 0);
06173   tmscm_install_procedure ("string-number?",  tmg_string_numberP, 1, 0, 0);
06174   tmscm_install_procedure ("string-occurs?",  tmg_string_occursP, 2, 0, 0);
06175   tmscm_install_procedure ("string-search-forwards",  tmg_string_search_forwards, 3, 0, 0);
06176   tmscm_install_procedure ("string-search-backwards",  tmg_string_search_backwards, 3, 0, 0);
06177   tmscm_install_procedure ("string-replace",  tmg_string_replace, 3, 0, 0);
06178   tmscm_install_procedure ("string-alpha?",  tmg_string_alphaP, 1, 0, 0);
06179   tmscm_install_procedure ("string-locase-alpha?",  tmg_string_locase_alphaP, 1, 0, 0);
06180   tmscm_install_procedure ("upcase-first",  tmg_upcase_first, 1, 0, 0);
06181   tmscm_install_procedure ("locase-first",  tmg_locase_first, 1, 0, 0);
06182   tmscm_install_procedure ("upcase-all",  tmg_upcase_all, 1, 0, 0);
06183   tmscm_install_procedure ("locase-all",  tmg_locase_all, 1, 0, 0);
06184   tmscm_install_procedure ("string-union",  tmg_string_union, 2, 0, 0);
06185   tmscm_install_procedure ("string-minus",  tmg_string_minus, 2, 0, 0);
06186   tmscm_install_procedure ("escape-generic",  tmg_escape_generic, 1, 0, 0);
06187   tmscm_install_procedure ("escape-verbatim",  tmg_escape_verbatim, 1, 0, 0);
06188   tmscm_install_procedure ("escape-shell",  tmg_escape_shell, 1, 0, 0);
06189   tmscm_install_procedure ("string-convert",  tmg_string_convert, 3, 0, 0);
06190   tmscm_install_procedure ("utf8->cork",  tmg_utf8_2cork, 1, 0, 0);
06191   tmscm_install_procedure ("cork->utf8",  tmg_cork_2utf8, 1, 0, 0);
06192   tmscm_install_procedure ("utf8->html",  tmg_utf8_2html, 1, 0, 0);
06193   tmscm_install_procedure ("tm->xml-name",  tmg_tm_2xml_name, 1, 0, 0);
06194   tmscm_install_procedure ("old-tm->xml-cdata",  tmg_old_tm_2xml_cdata, 1, 0, 0);
06195   tmscm_install_procedure ("tm->xml-cdata",  tmg_tm_2xml_cdata, 1, 0, 0);
06196   tmscm_install_procedure ("xml-name->tm",  tmg_xml_name_2tm, 1, 0, 0);
06197   tmscm_install_procedure ("old-xml-cdata->tm",  tmg_old_xml_cdata_2tm, 1, 0, 0);
06198   tmscm_install_procedure ("xml-unspace",  tmg_xml_unspace, 3, 0, 0);
06199   tmscm_install_procedure ("integer->hexadecimal",  tmg_integer_2hexadecimal, 1, 0, 0);
06200   tmscm_install_procedure ("integer->padded-hexadecimal",  tmg_integer_2padded_hexadecimal, 2, 0, 0);
06201   tmscm_install_procedure ("hexadecimal->integer",  tmg_hexadecimal_2integer, 1, 0, 0);
06202   tmscm_install_procedure ("string->tmstring",  tmg_string_2tmstring, 1, 0, 0);
06203   tmscm_install_procedure ("tmstring->string",  tmg_tmstring_2string, 1, 0, 0);
06204   tmscm_install_procedure ("tmstring-length",  tmg_tmstring_length, 1, 0, 0);
06205   tmscm_install_procedure ("tmstring-ref",  tmg_tmstring_ref, 2, 0, 0);
06206   tmscm_install_procedure ("tmstring-reverse-ref",  tmg_tmstring_reverse_ref, 2, 0, 0);
06207   tmscm_install_procedure ("tmstring->list",  tmg_tmstring_2list, 1, 0, 0);
06208   tmscm_install_procedure ("list->tmstring",  tmg_list_2tmstring, 1, 0, 0);
06209   tmscm_install_procedure ("string-next",  tmg_string_next, 2, 0, 0);
06210   tmscm_install_procedure ("string-previous",  tmg_string_previous, 2, 0, 0);
06211   tmscm_install_procedure ("packrat-define",  tmg_packrat_define, 3, 0, 0);
06212   tmscm_install_procedure ("packrat-property",  tmg_packrat_property, 4, 0, 0);
06213   tmscm_install_procedure ("packrat-inherit",  tmg_packrat_inherit, 2, 0, 0);
06214   tmscm_install_procedure ("packrat-parse",  tmg_packrat_parse, 3, 0, 0);
06215   tmscm_install_procedure ("packrat-correct?",  tmg_packrat_correctP, 3, 0, 0);
06216   tmscm_install_procedure ("packrat-context",  tmg_packrat_context, 4, 0, 0);
06217   tmscm_install_procedure ("parse-texmacs",  tmg_parse_texmacs, 1, 0, 0);
06218   tmscm_install_procedure ("serialize-texmacs",  tmg_serialize_texmacs, 1, 0, 0);
06219   tmscm_install_procedure ("parse-texmacs-snippet",  tmg_parse_texmacs_snippet, 1, 0, 0);
06220   tmscm_install_procedure ("serialize-texmacs-snippet",  tmg_serialize_texmacs_snippet, 1, 0, 0);
06221   tmscm_install_procedure ("texmacs->stm",  tmg_texmacs_2stm, 1, 0, 0);
06222   tmscm_install_procedure ("stm->texmacs",  tmg_stm_2texmacs, 1, 0, 0);
06223   tmscm_install_procedure ("stm-snippet->texmacs",  tmg_stm_snippet_2texmacs, 1, 0, 0);
06224   tmscm_install_procedure ("cpp-texmacs->verbatim",  tmg_cpp_texmacs_2verbatim, 3, 0, 0);
06225   tmscm_install_procedure ("cpp-verbatim-snippet->texmacs",  tmg_cpp_verbatim_snippet_2texmacs, 3, 0, 0);
06226   tmscm_install_procedure ("cpp-verbatim->texmacs",  tmg_cpp_verbatim_2texmacs, 3, 0, 0);
06227   tmscm_install_procedure ("parse-latex",  tmg_parse_latex, 1, 0, 0);
06228   tmscm_install_procedure ("parse-latex-document",  tmg_parse_latex_document, 1, 0, 0);
06229   tmscm_install_procedure ("latex->texmacs",  tmg_latex_2texmacs, 1, 0, 0);
06230   tmscm_install_procedure ("latex-document->texmacs",  tmg_latex_document_2texmacs, 1, 0, 0);
06231   tmscm_install_procedure ("latex-class-document->texmacs",  tmg_latex_class_document_2texmacs, 1, 0, 0);
06232   tmscm_install_procedure ("parse-xml",  tmg_parse_xml, 1, 0, 0);
06233   tmscm_install_procedure ("parse-html",  tmg_parse_html, 1, 0, 0);
06234   tmscm_install_procedure ("parse-bib",  tmg_parse_bib, 1, 0, 0);
06235   tmscm_install_procedure ("upgrade-tmml",  tmg_upgrade_tmml, 1, 0, 0);
06236   tmscm_install_procedure ("upgrade-mathml",  tmg_upgrade_mathml, 1, 0, 0);
06237   tmscm_install_procedure ("string->url",  tmg_string_2url, 1, 0, 0);
06238   tmscm_install_procedure ("url",  tmg_url, 2, 0, 0);
06239   tmscm_install_procedure ("url-system",  tmg_url_system, 1, 0, 0);
06240   tmscm_install_procedure ("url-none",  tmg_url_none, 0, 0, 0);
06241   tmscm_install_procedure ("url-any",  tmg_url_any, 0, 0, 0);
06242   tmscm_install_procedure ("url-wildcard",  tmg_url_wildcard, 1, 0, 0);
06243   tmscm_install_procedure ("url-parent",  tmg_url_parent, 0, 0, 0);
06244   tmscm_install_procedure ("url-ancestor",  tmg_url_ancestor, 0, 0, 0);
06245   tmscm_install_procedure ("url-append",  tmg_url_append, 2, 0, 0);
06246   tmscm_install_procedure ("url-or",  tmg_url_or, 2, 0, 0);
06247   tmscm_install_procedure ("url->string",  tmg_url_2string, 1, 0, 0);
06248   tmscm_install_procedure ("url-none?",  tmg_url_noneP, 1, 0, 0);
06249   tmscm_install_procedure ("url-rooted-web?",  tmg_url_rooted_webP, 1, 0, 0);
06250   tmscm_install_procedure ("url-concat?",  tmg_url_concatP, 1, 0, 0);
06251   tmscm_install_procedure ("url-or?",  tmg_url_orP, 1, 0, 0);
06252   tmscm_install_procedure ("url-ref",  tmg_url_ref, 2, 0, 0);
06253   tmscm_install_procedure ("url-head",  tmg_url_head, 1, 0, 0);
06254   tmscm_install_procedure ("url-tail",  tmg_url_tail, 1, 0, 0);
06255   tmscm_install_procedure ("url-suffix",  tmg_url_suffix, 1, 0, 0);
06256   tmscm_install_procedure ("url-glue",  tmg_url_glue, 2, 0, 0);
06257   tmscm_install_procedure ("url-unglue",  tmg_url_unglue, 2, 0, 0);
06258   tmscm_install_procedure ("url-relative",  tmg_url_relative, 2, 0, 0);
06259   tmscm_install_procedure ("url-expand",  tmg_url_expand, 1, 0, 0);
06260   tmscm_install_procedure ("url-factor",  tmg_url_factor, 1, 0, 0);
06261   tmscm_install_procedure ("url-delta",  tmg_url_delta, 2, 0, 0);
06262   tmscm_install_procedure ("url-secure?",  tmg_url_secureP, 1, 0, 0);
06263   tmscm_install_procedure ("url-descends?",  tmg_url_descendsP, 2, 0, 0);
06264   tmscm_install_procedure ("url-complete",  tmg_url_complete, 2, 0, 0);
06265   tmscm_install_procedure ("url-resolve",  tmg_url_resolve, 2, 0, 0);
06266   tmscm_install_procedure ("url-resolve-in-path",  tmg_url_resolve_in_path, 1, 0, 0);
06267   tmscm_install_procedure ("url-exists?",  tmg_url_existsP, 1, 0, 0);
06268   tmscm_install_procedure ("url-exists-in-path?",  tmg_url_exists_in_pathP, 1, 0, 0);
06269   tmscm_install_procedure ("url-exists-in-tex?",  tmg_url_exists_in_texP, 1, 0, 0);
06270   tmscm_install_procedure ("url-concretize",  tmg_url_concretize, 1, 0, 0);
06271   tmscm_install_procedure ("url-materialize",  tmg_url_materialize, 2, 0, 0);
06272   tmscm_install_procedure ("url-test?",  tmg_url_testP, 2, 0, 0);
06273   tmscm_install_procedure ("url-regular?",  tmg_url_regularP, 1, 0, 0);
06274   tmscm_install_procedure ("url-directory?",  tmg_url_directoryP, 1, 0, 0);
06275   tmscm_install_procedure ("url-link?",  tmg_url_linkP, 1, 0, 0);
06276   tmscm_install_procedure ("url-newer?",  tmg_url_newerP, 2, 0, 0);
06277   tmscm_install_procedure ("url-last-modified",  tmg_url_last_modified, 1, 0, 0);
06278   tmscm_install_procedure ("url-temp",  tmg_url_temp, 0, 0, 0);
06279   tmscm_install_procedure ("url-scratch",  tmg_url_scratch, 3, 0, 0);
06280   tmscm_install_procedure ("url-scratch?",  tmg_url_scratchP, 1, 0, 0);
06281   tmscm_install_procedure ("string-save",  tmg_string_save, 2, 0, 0);
06282   tmscm_install_procedure ("string-load",  tmg_string_load, 1, 0, 0);
06283   tmscm_install_procedure ("system-move",  tmg_system_move, 2, 0, 0);
06284   tmscm_install_procedure ("system-copy",  tmg_system_copy, 2, 0, 0);
06285   tmscm_install_procedure ("system-remove",  tmg_system_remove, 1, 0, 0);
06286   tmscm_install_procedure ("system-mkdir",  tmg_system_mkdir, 1, 0, 0);
06287   tmscm_install_procedure ("system-search-score",  tmg_system_search_score, 2, 0, 0);
06288   tmscm_install_procedure ("system-1",  tmg_system_1, 2, 0, 0);
06289   tmscm_install_procedure ("system-2",  tmg_system_2, 3, 0, 0);
06290   tmscm_install_procedure ("tmfs-set",  tmg_tmfs_set, 2, 0, 0);
06291   tmscm_install_procedure ("tmfs-reset",  tmg_tmfs_reset, 2, 0, 0);
06292   tmscm_install_procedure ("tmfs-get",  tmg_tmfs_get, 1, 0, 0);
06293   tmscm_install_procedure ("tmfs-new-save",  tmg_tmfs_new_save, 2, 0, 0);
06294   tmscm_install_procedure ("tmfs-new-remove",  tmg_tmfs_new_remove, 1, 0, 0);
06295   tmscm_install_procedure ("tmfs-new-load",  tmg_tmfs_new_load, 1, 0, 0);
06296   tmscm_install_procedure ("tmfs-create-ressource",  tmg_tmfs_create_ressource, 0, 0, 0);
06297   tmscm_install_procedure ("tmfs-ressource-head",  tmg_tmfs_ressource_head, 1, 0, 0);
06298   tmscm_install_procedure ("tmfs-ressource-versions",  tmg_tmfs_ressource_versions, 1, 0, 0);
06299   tmscm_install_procedure ("tmfs-save-ressource",  tmg_tmfs_save_ressource, 3, 0, 0);
06300   tmscm_install_procedure ("tmfs-load-ressource-file",  tmg_tmfs_load_ressource_file, 1, 0, 0);
06301   tmscm_install_procedure ("tmfs-load-ressource-properties",  tmg_tmfs_load_ressource_properties, 1, 0, 0);
06302   tmscm_install_procedure ("tmfs-create-user",  tmg_tmfs_create_user, 1, 0, 0);
06303   tmscm_install_procedure ("tmfs-search-user",  tmg_tmfs_search_user, 1, 0, 0);
06304   tmscm_install_procedure ("tmfs-set-user",  tmg_tmfs_set_user, 1, 0, 0);
06305   tmscm_install_procedure ("tmfs-get-user",  tmg_tmfs_get_user, 0, 0, 0);
06306   tmscm_install_procedure ("tmfs-allows?",  tmg_tmfs_allowsP, 2, 0, 0);
06307   tmscm_install_procedure ("tmfs-set-attributes",  tmg_tmfs_set_attributes, 2, 0, 0);
06308   tmscm_install_procedure ("tmfs-get-attributes",  tmg_tmfs_get_attributes, 1, 0, 0);
06309   tmscm_install_procedure ("tmfs-add-attributes",  tmg_tmfs_add_attributes, 2, 0, 0);
06310   tmscm_install_procedure ("tmfs-remove-attributes",  tmg_tmfs_remove_attributes, 2, 0, 0);
06311   tmscm_install_procedure ("tmfs-change-attributes",  tmg_tmfs_change_attributes, 2, 0, 0);
06312   tmscm_install_procedure ("tmfs-query",  tmg_tmfs_query, 1, 0, 0);
06313   tmscm_install_procedure ("solutions->collection",  tmg_solutions_2collection, 2, 0, 0);
06314   tmscm_install_procedure ("tmfs-create-file",  tmg_tmfs_create_file, 2, 0, 0);
06315   tmscm_install_procedure ("tmfs-create-file-in",  tmg_tmfs_create_file_in, 3, 0, 0);
06316   tmscm_install_procedure ("tmfs-search-file",  tmg_tmfs_search_file, 1, 0, 0);
06317   tmscm_install_procedure ("tmfs-save-file",  tmg_tmfs_save_file, 2, 0, 0);
06318   tmscm_install_procedure ("tmfs-load-file",  tmg_tmfs_load_file, 1, 0, 0);
06319   tmscm_install_procedure ("tmfs-create-project",  tmg_tmfs_create_project, 1, 0, 0);
06320   tmscm_install_procedure ("tmfs-search-project",  tmg_tmfs_search_project, 1, 0, 0);
06321   tmscm_install_procedure ("tmfs-get-file-projects",  tmg_tmfs_get_file_projects, 1, 0, 0);
06322   tmscm_install_procedure ("tmfs-get-project-files",  tmg_tmfs_get_project_files, 1, 0, 0);
06323   tmscm_install_procedure ("tmfs-create-branch",  tmg_tmfs_create_branch, 2, 0, 0);
06324   tmscm_install_procedure ("tmfs-set-root",  tmg_tmfs_set_root, 2, 0, 0);
06325   tmscm_install_procedure ("tmfs-get-root",  tmg_tmfs_get_root, 1, 0, 0);
06326   tmscm_install_procedure ("tmfs-import",  tmg_tmfs_import, 1, 0, 0);
06327   tmscm_install_procedure ("tmfs-export",  tmg_tmfs_export, 1, 0, 0);
06328   tmscm_install_procedure ("server-start",  tmg_server_start, 0, 0, 0);
06329   tmscm_install_procedure ("server-stop",  tmg_server_stop, 0, 0, 0);
06330   tmscm_install_procedure ("server-read",  tmg_server_read, 1, 0, 0);
06331   tmscm_install_procedure ("server-write",  tmg_server_write, 2, 0, 0);
06332   tmscm_install_procedure ("client-start",  tmg_client_start, 1, 0, 0);
06333   tmscm_install_procedure ("client-stop",  tmg_client_stop, 0, 0, 0);
06334   tmscm_install_procedure ("client-read",  tmg_client_read, 0, 0, 0);
06335   tmscm_install_procedure ("client-write",  tmg_client_write, 1, 0, 0);
06336   tmscm_install_procedure ("enter-secure-mode",  tmg_enter_secure_mode, 0, 0, 0);
06337   tmscm_install_procedure ("connection-start",  tmg_connection_start, 2, 0, 0);
06338   tmscm_install_procedure ("connection-status",  tmg_connection_status, 2, 0, 0);
06339   tmscm_install_procedure ("connection-write-string",  tmg_connection_write_string, 3, 0, 0);
06340   tmscm_install_procedure ("connection-write",  tmg_connection_write, 3, 0, 0);
06341   tmscm_install_procedure ("connection-cmd",  tmg_connection_cmd, 3, 0, 0);
06342   tmscm_install_procedure ("connection-eval",  tmg_connection_eval, 3, 0, 0);
06343   tmscm_install_procedure ("connection-interrupt",  tmg_connection_interrupt, 2, 0, 0);
06344   tmscm_install_procedure ("connection-stop",  tmg_connection_stop, 2, 0, 0);
06345   tmscm_install_procedure ("widget-printer",  tmg_widget_printer, 2, 0, 0);
06346   tmscm_install_procedure ("widget-color-picker",  tmg_widget_color_picker, 3, 0, 0);
06347   tmscm_install_procedure ("widget-extend",  tmg_widget_extend, 2, 0, 0);
06348   tmscm_install_procedure ("widget-hmenu",  tmg_widget_hmenu, 1, 0, 0);
06349   tmscm_install_procedure ("widget-vmenu",  tmg_widget_vmenu, 1, 0, 0);
06350   tmscm_install_procedure ("widget-tmenu",  tmg_widget_tmenu, 2, 0, 0);
06351   tmscm_install_procedure ("widget-minibar-menu",  tmg_widget_minibar_menu, 1, 0, 0);
06352   tmscm_install_procedure ("widget-separator",  tmg_widget_separator, 1, 0, 0);
06353   tmscm_install_procedure ("widget-menu-group",  tmg_widget_menu_group, 2, 0, 0);
06354   tmscm_install_procedure ("widget-pulldown-button",  tmg_widget_pulldown_button, 2, 0, 0);
06355   tmscm_install_procedure ("widget-pullright-button",  tmg_widget_pullright_button, 2, 0, 0);
06356   tmscm_install_procedure ("widget-menu-button",  tmg_widget_menu_button, 5, 0, 0);
06357   tmscm_install_procedure ("widget-toggle",  tmg_widget_toggle, 3, 0, 0);
06358   tmscm_install_procedure ("widget-balloon",  tmg_widget_balloon, 2, 0, 0);
06359   tmscm_install_procedure ("widget-empty",  tmg_widget_empty, 0, 0, 0);
06360   tmscm_install_procedure ("widget-text",  tmg_widget_text, 4, 0, 0);
06361   tmscm_install_procedure ("widget-input",  tmg_widget_input, 5, 0, 0);
06362   tmscm_install_procedure ("widget-enum",  tmg_widget_enum, 5, 0, 0);
06363   tmscm_install_procedure ("widget-choice",  tmg_widget_choice, 3, 0, 0);
06364   tmscm_install_procedure ("widget-choices",  tmg_widget_choices, 3, 0, 0);
06365   tmscm_install_procedure ("widget-xpm",  tmg_widget_xpm, 1, 0, 0);
06366   tmscm_install_procedure ("widget-box",  tmg_widget_box, 5, 0, 0);
06367   tmscm_install_procedure ("widget-glue",  tmg_widget_glue, 4, 0, 0);
06368   tmscm_install_procedure ("widget-color",  tmg_widget_color, 5, 0, 0);
06369   tmscm_install_procedure ("widget-hlist",  tmg_widget_hlist, 1, 0, 0);
06370   tmscm_install_procedure ("widget-vlist",  tmg_widget_vlist, 1, 0, 0);
06371   tmscm_install_procedure ("widget-aligned",  tmg_widget_aligned, 2, 0, 0);
06372   tmscm_install_procedure ("widget-tabs",  tmg_widget_tabs, 2, 0, 0);
06373   tmscm_install_procedure ("widget-scrollable",  tmg_widget_scrollable, 2, 0, 0);
06374   tmscm_install_procedure ("widget-resize",  tmg_widget_resize, 8, 0, 0);
06375   tmscm_install_procedure ("widget-hsplit",  tmg_widget_hsplit, 2, 0, 0);
06376   tmscm_install_procedure ("widget-vsplit",  tmg_widget_vsplit, 2, 0, 0);
06377   tmscm_install_procedure ("widget-texmacs-output",  tmg_widget_texmacs_output, 1, 0, 0);
06378   tmscm_install_procedure ("widget-texmacs-input",  tmg_widget_texmacs_input, 3, 0, 0);
06379   tmscm_install_procedure ("widget-ink",  tmg_widget_ink, 1, 0, 0);
06380   tmscm_install_procedure ("widget-refresh",  tmg_widget_refresh, 1, 0, 0);
06381   tmscm_install_procedure ("object->promise-widget",  tmg_object_2promise_widget, 1, 0, 0);
06382   tmscm_install_procedure ("tree-bounding-rectangle",  tmg_tree_bounding_rectangle, 1, 0, 0);
06383   tmscm_install_procedure ("show-balloon",  tmg_show_balloon, 3, 0, 0);
06384   tmscm_install_procedure ("get-style-menu",  tmg_get_style_menu, 0, 0, 0);
06385   tmscm_install_procedure ("get-add-package-menu",  tmg_get_add_package_menu, 0, 0, 0);
06386   tmscm_install_procedure ("get-remove-package-menu",  tmg_get_remove_package_menu, 0, 0, 0);
06387   tmscm_install_procedure ("this-buffer",  tmg_this_buffer, 0, 0, 0);
06388   tmscm_install_procedure ("all-buffers",  tmg_all_buffers, 0, 0, 0);
06389   tmscm_install_procedure ("path->buffer",  tmg_path_2buffer, 1, 0, 0);
06390   tmscm_install_procedure ("set-name-buffer",  tmg_set_name_buffer, 1, 0, 0);
06391   tmscm_install_procedure ("get-name-buffer",  tmg_get_name_buffer, 0, 0, 0);
06392   tmscm_install_procedure ("buffer-set-short-name",  tmg_buffer_set_short_name, 2, 0, 0);
06393   tmscm_install_procedure ("buffer-get-short-name",  tmg_buffer_get_short_name, 1, 0, 0);
06394   tmscm_install_procedure ("buffer-modified?",  tmg_buffer_modifiedP, 1, 0, 0);
06395   tmscm_install_procedure ("buffer-in-menu?",  tmg_buffer_in_menuP, 1, 0, 0);
06396   tmscm_install_procedure ("buffer-last-visited",  tmg_buffer_last_visited, 1, 0, 0);
06397   tmscm_install_procedure ("buffer-set-tree",  tmg_buffer_set_tree, 2, 0, 0);
06398   tmscm_install_procedure ("buffer-get-tree",  tmg_buffer_get_tree, 1, 0, 0);
06399   tmscm_install_procedure ("buffer-revert-tree",  tmg_buffer_revert_tree, 2, 0, 0);
06400   tmscm_install_procedure ("new-buffer",  tmg_new_buffer, 0, 0, 0);
06401   tmscm_install_procedure ("switch-to-buffer-path",  tmg_switch_to_buffer_path, 1, 0, 0);
06402   tmscm_install_procedure ("switch-to-buffer",  tmg_switch_to_buffer, 1, 0, 0);
06403   tmscm_install_procedure ("switch-to-active-buffer",  tmg_switch_to_active_buffer, 1, 0, 0);
06404   tmscm_install_procedure ("revert-buffer",  tmg_revert_buffer, 0, 0, 0);
06405   tmscm_install_procedure ("kill-buffer",  tmg_kill_buffer, 0, 0, 0);
06406   tmscm_install_procedure ("no-name?",  tmg_no_nameP, 0, 0, 0);
06407   tmscm_install_procedure ("help-buffer?",  tmg_help_bufferP, 0, 0, 0);
06408   tmscm_install_procedure ("aux-buffer?",  tmg_aux_bufferP, 1, 0, 0);
06409   tmscm_install_procedure ("set-aux",  tmg_set_aux, 2, 0, 0);
06410   tmscm_install_procedure ("set-aux-buffer",  tmg_set_aux_buffer, 3, 0, 0);
06411   tmscm_install_procedure ("set-help-buffer",  tmg_set_help_buffer, 2, 0, 0);
06412   tmscm_install_procedure ("open-buffer-in-window",  tmg_open_buffer_in_window, 3, 0, 0);
06413   tmscm_install_procedure ("open-window",  tmg_open_window, 0, 0, 0);
06414   tmscm_install_procedure ("open-window-geometry",  tmg_open_window_geometry, 1, 0, 0);
06415   tmscm_install_procedure ("clone-window",  tmg_clone_window, 0, 0, 0);
06416   tmscm_install_procedure ("kill-window",  tmg_kill_window, 0, 0, 0);
06417   tmscm_install_procedure ("kill-window-and-buffer",  tmg_kill_window_and_buffer, 0, 0, 0);
06418   tmscm_install_procedure ("project-attach",  tmg_project_attach, 1, 0, 0);
06419   tmscm_install_procedure ("project-detach",  tmg_project_detach, 0, 0, 0);
06420   tmscm_install_procedure ("project-attached?",  tmg_project_attachedP, 0, 0, 0);
06421   tmscm_install_procedure ("project-get",  tmg_project_get, 0, 0, 0);
06422   tmscm_install_procedure ("window-current",  tmg_window_current, 0, 0, 0);
06423   tmscm_install_procedure ("window-list",  tmg_window_list, 0, 0, 0);
06424   tmscm_install_procedure ("buffer->windows",  tmg_buffer_2windows, 1, 0, 0);
06425   tmscm_install_procedure ("window->buffer",  tmg_window_2buffer, 1, 0, 0);
06426   tmscm_install_procedure ("window-set-buffer",  tmg_window_set_buffer, 2, 0, 0);
06427   tmscm_install_procedure ("window-focus",  tmg_window_focus, 1, 0, 0);
06428   tmscm_install_procedure ("pretend-save-buffer",  tmg_pretend_save_buffer, 0, 0, 0);
06429   tmscm_install_procedure ("buffer-unsaved?",  tmg_buffer_unsavedP, 0, 0, 0);
06430   tmscm_install_procedure ("exists-unsaved-buffer?",  tmg_exists_unsaved_bufferP, 0, 0, 0);
06431   tmscm_install_procedure ("texmacs-load-tree",  tmg_texmacs_load_tree, 2, 0, 0);
06432   tmscm_install_procedure ("texmacs-load-buffer",  tmg_texmacs_load_buffer, 4, 0, 0);
06433   tmscm_install_procedure ("texmacs-save-buffer",  tmg_texmacs_save_buffer, 2, 0, 0);
06434   tmscm_install_procedure ("auto-save",  tmg_auto_save, 0, 0, 0);
06435   tmscm_install_procedure ("window-handle",  tmg_window_handle, 0, 0, 0);
06436   tmscm_install_procedure ("window-create",  tmg_window_create, 4, 0, 0);
06437   tmscm_install_procedure ("window-create-quit",  tmg_window_create_quit, 4, 0, 0);
06438   tmscm_install_procedure ("window-delete",  tmg_window_delete, 1, 0, 0);
06439   tmscm_install_procedure ("window-show",  tmg_window_show, 1, 0, 0);
06440   tmscm_install_procedure ("window-hide",  tmg_window_hide, 1, 0, 0);
06441   tmscm_install_procedure ("bib-add-period",  tmg_bib_add_period, 1, 0, 0);
06442   tmscm_install_procedure ("bib-upcase-first",  tmg_bib_upcase_first, 1, 0, 0);
06443   tmscm_install_procedure ("bib-locase",  tmg_bib_locase, 1, 0, 0);
06444   tmscm_install_procedure ("bib-upcase",  tmg_bib_upcase, 1, 0, 0);
06445   tmscm_install_procedure ("bib-default",  tmg_bib_default, 1, 0, 0);
06446   tmscm_install_procedure ("bib-purify",  tmg_bib_purify, 1, 0, 0);
06447   tmscm_install_procedure ("bib-text-length",  tmg_bib_text_length, 1, 0, 0);
06448   tmscm_install_procedure ("bib-prefix",  tmg_bib_prefix, 2, 0, 0);
06449   tmscm_install_procedure ("bib-empty?",  tmg_bib_emptyP, 2, 0, 0);
06450   tmscm_install_procedure ("bib-field",  tmg_bib_field, 2, 0, 0);
06451   tmscm_install_procedure ("bib-abbreviate",  tmg_bib_abbreviate, 3, 0, 0);
06452 }