Generated scanner from flex after fixing the 64-bit bugs.
[charm.git] / src / xlatcpm / conv-cpm.c
1 /* A lexical scanner generated by flex */
2
3 /* Scanner skeleton version:
4  * $Header$
5  */
6
7 #define FLEX_SCANNER
8 #define YY_FLEX_MAJOR_VERSION 2
9 #define YY_FLEX_MINOR_VERSION 5
10
11 #include <stdio.h>
12
13
14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
15 #ifdef c_plusplus
16 #ifndef __cplusplus
17 #define __cplusplus
18 #endif
19 #endif
20
21
22 #ifdef __cplusplus
23
24 #include <stdlib.h>
25 #include <unistd.h>
26
27 /* Use prototypes in function declarations. */
28 #define YY_USE_PROTOS
29
30 /* The "const" storage-class-modifier is valid. */
31 #define YY_USE_CONST
32
33 #else   /* ! __cplusplus */
34
35 #if __STDC__
36
37 #define YY_USE_PROTOS
38 #define YY_USE_CONST
39
40 #endif  /* __STDC__ */
41 #endif  /* ! __cplusplus */
42
43 #ifdef __TURBOC__
44  #pragma warn -rch
45  #pragma warn -use
46 #include <io.h>
47 #include <stdlib.h>
48 #define YY_USE_CONST
49 #define YY_USE_PROTOS
50 #endif
51
52 #ifdef YY_USE_CONST
53 #define yyconst const
54 #else
55 #define yyconst
56 #endif
57
58
59 #ifdef YY_USE_PROTOS
60 #define YY_PROTO(proto) proto
61 #else
62 #define YY_PROTO(proto) ()
63 #endif
64
65 /* Returned upon end-of-file. */
66 #define YY_NULL 0
67
68 /* Promotes a possibly negative, possibly signed char to an unsigned
69  * integer for use as an array index.  If the signed char is negative,
70  * we want to instead treat it as an 8-bit unsigned char, hence the
71  * double cast.
72  */
73 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
74
75 /* Enter a start condition.  This macro really ought to take a parameter,
76  * but we do it the disgusting crufty way forced on us by the ()-less
77  * definition of BEGIN.
78  */
79 #define BEGIN yy_start = 1 + 2 *
80
81 /* Translate the current start state into a value that can be later handed
82  * to BEGIN to return to the state.  The YYSTATE alias is for lex
83  * compatibility.
84  */
85 #define YY_START ((yy_start - 1) / 2)
86 #define YYSTATE YY_START
87
88 /* Action number for EOF rule of a given start state. */
89 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
90
91 /* Special action meaning "start processing a new file". */
92 #define YY_NEW_FILE yyrestart( yyin )
93
94 #define YY_END_OF_BUFFER_CHAR 0
95
96 /* Size of default input buffer. */
97 #define YY_BUF_SIZE 16384
98
99 typedef struct yy_buffer_state *YY_BUFFER_STATE;
100
101 extern int yyleng;
102 extern FILE *yyin, *yyout;
103
104 #define EOB_ACT_CONTINUE_SCAN 0
105 #define EOB_ACT_END_OF_FILE 1
106 #define EOB_ACT_LAST_MATCH 2
107
108 /* The funky do-while in the following #define is used to turn the definition
109  * int a single C statement (which needs a semi-colon terminator).  This
110  * avoids problems with code like:
111  *
112  *      if ( condition_holds )
113  *              yyless( 5 );
114  *      else
115  *              do_something_else();
116  *
117  * Prior to using the do-while the compiler would get upset at the
118  * "else" because it interpreted the "if" statement as being all
119  * done when it reached the ';' after the yyless() call.
120  */
121
122 /* Return all but the first 'n' matched characters back to the input stream. */
123
124 #define yyless(n) \
125         do \
126                 { \
127                 /* Undo effects of setting up yytext. */ \
128                 *yy_cp = yy_hold_char; \
129                 YY_RESTORE_YY_MORE_OFFSET \
130                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
131                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
132                 } \
133         while ( 0 )
134
135 #define unput(c) yyunput( c, yytext_ptr )
136
137 /* The following is because we cannot portably get our hands on size_t
138  * (without autoconf's help, which isn't available because we want
139  * flex-generated scanners to compile on their own).
140  */
141 typedef unsigned int yy_size_t;
142
143
144 struct yy_buffer_state
145         {
146         FILE *yy_input_file;
147
148         char *yy_ch_buf;                /* input buffer */
149         char *yy_buf_pos;               /* current position in input buffer */
150
151         /* Size of input buffer in bytes, not including room for EOB
152          * characters.
153          */
154         yy_size_t yy_buf_size;
155
156         /* Number of characters read into yy_ch_buf, not including EOB
157          * characters.
158          */
159         int yy_n_chars;
160
161         /* Whether we "own" the buffer - i.e., we know we created it,
162          * and can realloc() it to grow it, and should free() it to
163          * delete it.
164          */
165         int yy_is_our_buffer;
166
167         /* Whether this is an "interactive" input source; if so, and
168          * if we're using stdio for input, then we want to use getc()
169          * instead of fread(), to make sure we stop fetching input after
170          * each newline.
171          */
172         int yy_is_interactive;
173
174         /* Whether we're considered to be at the beginning of a line.
175          * If so, '^' rules will be active on the next match, otherwise
176          * not.
177          */
178         int yy_at_bol;
179
180         /* Whether to try to fill the input buffer when we reach the
181          * end of it.
182          */
183         int yy_fill_buffer;
184
185         int yy_buffer_status;
186 #define YY_BUFFER_NEW 0
187 #define YY_BUFFER_NORMAL 1
188         /* When an EOF's been seen but there's still some text to process
189          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
190          * shouldn't try reading from the input source any more.  We might
191          * still have a bunch of tokens to match, though, because of
192          * possible backing-up.
193          *
194          * When we actually see the EOF, we change the status to "new"
195          * (via yyrestart()), so that the user can continue scanning by
196          * just pointing yyin at a new input file.
197          */
198 #define YY_BUFFER_EOF_PENDING 2
199         };
200
201 static YY_BUFFER_STATE yy_current_buffer = 0;
202
203 /* We provide macros for accessing buffer states in case in the
204  * future we want to put the buffer states in a more general
205  * "scanner state".
206  */
207 #define YY_CURRENT_BUFFER yy_current_buffer
208
209
210 /* yy_hold_char holds the character lost when yytext is formed. */
211 static char yy_hold_char;
212
213 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
214
215
216 int yyleng;
217
218 /* Points to current character in buffer. */
219 static char *yy_c_buf_p = (char *) 0;
220 static int yy_init = 1;         /* whether we need to initialize */
221 static int yy_start = 0;        /* start state number */
222
223 /* Flag which is used to allow yywrap()'s to do buffer switches
224  * instead of setting up a fresh yyin.  A bit of a hack ...
225  */
226 static int yy_did_buffer_switch_on_eof;
227
228 void yyrestart YY_PROTO(( FILE *input_file ));
229
230 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
231 void yy_load_buffer_state YY_PROTO(( void ));
232 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
233 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
234 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
235 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
236 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
237
238 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
239 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
240 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
241
242 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
243 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
244 static void yy_flex_free YY_PROTO(( void * ));
245
246 #define yy_new_buffer yy_create_buffer
247
248 #define yy_set_interactive(is_interactive) \
249         { \
250         if ( ! yy_current_buffer ) \
251                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
252         yy_current_buffer->yy_is_interactive = is_interactive; \
253         }
254
255 #define yy_set_bol(at_bol) \
256         { \
257         if ( ! yy_current_buffer ) \
258                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
259         yy_current_buffer->yy_at_bol = at_bol; \
260         }
261
262 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
263
264 typedef unsigned char YY_CHAR;
265 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
266 typedef int yy_state_type;
267 extern char *yytext;
268 #define yytext_ptr yytext
269
270 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
271 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
272 static int yy_get_next_buffer YY_PROTO(( void ));
273 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
274
275 /* Done after the current pattern has been matched and before the
276  * corresponding action - sets up yytext.
277  */
278 #define YY_DO_BEFORE_ACTION \
279         yytext_ptr = yy_bp; \
280         yyleng = (int) (yy_cp - yy_bp); \
281         yy_hold_char = *yy_cp; \
282         *yy_cp = '\0'; \
283         yy_c_buf_p = yy_cp;
284
285 #define YY_NUM_RULES 16
286 #define YY_END_OF_BUFFER 17
287 static yyconst short int yy_accept[102] =
288     {   0,
289         0,    0,   17,   15,   13,   14,   15,   15,   15,    9,
290         8,    4,    4,   13,    0,   11,    0,    0,    0,    6,
291         5,    9,    0,    0,    9,    9,    0,    8,    8,    8,
292         4,    4,    0,    0,   12,    0,    0,    0,    6,    5,
293         0,    5,    0,    7,    9,    9,   10,    8,    8,    4,
294         0,    0,    0,    0,    0,    6,    0,    5,    7,   10,
295        10,    4,    4,    0,    0,    0,    0,   10,   10,    4,
296         4,    0,    0,    4,    4,    4,    4,    4,    4,    4,
297         4,    4,    4,    4,    4,    4,    4,    4,    3,    4,
298         4,    4,    4,    4,    4,    4,    4,    4,    2,    1,
299
300         0
301     } ;
302
303 static yyconst int yy_ec[256] =
304     {   0,
305         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
306         1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
307         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
308         1,    2,    1,    4,    1,    1,    1,    1,    5,    1,
309         1,    1,    6,    1,    6,    7,    1,    8,    9,   10,
310        10,   10,   10,   10,   10,   11,   11,    1,    1,    1,
311         1,    1,   12,    1,   13,   13,   14,   15,   16,   17,
312        18,   18,   19,   18,   18,   20,   18,   18,   18,   21,
313        18,   18,   22,   18,   23,   18,   18,   24,   18,   18,
314         1,   25,    1,    1,   18,    1,   26,   27,   28,   13,
315
316        29,   30,   18,   18,   31,   18,   32,   33,   34,   35,
317        36,   37,   18,   38,   18,   39,   23,   40,   18,   24,
318        18,   18,    1,    1,    1,    1,    1,    1,    1,    1,
319         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
320         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
321         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
322         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
323         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
324         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
325         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
326
327         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
328         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
329         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
330         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
331         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
332         1,    1,    1,    1,    1
333     } ;
334
335 static yyconst int yy_meta[41] =
336     {   0,
337         1,    1,    2,    3,    4,    1,    1,    5,    5,    5,
338         6,    4,    6,    6,    6,    6,    6,    7,    7,    7,
339         7,    7,    7,    8,    4,    5,    5,    6,    6,    5,
340         7,    7,    7,    7,    8,    7,    7,    8,    8,    8
341     } ;
342
343 static yyconst short int yy_base[111] =
344     {   0,
345         0,   25,  207,  412,  204,  412,   13,  179,   10,   44,
346        71,    0,  166,  199,   18,  412,   32,   19,   37,   97,
347       123,  176,  150,   87,  168,   29,    0,    0,  165,   37,
348         0,  153,  111,    0,  412,  137,    0,  159,  412,    0,
349       165,  412,   75,  172,  412,  412,   43,  412,  412,   50,
350       186,  208,  189,  235,  101,  258,  114,  284,  412,  163,
351        38,  156,  149,  112,  310,  124,  333,  412,  412,  150,
352       137,  125,  138,  139,  128,  129,  122,  113,  122,  115,
353       111,   53,  102,   82,   72,   73,   70,   65,    0,   57,
354        53,   50,   55,   43,   30,   10,    6,    4,    0,    0,
355
356       412,  363,  371,  379,  383,  390,  397,  401,  403,  405
357     } ;
358
359 static yyconst short int yy_def[111] =
360     {   0,
361       102,  102,  101,  101,  101,  101,  103,  104,  101,  101,
362       101,  105,  105,  101,  103,  101,  106,  104,  107,  101,
363       101,   10,  101,  101,  101,  101,  108,   11,  101,  101,
364       105,  105,  103,  109,  101,  104,  110,  101,  101,   21,
365       101,  101,  101,  101,  101,  101,  108,  101,  101,  105,
366       103,  103,  104,  104,  101,  101,  101,  101,  101,  101,
367       101,  105,  105,  103,   52,  104,   54,  101,  101,  105,
368       105,  103,  104,  105,  105,  105,  105,  105,  105,  105,
369       105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
370       105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
371
372         0,  101,  101,  101,  101,  101,  101,  101,  101,  101
373     } ;
374
375 static yyconst short int yy_nxt[453] =
376     {   0,
377         4,    5,    6,    7,    8,    4,    9,   10,   11,   11,
378        11,    4,  100,   13,   99,  101,   16,   20,   20,   20,
379        20,   16,   35,  101,    4,    4,    5,    6,    7,    8,
380         4,    9,   10,   11,   11,   11,    4,   17,   13,   33,
381        33,   33,   17,   19,   36,   36,   36,   98,   46,    4,
382        21,   22,   22,   22,   23,   34,   49,   69,   97,   24,
383        37,   46,   60,   25,   62,   61,   26,   27,   63,   49,
384        69,   96,   24,   84,   85,   60,   25,   21,   28,   28,
385        28,   28,   44,   44,   44,   44,   24,   95,   94,   93,
386        29,   92,   43,   30,   44,   44,   44,   44,   91,   24,
387
388        90,   89,   88,   29,   20,   20,   20,   20,   56,   56,
389        56,   56,   38,   39,   16,   16,   39,   87,   51,   51,
390        51,   58,   58,   58,   58,   38,   39,   35,   16,   39,
391        40,   40,   40,   40,   86,   17,   17,   83,   41,   42,
392        35,   35,   42,   82,   53,   53,   53,   81,   19,   17,
393        80,   41,   42,   79,   78,   42,   21,   23,   23,   23,
394        23,   19,   19,   77,   55,   24,   56,   56,   56,   56,
395        57,   76,   58,   58,   58,   58,   75,   74,   24,   44,
396        44,   44,   44,   71,   70,   68,   50,   48,   59,   16,
397        45,   59,   35,   64,   64,   64,   66,   66,   66,  101,
398
399        14,   59,   32,   19,   59,   14,  101,  101,  101,  101,
400        17,   16,  101,   19,  101,   65,   65,   65,   65,  101,
401        65,   65,   65,   65,   65,  101,  101,  101,  101,  101,
402       101,  101,   17,   65,   65,   65,   65,   65,   35,  101,
403       101,  101,   67,   67,   67,   67,  101,   67,   67,   67,
404        67,   67,  101,  101,  101,  101,  101,  101,  101,   19,
405        67,   67,   67,   67,   67,   56,   56,   56,   56,  101,
406       101,  101,  101,  101,   39,  101,  101,   39,  101,  101,
407       101,  101,  101,  101,  101,  101,  101,   39,  101,  101,
408        39,   58,   58,   58,   58,  101,  101,  101,  101,  101,
409
410        42,  101,  101,   42,  101,  101,  101,  101,  101,  101,
411       101,  101,  101,   42,  101,  101,   42,   72,   72,   72,
412        72,  101,   72,   72,   72,   72,   72,  101,  101,  101,
413       101,  101,  101,  101,  101,   72,   72,   72,   72,   72,
414        73,   73,   73,   73,  101,   73,   73,   73,   73,   73,
415       101,  101,  101,  101,  101,  101,  101,  101,   73,   73,
416        73,   73,   73,   12,   12,   12,   12,   12,   12,   12,
417        12,   15,  101,   15,   15,   15,   15,   15,   15,   18,
418       101,  101,   18,   18,   18,   18,   18,   31,   31,   31,
419        31,   15,   15,   15,   15,  101,  101,   15,   18,   18,
420
421        18,   18,  101,  101,   18,   47,   47,   52,   52,   54,
422        54,    3,  101,  101,  101,  101,  101,  101,  101,  101,
423       101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
424       101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
425       101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
426       101,  101
427     } ;
428
429 static yyconst short int yy_chk[453] =
430     {   0,
431         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
432         1,    1,   98,    1,   97,    0,    7,    9,    9,    9,
433         9,   15,   18,    0,    1,    2,    2,    2,    2,    2,
434         2,    2,    2,    2,    2,    2,    2,    7,    2,   17,
435        17,   17,   15,   18,   19,   19,   19,   96,   26,    2,
436        10,   10,   10,   10,   10,   17,   30,   61,   95,   10,
437        19,   26,   47,   10,   50,   47,   10,   10,   50,   30,
438        61,   94,   10,   82,   82,   47,   10,   11,   11,   11,
439        11,   11,   43,   43,   43,   43,   11,   93,   92,   91,
440        11,   90,   24,   11,   24,   24,   24,   24,   88,   11,
441
442        87,   86,   85,   11,   20,   20,   20,   20,   55,   55,
443        55,   55,   20,   20,   33,   64,   20,   84,   33,   33,
444        33,   57,   57,   57,   57,   20,   20,   66,   72,   20,
445        21,   21,   21,   21,   83,   33,   64,   81,   21,   21,
446        36,   73,   21,   80,   36,   36,   36,   79,   66,   72,
447        78,   21,   21,   77,   76,   21,   23,   23,   23,   23,
448        23,   36,   73,   75,   38,   23,   38,   38,   38,   38,
449        41,   74,   41,   41,   41,   41,   71,   70,   23,   44,
450        44,   44,   44,   63,   62,   60,   32,   29,   44,   51,
451        25,   44,   53,   51,   51,   51,   53,   53,   53,   22,
452
453        14,   44,   13,    8,   44,    5,    3,    0,    0,    0,
454        51,   52,    0,   53,    0,   52,   52,   52,   52,    0,
455        52,   52,   52,   52,   52,    0,    0,    0,    0,    0,
456         0,    0,   52,   52,   52,   52,   52,   52,   54,    0,
457         0,    0,   54,   54,   54,   54,    0,   54,   54,   54,
458        54,   54,    0,    0,    0,    0,    0,    0,    0,   54,
459        54,   54,   54,   54,   54,   56,   56,   56,   56,    0,
460         0,    0,    0,    0,   56,    0,    0,   56,    0,    0,
461         0,    0,    0,    0,    0,    0,    0,   56,    0,    0,
462        56,   58,   58,   58,   58,    0,    0,    0,    0,    0,
463
464        58,    0,    0,   58,    0,    0,    0,    0,    0,    0,
465         0,    0,    0,   58,    0,    0,   58,   65,   65,   65,
466        65,    0,   65,   65,   65,   65,   65,    0,    0,    0,
467         0,    0,    0,    0,    0,   65,   65,   65,   65,   65,
468        67,   67,   67,   67,    0,   67,   67,   67,   67,   67,
469         0,    0,    0,    0,    0,    0,    0,    0,   67,   67,
470        67,   67,   67,  102,  102,  102,  102,  102,  102,  102,
471       102,  103,    0,  103,  103,  103,  103,  103,  103,  104,
472         0,    0,  104,  104,  104,  104,  104,  105,  105,  105,
473       105,  106,  106,  106,  106,    0,    0,  106,  107,  107,
474
475       107,  107,    0,    0,  107,  108,  108,  109,  109,  110,
476       110,  101,  101,  101,  101,  101,  101,  101,  101,  101,
477       101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
478       101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
479       101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
480       101,  101
481     } ;
482
483 static yy_state_type yy_last_accepting_state;
484 static char *yy_last_accepting_cpos;
485
486 /* The intent behind this definition is that it'll catch
487  * any uses of REJECT which flex missed.
488  */
489 #define REJECT reject_used_but_not_detected
490 #define yymore() yymore_used_but_not_detected
491 #define YY_MORE_ADJ 0
492 #define YY_RESTORE_YY_MORE_OFFSET
493 char *yytext;
494 #line 1 "conv-cpm.flex"
495 #define INITIAL 0
496 #line 2 "conv-cpm.flex"
497 #include <stdio.h>
498 #include <string.h>
499 int tok_lineno = 0;
500 int yytoktype;
501
502 /******************************************************************************
503  *
504  * Files
505  *
506  *****************************************************************************/
507
508 FILE *file_src;
509 FILE *file_cpm;
510
511 /******************************************************************************
512  *
513  * Lexical Analyzer
514  *
515  *****************************************************************************/
516 #line 517 "lex.yy.c"
517
518 /* Macros after this point can all be overridden by user definitions in
519  * section 1.
520  */
521
522 #ifndef YY_SKIP_YYWRAP
523 #ifdef __cplusplus
524 extern "C" int yywrap YY_PROTO(( void ));
525 #else
526 extern int yywrap YY_PROTO(( void ));
527 #endif
528 #endif
529
530 #ifndef YY_NO_UNPUT
531 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
532 #endif
533
534 #ifndef yytext_ptr
535 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
536 #endif
537
538 #ifdef YY_NEED_STRLEN
539 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
540 #endif
541
542 #ifndef YY_NO_INPUT
543 #ifdef __cplusplus
544 static int yyinput YY_PROTO(( void ));
545 #else
546 static int input YY_PROTO(( void ));
547 #endif
548 #endif
549
550 #if YY_STACK_USED
551 static int yy_start_stack_ptr = 0;
552 static int yy_start_stack_depth = 0;
553 static int *yy_start_stack = 0;
554 #ifndef YY_NO_PUSH_STATE
555 static void yy_push_state YY_PROTO(( int new_state ));
556 #endif
557 #ifndef YY_NO_POP_STATE
558 static void yy_pop_state YY_PROTO(( void ));
559 #endif
560 #ifndef YY_NO_TOP_STATE
561 static int yy_top_state YY_PROTO(( void ));
562 #endif
563
564 #else
565 #define YY_NO_PUSH_STATE 1
566 #define YY_NO_POP_STATE 1
567 #define YY_NO_TOP_STATE 1
568 #endif
569
570 #ifdef YY_MALLOC_DECL
571 YY_MALLOC_DECL
572 #else
573 #if __STDC__
574 #ifndef __cplusplus
575 #include <stdlib.h>
576 #endif
577 #else
578 /* Just try to get by without declaring the routines.  This will fail
579  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
580  * or sizeof(void*) != sizeof(int).
581  */
582 #endif
583 #endif
584
585 /* Amount of stuff to slurp up with each read. */
586 #ifndef YY_READ_BUF_SIZE
587 #define YY_READ_BUF_SIZE 8192
588 #endif
589
590 /* Copy whatever the last rule matched to the standard output. */
591
592 #ifndef ECHO
593 /* This used to be an fputs(), but since the string might contain NUL's,
594  * we now use fwrite().
595  */
596 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
597 #endif
598
599 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
600  * is returned in "result".
601  */
602 #ifndef YY_INPUT
603 #define YY_INPUT(buf,result,max_size) \
604         if ( yy_current_buffer->yy_is_interactive ) \
605                 { \
606                 int c = '*', n; \
607                 for ( n = 0; n < max_size && \
608                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
609                         buf[n] = (char) c; \
610                 if ( c == '\n' ) \
611                         buf[n++] = (char) c; \
612                 if ( c == EOF && ferror( yyin ) ) \
613                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
614                 result = n; \
615                 } \
616         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
617                   && ferror( yyin ) ) \
618                 YY_FATAL_ERROR( "input in flex scanner failed" );
619 #endif
620
621 /* No semi-colon after return; correct usage is to write "yyterminate();" -
622  * we don't want an extra ';' after the "return" because that will cause
623  * some compilers to complain about unreachable statements.
624  */
625 #ifndef yyterminate
626 #define yyterminate() return YY_NULL
627 #endif
628
629 /* Number of entries by which start-condition stack grows. */
630 #ifndef YY_START_STACK_INCR
631 #define YY_START_STACK_INCR 25
632 #endif
633
634 /* Report a fatal error. */
635 #ifndef YY_FATAL_ERROR
636 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
637 #endif
638
639 /* Default declaration of generated scanner - a define so the user can
640  * easily add parameters.
641  */
642 #ifndef YY_DECL
643 #define YY_DECL int yylex YY_PROTO(( void ))
644 #endif
645
646 /* Code executed at the beginning of each rule, after yytext and yyleng
647  * have been set up.
648  */
649 #ifndef YY_USER_ACTION
650 #define YY_USER_ACTION
651 #endif
652
653 /* Code executed at the end of each rule. */
654 #ifndef YY_BREAK
655 #define YY_BREAK break;
656 #endif
657
658 #define YY_RULE_SETUP \
659         YY_USER_ACTION
660
661 YY_DECL
662         {
663         register yy_state_type yy_current_state;
664         register char *yy_cp, *yy_bp;
665         register int yy_act;
666
667 #line 32 "conv-cpm.flex"
668
669
670 #line 671 "lex.yy.c"
671
672         if ( yy_init )
673                 {
674                 yy_init = 0;
675
676 #ifdef YY_USER_INIT
677                 YY_USER_INIT;
678 #endif
679
680                 if ( ! yy_start )
681                         yy_start = 1;   /* first start state */
682
683                 if ( ! yyin )
684                         yyin = stdin;
685
686                 if ( ! yyout )
687                         yyout = stdout;
688
689                 if ( ! yy_current_buffer )
690                         yy_current_buffer =
691                                 yy_create_buffer( yyin, YY_BUF_SIZE );
692
693                 yy_load_buffer_state();
694                 }
695
696         while ( 1 )             /* loops until end-of-file is reached */
697                 {
698                 yy_cp = yy_c_buf_p;
699
700                 /* Support of yytext. */
701                 *yy_cp = yy_hold_char;
702
703                 /* yy_bp points to the position in yy_ch_buf of the start of
704                  * the current run.
705                  */
706                 yy_bp = yy_cp;
707
708                 yy_current_state = yy_start;
709 yy_match:
710                 do
711                         {
712                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
713                         if ( yy_accept[yy_current_state] )
714                                 {
715                                 yy_last_accepting_state = yy_current_state;
716                                 yy_last_accepting_cpos = yy_cp;
717                                 }
718                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
719                                 {
720                                 yy_current_state = (int) yy_def[yy_current_state];
721                                 if ( yy_current_state >= 102 )
722                                         yy_c = yy_meta[(unsigned int) yy_c];
723                                 }
724                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
725                         ++yy_cp;
726                         }
727                 while ( yy_base[yy_current_state] != 412 );
728
729 yy_find_action:
730                 yy_act = yy_accept[yy_current_state];
731                 if ( yy_act == 0 )
732                         { /* have to back up */
733                         yy_cp = yy_last_accepting_cpos;
734                         yy_current_state = yy_last_accepting_state;
735                         yy_act = yy_accept[yy_current_state];
736                         }
737
738                 YY_DO_BEFORE_ACTION;
739
740
741 do_action:      /* This label is used only to access EOF actions. */
742
743
744                 switch ( yy_act )
745         { /* beginning of action switch */
746                         case 0: /* must back up */
747                         /* undo the effects of YY_DO_BEFORE_ACTION */
748                         *yy_cp = yy_hold_char;
749                         yy_cp = yy_last_accepting_cpos;
750                         yy_current_state = yy_last_accepting_state;
751                         goto yy_find_action;
752
753 case 1:
754 YY_RULE_SETUP
755 #line 34 "conv-cpm.flex"
756 { return 'P'; }
757         YY_BREAK
758 case 2:
759 YY_RULE_SETUP
760 #line 35 "conv-cpm.flex"
761 { return 'S'; }
762         YY_BREAK
763 case 3:
764 YY_RULE_SETUP
765 #line 36 "conv-cpm.flex"
766 { return 'I'; }
767         YY_BREAK
768 case 4:
769 YY_RULE_SETUP
770 #line 37 "conv-cpm.flex"
771 { return 'i'; }
772         YY_BREAK
773 case 5:
774 YY_RULE_SETUP
775 #line 38 "conv-cpm.flex"
776 { return '0'; }
777         YY_BREAK
778 case 6:
779 YY_RULE_SETUP
780 #line 39 "conv-cpm.flex"
781 { return '0'; }
782         YY_BREAK
783 case 7:
784 YY_RULE_SETUP
785 #line 40 "conv-cpm.flex"
786 { return '0'; }
787         YY_BREAK
788 case 8:
789 YY_RULE_SETUP
790 #line 41 "conv-cpm.flex"
791 { return '0'; }
792         YY_BREAK
793 case 9:
794 YY_RULE_SETUP
795 #line 42 "conv-cpm.flex"
796 { return '0'; }
797         YY_BREAK
798 case 10:
799 YY_RULE_SETUP
800 #line 43 "conv-cpm.flex"
801 { return '0'; }
802         YY_BREAK
803 case 11:
804 YY_RULE_SETUP
805 #line 44 "conv-cpm.flex"
806 { return '"'; }
807         YY_BREAK
808 case 12:
809 YY_RULE_SETUP
810 #line 45 "conv-cpm.flex"
811 { return 'c'; }
812         YY_BREAK
813 case 13:
814 YY_RULE_SETUP
815 #line 46 "conv-cpm.flex"
816 { }
817         YY_BREAK
818 case 14:
819 YY_RULE_SETUP
820 #line 47 "conv-cpm.flex"
821 { tok_lineno++; }
822         YY_BREAK
823 case 15:
824 YY_RULE_SETUP
825 #line 48 "conv-cpm.flex"
826 { return yytext[0]; }
827         YY_BREAK
828 case 16:
829 YY_RULE_SETUP
830 #line 50 "conv-cpm.flex"
831 ECHO;
832         YY_BREAK
833 #line 834 "lex.yy.c"
834 case YY_STATE_EOF(INITIAL):
835         yyterminate();
836
837         case YY_END_OF_BUFFER:
838                 {
839                 /* Amount of text matched not including the EOB char. */
840                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
841
842                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
843                 *yy_cp = yy_hold_char;
844                 YY_RESTORE_YY_MORE_OFFSET
845
846                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
847                         {
848                         /* We're scanning a new file or input source.  It's
849                          * possible that this happened because the user
850                          * just pointed yyin at a new source and called
851                          * yylex().  If so, then we have to assure
852                          * consistency between yy_current_buffer and our
853                          * globals.  Here is the right place to do so, because
854                          * this is the first action (other than possibly a
855                          * back-up) that will match for the new input source.
856                          */
857                         yy_n_chars = yy_current_buffer->yy_n_chars;
858                         yy_current_buffer->yy_input_file = yyin;
859                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
860                         }
861
862                 /* Note that here we test for yy_c_buf_p "<=" to the position
863                  * of the first EOB in the buffer, since yy_c_buf_p will
864                  * already have been incremented past the NUL character
865                  * (since all states make transitions on EOB to the
866                  * end-of-buffer state).  Contrast this with the test
867                  * in input().
868                  */
869                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
870                         { /* This was really a NUL. */
871                         yy_state_type yy_next_state;
872
873                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
874
875                         yy_current_state = yy_get_previous_state();
876
877                         /* Okay, we're now positioned to make the NUL
878                          * transition.  We couldn't have
879                          * yy_get_previous_state() go ahead and do it
880                          * for us because it doesn't know how to deal
881                          * with the possibility of jamming (and we don't
882                          * want to build jamming into it because then it
883                          * will run more slowly).
884                          */
885
886                         yy_next_state = yy_try_NUL_trans( yy_current_state );
887
888                         yy_bp = yytext_ptr + YY_MORE_ADJ;
889
890                         if ( yy_next_state )
891                                 {
892                                 /* Consume the NUL. */
893                                 yy_cp = ++yy_c_buf_p;
894                                 yy_current_state = yy_next_state;
895                                 goto yy_match;
896                                 }
897
898                         else
899                                 {
900                                 yy_cp = yy_c_buf_p;
901                                 goto yy_find_action;
902                                 }
903                         }
904
905                 else switch ( yy_get_next_buffer() )
906                         {
907                         case EOB_ACT_END_OF_FILE:
908                                 {
909                                 yy_did_buffer_switch_on_eof = 0;
910
911                                 if ( yywrap() )
912                                         {
913                                         /* Note: because we've taken care in
914                                          * yy_get_next_buffer() to have set up
915                                          * yytext, we can now set up
916                                          * yy_c_buf_p so that if some total
917                                          * hoser (like flex itself) wants to
918                                          * call the scanner after we return the
919                                          * YY_NULL, it'll still work - another
920                                          * YY_NULL will get returned.
921                                          */
922                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
923
924                                         yy_act = YY_STATE_EOF(YY_START);
925                                         goto do_action;
926                                         }
927
928                                 else
929                                         {
930                                         if ( ! yy_did_buffer_switch_on_eof )
931                                                 YY_NEW_FILE;
932                                         }
933                                 break;
934                                 }
935
936                         case EOB_ACT_CONTINUE_SCAN:
937                                 yy_c_buf_p =
938                                         yytext_ptr + yy_amount_of_matched_text;
939
940                                 yy_current_state = yy_get_previous_state();
941
942                                 yy_cp = yy_c_buf_p;
943                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
944                                 goto yy_match;
945
946                         case EOB_ACT_LAST_MATCH:
947                                 yy_c_buf_p =
948                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
949
950                                 yy_current_state = yy_get_previous_state();
951
952                                 yy_cp = yy_c_buf_p;
953                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
954                                 goto yy_find_action;
955                         }
956                 break;
957                 }
958
959         default:
960                 YY_FATAL_ERROR(
961                         "fatal flex scanner internal error--no action found" );
962         } /* end of action switch */
963                 } /* end of scanning one token */
964         } /* end of yylex */
965
966
967 /* yy_get_next_buffer - try to read in a new buffer
968  *
969  * Returns a code representing an action:
970  *      EOB_ACT_LAST_MATCH -
971  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
972  *      EOB_ACT_END_OF_FILE - end of file
973  */
974
975 static int yy_get_next_buffer()
976         {
977         register char *dest = yy_current_buffer->yy_ch_buf;
978         register char *source = yytext_ptr;
979         register int number_to_move, i;
980         int ret_val;
981
982         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
983                 YY_FATAL_ERROR(
984                 "fatal flex scanner internal error--end of buffer missed" );
985
986         if ( yy_current_buffer->yy_fill_buffer == 0 )
987                 { /* Don't try to fill the buffer, so this is an EOF. */
988                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
989                         {
990                         /* We matched a single character, the EOB, so
991                          * treat this as a final EOF.
992                          */
993                         return EOB_ACT_END_OF_FILE;
994                         }
995
996                 else
997                         {
998                         /* We matched some text prior to the EOB, first
999                          * process it.
1000                          */
1001                         return EOB_ACT_LAST_MATCH;
1002                         }
1003                 }
1004
1005         /* Try to read more data. */
1006
1007         /* First move last chars to start of buffer. */
1008         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1009
1010         for ( i = 0; i < number_to_move; ++i )
1011                 *(dest++) = *(source++);
1012
1013         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1014                 /* don't do the read, it's not guaranteed to return an EOF,
1015                  * just force an EOF
1016                  */
1017                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1018
1019         else
1020                 {
1021                 int num_to_read =
1022                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1023
1024                 while ( num_to_read <= 0 )
1025                         { /* Not enough room in the buffer - grow it. */
1026 #ifdef YY_USES_REJECT
1027                         YY_FATAL_ERROR(
1028 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1029 #else
1030
1031                         /* just a shorter name for the current buffer */
1032                         YY_BUFFER_STATE b = yy_current_buffer;
1033
1034                         int yy_c_buf_p_offset =
1035                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1036
1037                         if ( b->yy_is_our_buffer )
1038                                 {
1039                                 int new_size = b->yy_buf_size * 2;
1040
1041                                 if ( new_size <= 0 )
1042                                         b->yy_buf_size += b->yy_buf_size / 8;
1043                                 else
1044                                         b->yy_buf_size *= 2;
1045
1046                                 b->yy_ch_buf = (char *)
1047                                         /* Include room in for 2 EOB chars. */
1048                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1049                                                          b->yy_buf_size + 2 );
1050                                 }
1051                         else
1052                                 /* Can't grow it, we don't own it. */
1053                                 b->yy_ch_buf = 0;
1054
1055                         if ( ! b->yy_ch_buf )
1056                                 YY_FATAL_ERROR(
1057                                 "fatal error - scanner input buffer overflow" );
1058
1059                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1060
1061                         num_to_read = yy_current_buffer->yy_buf_size -
1062                                                 number_to_move - 1;
1063 #endif
1064                         }
1065
1066                 if ( num_to_read > YY_READ_BUF_SIZE )
1067                         num_to_read = YY_READ_BUF_SIZE;
1068
1069                 /* Read in more data. */
1070                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1071                         yy_n_chars, num_to_read );
1072
1073                 yy_current_buffer->yy_n_chars = yy_n_chars;
1074                 }
1075
1076         if ( yy_n_chars == 0 )
1077                 {
1078                 if ( number_to_move == YY_MORE_ADJ )
1079                         {
1080                         ret_val = EOB_ACT_END_OF_FILE;
1081                         yyrestart( yyin );
1082                         }
1083
1084                 else
1085                         {
1086                         ret_val = EOB_ACT_LAST_MATCH;
1087                         yy_current_buffer->yy_buffer_status =
1088                                 YY_BUFFER_EOF_PENDING;
1089                         }
1090                 }
1091
1092         else
1093                 ret_val = EOB_ACT_CONTINUE_SCAN;
1094
1095         yy_n_chars += number_to_move;
1096         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1097         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1098
1099         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1100
1101         return ret_val;
1102         }
1103
1104
1105 /* yy_get_previous_state - get the state just before the EOB char was reached */
1106
1107 static yy_state_type yy_get_previous_state()
1108         {
1109         register yy_state_type yy_current_state;
1110         register char *yy_cp;
1111
1112         yy_current_state = yy_start;
1113
1114         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1115                 {
1116                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1117                 if ( yy_accept[yy_current_state] )
1118                         {
1119                         yy_last_accepting_state = yy_current_state;
1120                         yy_last_accepting_cpos = yy_cp;
1121                         }
1122                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1123                         {
1124                         yy_current_state = (int) yy_def[yy_current_state];
1125                         if ( yy_current_state >= 102 )
1126                                 yy_c = yy_meta[(unsigned int) yy_c];
1127                         }
1128                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1129                 }
1130
1131         return yy_current_state;
1132         }
1133
1134
1135 /* yy_try_NUL_trans - try to make a transition on the NUL character
1136  *
1137  * synopsis
1138  *      next_state = yy_try_NUL_trans( current_state );
1139  */
1140
1141 #ifdef YY_USE_PROTOS
1142 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1143 #else
1144 static yy_state_type yy_try_NUL_trans( yy_current_state )
1145 yy_state_type yy_current_state;
1146 #endif
1147         {
1148         register int yy_is_jam;
1149         register char *yy_cp = yy_c_buf_p;
1150
1151         register YY_CHAR yy_c = 1;
1152         if ( yy_accept[yy_current_state] )
1153                 {
1154                 yy_last_accepting_state = yy_current_state;
1155                 yy_last_accepting_cpos = yy_cp;
1156                 }
1157         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1158                 {
1159                 yy_current_state = (int) yy_def[yy_current_state];
1160                 if ( yy_current_state >= 102 )
1161                         yy_c = yy_meta[(unsigned int) yy_c];
1162                 }
1163         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1164         yy_is_jam = (yy_current_state == 101);
1165
1166         return yy_is_jam ? 0 : yy_current_state;
1167         }
1168
1169
1170 #ifndef YY_NO_UNPUT
1171 #ifdef YY_USE_PROTOS
1172 static void yyunput( int c, register char *yy_bp )
1173 #else
1174 static void yyunput( c, yy_bp )
1175 int c;
1176 register char *yy_bp;
1177 #endif
1178         {
1179         register char *yy_cp = yy_c_buf_p;
1180
1181         /* undo effects of setting up yytext */
1182         *yy_cp = yy_hold_char;
1183
1184         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1185                 { /* need to shift things up to make room */
1186                 /* +2 for EOB chars. */
1187                 register int number_to_move = yy_n_chars + 2;
1188                 register char *dest = &yy_current_buffer->yy_ch_buf[
1189                                         yy_current_buffer->yy_buf_size + 2];
1190                 register char *source =
1191                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1192
1193                 while ( source > yy_current_buffer->yy_ch_buf )
1194                         *--dest = *--source;
1195
1196                 yy_cp += (int) (dest - source);
1197                 yy_bp += (int) (dest - source);
1198                 yy_current_buffer->yy_n_chars =
1199                         yy_n_chars = yy_current_buffer->yy_buf_size;
1200
1201                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1202                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1203                 }
1204
1205         *--yy_cp = (char) c;
1206
1207
1208         yytext_ptr = yy_bp;
1209         yy_hold_char = *yy_cp;
1210         yy_c_buf_p = yy_cp;
1211         }
1212 #endif  /* ifndef YY_NO_UNPUT */
1213
1214
1215 #ifdef __cplusplus
1216 static int yyinput()
1217 #else
1218 static int input()
1219 #endif
1220         {
1221         int c;
1222
1223         *yy_c_buf_p = yy_hold_char;
1224
1225         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1226                 {
1227                 /* yy_c_buf_p now points to the character we want to return.
1228                  * If this occurs *before* the EOB characters, then it's a
1229                  * valid NUL; if not, then we've hit the end of the buffer.
1230                  */
1231                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1232                         /* This was really a NUL. */
1233                         *yy_c_buf_p = '\0';
1234
1235                 else
1236                         { /* need more input */
1237                         int offset = yy_c_buf_p - yytext_ptr;
1238                         ++yy_c_buf_p;
1239
1240                         switch ( yy_get_next_buffer() )
1241                                 {
1242                                 case EOB_ACT_LAST_MATCH:
1243                                         /* This happens because yy_g_n_b()
1244                                          * sees that we've accumulated a
1245                                          * token and flags that we need to
1246                                          * try matching the token before
1247                                          * proceeding.  But for input(),
1248                                          * there's no matching to consider.
1249                                          * So convert the EOB_ACT_LAST_MATCH
1250                                          * to EOB_ACT_END_OF_FILE.
1251                                          */
1252
1253                                         /* Reset buffer status. */
1254                                         yyrestart( yyin );
1255
1256                                         /* fall through */
1257
1258                                 case EOB_ACT_END_OF_FILE:
1259                                         {
1260                                         if ( yywrap() )
1261                                                 return EOF;
1262
1263                                         if ( ! yy_did_buffer_switch_on_eof )
1264                                                 YY_NEW_FILE;
1265 #ifdef __cplusplus
1266                                         return yyinput();
1267 #else
1268                                         return input();
1269 #endif
1270                                         }
1271
1272                                 case EOB_ACT_CONTINUE_SCAN:
1273                                         yy_c_buf_p = yytext_ptr + offset;
1274                                         break;
1275                                 }
1276                         }
1277                 }
1278
1279         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1280         *yy_c_buf_p = '\0';     /* preserve yytext */
1281         yy_hold_char = *++yy_c_buf_p;
1282
1283
1284         return c;
1285         }
1286
1287
1288 #ifdef YY_USE_PROTOS
1289 void yyrestart( FILE *input_file )
1290 #else
1291 void yyrestart( input_file )
1292 FILE *input_file;
1293 #endif
1294         {
1295         if ( ! yy_current_buffer )
1296                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1297
1298         yy_init_buffer( yy_current_buffer, input_file );
1299         yy_load_buffer_state();
1300         }
1301
1302
1303 #ifdef YY_USE_PROTOS
1304 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1305 #else
1306 void yy_switch_to_buffer( new_buffer )
1307 YY_BUFFER_STATE new_buffer;
1308 #endif
1309         {
1310         if ( yy_current_buffer == new_buffer )
1311                 return;
1312
1313         if ( yy_current_buffer )
1314                 {
1315                 /* Flush out information for old buffer. */
1316                 *yy_c_buf_p = yy_hold_char;
1317                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1318                 yy_current_buffer->yy_n_chars = yy_n_chars;
1319                 }
1320
1321         yy_current_buffer = new_buffer;
1322         yy_load_buffer_state();
1323
1324         /* We don't actually know whether we did this switch during
1325          * EOF (yywrap()) processing, but the only time this flag
1326          * is looked at is after yywrap() is called, so it's safe
1327          * to go ahead and always set it.
1328          */
1329         yy_did_buffer_switch_on_eof = 1;
1330         }
1331
1332
1333 #ifdef YY_USE_PROTOS
1334 void yy_load_buffer_state( void )
1335 #else
1336 void yy_load_buffer_state()
1337 #endif
1338         {
1339         yy_n_chars = yy_current_buffer->yy_n_chars;
1340         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1341         yyin = yy_current_buffer->yy_input_file;
1342         yy_hold_char = *yy_c_buf_p;
1343         }
1344
1345
1346 #ifdef YY_USE_PROTOS
1347 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1348 #else
1349 YY_BUFFER_STATE yy_create_buffer( file, size )
1350 FILE *file;
1351 int size;
1352 #endif
1353         {
1354         YY_BUFFER_STATE b;
1355
1356         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1357         if ( ! b )
1358                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1359
1360         b->yy_buf_size = size;
1361
1362         /* yy_ch_buf has to be 2 characters longer than the size given because
1363          * we need to put in 2 end-of-buffer characters.
1364          */
1365         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1366         if ( ! b->yy_ch_buf )
1367                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1368
1369         b->yy_is_our_buffer = 1;
1370
1371         yy_init_buffer( b, file );
1372
1373         return b;
1374         }
1375
1376
1377 #ifdef YY_USE_PROTOS
1378 void yy_delete_buffer( YY_BUFFER_STATE b )
1379 #else
1380 void yy_delete_buffer( b )
1381 YY_BUFFER_STATE b;
1382 #endif
1383         {
1384         if ( ! b )
1385                 return;
1386
1387         if ( b == yy_current_buffer )
1388                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1389
1390         if ( b->yy_is_our_buffer )
1391                 yy_flex_free( (void *) b->yy_ch_buf );
1392
1393         yy_flex_free( (void *) b );
1394         }
1395
1396
1397 #ifndef YY_ALWAYS_INTERACTIVE
1398 #ifndef YY_NEVER_INTERACTIVE
1399 extern int isatty YY_PROTO(( int ));
1400 #endif
1401 #endif
1402
1403 #ifdef YY_USE_PROTOS
1404 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1405 #else
1406 void yy_init_buffer( b, file )
1407 YY_BUFFER_STATE b;
1408 FILE *file;
1409 #endif
1410
1411
1412         {
1413         yy_flush_buffer( b );
1414
1415         b->yy_input_file = file;
1416         b->yy_fill_buffer = 1;
1417
1418 #if YY_ALWAYS_INTERACTIVE
1419         b->yy_is_interactive = 1;
1420 #else
1421 #if YY_NEVER_INTERACTIVE
1422         b->yy_is_interactive = 0;
1423 #else
1424         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1425 #endif
1426 #endif
1427         }
1428
1429
1430 #ifdef YY_USE_PROTOS
1431 void yy_flush_buffer( YY_BUFFER_STATE b )
1432 #else
1433 void yy_flush_buffer( b )
1434 YY_BUFFER_STATE b;
1435 #endif
1436
1437         {
1438         if ( ! b )
1439                 return;
1440
1441         b->yy_n_chars = 0;
1442
1443         /* We always need two end-of-buffer characters.  The first causes
1444          * a transition to the end-of-buffer state.  The second causes
1445          * a jam in that state.
1446          */
1447         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1448         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1449
1450         b->yy_buf_pos = &b->yy_ch_buf[0];
1451
1452         b->yy_at_bol = 1;
1453         b->yy_buffer_status = YY_BUFFER_NEW;
1454
1455         if ( b == yy_current_buffer )
1456                 yy_load_buffer_state();
1457         }
1458
1459
1460 #ifndef YY_NO_SCAN_BUFFER
1461 #ifdef YY_USE_PROTOS
1462 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1463 #else
1464 YY_BUFFER_STATE yy_scan_buffer( base, size )
1465 char *base;
1466 yy_size_t size;
1467 #endif
1468         {
1469         YY_BUFFER_STATE b;
1470
1471         if ( size < 2 ||
1472              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1473              base[size-1] != YY_END_OF_BUFFER_CHAR )
1474                 /* They forgot to leave room for the EOB's. */
1475                 return 0;
1476
1477         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1478         if ( ! b )
1479                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1480
1481         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1482         b->yy_buf_pos = b->yy_ch_buf = base;
1483         b->yy_is_our_buffer = 0;
1484         b->yy_input_file = 0;
1485         b->yy_n_chars = b->yy_buf_size;
1486         b->yy_is_interactive = 0;
1487         b->yy_at_bol = 1;
1488         b->yy_fill_buffer = 0;
1489         b->yy_buffer_status = YY_BUFFER_NEW;
1490
1491         yy_switch_to_buffer( b );
1492
1493         return b;
1494         }
1495 #endif
1496
1497
1498 #ifndef YY_NO_SCAN_STRING
1499 #ifdef YY_USE_PROTOS
1500 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1501 #else
1502 YY_BUFFER_STATE yy_scan_string( yy_str )
1503 yyconst char *yy_str;
1504 #endif
1505         {
1506         int len;
1507         for ( len = 0; yy_str[len]; ++len )
1508                 ;
1509
1510         return yy_scan_bytes( yy_str, len );
1511         }
1512 #endif
1513
1514
1515 #ifndef YY_NO_SCAN_BYTES
1516 #ifdef YY_USE_PROTOS
1517 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1518 #else
1519 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1520 yyconst char *bytes;
1521 int len;
1522 #endif
1523         {
1524         YY_BUFFER_STATE b;
1525         char *buf;
1526         yy_size_t n;
1527         int i;
1528
1529         /* Get memory for full buffer, including space for trailing EOB's. */
1530         n = len + 2;
1531         buf = (char *) yy_flex_alloc( n );
1532         if ( ! buf )
1533                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1534
1535         for ( i = 0; i < len; ++i )
1536                 buf[i] = bytes[i];
1537
1538         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1539
1540         b = yy_scan_buffer( buf, n );
1541         if ( ! b )
1542                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1543
1544         /* It's okay to grow etc. this buffer, and we should throw it
1545          * away when we're done.
1546          */
1547         b->yy_is_our_buffer = 1;
1548
1549         return b;
1550         }
1551 #endif
1552
1553
1554 #ifndef YY_NO_PUSH_STATE
1555 #ifdef YY_USE_PROTOS
1556 static void yy_push_state( int new_state )
1557 #else
1558 static void yy_push_state( new_state )
1559 int new_state;
1560 #endif
1561         {
1562         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1563                 {
1564                 yy_size_t new_size;
1565
1566                 yy_start_stack_depth += YY_START_STACK_INCR;
1567                 new_size = yy_start_stack_depth * sizeof( int );
1568
1569                 if ( ! yy_start_stack )
1570                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1571
1572                 else
1573                         yy_start_stack = (int *) yy_flex_realloc(
1574                                         (void *) yy_start_stack, new_size );
1575
1576                 if ( ! yy_start_stack )
1577                         YY_FATAL_ERROR(
1578                         "out of memory expanding start-condition stack" );
1579                 }
1580
1581         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1582
1583         BEGIN(new_state);
1584         }
1585 #endif
1586
1587
1588 #ifndef YY_NO_POP_STATE
1589 static void yy_pop_state()
1590         {
1591         if ( --yy_start_stack_ptr < 0 )
1592                 YY_FATAL_ERROR( "start-condition stack underflow" );
1593
1594         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1595         }
1596 #endif
1597
1598
1599 #ifndef YY_NO_TOP_STATE
1600 static int yy_top_state()
1601         {
1602         return yy_start_stack[yy_start_stack_ptr - 1];
1603         }
1604 #endif
1605
1606 #ifndef YY_EXIT_FAILURE
1607 #define YY_EXIT_FAILURE 2
1608 #endif
1609
1610 #ifdef YY_USE_PROTOS
1611 static void yy_fatal_error( yyconst char msg[] )
1612 #else
1613 static void yy_fatal_error( msg )
1614 char msg[];
1615 #endif
1616         {
1617         (void) fprintf( stderr, "%s\n", msg );
1618         exit( YY_EXIT_FAILURE );
1619         }
1620
1621
1622
1623 /* Redefine yyless() so it works in section 3 code. */
1624
1625 #undef yyless
1626 #define yyless(n) \
1627         do \
1628                 { \
1629                 /* Undo effects of setting up yytext. */ \
1630                 yytext[yyleng] = yy_hold_char; \
1631                 yy_c_buf_p = yytext + n; \
1632                 yy_hold_char = *yy_c_buf_p; \
1633                 *yy_c_buf_p = '\0'; \
1634                 yyleng = n; \
1635                 } \
1636         while ( 0 )
1637
1638
1639 /* Internal utility routines. */
1640
1641 #ifndef yytext_ptr
1642 #ifdef YY_USE_PROTOS
1643 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1644 #else
1645 static void yy_flex_strncpy( s1, s2, n )
1646 char *s1;
1647 yyconst char *s2;
1648 int n;
1649 #endif
1650         {
1651         register int i;
1652         for ( i = 0; i < n; ++i )
1653                 s1[i] = s2[i];
1654         }
1655 #endif
1656
1657 #ifdef YY_NEED_STRLEN
1658 #ifdef YY_USE_PROTOS
1659 static int yy_flex_strlen( yyconst char *s )
1660 #else
1661 static int yy_flex_strlen( s )
1662 yyconst char *s;
1663 #endif
1664         {
1665         register int n;
1666         for ( n = 0; s[n]; ++n )
1667                 ;
1668
1669         return n;
1670         }
1671 #endif
1672
1673
1674 #ifdef YY_USE_PROTOS
1675 static void *yy_flex_alloc( yy_size_t size )
1676 #else
1677 static void *yy_flex_alloc( size )
1678 yy_size_t size;
1679 #endif
1680         {
1681         return (void *) malloc( size );
1682         }
1683
1684 #ifdef YY_USE_PROTOS
1685 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1686 #else
1687 static void *yy_flex_realloc( ptr, size )
1688 void *ptr;
1689 yy_size_t size;
1690 #endif
1691         {
1692         /* The cast to (char *) in the following accommodates both
1693          * implementations that use char* generic pointers, and those
1694          * that use void* generic pointers.  It works with the latter
1695          * because both ANSI C and C++ allow castless assignment from
1696          * any pointer type to void*, and deal with argument conversions
1697          * as though doing an assignment.
1698          */
1699         return (void *) realloc( (char *) ptr, size );
1700         }
1701
1702 #ifdef YY_USE_PROTOS
1703 static void yy_flex_free( void *ptr )
1704 #else
1705 static void yy_flex_free( ptr )
1706 void *ptr;
1707 #endif
1708         {
1709         free( ptr );
1710         }
1711
1712 #if YY_MAIN
1713 int main()
1714         {
1715         yylex();
1716         return 0;
1717         }
1718 #endif
1719 #line 50 "conv-cpm.flex"
1720
1721
1722
1723 #ifdef yywrap
1724 #undef yywrap
1725 #endif
1726 yywrap(){ return(1); }
1727
1728 void yytokget()
1729 {
1730   yytoktype=yylex();
1731 }
1732
1733 void yychkword(char *s)
1734 {
1735   if (strcmp(yytext, s)) {
1736     fprintf(stderr,"%s expected\n", s);
1737     exit(1);
1738   }
1739 }
1740
1741 void yychktype(char c)
1742 {
1743   if (yytoktype == c) return;
1744   if (c=='i') {
1745     fprintf(stderr,"identifier expected\n");
1746     exit(1);
1747   } else {
1748     fprintf(stderr,"%c expected\n",c);
1749     exit(1);
1750   }
1751 }
1752
1753 /******************************************************************************
1754  *
1755  * The 'symbol table', such as it is.
1756  *
1757  *****************************************************************************/
1758
1759 char *mod_funcs[1000];
1760 int   mod_len;
1761
1762 char *type_name[1000];
1763 int   type_kind[1000];
1764 int   type_count;
1765
1766 char *func_name;
1767 char *func_args[1000];
1768 int   func_array[1000];
1769 int   func_pointer[1000];
1770 int   func_len;
1771 int   func_static;
1772
1773 int type_simple(char *type)
1774 {
1775   int i;
1776   for (i=0; i<type_count; i++) {
1777     if (strcmp(type, type_name[i])==0)
1778       return (type_kind[i]=='S') ? 1:0;
1779   }
1780   fprintf(stderr,"Unknown type %s\n", type);
1781   exit(1);
1782 }
1783
1784 void type_declare(char *type, int kind)
1785 {
1786   if (type_count==1000) {
1787     fprintf(stderr,"error: type table overflow.\n");
1788     exit(1);
1789   }
1790   type_name[type_count] = strdup(type);
1791   type_kind[type_count] = kind;
1792   type_count++;
1793 }
1794
1795 /******************************************************************************
1796  *
1797  * Code Generation
1798  *
1799  *****************************************************************************/
1800
1801 void gen_actual_args(FILE *f)
1802 {
1803   int i;
1804   fprintf(f, "(");
1805   if (func_len) {
1806     fprintf(f, "CpmA0");
1807     for (i=1; i<func_len; i++) {
1808       fprintf(f, ",CpmA%d", i);
1809     }
1810   }
1811   fprintf(f,");\n");
1812 }
1813
1814 void gen_dimension_required()
1815 {
1816   fprintf(stderr,"CpmDim required before array.\n");
1817   exit(1);
1818 }
1819
1820 void gen_func_struct()
1821 {
1822   int i;
1823   fprintf(file_cpm, "struct CpmSt_%s\n", func_name);
1824   fprintf(file_cpm, "{\n");
1825   fprintf(file_cpm, "char convcore[CmiMsgHeaderSizeBytes];\n");
1826   fprintf(file_cpm, "unsigned int envpos;\n");
1827   for (i=0; i<func_len; i++) {
1828     if ((func_pointer[i]==0) && (func_array[i]==0)) {
1829       fprintf(file_cpm, "%s f%d;\n",func_args[i],i);
1830     } else {
1831       fprintf(file_cpm, "int f%d;\n",i);
1832     }
1833   }
1834   fprintf(file_cpm, "};\n");
1835 }
1836
1837 void gen_func_recv()
1838 {
1839   int i;
1840   fprintf(file_cpm, "static void CpmRecv_%s(char *CpmM)\n", func_name);
1841   fprintf(file_cpm, "{\n");
1842   fprintf(file_cpm, "struct CpmSt_%s *CpmS=(struct CpmSt_%s *)CpmM;\n",
1843           func_name, func_name);
1844   fprintf(file_cpm, "char *CpmX = (char *)CpmS;\n");
1845   fprintf(file_cpm, "int i;\n");
1846   for (i=0; i<func_len; i++) {
1847     fprintf(file_cpm, "%s %sCpmA%d;\n", func_args[i], func_array[i]?"*":"", i);
1848   }
1849   for (i=0; i<func_len; i++) {
1850     int mode = (func_pointer[i] ? 2 : 0) + (func_array[i] ? 1 : 0);
1851     switch(mode) {
1852     case 0: /* simple */
1853       fprintf(file_cpm, "CpmA%d = CpmS->f%d;\n", i, i);
1854       fprintf(file_cpm, "CpmUnpack_%s(CpmA%d);\n", func_args[i], i);
1855       break;
1856     case 1: /* array of simple */
1857       if ((i==0)||(func_array[i-1])||(strcmp(func_args[i-1],"CpmDim")))
1858         gen_dimension_required();
1859       fprintf(file_cpm, "CpmA%d = (%s *)(CpmX+(CpmS->f%d));\n", i, func_args[i], i);
1860       fprintf(file_cpm, "for (i=0; i<CpmA%d; i++)\n", i-1);
1861       fprintf(file_cpm, "  CpmUnpack_%s(CpmA%d[i]);\n", func_args[i], i);
1862       break;
1863     case 2: /* pointer */
1864       fprintf(file_cpm, "CpmA%d = (%s)(CpmX+(CpmS->f%d));\n", i, func_args[i], i);
1865       fprintf(file_cpm, "CpmPtrUnpack_%s(CpmA%d);\n", func_args[i], i);
1866       break;
1867     case 3: /* array of pointer */
1868       if ((i==0)||(func_array[i-1])||(strcmp(func_args[i-1],"CpmDim")))
1869         gen_dimension_required();
1870       fprintf(file_cpm, "CpmA%d = (%s *)(CpmX+(CpmS->f%d));\n", i, func_args[i], i);
1871       fprintf(file_cpm, "for (i=0; i<CpmA%d; i++) {\n", i-1);
1872       fprintf(file_cpm, "  CpmA%d[i] = CpmM + (unsigned int)(CpmA%d[i]);\n", i, i);
1873       fprintf(file_cpm, "  CpmPtrUnpack_%s(CpmA%d[i]);\n", func_args[i], i);
1874       fprintf(file_cpm, "}\n");
1875       break;
1876     }
1877   }
1878   fprintf(file_cpm,"%s", func_name);
1879   gen_actual_args(file_cpm);
1880   fprintf(file_cpm, "}\n");
1881 }
1882
1883 void gen_func_send()
1884 {
1885   int i;
1886   if (func_static) fprintf(file_cpm, "static ");
1887
1888   fprintf(file_cpm,"void *Cpm_%s(CpmDestination ctrl",func_name);
1889   for (i=0; i<func_len; i++) {
1890     fprintf(file_cpm, ",%s %sa%d", func_args[i], func_array[i]?"*":"", i);
1891   }
1892   fprintf(file_cpm, ")\n");
1893   fprintf(file_cpm, "{\n");
1894   fprintf(file_cpm, "struct CpmSt_%s *msg;\n",func_name);
1895   fprintf(file_cpm, "char *data; int size, i, envpos; void *result;\n");
1896   fprintf(file_cpm, "int offs = CpmAlign(sizeof(struct CpmSt_%s), double);\n",func_name);
1897   for (i=0; i<func_len; i++) {
1898     if (func_array[i])
1899       fprintf(file_cpm, "int aoffs%d;\n",i);
1900     if (func_pointer[i]) {
1901       if (func_array[i]) {
1902         fprintf(file_cpm, "size_t *poffs%d = (size_t *)malloc(a%d*sizeof(size_t));\n",i,i-1);
1903       } else {
1904         fprintf(file_cpm, "int poffs%d;\n",i);
1905       }
1906     }
1907   }
1908   fprintf(file_cpm, "envpos=offs; offs=CpmAlign(offs+(ctrl->envsize),double);\n");
1909   for (i=0; i<func_len; i++) {
1910     if (func_array[i]) {
1911       fprintf(file_cpm, "size=a%d*sizeof(%s);\n",i-1,func_args[i]);
1912       fprintf(file_cpm, "aoffs%d=offs; offs=CpmAlign(offs+size,double);\n",i);
1913     }
1914   }
1915   for (i=0; i<func_len; i++) {
1916     if (func_pointer[i]) {
1917       if (func_array[i]) {
1918         fprintf(file_cpm, "for (i=0; i<a%d; i++) {\n",i-1) ;
1919         fprintf(file_cpm, "  size = CpmPtrSize_%s(a%d[i]);\n",func_args[i],i);
1920         fprintf(file_cpm, "  poffs%d[i]=offs; offs=CpmAlign(offs+size,double);\n",i);
1921         fprintf(file_cpm, "}\n");
1922       } else {
1923         fprintf(file_cpm, "size = CpmPtrSize_%s(a%d);\n",func_args[i],i);
1924         fprintf(file_cpm, "poffs%d=offs; offs=CpmAlign(offs+size, double);\n",i);
1925       }
1926     }
1927   }
1928   fprintf(file_cpm, "data = (char *)CmiAlloc(offs);\n");
1929   fprintf(file_cpm, "msg = (struct CpmSt_%s *)data;\n",func_name);
1930   fprintf(file_cpm, "msg->envpos = envpos;\n");
1931   for (i=0; i<func_len; i++) {
1932     int mode = (func_array[i]?2:0) | (func_pointer[i]?1:0);
1933     switch(mode) {
1934     case 0: /* one simple */
1935       fprintf(file_cpm, "CpmPack_%s(a%d);\n",func_args[i],i);
1936       fprintf(file_cpm, "msg->f%d = a%d;\n",i,i);
1937       break;
1938     case 1: /* one pointer */
1939       fprintf(file_cpm, "msg->f%d = poffs%d;\n",i,i);
1940       fprintf(file_cpm, "CpmPtrPack_%s(((%s)(data+poffs%d)), a%d);\n",
1941               func_args[i],func_args[i],i,i);
1942       break;
1943     case 2: /* array simple */
1944       fprintf(file_cpm, "msg->f%d = aoffs%d;\n",i,i);
1945       fprintf(file_cpm, "memcpy(data+aoffs%d, a%d, a%d*sizeof(%s));\n",
1946               i,i,i-1,func_args[i]);
1947       fprintf(file_cpm, "for(i=0; i<a%d; i++)\n",i-1);
1948       fprintf(file_cpm, "  CpmPack_%s(((%s *)(data+aoffs%d))[i]);\n",
1949               func_args[i],func_args[i],i);
1950       break;
1951     case 3: /* array pointer */
1952       fprintf(file_cpm, "msg->f%d = aoffs%d;\n",i,i);
1953       fprintf(file_cpm, "memcpy(data+aoffs%d, poffs%d, a%d*sizeof(size_t));\n",
1954               i,i,i-1);
1955       fprintf(file_cpm, "for(i=0; i<a%d; i++)\n",i-1);
1956       fprintf(file_cpm, "  CpmPtrPack_%s(((%s)(data+(poffs%d[i]))), a%d[i]);\n",
1957               func_args[i],func_args[i], i,i);
1958       break;
1959     }
1960   }
1961   fprintf(file_cpm,"CmiSetHandler(msg, CpvAccess(CpmIndex_%s));\n",func_name);
1962   fprintf(file_cpm,"result = (ctrl->sendfn)(ctrl, offs, msg);\n");
1963   for (i=0; i<func_len; i++)
1964     if ((func_pointer[i])&&(func_array[i]))
1965       fprintf(file_cpm, "free(poffs%d);\n", i);
1966   fprintf(file_cpm,"return result;\n");
1967   fprintf(file_cpm,"}\n");
1968 }
1969
1970 void gen_func_protos()
1971 {
1972   int i;
1973
1974   fprintf(file_cpm, "CpvStaticDeclare(int, CpmIndex_%s);\n", func_name);
1975
1976   fprintf(file_cpm,"void %s(",func_name);
1977   if (func_len) {
1978     fprintf(file_cpm, "%s %s", func_args[0], func_array[0]?"*":"");
1979     for (i=1; i<func_len; i++)
1980       fprintf(file_cpm, ",%s %s", func_args[i], func_array[i]?"*":"");
1981   }
1982   fprintf(file_cpm,");\n");
1983 }
1984
1985 void gen_func_c()
1986 {
1987   gen_func_protos();
1988   gen_func_struct();
1989   gen_func_recv();
1990   gen_func_send();
1991 }
1992
1993 void gen_mod_head()
1994 {
1995   fprintf(file_cpm, "CpvStaticDeclare(int, CpmIPRIO);\n");
1996 }
1997
1998 void gen_mod_tail()
1999 {
2000   int i;
2001   fprintf(file_cpm, "static void CpmInitializeThisModule()\n");
2002   fprintf(file_cpm, "{\n");
2003   fprintf(file_cpm, "CpvInitialize(int, CpmIPRIO);\n");
2004   for (i=0; i<mod_len; i++) {
2005     fprintf(file_cpm, "CpvInitialize(int, CpmIndex_%s);\n", mod_funcs[i]);
2006     fprintf(file_cpm, "CpvAccess(CpmIndex_%s) = CmiRegisterHandler(CpmRecv_%s);\n",
2007           mod_funcs[i], mod_funcs[i]);
2008   }
2009   fprintf(file_cpm, "}\n");
2010 }
2011
2012 /******************************************************************************
2013  *
2014  * The Parser
2015  *
2016  *****************************************************************************/
2017
2018 void parse_type()
2019 {
2020   int kind = yytoktype;
2021   yytokget();
2022   if (strncmp(yytext,"CpmType_",8)==0) {
2023     type_declare(yytext+8, kind);
2024   }
2025   yytokget();
2026 }
2027
2028 void parse_list()
2029 {
2030   int level=1;
2031   yychktype('{');
2032   yytokget();
2033   while (level) {
2034     if (yytoktype == '{') level++;
2035     if (yytoktype == '}') level--;
2036     if (yytoktype==0) return;
2037     yytokget();
2038   }
2039 }
2040
2041 void parse_func()
2042 {
2043   yychkword("CpmInvokable");
2044   yytokget();
2045   if (yytoktype==';')
2046     return;
2047   func_len=0;
2048   func_static=0;
2049   if (strcmp(yytext,"static")==0) {
2050     func_static=1;
2051     yytokget();
2052   }
2053   yychktype('i');
2054   func_name = strdup(yytext);
2055   yytokget();
2056   yychktype('(');
2057   yytokget();
2058   if (yytoktype != ')') {
2059     while (1) {
2060       yychktype('i');
2061       func_args[func_len] = strdup(yytext);
2062       func_array[func_len] = 0;
2063       yytokget();
2064       if (yytoktype == '*') {
2065         yytokget();
2066         func_array[func_len] = 1;
2067       }
2068       func_pointer[func_len] = !type_simple(func_args[func_len]);
2069       func_len++;
2070       yychktype('i');
2071       yytokget();
2072       if (yytoktype == ')') break;
2073       yychktype(',');
2074       yytokget();
2075     }
2076   }
2077   yytokget();
2078   mod_funcs[mod_len++] = func_name;
2079   gen_func_c();
2080 }
2081
2082 void parse_all()
2083 {  
2084   yyin = file_src;
2085   yytokget();
2086   gen_mod_head();
2087   top:
2088   switch (yytoktype) {
2089   case 0: break;
2090   case 'P': parse_type(); goto top;
2091   case 'S': parse_type(); goto top;
2092   case 'I': parse_func(); goto top;
2093   case '{': parse_list(); goto top;
2094   default: yytokget(); goto top; 
2095   }
2096   gen_mod_tail();
2097 }
2098
2099 /******************************************************************************
2100  *
2101  * Setup
2102  *
2103  *****************************************************************************/
2104
2105 void usage()
2106 {
2107   fprintf(stderr,"usage: cpm <modulename>\n");
2108   exit(1);
2109 }
2110
2111 FILE *fopen_nofail(char *path, char *mode)
2112 {
2113   FILE *res = fopen(path, mode);
2114   if (res==0) {
2115     fprintf(stderr,"Couldn't open %s with mode %s\n",path,mode);
2116     exit(1);
2117   }
2118   return res;
2119 }
2120
2121 void disclaim(FILE *f, char *src)
2122 {
2123   fprintf(f,"/* WARNING: This file generated by Converse */\n");
2124   fprintf(f,"/* Marshalling System from source-file %s. */\n",src);
2125   fprintf(f,"\n");
2126 }
2127
2128 main(int argc, char **argv)
2129 {
2130   int i; char *tail;
2131   if (argc != 3) usage();
2132   file_src = fopen_nofail(argv[1], "r");
2133   file_cpm = fopen_nofail(argv[2], "w");
2134   disclaim(file_cpm, argv[1]);
2135   parse_all();
2136   exit(0);
2137 }