home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / less-321-src.tgz / tar.out / fsf / less / optfunc.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  8KB  |  495 lines
  1. /*
  2.  * Copyright (c) 1984,1985,1989,1994,1995,1996  Mark Nudelman
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice in the documentation and/or other materials provided with 
  12.  *    the distribution.
  13.  *
  14.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY
  15.  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
  17.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
  18.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
  19.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
  20.  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 
  21.  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
  22.  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
  23.  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 
  24.  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25.  */
  26.  
  27.  
  28. /*
  29.  * Handling functions for command line options.
  30.  *
  31.  * Most options are handled by the generic code in option.c.
  32.  * But all string options, and a few non-string options, require
  33.  * special handling specific to the particular option.
  34.  * This special processing is done by the "handling functions" in this file.
  35.  *
  36.  * Each handling function is passed a "type" and, if it is a string
  37.  * option, the string which should be "assigned" to the option.
  38.  * The type may be one of:
  39.  *    INIT    The option is being initialized from the command line.
  40.  *    TOGGLE    The option is being changed from within the program.
  41.  *    QUERY    The setting of the option is merely being queried.
  42.  */
  43.  
  44. #include "less.h"
  45. #include "option.h"
  46.  
  47. extern int nbufs;
  48. extern int cbufs;
  49. extern int pr_type;
  50. extern int plusoption;
  51. extern int swindow;
  52. extern int sc_height;
  53. extern int any_display;
  54. extern int secure;
  55. extern int dohelp;
  56. extern char *prproto[];
  57. extern char *eqproto;
  58. extern char *hproto;
  59. extern IFILE curr_ifile;
  60. #if LOGFILE
  61. extern char *namelogfile;
  62. extern int force_logfile;
  63. extern int logfile;
  64. #endif
  65. #if TAGS
  66. public char *tagoption = NULL;
  67. extern char *tagfile;
  68. extern char *tags;
  69. extern int jump_sline;
  70. #endif
  71. #if MSDOS_COMPILER
  72. extern int nm_fg_color, nm_bg_color;
  73. extern int bo_fg_color, bo_bg_color;
  74. extern int ul_fg_color, ul_bg_color;
  75. extern int so_fg_color, so_bg_color;
  76. extern int bl_fg_color, bl_bg_color;
  77. #endif
  78.  
  79.  
  80. #if LOGFILE
  81. /*
  82.  * Handler for -o option.
  83.  */
  84.     public void
  85. opt_o(type, s)
  86.     int type;
  87.     char *s;
  88. {
  89.     PARG parg;
  90.  
  91.     if (secure)
  92.     {
  93.         error("log file support is not available", NULL_PARG);
  94.         return;
  95.     }
  96.     switch (type)
  97.     {
  98.     case INIT:
  99.         namelogfile = s;
  100.         break;
  101.     case TOGGLE:
  102.         if (ch_getflags() & CH_CANSEEK)
  103.         {
  104.             error("Input is not a pipe", NULL_PARG);
  105.             return;
  106.         }
  107.         if (logfile >= 0)
  108.         {
  109.             error("Log file is already in use", NULL_PARG);
  110.             return;
  111.         }
  112.         s = skipsp(s);
  113.         namelogfile = lglob(s);
  114.         use_logfile(namelogfile);
  115.         sync_logfile();
  116.         break;
  117.     case QUERY:
  118.         if (logfile < 0)
  119.             error("No log file", NULL_PARG);
  120.         else
  121.         {
  122.             parg.p_string = namelogfile;
  123.             error("Log file \"%s\"", &parg);
  124.         }
  125.         break;
  126.     }
  127. }
  128.  
  129. /*
  130.  * Handler for -O option.
  131.  */
  132.     public void
  133. opt__O(type, s)
  134.     int type;
  135.     char *s;
  136. {
  137.     force_logfile = TRUE;
  138.     opt_o(type, s);
  139. }
  140. #endif
  141.  
  142. /*
  143.  * Handlers for -l option.
  144.  */
  145.     public void
  146. opt_l(type, s)
  147.     int type;
  148.     char *s;
  149. {
  150.     int err;
  151.     int n;
  152.     char *t;
  153.     
  154.     switch (type)
  155.     {
  156.     case INIT:
  157.         t = s;
  158.         n = getnum(&t, 'l', &err);
  159.         if (err || n <= 0)
  160.         {
  161.             error("Line number is required after -l", NULL_PARG);
  162.             return;
  163.         }
  164.         plusoption = TRUE;
  165.         ungetsc(s);
  166.         break;
  167.     }
  168. }
  169.  
  170. #if USERFILE
  171.     public void
  172. opt_k(type, s)
  173.     int type;
  174.     char *s;
  175. {
  176.     PARG parg;
  177.  
  178.     switch (type)
  179.     {
  180.     case INIT:
  181.         if (lesskey(s))
  182.         {
  183.             parg.p_string = s;
  184.             error("Cannot use lesskey file \"%s\"", &parg);
  185.         }
  186.         break;
  187.     }
  188. }
  189. #endif
  190.  
  191. #if TAGS
  192. /*
  193.  * Handler for -t option.
  194.  */
  195.     public void
  196. opt_t(type, s)
  197.     int type;
  198.     char *s;
  199. {
  200.     IFILE save_ifile;
  201.     POSITION pos;
  202.  
  203.     switch (type)
  204.     {
  205.     case INIT:
  206.         tagoption = s;
  207.         /* Do the rest in main() */
  208.         break;
  209.     case TOGGLE:
  210.         if (secure)
  211.         {
  212.             error("tags support is not available", NULL_PARG);
  213.             break;
  214.         }
  215.         findtag(skipsp(s));
  216.         if (tagfile == NULL)
  217.             break;
  218.         save_ifile = curr_ifile;
  219.         if (edit(tagfile))
  220.             break;
  221.         if ((pos = tagsearch()) == NULL_POSITION)
  222.         {
  223.             reedit_ifile(save_ifile);
  224.             break;
  225.         }
  226.         jump_loc(pos, jump_sline);
  227.         break;
  228.     }
  229. }
  230.  
  231. /*
  232.  * Handler for -T option.
  233.  */
  234.     public void
  235. opt__T(type, s)
  236.     int type;
  237.     char *s;
  238. {
  239.     PARG parg;
  240.  
  241.     switch (type)
  242.     {
  243.     case INIT:
  244.         tags = s;
  245.         break;
  246.     case TOGGLE:
  247.         s = skipsp(s);
  248.         tags = lglob(s);
  249.         break;
  250.     case QUERY:
  251.         parg.p_string = tags;
  252.         error("Tags file \"%s\"", &parg);
  253.         break;
  254.     }
  255. }
  256. #endif
  257.  
  258. /*
  259.  * Handler for -p option.
  260.  */
  261.     public void
  262. opt_p(type, s)
  263.     int type;
  264.     register char *s;
  265. {
  266.     switch (type)
  267.     {
  268.     case INIT:
  269.         /*
  270.          * Unget a search command for the specified string.
  271.          * {{ This won't work if the "/" command is
  272.          *    changed or invalidated by a .lesskey file. }}
  273.          */
  274.         plusoption = TRUE;
  275.         ungetsc(s);
  276.         ungetsc("/");
  277.         break;
  278.     }
  279. }
  280.  
  281. /*
  282.  * Handler for -P option.
  283.  */
  284.     public void
  285. opt__P(type, s)
  286.     int type;
  287.     register char *s;
  288. {
  289.     register char **proto;
  290.     PARG parg;
  291.  
  292.     switch (type)
  293.     {
  294.     case INIT:
  295.     case TOGGLE:
  296.         /*
  297.          * Figure out which prototype string should be changed.
  298.          */
  299.         switch (*s)
  300.         {
  301.         case 's':  proto = &prproto[PR_SHORT];    s++;    break;
  302.         case 'm':  proto = &prproto[PR_MEDIUM];    s++;    break;
  303.         case 'M':  proto = &prproto[PR_LONG];    s++;    break;
  304.         case '=':  proto = &eqproto;        s++;    break;
  305.         case 'h':  proto = &hproto;        s++;    break;
  306.         default:   proto = &prproto[PR_SHORT];        break;
  307.         }
  308.         free(*proto);
  309.         *proto = save(s);
  310.         break;
  311.     case QUERY:
  312.         parg.p_string = prproto[pr_type];
  313.         error("%s", &parg);
  314.         break;
  315.     }
  316. }
  317.  
  318. /*
  319.  * Handler for the -b option.
  320.  */
  321.     /*ARGSUSED*/
  322.     public void
  323. opt_b(type, s)
  324.     int type;
  325.     char *s;
  326. {
  327.     switch (type)
  328.     {
  329.     case TOGGLE:
  330.     case QUERY:
  331.         /*
  332.          * Allocate the new number of buffers.
  333.          */
  334.         cbufs = ch_nbuf(cbufs);
  335.         break;
  336.     case INIT:
  337.         break;
  338.     }
  339. }
  340.  
  341. /*
  342.  * Handler for the -i option.
  343.  */
  344.     /*ARGSUSED*/
  345.     public void
  346. opt_i(type, s)
  347.     int type;
  348.     char *s;
  349. {
  350.     switch (type)
  351.     {
  352.     case TOGGLE:
  353.         chg_caseless();
  354.         break;
  355.     case QUERY:
  356.     case INIT:
  357.         break;
  358.     }
  359. }
  360.  
  361. /*
  362.  * Handler for the -V option.
  363.  */
  364.     /*ARGSUSED*/
  365.     public void
  366. opt__V(type, s)
  367.     int type;
  368.     char *s;
  369. {
  370.     switch (type)
  371.     {
  372.     case TOGGLE:
  373.     case QUERY:
  374.     case INIT:
  375.         dispversion();
  376.         if (type == INIT)
  377.             quit(QUIT_OK);
  378.         break;
  379.     }
  380. }
  381.  
  382. #if MSDOS_COMPILER
  383. /*
  384.  *
  385.  */
  386.        static void
  387. colordesc(s, fg_color, bg_color)
  388.     char *s;
  389.     int *fg_color;
  390.     int *bg_color;
  391. {
  392.     int fg, bg;
  393.     int err;
  394.     
  395.     fg = getnum(&s, 'D', &err);
  396.     if (err)
  397.     {
  398.         error("Missing fg color in -D", NULL_PARG);
  399.         return;
  400.     }
  401.     if (*s != '.')
  402.         bg = 0;
  403.     else
  404.     {
  405.         s++;
  406.         bg = getnum(&s, 'D', &err);
  407.         if (err)
  408.         {
  409.             error("Missing fg color in -D", NULL_PARG);
  410.             return;
  411.         }
  412.     }
  413.     *fg_color = fg;
  414.     *bg_color = bg;
  415. }
  416.  
  417. /*
  418.  * Handler for the -D option.
  419.  */
  420.     /*ARGSUSED*/
  421.     public void
  422. opt_D(type, s)
  423.     int type;
  424.     char *s;
  425. {
  426.     switch (type)
  427.     {
  428.     case INIT:
  429.     case TOGGLE:
  430.         switch (*s++)
  431.         {
  432.         case 'n':
  433.             colordesc(s, &nm_fg_color, &nm_bg_color);
  434.             break;
  435.         case 'd':
  436.             colordesc(s, &bo_fg_color, &bo_bg_color);
  437.             break;
  438.         case 'u':
  439.             colordesc(s, &ul_fg_color, &ul_bg_color);
  440.             break;
  441.         case 'k':
  442.             colordesc(s, &bl_fg_color, &bl_bg_color);
  443.             break;
  444.         case 's':
  445.             colordesc(s, &so_fg_color, &so_bg_color);
  446.             break;
  447.         default:
  448.             error("-D must be followed by n, d, u, k or s", NULL_PARG);
  449.             break;
  450.         }
  451.         if (type == TOGGLE)
  452.         {
  453.             so_enter();
  454.             so_exit();
  455.         }
  456.         break;
  457.     case QUERY:
  458.         break;
  459.     }
  460. }
  461. #endif
  462.  
  463. /*
  464.  * "-?" means display a help message.
  465.  * If from the command line, exit immediately.
  466.  */
  467.     /*ARGSUSED*/
  468.     public void
  469. opt_query(type, s)
  470.     int type;
  471.     char *s;
  472. {
  473.     switch (type)
  474.     {
  475.     case QUERY:
  476.     case TOGGLE:
  477.         error("Use \"h\" for help", NULL_PARG);
  478.         break;
  479.     case INIT:
  480.         dohelp = 1;
  481.     }
  482. }
  483.  
  484. /*
  485.  * Get the "screen window" size.
  486.  */
  487.     public int
  488. get_swindow()
  489. {
  490.     if (swindow > 0)
  491.         return (swindow);
  492.     return (sc_height + swindow);
  493. }
  494.  
  495.