author | zautrix <zautrix> | 2004-06-29 11:59:46 (UTC) |
---|---|---|
committer | zautrix <zautrix> | 2004-06-29 11:59:46 (UTC) |
commit | da43dbdc6c82453228f34766fc74585615cba938 (patch) (unidiff) | |
tree | 16576932cea08bf117b2d0320b0d5f66ee8ad093 /libkcal/versit/vcc.c | |
parent | 627489ea2669d3997676bc3cee0f5d0d0c16c4d4 (diff) | |
download | kdepimpi-da43dbdc6c82453228f34766fc74585615cba938.zip kdepimpi-da43dbdc6c82453228f34766fc74585615cba938.tar.gz kdepimpi-da43dbdc6c82453228f34766fc74585615cba938.tar.bz2 |
New lib ical.Some minor changes as well.
-rw-r--r-- | libkcal/versit/vcc.c | 1817 |
1 files changed, 987 insertions, 830 deletions
diff --git a/libkcal/versit/vcc.c b/libkcal/versit/vcc.c index 350cac3..9be752d 100644 --- a/libkcal/versit/vcc.c +++ b/libkcal/versit/vcc.c | |||
@@ -1,71 +1,66 @@ | |||
1 | 1 | /* A Bison parser, made from vcc.y | |
2 | /* A Bison parser, made from ./vcc.y | 2 | by GNU bison 1.35. */ |
3 | by GNU Bison version 1.28 */ | ||
4 | 3 | ||
5 | #define YYBISON 1 /* Identify Bison output. */ | 4 | #define YYBISON 1 /* Identify Bison output. */ |
6 | 5 | ||
7 | #ifdef _WIN32_ | 6 | # define EQ257 |
8 | #define strcasecmp _stricmp | 7 | # define COLON258 |
9 | #endif | 8 | # define DOT259 |
10 | 9 | # define SEMICOLON260 | |
11 | #define EQ257 | 10 | # define SPACE261 |
12 | #define COLON258 | 11 | # define HTAB262 |
13 | #define DOT259 | 12 | # define LINESEP263 |
14 | #define SEMICOLON260 | 13 | # define NEWLINE264 |
15 | #define SPACE261 | 14 | # define BEGIN_VCARD265 |
16 | #define HTAB262 | 15 | # define END_VCARD266 |
17 | #define LINESEP263 | 16 | # define BEGIN_VCAL267 |
18 | #define NEWLINE264 | 17 | # define END_VCAL268 |
19 | #define BEGIN_VCARD265 | 18 | # define BEGIN_VEVENT269 |
20 | #define END_VCARD266 | 19 | # define END_VEVENT270 |
21 | #define BEGIN_VCAL267 | 20 | # define BEGIN_VTODO271 |
22 | #define END_VCAL268 | 21 | # define END_VTODO272 |
23 | #define BEGIN_VEVENT269 | 22 | # define ID273 |
24 | #define END_VEVENT270 | 23 | # define STRING274 |
25 | #define BEGIN_VTODO271 | 24 | |
26 | #define END_VTODO272 | 25 | #line 1 "vcc.y" |
27 | #define ID273 | ||
28 | #define STRING274 | ||
29 | |||
30 | #line 1 "./vcc.y" | ||
31 | 26 | ||
32 | 27 | ||
33 | /*************************************************************************** | 28 | /*************************************************************************** |
34 | (C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International | 29 | (C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International |
35 | Business Machines Corporation and Siemens Rolm Communications Inc. | 30 | Business Machines Corporation and Siemens Rolm Communications Inc. |
36 | 31 | ||
37 | For purposes of this license notice, the term Licensors shall mean, | 32 | For purposes of this license notice, the term Licensors shall mean, |
38 | collectively, Apple Computer, Inc., AT&T Corp., International | 33 | collectively, Apple Computer, Inc., AT&T Corp., International |
39 | Business Machines Corporation and Siemens Rolm Communications Inc. | 34 | Business Machines Corporation and Siemens Rolm Communications Inc. |
40 | The term Licensor shall mean any of the Licensors. | 35 | The term Licensor shall mean any of the Licensors. |
41 | 36 | ||
42 | Subject to acceptance of the following conditions, permission is hereby | 37 | Subject to acceptance of the following conditions, permission is hereby |
43 | granted by Licensors without the need for written agreement and without | 38 | granted by Licensors without the need for written agreement and without |
44 | license or royalty fees, to use, copy, modify and distribute this | 39 | license or royalty fees, to use, copy, modify and distribute this |
45 | software for any purpose. | 40 | software for any purpose. |
46 | 41 | ||
47 | The above copyright notice and the following four paragraphs must be | 42 | The above copyright notice and the following four paragraphs must be |
48 | reproduced in all copies of this software and any software including | 43 | reproduced in all copies of this software and any software including |
49 | this software. | 44 | this software. |
50 | 45 | ||
51 | THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE | 46 | THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE |
52 | ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR | 47 | ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR |
53 | MODIFICATIONS. | 48 | MODIFICATIONS. |
54 | 49 | ||
55 | IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT, | 50 | IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT, |
56 | INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT | 51 | INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT |
57 | OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH | 52 | OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH |
58 | DAMAGE. | 53 | DAMAGE. |
59 | 54 | ||
60 | EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, | 55 | EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, |
61 | INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE | 56 | INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE |
62 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | 57 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
63 | PURPOSE. | 58 | PURPOSE. |
64 | 59 | ||
65 | The software is provided with RESTRICTED RIGHTS. Use, duplication, or | 60 | The software is provided with RESTRICTED RIGHTS. Use, duplication, or |
66 | disclosure by the government are subject to restrictions set forth in | 61 | disclosure by the government are subject to restrictions set forth in |
67 | DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable. | 62 | DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable. |
68 | 63 | ||
69 | ***************************************************************************/ | 64 | ***************************************************************************/ |
70 | 65 | ||
71 | /* | 66 | /* |
@@ -73,9 +68,9 @@ DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable. | |||
73 | * doc: Parser for vCard and vCalendar. Note that this code is | 68 | * doc: Parser for vCard and vCalendar. Note that this code is |
74 | * generated by a yacc parser generator. Generally it should not | 69 | * generated by a yacc parser generator. Generally it should not |
75 | * be edited by hand. The real source is vcc.y. The #line directives | 70 | * be edited by hand. The real source is vcc.y. The #line directives |
76 | * can be commented out here to make it easier to trace through | 71 | * can be commented out here to make it easier to trace through |
77 | * in a debugger. However, if a bug is found it should | 72 | * in a debugger. However, if a bug is found it should |
78 | * be fixed in vcc.y and this file regenerated. | 73 | * be fixed in vcc.y and this file regenerated. |
79 | */ | 74 | */ |
80 | 75 | ||
81 | 76 | ||
@@ -85,8 +80,13 @@ DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable. | |||
85 | #else | 80 | #else |
86 | #define DBG_(x) | 81 | #define DBG_(x) |
87 | #endif | 82 | #endif |
88 | 83 | ||
84 | #ifdef WIN32 | ||
85 | #define snprintf _snprintf | ||
86 | #define strcasecmp stricmp | ||
87 | #endif | ||
88 | |||
89 | /**** External Functions ****/ | 89 | /**** External Functions ****/ |
90 | 90 | ||
91 | /* assign local name to parser variables and functions so that | 91 | /* assign local name to parser variables and functions so that |
92 | we can use more than one yacc based parser. | 92 | we can use more than one yacc based parser. |
@@ -119,39 +119,35 @@ DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable. | |||
119 | #define yytable mime_table | 119 | #define yytable mime_table |
120 | #define yycheck mime_check | 120 | #define yycheck mime_check |
121 | #define yyname mime_name | 121 | #define yyname mime_name |
122 | #define yyrule mime_rule | 122 | #define yyrule mime_rule |
123 | #undef YYPREFIX | ||
124 | #define YYPREFIX "mime_" | 123 | #define YYPREFIX "mime_" |
125 | 124 | ||
126 | 125 | ||
127 | #ifndef _NO_LINE_FOLDING | 126 | #ifndef _NO_LINE_FOLDING |
128 | #define _SUPPORT_LINE_FOLDING 1 | 127 | #define _SUPPORT_LINE_FOLDING 1 |
129 | #endif | 128 | #endif |
130 | 129 | ||
131 | #include <string.h> | 130 | /* undef below if compile with MFC */ |
132 | #ifndef __FreeBSD__ | 131 | /* #define INCLUDEMFC 1 */ |
133 | #include <malloc.h> | 132 | |
133 | #if defined(WIN32) || defined(_WIN32) | ||
134 | #ifdef INCLUDEMFC | ||
135 | #include <afx.h> | ||
134 | #endif | 136 | #endif |
137 | #endif | ||
138 | |||
139 | #include <string.h> | ||
135 | #include <stdio.h> | 140 | #include <stdio.h> |
136 | #include <stdlib.h> | 141 | #include <stdlib.h> |
137 | #include <ctype.h> | 142 | #include <ctype.h> |
138 | #include "vcc.h" | 143 | #include "vcc.h" |
139 | 144 | ||
140 | /* The following is a hack that I hope will get things compiling | ||
141 | * on SunOS 4.1.x systems | ||
142 | */ | ||
143 | #ifndef SEEK_SET | ||
144 | #define SEEK_SET 0 /* Seek from beginning of file. */ | ||
145 | #define SEEK_CUR 1 /* Seek from current position. */ | ||
146 | #define SEEK_END 2 /* Seek from end of file. */ | ||
147 | #endif | ||
148 | |||
149 | /**** Types, Constants ****/ | 145 | /**** Types, Constants ****/ |
150 | 146 | ||
151 | #define YYDEBUG 0/* 1 to compile in some debugging code */ | 147 | #define YYDEBUG 1/* 1 to compile in some debugging code */ |
152 | #define MAXTOKEN 256/* maximum token (line) length */ | 148 | #define MAXTOKEN 256/* maximum token (line) length */ |
153 | #define YYSTACKSIZE 1000/* ~unref ? */ | 149 | #define YYSTACKSIZE 50/* ~unref ? */ |
154 | #define MAXLEVEL 10/* max # of nested objects parseable */ | 150 | #define MAXLEVEL 10/* max # of nested objects parseable */ |
155 | /* (includes outermost) */ | 151 | /* (includes outermost) */ |
156 | 152 | ||
157 | 153 | ||
@@ -168,17 +164,17 @@ static int ObjStackTop; | |||
168 | #if __CPLUSPLUS__ | 164 | #if __CPLUSPLUS__ |
169 | extern "C" { | 165 | extern "C" { |
170 | #endif | 166 | #endif |
171 | 167 | ||
172 | /* static void Parse_Debug(const char *s);*/ | 168 | extern void Parse_Debug(const char *s); |
173 | static void yyerror(char *s); | 169 | static void yyerror(char *s); |
174 | 170 | ||
175 | #if __CPLUSPLUS__ | 171 | #if __CPLUSPLUS__ |
176 | }; | 172 | }; |
177 | #endif | 173 | #endif |
178 | 174 | ||
179 | int yyparse(); | 175 | int yyparse(); |
180 | static int yylex(); | 176 | |
181 | enum LexMode { | 177 | enum LexMode { |
182 | L_NORMAL, | 178 | L_NORMAL, |
183 | L_VCARD, | 179 | L_VCARD, |
184 | L_VCAL, | 180 | L_VCAL, |
@@ -191,195 +187,216 @@ enum LexMode { | |||
191 | 187 | ||
192 | /**** Private Forward Declarations ****/ | 188 | /**** Private Forward Declarations ****/ |
193 | static int pushVObject(const char *prop); | 189 | static int pushVObject(const char *prop); |
194 | static VObject* popVObject(); | 190 | static VObject* popVObject(); |
195 | char* lexDataFromBase64(); | ||
196 | static void lexPopMode(int top); | 191 | static void lexPopMode(int top); |
197 | static int lexWithinMode(enum LexMode mode); | 192 | static int lexWithinMode(enum LexMode mode); |
198 | static void lexPushMode(enum LexMode mode); | 193 | static void lexPushMode(enum LexMode mode); |
199 | static void enterProps(const char *s); | 194 | static void enterProps(const char *s); |
200 | static void enterAttr(const char *s1, const char *s2); | 195 | static void enterAttr(const char *s1, const char *s2); |
201 | /* static void enterValues(const char *value); */ | 196 | static void enterValues(const char *value); |
202 | static void appendValue(const char *value); | ||
203 | static void mime_error_(char *s); | 197 | static void mime_error_(char *s); |
204 | 198 | ||
205 | 199 | ||
206 | #line 181 "./vcc.y" | 200 | #line 180 "vcc.y" |
201 | #ifndef YYSTYPE | ||
207 | typedef union { | 202 | typedef union { |
208 | char *str; | 203 | char *str; |
209 | VObject *vobj; | 204 | VObject *vobj; |
210 | } YYSTYPE; | 205 | } yystype; |
211 | #include <stdio.h> | 206 | # define YYSTYPE yystype |
212 | 207 | # define YYSTYPE_IS_TRIVIAL 1 | |
213 | #ifndef __cplusplus | ||
214 | #ifndef __STDC__ | ||
215 | #define const | ||
216 | #endif | 208 | #endif |
209 | #ifndef YYDEBUG | ||
210 | # define YYDEBUG 0 | ||
217 | #endif | 211 | #endif |
218 | 212 | ||
219 | 213 | ||
220 | 214 | ||
221 | #define YYFINAL 62 | 215 | #define YYFINAL 62 |
222 | #define YYFLAG -32768 | 216 | #define YYFLAG -32768 |
223 | #define YYNTBASE21 | 217 | #define YYNTBASE21 |
224 | 218 | ||
219 | /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ | ||
225 | #define YYTRANSLATE(x) ((unsigned)(x) <= 274 ? yytranslate[x] : 51) | 220 | #define YYTRANSLATE(x) ((unsigned)(x) <= 274 ? yytranslate[x] : 51) |
226 | 221 | ||
227 | static const char yytranslate[] = { 0, | 222 | /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */ |
228 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 223 | static const char yytranslate[] = |
229 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 224 | { |
230 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 225 | 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
231 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 226 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
232 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 227 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
233 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 228 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
234 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 229 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
235 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 230 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
236 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 231 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
237 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 232 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
238 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 233 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
239 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 234 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
240 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 235 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
241 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 236 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
242 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 237 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
243 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 238 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
244 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 239 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
245 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 240 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
246 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 241 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
247 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 242 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
248 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 243 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
249 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 244 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
250 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 245 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
251 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 246 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
252 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 247 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
253 | 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, | 248 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
254 | 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, | 249 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
255 | 17, 18, 19, 20 | 250 | 2, 2, 2, 2, 2, 2, 1, 3, 4, 5, |
251 | 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, | ||
252 | 16, 17, 18, 19, 20 | ||
256 | }; | 253 | }; |
257 | 254 | ||
258 | #if YYDEBUG != 0 | 255 | #if YYDEBUG |
259 | static const short yyprhs[] = { 0, | 256 | static const short yyprhs[] = |
260 | 0, 2, 3, 7, 9, 11, 13, 14, 19, 20, | 257 | { |
261 | 24, 27, 29, 30, 36, 38, 39, 43, 45, 48, | 258 | 0, 0, 2, 3, 7, 9, 11, 13, 14, 19, |
262 | 50, 53, 55, 59, 61, 62, 67, 69, 71, 72, | 259 | 20, 24, 27, 29, 30, 36, 38, 39, 43, 45, |
263 | 73, 78, 79, 83, 86, 88, 90, 92, 94, 95, | 260 | 48, 50, 53, 55, 59, 61, 62, 67, 69, 71, |
264 | 100, 101, 105, 106, 111, 112 | 261 | 72, 73, 78, 79, 83, 86, 88, 90, 92, 94, |
262 | 95, 100, 101, 105, 106, 111, 112 | ||
265 | }; | 263 | }; |
266 | 264 | static const short yyrhs[] = | |
267 | static const short yyrhs[] = { 22, | 265 | { |
268 | 0, 0, 24, 23, 22, 0, 24, 0, 25, 0, | 266 | 22, 0, 0, 24, 23, 22, 0, 24, 0, 25, |
269 | 40, 0, 0, 11, 26, 28, 12, 0, 0, 11, | 267 | 0, 40, 0, 0, 11, 26, 28, 12, 0, 0, |
270 | 27, 12, 0, 29, 28, 0, 29, 0, 0, 31, | 268 | 11, 27, 12, 0, 29, 28, 0, 29, 0, 0, |
271 | 4, 30, 37, 9, 0, 1, 0, 0, 36, 32, | 269 | 31, 4, 30, 37, 9, 0, 1, 0, 0, 36, |
272 | 33, 0, 36, 0, 34, 33, 0, 34, 0, 6, | 270 | 32, 33, 0, 36, 0, 34, 33, 0, 34, 0, |
273 | 35, 0, 36, 0, 36, 3, 36, 0, 19, 0, | 271 | 6, 35, 0, 36, 0, 36, 3, 36, 0, 19, |
274 | 0, 39, 6, 38, 37, 0, 39, 0, 20, 0, | 272 | 0, 0, 39, 6, 38, 37, 0, 39, 0, 20, |
275 | 0, 0, 13, 41, 43, 14, 0, 0, 13, 42, | 273 | 0, 0, 0, 13, 41, 43, 14, 0, 0, 13, |
276 | 14, 0, 44, 43, 0, 44, 0, 45, 0, 48, | 274 | 42, 14, 0, 44, 43, 0, 44, 0, 45, 0, |
277 | 0, 28, 0, 0, 15, 46, 28, 16, 0, 0, | 275 | 48, 0, 28, 0, 0, 15, 46, 28, 16, 0, |
278 | 15, 47, 16, 0, 0, 17, 49, 28, 18, 0, | 276 | 0, 15, 47, 16, 0, 0, 17, 49, 28, 18, |
279 | 0, 17, 50, 18, 0 | 277 | 0, 0, 17, 50, 18, 0 |
280 | }; | 278 | }; |
281 | 279 | ||
282 | #endif | 280 | #endif |
283 | 281 | ||
284 | #if YYDEBUG != 0 | 282 | #if YYDEBUG |
285 | static const short yyrline[] = { 0, | 283 | /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
286 | 209, 212, 215, 215, 219, 220, 223, 229, 234, 240, | 284 | static const short yyrline[] = |
287 | 246, 247, 250, 254, 260, 263, 268, 268, 274, 275, | 285 | { |
288 | 278, 281, 285, 292, 295, 296, 296, 300, 301, 305, | 286 | 0, 208, 211, 211, 214, 218, 219, 222, 222, 233, |
289 | 309, 311, 314, 317, 318, 321, 323, 324, 327, 334, | 287 | 233, 245, 246, 249, 249, 259, 262, 262, 267, 273, |
290 | 339, 345, 351, 358, 363, 369 | 288 | 274, 277, 280, 284, 291, 294, 294, 295, 299, 300, |
289 | 303, 303, 309, 309, 315, 316, 319, 321, 322, 325, | ||
290 | 325, 337, 337, 349, 349, 361, 361 | ||
291 | }; | 291 | }; |
292 | #endif | 292 | #endif |
293 | 293 | ||
294 | 294 | ||
295 | #if YYDEBUG != 0 || defined (YYERROR_VERBOSE) | 295 | #if (YYDEBUG) || defined YYERROR_VERBOSE |
296 | 296 | ||
297 | static const char * const yytname[] = { "$","error","$undefined.","EQ","COLON", | 297 | /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ |
298 | "DOT","SEMICOLON","SPACE","HTAB","LINESEP","NEWLINE","BEGIN_VCARD","END_VCARD", | 298 | static const char *const yytname[] = |
299 | "BEGIN_VCAL","END_VCAL","BEGIN_VEVENT","END_VEVENT","BEGIN_VTODO","END_VTODO", | 299 | { |
300 | "ID","STRING","mime","vobjects","@1","vobject","vcard","@2","@3","items","item", | 300 | "$", "error", "$undefined.", "EQ", "COLON", "DOT", "SEMICOLON", "SPACE", |
301 | "@4","prop","@5","attr_params","attr_param","attr","name","values","@6","value", | 301 | "HTAB", "LINESEP", "NEWLINE", "BEGIN_VCARD", "END_VCARD", "BEGIN_VCAL", |
302 | "vcal","@7","@8","calitems","calitem","eventitem","@9","@10","todoitem","@11", | 302 | "END_VCAL", "BEGIN_VEVENT", "END_VEVENT", "BEGIN_VTODO", "END_VTODO", |
303 | "@12", NULL | 303 | "ID", "STRING", "mime", "vobjects", "@1", "vobject", "vcard", "@2", |
304 | "@3", "items", "item", "@4", "prop", "@5", "attr_params", "attr_param", | ||
305 | "attr", "name", "values", "@6", "value", "vcal", "@7", "@8", "calitems", | ||
306 | "calitem", "eventitem", "@9", "@10", "todoitem", "@11", "@12", 0 | ||
304 | }; | 307 | }; |
305 | #endif | 308 | #endif |
306 | 309 | ||
307 | static const short yyr1[] = { 0, | 310 | /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
308 | 21, 23, 22, 22, 24, 24, 26, 25, 27, 25, | 311 | static const short yyr1[] = |
309 | 28, 28, 30, 29, 29, 32, 31, 31, 33, 33, | 312 | { |
310 | 34, 35, 35, 36, 38, 37, 37, 39, 39, 41, | 313 | 0, 21, 23, 22, 22, 24, 24, 26, 25, 27, |
311 | 40, 42, 40, 43, 43, 44, 44, 44, 46, 45, | 314 | 25, 28, 28, 30, 29, 29, 32, 31, 31, 33, |
312 | 47, 45, 49, 48, 50, 48 | 315 | 33, 34, 35, 35, 36, 38, 37, 37, 39, 39, |
316 | 41, 40, 42, 40, 43, 43, 44, 44, 44, 46, | ||
317 | 45, 47, 45, 49, 48, 50, 48 | ||
313 | }; | 318 | }; |
314 | 319 | ||
315 | static const short yyr2[] = { 0, | 320 | /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
316 | 1, 0, 3, 1, 1, 1, 0, 4, 0, 3, | 321 | static const short yyr2[] = |
317 | 2, 1, 0, 5, 1, 0, 3, 1, 2, 1, | 322 | { |
318 | 2, 1, 3, 1, 0, 4, 1, 1, 0, 0, | 323 | 0, 1, 0, 3, 1, 1, 1, 0, 4, 0, |
319 | 4, 0, 3, 2, 1, 1, 1, 1, 0, 4, | 324 | 3, 2, 1, 0, 5, 1, 0, 3, 1, 2, |
320 | 0, 3, 0, 4, 0, 3 | 325 | 1, 2, 1, 3, 1, 0, 4, 1, 1, 0, |
326 | 0, 4, 0, 3, 2, 1, 1, 1, 1, 0, | ||
327 | 4, 0, 3, 0, 4, 0, 3 | ||
321 | }; | 328 | }; |
322 | 329 | ||
323 | static const short yydefact[] = { 0, | 330 | /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE |
324 | 7, 30, 1, 2, 5, 6, 0, 0, 0, 0, | 331 | doesn't specify something else to do. Zero means the default is an |
325 | 0, 15, 24, 0, 0, 0, 16, 10, 39, 43, | 332 | error. */ |
326 | 38, 0, 0, 36, 37, 33, 3, 8, 11, 13, | 333 | static const short yydefact[] = |
327 | 0, 0, 0, 0, 0, 31, 34, 29, 0, 17, | 334 | { |
328 | 20, 0, 42, 0, 46, 28, 0, 27, 21, 22, | 335 | 0, 7, 30, 1, 2, 5, 6, 0, 0, 0, |
329 | 19, 40, 44, 14, 25, 0, 29, 23, 26, 0, | 336 | 0, 0, 15, 24, 0, 0, 0, 16, 10, 39, |
330 | 0, 0 | 337 | 43, 38, 0, 0, 36, 37, 33, 3, 8, 11, |
338 | 13, 0, 0, 0, 0, 0, 31, 34, 29, 0, | ||
339 | 17, 20, 0, 42, 0, 46, 28, 0, 27, 21, | ||
340 | 22, 19, 40, 44, 14, 25, 0, 29, 23, 26, | ||
341 | 0, 0, 0 | ||
331 | }; | 342 | }; |
332 | 343 | ||
333 | static const short yydefgoto[] = { 60, | 344 | static const short yydefgoto[] = |
334 | 3, 11, 4, 5, 7, 8, 21, 15, 38, 16, | 345 | { |
335 | 31, 40, 41, 49, 17, 47, 57, 48, 6, 9, | 346 | 60, 3, 11, 4, 5, 7, 8, 21, 15, 38, |
336 | 10, 22, 23, 24, 32, 33, 25, 34, 35 | 347 | 16, 31, 40, 41, 49, 17, 47, 57, 48, 6, |
348 | 9, 10, 22, 23, 24, 32, 33, 25, 34, 35 | ||
337 | }; | 349 | }; |
338 | 350 | ||
339 | static const short yypact[] = { -9, | 351 | static const short yypact[] = |
340 | -6, -5,-32768, 7,-32768,-32768, 2, -1, 19, 15, | 352 | { |
341 | -9,-32768,-32768, 1, 0, 26, 27,-32768, 16, 17, | 353 | -9, -6, -5,-32768, 7,-32768,-32768, 2, -1, 19, |
342 | -32768, 23, 9,-32768,-32768,-32768,-32768,-32768,-32768,-32768, | 354 | 15, -9,-32768,-32768, 1, 0, 26, 27,-32768, 16, |
343 | 33, 2, 24, 2, 25,-32768,-32768, 13, 22,-32768, | 355 | 17,-32768, 23, 9,-32768,-32768,-32768,-32768,-32768,-32768, |
344 | 33, 28,-32768, 29,-32768,-32768, 36, 40,-32768, 39, | 356 | -32768, 33, 2, 24, 2, 25,-32768,-32768, 13, 22, |
345 | -32768,-32768,-32768,-32768,-32768, 22, 13,-32768,-32768, 48, | 357 | -32768, 33, 28,-32768, 29,-32768,-32768, 36, 40,-32768, |
346 | 49,-32768 | 358 | 39,-32768,-32768,-32768,-32768,-32768, 22, 13,-32768,-32768, |
359 | 48, 49,-32768 | ||
347 | }; | 360 | }; |
348 | 361 | ||
349 | static const short yypgoto[] = {-32768, | 362 | static const short yypgoto[] = |
350 | 41,-32768,-32768,-32768,-32768,-32768, -7,-32768,-32768,-32768, | 363 | { |
351 | -32768, 10,-32768,-32768, -34, -4,-32768,-32768,-32768,-32768, | 364 | -32768, 41,-32768,-32768,-32768,-32768,-32768, -7,-32768,-32768, |
352 | -32768, 31,-32768,-32768,-32768,-32768,-32768,-32768,-32768 | 365 | -32768,-32768, 10,-32768,-32768, -34, -4,-32768,-32768,-32768, |
366 | -32768,-32768, 31,-32768,-32768,-32768,-32768,-32768,-32768,-32768 | ||
353 | }; | 367 | }; |
354 | 368 | ||
355 | 369 | ||
356 | #define YYLAST 54 | 370 | #define YYLAST 54 |
357 | 371 | ||
358 | 372 | ||
359 | static const short yytable[] = { 14, | 373 | static const short yytable[] = |
360 | 12, 1, 12, 2, 50, -9, -4, 29, -32, 12, | 374 | { |
361 | 18, -12, 28, -12, -12, -12, -12, -12, 13, 12, | 375 | 14, 12, 1, 12, 2, 50, -9, -4, 29, -32, |
362 | 13, 58, -35, 19, 42, 20, 44, 13, 26, 30, | 376 | 12, 18, -12, 28, -12, -12, -12, -12, -12, 13, |
363 | -18, -41, 46, 19, -45, 20, 36, 13, 39, 43, | 377 | 12, 13, 58, -35, 19, 42, 20, 44, 13, 26, |
364 | 13, 56, 45, 52, 54, 55, 53, 61, 62, 0, | 378 | 30, -18, -41, 46, 19, -45, 20, 36, 13, 39, |
365 | 51, 27, 59, 37 | 379 | 43, 13, 56, 45, 52, 54, 55, 53, 61, 62, |
380 | 0, 51, 27, 59, 37 | ||
366 | }; | 381 | }; |
367 | 382 | ||
368 | static const short yycheck[] = { 7, | 383 | static const short yycheck[] = |
369 | 1, 11, 1, 13, 39, 12, 0, 15, 14, 1, | 384 | { |
370 | 12, 12, 12, 14, 15, 16, 17, 18, 19, 1, | 385 | 7, 1, 11, 1, 13, 39, 12, 0, 15, 14, |
371 | 19, 56, 14, 15, 32, 17, 34, 19, 14, 4, | 386 | 1, 12, 12, 12, 14, 15, 16, 17, 18, 19, |
372 | 4, 16, 20, 15, 18, 17, 14, 19, 6, 16, | 387 | 1, 19, 56, 14, 15, 32, 17, 34, 19, 14, |
373 | 19, 3, 18, 16, 9, 6, 18, 0, 0, -1, | 388 | 4, 4, 16, 20, 15, 18, 17, 14, 19, 6, |
374 | 41, 11, 57, 23 | 389 | 16, 19, 3, 18, 16, 9, 6, 18, 0, 0, |
390 | -1, 41, 11, 57, 23 | ||
375 | }; | 391 | }; |
376 | /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ | 392 | /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ |
377 | #line 3 "/usr/share/bison.simple" | 393 | #line 3 "/usr/share/bison/bison.simple" |
378 | /* This file comes from bison-1.28. */ | ||
379 | 394 | ||
380 | /* Skeleton output parser for bison, | 395 | /* Skeleton output parser for bison, |
381 | Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. | 396 | |
397 | Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software | ||
398 | Foundation, Inc. | ||
382 | 399 | ||
383 | This program is free software; you can redistribute it and/or modify | 400 | This program is free software; you can redistribute it and/or modify |
384 | it under the terms of the GNU General Public License as published by | 401 | it under the terms of the GNU General Public License as published by |
385 | the Free Software Foundation; either version 2, or (at your option) | 402 | the Free Software Foundation; either version 2, or (at your option) |
@@ -399,275 +416,419 @@ static const short yycheck[] = { 7, | |||
399 | Bison output file, you may use that output file without restriction. | 416 | Bison output file, you may use that output file without restriction. |
400 | This special exception was added by the Free Software Foundation | 417 | This special exception was added by the Free Software Foundation |
401 | in version 1.24 of Bison. */ | 418 | in version 1.24 of Bison. */ |
402 | 419 | ||
403 | /* This is the parser code that is written into each bison parser | 420 | /* This is the parser code that is written into each bison parser when |
404 | when the %semantic_parser declaration is not specified in the grammar. | 421 | the %semantic_parser declaration is not specified in the grammar. |
405 | It was written by Richard Stallman by simplifying the hairy parser | 422 | It was written by Richard Stallman by simplifying the hairy parser |
406 | used when %semantic_parser is specified. */ | 423 | used when %semantic_parser is specified. */ |
424 | |||
425 | /* All symbols defined below should begin with yy or YY, to avoid | ||
426 | infringing on user name space. This should be done even for local | ||
427 | variables, as they might otherwise be expanded by user macros. | ||
428 | There are some unavoidable exceptions within include files to | ||
429 | define necessary library symbols; they are noted "INFRINGES ON | ||
430 | USER NAME SPACE" below. */ | ||
431 | |||
432 | #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) | ||
433 | |||
434 | /* The parser invokes alloca or malloc; define the necessary symbols. */ | ||
435 | |||
436 | # if YYSTACK_USE_ALLOCA | ||
437 | # define YYSTACK_ALLOC alloca | ||
438 | # else | ||
439 | # ifndef YYSTACK_USE_ALLOCA | ||
440 | # if defined (alloca) || defined (_ALLOCA_H) | ||
441 | # define YYSTACK_ALLOC alloca | ||
442 | # else | ||
443 | # ifdef __GNUC__ | ||
444 | # define YYSTACK_ALLOC __builtin_alloca | ||
445 | # endif | ||
446 | # endif | ||
447 | # endif | ||
448 | # endif | ||
449 | |||
450 | # ifdef YYSTACK_ALLOC | ||
451 | /* Pacify GCC's `empty if-body' warning. */ | ||
452 | # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) | ||
453 | # else | ||
454 | # if defined (__STDC__) || defined (__cplusplus) | ||
455 | # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ | ||
456 | # define YYSIZE_T size_t | ||
457 | # endif | ||
458 | # define YYSTACK_ALLOC malloc | ||
459 | # define YYSTACK_FREE free | ||
460 | # endif | ||
461 | #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ | ||
462 | |||
463 | |||
464 | #if (! defined (yyoverflow) \ | ||
465 | && (! defined (__cplusplus) \ | ||
466 | || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) | ||
467 | |||
468 | /* A type that is properly aligned for any stack member. */ | ||
469 | union yyalloc | ||
470 | { | ||
471 | short yyss; | ||
472 | YYSTYPE yyvs; | ||
473 | # if YYLSP_NEEDED | ||
474 | YYLTYPE yyls; | ||
475 | # endif | ||
476 | }; | ||
477 | |||
478 | /* The size of the maximum gap between one aligned stack and the next. */ | ||
479 | # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) | ||
480 | |||
481 | /* The size of an array large to enough to hold all stacks, each with | ||
482 | N elements. */ | ||
483 | # if YYLSP_NEEDED | ||
484 | # define YYSTACK_BYTES(N) \ | ||
485 | ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))\ | ||
486 | + 2 * YYSTACK_GAP_MAX) | ||
487 | # else | ||
488 | # define YYSTACK_BYTES(N) \ | ||
489 | ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ | ||
490 | + YYSTACK_GAP_MAX) | ||
491 | # endif | ||
492 | |||
493 | /* Copy COUNT objects from FROM to TO. The source and destination do | ||
494 | not overlap. */ | ||
495 | # ifndef YYCOPY | ||
496 | # if 1 < __GNUC__ | ||
497 | # define YYCOPY(To, From, Count) \ | ||
498 | __builtin_memcpy (To, From, (Count) * sizeof (*(From))) | ||
499 | # else | ||
500 | # define YYCOPY(To, From, Count) \ | ||
501 | do \ | ||
502 | { \ | ||
503 | register YYSIZE_T yyi; \ | ||
504 | for (yyi = 0; yyi < (Count); yyi++)\ | ||
505 | (To)[yyi] = (From)[yyi]; \ | ||
506 | } \ | ||
507 | while (0) | ||
508 | # endif | ||
509 | # endif | ||
510 | |||
511 | /* Relocate STACK from its old location to the new one. The | ||
512 | local variables YYSIZE and YYSTACKSIZE give the old and new number of | ||
513 | elements in the stack, and YYPTR gives the new location of the | ||
514 | stack. Advance YYPTR to a properly aligned location for the next | ||
515 | stack. */ | ||
516 | # define YYSTACK_RELOCATE(Stack) \ | ||
517 | do \ | ||
518 | { \ | ||
519 | YYSIZE_T yynewbytes; \ | ||
520 | YYCOPY (&yyptr->Stack, Stack, yysize); \ | ||
521 | Stack = &yyptr->Stack; \ | ||
522 | yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;\ | ||
523 | yyptr += yynewbytes / sizeof (*yyptr); \ | ||
524 | } \ | ||
525 | while (0) | ||
407 | 526 | ||
408 | #ifndef YYSTACK_USE_ALLOCA | ||
409 | #ifdef alloca | ||
410 | #define YYSTACK_USE_ALLOCA | ||
411 | #else /* alloca not defined */ | ||
412 | #ifdef __GNUC__ | ||
413 | #define YYSTACK_USE_ALLOCA | ||
414 | #define alloca __builtin_alloca | ||
415 | #else /* not GNU C. */ | ||
416 | #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) | ||
417 | #define YYSTACK_USE_ALLOCA | ||
418 | #include <alloca.h> | ||
419 | #else /* not sparc */ | ||
420 | /* We think this test detects Watcom and Microsoft C. */ | ||
421 | /* This used to test MSDOS, but that is a bad idea | ||
422 | since that symbol is in the user namespace. */ | ||
423 | #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) | ||
424 | #if 0 /* No need for malloc.h, which pollutes the namespace; | ||
425 | instead, just don't use alloca. */ | ||
426 | #include <malloc.h> | ||
427 | #endif | 527 | #endif |
428 | #else /* not MSDOS, or __TURBOC__ */ | 528 | |
429 | #if defined(_AIX) | 529 | |
430 | /* I don't know what this was needed for, but it pollutes the namespace. | 530 | #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) |
431 | So I turned it off. rms, 2 May 1997. */ | 531 | # define YYSIZE_T __SIZE_TYPE__ |
432 | /* #include <malloc.h> */ | ||
433 | #pragma alloca | ||
434 | #define YYSTACK_USE_ALLOCA | ||
435 | #else /* not MSDOS, or __TURBOC__, or _AIX */ | ||
436 | #if 0 | ||
437 | #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, | ||
438 | and on HPUX 10. Eventually we can turn this on. */ | ||
439 | #define YYSTACK_USE_ALLOCA | ||
440 | #define alloca __builtin_alloca | ||
441 | #endif /* __hpux */ | ||
442 | #endif | 532 | #endif |
443 | #endif /* not _AIX */ | 533 | #if ! defined (YYSIZE_T) && defined (size_t) |
444 | #endif /* not MSDOS, or __TURBOC__ */ | 534 | # define YYSIZE_T size_t |
445 | #endif /* not sparc */ | 535 | #endif |
446 | #endif /* not GNU C */ | 536 | #if ! defined (YYSIZE_T) |
447 | #endif /* alloca not defined */ | 537 | # if defined (__STDC__) || defined (__cplusplus) |
448 | #endif /* YYSTACK_USE_ALLOCA not defined */ | 538 | # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ |
449 | 539 | # define YYSIZE_T size_t | |
450 | #ifdef YYSTACK_USE_ALLOCA | 540 | # endif |
451 | #define YYSTACK_ALLOC alloca | 541 | #endif |
452 | #else | 542 | #if ! defined (YYSIZE_T) |
453 | #define YYSTACK_ALLOC malloc | 543 | # define YYSIZE_T unsigned int |
454 | #endif | 544 | #endif |
455 | |||
456 | /* Note: there must be only one dollar sign in this file. | ||
457 | It is replaced by the list of actions, each action | ||
458 | as one case of the switch. */ | ||
459 | 545 | ||
460 | #define yyerrok (yyerrstatus = 0) | 546 | #define yyerrok (yyerrstatus = 0) |
461 | #define yyclearin(yychar = YYEMPTY) | 547 | #define yyclearin(yychar = YYEMPTY) |
462 | #define YYEMPTY -2 | 548 | #define YYEMPTY -2 |
463 | #define YYEOF 0 | 549 | #define YYEOF 0 |
464 | #define YYACCEPTgoto yyacceptlab | 550 | #define YYACCEPTgoto yyacceptlab |
465 | #define YYABORT goto yyabortlab | 551 | #define YYABORT goto yyabortlab |
466 | #define YYERROR goto yyerrlab1 | 552 | #define YYERROR goto yyerrlab1 |
467 | /* Like YYERROR except do call yyerror. | 553 | /* Like YYERROR except do call yyerror. This remains here temporarily |
468 | This remains here temporarily to ease the | 554 | to ease the transition to the new meaning of YYERROR, for GCC. |
469 | transition to the new meaning of YYERROR, for GCC. | ||
470 | Once GCC version 2 has supplanted version 1, this can go. */ | 555 | Once GCC version 2 has supplanted version 1, this can go. */ |
471 | #define YYFAIL goto yyerrlab | 556 | #define YYFAIL goto yyerrlab |
472 | #define YYRECOVERING() (!!yyerrstatus) | 557 | #define YYRECOVERING() (!!yyerrstatus) |
473 | #define YYBACKUP(token, value) \ | 558 | #define YYBACKUP(Token, Value) \ |
474 | do \ | 559 | do \ |
475 | if (yychar == YYEMPTY && yylen == 1) \ | 560 | if (yychar == YYEMPTY && yylen == 1) \ |
476 | { yychar = (token), yylval = (value); \ | 561 | { \ |
562 | yychar = (Token); \ | ||
563 | yylval = (Value); \ | ||
477 | yychar1 = YYTRANSLATE (yychar); \ | 564 | yychar1 = YYTRANSLATE (yychar); \ |
478 | YYPOPSTACK; \ | 565 | YYPOPSTACK; \ |
479 | goto yybackup; \ | 566 | goto yybackup; \ |
480 | } \ | 567 | } \ |
481 | else \ | 568 | else \ |
482 | { yyerror ("syntax error: cannot back up"); YYERROR; }\ | 569 | { \ |
570 | yyerror ("syntax error: cannot back up"); \ | ||
571 | YYERROR; \ | ||
572 | } \ | ||
483 | while (0) | 573 | while (0) |
484 | 574 | ||
485 | #define YYTERROR1 | 575 | #define YYTERROR1 |
486 | #define YYERRCODE256 | 576 | #define YYERRCODE256 |
487 | 577 | ||
488 | #ifndef YYPURE | ||
489 | #define YYLEX yylex() | ||
490 | #endif | ||
491 | 578 | ||
492 | #ifdef YYPURE | 579 | /* YYLLOC_DEFAULT -- Compute the default location (before the actions |
493 | #ifdef YYLSP_NEEDED | 580 | are run). |
494 | #ifdef YYLEX_PARAM | ||
495 | #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) | ||
496 | #else | ||
497 | #define YYLEX yylex(&yylval, &yylloc) | ||
498 | #endif | ||
499 | #else /* not YYLSP_NEEDED */ | ||
500 | #ifdef YYLEX_PARAM | ||
501 | #define YYLEX yylex(&yylval, YYLEX_PARAM) | ||
502 | #else | ||
503 | #define YYLEX yylex(&yylval) | ||
504 | #endif | ||
505 | #endif /* not YYLSP_NEEDED */ | ||
506 | #endif | ||
507 | 581 | ||
508 | /* If nonreentrant, generate the variables here */ | 582 | When YYLLOC_DEFAULT is run, CURRENT is set the location of the |
583 | first token. By default, to implement support for ranges, extend | ||
584 | its range to the last symbol. */ | ||
509 | 585 | ||
510 | #ifndef YYPURE | 586 | #ifndef YYLLOC_DEFAULT |
511 | 587 | # define YYLLOC_DEFAULT(Current, Rhs, N) \ | |
512 | int yychar; /* the lookahead symbol */ | 588 | Current.last_line = Rhs[N].last_line;\ |
513 | YYSTYPE yylval; /* the semantic value of the */ | 589 | Current.last_column = Rhs[N].last_column; |
514 | /* lookahead symbol */ | ||
515 | |||
516 | #ifdef YYLSP_NEEDED | ||
517 | YYLTYPE yylloc; /* location data for the lookahead*/ | ||
518 | /* symbol */ | ||
519 | #endif | 590 | #endif |
520 | 591 | ||
521 | int yynerrs; /* number of parse errors so far */ | ||
522 | #endif /* not YYPURE */ | ||
523 | |||
524 | #if YYDEBUG != 0 | ||
525 | int yydebug; /* nonzero means print parse trace*/ | ||
526 | /* Since this is uninitialized, it does not stop multiple parsers | ||
527 | from coexisting. */ | ||
528 | #endif | ||
529 | |||
530 | /* YYINITDEPTH indicates the initial size of the parser's stacks*/ | ||
531 | 592 | ||
593 | /* YYLEX -- calling `yylex' with the right arguments. */ | ||
594 | |||
595 | #if YYPURE | ||
596 | # if YYLSP_NEEDED | ||
597 | # ifdef YYLEX_PARAM | ||
598 | # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) | ||
599 | # else | ||
600 | # define YYLEX yylex (&yylval, &yylloc) | ||
601 | # endif | ||
602 | # else /* !YYLSP_NEEDED */ | ||
603 | # ifdef YYLEX_PARAM | ||
604 | # define YYLEX yylex (&yylval, YYLEX_PARAM) | ||
605 | # else | ||
606 | # define YYLEX yylex (&yylval) | ||
607 | # endif | ||
608 | # endif /* !YYLSP_NEEDED */ | ||
609 | #else /* !YYPURE */ | ||
610 | # define YYLEX yylex () | ||
611 | #endif /* !YYPURE */ | ||
612 | |||
613 | |||
614 | /* Enable debugging if requested. */ | ||
615 | #if YYDEBUG | ||
616 | |||
617 | # ifndef YYFPRINTF | ||
618 | # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ | ||
619 | # define YYFPRINTF fprintf | ||
620 | # endif | ||
621 | |||
622 | # define YYDPRINTF(Args) \ | ||
623 | do { \ | ||
624 | if (yydebug) \ | ||
625 | YYFPRINTF Args; \ | ||
626 | } while (0) | ||
627 | /* Nonzero means print parse trace. It is left uninitialized so that | ||
628 | multiple parsers can coexist. */ | ||
629 | int yydebug; | ||
630 | #else /* !YYDEBUG */ | ||
631 | # define YYDPRINTF(Args) | ||
632 | #endif /* !YYDEBUG */ | ||
633 | |||
634 | /* YYINITDEPTH -- initial size of the parser's stacks. */ | ||
532 | #ifndefYYINITDEPTH | 635 | #ifndefYYINITDEPTH |
533 | #define YYINITDEPTH 200 | 636 | # define YYINITDEPTH 200 |
534 | #endif | 637 | #endif |
535 | 638 | ||
536 | /* YYMAXDEPTH is the maximum size the stacks can grow to | 639 | /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only |
537 | (effective only if the built-in stack extension method is used). */ | 640 | if the built-in stack extension method is used). |
641 | |||
642 | Do not make this value too large; the results are undefined if | ||
643 | SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) | ||
644 | evaluated with infinite-precision integer arithmetic. */ | ||
538 | 645 | ||
539 | #if YYMAXDEPTH == 0 | 646 | #if YYMAXDEPTH == 0 |
540 | #undef YYMAXDEPTH | 647 | # undef YYMAXDEPTH |
541 | #endif | 648 | #endif |
542 | 649 | ||
543 | #ifndef YYMAXDEPTH | 650 | #ifndef YYMAXDEPTH |
544 | #define YYMAXDEPTH 10000 | 651 | # define YYMAXDEPTH 10000 |
545 | #endif | 652 | #endif |
546 | 653 | ||
547 | /* Define __yy_memcpy. Note that the size argument | 654 | #ifdef YYERROR_VERBOSE |
548 | should be passed with type unsigned int, because that is what the non-GCC | ||
549 | definitions require. With GCC, __builtin_memcpy takes an arg | ||
550 | of type size_t, but it can handle unsigned int. */ | ||
551 | |||
552 | #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ | ||
553 | #define __yy_memcpy(TO,FROM,COUNT)__builtin_memcpy(TO,FROM,COUNT) | ||
554 | #else /* not GNU C or C++ */ | ||
555 | #ifndef __cplusplus | ||
556 | |||
557 | /* This is the most reliable way to avoid incompatibilities | ||
558 | in available built-in functions on various systems. */ | ||
559 | static void | ||
560 | __yy_memcpy (to, from, count) | ||
561 | char *to; | ||
562 | char *from; | ||
563 | unsigned int count; | ||
564 | { | ||
565 | register char *f = from; | ||
566 | register char *t = to; | ||
567 | register int i = count; | ||
568 | 655 | ||
569 | while (i-- > 0) | 656 | # ifndef yystrlen |
570 | *t++ = *f++; | 657 | # if defined (__GLIBC__) && defined (_STRING_H) |
571 | } | 658 | # define yystrlen strlen |
659 | # else | ||
660 | /* Return the length of YYSTR. */ | ||
661 | static YYSIZE_T | ||
662 | # if defined (__STDC__) || defined (__cplusplus) | ||
663 | yystrlen (const char *yystr) | ||
664 | # else | ||
665 | yystrlen (yystr) | ||
666 | const char *yystr; | ||
667 | # endif | ||
668 | { | ||
669 | register const char *yys = yystr; | ||
572 | 670 | ||
573 | #else /* __cplusplus */ | 671 | while (*yys++ != '\0') |
672 | continue; | ||
574 | 673 | ||
575 | /* This is the most reliable way to avoid incompatibilities | 674 | return yys - yystr - 1; |
576 | in available built-in functions on various systems. */ | 675 | } |
577 | static void | 676 | # endif |
578 | __yy_memcpy (char *to, char *from, unsigned int count) | 677 | # endif |
678 | |||
679 | # ifndef yystpcpy | ||
680 | # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) | ||
681 | # define yystpcpy stpcpy | ||
682 | # else | ||
683 | /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in | ||
684 | YYDEST. */ | ||
685 | static char * | ||
686 | # if defined (__STDC__) || defined (__cplusplus) | ||
687 | yystpcpy (char *yydest, const char *yysrc) | ||
688 | # else | ||
689 | yystpcpy (yydest, yysrc) | ||
690 | char *yydest; | ||
691 | const char *yysrc; | ||
692 | # endif | ||
579 | { | 693 | { |
580 | register char *t = to; | 694 | register char *yyd = yydest; |
581 | register char *f = from; | 695 | register const char *yys = yysrc; |
582 | register int i = count; | ||
583 | 696 | ||
584 | while (i-- > 0) | 697 | while ((*yyd++ = *yys++) != '\0') |
585 | *t++ = *f++; | 698 | continue; |
586 | } | ||
587 | 699 | ||
588 | #endif | 700 | return yyd - 1; |
701 | } | ||
702 | # endif | ||
703 | # endif | ||
589 | #endif | 704 | #endif |
590 | 705 | ||
591 | #line 217 "/usr/share/bison.simple" | 706 | #line 315 "/usr/share/bison/bison.simple" |
707 | |||
592 | 708 | ||
593 | /* The user can define YYPARSE_PARAM as the name of an argument to be passed | 709 | /* The user can define YYPARSE_PARAM as the name of an argument to be passed |
594 | into yyparse. The argument should have type void *. | 710 | into yyparse. The argument should have type void *. |
595 | It should actually point to an object. | 711 | It should actually point to an object. |
596 | Grammar actions can access the variable by casting it | 712 | Grammar actions can access the variable by casting it |
597 | to the proper pointer type. */ | 713 | to the proper pointer type. */ |
598 | 714 | ||
599 | #ifdef YYPARSE_PARAM | 715 | #ifdef YYPARSE_PARAM |
600 | #ifdef __cplusplus | 716 | # if defined (__STDC__) || defined (__cplusplus) |
601 | #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM | 717 | # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM |
602 | #define YYPARSE_PARAM_DECL | 718 | # define YYPARSE_PARAM_DECL |
603 | #else /* not __cplusplus */ | 719 | # else |
604 | #define YYPARSE_PARAM_ARG YYPARSE_PARAM | 720 | # define YYPARSE_PARAM_ARG YYPARSE_PARAM |
605 | #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; | 721 | # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; |
606 | #endif /* not __cplusplus */ | 722 | # endif |
607 | #else /* not YYPARSE_PARAM */ | 723 | #else /* !YYPARSE_PARAM */ |
608 | #define YYPARSE_PARAM_ARG | 724 | # define YYPARSE_PARAM_ARG |
609 | #define YYPARSE_PARAM_DECL | 725 | # define YYPARSE_PARAM_DECL |
610 | #endif /* not YYPARSE_PARAM */ | 726 | #endif /* !YYPARSE_PARAM */ |
611 | 727 | ||
612 | /* Prevent warning if -Wstrict-prototypes. */ | 728 | /* Prevent warning if -Wstrict-prototypes. */ |
613 | #if defined (__GNUC__) && ! defined (__cplusplus) | 729 | #ifdef __GNUC__ |
614 | #ifdef YYPARSE_PARAM | 730 | # ifdef YYPARSE_PARAM |
615 | int yyparse (void *); | 731 | int yyparse (void *); |
616 | #else | 732 | # else |
617 | int yyparse (void); | 733 | int yyparse (void); |
734 | # endif | ||
618 | #endif | 735 | #endif |
736 | |||
737 | /* YY_DECL_VARIABLES -- depending whether we use a pure parser, | ||
738 | variables are global, or local to YYPARSE. */ | ||
739 | |||
740 | #define YY_DECL_NON_LSP_VARIABLES \ | ||
741 | /* The lookahead symbol. */ \ | ||
742 | int yychar; \ | ||
743 | \ | ||
744 | /* The semantic value of the lookahead symbol. */\ | ||
745 | YYSTYPE yylval; \ | ||
746 | \ | ||
747 | /* Number of parse errors so far. */ \ | ||
748 | int yynerrs; | ||
749 | |||
750 | #if YYLSP_NEEDED | ||
751 | # define YY_DECL_VARIABLES \ | ||
752 | YY_DECL_NON_LSP_VARIABLES \ | ||
753 | \ | ||
754 | /* Location data for the lookahead symbol. */\ | ||
755 | YYLTYPE yylloc; | ||
756 | #else | ||
757 | # define YY_DECL_VARIABLES \ | ||
758 | YY_DECL_NON_LSP_VARIABLES | ||
619 | #endif | 759 | #endif |
620 | 760 | ||
761 | |||
762 | /* If nonreentrant, generate the variables here. */ | ||
763 | |||
764 | #if !YYPURE | ||
765 | YY_DECL_VARIABLES | ||
766 | #endif /* !YYPURE */ | ||
767 | |||
621 | int | 768 | int |
622 | yyparse(YYPARSE_PARAM_ARG) | 769 | yyparse (YYPARSE_PARAM_ARG) |
623 | YYPARSE_PARAM_DECL | 770 | YYPARSE_PARAM_DECL |
624 | { | 771 | { |
772 | /* If reentrant, generate the variables here. */ | ||
773 | #if YYPURE | ||
774 | YY_DECL_VARIABLES | ||
775 | #endif /* !YYPURE */ | ||
776 | |||
625 | register int yystate; | 777 | register int yystate; |
626 | register int yyn; | 778 | register int yyn; |
779 | int yyresult; | ||
780 | /* Number of tokens to shift before error messages enabled. */ | ||
781 | int yyerrstatus; | ||
782 | /* Lookahead token as an internal (translated) token number. */ | ||
783 | int yychar1 = 0; | ||
784 | |||
785 | /* Three stacks and their tools: | ||
786 | `yyss': related to states, | ||
787 | `yyvs': related to semantic values, | ||
788 | `yyls': related to locations. | ||
789 | |||
790 | Refer to the stacks thru separate pointers, to allow yyoverflow | ||
791 | to reallocate them elsewhere. */ | ||
792 | |||
793 | /* The state stack. */ | ||
794 | shortyyssa[YYINITDEPTH]; | ||
795 | short *yyss = yyssa; | ||
627 | register short *yyssp; | 796 | register short *yyssp; |
628 | register YYSTYPE *yyvsp; | ||
629 | int yyerrstatus;/* number of tokens to shift before error messages enabled */ | ||
630 | int yychar1 = 0; /* lookahead token as an internal (translated) token number */ | ||
631 | 797 | ||
632 | short yyssa[YYINITDEPTH]; /* the state stack */ | 798 | /* The semantic value stack. */ |
633 | YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ | 799 | YYSTYPE yyvsa[YYINITDEPTH]; |
634 | 800 | YYSTYPE *yyvs = yyvsa; | |
635 | short *yyss = yyssa; /* refer to the stacks thru separate pointers */ | 801 | register YYSTYPE *yyvsp; |
636 | YYSTYPE *yyvs = yyvsa;/* to allow yyoverflow to reallocate them elsewhere */ | ||
637 | 802 | ||
638 | #ifdef YYLSP_NEEDED | 803 | #if YYLSP_NEEDED |
639 | YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ | 804 | /* The location stack. */ |
805 | YYLTYPE yylsa[YYINITDEPTH]; | ||
640 | YYLTYPE *yyls = yylsa; | 806 | YYLTYPE *yyls = yylsa; |
641 | YYLTYPE *yylsp; | 807 | YYLTYPE *yylsp; |
808 | #endif | ||
642 | 809 | ||
643 | #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) | 810 | #if YYLSP_NEEDED |
811 | # define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) | ||
644 | #else | 812 | #else |
645 | #define YYPOPSTACK (yyvsp--, yyssp--) | 813 | # define YYPOPSTACK (yyvsp--, yyssp--) |
646 | #endif | 814 | #endif |
647 | 815 | ||
648 | int yystacksize = YYINITDEPTH; | 816 | YYSIZE_T yystacksize = YYINITDEPTH; |
649 | int yyfree_stacks = 0; | ||
650 | 817 | ||
651 | #ifdef YYPURE | ||
652 | int yychar; | ||
653 | YYSTYPE yylval; | ||
654 | int yynerrs; | ||
655 | #ifdef YYLSP_NEEDED | ||
656 | YYLTYPE yylloc; | ||
657 | #endif | ||
658 | #endif | ||
659 | 818 | ||
660 | YYSTYPE yyval; /* the variable used to return */ | 819 | /* The variables used to return semantic value and location from the |
661 | /* semantic values from the action*/ | 820 | action routines. */ |
662 | /* routines */ | 821 | YYSTYPE yyval; |
822 | #if YYLSP_NEEDED | ||
823 | YYLTYPE yyloc; | ||
824 | #endif | ||
663 | 825 | ||
826 | /* When reducing, the number of symbols on the RHS of the reduced | ||
827 | rule. */ | ||
664 | int yylen; | 828 | int yylen; |
665 | 829 | ||
666 | #if YYDEBUG != 0 | 830 | YYDPRINTF ((stderr, "Starting parse\n")); |
667 | if (yydebug) | ||
668 | fprintf(stderr, "Starting parse\n"); | ||
669 | #endif | ||
670 | 831 | ||
671 | yystate = 0; | 832 | yystate = 0; |
672 | yyerrstatus = 0; | 833 | yyerrstatus = 0; |
673 | yynerrs = 0; | 834 | yynerrs = 0; |
@@ -677,112 +838,112 @@ yyparse(YYPARSE_PARAM_ARG) | |||
677 | Waste one element of value and location stack | 838 | Waste one element of value and location stack |
678 | so that they stay on the same level as the state stack. | 839 | so that they stay on the same level as the state stack. |
679 | The wasted elements are never initialized. */ | 840 | The wasted elements are never initialized. */ |
680 | 841 | ||
681 | yyssp = yyss - 1; | 842 | yyssp = yyss; |
682 | yyvsp = yyvs; | 843 | yyvsp = yyvs; |
683 | #ifdef YYLSP_NEEDED | 844 | #if YYLSP_NEEDED |
684 | yylsp = yyls; | 845 | yylsp = yyls; |
685 | #endif | 846 | #endif |
847 | goto yysetstate; | ||
848 | |||
849 | /*------------------------------------------------------------. | ||
850 | | yynewstate -- Push a new state, which is found in yystate. | | ||
851 | `------------------------------------------------------------*/ | ||
852 | yynewstate: | ||
853 | /* In all cases, when you get here, the value and location stacks | ||
854 | have just been pushed. so pushing a state here evens the stacks. | ||
855 | */ | ||
856 | yyssp++; | ||
686 | 857 | ||
687 | /* Push a new state, which is found in yystate . */ | 858 | yysetstate: |
688 | /* In all cases, when you get here, the value and location stacks | 859 | *yyssp = yystate; |
689 | have just been pushed. so pushing a state here evens the stacks. */ | ||
690 | yynewstate: | ||
691 | |||
692 | *++yyssp = yystate; | ||
693 | 860 | ||
694 | if (yyssp >= yyss + yystacksize - 1) | 861 | if (yyssp >= yyss + yystacksize - 1) |
695 | { | 862 | { |
696 | /* Give user a chance to reallocate the stack */ | ||
697 | /* Use copies of these so that the &'s don't force the real ones into memory. */ | ||
698 | YYSTYPE *yyvs1 = yyvs; | ||
699 | short *yyss1 = yyss; | ||
700 | #ifdef YYLSP_NEEDED | ||
701 | YYLTYPE *yyls1 = yyls; | ||
702 | #endif | ||
703 | |||
704 | /* Get the current used size of the three stacks, in elements. */ | 863 | /* Get the current used size of the three stacks, in elements. */ |
705 | int size = yyssp - yyss + 1; | 864 | YYSIZE_T yysize = yyssp - yyss + 1; |
706 | 865 | ||
707 | #ifdef yyoverflow | 866 | #ifdef yyoverflow |
708 | /* Each stack pointer address is followed by the size of | 867 | { |
709 | the data in use in that stack, in bytes. */ | 868 | /* Give user a chance to reallocate the stack. Use copies of |
710 | #ifdef YYLSP_NEEDED | 869 | these so that the &'s don't force the real ones into |
711 | /* This used to be a conditional around just the two extra args, | 870 | memory. */ |
712 | but that might be undefined if yyoverflow is a macro. */ | 871 | YYSTYPE *yyvs1 = yyvs; |
713 | yyoverflow("parser stack overflow", | 872 | short *yyss1 = yyss; |
714 | &yyss1, size * sizeof (*yyssp), | 873 | |
715 | &yyvs1, size * sizeof (*yyvsp), | 874 | /* Each stack pointer address is followed by the size of the |
716 | &yyls1, size * sizeof (*yylsp), | 875 | data in use in that stack, in bytes. */ |
717 | &yystacksize); | 876 | # if YYLSP_NEEDED |
718 | #else | 877 | YYLTYPE *yyls1 = yyls; |
719 | yyoverflow("parser stack overflow", | 878 | /* This used to be a conditional around just the two extra args, |
720 | &yyss1, size * sizeof (*yyssp), | 879 | but that might be undefined if yyoverflow is a macro. */ |
721 | &yyvs1, size * sizeof (*yyvsp), | 880 | yyoverflow ("parser stack overflow", |
722 | &yystacksize); | 881 | &yyss1, yysize * sizeof (*yyssp), |
723 | #endif | 882 | &yyvs1, yysize * sizeof (*yyvsp), |
724 | 883 | &yyls1, yysize * sizeof (*yylsp), | |
725 | yyss = yyss1; yyvs = yyvs1; | 884 | &yystacksize); |
726 | #ifdef YYLSP_NEEDED | 885 | yyls = yyls1; |
727 | yyls = yyls1; | 886 | # else |
728 | #endif | 887 | yyoverflow ("parser stack overflow", |
888 | &yyss1, yysize * sizeof (*yyssp), | ||
889 | &yyvs1, yysize * sizeof (*yyvsp), | ||
890 | &yystacksize); | ||
891 | # endif | ||
892 | yyss = yyss1; | ||
893 | yyvs = yyvs1; | ||
894 | } | ||
729 | #else /* no yyoverflow */ | 895 | #else /* no yyoverflow */ |
896 | # ifndef YYSTACK_RELOCATE | ||
897 | goto yyoverflowlab; | ||
898 | # else | ||
730 | /* Extend the stack our own way. */ | 899 | /* Extend the stack our own way. */ |
731 | if (yystacksize >= YYMAXDEPTH) | 900 | if (yystacksize >= YYMAXDEPTH) |
732 | { | 901 | goto yyoverflowlab; |
733 | yyerror("parser stack overflow"); | ||
734 | if (yyfree_stacks) | ||
735 | { | ||
736 | free (yyss); | ||
737 | free (yyvs); | ||
738 | #ifdef YYLSP_NEEDED | ||
739 | free (yyls); | ||
740 | #endif | ||
741 | } | ||
742 | return 2; | ||
743 | } | ||
744 | yystacksize *= 2; | 902 | yystacksize *= 2; |
745 | if (yystacksize > YYMAXDEPTH) | 903 | if (yystacksize > YYMAXDEPTH) |
746 | yystacksize = YYMAXDEPTH; | 904 | yystacksize = YYMAXDEPTH; |
747 | #ifndef YYSTACK_USE_ALLOCA | 905 | |
748 | yyfree_stacks = 1; | 906 | { |
749 | #endif | 907 | short *yyss1 = yyss; |
750 | yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); | 908 | union yyalloc *yyptr = |
751 | __yy_memcpy ((char *)yyss, (char *)yyss1, | 909 | (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); |
752 | size * (unsigned int) sizeof (*yyssp)); | 910 | if (! yyptr) |
753 | yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); | 911 | goto yyoverflowlab; |
754 | __yy_memcpy ((char *)yyvs, (char *)yyvs1, | 912 | YYSTACK_RELOCATE (yyss); |
755 | size * (unsigned int) sizeof (*yyvsp)); | 913 | YYSTACK_RELOCATE (yyvs); |
756 | #ifdef YYLSP_NEEDED | 914 | # if YYLSP_NEEDED |
757 | yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); | 915 | YYSTACK_RELOCATE (yyls); |
758 | __yy_memcpy ((char *)yyls, (char *)yyls1, | 916 | # endif |
759 | size * (unsigned int) sizeof (*yylsp)); | 917 | # undef YYSTACK_RELOCATE |
760 | #endif | 918 | if (yyss1 != yyssa) |
919 | YYSTACK_FREE (yyss1); | ||
920 | } | ||
921 | # endif | ||
761 | #endif /* no yyoverflow */ | 922 | #endif /* no yyoverflow */ |
762 | 923 | ||
763 | yyssp = yyss + size - 1; | 924 | yyssp = yyss + yysize - 1; |
764 | yyvsp = yyvs + size - 1; | 925 | yyvsp = yyvs + yysize - 1; |
765 | #ifdef YYLSP_NEEDED | 926 | #if YYLSP_NEEDED |
766 | yylsp = yyls + size - 1; | 927 | yylsp = yyls + yysize - 1; |
767 | #endif | 928 | #endif |
768 | 929 | ||
769 | #if YYDEBUG != 0 | 930 | YYDPRINTF ((stderr, "Stack size increased to %lu\n", |
770 | if (yydebug) | 931 | (unsigned long int) yystacksize)); |
771 | fprintf(stderr, "Stack size increased to %d\n", yystacksize); | ||
772 | #endif | ||
773 | 932 | ||
774 | if (yyssp >= yyss + yystacksize - 1) | 933 | if (yyssp >= yyss + yystacksize - 1) |
775 | YYABORT; | 934 | YYABORT; |
776 | } | 935 | } |
777 | 936 | ||
778 | #if YYDEBUG != 0 | 937 | YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
779 | if (yydebug) | ||
780 | fprintf(stderr, "Entering state %d\n", yystate); | ||
781 | #endif | ||
782 | 938 | ||
783 | goto yybackup; | 939 | goto yybackup; |
784 | yybackup: | 940 | |
941 | |||
942 | /*-----------. | ||
943 | | yybackup. | | ||
944 | `-----------*/ | ||
945 | yybackup: | ||
785 | 946 | ||
786 | /* Do appropriate processing given the current state. */ | 947 | /* Do appropriate processing given the current state. */ |
787 | /* Read a lookahead token if we need one and don't already have one. */ | 948 | /* Read a lookahead token if we need one and don't already have one. */ |
788 | /* yyresume: */ | 949 | /* yyresume: */ |
@@ -799,12 +960,9 @@ yynewstate: | |||
799 | or a valid token in external form. */ | 960 | or a valid token in external form. */ |
800 | 961 | ||
801 | if (yychar == YYEMPTY) | 962 | if (yychar == YYEMPTY) |
802 | { | 963 | { |
803 | #if YYDEBUG != 0 | 964 | YYDPRINTF ((stderr, "Reading a token: ")); |
804 | if (yydebug) | ||
805 | fprintf(stderr, "Reading a token: "); | ||
806 | #endif | ||
807 | yychar = YYLEX; | 965 | yychar = YYLEX; |
808 | } | 966 | } |
809 | 967 | ||
810 | /* Convert token to internal form (in yychar1) for indexing tables with */ | 968 | /* Convert token to internal form (in yychar1) for indexing tables with */ |
@@ -813,27 +971,27 @@ yynewstate: | |||
813 | { | 971 | { |
814 | yychar1 = 0; | 972 | yychar1 = 0; |
815 | yychar = YYEOF; /* Don't call YYLEX any more */ | 973 | yychar = YYEOF; /* Don't call YYLEX any more */ |
816 | 974 | ||
817 | #if YYDEBUG != 0 | 975 | YYDPRINTF ((stderr, "Now at end of input.\n")); |
818 | if (yydebug) | ||
819 | fprintf(stderr, "Now at end of input.\n"); | ||
820 | #endif | ||
821 | } | 976 | } |
822 | else | 977 | else |
823 | { | 978 | { |
824 | yychar1 = YYTRANSLATE(yychar); | 979 | yychar1 = YYTRANSLATE (yychar); |
825 | 980 | ||
826 | #if YYDEBUG != 0 | 981 | #if YYDEBUG |
982 | /* We have to keep this `#if YYDEBUG', since we use variables | ||
983 | which are defined only if `YYDEBUG' is set. */ | ||
827 | if (yydebug) | 984 | if (yydebug) |
828 | { | 985 | { |
829 | fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); | 986 | YYFPRINTF (stderr, "Next token is %d (%s", |
830 | /* Give the individual parser a way to print the precise meaning | 987 | yychar, yytname[yychar1]); |
831 | of a token, for further debugging info. */ | 988 | /* Give the individual parser a way to print the precise |
832 | #ifdef YYPRINT | 989 | meaning of a token, for further debugging info. */ |
990 | # ifdef YYPRINT | ||
833 | YYPRINT (stderr, yychar, yylval); | 991 | YYPRINT (stderr, yychar, yylval); |
834 | #endif | 992 | # endif |
835 | fprintf (stderr, ")\n"); | 993 | YYFPRINTF (stderr, ")\n"); |
836 | } | 994 | } |
837 | #endif | 995 | #endif |
838 | } | 996 | } |
839 | 997 | ||
@@ -863,263 +1021,271 @@ yynewstate: | |||
863 | if (yyn == YYFINAL) | 1021 | if (yyn == YYFINAL) |
864 | YYACCEPT; | 1022 | YYACCEPT; |
865 | 1023 | ||
866 | /* Shift the lookahead token. */ | 1024 | /* Shift the lookahead token. */ |
867 | 1025 | YYDPRINTF ((stderr, "Shifting token %d (%s), ", | |
868 | #if YYDEBUG != 0 | 1026 | yychar, yytname[yychar1])); |
869 | if (yydebug) | ||
870 | fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); | ||
871 | #endif | ||
872 | 1027 | ||
873 | /* Discard the token being shifted unless it is eof. */ | 1028 | /* Discard the token being shifted unless it is eof. */ |
874 | if (yychar != YYEOF) | 1029 | if (yychar != YYEOF) |
875 | yychar = YYEMPTY; | 1030 | yychar = YYEMPTY; |
876 | 1031 | ||
877 | *++yyvsp = yylval; | 1032 | *++yyvsp = yylval; |
878 | #ifdef YYLSP_NEEDED | 1033 | #if YYLSP_NEEDED |
879 | *++yylsp = yylloc; | 1034 | *++yylsp = yylloc; |
880 | #endif | 1035 | #endif |
881 | 1036 | ||
882 | /* count tokens shifted since error; after three, turn off error status. */ | 1037 | /* Count tokens shifted since error; after three, turn off error |
883 | if (yyerrstatus) yyerrstatus--; | 1038 | status. */ |
1039 | if (yyerrstatus) | ||
1040 | yyerrstatus--; | ||
884 | 1041 | ||
885 | yystate = yyn; | 1042 | yystate = yyn; |
886 | goto yynewstate; | 1043 | goto yynewstate; |
887 | 1044 | ||
888 | /* Do the default action for the current state. */ | ||
889 | yydefault: | ||
890 | 1045 | ||
1046 | /*-----------------------------------------------------------. | ||
1047 | | yydefault -- do the default action for the current state. | | ||
1048 | `-----------------------------------------------------------*/ | ||
1049 | yydefault: | ||
891 | yyn = yydefact[yystate]; | 1050 | yyn = yydefact[yystate]; |
892 | if (yyn == 0) | 1051 | if (yyn == 0) |
893 | goto yyerrlab; | 1052 | goto yyerrlab; |
1053 | goto yyreduce; | ||
894 | 1054 | ||
895 | /* Do a reduction. yyn is the number of a rule to reduce with. */ | 1055 | |
1056 | /*-----------------------------. | ||
1057 | | yyreduce -- Do a reduction. | | ||
1058 | `-----------------------------*/ | ||
896 | yyreduce: | 1059 | yyreduce: |
1060 | /* yyn is the number of a rule to reduce with. */ | ||
897 | yylen = yyr2[yyn]; | 1061 | yylen = yyr2[yyn]; |
898 | if (yylen > 0) | ||
899 | yyval = yyvsp[1-yylen]; /* implement default value of the action */ | ||
900 | 1062 | ||
901 | #if YYDEBUG != 0 | 1063 | /* If YYLEN is nonzero, implement the default value of the action: |
1064 | `$$ = $1'. | ||
1065 | |||
1066 | Otherwise, the following line sets YYVAL to the semantic value of | ||
1067 | the lookahead token. This behavior is undocumented and Bison | ||
1068 | users should not rely upon it. Assigning to YYVAL | ||
1069 | unconditionally makes the parser a bit smaller, and it avoids a | ||
1070 | GCC warning that YYVAL may be used uninitialized. */ | ||
1071 | yyval = yyvsp[1-yylen]; | ||
1072 | |||
1073 | #if YYLSP_NEEDED | ||
1074 | /* Similarly for the default location. Let the user run additional | ||
1075 | commands if for instance locations are ranges. */ | ||
1076 | yyloc = yylsp[1-yylen]; | ||
1077 | YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); | ||
1078 | #endif | ||
1079 | |||
1080 | #if YYDEBUG | ||
1081 | /* We have to keep this `#if YYDEBUG', since we use variables which | ||
1082 | are defined only if `YYDEBUG' is set. */ | ||
902 | if (yydebug) | 1083 | if (yydebug) |
903 | { | 1084 | { |
904 | int i; | 1085 | int yyi; |
905 | 1086 | ||
906 | fprintf (stderr, "Reducing via rule %d (line %d), ", | 1087 | YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", |
907 | yyn, yyrline[yyn]); | 1088 | yyn, yyrline[yyn]); |
908 | 1089 | ||
909 | /* Print the symbols being reduced, and their result. */ | 1090 | /* Print the symbols being reduced, and their result. */ |
910 | for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) | 1091 | for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) |
911 | fprintf (stderr, "%s ", yytname[yyrhs[i]]); | 1092 | YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); |
912 | fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); | 1093 | YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); |
913 | } | 1094 | } |
914 | #endif | 1095 | #endif |
915 | 1096 | ||
916 | |||
917 | switch (yyn) { | 1097 | switch (yyn) { |
918 | 1098 | ||
919 | case 2: | 1099 | case 2: |
920 | #line 213 "./vcc.y" | 1100 | #line 212 "vcc.y" |
921 | { addList(&vObjList, yyvsp[0].vobj); curObj = 0; ; | 1101 | { addList(&vObjList, yyvsp[0].vobj); curObj = 0; } |
922 | break;} | 1102 | break; |
923 | case 4: | 1103 | case 4: |
924 | #line 216 "./vcc.y" | 1104 | #line 215 "vcc.y" |
925 | { addList(&vObjList, yyvsp[0].vobj); curObj = 0; ; | 1105 | { addList(&vObjList, yyvsp[0].vobj); curObj = 0; } |
926 | break;} | 1106 | break; |
927 | case 7: | 1107 | case 7: |
928 | #line 225 "./vcc.y" | 1108 | #line 224 "vcc.y" |
929 | { | 1109 | { |
930 | lexPushMode(L_VCARD); | 1110 | lexPushMode(L_VCARD); |
931 | if (!pushVObject(VCCardProp)) YYERROR; | 1111 | if (!pushVObject(VCCardProp)) YYERROR; |
932 | ; | 1112 | } |
933 | break;} | 1113 | break; |
934 | case 8: | 1114 | case 8: |
935 | #line 230 "./vcc.y" | 1115 | #line 229 "vcc.y" |
936 | { | 1116 | { |
937 | lexPopMode(0); | 1117 | lexPopMode(0); |
938 | yyval.vobj = popVObject(); | 1118 | yyval.vobj = popVObject(); |
939 | ; | 1119 | } |
940 | break;} | 1120 | break; |
941 | case 9: | 1121 | case 9: |
942 | #line 235 "./vcc.y" | 1122 | #line 234 "vcc.y" |
943 | { | 1123 | { |
944 | lexPushMode(L_VCARD); | 1124 | lexPushMode(L_VCARD); |
945 | if (!pushVObject(VCCardProp)) YYERROR; | 1125 | if (!pushVObject(VCCardProp)) YYERROR; |
946 | ; | 1126 | } |
947 | break;} | 1127 | break; |
948 | case 10: | 1128 | case 10: |
949 | #line 240 "./vcc.y" | 1129 | #line 239 "vcc.y" |
950 | { | 1130 | { |
951 | lexPopMode(0); | 1131 | lexPopMode(0); |
952 | yyval.vobj = popVObject(); | 1132 | yyval.vobj = popVObject(); |
953 | ; | 1133 | } |
954 | break;} | 1134 | break; |
955 | case 13: | 1135 | case 13: |
956 | #line 251 "./vcc.y" | 1136 | #line 250 "vcc.y" |
957 | { | 1137 | { |
958 | lexPushMode(L_VALUES); | 1138 | lexPushMode(L_VALUES); |
959 | ; | 1139 | } |
960 | break;} | 1140 | break; |
961 | case 14: | 1141 | case 14: |
962 | #line 255 "./vcc.y" | 1142 | #line 254 "vcc.y" |
963 | { | 1143 | { |
964 | if (lexWithinMode(L_BASE64) || lexWithinMode(L_QUOTED_PRINTABLE)) | 1144 | if (lexWithinMode(L_BASE64) || lexWithinMode(L_QUOTED_PRINTABLE)) |
965 | lexPopMode(0); | 1145 | lexPopMode(0); |
966 | lexPopMode(0); | 1146 | lexPopMode(0); |
967 | ; | 1147 | } |
968 | break;} | 1148 | break; |
969 | case 16: | 1149 | case 16: |
970 | #line 264 "./vcc.y" | 1150 | #line 263 "vcc.y" |
971 | { | 1151 | { |
972 | enterProps(yyvsp[0].str); | 1152 | enterProps(yyvsp[0].str); |
973 | ; | 1153 | } |
974 | break;} | 1154 | break; |
975 | case 18: | 1155 | case 18: |
976 | #line 269 "./vcc.y" | 1156 | #line 268 "vcc.y" |
977 | { | 1157 | { |
978 | enterProps(yyvsp[0].str); | 1158 | enterProps(yyvsp[0].str); |
979 | ; | 1159 | } |
980 | break;} | 1160 | break; |
981 | case 22: | 1161 | case 22: |
982 | #line 282 "./vcc.y" | 1162 | #line 281 "vcc.y" |
983 | { | 1163 | { |
984 | enterAttr(yyvsp[0].str,0); | 1164 | enterAttr(yyvsp[0].str,0); |
985 | ; | 1165 | } |
986 | break;} | 1166 | break; |
987 | case 23: | 1167 | case 23: |
988 | #line 286 "./vcc.y" | 1168 | #line 285 "vcc.y" |
989 | { | 1169 | { |
990 | enterAttr(yyvsp[-2].str,yyvsp[0].str); | 1170 | enterAttr(yyvsp[-2].str,yyvsp[0].str); |
991 | 1171 | ||
992 | ; | 1172 | } |
993 | break;} | 1173 | break; |
994 | case 25: | 1174 | case 25: |
995 | #line 295 "./vcc.y" | 1175 | #line 294 "vcc.y" |
996 | { appendValue(yyvsp[-1].str); ; | 1176 | { enterValues(yyvsp[-1].str); } |
997 | break;} | 1177 | break; |
998 | case 27: | 1178 | case 27: |
999 | #line 297 "./vcc.y" | 1179 | #line 296 "vcc.y" |
1000 | { appendValue(yyvsp[0].str); ; | 1180 | { enterValues(yyvsp[0].str); } |
1001 | break;} | 1181 | break; |
1002 | case 29: | 1182 | case 29: |
1003 | #line 302 "./vcc.y" | 1183 | #line 300 "vcc.y" |
1004 | { yyval.str = 0; ; | 1184 | { yyval.str = 0; } |
1005 | break;} | 1185 | break; |
1006 | case 30: | 1186 | case 30: |
1007 | #line 307 "./vcc.y" | 1187 | #line 305 "vcc.y" |
1008 | { if (!pushVObject(VCCalProp)) YYERROR; ; | 1188 | { if (!pushVObject(VCCalProp)) YYERROR; } |
1009 | break;} | 1189 | break; |
1010 | case 31: | 1190 | case 31: |
1011 | #line 310 "./vcc.y" | 1191 | #line 308 "vcc.y" |
1012 | { yyval.vobj = popVObject(); ; | 1192 | { yyval.vobj = popVObject(); } |
1013 | break;} | 1193 | break; |
1014 | case 32: | 1194 | case 32: |
1015 | #line 312 "./vcc.y" | 1195 | #line 310 "vcc.y" |
1016 | { if (!pushVObject(VCCalProp)) YYERROR; ; | 1196 | { if (!pushVObject(VCCalProp)) YYERROR; } |
1017 | break;} | 1197 | break; |
1018 | case 33: | 1198 | case 33: |
1019 | #line 314 "./vcc.y" | 1199 | #line 312 "vcc.y" |
1020 | { yyval.vobj = popVObject(); ; | 1200 | { yyval.vobj = popVObject(); } |
1021 | break;} | 1201 | break; |
1022 | case 39: | 1202 | case 39: |
1023 | #line 329 "./vcc.y" | 1203 | #line 327 "vcc.y" |
1024 | { | 1204 | { |
1025 | lexPushMode(L_VEVENT); | 1205 | lexPushMode(L_VEVENT); |
1026 | if (!pushVObject(VCEventProp)) YYERROR; | 1206 | if (!pushVObject(VCEventProp)) YYERROR; |
1027 | ; | 1207 | } |
1028 | break;} | 1208 | break; |
1029 | case 40: | 1209 | case 40: |
1030 | #line 335 "./vcc.y" | 1210 | #line 333 "vcc.y" |
1031 | { | 1211 | { |
1032 | lexPopMode(0); | 1212 | lexPopMode(0); |
1033 | popVObject(); | 1213 | popVObject(); |
1034 | ; | 1214 | } |
1035 | break;} | 1215 | break; |
1036 | case 41: | 1216 | case 41: |
1037 | #line 340 "./vcc.y" | 1217 | #line 338 "vcc.y" |
1038 | { | 1218 | { |
1039 | lexPushMode(L_VEVENT); | 1219 | lexPushMode(L_VEVENT); |
1040 | if (!pushVObject(VCEventProp)) YYERROR; | 1220 | if (!pushVObject(VCEventProp)) YYERROR; |
1041 | ; | 1221 | } |
1042 | break;} | 1222 | break; |
1043 | case 42: | 1223 | case 42: |
1044 | #line 345 "./vcc.y" | 1224 | #line 343 "vcc.y" |
1045 | { | 1225 | { |
1046 | lexPopMode(0); | 1226 | lexPopMode(0); |
1047 | popVObject(); | 1227 | popVObject(); |
1048 | ; | 1228 | } |
1049 | break;} | 1229 | break; |
1050 | case 43: | 1230 | case 43: |
1051 | #line 353 "./vcc.y" | 1231 | #line 351 "vcc.y" |
1052 | { | 1232 | { |
1053 | lexPushMode(L_VTODO); | 1233 | lexPushMode(L_VTODO); |
1054 | if (!pushVObject(VCTodoProp)) YYERROR; | 1234 | if (!pushVObject(VCTodoProp)) YYERROR; |
1055 | ; | 1235 | } |
1056 | break;} | 1236 | break; |
1057 | case 44: | 1237 | case 44: |
1058 | #line 359 "./vcc.y" | 1238 | #line 357 "vcc.y" |
1059 | { | 1239 | { |
1060 | lexPopMode(0); | 1240 | lexPopMode(0); |
1061 | popVObject(); | 1241 | popVObject(); |
1062 | ; | 1242 | } |
1063 | break;} | 1243 | break; |
1064 | case 45: | 1244 | case 45: |
1065 | #line 364 "./vcc.y" | 1245 | #line 362 "vcc.y" |
1066 | { | 1246 | { |
1067 | lexPushMode(L_VTODO); | 1247 | lexPushMode(L_VTODO); |
1068 | if (!pushVObject(VCTodoProp)) YYERROR; | 1248 | if (!pushVObject(VCTodoProp)) YYERROR; |
1069 | ; | 1249 | } |
1070 | break;} | 1250 | break; |
1071 | case 46: | 1251 | case 46: |
1072 | #line 369 "./vcc.y" | 1252 | #line 367 "vcc.y" |
1073 | { | 1253 | { |
1074 | lexPopMode(0); | 1254 | lexPopMode(0); |
1075 | popVObject(); | 1255 | popVObject(); |
1076 | ; | 1256 | } |
1077 | break;} | 1257 | break; |
1078 | } | 1258 | } |
1079 | /* the action file gets copied in in place of this dollarsign */ | ||
1080 | #line 543 "/usr/share/bison.simple" | ||
1081 | 1259 | ||
1260 | #line 705 "/usr/share/bison/bison.simple" | ||
1261 | |||
1262 | |||
1082 | yyvsp -= yylen; | 1263 | yyvsp -= yylen; |
1083 | yyssp -= yylen; | 1264 | yyssp -= yylen; |
1084 | #ifdef YYLSP_NEEDED | 1265 | #if YYLSP_NEEDED |
1085 | yylsp -= yylen; | 1266 | yylsp -= yylen; |
1086 | #endif | 1267 | #endif |
1087 | 1268 | ||
1088 | #if YYDEBUG != 0 | 1269 | #if YYDEBUG |
1089 | if (yydebug) | 1270 | if (yydebug) |
1090 | { | 1271 | { |
1091 | short *ssp1 = yyss - 1; | 1272 | short *yyssp1 = yyss - 1; |
1092 | fprintf (stderr, "state stack now"); | 1273 | YYFPRINTF (stderr, "state stack now"); |
1093 | while (ssp1 != yyssp) | 1274 | while (yyssp1 != yyssp) |
1094 | fprintf (stderr, " %d", *++ssp1); | 1275 | YYFPRINTF (stderr, " %d", *++yyssp1); |
1095 | fprintf (stderr, "\n"); | 1276 | YYFPRINTF (stderr, "\n"); |
1096 | } | 1277 | } |
1097 | #endif | 1278 | #endif |
1098 | 1279 | ||
1099 | *++yyvsp = yyval; | 1280 | *++yyvsp = yyval; |
1100 | 1281 | #if YYLSP_NEEDED | |
1101 | #ifdef YYLSP_NEEDED | 1282 | *++yylsp = yyloc; |
1102 | yylsp++; | ||
1103 | if (yylen == 0) | ||
1104 | { | ||
1105 | yylsp->first_line = yylloc.first_line; | ||
1106 | yylsp->first_column = yylloc.first_column; | ||
1107 | yylsp->last_line = (yylsp-1)->last_line; | ||
1108 | yylsp->last_column = (yylsp-1)->last_column; | ||
1109 | yylsp->text = 0; | ||
1110 | } | ||
1111 | else | ||
1112 | { | ||
1113 | yylsp->last_line = (yylsp+yylen-1)->last_line; | ||
1114 | yylsp->last_column = (yylsp+yylen-1)->last_column; | ||
1115 | } | ||
1116 | #endif | 1283 | #endif |
1117 | 1284 | ||
1118 | /* Now "shift" the result of the reduction. | 1285 | /* Now `shift' the result of the reduction. Determine what state |
1119 | Determine what state that goes to, | 1286 | that goes to, based on the state we popped back to and the rule |
1120 | based on the state we popped back to | 1287 | number reduced by. */ |
1121 | and the rule number reduced by. */ | ||
1122 | 1288 | ||
1123 | yyn = yyr1[yyn]; | 1289 | yyn = yyr1[yyn]; |
1124 | 1290 | ||
1125 | yystate = yypgoto[yyn - YYNTBASE] + *yyssp; | 1291 | yystate = yypgoto[yyn - YYNTBASE] + *yyssp; |
@@ -1129,116 +1295,138 @@ case 46: | |||
1129 | yystate = yydefgoto[yyn - YYNTBASE]; | 1295 | yystate = yydefgoto[yyn - YYNTBASE]; |
1130 | 1296 | ||
1131 | goto yynewstate; | 1297 | goto yynewstate; |
1132 | 1298 | ||
1133 | yyerrlab: /* here on detecting error */ | ||
1134 | 1299 | ||
1135 | if (! yyerrstatus) | 1300 | /*------------------------------------. |
1136 | /* If not already recovering from an error, report this error. */ | 1301 | | yyerrlab -- here on detecting error | |
1302 | `------------------------------------*/ | ||
1303 | yyerrlab: | ||
1304 | /* If not already recovering from an error, report this error. */ | ||
1305 | if (!yyerrstatus) | ||
1137 | { | 1306 | { |
1138 | ++yynerrs; | 1307 | ++yynerrs; |
1139 | 1308 | ||
1140 | #ifdef YYERROR_VERBOSE | 1309 | #ifdef YYERROR_VERBOSE |
1141 | yyn = yypact[yystate]; | 1310 | yyn = yypact[yystate]; |
1142 | 1311 | ||
1143 | if (yyn > YYFLAG && yyn < YYLAST) | 1312 | if (yyn > YYFLAG && yyn < YYLAST) |
1144 | { | 1313 | { |
1145 | int size = 0; | 1314 | YYSIZE_T yysize = 0; |
1146 | char *msg; | 1315 | char *yymsg; |
1147 | int x, count; | 1316 | int yyx, yycount; |
1148 | 1317 | ||
1149 | count = 0; | 1318 | yycount = 0; |
1150 | /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ | 1319 | /* Start YYX at -YYN if negative to avoid negative indexes in |
1151 | for (x = (yyn < 0 ? -yyn : 0); | 1320 | YYCHECK. */ |
1152 | x < (sizeof(yytname) / sizeof(char *)); x++) | 1321 | for (yyx = yyn < 0 ? -yyn : 0; |
1153 | if (yycheck[x + yyn] == x) | 1322 | yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) |
1154 | size += strlen(yytname[x]) + 15, count++; | 1323 | if (yycheck[yyx + yyn] == yyx) |
1155 | msg = (char *) malloc(size + 15); | 1324 | yysize += yystrlen (yytname[yyx]) + 15, yycount++; |
1156 | if (msg != 0) | 1325 | yysize += yystrlen ("parse error, unexpected ") + 1; |
1326 | yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); | ||
1327 | yymsg = (char *) YYSTACK_ALLOC (yysize); | ||
1328 | if (yymsg != 0) | ||
1157 | { | 1329 | { |
1158 | strcpy(msg, "parse error"); | 1330 | char *yyp = yystpcpy (yymsg, "parse error, unexpected "); |
1331 | yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); | ||
1159 | 1332 | ||
1160 | if (count < 5) | 1333 | if (yycount < 5) |
1161 | { | 1334 | { |
1162 | count = 0; | 1335 | yycount = 0; |
1163 | for (x = (yyn < 0 ? -yyn : 0); | 1336 | for (yyx = yyn < 0 ? -yyn : 0; |
1164 | x < (sizeof(yytname) / sizeof(char *)); x++) | 1337 | yyx < (int) (sizeof (yytname) / sizeof (char *)); |
1165 | if (yycheck[x + yyn] == x) | 1338 | yyx++) |
1339 | if (yycheck[yyx + yyn] == yyx) | ||
1166 | { | 1340 | { |
1167 | strcat(msg, count == 0 ? ", expecting `" : " or `"); | 1341 | const char *yyq = ! yycount ? ", expecting " : " or "; |
1168 | strcat(msg, yytname[x]); | 1342 | yyp = yystpcpy (yyp, yyq); |
1169 | strcat(msg, "'"); | 1343 | yyp = yystpcpy (yyp, yytname[yyx]); |
1170 | count++; | 1344 | yycount++; |
1171 | } | 1345 | } |
1172 | } | 1346 | } |
1173 | yyerror(msg); | 1347 | yyerror (yymsg); |
1174 | free(msg); | 1348 | YYSTACK_FREE (yymsg); |
1175 | } | 1349 | } |
1176 | else | 1350 | else |
1177 | yyerror ("parse error; also virtual memory exceeded"); | 1351 | yyerror ("parse error; also virtual memory exhausted"); |
1178 | } | 1352 | } |
1179 | else | 1353 | else |
1180 | #endif /* YYERROR_VERBOSE */ | 1354 | #endif /* defined (YYERROR_VERBOSE) */ |
1181 | yyerror("parse error"); | 1355 | yyerror ("parse error"); |
1182 | } | 1356 | } |
1183 | |||
1184 | goto yyerrlab1; | 1357 | goto yyerrlab1; |
1185 | yyerrlab1: /* here on error raised explicitly by an action */ | ||
1186 | 1358 | ||
1359 | |||
1360 | /*--------------------------------------------------. | ||
1361 | | yyerrlab1 -- error raised explicitly by an action | | ||
1362 | `--------------------------------------------------*/ | ||
1363 | yyerrlab1: | ||
1187 | if (yyerrstatus == 3) | 1364 | if (yyerrstatus == 3) |
1188 | { | 1365 | { |
1189 | /* if just tried and failed to reuse lookahead token after an error, discard it. */ | 1366 | /* If just tried and failed to reuse lookahead token after an |
1367 | error, discard it. */ | ||
1190 | 1368 | ||
1191 | /* return failure if at end of input */ | 1369 | /* return failure if at end of input */ |
1192 | if (yychar == YYEOF) | 1370 | if (yychar == YYEOF) |
1193 | YYABORT; | 1371 | YYABORT; |
1194 | 1372 | YYDPRINTF ((stderr, "Discarding token %d (%s).\n", | |
1195 | #if YYDEBUG != 0 | 1373 | yychar, yytname[yychar1])); |
1196 | if (yydebug) | ||
1197 | fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); | ||
1198 | #endif | ||
1199 | |||
1200 | yychar = YYEMPTY; | 1374 | yychar = YYEMPTY; |
1201 | } | 1375 | } |
1202 | 1376 | ||
1203 | /* Else will try to reuse lookahead token | 1377 | /* Else will try to reuse lookahead token after shifting the error |
1204 | after shifting the error token. */ | 1378 | token. */ |
1205 | 1379 | ||
1206 | yyerrstatus = 3; /* Each real token shifted decrements this */ | 1380 | yyerrstatus = 3; /* Each real token shifted decrements this */ |
1207 | 1381 | ||
1208 | goto yyerrhandle; | 1382 | goto yyerrhandle; |
1209 | 1383 | ||
1210 | yyerrdefault: /* current state does not do anything special for the error token. */ | ||
1211 | 1384 | ||
1385 | /*-------------------------------------------------------------------. | ||
1386 | | yyerrdefault -- current state does not do anything special for the | | ||
1387 | | error token. | | ||
1388 | `-------------------------------------------------------------------*/ | ||
1389 | yyerrdefault: | ||
1212 | #if 0 | 1390 | #if 0 |
1213 | /* This is wrong; only states that explicitly want error tokens | 1391 | /* This is wrong; only states that explicitly want error tokens |
1214 | should shift them. */ | 1392 | should shift them. */ |
1215 | yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ | 1393 | |
1216 | if (yyn) goto yydefault; | 1394 | /* If its default is to accept any token, ok. Otherwise pop it. */ |
1395 | yyn = yydefact[yystate]; | ||
1396 | if (yyn) | ||
1397 | goto yydefault; | ||
1217 | #endif | 1398 | #endif |
1218 | 1399 | ||
1219 | yyerrpop: /* pop the current state because it cannot handle the error token */ | ||
1220 | 1400 | ||
1221 | if (yyssp == yyss) YYABORT; | 1401 | /*---------------------------------------------------------------. |
1402 | | yyerrpop -- pop the current state because it cannot handle the | | ||
1403 | | error token | | ||
1404 | `---------------------------------------------------------------*/ | ||
1405 | yyerrpop: | ||
1406 | if (yyssp == yyss) | ||
1407 | YYABORT; | ||
1222 | yyvsp--; | 1408 | yyvsp--; |
1223 | yystate = *--yyssp; | 1409 | yystate = *--yyssp; |
1224 | #ifdef YYLSP_NEEDED | 1410 | #if YYLSP_NEEDED |
1225 | yylsp--; | 1411 | yylsp--; |
1226 | #endif | 1412 | #endif |
1227 | 1413 | ||
1228 | #if YYDEBUG != 0 | 1414 | #if YYDEBUG |
1229 | if (yydebug) | 1415 | if (yydebug) |
1230 | { | 1416 | { |
1231 | short *ssp1 = yyss - 1; | 1417 | short *yyssp1 = yyss - 1; |
1232 | fprintf (stderr, "Error: state stack now"); | 1418 | YYFPRINTF (stderr, "Error: state stack now"); |
1233 | while (ssp1 != yyssp) | 1419 | while (yyssp1 != yyssp) |
1234 | fprintf (stderr, " %d", *++ssp1); | 1420 | YYFPRINTF (stderr, " %d", *++yyssp1); |
1235 | fprintf (stderr, "\n"); | 1421 | YYFPRINTF (stderr, "\n"); |
1236 | } | 1422 | } |
1237 | #endif | 1423 | #endif |
1238 | 1424 | ||
1425 | /*--------------. | ||
1426 | | yyerrhandle. | | ||
1427 | `--------------*/ | ||
1239 | yyerrhandle: | 1428 | yyerrhandle: |
1240 | |||
1241 | yyn = yypact[yystate]; | 1429 | yyn = yypact[yystate]; |
1242 | if (yyn == YYFLAG) | 1430 | if (yyn == YYFLAG) |
1243 | goto yyerrdefault; | 1431 | goto yyerrdefault; |
1244 | 1432 | ||
@@ -1259,48 +1447,50 @@ yyerrhandle: | |||
1259 | 1447 | ||
1260 | if (yyn == YYFINAL) | 1448 | if (yyn == YYFINAL) |
1261 | YYACCEPT; | 1449 | YYACCEPT; |
1262 | 1450 | ||
1263 | #if YYDEBUG != 0 | 1451 | YYDPRINTF ((stderr, "Shifting error token, ")); |
1264 | if (yydebug) | ||
1265 | fprintf(stderr, "Shifting error token, "); | ||
1266 | #endif | ||
1267 | 1452 | ||
1268 | *++yyvsp = yylval; | 1453 | *++yyvsp = yylval; |
1269 | #ifdef YYLSP_NEEDED | 1454 | #if YYLSP_NEEDED |
1270 | *++yylsp = yylloc; | 1455 | *++yylsp = yylloc; |
1271 | #endif | 1456 | #endif |
1272 | 1457 | ||
1273 | yystate = yyn; | 1458 | yystate = yyn; |
1274 | goto yynewstate; | 1459 | goto yynewstate; |
1275 | 1460 | ||
1276 | yyacceptlab: | ||
1277 | /* YYACCEPT comes here. */ | ||
1278 | if (yyfree_stacks) | ||
1279 | { | ||
1280 | free (yyss); | ||
1281 | free (yyvs); | ||
1282 | #ifdef YYLSP_NEEDED | ||
1283 | free (yyls); | ||
1284 | #endif | ||
1285 | } | ||
1286 | return 0; | ||
1287 | 1461 | ||
1288 | yyabortlab: | 1462 | /*-------------------------------------. |
1289 | /* YYABORT comes here. */ | 1463 | | yyacceptlab -- YYACCEPT comes here. | |
1290 | if (yyfree_stacks) | 1464 | `-------------------------------------*/ |
1291 | { | 1465 | yyacceptlab: |
1292 | free (yyss); | 1466 | yyresult = 0; |
1293 | free (yyvs); | 1467 | goto yyreturn; |
1294 | #ifdef YYLSP_NEEDED | 1468 | |
1295 | free (yyls); | 1469 | /*-----------------------------------. |
1470 | | yyabortlab -- YYABORT comes here. | | ||
1471 | `-----------------------------------*/ | ||
1472 | yyabortlab: | ||
1473 | yyresult = 1; | ||
1474 | goto yyreturn; | ||
1475 | |||
1476 | /*---------------------------------------------. | ||
1477 | | yyoverflowab -- parser overflow comes here. | | ||
1478 | `---------------------------------------------*/ | ||
1479 | yyoverflowlab: | ||
1480 | yyerror ("parser stack overflow"); | ||
1481 | yyresult = 2; | ||
1482 | /* Fall through. */ | ||
1483 | |||
1484 | yyreturn: | ||
1485 | #ifndef yyoverflow | ||
1486 | if (yyss != yyssa) | ||
1487 | YYSTACK_FREE (yyss); | ||
1296 | #endif | 1488 | #endif |
1297 | } | 1489 | return yyresult; |
1298 | return 1; | ||
1299 | } | 1490 | } |
1300 | #line 375 "./vcc.y" | 1491 | #line 373 "vcc.y" |
1301 | 1492 | ||
1302 | /****************************************************************************/ | ||
1303 | static int pushVObject(const char *prop) | 1493 | static int pushVObject(const char *prop) |
1304 | { | 1494 | { |
1305 | VObject *newObj; | 1495 | VObject *newObj; |
1306 | if (ObjStackTop == MAXLEVEL) | 1496 | if (ObjStackTop == MAXLEVEL) |
@@ -1318,9 +1508,8 @@ static int pushVObject(const char *prop) | |||
1318 | return TRUE; | 1508 | return TRUE; |
1319 | } | 1509 | } |
1320 | 1510 | ||
1321 | 1511 | ||
1322 | /****************************************************************************/ | ||
1323 | /* This pops the recently built vCard off the stack and returns it. */ | 1512 | /* This pops the recently built vCard off the stack and returns it. */ |
1324 | static VObject* popVObject() | 1513 | static VObject* popVObject() |
1325 | { | 1514 | { |
1326 | VObject *oldObj; | 1515 | VObject *oldObj; |
@@ -1334,61 +1523,46 @@ static VObject* popVObject() | |||
1334 | return oldObj; | 1523 | return oldObj; |
1335 | } | 1524 | } |
1336 | 1525 | ||
1337 | 1526 | ||
1338 | /* static void enterValues(const char *value) */ | 1527 | static void enterValues(const char *value) |
1339 | /* { */ | 1528 | { |
1340 | /* if (fieldedProp && *fieldedProp) { */ | 1529 | if (fieldedProp && *fieldedProp) { |
1341 | /* if (value) { */ | 1530 | if (value) { |
1342 | /* addPropValue(curProp,*fieldedProp,value); */ | 1531 | addPropValue(curProp,*fieldedProp,value); |
1343 | /* } */ | 1532 | } |
1344 | /* else this field is empty, advance to next field */ | 1533 | /* else this field is empty, advance to next field */ |
1345 | /* fieldedProp++; */ | 1534 | fieldedProp++; |
1346 | /* } */ | 1535 | } |
1347 | /* else { */ | 1536 | else { |
1348 | /* if (value) { */ | 1537 | if (value) { |
1349 | /* setVObjectUStringZValue_(curProp,fakeUnicode(value,0)); */ | 1538 | char *p1, *p2; |
1350 | /* } */ | 1539 | wchar_t *p3; |
1351 | /* } */ | 1540 | int i; |
1352 | /* deleteStr(value); */ | 1541 | |
1353 | /* } */ | 1542 | /* If the property already has a string value, we append this one, |
1354 | 1543 | using ';' to separate the values. */ | |
1355 | static void appendValue(const char *value) | 1544 | if (vObjectUStringZValue(curProp)) { |
1356 | { | 1545 | p1 = fakeCString(vObjectUStringZValue(curProp)); |
1357 | char *p1, *p2; | 1546 | p2 = malloc((strlen(p1)+strlen(value)+1)); |
1358 | wchar_t *p3; | 1547 | strcpy(p2, p1); |
1359 | int i; | 1548 | deleteStr(p1); |
1360 | 1549 | ||
1361 | if (fieldedProp && *fieldedProp) { | 1550 | i = strlen(p2); |
1362 | if (value) { | 1551 | p2[i] = ';'; |
1363 | addPropValue(curProp, *fieldedProp, value); | 1552 | p2[i+1] = '\0'; |
1553 | p2 = strcat(p2, value); | ||
1554 | p3 = (wchar_t *) vObjectUStringZValue(curProp); | ||
1555 | free(p3); | ||
1556 | setVObjectUStringZValue_(curProp,fakeUnicode(p2,0)); | ||
1557 | deleteStr(p2); | ||
1558 | } else { | ||
1559 | setVObjectUStringZValue_(curProp,fakeUnicode(value,0)); | ||
1560 | } | ||
1561 | } | ||
1364 | } | 1562 | } |
1365 | /* else this field is empty, advance to next field */ | 1563 | deleteStr(value); |
1366 | fieldedProp++; | ||
1367 | } else { | ||
1368 | if (value) { | ||
1369 | if (vObjectUStringZValue(curProp)) { | ||
1370 | p1 = fakeCString(vObjectUStringZValue(curProp)); | ||
1371 | p2 = malloc(sizeof(char *) * (strlen(p1)+strlen(value)+1)); | ||
1372 | strcpy(p2, p1); | ||
1373 | deleteStr(p1); | ||
1374 | |||
1375 | i = strlen(p2); | ||
1376 | p2[i] = ','; | ||
1377 | p2[i+1] = '\0'; | ||
1378 | p2 = strcat(p2, value); | ||
1379 | p3 = (wchar_t *) vObjectUStringZValue(curProp); | ||
1380 | free(p3); | ||
1381 | setVObjectUStringZValue_(curProp,fakeUnicode(p2,0)); | ||
1382 | deleteStr(p2); | ||
1383 | } else { | ||
1384 | setVObjectUStringZValue_(curProp,fakeUnicode(value,0)); | ||
1385 | } | ||
1386 | } | 1564 | } |
1387 | } | ||
1388 | deleteStr(value); | ||
1389 | } | ||
1390 | |||
1391 | 1565 | ||
1392 | static void enterProps(const char *s) | 1566 | static void enterProps(const char *s) |
1393 | { | 1567 | { |
1394 | curProp = addGroup(curObj,s); | 1568 | curProp = addGroup(curObj,s); |
@@ -1396,9 +1570,9 @@ static void enterProps(const char *s) | |||
1396 | } | 1570 | } |
1397 | 1571 | ||
1398 | static void enterAttr(const char *s1, const char *s2) | 1572 | static void enterAttr(const char *s1, const char *s2) |
1399 | { | 1573 | { |
1400 | const char *p1=0L, *p2=0L; | 1574 | const char *p1, *p2; |
1401 | p1 = lookupProp_(s1); | 1575 | p1 = lookupProp_(s1); |
1402 | if (s2) { | 1576 | if (s2) { |
1403 | VObject *a; | 1577 | VObject *a; |
1404 | p2 = lookupProp_(s2); | 1578 | p2 = lookupProp_(s2); |
@@ -1406,12 +1580,12 @@ static void enterAttr(const char *s1, const char *s2) | |||
1406 | setVObjectStringZValue(a,p2); | 1580 | setVObjectStringZValue(a,p2); |
1407 | } | 1581 | } |
1408 | else | 1582 | else |
1409 | addProp(curProp,p1); | 1583 | addProp(curProp,p1); |
1410 | if (strcasecmp(p1,VCBase64Prop) == 0 || (s2 && strcasecmp(p2,VCBase64Prop)==0)) | 1584 | if (stricmp(p1,VCBase64Prop) == 0 || (s2 && stricmp(p2,VCBase64Prop)==0)) |
1411 | lexPushMode(L_BASE64); | 1585 | lexPushMode(L_BASE64); |
1412 | else if (strcasecmp(p1,VCQuotedPrintableProp) == 0 | 1586 | else if (stricmp(p1,VCQuotedPrintableProp) == 0 |
1413 | || (s2 && strcasecmp(p2,VCQuotedPrintableProp)==0)) | 1587 | || (s2 && stricmp(p2,VCQuotedPrintableProp)==0)) |
1414 | lexPushMode(L_QUOTED_PRINTABLE); | 1588 | lexPushMode(L_QUOTED_PRINTABLE); |
1415 | deleteStr(s1); deleteStr(s2); | 1589 | deleteStr(s1); deleteStr(s2); |
1416 | } | 1590 | } |
1417 | 1591 | ||
@@ -1422,9 +1596,13 @@ static void enterAttr(const char *s1, const char *s2) | |||
1422 | #define LEXMODE() (lexBuf.lexModeStack[lexBuf.lexModeStackTop]) | 1596 | #define LEXMODE() (lexBuf.lexModeStack[lexBuf.lexModeStackTop]) |
1423 | 1597 | ||
1424 | struct LexBuf { | 1598 | struct LexBuf { |
1425 | /* input */ | 1599 | /* input */ |
1600 | #ifdef INCLUDEMFC | ||
1601 | CFile *inputFile; | ||
1602 | #else | ||
1426 | FILE *inputFile; | 1603 | FILE *inputFile; |
1604 | #endif | ||
1427 | char *inputString; | 1605 | char *inputString; |
1428 | unsigned long curPos; | 1606 | unsigned long curPos; |
1429 | unsigned long inputLen; | 1607 | unsigned long inputLen; |
1430 | /* lookahead buffer */ | 1608 | /* lookahead buffer */ |
@@ -1468,20 +1646,22 @@ static int lexWithinMode(enum LexMode mode) { | |||
1468 | if (mode == lexBuf.lexModeStack[i]) return 1; | 1646 | if (mode == lexBuf.lexModeStack[i]) return 1; |
1469 | return 0; | 1647 | return 0; |
1470 | } | 1648 | } |
1471 | 1649 | ||
1472 | static int lexGetc_() | 1650 | static char lexGetc_() |
1473 | { | 1651 | { |
1474 | /* get next char from input, no buffering. */ | 1652 | /* get next char from input, no buffering. */ |
1475 | if (lexBuf.curPos == lexBuf.inputLen) | 1653 | if (lexBuf.curPos == lexBuf.inputLen) |
1476 | return EOF; | 1654 | return EOF; |
1477 | else if (lexBuf.inputString) | 1655 | else if (lexBuf.inputString) |
1478 | return *(lexBuf.inputString + lexBuf.curPos++); | 1656 | return *(lexBuf.inputString + lexBuf.curPos++); |
1479 | else { | 1657 | else { |
1480 | if (!feof(lexBuf.inputFile)) | 1658 | #ifdef INCLUDEMFC |
1481 | return fgetc(lexBuf.inputFile); | 1659 | char result; |
1482 | else | 1660 | return lexBuf.inputFile->Read(&result, 1) == 1 ? result : EOF; |
1483 | return EOF; | 1661 | #else |
1662 | return fgetc(lexBuf.inputFile); | ||
1663 | #endif | ||
1484 | } | 1664 | } |
1485 | } | 1665 | } |
1486 | 1666 | ||
1487 | static int lexGeta() | 1667 | static int lexGeta() |
@@ -1518,13 +1698,11 @@ static int lexLookahead() { | |||
1518 | } | 1698 | } |
1519 | lexBuf.buf[lexBuf.getPtr] = c = '\n'; | 1699 | lexBuf.buf[lexBuf.getPtr] = c = '\n'; |
1520 | } | 1700 | } |
1521 | else if (c == '\n') { | 1701 | else if (c == '\n') { |
1522 | int a; | 1702 | int a = (lexBuf.len>1)? |
1523 | if (lexBuf.len > 1) | 1703 | lexBuf.buf[lexBuf.getPtr+1]: |
1524 | a = lexBuf.buf[lexBuf.getPtr]; | 1704 | lexGeta_(1); |
1525 | else | ||
1526 | a = lexGeta_(1); | ||
1527 | if (a == '\r') { | 1705 | if (a == '\r') { |
1528 | lexSkipLookahead(); | 1706 | lexSkipLookahead(); |
1529 | } | 1707 | } |
1530 | lexBuf.buf[lexBuf.getPtr] = '\n'; | 1708 | lexBuf.buf[lexBuf.getPtr] = '\n'; |
@@ -1555,10 +1733,8 @@ static void lexClearToken() | |||
1555 | } | 1733 | } |
1556 | 1734 | ||
1557 | static void lexAppendc(int c) | 1735 | static void lexAppendc(int c) |
1558 | { | 1736 | { |
1559 | /* not sure if I am doing this right to fix purify report -- PGB */ | ||
1560 | lexBuf.strs = (char *) realloc(lexBuf.strs, (size_t) lexBuf.strsLen + 1); | ||
1561 | lexBuf.strs[lexBuf.strsLen] = c; | 1737 | lexBuf.strs[lexBuf.strsLen] = c; |
1562 | /* append up to zero termination */ | 1738 | /* append up to zero termination */ |
1563 | if (c == 0) return; | 1739 | if (c == 0) return; |
1564 | lexBuf.strsLen++; | 1740 | lexBuf.strsLen++; |
@@ -1585,36 +1761,17 @@ static char* lexGetWord() { | |||
1585 | int c; | 1761 | int c; |
1586 | lexSkipWhite(); | 1762 | lexSkipWhite(); |
1587 | lexClearToken(); | 1763 | lexClearToken(); |
1588 | c = lexLookahead(); | 1764 | c = lexLookahead(); |
1589 | /* some "words" have a space in them, like "NEEDS ACTION". | 1765 | while (c != EOF && !strchr("\t\n ;:=",c)) { |
1590 | this may be an oversight of the spec, but it is true nevertheless. | ||
1591 | while (c != EOF && !strchr("\t\n ;:=",c)) { */ | ||
1592 | while (c != EOF && !strchr("\n;:=",c)) { | ||
1593 | lexAppendc(c); | 1766 | lexAppendc(c); |
1594 | lexSkipLookahead(); | 1767 | lexSkipLookahead(); |
1595 | c = lexLookahead(); | 1768 | c = lexLookahead(); |
1596 | } | 1769 | } |
1597 | lexAppendc(0); | 1770 | lexAppendc(0); |
1598 | return lexStr(); | 1771 | return lexStr(); |
1599 | } | 1772 | } |
1600 | 1773 | ||
1601 | void lexPushLookahead(char *s, int len) { | ||
1602 | int putptr; | ||
1603 | if (len == 0) len = strlen(s); | ||
1604 | putptr = (int)lexBuf.getPtr - len; | ||
1605 | /* this function assumes that length of word to push back | ||
1606 | / is not greater than MAX_LEX_LOOKAHEAD. | ||
1607 | */ | ||
1608 | if (putptr < 0) putptr += MAX_LEX_LOOKAHEAD; | ||
1609 | lexBuf.getPtr = putptr; | ||
1610 | while (*s) { | ||
1611 | lexBuf.buf[putptr] = *s++; | ||
1612 | putptr = (putptr + 1) % MAX_LEX_LOOKAHEAD; | ||
1613 | } | ||
1614 | lexBuf.len += len; | ||
1615 | } | ||
1616 | |||
1617 | static void lexPushLookaheadc(int c) { | 1774 | static void lexPushLookaheadc(int c) { |
1618 | int putptr; | 1775 | int putptr; |
1619 | /* can't putback EOF, because it never leaves lookahead buffer */ | 1776 | /* can't putback EOF, because it never leaves lookahead buffer */ |
1620 | if (c == EOF) return; | 1777 | if (c == EOF) return; |
@@ -1721,36 +1878,29 @@ static char* lexGet1Value() { | |||
1721 | return c==EOF?0:lexStr(); | 1878 | return c==EOF?0:lexStr(); |
1722 | } | 1879 | } |
1723 | #endif | 1880 | #endif |
1724 | 1881 | ||
1725 | char* lexGetStrUntil(char *termset) { | ||
1726 | int c = lexLookahead(); | ||
1727 | lexClearToken(); | ||
1728 | while (c != EOF && !strchr(termset,c)) { | ||
1729 | lexAppendc(c); | ||
1730 | lexSkipLookahead(); | ||
1731 | c = lexLookahead(); | ||
1732 | } | ||
1733 | lexAppendc(0); | ||
1734 | return c==EOF?0:lexStr(); | ||
1735 | } | ||
1736 | 1882 | ||
1737 | static int match_begin_name(int end) { | 1883 | static int match_begin_name(int end) { |
1738 | char *n = lexLookaheadWord(); | 1884 | char *n = lexLookaheadWord(); |
1739 | int token = ID; | 1885 | int token = ID; |
1740 | if (n) { | 1886 | if (n) { |
1741 | if (!strcasecmp(n,"vcard")) token = end?END_VCARD:BEGIN_VCARD; | 1887 | if (!stricmp(n,"vcard")) token = end?END_VCARD:BEGIN_VCARD; |
1742 | else if (!strcasecmp(n,"vcalendar")) token = end?END_VCAL:BEGIN_VCAL; | 1888 | else if (!stricmp(n,"vcalendar")) token = end?END_VCAL:BEGIN_VCAL; |
1743 | else if (!strcasecmp(n,"vevent")) token = end?END_VEVENT:BEGIN_VEVENT; | 1889 | else if (!stricmp(n,"vevent")) token = end?END_VEVENT:BEGIN_VEVENT; |
1744 | else if (!strcasecmp(n,"vtodo")) token = end?END_VTODO:BEGIN_VTODO; | 1890 | else if (!stricmp(n,"vtodo")) token = end?END_VTODO:BEGIN_VTODO; |
1745 | deleteStr(n); | 1891 | deleteStr(n); |
1746 | return token; | 1892 | return token; |
1747 | } | 1893 | } |
1748 | return 0; | 1894 | return 0; |
1749 | } | 1895 | } |
1750 | 1896 | ||
1751 | 1897 | ||
1898 | #ifdef INCLUDEMFC | ||
1899 | void initLex(const char *inputstring, unsigned long inputlen, CFile *inputfile) | ||
1900 | #else | ||
1752 | void initLex(const char *inputstring, unsigned long inputlen, FILE *inputfile) | 1901 | void initLex(const char *inputstring, unsigned long inputlen, FILE *inputfile) |
1902 | #endif | ||
1753 | { | 1903 | { |
1754 | /* initialize lex mode stack */ | 1904 | /* initialize lex mode stack */ |
1755 | lexBuf.lexModeStack[lexBuf.lexModeStackTop=0] = L_NORMAL; | 1905 | lexBuf.lexModeStack[lexBuf.lexModeStackTop=0] = L_NORMAL; |
1756 | 1906 | ||
@@ -1773,9 +1923,8 @@ static void finiLex() { | |||
1773 | free(lexBuf.strs); | 1923 | free(lexBuf.strs); |
1774 | } | 1924 | } |
1775 | 1925 | ||
1776 | 1926 | ||
1777 | /****************************************************************************/ | ||
1778 | /* This parses and converts the base64 format for binary encoding into | 1927 | /* This parses and converts the base64 format for binary encoding into |
1779 | * a decoded buffer (allocated with new). See RFC 1521. | 1928 | * a decoded buffer (allocated with new). See RFC 1521. |
1780 | */ | 1929 | */ |
1781 | static char * lexGetDataFromBase64() | 1930 | static char * lexGetDataFromBase64() |
@@ -1956,17 +2105,19 @@ EndString: | |||
1956 | lexAppendc(0); | 2105 | lexAppendc(0); |
1957 | return lexStr(); | 2106 | return lexStr(); |
1958 | } /* LexQuotedPrintable */ | 2107 | } /* LexQuotedPrintable */ |
1959 | 2108 | ||
1960 | static int yylex() { | 2109 | int yylex() { |
1961 | 2110 | ||
1962 | int lexmode = LEXMODE(); | 2111 | int lexmode = LEXMODE(); |
1963 | if (lexmode == L_VALUES) { | 2112 | if (lexmode == L_VALUES) { |
1964 | int c = lexGetc(); | 2113 | int c = lexGetc(); |
1965 | if (c == ';') { | 2114 | if (c == ';') { |
1966 | DBG_(("db: SEMICOLON\n")); | 2115 | DBG_(("db: SEMICOLON\n")); |
1967 | lexPushLookaheadc(c); | 2116 | lexPushLookaheadc(c); |
2117 | #ifdef _SUPPORT_LINE_FOLDING | ||
1968 | handleMoreRFC822LineBreak(c); | 2118 | handleMoreRFC822LineBreak(c); |
2119 | #endif | ||
1969 | lexSkipLookahead(); | 2120 | lexSkipLookahead(); |
1970 | return SEMICOLON; | 2121 | return SEMICOLON; |
1971 | } | 2122 | } |
1972 | else if (strchr("\n",c)) { | 2123 | else if (strchr("\n",c)) { |
@@ -2007,23 +2158,22 @@ static int yylex() { | |||
2007 | } | 2158 | } |
2008 | else return 0; | 2159 | else return 0; |
2009 | } | 2160 | } |
2010 | } | 2161 | } |
2011 | |||
2012 | else { | 2162 | else { |
2013 | /* normal mode */ | 2163 | /* normal mode */ |
2014 | while (1) { | 2164 | while (1) { |
2015 | int c = lexGetc(); | 2165 | int c = lexGetc(); |
2016 | switch(c) { | 2166 | switch(c) { |
2017 | case ':': { | 2167 | case ':': { |
2018 | /* consume all line separator(s) adjacent to each other */ | 2168 | /* consume all line separator(s) adjacent to each other */ |
2019 | /* ignoring linesep immediately after colon. */ | 2169 | /* ignoring linesep immediately after colon. */ |
2020 | c = lexLookahead(); | 2170 | /* c = lexLookahead(); |
2021 | while (strchr("\n",c)) { | 2171 | while (strchr("\n",c)) { |
2022 | lexSkipLookahead(); | 2172 | lexSkipLookahead(); |
2023 | c = lexLookahead(); | 2173 | c = lexLookahead(); |
2024 | ++mime_lineNum; | 2174 | ++mime_lineNum; |
2025 | } | 2175 | }*/ |
2026 | DBG_(("db: COLON\n")); | 2176 | DBG_(("db: COLON\n")); |
2027 | return COLON; | 2177 | return COLON; |
2028 | } | 2178 | } |
2029 | case ';': | 2179 | case ';': |
@@ -2031,52 +2181,48 @@ static int yylex() { | |||
2031 | return SEMICOLON; | 2181 | return SEMICOLON; |
2032 | case '=': | 2182 | case '=': |
2033 | DBG_(("db: EQ\n")); | 2183 | DBG_(("db: EQ\n")); |
2034 | return EQ; | 2184 | return EQ; |
2035 | /* ignore tabs/newlines in this mode. We can't ignore | 2185 | /* ignore whitespace in this mode */ |
2036 | * spaces, because values like NEEDS ACTION have a space. */ | 2186 | case '\t': |
2037 | case '\t': continue; | 2187 | case ' ': continue; |
2038 | case '\n': { | 2188 | case '\n': { |
2039 | ++mime_lineNum; | 2189 | ++mime_lineNum; |
2040 | continue; | 2190 | continue; |
2041 | } | 2191 | } |
2042 | case EOF: return 0; | 2192 | case EOF: return 0; |
2043 | break; | 2193 | break; |
2044 | default: { | 2194 | default: { |
2045 | lexPushLookaheadc(c); | 2195 | lexPushLookaheadc(c); |
2046 | /* pending lutz : why linker error with isalpha(c)? */ | 2196 | if (isalpha(c)) { |
2047 | /*if ( isalpha(c) || c == ' ') { */ | ||
2048 | if ( ( c >= 'A' && c <= 'Z') || ( c >= 'a' && c <= 'z') || c == ' ') { | ||
2049 | |||
2050 | char *t = lexGetWord(); | 2197 | char *t = lexGetWord(); |
2051 | yylval.str = t; | 2198 | yylval.str = t; |
2052 | if (!strcasecmp(t, "begin")) { | 2199 | if (!stricmp(t, "begin")) { |
2053 | return match_begin_end_name(0); | 2200 | return match_begin_end_name(0); |
2054 | } | 2201 | } |
2055 | else if (!strcasecmp(t,"end")) { | 2202 | else if (!stricmp(t,"end")) { |
2056 | return match_begin_end_name(1); | 2203 | return match_begin_end_name(1); |
2057 | } | 2204 | } |
2058 | else { | 2205 | else { |
2059 | DBG_(("db: ID '%s'\n", t)); | 2206 | DBG_(("db: ID '%s'\n", t)); |
2060 | return ID; | 2207 | return ID; |
2061 | } | 2208 | } |
2062 | } | 2209 | } |
2063 | else { | 2210 | else { |
2064 | /* unknown token */ | 2211 | /* unknow token */ |
2065 | return 0; | 2212 | return 0; |
2066 | } | 2213 | } |
2067 | break; | 2214 | break; |
2068 | } | 2215 | } |
2069 | } | 2216 | } |
2070 | } | 2217 | } |
2071 | } | 2218 | } |
2072 | |||
2073 | return 0; | 2219 | return 0; |
2074 | } | 2220 | } |
2075 | 2221 | ||
2076 | 2222 | ||
2077 | /***************************************************************************/ | 2223 | /***************************************************************************/ |
2078 | /*** Public Functions ****/ | 2224 | /*** Public Functions ****/ |
2079 | /***************************************************************************/ | 2225 | /***************************************************************************/ |
2080 | 2226 | ||
2081 | static VObject* Parse_MIMEHelper() | 2227 | static VObject* Parse_MIMEHelper() |
2082 | { | 2228 | { |
@@ -2092,19 +2238,34 @@ static VObject* Parse_MIMEHelper() | |||
2092 | finiLex(); | 2238 | finiLex(); |
2093 | return vObjList; | 2239 | return vObjList; |
2094 | } | 2240 | } |
2095 | 2241 | ||
2096 | /****************************************************************************/ | 2242 | DLLEXPORT(VObject*) Parse_MIME(const char *input, unsigned long len) |
2097 | VObject* Parse_MIME(const char *input, unsigned long len) | ||
2098 | { | 2243 | { |
2099 | initLex(input, len, 0); | 2244 | initLex(input, len, 0); |
2100 | return Parse_MIMEHelper(); | 2245 | return Parse_MIMEHelper(); |
2101 | } | 2246 | } |
2102 | 2247 | ||
2103 | 2248 | ||
2249 | #if INCLUDEMFC | ||
2250 | |||
2251 | DLLEXPORT(VObject*) Parse_MIME_FromFile(CFile *file) | ||
2252 | { | ||
2253 | unsigned long startPos; | ||
2254 | VObject *result; | ||
2255 | |||
2256 | initLex(0,-1,file); | ||
2257 | startPos = file->GetPosition(); | ||
2258 | if (!(result = Parse_MIMEHelper())) | ||
2259 | file->Seek(startPos, CFile::begin); | ||
2260 | return result; | ||
2261 | } | ||
2262 | |||
2263 | #else | ||
2264 | |||
2104 | VObject* Parse_MIME_FromFile(FILE *file) | 2265 | VObject* Parse_MIME_FromFile(FILE *file) |
2105 | { | 2266 | { |
2106 | VObject *result; | 2267 | VObject *result; |
2107 | long startPos; | 2268 | long startPos; |
2108 | 2269 | ||
2109 | initLex(0,(unsigned long)-1,file); | 2270 | initLex(0,(unsigned long)-1,file); |
2110 | startPos = ftell(file); | 2271 | startPos = ftell(file); |
@@ -2113,34 +2274,30 @@ VObject* Parse_MIME_FromFile(FILE *file) | |||
2113 | } | 2274 | } |
2114 | return result; | 2275 | return result; |
2115 | } | 2276 | } |
2116 | 2277 | ||
2117 | VObject* Parse_MIME_FromFileName(const char *fname) | 2278 | DLLEXPORT(VObject*) Parse_MIME_FromFileName(char *fname) |
2118 | { | 2279 | { |
2119 | FILE *fp = fopen(fname,"r"); | 2280 | FILE *fp = fopen(fname,"r"); |
2120 | if (fp) { | 2281 | if (fp) { |
2121 | VObject* o = Parse_MIME_FromFile(fp); | 2282 | VObject* o = Parse_MIME_FromFile(fp); |
2122 | fclose(fp); | 2283 | fclose(fp); |
2123 | return o; | 2284 | return o; |
2124 | } | 2285 | } |
2125 | else { | 2286 | else { |
2126 | char msg[255]; | 2287 | char msg[256]; |
2127 | sprintf(msg, "can't open file '%s' for reading\n", fname); | 2288 | snprintf(msg, sizeof(msg), "can't open file '%s' for reading\n", fname); |
2128 | mime_error_(msg); | 2289 | mime_error_(msg); |
2129 | return 0; | 2290 | return 0; |
2130 | } | 2291 | } |
2131 | } | 2292 | } |
2132 | 2293 | ||
2133 | /****************************************************************************/ | 2294 | #endif |
2134 | void YYDebug(const char *s) | ||
2135 | { | ||
2136 | Parse_Debug(s); | ||
2137 | } | ||
2138 | 2295 | ||
2139 | 2296 | ||
2140 | static MimeErrorHandler mimeErrorHandler; | 2297 | static MimeErrorHandler mimeErrorHandler; |
2141 | 2298 | ||
2142 | void registerMimeErrorHandler(MimeErrorHandler me) | 2299 | DLLEXPORT(void) registerMimeErrorHandler(MimeErrorHandler me) |
2143 | { | 2300 | { |
2144 | mimeErrorHandler = me; | 2301 | mimeErrorHandler = me; |
2145 | } | 2302 | } |
2146 | 2303 | ||