← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/mit-scheme/intrepid-updates

« back to all changes in this revision

Viewing changes to src/microcode/comlin.c

  • Committer: Bazaar Package Importer
  • Author(s): Chris Hanson
  • Date: 2002-03-14 17:04:07 UTC
  • Revision ID: james.westby@ubuntu.com-20020314170407-m5lg1d6bdsl9lv0s
Tags: upstream-7.7.0
Import upstream version 7.7.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/microcode/comlin.c
 
1
/* -*-C-*-
 
2
 
 
3
Copyright (c) 1987-1999 Massachusetts Institute of Technology
 
4
 
 
5
This program is free software; you can redistribute it and/or modify
 
6
it under the terms of the GNU General Public License as published by
 
7
the Free Software Foundation; either version 2 of the License, or (at
 
8
your option) any later version.
 
9
 
 
10
This program is distributed in the hope that it will be useful, but
 
11
WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
13
General Public License for more details.
 
14
 
 
15
You should have received a copy of the GNU General Public License
 
16
along with this program; if not, write to the Free Software
 
17
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
18
*/
 
19
 
 
20
/* $Id: comlin.c,v 1.9 1999/01/02 06:11:34 cph Exp $
 
21
 *
 
22
 * This file contains the scheme command parser.
 
23
 *
 
24
 */
 
25
 
 
26
#include <stdio.h>
 
27
#ifndef toupper
 
28
#include <ctype.h>
 
29
#endif
 
30
 
 
31
#include "comlin.h"
 
32
 
 
33
/* Some string utilities */
 
34
 
 
35
char *
 
36
DEFUN (remove_initial_substring, (sub, str),
 
37
       register char * sub
 
38
       AND register char * str)
 
39
{
 
40
  for ( ; *sub != '\0'; sub++, str++)
 
41
  {
 
42
    if (*sub != *str)
 
43
    {
 
44
      return ((char *) NULL);
 
45
    }
 
46
  }
 
47
  return (str);
 
48
}
 
49
 
 
50
boolean
 
51
DEFUN (STREQUAL, (s1, s2),
 
52
       register char * s1
 
53
       AND register char * s2)
 
54
{
 
55
  for ( ; *s1 != '\0'; s1++, s2++)
 
56
  {
 
57
    if (toupper(*s1) != toupper(*s2))
 
58
    {
 
59
      return (false);
 
60
    }
 
61
  }
 
62
  return (*s2 == '\0');
 
63
}
 
64
 
 
65
/* Usage information */
 
66
 
 
67
void
 
68
DEFUN (print_usage_and_exit, (options, val),
 
69
       struct keyword_struct * options
 
70
       AND int val)
 
71
{
 
72
  register int i;
 
73
 
 
74
  fprintf(stderr, "usage: %s", program_name);
 
75
 
 
76
  if ((options[0].type_tag) == LAST_KYWRD)
 
77
  {
 
78
    fprintf(stderr, "\n");
 
79
    exit(val);
 
80
  }
 
81
 
 
82
  fprintf(stderr, " [args]\n");
 
83
  fprintf(stderr, "    where args are as follows:\n");
 
84
 
 
85
  for (i = 0;
 
86
       ((options[i].type_tag) != LAST_KYWRD);
 
87
       i++)
 
88
  {
 
89
    switch (options[i].type_tag)
 
90
    {
 
91
      case BOOLEAN_KYWRD:
 
92
        fprintf(stderr, "        %s={true,false}\n",
 
93
                options[i].keyword);
 
94
        break;
 
95
 
 
96
      case INT_KYWRD:
 
97
      case DOUBLE_KYWRD:
 
98
        fprintf(stderr, "        %s=%s\n",
 
99
                options[i].keyword, options[i].format);
 
100
        break;
 
101
 
 
102
      case STRING_KYWRD:
 
103
        fprintf(stderr, "        %s=%%s\n",
 
104
                options[i].keyword);
 
105
        break;
 
106
    }
 
107
  }
 
108
  exit(val);
 
109
}
 
110
 
 
111
void
 
112
DEFUN (supply, (options, j),
 
113
       struct keyword_struct * options
 
114
       AND int j)
 
115
{
 
116
  if (options[j].supplied_p != ((boolean *) NULL))
 
117
  {
 
118
    if (*(options[j].supplied_p))
 
119
    {
 
120
      fprintf(stderr,
 
121
              "parse_keywords: Repeated keyword: %s\n",
 
122
              options[j].keyword);
 
123
      print_usage_and_exit(&options[0], 1);
 
124
    }
 
125
    else
 
126
    {
 
127
      *(options[j].supplied_p) = true;
 
128
    }
 
129
  }
 
130
  return;
 
131
}
 
132
 
 
133
char * program_name;
 
134
 
 
135
/* This parser assumes that no keyword is an initial
 
136
   substring of another.
 
137
 */
 
138
 
 
139
void
 
140
DEFUN (parse_keywords,
 
141
       (argc, argv, options, allow_others_p),
 
142
       int argc
 
143
       AND char **argv
 
144
       AND struct keyword_struct * options
 
145
       AND boolean allow_others_p)
 
