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