home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / oleo-1.4 / args.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-13  |  9.4 KB  |  498 lines
  1. /*    Copyright (C) 1993 Free Software Foundation, Inc.
  2.  
  3. This program is free software; you can redistribute it and/or modify
  4. it under the terms of the GNU General Public License as published by
  5. the Free Software Foundation; either version 2, or (at your option)
  6. any later version.
  7.  
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. GNU General Public License for more details.
  12.  
  13. You should have received a copy of the GNU General Public License
  14. along with this software; see the file COPYING.  If not, write to
  15. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  16.  
  17. #include <ctype.h>
  18. #include "global.h"
  19. #define DEFINE_STYLES    1
  20. #include "args.h"
  21. #include "cmd.h"
  22. #include "io-abstract.h"
  23. #include "io-generic.h"
  24. #include "io-edit.h"
  25. #include "io-utils.h"
  26. #include "format.h"
  27.  
  28.  
  29.  
  30. /* These commands define the syntax and editting modes of command arguments.
  31.  * Each _verify function parses some kind of argument and stores its value
  32.  * in a command_arg structure.  An error message or NULL is returned.
  33.  * If the match succeeds, a string pointer is advanced to the end of what was
  34.  * parsed.
  35.  *
  36.  * Several arguments may be listed on one line separated only by
  37.  * whitespace.  A _verify function should stop after its argument and ignore
  38.  * everything after that. 
  39.  */
  40.  
  41. #ifdef __STDC__
  42. char *
  43. char_verify (char ** end, struct command_arg * arg)
  44. #else
  45. char *
  46. char_verify (end, arg)
  47.      char ** end;
  48.      struct command_arg * arg;
  49. #endif
  50. {
  51.   if (!**end)
  52.     return "No character specified";
  53.   else
  54.     {
  55.       int ch = string_to_char (end);
  56.       if (ch < 0)
  57.     {
  58.       setn_edit_line ("", 0);
  59.       return "Illegal character constant.";
  60.     }
  61.       else
  62.     {
  63.       arg->val.integer = ch;
  64.       return 0;
  65.     }
  66.     }
  67. }
  68.  
  69. #ifdef __STDC__
  70. char *
  71. symbol_verify (char ** end, struct command_arg * arg)
  72. #else
  73. char *
  74. symbol_verify (end, arg)
  75.      char ** end;
  76.      struct command_arg * arg;
  77. #endif
  78. {
  79.   char * e = *end;
  80.   char * start = *end;
  81.   if (isalpha (*e) || (*e == '-') || (*e == '_') || (*e == (a0 ? '$' : ':')))
  82.     {
  83.       while (isalpha(*e) || isdigit(*e) || (*e == '-') || (*e == '_')
  84.          || (*e == (a0 ? '$' : ':')))
  85.     ++e;
  86.       if (!isspace(*e) && *e)
  87.     goto bad_symbol;
  88.       *end = e;
  89.       arg->val.string = (char *)ck_malloc (e - start + 1);
  90.       if (e - start)
  91.     bcopy (start, arg->val.string, e - start);
  92.       arg->val.string[e - start] = '\0';
  93.       return 0;
  94.     }
  95.  bad_symbol:
  96.   if (arg->arg_desc[1] == '\'')
  97.     {
  98.       arg->val.string = 0;
  99.       return 0;
  100.     }
  101.   else
  102.     return "Invalid symbol name.";
  103. }
  104.  
  105. char *
  106. word_verify (end, arg)
  107.      char ** end;
  108.      struct command_arg * arg;
  109. {
  110.   char * e = *end;
  111.   char * start = *end;
  112.   if (!isspace (*e))
  113.     {
  114.       while (!isspace(*e))
  115.     ++e;
  116.       *end = e;
  117.       arg->val.string = (char *)ck_malloc (e - start + 1);
  118.       if (e - start)
  119.     bcopy (start, arg->val.string, e - start);
  120.       arg->val.string[e - start] = '\0';
  121.       return 0;
  122.     }
  123.   else if (arg->arg_desc[1] == '\'')
  124.     {
  125.       arg->val.string = 0;
  126.       return 0;
  127.     }
  128.   else
  129.     return "Invalid symbol name.";
  130. }
  131.  
  132. #ifdef __STDC__
  133. void
  134. symbol_destroy (struct command_arg * arg)
  135. #else
  136. void
  137. symbol_destroy (arg)
  138.      struct command_arg * arg;
  139. #endif
  140. {
  141.   if (arg->val.string)
  142.     ck_free (arg->val.string);
  143. }
  144.  
  145. #ifdef __STDC__
  146. char *
  147. command_verify (char ** end, struct command_arg * arg)
  148. #else
  149. char *
  150. command_verify (end, arg)
  151.      char ** end;
  152.      struct command_arg * arg;
  153. #endif
  154. {
  155.   char * error = symbol_verify (end, arg);
  156.   char * str;
  157.   if (error)
  158.     return error;
  159.   str = arg->val.string;
  160.   if (!(find_function (0, 0, arg->val.string, strlen(arg->val.string))
  161.         && get_abs_rng (&str, 0)))
  162.     return 0;
  163.   else
  164.     return "Not a command or macro address.";
  165. }
  166.  
  167. #ifdef __STDC__
  168. char * 
  169. read_file_verify (char ** end, struct command_arg * arg)
  170. #else
  171. char * 
  172. read_file_verify (end, arg)
  173.      char ** end;
  174.      struct command_arg * arg;
  175. #endif
  176. {
  177.   FILE * fp = xopen_with_backup (arg->text.buf, "r");
  178.   *end = 0;
  179.   if (!fp)
  180.     {
  181.       io_error_msg ("Can't open file '%s':%s", arg->text.buf, err_msg ());
  182.       return "";
  183.     }
  184.   else
  185.     {
  186.       arg->val.fp = fp;
  187.       return 0;
  188.     }
  189. }
  190.  
  191. #ifdef __STDC__
  192. void
  193. read_file_destroy (struct command_arg * arg)
  194. #else
  195. void
  196. read_file_destroy (arg)
  197.      struct command_arg * arg;
  198. #endif
  199. {
  200.   int num;
  201.   num = xclose (arg->val.fp);
  202.   if (num)
  203.     io_error_msg ("Can't close '%s': Error code %d: %s",
  204.           arg->text.buf, num, err_msg ());
  205. }
  206.  
  207.  
  208. #ifdef __STDC__
  209. char * 
  210. write_file_verify (char ** end, struct command_arg * arg)
  211. #else
  212. char * 
  213. write_file_verify (end, arg)
  214.      char ** end;
  215.      struct command_arg * arg;
  216. #endif
  217. {
  218.   FILE * fp = xopen_with_backup (arg->text.buf, "w");
  219.   *end = 0;
  220.   if (!fp)
  221.     {
  222.       io_error_msg ("Can't open file '%s':%s", arg->text.buf, err_msg ());
  223.       return "";
  224.     }
  225.   else
  226.     {
  227.       arg->val.fp = fp;
  228.       return 0;
  229.     }
  230. }
  231.  
  232. #ifdef __STDC__
  233. void
  234. write_file_destroy (struct command_arg * arg)
  235. #else
  236. void
  237. write_file_destroy (arg)
  238.      struct command_arg * arg;
  239. #endif
  240. {
  241.   int num;
  242.  
  243.   num = xclose (arg->val.fp);
  244.   if (num)
  245.     io_error_msg ("Can't close '%s': Error code %d: %s",
  246.           arg->text.buf, num, err_msg ());
  247. }
  248.  
  249. /* As a special case, cmd_loop makes sure that keyseq arguments are only read
  250.  * interactively.
  251.  */
  252.  
  253. #ifdef __STDC__
  254. char *
  255. keyseq_verify (char ** end, struct command_arg * arg)
  256. #else
  257. char *
  258. keyseq_verify (end, arg)
  259.      char ** end;
  260.      struct command_arg * arg;
  261. #endif
  262. {
  263.   *end = 0;
  264.   return 0;
  265. }
  266.  
  267.  
  268. #ifdef __STDC__
  269. char *
  270. keymap_verify (char ** end, struct command_arg * arg)
  271. #else
  272. char *
  273. keymap_verify (end, arg)
  274.      char ** end;
  275.      struct command_arg * arg;
  276. #endif
  277. {
  278.   char * start = *end;
  279.   char * error = symbol_verify (end, arg);
  280.   int id;
  281.   if (error)
  282.     return error;
  283.   id = map_idn (start, *end - start);
  284.   return (id >= 0
  285.       ? (char *) 0
  286.       : "No such keymap.");
  287. }
  288.  
  289.  
  290. #ifdef __STDC__
  291. char *
  292. number_verify (char ** end, struct command_arg * arg)
  293. #else
  294. char *
  295. number_verify (end, arg)
  296.      char ** end;
  297.      struct command_arg * arg;
  298. #endif
  299. {
  300.   char * e = *end;
  301.  
  302.   while (isspace (*e))
  303.     ++e;
  304.   if (isdigit(*e) || (*e == '-'))
  305.     {
  306.       arg->val.integer = astol (end);
  307.       if (arg->arg_desc[1] == '[')
  308.     {
  309.       char * prompt = arg->arg_desc + 2;
  310.       {
  311.         long low = 0;
  312.         long high = -1;
  313.         low = astol (&prompt);
  314.         while (isspace (*prompt))  ++prompt;
  315.         if (*prompt == ',') ++prompt;
  316.         high = astol (&prompt);
  317.         while (isspace (*prompt))  ++prompt;
  318.         if (*prompt == ']') ++prompt;
  319.         if (   (low > arg->val.integer)
  320.         || (high < arg->val.integer))
  321.           io_error_msg ("Out of range %d (should be in [%d - %d]).",
  322.                 arg->val.integer, low, high); /* no return */
  323.       }
  324.     }
  325.       return 0;
  326.     }
  327.   else
  328.     return "Not a number.";
  329. }
  330.  
  331.  
  332. #ifdef __STDC__
  333. char *
  334. double_verify (char ** end, struct command_arg * arg)
  335. #else
  336. char *
  337. double_verify (end, arg)
  338.      char ** end;
  339.      struct command_arg * arg;
  340. #endif
  341. {
  342.   char * e = *end;
  343.  
  344.   while (isspace (*e))
  345.     ++e;
  346.   if (isdigit(*e) || ((*e == '-') && isdigit (*(e + 1))))
  347.     {
  348.       arg->val.floating = astof (end);
  349.       return 0;
  350.     }
  351.   else
  352.     return "Not a number.";
  353. }
  354.  
  355.  
  356. #ifdef __STDC__
  357. char * 
  358. range_verify (char ** end, struct command_arg * arg)
  359. #else
  360. char * 
  361. range_verify (end, arg)
  362.      char ** end;
  363.      struct command_arg * arg;
  364. #endif
  365. {
  366.   union command_arg_val * val = &arg->val;
  367.   *end = arg->text.buf;
  368.   if (get_abs_rng (end, &val->range))
  369.     return "Not a range.";
  370.   else
  371.     return 0;
  372. }
  373.  
  374. #ifdef __STDC__
  375. char * 
  376. string_verify (char ** end, struct command_arg * arg)
  377. #else
  378. char * 
  379. string_verify (end, arg)
  380.      char ** end;
  381.      struct command_arg * arg;
  382. #endif
  383. {
  384.   arg->val.string = arg->text.buf;
  385.   *end = 0;
  386.   return 0;
  387. }
  388.  
  389. /* Unlike most verify functions, this
  390.  * one may destroy the command frame that it is 
  391.  * operating on.  It's purpose is to allow user's
  392.  * to abort commands. 
  393.  */
  394. #ifdef __STDC__
  395. char * 
  396. yes_verify (char ** end, struct command_arg * arg)
  397. #else
  398. char * 
  399. yes_verify (end, arg)
  400.      char ** end;
  401.      struct command_arg * arg;
  402. #endif
  403. {
  404.   if (words_imatch (end, "no"))
  405.     {
  406.       pop_unfinished_command ();
  407.       return "Aborted.";
  408.     }
  409.   else if (words_imatch (end, "yes"))
  410.     return 0;
  411.   else
  412.     {
  413.       setn_edit_line ("", 0);
  414.       return "Please answer yes or no.";
  415.     }
  416. }
  417.  
  418. #ifdef __STDC__
  419. char *
  420. incremental_cmd_verify (char ** end, struct command_arg * arg)
  421. #else
  422. char *
  423. incremental_cmd_verify (end, arg)
  424.      char ** end;
  425.      struct command_arg * arg;
  426. #endif
  427. {
  428.   return 0;
  429. }
  430.  
  431.  
  432. #ifdef __STDC__
  433. char *
  434. menu_verify (char ** end, struct command_arg * arg)
  435. #else
  436. char *
  437. menu_verify (end, arg)
  438.      char ** end;
  439.      struct command_arg * arg;
  440. #endif
  441. {
  442.   char * error = char_verify (end, arg);
  443.   if (error)
  444.     return error;
  445.  
  446.   {
  447.     int pick = arg->val.integer;
  448.     char * key = arg->arg_desc + 1;
  449.     while (*key && (*key != ']'))
  450.       {
  451.     if (*key == '\\')
  452.       {
  453.         ++key;
  454.         if (!*key)
  455.           break;
  456.       }
  457.     if (pick == *key)
  458.       return 0;
  459.     else
  460.       ++key;
  461.       }
  462.     setn_edit_line ("", 0);
  463.     return "No such menu option.";
  464.   }
  465. }
  466.  
  467.  
  468. #ifdef __STDC__
  469. char *
  470. format_verify (char ** end, struct command_arg * arg)
  471. #else
  472. char *
  473. format_verify (end, arg)
  474.      char ** end;
  475.      struct command_arg * arg;
  476. #endif
  477. {
  478.   arg->val.integer = str_to_fmt (*end);
  479.   if (arg->val.integer < 0)
  480.     return "Unknown format.";
  481.   *end = 0;
  482.   return 0;
  483. }
  484.  
  485.  
  486. #ifdef __STDC__
  487. char *
  488. noop_verify (char ** end, struct command_arg * arg)
  489. #else
  490. char *
  491. noop_verify (end, arg)
  492.      char ** end;
  493.      struct command_arg * arg;
  494. #endif
  495. {
  496.   return 0;
  497. }
  498.