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