//----------------------------------------------------------------------------- // V12 Engine // // Copyright (c) 2001 GarageGames.Com // Portions Copyright (c) 2001 by Sierra Online, Inc. //----------------------------------------------------------------------------- /* lex -a -P console\yylex.c -p CMD -o console\scan.cc console\scan.l */ #define YYNEWLINE 10 #define INITIAL 0 #define CMD_endst 180 #define CMD_nxtmax 2057 #define YY_LA_SIZE 23 static unsigned int CMD_la_act[] = { 0, 81, 41, 81, 2, 81, 3, 81, 81, 56, 81, 46, 81, 43, 81, 42, 81, 52, 81, 44, 81, 47, 81, 39, 81, 38, 81, 81, 40, 81, 53, 81, 54, 81, 76, 81, 76, 81, 76, 81, 32, 81, 33, 81, 34, 81, 35, 81, 36, 81, 37, 81, 45, 81, 48, 81, 49, 81, 50, 81, 51, 81, 55, 81, 76, 81, 76, 81, 76, 81, 76, 81, 76, 81, 76, 81, 76, 81, 76, 81, 76, 81, 76, 81, 76, 81, 76, 81, 76, 81, 76, 81, 78, 81, 78, 81, 81, 78, 79, 79, 77, 76, 76, 76, 73, 76, 76, 76, 76, 76, 76, 72, 76, 76, 76, 76, 76, 70, 76, 69, 76, 76, 76, 76, 76, 76, 71, 76, 76, 76, 76, 76, 76, 76, 67, 76, 76, 66, 76, 76, 76, 76, 68, 76, 76, 76, 76, 76, 76, 64, 76, 76, 76, 76, 76, 76, 74, 76, 76, 76, 76, 76, 76, 65, 76, 63, 76, 62, 76, 76, 76, 76, 61, 76, 76, 76, 60, 76, 76, 76, 76, 76, 59, 76, 76, 76, 76, 58, 76, 57, 76, 76, 31, 76, 76, 30, 76, 29, 76, 25, 23, 75, 80, 80, 75, 21, 15, 14, 19, 13, 20, 12, 11, 26, 10, 24, 9, 17, 27, 8, 18, 28, 7, 16, 6, 5, 4, 1, 22, 1, 0, 0 }; static unsigned char CMD_look[] = { 0 }; static int CMD_final[] = { 0, 0, 2, 4, 6, 7, 8, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 97, 98, 98, 98, 98, 99, 100, 100, 101, 102, 103, 104, 106, 107, 108, 109, 110, 111, 113, 114, 115, 116, 117, 119, 120, 121, 122, 123, 124, 125, 126, 128, 129, 130, 131, 132, 133, 134, 136, 137, 139, 140, 141, 142, 144, 145, 146, 147, 148, 149, 151, 152, 153, 154, 155, 156, 158, 159, 160, 161, 162, 163, 165, 167, 169, 170, 171, 172, 174, 175, 176, 178, 179, 180, 181, 182, 184, 185, 186, 187, 189, 191, 192, 194, 195, 197, 199, 200, 201, 202, 202, 203, 204, 204, 205, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 223, 224, 225, 225, 225, 226, 226, 226, 226, 227, 227, 228, 229, 230, 231 }; #ifndef CMD_state_t #define CMD_state_t unsigned char #endif static CMD_state_t CMD_begin[] = { 0, 0, 0 }; static CMD_state_t CMD_next[] = { 51, 51, 51, 51, 51, 51, 51, 51, 51, 1, 4, 1, 1, 3, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 1, 8, 5, 51, 16, 18, 11, 6, 27, 28, 17, 15, 33, 14, 29, 2, 49, 50, 50, 50, 50, 50, 50, 50, 50, 50, 13, 30, 10, 7, 9, 24, 23, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 20, 48, 48, 48, 48, 22, 21, 48, 48, 48, 48, 48, 48, 25, 51, 26, 19, 48, 51, 48, 36, 42, 44, 38, 41, 48, 48, 40, 48, 48, 48, 48, 43, 35, 46, 48, 37, 45, 47, 48, 48, 39, 48, 48, 48, 31, 12, 32, 34, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 53, 61, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 180, 180, 180, 180, 54, 58, 62, 55, 63, 55, 64, 54, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 65, 66, 67, 68, 54, 58, 69, 70, 71, 72, 73, 54, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 74, 75, 76, 78, 79, 80, 77, 59, 59, 59, 59, 59, 59, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 93, 94, 95, 96, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 92, 59, 59, 59, 59, 59, 59, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 97, 98, 99, 100, 60, 101, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 102, 118, 119, 120, 121, 122, 103, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 147, 148, 153, 139, 155, 159, 158, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 160, 161, 162, 163, 140, 166, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 180, 167, 154, 180, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 180, 180, 180, 180, 142, 180, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 144, 180, 180, 180, 180, 180, 180, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 180, 180, 180, 180, 143, 180, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 146, 180, 180, 180, 180, 180, 180, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 180, 180, 180, 180, 145, 180, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 149, 151, 156, 165, 179, 176, 179, 179, 180, 180, 180, 180, 180, 180, 180, 180, 180, 152, 150, 177, 180, 180, 180, 180, 180, 157, 180, 179, 164, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 180, 169, 169, 180, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 170, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 168, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 180, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 180, 173, 173, 180, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 174, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 172, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 180, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 180, 178, 178, 180, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 0 }; static CMD_state_t CMD_check[] = { 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, 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, 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, 50, 47, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 56, 55, 56, 55, 57, 49, 61, 54, 62, 54, 46, 50, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 64, 65, 66, 67, 57, 49, 68, 45, 70, 71, 72, 50, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 73, 74, 44, 77, 78, 79, 44, 58, 58, 58, 58, 58, 58, 80, 81, 76, 83, 84, 85, 86, 87, 88, 43, 90, 42, 93, 94, 92, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 42, 58, 58, 58, 58, 58, 58, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 96, 97, 98, 99, 48, 100, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 41, 104, 105, 106, 103, 108, 109, 110, 111, 112, 102, 40, 39, 116, 41, 117, 118, 38, 120, 121, 41, 37, 123, 124, 125, 126, 36, 128, 129, 130, 35, 22, 133, 21, 135, 20, 19, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 17, 16, 13, 18, 12, 10, 10, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 159, 9, 9, 162, 18, 165, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 141, 7, 12, ~0U, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, ~0U, ~0U, ~0U, ~0U, 141, ~0U, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, ~0U, ~0U, ~0U, ~0U, ~0U, ~0U, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, ~0U, ~0U, ~0U, ~0U, 142, ~0U, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, ~0U, ~0U, ~0U, ~0U, ~0U, ~0U, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, ~0U, ~0U, ~0U, ~0U, 140, ~0U, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 15, 14, 11, 8, 1, 2, 1, 1, ~0U, ~0U, ~0U, ~0U, ~0U, ~0U, ~0U, ~0U, ~0U, 14, 15, 2, ~0U, ~0U, ~0U, ~0U, ~0U, 11, ~0U, 1, 8, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, ~0U, 6, 6, ~0U, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, ~0U, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ~0U, 5, 5, ~0U, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, ~0U, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, ~0U, 176, 176, ~0U, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 0 }; static CMD_state_t CMD_default[] = { 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 18, 180, 180, 180, 48, 48, 48, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 180, 50, 180, 180, 50, 180, 180, 54, 54, 53, 180, 58, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 180, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 180, 180, 180, 18, 180, 142, 142, 140, 140, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 6, 180, 6, 180, 5, 180, 5, 180, 180, 176, 1, 0 }; static int CMD_base[] = { 0, 744, 707, 2058, 2058, 1290, 778, 477, 716, 445, 417, 713, 415, 416, 705, 706, 412, 411, 414, 400, 384, 393, 376, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 341, 337, 345, 334, 333, 334, 328, 249, 243, 227, 188, 181, 143, 302, 185, 210, 2058, 2058, 242, 232, 226, 225, 203, 264, 2058, 2058, 157, 175, 2058, 201, 194, 205, 200, 205, 2058, 203, 193, 211, 218, 287, 2058, 221, 223, 229, 210, 227, 220, 2058, 241, 241, 232, 230, 243, 236, 2058, 226, 2058, 239, 232, 247, 2058, 277, 289, 285, 279, 297, 2058, 321, 319, 318, 312, 327, 2058, 331, 315, 327, 322, 324, 2058, 2058, 2058, 333, 332, 340, 2058, 328, 343, 2058, 331, 331, 335, 340, 2058, 351, 356, 347, 2058, 2058, 390, 2058, 393, 2058, 2058, 2058, 2058, 626, 476, 551, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 2058, 444, 2058, 2058, 447, 2058, 2058, 449, 2058, 2058, 1034, 2058, 2058, 2058, 1546, 2058, 2058, 2058, 1802, 2058, 2058, 2058, 2058 }; #line 1 "console/yylex.c" /* * Copyright 1988, 1992 by Mortice Kern Systems Inc. All rights reserved. * All rights reserved. * * $Header: /cvs/torque/torque/engine/console/scan.cc,v 1.1 2001/05/17 02:16:15 timg Exp $ * */ #include #include #if __STDC__ #define YY_ARGS(args) args #else #define YY_ARGS(args) () #endif #ifdef LEX_WINDOWS #include /* * define, if not already defined * the flag YYEXIT, which will allow * graceful exits from CMDlex() * without resorting to calling exit(); */ #ifndef YYEXIT #define YYEXIT 1 #endif /* * the following is the handle to the current * instance of a windows program. The user * program calling CMDlex must supply this! */ #ifdef STRICT extern HINSTANCE hInst; #else extern HANDLE hInst; #endif #endif /* LEX_WINDOWS */ /* * Define m_textmsg() to an appropriate function for internationalized messages * or custom processing. */ #ifndef I18N #define m_textmsg(id, str, cls) (str) #else /*I18N*/ extern char* m_textmsg YY_ARGS((int id, const char* str, char* cls)); #endif/*I18N*/ /* * Include string.h to get definition of memmove() and size_t. * If you do not have string.h or it does not declare memmove * or size_t, you will have to declare them here. */ #include /* Uncomment next line if memmove() is not declared in string.h */ /*extern char * memmove();*/ /* Uncomment next line if size_t is not available in stdio.h or string.h */ /*typedef unsigned size_t;*/ /* Drop this when LATTICE provides memmove */ #ifdef LATTICE #define memmove memcopy #endif /* * YY_STATIC determines the scope of variables and functions * declared by the lex scanner. It must be set with a -DYY_STATIC * option to the compiler (it cannot be defined in the lex program). */ #ifdef YY_STATIC /* define all variables as static to allow more than one lex scanner */ #define YY_DECL static #else /* define all variables as global to allow other modules to access them */ #define YY_DECL #endif /* * You can redefine CMDgetc. For YACC Tracing, compile this code * with -DYYTRACE to get input from yt_getc */ #ifdef YYTRACE extern int yt_getc YY_ARGS((void)); #define CMDgetc() yt_getc() #else #define CMDgetc() getc(CMDin) /* CMDlex input source */ #endif /* * the following can be redefined by the user. */ #ifdef YYEXIT #define YY_FATAL(msg) { fprintf(CMDout, "CMDlex: %s\n", msg); CMDLexFatal = 1; } #else /* YYEXIT */ #define YY_FATAL(msg) { fprintf(stderr, "CMDlex: %s\n", msg); exit(1); } #endif /* YYEXIT */ #undef ECHO #define ECHO fputs(CMDtext, CMDout) #define output(c) putc((c), CMDout) /* CMDlex sink for unmatched chars */ #define YY_INTERACTIVE 1 /* save micro-seconds if 0 */ #define BEGIN CMD_start = #define REJECT goto CMD_reject #define NLSTATE (CMD_lastc = YYNEWLINE) #define YY_INIT \ (CMD_start = CMDleng = CMD_end = 0, CMD_lastc = YYNEWLINE) #define CMDmore() goto CMD_more #define CMDless(n) if ((n) < 0 || (n) > CMD_end) ; \ else { YY_SCANNER; CMDleng = (n); YY_USER; } YY_DECL void CMD_reset YY_ARGS((void)); YY_DECL int input YY_ARGS((void)); YY_DECL int unput YY_ARGS((int c)); /* functions defined in libl.lib */ extern int CMDwrap YY_ARGS((void)); extern void CMDerror YY_ARGS((char *fmt, ...)); extern void CMDcomment YY_ARGS((char *term)); extern int CMDmapch YY_ARGS((int delim, int escape)); #line 1 "console/scan.l" #define YYLMAX 4096 #include "platform/platform.h" #include "console/console.h" #include "console/ast.h" #include "console/gram.h" #include "core/stringTable.h" static int Sc_ScanString(int ret); static int Sc_ScanNum(); static int Sc_ScanVar(); static int Sc_ScanHex(); #define FLEX_DEBUG 1 //#undef input //#undef unput #undef CMDgetc int CMDgetc(); static int lineIndex; extern DataChunker consoleAllocator; // Prototypes void SetScanBuffer(const char *sb, const char *fn); const char * CMDgetFileLine(int &lineNumber); void CMDerror(char * s, ...); #line 127 "console/yylex.c" #ifndef YYLMAX #define YYLMAX 100 /* token and pushback buffer size */ #endif /* YYLMAX */ /* * If %array is used (or defaulted), CMDtext[] contains the token. * If %pointer is used, CMDtext is a pointer to CMD_tbuf[]. */ YY_DECL char CMDtext[YYLMAX+1]; #ifdef YY_DEBUG #undef YY_DEBUG #define YY_DEBUG(fmt, a1, a2) fprintf(stderr, fmt, a1, a2) #else #define YY_DEBUG(fmt, a1, a2) #endif /* * The declaration for the lex scanner can be changed by * redefining YYLEX or YYDECL. This must be done if you have * more than one scanner in a program. */ #ifndef YYLEX #define YYLEX CMDlex /* name of lex scanner */ #endif #ifndef YYDECL #define YYDECL int YYLEX YY_ARGS((void)) /* declaration for lex scanner */ #endif /* * stdin and stdout may not neccessarily be constants. * If stdin and stdout are constant, and you want to save a few cycles, then * #define YY_STATIC_STDIO 1 in this file or on the commandline when * compiling this file */ #ifndef YY_STATIC_STDIO #define YY_STATIC_STDIO 0 #endif #if YY_STATIC_STDIO YY_DECL FILE *CMDin = stdin; YY_DECL FILE *CMDout = stdout; #else YY_DECL FILE *CMDin = (FILE *)0; YY_DECL FILE *CMDout = (FILE *)0; #endif YY_DECL int CMDlineno = 1; /* line number */ /* CMD_sbuf[0:CMDleng-1] contains the states corresponding to CMDtext. * CMDtext[0:CMDleng-1] contains the current token. * CMDtext[CMDleng:CMD_end-1] contains pushed-back characters. * When the user action routine is active, * CMD_save contains CMDtext[CMDleng], which is set to '\0'. * Things are different when YY_PRESERVE is defined. */ static CMD_state_t CMD_sbuf [YYLMAX+1]; /* state buffer */ static int CMD_end = 0; /* end of pushback */ static int CMD_start = 0; /* start state */ static int CMD_lastc = YYNEWLINE; /* previous char */ YY_DECL int CMDleng = 0; /* CMDtext token length */ #ifdef YYEXIT static int CMDLexFatal; #endif /* YYEXIT */ #ifndef YY_PRESERVE /* the efficient default push-back scheme */ static char CMD_save; /* saved CMDtext[CMDleng] */ #define YY_USER { /* set up CMDtext for user */ \ CMD_save = CMDtext[CMDleng]; \ CMDtext[CMDleng] = 0; \ } #define YY_SCANNER { /* set up CMDtext for scanner */ \ CMDtext[CMDleng] = CMD_save; \ } #else /* not-so efficient push-back for CMDtext mungers */ static char CMD_save [YYLMAX]; static char *CMD_push = CMD_save+YYLMAX; #define YY_USER { \ size_t n = CMD_end - CMDleng; \ CMD_push = CMD_save+YYLMAX - n; \ if (n > 0) \ memmove(CMD_push, CMDtext+CMDleng, n); \ CMDtext[CMDleng] = 0; \ } #define YY_SCANNER { \ size_t n = CMD_save+YYLMAX - CMD_push; \ if (n > 0) \ memmove(CMDtext+CMDleng, CMD_push, n); \ CMD_end = CMDleng + n; \ } #endif #ifdef LEX_WINDOWS /* * When using the windows features of lex, * it is necessary to load in the resources being * used, and when done with them, the resources must * be freed up, otherwise we have a windows app that * is not following the rules. Thus, to make CMDlex() * behave in a windows environment, create a new * CMDlex() which will call the original CMDlex() as * another function call. Observe ... */ /* * The actual lex scanner (usually CMDlex(void)). * NOTE: you should invoke CMD_init() if you are calling CMDlex() * with new input; otherwise old lookaside will get in your way * and CMDlex() will die horribly. */ static int win_CMDlex(); /* prototype for windows CMDlex handler */ YYDECL { int wReturnValue; HANDLE hRes_table; unsigned short far *old_CMD_la_act; /* remember previous pointer values */ short far *old_CMD_final; CMD_state_t far *old_CMD_begin; CMD_state_t far *old_CMD_next; CMD_state_t far *old_CMD_check; CMD_state_t far *old_CMD_default; short far *old_CMD_base; /* * the following code will load the required * resources for a Windows based parser. */ hRes_table = LoadResource (hInst, FindResource (hInst, "UD_RES_CMDLEX", "CMDLEXTBL")); /* * return an error code if any * of the resources did not load */ if (hRes_table == NULL) return (0); /* * the following code will lock the resources * into fixed memory locations for the scanner * (and remember previous pointer locations) */ old_CMD_la_act = CMD_la_act; old_CMD_final = CMD_final; old_CMD_begin = CMD_begin; old_CMD_next = CMD_next; old_CMD_check = CMD_check; old_CMD_default = CMD_default; old_CMD_base = CMD_base; CMD_la_act = (unsigned short far *)LockResource (hRes_table); CMD_final = (short far *)(CMD_la_act + Sizeof_CMD_la_act); CMD_begin = (CMD_state_t far *)(CMD_final + Sizeof_CMD_final); CMD_next = (CMD_state_t far *)(CMD_begin + Sizeof_CMD_begin); CMD_check = (CMD_state_t far *)(CMD_next + Sizeof_CMD_next); CMD_default = (CMD_state_t far *)(CMD_check + Sizeof_CMD_check); CMD_base = (CMD_state_t far *)(CMD_default + Sizeof_CMD_default); /* * call the standard CMDlex() code */ wReturnValue = win_CMDlex(); /* * unlock the resources */ UnlockResource (hRes_table); /* * and now free the resource */ FreeResource (hRes_table); /* * restore previously saved pointers */ CMD_la_act = old_CMD_la_act; CMD_final = old_CMD_final; CMD_begin = old_CMD_begin; CMD_next = old_CMD_next; CMD_check = old_CMD_check; CMD_default = old_CMD_default; CMD_base = old_CMD_base; return (wReturnValue); } /* end function */ static int win_CMDlex() { #else /* LEX_WINDOWS */ /* * The actual lex scanner (usually CMDlex(void)). * NOTE: you should invoke CMD_init() if you are calling CMDlex() * with new input; otherwise old lookaside will get in your way * and CMDlex() will die horribly. */ YYDECL { #endif /* LEX_WINDOWS */ register int c, i, CMDbase; unsigned CMDst; /* state */ int CMDfmin, CMDfmax; /* CMD_la_act indices of final states */ int CMDoldi, CMDoleng; /* base i, CMDleng before look-ahead */ int CMDeof; /* 1 if eof has already been read */ #line 47 "console/scan.l" ; #line 350 "console/yylex.c" #if !YY_STATIC_STDIO if (CMDin == (FILE *)0) CMDin = stdin; if (CMDout == (FILE *)0) CMDout = stdout; #endif #ifdef YYEXIT CMDLexFatal = 0; #endif /* YYEXIT */ CMDeof = 0; i = CMDleng; YY_SCANNER; CMD_again: CMDleng = i; /* determine previous char. */ if (i > 0) CMD_lastc = CMDtext[i-1]; /* scan previously accepted token adjusting CMDlineno */ while (i > 0) if (CMDtext[--i] == YYNEWLINE) CMDlineno++; /* adjust pushback */ CMD_end -= CMDleng; if (CMD_end > 0) memmove(CMDtext, CMDtext+CMDleng, (size_t) CMD_end); i = 0; CMD_contin: CMDoldi = i; /* run the state machine until it jams */ CMDst = CMD_begin[CMD_start + ((CMD_lastc == YYNEWLINE) ? 1 : 0)]; CMD_sbuf[i] = (CMD_state_t) CMDst; do { YY_DEBUG(m_textmsg(1547, "\n", "I num1 num2"), CMDst, i); if (i >= YYLMAX) { YY_FATAL(m_textmsg(1548, "Token buffer overflow", "E")); #ifdef YYEXIT if (CMDLexFatal) return -2; #endif /* YYEXIT */ } /* endif */ /* get input char */ if (i < CMD_end) c = CMDtext[i]; /* get pushback char */ else if (!CMDeof && (c = CMDgetc()) != EOF) { CMD_end = i+1; CMDtext[i] = (char) c; } else /* c == EOF */ { c = EOF; /* just to make sure... */ if (i == CMDoldi) { /* no token */ CMDeof = 0; if (CMDwrap()) return 0; else goto CMD_again; } else { CMDeof = 1; /* don't re-read EOF */ break; } } YY_DEBUG(m_textmsg(1549, "\n", "I num hexnum"), c, c); /* look up next state */ while ((CMDbase = CMD_base[CMDst]+(unsigned char)c) > CMD_nxtmax || CMD_check[CMDbase] != (CMD_state_t) CMDst) { if (CMDst == CMD_endst) goto CMD_jammed; CMDst = CMD_default[CMDst]; } CMDst = CMD_next[CMDbase]; CMD_jammed: ; CMD_sbuf[++i] = (CMD_state_t) CMDst; } while (!(CMDst == CMD_endst || YY_INTERACTIVE && CMD_base[CMDst] > CMD_nxtmax && CMD_default[CMDst] == CMD_endst)); YY_DEBUG(m_textmsg(1550, "\n", "I num1 num2"), CMDst, i); if (CMDst != CMD_endst) ++i; CMD_search: /* search backward for a final state */ while (--i > CMDoldi) { CMDst = CMD_sbuf[i]; if ((CMDfmin = CMD_final[CMDst]) < (CMDfmax = CMD_final[CMDst+1])) goto CMD_found; /* found final state(s) */ } /* no match, default action */ i = CMDoldi + 1; output(CMDtext[CMDoldi]); goto CMD_again; CMD_found: YY_DEBUG(m_textmsg(1551, "\n", "I num1 num2"), CMDst, i); CMDoleng = i; /* save length for REJECT */ /* pushback look-ahead RHS */ if ((c = (int)(CMD_la_act[CMDfmin]>>9) - 1) >= 0) { /* trailing context? */ unsigned char *bv = CMD_look + c*YY_LA_SIZE; static unsigned char bits [8] = { 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7 }; while (1) { if (--i < CMDoldi) { /* no / */ i = CMDoleng; break; } CMDst = CMD_sbuf[i]; if (bv[(unsigned)CMDst/8] & bits[(unsigned)CMDst%8]) break; } } /* perform action */ CMDleng = i; YY_USER; switch (CMD_la_act[CMDfmin] & 0777) { case 0: #line 48 "console/scan.l" { } break; case 1: #line 49 "console/scan.l" ; break; case 2: #line 50 "console/scan.l" ; break; case 3: #line 51 "console/scan.l" {lineIndex++;} break; case 4: #line 52 "console/scan.l" { return(Sc_ScanString(STRATOM)); } break; case 5: #line 53 "console/scan.l" { return(Sc_ScanString(TAGATOM)); } break; case 6: #line 54 "console/scan.l" return(CMDlval.i = opEQ); break; case 7: #line 55 "console/scan.l" return(CMDlval.i = opNE); break; case 8: #line 56 "console/scan.l" return(CMDlval.i = opGE); break; case 9: #line 57 "console/scan.l" return(CMDlval.i = opLE); break; case 10: #line 58 "console/scan.l" return(CMDlval.i = opAND); break; case 11: #line 59 "console/scan.l" return(CMDlval.i = opOR); break; case 12: #line 60 "console/scan.l" return(CMDlval.i = opCOLONCOLON); break; case 13: #line 61 "console/scan.l" return(CMDlval.i = opMINUSMINUS); break; case 14: #line 62 "console/scan.l" return(CMDlval.i = opPLUSPLUS); break; case 15: #line 63 "console/scan.l" return(CMDlval.i = opSTREQ); break; case 16: #line 64 "console/scan.l" return(CMDlval.i = opSTRNE); break; case 17: #line 65 "console/scan.l" return(CMDlval.i = opSHL); break; case 18: #line 66 "console/scan.l" return(CMDlval.i = opSHR); break; case 19: #line 67 "console/scan.l" return(CMDlval.i = opPLASN); break; case 20: #line 68 "console/scan.l" return(CMDlval.i = opMIASN); break; case 21: #line 69 "console/scan.l" return(CMDlval.i = opMLASN); break; case 22: #line 70 "console/scan.l" return(CMDlval.i = opDVASN); break; case 23: #line 71 "console/scan.l" return(CMDlval.i = opMODASN); break; case 24: #line 72 "console/scan.l" return(CMDlval.i = opANDASN); break; case 25: #line 73 "console/scan.l" return(CMDlval.i = opXORASN); break; case 26: #line 74 "console/scan.l" return(CMDlval.i = opORASN); break; case 27: #line 75 "console/scan.l" return(CMDlval.i = opSLASN); break; case 28: #line 76 "console/scan.l" return(CMDlval.i = opSRASN); break; case 29: #line 77 "console/scan.l" {CMDlval.i = '\n'; return '@'; } break; case 30: #line 78 "console/scan.l" {CMDlval.i = '\t'; return '@'; } break; case 31: #line 79 "console/scan.l" {CMDlval.i = ' '; return '@'; } break; case 32: #line 80 "console/scan.l" {CMDlval.i = 0; return '@'; } break; case 33: case 34: case 35: case 36: case 37: case 38: case 39: case 40: case 41: case 42: case 43: case 44: case 45: case 46: case 47: case 48: case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: #line 104 "console/scan.l" { return(CMDlval.i = CMDtext[0]); } break; case 57: #line 105 "console/scan.l" { CMDlval.i = lineIndex; return(rwCASEOR); } break; case 58: #line 106 "console/scan.l" { CMDlval.i = lineIndex; return(rwBREAK); } break; case 59: #line 107 "console/scan.l" { CMDlval.i = lineIndex; return(rwRETURN); } break; case 60: #line 108 "console/scan.l" { CMDlval.i = lineIndex; return(rwELSE); } break; case 61: #line 109 "console/scan.l" { CMDlval.i = lineIndex; return(rwWHILE); } break; case 62: #line 110 "console/scan.l" { CMDlval.i = lineIndex; return(rwIF); } break; case 63: #line 111 "console/scan.l" { CMDlval.i = lineIndex; return(rwFOR); } break; case 64: #line 112 "console/scan.l" { CMDlval.i = lineIndex; return(rwCONTINUE); } break; case 65: #line 113 "console/scan.l" { CMDlval.i = lineIndex; return(rwDEFINE); } break; case 66: #line 114 "console/scan.l" { CMDlval.i = lineIndex; return(rwDECLARE); } break; case 67: #line 115 "console/scan.l" { CMDlval.i = lineIndex; return(rwDATABLOCK); } break; case 68: #line 116 "console/scan.l" { CMDlval.i = lineIndex; return(rwCASE); } break; case 69: #line 117 "console/scan.l" { CMDlval.i = lineIndex; return(rwSWITCHSTR); } break; case 70: #line 118 "console/scan.l" { CMDlval.i = lineIndex; return(rwSWITCH); } break; case 71: #line 119 "console/scan.l" { CMDlval.i = lineIndex; return(rwDEFAULT); } break; case 72: #line 120 "console/scan.l" { CMDlval.i = lineIndex; return(rwPACKAGE); } break; case 73: #line 121 "console/scan.l" { CMDlval.i = 1; return INTCONST; } break; case 74: #line 122 "console/scan.l" { CMDlval.i = 0; return INTCONST; } break; case 75: #line 123 "console/scan.l" return(Sc_ScanVar()); break; case 76: #line 124 "console/scan.l" { CMDtext[CMDleng] = 0; CMDlval.s = StringTable->insert(CMDtext); return(IDENT); } break; case 77: #line 125 "console/scan.l" return(Sc_ScanHex()); break; case 78: #line 126 "console/scan.l" { CMDtext[CMDleng] = 0; CMDlval.i = atoi(CMDtext); return INTCONST; } break; case 79: #line 127 "console/scan.l" return Sc_ScanNum(); break; case 80: #line 128 "console/scan.l" return(ILLEGAL_TOKEN); break; case 81: #line 129 "console/scan.l" return(ILLEGAL_TOKEN); break; #line 472 "console/yylex.c" } YY_SCANNER; i = CMDleng; goto CMD_again; /* action fell though */ CMD_reject: YY_SCANNER; i = CMDoleng; /* restore original CMDtext */ if (++CMDfmin < CMDfmax) goto CMD_found; /* another final state, same length */ else goto CMD_search; /* try shorter CMDtext */ CMD_more: YY_SCANNER; i = CMDleng; if (i > 0) CMD_lastc = CMDtext[i-1]; goto CMD_contin; } /* * Safely switch input stream underneath LEX */ typedef struct CMD_save_block_tag { FILE * oldfp; int oldline; int oldend; int oldstart; int oldlastc; int oldleng; char savetext[YYLMAX+1]; CMD_state_t savestate[YYLMAX+1]; } YY_SAVED; void CMD_reset() { YY_INIT; CMDlineno = 1; /* line number */ } #if 0 YY_SAVED * CMDSaveScan(fp) FILE * fp; { YY_SAVED * p; if ((p = (YY_SAVED *) malloc(sizeof(*p))) == NULL) return p; p->oldfp = CMDin; p->oldline = CMDlineno; p->oldend = CMD_end; p->oldstart = CMD_start; p->oldlastc = CMD_lastc; p->oldleng = CMDleng; (void) memcpy(p->savetext, CMDtext, sizeof CMDtext); (void) memcpy((char *) p->savestate, (char *) CMD_sbuf, sizeof CMD_sbuf); CMDin = fp; CMDlineno = 1; YY_INIT; return p; } /*f * Restore previous LEX state */ void CMDRestoreScan(p) YY_SAVED * p; { if (p == NULL) return; CMDin = p->oldfp; CMDlineno = p->oldline; CMD_end = p->oldend; CMD_start = p->oldstart; CMD_lastc = p->oldlastc; CMDleng = p->oldleng; (void) memcpy(CMDtext, p->savetext, sizeof CMDtext); (void) memcpy((char *) CMD_sbuf, (char *) p->savestate, sizeof CMD_sbuf); free(p); } /* * User-callable re-initialization of CMDlex() */ /* get input char with pushback */ YY_DECL int input() { int c; #ifndef YY_PRESERVE if (CMD_end > CMDleng) { CMD_end--; memmove(CMDtext+CMDleng, CMDtext+CMDleng+1, (size_t) (CMD_end-CMDleng)); c = CMD_save; YY_USER; #else if (CMD_push < CMD_save+YYLMAX) { c = *CMD_push++; #endif } else c = CMDgetc(); CMD_lastc = c; if (c == YYNEWLINE) CMDlineno++; if (c == EOF) /* CMDgetc() can set c=EOF vsc4 wants c==EOF to return 0 */ return 0; else return c; } /*f * pushback char */ YY_DECL int unput(c) int c; { #ifndef YY_PRESERVE if (CMD_end >= YYLMAX) { YY_FATAL(m_textmsg(1552, "Push-back buffer overflow", "E")); } else { if (CMD_end > CMDleng) { CMDtext[CMDleng] = CMD_save; memmove(CMDtext+CMDleng+1, CMDtext+CMDleng, (size_t) (CMD_end-CMDleng)); CMDtext[CMDleng] = 0; } CMD_end++; CMD_save = (char) c; #else if (CMD_push <= CMD_save) { YY_FATAL(m_textmsg(1552, "Push-back buffer overflow", "E")); } else { *--CMD_push = c; #endif if (c == YYNEWLINE) CMDlineno--; } /* endif */ return c; } #endif #line 131 "console/scan.l" /* * Scan character constant. */ /* * Scan identifier. */ static const char *scanBuffer; static const char *fileName; static int scanIndex; const char * CMDGetCurrentFile() { return fileName; } int CMDGetCurrentLine() { return lineIndex; } extern bool gConsoleSyntaxError; void CMDerror(char *, ...) { gConsoleSyntaxError = true; if(fileName) { Con::errorf(ConsoleLogEntry::Script, "%s Line: %d - Syntax error.", fileName, lineIndex); char tempBuf[256]; const char *prevStr = Con::getVariable("$ScriptError"); if (prevStr[0]) dSprintf(tempBuf, sizeof(tempBuf), "%s\n%s Line: %d - Syntax error.", prevStr, fileName, lineIndex); else dSprintf(tempBuf, sizeof(tempBuf), "%s Line: %d - Syntax error.", fileName, lineIndex); Con::setVariable("$ScriptError", tempBuf); } else Con::errorf(ConsoleLogEntry::Script, "Syntax error in input."); } void SetScanBuffer(const char *sb, const char *fn) { scanBuffer = sb; fileName = fn; scanIndex = 0; lineIndex = 1; } int CMDgetc() { int ret = scanBuffer[scanIndex]; if(ret) scanIndex++; else ret = -1; return ret; } int CMDwrap() { return 1; } static int Sc_ScanVar() { CMDtext[CMDleng] = 0; CMDlval.s = StringTable->insert(CMDtext); return(VAR); } /* * Scan string constant. */ static int charConv(int in) { switch(in) { case 'r': return '\r'; case 'n': return '\n'; case 't': return '\t'; default: return in; } } static int getHexDigit(char c) { if(c >= '0' && c <= '9') return c - '0'; if(c >= 'A' && c <= 'F') return c - 'A' + 10; if(c >= 'a' && c <= 'f') return c - 'a' + 10; return -1; } static int Sc_ScanString(int ret) { CMDtext[CMDleng - 1] = 0; if(!collapseEscape(CMDtext+1)) return -1; CMDlval.str = (char *) consoleAllocator.alloc(dStrlen(CMDtext)); dStrcpy(CMDlval.str, CMDtext + 1); return(ret); } void expandEscape(char *dest, const char *src) { unsigned char c; while((c = (unsigned char) *src++) != 0) { if(c == '\"') { *dest++ = '\\'; *dest++ = '\"'; } else if(c == '\\') { *dest++ = '\\'; *dest++ = '\\'; } else if(c == '\r') { *dest++ = '\\'; *dest++ = 'r'; } else if(c == '\n') { *dest++ = '\\'; *dest++ = 'n'; } else if(c == '\t') { *dest++ = '\\'; *dest++ = 't'; } else if(c == '\'') { *dest++ = '\\'; *dest++ = '\''; } else if((c >= 2 && c <= 8) || (c >= 11 && c <= 12) || (c >= 14 && c <= 15)) { /* Remap around: \t = 0x9, \n = 0xa, \r = 0xd */ static char expandRemap[15] = { 0x0, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x0, 0x0, 0x7, 0x8, 0x0, 0x9 }; *dest++ = '\\'; *dest++ = 'c'; if(c == 15) *dest++ = 'r'; else if(c == 16) *dest++ = 'p'; else if(c == 17) *dest++ = 'o'; else *dest++ = expandRemap[c] + '0'; } else if(c < 32) { *dest++ = '\\'; *dest++ = 'x'; S32 dig1 = c >> 4; S32 dig2 = c & 0xf; if(dig1 < 10) dig1 += '0'; else dig1 += 'A' - 10; if(dig2 < 10) dig2 += '0'; else dig2 += 'A' - 10; *dest++ = dig1; *dest++ = dig2; } else *dest++ = c; } *dest = '\0'; } bool collapseEscape(char *buf) { int len = dStrlen(buf) + 1; for(int i = 0; i < len;) { if(buf[i] == '\\') { if(buf[i+1] == 'x') { int dig1 = getHexDigit(buf[i+2]); if(dig1 == -1) return false; int dig2 = getHexDigit(buf[i+3]); if(dig2 == -1) return false; buf[i] = dig1 * 16 + dig2; dMemmove(buf + i + 1, buf + i + 4, len - i - 3); len -= 3; i++; } else if(buf[i+1] == 'c') { /* Remap around: \t = 0x9, \n = 0xa, \r = 0xd */ static char collapseRemap[10] = { 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0xb, 0xc, 0xe }; if(buf[i+2] == 'r') buf[i] = 15; else if(buf[i+2] == 'p') buf[i] = 16; else if(buf[i+2] == 'o') buf[i] = 17; else { int dig1 = buf[i+2] - '0'; if(dig1 < 0 || dig1 > 9) return false; buf[i] = collapseRemap[dig1]; } dMemmove(buf + i + 1, buf + i + 3, len - i - 2); len -= 2; i++; } else { buf[i] = charConv(buf[i+1]); dMemmove(buf + i + 1, buf + i + 2, len - i - 1); len--; i++; } } else i++; } return true; } static int Sc_ScanNum() { CMDtext[CMDleng] = 0; CMDlval.f = atof(CMDtext); return(FLTCONST); } static int Sc_ScanHex() { int val = 0; dSscanf(CMDtext, "%x", &val); CMDlval.i = val; return INTCONST; }