← Back to branch summary

~ubuntu-branches/ubuntu/vivid/texlive-bin/vivid

« back to all changes in this revision

Viewing changes to utils/asymptote/lex.yy.cc

  • Committer: Package Import Robot
  • Author(s): Norbert Preining
  • Date: 2012-06-23 12:57:25 UTC
  • mfrom: (1.2.8)
  • Revision ID: package-import@ubuntu.com-20120623125725-usp25qvphkyd6jlm
Tags: 2012.20120623-1
http://bugs.debian.org/677300
* post release fixed from Peter Breitenlohner (will be included upstream):
  - (patch-dvi2tty, patch-lacheck) Ken Brown <kbrow1i@gmail.com> has noteda
  that already moderately long pathnames may yield buffer overruns in 
  lacheck and dvi2tty.
  - (patch-icu) three ICU library files have been modified (undoing ICU 
  SVN commit 36090 from 2009-06-11), in order to solve all/most XeTeX 
  problems with Indic scripts.
  - (patch-pdftex) a small change in pdftexdir/pdftosrc.cc required to
  build pdfTeX with poppler >=0.18.4 (system-xpdf).  Note, however, that 
  building pdfTeX that way slightly reduces its capability to handle large 
  files (see README.config 1.6 and 3.4.2).
* update updmap man page (Closes: #677300)
* (pulled from upupstream cvs, patch xdvi-upupstream-fixes)
  - Fixed bugs in property handling on 64-bit systems (related to source 
    specials).
  - Added support for XkbBell, to make the console bell work again.

Show diffs side-by-side

added added

removed removed

Lines of Context:
utils/asymptote/lex.yy.cc
767
767
 
768
768
static yyconst flex_int16_t yy_rule_linenum[122] =
769
769
    {   0,
770
 
      205,  206,  208,  214,  218,  219,  229,  230,  231,  232,
771
 
      236,  237,  247,  248,  249,  250,  251,  252,  253,  254,
772
 
      255,  256,  261,  266,  272,  278,  286,  289,  290,  291,
773
 
      292,  293,  294,  295,  296,  297,  298,  299,  300,  301,
774
 
      302,  304,  305,  306,  307,  308,  309,  310,  311,  312,
775
 
      313,  314,  315,  316,  317,  318,  319,  320,  321,  322,
776
 
      323,  324,  325,  326,  327,  328,  329,  330,  332,  333,
777
 
      334,  335,  336,  337,  339,  340,  341,  342,  343,  345,
778
 
      346,  347,  348,  349,  350,  351,  352,  353,  354,  355,
779
 
      356,  357,  358,  359,  360,  361,  362,  364,  365,  366,
 
770
      212,  213,  215,  221,  225,  226,  236,  237,  238,  239,
 
771
      243,  244,  254,  255,  256,  257,  258,  259,  260,  261,
 
772
      262,  263,  268,  273,  279,  285,  293,  296,  297,  298,
 
773
      299,  300,  301,  302,  303,  304,  305,  306,  307,  308,
 
774
      309,  311,  312,  313,  314,  315,  316,  317,  318,  319,
 
775
      320,  321,  322,  323,  324,  325,  326,  327,  328,  329,
 
776
      330,  331,  332,  333,  334,  335,  336,  337,  339,  340,
 
777
      341,  342,  343,  344,  346,  347,  348,  349,  350,  352,
 
778
      353,  354,  355,  356,  357,  358,  359,  360,  361,  362,
 
779
      363,  364,  365,  366,  367,  368,  369,  371,  372,  373,
780
780
 
781
 
      367,  368,  371,  378,  385,  387,  389,  391,  393,  396,
782
 
      398,  399,  405,  409,  413,  417,  420,  424,  425,  426,
783
 
      430
 
781
      374,  375,  378,  385,  392,  394,  396,  398,  400,  403,
 
782
      405,  406,  412,  416,  420,  424,  427,  431,  432,  433,
 
783
      437
784
784
    } ;
785
785
 
786
786
/* The intent behind this definition is that it'll catch
821
821
 
822
822
#include "opsymbols.h"
823
823
 
 
824
#define YY_NO_INPUT
 
825
 
824
826
static void yyunput(int, char *);
825
827
void (*unused)(int,char *) = yyunput;
826
828
 
897
899
#define DEFSYMBOL(name) \
898
900
    savesymbol(name)
899
901
 
 
902
 /* Extra symbols can be added by EXTRASYMBOL */
 
903
#define EXTRASYMBOL(chars, codename) /* blank */
 
904
 
 
905
EXTRASYMBOL(tuple, SYM_TUPLE);
 
906
 
900
907
void makesymbol()
901
908
{
902
909
  assert(strlen(yytext) == (size_t)yyleng);
985
992
 
986
993
 
987
994
 
988
 
#line 989 "lex.yy.cc"
 
995
#line 996 "lex.yy.cc"
989
996
 
990
997
#define INITIAL 0
991
998
#define lexcomment 1
1232
1239
        register int yy_act;
1233
1240
    
1234
1241
/* %% [7.0] user's declarations go here */
1235
 
#line 202 "camp.l"
1236
 
 
1237
 
 
1238
 
#line 1239 "lex.yy.cc"
 
1242
#line 209 "camp.l"
 
1243
 
 
1244
 
 
1245
#line 1246 "lex.yy.cc"
1239
1246
 
1240
1247
        if ( !(yy_init) )
1241
1248
                {
1351
1358
 
1352
1359
case 1:
1353
1360
YY_RULE_SETUP
1354
 
#line 205 "camp.l"
 
1361
#line 212 "camp.l"
1355
1362
{adjust(); /*commentDepth++;*/}
1356
1363
        YY_BREAK
1357
1364
case 2:
1358
1365
YY_RULE_SETUP
1359
 
#line 206 "camp.l"
 
1366
#line 213 "camp.l"
1360
1367
{adjust(); /*commentDepth--;*/
1361
1368
                    /*if (commentDepth == 0)*/ BEGIN INITIAL; }
1362
1369
        YY_BREAK
1363
1370
case 3:
1364
1371
/* rule 3 can match eol */
1365
1372
YY_RULE_SETUP
1366
 
#line 208 "camp.l"
 
1373
#line 215 "camp.l"
1367
1374
{adjust(); newline(); continue; }
1368
1375
        YY_BREAK
1369
1376
case YY_STATE_EOF(lexcomment):
1370
 
#line 209 "camp.l"
 
1377
#line 216 "camp.l"
1371
1378
{adjust();
1372
1379
                    setEOF("comment not terminated");
1373
1380
                    BEGIN INITIAL;
1376
1383
        YY_BREAK
1377
1384
case 4:
1378
1385
YY_RULE_SETUP
1379
 
#line 214 "camp.l"
 
1386
#line 221 "camp.l"
1380
1387
{adjust(); continue; }
1381
1388
        YY_BREAK
1382
1389
 
1387
1394
(yy_c_buf_p) = yy_cp = yy_bp + 1;
1388
1395
YY_DO_BEFORE_ACTION; /* set up yytext again */
1389
1396
YY_RULE_SETUP
1390
 
#line 218 "camp.l"
 
1397
#line 225 "camp.l"
1391
1398
{adjust(); BEGIN INITIAL;}
1392
1399
        YY_BREAK
1393
1400
case 6:
1394
1401
YY_RULE_SETUP
1395
 
#line 219 "camp.l"
 
1402
#line 226 "camp.l"
1396
1403
{adjust(); 
1397
1404
                    BEGIN INITIAL;
1398
1405
                    getstring(); 
1399
1406
                    return STRING; }
1400
1407
        YY_BREAK
1401
1408
case YY_STATE_EOF(texstring):
1402
 
#line 223 "camp.l"
 
1409
#line 230 "camp.l"
1403
1410
{adjust();
1404
1411
                    setEOF("string not terminated");
1405
1412
                    BEGIN INITIAL;
1410
1417
case 7:
1411
1418
/* rule 7 can match eol */
1412
1419
YY_RULE_SETUP
1413
 
#line 229 "camp.l"
 
1420
#line 236 "camp.l"
1414
1421
{adjust(); newline(); append('\n'); continue; }
1415
1422
        YY_BREAK
1416
1423
case 8:
1417
1424
YY_RULE_SETUP
1418
 
#line 230 "camp.l"
 
1425
#line 237 "camp.l"
1419
1426
{adjust(); append('\\'); append('\\'); continue; }
1420
1427
        YY_BREAK
1421
1428
case 9:
1422
1429
YY_RULE_SETUP
1423
 
#line 231 "camp.l"
 
1430
#line 238 "camp.l"
1424
1431
{adjust(); append('\"'); continue; }
1425
1432
        YY_BREAK
1426
1433
case 10:
1427
1434
YY_RULE_SETUP
1428
 
#line 232 "camp.l"
 
1435
#line 239 "camp.l"
1429
1436
{adjust(); append(*yytext); }
1430
1437
        YY_BREAK
1431
1438
 
1436
1443
(yy_c_buf_p) = yy_cp = yy_bp + 1;
1437
1444
YY_DO_BEFORE_ACTION; /* set up yytext again */
1438
1445
YY_RULE_SETUP
1439
 
#line 236 "camp.l"
 
1446
#line 243 "camp.l"
1440
1447
{adjust(); BEGIN INITIAL;}
1441
1448
        YY_BREAK
1442
1449
case 12:
1443
1450
YY_RULE_SETUP
1444
 
#line 237 "camp.l"
 
1451
#line 244 "camp.l"
1445
1452
{adjust(); 
1446
1453
                    BEGIN INITIAL;
1447
1454
                    getstring(); 
1448
1455
                    return STRING; }
1449
1456
        YY_BREAK
1450
1457
case YY_STATE_EOF(cstring):
1451
 
#line 241 "camp.l"
 
1458
#line 248 "camp.l"
1452
1459
{adjust();
1453
1460
                    setEOF("string not terminated");
1454
1461
                    BEGIN INITIAL;
1459
1466
case 13:
1460
1467
/* rule 13 can match eol */
1461
1468
YY_RULE_SETUP
1462
 
#line 247 "camp.l"
 
1469
#line 254 "camp.l"
1463
1470
{adjust(); newline(); append('\n'); continue; }
1464
1471
        YY_BREAK
1465
1472
case 14:
1466
1473
YY_RULE_SETUP
1467
 
#line 248 "camp.l"
 
1474
#line 255 "camp.l"
1468
1475
{adjust(); append(yytext[1]); continue; }
1469
1476
        YY_BREAK
1470
1477
case 15:
1471
1478
YY_RULE_SETUP
1472
 
#line 249 "camp.l"
 
1479
#line 256 "camp.l"
1473
1480
{adjust(); append('\a'); continue; }
1474
1481
        YY_BREAK
1475
1482
case 16:
1476
1483
YY_RULE_SETUP
1477
 
#line 250 "camp.l"
 
1484
#line 257 "camp.l"
1478
1485
{adjust(); append('\b'); continue; }
1479
1486
        YY_BREAK
1480
1487
case 17:
1481
1488
YY_RULE_SETUP
1482
 
#line 251 "camp.l"
 
1489
#line 258 "camp.l"
1483
1490
{adjust(); append('\f'); continue; }
1484
1491
        YY_BREAK
1485
1492
case 18:
1486
1493
YY_RULE_SETUP
1487
 
#line 252 "camp.l"
 
1494
#line 259 "camp.l"
1488
1495
{adjust(); append('\n'); continue; }
1489
1496
        YY_BREAK
1490
1497
case 19:
1491
1498
YY_RULE_SETUP
1492
 
#line 253 "camp.l"
 
1499
#line 260 "camp.l"
1493
1500
{adjust(); append('\r'); continue; }
1494
1501
        YY_BREAK
1495
1502
case 20:
1496
1503
YY_RULE_SETUP
1497
 
#line 254 "camp.l"
 
1504
#line 261 "camp.l"
1498
1505
{adjust(); append('\t'); continue; }
1499
1506
        YY_BREAK
1500
1507
case 21:
1501
1508
YY_RULE_SETUP
1502
 
#line 255 "camp.l"
 
1509
#line 262 "camp.l"
1503
1510
{adjust(); append('\v'); continue; }
1504
1511
        YY_BREAK
1505
1512
case 22:
1506
1513
YY_RULE_SETUP
1507
 
#line 256 "camp.l"
 
1514
#line 263 "camp.l"
1508
1515
{adjust();
1509
1516
                    char x=(char)(yytext[1]-'0');
1510
1517
                    append(x);
1513
1520
        YY_BREAK
1514
1521
case 23:
1515
1522
YY_RULE_SETUP
1516
 
#line 261 "camp.l"
 
1523
#line 268 "camp.l"
1517
1524
{adjust();
1518
1525
                    char x=(char)((yytext[1]-'0')*8+yytext[2]-'0');
1519
1526
                    append(x);
1522
1529
        YY_BREAK
1523
1530
case 24:
1524
1531
YY_RULE_SETUP
1525
 
#line 266 "camp.l"
 
1532
#line 273 "camp.l"
1526
1533
{adjust();
1527
1534
                    char x=(char)((yytext[1]-'0')*64+(yytext[2]-'0')*8
1528
1535
                            +yytext[3]-'0');
1532
1539
        YY_BREAK
1533
1540
case 25:
1534
1541
YY_RULE_SETUP
1535
 
#line 272 "camp.l"
 
1542
#line 279 "camp.l"
1536
1543
{adjust();
1537
1544
                    char x=(char) (yytext[2] <= '9' ? yytext[2]-'0' : 
1538
1545
                                                      10+yytext[2]-'A');
1542
1549
        YY_BREAK
1543
1550
case 26:
1544
1551
YY_RULE_SETUP
1545
 
#line 278 "camp.l"
 
1552
#line 285 "camp.l"
1546
1553
{adjust();
1547
1554
                    char x=(char) ((yytext[2] <= '9' ? yytext[2]-'0' : 
1548
1555
                                                      10+yytext[2]-'A')*16
1554
1561
        YY_BREAK
1555
1562
case 27:
1556
1563
YY_RULE_SETUP
1557
 
#line 286 "camp.l"
 
1564
#line 293 "camp.l"
1558
1565
{adjust(); append(*yytext); }
1559
1566
        YY_BREAK
1560
1567
 
1561
1568
case 28:
1562
1569
YY_RULE_SETUP
1563
 
#line 289 "camp.l"
 
1570
#line 296 "camp.l"
1564
1571
{adjust(); continue;}
1565
1572
        YY_BREAK
1566
1573
case 29:
1567
1574
/* rule 29 can match eol */
1568
1575
YY_RULE_SETUP
1569
 
#line 290 "camp.l"
 
1576
#line 297 "camp.l"
1570
1577
{adjust(); newline(); continue;}
1571
1578
        YY_BREAK
1572
1579
case 30:
1573
1580
YY_RULE_SETUP
1574
 
#line 291 "camp.l"
 
1581
#line 298 "camp.l"
1575
1582
{adjust(); continue;}
1576
1583
        YY_BREAK
1577
1584
case 31:
1578
1585
YY_RULE_SETUP
1579
 
#line 292 "camp.l"
 
1586
#line 299 "camp.l"
1580
1587
{adjust(); return ','; }
1581
1588
        YY_BREAK
1582
1589
case 32:
1583
1590
YY_RULE_SETUP
1584
 
#line 293 "camp.l"
 
1591
#line 300 "camp.l"
1585
1592
{adjust(); return ':'; }
1586
1593
        YY_BREAK
1587
1594
case 33:
1588
1595
YY_RULE_SETUP
1589
 
#line 294 "camp.l"
 
1596
#line 301 "camp.l"
1590
1597
{adjust(); return ';'; }
1591
1598
        YY_BREAK
1592
1599
case 34:
1593
1600
YY_RULE_SETUP
1594
 
#line 295 "camp.l"
 
1601
#line 302 "camp.l"
1595
1602
{adjust(); return '('; }
1596
1603
        YY_BREAK
1597
1604
case 35:
1598
1605
YY_RULE_SETUP
1599
 
#line 296 "camp.l"
 
1606
#line 303 "camp.l"
1600
1607
{adjust(); return ')'; }
1601
1608
        YY_BREAK
1602
1609
case 36:
1603
1610
YY_RULE_SETUP
1604
 
#line 297 "camp.l"
 
1611
#line 304 "camp.l"
1605
1612
{adjust(); return '['; }
1606
1613
        YY_BREAK
1607
1614
case 37:
1608
1615
YY_RULE_SETUP
1609
 
#line 298 "camp.l"
 
1616
#line 305 "camp.l"
1610
1617
{adjust(); return ']'; }
1611
1618
        YY_BREAK
1612
1619
case 38:
1613
1620
YY_RULE_SETUP
1614
 
#line 299 "camp.l"
 
1621
#line 306 "camp.l"
1615
1622
{adjust(); return '{'; }
1616
1623
        YY_BREAK
1617
1624
case 39:
1618
1625
YY_RULE_SETUP
1619
 
#line 300 "camp.l"
 
1626
#line 307 "camp.l"
1620
1627
{adjust(); return '}'; }
1621
1628
        YY_BREAK
1622
1629
case 40:
1623
1630
YY_RULE_SETUP
1624
 
#line 301 "camp.l"
 
1631
#line 308 "camp.l"
1625
1632
{adjust(); return '.'; }
1626
1633
        YY_BREAK
1627
1634
case 41:
1628
1635
YY_RULE_SETUP
1629
 
#line 302 "camp.l"
 
1636
#line 309 "camp.l"
1630
1637
{adjust(); return ELLIPSIS; }
1631
1638
        YY_BREAK
1632
1639
case 42:
1633
1640
YY_RULE_SETUP
1634
 
#line 304 "camp.l"
 
1641
#line 311 "camp.l"
1635
1642
{DEFSYMBOL(SYM_PLUS); return '+'; }
1636
1643
        YY_BREAK
1637
1644
case 43:
1638
1645
YY_RULE_SETUP
1639
 
#line 305 "camp.l"
 
1646
#line 312 "camp.l"
1640
1647
{DEFSYMBOL(SYM_MINUS); return '-'; }
1641
1648
        YY_BREAK
1642
1649
case 44:
1643
1650
YY_RULE_SETUP
1644
 
#line 306 "camp.l"
 
1651
#line 313 "camp.l"
1645
1652
{DEFSYMBOL(SYM_TIMES); return '*'; }
1646
1653
        YY_BREAK
1647
1654
case 45:
1648
1655
YY_RULE_SETUP
1649
 
#line 307 "camp.l"
 
1656
#line 314 "camp.l"
1650
1657
{DEFSYMBOL(SYM_DIVIDE); return '/'; }
1651
1658
        YY_BREAK
1652
1659
case 46:
1653
1660
YY_RULE_SETUP
1654
 
#line 308 "camp.l"
 
1661
#line 315 "camp.l"
1655
1662
{DEFSYMBOL(SYM_MOD); return '%'; }
1656
1663
        YY_BREAK
1657
1664
case 47:
1658
1665
YY_RULE_SETUP
1659
 
#line 309 "camp.l"
 
1666
#line 316 "camp.l"
1660
1667
{DEFSYMBOL(SYM_CARET); return '^'; }
1661
1668
        YY_BREAK
1662
1669
case 48:
1663
1670
YY_RULE_SETUP
1664
 
#line 310 "camp.l"
 
1671
#line 317 "camp.l"
1665
1672
{savesymbol(SYM_CARET); return '^'; }
1666
1673
        YY_BREAK
1667
1674
case 49:
1668
1675
YY_RULE_SETUP
1669
 
#line 311 "camp.l"
 
1676
#line 318 "camp.l"
1670
1677
{adjust(); return '?'; }
1671
1678
        YY_BREAK
1672
1679
case 50:
1673
1680
YY_RULE_SETUP
1674
 
#line 312 "camp.l"
 
1681
#line 319 "camp.l"
1675
1682
{adjust(); return ASSIGN; }
1676
1683
        YY_BREAK
1677
1684
case 51:
1678
1685
YY_RULE_SETUP
1679
 
#line 313 "camp.l"
 
1686
#line 320 "camp.l"
1680
1687
{DEFSYMBOL(SYM_EQ); return EQ; }
1681
1688
        YY_BREAK
1682
1689
case 52:
1683
1690
YY_RULE_SETUP
1684
 
#line 314 "camp.l"
 
1691
#line 321 "camp.l"
1685
1692
{DEFSYMBOL(SYM_NEQ); return NEQ; }
1686
1693
        YY_BREAK
1687
1694
case 53:
1688
1695
YY_RULE_SETUP
1689
 
#line 315 "camp.l"
 
1696
#line 322 "camp.l"
1690
1697
{DEFSYMBOL(SYM_LT); return LT; }
1691
1698
        YY_BREAK
1692
1699
case 54:
1693
1700
YY_RULE_SETUP
1694
 
#line 316 "camp.l"
 
1701
#line 323 "camp.l"
1695
1702
{DEFSYMBOL(SYM_LE); return LE; }
1696
1703
        YY_BREAK
1697
1704
case 55:
1698
1705
YY_RULE_SETUP
1699
 
#line 317 "camp.l"
 
1706
#line 324 "camp.l"
1700
1707
{DEFSYMBOL(SYM_GT); return GT; }
1701
1708
        YY_BREAK
1702
1709
case 56:
1703
1710
YY_RULE_SETUP
1704
 
#line 318 "camp.l"
 
1711
#line 325 "camp.l"
1705
1712
{DEFSYMBOL(SYM_GE); return GE; }
1706
1713
        YY_BREAK
1707
1714
case 57:
1708
1715
YY_RULE_SETUP
1709
 
#line 319 "camp.l"
 
1716
#line 326 "camp.l"
1710
1717
{DEFSYMBOL(SYM_CAND); return CAND; }
1711
1718
        YY_BREAK
1712
1719
case 58:
1713
1720
YY_RULE_SETUP
1714
 
#line 320 "camp.l"
 
1721
#line 327 "camp.l"
1715
1722
{DEFSYMBOL(SYM_COR); return COR; }
1716
1723
        YY_BREAK
1717
1724
case 59:
1718
1725
YY_RULE_SETUP
1719
 
#line 321 "camp.l"
 
1726
#line 328 "camp.l"
1720
1727
{DEFSYMBOL(SYM_LOGNOT); return LOGNOT; }
1721
1728
        YY_BREAK
1722
1729
case 60:
1723
1730
YY_RULE_SETUP
1724
 
#line 322 "camp.l"
 
1731
#line 329 "camp.l"
1725
1732
{DEFSYMBOL(SYM_CARETS); return CARETS; }
1726
1733
        YY_BREAK
1727
1734
case 61:
1728
1735
YY_RULE_SETUP
1729
 
#line 323 "camp.l"
 
1736
#line 330 "camp.l"
1730
1737
{DEFSYMBOL(SYM_COLONS); return COLONS; }
1731
1738
        YY_BREAK
1732
1739
case 62:
1733
1740
YY_RULE_SETUP
1734
 
#line 324 "camp.l"
 
1741
#line 331 "camp.l"
1735
1742
{DEFSYMBOL(SYM_INCR); return INCR; }
1736
1743
        YY_BREAK
1737
1744
case 63:
1738
1745
YY_RULE_SETUP
1739
 
#line 325 "camp.l"
 
1746
#line 332 "camp.l"
1740
1747
{DEFSYMBOL(SYM_DOTS); return DOTS; }
1741
1748
        YY_BREAK
1742
1749
case 64:
1743
1750
YY_RULE_SETUP
1744
 
#line 326 "camp.l"
 
1751
#line 333 "camp.l"
1745
1752
{DEFSYMBOL(SYM_DASHES); return DASHES; }
1746
1753
        YY_BREAK
1747
1754
case 65:
1748
1755
YY_RULE_SETUP
1749
 
#line 327 "camp.l"
 
1756
#line 334 "camp.l"
1750
1757
{DEFSYMBOL(SYM_LONGDASH); return LONGDASH; }
1751
1758
        YY_BREAK
1752
1759
case 66:
1753
1760
YY_RULE_SETUP
1754
 
#line 328 "camp.l"
 
1761
#line 335 "camp.l"
1755
1762
{DEFSYMBOL(SYM_AMPERSAND); return AMPERSAND; }
1756
1763
        YY_BREAK
1757
1764
case 67:
1758
1765
YY_RULE_SETUP
1759
 
#line 329 "camp.l"
 
1766
#line 336 "camp.l"
1760
1767
{DEFSYMBOL(SYM_BAR); return BAR; }
1761
1768
        YY_BREAK
1762
1769
case 68:
1763
1770
YY_RULE_SETUP
1764
 
#line 330 "camp.l"
 
1771
#line 337 "camp.l"
1765
1772
{makeopsymbol(); return OPERATOR; }
1766
1773
        YY_BREAK
1767
1774
case 69:
1768
1775
YY_RULE_SETUP
1769
 
#line 332 "camp.l"
 
1776
#line 339 "camp.l"
1770
1777
{savesymbol(SYM_PLUS); return SELFOP; }
1771
1778
        YY_BREAK
1772
1779
case 70:
1773
1780
YY_RULE_SETUP
1774
 
#line 333 "camp.l"
 
1781
#line 340 "camp.l"
1775
1782
{savesymbol(SYM_MINUS); return SELFOP; }
1776
1783
        YY_BREAK
1777
1784
case 71:
1778
1785
YY_RULE_SETUP
1779
 
#line 334 "camp.l"
 
1786
#line 341 "camp.l"
1780
1787
{savesymbol(SYM_TIMES); return SELFOP; }
1781
1788
        YY_BREAK
1782
1789
case 72:
1783
1790
YY_RULE_SETUP
1784
 
#line 335 "camp.l"
 
1791
#line 342 "camp.l"
1785
1792
{savesymbol(SYM_DIVIDE); return SELFOP; }
1786
1793
        YY_BREAK
1787
1794
case 73:
1788
1795
YY_RULE_SETUP
1789
 
#line 336 "camp.l"
 
1796
#line 343 "camp.l"
1790
1797
{savesymbol(SYM_MOD); return SELFOP; }
1791
1798
        YY_BREAK
1792
1799
case 74:
1793
1800
YY_RULE_SETUP
1794
 
#line 337 "camp.l"
 
1801
#line 344 "camp.l"
1795
1802
{savesymbol(SYM_CARET); return SELFOP; }
1796
1803
        YY_BREAK
1797
1804
case 75:
1798
1805
YY_RULE_SETUP
1799
 
#line 339 "camp.l"
 
1806
#line 346 "camp.l"
1800
1807
{adjust(); return AND; }
1801
1808
        YY_BREAK
1802
1809
case 76:
1803
1810
YY_RULE_SETUP
1804
 
#line 340 "camp.l"
 
1811
#line 347 "camp.l"
1805
1812
{DEFSYMBOL(SYM_CONTROLS); return CONTROLS; }
1806
1813
        YY_BREAK
1807
1814
case 77:
1808
1815
YY_RULE_SETUP
1809
 
#line 341 "camp.l"
 
1816
#line 348 "camp.l"
1810
1817
{DEFSYMBOL(SYM_TENSION); return TENSION; }
1811
1818
        YY_BREAK
1812
1819
case 78:
1813
1820
YY_RULE_SETUP
1814
 
#line 342 "camp.l"
 
1821
#line 349 "camp.l"
1815
1822
{DEFSYMBOL(SYM_ATLEAST); return ATLEAST; }
1816
1823
        YY_BREAK
1817
1824
case 79:
1818
1825
YY_RULE_SETUP
1819
 
#line 343 "camp.l"
 
1826
#line 350 "camp.l"
1820
1827
{DEFSYMBOL(SYM_CURL); return CURL; }
1821
1828
        YY_BREAK
1822
1829
case 80:
1823
1830
YY_RULE_SETUP
1824
 
#line 345 "camp.l"
 
1831
#line 352 "camp.l"
1825
1832
{adjust(); return IF; }
1826
1833
        YY_BREAK
1827
1834
case 81:
1828
1835
YY_RULE_SETUP
1829
 
#line 346 "camp.l"
 
1836
#line 353 "camp.l"
1830
1837
{adjust(); return ELSE; }
1831
1838
        YY_BREAK
1832
1839
case 82:
1833
1840
YY_RULE_SETUP
1834
 
#line 347 "camp.l"
 
1841
#line 354 "camp.l"
1835
1842
{adjust(); return WHILE; }
1836
1843
        YY_BREAK
1837
1844
case 83:
1838
1845
YY_RULE_SETUP
1839
 
#line 348 "camp.l"
 
1846
#line 355 "camp.l"
1840
1847
{adjust(); return FOR; }
1841
1848
        YY_BREAK
1842
1849
case 84:
1843
1850
YY_RULE_SETUP
1844
 
#line 349 "camp.l"
 
1851
#line 356 "camp.l"
1845
1852
{adjust(); return DO; }
1846
1853
        YY_BREAK
1847
1854
case 85:
1848
1855
YY_RULE_SETUP
1849
 
#line 350 "camp.l"
 
1856
#line 357 "camp.l"
1850
1857
{adjust(); return RETURN_; }
1851
1858
        YY_BREAK
1852
1859
case 86:
1853
1860
YY_RULE_SETUP
1854
 
#line 351 "camp.l"
 
1861
#line 358 "camp.l"
1855
1862
{adjust(); return BREAK; }
1856
1863
        YY_BREAK
1857
1864
case 87:
1858
1865
YY_RULE_SETUP
1859
 
#line 352 "camp.l"
 
1866
#line 359 "camp.l"
1860
1867
{adjust(); return CONTINUE; }
1861
1868
        YY_BREAK
1862
1869
case 88:
1863
1870
YY_RULE_SETUP
1864
 
#line 353 "camp.l"
 
1871
#line 360 "camp.l"
1865
1872
{adjust(); return STRUCT; }
1866
1873
        YY_BREAK
1867
1874
case 89:
1868
1875
YY_RULE_SETUP
1869
 
#line 354 "camp.l"
 
1876
#line 361 "camp.l"
1870
1877
{adjust(); return TYPEDEF; }
1871
1878
        YY_BREAK
1872
1879
case 90:
1873
1880
YY_RULE_SETUP
1874
 
#line 355 "camp.l"
 
1881
#line 362 "camp.l"
1875
1882
{adjust(); return NEW; }
1876
1883
        YY_BREAK
1877
1884
case 91:
1878
1885
YY_RULE_SETUP
1879
 
#line 356 "camp.l"
 
1886
#line 363 "camp.l"
1880
1887
{adjust(); return ACCESS; }
1881
1888
        YY_BREAK
1882
1889
case 92:
1883
1890
YY_RULE_SETUP
1884
 
#line 357 "camp.l"
 
1891
#line 364 "camp.l"
1885
1892
{adjust(); return IMPORT; }
1886
1893
        YY_BREAK
1887
1894
case 93:
1888
1895
YY_RULE_SETUP
1889
 
#line 358 "camp.l"
 
1896
#line 365 "camp.l"
1890
1897
{adjust(); return UNRAVEL; }
1891
1898
        YY_BREAK
1892
1899
case 94:
1893
1900
YY_RULE_SETUP
1894
 
#line 359 "camp.l"
 
1901
#line 366 "camp.l"
1895
1902
{adjust(); return FROM; }
1896
1903
        YY_BREAK
1897
1904
case 95:
1898
1905
YY_RULE_SETUP
1899
 
#line 360 "camp.l"
 
1906
#line 367 "camp.l"
1900
1907
{adjust(); return INCLUDE; }
1901
1908
        YY_BREAK
1902
1909
case 96:
1903
1910
YY_RULE_SETUP
1904
 
#line 361 "camp.l"
 
1911
#line 368 "camp.l"
1905
1912
{adjust(); return QUOTE; }
1906
1913
        YY_BREAK
1907
1914
case 97:
1908
1915
YY_RULE_SETUP
1909
 
#line 362 "camp.l"
 
1916
#line 369 "camp.l"
1910
1917
{adjust(); makemod(trans::EXPLICIT_STATIC);
1911
1918
                              return MODIFIER; }
1912
1919
        YY_BREAK
1913
1920
case 98:
1914
1921
YY_RULE_SETUP
1915
 
#line 364 "camp.l"
 
1922
#line 371 "camp.l"
1916
1923
{adjust(); makeperm(trans::PUBLIC); return PERM; }
1917
1924
        YY_BREAK
1918
1925
case 99:
1919
1926
YY_RULE_SETUP
1920
 
#line 365 "camp.l"
 
1927
#line 372 "camp.l"
1921
1928
{adjust(); makeperm(trans::PRIVATE); return PERM; }
1922
1929
        YY_BREAK
1923
1930
case 100:
1924
1931
YY_RULE_SETUP
1925
 
#line 366 "camp.l"
 
1932
#line 373 "camp.l"
1926
1933
{adjust(); makeperm(trans::RESTRICTED); return PERM; }
1927
1934
        YY_BREAK
1928
1935
case 101:
1929
1936
YY_RULE_SETUP
1930
 
#line 367 "camp.l"
 
1937
#line 374 "camp.l"
1931
1938
{adjust(); return THIS; }
1932
1939
        YY_BREAK
1933
1940
case 102:
1934
1941
YY_RULE_SETUP
1935
 
#line 368 "camp.l"
 
1942
#line 375 "camp.l"
1936
1943
{adjust(); return EXPLICIT; }
1937
1944
        YY_BREAK
1938
1945
case 103:
1939
1946
YY_RULE_SETUP
1940
 
#line 371 "camp.l"
 
1947
#line 378 "camp.l"
1941
1948
try {
1942
1949
  adjust(); yylval.e= new intExp(here(), lexical::cast<Int>(yytext)); 
1943
1950
  } catch (lexical::bad_cast&) {
1948
1955
        YY_BREAK
1949
1956
case 104:
1950
1957
YY_RULE_SETUP
1951
 
#line 378 "camp.l"
 
1958
#line 385 "camp.l"
1952
1959
try {
1953
1960
  adjust(); yylval.e= new realExp(here(), lexical::cast<double>(yytext));
1954
1961
  } catch (lexical::bad_cast&) {
1959
1966
        YY_BREAK
1960
1967
case 105:
1961
1968
YY_RULE_SETUP
1962
 
#line 385 "camp.l"
 
1969
#line 392 "camp.l"
1963
1970
{
1964
1971
  adjust(); yylval.e= new booleanExp(here(), true); return LIT; }
1965
1972
        YY_BREAK
1966
1973
case 106:
1967
1974
YY_RULE_SETUP
1968
 
#line 387 "camp.l"
 
1975
#line 394 "camp.l"
1969
1976
{
1970
1977
  adjust(); yylval.e= new booleanExp(here(), false); return LIT; }
1971
1978
        YY_BREAK
1972
1979
case 107:
1973
1980
YY_RULE_SETUP
1974
 
#line 389 "camp.l"
 
1981
#line 396 "camp.l"
1975
1982
{
1976
1983
  adjust(); yylval.e= new nullExp(here()); return LIT; }
1977
1984
        YY_BREAK
1978
1985
case 108:
1979
1986
YY_RULE_SETUP
1980
 
#line 391 "camp.l"
 
1987
#line 398 "camp.l"
1981
1988
{
1982
1989
  adjust(); yylval.e= new cycleExp(here()); return LIT; }
1983
1990
        YY_BREAK
1984
1991
case 109:
1985
1992
YY_RULE_SETUP
1986
 
#line 393 "camp.l"
 
1993
#line 400 "camp.l"
1987
1994
{
1988
1995
  adjust(); yylval.e= new newPictureExp(here()); return LIT; }
1989
1996
        YY_BREAK
1990
1997
case 110:
1991
1998
YY_RULE_SETUP
1992
 
#line 396 "camp.l"
 
1999
#line 403 "camp.l"
1993
2000
{adjust(); BEGIN opname; }
1994
2001
        YY_BREAK
1995
2002
 
1996
2003
case 111:
1997
2004
YY_RULE_SETUP
1998
 
#line 398 "camp.l"
 
2005
#line 405 "camp.l"
1999
2006
{adjust(); continue;} 
2000
2007
        YY_BREAK
2001
2008
case 112:
2002
2009
/* rule 112 can match eol */
2003
2010
YY_RULE_SETUP
2004
 
#line 399 "camp.l"
 
2011
#line 406 "camp.l"
2005
2012
{adjust(); newline(); continue;}
2006
2013
        YY_BREAK
2007
2014
case YY_STATE_EOF(opname):
2008
 
#line 400 "camp.l"
 
2015
#line 407 "camp.l"
2009
2016
{adjust();
2010
2017
                    setEOF("missing operator name");
2011
2018
                    BEGIN INITIAL;
2014
2021
        YY_BREAK
2015
2022
case 113:
2016
2023
YY_RULE_SETUP
2017
 
#line 405 "camp.l"
 
2024
#line 412 "camp.l"
2018
2025
{ savesymbol(SYM_CARET);
2019
2026
                     BEGIN INITIAL;
2020
2027
                     return ID;
2022
2029
        YY_BREAK
2023
2030
case 114:
2024
2031
YY_RULE_SETUP
2025
 
#line 409 "camp.l"
 
2032
#line 416 "camp.l"
2026
2033
{
2027
2034
  makeopsymbol();
2028
2035
  BEGIN INITIAL;
2030
2037
        YY_BREAK
2031
2038
case 115:
2032
2039
YY_RULE_SETUP
2033
 
#line 413 "camp.l"
 
2040
#line 420 "camp.l"
2034
2041
{
2035
2042
  makeopsymbol();
2036
2043
  BEGIN INITIAL;
2038
2045
        YY_BREAK
2039
2046
case 116:
2040
2047
YY_RULE_SETUP
2041
 
#line 417 "camp.l"
 
2048
#line 424 "camp.l"
2042
2049
{}
2043
2050
        YY_BREAK
2044
2051
 
2045
2052
case 117:
2046
2053
YY_RULE_SETUP
2047
 
#line 420 "camp.l"
 
2054
#line 427 "camp.l"
2048
2055
{
2049
2056
  makesymbol();
2050
2057
  return ID; }  
2051
2058
        YY_BREAK
2052
2059
case 118:
2053
2060
YY_RULE_SETUP
2054
 
#line 424 "camp.l"
 
2061
#line 431 "camp.l"
2055
2062
{adjust(); /*commentDepth = 1;*/ BEGIN lexcomment; }
2056
2063
        YY_BREAK
2057
2064
case 119:
2058
2065
YY_RULE_SETUP
2059
 
#line 425 "camp.l"
 
2066
#line 432 "camp.l"
2060
2067
{startstring(); BEGIN texstring; }
2061
2068
        YY_BREAK
2062
2069
case 120:
2063
2070
YY_RULE_SETUP
2064
 
#line 426 "camp.l"
 
2071
#line 433 "camp.l"
2065
2072
{startstring(); BEGIN cstring; }
2066
2073
        YY_BREAK
2067
2074
case YY_STATE_EOF(INITIAL):
2068
2075
case YY_STATE_EOF(lexformat):
2069
 
#line 428 "camp.l"
 
2076
#line 435 "camp.l"
2070
2077
{ setEOF("unexpected end of input"); yyterminate(); }
2071
2078
        YY_BREAK
2072
2079
case 121:
2073
2080
YY_RULE_SETUP
2074
 
#line 430 "camp.l"
 
2081
#line 437 "camp.l"
2075
2082
{adjust();
2076
2083
                    error();
2077
2084
                    em << "invalid token";
2081
2088
        YY_BREAK
2082
2089
case 122:
2083
2090
YY_RULE_SETUP
2084
 
#line 436 "camp.l"
 
2091
#line 443 "camp.l"
2085
2092
ECHO;
2086
2093
        YY_BREAK
2087
 
#line 2088 "lex.yy.cc"
 
2094
#line 2095 "lex.yy.cc"
2088
2095
 
2089
2096
        case YY_END_OF_BUFFER:
2090
2097
                {
3217
3224
 
3218
3225
/* %ok-for-header */
3219
3226
 
3220
 
#line 436 "camp.l"
 
3227
#line 443 "camp.l"