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