home *** CD-ROM | disk | FTP | other *** search
/ Informática Multimedia: Special Games (Alt) / INFESPGAMES.iso / os2 / backgam / source / command2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-25  |  19.0 KB  |  809 lines
  1. /*************************************************************
  2.  *    ______                                                 *
  3.  *   /     /\  TinyFugue was derived from a client initially *
  4.  *  /   __/  \ written by Anton Rang (Tarrant) and later     *
  5.  *  |  / /\  | modified by Leo Plotkin (Grod).  The early    *
  6.  *  |  |/    | versions of TinyFugue written by Greg Hudson  *
  7.  *  |  X__/  | (Explorer_Bob).  The current version is       *
  8.  *  \ /      / written and maintained by Ken Keys (Hawkeye), *
  9.  *   \______/  who can be reached at kkeys@ucsd.edu.         *
  10.  *                                                           *
  11.  *             No copyright 1992, no rights reserved.        *
  12.  *             Fugue is in the public domain.                *
  13.  *************************************************************/
  14.  
  15. /*********************************************************
  16.  * Fugue command handlers, part 2                        *
  17.  *                                                       *
  18.  * Contents:                                             *
  19.  * 1. Flags and numerical runtime registers              *
  20.  * 2. Macro subsystem, including gags, triggers, hilites *
  21.  *********************************************************/
  22.  
  23. #include <stdio.h>
  24. #include <ctype.h>
  25. #include "tf.h"
  26. #include "dstring.h"
  27. #include "util.h"
  28. #include "macro.h"
  29. #include "keyboard.h"
  30. #include "output.h"
  31. #include "command1.h"
  32. #include "history.h"
  33. #include "world.h"
  34. #include "socket.h"
  35.  
  36. #define ON (!cstrcmp(args, "on"))
  37. #define OFF (!cstrcmp(args, "off"))
  38.  
  39. static void FDECL(do_flag,(char *args, int *flag, char *prep));
  40. static void FDECL(do_prefix,(char *args, int *flag,
  41.                              Stringp prefix, char *prep));
  42.  
  43. void NDECL(init_prefixes);
  44. int  FDECL(do_file_load,(char *args));
  45. void FDECL(read_file_commands,(TFILE *file, int oldformat));
  46.  
  47. extern char *do_board();
  48.  
  49. HANDLER (handle_background_command);
  50. HANDLER (handle_bamf_command);
  51. HANDLER (handle_board_commnd);
  52. HANDLER (handle_beep_command);
  53. HANDLER (handle_bind_command);
  54. HANDLER (handle_borg_command);
  55. HANDLER (handle_cat_command);
  56. HANDLER (handle_cleardone_command);
  57. HANDLER (handle_clearfull_command);
  58. HANDLER (handle_def_command);
  59. HANDLER (handle_dokey_command);
  60. HANDLER (handle_edit_command);
  61. HANDLER (handle_gag_command);
  62. HANDLER (handle_gpri_command);
  63. HANDLER (handle_hilite_command);
  64. HANDLER (handle_hook_command);
  65. HANDLER (handle_hpri_command);
  66. HANDLER (handle_isize_command);
  67. HANDLER (handle_kecho_command);
  68. HANDLER (handle_list_command);
  69. HANDLER (handle_load_command);
  70. HANDLER (handle_log_command);
  71. HANDLER (handle_login_command);
  72. HANDLER (handle_lp_command);
  73. HANDLER (handle_lpquote_command);
  74. HANDLER (handle_mecho_command);
  75. HANDLER (handle_more_command);
  76. HANDLER (handle_nogag_command);
  77. HANDLER (handle_nohilite_command);
  78. HANDLER (handle_ptime_command);
  79. HANDLER (handle_purge_command);
  80. HANDLER (handle_qecho_command);
  81. HANDLER (handle_quiet_command);
  82. HANDLER (handle_quitdone_command);
  83. HANDLER (handle_redef_command);
  84. HANDLER (handle_save_command);
  85. HANDLER (handle_shpause_command);
  86. HANDLER (handle_sockmload_command);
  87. HANDLER (handle_sub_command);
  88. HANDLER (handle_trig_command);
  89. HANDLER (handle_trigc_command);
  90. HANDLER (handle_trigp_command);
  91. HANDLER (handle_trigpc_command);
  92. HANDLER (handle_unbind_command);
  93. HANDLER (handle_undef_command);
  94. HANDLER (handle_undefn_command);
  95. HANDLER (handle_undeft_command);
  96. HANDLER (handle_unhook_command);
  97. HANDLER (handle_untrig_command);
  98. HANDLER (handle_visual_command);
  99. HANDLER (handle_watchdog_command);
  100. HANDLER (handle_watchname_command);
  101. HANDLER (handle_wrap_command);
  102. HANDLER (handle_wrapspace_command);
  103.  
  104. int background = 1     ,     kecho      = FALSE ,     shpause    = FALSE ,
  105.     bamf       = FALSE ,     log_on     = 0     ,     sockmload  = FALSE ,
  106.     beeping    = TRUE  ,     lpflag     = FALSE ,     sub        = FALSE ,
  107.     borg       = TRUE  ,     lpquote    = FALSE ,     login      = TRUE  ,
  108.     clear      = FALSE ,     mecho      = FALSE ,     visual     = FALSE ,
  109.     cleardone  = FALSE ,     more       = 0     ,     wd_enabled = FALSE ,
  110.     concat     = FALSE ,     qecho      = FALSE ,     wn_enabled = FALSE ,
  111.     gag        = TRUE  ,     quitdone   = FALSE ,     
  112.     hilite     = TRUE  ,     quiet      = FALSE ,                
  113.     hookflag   = TRUE  ,     redef      = FALSE ;
  114.     board      = FALSE;
  115.  
  116. Stringp mprefix, kprefix, qprefix, pattern, body;
  117. int wrapspace = 0, hpri = 0, gpri = 0;
  118. int wnmatch = 4, wnlines = 5, wdmatch = 2, wdlines = 5;
  119.  
  120. extern int style;
  121.  
  122. void init_prefixes()
  123. {
  124.     Stringinit(kprefix);
  125.     Stringinit(mprefix);
  126.     Stringinit(qprefix);
  127.     Stringinit(pattern);
  128.     Stringinit(body);
  129. }
  130.  
  131. #ifdef DMALLOC
  132. void free_prefixes()
  133. {
  134.     Stringfree(kprefix);
  135.     Stringfree(mprefix);
  136.     Stringfree(qprefix);
  137.     Stringfree(pattern);
  138.     Stringfree(body);
  139. }
  140. #endif
  141.  
  142. /********************
  143.  * Generic handlers *
  144.  ********************/   
  145.  
  146. static void do_flag(args, flag, prep)
  147.     char *args;
  148.     int *flag;
  149.     char *prep;
  150. {
  151.     if (!*args) oprintf("%% %s %sabled", prep, (*flag) ? "en" : "dis");
  152.     else if (OFF) *flag = FALSE;
  153.     else if (ON) *flag = TRUE;
  154.     else oputs("% Unknown option; valid options are OFF and ON");
  155. }
  156.  
  157. static void do_prefix(args, flag, prefix, prep)
  158.     Stringp prefix;
  159.     int *flag;
  160.     char *args, *prep;
  161. {
  162.     if (!*args) oprintf("%% %s %s", prep, *flag ? "on" : "off");
  163.     else if (OFF) {
  164.         *flag = FALSE;
  165.         Stringterm(prefix, 0);
  166.     } else if (ON) *flag = TRUE;
  167.     else {
  168.         Sprintf(prefix, "%s ", args);
  169.         *flag = TRUE;
  170.     }
  171. }
  172.  
  173. void read_file_commands(file, oldformat)
  174.     TFILE *file;
  175.     int oldformat;    /* Accept tinytalk-style world defs at top of file? */
  176. {
  177.     Stringp line, cmd;
  178.     char *p;
  179.  
  180.     Stringinit(line);
  181.     Stringinit(cmd);
  182.     while (tfgetS(line, file) != NULL) {
  183.         if (!line->len || line->s[0] == ';') continue;
  184.         if (line->s[0] == '/') oldformat = FALSE;
  185.         newline_package(line, 0);
  186.         for (p = line->s; isspace(*p); p++);
  187.         Stringcat(cmd, p);
  188.         if (line->len && line->s[line->len - 1] == '\\')
  189.             if (line->len < 2 || line->s[line->len - 2] != '%') {
  190.                 Stringterm(cmd, cmd->len - 1);
  191.                 continue;
  192.             }
  193.         if (!cmd->len) continue;
  194.         if (oldformat) addworld(cmd->s); else handle_command(cmd->s, NULL);
  195.         Stringterm(cmd, 0);
  196.     }
  197.     if (cmd->len)
  198.         if (oldformat) addworld(cmd->s); else handle_command(cmd->s, NULL);
  199.     Stringfree(line);
  200.     Stringfree(cmd);
  201. }
  202.  
  203. int do_file_load(args)
  204.     char *args;
  205. {
  206.     register TFILE *cmdfile;
  207.  
  208.     if ((cmdfile = tfopen(args, NULL, "r")) == NULL) return FALSE;
  209.     do_hook(H_LOAD, "%% Loading commands from %s.", "%s", cmdfile->name);
  210.     read_file_commands(cmdfile, FALSE);
  211.     tfclose(cmdfile);
  212.     return TRUE;
  213. }
  214.  
  215. /*********************************************************************
  216.  *                           F L A G S                               *
  217.  *********************************************************************/
  218.  
  219. /****************
  220.  * Pure toggles *
  221.  ****************/
  222.  
  223. void handle_quiet_command(args)      /* Turn on portal suppression. */
  224.     char *args;
  225. {
  226.     do_flag(args, &quiet, "Suppression of login messages");
  227. }
  228.  
  229. void handle_login_command(args)      /* Turn on automatic login. */
  230.     char *args;
  231. {
  232.     do_flag(args, &login, "Autologin is");
  233. }
  234.  
  235. void handle_background_command(args)
  236.     char *args;
  237. {
  238.     int old = background;
  239.  
  240.     do_flag(args, &background, "Background triggers");
  241.     if (background && !old) background_on();
  242. }
  243.  
  244. void handle_bamf_command(args)
  245.     char *args;
  246. {
  247.     if (!*args) {
  248.         if (!bamf) oputs("% Bamfing is disabled.");
  249.         else if (bamf == 1) oputs("% Unter bamfing is enabled.");
  250.         else if (bamf == 2) oputs("% Old-style bamfing is enabled.");
  251.     } else if (OFF) bamf = 0;
  252.     else if ((ON) || !cstrncmp(args, "unter", 5)) bamf = 1;
  253.     else if (!cstrncmp(args, "old", 3)) bamf = 2;
  254.     else oputs("% Unknown option; valid options are OFF, ON and OLD.");
  255. }
  256.  
  257. void handle_borg_command(args)
  258.     char *args;
  259. {
  260.     do_flag(args, &borg, "Cyborg triggers");
  261. }
  262.  
  263. void handle_redef_command(args)
  264.     char *args;
  265. {
  266.     do_flag(args, &redef, "Redefinition");
  267. }
  268.  
  269. void handle_visual_command(args)
  270.     char *args;
  271. {
  272.     int old_state = visual;
  273.     extern int can_have_visual;
  274.  
  275.     if (can_have_visual) {
  276.         do_flag(args, &visual, "Visual mode");
  277.         if (old_state != visual) {
  278.             if (!visual) fix_screen();
  279.             setup_screen();
  280.         }
  281.     } else {
  282.         oputs("% Visual mode not supported.");
  283.     }
  284. }
  285.  
  286. void handle_clearfull_command(args)
  287.     char *args;
  288. {
  289.     do_flag(args, &clear, "Clearing of input window upon filling");
  290. }
  291.  
  292. void handle_sub_command(args)
  293.     char *args;
  294. {
  295.     if (!*args) {
  296.         if (!sub) oputs("% No substitution on normal input.");
  297.         else if (sub == 1) oputs("% Newline substitution on.");
  298.         else if (sub == 2)
  299.             oputs("% Full reentrance substitution on normal input.");
  300.     } else if (OFF) sub = 0;
  301.     else if (ON) sub = 1;
  302.     else if (!cstrncmp(args, "full", 4)) sub = 2;
  303.     else oputs("% Unknown option; valid options are OFF, ON and FULL.");
  304. }
  305.  
  306. void handle_shpause_command(args)
  307.     char *args;
  308. {
  309.     do_flag(args, &shpause, "Pause before returning from /sh command");
  310. }
  311.  
  312. void handle_cleardone_command(args)
  313.     char *args;
  314. {
  315.     do_flag(args, &cleardone, "Clearing on return");
  316. }
  317.  
  318. void handle_sockmload_command(args)
  319.     char *args;
  320. {
  321.     do_flag(args, &sockmload, "Load macro file on socket moves");
  322. }
  323.  
  324. void handle_lp_command(args)
  325.     char *args;
  326. {
  327.     do_flag(args, &lpflag, "Displaying of partial lines");
  328. }
  329.  
  330. void handle_lpquote_command(args)
  331.     char *args;
  332. {
  333.     do_flag(args, &lpquote, "Waiting for *^H for quoting");
  334. }
  335.  
  336. void handle_more_command(args)
  337.     char *args;
  338. {
  339.     if (!*args) oprintf("%% Paging %sabled", more ? "en" : "dis");
  340.     else if (OFF) { clear_more(0); more = 0; }
  341.     else if (ON) { more = 1; reset_outcount(); }
  342.     else oputs("% Unknown option; valid options are OFF and ON");
  343. }
  344.  
  345. void handle_quitdone_command(args)
  346.     char *args;
  347. {
  348.     do_flag(args, &quitdone, "Quitting upon disconnection from last socket");
  349. }
  350.  
  351. /**************************
  352.  * Toggles with arguments *
  353.  **************************/
  354.  
  355. void handle_wrap_command(args)
  356.     char *args;
  357. {
  358.     static int wordwrap = TRUE;
  359.     int width;
  360.  
  361.     if (*args) {
  362.         if (OFF) wordwrap = 0;
  363.         else if (ON) wordwrap = 1;
  364.         else {
  365.             width = numarg(&args);
  366.             if (args && !*args) enable_wrap(width);
  367.             else oputs("% Invalid argument.");
  368.         }
  369.     }
  370.     oputs(wordwrap ? "% Wordwrap is enabled." : "% Wordwrap is disabled.");
  371.     if (wordwrap) enable_wrap(0);
  372.     else disable_wrap();
  373. }
  374.  
  375. void handle_board_command(args)      /* use additional window */
  376.     char *args;
  377. {
  378.     int oldboard=board;
  379.     int oldstyle=style;
  380.     int newstyle=0;
  381.  
  382.     if (*args) {
  383.       if (OFF) board=0;
  384.       else if (ON) board=1;
  385.       else {
  386.           newstyle = numarg(&args);
  387.           if (args && !*args && (newstyle==1 ||  newstyle==2 || newstyle==4)) style=newstyle;
  388.           else oputs("% Invalid argument.");
  389.       }
  390.     }
  391.     else 
  392.       oputs(board ? "% Backgammon window used." : "% Backgammon window not used.");
  393.     if (style != oldstyle) {
  394.       do_board(NULL);
  395.       setup_screen();
  396.     }
  397.     else if (board!=oldboard)
  398.       setup_screen();
  399. }
  400.  
  401. /* Actually a miscellaneous routine, but it looks a lot like a flag */
  402.  
  403. void handle_beep_command(args)
  404.     char *args;
  405. {
  406.     int beep = 3;
  407.  
  408.     if (ON) beeping = TRUE;
  409.     else if (OFF) beeping = FALSE;
  410.     else if (isdigit(*args)) beep = atoi(args);
  411.  
  412.     if (!beeping) return;
  413.     while (beep--) putch('\007');
  414. }
  415.  
  416. void handle_log_command(args)    /* Enable logging. */
  417.     char *args;
  418. {
  419.     do_log(args);
  420. }
  421.  
  422. void handle_kecho_command(args)
  423.     char *args;
  424. {
  425.     do_prefix(args, &kecho, kprefix, "Echoing of input is");
  426. }
  427.  
  428. void handle_mecho_command(args)
  429.     char *args;
  430. {
  431.     do_prefix(args, &mecho, mprefix, "Echoing of macros is");
  432. }
  433.  
  434. void handle_qecho_command(args)
  435.     char *args;
  436. {
  437.     do_prefix(args, &qecho, qprefix, "Echoing of quote text is");
  438. }
  439.  
  440. void handle_cat_command(args)
  441.     char *args;
  442. {
  443.     concat = (*args == '%') ? 2 : 1;
  444. }
  445.  
  446. void do_watch(args, name, wlines, wmatch, flag)
  447.     char *args, *name;
  448.     int *wlines, *wmatch, *flag;
  449. {
  450.     int lines = 0, match = 0;
  451.     char *ptr;
  452.  
  453.     if (OFF) {
  454.         *flag = FALSE;
  455.         oprintf("%% %s disabled.", name);
  456.         return;
  457.     }
  458.     ptr = args;
  459.     if (ON) for (ptr += 2; isspace(*ptr); ptr++);
  460.     if (match = numarg(&ptr)) *wmatch = match;
  461.     if (ptr && (lines = numarg(&ptr))) *wlines = lines;
  462.     *flag = TRUE;
  463.     oprintf("%% %s enabled, searching for %d out of %d lines",
  464.       name, *wmatch, *wlines);
  465. }
  466.  
  467. void handle_watchdog_command(args)
  468.     char *args;
  469. {
  470.     do_watch(args, "Watchdog", &wdlines, &wdmatch, &wd_enabled);
  471. }
  472.  
  473. void handle_watchname_command(args)
  474.     char *args;
  475. {
  476.     do_watch(args, "Namewatch", &wnlines, &wnmatch, &wn_enabled);
  477. }
  478.  
  479. /******************************
  480.  * Runtime user-set variables *
  481.  ******************************/
  482.  
  483. void handle_isize_command(args)
  484.     char *args;
  485. {
  486.     extern int ilines;
  487.     int size;
  488.  
  489.     if (*args && ((size = atoi(args)) > 0)) {
  490.         ilines = size;
  491.         if (visual) {
  492.             fix_screen();
  493.             setup_screen();
  494.         }
  495.     } else oprintf("%% Input window is %d lines.", ilines);
  496. }
  497.  
  498. void handle_wrapspace_command(args)
  499.     char *args;
  500. {
  501.     if (*args) {
  502.         if (isdigit(*args)) wrapspace = atoi(args);
  503.         else if (OFF) wrapspace = 0;
  504.         else oputs("% Wrapspace must be followed by a number or OFF");
  505.     }
  506.     else oprintf("%% Wrap indents %d columns", wrapspace);
  507. }
  508.  
  509. void handle_ptime_command(args)
  510.     char *args;
  511. {
  512.     extern TIME_T process_time;
  513.  
  514.     if (*args) {
  515.         if (isdigit(*args)) process_time = atoi(args);
  516.         else oputs("% /ptime must be followed by a number");
  517.     } else oprintf("%% %d seconds between quote lines", process_time);
  518. }
  519.  
  520. void handle_hpri_command(args)
  521.     char *args;
  522. {
  523.     if (!*args) oprintf("%% Hilite priority is %d", hpri);
  524.     else hpri = atoi(args);
  525. }
  526.  
  527. void handle_gpri_command(args)
  528.     char *args;
  529. {
  530.     if (!*args) oprintf("%% Gag priority is %d", gpri);
  531.     else gpri = atoi(args);
  532. }
  533.  
  534.  
  535. /*************************************************************************
  536.  *                     M A C R O   S U B S Y S T E M                     *
  537.  *************************************************************************/
  538.  
  539.  
  540. /**********
  541.  * Macros *
  542.  **********/
  543.  
  544. void handle_def_command(args)                /* Define a macro. */
  545.     char *args;
  546. {
  547.     Macro *spec;
  548.     if (spec = macro_spec(args)) do_add(spec);
  549. }
  550.  
  551. void handle_edit_command(args)
  552.     char *args;
  553. {
  554.     Macro *spec;
  555.     if (spec = macro_spec(args)) do_edit(spec);
  556. }
  557.  
  558. void handle_undef_command(args)              /* Undefine a macro. */
  559.     char *args;
  560. {
  561.     remove_macro(args, 0, 0);
  562. }
  563.  
  564. void handle_undeft_command(args)
  565.     char *args;
  566. {
  567.     remove_macro(args, F_ALL, 0);
  568. }
  569.  
  570. void handle_undefn_command(args)
  571.     char *args;
  572. {
  573.     remove_by_number(args);
  574. }
  575.  
  576. void handle_purge_command(args)
  577.     char *args;
  578. {
  579.     purge_macro(macro_spec(args));
  580. }
  581.  
  582. void handle_save_command(args)
  583.     char *args;
  584. {
  585.     save_macros(args);
  586. }
  587.  
  588. void handle_list_command(args)
  589.     char *args;
  590. {
  591.     list_macros(args);
  592. }
  593.  
  594. void handle_load_command(args)
  595.     char *args;
  596. {                   
  597.     do_file_load(args);
  598. }
  599.  
  600. /*
  601.  * Generic utility to split arguments into pattern and body.
  602.  * Note: I can get away with this only because none of the functions
  603.  * that use it are reentrant.  Be careful.
  604.  */
  605.  
  606. static void split_args(args)
  607.     char *args;
  608. {
  609.     extern Stringp pattern, body;
  610.     char *place;
  611.  
  612.     place = strchr(args, '=');
  613.     if (place == NULL) {
  614.         Stringcpy(pattern, args);
  615.         Stringterm(body, 0);
  616.     } else {
  617.         Stringncpy(pattern, args, place - args);
  618.         Stringcpy(body, place + 1);
  619.     }
  620.     stripString(pattern);
  621.     stripString(body);
  622. }
  623.  
  624. /***********
  625.  * Hilites *
  626.  ***********/
  627.  
  628. void handle_hilite_command(args)
  629.     char *args;
  630. {
  631.     if (!*args) {
  632.         hilite = TRUE;
  633.         oputs("Hilites are enabled.");
  634.     } else {
  635.         split_args(args);
  636.         add_macro(new_macro("", pattern->s, "", 0, "", body->s, NULL,
  637.             hpri, 100, F_HILITE, 0, 0));
  638.     }
  639. }
  640.  
  641. void handle_nohilite_command(args)
  642.     char *args;
  643. {
  644.     if (!*args) {
  645.         hilite = FALSE;
  646.         oputs("Hilites are disabled.");
  647.     } else {
  648.         remove_macro(args, F_HILITE, 0);
  649.     }
  650. }
  651.  
  652.  
  653. /********
  654.  * Gags *
  655.  ********/
  656.  
  657. void handle_gag_command(args)
  658.     char *args;
  659. {
  660.     if (!*args) {
  661.         gag = TRUE;
  662.         oputs("Gags are enabled.");
  663.     } else {
  664.         split_args(args);
  665.         add_macro(new_macro("", pattern->s, "", 0, "", body->s, NULL,
  666.             gpri, 100, F_GAG, 0, 0));
  667.     }
  668. }
  669.  
  670. void handle_nogag_command(args)
  671.     char *args;
  672. {
  673.     if (!*args) {
  674.         gag = FALSE;
  675.         oputs("Gags are disabled.");
  676.     } else {
  677.         remove_macro(args, F_GAG, 0);
  678.     }
  679. }
  680.  
  681.  
  682. /************
  683.  * Triggers *
  684.  ************/
  685.  
  686. void handle_trig_command(args)
  687.     char *args;
  688. {
  689.     split_args(args);
  690.     add_macro(new_macro("", pattern->s, "", 0, "", body->s, NULL, 0, 100,
  691.         F_NORM, 0, 0));
  692. }
  693.  
  694. void handle_trigp_command(args)
  695.     char *args;
  696. {
  697.     int pri;
  698.  
  699.     pri = numarg(&args);
  700.     if (!args || !*args) {
  701.         oputs("% Bad /trigp format");
  702.         return;
  703.     }
  704.     split_args(args);
  705.     add_macro(new_macro("", pattern->s, "", 0, "", body->s, NULL, pri,
  706.         100, F_NORM, 0, 0));
  707. }
  708.  
  709. void handle_trigc_command(args)
  710.     char *args;
  711. {
  712.     int prob;
  713.  
  714.     prob = numarg(&args);
  715.     if (!args || !*args) {
  716.         oputs("% Bad /trigc format");
  717.         return;
  718.     }
  719.     split_args(args);
  720.     add_macro(new_macro("", pattern->s, "", 0, "", body->s, NULL, 0, prob,
  721.         F_NORM, 0, 0));
  722. }
  723.  
  724. void handle_trigpc_command(args)
  725.     char *args;
  726. {
  727.     int pri, prob;
  728.  
  729.     pri = numarg(&args);
  730.     if (!args || !*args) {
  731.         oputs("% Bad /trigpc format");
  732.         return;
  733.     }
  734.     prob = numarg(&args);
  735.     if (!args || !*args) {
  736.         oputs("% Bad /trigpc format");
  737.         return;
  738.     }
  739.     split_args(args);
  740.     add_macro(new_macro("", pattern->s, "", 0, "", body->s, NULL, pri,
  741.         prob, F_NORM, 0, 0));
  742. }
  743.  
  744. void handle_untrig_command(args)
  745.     char *args;
  746. {
  747.     remove_macro(args, F_NORM, 0);
  748. }
  749.  
  750.  
  751. /*********
  752.  * Hooks *
  753.  *********/
  754.  
  755. void handle_hook_command(args)
  756.     char *args;
  757. {
  758.     if (!*args) oprintf("%% Hooks %sabled", hookflag ? "en" : "dis");
  759.     else if (OFF) hookflag = FALSE;
  760.     else if (ON) hookflag = TRUE;
  761.     else {
  762.         split_args(args);
  763.         add_hook(pattern->s, body->s);
  764.     }
  765. }
  766.  
  767.  
  768. void handle_unhook_command(args)
  769.     char *args;
  770. {
  771.     remove_macro(args, 0, 1);
  772. }
  773.  
  774.  
  775. /********
  776.  * Keys *
  777.  ********/
  778.  
  779. void handle_unbind_command(args)
  780.     char *args;
  781. {
  782.     Macro *macro;
  783.  
  784.     if (!*args) return;
  785.     if (macro = find_key(translate_keystring(args))) nuke_macro(macro);
  786.     else oprintf("%% No binding for %s", args);
  787. }
  788.  
  789. void handle_bind_command(args)
  790.     char *args;
  791. {
  792.     Macro *spec;
  793.  
  794.     if (!*args) return;
  795.     split_args(args);
  796.     spec = new_macro("", "", translate_keystring(pattern->s), 0, "", body->s,
  797.         NULL, 0, 0, 0, 0, 0);
  798.     if (install_bind(spec)) add_macro(spec);
  799. }
  800.  
  801. void handle_dokey_command(args)
  802.     char *args;
  803. {
  804.     NFunc *func;
  805.  
  806.     if (func = find_efunc(args)) (*func)();
  807.     else oprintf("%% No editing function %s", args); 
  808. }
  809.