1 // New PGN parser by by HGM. I was dissatisfied with the old flex-generated parser for several reasons:
2 // 1) It required flex to build
3 // 2) It was not possible to use variant-dependent syntax, which gave trouble for '+' as Sogi promoChar vs check symbol
4 // 3) It could not handle double-digit rank numbers
5 // 4) It could not handle PSN moves, with (alpha rank and file digit)
6 // 5) Having more than 12 ranks would require extension of the rules anyway
7 // 6) It was cumbersome to maintain, which much code duplication that had to be kept in sync when changing something
8 // 7) It needed special handling for packaging, because we wanted to include parser.c for people who had no flex
9 // 8) It was quite large because of the table-driven flex algorithm.
10 // This new parser suffers from none of that. It might even accomodate traditional Xiangqi notation at some future time.
23 extern Board boards[MAX_MOVES];
24 extern int PosFlags(int nr);
26 int yyskipmoves = FALSE;
27 char currentMoveString[4096]; // a bit ridiculous size?
30 #define PARSEBUFSIZE 10000
32 static FILE *inputFile;
33 static char *inPtr, *parsePtr, *parseStart;
34 static char inputBuf[PARSEBUFSIZE];
35 static char yytext[PARSEBUFSIZE];
36 static char fromString = 0, lastChar = '\n';
41 #define BADNUMBER (-2000000000)
44 { // Read one line from the input file, and append to the buffer
45 char c, *start = inPtr;
46 if(fromString) return 0; // parsing string, so the end is a hard end
47 if(!inputFile) return 0;
48 while((c = fgetc(inputFile)) != EOF) {
50 if(c == '\n') { *inPtr = NULLCHAR; return 1; }
51 if(inPtr - inputBuf > PARSEBUFSIZE-2) inPtr--; //prevent crash on overflow
53 if(inPtr == start) return 0;
54 *inPtr++ = '\n', *inPtr = NULLCHAR; // repair missing linefeed at EOF
58 int Scan(char c, char **p)
59 { // line-spanning skip to mentioned character or EOF
61 while(**p) if(*(*p)++ == c) return 0;
63 // no closing bracket; force match for entire rest of file.
67 int SkipWhite(char **p)
68 { // skip spaces tabs and newlines; return 1 if anything was skipped
71 while(**p == ' ' || **p == '\t' || **p == '\n' || **p == '\r') (*p)++;
72 } while(**p == NULLCHAR && ReadLine()); // continue as long as ReadLine reads something
76 inline int Match(char *pattern, char **ptr)
78 char *p = pattern, *s = *ptr;
79 while(*p && (*p == *s++ || s[-1] == '\r' && *p--)) p++;
84 return 0; // no match, no ptr update
87 inline int Word(char *pattern, char **p)
89 if(Match(pattern, p)) return 1;
90 if(*pattern >= 'a' && *pattern <= 'z' && *pattern - **p == 'a' - 'A') { // capitalized
92 if(Match(pattern + 1, p)) return 1;
98 int Verb(char *pattern, char **p)
100 int res = Word(pattern, p);
101 if(res && !Match("s", p)) Match("ed", p); // eat conjugation suffix, if any
109 if(**p < '0' || **p > '9') return BADNUMBER;
110 while(**p >= '0' && **p <= '9') {
111 val = 10*val + *(*p)++ - '0';
116 int RdTime(char c, char **p)
118 char *start = ++(*p), *sec; // increment *p, as it was pointing to the opening ( or {
119 if(Number(p) == BADNUMBER) return 0;
121 if(Match(":", p) && Number(p) != BADNUMBER && *p - sec == 3) { // well formed
123 if(Match(".", p) && Number(p) != BADNUMBER && *(*p)++ == c) return 1; // well-formed fraction
125 if(*(*p)++ == c) return 1; // matching bracket without fraction
127 *p = start; // failure
131 char PromoSuffix(char **p)
134 if(**p == 'e' && (Match("ep", p) || Match("e.p.", p))) { *p = start; return NULLCHAR; } // non-compliant e.p. suffix is no promoChar!
135 if(**p == '+' && gameInfo.variant == VariantShogi) { (*p)++; return '+'; }
136 if(**p == '=') (*p)++; //optional =
137 if(**p == '(' && (*p)[2] == ')' && isalpha( (*p)[1] )) { (*p) += 3; return (*p)[-2]; }
138 if(isalpha(**p)) return *(*p)++;
139 if(*p != start) return '='; // must be the optional =
140 return NULLCHAR; // no suffix detected
143 int NextUnit(char **p)
144 { // Main parser routine
145 int coord[4], n, result, piece, i;
146 char type[4], promoted, separator, slash, *oldp, *commentEnd, c;
147 int wom = WhiteOnMove(yyboardindex);
149 // ********* try white first, because it is so common **************************
150 if(**p == ' ' || **p == '\n' || **p == '\t') { parseStart = (*p)++; return Nothing; }
153 if(**p == NULLCHAR) { // make sure there is something to parse
154 if(fromString) return 0; // we are parsing string, so the end is really the end
155 *p = inPtr = inputBuf;
156 if(!ReadLine()) return 0; // EOF
158 parseStart = oldp = *p; // remember where we begin
161 // ********* attempt to recognize a SAN move in the leading non-blank text *****
162 piece = separator = promoted = slash = n = 0;
163 for(i=0; i<4; i++) coord[i] = -1, type[i] = NOTHING;
164 if(**p == '+') (*p)++, promoted++;
165 if(**p >= 'a' && **p <= 'z' && (*p)[1]== '@') piece =*(*p)++ + 'A' - 'a'; else
166 if(**p >= 'A' && **p <= 'Z') {
167 piece = *(*p)++; // Note we could test for 2-byte non-ascii names here
168 if(**p == '/') slash = *(*p)++;
171 if(**p >= 'a' && **p < 'x') coord[n] = *(*p)++ - 'a', type[n++] = ALPHABETIC;
172 else if((i = Number(p)) != BADNUMBER) coord[n] = i, type[n++] = NUMERIC;
174 if(n == 2 && type[0] == type[1]) { // if two identical types, the opposite type in between must have been missing
175 type[2] = type[1]; coord[2] = coord[1];
176 type[1] = NOTHING; coord[1] = -1; n++;
179 // we always get here, and might have read a +, a piece, and upto 4 potential coordinates
180 if(n <= 2) { // could be from-square or disambiguator, when -:xX follow, or drop with @ directly after piece, but also to-square
181 if(**p == '-' || **p == ':' || **p == 'x' || **p == 'X' || // these cannot be move suffix, so to-square must follow
182 (**p == '@' || **p == '*') && n == 0 && !promoted && piece) { // P@ must also be followed by to-square
184 if(n == 1) coord[1] = coord[0]; // must be disambiguator, but we do not know which yet
186 while(n < 4) { // attempt to read to-square
187 if(**p >= 'a' && **p < 'x') coord[n] = *(*p)++ - 'a', type[n++] = ALPHABETIC;
188 else if((i = Number(p)) != BADNUMBER) coord[n] = i, type[n++] = NUMERIC;
191 } else if((**p == '+' || **p == '=') && n == 1 && piece && type[0] == NUMERIC) { // can be traditional Xiangqi notation
194 if((i = Number(p)) != BADNUMBER) coord[n] = i, type[n++] = NUMERIC;
195 } else if(n == 2) { // only one square mentioned, must be to-square
196 while(n < 4) { coord[n] = coord[n-2], type[n] = type[n-2], coord[n-2] = -1, type[n-2] = NOTHING; n++; }
198 } else if(n == 3 && type[1] != NOTHING) { // must be hyphenless disambiguator + to-square
199 for(i=3; i>0; i--) coord[i] = coord[i-1], type[i] = type[i-1]; // move to-square to where it belongs
200 type[1] = NOTHING; // disambiguator goes in first two positions
203 if(appData.debugMode)fprintf(debugFP, "trial %d,%d,%d,%d type %d%d%d%d\n", coord[0], coord[1], coord[2], coord[3], type[0], type[1], type[2], type[3]);
204 // we always get here; move must be completely read now, with to-square coord(s) at end
205 if(n == 3) { // incomplete to-square. Could be Xiangqi traditional, or stuff like fxg
206 if(piece && type[1] == NOTHING && type[0] == NUMERIC && type[2] == NUMERIC &&
207 (separator == '+' || separator == '=' || separator == '-')) {
208 // Xiangqi traditional
210 return ImpossibleMove; // for now treat as invalid
212 // fxg stuff, but also things like 0-0, 0-1 and 1-0
213 if(!piece && type[1] == NOTHING && type[0] == ALPHABETIC && type[2] == ALPHABETIC
214 && (coord[0] != 14 || coord[2] != 14) /* reserve oo for castling! */ ) {
215 piece = 'P'; n = 4; // kludge alert: fake full to-square
217 } else if(n == 1 && type[0] == NUMERIC && coord[0] > 1) { while(**p == '.') (*p)++; return Nothing; } // fast exit for move numbers
218 if(n == 4 && type[2] != type[3] && // we have a valid to-square (kludge: type[3] can be NOTHING on fxg type move)
219 (piece || !promoted) && // promoted indicator only valid on named piece type
220 (type[2] == ALPHABETIC || gameInfo.variant == VariantShogi)) { // in Shogi also allow alphabetic rank
221 DisambiguateClosure cl;
222 int fromX, fromY, toX, toY;
224 if(slash && (!piece || type[1] == NOTHING)) goto badMove; // slash after piece only in ICS long format
225 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
227 if(type[2] == NUMERIC) { // alpha-rank
228 coord[2] = BOARD_RGHT - BOARD_LEFT - coord[2];
229 coord[3] = BOARD_HEIGHT - coord[3];
230 if(coord[0] >= 0) coord[0] = BOARD_RGHT - BOARD_LEFT - coord[0];
231 if(coord[1] >= 0) coord[1] = BOARD_HEIGHT - coord[1];
233 toX = cl.ftIn = (currentMoveString[2] = coord[2] + 'a') - AAA;
234 toY = cl.rtIn = (currentMoveString[3] = coord[3] + '0') - ONE;
235 if(type[3] == NOTHING) cl.rtIn = -1; // for fxg type moves ask for toY disambiguation
236 else if(toY >= BOARD_HEIGHT || toY < 0) return ImpossibleMove; // vert off-board to-square
237 if(toX < BOARD_LEFT || toX >= BOARD_RGHT) return ImpossibleMove;
239 cl.pieceIn = CharToPiece(wom ? piece : ToLower(piece));
240 if(cl.pieceIn == EmptySquare) return ImpossibleMove; // non-existent piece
241 if(promoted) cl.pieceIn = (ChessSquare) (PROMOTED cl.pieceIn);
242 } else cl.pieceIn = EmptySquare;
243 if(separator == '@' || separator == '*') { // drop move. We only get here without from-square or promoted piece
244 fromY = DROP_RANK; fromX = cl.pieceIn;
245 currentMoveString[0] = piece;
246 currentMoveString[1] = '@';
247 return LegalityTest(boards[yyboardindex], PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, fromY, fromX, toY, toX, NULLCHAR);
249 if(type[1] == NOTHING && type[0] != NOTHING) { // there is a disambiguator
250 if(type[0] != type[2]) coord[0] = -1, type[1] = type[0], type[0] = NOTHING; // it was a rank-disambiguator
252 if( type[1] != type[2] && // means fromY is of opposite type as ToX, or NOTHING
253 (type[0] == NOTHING || type[0] == type[2]) ) { // well formed
255 fromX = (currentMoveString[0] = coord[0] + 'a') - AAA;
256 fromY = (currentMoveString[1] = coord[1] + '0') - ONE;
257 currentMoveString[4] = cl.promoCharIn = PromoSuffix(p);
258 currentMoveString[5] = NULLCHAR;
259 if(type[0] != NOTHING && type[1] != NOTHING && type[3] != NOTHING) { // fully specified.
260 // Note that Disambiguate does not work for illegal moves, but flags them as impossible
261 if(piece) { // check if correct piece indicated
262 ChessSquare realPiece = boards[yyboardindex][fromY][fromX];
263 if(PieceToChar(realPiece) == '~') realPiece = (ChessSquare) (DEMOTED realPiece);
264 if(!(appData.icsActive && PieceToChar(realPiece) == '+') && // trust ICS if it moves promoted pieces
265 piece && realPiece != cl.pieceIn) return ImpossibleMove;
267 result = LegalityTest(boards[yyboardindex], PosFlags(yyboardindex), fromY, fromX, toY, toX, cl.promoCharIn);
268 if (currentMoveString[4] == NULLCHAR) { // suppy missing mandatory promotion character
269 if(result == WhitePromotion || result == BlackPromotion) {
270 switch(gameInfo.variant) {
272 case VariantShatranj: currentMoveString[4] = PieceToChar(BlackFerz); break;
273 case VariantGreat: currentMoveString[4] = PieceToChar(BlackMan); break;
274 case VariantShogi: currentMoveString[4] = '+'; break;
275 default: currentMoveString[4] = PieceToChar(BlackQueen);
277 } else if(result == WhiteNonPromotion || result == BlackNonPromotion) {
278 currentMoveString[4] = '=';
280 } else if(appData.testLegality && gameInfo.variant != VariantSChess && // strip off unnecessary and false promo characters
281 !(result == WhitePromotion || result == BlackPromotion ||
282 result == WhiteNonPromotion || result == BlackNonPromotion)) currentMoveString[4] = NULLCHAR;
284 } else if(cl.pieceIn == EmptySquare) cl.pieceIn = wom ? WhitePawn : BlackPawn;
285 cl.ffIn = type[0] == NOTHING ? -1 : coord[0] + 'a' - AAA;
286 cl.rfIn = type[1] == NOTHING ? -1 : coord[1] + '0' - ONE;
288 Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);
290 if(cl.kind == ImpossibleMove && !piece && type[1] == NOTHING // fxg5 type
291 && toY == (wom ? 4 : 3)) { // could be improperly written e.p.
292 cl.rtIn += wom ? 1 : -1; // shift target square to e.p. square
293 Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);
294 if((cl.kind != WhiteCapturesEnPassant && cl.kind != BlackCapturesEnPassant))
295 return ImpossibleMove; // nice try, but no cigar
298 currentMoveString[0] = cl.ff + AAA;
299 currentMoveString[1] = cl.rf + ONE;
300 currentMoveString[3] = cl.rt + ONE;
301 currentMoveString[4] = cl.promoChar;
303 if((cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) && (Match("ep", p) || Match("e.p.", p)));
305 return (int) cl.kind;
308 badMove:// we failed to find algebraic move
312 // Next we do some common symbols where the first character commits us to things that cannot possibly be a move
314 // ********* PGN tags ******************************************
317 if(Match("--", p)) { // "[--" could be start of position diagram
318 if(!Scan(']', p) && (*p)[-3] == '-' && (*p)[-2] == '-') return PositionDiagram;
322 if(isdigit(**p) || isalpha(**p)) {
323 do (*p)++; while(isdigit(**p) || isalpha(**p) || **p == '+' ||
324 **p == '-' || **p == '=' || **p == '_' || **p == '#');
327 while(**p != '\n' && (*(*p)++ != '"'|| (*p)[-2] == '\\')); // look for unescaped quote
328 if((*p)[-1] !='"') { *p = oldp; Scan(']', p); return Comment; } // string closing delimiter missing
329 SkipWhite(p); if(*(*p)++ == ']') return PGNTag;
332 Scan(']', p); return Comment;
335 // ********* SAN Castings *************************************
336 if(**p == 'O' || **p == 'o' || **p == '0') {
337 int castlingType = 0;
338 if(Match("O-O-O", p) || Match("o-o-o", p) || Match("0-0-0", p) ||
339 Match("OOO", p) || Match("ooo", p) || Match("000", p)) castlingType = 2;
340 else if(Match("O-O", p) || Match("o-o", p) || Match("0-0", p) ||
341 Match("OO", p) || Match("oo", p) || Match("00", p)) castlingType = 1;
342 if(castlingType) { //code from old parser, collapsed for both castling types, and streamlined a bit
343 int rf, ff, rt, ft; ChessSquare king;
345 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
356 ff = (BOARD_WIDTH-1)>>1; // this would be d-file
357 if (boards[yyboardindex][rf][ff] == king) {
358 /* ICS wild castling */
359 ft = castlingType == 1 ? BOARD_LEFT+1 : BOARD_RGHT-3;
361 ff = BOARD_WIDTH>>1; // e-file
362 ft = castlingType == 1 ? BOARD_RGHT-2 : BOARD_LEFT+2;
364 if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
366 ff = initialRights[2];
367 ft = initialRights[castlingType-1];
369 ff = initialRights[5];
370 ft = initialRights[castlingType+2];
372 if (appData.debugMode) fprintf(debugFP, "Parser FRC (type=%d) %d %d\n", castlingType, ff, ft);
373 if(ff == NoRights || ft == NoRights) return ImpossibleMove;
375 sprintf(currentMoveString, "%c%c%c%c",ff+AAA,rf+ONE,ft+AAA,rt+ONE);
376 if (appData.debugMode) fprintf(debugFP, "(%d-type) castling %d %d\n", castlingType, ff, ft);
378 return (int) LegalityTest(boards[yyboardindex],
379 PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: e.p.!
380 rf, ff, rt, ft, NULLCHAR);
385 // ********* variations (nesting) ******************************
387 if(RdTime(')', p)) return ElapsedTime;
390 if(**p ==')') { (*p)++; return Close; }
391 if(**p == ';') { while(**p != '\n') (*p)++; return Comment; }
394 // ********* Comments and result messages **********************
395 *p = oldp; commentEnd = NULL; result = 0;
397 if(RdTime('}', p)) return ElapsedTime;
398 if(lastChar == '\n' && Match("--------------\n", p)) {
400 i = Scan ('}', p); q = *p - 16;
401 if(Match("\n--------------}\n", &q)) return PositionDiagram;
402 } else i = Scan('}', p);
403 commentEnd = *p; if(i) return Comment; // return comment that runs to EOF immediately
405 if(commentEnd) SkipWhite(p);
406 if(Match("*", p)) result = GameUnfinished;
407 else if(**p == '0') {
408 if( Match("0-1", p) || Match("0/1", p) || Match("0:1", p) ||
409 Match("0 - 1", p) || Match("0 / 1", p) || Match("0 : 1", p)) result = BlackWins;
410 } else if(**p == '1') {
411 if( Match("1-0", p) || Match("1/0", p) || Match("1:0", p) ||
412 Match("1 - 0", p) || Match("1 / 0", p) || Match("1 : 0", p)) result = WhiteWins;
413 else if(Match("1/2 - 1/2", p) || Match("1/2:1/2", p) || Match("1/2 : 1/2", p) || Match("1 / 2 - 1 / 2", p) ||
414 Match("1 / 2 : 1 / 2", p) || Match("1/2", p) || Match("1 / 2", p)) result = GameIsDrawn;
417 if(Match(" (", p) && !Scan(')', p) || Match(" {", p) && !Scan('}', p)) { // there is a comment after the PGN result!
418 if(commentEnd) { *p = commentEnd; return Comment; } // so comment before it is normal comment; return that first
420 return result; // this returns a possible preceeding comment as result details
422 if(commentEnd) { *p = commentEnd; return Comment; } // there was no PGN result following, so return as normal comment
425 // ********* Move numbers (after castlings or PGN results!) ***********
426 if((i = Number(p)) != BADNUMBER) { // a single number was read as part of our attempt to read a move
428 if(**p == '.') (*p)++; SkipWhite(p);
429 if(**p == '+' || isalpha(**p) || gameInfo.variant == VariantShogi && *p != numEnd && isdigit(**p)) {
431 return i == 1 ? MoveNumberOne : Nothing;
433 *p = numEnd; return Nothing;
437 // ********* non-compliant game-result indicators *********************
438 if(Match("+-+", p) || Word("stalemate", p)) return GameIsDrawn;
439 if(Match("++", p) || Verb("resign", p) || (Word("check", p) || 1) && Word("mate", p) )
440 return (wom ? BlackWins : WhiteWins);
442 if(Word("w", p) && (Match("hite", p) || 1) || Word("b", p) && (Match("lack", p) || 1) ) {
443 if(**p != ' ') return Nothing;
445 if(Verb("disconnect", p)) return GameUnfinished;
446 if(Verb("resign", p) || Verb("forfeit", p) || Word("mated", p) || Word("lost", p) || Word("loses", p))
447 return (c == 'W' ? BlackWins : WhiteWins);
448 if(Word("mates", p) || Word("wins", p) || Word("won", p))
449 return (c != 'W' ? BlackWins : WhiteWins);
452 if(Word("draw", p)) {
453 if(**p == 'n') (*p)++;
454 if(**p != ' ') return GameIsDrawn;
456 if(Word("agreed", p)) return GameIsDrawn;
457 if(Match("by ", p) && (Word("repetition", p) || Word("agreement", p)) ) return GameIsDrawn;
460 while(**p != '\n') if(*(*p)++ == ')') break;
461 if((*p)[-1] == ')') return GameIsDrawn;
463 *p = oldp - 1; return GameIsDrawn;
467 // ********* Numeric annotation glyph **********************************
468 if(**p == '$') { (*p)++; if(Number(p) != BADNUMBER) return NAG; return Nothing; }
471 // ********** by now we are getting down to the silly stuff ************
472 if(Word("gnu", p) || Match("GNU", p)) {
473 if(**p == ' ') (*p)++;
474 if(Word("chess", p) || Match("CHESS", p)) {
476 if((q = strstr(*p, "game")) || (q = strstr(*p, "GAME")) || (q = strstr(*p, "Game"))) {
477 (*p) = q + 4; return GNUChessGame;
482 if(lastChar == '\n' && (Match("# ", p) || Match("; ", p) || Match("% ", p))) {
483 while(**p != '\n' && **p != ' ') (*p)++;
484 if(**p == ' ' && (Match(" game file", p) || Match(" position file", p))) {
485 while(**p != '\n') (*p)++; // skip to EOLN
488 *p = oldp; // we might need to re-match the skipped stuff
491 if(Match("@@@@", p) || Match("--", p) || Match("Z0", p) || Match("pass", p) || Match("null", p)) {
492 strncpy(currentMoveString, "@@@@", 5);
493 return yyboardindex & F_WHITE_ON_MOVE ? WhiteDrop : BlackDrop;
496 // ********* Efficient skipping of (mostly) alphabetic chatter **********
497 while(isdigit(**p) || isalpha(**p) || **p == '-') (*p)++;
500 while(isdigit(**p) || isalpha(**p) || **p == '-' || **p == '\'') (*p)++;
501 return Nothing; // random word
503 if(lastChar == '\n' && Match(": ", p)) { // mail header, skip indented lines
505 while(**p != '\n') (*p)++;
506 if(!ReadLine()) return Nothing; // append next line if not EOF
507 } while(Match("\n ", p) || Match("\n\t", p));
513 // ********* Could not match to anything. Return offending character ****
519 Return offset of next pattern in the current file.
523 return ftell(inputFile) - (inPtr - parsePtr); // subtract what is read but not yet parsed
526 void yynewfile (FILE *f)
527 { // prepare parse buffer for reading file
529 inPtr = parsePtr = inputBuf;
532 *inPtr = NULLCHAR; // make sure we will start by reading a line
535 void yynewstr P((char *s))
543 { // this replaces the flex-generated parser
544 int result = NextUnit(&parsePtr);
545 char *p = parseStart, *q = yytext;
546 while(p < parsePtr) *q++ = *p++; // copy the matched text to yytext[]
553 { // [HGM] wrapper for yylex, which treats nesting of parentheses
554 int symbol, nestingLevel = 0, i=0;
556 static char buf[256*MSG_SIZ];
558 do { // eat away anything not at level 0
560 if(symbol == Open) nestingLevel++;
561 if(nestingLevel) { // save all parsed text between (and including) the ()
562 for(p=yytext; *p && i<256*MSG_SIZ-2;) buf[i++] = *p++;
565 if(symbol == 0) break; // ran into EOF
566 if(symbol == Close) symbol = Comment, nestingLevel--;
567 } while(nestingLevel || symbol == Nothing);
568 yy_text = buf[0] ? buf : (char*)yytext;
572 ChessMove yylexstr(int boardIndex, char *s, char *buf, int buflen)
575 char *savPP = parsePtr;
577 yyboardindex = boardIndex;
579 ret = (ChessMove) Myylex();
580 strncpy(buf, yy_text, buflen-1);
581 buf[buflen-1] = NULLCHAR;