From 7d975fc200bbbea991ec4c04c08f3a5ea7b847af Mon Sep 17 00:00:00 2001 From: Ethan Nicholas Date: Thu, 23 Feb 2017 16:18:54 +0000 Subject: Revert "skslc switch support" This reverts commit 2b1e468dabd2ac7bea7ec17740275f4f4aad30c3. Reason for revert: bot breakage Original change's description: > skslc switch support > > BUG=skia: > > Change-Id: Ida7f9e80139aa1e4f43804cafbcac640e47fab25 > Reviewed-on: https://skia-review.googlesource.com/8771 > Commit-Queue: Ethan Nicholas > Reviewed-by: Ben Wagner > TBR=benjaminwagner@google.com,ethannicholas@google.com,reviews@skia.org NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=skia: Change-Id: Iaaa35d10a15704279c6883d4d68f6d4ad5078320 Reviewed-on: https://skia-review.googlesource.com/8792 Reviewed-by: Ethan Nicholas Commit-Queue: Ethan Nicholas --- src/sksl/lex.sksl.c | 634 ++++++++++++++++++++++++++-------------------------- 1 file changed, 318 insertions(+), 316 deletions(-) (limited to 'src/sksl/lex.sksl.c') diff --git a/src/sksl/lex.sksl.c b/src/sksl/lex.sksl.c index 2c5eb73402..4cff376fa5 100644 --- a/src/sksl/lex.sksl.c +++ b/src/sksl/lex.sksl.c @@ -1,5 +1,5 @@ /* - * Copyright 2017 Google Inc. + * Copyright 2016 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. @@ -13,8 +13,8 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 39 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 0 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -248,7 +248,7 @@ struct yy_buffer_state /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - yy_size_t yy_n_chars; + int yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -368,6 +368,9 @@ typedef int yy_state_type; static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner); static int yy_get_next_buffer (yyscan_t yyscanner ); +#if defined(__GNUC__) && __GNUC__ >= 3 +__attribute__((__noreturn__)) +#endif static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); /* Done after the current pattern has been matched and before the @@ -380,8 +383,8 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; -#define YY_NUM_RULES 92 -#define YY_END_OF_BUFFER 93 +#define YY_NUM_RULES 89 +#define YY_END_OF_BUFFER 90 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -389,39 +392,37 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_accept[253] = +static yyconst flex_int16_t yy_accept[239] = { 0, - 0, 0, 93, 91, 90, 90, 64, 91, 38, 54, - 59, 40, 41, 52, 50, 47, 51, 46, 53, 4, - 4, 66, 87, 71, 67, 70, 65, 44, 45, 58, - 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, - 38, 38, 38, 38, 38, 38, 38, 38, 42, 57, - 43, 60, 90, 69, 39, 38, 78, 63, 83, 76, - 48, 74, 49, 75, 1, 0, 88, 77, 2, 4, - 0, 0, 55, 73, 68, 72, 56, 82, 62, 38, - 38, 38, 38, 38, 12, 38, 38, 38, 38, 38, - 8, 20, 38, 38, 38, 38, 38, 38, 38, 38, - - 38, 38, 38, 38, 38, 38, 81, 61, 39, 86, - 0, 0, 0, 88, 1, 0, 0, 3, 5, 79, - 80, 85, 38, 38, 38, 38, 38, 38, 38, 38, - 38, 10, 38, 38, 38, 38, 38, 38, 21, 38, - 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, - 84, 0, 1, 89, 0, 0, 2, 38, 14, 38, - 38, 38, 38, 38, 9, 38, 28, 38, 38, 38, - 25, 38, 38, 38, 38, 38, 38, 38, 38, 6, - 38, 38, 38, 38, 0, 1, 16, 38, 24, 38, - 38, 38, 7, 27, 22, 38, 38, 38, 38, 38, - - 38, 38, 38, 38, 38, 38, 11, 38, 38, 38, - 38, 38, 36, 38, 38, 38, 38, 38, 19, 35, - 13, 38, 38, 38, 38, 38, 15, 18, 26, 38, - 38, 38, 38, 23, 38, 38, 32, 17, 38, 38, - 30, 34, 33, 38, 38, 37, 31, 38, 38, 38, - 29, 0 + 0, 0, 90, 88, 87, 87, 61, 88, 35, 51, + 56, 37, 38, 49, 47, 44, 48, 43, 50, 4, + 4, 63, 84, 68, 64, 67, 62, 41, 42, 55, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 39, 54, + 40, 57, 87, 66, 36, 35, 75, 60, 80, 73, + 45, 71, 46, 72, 1, 0, 85, 74, 2, 4, + 0, 0, 52, 70, 65, 69, 53, 79, 59, 35, + 35, 35, 12, 35, 35, 35, 35, 35, 8, 17, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + + 35, 35, 35, 78, 58, 36, 83, 0, 0, 0, + 85, 1, 0, 0, 3, 5, 76, 77, 82, 35, + 35, 35, 35, 35, 35, 35, 10, 35, 35, 35, + 35, 35, 35, 18, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 81, 0, 1, 86, 0, 0, + 2, 35, 35, 35, 35, 35, 9, 35, 25, 35, + 35, 35, 22, 35, 35, 35, 35, 35, 35, 35, + 6, 35, 35, 35, 35, 0, 1, 13, 35, 21, + 35, 35, 7, 24, 19, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 11, 35, 35, 35, 35, + + 33, 35, 35, 35, 35, 35, 16, 32, 35, 35, + 35, 35, 35, 15, 23, 35, 35, 35, 35, 20, + 35, 35, 29, 14, 35, 35, 27, 31, 30, 35, + 35, 34, 28, 35, 35, 35, 26, 0 } ; -static yyconst flex_int32_t yy_ec[256] = +static yyconst YY_CHAR yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, @@ -453,7 +454,7 @@ static yyconst flex_int32_t yy_ec[256] = 1, 1, 1, 1, 1 } ; -static yyconst flex_int32_t yy_meta[57] = +static yyconst YY_CHAR yy_meta[57] = { 0, 1, 1, 2, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 1, 1, @@ -463,71 +464,69 @@ static yyconst flex_int32_t yy_meta[57] = 3, 3, 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[259] = +static yyconst flex_uint16_t yy_base[245] = { 0, - 0, 0, 320, 321, 55, 57, 297, 0, 0, 296, - 53, 321, 321, 295, 50, 321, 49, 47, 57, 52, - 59, 321, 321, 59, 294, 60, 321, 321, 321, 62, - 270, 57, 54, 274, 59, 275, 59, 65, 278, 268, - 262, 264, 274, 57, 262, 264, 262, 53, 321, 74, - 321, 321, 103, 321, 0, 0, 321, 282, 321, 321, - 321, 321, 321, 321, 92, 292, 0, 321, 95, 99, - 118, 0, 280, 321, 321, 321, 279, 321, 278, 265, - 252, 78, 262, 250, 0, 249, 254, 263, 247, 255, - 0, 247, 237, 238, 254, 242, 238, 250, 92, 238, - - 244, 233, 242, 239, 240, 239, 321, 254, 0, 321, - 128, 264, 258, 0, 126, 136, 106, 138, 0, 321, - 321, 321, 243, 238, 237, 111, 240, 237, 234, 221, - 219, 0, 228, 216, 220, 218, 223, 226, 0, 227, - 225, 210, 208, 207, 207, 219, 217, 221, 210, 202, - 321, 144, 146, 321, 153, 151, 155, 209, 0, 202, - 199, 207, 196, 213, 0, 208, 0, 197, 193, 191, - 0, 190, 192, 198, 192, 189, 188, 200, 199, 0, - 187, 182, 194, 193, 157, 159, 0, 192, 0, 183, - 184, 178, 0, 0, 0, 175, 180, 174, 173, 176, - - 179, 174, 168, 177, 168, 174, 0, 168, 168, 161, - 161, 174, 0, 162, 161, 166, 163, 170, 0, 0, - 0, 160, 160, 157, 146, 145, 0, 0, 0, 132, - 116, 99, 102, 0, 113, 101, 0, 0, 105, 92, - 0, 0, 0, 79, 80, 0, 0, 81, 62, 32, - 0, 321, 175, 178, 181, 186, 191, 193 + 0, 0, 306, 307, 55, 57, 283, 0, 0, 282, + 53, 307, 307, 281, 50, 307, 49, 47, 57, 52, + 59, 307, 307, 59, 280, 60, 307, 307, 307, 62, + 256, 257, 49, 259, 58, 260, 54, 64, 263, 253, + 247, 249, 259, 245, 246, 248, 246, 60, 307, 68, + 307, 307, 97, 307, 0, 0, 307, 266, 307, 307, + 307, 307, 307, 307, 91, 276, 0, 307, 93, 97, + 112, 0, 264, 307, 307, 307, 263, 307, 262, 249, + 76, 236, 0, 235, 240, 249, 233, 241, 0, 233, + 223, 224, 240, 228, 224, 236, 74, 224, 220, 229, + + 226, 227, 226, 307, 241, 0, 307, 120, 251, 245, + 0, 118, 128, 130, 132, 0, 307, 307, 307, 230, + 225, 107, 226, 223, 210, 208, 0, 217, 205, 209, + 207, 212, 215, 0, 216, 214, 199, 197, 196, 209, + 207, 211, 200, 192, 307, 138, 140, 307, 147, 145, + 149, 199, 192, 189, 197, 204, 0, 199, 0, 188, + 184, 182, 0, 181, 183, 189, 183, 180, 179, 191, + 0, 179, 174, 186, 185, 151, 153, 0, 184, 0, + 175, 171, 0, 0, 0, 168, 173, 167, 166, 169, + 172, 167, 161, 162, 168, 0, 162, 162, 155, 169, + + 0, 157, 156, 161, 158, 165, 0, 0, 155, 155, + 152, 146, 153, 0, 0, 139, 117, 99, 96, 0, + 107, 99, 0, 0, 101, 86, 0, 0, 0, 64, + 59, 0, 0, 64, 46, 32, 0, 307, 169, 172, + 175, 180, 185, 187 } ; -static yyconst flex_int16_t yy_def[259] = +static yyconst flex_int16_t yy_def[245] = { 0, - 252, 1, 252, 252, 252, 252, 252, 253, 254, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 252, 252, - 252, 252, 252, 252, 255, 254, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 256, 257, 252, 252, 252, - 252, 258, 252, 252, 252, 252, 252, 252, 252, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - - 254, 254, 254, 254, 254, 254, 252, 252, 255, 252, - 252, 256, 256, 257, 252, 252, 252, 252, 258, 252, - 252, 252, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 252, 252, 252, 252, 252, 252, 252, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 252, 252, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 0, 252, 252, 252, 252, 252, 252 + 238, 1, 238, 238, 238, 238, 238, 239, 240, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 238, 238, + 238, 238, 238, 238, 241, 240, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 242, 243, 238, 238, 238, + 238, 244, 238, 238, 238, 238, 238, 238, 238, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + + 240, 240, 240, 238, 238, 241, 238, 238, 242, 242, + 243, 238, 238, 238, 238, 244, 238, 238, 238, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 238, 238, 238, 238, 238, 238, + 238, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 238, 238, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 0, 238, 238, + 238, 238, 238, 238 } ; -static yyconst flex_int16_t yy_nxt[378] = +static yyconst flex_uint16_t yy_nxt[364] = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, @@ -535,44 +534,43 @@ static yyconst flex_int16_t yy_nxt[378] = 31, 32, 33, 34, 35, 9, 36, 37, 9, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 9, 9, 49, 50, 51, 52, 53, 53, 53, 53, - 58, 61, 63, 65, 65, 251, 69, 66, 70, 70, + 58, 61, 63, 65, 65, 237, 69, 66, 70, 70, 64, 62, 67, 69, 59, 70, 70, 71, 68, 73, - 74, 76, 77, 78, 71, 71, 81, 83, 87, 105, - 79, 84, 71, 91, 93, 107, 85, 106, 88, 82, - - 92, 89, 72, 100, 53, 53, 101, 94, 65, 65, - 250, 115, 115, 69, 125, 70, 70, 111, 249, 126, - 116, 141, 118, 118, 71, 111, 248, 108, 116, 117, - 247, 117, 71, 246, 118, 118, 245, 142, 143, 152, - 244, 152, 115, 115, 153, 153, 243, 156, 242, 156, - 241, 155, 157, 157, 118, 118, 161, 162, 240, 155, - 153, 153, 153, 153, 185, 239, 185, 157, 157, 186, - 186, 157, 157, 186, 186, 186, 186, 55, 238, 55, - 56, 56, 56, 109, 109, 109, 112, 112, 112, 112, - 112, 114, 237, 114, 114, 114, 119, 119, 236, 235, - - 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, - 224, 223, 222, 221, 220, 219, 218, 217, 216, 215, - 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, - 204, 203, 202, 201, 200, 199, 198, 197, 196, 195, - 194, 193, 192, 191, 190, 189, 188, 187, 184, 183, - 182, 181, 180, 179, 178, 177, 176, 175, 174, 173, - 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, - 160, 159, 158, 154, 113, 151, 150, 149, 148, 147, - 146, 145, 144, 140, 139, 138, 137, 136, 135, 134, - 133, 132, 131, 130, 129, 128, 127, 124, 123, 122, - - 121, 120, 113, 110, 104, 103, 102, 99, 98, 97, - 96, 95, 90, 86, 80, 75, 60, 57, 54, 252, - 3, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252 + 74, 76, 77, 78, 71, 71, 82, 85, 89, 104, + 79, 83, 71, 91, 236, 90, 102, 86, 53, 53, + + 87, 235, 72, 136, 103, 234, 92, 65, 65, 112, + 112, 69, 121, 70, 70, 233, 108, 122, 113, 137, + 138, 105, 71, 114, 108, 114, 113, 232, 115, 115, + 71, 146, 231, 146, 112, 112, 147, 147, 230, 150, + 229, 150, 228, 149, 151, 151, 115, 115, 115, 115, + 227, 149, 154, 155, 147, 147, 147, 147, 176, 226, + 176, 151, 151, 177, 177, 151, 151, 177, 177, 177, + 177, 55, 225, 55, 56, 56, 56, 106, 106, 106, + 109, 109, 109, 109, 109, 111, 224, 111, 111, 111, + 116, 116, 223, 222, 221, 220, 219, 218, 217, 216, + + 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, + 205, 204, 203, 202, 201, 200, 199, 198, 197, 196, + 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, + 185, 184, 183, 182, 181, 180, 179, 178, 175, 174, + 173, 172, 171, 170, 169, 168, 167, 166, 165, 164, + 163, 162, 161, 160, 159, 158, 157, 156, 153, 152, + 148, 110, 145, 144, 143, 142, 141, 140, 139, 135, + 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, + 124, 123, 120, 119, 118, 117, 110, 107, 101, 100, + 99, 98, 97, 96, 95, 94, 93, 88, 84, 81, + + 80, 75, 60, 57, 54, 238, 3, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238 } ; -static yyconst flex_int16_t yy_chk[378] = +static yyconst flex_int16_t yy_chk[364] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -580,51 +578,50 @@ static yyconst flex_int16_t yy_chk[378] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 6, 6, - 11, 15, 17, 18, 18, 250, 20, 19, 20, 20, + 11, 15, 17, 18, 18, 236, 20, 19, 20, 20, 17, 15, 19, 21, 11, 21, 21, 20, 19, 24, - 24, 26, 26, 30, 21, 20, 32, 33, 35, 48, - 30, 33, 21, 37, 38, 50, 33, 48, 35, 32, - - 37, 35, 20, 44, 53, 53, 44, 38, 65, 65, - 249, 69, 69, 70, 82, 70, 70, 65, 248, 82, - 69, 99, 117, 117, 70, 65, 245, 50, 69, 71, - 244, 71, 70, 240, 71, 71, 239, 99, 99, 111, - 236, 111, 115, 115, 111, 111, 235, 116, 233, 116, - 232, 115, 116, 116, 118, 118, 126, 126, 231, 115, - 152, 152, 153, 153, 155, 230, 155, 156, 156, 155, - 155, 157, 157, 185, 185, 186, 186, 253, 226, 253, - 254, 254, 254, 255, 255, 255, 256, 256, 256, 256, - 256, 257, 225, 257, 257, 257, 258, 258, 224, 223, - - 222, 218, 217, 216, 215, 214, 212, 211, 210, 209, - 208, 206, 205, 204, 203, 202, 201, 200, 199, 198, - 197, 196, 192, 191, 190, 188, 184, 183, 182, 181, - 179, 178, 177, 176, 175, 174, 173, 172, 170, 169, - 168, 166, 164, 163, 162, 161, 160, 158, 150, 149, - 148, 147, 146, 145, 144, 143, 142, 141, 140, 138, - 137, 136, 135, 134, 133, 131, 130, 129, 128, 127, - 125, 124, 123, 113, 112, 108, 106, 105, 104, 103, - 102, 101, 100, 98, 97, 96, 95, 94, 93, 92, - 90, 89, 88, 87, 86, 84, 83, 81, 80, 79, - - 77, 73, 66, 58, 47, 46, 45, 43, 42, 41, - 40, 39, 36, 34, 31, 25, 14, 10, 7, 3, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252 + 24, 26, 26, 30, 21, 20, 33, 35, 37, 50, + 30, 33, 21, 38, 235, 37, 48, 35, 53, 53, + + 35, 234, 20, 97, 48, 231, 38, 65, 65, 69, + 69, 70, 81, 70, 70, 230, 65, 81, 69, 97, + 97, 50, 70, 71, 65, 71, 69, 226, 71, 71, + 70, 108, 225, 108, 112, 112, 108, 108, 222, 113, + 221, 113, 219, 112, 113, 113, 114, 114, 115, 115, + 218, 112, 122, 122, 146, 146, 147, 147, 149, 217, + 149, 150, 150, 149, 149, 151, 151, 176, 176, 177, + 177, 239, 216, 239, 240, 240, 240, 241, 241, 241, + 242, 242, 242, 242, 242, 243, 213, 243, 243, 243, + 244, 244, 212, 211, 210, 209, 206, 205, 204, 203, + + 202, 200, 199, 198, 197, 195, 194, 193, 192, 191, + 190, 189, 188, 187, 186, 182, 181, 179, 175, 174, + 173, 172, 170, 169, 168, 167, 166, 165, 164, 162, + 161, 160, 158, 156, 155, 154, 153, 152, 144, 143, + 142, 141, 140, 139, 138, 137, 136, 135, 133, 132, + 131, 130, 129, 128, 126, 125, 124, 123, 121, 120, + 110, 109, 105, 103, 102, 101, 100, 99, 98, 96, + 95, 94, 93, 92, 91, 90, 88, 87, 86, 85, + 84, 82, 80, 79, 77, 73, 66, 58, 47, 46, + 45, 44, 43, 42, 41, 40, 39, 36, 34, 32, + + 31, 25, 14, 10, 7, 3, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238 } ; /* Table of booleans, true if rule could match eol. */ -static yyconst flex_int32_t yy_rule_can_match_eol[93] = +static yyconst flex_int32_t yy_rule_can_match_eol[90] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, }; + 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, }; /* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. @@ -647,7 +644,7 @@ static yyconst flex_int32_t yy_rule_can_match_eol[93] = */ #define YY_NO_UNISTD_H 1 -#line 645 "lex.sksl.c" +#line 642 "lex.sksl.c" #define INITIAL 0 @@ -676,7 +673,7 @@ struct yyguts_t size_t yy_buffer_stack_max; /**< capacity of stack. */ YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ char yy_hold_char; - yy_size_t yy_n_chars; + int yy_n_chars; yy_size_t yyleng_r; char *yy_c_buf_p; int yy_init; @@ -718,11 +715,11 @@ void skslset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); FILE *skslget_in (yyscan_t yyscanner ); -void skslset_in (FILE * in_str ,yyscan_t yyscanner ); +void skslset_in (FILE * _in_str ,yyscan_t yyscanner ); FILE *skslget_out (yyscan_t yyscanner ); -void skslset_out (FILE * out_str ,yyscan_t yyscanner ); +void skslset_out (FILE * _out_str ,yyscan_t yyscanner ); yy_size_t skslget_leng (yyscan_t yyscanner ); @@ -730,11 +727,11 @@ char *skslget_text (yyscan_t yyscanner ); int skslget_lineno (yyscan_t yyscanner ); -void skslset_lineno (int line_number ,yyscan_t yyscanner ); +void skslset_lineno (int _line_number ,yyscan_t yyscanner ); int skslget_column (yyscan_t yyscanner ); -void skslset_column (int column_no ,yyscan_t yyscanner ); +void skslset_column (int _column_no ,yyscan_t yyscanner ); /* Macros after this point can all be overridden by user definitions in * section 1. @@ -748,8 +745,12 @@ extern int skslwrap (yyscan_t yyscanner ); #endif #endif +#ifndef YY_NO_UNPUT + static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner); +#endif + #ifndef yytext_ptr static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner); #endif @@ -862,7 +863,7 @@ extern int sksllex (yyscan_t yyscanner); /* Code executed at the end of each rule. */ #ifndef YY_BREAK -#define YY_BREAK break; +#define YY_BREAK /*LINTED*/break; #endif #define YY_RULE_SETUP \ @@ -872,9 +873,9 @@ extern int sksllex (yyscan_t yyscanner); */ YY_DECL { - register yy_state_type yy_current_state; - register char *yy_cp, *yy_bp; - register int yy_act; + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( !yyg->yy_init ) @@ -907,9 +908,9 @@ YY_DECL #line 23 "sksl.flex" -#line 905 "lex.sksl.c" +#line 906 "lex.sksl.c" - while ( 1 ) /* loops until end-of-file is reached */ + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { yy_cp = yyg->yy_c_buf_p; @@ -925,7 +926,7 @@ YY_DECL yy_match: do { - register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; @@ -934,13 +935,13 @@ yy_match: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 253 ) + if ( yy_current_state >= 239 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } - while ( yy_current_state != 252 ); + while ( yy_current_state != 238 ); yy_cp = yyg->yy_last_accepting_cpos; yy_current_state = yyg->yy_last_accepting_state; @@ -1035,406 +1036,391 @@ YY_RULE_SETUP case 13: YY_RULE_SETUP #line 49 "sksl.flex" -{ return SkSL::Token::SWITCH; } +{ return SkSL::Token::BREAK; } YY_BREAK case 14: YY_RULE_SETUP #line 51 "sksl.flex" -{ return SkSL::Token::CASE; } +{ return SkSL::Token::CONTINUE; } YY_BREAK case 15: YY_RULE_SETUP #line 53 "sksl.flex" -{ return SkSL::Token::DEFAULT; } +{ return SkSL::Token::DISCARD; } YY_BREAK case 16: YY_RULE_SETUP #line 55 "sksl.flex" -{ return SkSL::Token::BREAK; } +{ return SkSL::Token::RETURN; } YY_BREAK case 17: YY_RULE_SETUP #line 57 "sksl.flex" -{ return SkSL::Token::CONTINUE; } +{ return SkSL::Token::IN; } YY_BREAK case 18: YY_RULE_SETUP #line 59 "sksl.flex" -{ return SkSL::Token::DISCARD; } +{ return SkSL::Token::OUT; } YY_BREAK case 19: YY_RULE_SETUP #line 61 "sksl.flex" -{ return SkSL::Token::RETURN; } +{ return SkSL::Token::INOUT; } YY_BREAK case 20: YY_RULE_SETUP #line 63 "sksl.flex" -{ return SkSL::Token::IN; } +{ return SkSL::Token::UNIFORM; } YY_BREAK case 21: YY_RULE_SETUP #line 65 "sksl.flex" -{ return SkSL::Token::OUT; } +{ return SkSL::Token::CONST; } YY_BREAK case 22: YY_RULE_SETUP #line 67 "sksl.flex" -{ return SkSL::Token::INOUT; } +{ return SkSL::Token::LOWP; } YY_BREAK case 23: YY_RULE_SETUP #line 69 "sksl.flex" -{ return SkSL::Token::UNIFORM; } +{ return SkSL::Token::MEDIUMP; } YY_BREAK case 24: YY_RULE_SETUP #line 71 "sksl.flex" -{ return SkSL::Token::CONST; } +{ return SkSL::Token::HIGHP; } YY_BREAK case 25: YY_RULE_SETUP #line 73 "sksl.flex" -{ return SkSL::Token::LOWP; } +{ return SkSL::Token::FLAT; } YY_BREAK case 26: YY_RULE_SETUP #line 75 "sksl.flex" -{ return SkSL::Token::MEDIUMP; } +{ return SkSL::Token::NOPERSPECTIVE; } YY_BREAK case 27: YY_RULE_SETUP #line 77 "sksl.flex" -{ return SkSL::Token::HIGHP; } +{ return SkSL::Token::READONLY; } YY_BREAK case 28: YY_RULE_SETUP #line 79 "sksl.flex" -{ return SkSL::Token::FLAT; } +{ return SkSL::Token::WRITEONLY; } YY_BREAK case 29: YY_RULE_SETUP #line 81 "sksl.flex" -{ return SkSL::Token::NOPERSPECTIVE; } +{ return SkSL::Token::COHERENT; } YY_BREAK case 30: YY_RULE_SETUP #line 83 "sksl.flex" -{ return SkSL::Token::READONLY; } +{ return SkSL::Token::VOLATILE; } YY_BREAK case 31: YY_RULE_SETUP #line 85 "sksl.flex" -{ return SkSL::Token::WRITEONLY; } +{ return SkSL::Token::RESTRICT; } YY_BREAK case 32: YY_RULE_SETUP #line 87 "sksl.flex" -{ return SkSL::Token::COHERENT; } +{ return SkSL::Token::STRUCT; } YY_BREAK case 33: YY_RULE_SETUP #line 89 "sksl.flex" -{ return SkSL::Token::VOLATILE; } +{ return SkSL::Token::LAYOUT; } YY_BREAK case 34: YY_RULE_SETUP #line 91 "sksl.flex" -{ return SkSL::Token::RESTRICT; } +{ return SkSL::Token::PRECISION; } YY_BREAK case 35: YY_RULE_SETUP #line 93 "sksl.flex" -{ return SkSL::Token::STRUCT; } +{ return SkSL::Token::IDENTIFIER; } YY_BREAK case 36: YY_RULE_SETUP #line 95 "sksl.flex" -{ return SkSL::Token::LAYOUT; } +{ return SkSL::Token::DIRECTIVE; } YY_BREAK case 37: YY_RULE_SETUP #line 97 "sksl.flex" -{ return SkSL::Token::PRECISION; } +{ return SkSL::Token::LPAREN; } YY_BREAK case 38: YY_RULE_SETUP #line 99 "sksl.flex" -{ return SkSL::Token::IDENTIFIER; } +{ return SkSL::Token::RPAREN; } YY_BREAK case 39: YY_RULE_SETUP #line 101 "sksl.flex" -{ return SkSL::Token::DIRECTIVE; } +{ return SkSL::Token::LBRACE; } YY_BREAK case 40: YY_RULE_SETUP #line 103 "sksl.flex" -{ return SkSL::Token::LPAREN; } +{ return SkSL::Token::RBRACE; } YY_BREAK case 41: YY_RULE_SETUP #line 105 "sksl.flex" -{ return SkSL::Token::RPAREN; } +{ return SkSL::Token::LBRACKET; } YY_BREAK case 42: YY_RULE_SETUP #line 107 "sksl.flex" -{ return SkSL::Token::LBRACE; } +{ return SkSL::Token::RBRACKET; } YY_BREAK case 43: YY_RULE_SETUP #line 109 "sksl.flex" -{ return SkSL::Token::RBRACE; } +{ return SkSL::Token::DOT; } YY_BREAK case 44: YY_RULE_SETUP #line 111 "sksl.flex" -{ return SkSL::Token::LBRACKET; } +{ return SkSL::Token::COMMA; } YY_BREAK case 45: YY_RULE_SETUP #line 113 "sksl.flex" -{ return SkSL::Token::RBRACKET; } +{ return SkSL::Token::PLUSPLUS; } YY_BREAK case 46: YY_RULE_SETUP #line 115 "sksl.flex" -{ return SkSL::Token::DOT; } +{ return SkSL::Token::MINUSMINUS; } YY_BREAK case 47: YY_RULE_SETUP #line 117 "sksl.flex" -{ return SkSL::Token::COMMA; } +{ return SkSL::Token::PLUS; } YY_BREAK case 48: YY_RULE_SETUP #line 119 "sksl.flex" -{ return SkSL::Token::PLUSPLUS; } +{ return SkSL::Token::MINUS; } YY_BREAK case 49: YY_RULE_SETUP #line 121 "sksl.flex" -{ return SkSL::Token::MINUSMINUS; } +{ return SkSL::Token::STAR; } YY_BREAK case 50: YY_RULE_SETUP #line 123 "sksl.flex" -{ return SkSL::Token::PLUS; } +{ return SkSL::Token::SLASH; } YY_BREAK case 51: YY_RULE_SETUP #line 125 "sksl.flex" -{ return SkSL::Token::MINUS; } +{ return SkSL::Token::PERCENT; } YY_BREAK case 52: YY_RULE_SETUP #line 127 "sksl.flex" -{ return SkSL::Token::STAR; } +{ return SkSL::Token::SHL; } YY_BREAK case 53: YY_RULE_SETUP #line 129 "sksl.flex" -{ return SkSL::Token::SLASH; } +{ return SkSL::Token::SHR; } YY_BREAK case 54: YY_RULE_SETUP #line 131 "sksl.flex" -{ return SkSL::Token::PERCENT; } +{ return SkSL::Token::BITWISEOR; } YY_BREAK case 55: YY_RULE_SETUP #line 133 "sksl.flex" -{ return SkSL::Token::SHL; } +{ return SkSL::Token::BITWISEXOR; } YY_BREAK case 56: YY_RULE_SETUP #line 135 "sksl.flex" -{ return SkSL::Token::SHR; } +{ return SkSL::Token::BITWISEAND; } YY_BREAK case 57: YY_RULE_SETUP #line 137 "sksl.flex" -{ return SkSL::Token::BITWISEOR; } +{ return SkSL::Token::BITWISENOT; } YY_BREAK case 58: YY_RULE_SETUP #line 139 "sksl.flex" -{ return SkSL::Token::BITWISEXOR; } +{ return SkSL::Token::LOGICALOR; } YY_BREAK case 59: YY_RULE_SETUP #line 141 "sksl.flex" -{ return SkSL::Token::BITWISEAND; } +{ return SkSL::Token::LOGICALXOR; } YY_BREAK case 60: YY_RULE_SETUP #line 143 "sksl.flex" -{ return SkSL::Token::BITWISENOT; } +{ return SkSL::Token::LOGICALAND; } YY_BREAK case 61: YY_RULE_SETUP #line 145 "sksl.flex" -{ return SkSL::Token::LOGICALOR; } +{ return SkSL::Token::LOGICALNOT; } YY_BREAK case 62: YY_RULE_SETUP #line 147 "sksl.flex" -{ return SkSL::Token::LOGICALXOR; } +{ return SkSL::Token::QUESTION; } YY_BREAK case 63: YY_RULE_SETUP #line 149 "sksl.flex" -{ return SkSL::Token::LOGICALAND; } +{ return SkSL::Token::COLON; } YY_BREAK case 64: YY_RULE_SETUP #line 151 "sksl.flex" -{ return SkSL::Token::LOGICALNOT; } +{ return SkSL::Token::EQ; } YY_BREAK case 65: YY_RULE_SETUP #line 153 "sksl.flex" -{ return SkSL::Token::QUESTION; } +{ return SkSL::Token::EQEQ; } YY_BREAK case 66: YY_RULE_SETUP #line 155 "sksl.flex" -{ return SkSL::Token::COLON; } +{ return SkSL::Token::NEQ; } YY_BREAK case 67: YY_RULE_SETUP #line 157 "sksl.flex" -{ return SkSL::Token::EQ; } +{ return SkSL::Token::GT; } YY_BREAK case 68: YY_RULE_SETUP #line 159 "sksl.flex" -{ return SkSL::Token::EQEQ; } +{ return SkSL::Token::LT; } YY_BREAK case 69: YY_RULE_SETUP #line 161 "sksl.flex" -{ return SkSL::Token::NEQ; } +{ return SkSL::Token::GTEQ; } YY_BREAK case 70: YY_RULE_SETUP #line 163 "sksl.flex" -{ return SkSL::Token::GT; } +{ return SkSL::Token::LTEQ; } YY_BREAK case 71: YY_RULE_SETUP #line 165 "sksl.flex" -{ return SkSL::Token::LT; } +{ return SkSL::Token::PLUSEQ; } YY_BREAK case 72: YY_RULE_SETUP #line 167 "sksl.flex" -{ return SkSL::Token::GTEQ; } +{ return SkSL::Token::MINUSEQ; } YY_BREAK case 73: YY_RULE_SETUP #line 169 "sksl.flex" -{ return SkSL::Token::LTEQ; } +{ return SkSL::Token::STAREQ; } YY_BREAK case 74: YY_RULE_SETUP #line 171 "sksl.flex" -{ return SkSL::Token::PLUSEQ; } +{ return SkSL::Token::SLASHEQ; } YY_BREAK case 75: YY_RULE_SETUP #line 173 "sksl.flex" -{ return SkSL::Token::MINUSEQ; } +{ return SkSL::Token::PERCENTEQ; } YY_BREAK case 76: YY_RULE_SETUP #line 175 "sksl.flex" -{ return SkSL::Token::STAREQ; } +{ return SkSL::Token::SHLEQ; } YY_BREAK case 77: YY_RULE_SETUP #line 177 "sksl.flex" -{ return SkSL::Token::SLASHEQ; } +{ return SkSL::Token::SHREQ; } YY_BREAK case 78: YY_RULE_SETUP #line 179 "sksl.flex" -{ return SkSL::Token::PERCENTEQ; } +{ return SkSL::Token::BITWISEOREQ; } YY_BREAK case 79: YY_RULE_SETUP #line 181 "sksl.flex" -{ return SkSL::Token::SHLEQ; } +{ return SkSL::Token::BITWISEXOREQ; } YY_BREAK case 80: YY_RULE_SETUP #line 183 "sksl.flex" -{ return SkSL::Token::SHREQ; } +{ return SkSL::Token::BITWISEANDEQ; } YY_BREAK case 81: YY_RULE_SETUP #line 185 "sksl.flex" -{ return SkSL::Token::BITWISEOREQ; } +{ return SkSL::Token::LOGICALOREQ; } YY_BREAK case 82: YY_RULE_SETUP #line 187 "sksl.flex" -{ return SkSL::Token::BITWISEXOREQ; } +{ return SkSL::Token::LOGICALXOREQ; } YY_BREAK case 83: YY_RULE_SETUP #line 189 "sksl.flex" -{ return SkSL::Token::BITWISEANDEQ; } +{ return SkSL::Token::LOGICALANDEQ; } YY_BREAK case 84: YY_RULE_SETUP #line 191 "sksl.flex" -{ return SkSL::Token::LOGICALOREQ; } +{ return SkSL::Token::SEMICOLON; } YY_BREAK case 85: YY_RULE_SETUP #line 193 "sksl.flex" -{ return SkSL::Token::LOGICALXOREQ; } +/* line comment */ YY_BREAK case 86: +/* rule 86 can match eol */ YY_RULE_SETUP #line 195 "sksl.flex" -{ return SkSL::Token::LOGICALANDEQ; } +/* block comment */ YY_BREAK case 87: +/* rule 87 can match eol */ YY_RULE_SETUP #line 197 "sksl.flex" -{ return SkSL::Token::SEMICOLON; } +/* whitespace */ YY_BREAK case 88: YY_RULE_SETUP #line 199 "sksl.flex" -/* line comment */ +{ return SkSL::Token::INVALID_TOKEN; } YY_BREAK case 89: -/* rule 89 can match eol */ YY_RULE_SETUP #line 201 "sksl.flex" -/* block comment */ - YY_BREAK -case 90: -/* rule 90 can match eol */ -YY_RULE_SETUP -#line 203 "sksl.flex" -/* whitespace */ - YY_BREAK -case 91: -YY_RULE_SETUP -#line 205 "sksl.flex" -{ return SkSL::Token::INVALID_TOKEN; } - YY_BREAK -case 92: -YY_RULE_SETUP -#line 207 "sksl.flex" ECHO; YY_BREAK -#line 1432 "lex.sksl.c" +#line 1418 "lex.sksl.c" case YY_STATE_EOF(INITIAL): yyterminate(); @@ -1579,9 +1565,9 @@ case YY_STATE_EOF(INITIAL): static int yy_get_next_buffer (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - register char *source = yyg->yytext_ptr; - register int number_to_move, i; + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = yyg->yytext_ptr; + yy_size_t number_to_move, i; int ret_val; if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) @@ -1610,7 +1596,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) /* Try to read more data. */ /* First move last chars to start of buffer. */ - number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; + number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); @@ -1692,9 +1678,9 @@ static int yy_get_next_buffer (yyscan_t yyscanner) else ret_val = EOB_ACT_CONTINUE_SCAN; - if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + if ((int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ - yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); + int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) skslrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); @@ -1713,15 +1699,15 @@ static int yy_get_next_buffer (yyscan_t yyscanner) static yy_state_type yy_get_previous_state (yyscan_t yyscanner) { - register yy_state_type yy_current_state; - register char *yy_cp; + yy_state_type yy_current_state; + char *yy_cp; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_current_state = yyg->yy_start; for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) { - register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; @@ -1730,7 +1716,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 253 ) + if ( yy_current_state >= 239 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -1746,11 +1732,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner) */ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) { - register int yy_is_jam; + int yy_is_jam; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ - register char *yy_cp = yyg->yy_c_buf_p; + char *yy_cp = yyg->yy_c_buf_p; - register YY_CHAR yy_c = 1; + YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; @@ -1759,19 +1745,21 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 253 ) + if ( yy_current_state >= 239 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - yy_is_jam = (yy_current_state == 252); + yy_is_jam = (yy_current_state == 238); (void)yyg; return yy_is_jam ? 0 : yy_current_state; } - static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner) +#ifndef YY_NO_UNPUT + + static void yyunput (int c, char * yy_bp , yyscan_t yyscanner) { - register char *yy_cp; + char *yy_cp; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_cp = yyg->yy_c_buf_p; @@ -1782,10 +1770,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner) if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ - register yy_size_t number_to_move = yyg->yy_n_chars + 2; - register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + yy_size_t number_to_move = yyg->yy_n_chars + 2; + char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; - register char *source = + char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) @@ -1811,6 +1799,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner) yyg->yy_c_buf_p = yy_cp; } +#endif + #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (yyscan_t yyscanner) @@ -1971,7 +1961,7 @@ static void sksl_load_buffer_state (yyscan_t yyscanner) if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in sksl_create_buffer()" ); - b->yy_buf_size = size; + b->yy_buf_size = (yy_size_t)size; /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. @@ -2132,7 +2122,7 @@ static void skslensure_buffer_stack (yyscan_t yyscanner) * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. */ - num_to_alloc = 1; + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ yyg->yy_buffer_stack = (struct yy_buffer_state**)skslalloc (num_to_alloc * sizeof(struct yy_buffer_state*) , yyscanner); @@ -2149,7 +2139,7 @@ static void skslensure_buffer_stack (yyscan_t yyscanner) if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ /* Increase the buffer to prepare for a possible push. */ - int grow_size = 8 /* arbitrary grow size */; + yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = yyg->yy_buffer_stack_max + grow_size; yyg->yy_buffer_stack = (struct yy_buffer_state**)skslrealloc @@ -2257,7 +2247,9 @@ YY_BUFFER_STATE sksl_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_le static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner) { - (void) fprintf( stderr, "%s\n", msg ); + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + (void) fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } @@ -2363,10 +2355,10 @@ void skslset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) } /** Set the current line number. - * @param line_number + * @param _line_number line number * @param yyscanner The scanner object. */ -void skslset_lineno (int line_number , yyscan_t yyscanner) +void skslset_lineno (int _line_number , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; @@ -2374,14 +2366,14 @@ void skslset_lineno (int line_number , yyscan_t yyscanner) if (! YY_CURRENT_BUFFER ) YY_FATAL_ERROR( "skslset_lineno called with no buffer" ); - yylineno = line_number; + yylineno = _line_number; } /** Set the current column. - * @param line_number + * @param _column_no column number * @param yyscanner The scanner object. */ -void skslset_column (int column_no , yyscan_t yyscanner) +void skslset_column (int _column_no , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; @@ -2389,25 +2381,25 @@ void skslset_column (int column_no , yyscan_t yyscanner) if (! YY_CURRENT_BUFFER ) YY_FATAL_ERROR( "skslset_column called with no buffer" ); - yycolumn = column_no; + yycolumn = _column_no; } /** Set the input stream. This does not discard the current * input buffer. - * @param in_str A readable stream. + * @param _in_str A readable stream. * @param yyscanner The scanner object. * @see sksl_switch_to_buffer */ -void skslset_in (FILE * in_str , yyscan_t yyscanner) +void skslset_in (FILE * _in_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyin = in_str ; + yyin = _in_str ; } -void skslset_out (FILE * out_str , yyscan_t yyscanner) +void skslset_out (FILE * _out_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyout = out_str ; + yyout = _out_str ; } int skslget_debug (yyscan_t yyscanner) @@ -2416,10 +2408,10 @@ int skslget_debug (yyscan_t yyscanner) return yy_flex_debug; } -void skslset_debug (int bdebug , yyscan_t yyscanner) +void skslset_debug (int _bdebug , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yy_flex_debug = bdebug ; + yy_flex_debug = _bdebug ; } /* Accessor methods for yylval and yylloc */ @@ -2558,7 +2550,10 @@ int sksllex_destroy (yyscan_t yyscanner) #ifndef yytext_ptr static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner) { - register int i; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + + int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } @@ -2567,7 +2562,7 @@ static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yysca #ifdef YY_NEED_STRLEN static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) { - register int n; + int n; for ( n = 0; s[n]; ++n ) ; @@ -2577,11 +2572,16 @@ static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) void *skslalloc (yy_size_t size , yyscan_t yyscanner) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; return (void *) malloc( size ); } void *skslrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter @@ -2594,12 +2594,14 @@ void *skslrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) void skslfree (void * ptr , yyscan_t yyscanner) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; free( (char *) ptr ); /* see skslrealloc() for (char *) cast */ } #define YYTABLES_NAME "yytables" -#line 206 "sksl.flex" +#line 201 "sksl.flex" -- cgit v1.2.3