146
{
 
147
  register int i, j, length;
 
148
  char *argument;
 
149
 
 
150
  program_name = argv[0];
 
151
  argv += 1;
 
152
  argc -= 1;
 
153
 
 
154
  /* Initialize defaults */
 
155
 
 
156
  for (length = 0;
 
157
       ((options[length].type_tag) != LAST_KYWRD);
 
158
       length++)
 
159
  {
 
160
    if (options[length].supplied_p != ((boolean *) NULL))
 
161
    {
 
162
      *(options[length].supplied_p) = false;
 
163
    }
 
164
 
 
165
    switch (options[length].type_tag)
 
166
    {
 
167
      case BOOLEAN_KYWRD:
 
168
        if (options[length].format != BFRMT)
 
169
        {
 
170
          fprintf(stderr,
 
171
                  "parse_keywords: format (%s) for boolean keyword %s\n",
 
172
                  options[length].format,
 
173
                  options[length].keyword);
 
174
          exit(1);
 
175
        }
 
176
        break;
 
177
 
 
178
      case INT_KYWRD:
 
179
        break;
 
180
 
 
181
      case DOUBLE_KYWRD:
 
182
        break;
 
183
 
 
184
      case STRING_KYWRD:
 
185
        if (options[length].format != SFRMT)
 
186
        {
 
187
          fprintf(stderr,
 
188
                  "parse_keywords: format (%s) for string keyword %s\n",
 
189
                  options[length].format,
 
190
                  options[length].keyword);
 
191
          exit(1);
 
192
        }
 
193
        break;
 
194
 
 
195
      default:
 
196
        fprintf(stderr, "parse_keywords: bad type %d\n",
 
197
                options[length].type_tag);
 
198
        exit(1);
 
199
    }
 
200
  }
 
201
 
 
202
  for (i = 0; i < argc; i++)
 
203
  {
 
204
    for (j = 0; j < length; j++)
 
205
    {
 
206
      argument = remove_initial_substring(options[j].keyword,argv[i]);
 
207
      if (argument != ((char *) NULL))
 
208
      {
 
209
        switch (options[j].type_tag)
 
210
        {
 
211
 
 
212
          case BOOLEAN_KYWRD:
 
213
          {
 
214
            boolean value;
 
215
 
 
216
            if (*argument != '\0')
 
217
            {
 
218
              if (*argument != '=')
 
219
              {
 
220
                fprintf(stderr,
 
221
                        "parse_keywords: unrecognized parameter: %s\n",
 
222
                        argv[i]);
 
223
                print_usage_and_exit(&options[0], 1);
 
224
              }
 
225
              else
 
226
              {
 
227
                argument = &argument[1];
 
228
                if (STREQUAL(argument,"t") || STREQUAL(argument,"true"))
 
229
                {
 
230
                  value = true;
 
231
                }
 
232
                else if (STREQUAL(argument,"f") ||
 
233
                         STREQUAL(argument,"false") ||
 
234
                         STREQUAL(argument,"nil"))
 
235
                {
 
236
                  value = false;
 
237
                }
 
238
                else
 
239
                {
 
240
                  fprintf(stderr,
 
241
                          "parse_keywords: Invalid boolean value: %s\n",
 
242
                          argv[i]);
 
243
                  print_usage_and_exit(&options[0], 1);
 
244
                }
 
245
              }
 
246
            }
 
247
            else
 
248
            {
 
249
              value = true;
 
250
            }
 
251
            supply(options, j);
 
252
            *(BOOLEAN_LVALUE(options[j])) = value;
 
253
            break;
 
254
          }
 
255
 
 
256
          case INT_KYWRD:
 
257
            if (*argument != '=')
 
258
            {
 
259
              {
 
260
                fprintf(stderr,
 
261
                        "parse_keywords: %s: %s\n",
 
262
                        ((*argument == '\0')    ?
 
263
                         "missing integer value"        :
 
264
                         "unrecognized parameter"),
 
265
                        argv[i]);
 
266
                print_usage_and_exit(&options[0], 1);
 
267
              }
 
268
            }
 
269
            supply(options, j);
 
270
            sscanf(&argument[1], options[j].format, INT_LVALUE(options[j]));
 
271
            break;
 
272
 
 
273
          case DOUBLE_KYWRD:
 
274
            if (*argument != '=')
 
275
            {
 
276
              {
 
277
                fprintf(stderr,
 
278
                        "parse_keywords: %s: %s\n",
 
279
                        ((*argument == '\0')            ?
 
280
                         "missing floating point value" :
 
281
                         "unrecognized parameter"),
 
282
                        argv[i]);
 
283
                print_usage_and_exit(&options[0], 1);
 
284
              }
 
285
            }
 
286
            supply(options, j);
 
287
            sscanf(&argument[1], options[j].format, DOUBLE_LVALUE(options[j]));
 
288
            break;
 
289
 
 
290
          case STRING_KYWRD:
 
291
            if (*argument != '=')
 
292
            {
 
293
              {
 
294
                fprintf(stderr,
 
295
                        "parse_keywords: %s: %s\n",
 
296
                        ((*argument == '\0')    ?
 
297
                         "missing string value" :
 
298
                         "unrecognized parameter"),
 
299
                        argv[i]);
 
300
                print_usage_and_exit(&options[0], 1);
 
301
              }
 
302
            }
 
303
            supply(options, j);
 
304
            *(STRING_LVALUE(options[j])) = &argument[1];
 
305
            break;
 
306
          }
 
307
        break;
 
308
      }
 
309
    }
 
310
    if ((j >= length) && (!allow_others_p))
 
311
    {
 
312
      fprintf(stderr,
 
313
              "parse_keywords: unrecognized parameter: %s\n",
 
314
              argv[i]);
 
315
      print_usage_and_exit(&options[0], 1);
 
316
    }
 
317
  }
 
318
  return;
 
319
}