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