dlog: 40| 606|void dlog(int level, int flevel, char const *fmt, ...) {} LLVMFuzzerTestOneInput: 48| 606|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 49| 606| char filename[] = "/tmp/fuzz-config-XXXXXX"; 50| 606| int fd = mkstemp(filename); 51| 606| if (fd < 0) { ------------------ | Branch (51:9): [True: 0, False: 606] ------------------ 52| 0| return 0; 53| 0| } 54| 606| write(fd, data, size); 55| 606| close(fd); 56| | 57| 606| struct Interface *ifaces = readin_config(filename); 58| | 59| 606| if (ifaces) { ------------------ | Branch (59:9): [True: 0, False: 606] ------------------ 60| 0| free_ifaces(ifaces); 61| 0| } 62| | 63| 606| unlink(filename); 64| 606| return 0; 65| 606|} yyparse: 1451| 606|{ 1452| 606| yy_state_fast_t yystate = 0; 1453| | /* Number of tokens to shift before error messages enabled. */ 1454| 606| int yyerrstatus = 0; 1455| | 1456| | /* Refer to the stacks through separate pointers, to allow yyoverflow 1457| | to reallocate them elsewhere. */ 1458| | 1459| | /* Their size. */ 1460| 606| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 583| 606|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 1396| 606|# define YYINITDEPTH 200 ------------------ 1461| | 1462| | /* The state stack: array, bottom, top. */ 1463| 606| yy_state_t yyssa[YYINITDEPTH]; 1464| 606| yy_state_t *yyss = yyssa; 1465| 606| yy_state_t *yyssp = yyss; 1466| | 1467| | /* The semantic value stack: array, bottom, top. */ 1468| 606| YYSTYPE yyvsa[YYINITDEPTH]; 1469| 606| YYSTYPE *yyvs = yyvsa; 1470| 606| YYSTYPE *yyvsp = yyvs; 1471| | 1472| 606| int yyn; 1473| | /* The return value of yyparse. */ 1474| 606| int yyresult; 1475| | /* Lookahead symbol kind. */ 1476| 606| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1477| | /* The variables used to return semantic value and location from the 1478| | action routines. */ 1479| 606| YYSTYPE yyval; 1480| | 1481| | 1482| | 1483| 606|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1484| | 1485| | /* The number of symbols on the RHS of the reduced rule. 1486| | Keep to zero when no symbol should be popped. */ 1487| 606| int yylen = 0; 1488| | 1489| 606| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 1387| 606|# define YYDPRINTF(Args) ((void) 0) ------------------ 1490| | 1491| 606| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 227| 606|#define YYEMPTY -2 ------------------ 1492| | 1493| 606| goto yysetstate; 1494| | 1495| | 1496| |/*------------------------------------------------------------. 1497| || yynewstate -- push a new state, which is found in yystate. | 1498| |`------------------------------------------------------------*/ 1499| 0|yynewstate: 1500| | /* In all cases, when you get here, the value and location stacks 1501| | have just been pushed. So pushing a state here evens the stacks. */ 1502| 0| yyssp++; 1503| | 1504| | 1505| |/*--------------------------------------------------------------------. 1506| || yysetstate -- set current state (the top of the stack) to yystate. | 1507| |`--------------------------------------------------------------------*/ 1508| 606|yysetstate: 1509| 606| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 1387| 606|# define YYDPRINTF(Args) ((void) 0) ------------------ 1510| 606| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 699| 606|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (699:31): [Folded, False: 606] | | | Branch (699:37): [True: 0, False: 0] | | | Branch (699:37): [True: 0, False: 0] | | ------------------ ------------------ 1511| 606| YY_IGNORE_USELESS_CAST_BEGIN 1512| 606| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 112| 606|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1513| 606| YY_IGNORE_USELESS_CAST_END 1514| 606| YY_STACK_PRINT (yyss, yyssp); 1515| | 1516| 606| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1516:7): [True: 0, False: 606] ------------------ 1517| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1518| | YYNOMEM; 1519| |#else 1520| 0| { 1521| | /* Get the current used size of the three stacks, in elements. */ 1522| 0| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 583| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1523| | 1524| |# if defined yyoverflow 1525| | { 1526| | /* Give user a chance to reallocate the stack. Use copies of 1527| | these so that the &'s don't force the real ones into 1528| | memory. */ 1529| | yy_state_t *yyss1 = yyss; 1530| | YYSTYPE *yyvs1 = yyvs; 1531| | 1532| | /* Each stack pointer address is followed by the size of the 1533| | data in use in that stack, in bytes. This used to be a 1534| | conditional around just the two extra args, but that might 1535| | be undefined if yyoverflow is a macro. */ 1536| | yyoverflow (YY_("memory exhausted"), 1537| | &yyss1, yysize * YYSIZEOF (*yyssp), 1538| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 1539| | &yystacksize); 1540| | yyss = yyss1; 1541| | yyvs = yyvs1; 1542| | } 1543| |# else /* defined YYSTACK_RELOCATE */ 1544| | /* Extend the stack our own way. */ 1545| 0| if (YYMAXDEPTH <= yystacksize) ------------------ | | 1407| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1545:11): [True: 0, False: 0] ------------------ 1546| 0| YYNOMEM; ------------------ | | 1240| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 1547| 0| yystacksize *= 2; 1548| 0| if (YYMAXDEPTH < yystacksize) ------------------ | | 1407| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1548:11): [True: 0, False: 0] ------------------ 1549| 0| yystacksize = YYMAXDEPTH; ------------------ | | 1407| 0|# define YYMAXDEPTH 10000 ------------------ 1550| | 1551| 0| { 1552| 0| yy_state_t *yyss1 = yyss; 1553| 0| union yyalloc *yyptr = 1554| 0| YY_CAST (union yyalloc *, ------------------ | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1555| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1556| 0| if (! yyptr) ------------------ | Branch (1556:13): [True: 0, False: 0] ------------------ 1557| 0| YYNOMEM; ------------------ | | 1240| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 1558| 0| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 796| 0| do \ | | 797| 0| { \ | | 798| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 583| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 799| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 814| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 800| 0| Stack = &yyptr->Stack_alloc; \ | | 801| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 616| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 780| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 616| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 802| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 616| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 803| 0| } \ | | 804| 0| while (0) | | ------------------ | | | Branch (804:12): [Folded, False: 0] | | ------------------ ------------------ 1559| 0| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 796| 0| do \ | | 797| 0| { \ | | 798| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 583| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 799| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 814| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 800| 0| Stack = &yyptr->Stack_alloc; \ | | 801| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 616| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 780| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 616| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 802| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 616| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 803| 0| } \ | | 804| 0| while (0) | | ------------------ | | | Branch (804:12): [Folded, False: 0] | | ------------------ ------------------ 1560| 0|# undef YYSTACK_RELOCATE 1561| 0| if (yyss1 != yyssa) ------------------ | Branch (1561:13): [True: 0, False: 0] ------------------ 1562| 0| YYSTACK_FREE (yyss1); ------------------ | | 741| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 760| 0|# define YYFREE free | | ------------------ ------------------ 1563| 0| } 1564| 0|# endif 1565| | 1566| 0| yyssp = yyss + yysize - 1; 1567| 0| yyvsp = yyvs + yysize - 1; 1568| | 1569| 0| YY_IGNORE_USELESS_CAST_BEGIN 1570| 0| YYDPRINTF ((stderr, "Stack size increased to %ld\n", ------------------ | | 1387| 0|# define YYDPRINTF(Args) ((void) 0) ------------------ 1571| 0| YY_CAST (long, yystacksize))); 1572| 0| YY_IGNORE_USELESS_CAST_END 1573| | 1574| 0| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1574:11): [True: 0, False: 0] ------------------ 1575| 0| YYABORT; ------------------ | | 1238| 0|#define YYABORT goto yyabortlab ------------------ 1576| 0| } 1577| 606|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1578| | 1579| | 1580| 606| if (yystate == YYFINAL) ------------------ | | 829| 606|#define YYFINAL 7 ------------------ | Branch (1580:7): [True: 0, False: 606] ------------------ 1581| 0| YYACCEPT; ------------------ | | 1237| 0|#define YYACCEPT goto yyacceptlab ------------------ 1582| | 1583| 606| goto yybackup; 1584| | 1585| | 1586| |/*-----------. 1587| || yybackup. | 1588| |`-----------*/ 1589| 606|yybackup: 1590| | /* Do appropriate processing given the current state. Read a 1591| | lookahead token if we need one and don't already have one. */ 1592| | 1593| | /* First try to decide what to do without reference to lookahead token. */ 1594| 606| yyn = yypact[yystate]; 1595| 606| if (yypact_value_is_default (yyn)) ------------------ | | 976| 606| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 973| 606|#define YYPACT_NINF (-92) | | ------------------ | | | Branch (976:3): [True: 0, False: 606] | | ------------------ ------------------ 1596| 0| goto yydefault; 1597| | 1598| | /* Not known => get a lookahead token if don't already have one. */ 1599| | 1600| | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 1601| 606| if (yychar == YYEMPTY) ------------------ | | 227| 606|#define YYEMPTY -2 ------------------ | Branch (1601:7): [True: 606, False: 0] ------------------ 1602| 606| { 1603| 606| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 1387| 606|# define YYDPRINTF(Args) ((void) 0) ------------------ 1604| 606| yychar = yylex (); 1605| 606| } 1606| | 1607| 606| if (yychar <= YYEOF) ------------------ | | 228| 606|#define YYEOF 0 ------------------ | Branch (1607:7): [True: 53, False: 553] ------------------ 1608| 53| { 1609| 53| yychar = YYEOF; ------------------ | | 228| 53|#define YYEOF 0 ------------------ 1610| 53| yytoken = YYSYMBOL_YYEOF; 1611| 53| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 1387| 53|# define YYDPRINTF(Args) ((void) 0) ------------------ 1612| 53| } 1613| 553| else if (yychar == YYerror) ------------------ | | 229| 553|#define YYerror 256 ------------------ | Branch (1613:12): [True: 0, False: 553] ------------------ 1614| 0| { 1615| | /* The scanner already issued an error message, process directly 1616| | to error recovery. But do not keep the error token as 1617| | lookahead, it is too special and may lead us to an endless 1618| | loop in error recovery. */ 1619| 0| yychar = YYUNDEF; ------------------ | | 230| 0|#define YYUNDEF 257 ------------------ 1620| 0| yytoken = YYSYMBOL_YYerror; 1621| 0| goto yyerrlab1; 1622| 0| } 1623| 553| else 1624| 553| { 1625| 553| yytoken = YYTRANSLATE (yychar); ------------------ | | 849| 553| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 843| 553|#define YYMAXUTOK 331 | | ------------------ | | | Branch (849:4): [True: 553, False: 0] | | | Branch (849:18): [True: 553, False: 0] | | ------------------ | | 850| 553| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 112| 553|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 851| 553| : YYSYMBOL_YYUNDEF) ------------------ 1626| 553| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1627| 553| } 1628| | 1629| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1630| | detect an error, take that action. */ 1631| 606| yyn += yytoken; 1632| 606| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 831| 606|#define YYLAST 298 ------------------ | Branch (1632:7): [True: 0, False: 606] | Branch (1632:18): [True: 0, False: 606] | Branch (1632:34): [True: 606, False: 0] ------------------ 1633| 606| goto yydefault; 1634| 0| yyn = yytable[yyn]; 1635| 0| if (yyn <= 0) ------------------ | Branch (1635:7): [True: 0, False: 0] ------------------ 1636| 0| { 1637| 0| if (yytable_value_is_error (yyn)) ------------------ | | 981| 0| 0 | | ------------------ | | | Branch (981:3): [Folded, False: 0] | | ------------------ ------------------ 1638| 0| goto yyerrlab; 1639| 0| yyn = -yyn; 1640| 0| goto yyreduce; 1641| 0| } 1642| | 1643| | /* Count tokens shifted since error; after three, turn off error 1644| | status. */ 1645| 0| if (yyerrstatus) ------------------ | Branch (1645:7): [True: 0, False: 0] ------------------ 1646| 0| yyerrstatus--; 1647| | 1648| | /* Shift the lookahead token. */ 1649| 0| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1650| 0| yystate = yyn; 1651| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1652| 0| *++yyvsp = yylval; 1653| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 1654| | 1655| | /* Discard the shifted token. */ 1656| 0| yychar = YYEMPTY; ------------------ | | 227| 0|#define YYEMPTY -2 ------------------ 1657| 0| goto yynewstate; 1658| | 1659| | 1660| |/*-----------------------------------------------------------. 1661| || yydefault -- do the default action for the current state. | 1662| |`-----------------------------------------------------------*/ 1663| 606|yydefault: 1664| 606| yyn = yydefact[yystate]; 1665| 606| if (yyn == 0) ------------------ | Branch (1665:7): [True: 606, False: 0] ------------------ 1666| 606| goto yyerrlab; 1667| 0| goto yyreduce; 1668| | 1669| | 1670| |/*-----------------------------. 1671| || yyreduce -- do a reduction. | 1672| |`-----------------------------*/ 1673| 0|yyreduce: 1674| | /* yyn is the number of a rule to reduce with. */ 1675| 0| yylen = yyr2[yyn]; 1676| | 1677| | /* If YYLEN is nonzero, implement the default value of the action: 1678| | '$$ = $1'. 1679| | 1680| | Otherwise, the following line sets YYVAL to garbage. 1681| | This behavior is undocumented and Bison 1682| | users should not rely upon it. Assigning to YYVAL 1683| | unconditionally makes the parser a bit smaller, and it avoids a 1684| | GCC warning that YYVAL may be used uninitialized. */ 1685| 0| yyval = yyvsp[1-yylen]; 1686| | 1687| | 1688| 0| YY_REDUCE_PRINT (yyn); 1689| 0| switch (yyn) 1690| 0| { 1691| 0| case 4: /* ifacedef: ifacehead '{' ifaceparams '}' ';' */ ------------------ | Branch (1691:3): [True: 0, False: 0] ------------------ 1692| 0|#line 194 "gram.y" 1693| 0| { 1694| 0| dlog(LOG_DEBUG, 4, "%s interface definition ok", iface->props.name); 1695| | 1696| 0| iface->next = IfaceList; 1697| 0| IfaceList = iface; 1698| | 1699| 0| iface = NULL; 1700| 0| } 1701| 0|#line 1702 "gram.c" 1702| 0| break; 1703| | 1704| 0| case 5: /* ifacehead: T_INTERFACE name */ ------------------ | Branch (1704:3): [True: 0, False: 0] ------------------ 1705| 0|#line 204 "gram.y" 1706| 0| { 1707| 0| iface = IfaceList; 1708| | 1709| 0| while (iface) ------------------ | Branch (1709:11): [True: 0, False: 0] ------------------ 1710| 0| { 1711| 0| if (!strcmp((yyvsp[0].str), iface->props.name)) ------------------ | Branch (1711:9): [True: 0, False: 0] ------------------ 1712| 0| { 1713| 0| flog(LOG_ERR, "duplicate interface " 1714| 0| "definition for %s", (yyvsp[0].str)); 1715| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 1716| 0| } 1717| 0| iface = iface->next; 1718| 0| } 1719| | 1720| 0| iface = malloc(sizeof(struct Interface)); 1721| | 1722| 0| if (iface == NULL) { ------------------ | Branch (1722:8): [True: 0, False: 0] ------------------ 1723| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 1724| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 1725| 0| } 1726| | 1727| 0| iface_init_defaults(iface); 1728| 0| memset(&iface->props.name, 0, sizeof(iface->props.name)); 1729| 0| strlcpy(iface->props.name, (yyvsp[0].str), sizeof(iface->props.name)); 1730| 0| iface->lineno = num_lines; 1731| 0| } 1732| 0|#line 1733 "gram.c" 1733| 0| break; 1734| | 1735| 0| case 6: /* name: STRING */ ------------------ | Branch (1735:3): [True: 0, False: 0] ------------------ 1736| 0|#line 233 "gram.y" 1737| 0| { 1738| | /* check vality */ 1739| 0| (yyval.str) = (yyvsp[0].str); 1740| 0| } 1741| 0|#line 1742 "gram.c" 1742| 0| break; 1743| | 1744| 0| case 10: /* ifaceparam: prefixdef */ ------------------ | Branch (1744:3): [True: 0, False: 0] ------------------ 1745| 0|#line 244 "gram.y" 1746| 0| { ADD_TO_LL(struct AdvPrefix, AdvPrefixList, (yyvsp[0].pinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1747| 0|#line 1748 "gram.c" 1748| 0| break; 1749| | 1750| 0| case 11: /* ifaceparam: clientslist */ ------------------ | Branch (1750:3): [True: 0, False: 0] ------------------ 1751| 0|#line 245 "gram.y" 1752| 0| { ADD_TO_LL(struct Clients, ClientList, (yyvsp[0].ainfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1753| 0|#line 1754 "gram.c" 1754| 0| break; 1755| | 1756| 0| case 12: /* ifaceparam: routedef */ ------------------ | Branch (1756:3): [True: 0, False: 0] ------------------ 1757| 0|#line 246 "gram.y" 1758| 0| { ADD_TO_LL(struct AdvRoute, AdvRouteList, (yyvsp[0].rinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1759| 0|#line 1760 "gram.c" 1760| 0| break; 1761| | 1762| 0| case 13: /* ifaceparam: rdnssdef */ ------------------ | Branch (1762:3): [True: 0, False: 0] ------------------ 1763| 0|#line 247 "gram.y" 1764| 0| { ADD_TO_LL(struct AdvRDNSS, AdvRDNSSList, (yyvsp[0].rdnssinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1765| 0|#line 1766 "gram.c" 1766| 0| break; 1767| | 1768| 0| case 14: /* ifaceparam: dnssldef */ ------------------ | Branch (1768:3): [True: 0, False: 0] ------------------ 1769| 0|#line 248 "gram.y" 1770| 0| { ADD_TO_LL(struct AdvDNSSL, AdvDNSSLList, (yyvsp[0].dnsslinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1771| 0|#line 1772 "gram.c" 1772| 0| break; 1773| | 1774| 0| case 15: /* ifaceparam: lowpancodef */ ------------------ | Branch (1774:3): [True: 0, False: 0] ------------------ 1775| 0|#line 249 "gram.y" 1776| 0| { ADD_TO_LL(struct AdvLowpanCo, AdvLowpanCoList, (yyvsp[0].lowpancoinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1777| 0|#line 1778 "gram.c" 1778| 0| break; 1779| | 1780| 0| case 16: /* ifaceparam: abrodef */ ------------------ | Branch (1780:3): [True: 0, False: 0] ------------------ 1781| 0|#line 250 "gram.y" 1782| 0| { ADD_TO_LL(struct AdvAbro, AdvAbroList, (yyvsp[0].abroinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1783| 0|#line 1784 "gram.c" 1784| 0| break; 1785| | 1786| 0| case 17: /* ifaceparam: rasrcaddresslist */ ------------------ | Branch (1786:3): [True: 0, False: 0] ------------------ 1787| 0|#line 251 "gram.y" 1788| 0| { ADD_TO_LL(struct AdvRASrcAddress, AdvRASrcAddressList, (yyvsp[0].rasrcaddressinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1789| 0|#line 1790 "gram.c" 1790| 0| break; 1791| | 1792| 0| case 18: /* ifaceparam: nat64prefixdef */ ------------------ | Branch (1792:3): [True: 0, False: 0] ------------------ 1793| 0|#line 252 "gram.y" 1794| 0| { ADD_TO_LL(struct NAT64Prefix, NAT64PrefixList, (yyvsp[0].nat64pinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1795| 0|#line 1796 "gram.c" 1796| 0| break; 1797| | 1798| 0| case 19: /* ifaceparam: ignoreprefixlist */ ------------------ | Branch (1798:3): [True: 0, False: 0] ------------------ 1799| 0|#line 253 "gram.y" 1800| 0| { ADD_TO_LL(struct AutogenIgnorePrefix, IgnorePrefixList, (yyvsp[0].igpinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1801| 0|#line 1802 "gram.c" 1802| 0| break; 1803| | 1804| 0| case 20: /* ifaceval: T_MinRtrAdvInterval NUMBER ';' */ ------------------ | Branch (1804:3): [True: 0, False: 0] ------------------ 1805| 0|#line 257 "gram.y" 1806| 0| { 1807| 0| iface->MinRtrAdvInterval = (yyvsp[-1].num); 1808| 0| } 1809| 0|#line 1810 "gram.c" 1810| 0| break; 1811| | 1812| 0| case 21: /* ifaceval: T_MaxRtrAdvInterval NUMBER ';' */ ------------------ | Branch (1812:3): [True: 0, False: 0] ------------------ 1813| 0|#line 261 "gram.y" 1814| 0| { 1815| 0| iface->MaxRtrAdvInterval = (yyvsp[-1].num); 1816| 0| } 1817| 0|#line 1818 "gram.c" 1818| 0| break; 1819| | 1820| 0| case 22: /* ifaceval: T_MinDelayBetweenRAs NUMBER ';' */ ------------------ | Branch (1820:3): [True: 0, False: 0] ------------------ 1821| 0|#line 265 "gram.y" 1822| 0| { 1823| 0| iface->MinDelayBetweenRAs = (yyvsp[-1].num); 1824| 0| } 1825| 0|#line 1826 "gram.c" 1826| 0| break; 1827| | 1828| 0| case 23: /* ifaceval: T_MinRtrAdvInterval DECIMAL ';' */ ------------------ | Branch (1828:3): [True: 0, False: 0] ------------------ 1829| 0|#line 269 "gram.y" 1830| 0| { 1831| 0| iface->MinRtrAdvInterval = (yyvsp[-1].dec); 1832| 0| } 1833| 0|#line 1834 "gram.c" 1834| 0| break; 1835| | 1836| 0| case 24: /* ifaceval: T_MaxRtrAdvInterval DECIMAL ';' */ ------------------ | Branch (1836:3): [True: 0, False: 0] ------------------ 1837| 0|#line 273 "gram.y" 1838| 0| { 1839| 0| iface->MaxRtrAdvInterval = (yyvsp[-1].dec); 1840| 0| } 1841| 0|#line 1842 "gram.c" 1842| 0| break; 1843| | 1844| 0| case 25: /* ifaceval: T_MinDelayBetweenRAs DECIMAL ';' */ ------------------ | Branch (1844:3): [True: 0, False: 0] ------------------ 1845| 0|#line 277 "gram.y" 1846| 0| { 1847| 0| iface->MinDelayBetweenRAs = (yyvsp[-1].dec); 1848| 0| } 1849| 0|#line 1850 "gram.c" 1850| 0| break; 1851| | 1852| 0| case 26: /* ifaceval: T_IgnoreIfMissing SWITCH ';' */ ------------------ | Branch (1852:3): [True: 0, False: 0] ------------------ 1853| 0|#line 281 "gram.y" 1854| 0| { 1855| 0| iface->IgnoreIfMissing = (yyvsp[-1].num); 1856| 0| } 1857| 0|#line 1858 "gram.c" 1858| 0| break; 1859| | 1860| 0| case 27: /* ifaceval: T_AdvSendAdvert SWITCH ';' */ ------------------ | Branch (1860:3): [True: 0, False: 0] ------------------ 1861| 0|#line 285 "gram.y" 1862| 0| { 1863| 0| iface->AdvSendAdvert = (yyvsp[-1].num); 1864| 0| } 1865| 0|#line 1866 "gram.c" 1866| 0| break; 1867| | 1868| 0| case 28: /* ifaceval: T_AdvManagedFlag SWITCH ';' */ ------------------ | Branch (1868:3): [True: 0, False: 0] ------------------ 1869| 0|#line 289 "gram.y" 1870| 0| { 1871| 0| iface->ra_header_info.AdvManagedFlag = (yyvsp[-1].num); 1872| 0| } 1873| 0|#line 1874 "gram.c" 1874| 0| break; 1875| | 1876| 0| case 29: /* ifaceval: T_AdvOtherConfigFlag SWITCH ';' */ ------------------ | Branch (1876:3): [True: 0, False: 0] ------------------ 1877| 0|#line 293 "gram.y" 1878| 0| { 1879| 0| iface->ra_header_info.AdvOtherConfigFlag = (yyvsp[-1].num); 1880| 0| } 1881| 0|#line 1882 "gram.c" 1882| 0| break; 1883| | 1884| 0| case 30: /* ifaceval: T_AdvLinkMTU NUMBER ';' */ ------------------ | Branch (1884:3): [True: 0, False: 0] ------------------ 1885| 0|#line 297 "gram.y" 1886| 0| { 1887| 0| iface->AdvLinkMTU = (yyvsp[-1].num); 1888| 0| } 1889| 0|#line 1890 "gram.c" 1890| 0| break; 1891| | 1892| 0| case 31: /* ifaceval: T_AdvRAMTU NUMBER ';' */ ------------------ | Branch (1892:3): [True: 0, False: 0] ------------------ 1893| 0|#line 301 "gram.y" 1894| 0| { 1895| 0| iface->AdvRAMTU = (yyvsp[-1].num); 1896| 0| iface->AdvRAMTU = MAX(MIN_AdvLinkMTU, iface->AdvRAMTU); ------------------ | Branch (1896:22): [True: 0, False: 0] ------------------ 1897| 0| iface->AdvRAMTU = MIN(MAX_AdvLinkMTU, iface->AdvRAMTU); ------------------ | Branch (1897:22): [True: 0, False: 0] ------------------ 1898| 0| } 1899| 0|#line 1900 "gram.c" 1900| 0| break; 1901| | 1902| 0| case 32: /* ifaceval: T_AdvReachableTime NUMBER ';' */ ------------------ | Branch (1902:3): [True: 0, False: 0] ------------------ 1903| 0|#line 307 "gram.y" 1904| 0| { 1905| 0| iface->ra_header_info.AdvReachableTime = (yyvsp[-1].num); 1906| 0| } 1907| 0|#line 1908 "gram.c" 1908| 0| break; 1909| | 1910| 0| case 33: /* ifaceval: T_AdvRetransTimer NUMBER ';' */ ------------------ | Branch (1910:3): [True: 0, False: 0] ------------------ 1911| 0|#line 311 "gram.y" 1912| 0| { 1913| 0| iface->ra_header_info.AdvRetransTimer = (yyvsp[-1].num); 1914| 0| } 1915| 0|#line 1916 "gram.c" 1916| 0| break; 1917| | 1918| 0| case 34: /* ifaceval: T_AdvDefaultLifetime NUMBER ';' */ ------------------ | Branch (1918:3): [True: 0, False: 0] ------------------ 1919| 0|#line 315 "gram.y" 1920| 0| { 1921| 0| iface->ra_header_info.AdvDefaultLifetime = (yyvsp[-1].num); 1922| 0| } 1923| 0|#line 1924 "gram.c" 1924| 0| break; 1925| | 1926| 0| case 35: /* ifaceval: T_AdvDefaultPreference SIGNEDNUMBER ';' */ ------------------ | Branch (1926:3): [True: 0, False: 0] ------------------ 1927| 0|#line 319 "gram.y" 1928| 0| { 1929| 0| iface->ra_header_info.AdvDefaultPreference = (yyvsp[-1].snum); 1930| 0| } 1931| 0|#line 1932 "gram.c" 1932| 0| break; 1933| | 1934| 0| case 36: /* ifaceval: T_AdvCurHopLimit NUMBER ';' */ ------------------ | Branch (1934:3): [True: 0, False: 0] ------------------ 1935| 0|#line 323 "gram.y" 1936| 0| { 1937| 0| iface->ra_header_info.AdvCurHopLimit = (yyvsp[-1].num); 1938| 0| } 1939| 0|#line 1940 "gram.c" 1940| 0| break; 1941| | 1942| 0| case 37: /* ifaceval: T_RemoveAdvOnExit SWITCH ';' */ ------------------ | Branch (1942:3): [True: 0, False: 0] ------------------ 1943| 0|#line 327 "gram.y" 1944| 0| { 1945| 0| iface->RemoveAdvOnExit = (yyvsp[-1].num); 1946| 0| } 1947| 0|#line 1948 "gram.c" 1948| 0| break; 1949| | 1950| 0| case 38: /* ifaceval: T_AdvSourceLLAddress SWITCH ';' */ ------------------ | Branch (1950:3): [True: 0, False: 0] ------------------ 1951| 0|#line 331 "gram.y" 1952| 0| { 1953| 0| iface->AdvSourceLLAddress = (yyvsp[-1].num); 1954| 0| } 1955| 0|#line 1956 "gram.c" 1956| 0| break; 1957| | 1958| 0| case 39: /* ifaceval: T_AdvIntervalOpt SWITCH ';' */ ------------------ | Branch (1958:3): [True: 0, False: 0] ------------------ 1959| 0|#line 335 "gram.y" 1960| 0| { 1961| 0| iface->mipv6.AdvIntervalOpt = (yyvsp[-1].num); 1962| 0| } 1963| 0|#line 1964 "gram.c" 1964| 0| break; 1965| | 1966| 0| case 40: /* ifaceval: T_AdvHomeAgentInfo SWITCH ';' */ ------------------ | Branch (1966:3): [True: 0, False: 0] ------------------ 1967| 0|#line 339 "gram.y" 1968| 0| { 1969| 0| iface->mipv6.AdvHomeAgentInfo = (yyvsp[-1].num); 1970| 0| } 1971| 0|#line 1972 "gram.c" 1972| 0| break; 1973| | 1974| 0| case 41: /* ifaceval: T_AdvHomeAgentFlag SWITCH ';' */ ------------------ | Branch (1974:3): [True: 0, False: 0] ------------------ 1975| 0|#line 343 "gram.y" 1976| 0| { 1977| 0| iface->ra_header_info.AdvHomeAgentFlag = (yyvsp[-1].num); 1978| 0| } 1979| 0|#line 1980 "gram.c" 1980| 0| break; 1981| | 1982| 0| case 42: /* ifaceval: T_HomeAgentPreference NUMBER ';' */ ------------------ | Branch (1982:3): [True: 0, False: 0] ------------------ 1983| 0|#line 347 "gram.y" 1984| 0| { 1985| 0| iface->mipv6.HomeAgentPreference = (yyvsp[-1].num); 1986| 0| } 1987| 0|#line 1988 "gram.c" 1988| 0| break; 1989| | 1990| 0| case 43: /* ifaceval: T_HomeAgentLifetime NUMBER ';' */ ------------------ | Branch (1990:3): [True: 0, False: 0] ------------------ 1991| 0|#line 351 "gram.y" 1992| 0| { 1993| 0| iface->mipv6.HomeAgentLifetime = (yyvsp[-1].num); 1994| 0| } 1995| 0|#line 1996 "gram.c" 1996| 0| break; 1997| | 1998| 0| case 44: /* ifaceval: T_AdvSNACRouterFlag SWITCH ';' */ ------------------ | Branch (1998:3): [True: 0, False: 0] ------------------ 1999| 0|#line 355 "gram.y" 2000| 0| { 2001| 0| iface->ra_header_info.AdvSNACRouterFlag = (yyvsp[-1].num); 2002| 0| } 2003| 0|#line 2004 "gram.c" 2004| 0| break; 2005| | 2006| 0| case 45: /* ifaceval: T_UnicastOnly SWITCH ';' */ ------------------ | Branch (2006:3): [True: 0, False: 0] ------------------ 2007| 0|#line 359 "gram.y" 2008| 0| { 2009| 0| iface->UnicastOnly = (yyvsp[-1].num); 2010| 0| } 2011| 0|#line 2012 "gram.c" 2012| 0| break; 2013| | 2014| 0| case 46: /* ifaceval: T_UnrestrictedUnicast SWITCH ';' */ ------------------ | Branch (2014:3): [True: 0, False: 0] ------------------ 2015| 0|#line 363 "gram.y" 2016| 0| { 2017| 0| iface->UnrestrictedUnicast = (yyvsp[-1].num); 2018| 0| } 2019| 0|#line 2020 "gram.c" 2020| 0| break; 2021| | 2022| 0| case 47: /* ifaceval: T_AdvRASolicitedUnicast SWITCH ';' */ ------------------ | Branch (2022:3): [True: 0, False: 0] ------------------ 2023| 0|#line 367 "gram.y" 2024| 0| { 2025| 0| iface->AdvRASolicitedUnicast = (yyvsp[-1].num); 2026| 0| } 2027| 0|#line 2028 "gram.c" 2028| 0| break; 2029| | 2030| 0| case 48: /* ifaceval: T_AdvCaptivePortalAPI STRING ';' */ ------------------ | Branch (2030:3): [True: 0, False: 0] ------------------ 2031| 0|#line 371 "gram.y" 2032| 0| { 2033| 0| const char *source = (yyvsp[-1].str); 2034| 0| size_t len = strlen(source); 2035| | 2036| 0| if (iface->AdvCaptivePortalAPI) { ------------------ | Branch (2036:8): [True: 0, False: 0] ------------------ 2037| 0| flog(LOG_WARNING, "warning: AdvCaptivePortalAPI specified twice for interface " 2038| 0| "%s in %s, line %d", iface->props.name, filename, num_lines); 2039| | 2040| 0| free(iface->AdvCaptivePortalAPI); 2041| 0| iface->AdvCaptivePortalAPI = NULL; 2042| 0| } 2043| | 2044| | /* trim double-quotes from start and end of string */ 2045| 0| if ((len > 0) && (source[0] == '"')) { ------------------ | Branch (2045:8): [True: 0, False: 0] | Branch (2045:21): [True: 0, False: 0] ------------------ 2046| 0| source++; 2047| 0| len--; 2048| 0| } 2049| 0| if ((len > 0) && (source[len-1] == '"')) { ------------------ | Branch (2049:8): [True: 0, False: 0] | Branch (2049:21): [True: 0, False: 0] ------------------ 2050| 0| len--; 2051| 0| } 2052| | 2053| 0| if (len <= 0) { ------------------ | Branch (2053:8): [True: 0, False: 0] ------------------ 2054| 0| flog(LOG_ERR, "AdvCaptivePortalAPI empty URL specified for interface %s.", iface->props.name); 2055| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2056| 0| } 2057| | 2058| 0| iface->AdvCaptivePortalAPI = strndup(source, len); 2059| | 2060| 0| if (!iface->AdvCaptivePortalAPI) { ------------------ | Branch (2060:8): [True: 0, False: 0] ------------------ 2061| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2062| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2063| 0| } 2064| 0| } 2065| 0|#line 2066 "gram.c" 2066| 0| break; 2067| | 2068| 0| case 49: /* ifaceval: T_AdvMobRtrSupportFlag SWITCH ';' */ ------------------ | Branch (2068:3): [True: 0, False: 0] ------------------ 2069| 0|#line 405 "gram.y" 2070| 0| { 2071| 0| iface->mipv6.AdvMobRtrSupportFlag = (yyvsp[-1].num); 2072| 0| } 2073| 0|#line 2074 "gram.c" 2074| 0| break; 2075| | 2076| 0| case 50: /* clientslist: T_CLIENTS '{' v6addrlist_clients '}' ';' */ ------------------ | Branch (2076:3): [True: 0, False: 0] ------------------ 2077| 0|#line 411 "gram.y" 2078| 0| { 2079| 0| (yyval.ainfo) = (yyvsp[-2].ainfo); 2080| 0| } 2081| 0|#line 2082 "gram.c" 2082| 0| break; 2083| | 2084| 0| case 51: /* v6addrlist_clients: IPV6ADDR ';' */ ------------------ | Branch (2084:3): [True: 0, False: 0] ------------------ 2085| 0|#line 417 "gram.y" 2086| 0| { 2087| 0| struct Clients *new = calloc(1, sizeof(struct Clients)); 2088| 0| if (new == NULL) { ------------------ | Branch (2088:8): [True: 0, False: 0] ------------------ 2089| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2090| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2091| 0| } 2092| | 2093| 0| memcpy(&(new->Address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2094| 0| new->ignored = 0; 2095| 0| (yyval.ainfo) = new; 2096| 0| } 2097| 0|#line 2098 "gram.c" 2098| 0| break; 2099| | 2100| 0| case 52: /* v6addrlist_clients: NOT_IPV6ADDR ';' */ ------------------ | Branch (2100:3): [True: 0, False: 0] ------------------ 2101| 0|#line 429 "gram.y" 2102| 0| { 2103| 0| struct Clients *new = calloc(1, sizeof(struct Clients)); 2104| 0| if (new == NULL) { ------------------ | Branch (2104:8): [True: 0, False: 0] ------------------ 2105| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2106| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2107| 0| } 2108| | 2109| 0| memcpy(&(new->Address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2110| 0| new->ignored = 1; 2111| 0| (yyval.ainfo) = new; 2112| 0| } 2113| 0|#line 2114 "gram.c" 2114| 0| break; 2115| | 2116| 0| case 53: /* v6addrlist_clients: v6addrlist_clients IPV6ADDR ';' */ ------------------ | Branch (2116:3): [True: 0, False: 0] ------------------ 2117| 0|#line 441 "gram.y" 2118| 0| { 2119| 0| struct Clients *new = calloc(1, sizeof(struct Clients)); 2120| 0| if (new == NULL) { ------------------ | Branch (2120:8): [True: 0, False: 0] ------------------ 2121| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2122| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2123| 0| } 2124| | 2125| 0| memcpy(&(new->Address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2126| 0| new->ignored = 0; 2127| 0| new->next = (yyvsp[-2].ainfo); 2128| 0| (yyval.ainfo) = new; 2129| 0| } 2130| 0|#line 2131 "gram.c" 2131| 0| break; 2132| | 2133| 0| case 54: /* v6addrlist_clients: v6addrlist_clients NOT_IPV6ADDR ';' */ ------------------ | Branch (2133:3): [True: 0, False: 0] ------------------ 2134| 0|#line 454 "gram.y" 2135| 0| { 2136| 0| struct Clients *new = calloc(1, sizeof(struct Clients)); 2137| 0| if (new == NULL) { ------------------ | Branch (2137:8): [True: 0, False: 0] ------------------ 2138| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2139| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2140| 0| } 2141| | 2142| 0| memcpy(&(new->Address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2143| 0| new->ignored = 1; 2144| 0| new->next = (yyvsp[-2].ainfo); 2145| 0| (yyval.ainfo) = new; 2146| 0| } 2147| 0|#line 2148 "gram.c" 2148| 0| break; 2149| | 2150| 0| case 55: /* rasrcaddresslist: T_RASRCADDRESS '{' v6addrlist_rasrcaddress '}' ';' */ ------------------ | Branch (2150:3): [True: 0, False: 0] ------------------ 2151| 0|#line 469 "gram.y" 2152| 0| { 2153| 0| (yyval.rasrcaddressinfo) = (yyvsp[-2].rasrcaddressinfo); 2154| 0| } 2155| 0|#line 2156 "gram.c" 2156| 0| break; 2157| | 2158| 0| case 56: /* v6addrlist_rasrcaddress: IPV6ADDR ';' */ ------------------ | Branch (2158:3): [True: 0, False: 0] ------------------ 2159| 0|#line 475 "gram.y" 2160| 0| { 2161| 0| struct AdvRASrcAddress *new = calloc(1, sizeof(struct AdvRASrcAddress)); 2162| 0| if (new == NULL) { ------------------ | Branch (2162:8): [True: 0, False: 0] ------------------ 2163| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2164| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2165| 0| } 2166| | 2167| 0| memcpy(&(new->address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2168| 0| (yyval.rasrcaddressinfo) = new; 2169| 0| } 2170| 0|#line 2171 "gram.c" 2171| 0| break; 2172| | 2173| 0| case 57: /* v6addrlist_rasrcaddress: v6addrlist_rasrcaddress IPV6ADDR ';' */ ------------------ | Branch (2173:3): [True: 0, False: 0] ------------------ 2174| 0|#line 486 "gram.y" 2175| 0| { 2176| 0| struct AdvRASrcAddress *new = calloc(1, sizeof(struct AdvRASrcAddress)); 2177| 0| if (new == NULL) { ------------------ | Branch (2177:8): [True: 0, False: 0] ------------------ 2178| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2179| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2180| 0| } 2181| | 2182| 0| memcpy(&(new->address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2183| 0| new->next = (yyvsp[-2].rasrcaddressinfo); 2184| 0| (yyval.rasrcaddressinfo) = new; 2185| 0| } 2186| 0|#line 2187 "gram.c" 2187| 0| break; 2188| | 2189| 0| case 58: /* nat64prefixdef: nat64prefixhead optional_nat64prefixplist ';' */ ------------------ | Branch (2189:3): [True: 0, False: 0] ------------------ 2190| 0|#line 500 "gram.y" 2191| 0| { 2192| 0| if (nat64prefix) { ------------------ | Branch (2192:8): [True: 0, False: 0] ------------------ 2193| | 2194| 0| if (nat64prefix->AdvValidLifetime > DFLT_NAT64MaxValidLifetime) ------------------ | | 68| 0|#define DFLT_NAT64MaxValidLifetime 65528 /* seconds */ ------------------ | Branch (2194:9): [True: 0, False: 0] ------------------ 2195| 0| { 2196| 0| flog(LOG_ERR, "AdvValidLifetime must be " 2197| 0| "smaller or equal to %d in %s, line %d", 2198| 0| DFLT_NAT64MaxValidLifetime, filename, num_lines); ------------------ | | 68| 0|#define DFLT_NAT64MaxValidLifetime 65528 /* seconds */ ------------------ 2199| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2200| 0| } 2201| 0| nat64prefix->curr_validlft = nat64prefix->AdvValidLifetime; 2202| 0| } 2203| 0| (yyval.nat64pinfo) = nat64prefix; 2204| 0| nat64prefix = NULL; 2205| 0| } 2206| 0|#line 2207 "gram.c" 2207| 0| break; 2208| | 2209| 0| case 59: /* nat64prefixhead: T_NAT64PREFIX IPV6ADDR '/' NUMBER */ ------------------ | Branch (2209:3): [True: 0, False: 0] ------------------ 2210| 0|#line 518 "gram.y" 2211| 0| { 2212| 0| struct in6_addr zeroaddr; 2213| 0| memset(&zeroaddr, 0, sizeof(zeroaddr)); 2214| | 2215| 0| if (!memcmp((yyvsp[-2].addr), &zeroaddr, sizeof(struct in6_addr))) { ------------------ | Branch (2215:8): [True: 0, False: 0] ------------------ 2216| 0| flog(LOG_ERR, "invalid all-zeros nat64prefix in %s, line %d", filename, num_lines); 2217| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2218| 0| } 2219| | 2220| 0| nat64prefix = malloc(sizeof(struct NAT64Prefix)); 2221| | 2222| 0| if (nat64prefix == NULL) { ------------------ | Branch (2222:8): [True: 0, False: 0] ------------------ 2223| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2224| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2225| 0| } 2226| | 2227| 0| nat64prefix_init_defaults(nat64prefix, iface); 2228| | 2229| 0| if ((yyvsp[0].num) > MAX_PrefixLen) ------------------ | | 157| 0|#define MAX_PrefixLen 128 ------------------ | Branch (2229:8): [True: 0, False: 0] ------------------ 2230| 0| { 2231| 0| flog(LOG_ERR, "invalid prefix length in %s, line %d", filename, num_lines); 2232| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2233| 0| } 2234| | 2235| | /* RFC8781, section 4: only prefix lengths of 96, 64, 56, 48, 40, and 32 bits are valid */ 2236| 0| switch ((yyvsp[0].num)) { 2237| 0| case 32: ------------------ | Branch (2237:4): [True: 0, False: 0] ------------------ 2238| 0| case 40: ------------------ | Branch (2238:4): [True: 0, False: 0] ------------------ 2239| 0| case 48: ------------------ | Branch (2239:4): [True: 0, False: 0] ------------------ 2240| 0| case 56: ------------------ | Branch (2240:4): [True: 0, False: 0] ------------------ 2241| 0| case 64: ------------------ | Branch (2241:4): [True: 0, False: 0] ------------------ 2242| 0| case 96: ------------------ | Branch (2242:4): [True: 0, False: 0] ------------------ 2243| 0| break; 2244| 0| default: ------------------ | Branch (2244:4): [True: 0, False: 0] ------------------ 2245| 0| flog(LOG_ERR, "only /96, /64, /56, /48, /40 and /32 are allowed for " 2246| 0| "nat64prefix in %s:%d", filename, num_lines); 2247| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2248| 0| } 2249| 0| nat64prefix->PrefixLen = (yyvsp[0].num); 2250| | 2251| 0| memcpy(&nat64prefix->Prefix, (yyvsp[-2].addr), sizeof(struct in6_addr)); 2252| 0| } 2253| 0|#line 2254 "gram.c" 2254| 0| break; 2255| | 2256| 0| case 65: /* nat64prefixparms: T_AdvValidLifetime NUMBER ';' */ ------------------ | Branch (2256:3): [True: 0, False: 0] ------------------ 2257| 0|#line 572 "gram.y" 2258| 0| { 2259| 0| if ((yyvsp[-1].num) > DFLT_NAT64MaxValidLifetime) ------------------ | | 68| 0|#define DFLT_NAT64MaxValidLifetime 65528 /* seconds */ ------------------ | Branch (2259:8): [True: 0, False: 0] ------------------ 2260| 0| { 2261| 0| flog(LOG_ERR, "maximum for NAT64 AdvValidLifetime is %d (in %s, line %d)", 2262| 0| DFLT_NAT64MaxValidLifetime, filename, num_lines); ------------------ | | 68| 0|#define DFLT_NAT64MaxValidLifetime 65528 /* seconds */ ------------------ 2263| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2264| 0| } 2265| 0| if (nat64prefix) { ------------------ | Branch (2265:8): [True: 0, False: 0] ------------------ 2266| 0| nat64prefix->AdvValidLifetime = (yyvsp[-1].num); 2267| 0| } 2268| 0| } 2269| 0|#line 2270 "gram.c" 2270| 0| break; 2271| | 2272| 0| case 66: /* ignoreprefixlist: T_AUTOIGNOREPREFIX '{' ignoreprefixes '}' ';' */ ------------------ | Branch (2272:3): [True: 0, False: 0] ------------------ 2273| 0|#line 586 "gram.y" 2274| 0| { 2275| 0| (yyval.igpinfo) = (yyvsp[-2].igpinfo); 2276| 0| } 2277| 0|#line 2278 "gram.c" 2278| 0| break; 2279| | 2280| 0| case 67: /* ignoreprefixes: IPV6ADDR '/' NUMBER ';' */ ------------------ | Branch (2280:3): [True: 0, False: 0] ------------------ 2281| 0|#line 592 "gram.y" 2282| 0| { 2283| 0| struct AutogenIgnorePrefix *new = calloc(1, sizeof(struct AutogenIgnorePrefix)); 2284| 0| if (new == NULL) { ------------------ | Branch (2284:8): [True: 0, False: 0] ------------------ 2285| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2286| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2287| 0| } 2288| | 2289| 0| memcpy(&(new->Prefix), (yyvsp[-3].addr), sizeof(struct in6_addr)); 2290| | 2291| | // Create subnet mask from CIDR notation 2292| 0| int fullOctets = (yyvsp[-1].num) / 8; 2293| 0| for (int i = 0; i < fullOctets; ++i) { ------------------ | Branch (2293:20): [True: 0, False: 0] ------------------ 2294| 0| new->Mask.s6_addr[i] = 0xff; 2295| 0| } 2296| | 2297| 0| if (fullOctets != 16) { ------------------ | Branch (2297:8): [True: 0, False: 0] ------------------ 2298| 0| new->Mask.s6_addr[fullOctets] = ~(1 << (8 - (yyvsp[-1].num) % 8)) + 1; 2299| 0| } 2300| | 2301| 0| (yyval.igpinfo) = new; 2302| 0| } 2303| 0|#line 2304 "gram.c" 2304| 0| break; 2305| | 2306| 0| case 68: /* ignoreprefixes: ignoreprefixes IPV6ADDR '/' NUMBER ';' */ ------------------ | Branch (2306:3): [True: 0, False: 0] ------------------ 2307| 0|#line 614 "gram.y" 2308| 0| { 2309| 0| struct AutogenIgnorePrefix *new = calloc(1, sizeof(struct AutogenIgnorePrefix)); 2310| 0| if (new == NULL) { ------------------ | Branch (2310:8): [True: 0, False: 0] ------------------ 2311| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2312| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2313| 0| } 2314| | 2315| 0| memcpy(&(new->Prefix), (yyvsp[-3].addr), sizeof(struct in6_addr)); 2316| | 2317| | // Create subnet mask from CIDR notation 2318| 0| int fullOctets = (yyvsp[-1].num) / 8; 2319| 0| for (int i = 0; i < fullOctets; ++i) { ------------------ | Branch (2319:20): [True: 0, False: 0] ------------------ 2320| 0| new->Mask.s6_addr[i] = 0xff; 2321| 0| } 2322| | 2323| 0| if (fullOctets != 16) { ------------------ | Branch (2323:8): [True: 0, False: 0] ------------------ 2324| 0| new->Mask.s6_addr[fullOctets] = ~(1 << (8 - (yyvsp[-1].num) % 8)) + 1; 2325| 0| } 2326| | 2327| 0| new->next = (yyvsp[-4].igpinfo); 2328| 0| (yyval.igpinfo) = new; 2329| 0| } 2330| 0|#line 2331 "gram.c" 2331| 0| break; 2332| | 2333| 0| case 69: /* prefixdef: prefixhead optional_prefixplist ';' */ ------------------ | Branch (2333:3): [True: 0, False: 0] ------------------ 2334| 0|#line 639 "gram.y" 2335| 0| { 2336| 0| if (prefix) { ------------------ | Branch (2336:8): [True: 0, False: 0] ------------------ 2337| | 2338| 0| if (prefix->AdvPreferredLifetime > prefix->AdvValidLifetime) ------------------ | Branch (2338:9): [True: 0, False: 0] ------------------ 2339| 0| { 2340| 0| flog(LOG_ERR, "AdvValidLifetime must be " 2341| 0| "greater than or equal to AdvPreferredLifetime in %s, line %d", 2342| 0| filename, num_lines); 2343| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2344| 0| } 2345| | 2346| 0| if ( prefix->if6[0] ) ------------------ | Branch (2346:10): [True: 0, False: 0] ------------------ 2347| 0| { 2348| 0| if (prefix->PrefixLen != 64) { ------------------ | Branch (2348:10): [True: 0, False: 0] ------------------ 2349| 0| flog(LOG_ERR, "only /64 is allowed with Base6Interface. %s:%d", filename, num_lines); 2350| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2351| 0| } 2352| 0| } 2353| 0| } 2354| 0| (yyval.pinfo) = prefix; 2355| 0| prefix = NULL; 2356| 0| } 2357| 0|#line 2358 "gram.c" 2358| 0| break; 2359| | 2360| 0| case 70: /* prefixhead: T_PREFIX IPV6ADDR '/' NUMBER */ ------------------ | Branch (2360:3): [True: 0, False: 0] ------------------ 2361| 0|#line 664 "gram.y" 2362| 0| { 2363| 0| struct in6_addr zeroaddr; 2364| 0| memset(&zeroaddr, 0, sizeof(zeroaddr)); 2365| | 2366| |#ifndef HAVE_IFADDRS_H // all-zeros prefix is a way to tell us to get the prefix from the interface config 2367| | if (!memcmp((yyvsp[-2].addr), &zeroaddr, sizeof(struct in6_addr))) { 2368| | flog(LOG_WARNING, "invalid all-zeros prefix in %s, line %d", filename, num_lines); 2369| | } 2370| |#endif 2371| 0| prefix = malloc(sizeof(struct AdvPrefix)); 2372| | 2373| 0| if (prefix == NULL) { ------------------ | Branch (2373:8): [True: 0, False: 0] ------------------ 2374| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2375| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2376| 0| } 2377| | 2378| 0| prefix_init_defaults(prefix); 2379| | 2380| 0| if ((yyvsp[0].num) > MAX_PrefixLen) ------------------ | | 157| 0|#define MAX_PrefixLen 128 ------------------ | Branch (2380:8): [True: 0, False: 0] ------------------ 2381| 0| { 2382| 0| flog(LOG_ERR, "invalid prefix length in %s, line %d", filename, num_lines); 2383| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2384| 0| } 2385| | 2386| 0| prefix->PrefixLen = (yyvsp[0].num); 2387| | 2388| 0| memcpy(&prefix->Prefix, (yyvsp[-2].addr), sizeof(struct in6_addr)); 2389| 0| } 2390| 0|#line 2391 "gram.c" 2391| 0| break; 2392| | 2393| 0| case 76: /* prefixparms: T_AdvOnLink SWITCH ';' */ ------------------ | Branch (2393:3): [True: 0, False: 0] ------------------ 2394| 0|#line 704 "gram.y" 2395| 0| { 2396| 0| if (prefix) { ------------------ | Branch (2396:8): [True: 0, False: 0] ------------------ 2397| 0| prefix->AdvOnLinkFlag = (yyvsp[-1].num); 2398| 0| } 2399| 0| } 2400| 0|#line 2401 "gram.c" 2401| 0| break; 2402| | 2403| 0| case 77: /* prefixparms: T_AdvAutonomous SWITCH ';' */ ------------------ | Branch (2403:3): [True: 0, False: 0] ------------------ 2404| 0|#line 710 "gram.y" 2405| 0| { 2406| 0| if (prefix) { ------------------ | Branch (2406:8): [True: 0, False: 0] ------------------ 2407| 0| prefix->AdvAutonomousFlag = (yyvsp[-1].num); 2408| 0| } 2409| 0| } 2410| 0|#line 2411 "gram.c" 2411| 0| break; 2412| | 2413| 0| case 78: /* prefixparms: T_AdvRouterAddr SWITCH ';' */ ------------------ | Branch (2413:3): [True: 0, False: 0] ------------------ 2414| 0|#line 716 "gram.y" 2415| 0| { 2416| 0| if (prefix) { ------------------ | Branch (2416:8): [True: 0, False: 0] ------------------ 2417| 0| prefix->AdvRouterAddr = (yyvsp[-1].num); 2418| 0| } 2419| 0| } 2420| 0|#line 2421 "gram.c" 2421| 0| break; 2422| | 2423| 0| case 79: /* prefixparms: T_AdvDHCPv6PDPreferred SWITCH ';' */ ------------------ | Branch (2423:3): [True: 0, False: 0] ------------------ 2424| 0|#line 722 "gram.y" 2425| 0| { 2426| 0| if (prefix) { ------------------ | Branch (2426:8): [True: 0, False: 0] ------------------ 2427| 0| prefix->AdvDHCPv6PDPreferredFlag = (yyvsp[-1].num); 2428| 0| } 2429| 0| } 2430| 0|#line 2431 "gram.c" 2431| 0| break; 2432| | 2433| 0| case 80: /* prefixparms: T_AdvValidLifetime number_or_infinity ';' */ ------------------ | Branch (2433:3): [True: 0, False: 0] ------------------ 2434| 0|#line 728 "gram.y" 2435| 0| { 2436| 0| if (prefix) { ------------------ | Branch (2436:8): [True: 0, False: 0] ------------------ 2437| 0| prefix->AdvValidLifetime = (yyvsp[-1].num); 2438| 0| prefix->curr_validlft = (yyvsp[-1].num); 2439| 0| } 2440| 0| } 2441| 0|#line 2442 "gram.c" 2442| 0| break; 2443| | 2444| 0| case 81: /* prefixparms: T_AdvPreferredLifetime number_or_infinity ';' */ ------------------ | Branch (2444:3): [True: 0, False: 0] ------------------ 2445| 0|#line 735 "gram.y" 2446| 0| { 2447| 0| if (prefix) { ------------------ | Branch (2447:8): [True: 0, False: 0] ------------------ 2448| 0| prefix->AdvPreferredLifetime = (yyvsp[-1].num); 2449| 0| prefix->curr_preferredlft = (yyvsp[-1].num); 2450| 0| } 2451| 0| } 2452| 0|#line 2453 "gram.c" 2453| 0| break; 2454| | 2455| 0| case 82: /* prefixparms: T_DeprecatePrefix SWITCH ';' */ ------------------ | Branch (2455:3): [True: 0, False: 0] ------------------ 2456| 0|#line 742 "gram.y" 2457| 0| { 2458| 0| if (prefix) { ------------------ | Branch (2458:8): [True: 0, False: 0] ------------------ 2459| 0| prefix->DeprecatePrefixFlag = (yyvsp[-1].num); 2460| 0| } 2461| 0| } 2462| 0|#line 2463 "gram.c" 2463| 0| break; 2464| | 2465| 0| case 83: /* prefixparms: T_DecrementLifetimes SWITCH ';' */ ------------------ | Branch (2465:3): [True: 0, False: 0] ------------------ 2466| 0|#line 748 "gram.y" 2467| 0| { 2468| 0| if (prefix) { ------------------ | Branch (2468:8): [True: 0, False: 0] ------------------ 2469| 0| prefix->DecrementLifetimesFlag = (yyvsp[-1].num); 2470| 0| } 2471| 0| } 2472| 0|#line 2473 "gram.c" 2473| 0| break; 2474| | 2475| 0| case 84: /* prefixparms: T_Base6Interface name ';' */ ------------------ | Branch (2475:3): [True: 0, False: 0] ------------------ 2476| 0|#line 754 "gram.y" 2477| 0| { 2478| |#ifndef HAVE_IFADDRS_H 2479| | flog(LOG_ERR, "Base6Interface not supported in %s, line %d", filename, num_lines); 2480| | ABORT; 2481| |#else 2482| 0| if (prefix) { ------------------ | Branch (2482:8): [True: 0, False: 0] ------------------ 2483| 0| dlog(LOG_DEBUG, 4, "using prefixes on interface %s for prefixes on interface %s", (yyvsp[-1].str), iface->props.name); 2484| 0| memset(&prefix->if6, 0, sizeof(prefix->if6)); 2485| 0| strlcpy(prefix->if6, (yyvsp[-1].str), sizeof(prefix->if6)); 2486| 0| } 2487| 0|#endif 2488| 0| } 2489| 0|#line 2490 "gram.c" 2490| 0| break; 2491| | 2492| 0| case 85: /* prefixparms: T_Base6to4Interface name ';' */ ------------------ | Branch (2492:3): [True: 0, False: 0] ------------------ 2493| 0|#line 768 "gram.y" 2494| 0| { 2495| |#ifndef HAVE_IFADDRS_H 2496| | flog(LOG_ERR, "Base6to4Interface not supported in %s, line %d", filename, num_lines); 2497| | ABORT; 2498| |#else 2499| 0| if (prefix) { ------------------ | Branch (2499:8): [True: 0, False: 0] ------------------ 2500| 0| dlog(LOG_DEBUG, 4, "using interface %s for 6to4 prefixes on interface %s", (yyvsp[-1].str), iface->props.name); 2501| 0| memset(&prefix->if6to4, 0, sizeof(prefix->if6to4)); 2502| 0| strlcpy(prefix->if6to4, (yyvsp[-1].str), sizeof(prefix->if6to4)); 2503| 0| } 2504| 0|#endif 2505| 0| } 2506| 0|#line 2507 "gram.c" 2507| 0| break; 2508| | 2509| 0| case 86: /* routedef: routehead '{' optional_routeplist '}' ';' */ ------------------ | Branch (2509:3): [True: 0, False: 0] ------------------ 2510| 0|#line 783 "gram.y" 2511| 0| { 2512| 0| (yyval.rinfo) = route; 2513| 0| route = NULL; 2514| 0| } 2515| 0|#line 2516 "gram.c" 2516| 0| break; 2517| | 2518| 0| case 87: /* routehead: T_ROUTE IPV6ADDR '/' NUMBER */ ------------------ | Branch (2518:3): [True: 0, False: 0] ------------------ 2519| 0|#line 791 "gram.y" 2520| 0| { 2521| 0| route = malloc(sizeof(struct AdvRoute)); 2522| | 2523| 0| if (route == NULL) { ------------------ | Branch (2523:8): [True: 0, False: 0] ------------------ 2524| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2525| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2526| 0| } 2527| | 2528| 0| route_init_defaults(route, iface); 2529| | 2530| 0| if ((yyvsp[0].num) > MAX_PrefixLen) ------------------ | | 157| 0|#define MAX_PrefixLen 128 ------------------ | Branch (2530:8): [True: 0, False: 0] ------------------ 2531| 0| { 2532| 0| flog(LOG_ERR, "invalid route prefix length in %s, line %d", filename, num_lines); 2533| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2534| 0| } 2535| | 2536| 0| route->PrefixLen = (yyvsp[0].num); 2537| | 2538| 0| memcpy(&route->Prefix, (yyvsp[-2].addr), sizeof(struct in6_addr)); 2539| 0| } 2540| 0|#line 2541 "gram.c" 2541| 0| break; 2542| | 2543| 0| case 92: /* routeparms: T_AdvRoutePreference SIGNEDNUMBER ';' */ ------------------ | Branch (2543:3): [True: 0, False: 0] ------------------ 2544| 0|#line 824 "gram.y" 2545| 0| { 2546| 0| route->AdvRoutePreference = (yyvsp[-1].snum); 2547| 0| } 2548| 0|#line 2549 "gram.c" 2549| 0| break; 2550| | 2551| 0| case 93: /* routeparms: T_AdvRouteLifetime number_or_infinity ';' */ ------------------ | Branch (2551:3): [True: 0, False: 0] ------------------ 2552| 0|#line 828 "gram.y" 2553| 0| { 2554| 0| route->AdvRouteLifetime = (yyvsp[-1].num); 2555| 0| } 2556| 0|#line 2557 "gram.c" 2557| 0| break; 2558| | 2559| 0| case 94: /* routeparms: T_RemoveRoute SWITCH ';' */ ------------------ | Branch (2559:3): [True: 0, False: 0] ------------------ 2560| 0|#line 832 "gram.y" 2561| 0| { 2562| 0| route->RemoveRouteFlag = (yyvsp[-1].num); 2563| 0| } 2564| 0|#line 2565 "gram.c" 2565| 0| break; 2566| | 2567| 0| case 95: /* rdnssdef: rdnsshead '{' optional_rdnssplist '}' ';' */ ------------------ | Branch (2567:3): [True: 0, False: 0] ------------------ 2568| 0|#line 838 "gram.y" 2569| 0| { 2570| 0| (yyval.rdnssinfo) = rdnss; 2571| 0| rdnss = NULL; 2572| 0| } 2573| 0|#line 2574 "gram.c" 2574| 0| break; 2575| | 2576| 0| case 98: /* rdnssaddr: IPV6ADDR */ ------------------ | Branch (2576:3): [True: 0, False: 0] ------------------ 2577| 0|#line 849 "gram.y" 2578| 0| { 2579| 0| if (!rdnss) { ------------------ | Branch (2579:8): [True: 0, False: 0] ------------------ 2580| | /* first IP found */ 2581| 0| rdnss = malloc(sizeof(struct AdvRDNSS)); 2582| | 2583| 0| if (rdnss == NULL) { ------------------ | Branch (2583:9): [True: 0, False: 0] ------------------ 2584| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2585| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2586| 0| } 2587| | 2588| 0| rdnss_init_defaults(rdnss, iface); 2589| 0| } 2590| | 2591| 0| rdnss->AdvRDNSSNumber++; 2592| 0| if (rdnss->AdvRDNSSNumber > 127) { ------------------ | Branch (2592:8): [True: 0, False: 0] ------------------ 2593| 0| flog(LOG_CRIT, "Too many RDNSS servers specified - upper limit is 127 based on RDNSSI length field being uint8, RFC8106, section 5.1"); 2594| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2595| 0| } 2596| 0| rdnss->AdvRDNSSAddr = 2597| 0| realloc(rdnss->AdvRDNSSAddr, 2598| 0| rdnss->AdvRDNSSNumber * sizeof(struct in6_addr)); 2599| 0| if (rdnss->AdvRDNSSAddr == NULL) { ------------------ | Branch (2599:8): [True: 0, False: 0] ------------------ 2600| 0| flog(LOG_CRIT, "realloc failed: %s", strerror(errno)); 2601| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2602| 0| } 2603| 0| memcpy(&rdnss->AdvRDNSSAddr[rdnss->AdvRDNSSNumber - 1], (yyvsp[0].addr), sizeof(struct in6_addr)); 2604| 0| } 2605| 0|#line 2606 "gram.c" 2606| 0| break; 2607| | 2608| 0| case 99: /* rdnsshead: T_RDNSS rdnssaddrs */ ------------------ | Branch (2608:3): [True: 0, False: 0] ------------------ 2609| 0|#line 879 "gram.y" 2610| 0| { 2611| 0| if (!rdnss) { ------------------ | Branch (2611:8): [True: 0, False: 0] ------------------ 2612| 0| flog(LOG_CRIT, "no address specified in RDNSS section"); 2613| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2614| 0| } 2615| 0| } 2616| 0|#line 2617 "gram.c" 2617| 0| break; 2618| | 2619| 0| case 104: /* rdnssparms: T_AdvRDNSSPreference NUMBER ';' */ ------------------ | Branch (2619:3): [True: 0, False: 0] ------------------ 2620| 0|#line 897 "gram.y" 2621| 0| { 2622| 0| flog(LOG_WARNING, "ignoring deprecated RDNSS preference"); 2623| 0| } 2624| 0|#line 2625 "gram.c" 2625| 0| break; 2626| | 2627| 0| case 105: /* rdnssparms: T_AdvRDNSSOpenFlag SWITCH ';' */ ------------------ | Branch (2627:3): [True: 0, False: 0] ------------------ 2628| 0|#line 901 "gram.y" 2629| 0| { 2630| 0| flog(LOG_WARNING, "ignoring deprecated RDNSS open flag"); 2631| 0| } 2632| 0|#line 2633 "gram.c" 2633| 0| break; 2634| | 2635| 0| case 106: /* rdnssparms: T_AdvRDNSSLifetime number_or_infinity ';' */ ------------------ | Branch (2635:3): [True: 0, False: 0] ------------------ 2636| 0|#line 905 "gram.y" 2637| 0| { 2638| 0| rdnss->AdvRDNSSLifetime = (yyvsp[-1].num); 2639| 0| } 2640| 0|#line 2641 "gram.c" 2641| 0| break; 2642| | 2643| 0| case 107: /* rdnssparms: T_FlushRDNSS SWITCH ';' */ ------------------ | Branch (2643:3): [True: 0, False: 0] ------------------ 2644| 0|#line 909 "gram.y" 2645| 0| { 2646| 0| rdnss->FlushRDNSSFlag = (yyvsp[-1].num); 2647| 0| } 2648| 0|#line 2649 "gram.c" 2649| 0| break; 2650| | 2651| 0| case 108: /* dnssldef: dnsslhead '{' optional_dnsslplist '}' ';' */ ------------------ | Branch (2651:3): [True: 0, False: 0] ------------------ 2652| 0|#line 915 "gram.y" 2653| 0| { 2654| 0| (yyval.dnsslinfo) = dnssl; 2655| 0| dnssl = NULL; 2656| 0| } 2657| 0|#line 2658 "gram.c" 2658| 0| break; 2659| | 2660| 0| case 111: /* dnsslsuffix: STRING */ ------------------ | Branch (2660:3): [True: 0, False: 0] ------------------ 2661| 0|#line 926 "gram.y" 2662| 0| { 2663| 0| char *ch; 2664| 0| for (ch = (yyvsp[0].str);*ch != '\0';ch++) { ------------------ | Branch (2664:29): [True: 0, False: 0] ------------------ 2665| 0| if (*ch >= 'A' && *ch <= 'Z') ------------------ | Branch (2665:9): [True: 0, False: 0] | Branch (2665:23): [True: 0, False: 0] ------------------ 2666| 0| continue; 2667| 0| if (*ch >= 'a' && *ch <= 'z') ------------------ | Branch (2667:9): [True: 0, False: 0] | Branch (2667:23): [True: 0, False: 0] ------------------ 2668| 0| continue; 2669| 0| if (*ch >= '0' && *ch <= '9') ------------------ | Branch (2669:9): [True: 0, False: 0] | Branch (2669:23): [True: 0, False: 0] ------------------ 2670| 0| continue; 2671| 0| if (*ch == '-' || *ch == '.') ------------------ | Branch (2671:9): [True: 0, False: 0] | Branch (2671:23): [True: 0, False: 0] ------------------ 2672| 0| continue; 2673| | 2674| 0| flog(LOG_CRIT, "invalid domain suffix specified"); 2675| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2676| 0| } 2677| | 2678| 0| if (!dnssl) { ------------------ | Branch (2678:8): [True: 0, False: 0] ------------------ 2679| | /* first domain found */ 2680| 0| dnssl = malloc(sizeof(struct AdvDNSSL)); 2681| | 2682| 0| if (dnssl == NULL) { ------------------ | Branch (2682:9): [True: 0, False: 0] ------------------ 2683| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2684| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2685| 0| } 2686| | 2687| 0| dnssl_init_defaults(dnssl, iface); 2688| 0| } 2689| | 2690| 0| dnssl->AdvDNSSLNumber++; 2691| 0| dnssl->AdvDNSSLSuffixes = 2692| 0| realloc(dnssl->AdvDNSSLSuffixes, 2693| 0| dnssl->AdvDNSSLNumber * sizeof(char*)); 2694| 0| if (dnssl->AdvDNSSLSuffixes == NULL) { ------------------ | Branch (2694:8): [True: 0, False: 0] ------------------ 2695| 0| flog(LOG_CRIT, "realloc failed: %s", strerror(errno)); 2696| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2697| 0| } 2698| | 2699| 0| dnssl->AdvDNSSLSuffixes[dnssl->AdvDNSSLNumber - 1] = strdup((yyvsp[0].str)); 2700| 0| } 2701| 0|#line 2702 "gram.c" 2702| 0| break; 2703| | 2704| 0| case 112: /* dnsslhead: T_DNSSL dnsslsuffixes */ ------------------ | Branch (2704:3): [True: 0, False: 0] ------------------ 2705| 0|#line 968 "gram.y" 2706| 0| { 2707| 0| if (!dnssl) { ------------------ | Branch (2707:8): [True: 0, False: 0] ------------------ 2708| 0| flog(LOG_CRIT, "no domain specified in DNSSL section"); 2709| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2710| 0| } 2711| 0| } 2712| 0|#line 2713 "gram.c" 2713| 0| break; 2714| | 2715| 0| case 117: /* dnsslparms: T_AdvDNSSLLifetime number_or_infinity ';' */ ------------------ | Branch (2715:3): [True: 0, False: 0] ------------------ 2716| 0|#line 986 "gram.y" 2717| 0| { 2718| 0| dnssl->AdvDNSSLLifetime = (yyvsp[-1].num); 2719| | 2720| 0| } 2721| 0|#line 2722 "gram.c" 2722| 0| break; 2723| | 2724| 0| case 118: /* dnsslparms: T_FlushDNSSL SWITCH ';' */ ------------------ | Branch (2724:3): [True: 0, False: 0] ------------------ 2725| 0|#line 991 "gram.y" 2726| 0| { 2727| 0| dnssl->FlushDNSSLFlag = (yyvsp[-1].num); 2728| 0| } 2729| 0|#line 2730 "gram.c" 2730| 0| break; 2731| | 2732| 0| case 119: /* lowpancodef: lowpancohead '{' optional_lowpancoplist '}' ';' */ ------------------ | Branch (2732:3): [True: 0, False: 0] ------------------ 2733| 0|#line 997 "gram.y" 2734| 0| { 2735| 0| (yyval.lowpancoinfo) = lowpanco; 2736| 0| lowpanco = NULL; 2737| 0| } 2738| 0|#line 2739 "gram.c" 2739| 0| break; 2740| | 2741| 0| case 120: /* lowpancohead: T_LOWPANCO */ ------------------ | Branch (2741:3): [True: 0, False: 0] ------------------ 2742| 0|#line 1004 "gram.y" 2743| 0| { 2744| 0| lowpanco = malloc(sizeof(struct AdvLowpanCo)); 2745| | 2746| 0| if (lowpanco == NULL) { ------------------ | Branch (2746:8): [True: 0, False: 0] ------------------ 2747| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2748| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2749| 0| } 2750| | 2751| 0| memset(lowpanco, 0, sizeof(struct AdvLowpanCo)); 2752| 0| } 2753| 0|#line 2754 "gram.c" 2754| 0| break; 2755| | 2756| 0| case 125: /* lowpancoparms: T_AdvContextLength NUMBER ';' */ ------------------ | Branch (2756:3): [True: 0, False: 0] ------------------ 2757| 0|#line 1025 "gram.y" 2758| 0| { 2759| 0| lowpanco->ContextLength = (yyvsp[-1].num); 2760| 0| } 2761| 0|#line 2762 "gram.c" 2762| 0| break; 2763| | 2764| 0| case 126: /* lowpancoparms: T_AdvContextCompressionFlag SWITCH ';' */ ------------------ | Branch (2764:3): [True: 0, False: 0] ------------------ 2765| 0|#line 1029 "gram.y" 2766| 0| { 2767| 0| lowpanco->ContextCompressionFlag = (yyvsp[-1].num); 2768| 0| } 2769| 0|#line 2770 "gram.c" 2770| 0| break; 2771| | 2772| 0| case 127: /* lowpancoparms: T_AdvContextID NUMBER ';' */ ------------------ | Branch (2772:3): [True: 0, False: 0] ------------------ 2773| 0|#line 1033 "gram.y" 2774| 0| { 2775| 0| lowpanco->AdvContextID = (yyvsp[-1].num); 2776| 0| } 2777| 0|#line 2778 "gram.c" 2778| 0| break; 2779| | 2780| 0| case 128: /* lowpancoparms: T_AdvLifeTime NUMBER ';' */ ------------------ | Branch (2780:3): [True: 0, False: 0] ------------------ 2781| 0|#line 1037 "gram.y" 2782| 0| { 2783| 0| lowpanco->AdvLifeTime = (yyvsp[-1].num); 2784| 0| } 2785| 0|#line 2786 "gram.c" 2786| 0| break; 2787| | 2788| 0| case 129: /* abrodef: abrohead '{' optional_abroplist '}' ';' */ ------------------ | Branch (2788:3): [True: 0, False: 0] ------------------ 2789| 0|#line 1043 "gram.y" 2790| 0| { 2791| 0| (yyval.abroinfo) = abro; 2792| 0| abro = NULL; 2793| 0| } 2794| 0|#line 2795 "gram.c" 2795| 0| break; 2796| | 2797| 0| case 132: /* abrohead_new: T_ABRO IPV6ADDR */ ------------------ | Branch (2797:3): [True: 0, False: 0] ------------------ 2798| 0|#line 1052 "gram.y" 2799| 0| { 2800| 0| abro = malloc(sizeof(struct AdvAbro)); 2801| | 2802| 0| if (abro == NULL) { ------------------ | Branch (2802:8): [True: 0, False: 0] ------------------ 2803| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2804| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2805| 0| } 2806| | 2807| 0| memset(abro, 0, sizeof(struct AdvAbro)); 2808| 0| memcpy(&abro->LBRaddress, (yyvsp[0].addr), sizeof(struct in6_addr)); 2809| 0| } 2810| 0|#line 2811 "gram.c" 2811| 0| break; 2812| | 2813| 0| case 133: /* abrohead_dep: T_ABRO IPV6ADDR '/' NUMBER */ ------------------ | Branch (2813:3): [True: 0, False: 0] ------------------ 2814| 0|#line 1066 "gram.y" 2815| 0| { 2816| 0| flog(LOG_WARNING 2817| 0| , "%s:%d abro prefix length deprecated, remove trailing '/%d'" 2818| 0| , filename 2819| 0| , num_lines 2820| 0| , (yyvsp[0].num) 2821| 0| ); 2822| 0| abro = malloc(sizeof(struct AdvAbro)); 2823| | 2824| 0| if (abro == NULL) { ------------------ | Branch (2824:8): [True: 0, False: 0] ------------------ 2825| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2826| 0| ABORT; ------------------ | | 504| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1238| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (504:49): [Folded, False: 0] | | ------------------ ------------------ 2827| 0| } 2828| | 2829| 0| memset(abro, 0, sizeof(struct AdvAbro)); 2830| 0| memcpy(&abro->LBRaddress, (yyvsp[-2].addr), sizeof(struct in6_addr)); 2831| 0| } 2832| 0|#line 2833 "gram.c" 2833| 0| break; 2834| | 2835| 0| case 138: /* abroparms: T_AdvVersionLow NUMBER ';' */ ------------------ | Branch (2835:3): [True: 0, False: 0] ------------------ 2836| 0|#line 1094 "gram.y" 2837| 0| { 2838| 0| abro->Version[1] = (yyvsp[-1].num); 2839| 0| } 2840| 0|#line 2841 "gram.c" 2841| 0| break; 2842| | 2843| 0| case 139: /* abroparms: T_AdvVersionHigh NUMBER ';' */ ------------------ | Branch (2843:3): [True: 0, False: 0] ------------------ 2844| 0|#line 1098 "gram.y" 2845| 0| { 2846| 0| abro->Version[0] = (yyvsp[-1].num); 2847| 0| } 2848| 0|#line 2849 "gram.c" 2849| 0| break; 2850| | 2851| 0| case 140: /* abroparms: T_AdvValidLifetime NUMBER ';' */ ------------------ | Branch (2851:3): [True: 0, False: 0] ------------------ 2852| 0|#line 1102 "gram.y" 2853| 0| { 2854| 0| abro->ValidLifeTime = (yyvsp[-1].num); 2855| 0| } 2856| 0|#line 2857 "gram.c" 2857| 0| break; 2858| | 2859| 0| case 141: /* number_or_infinity: NUMBER */ ------------------ | Branch (2859:3): [True: 0, False: 0] ------------------ 2860| 0|#line 1108 "gram.y" 2861| 0| { 2862| 0| (yyval.num) = (yyvsp[0].num); 2863| 0| } 2864| 0|#line 2865 "gram.c" 2865| 0| break; 2866| | 2867| 0| case 142: /* number_or_infinity: INFINITY */ ------------------ | Branch (2867:3): [True: 0, False: 0] ------------------ 2868| 0|#line 1112 "gram.y" 2869| 0| { 2870| 0| (yyval.num) = (uint32_t)~0; 2871| 0| } 2872| 0|#line 2873 "gram.c" 2873| 0| break; 2874| | 2875| | 2876| 0|#line 2877 "gram.c" 2877| | 2878| 0| default: break; ------------------ | Branch (2878:7): [True: 0, False: 0] ------------------ 2879| 0| } 2880| | /* User semantic actions sometimes alter yychar, and that requires 2881| | that yytoken be updated with the new translation. We take the 2882| | approach of translating immediately before every use of yytoken. 2883| | One alternative is translating here after every semantic action, 2884| | but that translation would be missed if the semantic action invokes 2885| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2886| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2887| | incorrect destructor might then be invoked immediately. In the 2888| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 2889| | to an incorrect destructor call or verbose syntax error message 2890| | before the lookahead is translated. */ 2891| 0| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 2892| | 2893| 0| YYPOPSTACK (yylen); ------------------ | | 1483| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2894| 0| yylen = 0; 2895| | 2896| 0| *++yyvsp = yyval; 2897| | 2898| | /* Now 'shift' the result of the reduction. Determine what state 2899| | that goes to, based on the state we popped back to and the rule 2900| | number reduced by. */ 2901| 0| { 2902| 0| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 834| 0|#define YYNTOKENS 81 ------------------ 2903| 0| const int yyi = yypgoto[yylhs] + *yyssp; 2904| 0| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 831| 0|#define YYLAST 298 ------------------ | Branch (2904:16): [True: 0, False: 0] | Branch (2904:28): [True: 0, False: 0] | Branch (2904:45): [True: 0, False: 0] ------------------ 2905| 0| ? yytable[yyi] 2906| 0| : yydefgoto[yylhs]); 2907| 0| } 2908| | 2909| 0| goto yynewstate; 2910| | 2911| | 2912| |/*--------------------------------------. 2913| || yyerrlab -- here on detecting error. | 2914| |`--------------------------------------*/ 2915| 606|yyerrlab: 2916| | /* Make sure we have latest lookahead translation. See comments at 2917| | user semantic actions for why this is necessary. */ 2918| 606| yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 227| 606|#define YYEMPTY -2 ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 849| 1.21k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 843| 606|#define YYMAXUTOK 331 | | ------------------ | | | Branch (849:4): [True: 606, False: 0] | | | Branch (849:18): [True: 606, False: 0] | | ------------------ | | 850| 1.21k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 112| 606|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 851| 1.21k| : YYSYMBOL_YYUNDEF) ------------------ | Branch (2918:13): [True: 0, False: 606] ------------------ 2919| | /* If not already recovering from an error, report this error. */ 2920| 606| if (!yyerrstatus) ------------------ | Branch (2920:7): [True: 606, False: 0] ------------------ 2921| 606| { 2922| 606| ++yynerrs; 2923| 606| yyerror (YY_("syntax error")); ------------------ | | 633| 606|# define YY_(Msgid) Msgid ------------------ 2924| 606| } 2925| | 2926| 606| if (yyerrstatus == 3) ------------------ | Branch (2926:7): [True: 0, False: 606] ------------------ 2927| 0| { 2928| | /* If just tried and failed to reuse lookahead token after an 2929| | error, discard it. */ 2930| | 2931| 0| if (yychar <= YYEOF) ------------------ | | 228| 0|#define YYEOF 0 ------------------ | Branch (2931:11): [True: 0, False: 0] ------------------ 2932| 0| { 2933| | /* Return failure if at end of input. */ 2934| 0| if (yychar == YYEOF) ------------------ | | 228| 0|#define YYEOF 0 ------------------ | Branch (2934:15): [True: 0, False: 0] ------------------ 2935| 0| YYABORT; ------------------ | | 1238| 0|#define YYABORT goto yyabortlab ------------------ 2936| 0| } 2937| 0| else 2938| 0| { 2939| 0| yydestruct ("Error: discarding", 2940| 0| yytoken, &yylval); 2941| 0| yychar = YYEMPTY; ------------------ | | 227| 0|#define YYEMPTY -2 ------------------ 2942| 0| } 2943| 0| } 2944| | 2945| | /* Else will try to reuse lookahead token after shifting the error 2946| | token. */ 2947| 606| goto yyerrlab1; 2948| | 2949| | 2950| |/*---------------------------------------------------. 2951| || yyerrorlab -- error raised explicitly by YYERROR. | 2952| |`---------------------------------------------------*/ 2953| 606|yyerrorlab: 2954| | /* Pacify compilers when the user code never invokes YYERROR and the 2955| | label yyerrorlab therefore never appears in user code. */ 2956| 0| if (0) ------------------ | Branch (2956:7): [Folded, False: 0] ------------------ 2957| 0| YYERROR; ------------------ | | 1239| 0|#define YYERROR goto yyerrorlab ------------------ 2958| 0| ++yynerrs; 2959| | 2960| | /* Do not reclaim the symbols of the rule whose action triggered 2961| | this YYERROR. */ 2962| 0| YYPOPSTACK (yylen); ------------------ | | 1483| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2963| 0| yylen = 0; 2964| 0| YY_STACK_PRINT (yyss, yyssp); 2965| 0| yystate = *yyssp; 2966| 0| goto yyerrlab1; 2967| | 2968| | 2969| |/*-------------------------------------------------------------. 2970| || yyerrlab1 -- common code for both syntax error and YYERROR. | 2971| |`-------------------------------------------------------------*/ 2972| 606|yyerrlab1: 2973| 606| yyerrstatus = 3; /* Each real token shifted decrements this. */ 2974| | 2975| | /* Pop stack until we find a state that shifts the error token. */ 2976| 606| for (;;) 2977| 606| { 2978| 606| yyn = yypact[yystate]; 2979| 606| if (!yypact_value_is_default (yyn)) ------------------ | | 976| 606| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 973| 606|#define YYPACT_NINF (-92) | | ------------------ ------------------ | Branch (2979:11): [True: 606, False: 0] ------------------ 2980| 606| { 2981| 606| yyn += YYSYMBOL_YYerror; 2982| 606| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 831| 1.21k|#define YYLAST 298 ------------------ | Branch (2982:15): [True: 606, False: 0] | Branch (2982:27): [True: 606, False: 0] | Branch (2982:44): [True: 0, False: 606] ------------------ 2983| 0| { 2984| 0| yyn = yytable[yyn]; 2985| 0| if (0 < yyn) ------------------ | Branch (2985:19): [True: 0, False: 0] ------------------ 2986| 0| break; 2987| 0| } 2988| 606| } 2989| | 2990| | /* Pop the current state because it cannot handle the error token. */ 2991| 606| if (yyssp == yyss) ------------------ | Branch (2991:11): [True: 606, False: 0] ------------------ 2992| 606| YYABORT; ------------------ | | 1238| 606|#define YYABORT goto yyabortlab ------------------ 2993| | 2994| | 2995| 0| yydestruct ("Error: popping", 2996| 0| YY_ACCESSING_SYMBOL (yystate), yyvsp); ------------------ | | 916| 0|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 2997| 0| YYPOPSTACK (1); ------------------ | | 1483| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2998| 0| yystate = *yyssp; 2999| 0| YY_STACK_PRINT (yyss, yyssp); 3000| 0| } 3001| | 3002| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3003| 0| *++yyvsp = yylval; 3004| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 3005| | 3006| | 3007| | /* Shift the error token. */ 3008| 0| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 3009| | 3010| 0| yystate = yyn; 3011| 0| goto yynewstate; 3012| | 3013| | 3014| |/*-------------------------------------. 3015| || yyacceptlab -- YYACCEPT comes here. | 3016| |`-------------------------------------*/ 3017| 0|yyacceptlab: 3018| 0| yyresult = 0; 3019| 0| goto yyreturnlab; 3020| | 3021| | 3022| |/*-----------------------------------. 3023| || yyabortlab -- YYABORT comes here. | 3024| |`-----------------------------------*/ 3025| 606|yyabortlab: 3026| 606| yyresult = 1; 3027| 606| goto yyreturnlab; 3028| | 3029| | 3030| |/*-----------------------------------------------------------. 3031| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 3032| |`-----------------------------------------------------------*/ 3033| 0|yyexhaustedlab: 3034| 0| yyerror (YY_("memory exhausted")); ------------------ | | 633| 0|# define YY_(Msgid) Msgid ------------------ 3035| 0| yyresult = 2; 3036| 0| goto yyreturnlab; 3037| | 3038| | 3039| |/*----------------------------------------------------------. 3040| || yyreturnlab -- parsing is finished, clean up and return. | 3041| |`----------------------------------------------------------*/ 3042| 606|yyreturnlab: 3043| 606| if (yychar != YYEMPTY) ------------------ | | 227| 606|#define YYEMPTY -2 ------------------ | Branch (3043:7): [True: 606, False: 0] ------------------ 3044| 606| { 3045| | /* Make sure we have latest lookahead translation. See comments at 3046| | user semantic actions for why this is necessary. */ 3047| 606| yytoken = YYTRANSLATE (yychar); ------------------ | | 849| 606| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 843| 606|#define YYMAXUTOK 331 | | ------------------ | | | Branch (849:4): [True: 606, False: 0] | | | Branch (849:18): [True: 606, False: 0] | | ------------------ | | 850| 606| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 112| 606|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 851| 606| : YYSYMBOL_YYUNDEF) ------------------ 3048| 606| yydestruct ("Cleanup: discarding lookahead", 3049| 606| yytoken, &yylval); 3050| 606| } 3051| | /* Do not reclaim the symbols of the rule whose action triggered 3052| | this YYABORT or YYACCEPT. */ 3053| 606| YYPOPSTACK (yylen); ------------------ | | 1483| 606|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 3054| 606| YY_STACK_PRINT (yyss, yyssp); 3055| 606| while (yyssp != yyss) ------------------ | Branch (3055:10): [True: 0, False: 606] ------------------ 3056| 0| { 3057| 0| yydestruct ("Cleanup: popping", 3058| 0| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); ------------------ | | 916| 0|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 3059| 0| YYPOPSTACK (1); ------------------ | | 1483| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 3060| 0| } 3061| 606|#ifndef yyoverflow 3062| 606| if (yyss != yyssa) ------------------ | Branch (3062:7): [True: 0, False: 606] ------------------ 3063| 0| YYSTACK_FREE (yyss); ------------------ | | 741| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 760| 0|# define YYFREE free | | ------------------ ------------------ 3064| 606|#endif 3065| | 3066| 606| return yyresult; 3067| 606|} readin_config: 3116| 606|{ 3117| 606| IfaceList = 0; 3118| 606| FILE * in = fopen(path, "r"); 3119| 606| if (in) { ------------------ | Branch (3119:6): [True: 606, False: 0] ------------------ 3120| 606| filename = path; 3121| 606| num_lines = 1; 3122| 606| iface = 0; 3123| | 3124| 606| yyset_in(in); 3125| 606| if (yyparse() != 0) { ------------------ | Branch (3125:7): [True: 606, False: 0] ------------------ 3126| 606| free_ifaces(iface); 3127| 606| iface = 0; 3128| 606| IfaceList = 0; 3129| 606| } else { 3130| 0| dlog(LOG_DEBUG, 1, "config file, %s, syntax ok", path); 3131| 0| } 3132| 606| yylex_destroy(); 3133| 606| fclose(in); 3134| 606| } 3135| | 3136| 606| return IfaceList; 3137| 606|} gram.c:yydestruct: 1422| 606|{ 1423| 606| YY_USE (yyvaluep); ------------------ | | 656| 606|# define YY_USE(E) ((void) (E)) ------------------ 1424| 606| if (!yymsg) ------------------ | Branch (1424:7): [True: 0, False: 606] ------------------ 1425| 0| yymsg = "Deleting"; 1426| 606| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 1427| | 1428| 606| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1429| 606| YY_USE (yykind); ------------------ | | 656| 606|# define YY_USE(E) ((void) (E)) ------------------ 1430| 606| YY_IGNORE_MAYBE_UNINITIALIZED_END 1431| 606|} gram.c:yyerror: 3140| 606|{ 3141| | fprintf(stderr, "%s:%d error: %s\n", 3142| 606| filename, 3143| 606| num_lines, 3144| 606| msg); 3145| 606|} free_ifaces: 468| 606|{ 469| 606| dlog(LOG_DEBUG, 3, "Freeing Interfaces"); 470| | 471| 606| free_iface_list(ifaces); 472| 606|} interface.c:free_iface_list: 399| 606|{ 400| 606| while (iface) { ------------------ | Branch (400:9): [True: 0, False: 606] ------------------ 401| 0| struct Interface *next_iface = iface->next; 402| | 403| 0| dlog(LOG_DEBUG, 4, "freeing interface %s", iface->props.name); 404| | 405| 0| struct AdvPrefix *prefix = iface->AdvPrefixList; 406| 0| while (prefix) { ------------------ | Branch (406:10): [True: 0, False: 0] ------------------ 407| 0| struct AdvPrefix *next_prefix = prefix->next; 408| | 409| 0| free(prefix); 410| 0| prefix = next_prefix; 411| 0| } 412| | 413| 0| struct AdvRoute *route = iface->AdvRouteList; 414| 0| while (route) { ------------------ | Branch (414:10): [True: 0, False: 0] ------------------ 415| 0| struct AdvRoute *next_route = route->next; 416| | 417| 0| free(route); 418| 0| route = next_route; 419| 0| } 420| | 421| 0| struct AdvRDNSS *rdnss = iface->AdvRDNSSList; 422| 0| while (rdnss) { ------------------ | Branch (422:10): [True: 0, False: 0] ------------------ 423| 0| struct AdvRDNSS *next_rdnss = rdnss->next; 424| | 425| 0| free(rdnss->AdvRDNSSAddr); 426| 0| free(rdnss); 427| 0| rdnss = next_rdnss; 428| 0| } 429| | 430| 0| struct AdvDNSSL *dnssl = iface->AdvDNSSLList; 431| 0| while (dnssl) { ------------------ | Branch (431:10): [True: 0, False: 0] ------------------ 432| 0| struct AdvDNSSL *next_dnssl = dnssl->next; 433| | 434| 0| for (int i = 0; i < dnssl->AdvDNSSLNumber; i++) ------------------ | Branch (434:20): [True: 0, False: 0] ------------------ 435| 0| free(dnssl->AdvDNSSLSuffixes[i]); 436| 0| free(dnssl->AdvDNSSLSuffixes); 437| 0| free(dnssl); 438| | 439| 0| dnssl = next_dnssl; 440| 0| } 441| | 442| 0| struct AutogenIgnorePrefix *ignore_prefixes = iface->IgnorePrefixList; 443| 0| while (ignore_prefixes) { ------------------ | Branch (443:10): [True: 0, False: 0] ------------------ 444| 0| struct AutogenIgnorePrefix *next_ignore_prefix = ignore_prefixes->next; 445| | 446| 0| free(ignore_prefixes); 447| 0| ignore_prefixes = next_ignore_prefix; 448| 0| } 449| | 450| 0| struct Clients *clients = iface->ClientList; 451| 0| while (clients) { ------------------ | Branch (451:10): [True: 0, False: 0] ------------------ 452| 0| struct Clients *next_client = clients->next; 453| | 454| 0| free(clients); 455| 0| clients = next_client; 456| 0| } 457| | 458| 0| free(iface->props.if_addrs); 459| | 460| 0| free(iface->AdvCaptivePortalAPI); 461| | 462| 0| free(iface); 463| 0| iface = next_iface; 464| 0| } 465| 606|} yylex: 1717| 606|{ 1718| 606| yy_state_type yy_current_state; 1719| 606| char *yy_cp, *yy_bp; 1720| 606| int yy_act; 1721| | 1722| 606| if ( !(yy_init) ) ------------------ | Branch (1722:7): [True: 606, False: 0] ------------------ 1723| 606| { 1724| 606| (yy_init) = 1; 1725| | 1726| |#ifdef YY_USER_INIT 1727| | YY_USER_INIT; 1728| |#endif 1729| | 1730| 606| if ( ! (yy_start) ) ------------------ | Branch (1730:8): [True: 606, False: 0] ------------------ 1731| 606| (yy_start) = 1; /* first start state */ 1732| | 1733| 606| if ( ! yyin ) ------------------ | Branch (1733:8): [True: 0, False: 606] ------------------ 1734| 0| yyin = stdin; 1735| | 1736| 606| if ( ! yyout ) ------------------ | Branch (1736:8): [True: 606, False: 0] ------------------ 1737| 606| yyout = stdout; 1738| | 1739| 606| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 278| 606|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 0, False: 606] | | ------------------ | | 279| 606| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 606| : NULL) ------------------ | Branch (1739:8): [True: 606, False: 0] ------------------ 1740| 606| yyensure_buffer_stack (); 1741| 606| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 284| 606|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 1742| 606| yy_create_buffer( yyin, YY_BUF_SIZE ); ------------------ | | 139| 606|#define YY_BUF_SIZE 16384 ------------------ 1743| 606| } 1744| | 1745| 606| yy_load_buffer_state( ); 1746| 606| } 1747| | 1748| 606| { 1749| 606|#line 40 "scanner.l" 1750| | 1751| | 1752| 606|#line 1753 "scanner.c" 1753| | 1754| 3.45M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1754:23): [True: 3.45M, Folded] ------------------ 1755| 3.45M| { 1756| 3.45M| yy_cp = (yy_c_buf_p); 1757| | 1758| | /* Support of yytext. */ 1759| 3.45M| *yy_cp = (yy_hold_char); 1760| | 1761| | /* yy_bp points to the position in yy_ch_buf of the start of 1762| | * the current run. 1763| | */ 1764| 3.45M| yy_bp = yy_cp; 1765| | 1766| 3.45M| yy_current_state = (yy_start); 1767| 3.51M|yy_match: 1768| 3.51M| do 1769| 16.4M| { 1770| 16.4M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 111| 16.4M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1771| 16.4M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1771:9): [True: 1.48M, False: 14.9M] ------------------ 1772| 1.48M| { 1773| 1.48M| (yy_last_accepting_state) = yy_current_state; 1774| 1.48M| (yy_last_accepting_cpos) = yy_cp; 1775| 1.48M| } 1776| 28.2M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1776:12): [True: 11.7M, False: 16.4M] ------------------ 1777| 11.7M| { 1778| 11.7M| yy_current_state = (int) yy_def[yy_current_state]; 1779| 11.7M| if ( yy_current_state >= 925 ) ------------------ | Branch (1779:10): [True: 11.6M, False: 96.8k] ------------------ 1780| 11.6M| yy_c = yy_meta[yy_c]; 1781| 11.7M| } 1782| 16.4M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1783| 16.4M| ++yy_cp; 1784| 16.4M| } 1785| 16.4M| while ( yy_base[yy_current_state] != 3263 ); ------------------ | Branch (1785:11): [True: 12.9M, False: 3.51M] ------------------ 1786| | 1787| 3.51M|yy_find_action: 1788| 3.51M| yy_act = yy_accept[yy_current_state]; 1789| 3.51M| if ( yy_act == 0 ) ------------------ | Branch (1789:8): [True: 68.3k, False: 3.45M] ------------------ 1790| 68.3k| { /* have to back up */ 1791| 68.3k| yy_cp = (yy_last_accepting_cpos); 1792| 68.3k| yy_current_state = (yy_last_accepting_state); 1793| 68.3k| yy_act = yy_accept[yy_current_state]; 1794| 68.3k| } 1795| | 1796| 3.51M| YY_DO_BEFORE_ACTION; ------------------ | | 371| 3.51M| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 360| 3.51M|#define yytext_ptr yytext | | ------------------ | | 372| 3.51M| yyleng = (int) (yy_cp - yy_bp); \ | | 373| 3.51M| (yy_hold_char) = *yy_cp; \ | | 374| 3.51M| *yy_cp = '\0'; \ | | 375| 3.51M| (yy_c_buf_p) = yy_cp; ------------------ 1797| | 1798| 3.51M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 377| 7.03M|#define YY_END_OF_BUFFER 84 ------------------ | Branch (1798:8): [True: 3.45M, False: 66.2k] | Branch (1798:38): [True: 3.43M, False: 16.2k] ------------------ 1799| 3.43M| { 1800| 3.43M| int yyl; 1801| 7.95M| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | Branch (1801:19): [True: 4.52M, False: 3.43M] ------------------ 1802| 4.52M| if ( yytext[yyl] == '\n' ) ------------------ | Branch (1802:10): [True: 3.43M, False: 1.08M] ------------------ 1803| | 1804| 3.43M| yylineno++; 1805| 3.43M|; 1806| 3.43M| } 1807| | 1808| 3.51M|do_action: /* This label is used only to access EOF actions. */ 1809| | 1810| 3.51M| switch ( yy_act ) 1811| 3.51M| { /* beginning of action switch */ 1812| 0| case 0: /* must back up */ ------------------ | Branch (1812:4): [True: 0, False: 3.51M] ------------------ 1813| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1814| 0| *yy_cp = (yy_hold_char); 1815| 0| yy_cp = (yy_last_accepting_cpos); 1816| 0| yy_current_state = (yy_last_accepting_state); 1817| 0| goto yy_find_action; 1818| | 1819| 14.1k|case 1: ------------------ | Branch (1819:1): [True: 14.1k, False: 3.50M] ------------------ 1820| 14.1k|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 1821| 14.1k|(yy_c_buf_p) = yy_cp -= 1; 1822| 14.1k|YY_DO_BEFORE_ACTION; /* set up yytext again */ ------------------ | | 371| 14.1k| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 360| 14.1k|#define yytext_ptr yytext | | ------------------ | | 372| 14.1k| yyleng = (int) (yy_cp - yy_bp); \ | | 373| 14.1k| (yy_hold_char) = *yy_cp; \ | | 374| 14.1k| *yy_cp = '\0'; \ | | 375| 14.1k| (yy_c_buf_p) = yy_cp; ------------------ 1823| 14.1k|YY_RULE_SETUP 1824| 14.1k|#line 42 "scanner.l" 1825| 14.1k|{/* ignore comments */} 1826| 14.1k| YY_BREAK ------------------ | | 1708| 14.1k|#define YY_BREAK /*LINTED*/break; ------------------ 1827| 3.43M|case 2: ------------------ | Branch (1827:1): [True: 3.43M, False: 82.9k] ------------------ 1828| |/* rule 2 can match eol */ 1829| 3.43M|YY_RULE_SETUP 1830| 3.43M|#line 43 "scanner.l" 1831| 3.43M|{num_lines++;} 1832| 3.43M| YY_BREAK ------------------ | | 1708| 3.43M|#define YY_BREAK /*LINTED*/break; ------------------ 1833| 1.87k|case 3: ------------------ | Branch (1833:1): [True: 1.87k, False: 3.51M] ------------------ 1834| 1.87k|YY_RULE_SETUP 1835| 1.87k|#line 44 "scanner.l" 1836| 1.87k|{} 1837| 1.87k| YY_BREAK ------------------ | | 1708| 1.87k|#define YY_BREAK /*LINTED*/break; ------------------ 1838| 0|case 4: ------------------ | Branch (1838:1): [True: 0, False: 3.51M] ------------------ 1839| 0|YY_RULE_SETUP 1840| 0|#line 46 "scanner.l" 1841| 0|{ return T_INTERFACE; } ------------------ | | 139| 0|#define T_INTERFACE 258 ------------------ 1842| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1843| 2|case 5: ------------------ | Branch (1843:1): [True: 2, False: 3.51M] ------------------ 1844| 2|YY_RULE_SETUP 1845| 2|#line 47 "scanner.l" 1846| 2|{ return T_PREFIX; } ------------------ | | 140| 2|#define T_PREFIX 259 ------------------ 1847| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1848| 1|case 6: ------------------ | Branch (1848:1): [True: 1, False: 3.51M] ------------------ 1849| 1|YY_RULE_SETUP 1850| 1|#line 48 "scanner.l" 1851| 1|{ return T_ROUTE; } ------------------ | | 141| 1|#define T_ROUTE 260 ------------------ 1852| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1853| 1|case 7: ------------------ | Branch (1853:1): [True: 1, False: 3.51M] ------------------ 1854| 1|YY_RULE_SETUP 1855| 1|#line 49 "scanner.l" 1856| 1|{ return T_RDNSS; } ------------------ | | 142| 1|#define T_RDNSS 261 ------------------ 1857| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1858| 2|case 8: ------------------ | Branch (1858:1): [True: 2, False: 3.51M] ------------------ 1859| 2|YY_RULE_SETUP 1860| 2|#line 50 "scanner.l" 1861| 2|{ return T_DNSSL; } ------------------ | | 143| 2|#define T_DNSSL 262 ------------------ 1862| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1863| 0|case 9: ------------------ | Branch (1863:1): [True: 0, False: 3.51M] ------------------ 1864| 0|YY_RULE_SETUP 1865| 0|#line 51 "scanner.l" 1866| 0|{ return T_CLIENTS; } ------------------ | | 144| 0|#define T_CLIENTS 263 ------------------ 1867| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1868| 0|case 10: ------------------ | Branch (1868:1): [True: 0, False: 3.51M] ------------------ 1869| 0|YY_RULE_SETUP 1870| 0|#line 52 "scanner.l" 1871| 0|{ return T_LOWPANCO; } ------------------ | | 145| 0|#define T_LOWPANCO 264 ------------------ 1872| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1873| 1|case 11: ------------------ | Branch (1873:1): [True: 1, False: 3.51M] ------------------ 1874| 1|YY_RULE_SETUP 1875| 1|#line 53 "scanner.l" 1876| 1|{ return T_ABRO; } ------------------ | | 146| 1|#define T_ABRO 265 ------------------ 1877| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1878| 0|case 12: ------------------ | Branch (1878:1): [True: 0, False: 3.51M] ------------------ 1879| 0|YY_RULE_SETUP 1880| 0|#line 54 "scanner.l" 1881| 0|{ return T_NAT64PREFIX; } ------------------ | | 148| 0|#define T_NAT64PREFIX 267 ------------------ 1882| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1883| 0|case 13: ------------------ | Branch (1883:1): [True: 0, False: 3.51M] ------------------ 1884| 0|YY_RULE_SETUP 1885| 0|#line 55 "scanner.l" 1886| 0|{ return T_AUTOIGNOREPREFIX; } ------------------ | | 149| 0|#define T_AUTOIGNOREPREFIX 268 ------------------ 1887| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1888| 0|case 14: ------------------ | Branch (1888:1): [True: 0, False: 3.51M] ------------------ 1889| 0|YY_RULE_SETUP 1890| 0|#line 57 "scanner.l" 1891| 0|{ return T_RASRCADDRESS; } ------------------ | | 147| 0|#define T_RASRCADDRESS 266 ------------------ 1892| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1893| 0|case 15: ------------------ | Branch (1893:1): [True: 0, False: 3.51M] ------------------ 1894| 0|YY_RULE_SETUP 1895| 0|#line 59 "scanner.l" 1896| 0|{ return T_IgnoreIfMissing; } ------------------ | | 158| 0|#define T_IgnoreIfMissing 277 ------------------ 1897| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1898| 0|case 16: ------------------ | Branch (1898:1): [True: 0, False: 3.51M] ------------------ 1899| 0|YY_RULE_SETUP 1900| 0|#line 60 "scanner.l" 1901| 0|{ return T_AdvSendAdvert; } ------------------ | | 159| 0|#define T_AdvSendAdvert 278 ------------------ 1902| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1903| 0|case 17: ------------------ | Branch (1903:1): [True: 0, False: 3.51M] ------------------ 1904| 0|YY_RULE_SETUP 1905| 0|#line 61 "scanner.l" 1906| 0|{ return T_MaxRtrAdvInterval; } ------------------ | | 160| 0|#define T_MaxRtrAdvInterval 279 ------------------ 1907| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1908| 0|case 18: ------------------ | Branch (1908:1): [True: 0, False: 3.51M] ------------------ 1909| 0|YY_RULE_SETUP 1910| 0|#line 62 "scanner.l" 1911| 0|{ return T_MinRtrAdvInterval; } ------------------ | | 161| 0|#define T_MinRtrAdvInterval 280 ------------------ 1912| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1913| 0|case 19: ------------------ | Branch (1913:1): [True: 0, False: 3.51M] ------------------ 1914| 0|YY_RULE_SETUP 1915| 0|#line 63 "scanner.l" 1916| 0|{ return T_AdvManagedFlag; } ------------------ | | 163| 0|#define T_AdvManagedFlag 282 ------------------ 1917| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1918| 0|case 20: ------------------ | Branch (1918:1): [True: 0, False: 3.51M] ------------------ 1919| 0|YY_RULE_SETUP 1920| 0|#line 64 "scanner.l" 1921| 0|{ return T_AdvOtherConfigFlag; } ------------------ | | 164| 0|#define T_AdvOtherConfigFlag 283 ------------------ 1922| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1923| 0|case 21: ------------------ | Branch (1923:1): [True: 0, False: 3.51M] ------------------ 1924| 0|YY_RULE_SETUP 1925| 0|#line 65 "scanner.l" 1926| 0|{ return T_AdvLinkMTU; } ------------------ | | 165| 0|#define T_AdvLinkMTU 284 ------------------ 1927| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1928| 0|case 22: ------------------ | Branch (1928:1): [True: 0, False: 3.51M] ------------------ 1929| 0|YY_RULE_SETUP 1930| 0|#line 66 "scanner.l" 1931| 0|{ return T_AdvRAMTU; } ------------------ | | 166| 0|#define T_AdvRAMTU 285 ------------------ 1932| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1933| 0|case 23: ------------------ | Branch (1933:1): [True: 0, False: 3.51M] ------------------ 1934| 0|YY_RULE_SETUP 1935| 0|#line 67 "scanner.l" 1936| 0|{ return T_AdvReachableTime; } ------------------ | | 167| 0|#define T_AdvReachableTime 286 ------------------ 1937| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1938| 0|case 24: ------------------ | Branch (1938:1): [True: 0, False: 3.51M] ------------------ 1939| 0|YY_RULE_SETUP 1940| 0|#line 68 "scanner.l" 1941| 0|{ return T_AdvRetransTimer; } ------------------ | | 168| 0|#define T_AdvRetransTimer 287 ------------------ 1942| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1943| 0|case 25: ------------------ | Branch (1943:1): [True: 0, False: 3.51M] ------------------ 1944| 0|YY_RULE_SETUP 1945| 0|#line 69 "scanner.l" 1946| 0|{ return T_AdvCurHopLimit; } ------------------ | | 169| 0|#define T_AdvCurHopLimit 288 ------------------ 1947| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1948| 0|case 26: ------------------ | Branch (1948:1): [True: 0, False: 3.51M] ------------------ 1949| 0|YY_RULE_SETUP 1950| 0|#line 70 "scanner.l" 1951| 0|{ return T_AdvDefaultLifetime; } ------------------ | | 170| 0|#define T_AdvDefaultLifetime 289 ------------------ 1952| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1953| 0|case 27: ------------------ | Branch (1953:1): [True: 0, False: 3.51M] ------------------ 1954| 0|YY_RULE_SETUP 1955| 0|#line 71 "scanner.l" 1956| 0|{ return T_AdvDefaultPreference; } ------------------ | | 171| 0|#define T_AdvDefaultPreference 290 ------------------ 1957| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1958| 0|case 28: ------------------ | Branch (1958:1): [True: 0, False: 3.51M] ------------------ 1959| 0|YY_RULE_SETUP 1960| 0|#line 72 "scanner.l" 1961| 0|{ return T_AdvSourceLLAddress; } ------------------ | | 172| 0|#define T_AdvSourceLLAddress 291 ------------------ 1962| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1963| 0|case 29: ------------------ | Branch (1963:1): [True: 0, False: 3.51M] ------------------ 1964| 0|YY_RULE_SETUP 1965| 0|#line 73 "scanner.l" 1966| 0|{ return T_RemoveAdvOnExit; } ------------------ | | 173| 0|#define T_RemoveAdvOnExit 292 ------------------ 1967| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1968| 0|case 30: ------------------ | Branch (1968:1): [True: 0, False: 3.51M] ------------------ 1969| 0|YY_RULE_SETUP 1970| 0|#line 75 "scanner.l" 1971| 0|{ return T_AdvOnLink; } ------------------ | | 174| 0|#define T_AdvOnLink 293 ------------------ 1972| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1973| 0|case 31: ------------------ | Branch (1973:1): [True: 0, False: 3.51M] ------------------ 1974| 0|YY_RULE_SETUP 1975| 0|#line 76 "scanner.l" 1976| 0|{ return T_AdvAutonomous; } ------------------ | | 175| 0|#define T_AdvAutonomous 294 ------------------ 1977| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1978| 0|case 32: ------------------ | Branch (1978:1): [True: 0, False: 3.51M] ------------------ 1979| 0|YY_RULE_SETUP 1980| 0|#line 77 "scanner.l" 1981| 0|{ return T_AdvDHCPv6PDPreferred; } ------------------ | | 176| 0|#define T_AdvDHCPv6PDPreferred 295 ------------------ 1982| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1983| 0|case 33: ------------------ | Branch (1983:1): [True: 0, False: 3.51M] ------------------ 1984| 0|YY_RULE_SETUP 1985| 0|#line 78 "scanner.l" 1986| 0|{ return T_AdvValidLifetime; } ------------------ | | 177| 0|#define T_AdvValidLifetime 296 ------------------ 1987| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1988| 0|case 34: ------------------ | Branch (1988:1): [True: 0, False: 3.51M] ------------------ 1989| 0|YY_RULE_SETUP 1990| 0|#line 79 "scanner.l" 1991| 0|{ return T_AdvPreferredLifetime; } ------------------ | | 178| 0|#define T_AdvPreferredLifetime 297 ------------------ 1992| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1993| 0|case 35: ------------------ | Branch (1993:1): [True: 0, False: 3.51M] ------------------ 1994| 0|YY_RULE_SETUP 1995| 0|#line 80 "scanner.l" 1996| 0|{ return T_DeprecatePrefix; } ------------------ | | 179| 0|#define T_DeprecatePrefix 298 ------------------ 1997| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1998| 0|case 36: ------------------ | Branch (1998:1): [True: 0, False: 3.51M] ------------------ 1999| 0|YY_RULE_SETUP 2000| 0|#line 81 "scanner.l" 2001| 0|{ return T_DecrementLifetimes; } ------------------ | | 180| 0|#define T_DecrementLifetimes 299 ------------------ 2002| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2003| 0|case 37: ------------------ | Branch (2003:1): [True: 0, False: 3.51M] ------------------ 2004| 0|YY_RULE_SETUP 2005| 0|#line 83 "scanner.l" 2006| 0|{ return T_AdvRouterAddr; } ------------------ | | 181| 0|#define T_AdvRouterAddr 300 ------------------ 2007| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2008| 0|case 38: ------------------ | Branch (2008:1): [True: 0, False: 3.51M] ------------------ 2009| 0|YY_RULE_SETUP 2010| 0|#line 84 "scanner.l" 2011| 0|{ return T_AdvHomeAgentFlag; } ------------------ | | 182| 0|#define T_AdvHomeAgentFlag 301 ------------------ 2012| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2013| 0|case 39: ------------------ | Branch (2013:1): [True: 0, False: 3.51M] ------------------ 2014| 0|YY_RULE_SETUP 2015| 0|#line 85 "scanner.l" 2016| 0|{ return T_AdvIntervalOpt; } ------------------ | | 183| 0|#define T_AdvIntervalOpt 302 ------------------ 2017| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2018| 0|case 40: ------------------ | Branch (2018:1): [True: 0, False: 3.51M] ------------------ 2019| 0|YY_RULE_SETUP 2020| 0|#line 86 "scanner.l" 2021| 0|{ return T_AdvHomeAgentInfo; } ------------------ | | 184| 0|#define T_AdvHomeAgentInfo 303 ------------------ 2022| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2023| 0|case 41: ------------------ | Branch (2023:1): [True: 0, False: 3.51M] ------------------ 2024| 0|YY_RULE_SETUP 2025| 0|#line 87 "scanner.l" 2026| 0|{ return T_UnicastOnly; } ------------------ | | 188| 0|#define T_UnicastOnly 307 ------------------ 2027| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2028| 0|case 42: ------------------ | Branch (2028:1): [True: 0, False: 3.51M] ------------------ 2029| 0|YY_RULE_SETUP 2030| 0|#line 88 "scanner.l" 2031| 0|{ return T_UnrestrictedUnicast; } ------------------ | | 189| 0|#define T_UnrestrictedUnicast 308 ------------------ 2032| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2033| 0|case 43: ------------------ | Branch (2033:1): [True: 0, False: 3.51M] ------------------ 2034| 0|YY_RULE_SETUP 2035| 0|#line 89 "scanner.l" 2036| 0|{ return T_AdvRASolicitedUnicast; } ------------------ | | 190| 0|#define T_AdvRASolicitedUnicast 309 ------------------ 2037| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2038| 0|case 44: ------------------ | Branch (2038:1): [True: 0, False: 3.51M] ------------------ 2039| 0|YY_RULE_SETUP 2040| 0|#line 90 "scanner.l" 2041| 0|{ return T_AdvCaptivePortalAPI; } ------------------ | | 191| 0|#define T_AdvCaptivePortalAPI 310 ------------------ 2042| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2043| 0|case 45: ------------------ | Branch (2043:1): [True: 0, False: 3.51M] ------------------ 2044| 0|YY_RULE_SETUP 2045| 0|#line 91 "scanner.l" 2046| 0|{ return T_AdvSNACRouterFlag; } ------------------ | | 185| 0|#define T_AdvSNACRouterFlag 304 ------------------ 2047| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2048| 0|case 46: ------------------ | Branch (2048:1): [True: 0, False: 3.51M] ------------------ 2049| 0|YY_RULE_SETUP 2050| 0|#line 93 "scanner.l" 2051| 0|{ return T_Base6Interface; } ------------------ | | 186| 0|#define T_Base6Interface 305 ------------------ 2052| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2053| 0|case 47: ------------------ | Branch (2053:1): [True: 0, False: 3.51M] ------------------ 2054| 0|YY_RULE_SETUP 2055| 0|#line 94 "scanner.l" 2056| 0|{ return T_Base6to4Interface; } ------------------ | | 187| 0|#define T_Base6to4Interface 306 ------------------ 2057| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2058| 0|case 48: ------------------ | Branch (2058:1): [True: 0, False: 3.51M] ------------------ 2059| 0|YY_RULE_SETUP 2060| 0|#line 96 "scanner.l" 2061| 0|{ return T_HomeAgentPreference; } ------------------ | | 192| 0|#define T_HomeAgentPreference 311 ------------------ 2062| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2063| 0|case 49: ------------------ | Branch (2063:1): [True: 0, False: 3.51M] ------------------ 2064| 0|YY_RULE_SETUP 2065| 0|#line 97 "scanner.l" 2066| 0|{ return T_HomeAgentLifetime; } ------------------ | | 193| 0|#define T_HomeAgentLifetime 312 ------------------ 2067| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2068| 0|case 50: ------------------ | Branch (2068:1): [True: 0, False: 3.51M] ------------------ 2069| 0|YY_RULE_SETUP 2070| 0|#line 99 "scanner.l" 2071| 0|{ return T_AdvRoutePreference; } ------------------ | | 194| 0|#define T_AdvRoutePreference 313 ------------------ 2072| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2073| 0|case 51: ------------------ | Branch (2073:1): [True: 0, False: 3.51M] ------------------ 2074| 0|YY_RULE_SETUP 2075| 0|#line 100 "scanner.l" 2076| 0|{ return T_AdvRouteLifetime; } ------------------ | | 195| 0|#define T_AdvRouteLifetime 314 ------------------ 2077| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2078| 0|case 52: ------------------ | Branch (2078:1): [True: 0, False: 3.51M] ------------------ 2079| 0|YY_RULE_SETUP 2080| 0|#line 101 "scanner.l" 2081| 0|{ return T_RemoveRoute; } ------------------ | | 196| 0|#define T_RemoveRoute 315 ------------------ 2082| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2083| 0|case 53: ------------------ | Branch (2083:1): [True: 0, False: 3.51M] ------------------ 2084| 0|YY_RULE_SETUP 2085| 0|#line 103 "scanner.l" 2086| 0|{ return T_AdvRDNSSPreference; } ------------------ | | 197| 0|#define T_AdvRDNSSPreference 316 ------------------ 2087| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2088| 0|case 54: ------------------ | Branch (2088:1): [True: 0, False: 3.51M] ------------------ 2089| 0|YY_RULE_SETUP 2090| 0|#line 104 "scanner.l" 2091| 0|{ return T_AdvRDNSSOpenFlag; } ------------------ | | 198| 0|#define T_AdvRDNSSOpenFlag 317 ------------------ 2092| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2093| 0|case 55: ------------------ | Branch (2093:1): [True: 0, False: 3.51M] ------------------ 2094| 0|YY_RULE_SETUP 2095| 0|#line 105 "scanner.l" 2096| 0|{ return T_AdvRDNSSLifetime; } ------------------ | | 199| 0|#define T_AdvRDNSSLifetime 318 ------------------ 2097| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2098| 0|case 56: ------------------ | Branch (2098:1): [True: 0, False: 3.51M] ------------------ 2099| 0|YY_RULE_SETUP 2100| 0|#line 106 "scanner.l" 2101| 0|{ return T_FlushRDNSS; } ------------------ | | 200| 0|#define T_FlushRDNSS 319 ------------------ 2102| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2103| 0|case 57: ------------------ | Branch (2103:1): [True: 0, False: 3.51M] ------------------ 2104| 0|YY_RULE_SETUP 2105| 0|#line 108 "scanner.l" 2106| 0|{ return T_AdvDNSSLLifetime; } ------------------ | | 201| 0|#define T_AdvDNSSLLifetime 320 ------------------ 2107| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2108| 0|case 58: ------------------ | Branch (2108:1): [True: 0, False: 3.51M] ------------------ 2109| 0|YY_RULE_SETUP 2110| 0|#line 109 "scanner.l" 2111| 0|{ return T_FlushDNSSL; } ------------------ | | 202| 0|#define T_FlushDNSSL 321 ------------------ 2112| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2113| 0|case 59: ------------------ | Branch (2113:1): [True: 0, False: 3.51M] ------------------ 2114| 0|YY_RULE_SETUP 2115| 0|#line 111 "scanner.l" 2116| 0|{ return T_MinDelayBetweenRAs; } ------------------ | | 162| 0|#define T_MinDelayBetweenRAs 281 ------------------ 2117| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2118| 0|case 60: ------------------ | Branch (2118:1): [True: 0, False: 3.51M] ------------------ 2119| 0|YY_RULE_SETUP 2120| 0|#line 113 "scanner.l" 2121| 0|{ return T_AdvMobRtrSupportFlag; } ------------------ | | 203| 0|#define T_AdvMobRtrSupportFlag 322 ------------------ 2122| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2123| 0|case 61: ------------------ | Branch (2123:1): [True: 0, False: 3.51M] ------------------ 2124| 0|YY_RULE_SETUP 2125| 0|#line 115 "scanner.l" 2126| 0|{ return T_AdvContextLength; } ------------------ | | 204| 0|#define T_AdvContextLength 323 ------------------ 2127| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2128| 0|case 62: ------------------ | Branch (2128:1): [True: 0, False: 3.51M] ------------------ 2129| 0|YY_RULE_SETUP 2130| 0|#line 116 "scanner.l" 2131| 0|{ return T_AdvContextCompressionFlag; } ------------------ | | 205| 0|#define T_AdvContextCompressionFlag 324 ------------------ 2132| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2133| 0|case 63: ------------------ | Branch (2133:1): [True: 0, False: 3.51M] ------------------ 2134| 0|YY_RULE_SETUP 2135| 0|#line 117 "scanner.l" 2136| 0|{ return T_AdvContextID; } ------------------ | | 206| 0|#define T_AdvContextID 325 ------------------ 2137| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2138| 0|case 64: ------------------ | Branch (2138:1): [True: 0, False: 3.51M] ------------------ 2139| 0|YY_RULE_SETUP 2140| 0|#line 118 "scanner.l" 2141| 0|{ return T_AdvLifeTime; } ------------------ | | 207| 0|#define T_AdvLifeTime 326 ------------------ 2142| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2143| 0|case 65: ------------------ | Branch (2143:1): [True: 0, False: 3.51M] ------------------ 2144| 0|YY_RULE_SETUP 2145| 0|#line 119 "scanner.l" 2146| 0|{ return T_AdvContextPrefix; } ------------------ | | 208| 0|#define T_AdvContextPrefix 327 ------------------ 2147| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2148| 0|case 66: ------------------ | Branch (2148:1): [True: 0, False: 3.51M] ------------------ 2149| 0|YY_RULE_SETUP 2150| 0|#line 121 "scanner.l" 2151| 0|{ return T_AdvVersionLow; } ------------------ | | 209| 0|#define T_AdvVersionLow 328 ------------------ 2152| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2153| 0|case 67: ------------------ | Branch (2153:1): [True: 0, False: 3.51M] ------------------ 2154| 0|YY_RULE_SETUP 2155| 0|#line 122 "scanner.l" 2156| 0|{ return T_AdvVersionHigh; } ------------------ | | 210| 0|#define T_AdvVersionHigh 329 ------------------ 2157| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2158| 0|case 68: ------------------ | Branch (2158:1): [True: 0, False: 3.51M] ------------------ 2159| 0|YY_RULE_SETUP 2160| 0|#line 123 "scanner.l" 2161| 0|{ return T_Adv6LBRaddress; } ------------------ | | 211| 0|#define T_Adv6LBRaddress 330 ------------------ 2162| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2163| 3|case 69: ------------------ | Branch (2163:1): [True: 3, False: 3.51M] ------------------ 2164| 3|YY_RULE_SETUP 2165| 3|#line 125 "scanner.l" 2166| 3|{ 2167| 3| static struct in6_addr addr; 2168| 3| if (inet_pton(AF_INET6, yytext, &addr) < 1) { ------------------ | Branch (2168:8): [True: 1, False: 2] ------------------ 2169| 1| return T_BAD_TOKEN; ------------------ | | 212| 1|#define T_BAD_TOKEN 331 ------------------ 2170| 1| } 2171| | 2172| 2| yylval.addr = &addr; 2173| 2| return IPV6ADDR; ------------------ | | 155| 2|#define IPV6ADDR 274 ------------------ 2174| 3| } 2175| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2176| 3|case 70: ------------------ | Branch (2176:1): [True: 3, False: 3.51M] ------------------ 2177| 3|YY_RULE_SETUP 2178| 3|#line 135 "scanner.l" 2179| 3|{ 2180| 3| static struct in6_addr addr; 2181| 3| if (inet_pton(AF_INET6, &yytext[1], &addr) < 1) { ------------------ | Branch (2181:8): [True: 1, False: 2] ------------------ 2182| 1| return T_BAD_TOKEN; ------------------ | | 212| 1|#define T_BAD_TOKEN 331 ------------------ 2183| 1| } 2184| | 2185| 2| yylval.addr = &addr; 2186| 2| return NOT_IPV6ADDR; ------------------ | | 156| 2|#define NOT_IPV6ADDR 275 ------------------ 2187| 3| } 2188| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2189| 140|case 71: ------------------ | Branch (2189:1): [True: 140, False: 3.51M] ------------------ 2190| 140|YY_RULE_SETUP 2191| 140|#line 145 "scanner.l" 2192| 140|{ 2193| 140| unsigned long lnum; 2194| 140| char *endp; 2195| 140| lnum = strtoul(yytext, &endp, 10); 2196| 140| if (*yytext == '\0' || *endp != '\0') ------------------ | Branch (2196:8): [True: 0, False: 140] | Branch (2196:27): [True: 0, False: 140] ------------------ 2197| 0| return T_BAD_TOKEN; ------------------ | | 212| 0|#define T_BAD_TOKEN 331 ------------------ 2198| 140| if (lnum > 0xFFFFFFFFUL) ------------------ | Branch (2198:8): [True: 68, False: 72] ------------------ 2199| 68| return T_BAD_TOKEN; /* XXX */ ------------------ | | 212| 68|#define T_BAD_TOKEN 331 ------------------ 2200| 72| yylval.num = lnum; 2201| 72| return NUMBER; ------------------ | | 151| 72|#define NUMBER 270 ------------------ 2202| 140| } 2203| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2204| 2|case 72: ------------------ | Branch (2204:1): [True: 2, False: 3.51M] ------------------ 2205| 2|YY_RULE_SETUP 2206| 2|#line 157 "scanner.l" 2207| 2|{ yylval.snum = atoi(yytext); return SIGNEDNUMBER; } ------------------ | | 152| 2|#define SIGNEDNUMBER 271 ------------------ 2208| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2209| 1|case 73: ------------------ | Branch (2209:1): [True: 1, False: 3.51M] ------------------ 2210| 1|YY_RULE_SETUP 2211| 1|#line 159 "scanner.l" 2212| 1|{ yylval.dec = atof(yytext); return DECIMAL; } ------------------ | | 153| 1|#define DECIMAL 272 ------------------ 2213| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2214| 1|case 74: ------------------ | Branch (2214:1): [True: 1, False: 3.51M] ------------------ 2215| 1|YY_RULE_SETUP 2216| 1|#line 161 "scanner.l" 2217| 1|{ return INFINITY; } ------------------ | | 157| 1|#define INFINITY 276 ------------------ 2218| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2219| 2|case 75: ------------------ | Branch (2219:1): [True: 2, False: 3.51M] ------------------ 2220| 2|YY_RULE_SETUP 2221| 2|#line 163 "scanner.l" 2222| 2|{ yylval.num = 1; return SWITCH; } ------------------ | | 154| 2|#define SWITCH 273 ------------------ 2223| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2224| 1|case 76: ------------------ | Branch (2224:1): [True: 1, False: 3.51M] ------------------ 2225| 1|YY_RULE_SETUP 2226| 1|#line 165 "scanner.l" 2227| 1|{ yylval.num = 0; return SWITCH; } ------------------ | | 154| 1|#define SWITCH 273 ------------------ 2228| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2229| 1|case 77: ------------------ | Branch (2229:1): [True: 1, False: 3.51M] ------------------ 2230| 1|YY_RULE_SETUP 2231| 1|#line 167 "scanner.l" 2232| 1|{ yylval.snum = -1; return SIGNEDNUMBER; } ------------------ | | 152| 1|#define SIGNEDNUMBER 271 ------------------ 2233| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2234| 0|case 78: ------------------ | Branch (2234:1): [True: 0, False: 3.51M] ------------------ 2235| 0|YY_RULE_SETUP 2236| 0|#line 169 "scanner.l" 2237| 0|{ yylval.snum = 0; return SIGNEDNUMBER; } ------------------ | | 152| 0|#define SIGNEDNUMBER 271 ------------------ 2238| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2239| 2|case 79: ------------------ | Branch (2239:1): [True: 2, False: 3.51M] ------------------ 2240| 2|YY_RULE_SETUP 2241| 2|#line 171 "scanner.l" 2242| 2|{ yylval.snum = 1; return SIGNEDNUMBER; } ------------------ | | 152| 2|#define SIGNEDNUMBER 271 ------------------ 2243| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2244| 280|case 80: ------------------ | Branch (2244:1): [True: 280, False: 3.51M] ------------------ 2245| |/* rule 80 can match eol */ 2246| 280|YY_RULE_SETUP 2247| 280|#line 173 "scanner.l" 2248| 280|{ 2249| 280| static char string[256]; 2250| | 2251| 280| strncpy(string, yytext, sizeof(string)); 2252| 280| string[sizeof(string)-1] = '\0'; 2253| 280| yylval.str = string; 2254| 280| return STRING; ------------------ | | 150| 280|#define STRING 269 ------------------ 2255| 140| } 2256| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2257| 5|case 81: ------------------ | Branch (2257:1): [True: 5, False: 3.51M] ------------------ 2258| 5|YY_RULE_SETUP 2259| 5|#line 182 "scanner.l" 2260| 5|{ return *yytext; } 2261| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2262| 105|case 82: ------------------ | Branch (2262:1): [True: 105, False: 3.51M] ------------------ 2263| 105|YY_RULE_SETUP 2264| 105|#line 184 "scanner.l" 2265| 105|{ return T_BAD_TOKEN; } ------------------ | | 212| 105|#define T_BAD_TOKEN 331 ------------------ 2266| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2267| 0|case 83: ------------------ | Branch (2267:1): [True: 0, False: 3.51M] ------------------ 2268| 0|YY_RULE_SETUP 2269| 0|#line 185 "scanner.l" 2270| 0|ECHO; ------------------ | | 1629| 0|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | Branch (1629:23): [True: 0, False: 0] | | | Branch (1629:80): [Folded, False: 0] | | ------------------ ------------------ 2271| 0| YY_BREAK ------------------ | | 1708| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2272| 0|#line 2273 "scanner.c" 2273| 53|case YY_STATE_EOF(INITIAL): ------------------ | | 125| 53|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 377| 53|#define YY_END_OF_BUFFER 84 | | ------------------ ------------------ | Branch (2273:1): [True: 53, False: 3.51M] ------------------ 2274| 53| yyterminate(); ------------------ | | 1673| 53|#define yyterminate() return YY_NULL | | ------------------ | | | | 106| 53|#define YY_NULL 0 | | ------------------ ------------------ 2275| | 2276| 66.2k| case YY_END_OF_BUFFER: ------------------ | | 377| 66.2k|#define YY_END_OF_BUFFER 84 ------------------ | Branch (2276:2): [True: 66.2k, False: 3.45M] ------------------ 2277| 66.2k| { 2278| | /* Amount of text matched not including the EOB char. */ 2279| 66.2k| int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; ------------------ | | 360| 66.2k|#define yytext_ptr yytext ------------------ 2280| | 2281| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 2282| 66.2k| *yy_cp = (yy_hold_char); 2283| 66.2k| YY_RESTORE_YY_MORE_OFFSET 2284| | 2285| 66.2k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 284| 66.2k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 250| 66.2k|#define YY_BUFFER_NEW 0 ------------------ | Branch (2285:8): [True: 606, False: 65.6k] ------------------ 2286| 606| { 2287| | /* We're scanning a new file or input source. It's 2288| | * possible that this happened because the user 2289| | * just pointed yyin at a new source and called 2290| | * yylex(). If so, then we have to assure 2291| | * consistency between YY_CURRENT_BUFFER and our 2292| | * globals. Here is the right place to do so, because 2293| | * this is the first action (other than possibly a 2294| | * back-up) that will match for the new input source. 2295| | */ 2296| 606| (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 284| 606|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2297| 606| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 284| 606|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2298| 606| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 284| 606|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 251| 606|#define YY_BUFFER_NORMAL 1 ------------------ 2299| 606| } 2300| | 2301| | /* Note that here we test for yy_c_buf_p "<=" to the position 2302| | * of the first EOB in the buffer, since yy_c_buf_p will 2303| | * already have been incremented past the NUL character 2304| | * (since all states make transitions on EOB to the 2305| | * end-of-buffer state). Contrast this with the test 2306| | * in input(). 2307| | */ 2308| 66.2k| if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) ------------------ | | 284| 66.2k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (2308:8): [True: 62.9k, False: 3.30k] ------------------ 2309| 62.9k| { /* This was really a NUL. */ 2310| 62.9k| yy_state_type yy_next_state; 2311| | 2312| 62.9k| (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; ------------------ | | 360| 62.9k|#define yytext_ptr yytext ------------------ 2313| | 2314| 62.9k| yy_current_state = yy_get_previous_state( ); 2315| | 2316| | /* Okay, we're now positioned to make the NUL 2317| | * transition. We couldn't have 2318| | * yy_get_previous_state() go ahead and do it 2319| | * for us because it doesn't know how to deal 2320| | * with the possibility of jamming (and we don't 2321| | * want to build jamming into it because then it 2322| | * will run more slowly). 2323| | */ 2324| | 2325| 62.9k| yy_next_state = yy_try_NUL_trans( yy_current_state ); 2326| | 2327| 62.9k| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 360| 62.9k|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 1506| 62.9k|#define YY_MORE_ADJ 0 ------------------ 2328| | 2329| 62.9k| if ( yy_next_state ) ------------------ | Branch (2329:9): [True: 62.8k, False: 84] ------------------ 2330| 62.8k| { 2331| | /* Consume the NUL. */ 2332| 62.8k| yy_cp = ++(yy_c_buf_p); 2333| 62.8k| yy_current_state = yy_next_state; 2334| 62.8k| goto yy_match; 2335| 62.8k| } 2336| | 2337| 84| else 2338| 84| { 2339| 84| yy_cp = (yy_c_buf_p); 2340| 84| goto yy_find_action; 2341| 84| } 2342| 62.9k| } 2343| | 2344| 3.30k| else switch ( yy_get_next_buffer( ) ) ------------------ | Branch (2344:17): [True: 3.30k, False: 0] ------------------ 2345| 3.30k| { 2346| 53| case EOB_ACT_END_OF_FILE: ------------------ | | 162| 53|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (2346:4): [True: 53, False: 3.25k] ------------------ 2347| 53| { 2348| 53| (yy_did_buffer_switch_on_eof) = 0; 2349| | 2350| 53| if ( yywrap( ) ) ------------------ | | 345| 53|#define yywrap() (/*CONSTCOND*/1) | | ------------------ | | | Branch (345:18): [True: 53, Folded] | | ------------------ ------------------ 2351| 53| { 2352| | /* Note: because we've taken care in 2353| | * yy_get_next_buffer() to have set up 2354| | * yytext, we can now set up 2355| | * yy_c_buf_p so that if some total 2356| | * hoser (like flex itself) wants to 2357| | * call the scanner after we return the 2358| | * YY_NULL, it'll still work - another 2359| | * YY_NULL will get returned. 2360| | */ 2361| 53| (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 360| 53|#define yytext_ptr yytext ------------------ (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 1506| 53|#define YY_MORE_ADJ 0 ------------------ 2362| | 2363| 53| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 125| 53|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 377| 53|#define YY_END_OF_BUFFER 84 | | ------------------ ------------------ 2364| 53| goto do_action; 2365| 53| } 2366| | 2367| 0| else 2368| 0| { 2369| 0| if ( ! (yy_did_buffer_switch_on_eof) ) ------------------ | Branch (2369:11): [True: 0, False: 0] ------------------ 2370| 0| YY_NEW_FILE; ------------------ | | 127| 0|#define YY_NEW_FILE yyrestart( yyin ) ------------------ 2371| 0| } 2372| 0| break; 2373| 53| } 2374| | 2375| 2.78k| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 161| 2.78k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (2375:4): [True: 2.78k, False: 523] ------------------ 2376| 2.78k| (yy_c_buf_p) = 2377| 2.78k| (yytext_ptr) + yy_amount_of_matched_text; ------------------ | | 360| 2.78k|#define yytext_ptr yytext ------------------ 2378| | 2379| 2.78k| yy_current_state = yy_get_previous_state( ); 2380| | 2381| 2.78k| yy_cp = (yy_c_buf_p); 2382| 2.78k| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 360| 2.78k|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 1506| 2.78k|#define YY_MORE_ADJ 0 ------------------ 2383| 2.78k| goto yy_match; 2384| | 2385| 470| case EOB_ACT_LAST_MATCH: ------------------ | | 163| 470|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (2385:4): [True: 470, False: 2.83k] ------------------ 2386| 470| (yy_c_buf_p) = 2387| 470| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; ------------------ | | 284| 470|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2388| | 2389| 470| yy_current_state = yy_get_previous_state( ); 2390| | 2391| 470| yy_cp = (yy_c_buf_p); 2392| 470| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 360| 470|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 1506| 470|#define YY_MORE_ADJ 0 ------------------ 2393| 470| goto yy_find_action; 2394| 3.30k| } 2395| 0| break; 2396| 66.2k| } 2397| | 2398| 0| default: ------------------ | Branch (2398:2): [True: 0, False: 3.51M] ------------------ 2399| 0| YY_FATAL_ERROR( ------------------ | | 1683| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2400| 3.51M| "fatal flex scanner internal error--no action found" ); 2401| 3.51M| } /* end of action switch */ 2402| 3.51M| } /* end of scanning one token */ 2403| 606| } /* end of user's declarations */ 2404| 606|} /* end of yylex */ yyrestart: 2695| 53|{ 2696| | 2697| 53| if ( ! YY_CURRENT_BUFFER ){ ------------------ | | 278| 53|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 53, False: 0] | | ------------------ | | 279| 53| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 53| : NULL) ------------------ | Branch (2697:7): [True: 0, False: 53] ------------------ 2698| 0| yyensure_buffer_stack (); 2699| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2700| 0| yy_create_buffer( yyin, YY_BUF_SIZE ); ------------------ | | 139| 0|#define YY_BUF_SIZE 16384 ------------------ 2701| 0| } 2702| | 2703| | yy_init_buffer( YY_CURRENT_BUFFER, input_file ); ------------------ | | 278| 53|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 53, False: 0] | | ------------------ | | 279| 53| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 53| : NULL) ------------------ 2704| 53| yy_load_buffer_state( ); 2705| 53|} yy_create_buffer: 2757| 606|{ 2758| 606| YY_BUFFER_STATE b; 2759| | 2760| 606| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); 2761| 606| if ( ! b ) ------------------ | Branch (2761:7): [True: 0, False: 606] ------------------ 2762| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 1683| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2763| | 2764| 606| b->yy_buf_size = size; 2765| | 2766| | /* yy_ch_buf has to be 2 characters longer than the size given because 2767| | * we need to put in 2 end-of-buffer characters. 2768| | */ 2769| 606| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); 2770| 606| if ( ! b->yy_ch_buf ) ------------------ | Branch (2770:7): [True: 0, False: 606] ------------------ 2771| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 1683| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2772| | 2773| 606| b->yy_is_our_buffer = 1; 2774| | 2775| 606| yy_init_buffer( b, file ); 2776| | 2777| 606| return b; 2778| 606|} yy_delete_buffer: 2785| 606|{ 2786| | 2787| 606| if ( ! b ) ------------------ | Branch (2787:7): [True: 0, False: 606] ------------------ 2788| 0| return; 2789| | 2790| 606| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 278| 606|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 606, False: 0] | | ------------------ | | 279| 606| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 606| : NULL) ------------------ | Branch (2790:7): [True: 606, False: 0] ------------------ 2791| 606| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 284| 606|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2792| | 2793| 606| if ( b->yy_is_our_buffer ) ------------------ | Branch (2793:7): [True: 606, False: 0] ------------------ 2794| 606| yyfree( (void *) b->yy_ch_buf ); 2795| | 2796| 606| yyfree( (void *) b ); 2797| 606|} yy_flush_buffer: 2832| 659|{ 2833| 659| if ( ! b ) ------------------ | Branch (2833:11): [True: 0, False: 659] ------------------ 2834| 0| return; 2835| | 2836| 659| b->yy_n_chars = 0; 2837| | 2838| | /* We always need two end-of-buffer characters. The first causes 2839| | * a transition to the end-of-buffer state. The second causes 2840| | * a jam in that state. 2841| | */ 2842| 659| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 128| 659|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2843| 659| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 128| 659|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2844| | 2845| 659| b->yy_buf_pos = &b->yy_ch_buf[0]; 2846| | 2847| 659| b->yy_at_bol = 1; 2848| 659| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 250| 659|#define YY_BUFFER_NEW 0 ------------------ 2849| | 2850| 659| if ( b == YY_CURRENT_BUFFER ) ------------------ | | 278| 659|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 659, False: 0] | | ------------------ | | 279| 659| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 659| : NULL) ------------------ | Branch (2850:7): [True: 53, False: 606] ------------------ 2851| 53| yy_load_buffer_state( ); 2852| 659|} yypop_buffer_state: 2891| 606|{ 2892| 606| if (!YY_CURRENT_BUFFER) ------------------ | | 278| 606|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 606, False: 0] | | ------------------ | | 279| 606| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 606| : NULL) ------------------ | Branch (2892:10): [True: 606, False: 0] ------------------ 2893| 606| return; 2894| | 2895| 0| yy_delete_buffer(YY_CURRENT_BUFFER ); ------------------ | | 278| 0|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 0, False: 0] | | ------------------ | | 279| 0| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 0| : NULL) ------------------ 2896| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2897| 0| if ((yy_buffer_stack_top) > 0) ------------------ | Branch (2897:6): [True: 0, False: 0] ------------------ 2898| 0| --(yy_buffer_stack_top); 2899| | 2900| 0| if (YY_CURRENT_BUFFER) { ------------------ | | 278| 0|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:27): [True: 0, False: 0] | | | Branch (278:29): [True: 0, False: 0] | | ------------------ | | 279| 0| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 0| : NULL) ------------------ 2901| 0| yy_load_buffer_state( ); 2902| 0| (yy_did_buffer_switch_on_eof) = 1; 2903| 0| } 2904| 0|} yyset_in: 3126| 606|{ 3127| 606| yyin = _in_str ; 3128| 606|} yylex_destroy: 3178| 606|{ 3179| | 3180| | /* Pop the buffer stack, destroying each element. */ 3181| 1.21k| while(YY_CURRENT_BUFFER){ ------------------ | | 278| 1.21k|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:27): [True: 606, False: 606] | | | Branch (278:29): [True: 1.21k, False: 0] | | ------------------ | | 279| 1.21k| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 1.21k| : NULL) ------------------ 3182| 606| yy_delete_buffer( YY_CURRENT_BUFFER ); ------------------ | | 278| 606|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 606, False: 0] | | ------------------ | | 279| 606| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 606| : NULL) ------------------ 3183| 606| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 284| 606|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 3184| 606| yypop_buffer_state(); 3185| 606| } 3186| | 3187| | /* Destroy the stack itself. */ 3188| 606| yyfree((yy_buffer_stack) ); 3189| 606| (yy_buffer_stack) = NULL; 3190| | 3191| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 3192| | * yylex() is called, initialization will occur. */ 3193| 606| yy_init_globals( ); 3194| | 3195| 606| return 0; 3196| 606|} yyalloc: 3224| 1.81k|{ 3225| 1.81k| return malloc(size); 3226| 1.81k|} yyrealloc: 3229| 137|{ 3230| | 3231| | /* The cast to (char *) in the following accommodates both 3232| | * implementations that use char* generic pointers, and those 3233| | * that use void* generic pointers. It works with the latter 3234| | * because both ANSI C and C++ allow castless assignment from 3235| | * any pointer type to void*, and deal with argument conversions 3236| | * as though doing an assignment. 3237| | */ 3238| 137| return realloc(ptr, size); 3239| 137|} yyfree: 3242| 1.81k|{ 3243| 1.81k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 3244| 1.81k|} scanner.c:yy_get_next_buffer: 2414| 3.30k|{ 2415| 3.30k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 284| 3.30k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2416| 3.30k| char *source = (yytext_ptr); ------------------ | | 360| 3.30k|#define yytext_ptr yytext ------------------ 2417| 3.30k| int number_to_move, i; 2418| 3.30k| int ret_val; 2419| | 2420| 3.30k| if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) ------------------ | | 284| 3.30k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (2420:7): [True: 0, False: 3.30k] ------------------ 2421| 0| YY_FATAL_ERROR( ------------------ | | 1683| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2422| 3.30k| "fatal flex scanner internal error--end of buffer missed" ); 2423| | 2424| 3.30k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 284| 3.30k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (2424:7): [True: 0, False: 3.30k] ------------------ 2425| 0| { /* Don't try to fill the buffer, so this is an EOF. */ 2426| 0| if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) ------------------ | | 360| 0|#define yytext_ptr yytext ------------------ if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) ------------------ | | 1506| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (2426:8): [True: 0, False: 0] ------------------ 2427| 0| { 2428| | /* We matched a single character, the EOB, so 2429| | * treat this as a final EOF. 2430| | */ 2431| 0| return EOB_ACT_END_OF_FILE; ------------------ | | 162| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 2432| 0| } 2433| | 2434| 0| else 2435| 0| { 2436| | /* We matched some text prior to the EOB, first 2437| | * process it. 2438| | */ 2439| 0| return EOB_ACT_LAST_MATCH; ------------------ | | 163| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 2440| 0| } 2441| 0| } 2442| | 2443| | /* Try to read more data. */ 2444| | 2445| | /* First move last chars to start of buffer. */ 2446| 3.30k| number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); ------------------ | | 360| 3.30k|#define yytext_ptr yytext ------------------ 2447| | 2448| 227M| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (2448:15): [True: 227M, False: 3.30k] ------------------ 2449| 227M| *(dest++) = *(source++); 2450| | 2451| 3.30k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 284| 3.30k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 262| 3.30k|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (2451:7): [True: 16, False: 3.29k] ------------------ 2452| | /* don't do the read, it's not guaranteed to return an EOF, 2453| | * just force an EOF 2454| | */ 2455| 16| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; ------------------ | | 284| 16|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2456| | 2457| 3.29k| else 2458| 3.29k| { 2459| 3.29k| int num_to_read = 2460| 3.29k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 284| 3.29k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2461| | 2462| 3.42k| while ( num_to_read <= 0 ) ------------------ | Branch (2462:11): [True: 137, False: 3.29k] ------------------ 2463| 137| { /* Not enough room in the buffer - grow it. */ 2464| | 2465| | /* just a shorter name for the current buffer */ 2466| 137| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 284| 137|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2467| | 2468| 137| int yy_c_buf_p_offset = 2469| 137| (int) ((yy_c_buf_p) - b->yy_ch_buf); 2470| | 2471| 137| if ( b->yy_is_our_buffer ) ------------------ | Branch (2471:9): [True: 137, False: 0] ------------------ 2472| 137| { 2473| 137| int new_size = b->yy_buf_size * 2; 2474| | 2475| 137| if ( new_size <= 0 ) ------------------ | Branch (2475:10): [True: 0, False: 137] ------------------ 2476| 0| b->yy_buf_size += b->yy_buf_size / 8; 2477| 137| else 2478| 137| b->yy_buf_size *= 2; 2479| | 2480| 137| b->yy_ch_buf = (char *) 2481| | /* Include room in for 2 EOB chars. */ 2482| 137| yyrealloc( (void *) b->yy_ch_buf, 2483| 137| (yy_size_t) (b->yy_buf_size + 2) ); 2484| 137| } 2485| 0| else 2486| | /* Can't grow it, we don't own it. */ 2487| 0| b->yy_ch_buf = NULL; 2488| | 2489| 137| if ( ! b->yy_ch_buf ) ------------------ | Branch (2489:9): [True: 0, False: 137] ------------------ 2490| 0| YY_FATAL_ERROR( ------------------ | | 1683| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2491| 137| "fatal error - scanner input buffer overflow" ); 2492| | 2493| 137| (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 2494| | 2495| 137| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 284| 137|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2496| 137| number_to_move - 1; 2497| | 2498| 137| } 2499| | 2500| 3.29k| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 1620| 3.29k|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (2500:8): [True: 2.85k, False: 436] ------------------ 2501| 2.85k| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 1620| 2.85k|#define YY_READ_BUF_SIZE 8192 ------------------ 2502| | 2503| | /* Read in more data. */ 2504| 3.29k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 1637| 3.29k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 284| 3.29k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | | Branch (1637:7): [True: 0, False: 3.29k] | | ------------------ | | 1638| 3.29k| { \ | | 1639| 0| int c = '*'; \ | | 1640| 0| int n; \ | | 1641| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (1641:16): [True: 0, False: 0] | | ------------------ | | 1642| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | Branch (1642:9): [True: 0, False: 0] | | | Branch (1642:38): [True: 0, False: 0] | | ------------------ | | 1643| 0| buf[n] = (char) c; \ | | 1644| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (1644:8): [True: 0, False: 0] | | ------------------ | | 1645| 0| buf[n++] = (char) c; \ | | 1646| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | Branch (1646:8): [True: 0, False: 0] | | | Branch (1646:20): [True: 0, False: 0] | | ------------------ | | 1647| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 1683| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) | | ------------------ | | 1648| 0| result = n; \ | | 1649| 0| } \ | | 1650| 3.29k| else \ | | 1651| 3.29k| { \ | | 1652| 3.29k| errno=0; \ | | 1653| 3.29k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | Branch (1653:11): [True: 507, False: 2.78k] | | | Branch (1653:78): [True: 0, False: 507] | | ------------------ | | 1654| 3.29k| { \ | | 1655| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (1655:8): [True: 0, False: 0] | | ------------------ | | 1656| 0| { \ | | 1657| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 1683| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) | | ------------------ | | 1658| 0| break; \ | | 1659| 0| } \ | | 1660| 0| errno=0; \ | | 1661| 0| clearerr(yyin); \ | | 1662| 0| } \ | | 1663| 3.29k| }\ ------------------ 2505| 3.29k| (yy_n_chars), num_to_read ); 2506| | 2507| 3.29k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); ------------------ | | 284| 3.29k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2508| 3.29k| } 2509| | 2510| 3.30k| if ( (yy_n_chars) == 0 ) ------------------ | Branch (2510:7): [True: 523, False: 2.78k] ------------------ 2511| 523| { 2512| 523| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 1506| 523|#define YY_MORE_ADJ 0 ------------------ | Branch (2512:8): [True: 53, False: 470] ------------------ 2513| 53| { 2514| 53| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 162| 53|#define EOB_ACT_END_OF_FILE 1 ------------------ 2515| 53| yyrestart( yyin ); 2516| 53| } 2517| | 2518| 470| else 2519| 470| { 2520| 470| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 163| 470|#define EOB_ACT_LAST_MATCH 2 ------------------ 2521| 470| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 284| 470|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2522| 470| YY_BUFFER_EOF_PENDING; ------------------ | | 262| 470|#define YY_BUFFER_EOF_PENDING 2 ------------------ 2523| 470| } 2524| 523| } 2525| | 2526| 2.78k| else 2527| 2.78k| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 161| 2.78k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 2528| | 2529| 3.30k| if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 284| 3.30k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (2529:6): [True: 0, False: 3.30k] ------------------ 2530| | /* Extend the array by 50%, plus the number we really need. */ 2531| 0| int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 2532| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2533| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2534| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (2534:8): [True: 0, False: 0] ------------------ 2535| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 1683| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2536| | /* "- 2" to take care of EOB's */ 2537| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2538| 0| } 2539| | 2540| 3.30k| (yy_n_chars) += number_to_move; 2541| 3.30k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; ------------------ | | 284| 3.30k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; ------------------ | | 128| 3.30k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2542| 3.30k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 284| 3.30k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 128| 3.30k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2543| | 2544| 3.30k| (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 360| 3.30k|#define yytext_ptr yytext ------------------ (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 284| 3.30k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2545| | 2546| 3.30k| return ret_val; 2547| 3.30k|} scanner.c:yy_get_previous_state: 2552| 66.2k|{ 2553| 66.2k| yy_state_type yy_current_state; 2554| 66.2k| char *yy_cp; 2555| | 2556| 66.2k| yy_current_state = (yy_start); 2557| | 2558| 1.11G| for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) ------------------ | | 360| 66.2k|#define yytext_ptr yytext ------------------ for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) ------------------ | | 1506| 66.2k|#define YY_MORE_ADJ 0 ------------------ | Branch (2558:44): [True: 1.11G, False: 66.2k] ------------------ 2559| 1.11G| { 2560| 1.11G| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 111| 1.11G|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (2560:19): [True: 1.11G, False: 4.42M] ------------------ 2561| 1.11G| if ( yy_accept[yy_current_state] ) ------------------ | Branch (2561:8): [True: 34.9M, False: 1.08G] ------------------ 2562| 34.9M| { 2563| 34.9M| (yy_last_accepting_state) = yy_current_state; 2564| 34.9M| (yy_last_accepting_cpos) = yy_cp; 2565| 34.9M| } 2566| 2.17G| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (2566:11): [True: 1.06G, False: 1.11G] ------------------ 2567| 1.06G| { 2568| 1.06G| yy_current_state = (int) yy_def[yy_current_state]; 2569| 1.06G| if ( yy_current_state >= 925 ) ------------------ | Branch (2569:9): [True: 1.06G, False: 8.94k] ------------------ 2570| 1.06G| yy_c = yy_meta[yy_c]; 2571| 1.06G| } 2572| 1.11G| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 2573| 1.11G| } 2574| | 2575| 66.2k| return yy_current_state; 2576| 66.2k|} scanner.c:yy_try_NUL_trans: 2584| 62.9k|{ 2585| 62.9k| int yy_is_jam; 2586| 62.9k| char *yy_cp = (yy_c_buf_p); 2587| | 2588| 62.9k| YY_CHAR yy_c = 1; 2589| 62.9k| if ( yy_accept[yy_current_state] ) ------------------ | Branch (2589:7): [True: 10.9k, False: 52.0k] ------------------ 2590| 10.9k| { 2591| 10.9k| (yy_last_accepting_state) = yy_current_state; 2592| 10.9k| (yy_last_accepting_cpos) = yy_cp; 2593| 10.9k| } 2594| 115k| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (2594:10): [True: 52.2k, False: 62.9k] ------------------ 2595| 52.2k| { 2596| 52.2k| yy_current_state = (int) yy_def[yy_current_state]; 2597| 52.2k| if ( yy_current_state >= 925 ) ------------------ | Branch (2597:8): [True: 52.0k, False: 204] ------------------ 2598| 52.0k| yy_c = yy_meta[yy_c]; 2599| 52.2k| } 2600| 62.9k| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 2601| 62.9k| yy_is_jam = (yy_current_state == 924); 2602| | 2603| 62.9k| return yy_is_jam ? 0 : yy_current_state; ------------------ | Branch (2603:10): [True: 84, False: 62.8k] ------------------ 2604| 62.9k|} scanner.c:yy_load_buffer_state: 2743| 712|{ 2744| 712| (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 284| 712|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2745| 712| (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 360| 712|#define yytext_ptr yytext ------------------ (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 284| 712|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2746| 712| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 284| 712|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2747| 712| (yy_hold_char) = *(yy_c_buf_p); 2748| 712|} scanner.c:yy_init_buffer: 2805| 659|{ 2806| 659| int oerrno = errno; 2807| | 2808| 659| yy_flush_buffer( b ); 2809| | 2810| 659| b->yy_input_file = file; 2811| 659| b->yy_fill_buffer = 1; 2812| | 2813| | /* If b is the current buffer, then yy_init_buffer was _probably_ 2814| | * called from yyrestart() or through yy_get_next_buffer. 2815| | * In that case, we don't want to reset the lineno or column. 2816| | */ 2817| 659| if (b != YY_CURRENT_BUFFER){ ------------------ | | 278| 659|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 659, False: 0] | | ------------------ | | 279| 659| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 659| : NULL) ------------------ | Branch (2817:9): [True: 606, False: 53] ------------------ 2818| 606| b->yy_bs_lineno = 1; 2819| 606| b->yy_bs_column = 0; 2820| 606| } 2821| | 2822| 659| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ------------------ | Branch (2822:32): [True: 659, False: 0] ------------------ 2823| | 2824| | errno = oerrno; 2825| 659|} scanner.c:yyensure_buffer_stack: 2910| 606|{ 2911| 606| yy_size_t num_to_alloc; 2912| | 2913| 606| if (!(yy_buffer_stack)) { ------------------ | Branch (2913:6): [True: 606, False: 0] ------------------ 2914| | 2915| | /* First allocation is just for 2 elements, since we don't know if this 2916| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 2917| | * immediate realloc on the next call. 2918| | */ 2919| 606| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2920| 606| (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 2921| 606| (num_to_alloc * sizeof(struct yy_buffer_state*) 2922| 606| ); 2923| 606| if ( ! (yy_buffer_stack) ) ------------------ | Branch (2923:8): [True: 0, False: 606] ------------------ 2924| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 1683| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2925| | 2926| 606| memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2927| | 2928| 606| (yy_buffer_stack_max) = num_to_alloc; 2929| 606| (yy_buffer_stack_top) = 0; 2930| 606| return; 2931| 606| } 2932| | 2933| 0| if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ ------------------ | Branch (2933:6): [True: 0, False: 0] ------------------ 2934| | 2935| | /* Increase the buffer to prepare for a possible push. */ 2936| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 2937| | 2938| 0| num_to_alloc = (yy_buffer_stack_max) + grow_size; 2939| 0| (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 2940| 0| ((yy_buffer_stack), 2941| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 2942| 0| ); 2943| 0| if ( ! (yy_buffer_stack) ) ------------------ | Branch (2943:8): [True: 0, False: 0] ------------------ 2944| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 1683| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2945| | 2946| | /* zero only the new slots.*/ 2947| 0| memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 2948| 0| (yy_buffer_stack_max) = num_to_alloc; 2949| 0| } 2950| 0|} scanner.c:yy_init_globals: 3146| 606|{ 3147| | /* Initialization is the same as for the non-reentrant scanner. 3148| | * This function is called from yylex_destroy(), so don't allocate here. 3149| | */ 3150| | 3151| | /* We do not touch yylineno unless the option is enabled. */ 3152| 606| yylineno = 1; 3153| | 3154| 606| (yy_buffer_stack) = NULL; 3155| 606| (yy_buffer_stack_top) = 0; 3156| 606| (yy_buffer_stack_max) = 0; 3157| 606| (yy_c_buf_p) = NULL; 3158| 606| (yy_init) = 0; 3159| 606| (yy_start) = 0; 3160| | 3161| |/* Defined in main.c */ 3162| |#ifdef YY_STDINIT 3163| | yyin = stdin; 3164| | yyout = stdout; 3165| |#else 3166| 606| yyin = NULL; 3167| 606| yyout = NULL; 3168| 606|#endif 3169| | 3170| | /* For future reference: Set errno on error, since we are called by 3171| | * yylex_init() 3172| | */ 3173| 606| return 0; 3174| 606|}