CUBRID Engine  latest
cnvlex.l
Go to the documentation of this file.
1 /*
2  * Copyright 2008 Search Solution Corporation
3  * Copyright 2016 CUBRID Corporation
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  */
18 
19 /*
20  * cnvlex.l - lexical scanner
21  */
22 %
23 {
24 
25 #ident "$Id$"
26 
27 #include <stdlib.h>
28 #include <assert.h>
29 
30 #include "config.h"
31 
32 /* Set up custom prefix */
33 #define YY_PREFIX dbcnv
34 
35 #include "cnvlex.h"
36 #include "util_func.h"
37 
38  static int cnv_fmt_lex_start (FMT_LEX_MODE mode);
39  void cnv_fmt_exit (void);
40 
41 /* Global variables */
42  static int cnv_fmt__init = 0;
43  static const char *cnv_fmt__input = NULL;
44  static const char *cnv_fmt__next = NULL;
45  static int cnv_fmt__unlex = 0;
46  static FMT_LEX_MODE cnv_fmt__mode = FL_LOCAL_NUMBER;
47 
48 #undef YY_READ_BUF_SIZE
49 #define YY_READ_BUF_SIZE 512
50 
51 #undef YY_DECL
52 #define YY_DECL \
53 FMT_TOKEN_TYPE cnv_fmt_lex( FMT_TOKEN *token)
54 
55 #undef YY_INPUT
56 #define YY_INPUT( buf, result, max) \
57 result = (*(buf) = *cnv_fmt__input)? (cnv_fmt__input++, 1) : YY_NULL;
58 
59 #undef YY_USER_ACTION
60 #define YY_USER_ACTION \
61 token->text = token->raw_text = (const char *)yytext; \
62 token->length = yyleng;
63 
64 #undef YY_USER_INIT
65 #define YY_USER_INIT \
66 if( !cnv_fmt__init) { \
67  atexit( cnv_fmt_exit); \
68  cnv_fmt__init = 1; \
69  } \
70 BEGIN( cnv_fmt_lex_start( cnv_fmt__mode));
71 
72 
73 #define DB_FMT_LEX_RETURN( t) \
74 token->type = t; \
75 cnv_fmt__next += yyleng; \
76 return t;
77 
78 %}
79 
80 %s SC_US_ENG_NUMBER
81  % s SC_KO_KR_NUMBER
82  % s SC_US_ENG_TIME
83  % s SC_KO_KR_TIME
84  % s SC_BIT_STRING
85  % s SC_INTEGER_FORMAT
86  % s SC_TIME_FORMAT
87  % s SC_BIT_STRING_FORMAT
88  % s SC_VALIDATE_DATE_FORMAT
89  % s SC_VALIDATE_FLOAT_FORMAT
90  % s SC_VALIDATE_INTEGER_FORMAT
91  % s SC_VALIDATE_MONETARY_FORMAT
92  % s SC_VALIDATE_TIME_FORMAT
93  % s SC_VALIDATE_TIMESTAMP_FORMAT
94  % s SC_VALIDATE_BIT_STRING_FORMAT
95  DATE_SPEC %[%aAbBdDEemwxyY]
96  TIME_SPEC %[%HIklMprRSTXZ] TIMESTAMP_SPEC %[cC] |
97 {
98 DATE_SPEC} |
99 
100 {
101 TIME_SPEC}
102 
103 TIME_PATTERN[^%]BINARY_PATTERN[bB] HEX_PATTERN[hHxX] BIT_STRING_SPEC % ("%" |
104  {
105  BINARY_PATTERN} |
106 
107  {
108  HEX_PATTERN})
109  ANY_DIGITS
110 {
111 INTEGRAL_DIGITS} ? ("."
112 
113  {
114  DIGITS} ?) ? INTEGRAL_DIGITS
115 
116 {
117 DIGITS} |
118 
119 {
120 Z_THOUS} |
121 
122 {
123 N_THOUS} |
124 
125 {
126 S_THOUS}
127 
128 DIGITS
129 {
130 Z_SEQ} |
131 
132 {
133 N_SEQ} |
134 
135 {
136 S_SEQ}
137 Z_SEQ Z + N_SEQ 9 + S_SEQ "*" + Z_THOUS Z,
138 {
139 Z_SEQ} ? N_THOUS 9,
140 {
141 N_SEQ} ? S_THOUS "*",
142 
143 {
144 S_SEQ} ?
145  INTEGER_PATTERN[^X \\] | "\\X" TIME_SEPARATOR ":" DATE_SEPARATOR "/" %%
146  /* Preliminary "actions" */
147  if (cnv_fmt__unlex && yy_current_buffer->yy_eof_status != EOF_DONE)
148  {
149  /*
150  * Push back current token so that it can be read again.
151  * See cnv_fmt_unlex().
152  */
153  int i;
154  for (i = yyleng - 1; i >= 0; --i)
155  {
156  unput (yytext[i]);
157  }
158  cnv_fmt__next -= yyleng;
159  cnv_fmt__unlex = 0;
160  }
161 
162 
163 <INITIAL, SC_US_ENG_NUMBER, SC_KO_KR_NUMBER > "-"
164 {
165  DB_FMT_LEX_RETURN (FT_MINUS);
166 }
167 
168 <INITIAL, SC_US_ENG_NUMBER, SC_KO_KR_NUMBER > "+"
169 {
170  DB_FMT_LEX_RETURN (FT_PLUS);
171 }
172 
173 <INITIAL, SC_US_ENG_NUMBER, SC_KO_KR_NUMBER > "."
174 {
175  DB_FMT_LEX_RETURN (FT_DECIMAL);
176 }
177 
178 <INITIAL, SC_US_ENG_NUMBER > "$"
179 {
180  DB_FMT_LEX_RETURN (FT_CURRENCY);
181 }
182 
183 <SC_KO_KR_NUMBER > "\\" | "\243\334"
184 {
185  DB_FMT_LEX_RETURN (FT_CURRENCY);
186 }
187 
188 <INITIAL, SC_US_ENG_NUMBER, SC_KO_KR_NUMBER > ","[0 - 9]
189 {
190 3}
191 
192 {
193  int csize = mblen (token->text, token->length);
194  token->text += csize;
195  token->length -= csize;
196  DB_FMT_LEX_RETURN (FT_THOUSANDS);
197 }
198 
199 <INITIAL, SC_US_ENG_NUMBER, SC_KO_KR_NUMBER >[1 - 9] ([0 - 9] *[1 - 9]) ?
200 {
201  /* Number with no leading or trailing zeroes. */
202  DB_FMT_LEX_RETURN (FT_NUMBER);
203 }
204 
205 <INITIAL, SC_US_ENG_NUMBER, SC_KO_KR_NUMBER > "*" +
206 {
207  DB_FMT_LEX_RETURN (FT_STARS);
208 }
209 
210 <INITIAL, SC_US_ENG_NUMBER, SC_KO_KR_NUMBER > "0" +
211 {
212  DB_FMT_LEX_RETURN (FT_ZEROES);
213 }
214 
215 <SC_US_ENG_TIME, SC_KO_KR_TIME > "0"[0 - 9]
216 {
217  DB_FMT_LEX_RETURN (FT_TIME_DIGITS_0);
218 }
219 
220 <SC_US_ENG_TIME, SC_KO_KR_TIME > " "[0 - 9]
221 {
222  DB_FMT_LEX_RETURN (FT_TIME_DIGITS_BLANK);
223 }
224 
225 <SC_US_ENG_TIME, SC_KO_KR_TIME >[1 - 9][0 - 9]
226 {
227  DB_FMT_LEX_RETURN (FT_TIME_DIGITS);
228 }
229 
230 <SC_US_ENG_TIME, SC_KO_KR_TIME > "0" | ([1 - 9][0 - 9] *)
231 {
232  DB_FMT_LEX_RETURN (FT_TIME_DIGITS_ANY);
233 }
234 
235 <SC_US_ENG_TIME, SC_KO_KR_TIME >
236 {
237 DATE_SEPARATOR}
238 
239 {
240  DB_FMT_LEX_RETURN (FT_DATE_SEPARATOR);
241 }
242 
243 <SC_US_ENG_TIME, SC_KO_KR_TIME >
244 {
245 TIME_SEPARATOR}
246 
247 {
248  DB_FMT_LEX_RETURN (FT_TIME_SEPARATOR);
249 }
250 
251 <SC_KO_KR_TIME > "\xb3\xe2" | "\xbf\xf9" | "\xc0\xcf"
252 {
253  DB_FMT_LEX_RETURN (FT_LOCAL_DATE_SEPARATOR);
254 }
255 
256 <SC_US_ENG_TIME > "AM" | "am"
257 {
258  token->value = 0;
259  DB_FMT_LEX_RETURN (FT_AM_PM);
260 }
261 
262 <SC_US_ENG_TIME > "PM" | "pm"
263 {
264  token->value = 1;
265  DB_FMT_LEX_RETURN (FT_AM_PM);
266 }
267 
268 
269 <SC_US_ENG_TIME > "Sunday"
270 {
271  token->value = 0;
272  DB_FMT_LEX_RETURN (FT_WEEKDAY_LONG);
273 }
274 
275 <SC_US_ENG_TIME > "Monday"
276 {
277  token->value = 1;
278  DB_FMT_LEX_RETURN (FT_WEEKDAY_LONG);
279 }
280 
281 <SC_US_ENG_TIME > "Tuesday"
282 {
283  token->value = 2;
284  DB_FMT_LEX_RETURN (FT_WEEKDAY_LONG);
285 }
286 
287 <SC_US_ENG_TIME > "Wednesday"
288 {
289  token->value = 3;
290  DB_FMT_LEX_RETURN (FT_WEEKDAY_LONG);
291 }
292 
293 <SC_US_ENG_TIME > "Thursday"
294 {
295  token->value = 4;
296  DB_FMT_LEX_RETURN (FT_WEEKDAY_LONG);
297 }
298 
299 <SC_US_ENG_TIME > "Friday"
300 {
301  token->value = 5;
302  DB_FMT_LEX_RETURN (FT_WEEKDAY_LONG);
303 }
304 
305 <SC_US_ENG_TIME > "Saturday"
306 {
307  token->value = 6;
308  DB_FMT_LEX_RETURN (FT_WEEKDAY_LONG);
309 }
310 
311 <SC_US_ENG_TIME > "Sun"
312 {
313  token->value = 0;
314  DB_FMT_LEX_RETURN (FT_WEEKDAY);
315 }
316 
317 <SC_US_ENG_TIME > "Mon"
318 {
319  token->value = 1;
320  DB_FMT_LEX_RETURN (FT_WEEKDAY);
321 }
322 
323 <SC_US_ENG_TIME > "Tue"
324 {
325  token->value = 2;
326  DB_FMT_LEX_RETURN (FT_WEEKDAY);
327 }
328 
329 <SC_US_ENG_TIME > "Wed"
330 {
331  token->value = 3;
332  DB_FMT_LEX_RETURN (FT_WEEKDAY);
333 }
334 
335 <SC_US_ENG_TIME > "Thu"
336 {
337  token->value = 4;
338  DB_FMT_LEX_RETURN (FT_WEEKDAY);
339 }
340 
341 <SC_US_ENG_TIME > "Fri"
342 {
343  token->value = 5;
344  DB_FMT_LEX_RETURN (FT_WEEKDAY);
345 }
346 
347 <SC_US_ENG_TIME > "Sat"
348 {
349  token->value = 6;
350  DB_FMT_LEX_RETURN (FT_WEEKDAY);
351 }
352 
353 
354 
355 <SC_US_ENG_TIME > "January"
356 {
357  token->value = 1;
358  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
359 }
360 
361 <SC_US_ENG_TIME > "February"
362 {
363  token->value = 2;
364  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
365 }
366 
367 <SC_US_ENG_TIME > "March"
368 {
369  token->value = 3;
370  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
371 }
372 
373 <SC_US_ENG_TIME > "April"
374 {
375  token->value = 4;
376  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
377 }
378 
379 <SC_US_ENG_TIME > "May"
380 {
381  token->value = 5;
382  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
383 }
384 
385 <SC_US_ENG_TIME > "June"
386 {
387  token->value = 6;
388  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
389 }
390 
391 <SC_US_ENG_TIME > "July"
392 {
393  token->value = 7;
394  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
395 }
396 
397 <SC_US_ENG_TIME > "August"
398 {
399  token->value = 8;
400  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
401 }
402 
403 <SC_US_ENG_TIME > "September"
404 {
405  token->value = 9;
406  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
407 }
408 
409 <SC_US_ENG_TIME > "October"
410 {
411  token->value = 10;
412  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
413 }
414 
415 <SC_US_ENG_TIME > "November"
416 {
417  token->value = 11;
418  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
419 }
420 
421 <SC_US_ENG_TIME > "December"
422 {
423  token->value = 12;
424  DB_FMT_LEX_RETURN (FT_MONTH_LONG);
425 }
426 
427 <SC_US_ENG_TIME > "Jan"
428 {
429  token->value = 1;
430  DB_FMT_LEX_RETURN (FT_MONTH);
431 }
432 
433 <SC_US_ENG_TIME > "Feb"
434 {
435  token->value = 2;
436  DB_FMT_LEX_RETURN (FT_MONTH);
437 }
438 
439 <SC_US_ENG_TIME > "Mar"
440 {
441  token->value = 3;
442  DB_FMT_LEX_RETURN (FT_MONTH);
443 }
444 
445 <SC_US_ENG_TIME > "Apr"
446 {
447  token->value = 4;
448  DB_FMT_LEX_RETURN (FT_MONTH);
449 }
450 
451 <SC_US_ENG_TIME > "May"
452 {
453  token->value = 5;
454  DB_FMT_LEX_RETURN (FT_MONTH);
455 }
456 
457 <SC_US_ENG_TIME > "Jun"
458 {
459  token->value = 6;
460  DB_FMT_LEX_RETURN (FT_MONTH);
461 }
462 
463 <SC_US_ENG_TIME > "Jul"
464 {
465  token->value = 7;
466  DB_FMT_LEX_RETURN (FT_MONTH);
467 }
468 
469 <SC_US_ENG_TIME > "Aug"
470 {
471  token->value = 8;
472  DB_FMT_LEX_RETURN (FT_MONTH);
473 }
474 
475 <SC_US_ENG_TIME > "Sep"
476 {
477  token->value = 9;
478  DB_FMT_LEX_RETURN (FT_MONTH);
479 }
480 
481 <SC_US_ENG_TIME > "Oct"
482 {
483  token->value = 10;
484  DB_FMT_LEX_RETURN (FT_MONTH);
485 }
486 
487 <SC_US_ENG_TIME > "Nov"
488 {
489  token->value = 11;
490  DB_FMT_LEX_RETURN (FT_MONTH);
491 }
492 
493 <SC_US_ENG_TIME > "Dec"
494 {
495  token->value = 12;
496  DB_FMT_LEX_RETURN (FT_MONTH);
497 }
498 
499 
500 
501 <SC_INTEGER_FORMAT > "X" +
502 {
503  DB_FMT_LEX_RETURN (FT_NUMBER);
504 }
505 
506 <SC_INTEGER_FORMAT >[^X \\] +
507 {
508  DB_FMT_LEX_RETURN (FT_PATTERN);
509 }
510 
511 <SC_INTEGER_FORMAT > "\\X"
512 {
513  /* Escaped X is treated like a pattern char. */
514  int csize = mblen (token->text, token->length);
515  token->text += csize;
516  token->length -= csize;
517  DB_FMT_LEX_RETURN (FT_PATTERN);
518 }
519 
520 
521 
522 <SC_TIME_FORMAT >[^%] +
523 {
524  DB_FMT_LEX_RETURN (FT_PATTERN);
525 }
526 
527 <SC_TIME_FORMAT > "%%"
528 {
529  /* Escaped % is treated like a pattern char. */
530  int csize = mblen (token->text, token->length);
531  token->text += csize;
532  token->length -= csize;
533  DB_FMT_LEX_RETURN (FT_PATTERN);
534 }
535 
536 <SC_TIME_FORMAT > %[DxE]
537 {
538  int csize = mblen (token->text, token->length);
539  token->text += csize;
540  token->length -= csize;
541  DB_FMT_LEX_RETURN (FT_DATE);
542 }
543 
544 <SC_TIME_FORMAT > %[yY]
545 {
546  int csize = mblen (token->text, token->length);
547  token->text += csize;
548  token->length -= csize;
549  DB_FMT_LEX_RETURN (FT_YEAR);
550 }
551 
552 <SC_TIME_FORMAT > %[bBm]
553 {
554  int csize = mblen (token->text, token->length);
555  token->text += csize;
556  token->length -= csize;
557  DB_FMT_LEX_RETURN (FT_MONTH);
558 }
559 
560 <SC_TIME_FORMAT > %[de]
561 {
562  int csize = mblen (token->text, token->length);
563  token->text += csize;
564  token->length -= csize;
565  DB_FMT_LEX_RETURN (FT_MONTHDAY);
566 }
567 
568 <SC_TIME_FORMAT > %[aAw]
569 {
570  int csize = mblen (token->text, token->length);
571  token->text += csize;
572  token->length -= csize;
573  DB_FMT_LEX_RETURN (FT_WEEKDAY);
574 }
575 
576 <SC_TIME_FORMAT > %[HIkl]
577 {
578  int csize = mblen (token->text, token->length);
579  token->text += csize;
580  token->length -= csize;
581  DB_FMT_LEX_RETURN (FT_HOUR);
582 }
583 
584 <SC_TIME_FORMAT > %[M]
585 {
586  int csize = mblen (token->text, token->length);
587  token->text += csize;
588  token->length -= csize;
589  DB_FMT_LEX_RETURN (FT_MINUTE);
590 }
591 
592 <SC_TIME_FORMAT > %[S]
593 {
594  int csize = mblen (token->text, token->length);
595  token->text += csize;
596  token->length -= csize;
597  DB_FMT_LEX_RETURN (FT_SECOND);
598 }
599 
600 <SC_TIME_FORMAT > %[F]
601 {
602  int csize = mblen (token->text, token->length);
603  token->text += csize;
604  token->length -= csize;
605  DB_FMT_LEX_RETURN (FT_MILLISECOND);
606 }
607 
608 <SC_TIME_FORMAT > %[p]
609 {
610  int csize = mblen (token->text, token->length);
611  token->text += csize;
612  token->length -= csize;
613  DB_FMT_LEX_RETURN (FT_AM_PM);
614 }
615 
616 <SC_TIME_FORMAT > %[Z]
617 {
618  int csize = mblen (token->text, token->length);
619  token->text += csize;
620  token->length -= csize;
621  DB_FMT_LEX_RETURN (FT_ZONE);
622 }
623 
624 <SC_TIME_FORMAT > %[rRTX]
625 {
626  int csize = mblen (token->text, token->length);
627  token->text += csize;
628  token->length -= csize;
629  DB_FMT_LEX_RETURN (FT_TIME);
630 }
631 
632 <SC_TIME_FORMAT > %[cC]
633 {
634  int csize = mblen (token->text, token->length);
635  token->text += csize;
636  token->length -= csize;
637  DB_FMT_LEX_RETURN (FT_TIMESTAMP);
638 }
639 
640 
641 
642 
643 <SC_VALIDATE_DATE_FORMAT > (
644  {
645  TIME_PATTERN} *
646 
647  {
648  DATE_SPEC} +
649 
650  {
651  TIME_PATTERN} *) *
652 
653 {
654  DB_FMT_LEX_RETURN (FT_DATE_FORMAT);
655 }
656 
657 <SC_VALIDATE_FLOAT_FORMAT > ("+") ?
658 {
659 ANY_DIGITS}
660 
661 {
662  DB_FMT_LEX_RETURN (FT_FLOAT_FORMAT);
663 }
664 
665 <SC_VALIDATE_INTEGER_FORMAT > ("+") ?
666 {
667 INTEGRAL_DIGITS} ?
668 
669 {
670  DB_FMT_LEX_RETURN (FT_INTEGER_FORMAT);
671 }
672 
673 <SC_VALIDATE_INTEGER_FORMAT > (
674  {
675  INTEGER_PATTERN} *X +
676 
677  {
678  INTEGER_PATTERN} *) +
679 
680 {
681  DB_FMT_LEX_RETURN (FT_INTEGER_FORMAT);
682 }
683 
684 <SC_VALIDATE_MONETARY_FORMAT > ("$") ?
685 {
686 ANY_DIGITS} |
687 
688 {
689 ANY_DIGITS} "$"
690 
691 {
692  DB_FMT_LEX_RETURN (FT_MONETARY_FORMAT);
693 }
694 
695 <SC_VALIDATE_TIME_FORMAT > (
696  {
697  TIME_PATTERN} *
698 
699  {
700  TIME_SPEC} +
701 
702  {
703  TIME_PATTERN} *) *
704 
705 {
706  DB_FMT_LEX_RETURN (FT_TIME_FORMAT);
707 }
708 
709 <SC_VALIDATE_TIMESTAMP_FORMAT > (
710  {
711  TIME_PATTERN} *
712 
713  {
714  TIMESTAMP_SPEC} +
715 
716  {
717  TIME_PATTERN} *) *
718 
719 {
720  DB_FMT_LEX_RETURN (FT_TIMESTAMP_FORMAT);
721 }
722 
723 <SC_VALIDATE_BIT_STRING_FORMAT >
724 {
725 BIT_STRING_SPEC}
726 
727 {
728  DB_FMT_LEX_RETURN (FT_BIT_STRING_FORMAT);
729 }
730 
731 <SC_BIT_STRING_FORMAT > %("%" |
732  {
733  BINARY_PATTERN})
734 
735 {
736  DB_FMT_LEX_RETURN (FT_BINARY_DIGITS);
737 }
738 
739 <SC_BIT_STRING_FORMAT > %
740 {
741 HEX_PATTERN}
742 
743 {
744  DB_FMT_LEX_RETURN (FT_HEX_DIGITS);
745 }
746 
747 <SC_BIT_STRING >[01] *
748 {
749  DB_FMT_LEX_RETURN (FT_BINARY_DIGITS);
750 }
751 
752 <SC_BIT_STRING >[0 - 9 a - fA - F] *
753 {
754  DB_FMT_LEX_RETURN (FT_HEX_DIGITS);
755 }
756 
757 <SC_KO_KR_TIME > "\xbf\xc0\xc0\xfc"
758 {
759  token->value = 0;
760  DB_FMT_LEX_RETURN (FT_AM_PM);
761 }
762 
763 <SC_KO_KR_TIME > "\xbf\xc0\xc8\xc4"
764 {
765  token->value = 1;
766  DB_FMT_LEX_RETURN (FT_AM_PM);
767 }
768 
769 <SC_KO_KR_TIME > "(" "\xc0\xcf" ")"
770 {
771  token->value = 0;
772  DB_FMT_LEX_RETURN (FT_WEEKDAY);
773 }
774 
775 <SC_KO_KR_TIME > "(" "\xbf\xf9" ")"
776 {
777  token->value = 1;
778  DB_FMT_LEX_RETURN (FT_WEEKDAY);
779 }
780 
781 <SC_KO_KR_TIME > "(" "\xc8\xad" ")"
782 {
783  token->value = 2;
784  DB_FMT_LEX_RETURN (FT_WEEKDAY);
785 }
786 
787 <SC_KO_KR_TIME > "(" "\xbc\xf6" ")"
788 {
789  token->value = 3;
790  DB_FMT_LEX_RETURN (FT_WEEKDAY);
791 }
792 
793 <SC_KO_KR_TIME > "(" "\xb8\xf1" ")"
794 {
795  token->value = 4;
796  DB_FMT_LEX_RETURN (FT_WEEKDAY);
797 }
798 
799 <SC_KO_KR_TIME > "(" "\xb1\xdd" ")"
800 {
801  token->value = 5;
802  DB_FMT_LEX_RETURN (FT_WEEKDAY);
803 }
804 
805 <SC_KO_KR_TIME > "(" "\xc5\xe4" ")"
806 {
807  token->value = 6;
808  DB_FMT_LEX_RETURN (FT_WEEKDAY);
809 }
810 
811 
812 .
813 {
814  DB_FMT_LEX_RETURN (FT_UNKNOWN);
815 }
816 
817 
818 <<EOF >>
819 {
820  cnv_fmt__next = cnv_fmt__input;
821  token->type = FT_NONE;
822  token->text = token->raw_text = cnv_fmt__input;
823  token->length = 0;
824  yyterminate ();
825 }
826 
827 
828 %%
829 /*
830  * cnv_fmt_analyze() - Initialize lexical scan of instring, using
831  * the given scan mode.
832  * return:
833  * instring(in) :
834  * mode(in) :
835  */
836  void
837 cnv_fmt_analyze (const char *instring, FMT_LEX_MODE mode)
838 {
839  assert (instring);
840  cnv_fmt__input = cnv_fmt__next = instring;
841  yy_init = 1;
842  cnv_fmt__unlex = 0;
843  cnv_fmt__mode = mode;
844 }
845 
846 
847 /*
848  * cnv_fmt_unlex() - Push back the current token so that it can be read again.
849  * return:
850  */
851 void
852 cnv_fmt_unlex ()
853 {
854  cnv_fmt__unlex = 1; /* see rules section */
855 }
856 
857 
858 /*
859  * cnv_fmt_next_token() - Return pointer to next lexical token in value string.
860  * return:
861  */
862 const char *
863 cnv_fmt_next_token ()
864 {
865  return cnv_fmt__next;
866 }
867 
868 
869 /*
870  * cnv_fmt_lex_start() - Return the start condition for the given scan mode.
871  * return:
872  * mode(in) :
873  */
874 static int
875 cnv_fmt_lex_start (FMT_LEX_MODE mode)
876 {
877  return
878  mode == FL_LOCAL_NUMBER ?
879  cnv_fmt_lex_start (cnv_fmt_number_mode (intl_zone (LC_MONETARY))) :
880  mode == FL_LOCAL_TIME ?
881  cnv_fmt_lex_start (cnv_fmt_time_mode (intl_zone (LC_TIME))) :
882  mode == FL_US_ENG_NUMBER ? SC_US_ENG_NUMBER :
883  mode == FL_KO_KR_NUMBER ? SC_KO_KR_NUMBER :
884  mode == FL_US_ENG_TIME ? SC_US_ENG_TIME :
885  mode == FL_KO_KR_TIME ? SC_KO_KR_TIME :
886  mode == FL_INTEGER_FORMAT ? SC_INTEGER_FORMAT :
887  mode == FL_TIME_FORMAT ? SC_TIME_FORMAT :
888  mode == FL_BIT_STRING_FORMAT ? SC_BIT_STRING_FORMAT :
889  mode == FL_BIT_STRING ? SC_BIT_STRING :
890  mode == FL_VALIDATE_DATE_FORMAT ? SC_VALIDATE_DATE_FORMAT :
891  mode == FL_VALIDATE_FLOAT_FORMAT ? SC_VALIDATE_FLOAT_FORMAT :
892  mode == FL_VALIDATE_INTEGER_FORMAT ? SC_VALIDATE_INTEGER_FORMAT :
893  mode == FL_VALIDATE_MONETARY_FORMAT ? SC_VALIDATE_MONETARY_FORMAT :
894  mode == FL_VALIDATE_TIME_FORMAT ? SC_VALIDATE_TIME_FORMAT :
895  mode == FL_VALIDATE_TIMESTAMP_FORMAT ? SC_VALIDATE_TIMESTAMP_FORMAT :
896  mode == FL_VALIDATE_BIT_STRING_FORMAT ? SC_VALIDATE_BIT_STRING_FORMAT :
897  INITIAL;
898 }
899 
900 
901 
902 /*
903  * cnv_fmt_number_mode() - Return the number value scan mode for the given zone.
904  * return:
905  * zone(in) :
906  */
907 FMT_LEX_MODE
908 cnv_fmt_number_mode (INTL_ZONE zone)
909 {
910  FMT_LEX_MODE mode;
911 
912  switch (zone)
913  {
914  case INTL_ZONE_US:
915  {
916  mode = FL_US_ENG_NUMBER;
917  break;
918  }
919  case INTL_ZONE_KR:
920  {
921  mode = FL_KO_KR_NUMBER;
922  break;
923  }
924  default:
925  {
926  assert (!"Zone not implemented!");
927  mode = FL_US_ENG_NUMBER;
928  break;
929  }
930  }
931 
932  return mode;
933 }
934 
935 
936 
937 /*
938  * cnv_fmt_time_mode() - Return the time value scan mode for the given zone.
939  * return:
940  * zone(in) :
941  */
942 FMT_LEX_MODE
943 cnv_fmt_time_mode (INTL_ZONE zone)
944 {
945  FMT_LEX_MODE mode;
946 
947  switch (zone)
948  {
949  case INTL_ZONE_US:
950  {
951  mode = FL_US_ENG_TIME;
952  break;
953  }
954  case INTL_ZONE_KR:
955  {
956  mode = FL_KO_KR_TIME;
957  break;
958  }
959 
960  default:
961  {
962  assert (!"Zone not implemented!");
963  mode = FL_US_ENG_TIME;
964  break;
965  }
966  }
967 
968  return mode;
969 }
970 
971 
972 /*
973  * cnv_fmt_exit() - Free buffers when exit.
974  * return:
975  */
976 void
977 cnv_fmt_exit (void)
978 {
979  if (YY_CURRENT_BUFFER != NULL)
980  {
981  yy_delete_buffer (YY_CURRENT_BUFFER);
982  YY_CURRENT_BUFFER = NULL;
983  }
984 }
985