Text   |  XML   |  ReML   |   Visible Warnings:

Unreachable Control Flow  at wimaxasncp_dict.c:1719

No properties have been set. | edit properties
Jump to warning location ↓ warning details...
Show Events | Options

WimaxasncpDictlex

(/home/sate/Testcases/c/cve/wireshark-1.2.0/plugins/wimaxasncp/wimaxasncp_dict.c)expand/collapse
Show more  
 1132  YY_DECL 
 1133  {
 1134          register yy_state_type yy_current_state;
 1135          register char *yy_cp, *yy_bp;
 1136          register int yy_act;
 1137       
 1138  #line 183 "wimaxasncp_dict.l"
 1139   
 1140  #line 1141 "wimaxasncp_dict.c"
 1141   
 1142          if ( !(yy_init) )
 1143                  {
 1144                  (yy_init) = 1;
 1145   
 1146  #ifdef YY_USER_INIT 
 1147                  YY_USER_INIT;
 1148  #endif
 1149   
 1150                  if ( ! (yy_start) )
 1151                          (yy_start) = 1; /* first start state */
 1152   
 1153                  if ( ! WimaxasncpDictin )
 1154                          WimaxasncpDictin = stdin;
 1155   
 1156                  if ( ! WimaxasncpDictout )
 1157                          WimaxasncpDictout = stdout;
 1158   
 1159                  if ( ! YY_CURRENT_BUFFER ) {
 1160                          WimaxasncpDictensure_buffer_stack ();
 1161                          YY_CURRENT_BUFFER_LVALUE =
 1162                                  WimaxasncpDict_create_buffer(WimaxasncpDictin,YY_BUF_SIZE );
 1163                  }
 1164   
 1165                  WimaxasncpDict_load_buffer_state( );
 1166                  }
 1167   
 1168          while ( 1 )             /* loops until end-of-file is reached */
 1169                  {
 1170                  yy_cp = (yy_c_buf_p);
 1171   
 1172                  /* Support of WimaxasncpDicttext. */
 1173                  *yy_cp = (yy_hold_char);
 1174   
 1175                  /* yy_bp points to the position in yy_ch_buf of the start of 
 1176                   * the current run.
 1177                   */
 1178                  yy_bp = yy_cp;
 1179   
 1180                  yy_current_state = (yy_start);
 1181  yy_match:
 1182                  do 
 1183                          {
 1184                          register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 1185                          if ( yy_accept[yy_current_state] )
 1186                                  {
 1187                                  (yy_last_accepting_state) = yy_current_state;
 1188                                  (yy_last_accepting_cpos) = yy_cp;
 1189                                  }
 1190                          while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 1191                                  {
 1192                                  yy_current_state = (int) yy_def[yy_current_state];
 1193                                  if ( yy_current_state >= 326 )
 1194                                          yy_c = yy_meta[(unsigned int) yy_c];
 1195                                  }
 1196                          yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 1197                          ++yy_cp;
 1198                          }
 1199                  while ( yy_current_state != 325 );
 1200                  yy_cp = (yy_last_accepting_cpos);
 1201                  yy_current_state = (yy_last_accepting_state);
 1202   
 1203  yy_find_action:
 1204                  yy_act = yy_accept[yy_current_state];
 1205   
 1206                  YY_DO_BEFORE_ACTION;
 1207   
 1208  do_action:      /* This label is used only to access EOF actions. */
 1209   
 1210                  switch ( yy_act )
 1211          { /* beginning of action switch */
 1212                          case 0: /* must back up */
 1213                          /* undo the effects of YY_DO_BEFORE_ACTION */
 1214                          *yy_cp = (yy_hold_char);
 1215                          yy_cp = (yy_last_accepting_cpos);
 1216                          yy_current_state = (yy_last_accepting_state);
 1217                          goto yy_find_action;
 1218   
 1219  case 1:
 1220  /* rule 1 can match eol */
 1221  YY_RULE_SETUP 
 1222  #line 184 "wimaxasncp_dict.l"
 1223  ;
 1224          YY_BREAK 
 1225  case 2:
 1226  /* rule 2 can match eol */
 1227  YY_RULE_SETUP 
 1228  #line 185 "wimaxasncp_dict.l"
 1229  ;
 1230          YY_BREAK 
 1231  case 3:
 1232  /* rule 3 can match eol */
 1233  YY_RULE_SETUP 
 1234  #line 187 "wimaxasncp_dict.l"
 1235  BEGIN LOADING_COMMENT;
 1236          YY_BREAK 
 1237  case 4:
 1238  YY_RULE_SETUP 
 1239  #line 188 "wimaxasncp_dict.l"
 1240  ;
 1241          YY_BREAK 
 1242  case 5:
 1243  /* rule 5 can match eol */
 1244  YY_RULE_SETUP 
 1245  #line 189 "wimaxasncp_dict.l"
 1246  BEGIN LOADING;
 1247          YY_BREAK 
 1248  case 6:
 1249  /* rule 6 can match eol */
 1250  YY_RULE_SETUP 
 1251  #line 191 "wimaxasncp_dict.l"
 1252  BEGIN LOADING_XMLPI;
 1253          YY_BREAK 
 1254  case 7:
 1255  /* rule 7 can match eol */
 1256  YY_RULE_SETUP 
 1257  #line 192 "wimaxasncp_dict.l"
 1258  ;
 1259          YY_BREAK 
 1260  case 8:
 1261  YY_RULE_SETUP 
 1262  #line 193 "wimaxasncp_dict.l"
 1263  {
 1264          xmlpi = g_malloc(sizeof(wimaxasncp_dict_xmlpi_t));
 1265          xmlpi->name = g_strdup(WimaxasncpDicttext);
 1266          xmlpi->key = NULL;
 1267          xmlpi->value = NULL;
 1268          xmlpi->next = NULL;
 1269   
 1270          if (!dict->xmlpis) last_xmlpi = dict->xmlpis = xmlpi;
 1271          else last_xmlpi = last_xmlpi->next = xmlpi;
 1272   
 1273          BEGIN XMLPI_ATTRS;
 1274  }
 1275          YY_BREAK 
 1276  case 9:
 1277  /* rule 9 can match eol */
 1278  YY_RULE_SETUP 
 1279  #line 206 "wimaxasncp_dict.l"
 1280  BEGIN XMLPI_GETKEY;
 1281          YY_BREAK 
 1282  case 10:
 1283  /* rule 10 can match eol */
 1284  YY_RULE_SETUP 
 1285  #line 207 "wimaxasncp_dict.l"
 1286  { xmlpi->key = g_strdup(WimaxasncpDicttext); BEGIN XMLPI_ATTRS; }
 1287          YY_BREAK 
 1288  case 11:
 1289  /* rule 11 can match eol */
 1290  YY_RULE_SETUP 
 1291  #line 209 "wimaxasncp_dict.l"
 1292  BEGIN XMLPI_GETVAL;
 1293          YY_BREAK 
 1294  case 12:
 1295  /* rule 12 can match eol */
 1296  YY_RULE_SETUP 
 1297  #line 210 "wimaxasncp_dict.l"
 1298  { xmlpi->value = g_strdup(WimaxasncpDicttext); BEGIN XMLPI_ATTRS; }
 1299          YY_BREAK 
 1300  case 13:
 1301  YY_RULE_SETUP 
 1302  #line 212 "wimaxasncp_dict.l"
 1303   
 1304          YY_BREAK 
 1305  case 14:
 1306  /* rule 14 can match eol */
 1307  YY_RULE_SETUP 
 1308  #line 213 "wimaxasncp_dict.l"
 1309  BEGIN LOADING;
 1310          YY_BREAK 
 1311  case 15:
 1312  /* rule 15 can match eol */
 1313  YY_RULE_SETUP 
 1314  #line 216 "wimaxasncp_dict.l"
 1315  BEGIN ENTITY;
 1316          YY_BREAK 
 1317  case 16:
 1318  YY_RULE_SETUP 
 1319  #line 217 "wimaxasncp_dict.l"
 1320  {
 1321          entity_t *e = g_malloc(sizeof(entity_t));
 1322          D(("ENTITY: %s\n",WimaxasncpDicttext));
 1323          e->name = g_strdup(WimaxasncpDicttext);
 1324          e->next = ents.next;
 1325          ents.next = e;
 1326          BEGIN GET_SYSTEM;
 1327  };
 1328          YY_BREAK 
 1329  case 17:
 1330  /* rule 17 can match eol */
 1331  YY_RULE_SETUP 
 1332  #line 225 "wimaxasncp_dict.l"
 1333  BEGIN GET_FILE;
 1334          YY_BREAK 
 1335  case 18:
 1336  /* rule 18 can match eol */
 1337  YY_RULE_SETUP 
 1338  #line 226 "wimaxasncp_dict.l"
 1339  {
 1340          D(("GET_FILE: %s\n",WimaxasncpDicttext));
 1341          ents.next->file = g_strdup(WimaxasncpDicttext);
 1342          BEGIN END_ENTITY;
 1343  }
 1344          YY_BREAK 
 1345  case 19:
 1346  /* rule 19 can match eol */
 1347  YY_RULE_SETUP 
 1348  #line 231 "wimaxasncp_dict.l"
 1349  BEGIN LOADING;
 1350          YY_BREAK 
 1351  case 20:
 1352  /* rule 20 can match eol */
 1353  YY_RULE_SETUP 
 1354  #line 233 "wimaxasncp_dict.l"
 1355  APPEND("<",1);
 1356          YY_BREAK 
 1357  case 21:
 1358  /* rule 21 can match eol */
 1359  YY_RULE_SETUP 
 1360  #line 235 "wimaxasncp_dict.l"
 1361  APPEND(">",1);
 1362          YY_BREAK 
 1363  case 22:
 1364  /* rule 22 can match eol */
 1365  YY_RULE_SETUP 
 1366  #line 237 "wimaxasncp_dict.l"
 1367  APPEND("/>",2);
 1368          YY_BREAK 
 1369  case 23:
 1370  /* rule 23 can match eol */
 1371  YY_RULE_SETUP 
 1372  #line 239 "wimaxasncp_dict.l"
 1373  APPEND("</",2);
 1374          YY_BREAK 
 1375  case 24:
 1376  /* rule 24 can match eol */
 1377  YY_RULE_SETUP 
 1378  #line 241 "wimaxasncp_dict.l"
 1379  APPEND(" ",1);
 1380          YY_BREAK 
 1381  case 25:
 1382  /* rule 25 can match eol */
 1383  YY_RULE_SETUP 
 1384  #line 243 "wimaxasncp_dict.l"
 1385  APPEND(WimaxasncpDicttext,WimaxasncpDictleng);
 1386          YY_BREAK 
 1387  case 26:
 1388  /* rule 26 can match eol */
 1389  YY_RULE_SETUP 
 1390  #line 245 "wimaxasncp_dict.l"
 1391  APPEND("=",1);
 1392          YY_BREAK 
 1393  case 27:
 1394  YY_RULE_SETUP 
 1395  #line 247 "wimaxasncp_dict.l"
 1396  APPEND(WimaxasncpDicttext,WimaxasncpDictleng);
 1397          YY_BREAK 
 1398  case 28:
 1399  YY_RULE_SETUP 
 1400  #line 249 "wimaxasncp_dict.l"
 1401  {
 1402          gchar *p = ++WimaxasncpDicttext, *temp_str;
 1403          entity_t* e;
 1404   
 1405          while(*p != ';') p++;
 1406   
 1407          *p = '\0';
 1408   
 1409          D(("looking for entity: %s\n",WimaxasncpDicttext));
 1410   
 1411          if ( include_stack_ptr >= MAX_INCLUDE_DEPTH ) {
 1412                  dict_error = g_string_append(
 1413                          dict_error, "included files nested too deeply\n");
 1414                  yyterminate();
 1415          }
 1416   
 1417          include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
 1418   
 1419   
 1420          for (e = ents.next; e; e = e->next) {
 1421                  if (strcmp(e->name,WimaxasncpDicttext) == 0) {
 1422                          WimaxasncpDictin = wimaxasncp_dict_open(sys_dir,e->file);
 1423                          D(("entity: %s filename: %s WimaxasncpDictin: %p\n",e->name,e->file,WimaxasncpDictin));
 1424                          if (!WimaxasncpDictin) {
 1425                                  yyterminate();
 1426                          } else {
 1427                                  WimaxasncpDict_switch_to_buffer(WimaxasncpDict_create_buffer(WimaxasncpDictin,YY_BUF_SIZE ) );
 1428                          }
 1429                          break;
 1430                  }
 1431          }
 1432   
 1433          if (!e) {
 1434                  temp_str = g_strdup_printf(
 1435                          "cannot find entity: '%s'\n", e->name);
 1436                  dict_error = g_string_append(dict_error, temp_str);
 1437                  g_free(temp_str);
 1438                  yyterminate();
 1439          }
 1440   
 1441  }
 1442          YY_BREAK 
 1443  case YY_STATE_EOF(INITIAL):
 1444  case YY_STATE_EOF(LOADING):
 1445  case YY_STATE_EOF(LOADING_COMMENT):
 1446  case YY_STATE_EOF(LOADING_XMLPI):
 1447  case YY_STATE_EOF(ENTITY):
 1448  case YY_STATE_EOF(GET_SYSTEM):
 1449  case YY_STATE_EOF(GET_FILE):
 1450  case YY_STATE_EOF(END_ENTITY):
 1451  case YY_STATE_EOF(GET_ATTR):
 1452  case YY_STATE_EOF(GET_UINT_ATTR):
 1453  case YY_STATE_EOF(GET_UINT16_ATTR):
 1454  case YY_STATE_EOF(BIT32):
 1455  case YY_STATE_EOF(BIT16):
 1456  case YY_STATE_EOF(BIT8):
 1457  case YY_STATE_EOF(GET_DECODER_ATTR):
 1458  case YY_STATE_EOF(END_ATTR):
 1459  case YY_STATE_EOF(OUTSIDE):
 1460  case YY_STATE_EOF(IN_DICT):
 1461  case YY_STATE_EOF(IN_APPL):
 1462  case YY_STATE_EOF(IN_TLV):
 1463  case YY_STATE_EOF(IGNORE_ATTR):
 1464  case YY_STATE_EOF(ENUM_ATTRS):
 1465  case YY_STATE_EOF(TLV_ATTRS):
 1466  case YY_STATE_EOF(XMLPI_ATTRS):
 1467  case YY_STATE_EOF(XMLPI_GETKEY):
 1468  case YY_STATE_EOF(XMLPI_GETVAL):
 1469  case YY_STATE_EOF(XMLPI_ENDATTR):
 1470  #line 291 "wimaxasncp_dict.l"
 1471  {
 1472          if (!WimaxasncpDictin) yyterminate();
 1473   
 1474          fclose(WimaxasncpDictin);
 1475          D(("closing: %p %i\n",WimaxasncpDictin,include_stack_ptr));
 1476   
 1477          if ( --include_stack_ptr < 0 ) {
 1478                  D(("DONE READING\n"));
 1479                  WimaxasncpDictin = NULL;
 1480                  yyterminate();
 1481          } else {
 1482                  WimaxasncpDict_delete_buffer(YY_CURRENT_BUFFER );
 1483                  WimaxasncpDict_switch_to_buffer(include_stack[include_stack_ptr]);
 1484                  BEGIN LOADING;
 1485          }
 1486  }
 1487          YY_BREAK 
 1488  case 29:
 1489  /* rule 29 can match eol */
 1490  YY_RULE_SETUP 
 1491  #line 309 "wimaxasncp_dict.l"
 1492  {
 1493          *attr_str = g_strdup(WimaxasncpDicttext);
 1494          D(("%s\n",WimaxasncpDicttext));
 1495          attr_str = NULL;
 1496          BEGIN END_ATTR;
 1497  }
 1498          YY_BREAK 
 1499  case 30:
 1500  YY_RULE_SETUP 
 1501  #line 316 "wimaxasncp_dict.l"
 1502  {
 1503          *attr_uint = strtoul(WimaxasncpDicttext,NULL,0);
 1504          D(("%s\n",WimaxasncpDicttext););
 1505          attr_uint = NULL;
 1506          BEGIN END_ATTR;
 1507  }
 1508          YY_BREAK 
 1509  case 31:
 1510  YY_RULE_SETUP 
 1511  #line 323 "wimaxasncp_dict.l"
 1512  {
 1513          *attr_uint16 = (gint16) strtol(WimaxasncpDicttext,NULL,0);
 1514          D(("%s\n",WimaxasncpDicttext););
 1515          attr_uint16 = NULL;
 1516          BEGIN END_ATTR;
 1517  }
 1518          YY_BREAK 
 1519  case 32:
 1520  YY_RULE_SETUP 
 1521  #line 330 "wimaxasncp_dict.l"
 1522  { BEGIN BIT32; }
 1523          YY_BREAK 
 1524  case 33:
 1525  YY_RULE_SETUP 
 1526  #line 332 "wimaxasncp_dict.l"
 1527  {
 1528          *attr_uint = wimaxasncp_bits(32, WimaxasncpDicttext);
 1529          D(("WIMAXASNCP_BIT32(%s)\n",WimaxasncpDicttext););
 1530          attr_uint = NULL;
 1531  }
 1532          YY_BREAK 
 1533  case 34:
 1534  YY_RULE_SETUP 
 1535  #line 338 "wimaxasncp_dict.l"
 1536  { BEGIN BIT16; }
 1537          YY_BREAK 
 1538  case 35:
 1539  YY_RULE_SETUP 
 1540  #line 340 "wimaxasncp_dict.l"
 1541  {
 1542          *attr_uint = wimaxasncp_bits(16, WimaxasncpDicttext);
 1543          D(("WIMAXASNCP_BIT16(%s)\n",WimaxasncpDicttext););
 1544          attr_uint = NULL;
 1545  }
 1546          YY_BREAK 
 1547  case 36:
 1548  YY_RULE_SETUP 
 1549  #line 346 "wimaxasncp_dict.l"
 1550  { BEGIN BIT8; }
 1551          YY_BREAK 
 1552  case 37:
 1553  YY_RULE_SETUP 
 1554  #line 348 "wimaxasncp_dict.l"
 1555  {
 1556          *attr_uint = wimaxasncp_bits(8, WimaxasncpDicttext);
 1557          D(("WIMAXASNCP_BIT8(%s)\n",WimaxasncpDicttext););
 1558          attr_uint = NULL;
 1559  }
 1560          YY_BREAK 
 1561  case 38:
 1562  YY_RULE_SETUP 
 1563  #line 354 "wimaxasncp_dict.l"
 1564  { BEGIN END_ATTR; }
 1565          YY_BREAK 
 1566  case 39:
 1567  /* rule 39 can match eol */
 1568  YY_RULE_SETUP 
 1569  #line 356 "wimaxasncp_dict.l"
 1570  {
 1571          *attr_uint = wimaxasncp_decode_type(WimaxasncpDicttext);
 1572          D(("%s\n",WimaxasncpDicttext));
 1573          attr_uint = NULL;
 1574          BEGIN END_ATTR;
 1575  }
 1576          YY_BREAK 
 1577  case 40:
 1578  YY_RULE_SETUP 
 1579  #line 363 "wimaxasncp_dict.l"
 1580  {       yy_pop_state(); }
 1581          YY_BREAK 
 1582  case 41:
 1583  YY_RULE_SETUP 
 1584  #line 365 "wimaxasncp_dict.l"
 1585  {
 1586          /* XXX: should go?*/
 1587          D(("{%s}",WimaxasncpDicttext));
 1588  }
 1589          YY_BREAK 
 1590  case 42:
 1591  /* rule 42 can match eol */
 1592  YY_RULE_SETUP 
 1593  #line 370 "wimaxasncp_dict.l"
 1594  {
 1595          D(("=>%s<=\n",WimaxasncpDicttext));
 1596          yy_pop_state();
 1597  }
 1598          YY_BREAK 
 1599  case 43:
 1600  YY_RULE_SETUP 
 1601  #line 375 "wimaxasncp_dict.l"
 1602  {
 1603          D(("dictionary_start\n"));
 1604   
 1605          BEGIN IN_DICT;
 1606  }
 1607          YY_BREAK 
 1608  case 44:
 1609  YY_RULE_SETUP 
 1610  #line 381 "wimaxasncp_dict.l"
 1611  {
 1612          D(("tlv_start\n"));
 1613   
 1614          tlv = g_malloc(sizeof(wimaxasncp_dict_tlv_t));
 1615          tlv->type = 0;
 1616          tlv->name = NULL;
 1617          tlv->description = NULL;
 1618          tlv->decoder = 0;
 1619          tlv->hf_root = -1;
 1620          tlv->hf_value = -1;
 1621          tlv->hf_ipv4 = -1;
 1622          tlv->hf_ipv6 = -1;
 1623          tlv->hf_bsid = -1;
 1624          tlv->hf_protocol = -1;
 1625          tlv->hf_port_low = -1;
 1626          tlv->hf_port_high = -1;
 1627          tlv->hf_ipv4_mask = -1;
 1628          tlv->hf_ipv6_mask = -1;
 1629          tlv->hf_vendor_id = -1;
 1630          tlv->hf_vendor_rest_of_info = -1;
 1631          tlv->enum_vs = NULL;
 1632          tlv->enums = NULL;
 1633          tlv->next = NULL;
 1634   
 1635          if (! dict->tlvs ) last_tlv = dict->tlvs = tlv;
 1636          else last_tlv = last_tlv->next = tlv;
 1637   
 1638          BEGIN TLV_ATTRS;
 1639  }
 1640          YY_BREAK 
 1641  case 45:
 1642  YY_RULE_SETUP 
 1643  #line 411 "wimaxasncp_dict.l"
 1644  { ATTR_STR(tlv->name); }
 1645          YY_BREAK 
 1646  case 46:
 1647  YY_RULE_SETUP 
 1648  #line 412 "wimaxasncp_dict.l"
 1649  { ATTR_STR(tlv->description); }
 1650          YY_BREAK 
 1651  case 47:
 1652  YY_RULE_SETUP 
 1653  #line 413 "wimaxasncp_dict.l"
 1654  { ATTR_UINT16(tlv->type); }
 1655          YY_BREAK 
 1656  case 48:
 1657  YY_RULE_SETUP 
 1658  #line 414 "wimaxasncp_dict.l"
 1659  { ATTR_DECODER(tlv->decoder); }
 1660          YY_BREAK 
 1661  case 49:
 1662  YY_RULE_SETUP 
 1663  #line 415 "wimaxasncp_dict.l"
 1664  { BEGIN IN_TLV;  }
 1665          YY_BREAK 
 1666  case 50:
 1667  YY_RULE_SETUP 
 1668  #line 416 "wimaxasncp_dict.l"
 1669  { BEGIN IN_DICT; }
 1670          YY_BREAK 
 1671  case 51:
 1672  YY_RULE_SETUP 
 1673  #line 419 "wimaxasncp_dict.l"
 1674  {
 1675          D(("enum_start\n"));
 1676   
 1677          enumitem = g_malloc(sizeof(wimaxasncp_dict_enum_t));
 1678          enumitem->name = NULL;
 1679          enumitem->code = 0;
 1680          enumitem->next = NULL;
 1681   
 1682          if (!tlv->enums) last_enumitem = tlv->enums = enumitem;
 1683          else last_enumitem = last_enumitem->next = enumitem;
 1684   
 1685          BEGIN ENUM_ATTRS;
 1686  }
 1687          YY_BREAK 
 1688  case 52:
 1689  YY_RULE_SETUP 
 1690  #line 434 "wimaxasncp_dict.l"
 1691  { ATTR_STR(enumitem->name); }
 1692          YY_BREAK 
 1693  case 53:
 1694  YY_RULE_SETUP 
 1695  #line 435 "wimaxasncp_dict.l"
 1696  { ATTR_UINT(enumitem->code); }
 1697          YY_BREAK 
 1698  case 54:
 1699  YY_RULE_SETUP 
 1700  #line 437 "wimaxasncp_dict.l"
 1701  { BEGIN IN_TLV; }
 1702          YY_BREAK 
 1703  case 55:
 1704  YY_RULE_SETUP 
 1705  #line 438 "wimaxasncp_dict.l"
 1706  { BEGIN IN_TLV; }
 1707          YY_BREAK 
 1708  case 56:
 1709  YY_RULE_SETUP 
 1710  #line 440 "wimaxasncp_dict.l"
 1711  { D(("tlv_end")); BEGIN IN_DICT; }
 1712          YY_BREAK 
 1713  case 57:
 1714  YY_RULE_SETUP 
 1715  #line 442 "wimaxasncp_dict.l"
 1716  {
 1717          yyterminate();
 1718  }
 1719          YY_BREAK 
 1720  case 58:
 1721  YY_RULE_SETUP 
 1722  #line 446 "wimaxasncp_dict.l"
 1723  WIMAXASNCP_IGNORE();
 1724          YY_BREAK 
 1725  case 59:
 1726  YY_RULE_SETUP 
 1727  #line 448 "wimaxasncp_dict.l"
 1728  ;
 1729          YY_BREAK 
 1730  case 60:
 1731  YY_RULE_SETUP 
 1732  #line 455 "wimaxasncp_dict.l"
 1733  ECHO;
 1734          YY_BREAK 
 1735  #line 1736 "wimaxasncp_dict.c"
 1736   
 1737          case YY_END_OF_BUFFER:
 1738                  {
 1739                  /* Amount of text matched not including the EOB char. */
 1740                  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 1741   
 1742                  /* Undo the effects of YY_DO_BEFORE_ACTION. */
 1743                  *yy_cp = (yy_hold_char);
 1744                  YY_RESTORE_YY_MORE_OFFSET 
 1745   
 1746                  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 1747                          {
 1748                          /* We're scanning a new file or input source.  It's
 1749                           * possible that this happened because the user 
 1750                           * just pointed WimaxasncpDictin at a new source and called 
 1751                           * WimaxasncpDictlex().  If so, then we have to assure 
 1752                           * consistency between YY_CURRENT_BUFFER and our 
 1753                           * globals.  Here is the right place to do so, because 
 1754                           * this is the first action (other than possibly a 
 1755                           * back-up) that will match for the new input source.
 1756                           */
 1757                          (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 1758                          YY_CURRENT_BUFFER_LVALUE->yy_input_file = WimaxasncpDictin;
 1759                          YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 1760                          }
 1761   
 1762                  /* Note that here we test for yy_c_buf_p "<=" to the position 
 1763                   * of the first EOB in the buffer, since yy_c_buf_p will 
 1764                   * already have been incremented past the NUL character
 1765                   * (since all states make transitions on EOB to the
 1766                   * end-of-buffer state).  Contrast this with the test
 1767                   * in input().
 1768                   */
 1769                  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
 1770                          { /* This was really a NUL. */
 1771                          yy_state_type yy_next_state;
 1772   
 1773                          (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 1774   
 1775                          yy_current_state = yy_get_previous_state(  );
 1776   
 1777                          /* Okay, we're now positioned to make the NUL
 1778                           * transition.  We couldn't have 
 1779                           * yy_get_previous_state() go ahead and do it 
 1780                           * for us because it doesn't know how to deal
 1781                           * with the possibility of jamming (and we don't
 1782                           * want to build jamming into it because then it 
 1783                           * will run more slowly).
 1784                           */
 1785   
 1786                          yy_next_state = yy_try_NUL_trans( yy_current_state );
 1787   
 1788                          yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 1789   
 1790                          if ( yy_next_state )
 1791                                  {
 1792                                  /* Consume the NUL. */
 1793                                  yy_cp = ++(yy_c_buf_p);
 1794                                  yy_current_state = yy_next_state;
 1795                                  goto yy_match;
 1796                                  }
 1797   
 1798                          else 
 1799                                  {
 1800                                  yy_cp = (yy_last_accepting_cpos);
 1801                                  yy_current_state = (yy_last_accepting_state);
 1802                                  goto yy_find_action;
 1803                                  }
 1804                          }
 1805   
 1806                  else switch ( yy_get_next_buffer(  ) )
 1807                          {
 1808                          case EOB_ACT_END_OF_FILE:
 1809                                  {
 1810                                  (yy_did_buffer_switch_on_eof) = 0;
 1811   
 1812                                  if ( WimaxasncpDictwrap( ) )
 1813                                          {
 1814                                          /* Note: because we've taken care in 
 1815                                           * yy_get_next_buffer() to have set up
 1816                                           * WimaxasncpDicttext, we can now set up 
 1817                                           * yy_c_buf_p so that if some total
 1818                                           * hoser (like flex itself) wants to
 1819                                           * call the scanner after we return the 
 1820                                           * YY_NULL, it'll still work - another 
 1821                                           * YY_NULL will get returned.
 1822                                           */
 1823                                          (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 1824   
 1825                                          yy_act = YY_STATE_EOF(YY_START);
 1826                                          goto do_action;
 1827                                          }
 1828   
 1829                                  else 
 1830                                          {
 1831                                          if ( ! (yy_did_buffer_switch_on_eof) )
 1832                                                  YY_NEW_FILE;
 1833                                          }
 1834                                  break;
 1835                                  }
 1836   
 1837                          case EOB_ACT_CONTINUE_SCAN:
 1838                                  (yy_c_buf_p) =
 1839                                          (yytext_ptr) + yy_amount_of_matched_text;
 1840   
 1841                                  yy_current_state = yy_get_previous_state(  );
 1842   
 1843                                  yy_cp = (yy_c_buf_p);
 1844                                  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 1845                                  goto yy_match;
 1846   
 1847                          case EOB_ACT_LAST_MATCH:
 1848                                  (yy_c_buf_p) =
 1849                                  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 1850   
 1851                                  yy_current_state = yy_get_previous_state(  );
 1852   
 1853                                  yy_cp = (yy_c_buf_p);
 1854                                  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 1855                                  goto yy_find_action;
 1856                          }
 1857                  break;
 1858                  }
 1859   
 1860          default:
 1861                  YY_FATAL_ERROR(
 1862                          "fatal flex scanner internal error--no action found" );
 1863          } /* end of action switch */
 1864                  } /* end of scanning one token */
 1865  } /* end of WimaxasncpDictlex */
Show more  




Change Warning 3929.30369 : Unreachable Control Flow

Priority:
State:
Finding:
Owner:
Note: