btparser/cparser/tests/exp_lex/MOBITemplate.bt

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
9: 
10: 
11: 
12: 
13: typedef struct { 
14: DWORD dataOffset ; 
15: UBYTE attributeBits ; 
16: UBYTE uid1 ; 
17: WORD uid2 ; 
18: } ri ; 
19: 
20: void checkpdfheader ( ) 
21: { 
22: 
23: if ( ( type != "BOOK" || creator != "MOBI" ) 
24: && ( type != "TEXt" || creator != "REAd" ) ) 
25: { 
26: Warning ( "File is not BOOKMOBI or TEXtREAd. Template stopped." ) ; 
27: return - 1 ; 
28: } 
29: } 
30: 
31: typedef struct { 
32: CHAR name [ 32 ] ; 
33: WORD attributeBits ; 
34: WORD version ; 
35: DWORD creationDate ; 
36: DWORD modificationDate ; 
37: DWORD lastBackupDate ; 
38: DWORD modificationNumber ; 
39: DWORD appInfoID ; 
40: DWORD sortInfoID ; 
41: CHAR type [ 4 ] ; 
42: CHAR creator [ 4 ] ; 
43: checkpdfheader ( ) ; 
44: DWORD uniqueIDseed ; 
45: DWORD nextRecordListID ; 
46: WORD numberOfRecords ; 
47: 
48: SetBackColor ( cWhite ) ; 
49: struct { 
50: DWORD dataOffset ; 
51: UBYTE attributeBits ; 
52: UBYTE uid1 ; 
53: WORD uid2 ; 
54: } recptr [ pdf . numberOfRecords ] ; 
55: } PalmDatabaseFormat ; 
56: 
57: enum < ushort > eCompression { 
58: NoCompression = 1 , 
59: PalmDOC = 2 , 
60: HUFFCDIC = 17480 
61: } ; 
62: 
63: enum < ushort > encryptionType { 
64: NoEncryption = 0 , 
65: OldMobipocketEncryption = 1 , 
66: MobipocketEncryption = 2 
67: } ; 
68: 
69: enum < ushort > TextEncoding { 
70: CP1252_WinLatin1 = 1252 , 
71: UTF8 = 65001 
72: } ; 
73: 
74: enum < uint > MobiType { 
75: MobipocketBook = 2 , 
76: PalmDOCbook = 3 , 
77: Audio = 4 , 
78: News = 257 , 
79: NewsFeed = 258 , 
80: NewsMagazine = 259 , 
81: PICS = 513 , 
82: Word = 514 , 
83: XLS = 515 , 
84: PPT = 516 , 
85: TEXT = 517 , 
86: HTML = 518 
87: } ; 
88: 
89: 
90: typedef struct { 
91: eCompression compression ; 
92: WORD unused ; 
93: DWORD textLength ; 
94: WORD numPDBrecords ; 
95: WORD recMaxSize ; 
96: encryptionType encryption ; 
97: Assert ( encryption == 0 , "File encrypted. Abort." ) ; 
98: WORD unknown1 ; 
99: } PalmDOCheader ; 
100: 
101: typedef enum < uint32 > eMBHflags { 
102: multibyte = 0x1 , 
103: trailers = 0x2 
104: } MBHflags < read = readMBHflags > ; 
105: 
106: string readMBHflags ( local MBHflags & flags ) { 
107: local string s = "" ; 
108: local int commaNeeded = 0 ; 
109: local MBHflags i = 1 ; 
110: 
111: SPrintf ( s , "%x: " , flags ) ; 
112: 
113: 
114: 
115: 
116: 
117: while ( i <= 2 ) { 
118: if ( flags && i ) { 
119: if ( commaNeeded ) { s += ", " ; } 
120: s += EnumToString ( i ) ; 
121: commaNeeded = 1 ; 
122: } 
123: i = i << 1 ; 
124: } 
125: return s ; 
126: } 
127: 
128: 
129: typedef struct { 
130: CHAR identifier [ 4 ] < comment = "continuation of Palm DOC Header" > ; 
131: DWORD headerLength ; 
132: MobiType mobiType ; 
133: WORD cryptoType ; 
134: TextEncoding textEncoding < comment = "codepage" > ; 
135: DWORD uniqueID ; 
136: DWORD MOBIversion ; 
137: DWORD orthographicIndex < format = hex > ; 
138: DWORD inflectionIndex < format = hex > ; 
139: DWORD indexNames < format = hex > ; 
140: DWORD indexKeys < format = hex > ; 
141: DWORD extraIndex0 < format = hex > ; 
142: DWORD extraIndex1 < format = hex > ; 
143: DWORD extraIndex2 < format = hex > ; 
144: DWORD extraIndex3 < format = hex > ; 
145: DWORD extraIndex4 < format = hex > ; 
146: DWORD extraIndex5 < format = hex > ; 
147: DWORD firstNonBookIndex < format = hex > ; 
148: DWORD fullNameOffset < comment = "Book Title" > ; 
149: DWORD fullNameLength < comment = "Book Title Length" > ; 
150: DWORD locale ; 
151: DWORD inputLanguage ; 
152: DWORD outputLanguage ; 
153: DWORD minVersion ; 
154: DWORD firstImageIndex ; 
155: DWORD huffmanRecordOffset ; 
156: DWORD huffmanRecordCount ; 
157: DWORD huffmanTableOffset ; 
158: DWORD huffmanTableLength ; 
159: DWORD EXTHflags ; 
160: CHAR unknown2 [ 32 ] ; 
161: DWORD DRMoffset ; 
162: DWORD DRMcount < format = hex > ; 
163: DWORD DRMsize < format = hex > ; 
164: DWORD DRMflags ; 
165: CHAR unknown3 [ 12 ] ; 
166: WORD FirstContentRecNo ; 
167: WORD LastContentRecNo ; 
168: DWORD unknown4 ; 
169: DWORD FCISrecNo ; 
170: DWORD unknown5 ; 
171: DWORD FLISrecNo ; 
172: DWORD unknown6 ; 
173: QWORD unknown7 ; 
174: DWORD unknown8 ; 
175: DWORD unknown9 ; 
176: DWORD unknown10 ; 
177: DWORD unknown11 ; 
178: MBHflags mbhflags ; 
179: DWORD INDXrecordOffset ; 
180: } MobiHeader ; 
181: 
182: 
183: enum < ubyte > TextToSpeach { 
184: TextToSpeechEnabled = 0 , 
185: TextToSpeechDisabled = 1 
186: } ; 
187: 
188: enum < DWORD > CreatorSoftware { 
189: mobigen = 1 , 
190: MobipocketCreator = 2 , 
191: kindlegen_Windows = 200 , 
192: kindlegen_Linux = 201 , 
193: kindlegen_Mac = 202 
194: } ; 
195: 
196: typedef struct { 
197: enum < DWORD > EXTHrecordType { 
198: Drm_Server_Id = 1 , 
199: Drm_Commerce_Id = 2 , 
200: Drm_Ebookbase_Book_Id = 3 , 
201: Creator = 100 , 
202: Publisher = 101 , 
203: Imprint = 102 , 
204: Description = 103 , 
205: ISBN = 104 , 
206: Subject = 105 , 
207: Published = 106 , 
208: Review = 107 , 
209: Contributor = 108 , 
210: Rights = 109 , 
211: SubjectCode = 110 , 
212: Type = 111 , 
213: Source = 112 , 
214: ASIN = 113 , 
215: VersionNumber = 114 , 
216: Sample = 115 , 
217: StartReading = 116 , 
218: Adult = 117 , 
219: Price = 118 , 
220: Currency = 119 , 
221: K8_Boundary_Section = 121 , 
222: fixed_layout = 122 , 
223: book_type = 123 , 
224: orientation_lock = 124 , 
225: K8_Count_of_Resources_Fonts_Images = 125 , 
226: original_resolution = 126 , 
227: K8_Cover_Image = 129 , 
228: K8_Unidentified_Count = 131 , 
229: RegionMagnification = 132 , 
230: DictShortName = 200 , 
231: CoverOffset = 201 , 
232: ThumbOffset = 202 , 
233: HasFakeCover = 203 , 
234: CreatorSoftwareRecord = 204 , 
235: CreatorMajorVersion = 205 , 
236: CreatorMinorVersion = 206 , 
237: CreatorBuildNumber = 207 , 
238: Watermark = 208 , 
239: Tamper_proof_keys = 209 , 
240: FontSignature = 300 , 
241: ClippingLimit = 401 , 
242: PublisherLimit = 402 , 
243: TextToSpeachFlag = 404 , 
244: CDE_Type = 501 , 
245: last_update_time = 502 , 
246: Updated_Title = 503 
247: 
248: 
249: 
250: 
251: 
252: 
253: 
254: } recordType ; 
255: DWORD recordLength ; 
256: switch ( recordType ) { 
257: case 1 : 
258: UBYTE Drm_Server_Id [ recordLength - 8 ] ; 
259: break ; 
260: case 2 : 
261: UBYTE Drm_Commerce_Id [ recordLength - 8 ] ; 
262: break ; 
263: case 3 : 
264: UBYTE Drm_Ebookbase_Book_Id [ recordLength - 8 ] ; 
265: break ; 
266: case 100 : 
267: UBYTE creator [ recordLength - 8 ] ; 
268: break ; 
269: case 101 : 
270: UBYTE publisher [ recordLength - 8 ] ; 
271: break ; 
272: case 102 : 
273: UBYTE imprint [ recordLength - 8 ] ; 
274: break ; 
275: case 103 : 
276: UBYTE description [ recordLength - 8 ] ; 
277: break ; 
278: case 104 : 
279: UBYTE ISBN [ recordLength - 8 ] ; 
280: break ; 
281: case 105 : 
282: UBYTE subject [ recordLength - 8 ] ; 
283: break ; 
284: case 106 : 
285: UBYTE publishingDate [ recordLength - 8 ] ; 
286: break ; 
287: case 107 : 
288: UBYTE review [ recordLength - 8 ] ; 
289: break ; 
290: case 108 : 
291: UBYTE contributor [ recordLength - 8 ] ; 
292: break ; 
293: case 109 : 
294: UBYTE rights [ recordLength - 8 ] ; 
295: break ; 
296: case 110 : 
297: UBYTE subjectCode [ recordLength - 8 ] ; 
298: break ; 
299: case 111 : 
300: UBYTE type [ recordLength - 8 ] ; 
301: break ; 
302: case 112 : 
303: UBYTE source [ recordLength - 8 ] ; 
304: break ; 
305: case 113 : 
306: UBYTE ASIN [ recordLength - 8 ] ; 
307: break ; 
308: case 114 : 
309: UBYTE versionNumber [ recordLength - 8 ] ; 
310: break ; 
311: case 115 : 
312: Assert ( recordLength == 12 , "sample recordLength-8 != 4 (DWORD)." ) ; 
313: DWORD sample ; 
314: break ; 
315: case 116 : 
316: UBYTE startReading [ recordLength - 8 ] ; 
317: break ; 
318: case 117 : 
319: UBYTE adult [ recordLength - 8 ] ; 
320: break ; 
321: case 118 : 
322: UBYTE price [ recordLength - 8 ] ; 
323: break ; 
324: case 119 : 
325: UBYTE currency [ recordLength - 8 ] ; 
326: break ; 
327: case 121 : 
328: case 122 : 
329: case 123 : 
330: case 124 : 
331: case 125 : 
332: case 126 : 
333: case 129 : 
334: case 131 : 
335: case 132 : 
336: UBYTE unknown [ recordLength - 8 ] ; 
337: break ; 
338: 
339: case 200 : 
340: UBYTE dictShortName [ recordLength - 8 ] ; 
341: break ; 
342: case 201 : 
343: Assert ( recordLength == 12 , "coverOffset recordLength-8 != 4 (DWORD)." ) ; 
344: DWORD coverOffset ; 
345: break ; 
346: case 202 : 
347: Assert ( recordLength == 12 , "thumbOffset recordLength-8 != 4 (DWORD)." ) ; 
348: DWORD thumbOffset ; 
349: break ; 
350: case 203 : 
351: UBYTE hasFakeCover [ recordLength - 8 ] ; 
352: break ; 
353: case 204 : 
354: Assert ( recordLength == 12 , "creatorSoftware recordLength-8 != 4 (DWORD)." ) ; 
355: CreatorSoftware creatorSoftware ; 
356: break ; 
357: case 205 : 
358: Assert ( recordLength == 12 , "creatorMajorVersion recordLength-8 != 4 (DWORD)." ) ; 
359: DWORD creatorMajorVersion ; 
360: break ; 
361: case 206 : 
362: Assert ( recordLength == 12 , "creatorMinorVersion recordLength-8 != 4 (DWORD)." ) ; 
363: DWORD creatorMinorVersion ; 
364: break ; 
365: case 207 : 
366: Assert ( recordLength == 12 , "creatorBuildNumber recordLength-8 != 4. (DWORD)" ) ; 
367: DWORD creatorBuildNumber ; 
368: break ; 
369: case 208 : 
370: UBYTE watermark [ recordLength - 8 ] ; 
371: break ; 
372: case 209 : 
373: UBYTE tamper_proof_keys [ recordLength - 8 ] ; 
374: break ; 
375: case 300 : 
376: UBYTE fontSignature [ recordLength - 8 ] ; 
377: break ; 
378: case 301 : 
379: UBYTE clippingLimit [ recordLength - 8 ] ; 
380: break ; 
381: case 402 : 
382: UBYTE publisherLimit [ recordLength - 8 ] ; 
383: break ; 
384: case 404 : 
385: Assert ( recordLength == 9 , "TextToSpeach recordLength-8 != 1 (BYTE)." ) ; 
386: TextToSpeach textToSpeach ; 
387: break ; 
388: case 501 : 
389: Assert ( recordLength == 12 , "CDEtype recordLength-8 != 1. (DWORD)" ) ; 
390: CHAR CDEtype [ 4 ] ; 
391: break ; 
392: case 502 : 
393: UBYTE lastUpdateTime [ recordLength - 8 ] ; 
394: break ; 
395: case 503 : 
396: UBYTE updatedTitle [ recordLength - 8 ] ; 
397: break ; 
398: case 504 : 
399: UBYTE ASINcopy [ recordLength - 8 ] ; 
400: break ; 
401: case 524 : 
402: UBYTE dclanguage [ recordLength - 8 ] ; 
403: break ; 
404: default : 
405: UBYTE unknown [ recordLength - 8 ] ; 
406: break ; 
407: } 
408: } EXTHrecord ; 
409: 
410: typedef struct { 
411: CHAR identifier [ 4 ] ; 
412: DWORD headerLength ; 
413: UINT recordCount ; 
414: local int i = 0 ; 
415: for ( i = 0 ; i < recordCount ; i ++ ) { 
416: EXTHrecord exthrecord ; 
417: } 
418: } ExthHeader ; 
419: 
420: typedef struct { 
421: UINT ID < comment = "FLIS" > ; 
422: UINT fixed1 < comment = "fixed value 8" > ; 
423: USHORT fixed2 < comment = "fixed value 65" > ; 
424: USHORT fixed3 < comment = "fixed value 0" > ; 
425: UINT fixed4 < comment = "fixed value 0" > ; 
426: UINT fixed5 < comment = "fixed value -1" > ; 
427: USHORT fixed6 < comment = "fixed value 1" > ; 
428: USHORT fixed7 < comment = "fixed value 3" > ; 
429: UINT fixed8 < comment = "fixed value 3" > ; 
430: UINT fixed9 < comment = "fixed value 1" > ; 
431: UINT fixed10 < comment = "fixed value -1" > ; 
432: } FLISRECORD ; 
433: 
434: 
435: typedef struct { 
436: UINT ID < comment = "FDST" > ; 
437: UINT FDSTstart < comment = "FDST start" > ; 
438: UINT fdstcnt < comment = "Number of records inside FDST" > ; 
439: struct { 
440: UBYTE record [ reclen - 12 ] ; 
441: } fdst ; 
442: } FDSTkf8RECORD ; 
443: 
444: typedef struct { 
445: UINT ID < comment = "FCIS" > ; 
446: UINT fixed1 < comment = "fixed value 20" > ; 
447: UINT fixed2 < comment = "fixed value 16" > ; 
448: UINT fixed3 < comment = "fixed value 1" > ; 
449: UINT fixed4 < comment = "fixed value 0" > ; 
450: UINT fixed5 < comment = "text length (the same value as \"text length\" in the PalmDoc header)" > ; 
451: UINT fixed6 < comment = "fixed value 0" > ; 
452: UINT fixed7 < comment = "fixed value 32" > ; 
453: UINT fixed8 < comment = "fixed value 8" > ; 
454: USHORT fixed9 < comment = "fixed value 1" > ; 
455: USHORT fixed10 < comment = "fixed value 1" > ; 
456: UINT fixed11 < comment = "fixed value 0" > ; 
457: } FCISRECORD ; 
458: 
459: typedef struct { 
460: UINT ID < comment = "SRCS" > ; 
461: struct { 
462: UBYTE record [ reclen - 4 ] ; 
463: } srcs ; 
464: } SRCSRECORD ; 
465: 
466: typedef struct { 
467: UINT ID < comment = "DATP" > ; 
468: struct { 
469: UBYTE record [ reclen - 4 ] ; 
470: } datp ; 
471: } DATPRECORD ; 
472: 
473: typedef struct { 
474: QUAD ID < comment = "BOUNDARY" > ; 
475: } BOUNDARYRECORD ; 
476: 
477: typedef struct { 
478: struct { 
479: UBYTE b [ reclen ] ; 
480: } html ; 
481: } HTML ; 
482: 
483: typedef struct { 
484: UINT ID < comment = "INDX" > ; 
485: UINT headerLength < comment = "" > ; 
486: UINT indexType < comment = "" > ; 
487: UINT unknown1 < comment = "" > ; 
488: UINT unknown2 < comment = "" > ; 
489: UINT idxtStart < comment = "offset to the IDXT section" > ; 
490: UINT indexEncoding ; 
491: UINT indexLanguage < comment = "language code of the index" > ; 
492: UINT totalIndexCount < comment = "number of index entries" > ; 
493: UINT ordtStart < comment = "offset to the ORDT section" > ; 
494: UINT ligtStart < comment = "offset to the LIGT section" > ; 
495: UINT unknown3 ; 
496: UINT unknown4 ; 
497: } INDXRECORD ; 
498: 
499: typedef struct { 
500: UBYTE fixed1 < comment = "fixed value 233 (0xE9)" > ; 
501: UBYTE fixed2 < comment = "fixed value 142 (0x8E)" > ; 
502: UBYTE fixed3 < comment = "fixed value 13 (0x0D)" > ; 
503: UBYTE fixed4 < comment = "fixed value 10 (0x0A)" > ; 
504: } ENDRECORD ; 
505: 
506: 
507: 
508: 
509: 
510: BigEndian ( ) ; 
511: SetBackColor ( cLtGray ) ; 
512: PalmDatabaseFormat pdf ; 
513: 
514: 
515: FSeek ( pdf . recptr [ 0 ] . dataOffset ) ; 
516: SetBackColor ( cLtGray ) ; 
517: PalmDOCheader pdh ; 
518: MobiHeader mbh ; 
519: local char fullName [ 255 ] ; 
520: local char KF8fullName [ 255 ] ; 
521: 
522: local int reclen ; 
523: local int i , n ; 
524: local int endrec ; 
525: local char tag [ 9 ] ; 
526: 
527: if ( mbh . fullNameOffset != 0 ) 
528: { 
529: 
530: FSeek ( pdf . recptr [ 0 ] . dataOffset + mbh . fullNameOffset ) ; 
531: ReadBytes ( fullName , FTell ( ) , mbh . fullNameLength ) ; 
532: fullName [ mbh . fullNameLength ] = '\0' ; 
533: 
534: } 
535: 
536: if ( mbh . EXTHflags & 0x40 ) 
537: { 
538: 
539: FSeek ( pdf . recptr [ 0 ] . dataOffset + 16 + mbh . headerLength ) ; 
540: SetBackColor ( cYellow ) ; 
541: ExthHeader exth ; 
542: } 
543: 
544: local uint multibyte = 0 ; 
545: local uint trailers = 0 ; 
546: if ( pdf . type == "BOOK" && pdf . creator == "MOBI" ) 
547: { 
548: if ( ( mbh . headerLength >= 0xE4 ) && ( pdf . version >= 5 ) ) 
549: { 
550: multibyte = flags & 1 ; 
551: while ( flags > 1 ) 
552: { 
553: if ( flags & 2 ) 
554: { 
555: ++ trailers ; 
556: flags = flags >> 1 ; 
557: } 
558: } 
559: } 
560: } 
561: 
562: 
563: for ( i = 0 ; i < pdf . numberOfRecords - 1 ; i ++ ) 
564: { 
565: FSeek ( pdf . recptr [ i ] . dataOffset ) ; 
566: reclen = ( pdf . recptr [ i + 1 ] . dataOffset - pdf . recptr [ i ] . dataOffset ) ; 
567: 
568: ReadBytes ( tag , FTell ( ) , 8 ) ; 
569: tag [ 8 ] = '\0' ; 
570: 
571: 
572: 
573: if ( Memcmp ( tag , "FLIS" , 4 ) == 0 ) 
574: { 
575: SetBackColor ( cLtGray ) ; 
576: FLISRECORD data ; 
577: } 
578: else if ( Memcmp ( tag , "FDST" , 4 ) == 0 ) 
579: { 
580: SetBackColor ( cLtGray ) ; 
581: FDSTkf8RECORD data ; 
582: } 
583: else if ( Memcmp ( tag , "FCIS" , 4 ) == 0 ) 
584: { 
585: SetBackColor ( cLtGreen ) ; 
586: FCISRECORD data ; 
587: if ( data . fixed1 < 0x10 ) 
588: { 
589: 
590: } 
591: 
592: 
593: } 
594: else if ( Memcmp ( tag , "SRCS" , 4 ) == 0 ) 
595: { 
596: SetBackColor ( cLtRed ) ; 
597: SRCSRECORD data ; 
598: } 
599: else if ( Memcmp ( tag , "DATP" , 4 ) == 0 ) 
600: { 
601: SetBackColor ( cLtBlue ) ; 
602: DATPRECORD data ; 
603: for ( n = 0 ; n < reclen - 4 ; n ++ ) 
604: { 
605: if ( data . datp . record [ n ] < 0x10 ) 
606: { 
607: 
608: } 
609: 
610: } 
611: 
612: } 
613: else if ( Memcmp ( tag , "INDX" , 4 ) == 0 ) 
614: { 
615: SetBackColor ( cSilver ) ; 
616: INDXRECORD data ; 
617: } 
618: else if ( Memcmp ( tag , "BOUNDARY" , 8 ) == 0 ) 
619: { 
620: SetBackColor ( cYellow ) ; 
621: BOUNDARYRECORD data ; 
622: 
623: SetBackColor ( cLtGray ) ; 
624: i ++ ; 
625: PalmDOCheader data ; 
626: MobiHeader KF8mbh ; 
627: if ( KF8mbh . fullNameOffset != 0 ) 
628: { 
629: 
630: FSeek ( pdf . recptr [ i ] . dataOffset + KF8mbh . fullNameOffset ) ; 
631: ReadBytes ( KF8fullName , FTell ( ) , KF8mbh . fullNameLength ) ; 
632: fullName [ KF8mbh . fullNameLength ] = '\0' ; 
633: 
634: } 
635: if ( KF8mbh . EXTHflags & 0x40 ) 
636: { 
637: 
638: 
639: FSeek ( pdf . recptr [ i ] . dataOffset + 16 + KF8mbh . headerLength ) ; 
640: SetBackColor ( cYellow ) ; 
641: ExthHeader KF8exth ; 
642: } 
643: } 
644: else if ( Memcmp ( tag , "<html>" , 6 ) == 0 ) 
645: { 
646: SetBackColor ( cLtGreen ) ; 
647: HTML data ; 
648: } 
649: else if ( Memcmp ( tag , "<!DOCTYP" , 8 ) == 0 ) 
650: { 
651: SetBackColor ( cLtGreen ) ; 
652: HTML data ; 
653: } 
654: else 
655: { 
656: SetBackColor ( cLtGray ) ; 
657: struct { 
658: UBYTE unknown [ reclen ] ; 
659: } data ; 
660: } 
661: } 
662: 
663: endrec = ReadUInt ( FTell ( ) ) ; 
664: 
665: if ( endrec == 0xE98E0D0A ) 
666: { 
667: SetBackColor ( cLtGreen ) ; 
668: ENDRECORD data ; 
669: } 
670: 
671: 
672: 
673: 
674: 
675: 
676: 
677: 
678: 
679: 
680: 
681: 
682: 
683: 
684: 
685: 
686: 
687: 
688: 
689: 
690: 
691: 
692: 
693: 
694: 
695: 
696: 
697: 
698: 
699: 
700: 
701: 
702: 
703: 
704: 
705: 
706: 
707: 
708: 
709: 
710: 
711: 
712: 
713: 
714: return ; tok_eof