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