diff --git a/etc/mapserver-sample.conf b/etc/mapserver-sample.conf index 3391e1d2fd..778d782a00 100644 --- a/etc/mapserver-sample.conf +++ b/etc/mapserver-sample.conf @@ -20,6 +20,11 @@ CONFIG # MS_DEBUGLEVEL "5" # MS_ERRORFILE "/opt/mapserver/logs/mapserver.log" + # + # Global Error Redirect Handling (see web object docs) + # + # MS_EMPTY "https://mapserver.org/" + # # Default Map # diff --git a/msautotest/query/6907_01.conf b/msautotest/query/6907_01.conf new file mode 100644 index 0000000000..ba79b5f104 --- /dev/null +++ b/msautotest/query/6907_01.conf @@ -0,0 +1,6 @@ +CONFIG + ENV + MS_MAP_PATTERN "." + MS_EMPTY "http://localhost/6907_01.html" + END +END diff --git a/msautotest/query/6907_01.map b/msautotest/query/6907_01.map index 4e2ce127fa..de3b75bf6c 100644 --- a/msautotest/query/6907_01.map +++ b/msautotest/query/6907_01.map @@ -1,8 +1,11 @@ # Test 1: mode=itemquery - matching record -# RUN_PARMS: 6709_01_test001.txt [MAPSERV] QUERY_STRING='map=[MAPFILE]&mode=itemquery&qlayer=bdry_counpy2&qstring=ANOK&qitem=cty_abbr' > [RESULT_DEMIME] +# RUN_PARMS: 6907_01_test001.txt [MAPSERV] QUERY_STRING='map=[MAPFILE]&mode=itemquery&qlayer=bdry_counpy2&qstring=ANOK&qitem=cty_abbr' > [RESULT] # # Test 2: mode=itemquery - no matching record -# RUN_PARMS: 6709_01_test001.txt [MAPSERV] QUERY_STRING='map=[MAPFILE]&mode=itemquery&qlayer=bdry_counpy2&qstring=ABCD&qitem=cty_abbr' > [RESULT_DEMIME] +# RUN_PARMS: 6907_01_test002.txt [MAPSERV] QUERY_STRING='map=[MAPFILE]&mode=itemquery&qlayer=bdry_counpy2&qstring=ABCD&qitem=cty_abbr' > [RESULT] +# +# Test 3: mode=itemquery - no matching record, MS_EMPTY in config +# RUN_PARMS: 6907_01_test003.txt [MAPSERV] -conf 6907_01.conf QUERY_STRING='map=[MAPFILE]&mode=itemquery&qlayer=bdry_counpy2&qstring=ABCD&qitem=cty_abbr' > [RESULT] MAP NAME 'query' EXTENT 125000 4785000 789000 5489000 @@ -16,7 +19,7 @@ MAP NAME 'tmpl' DRIVER 'TEMPLATE' MIMETYPE 'text/html' - FORMATOPTION "FILE=template/query.tmpl" + FORMATOPTION "FILE=template/6907.tmpl" END LAYER diff --git a/msautotest/query/6907_02.map b/msautotest/query/6907_02.map index e007b0a0e4..bb1672be8c 100644 --- a/msautotest/query/6907_02.map +++ b/msautotest/query/6907_02.map @@ -1,15 +1,15 @@ # Test 1: mode=itemquery - matching record -# RUN_PARMS: 6709_02_test001.txt [MAPSERV] QUERY_STRING='map=[MAPFILE]&mode=itemquery&qlayer=bdry_counpy2&qstring=ANOK&qitem=cty_abbr' > [RESULT_DEMIME] +# RUN_PARMS: 6907_02_test001.txt [MAPSERV] QUERY_STRING='map=[MAPFILE]&mode=itemquery&qlayer=bdry_counpy2&qstring=ANOK&qitem=cty_abbr' > [RESULT] # # Test 2: mode=itemquery - no matching record -# RUN_PARMS: 6709_02_test001.txt [MAPSERV] QUERY_STRING='map=[MAPFILE]&mode=itemquery&qlayer=bdry_counpy2&qstring=ABCD&qitem=cty_abbr' > [RESULT_DEMIME] +# RUN_PARMS: 6907_02_test002.txt [MAPSERV] QUERY_STRING='map=[MAPFILE]&mode=itemquery&qlayer=bdry_counpy2&qstring=ABCD&qitem=cty_abbr' > [RESULT] MAP NAME 'query' EXTENT 125000 4785000 789000 5489000 UNITS METERS WEB - EMPTY 'https://mapserver.org/' + EMPTY 'http://localhost/6907_02.html' QUERYFORMAT 'tmpl' END @@ -17,7 +17,7 @@ MAP NAME 'tmpl' DRIVER 'TEMPLATE' MIMETYPE 'text/html' - FORMATOPTION "FILE=template/query.tmpl" + FORMATOPTION "FILE=template/6907.tmpl" END LAYER diff --git a/msautotest/query/6907_03.conf b/msautotest/query/6907_03.conf deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/msautotest/query/6907_03.map b/msautotest/query/6907_03.map deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/msautotest/query/expected/6907_01_test001.txt b/msautotest/query/expected/6907_01_test001.txt new file mode 100644 index 0000000000..3f4db3ce69 --- /dev/null +++ b/msautotest/query/expected/6907_01_test001.txt @@ -0,0 +1,4 @@ +Content-Type: text/html + +Anoka:ANOK + diff --git a/msautotest/query/expected/6907_01_test002.txt b/msautotest/query/expected/6907_01_test002.txt new file mode 100644 index 0000000000..1ef38c7a04 --- /dev/null +++ b/msautotest/query/expected/6907_01_test002.txt @@ -0,0 +1,4 @@ +Content-Type: text/html + + + diff --git a/msautotest/query/expected/6907_01_test003.txt b/msautotest/query/expected/6907_01_test003.txt new file mode 100644 index 0000000000..e11fa68333 --- /dev/null +++ b/msautotest/query/expected/6907_01_test003.txt @@ -0,0 +1,5 @@ +Status: 302 Found +Uri: http://localhost/6907_01.html +Location: http://localhost/6907_01.html +Content-Type: text/html + diff --git a/msautotest/query/expected/6907_02_test001.txt b/msautotest/query/expected/6907_02_test001.txt new file mode 100644 index 0000000000..3f4db3ce69 --- /dev/null +++ b/msautotest/query/expected/6907_02_test001.txt @@ -0,0 +1,4 @@ +Content-Type: text/html + +Anoka:ANOK + diff --git a/msautotest/query/expected/6907_02_test002.txt b/msautotest/query/expected/6907_02_test002.txt new file mode 100644 index 0000000000..27450584b8 --- /dev/null +++ b/msautotest/query/expected/6907_02_test002.txt @@ -0,0 +1,5 @@ +Status: 302 Found +Uri: http://localhost/6907_02.html +Location: http://localhost/6907_02.html +Content-Type: text/html + diff --git a/msautotest/query/template/6907.tmpl b/msautotest/query/template/6907.tmpl new file mode 100644 index 0000000000..e774d40e2f --- /dev/null +++ b/msautotest/query/template/6907.tmpl @@ -0,0 +1,3 @@ + +[resultset layer="bdry_counpy2"][feature][item name="cty_name"]:[item name="cty_abbr"] [/feature][/resultset] + diff --git a/src/maplexer.c b/src/maplexer.c index b27c9dd370..1c9fc20219 100644 --- a/src/maplexer.c +++ b/src/maplexer.c @@ -1,6 +1,6 @@ -#line 2 "/home/even/mapserver/mapserver/maplexer.c" +#line 2 "src/maplexer.c" -#line 4 "/home/even/mapserver/mapserver/maplexer.c" +#line 4 "src/maplexer.c" #define YY_INT_ALIGNED short int @@ -2170,8 +2170,8 @@ int yy_flex_debug = 0; #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET char *yytext; -#line 1 "maplexer.l" -#line 4 "maplexer.l" +#line 1 "src/maplexer.l" +#line 4 "src/maplexer.l" /* ** READ ME FIRST! ** @@ -2283,9 +2283,9 @@ int include_lineno[MAX_INCLUDE_DEPTH]; int include_stack_ptr = 0; char path[MS_MAXPATHLEN]; -#line 2287 "/home/even/mapserver/mapserver/maplexer.c" +#line 2287 "src/maplexer.c" -#line 2289 "/home/even/mapserver/mapserver/maplexer.c" +#line 2289 "src/maplexer.c" #define INITIAL 0 #define EXPRESSION_STRING 1 @@ -2499,9 +2499,9 @@ YY_DECL } { -#line 123 "maplexer.l" +#line 123 "src/maplexer.l" -#line 125 "maplexer.l" +#line 125 "src/maplexer.l" if (msyystring_buffer == NULL) { msyystring_buffer_size = 256; @@ -2565,7 +2565,7 @@ YY_DECL break; } -#line 2569 "/home/even/mapserver/mapserver/maplexer.c" +#line 2569 "src/maplexer.c" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -2620,1599 +2620,1599 @@ YY_DECL case 1: YY_RULE_SETUP -#line 188 "maplexer.l" +#line 188 "src/maplexer.l" ; YY_BREAK case 2: YY_RULE_SETUP -#line 190 "maplexer.l" +#line 190 "src/maplexer.l" { if (msyyreturncomments) return(MS_COMMENT); } YY_BREAK case 3: YY_RULE_SETUP -#line 192 "maplexer.l" +#line 192 "src/maplexer.l" { BEGIN(MULTILINE_COMMENT); } YY_BREAK case 4: YY_RULE_SETUP -#line 193 "maplexer.l" +#line 193 "src/maplexer.l" { BEGIN(INITIAL); } YY_BREAK case 5: YY_RULE_SETUP -#line 194 "maplexer.l" +#line 194 "src/maplexer.l" ; YY_BREAK case 6: YY_RULE_SETUP -#line 195 "maplexer.l" +#line 195 "src/maplexer.l" ; YY_BREAK case 7: /* rule 7 can match eol */ YY_RULE_SETUP -#line 196 "maplexer.l" +#line 196 "src/maplexer.l" { msyylineno++; } YY_BREAK case 8: YY_RULE_SETUP -#line 198 "maplexer.l" +#line 198 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CONFIG_SECTION); } YY_BREAK case 9: YY_RULE_SETUP -#line 199 "maplexer.l" +#line 199 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CONFIG_SECTION_ENV); } YY_BREAK case 10: YY_RULE_SETUP -#line 200 "maplexer.l" +#line 200 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CONFIG_SECTION_MAPS); } YY_BREAK case 11: YY_RULE_SETUP -#line 201 "maplexer.l" +#line 201 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CONFIG_SECTION_PLUGINS) } YY_BREAK case 12: YY_RULE_SETUP -#line 203 "maplexer.l" +#line 203 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_LOGICAL_OR); } YY_BREAK case 13: YY_RULE_SETUP -#line 204 "maplexer.l" +#line 204 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_LOGICAL_AND); } YY_BREAK case 14: YY_RULE_SETUP -#line 205 "maplexer.l" +#line 205 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_LOGICAL_NOT); } YY_BREAK case 15: YY_RULE_SETUP -#line 206 "maplexer.l" +#line 206 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_EQ); } YY_BREAK case 16: YY_RULE_SETUP -#line 207 "maplexer.l" +#line 207 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_NE); } YY_BREAK case 17: YY_RULE_SETUP -#line 208 "maplexer.l" +#line 208 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_GT); } YY_BREAK case 18: YY_RULE_SETUP -#line 209 "maplexer.l" +#line 209 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_LT); } YY_BREAK case 19: YY_RULE_SETUP -#line 210 "maplexer.l" +#line 210 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_GE); } YY_BREAK case 20: YY_RULE_SETUP -#line 211 "maplexer.l" +#line 211 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_LE); } YY_BREAK case 21: YY_RULE_SETUP -#line 212 "maplexer.l" +#line 212 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_RE); } YY_BREAK case 22: YY_RULE_SETUP -#line 214 "maplexer.l" +#line 214 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_IEQ); } YY_BREAK case 23: YY_RULE_SETUP -#line 215 "maplexer.l" +#line 215 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_IRE); } YY_BREAK case 24: YY_RULE_SETUP -#line 217 "maplexer.l" +#line 217 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_IN); /* was IN */ } YY_BREAK case 25: YY_RULE_SETUP -#line 219 "maplexer.l" +#line 219 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_AREA); } YY_BREAK case 26: YY_RULE_SETUP -#line 220 "maplexer.l" +#line 220 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_LENGTH); } YY_BREAK case 27: YY_RULE_SETUP -#line 221 "maplexer.l" +#line 221 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_TOSTRING); } YY_BREAK case 28: YY_RULE_SETUP -#line 222 "maplexer.l" +#line 222 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_COMMIFY); } YY_BREAK case 29: YY_RULE_SETUP -#line 223 "maplexer.l" +#line 223 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_ROUND); } YY_BREAK case 30: YY_RULE_SETUP -#line 224 "maplexer.l" +#line 224 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_UPPER); } YY_BREAK case 31: YY_RULE_SETUP -#line 225 "maplexer.l" +#line 225 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_LOWER); } YY_BREAK case 32: YY_RULE_SETUP -#line 226 "maplexer.l" +#line 226 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_INITCAP); } YY_BREAK case 33: YY_RULE_SETUP -#line 227 "maplexer.l" +#line 227 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_FIRSTCAP); } YY_BREAK case 34: YY_RULE_SETUP -#line 229 "maplexer.l" +#line 229 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_BUFFER); } YY_BREAK case 35: YY_RULE_SETUP -#line 230 "maplexer.l" +#line 230 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_DIFFERENCE); } YY_BREAK case 36: YY_RULE_SETUP -#line 231 "maplexer.l" +#line 231 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_SIMPLIFY); } YY_BREAK case 37: YY_RULE_SETUP -#line 232 "maplexer.l" +#line 232 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_SIMPLIFYPT); } YY_BREAK case 38: YY_RULE_SETUP -#line 233 "maplexer.l" +#line 233 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_GENERALIZE); } YY_BREAK case 39: YY_RULE_SETUP -#line 234 "maplexer.l" +#line 234 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_SMOOTHSIA); } YY_BREAK case 40: YY_RULE_SETUP -#line 235 "maplexer.l" +#line 235 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_CENTERLINE); } YY_BREAK case 41: YY_RULE_SETUP -#line 236 "maplexer.l" +#line 236 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_DENSIFY); } YY_BREAK case 42: YY_RULE_SETUP -#line 237 "maplexer.l" +#line 237 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_OUTER); } YY_BREAK case 43: YY_RULE_SETUP -#line 238 "maplexer.l" +#line 238 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_INNER); } YY_BREAK case 44: YY_RULE_SETUP -#line 239 "maplexer.l" +#line 239 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_JAVASCRIPT); } YY_BREAK case 45: YY_RULE_SETUP -#line 241 "maplexer.l" +#line 241 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_INTERSECTS); } YY_BREAK case 46: YY_RULE_SETUP -#line 242 "maplexer.l" +#line 242 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_DISJOINT); } YY_BREAK case 47: YY_RULE_SETUP -#line 243 "maplexer.l" +#line 243 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_TOUCHES); } YY_BREAK case 48: YY_RULE_SETUP -#line 244 "maplexer.l" +#line 244 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_OVERLAPS); } YY_BREAK case 49: YY_RULE_SETUP -#line 245 "maplexer.l" +#line 245 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_CROSSES); } YY_BREAK case 50: YY_RULE_SETUP -#line 246 "maplexer.l" +#line 246 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_WITHIN); } YY_BREAK case 51: YY_RULE_SETUP -#line 247 "maplexer.l" +#line 247 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_CONTAINS); } YY_BREAK case 52: YY_RULE_SETUP -#line 248 "maplexer.l" +#line 248 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_EQUALS); } YY_BREAK case 53: YY_RULE_SETUP -#line 249 "maplexer.l" +#line 249 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_BEYOND); } YY_BREAK case 54: YY_RULE_SETUP -#line 250 "maplexer.l" +#line 250 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_COMPARISON_DWITHIN); } YY_BREAK case 55: YY_RULE_SETUP -#line 252 "maplexer.l" +#line 252 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TOKEN_FUNCTION_FROMTEXT); } YY_BREAK case 56: YY_RULE_SETUP -#line 254 "maplexer.l" +#line 254 "src/maplexer.l" { msyynumber=MS_TRUE; return(MS_TOKEN_LITERAL_BOOLEAN); } YY_BREAK case 57: YY_RULE_SETUP -#line 255 "maplexer.l" +#line 255 "src/maplexer.l" { msyynumber=MS_FALSE; return(MS_TOKEN_LITERAL_BOOLEAN); } YY_BREAK case 58: YY_RULE_SETUP -#line 257 "maplexer.l" +#line 257 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(COLORRANGE); } YY_BREAK case 59: YY_RULE_SETUP -#line 258 "maplexer.l" +#line 258 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(DATARANGE); } YY_BREAK case 60: YY_RULE_SETUP -#line 259 "maplexer.l" +#line 259 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(RANGEITEM); } YY_BREAK case 61: YY_RULE_SETUP -#line 261 "maplexer.l" +#line 261 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(ALIGN); } YY_BREAK case 62: YY_RULE_SETUP -#line 262 "maplexer.l" +#line 262 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(ANCHORPOINT); } YY_BREAK case 63: YY_RULE_SETUP -#line 263 "maplexer.l" +#line 263 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(ANGLE); } YY_BREAK case 64: YY_RULE_SETUP -#line 264 "maplexer.l" +#line 264 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(ANTIALIAS); } YY_BREAK case 65: YY_RULE_SETUP -#line 265 "maplexer.l" +#line 265 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(BACKGROUNDCOLOR); } YY_BREAK case 66: YY_RULE_SETUP -#line 266 "maplexer.l" +#line 266 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(BANDSITEM); } YY_BREAK case 67: YY_RULE_SETUP -#line 267 "maplexer.l" +#line 267 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(BINDVALS); } YY_BREAK case 68: YY_RULE_SETUP -#line 268 "maplexer.l" +#line 268 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(BOM); } YY_BREAK case 69: YY_RULE_SETUP -#line 269 "maplexer.l" +#line 269 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(BROWSEFORMAT); } YY_BREAK case 70: YY_RULE_SETUP -#line 270 "maplexer.l" +#line 270 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(BUFFER); } YY_BREAK case 71: YY_RULE_SETUP -#line 271 "maplexer.l" +#line 271 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(CHARACTER); } YY_BREAK case 72: YY_RULE_SETUP -#line 272 "maplexer.l" +#line 272 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(CLASS); } YY_BREAK case 73: YY_RULE_SETUP -#line 273 "maplexer.l" +#line 273 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(CLASSITEM); } YY_BREAK case 74: YY_RULE_SETUP -#line 274 "maplexer.l" +#line 274 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(CLASSGROUP); } YY_BREAK case 75: YY_RULE_SETUP -#line 275 "maplexer.l" +#line 275 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(CLUSTER); } YY_BREAK case 76: YY_RULE_SETUP -#line 276 "maplexer.l" +#line 276 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(COLOR); } YY_BREAK case 77: YY_RULE_SETUP -#line 277 "maplexer.l" +#line 277 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(COMPFILTER); } YY_BREAK case 78: YY_RULE_SETUP -#line 278 "maplexer.l" +#line 278 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(COMPOSITE); } YY_BREAK case 79: YY_RULE_SETUP -#line 279 "maplexer.l" +#line 279 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(COMPOP); } YY_BREAK case 80: YY_RULE_SETUP -#line 280 "maplexer.l" +#line 280 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(CONFIG); } YY_BREAK case 81: YY_RULE_SETUP -#line 281 "maplexer.l" +#line 281 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(CONNECTION); } YY_BREAK case 82: YY_RULE_SETUP -#line 282 "maplexer.l" +#line 282 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(CONNECTIONTYPE); } YY_BREAK case 83: YY_RULE_SETUP -#line 283 "maplexer.l" +#line 283 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(DATA); } YY_BREAK case 84: YY_RULE_SETUP -#line 284 "maplexer.l" +#line 284 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(DEBUG); } YY_BREAK case 85: YY_RULE_SETUP -#line 285 "maplexer.l" +#line 285 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(DRIVER); } YY_BREAK case 86: YY_RULE_SETUP -#line 286 "maplexer.l" +#line 286 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(EMPTY); } YY_BREAK case 87: YY_RULE_SETUP -#line 287 "maplexer.l" +#line 287 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(ENCODING); } YY_BREAK case 88: YY_RULE_SETUP -#line 288 "maplexer.l" +#line 288 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(END); } YY_BREAK case 89: YY_RULE_SETUP -#line 289 "maplexer.l" +#line 289 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(ERROR); } YY_BREAK case 90: YY_RULE_SETUP -#line 290 "maplexer.l" +#line 290 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(EXPRESSION); } YY_BREAK case 91: YY_RULE_SETUP -#line 291 "maplexer.l" +#line 291 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(EXTENT); } YY_BREAK case 92: YY_RULE_SETUP -#line 292 "maplexer.l" +#line 292 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(EXTENSION); } YY_BREAK case 93: YY_RULE_SETUP -#line 293 "maplexer.l" +#line 293 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(FEATURE); } YY_BREAK case 94: YY_RULE_SETUP -#line 294 "maplexer.l" +#line 294 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(FILLED); } YY_BREAK case 95: YY_RULE_SETUP -#line 295 "maplexer.l" +#line 295 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(FILTER); } YY_BREAK case 96: YY_RULE_SETUP -#line 296 "maplexer.l" +#line 296 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(FILTERITEM); } YY_BREAK case 97: YY_RULE_SETUP -#line 297 "maplexer.l" +#line 297 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(FOOTER); } YY_BREAK case 98: YY_RULE_SETUP -#line 298 "maplexer.l" +#line 298 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(FONT); } YY_BREAK case 99: YY_RULE_SETUP -#line 299 "maplexer.l" +#line 299 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(FONTSET); } YY_BREAK case 100: YY_RULE_SETUP -#line 300 "maplexer.l" +#line 300 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(FORCE); } YY_BREAK case 101: YY_RULE_SETUP -#line 301 "maplexer.l" +#line 301 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(FORMATOPTION); } YY_BREAK case 102: YY_RULE_SETUP -#line 302 "maplexer.l" +#line 302 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(FROM); } YY_BREAK case 103: YY_RULE_SETUP -#line 303 "maplexer.l" +#line 303 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(GAP); } YY_BREAK case 104: YY_RULE_SETUP -#line 304 "maplexer.l" +#line 304 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(GEOMTRANSFORM); } YY_BREAK case 105: YY_RULE_SETUP -#line 305 "maplexer.l" +#line 305 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(GRID); } YY_BREAK case 106: YY_RULE_SETUP -#line 306 "maplexer.l" +#line 306 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(GRIDSTEP); } YY_BREAK case 107: YY_RULE_SETUP -#line 307 "maplexer.l" +#line 307 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(GRATICULE); } YY_BREAK case 108: YY_RULE_SETUP -#line 308 "maplexer.l" +#line 308 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(GROUP); } YY_BREAK case 109: YY_RULE_SETUP -#line 309 "maplexer.l" +#line 309 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(HEADER); } YY_BREAK case 110: YY_RULE_SETUP -#line 310 "maplexer.l" +#line 310 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(IMAGE); } YY_BREAK case 111: YY_RULE_SETUP -#line 311 "maplexer.l" +#line 311 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(IMAGECOLOR); } YY_BREAK case 112: YY_RULE_SETUP -#line 312 "maplexer.l" +#line 312 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(IMAGETYPE); } YY_BREAK case 113: YY_RULE_SETUP -#line 313 "maplexer.l" +#line 313 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(IMAGEMODE); } YY_BREAK case 114: YY_RULE_SETUP -#line 314 "maplexer.l" +#line 314 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(IMAGEPATH); } YY_BREAK case 115: YY_RULE_SETUP -#line 315 "maplexer.l" +#line 315 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TEMPPATH); } YY_BREAK case 116: YY_RULE_SETUP -#line 316 "maplexer.l" +#line 316 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(IMAGEURL); } YY_BREAK case 117: YY_RULE_SETUP -#line 317 "maplexer.l" +#line 317 "src/maplexer.l" { BEGIN(INCLUDE); } YY_BREAK case 118: YY_RULE_SETUP -#line 318 "maplexer.l" +#line 318 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(INDEX); } YY_BREAK case 119: YY_RULE_SETUP -#line 319 "maplexer.l" +#line 319 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(INITIALGAP); } YY_BREAK case 120: YY_RULE_SETUP -#line 320 "maplexer.l" +#line 320 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(INTERVALS); } YY_BREAK case 121: YY_RULE_SETUP -#line 321 "maplexer.l" +#line 321 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(JOIN); } YY_BREAK case 122: YY_RULE_SETUP -#line 322 "maplexer.l" +#line 322 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(KEYIMAGE); } YY_BREAK case 123: YY_RULE_SETUP -#line 323 "maplexer.l" +#line 323 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(KEYSIZE); } YY_BREAK case 124: YY_RULE_SETUP -#line 324 "maplexer.l" +#line 324 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(KEYSPACING); } YY_BREAK case 125: YY_RULE_SETUP -#line 325 "maplexer.l" +#line 325 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LABEL); } YY_BREAK case 126: YY_RULE_SETUP -#line 326 "maplexer.l" +#line 326 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LABELCACHE); } YY_BREAK case 127: YY_RULE_SETUP -#line 327 "maplexer.l" +#line 327 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LABELFORMAT); } YY_BREAK case 128: YY_RULE_SETUP -#line 328 "maplexer.l" +#line 328 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LABELITEM); } YY_BREAK case 129: YY_RULE_SETUP -#line 329 "maplexer.l" +#line 329 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LABELMAXSCALE); } YY_BREAK case 130: YY_RULE_SETUP -#line 330 "maplexer.l" +#line 330 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LABELMAXSCALEDENOM); } YY_BREAK case 131: YY_RULE_SETUP -#line 331 "maplexer.l" +#line 331 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LABELMINSCALE); } YY_BREAK case 132: YY_RULE_SETUP -#line 332 "maplexer.l" +#line 332 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LABELMINSCALEDENOM); } YY_BREAK case 133: YY_RULE_SETUP -#line 333 "maplexer.l" +#line 333 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LABELREQUIRES); } YY_BREAK case 134: YY_RULE_SETUP -#line 334 "maplexer.l" +#line 334 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LATLON); } YY_BREAK case 135: YY_RULE_SETUP -#line 335 "maplexer.l" +#line 335 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LAYER); } YY_BREAK case 136: YY_RULE_SETUP -#line 336 "maplexer.l" +#line 336 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LEADER); } YY_BREAK case 137: YY_RULE_SETUP -#line 337 "maplexer.l" +#line 337 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LEGEND); } YY_BREAK case 138: YY_RULE_SETUP -#line 338 "maplexer.l" +#line 338 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LEGENDFORMAT); } YY_BREAK case 139: YY_RULE_SETUP -#line 339 "maplexer.l" +#line 339 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LINECAP); } YY_BREAK case 140: YY_RULE_SETUP -#line 340 "maplexer.l" +#line 340 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LINEJOIN); } YY_BREAK case 141: YY_RULE_SETUP -#line 341 "maplexer.l" +#line 341 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(LINEJOINMAXSIZE); } YY_BREAK case 142: YY_RULE_SETUP -#line 342 "maplexer.l" +#line 342 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAP); } YY_BREAK case 143: YY_RULE_SETUP -#line 343 "maplexer.l" +#line 343 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MARKER); } YY_BREAK case 144: YY_RULE_SETUP -#line 344 "maplexer.l" +#line 344 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MARKERSIZE); } YY_BREAK case 145: YY_RULE_SETUP -#line 345 "maplexer.l" +#line 345 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MASK); } YY_BREAK case 146: YY_RULE_SETUP -#line 346 "maplexer.l" +#line 346 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXARCS); } YY_BREAK case 147: YY_RULE_SETUP -#line 347 "maplexer.l" +#line 347 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXBOXSIZE); } YY_BREAK case 148: YY_RULE_SETUP -#line 348 "maplexer.l" +#line 348 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXDISTANCE); } YY_BREAK case 149: YY_RULE_SETUP -#line 349 "maplexer.l" +#line 349 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXFEATURES); } YY_BREAK case 150: YY_RULE_SETUP -#line 350 "maplexer.l" +#line 350 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXINTERVAL); } YY_BREAK case 151: YY_RULE_SETUP -#line 351 "maplexer.l" +#line 351 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXSCALE); } YY_BREAK case 152: YY_RULE_SETUP -#line 352 "maplexer.l" +#line 352 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXSCALEDENOM); } YY_BREAK case 153: YY_RULE_SETUP -#line 353 "maplexer.l" +#line 353 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXGEOWIDTH); } YY_BREAK case 154: YY_RULE_SETUP -#line 354 "maplexer.l" +#line 354 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXLENGTH); } YY_BREAK case 155: YY_RULE_SETUP -#line 355 "maplexer.l" +#line 355 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXSIZE); } YY_BREAK case 156: YY_RULE_SETUP -#line 356 "maplexer.l" +#line 356 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXSUBDIVIDE); } YY_BREAK case 157: YY_RULE_SETUP -#line 357 "maplexer.l" +#line 357 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXTEMPLATE); } YY_BREAK case 158: YY_RULE_SETUP -#line 358 "maplexer.l" +#line 358 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXWIDTH); } YY_BREAK case 159: YY_RULE_SETUP -#line 359 "maplexer.l" +#line 359 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(METADATA); } YY_BREAK case 160: YY_RULE_SETUP -#line 360 "maplexer.l" +#line 360 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MIMETYPE); } YY_BREAK case 161: YY_RULE_SETUP -#line 361 "maplexer.l" +#line 361 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MINARCS); } YY_BREAK case 162: YY_RULE_SETUP -#line 362 "maplexer.l" +#line 362 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MINBOXSIZE); } YY_BREAK case 163: YY_RULE_SETUP -#line 363 "maplexer.l" +#line 363 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MINDISTANCE); } YY_BREAK case 164: YY_RULE_SETUP -#line 364 "maplexer.l" +#line 364 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(REPEATDISTANCE); } YY_BREAK case 165: YY_RULE_SETUP -#line 365 "maplexer.l" +#line 365 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MAXOVERLAPANGLE); } YY_BREAK case 166: YY_RULE_SETUP -#line 366 "maplexer.l" +#line 366 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MINFEATURESIZE); } YY_BREAK case 167: YY_RULE_SETUP -#line 367 "maplexer.l" +#line 367 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MININTERVAL); } YY_BREAK case 168: YY_RULE_SETUP -#line 368 "maplexer.l" +#line 368 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MINSCALE); } YY_BREAK case 169: YY_RULE_SETUP -#line 369 "maplexer.l" +#line 369 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MINSCALEDENOM); } YY_BREAK case 170: YY_RULE_SETUP -#line 370 "maplexer.l" +#line 370 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MINGEOWIDTH); } YY_BREAK case 171: YY_RULE_SETUP -#line 371 "maplexer.l" +#line 371 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MINSIZE); } YY_BREAK case 172: YY_RULE_SETUP -#line 372 "maplexer.l" +#line 372 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MINSUBDIVIDE); } YY_BREAK case 173: YY_RULE_SETUP -#line 373 "maplexer.l" +#line 373 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MINTEMPLATE); } YY_BREAK case 174: YY_RULE_SETUP -#line 374 "maplexer.l" +#line 374 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MINWIDTH); } YY_BREAK case 175: YY_RULE_SETUP -#line 375 "maplexer.l" +#line 375 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(NAME); } YY_BREAK case 176: YY_RULE_SETUP -#line 376 "maplexer.l" +#line 376 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(OFFSET); } YY_BREAK case 177: YY_RULE_SETUP -#line 377 "maplexer.l" +#line 377 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(OFFSITE); } YY_BREAK case 178: YY_RULE_SETUP -#line 378 "maplexer.l" +#line 378 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(OPACITY); } YY_BREAK case 179: YY_RULE_SETUP -#line 379 "maplexer.l" +#line 379 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(CONNECTIONOPTIONS); } YY_BREAK case 180: YY_RULE_SETUP -#line 380 "maplexer.l" +#line 380 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(OUTLINECOLOR); } YY_BREAK case 181: YY_RULE_SETUP -#line 381 "maplexer.l" +#line 381 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(OUTLINEWIDTH); } YY_BREAK case 182: YY_RULE_SETUP -#line 382 "maplexer.l" +#line 382 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(OUTPUTFORMAT); } YY_BREAK case 183: YY_RULE_SETUP -#line 383 "maplexer.l" +#line 383 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(PARTIALS); } YY_BREAK case 184: YY_RULE_SETUP -#line 384 "maplexer.l" +#line 384 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(PATTERN); } YY_BREAK case 185: YY_RULE_SETUP -#line 385 "maplexer.l" +#line 385 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(POINTS); } YY_BREAK case 186: YY_RULE_SETUP -#line 386 "maplexer.l" +#line 386 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(ITEMS); } YY_BREAK case 187: YY_RULE_SETUP -#line 387 "maplexer.l" +#line 387 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(POSITION); } YY_BREAK case 188: YY_RULE_SETUP -#line 388 "maplexer.l" +#line 388 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(POSTLABELCACHE); } YY_BREAK case 189: YY_RULE_SETUP -#line 389 "maplexer.l" +#line 389 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(PRIORITY); } YY_BREAK case 190: YY_RULE_SETUP -#line 390 "maplexer.l" +#line 390 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(PROCESSING); } YY_BREAK case 191: YY_RULE_SETUP -#line 391 "maplexer.l" +#line 391 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(PROJECTION); } YY_BREAK case 192: YY_RULE_SETUP -#line 392 "maplexer.l" +#line 392 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(QUERYFORMAT); } YY_BREAK case 193: YY_RULE_SETUP -#line 393 "maplexer.l" +#line 393 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(QUERYMAP); } YY_BREAK case 194: YY_RULE_SETUP -#line 394 "maplexer.l" +#line 394 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(REFERENCE); } YY_BREAK case 195: YY_RULE_SETUP -#line 395 "maplexer.l" +#line 395 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(REGION); } YY_BREAK case 196: YY_RULE_SETUP -#line 396 "maplexer.l" +#line 396 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(RELATIVETO); } YY_BREAK case 197: YY_RULE_SETUP -#line 397 "maplexer.l" +#line 397 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(REQUIRES); } YY_BREAK case 198: YY_RULE_SETUP -#line 398 "maplexer.l" +#line 398 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(RESOLUTION); } YY_BREAK case 199: YY_RULE_SETUP -#line 399 "maplexer.l" +#line 399 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(DEFRESOLUTION); } YY_BREAK case 200: YY_RULE_SETUP -#line 400 "maplexer.l" +#line 400 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SCALE); } YY_BREAK case 201: YY_RULE_SETUP -#line 401 "maplexer.l" +#line 401 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SCALEDENOM); } YY_BREAK case 202: YY_RULE_SETUP -#line 402 "maplexer.l" +#line 402 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SCALEBAR); } YY_BREAK case 203: YY_RULE_SETUP -#line 403 "maplexer.l" +#line 403 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SCALETOKEN); } YY_BREAK case 204: YY_RULE_SETUP -#line 404 "maplexer.l" +#line 404 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SHADOWCOLOR); } YY_BREAK case 205: YY_RULE_SETUP -#line 405 "maplexer.l" +#line 405 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SHADOWSIZE); } YY_BREAK case 206: YY_RULE_SETUP -#line 406 "maplexer.l" +#line 406 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SHAPEPATH); } YY_BREAK case 207: YY_RULE_SETUP -#line 407 "maplexer.l" +#line 407 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SIZE); } YY_BREAK case 208: YY_RULE_SETUP -#line 408 "maplexer.l" +#line 408 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SIZEUNITS); } YY_BREAK case 209: YY_RULE_SETUP -#line 409 "maplexer.l" +#line 409 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(STATUS); } YY_BREAK case 210: YY_RULE_SETUP -#line 410 "maplexer.l" +#line 410 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(STYLE); } YY_BREAK case 211: YY_RULE_SETUP -#line 411 "maplexer.l" +#line 411 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(STYLEITEM); } YY_BREAK case 212: YY_RULE_SETUP -#line 412 "maplexer.l" +#line 412 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SYMBOL); } YY_BREAK case 213: YY_RULE_SETUP -#line 413 "maplexer.l" +#line 413 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SYMBOLSCALE); } YY_BREAK case 214: YY_RULE_SETUP -#line 414 "maplexer.l" +#line 414 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SYMBOLSCALEDENOM); } YY_BREAK case 215: YY_RULE_SETUP -#line 415 "maplexer.l" +#line 415 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(SYMBOLSET); } YY_BREAK case 216: YY_RULE_SETUP -#line 416 "maplexer.l" +#line 416 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TABLE); } YY_BREAK case 217: YY_RULE_SETUP -#line 417 "maplexer.l" +#line 417 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TEMPLATE); } YY_BREAK case 218: YY_RULE_SETUP -#line 418 "maplexer.l" +#line 418 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TEXT); } YY_BREAK case 219: YY_RULE_SETUP -#line 419 "maplexer.l" +#line 419 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TILEINDEX); } YY_BREAK case 220: YY_RULE_SETUP -#line 420 "maplexer.l" +#line 420 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TILEITEM); } YY_BREAK case 221: YY_RULE_SETUP -#line 421 "maplexer.l" +#line 421 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TILESRS); } YY_BREAK case 222: YY_RULE_SETUP -#line 422 "maplexer.l" +#line 422 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TITLE); } YY_BREAK case 223: YY_RULE_SETUP -#line 423 "maplexer.l" +#line 423 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TO); } YY_BREAK case 224: YY_RULE_SETUP -#line 424 "maplexer.l" +#line 424 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TOLERANCE); } YY_BREAK case 225: YY_RULE_SETUP -#line 425 "maplexer.l" +#line 425 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TOLERANCEUNITS); } YY_BREAK case 226: YY_RULE_SETUP -#line 426 "maplexer.l" +#line 426 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TRANSPARENT); } YY_BREAK case 227: YY_RULE_SETUP -#line 427 "maplexer.l" +#line 427 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TRANSFORM); } YY_BREAK case 228: YY_RULE_SETUP -#line 428 "maplexer.l" +#line 428 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(TYPE); } YY_BREAK case 229: YY_RULE_SETUP -#line 429 "maplexer.l" +#line 429 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(UNITS); } YY_BREAK case 230: YY_RULE_SETUP -#line 430 "maplexer.l" +#line 430 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(UTFDATA); } YY_BREAK case 231: YY_RULE_SETUP -#line 431 "maplexer.l" +#line 431 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(UTFITEM); } YY_BREAK case 232: YY_RULE_SETUP -#line 432 "maplexer.l" +#line 432 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(VALIDATION); } YY_BREAK case 233: YY_RULE_SETUP -#line 433 "maplexer.l" +#line 433 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(VALUES); } YY_BREAK case 234: YY_RULE_SETUP -#line 434 "maplexer.l" +#line 434 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(WEB); } YY_BREAK case 235: YY_RULE_SETUP -#line 435 "maplexer.l" +#line 435 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(WIDTH); } YY_BREAK case 236: YY_RULE_SETUP -#line 436 "maplexer.l" +#line 436 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(WKT); } YY_BREAK case 237: YY_RULE_SETUP -#line 437 "maplexer.l" +#line 437 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(WRAP); } YY_BREAK case 238: YY_RULE_SETUP -#line 439 "maplexer.l" +#line 439 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LAYER_ANNOTATION); } YY_BREAK case 239: YY_RULE_SETUP -#line 440 "maplexer.l" +#line 440 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_AUTO); } YY_BREAK case 240: YY_RULE_SETUP -#line 441 "maplexer.l" +#line 441 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_AUTO2); } YY_BREAK case 241: YY_RULE_SETUP -#line 442 "maplexer.l" +#line 442 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CJC_BEVEL); } YY_BREAK case 242: YY_RULE_SETUP -#line 443 "maplexer.l" +#line 443 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_BITMAP); } YY_BREAK case 243: YY_RULE_SETUP -#line 444 "maplexer.l" +#line 444 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CJC_BUTT); } YY_BREAK case 244: YY_RULE_SETUP -#line 445 "maplexer.l" +#line 445 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CC); } YY_BREAK case 245: YY_RULE_SETUP -#line 446 "maplexer.l" +#line 446 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_ALIGN_CENTER); } YY_BREAK case 246: YY_RULE_SETUP -#line 447 "maplexer.l" +#line 447 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LAYER_CHART); } YY_BREAK case 247: YY_RULE_SETUP -#line 448 "maplexer.l" +#line 448 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LAYER_CIRCLE); } YY_BREAK case 248: YY_RULE_SETUP -#line 449 "maplexer.l" +#line 449 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CL); } YY_BREAK case 249: YY_RULE_SETUP -#line 450 "maplexer.l" +#line 450 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CR); } YY_BREAK case 250: YY_RULE_SETUP -#line 451 "maplexer.l" +#line 451 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_DB_CSV); } YY_BREAK case 251: YY_RULE_SETUP -#line 452 "maplexer.l" +#line 452 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_DB_POSTGRES); } YY_BREAK case 252: YY_RULE_SETUP -#line 453 "maplexer.l" +#line 453 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_DB_MYSQL); } YY_BREAK case 253: YY_RULE_SETUP -#line 454 "maplexer.l" +#line 454 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_DEFAULT); } YY_BREAK case 254: YY_RULE_SETUP -#line 455 "maplexer.l" +#line 455 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_DD); } YY_BREAK case 255: YY_RULE_SETUP -#line 456 "maplexer.l" +#line 456 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_SYMBOL_ELLIPSE); } YY_BREAK case 256: YY_RULE_SETUP -#line 457 "maplexer.l" +#line 457 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_EMBED); } YY_BREAK case 257: YY_RULE_SETUP -#line 458 "maplexer.l" +#line 458 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_FALSE); } YY_BREAK case 258: YY_RULE_SETUP -#line 459 "maplexer.l" +#line 459 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_FEET); } YY_BREAK case 259: YY_RULE_SETUP -#line 460 "maplexer.l" +#line 460 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_FOLLOW); } YY_BREAK case 260: YY_RULE_SETUP -#line 461 "maplexer.l" +#line 461 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_GIANT); } YY_BREAK case 261: YY_RULE_SETUP -#line 462 "maplexer.l" +#line 462 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_SYMBOL_HATCH); } YY_BREAK case 262: YY_RULE_SETUP -#line 463 "maplexer.l" +#line 463 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_KERNELDENSITY); } YY_BREAK case 263: YY_RULE_SETUP -#line 464 "maplexer.l" +#line 464 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_IDW); } YY_BREAK case 264: YY_RULE_SETUP -#line 465 "maplexer.l" +#line 465 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_HILITE); } YY_BREAK case 265: YY_RULE_SETUP -#line 466 "maplexer.l" +#line 466 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_INCHES); } YY_BREAK case 266: YY_RULE_SETUP -#line 467 "maplexer.l" +#line 467 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_KILOMETERS); } YY_BREAK case 267: YY_RULE_SETUP -#line 468 "maplexer.l" +#line 468 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LARGE); } YY_BREAK case 268: YY_RULE_SETUP -#line 469 "maplexer.l" +#line 469 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LC); } YY_BREAK case 269: YY_RULE_SETUP -#line 470 "maplexer.l" +#line 470 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_ALIGN_LEFT); } YY_BREAK case 270: YY_RULE_SETUP -#line 471 "maplexer.l" +#line 471 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LAYER_LINE); } YY_BREAK case 271: YY_RULE_SETUP -#line 472 "maplexer.l" +#line 472 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LL); } YY_BREAK case 272: YY_RULE_SETUP -#line 473 "maplexer.l" +#line 473 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LR); } YY_BREAK case 273: YY_RULE_SETUP -#line 474 "maplexer.l" +#line 474 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_MEDIUM); } YY_BREAK case 274: YY_RULE_SETUP -#line 475 "maplexer.l" +#line 475 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_METERS); } YY_BREAK case 275: YY_RULE_SETUP -#line 476 "maplexer.l" +#line 476 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_NAUTICALMILES); } YY_BREAK case 276: YY_RULE_SETUP -#line 477 "maplexer.l" +#line 477 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_MILES); } YY_BREAK case 277: YY_RULE_SETUP -#line 478 "maplexer.l" +#line 478 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CJC_MITER); } YY_BREAK case 278: YY_RULE_SETUP -#line 479 "maplexer.l" +#line 479 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_MULTIPLE); } YY_BREAK case 279: YY_RULE_SETUP -#line 480 "maplexer.l" +#line 480 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CJC_NONE); } YY_BREAK case 280: YY_RULE_SETUP -#line 481 "maplexer.l" +#line 481 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_NORMAL); } YY_BREAK case 281: YY_RULE_SETUP -#line 482 "maplexer.l" +#line 482 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_OFF); } YY_BREAK case 282: YY_RULE_SETUP -#line 483 "maplexer.l" +#line 483 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_OGR); } YY_BREAK case 283: YY_RULE_SETUP -#line 484 "maplexer.l" +#line 484 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_FLATGEOBUF); } YY_BREAK case 284: YY_RULE_SETUP -#line 485 "maplexer.l" +#line 485 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_ON); } YY_BREAK case 285: YY_RULE_SETUP -#line 486 "maplexer.l" +#line 486 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_JOIN_ONE_TO_ONE); } YY_BREAK case 286: YY_RULE_SETUP -#line 487 "maplexer.l" +#line 487 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_JOIN_ONE_TO_MANY); } YY_BREAK case 287: YY_RULE_SETUP -#line 488 "maplexer.l" +#line 488 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_ORACLESPATIAL); } YY_BREAK case 288: YY_RULE_SETUP -#line 489 "maplexer.l" +#line 489 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_PERCENTAGES); } YY_BREAK case 289: YY_RULE_SETUP -#line 490 "maplexer.l" +#line 490 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_SYMBOL_PIXMAP); } YY_BREAK case 290: YY_RULE_SETUP -#line 491 "maplexer.l" +#line 491 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_PIXELS); } YY_BREAK case 291: YY_RULE_SETUP -#line 492 "maplexer.l" +#line 492 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LAYER_POINT); } YY_BREAK case 292: YY_RULE_SETUP -#line 493 "maplexer.l" +#line 493 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LAYER_POLYGON); } YY_BREAK case 293: YY_RULE_SETUP -#line 494 "maplexer.l" +#line 494 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_POSTGIS); } YY_BREAK case 294: YY_RULE_SETUP -#line 495 "maplexer.l" +#line 495 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_PLUGIN); } YY_BREAK case 295: YY_RULE_SETUP -#line 496 "maplexer.l" +#line 496 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LAYER_QUERY); } YY_BREAK case 296: YY_RULE_SETUP -#line 497 "maplexer.l" +#line 497 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_LAYER_RASTER); } YY_BREAK case 297: YY_RULE_SETUP -#line 498 "maplexer.l" +#line 498 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_ALIGN_RIGHT); } YY_BREAK case 298: YY_RULE_SETUP -#line 499 "maplexer.l" +#line 499 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CJC_ROUND); } YY_BREAK case 299: YY_RULE_SETUP -#line 500 "maplexer.l" +#line 500 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_SELECTED); } YY_BREAK case 300: YY_RULE_SETUP -#line 501 "maplexer.l" +#line 501 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_SYMBOL_SIMPLE); } YY_BREAK case 301: YY_RULE_SETUP -#line 502 "maplexer.l" +#line 502 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_SINGLE); } YY_BREAK case 302: YY_RULE_SETUP -#line 503 "maplexer.l" +#line 503 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_SMALL); } YY_BREAK case 303: YY_RULE_SETUP -#line 504 "maplexer.l" +#line 504 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CJC_SQUARE); } YY_BREAK case 304: YY_RULE_SETUP -#line 505 "maplexer.l" +#line 505 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_SYMBOL_SVG); } YY_BREAK case 305: YY_RULE_SETUP -#line 506 "maplexer.l" +#line 506 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(POLAROFFSET); } YY_BREAK case 306: YY_RULE_SETUP -#line 507 "maplexer.l" +#line 507 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TINY); } YY_BREAK case 307: YY_RULE_SETUP -#line 508 "maplexer.l" +#line 508 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CJC_TRIANGLE); } YY_BREAK case 308: YY_RULE_SETUP -#line 509 "maplexer.l" +#line 509 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TRUE); } YY_BREAK case 309: YY_RULE_SETUP -#line 510 "maplexer.l" +#line 510 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_TRUETYPE); } YY_BREAK case 310: YY_RULE_SETUP -#line 511 "maplexer.l" +#line 511 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_UC); } YY_BREAK case 311: YY_RULE_SETUP -#line 512 "maplexer.l" +#line 512 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_UL); } YY_BREAK case 312: YY_RULE_SETUP -#line 513 "maplexer.l" +#line 513 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_UR); } YY_BREAK case 313: YY_RULE_SETUP -#line 514 "maplexer.l" +#line 514 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_UNION); } YY_BREAK case 314: YY_RULE_SETUP -#line 515 "maplexer.l" +#line 515 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_UVRASTER); } YY_BREAK case 315: YY_RULE_SETUP -#line 516 "maplexer.l" +#line 516 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_CONTOUR); } YY_BREAK case 316: YY_RULE_SETUP -#line 517 "maplexer.l" +#line 517 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_SYMBOL_VECTOR); } YY_BREAK case 317: YY_RULE_SETUP -#line 518 "maplexer.l" +#line 518 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_WFS); } YY_BREAK case 318: YY_RULE_SETUP -#line 519 "maplexer.l" +#line 519 "src/maplexer.l" { MS_LEXER_RETURN_TOKEN(MS_WMS); } YY_BREAK case 319: /* rule 319 can match eol */ YY_RULE_SETUP -#line 521 "maplexer.l" +#line 521 "src/maplexer.l" { msyytext++; msyytext[msyyleng-1-1] = '\0'; @@ -4224,7 +4224,7 @@ YY_RULE_SETUP YY_BREAK case 320: YY_RULE_SETUP -#line 530 "maplexer.l" +#line 530 "src/maplexer.l" { /* attribute binding - shape (fixed value) */ return(MS_TOKEN_BINDING_SHAPE); @@ -4232,7 +4232,7 @@ YY_RULE_SETUP YY_BREAK case 321: YY_RULE_SETUP -#line 534 "maplexer.l" +#line 534 "src/maplexer.l" { /* attribute binding - map cellsize */ return(MS_TOKEN_BINDING_MAP_CELLSIZE); @@ -4240,7 +4240,7 @@ YY_RULE_SETUP YY_BREAK case 322: YY_RULE_SETUP -#line 538 "maplexer.l" +#line 538 "src/maplexer.l" { /* attribute binding - data cellsize */ return(MS_TOKEN_BINDING_DATA_CELLSIZE); @@ -4249,7 +4249,7 @@ YY_RULE_SETUP case 323: /* rule 323 can match eol */ YY_RULE_SETUP -#line 542 "maplexer.l" +#line 542 "src/maplexer.l" { /* attribute binding - numeric (no quotes) */ msyytext++; @@ -4263,7 +4263,7 @@ YY_RULE_SETUP case 324: /* rule 324 can match eol */ YY_RULE_SETUP -#line 551 "maplexer.l" +#line 551 "src/maplexer.l" { /* attribute binding - string (single or double quotes) */ msyytext+=2; @@ -4277,7 +4277,7 @@ YY_RULE_SETUP case 325: /* rule 325 can match eol */ YY_RULE_SETUP -#line 560 "maplexer.l" +#line 560 "src/maplexer.l" { /* attribute binding - time */ msyytext+=2; @@ -4290,7 +4290,7 @@ YY_RULE_SETUP YY_BREAK case 326: YY_RULE_SETUP -#line 570 "maplexer.l" +#line 570 "src/maplexer.l" { MS_LEXER_STRING_REALLOC(msyystring_buffer, msyyleng, msyystring_buffer_size); @@ -4301,7 +4301,7 @@ YY_RULE_SETUP YY_BREAK case 327: YY_RULE_SETUP -#line 578 "maplexer.l" +#line 578 "src/maplexer.l" { MS_LEXER_STRING_REALLOC(msyystring_buffer, msyyleng, msyystring_buffer_size); @@ -4313,7 +4313,7 @@ YY_RULE_SETUP case 328: /* rule 328 can match eol */ YY_RULE_SETUP -#line 586 "maplexer.l" +#line 586 "src/maplexer.l" { msyytext++; msyytext[msyyleng-1-1] = '\0'; @@ -4326,7 +4326,7 @@ YY_RULE_SETUP case 329: /* rule 329 can match eol */ YY_RULE_SETUP -#line 595 "maplexer.l" +#line 595 "src/maplexer.l" { msyytext++; msyytext[msyyleng-1-2] = '\0'; @@ -4339,7 +4339,7 @@ YY_RULE_SETUP case 330: /* rule 330 can match eol */ YY_RULE_SETUP -#line 604 "maplexer.l" +#line 604 "src/maplexer.l" { msyytext++; msyytext[msyyleng-1-1] = '\0'; @@ -4351,7 +4351,7 @@ YY_RULE_SETUP YY_BREAK case 331: YY_RULE_SETUP -#line 613 "maplexer.l" +#line 613 "src/maplexer.l" { msyytext++; msyytext[msyyleng-1-1] = '\0'; @@ -4363,7 +4363,7 @@ YY_RULE_SETUP YY_BREAK case 332: YY_RULE_SETUP -#line 622 "maplexer.l" +#line 622 "src/maplexer.l" { msyytext++; msyytext[msyyleng-1-1] = '\0'; @@ -4375,7 +4375,7 @@ YY_RULE_SETUP YY_BREAK case 333: YY_RULE_SETUP -#line 631 "maplexer.l" +#line 631 "src/maplexer.l" { msyystring_return_state = MS_STRING; msyystring_begin = msyytext[0]; @@ -4386,7 +4386,7 @@ YY_RULE_SETUP YY_BREAK case 334: YY_RULE_SETUP -#line 639 "maplexer.l" +#line 639 "src/maplexer.l" { if (msyystring_begin == msyytext[0]) { BEGIN(msyystring_begin_state); @@ -4415,7 +4415,7 @@ YY_RULE_SETUP YY_BREAK case 335: YY_RULE_SETUP -#line 665 "maplexer.l" +#line 665 "src/maplexer.l" { ++msyystring_size; MS_LEXER_STRING_REALLOC(msyystring_buffer, msyystring_size, @@ -4431,7 +4431,7 @@ YY_RULE_SETUP case 336: /* rule 336 can match eol */ YY_RULE_SETUP -#line 677 "maplexer.l" +#line 677 "src/maplexer.l" { int old_size = msyystring_size; msyystring_size += msyyleng; @@ -4443,7 +4443,7 @@ YY_RULE_SETUP case 337: /* rule 337 can match eol */ YY_RULE_SETUP -#line 685 "maplexer.l" +#line 685 "src/maplexer.l" { msyytext++; msyytext[msyyleng-1-1] = '\0'; @@ -4472,7 +4472,7 @@ YY_RULE_SETUP YY_BREAK case 338: YY_RULE_SETUP -#line 711 "maplexer.l" +#line 711 "src/maplexer.l" { msyystring_return_state = MS_TOKEN_LITERAL_STRING; msyystring_begin = msyytext[0]; @@ -4483,7 +4483,7 @@ YY_RULE_SETUP YY_BREAK case 339: YY_RULE_SETUP -#line 719 "maplexer.l" +#line 719 "src/maplexer.l" { MS_LEXER_STRING_REALLOC(msyystring_buffer, msyyleng, msyystring_buffer_size); @@ -4494,12 +4494,12 @@ YY_RULE_SETUP case 340: /* rule 340 can match eol */ YY_RULE_SETUP -#line 726 "maplexer.l" +#line 726 "src/maplexer.l" { msyylineno++; } YY_BREAK case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(CONFIG_FILE): -#line 728 "maplexer.l" +#line 728 "src/maplexer.l" { if( --include_stack_ptr < 0 ) return(EOF); /* end of main file */ @@ -4514,14 +4514,14 @@ case YY_STATE_EOF(CONFIG_FILE): case 341: /* rule 341 can match eol */ YY_RULE_SETUP -#line 739 "maplexer.l" +#line 739 "src/maplexer.l" { return(0); } YY_BREAK case 342: YY_RULE_SETUP -#line 743 "maplexer.l" +#line 743 "src/maplexer.l" { MS_LEXER_STRING_REALLOC(msyystring_buffer, msyyleng, msyystring_buffer_size); @@ -4531,15 +4531,15 @@ YY_RULE_SETUP YY_BREAK case 343: YY_RULE_SETUP -#line 749 "maplexer.l" +#line 749 "src/maplexer.l" { return(msyytext[0]); } YY_BREAK case 344: YY_RULE_SETUP -#line 750 "maplexer.l" +#line 750 "src/maplexer.l" ECHO; YY_BREAK -#line 4543 "/home/even/mapserver/mapserver/maplexer.c" +#line 4543 "src/maplexer.c" case YY_STATE_EOF(EXPRESSION_STRING): case YY_STATE_EOF(INCLUDE): case YY_STATE_EOF(MSSTRING): @@ -5548,7 +5548,7 @@ void yyfree (void * ptr ) #define YYTABLES_NAME "yytables" -#line 750 "maplexer.l" +#line 750 "src/maplexer.l" /* diff --git a/src/mapparser.c b/src/mapparser.c index 60265f96ae..efcaa26c60 100644 --- a/src/mapparser.c +++ b/src/mapparser.c @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.5.1. */ /* Bison implementation for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -40,11 +41,14 @@ define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + /* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "3.0.4" +#define YYBISON_VERSION "3.5.1" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -61,8 +65,8 @@ -/* Copy the first part of user declarations. */ -#line 5 "mapparser.y" /* yacc.c:339 */ +/* First part of user prologue. */ +#line 5 "src/mapparser.y" /* C declarations */ #include @@ -80,13 +84,26 @@ int yylex(YYSTYPE *, parseObj *); /* prototype functions, defined after the grammar */ int yyerror(parseObj *, const char *); -#line 84 "/vagrant/mapparser.c" /* yacc.c:339 */ +#line 88 "src/mapparser.c" +# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) +# else +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif # ifndef YY_NULLPTR -# if defined __cplusplus && 201103L <= __cplusplus -# define YY_NULLPTR nullptr +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif # else -# define YY_NULLPTR 0 +# define YY_NULLPTR ((void*)0) # endif # endif @@ -98,10 +115,10 @@ int yyerror(parseObj *, const char *); # define YYERROR_VERBOSE 0 #endif -/* In a future release of Bison, this section will be replaced - by #include "mapparser.h". */ -#ifndef YY_YY_VAGRANT_MAPPARSER_H_INCLUDED -# define YY_YY_VAGRANT_MAPPARSER_H_INCLUDED +/* Use api.header.include to #include this header + instead of duplicating it here. */ +#ifndef YY_YY_SRC_MAPPARSER_H_INCLUDED +# define YY_YY_SRC_MAPPARSER_H_INCLUDED /* Debug traces. */ #ifndef YYDEBUG # define YYDEBUG 0 @@ -219,10 +236,9 @@ extern int yydebug; /* Value type. */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED - union YYSTYPE { -#line 30 "mapparser.y" /* yacc.c:355 */ +#line 30 "src/mapparser.y" double dblval; int intval; @@ -230,9 +246,9 @@ union YYSTYPE struct tm tmval; shapeObj *shpval; -#line 234 "/vagrant/mapparser.c" /* yacc.c:355 */ -}; +#line 250 "src/mapparser.c" +}; typedef union YYSTYPE YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 @@ -242,38 +258,83 @@ typedef union YYSTYPE YYSTYPE; int yyparse (parseObj *p); -#endif /* !YY_YY_VAGRANT_MAPPARSER_H_INCLUDED */ +#endif /* !YY_YY_SRC_MAPPARSER_H_INCLUDED */ -/* Copy the second part of user declarations. */ -#line 250 "/vagrant/mapparser.c" /* yacc.c:358 */ #ifdef short # undef short #endif -#ifdef YYTYPE_UINT8 -typedef YYTYPE_UINT8 yytype_uint8; -#else -typedef unsigned char yytype_uint8; +/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure + and (if available) are included + so that the code can choose integer types of a good width. */ + +#ifndef __PTRDIFF_MAX__ +# include /* INFRINGES ON USER NAME SPACE */ +# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_STDINT_H +# endif #endif -#ifdef YYTYPE_INT8 -typedef YYTYPE_INT8 yytype_int8; +/* Narrow types that promote to a signed type and that can represent a + signed or unsigned integer of at least N bits. In tables they can + save space and decrease cache pressure. Promoting to a signed type + helps avoid bugs in integer arithmetic. */ + +#ifdef __INT_LEAST8_MAX__ +typedef __INT_LEAST8_TYPE__ yytype_int8; +#elif defined YY_STDINT_H +typedef int_least8_t yytype_int8; #else typedef signed char yytype_int8; #endif -#ifdef YYTYPE_UINT16 -typedef YYTYPE_UINT16 yytype_uint16; +#ifdef __INT_LEAST16_MAX__ +typedef __INT_LEAST16_TYPE__ yytype_int16; +#elif defined YY_STDINT_H +typedef int_least16_t yytype_int16; #else -typedef unsigned short int yytype_uint16; +typedef short yytype_int16; #endif -#ifdef YYTYPE_INT16 -typedef YYTYPE_INT16 yytype_int16; +#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST8_TYPE__ yytype_uint8; +#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST8_MAX <= INT_MAX) +typedef uint_least8_t yytype_uint8; +#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX +typedef unsigned char yytype_uint8; #else -typedef short int yytype_int16; +typedef short yytype_uint8; +#endif + +#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST16_TYPE__ yytype_uint16; +#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST16_MAX <= INT_MAX) +typedef uint_least16_t yytype_uint16; +#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX +typedef unsigned short yytype_uint16; +#else +typedef int yytype_uint16; +#endif + +#ifndef YYPTRDIFF_T +# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ +# define YYPTRDIFF_T __PTRDIFF_TYPE__ +# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ +# elif defined PTRDIFF_MAX +# ifndef ptrdiff_t +# include /* INFRINGES ON USER NAME SPACE */ +# endif +# define YYPTRDIFF_T ptrdiff_t +# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX +# else +# define YYPTRDIFF_T long +# define YYPTRDIFF_MAXIMUM LONG_MAX +# endif #endif #ifndef YYSIZE_T @@ -281,15 +342,27 @@ typedef short int yytype_int16; # define YYSIZE_T __SIZE_TYPE__ # elif defined size_t # define YYSIZE_T size_t -# elif ! defined YYSIZE_T +# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else -# define YYSIZE_T unsigned int +# define YYSIZE_T unsigned # endif #endif -#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) +#define YYSIZE_MAXIMUM \ + YY_CAST (YYPTRDIFF_T, \ + (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ + ? YYPTRDIFF_MAXIMUM \ + : YY_CAST (YYSIZE_T, -1))) + +#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) + +/* Stored state numbers (used for stacks). */ +typedef yytype_int16 yy_state_t; + +/* State numbers in computations. */ +typedef int yy_state_fast_t; #ifndef YY_ # if defined YYENABLE_NLS && YYENABLE_NLS @@ -303,30 +376,19 @@ typedef short int yytype_int16; # endif #endif -#ifndef YY_ATTRIBUTE -# if (defined __GNUC__ \ - && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ - || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C -# define YY_ATTRIBUTE(Spec) __attribute__(Spec) +#ifndef YY_ATTRIBUTE_PURE +# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) # else -# define YY_ATTRIBUTE(Spec) /* empty */ +# define YY_ATTRIBUTE_PURE # endif #endif -#ifndef YY_ATTRIBUTE_PURE -# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) -#endif - #ifndef YY_ATTRIBUTE_UNUSED -# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) -#endif - -#if !defined _Noreturn \ - && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) -# if defined _MSC_VER && 1200 <= _MSC_VER -# define _Noreturn __declspec (noreturn) +# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) # else -# define _Noreturn YY_ATTRIBUTE ((__noreturn__)) +# define YY_ATTRIBUTE_UNUSED # endif #endif @@ -337,13 +399,13 @@ typedef short int yytype_int16; # define YYUSE(E) /* empty */ #endif -#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") -# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ _Pragma ("GCC diagnostic pop") #else # define YY_INITIAL_VALUE(Value) Value @@ -356,6 +418,20 @@ typedef short int yytype_int16; # define YY_INITIAL_VALUE(Value) /* Nothing. */ #endif +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif + + +#define YY_ASSERT(E) ((void) (0 && (E))) #if ! defined yyoverflow || YYERROR_VERBOSE @@ -432,17 +508,17 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */ /* A type that is properly aligned for any stack member. */ union yyalloc { - yytype_int16 yyss_alloc; + yy_state_t yyss_alloc; YYSTYPE yyvs_alloc; }; /* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) +# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ # define YYSTACK_BYTES(N) \ - ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ + YYSTACK_GAP_MAXIMUM) # define YYCOPY_NEEDED 1 @@ -455,11 +531,11 @@ union yyalloc # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ do \ { \ - YYSIZE_T yynewbytes; \ + YYPTRDIFF_T yynewbytes; \ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ Stack = &yyptr->Stack_alloc; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof (*yyptr); \ + yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / YYSIZEOF (*yyptr); \ } \ while (0) @@ -471,12 +547,12 @@ union yyalloc # ifndef YYCOPY # if defined __GNUC__ && 1 < __GNUC__ # define YYCOPY(Dst, Src, Count) \ - __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) + __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) # else # define YYCOPY(Dst, Src, Count) \ do \ { \ - YYSIZE_T yyi; \ + YYPTRDIFF_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ (Dst)[yyi] = (Src)[yyi]; \ } \ @@ -499,17 +575,18 @@ union yyalloc /* YYNSTATES -- Number of states. */ #define YYNSTATES 306 -/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned - by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 #define YYMAXUTOK 306 + +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ #define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM - as returned by yylex, without out-of-bounds checking. */ -static const yytype_uint8 yytranslate[] = + as returned by yylex. */ +static const yytype_int8 yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -546,7 +623,7 @@ static const yytype_uint8 yytranslate[] = #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ -static const yytype_uint16 yyrline[] = +static const yytype_int16 yyrline[] = { 0, 68, 68, 69, 82, 96, 110, 120, 121, 122, 126, 134, 143, 151, 160, 168, 177, 185, 194, 195, @@ -583,7 +660,7 @@ static const char *const yytname[] = # ifdef YYPRINT /* YYTOKNUM[NUM] -- (External) token number corresponding to the (internal) symbol number NUM (which must be that of a token). */ -static const yytype_uint16 yytoknum[] = +static const yytype_int16 yytoknum[] = { 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, @@ -595,14 +672,14 @@ static const yytype_uint16 yytoknum[] = }; # endif -#define YYPACT_NINF -56 +#define YYPACT_NINF (-56) -#define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-56))) +#define yypact_value_is_default(Yyn) \ + ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF -1 +#define YYTABLE_NINF (-1) -#define yytable_value_is_error(Yytable_value) \ +#define yytable_value_is_error(Yyn) \ 0 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing @@ -645,7 +722,7 @@ static const yytype_int16 yypact[] = /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. Performed when YYTABLE does not specify something else to do. Zero means the default is an error. */ -static const yytype_uint8 yydefact[] = +static const yytype_int8 yydefact[] = { 2, 7, 63, 92, 101, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -695,7 +772,7 @@ static const yytype_int8 yydefgoto[] = /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule whose number is the opposite. If YYTABLE_NINF, syntax error. */ -static const yytype_uint16 yytable[] = +static const yytype_int16 yytable[] = { 43, 2, 4, 49, 45, 124, 106, 87, 88, 3, 50, 89, 85, 234, 124, 107, 108, 109, 110, 111, @@ -815,7 +892,7 @@ static const yytype_int16 yycheck[] = /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ -static const yytype_uint8 yystos[] = +static const yytype_int8 yystos[] = { 0, 3, 4, 5, 6, 7, 10, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, @@ -851,7 +928,7 @@ static const yytype_uint8 yystos[] = }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const yytype_uint8 yyr1[] = +static const yytype_int8 yyr1[] = { 0, 61, 62, 62, 62, 62, 62, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, @@ -867,7 +944,7 @@ static const yytype_uint8 yyr1[] = }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ -static const yytype_uint8 yyr2[] = +static const yytype_int8 yyr2[] = { 0, 2, 0, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, @@ -895,22 +972,22 @@ static const yytype_uint8 yyr2[] = #define YYRECOVERING() (!!yyerrstatus) -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - YYPOPSTACK (yylen); \ - yystate = *yyssp; \ - goto yybackup; \ - } \ - else \ - { \ - yyerror (p, YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (0) +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (p, YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) /* Error token number */ #define YYTERROR 1 @@ -950,38 +1027,40 @@ do { \ } while (0) -/*----------------------------------------. -| Print this symbol's value on YYOUTPUT. | -`----------------------------------------*/ +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ static void -yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parseObj *p) +yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, parseObj *p) { - FILE *yyo = yyoutput; - YYUSE (yyo); + FILE *yyoutput = yyo; + YYUSE (yyoutput); YYUSE (p); if (!yyvaluep) return; # ifdef YYPRINT if (yytype < YYNTOKENS) - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); + YYPRINT (yyo, yytoknum[yytype], *yyvaluep); # endif + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN YYUSE (yytype); + YY_IGNORE_MAYBE_UNINITIALIZED_END } -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ static void -yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parseObj *p) +yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, parseObj *p) { - YYFPRINTF (yyoutput, "%s %s (", + YYFPRINTF (yyo, "%s %s (", yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); - yy_symbol_value_print (yyoutput, yytype, yyvaluep, p); - YYFPRINTF (yyoutput, ")"); + yy_symbol_value_print (yyo, yytype, yyvaluep, p); + YYFPRINTF (yyo, ")"); } /*------------------------------------------------------------------. @@ -990,7 +1069,7 @@ yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, par `------------------------------------------------------------------*/ static void -yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) { YYFPRINTF (stderr, "Stack now"); for (; yybottom <= yytop; yybottom++) @@ -1013,20 +1092,20 @@ do { \ `------------------------------------------------*/ static void -yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, parseObj *p) +yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule, parseObj *p) { - unsigned long int yylno = yyrline[yyrule]; + int yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; - YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", yyrule - 1, yylno); /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { YYFPRINTF (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, - yystos[yyssp[yyi + 1 - yynrhs]], - &(yyvsp[(yyi + 1) - (yynrhs)]) + yystos[+yyssp[yyi + 1 - yynrhs]], + &yyvsp[(yyi + 1) - (yynrhs)] , p); YYFPRINTF (stderr, "\n"); } @@ -1070,13 +1149,13 @@ int yydebug; # ifndef yystrlen # if defined __GLIBC__ && defined _STRING_H -# define yystrlen strlen +# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) # else /* Return the length of YYSTR. */ -static YYSIZE_T +static YYPTRDIFF_T yystrlen (const char *yystr) { - YYSIZE_T yylen; + YYPTRDIFF_T yylen; for (yylen = 0; yystr[yylen]; yylen++) continue; return yylen; @@ -1112,12 +1191,12 @@ yystpcpy (char *yydest, const char *yysrc) backslash-backslash). YYSTR is taken from yytname. If YYRES is null, do not copy; instead, return the length of what the result would have been. */ -static YYSIZE_T +static YYPTRDIFF_T yytnamerr (char *yyres, const char *yystr) { if (*yystr == '"') { - YYSIZE_T yyn = 0; + YYPTRDIFF_T yyn = 0; char const *yyp = yystr; for (;;) @@ -1130,7 +1209,10 @@ yytnamerr (char *yyres, const char *yystr) case '\\': if (*++yyp != '\\') goto do_not_strip_quotes; - /* Fall through. */ + else + goto append; + + append: default: if (yyres) yyres[yyn] = *yyp; @@ -1145,10 +1227,10 @@ yytnamerr (char *yyres, const char *yystr) do_not_strip_quotes: ; } - if (! yyres) + if (yyres) + return yystpcpy (yyres, yystr) - yyres; + else return yystrlen (yystr); - - return yystpcpy (yyres, yystr) - yyres; } # endif @@ -1161,19 +1243,19 @@ yytnamerr (char *yyres, const char *yystr) *YYMSG_ALLOC to the required number of bytes. Return 2 if the required number of bytes is too large to store. */ static int -yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, - yytype_int16 *yyssp, int yytoken) +yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg, + yy_state_t *yyssp, int yytoken) { - YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); - YYSIZE_T yysize = yysize0; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; /* Internationalized format string. */ const char *yyformat = YY_NULLPTR; - /* Arguments of yyformat. */ + /* Arguments of yyformat: reported tokens (one for the "unexpected", + one per "expected"). */ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - /* Number of reported tokens (one for the "unexpected", one per - "expected"). */ + /* Actual size of YYARG. */ int yycount = 0; + /* Cumulated lengths of YYARG. */ + YYPTRDIFF_T yysize = 0; /* There are many possibilities here to consider: - If this state is a consistent state with a default action, then @@ -1200,7 +1282,9 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, */ if (yytoken != YYEMPTY) { - int yyn = yypact[*yyssp]; + int yyn = yypact[+*yyssp]; + YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); + yysize = yysize0; yyarg[yycount++] = yytname[yytoken]; if (!yypact_value_is_default (yyn)) { @@ -1225,11 +1309,12 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, } yyarg[yycount++] = yytname[yyx]; { - YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); - if (! (yysize <= yysize1 - && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + YYPTRDIFF_T yysize1 + = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } } } @@ -1241,6 +1326,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, case N: \ yyformat = S; \ break + default: /* Avoid compiler warnings. */ YYCASE_(0, YY_("syntax error")); YYCASE_(1, YY_("syntax error, unexpected %s")); YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); @@ -1251,10 +1337,13 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, } { - YYSIZE_T yysize1 = yysize + yystrlen (yyformat); - if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + /* Don't count the "%s"s in the final size, but reserve room for + the terminator. */ + YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } if (*yymsg_alloc < yysize) @@ -1280,8 +1369,8 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, } else { - yyp++; - yyformat++; + ++yyp; + ++yyformat; } } return 0; @@ -1329,7 +1418,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); /* Number of syntax errors so far. */ int yynerrs; - int yystate; + yy_state_fast_t yystate; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; @@ -1341,16 +1430,16 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); to reallocate them elsewhere. */ /* The state stack. */ - yytype_int16 yyssa[YYINITDEPTH]; - yytype_int16 *yyss; - yytype_int16 *yyssp; + yy_state_t yyssa[YYINITDEPTH]; + yy_state_t *yyss; + yy_state_t *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs; YYSTYPE *yyvsp; - YYSIZE_T yystacksize; + YYPTRDIFF_T yystacksize; int yyn; int yyresult; @@ -1364,7 +1453,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; char *yymsg = yymsgbuf; - YYSIZE_T yymsg_alloc = sizeof yymsgbuf; + YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; #endif #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) @@ -1385,46 +1474,54 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); yychar = YYEMPTY; /* Cause a token to be read. */ goto yysetstate; + /*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | +| yynewstate -- push a new state, which is found in yystate. | `------------------------------------------------------------*/ - yynewstate: +yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks. */ yyssp++; - yysetstate: - *yyssp = yystate; + +/*--------------------------------------------------------------------. +| yysetstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + YY_ASSERT (0 <= yystate && yystate < YYNSTATES); + YY_IGNORE_USELESS_CAST_BEGIN + *yyssp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + goto yyexhaustedlab; +#else { /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; + YYPTRDIFF_T yysize = yyssp - yyss + 1; -#ifdef yyoverflow +# if defined yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into memory. */ + yy_state_t *yyss1 = yyss; YYSTYPE *yyvs1 = yyvs; - yytype_int16 *yyss1 = yyss; /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. This used to be a conditional around just the two extra args, but that might be undefined if yyoverflow is a macro. */ yyoverflow (YY_("memory exhausted"), - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), + &yyss1, yysize * YYSIZEOF (*yyssp), + &yyvs1, yysize * YYSIZEOF (*yyvsp), &yystacksize); - yyss = yyss1; yyvs = yyvs1; } -#else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyexhaustedlab; -# else +# else /* defined YYSTACK_RELOCATE */ /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) goto yyexhaustedlab; @@ -1433,42 +1530,43 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); yystacksize = YYMAXDEPTH; { - yytype_int16 *yyss1 = yyss; + yy_state_t *yyss1 = yyss; union yyalloc *yyptr = - (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + YY_CAST (union yyalloc *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); if (! yyptr) goto yyexhaustedlab; YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyvs_alloc, yyvs); -# undef YYSTACK_RELOCATE +# undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif -#endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; - YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); + YY_IGNORE_USELESS_CAST_BEGIN + YYDPRINTF ((stderr, "Stack size increased to %ld\n", + YY_CAST (long, yystacksize))); + YY_IGNORE_USELESS_CAST_END if (yyss + yystacksize - 1 <= yyssp) YYABORT; } - - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ if (yystate == YYFINAL) YYACCEPT; goto yybackup; + /*-----------. | yybackup. | `-----------*/ yybackup: - /* Do appropriate processing given the current state. Read a lookahead token if we need one and don't already have one. */ @@ -1518,15 +1616,13 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); /* Shift the lookahead token. */ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); - - /* Discard the shifted token. */ - yychar = YYEMPTY; - yystate = yyn; YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN *++yyvsp = yylval; YY_IGNORE_MAYBE_UNINITIALIZED_END + /* Discard the shifted token. */ + yychar = YYEMPTY; goto yynewstate; @@ -1541,7 +1637,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); /*-----------------------------. -| yyreduce -- Do a reduction. | +| yyreduce -- do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ @@ -1561,9 +1657,9 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); YY_REDUCE_PRINT (yyn); switch (yyn) { - case 3: -#line 69 "mapparser.y" /* yacc.c:1646 */ - { + case 3: +#line 69 "src/mapparser.y" + { switch(p->type) { case(MS_PARSE_TYPE_BOOLEAN): p->result.intval = (yyvsp[0].intval); @@ -1576,12 +1672,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); break; } } -#line 1580 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1676 "src/mapparser.c" break; case 4: -#line 82 "mapparser.y" /* yacc.c:1646 */ - { +#line 82 "src/mapparser.y" + { switch(p->type) { case(MS_PARSE_TYPE_BOOLEAN): if((yyvsp[0].dblval) != 0) @@ -1595,12 +1691,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); break; } } -#line 1599 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1695 "src/mapparser.c" break; case 5: -#line 96 "mapparser.y" /* yacc.c:1646 */ - { +#line 96 "src/mapparser.y" + { switch(p->type) { case(MS_PARSE_TYPE_BOOLEAN): if((yyvsp[0].strval)) /* string is not NULL */ @@ -1614,12 +1710,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); break; } } -#line 1618 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1714 "src/mapparser.c" break; case 6: -#line 110 "mapparser.y" /* yacc.c:1646 */ - { +#line 110 "src/mapparser.y" + { switch(p->type) { case(MS_PARSE_TYPE_SHAPE): p->result.shpval = (yyvsp[0].shpval); @@ -1627,27 +1723,27 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); break; } } -#line 1631 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1727 "src/mapparser.c" break; case 8: -#line 121 "mapparser.y" /* yacc.c:1646 */ - { (yyval.intval) = (yyvsp[-1].intval); } -#line 1637 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 121 "src/mapparser.y" + { (yyval.intval) = (yyvsp[-1].intval); } +#line 1733 "src/mapparser.c" break; case 9: -#line 122 "mapparser.y" /* yacc.c:1646 */ - { +#line 122 "src/mapparser.y" + { (yyval.intval) = MS_FALSE; if((yyvsp[-2].intval) == (yyvsp[0].intval)) (yyval.intval) = MS_TRUE; } -#line 1646 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1742 "src/mapparser.c" break; case 10: -#line 126 "mapparser.y" /* yacc.c:1646 */ - { +#line 126 "src/mapparser.y" + { if((yyvsp[-2].intval) == MS_TRUE) (yyval.intval) = MS_TRUE; else if((yyvsp[0].intval) == MS_TRUE) @@ -1655,12 +1751,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.intval) = MS_FALSE; } -#line 1659 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1755 "src/mapparser.c" break; case 11: -#line 134 "mapparser.y" /* yacc.c:1646 */ - { +#line 134 "src/mapparser.y" + { if((yyvsp[-2].intval) == MS_TRUE) { if((yyvsp[0].intval) == MS_TRUE) (yyval.intval) = MS_TRUE; @@ -1669,12 +1765,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = MS_FALSE; } -#line 1673 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1769 "src/mapparser.c" break; case 12: -#line 143 "mapparser.y" /* yacc.c:1646 */ - { +#line 143 "src/mapparser.y" + { if((yyvsp[-2].intval) == MS_TRUE) (yyval.intval) = MS_TRUE; else if((yyvsp[0].dblval) != 0) @@ -1682,12 +1778,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.intval) = MS_FALSE; } -#line 1686 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1782 "src/mapparser.c" break; case 13: -#line 151 "mapparser.y" /* yacc.c:1646 */ - { +#line 151 "src/mapparser.y" + { if((yyvsp[-2].intval) == MS_TRUE) { if((yyvsp[0].dblval) != 0) (yyval.intval) = MS_TRUE; @@ -1696,12 +1792,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = MS_FALSE; } -#line 1700 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1796 "src/mapparser.c" break; case 14: -#line 160 "mapparser.y" /* yacc.c:1646 */ - { +#line 160 "src/mapparser.y" + { if((yyvsp[-2].dblval) != 0) (yyval.intval) = MS_TRUE; else if((yyvsp[0].intval) == MS_TRUE) @@ -1709,12 +1805,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.intval) = MS_FALSE; } -#line 1713 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1809 "src/mapparser.c" break; case 15: -#line 168 "mapparser.y" /* yacc.c:1646 */ - { +#line 168 "src/mapparser.y" + { if((yyvsp[-2].dblval) != 0) { if((yyvsp[0].intval) == MS_TRUE) (yyval.intval) = MS_TRUE; @@ -1723,12 +1819,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = MS_FALSE; } -#line 1727 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1823 "src/mapparser.c" break; case 16: -#line 177 "mapparser.y" /* yacc.c:1646 */ - { +#line 177 "src/mapparser.y" + { if((yyvsp[-2].dblval) != 0) (yyval.intval) = MS_TRUE; else if((yyvsp[0].dblval) != 0) @@ -1736,12 +1832,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.intval) = MS_FALSE; } -#line 1740 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1836 "src/mapparser.c" break; case 17: -#line 185 "mapparser.y" /* yacc.c:1646 */ - { +#line 185 "src/mapparser.y" + { if((yyvsp[-2].dblval) != 0) { if((yyvsp[0].dblval) != 0) (yyval.intval) = MS_TRUE; @@ -1750,24 +1846,24 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = MS_FALSE; } -#line 1754 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1850 "src/mapparser.c" break; case 18: -#line 194 "mapparser.y" /* yacc.c:1646 */ - { (yyval.intval) = !(yyvsp[0].intval); } -#line 1760 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 194 "src/mapparser.y" + { (yyval.intval) = !(yyvsp[0].intval); } +#line 1856 "src/mapparser.c" break; case 19: -#line 195 "mapparser.y" /* yacc.c:1646 */ - { (yyval.intval) = !(yyvsp[0].dblval); } -#line 1766 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 195 "src/mapparser.y" + { (yyval.intval) = !(yyvsp[0].dblval); } +#line 1862 "src/mapparser.c" break; case 20: -#line 196 "mapparser.y" /* yacc.c:1646 */ - { +#line 196 "src/mapparser.y" + { ms_regex_t re; if(MS_STRING_IS_NULL_OR_EMPTY((yyvsp[-2].strval)) == MS_TRUE) { @@ -1787,12 +1883,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); free((yyvsp[-2].strval)); free((yyvsp[0].strval)); } -#line 1791 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1887 "src/mapparser.c" break; case 21: -#line 216 "mapparser.y" /* yacc.c:1646 */ - { +#line 216 "src/mapparser.y" + { ms_regex_t re; if(MS_STRING_IS_NULL_OR_EMPTY((yyvsp[-2].strval)) == MS_TRUE) { @@ -1812,78 +1908,78 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); free((yyvsp[-2].strval)); free((yyvsp[0].strval)); } -#line 1816 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1912 "src/mapparser.c" break; case 22: -#line 236 "mapparser.y" /* yacc.c:1646 */ - { +#line 236 "src/mapparser.y" + { if((yyvsp[-2].dblval) == (yyvsp[0].dblval)) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 1827 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1923 "src/mapparser.c" break; case 23: -#line 242 "mapparser.y" /* yacc.c:1646 */ - { +#line 242 "src/mapparser.y" + { if((yyvsp[-2].dblval) != (yyvsp[0].dblval)) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 1838 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1934 "src/mapparser.c" break; case 24: -#line 248 "mapparser.y" /* yacc.c:1646 */ - { +#line 248 "src/mapparser.y" + { if((yyvsp[-2].dblval) > (yyvsp[0].dblval)) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 1849 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1945 "src/mapparser.c" break; case 25: -#line 254 "mapparser.y" /* yacc.c:1646 */ - { +#line 254 "src/mapparser.y" + { if((yyvsp[-2].dblval) < (yyvsp[0].dblval)) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 1860 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1956 "src/mapparser.c" break; case 26: -#line 260 "mapparser.y" /* yacc.c:1646 */ - { +#line 260 "src/mapparser.y" + { if((yyvsp[-2].dblval) >= (yyvsp[0].dblval)) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 1871 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1967 "src/mapparser.c" break; case 27: -#line 266 "mapparser.y" /* yacc.c:1646 */ - { +#line 266 "src/mapparser.y" + { if((yyvsp[-2].dblval) <= (yyvsp[0].dblval)) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 1882 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1978 "src/mapparser.c" break; case 28: -#line 272 "mapparser.y" /* yacc.c:1646 */ - { +#line 272 "src/mapparser.y" + { if(strcmp((yyvsp[-2].strval), (yyvsp[0].strval)) == 0) (yyval.intval) = MS_TRUE; else @@ -1891,12 +1987,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); free((yyvsp[-2].strval)); free((yyvsp[0].strval)); } -#line 1895 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 1991 "src/mapparser.c" break; case 29: -#line 280 "mapparser.y" /* yacc.c:1646 */ - { +#line 280 "src/mapparser.y" + { if(strcmp((yyvsp[-2].strval), (yyvsp[0].strval)) != 0) (yyval.intval) = MS_TRUE; else @@ -1904,12 +2000,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); free((yyvsp[-2].strval)); free((yyvsp[0].strval)); } -#line 1908 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2004 "src/mapparser.c" break; case 30: -#line 288 "mapparser.y" /* yacc.c:1646 */ - { +#line 288 "src/mapparser.y" + { if(strcmp((yyvsp[-2].strval), (yyvsp[0].strval)) > 0) (yyval.intval) = MS_TRUE; else @@ -1917,12 +2013,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); free((yyvsp[-2].strval)); free((yyvsp[0].strval)); } -#line 1921 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2017 "src/mapparser.c" break; case 31: -#line 296 "mapparser.y" /* yacc.c:1646 */ - { +#line 296 "src/mapparser.y" + { if(strcmp((yyvsp[-2].strval), (yyvsp[0].strval)) < 0) (yyval.intval) = MS_TRUE; else @@ -1930,12 +2026,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); free((yyvsp[-2].strval)); free((yyvsp[0].strval)); } -#line 1934 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2030 "src/mapparser.c" break; case 32: -#line 304 "mapparser.y" /* yacc.c:1646 */ - { +#line 304 "src/mapparser.y" + { if(strcmp((yyvsp[-2].strval), (yyvsp[0].strval)) >= 0) (yyval.intval) = MS_TRUE; else @@ -1943,12 +2039,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); free((yyvsp[-2].strval)); free((yyvsp[0].strval)); } -#line 1947 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2043 "src/mapparser.c" break; case 33: -#line 312 "mapparser.y" /* yacc.c:1646 */ - { +#line 312 "src/mapparser.y" + { if(strcmp((yyvsp[-2].strval), (yyvsp[0].strval)) <= 0) (yyval.intval) = MS_TRUE; else @@ -1956,78 +2052,78 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); free((yyvsp[-2].strval)); free((yyvsp[0].strval)); } -#line 1960 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2056 "src/mapparser.c" break; case 34: -#line 320 "mapparser.y" /* yacc.c:1646 */ - { +#line 320 "src/mapparser.y" + { if(msTimeCompare(&((yyvsp[-2].tmval)), &((yyvsp[0].tmval))) == 0) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 1971 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2067 "src/mapparser.c" break; case 35: -#line 326 "mapparser.y" /* yacc.c:1646 */ - { +#line 326 "src/mapparser.y" + { if(msTimeCompare(&((yyvsp[-2].tmval)), &((yyvsp[0].tmval))) != 0) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 1982 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2078 "src/mapparser.c" break; case 36: -#line 332 "mapparser.y" /* yacc.c:1646 */ - { +#line 332 "src/mapparser.y" + { if(msTimeCompare(&((yyvsp[-2].tmval)), &((yyvsp[0].tmval))) > 0) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 1993 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2089 "src/mapparser.c" break; case 37: -#line 338 "mapparser.y" /* yacc.c:1646 */ - { +#line 338 "src/mapparser.y" + { if(msTimeCompare(&((yyvsp[-2].tmval)), &((yyvsp[0].tmval))) < 0) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 2004 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2100 "src/mapparser.c" break; case 38: -#line 344 "mapparser.y" /* yacc.c:1646 */ - { +#line 344 "src/mapparser.y" + { if(msTimeCompare(&((yyvsp[-2].tmval)), &((yyvsp[0].tmval))) >= 0) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 2015 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2111 "src/mapparser.c" break; case 39: -#line 350 "mapparser.y" /* yacc.c:1646 */ - { +#line 350 "src/mapparser.y" + { if(msTimeCompare(&((yyvsp[-2].tmval)), &((yyvsp[0].tmval))) <= 0) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 2026 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2122 "src/mapparser.c" break; case 40: -#line 356 "mapparser.y" /* yacc.c:1646 */ - { +#line 356 "src/mapparser.y" + { char *delim, *bufferp; (yyval.intval) = MS_FALSE; @@ -2048,12 +2144,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); free((yyvsp[-2].strval)); free((yyvsp[0].strval)); } -#line 2052 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2148 "src/mapparser.c" break; case 41: -#line 377 "mapparser.y" /* yacc.c:1646 */ - { +#line 377 "src/mapparser.y" + { char *delim,*bufferp; (yyval.intval) = MS_FALSE; @@ -2073,23 +2169,23 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.intval) = MS_TRUE; free((yyvsp[0].strval)); } -#line 2077 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2173 "src/mapparser.c" break; case 42: -#line 397 "mapparser.y" /* yacc.c:1646 */ - { +#line 397 "src/mapparser.y" + { if((yyvsp[-2].dblval) == (yyvsp[0].dblval)) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 2088 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2184 "src/mapparser.c" break; case 43: -#line 403 "mapparser.y" /* yacc.c:1646 */ - { +#line 403 "src/mapparser.y" + { if(strcasecmp((yyvsp[-2].strval), (yyvsp[0].strval)) == 0) (yyval.intval) = MS_TRUE; else @@ -2097,23 +2193,23 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); free((yyvsp[-2].strval)); free((yyvsp[0].strval)); } -#line 2101 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2197 "src/mapparser.c" break; case 44: -#line 411 "mapparser.y" /* yacc.c:1646 */ - { +#line 411 "src/mapparser.y" + { if(msTimeCompare(&((yyvsp[-2].tmval)), &((yyvsp[0].tmval))) == 0) (yyval.intval) = MS_TRUE; else (yyval.intval) = MS_FALSE; } -#line 2112 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2208 "src/mapparser.c" break; case 45: -#line 417 "mapparser.y" /* yacc.c:1646 */ - { +#line 417 "src/mapparser.y" + { int rval; rval = msGEOSEquals((yyvsp[-2].shpval), (yyvsp[0].shpval)); if((yyvsp[-2].shpval) && (yyvsp[-2].shpval)->scratch == MS_TRUE) { @@ -2130,12 +2226,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2134 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2230 "src/mapparser.c" break; case 46: -#line 434 "mapparser.y" /* yacc.c:1646 */ - { +#line 434 "src/mapparser.y" + { int rval; rval = msGEOSEquals((yyvsp[-3].shpval), (yyvsp[-1].shpval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2152,12 +2248,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2156 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2252 "src/mapparser.c" break; case 47: -#line 451 "mapparser.y" /* yacc.c:1646 */ - { +#line 451 "src/mapparser.y" + { int rval; rval = msGEOSIntersects((yyvsp[-3].shpval), (yyvsp[-1].shpval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2174,12 +2270,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2178 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2274 "src/mapparser.c" break; case 48: -#line 468 "mapparser.y" /* yacc.c:1646 */ - { +#line 468 "src/mapparser.y" + { int rval; rval = msGEOSIntersects((yyvsp[-2].shpval), (yyvsp[0].shpval)); if((yyvsp[-2].shpval) && (yyvsp[-2].shpval)->scratch == MS_TRUE) { @@ -2196,12 +2292,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2200 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2296 "src/mapparser.c" break; case 49: -#line 485 "mapparser.y" /* yacc.c:1646 */ - { +#line 485 "src/mapparser.y" + { int rval; rval = msGEOSDisjoint((yyvsp[-3].shpval), (yyvsp[-1].shpval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2218,12 +2314,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2222 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2318 "src/mapparser.c" break; case 50: -#line 502 "mapparser.y" /* yacc.c:1646 */ - { +#line 502 "src/mapparser.y" + { int rval; rval = msGEOSDisjoint((yyvsp[-2].shpval), (yyvsp[0].shpval)); if((yyvsp[-2].shpval) && (yyvsp[-2].shpval)->scratch == MS_TRUE) { @@ -2240,12 +2336,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2244 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2340 "src/mapparser.c" break; case 51: -#line 519 "mapparser.y" /* yacc.c:1646 */ - { +#line 519 "src/mapparser.y" + { int rval; rval = msGEOSTouches((yyvsp[-3].shpval), (yyvsp[-1].shpval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2262,12 +2358,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2266 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2362 "src/mapparser.c" break; case 52: -#line 536 "mapparser.y" /* yacc.c:1646 */ - { +#line 536 "src/mapparser.y" + { int rval; rval = msGEOSTouches((yyvsp[-2].shpval), (yyvsp[0].shpval)); if((yyvsp[-2].shpval) && (yyvsp[-2].shpval)->scratch == MS_TRUE) { @@ -2284,12 +2380,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2288 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2384 "src/mapparser.c" break; case 53: -#line 553 "mapparser.y" /* yacc.c:1646 */ - { +#line 553 "src/mapparser.y" + { int rval; rval = msGEOSOverlaps((yyvsp[-3].shpval), (yyvsp[-1].shpval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2306,12 +2402,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2310 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2406 "src/mapparser.c" break; case 54: -#line 570 "mapparser.y" /* yacc.c:1646 */ - { +#line 570 "src/mapparser.y" + { int rval; rval = msGEOSOverlaps((yyvsp[-2].shpval), (yyvsp[0].shpval)); if((yyvsp[-2].shpval) && (yyvsp[-2].shpval)->scratch == MS_TRUE) { @@ -2328,12 +2424,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2332 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2428 "src/mapparser.c" break; case 55: -#line 587 "mapparser.y" /* yacc.c:1646 */ - { +#line 587 "src/mapparser.y" + { int rval; rval = msGEOSCrosses((yyvsp[-3].shpval), (yyvsp[-1].shpval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2350,12 +2446,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2354 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2450 "src/mapparser.c" break; case 56: -#line 604 "mapparser.y" /* yacc.c:1646 */ - { +#line 604 "src/mapparser.y" + { int rval; rval = msGEOSCrosses((yyvsp[-2].shpval), (yyvsp[0].shpval)); if((yyvsp[-2].shpval) && (yyvsp[-2].shpval)->scratch == MS_TRUE) { @@ -2372,12 +2468,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2376 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2472 "src/mapparser.c" break; case 57: -#line 621 "mapparser.y" /* yacc.c:1646 */ - { +#line 621 "src/mapparser.y" + { int rval; rval = msGEOSWithin((yyvsp[-3].shpval), (yyvsp[-1].shpval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2394,12 +2490,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2398 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2494 "src/mapparser.c" break; case 58: -#line 638 "mapparser.y" /* yacc.c:1646 */ - { +#line 638 "src/mapparser.y" + { int rval; rval = msGEOSWithin((yyvsp[-2].shpval), (yyvsp[0].shpval)); if((yyvsp[-2].shpval) && (yyvsp[-2].shpval)->scratch == MS_TRUE) { @@ -2416,12 +2512,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2420 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2516 "src/mapparser.c" break; case 59: -#line 655 "mapparser.y" /* yacc.c:1646 */ - { +#line 655 "src/mapparser.y" + { int rval; rval = msGEOSContains((yyvsp[-3].shpval), (yyvsp[-1].shpval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2438,12 +2534,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2442 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2538 "src/mapparser.c" break; case 60: -#line 672 "mapparser.y" /* yacc.c:1646 */ - { +#line 672 "src/mapparser.y" + { int rval; rval = msGEOSContains((yyvsp[-2].shpval), (yyvsp[0].shpval)); if((yyvsp[-2].shpval) && (yyvsp[-2].shpval)->scratch == MS_TRUE) { @@ -2460,12 +2556,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.intval) = rval; } -#line 2464 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2560 "src/mapparser.c" break; case 61: -#line 689 "mapparser.y" /* yacc.c:1646 */ - { +#line 689 "src/mapparser.y" + { double d; d = msGEOSDistance((yyvsp[-5].shpval), (yyvsp[-3].shpval)); if((yyvsp[-5].shpval) && (yyvsp[-5].shpval)->scratch == MS_TRUE) { @@ -2481,12 +2577,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.intval) = MS_FALSE; } -#line 2485 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2581 "src/mapparser.c" break; case 62: -#line 705 "mapparser.y" /* yacc.c:1646 */ - { +#line 705 "src/mapparser.y" + { double d; d = msGEOSDistance((yyvsp[-5].shpval), (yyvsp[-3].shpval)); if((yyvsp[-5].shpval) && (yyvsp[-5].shpval)->scratch == MS_TRUE) { @@ -2502,72 +2598,72 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.intval) = MS_FALSE; } -#line 2506 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2602 "src/mapparser.c" break; case 64: -#line 724 "mapparser.y" /* yacc.c:1646 */ - { (yyval.dblval) = (yyvsp[-1].dblval); } -#line 2512 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 724 "src/mapparser.y" + { (yyval.dblval) = (yyvsp[-1].dblval); } +#line 2608 "src/mapparser.c" break; case 65: -#line 725 "mapparser.y" /* yacc.c:1646 */ - { (yyval.dblval) = (yyvsp[-2].dblval) + (yyvsp[0].dblval); } -#line 2518 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 725 "src/mapparser.y" + { (yyval.dblval) = (yyvsp[-2].dblval) + (yyvsp[0].dblval); } +#line 2614 "src/mapparser.c" break; case 66: -#line 726 "mapparser.y" /* yacc.c:1646 */ - { (yyval.dblval) = (yyvsp[-2].dblval) - (yyvsp[0].dblval); } -#line 2524 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 726 "src/mapparser.y" + { (yyval.dblval) = (yyvsp[-2].dblval) - (yyvsp[0].dblval); } +#line 2620 "src/mapparser.c" break; case 67: -#line 727 "mapparser.y" /* yacc.c:1646 */ - { (yyval.dblval) = (yyvsp[-2].dblval) * (yyvsp[0].dblval); } -#line 2530 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 727 "src/mapparser.y" + { (yyval.dblval) = (yyvsp[-2].dblval) * (yyvsp[0].dblval); } +#line 2626 "src/mapparser.c" break; case 68: -#line 728 "mapparser.y" /* yacc.c:1646 */ - { (yyval.dblval) = (int)(yyvsp[-2].dblval) % (int)(yyvsp[0].dblval); } -#line 2536 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 728 "src/mapparser.y" + { (yyval.dblval) = (int)(yyvsp[-2].dblval) % (int)(yyvsp[0].dblval); } +#line 2632 "src/mapparser.c" break; case 69: -#line 729 "mapparser.y" /* yacc.c:1646 */ - { +#line 729 "src/mapparser.y" + { if((yyvsp[0].dblval) == 0.0) { yyerror(p, "Division by zero."); return(-1); } else (yyval.dblval) = (yyvsp[-2].dblval) / (yyvsp[0].dblval); } -#line 2548 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2644 "src/mapparser.c" break; case 70: -#line 736 "mapparser.y" /* yacc.c:1646 */ - { (yyval.dblval) = (yyvsp[0].dblval); } -#line 2554 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 736 "src/mapparser.y" + { (yyval.dblval) = (yyvsp[0].dblval); } +#line 2650 "src/mapparser.c" break; case 71: -#line 737 "mapparser.y" /* yacc.c:1646 */ - { (yyval.dblval) = pow((yyvsp[-2].dblval), (yyvsp[0].dblval)); } -#line 2560 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 737 "src/mapparser.y" + { (yyval.dblval) = pow((yyvsp[-2].dblval), (yyvsp[0].dblval)); } +#line 2656 "src/mapparser.c" break; case 72: -#line 738 "mapparser.y" /* yacc.c:1646 */ - { (yyval.dblval) = strlen((yyvsp[-1].strval)); } -#line 2566 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 738 "src/mapparser.y" + { (yyval.dblval) = strlen((yyvsp[-1].strval)); } +#line 2662 "src/mapparser.c" break; case 73: -#line 739 "mapparser.y" /* yacc.c:1646 */ - { +#line 739 "src/mapparser.y" + { if((yyvsp[-1].shpval)->type != MS_SHAPE_POLYGON) { yyerror(p, "Area can only be computed for polygon shapes."); return(-1); @@ -2578,30 +2674,30 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); free((yyvsp[-1].shpval)); } } -#line 2582 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2678 "src/mapparser.c" break; case 74: -#line 750 "mapparser.y" /* yacc.c:1646 */ - { (yyval.dblval) = (MS_NINT((yyvsp[-3].dblval)/(yyvsp[-1].dblval)))*(yyvsp[-1].dblval); } -#line 2588 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 750 "src/mapparser.y" + { (yyval.dblval) = (MS_NINT((yyvsp[-3].dblval)/(yyvsp[-1].dblval)))*(yyvsp[-1].dblval); } +#line 2684 "src/mapparser.c" break; case 75: -#line 751 "mapparser.y" /* yacc.c:1646 */ - { (yyval.dblval) = (MS_NINT((yyvsp[-1].dblval))); } -#line 2594 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 751 "src/mapparser.y" + { (yyval.dblval) = (MS_NINT((yyvsp[-1].dblval))); } +#line 2690 "src/mapparser.c" break; case 77: -#line 755 "mapparser.y" /* yacc.c:1646 */ - { (yyval.shpval) = (yyvsp[-1].shpval); } -#line 2600 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 755 "src/mapparser.y" + { (yyval.shpval) = (yyvsp[-1].shpval); } +#line 2696 "src/mapparser.c" break; case 78: -#line 756 "mapparser.y" /* yacc.c:1646 */ - { +#line 756 "src/mapparser.y" + { shapeObj *s; s = msGEOSBuffer((yyvsp[-3].shpval), (yyvsp[-1].dblval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2615,12 +2711,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2619 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2715 "src/mapparser.c" break; case 79: -#line 770 "mapparser.y" /* yacc.c:1646 */ - { +#line 770 "src/mapparser.y" + { shapeObj *s; s = msRings2Shape((yyvsp[-1].shpval), MS_FALSE); if((yyvsp[-1].shpval) && (yyvsp[-1].shpval)->scratch == MS_TRUE) { @@ -2634,12 +2730,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2638 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2734 "src/mapparser.c" break; case 80: -#line 784 "mapparser.y" /* yacc.c:1646 */ - { +#line 784 "src/mapparser.y" + { shapeObj *s; s = msRings2Shape((yyvsp[-1].shpval), MS_TRUE); if((yyvsp[-1].shpval) && (yyvsp[-1].shpval)->scratch == MS_TRUE) { @@ -2653,12 +2749,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2657 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2753 "src/mapparser.c" break; case 81: -#line 798 "mapparser.y" /* yacc.c:1646 */ - { +#line 798 "src/mapparser.y" + { shapeObj *s; s = msGEOSCenterline((yyvsp[-1].shpval)); if((yyvsp[-1].shpval) && (yyvsp[-1].shpval)->scratch == MS_TRUE) { @@ -2672,12 +2768,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2676 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2772 "src/mapparser.c" break; case 82: -#line 812 "mapparser.y" /* yacc.c:1646 */ - { +#line 812 "src/mapparser.y" + { shapeObj *s; s = msGEOSDifference((yyvsp[-3].shpval), (yyvsp[-1].shpval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2691,12 +2787,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2695 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2791 "src/mapparser.c" break; case 83: -#line 826 "mapparser.y" /* yacc.c:1646 */ - { +#line 826 "src/mapparser.y" + { shapeObj *s; s = msDensify((yyvsp[-3].shpval), (yyvsp[-1].dblval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2710,12 +2806,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2714 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2810 "src/mapparser.c" break; case 84: -#line 840 "mapparser.y" /* yacc.c:1646 */ - { +#line 840 "src/mapparser.y" + { shapeObj *s; s = msGEOSSimplify((yyvsp[-3].shpval), (yyvsp[-1].dblval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2729,12 +2825,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2733 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2829 "src/mapparser.c" break; case 85: -#line 854 "mapparser.y" /* yacc.c:1646 */ - { +#line 854 "src/mapparser.y" + { shapeObj *s; s = msGEOSTopologyPreservingSimplify((yyvsp[-3].shpval), (yyvsp[-1].dblval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2748,12 +2844,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2752 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2848 "src/mapparser.c" break; case 86: -#line 868 "mapparser.y" /* yacc.c:1646 */ - { +#line 868 "src/mapparser.y" + { shapeObj *s; s = msGeneralize((yyvsp[-3].shpval), (yyvsp[-1].dblval)); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2767,12 +2863,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2771 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2867 "src/mapparser.c" break; case 87: -#line 882 "mapparser.y" /* yacc.c:1646 */ - { +#line 882 "src/mapparser.y" + { shapeObj *s; s = msSmoothShapeSIA((yyvsp[-1].shpval), 3, 1, NULL); if((yyvsp[-1].shpval) && (yyvsp[-1].shpval)->scratch == MS_TRUE) { @@ -2786,12 +2882,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2790 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2886 "src/mapparser.c" break; case 88: -#line 896 "mapparser.y" /* yacc.c:1646 */ - { +#line 896 "src/mapparser.y" + { shapeObj *s; s = msSmoothShapeSIA((yyvsp[-3].shpval), (yyvsp[-1].dblval), 1, NULL); if((yyvsp[-3].shpval) && (yyvsp[-3].shpval)->scratch == MS_TRUE) { @@ -2805,12 +2901,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2809 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2905 "src/mapparser.c" break; case 89: -#line 910 "mapparser.y" /* yacc.c:1646 */ - { +#line 910 "src/mapparser.y" + { shapeObj *s; s = msSmoothShapeSIA((yyvsp[-5].shpval), (yyvsp[-3].dblval), (yyvsp[-1].dblval), NULL); if((yyvsp[-5].shpval) && (yyvsp[-5].shpval)->scratch == MS_TRUE) { @@ -2824,12 +2920,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2828 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2924 "src/mapparser.c" break; case 90: -#line 924 "mapparser.y" /* yacc.c:1646 */ - { +#line 924 "src/mapparser.y" + { shapeObj *s; s = msSmoothShapeSIA((yyvsp[-7].shpval), (yyvsp[-5].dblval), (yyvsp[-3].dblval), (yyvsp[-1].strval)); if((yyvsp[-7].shpval) && (yyvsp[-7].shpval)->scratch == MS_TRUE) { @@ -2844,12 +2940,12 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); s->scratch = MS_TRUE; (yyval.shpval) = s; } -#line 2848 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2944 "src/mapparser.c" break; case 91: -#line 939 "mapparser.y" /* yacc.c:1646 */ - { +#line 939 "src/mapparser.y" + { #ifdef USE_V8_MAPSCRIPT shapeObj *s; s = msV8TransformShape((yyvsp[-3].shpval), (yyvsp[-1].strval)); @@ -2869,87 +2965,88 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); return(-1); #endif } -#line 2873 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2969 "src/mapparser.c" break; case 93: -#line 962 "mapparser.y" /* yacc.c:1646 */ - { (yyval.strval) = (yyvsp[-1].strval); } -#line 2879 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 962 "src/mapparser.y" + { (yyval.strval) = (yyvsp[-1].strval); } +#line 2975 "src/mapparser.c" break; case 94: -#line 963 "mapparser.y" /* yacc.c:1646 */ - { +#line 963 "src/mapparser.y" + { (yyval.strval) = (char *)malloc(strlen((yyvsp[-2].strval)) + strlen((yyvsp[0].strval)) + 1); sprintf((yyval.strval), "%s%s", (yyvsp[-2].strval), (yyvsp[0].strval)); free((yyvsp[-2].strval)); free((yyvsp[0].strval)); } -#line 2888 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2984 "src/mapparser.c" break; case 95: -#line 967 "mapparser.y" /* yacc.c:1646 */ - { +#line 967 "src/mapparser.y" + { (yyval.strval) = (char *) malloc(strlen((yyvsp[-1].strval)) + 64); /* Plenty big? Should use snprintf below... */ sprintf((yyval.strval), (yyvsp[-1].strval), (yyvsp[-3].dblval)); free((yyvsp[-1].strval)); } -#line 2898 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 2994 "src/mapparser.c" break; case 96: -#line 972 "mapparser.y" /* yacc.c:1646 */ - { +#line 972 "src/mapparser.y" + { (yyvsp[-1].strval) = msCommifyString((yyvsp[-1].strval)); (yyval.strval) = (yyvsp[-1].strval); } -#line 2907 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 3003 "src/mapparser.c" break; case 97: -#line 976 "mapparser.y" /* yacc.c:1646 */ - { +#line 976 "src/mapparser.y" + { msStringToUpper((yyvsp[-1].strval)); (yyval.strval) = (yyvsp[-1].strval); } -#line 2916 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 3012 "src/mapparser.c" break; case 98: -#line 980 "mapparser.y" /* yacc.c:1646 */ - { +#line 980 "src/mapparser.y" + { msStringToLower((yyvsp[-1].strval)); (yyval.strval) = (yyvsp[-1].strval); } -#line 2925 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 3021 "src/mapparser.c" break; case 99: -#line 984 "mapparser.y" /* yacc.c:1646 */ - { +#line 984 "src/mapparser.y" + { msStringInitCap((yyvsp[-1].strval)); (yyval.strval) = (yyvsp[-1].strval); } -#line 2934 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 3030 "src/mapparser.c" break; case 100: -#line 988 "mapparser.y" /* yacc.c:1646 */ - { +#line 988 "src/mapparser.y" + { msStringFirstCap((yyvsp[-1].strval)); (yyval.strval) = (yyvsp[-1].strval); } -#line 2943 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 3039 "src/mapparser.c" break; case 102: -#line 995 "mapparser.y" /* yacc.c:1646 */ - { (yyval.tmval) = (yyvsp[-1].tmval); } -#line 2949 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 995 "src/mapparser.y" + { (yyval.tmval) = (yyvsp[-1].tmval); } +#line 3045 "src/mapparser.c" break; -#line 2953 "/vagrant/mapparser.c" /* yacc.c:1646 */ +#line 3049 "src/mapparser.c" + default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -2974,14 +3071,13 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); /* Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTOKENS]; + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } goto yynewstate; @@ -3013,7 +3109,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); { if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); - yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); if (!yymsg) { yymsg = yymsgbuf; @@ -3064,12 +3160,10 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ yyerrorlab: - - /* Pacify compilers like GCC when the user code never invokes - YYERROR and the label yyerrorlab therefore never appears in user - code. */ - if (/*CONSTCOND*/ 0) - goto yyerrorlab; + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; /* Do not reclaim the symbols of the rule whose action triggered this YYERROR. */ @@ -3131,6 +3225,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); yyresult = 0; goto yyreturn; + /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ @@ -3138,6 +3233,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); yyresult = 1; goto yyreturn; + #if !defined yyoverflow || YYERROR_VERBOSE /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | @@ -3148,6 +3244,10 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); /* Fall through. */ #endif + +/*-----------------------------------------------------. +| yyreturn -- parsing is finished, return the result. | +`-----------------------------------------------------*/ yyreturn: if (yychar != YYEMPTY) { @@ -3164,7 +3264,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); while (yyssp != yyss) { yydestruct ("Cleanup: popping", - yystos[*yyssp], yyvsp, p); + yystos[+*yyssp], yyvsp, p); YYPOPSTACK (1); } #ifndef yyoverflow @@ -3177,7 +3277,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); #endif return yyresult; } -#line 998 "mapparser.y" /* yacc.c:1906 */ +#line 998 "src/mapparser.y" /* diff --git a/src/mapparser.h b/src/mapparser.h index 15c3cf8ee0..1255fe3474 100644 --- a/src/mapparser.h +++ b/src/mapparser.h @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.5.1. */ /* Bison interface for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -30,8 +31,11 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ -#ifndef YY_YY_VAGRANT_MAPPARSER_H_INCLUDED -# define YY_YY_VAGRANT_MAPPARSER_H_INCLUDED +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + +#ifndef YY_YY_SRC_MAPPARSER_H_INCLUDED +# define YY_YY_SRC_MAPPARSER_H_INCLUDED /* Debug traces. */ #ifndef YYDEBUG # define YYDEBUG 0 @@ -149,10 +153,9 @@ extern int yydebug; /* Value type. */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED - union YYSTYPE { -#line 30 "mapparser.y" /* yacc.c:1909 */ +#line 30 "src/mapparser.y" double dblval; int intval; @@ -160,9 +163,9 @@ union YYSTYPE struct tm tmval; shapeObj *shpval; -#line 164 "/vagrant/mapparser.h" /* yacc.c:1909 */ -}; +#line 167 "src/mapparser.h" +}; typedef union YYSTYPE YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 @@ -172,4 +175,4 @@ typedef union YYSTYPE YYSTYPE; int yyparse (parseObj *p); -#endif /* !YY_YY_VAGRANT_MAPPARSER_H_INCLUDED */ +#endif /* !YY_YY_SRC_MAPPARSER_H_INCLUDED */ diff --git a/src/mapservutil.c b/src/mapservutil.c index 24d8095c40..2bb3f851d9 100644 --- a/src/mapservutil.c +++ b/src/mapservutil.c @@ -89,9 +89,12 @@ void msCGIWriteError(mapservObj *mapserv) { return; } - if ((ms_error->code == MS_NOTFOUND) && (mapserv->map->web.empty)) { - /* msRedirect(mapserv->map->web.empty); */ - if (msReturnURL(mapserv, mapserv->map->web.empty, BROWSE) != MS_SUCCESS) { + if ((ms_error->code == MS_NOTFOUND) && + (mapserv->map->web.empty != NULL || CPLGetConfigOption("MS_EMPTY", NULL) != NULL)) { + const char *url = mapserv->map->web.empty; + if(url == NULL) + url = CPLGetConfigOption("MS_EMPTY", NULL); + if (msReturnURL(mapserv, url, BROWSE) != MS_SUCCESS) { msIO_setHeader("Content-Type", "text/html"); msIO_sendHeaders(); msIO_printf("\n"); @@ -1990,11 +1993,12 @@ int msCGIDispatchQueryRequest(mapservObj *mapserv) { break; } /* end mode switch */ + /* finally execute the query */ if(msExecuteQuery(mapserv->map) != MS_SUCCESS) return MS_FAILURE; /* catch empty result set when web->empty is set (#6907) */ - if(mapserv->map->web.empty) { // TODO: consider config MS_EMPTY global setting + if(mapserv->map->web.empty != NULL || CPLGetConfigOption("MS_EMPTY", NULL) != NULL) { int n=0; for(int i=0; imap->numlayers; i++) { // count results for each layer if (mapserv->map->layers[i]->resultcache) { @@ -2002,7 +2006,8 @@ int msCGIDispatchQueryRequest(mapservObj *mapserv) { } } if(n == 0) { - msSetError(MS_NOTFOUND, "No matching record(s) found.", "msCGIDispatchQueryRequest()"); // this message will never be displayed + /* note: this error message will not be displayed */ + msSetError(MS_NOTFOUND, "No matching record(s) found.", "msCGIDispatchQueryRequest()"); return(MS_FAILURE); } }