Text   |  XML   |  ReML   |   Visible Warnings:

Unreachable Computation  at ascend-grammar.c:1913

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

ascendparse

(/home/sate/Testcases/c/cve/wireshark-1.2.0/wiretap/ascend-grammar.c)expand/collapse
Show more  
 1375  yyparse (void)
 1376  #else
 1377  int 
 1378  yyparse ()
 1379   
 1380  #endif
 1381  #endif
 1382  {
 1383     
 1384    int yystate;
 1385    int yyn;
 1386    int yyresult;
 1387    /* Number of tokens to shift before error messages enabled.  */
 1388    int yyerrstatus;
 1389    /* Look-ahead token as an internal (translated) token number.  */
 1390    int yytoken = 0;
 1391  #if YYERROR_VERBOSE 
 1392    /* Buffer for error messages, and its allocated size.  */
 1393    char yymsgbuf[128];
 1394    char *yymsg = yymsgbuf;
 1395    YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 1396  #endif
 1397   
 1398    /* Three stacks and their tools:
 1399       `yyss': related to states,
 1400       `yyvs': related to semantic values,
 1401       `yyls': related to locations.
 1402   
 1403       Refer to the stacks thru separate pointers, to allow yyoverflow 
 1404       to reallocate them elsewhere.  */
 1405   
 1406    /* The state stack.  */
 1407    yytype_int16 yyssa[YYINITDEPTH];
 1408    yytype_int16 *yyss = yyssa;
 1409    yytype_int16 *yyssp;
 1410   
 1411    /* The semantic value stack.  */
 1412    YYSTYPE yyvsa[YYINITDEPTH];
 1413    YYSTYPE *yyvs = yyvsa;
 1414    YYSTYPE *yyvsp;
 1415   
 1416   
 1417   
 1418  #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 1419   
 1420    YYSIZE_T yystacksize = YYINITDEPTH;
 1421   
 1422    /* The variables used to return semantic value and location from the 
 1423       action routines.  */
 1424    YYSTYPE yyval;
 1425   
 1426   
 1427    /* The number of symbols on the RHS of the reduced rule.
 1428       Keep to zero when no symbol should be popped.  */
 1429    int yylen = 0;
 1430   
 1431    YYDPRINTF ((stderr, "Starting parse\n"));
 1432   
 1433    yystate = 0;
 1434    yyerrstatus = 0;
 1435    yynerrs = 0;
 1436    yychar = YYEMPTY;             /* Cause a token to be read.  */
 1437   
 1438    /* Initialize stack pointers.
 1439       Waste one element of value and location stack 
 1440       so that they stay on the same level as the state stack.
 1441       The wasted elements are never initialized.  */
 1442   
 1443    yyssp = yyss;
 1444    yyvsp = yyvs;
 1445   
 1446    goto yysetstate;
 1447   
 1448  /*------------------------------------------------------------.
 1449  | yynewstate -- Push a new state, which is found in yystate.  |
 1450  `------------------------------------------------------------*/
 1451   yynewstate:
 1452    /* In all cases, when you get here, the value and location stacks 
 1453       have just been pushed.  So pushing a state here evens the stacks.  */
 1454    yyssp++;
 1455   
 1456   yysetstate:
 1457    *yyssp = yystate;
 1458   
 1459    if (yyss + yystacksize - 1 <= yyssp)
 1460      {
 1461        /* Get the current used size of the three stacks, in elements.  */
 1462        YYSIZE_T yysize = yyssp - yyss + 1;
 1463   
 1464  #ifdef yyoverflow 
 1465        {
 1466          /* Give user a chance to reallocate the stack.  Use copies of
 1467             these so that the &'s don't force the real ones into 
 1468             memory.  */
 1469          YYSTYPE *yyvs1 = yyvs;
 1470          yytype_int16 *yyss1 = yyss;
 1471   
 1472   
 1473          /* Each stack pointer address is followed by the size of the 
 1474             data in use in that stack, in bytes.  This used to be a
 1475             conditional around just the two extra args, but that might 
 1476             be undefined if yyoverflow is a macro.  */
 1477          yyoverflow (YY_("memory exhausted"),
 1478                      &yyss1, yysize * sizeof (*yyssp),
 1479                      &yyvs1, yysize * sizeof (*yyvsp),
 1480   
 1481                      &yystacksize);
 1482   
 1483          yyss = yyss1;
 1484          yyvs = yyvs1;
 1485        }
 1486  #else /* no yyoverflow */
 1487  # ifndef YYSTACK_RELOCATE
 1488        goto yyexhaustedlab;
 1489  # else 
 1490        /* Extend the stack our own way.  */
 1491        if (YYMAXDEPTH <= yystacksize)
 1492          goto yyexhaustedlab;
 1493        yystacksize *= 2;
 1494        if (YYMAXDEPTH < yystacksize)
 1495          yystacksize = YYMAXDEPTH;
 1496   
 1497        {
 1498          yytype_int16 *yyss1 = yyss;
 1499          union yyalloc *yyptr =
 1500            (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 1501          if (! yyptr)
 1502            goto yyexhaustedlab;
 1503          YYSTACK_RELOCATE (yyss);
 1504          YYSTACK_RELOCATE (yyvs);
 1505   
 1506  #  undef YYSTACK_RELOCATE 
 1507          if (yyss1 != yyssa)
 1508            YYSTACK_FREE (yyss1);
 1509        }
 1510  # endif 
 1511  #endif /* no yyoverflow */
 1512   
 1513        yyssp = yyss + yysize - 1;
 1514        yyvsp = yyvs + yysize - 1;
 1515   
 1516   
 1517        YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 1518                    (unsigned long int) yystacksize));
 1519   
 1520        if (yyss + yystacksize - 1 <= yyssp)
 1521          YYABORT;
 1522      }
 1523   
 1524    YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 1525   
 1526    goto yybackup;
 1527   
 1528  /*-----------.
 1529  | yybackup.  |
 1530  `-----------*/
 1531  yybackup:
 1532   
 1533    /* Do appropriate processing given the current state.  Read a 
 1534       look-ahead token if we need one and don't already have one.  */
 1535   
 1536    /* First try to decide what to do without reference to look-ahead token.  */
 1537    yyn = yypact[yystate];
 1538    if (yyn == YYPACT_NINF)
 1539      goto yydefault;
 1540   
 1541    /* Not known => get a look-ahead token if don't already have one.  */
 1542   
 1543    /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
 1544    if (yychar == YYEMPTY)
 1545      {
 1546        YYDPRINTF ((stderr, "Reading a token: "));
 1547        yychar = YYLEX;
 1548      }
 1549   
 1550    if (yychar <= YYEOF)
 1551      {
 1552        yychar = yytoken = YYEOF;
 1553        YYDPRINTF ((stderr, "Now at end of input.\n"));
 1554      }
 1555    else 
 1556      {
 1557        yytoken = YYTRANSLATE (yychar);
 1558        YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
 1559      }
 1560   
 1561    /* If the proper action on seeing token YYTOKEN is to reduce or to 
 1562       detect an error, take that action.  */
 1563    yyn += yytoken;
 1564    if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
 1565      goto yydefault;
 1566    yyn = yytable[yyn];
 1567    if (yyn <= 0)
 1568      {
 1569        if (yyn == 0 || yyn == YYTABLE_NINF)
 1570          goto yyerrlab;
 1571        yyn = -yyn;
 1572        goto yyreduce;
 1573      }
 1574   
 1575    if (yyn == YYFINAL)
 1576      YYACCEPT;
 1577   
 1578    /* Count tokens shifted since error; after three, turn off error 
 1579       status.  */
 1580    if (yyerrstatus)
 1581      yyerrstatus--;
 1582   
 1583    /* Shift the look-ahead token.  */
 1584    YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 1585   
 1586    /* Discard the shifted token unless it is eof.  */
 1587    if (yychar != YYEOF)
 1588      yychar = YYEMPTY;
 1589   
 1590    yystate = yyn;
 1591    *++yyvsp = yylval;
 1592   
 1593    goto yynewstate;
 1594   
 1595   
 1596  /*-----------------------------------------------------------.
 1597  | yydefault -- do the default action for the current state.  |
 1598  `-----------------------------------------------------------*/
 1599  yydefault:
 1600    yyn = yydefact[yystate];
 1601    if (yyn == 0)
 1602      goto yyerrlab;
 1603    goto yyreduce;
 1604   
 1605   
 1606  /*-----------------------------.
 1607  | yyreduce -- Do a reduction.  |
 1608  `-----------------------------*/
 1609  yyreduce:
 1610    /* yyn is the number of a rule to reduce with.  */
 1611    yylen = yyr2[yyn];
 1612   
 1613    /* If YYLEN is nonzero, implement the default value of the action:
 1614       `$$ = $1'.
 1615   
 1616       Otherwise, the following line sets YYVAL to garbage.
 1617       This behavior is undocumented and Bison 
 1618       users should not rely upon it.  Assigning to YYVAL
 1619       unconditionally makes the parser a bit smaller, and it avoids a
 1620       GCC warning that YYVAL may be used uninitialized.  */
 1621    yyval = yyvsp[1-yylen];
 1622   
 1623   
 1624    YY_REDUCE_PRINT (yyn);
 1625    switch (yyn)
 1626      {
 1627          case 18:
 1628  #line 214 "./ascend-grammar.y"
 1629      {
 1630    wirelen += (yyvsp[(11) - (13)].d);
 1631    caplen += (yyvsp[(11) - (13)].d);
 1632    secs = (yyvsp[(9) - (13)].d);
 1633    usecs = (yyvsp[(10) - (13)].d);
 1634    if (pseudo_header != NULL) {
 1635      pseudo_header->type = (yyvsp[(1) - (13)].d);
 1636      pseudo_header->sess = (yyvsp[(2) - (13)].d);
 1637      pseudo_header->call_num[0] = '\0';
 1638      pseudo_header->chunk = 0;
 1639      pseudo_header->task = (yyvsp[(7) - (13)].d);
 1640    }
 1641    /* because we have two data groups */
 1642    first_hexbyte = 0;
 1643  }
 1644      break;
 1645   
 1646    case 19:
 1647  #line 236 "./ascend-grammar.y"
 1648      {
 1649    wirelen = (yyvsp[(10) - (12)].d);
 1650    caplen = (yyvsp[(10) - (12)].d);
 1651    secs = (yyvsp[(8) - (12)].d);
 1652    usecs = (yyvsp[(9) - (12)].d);
 1653    if (pseudo_header != NULL) {
 1654      pseudo_header->type = (yyvsp[(1) - (12)].d);
 1655      pseudo_header->sess = (yyvsp[(2) - (12)].d);
 1656      pseudo_header->call_num[0] = '\0';
 1657      pseudo_header->chunk = 0;
 1658      pseudo_header->task = (yyvsp[(6) - (12)].d);
 1659    }
 1660    first_hexbyte = 0;
 1661  }
 1662      break;
 1663   
 1664    case 20:
 1665  #line 257 "./ascend-grammar.y"
 1666      {
 1667    wirelen = (yyvsp[(10) - (12)].d);
 1668    caplen = (yyvsp[(10) - (12)].d);
 1669    secs = (yyvsp[(8) - (12)].d);
 1670    usecs = (yyvsp[(9) - (12)].d);
 1671    if (pseudo_header != NULL) {
 1672      pseudo_header->type = (yyvsp[(1) - (12)].d);
 1673      pseudo_header->call_num[0] = '\0';
 1674      pseudo_header->chunk = 0;
 1675      pseudo_header->task = (yyvsp[(6) - (12)].d);
 1676    }
 1677  }
 1678      break;
 1679   
 1680    case 21:
 1681  #line 273 "./ascend-grammar.y"
 1682      {
 1683    wirelen = (yyvsp[(9) - (11)].d);
 1684    caplen = (yyvsp[(9) - (11)].d);
 1685    secs = (yyvsp[(7) - (11)].d);
 1686    usecs = (yyvsp[(8) - (11)].d);
 1687    if (pseudo_header != NULL) {
 1688      /* pseudo_header->user is set in ascend-scanner.l */
 1689      pseudo_header->type = (yyvsp[(1) - (11)].d);
 1690      pseudo_header->sess = (yyvsp[(3) - (11)].d);
 1691      pseudo_header->call_num[0] = '\0';
 1692      pseudo_header->chunk = 0;
 1693      pseudo_header->task = (yyvsp[(5) - (11)].d);
 1694    }
 1695  }
 1696      break;
 1697   
 1698    case 22:
 1699  #line 291 "./ascend-grammar.y"
 1700      {
 1701    wirelen = (yyvsp[(11) - (13)].d);
 1702    caplen = (yyvsp[(11) - (13)].d);
 1703    secs = (yyvsp[(9) - (13)].d);
 1704    usecs = (yyvsp[(10) - (13)].d);
 1705    if (pseudo_header != NULL) {
 1706      /* pseudo_header->user is set in ascend-scanner.l */
 1707      pseudo_header->type = (yyvsp[(1) - (13)].d);
 1708      pseudo_header->sess = (yyvsp[(3) - (13)].d);
 1709      pseudo_header->call_num[0] = '\0';
 1710      pseudo_header->chunk = 0;
 1711      pseudo_header->task = (yyvsp[(7) - (13)].d);
 1712    }
 1713  }
 1714      break;
 1715   
 1716    case 23:
 1717  #line 309 "./ascend-grammar.y"
 1718      {
 1719    wirelen = (yyvsp[(8) - (10)].d);
 1720    caplen = (yyvsp[(8) - (10)].d);
 1721    secs = (yyvsp[(6) - (10)].d);
 1722    usecs = (yyvsp[(7) - (10)].d);
 1723    if (pseudo_header != NULL) {
 1724      /* pseudo_header->user is set in ascend-scanner.l */
 1725      pseudo_header->type = (yyvsp[(1) - (10)].d);
 1726      pseudo_header->sess = (yyvsp[(2) - (10)].d);
 1727      pseudo_header->call_num[0] = '\0';
 1728      pseudo_header->chunk = 0;
 1729      pseudo_header->task = (yyvsp[(4) - (10)].d);
 1730    }
 1731  }
 1732      break;
 1733   
 1734    case 24:
 1735  #line 327 "./ascend-grammar.y"
 1736      {
 1737    wirelen = (yyvsp[(10) - (12)].d);
 1738    caplen = (yyvsp[(10) - (12)].d);
 1739    secs = (yyvsp[(8) - (12)].d);
 1740    usecs = (yyvsp[(9) - (12)].d);
 1741    if (pseudo_header != NULL) {
 1742      /* pseudo_header->user is set in ascend-scanner.l */
 1743      pseudo_header->type = (yyvsp[(1) - (12)].d);
 1744      pseudo_header->sess = (yyvsp[(2) - (12)].d);
 1745      pseudo_header->call_num[0] = '\0';
 1746      pseudo_header->chunk = 0;
 1747      pseudo_header->task = (yyvsp[(6) - (12)].d);
 1748    }
 1749  }
 1750      break;
 1751   
 1752    case 25:
 1753  #line 348 "./ascend-grammar.y"
 1754      {
 1755    /*
 1756     * Supply the date/time value to the code above us; it will use the
 1757     * first date/time value supplied as the capture start date/time.
 1758     */
 1759    struct tm wddt;
 1760   
 1761    wddt.tm_sec  = (yyvsp[(8) - (10)].d);
 1762    wddt.tm_min  = (yyvsp[(7) - (10)].d);
 1763    wddt.tm_hour = (yyvsp[(6) - (10)].d);
 1764    wddt.tm_mday = (yyvsp[(3) - (10)].d);
 1765    wddt.tm_mon  = (yyvsp[(2) - (10)].d) - 1;
 1766    wddt.tm_year = ((yyvsp[(4) - (10)].d) > 1970) ? (yyvsp[(4) - (10)].d) - 1900 : 70;
 1767    wddt.tm_isdst = -1;
 1768     
 1769    start_time = (guint32) mktime(&wddt);
 1770  }
 1771      break;
 1772   
 1773    case 26:
 1774  #line 372 "./ascend-grammar.y"
 1775      {
 1776    wirelen = (yyvsp[(9) - (11)].d);
 1777    caplen = (yyvsp[(9) - (11)].d);
 1778    secs = (yyvsp[(7) - (11)].d);
 1779    usecs = (yyvsp[(8) - (11)].d);
 1780    if (pseudo_header != NULL) {
 1781      /* pseudo_header->call_num is set in ascend-scanner.l */
 1782      pseudo_header->type = ASCEND_PFX_WDD;
 1783      pseudo_header->user[0] = '\0';
 1784      pseudo_header->sess = 0;
 1785      pseudo_header->chunk = (yyvsp[(2) - (11)].d);
 1786      pseudo_header->task = (yyvsp[(5) - (11)].d);
 1787    }
 1788  }
 1789      break;
 1790   
 1791    case 27:
 1792  #line 388 "./ascend-grammar.y"
 1793      {
 1794    /* remember the position of the data group in the trace, to tip
 1795       off ascend_seek() as to where to look for the next header. */
 1796    if (first_hexbyte == 0)
 1797      first_hexbyte = file_tell(*fh_ptr);
 1798   
 1799    if (bcur < caplen) {
 1800      pkt_data[bcur] = (yyvsp[(1) - (1)].b);
 1801      bcur++;
 1802    }
 1803   
 1804    /* arbitrary safety maximum... */
 1805    if (bcur >= ASCEND_MAX_PKT_LEN)
 1806      YYACCEPT;
 1807  }
 1808      break;
 1809   
 1810   
 1811  /* Line 1267 of yacc.c.  */
 1812  #line 1813 "ascend-grammar.c"
 1813        default: break;
 1814      }
 1815    YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
 1816   
 1817    YYPOPSTACK (yylen);
 1818    yylen = 0;
 1819    YY_STACK_PRINT (yyss, yyssp);
 1820   
 1821    *++yyvsp = yyval;
 1822   
 1823   
 1824    /* Now `shift' the result of the reduction.  Determine what state
 1825       that goes to, based on the state we popped back to and the rule 
 1826       number reduced by.  */
 1827   
 1828    yyn = yyr1[yyn];
 1829   
 1830    yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
 1831    if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
 1832      yystate = yytable[yystate];
 1833    else 
 1834      yystate = yydefgoto[yyn - YYNTOKENS];
 1835   
 1836    goto yynewstate;
 1837   
 1838   
 1839  /*------------------------------------.
 1840  | yyerrlab -- here on detecting error |
 1841  `------------------------------------*/
 1842  yyerrlab:
 1843    /* If not already recovering from an error, report this error.  */
 1844    if (!yyerrstatus)
 1845      {
 1846        ++yynerrs;
 1847  #if ! YYERROR_VERBOSE 
 1848        yyerror (YY_("syntax error"));
 1849  #else
 1850        {
 1851          YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
 1852          if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
 1853            {
 1854              YYSIZE_T yyalloc = 2 * yysize;
 1855              if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
 1856                yyalloc = YYSTACK_ALLOC_MAXIMUM;
 1857              if (yymsg != yymsgbuf)
 1858                YYSTACK_FREE (yymsg);
 1859
1875
Show [ Lines 1859 to 1875 omitted. ]
 1876              yyerror (YY_("syntax error"));
 1877              if (yysize != 0)
 1878                goto yyexhaustedlab;
 1879            }
 1880        }
 1881  #endif
 1882      }
 1883   
 1884   
 1885   
 1886    if (yyerrstatus == 3)
 1887      {
 1888        /* If just tried and failed to reuse look-ahead token after an 
 1889           error, discard it.  */
 1890   
 1891        if (yychar <= YYEOF)
 1892          {
 1893            /* Return failure if at end of input.  */
 1894            if (yychar == YYEOF)
 1895              YYABORT;
 1896          }
 1897        else 
 1898          {
 1899            yydestruct ("Error: discarding",
 1900                        yytoken, &yylval);
 1901            yychar = YYEMPTY;
 1902          }
 1903      }
 1904   
 1905    /* Else will try to reuse look-ahead token after shifting the error 
 1906       token.  */
 1907    goto yyerrlab1;
 1908   
 1909   
 1910  /*---------------------------------------------------.
 1911  | yyerrorlab -- error raised explicitly by YYERROR.  |
 1912  `---------------------------------------------------*/
 1913  yyerrorlab:
 1914   
 1915    /* Pacify compilers like GCC when the user code never invokes
 1916       YYERROR and the label yyerrorlab therefore never appears in user 
 1917       code.  */
 1918    if (/*CONSTCOND*/ 0)
 1919       goto yyerrorlab;
 1920   
 1921    /* Do not reclaim the symbols of the rule which action triggered 
 1922       this YYERROR.  */
 1923    YYPOPSTACK (yylen);
 1924    yylen = 0;
 1925    YY_STACK_PRINT (yyss, yyssp);
 1926    yystate = *yyssp;
 1927    goto yyerrlab1;
 1928   
 1929   
 1930  /*-------------------------------------------------------------.
 1931  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
 1932  `-------------------------------------------------------------*/
 1933  yyerrlab1:
 1934    yyerrstatus = 3;      /* Each real token shifted decrements this.  */
 1935   
 1936    for (;;)
 1937      {
 1938        yyn = yypact[yystate];
 1939        if (yyn != YYPACT_NINF)
 1940          {
 1941            yyn += YYTERROR;
 1942            if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
 1943              {
 1944                yyn = yytable[yyn];
 1945                if (0 < yyn)
 1946                  break;
 1947              }
 1948          }
 1949   
 1950        /* Pop the current state because it cannot handle the error token.  */
 1951        if (yyssp == yyss)
 1952          YYABORT;
 1953   
 1954   
 1955        yydestruct ("Error: popping",
 1956                    yystos[yystate], yyvsp);
 1957        YYPOPSTACK (1);
 1958        yystate = *yyssp;
 1959        YY_STACK_PRINT (yyss, yyssp);
 1960      }
 1961   
 1962    if (yyn == YYFINAL)
 1963      YYACCEPT;
 1964   
 1965    *++yyvsp = yylval;
 1966   
 1967   
 1968    /* Shift the error token.  */
 1969    YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 1970   
 1971    yystate = yyn;
 1972    goto yynewstate;
 1973   
 1974   
 1975  /*-------------------------------------.
 1976  | yyacceptlab -- YYACCEPT comes here.  |
 1977  `-------------------------------------*/
 1978  yyacceptlab:
 1979    yyresult = 0;
 1980    goto yyreturn;
 1981   
 1982  /*-----------------------------------.
 1983  | yyabortlab -- YYABORT comes here.  |
 1984  `-----------------------------------*/
 1985  yyabortlab:
 1986    yyresult = 1;
 1987    goto yyreturn;
 1988   
 1989  #ifndef yyoverflow 
 1990  /*-------------------------------------------------.
 1991  | yyexhaustedlab -- memory exhaustion comes here.  |
 1992  `-------------------------------------------------*/
 1993  yyexhaustedlab:
 1994    yyerror (YY_("memory exhausted"));
 1995    yyresult = 2;
 1996    /* Fall through.  */
 1997  #endif
 1998   
 1999  yyreturn:
 2000    if (yychar != YYEOF && yychar != YYEMPTY)
 2001       yydestruct ("Cleanup: discarding lookahead",
 2002                   yytoken, &yylval);
 2003    /* Do not reclaim the symbols of the rule which action triggered 
 2004       this YYABORT or YYACCEPT.  */
 2005    YYPOPSTACK (yylen);
 2006    YY_STACK_PRINT (yyss, yyssp);
 2007    while (yyssp != yyss)
 2008      {
 2009        yydestruct ("Cleanup: popping",
 2010                    yystos[*yyssp], yyvsp);
 2011        YYPOPSTACK (1);
 2012      }
 2013  #ifndef yyoverflow 
 2014    if (yyss != yyssa)
 2015      YYSTACK_FREE (yyss);
 2016  #endif
 2017  #if YYERROR_VERBOSE 
 2018    if (yymsg != yymsgbuf)
 2019      YYSTACK_FREE (yymsg);
 2020  #endif
 2021    /* Make sure YYID is used.  */
 2022    return YYID (yyresult);
 2023  }
Show more  




Change Warning 962.30602 : Unreachable Computation

Priority:
State:
Finding:
Owner:
Note: