← Back to branch summary

~ubuntu-branches/ubuntu/utopic/anjuta/utopic-proposed

« back to all changes in this revision

Viewing changes to plugins/am-project/ac-parser.c

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson, Jackson Doak
  • Date: 2014-07-12 15:17:39 UTC
  • mfrom: (1.4.14)
  • Revision ID: package-import@ubuntu.com-20140712151739-p9xy0ntlgbpm2nxq
Tags: 2:3.12.0-1
* Team upload.

[ Jackson Doak ]
* New upstream release
* Drop 03_valac_0.22.patch, fixed upstream\
* debian/control:
  - Bump b-dep version on libgtk-3-dev (>= 3.6.0), libglib2.0-dev (>= 2.34.0)
  - Bump stardards-version to 3.9.5. No changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/am-project/ac-parser.c
1
 
/* A Bison parser, made by GNU Bison 2.5.  */
 
1
/* A Bison parser, made by GNU Bison 2.7.  */
2
2
 
3
3
/* Bison implementation for Yacc-like parsers in C
4
4
   
5
 
      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
 
5
      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
6
6
   
7
7
   This program is free software: you can redistribute it and/or modify
8
8
   it under the terms of the GNU General Public License as published by
44
44
#define YYBISON 1
45
45
 
46
46
/* Bison version.  */
47
 
#define YYBISON_VERSION "2.5"
 
47
#define YYBISON_VERSION "2.7"
48
48
 
49
49
/* Skeleton name.  */
50
50
#define YYSKELETON_NAME "yacc.c"
58
58
/* Pull parsers.  */
59
59
#define YYPULL 0
60
60
 
61
 
/* Using locations.  */
62
 
#define YYLSP_NEEDED 1
63
61
 
64
62
/* Substitute the variable and function names.  */
65
63
#define yypush_parse    amp_ac_yypush_parse
75
73
#define yylloc          amp_ac_yylloc
76
74
 
77
75
/* Copy the first part of user declarations.  */
78
 
 
79
 
/* Line 268 of yacc.c  */
 
76
/* Line 371 of yacc.c  */
80
77
#line 19 "ac-parser.y"
81
78
 
82
79
 
93
90
 * maintain a separate location variable */
94
91
#define YYLLOC_DEFAULT(Current, Rhs, N) ((Current) = YYRHSLOC(Rhs, (N) ? 1 : 0))
95
92
 
96
 
 
97
 
/* Line 268 of yacc.c  */
 
93
/* Line 371 of yacc.c  */
98
94
#line 133 "ac-parser.y"
99
95
 
100
96
 
147
143
}
148
144
 
149
145
 
150
 
 
151
 
/* Line 268 of yacc.c  */
152
 
#line 153 "ac-parser.c"
153
 
 
154
 
/* Enabling traces.  */
155
 
#ifndef YYDEBUG
156
 
# define YYDEBUG 1
157
 
#endif
 
146
/* Line 371 of yacc.c  */
 
147
#line 148 "ac-parser.c"
 
148
 
 
149
# ifndef YY_NULL
 
150
#  if defined __cplusplus && 201103L <= __cplusplus
 
151
#   define YY_NULL nullptr
 
152
#  else
 
153
#   define YY_NULL 0
 
154
#  endif
 
155
# endif
158
156
 
159
157
/* Enabling verbose error messages.  */
160
158
#ifdef YYERROR_VERBOSE
164
162
# define YYERROR_VERBOSE 0
165
163
#endif
166
164
 
167
 
/* Enabling the token table.  */
168
 
#ifndef YYTOKEN_TABLE
169
 
# define YYTOKEN_TABLE 0
170
 
#endif
171
 
 
 
165
/* In a future release of Bison, this section will be replaced
 
166
   by #include "ac-parser.h".  */
 
167
#ifndef YY_AMP_AC_YY_AC_PARSER_H_INCLUDED
 
168
# define YY_AMP_AC_YY_AC_PARSER_H_INCLUDED
 
169
/* Enabling traces.  */
 
170
#ifndef YYDEBUG
 
171
# define YYDEBUG 1
 
172
#endif
 
173
#if YYDEBUG
 
174
extern int amp_ac_yydebug;
 
175
#endif
172
176
 
173
177
/* Tokens.  */
174
178
#ifndef YYTOKENTYPE
318
322
 
319
323
 
320
324
 
321
 
 
322
325
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
323
326
typedef int YYSTYPE;
324
327
# define YYSTYPE_IS_TRIVIAL 1
339
342
# define YYLTYPE_IS_TRIVIAL 1
340
343
#endif
341
344
 
342
 
#ifndef YYPUSH_DECLS
343
 
#  define YYPUSH_DECLS
344
 
struct yypstate;
345
 
typedef struct yypstate yypstate;
 
345
 
 
346
#ifndef YYPUSH_MORE_DEFINED
 
347
# define YYPUSH_MORE_DEFINED
346
348
enum { YYPUSH_MORE = 4 };
347
 
 
348
 
#if defined __STDC__ || defined __cplusplus
349
 
int yypush_parse (yypstate *yyps, int yypushed_char, YYSTYPE const *yypushed_val, YYLTYPE const *yypushed_loc, AmpAcScanner* scanner);
350
 
#else
351
 
int yypush_parse ();
352
 
#endif
353
 
 
354
 
#if defined __STDC__ || defined __cplusplus
355
 
yypstate * yypstate_new (void);
356
 
#else
357
 
yypstate * yypstate_new ();
358
 
#endif
359
 
#if defined __STDC__ || defined __cplusplus
360
 
void yypstate_delete (yypstate *yyps);
361
 
#else
362
 
void yypstate_delete ();
363
 
#endif
364
 
#endif
365
 
 
 
349
#endif
 
350
 
 
351
typedef struct amp_ac_yypstate amp_ac_yypstate;
 
352
 
 
353
#if defined __STDC__ || defined __cplusplus
 
354
int amp_ac_yypush_parse (amp_ac_yypstate *ps, int pushed_char, YYSTYPE const *pushed_val, YYLTYPE *pushed_loc, AmpAcScanner* scanner);
 
355
#else
 
356
int amp_ac_yypush_parse ();
 
357
#endif
 
358
 
 
359
#if defined __STDC__ || defined __cplusplus
 
360
amp_ac_yypstate * amp_ac_yypstate_new (void);
 
361
#else
 
362
amp_ac_yypstate * amp_ac_yypstate_new ();
 
363
#endif
 
364
#if defined __STDC__ || defined __cplusplus
 
365
void amp_ac_yypstate_delete (amp_ac_yypstate *ps);
 
366
#else
 
367
void amp_ac_yypstate_delete ();
 
368
#endif
 
369
 
 
370
#endif /* !YY_AMP_AC_YY_AC_PARSER_H_INCLUDED  */
366
371
 
367
372
/* Copy the second part of user declarations.  */
368
373
 
369
 
 
370
 
/* Line 343 of yacc.c  */
371
 
#line 372 "ac-parser.c"
 
374
/* Line 390 of yacc.c  */
 
375
#line 376 "ac-parser.c"
372
376
 
373
377
#ifdef short
374
378
# undef short
421
425
# if defined YYENABLE_NLS && YYENABLE_NLS
422
426
#  if ENABLE_NLS
423
427
#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
424
 
#   define YY_(msgid) dgettext ("bison-runtime", msgid)
 
428
#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
425
429
#  endif
426
430
# endif
427
431
# ifndef YY_
428
 
#  define YY_(msgid) msgid
 
432
#  define YY_(Msgid) Msgid
429
433
# endif
430
434
#endif
431
435
 
432
436
/* Suppress unused-variable warnings by "using" E.  */
433
437
#if ! defined lint || defined __GNUC__
434
 
# define YYUSE(e) ((void) (e))
 
438
# define YYUSE(E) ((void) (E))
435
439
#else
436
 
# define YYUSE(e) /* empty */
 
440
# define YYUSE(E) /* empty */
437
441
#endif
438
442
 
439
443
/* Identity function, used to suppress warnings about constant conditions.  */
440
444
#ifndef lint
441
 
# define YYID(n) (n)
 
445
# define YYID(N) (N)
442
446
#else
443
447
#if (defined __STDC__ || defined __C99__FUNC__ \
444
448
     || defined __cplusplus || defined _MSC_VER)
543
547
#endif
544
548
 
545
549
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
546
 
/* Copy COUNT objects from FROM to TO.  The source and destination do
 
550
/* Copy COUNT objects from SRC to DST.  The source and destination do
547
551
   not overlap.  */
548
552
# ifndef YYCOPY
549
553
#  if defined __GNUC__ && 1 < __GNUC__
550
 
#   define YYCOPY(To, From, Count) \
551
 
      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 
554
#   define YYCOPY(Dst, Src, Count) \
 
555
      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
552
556
#  else
553
 
#   define YYCOPY(To, From, Count)              \
554
 
      do                                        \
555
 
        {                                       \
556
 
          YYSIZE_T yyi;                         \
557
 
          for (yyi = 0; yyi < (Count); yyi++)   \
558
 
            (To)[yyi] = (From)[yyi];            \
559
 
        }                                       \
 
557
#   define YYCOPY(Dst, Src, Count)              \
 
558
      do                                        \
 
559
        {                                       \
 
560
          YYSIZE_T yyi;                         \
 
561
          for (yyi = 0; yyi < (Count); yyi++)   \
 
562
            (Dst)[yyi] = (Src)[yyi];            \
 
563
        }                                       \
560
564
      while (YYID (0))
561
565
#  endif
562
566
# endif
771
775
};
772
776
#endif
773
777
 
774
 
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 
778
#if YYDEBUG || YYERROR_VERBOSE || 0
775
779
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
776
780
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
777
781
static const char *const yytname[] =
808
812
  "expression_body", "optional_spaces", "spaces", "spaces_with_eol",
809
813
  "not_eol_token", "not_brace_token", "args_token", "not_operator_token",
810
814
  "word_token", "any_macro", "ac_macro_without_arg_token",
811
 
  "ac_macro_with_arg_token", "end_of_line", 0
 
815
  "ac_macro_with_arg_token", "end_of_line", YY_NULL
812
816
};
813
817
#endif
814
818
 
1177
1181
      56,    57,    93,    59
1178
1182
};
1179
1183
 
1180
 
#define yypact_value_is_default(yystate) \
1181
 
  ((yystate) == (-288))
 
1184
#define yypact_value_is_default(Yystate) \
 
1185
  (!!((Yystate) == (-288)))
1182
1186
 
1183
 
#define yytable_value_is_error(yytable_value) \
 
1187
#define yytable_value_is_error(Yytable_value) \
1184
1188
  YYID (0)
1185
1189
 
1186
1190
static const yytype_int16 yycheck[] =
1417
1421
 
1418
1422
#define YYRECOVERING()  (!!yyerrstatus)
1419
1423
 
1420
 
#define YYBACKUP(Token, Value)                                  \
1421
 
do                                                              \
1422
 
  if (yychar == YYEMPTY && yylen == 1)                          \
1423
 
    {                                                           \
1424
 
      yychar = (Token);                                         \
1425
 
      yylval = (Value);                                         \
1426
 
      YYPOPSTACK (1);                                           \
1427
 
      goto yybackup;                                            \
1428
 
    }                                                           \
1429
 
  else                                                          \
1430
 
    {                                                           \
 
1424
#define YYBACKUP(Token, Value)                                  \
 
1425
do                                                              \
 
1426
  if (yychar == YYEMPTY)                                        \
 
1427
    {                                                           \
 
1428
      yychar = (Token);                                         \
 
1429
      yylval = (Value);                                         \
 
1430
      YYPOPSTACK (yylen);                                       \
 
1431
      yystate = *yyssp;                                         \
 
1432
      goto yybackup;                                            \
 
1433
    }                                                           \
 
1434
  else                                                          \
 
1435
    {                                                           \
1431
1436
      yyerror (&yylloc, scanner, YY_("syntax error: cannot back up")); \
1432
1437
      YYERROR;                                                  \
1433
1438
    }                                                           \
1434
1439
while (YYID (0))
1435
1440
 
1436
 
 
 
1441
/* Error token number */
1437
1442
#define YYTERROR        1
1438
1443
#define YYERRCODE       256
1439
1444
 
1442
1447
   If N is 0, then set CURRENT to the empty location which ends
1443
1448
   the previous symbol: RHS[0] (always defined).  */
1444
1449
 
 
1450
#ifndef YYLLOC_DEFAULT
 
1451
# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
 
1452
    do                                                                  \
 
1453
      if (YYID (N))                                                     \
 
1454
        {                                                               \
 
1455
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
 
1456
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
 
1457
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
 
1458
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
 
1459
        }                                                               \
 
1460
      else                                                              \
 
1461
        {                                                               \
 
1462
          (Current).first_line   = (Current).last_line   =              \
 
1463
            YYRHSLOC (Rhs, 0).last_line;                                \
 
1464
          (Current).first_column = (Current).last_column =              \
 
1465
            YYRHSLOC (Rhs, 0).last_column;                              \
 
1466
        }                                                               \
 
1467
    while (YYID (0))
 
1468
#endif
 
1469
 
1445
1470
#define YYRHSLOC(Rhs, K) ((Rhs)[K])
1446
 
#ifndef YYLLOC_DEFAULT
1447
 
# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
1448
 
    do                                                                  \
1449
 
      if (YYID (N))                                                    \
1450
 
        {                                                               \
1451
 
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
1452
 
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
1453
 
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
1454
 
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
1455
 
        }                                                               \
1456
 
      else                                                              \
1457
 
        {                                                               \
1458
 
          (Current).first_line   = (Current).last_line   =              \
1459
 
            YYRHSLOC (Rhs, 0).last_line;                                \
1460
 
          (Current).first_column = (Current).last_column =              \
1461
 
            YYRHSLOC (Rhs, 0).last_column;                              \
1462
 
        }                                                               \
1463
 
    while (YYID (0))
1464
 
#endif
1465
1471
 
1466
1472
 
1467
1473
/* YY_LOCATION_PRINT -- Print the location on the stream.
1470
1476
 
1471
1477
#ifndef YY_LOCATION_PRINT
1472
1478
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1473
 
#  define YY_LOCATION_PRINT(File, Loc)                  \
1474
 
     fprintf (File, "%d.%d-%d.%d",                      \
1475
 
              (Loc).first_line, (Loc).first_column,     \
1476
 
              (Loc).last_line,  (Loc).last_column)
 
1479
 
 
1480
/* Print *YYLOCP on YYO.  Private, do not rely on its existence. */
 
1481
 
 
1482
__attribute__((__unused__))
 
1483
#if (defined __STDC__ || defined __C99__FUNC__ \
 
1484
     || defined __cplusplus || defined _MSC_VER)
 
1485
static unsigned
 
1486
yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
 
1487
#else
 
1488
static unsigned
 
1489
yy_location_print_ (yyo, yylocp)
 
1490
    FILE *yyo;
 
1491
    YYLTYPE const * const yylocp;
 
1492
#endif
 
1493
{
 
1494
  unsigned res = 0;
 
1495
  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
 
1496
  if (0 <= yylocp->first_line)
 
1497
    {
 
1498
      res += fprintf (yyo, "%d", yylocp->first_line);
 
1499
      if (0 <= yylocp->first_column)
 
1500
        res += fprintf (yyo, ".%d", yylocp->first_column);
 
1501
    }
 
1502
  if (0 <= yylocp->last_line)
 
1503
    {
 
1504
      if (yylocp->first_line < yylocp->last_line)
 
1505
        {
 
1506
          res += fprintf (yyo, "-%d", yylocp->last_line);
 
1507
          if (0 <= end_col)
 
1508
            res += fprintf (yyo, ".%d", end_col);
 
1509
        }
 
1510
      else if (0 <= end_col && yylocp->first_column < end_col)
 
1511
        res += fprintf (yyo, "-%d", end_col);
 
1512
    }
 
1513
  return res;
 
1514
 }
 
1515
 
 
1516
#  define YY_LOCATION_PRINT(File, Loc)          \
 
1517
  yy_location_print_ (File, &(Loc))
 
1518
 
1477
1519
# else
1478
1520
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1479
1521
# endif
1481
1523
 
1482
1524
 
1483
1525
/* YYLEX -- calling `yylex' with the right arguments.  */
1484
 
 
1485
1526
#ifdef YYLEX_PARAM
1486
1527
# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
1487
1528
#else
1533
1574
    AmpAcScanner* scanner;
1534
1575
#endif
1535
1576
{
 
1577
  FILE *yyo = yyoutput;
 
1578
  YYUSE (yyo);
1536
1579
  if (!yyvaluep)
1537
1580
    return;
1538
1581
  YYUSE (yylocationp);
1546
1589
  switch (yytype)
1547
1590
    {
1548
1591
      default:
1549
 
        break;
 
1592
        break;
1550
1593
    }
1551
1594
}
1552
1595
 
1792
1835
yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1793
1836
                yytype_int16 *yyssp, int yytoken)
1794
1837
{
1795
 
  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
 
1838
  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
1796
1839
  YYSIZE_T yysize = yysize0;
1797
 
  YYSIZE_T yysize1;
1798
1840
  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1799
1841
  /* Internationalized format string. */
1800
 
  const char *yyformat = 0;
 
1842
  const char *yyformat = YY_NULL;
1801
1843
  /* Arguments of yyformat. */
1802
1844
  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1803
1845
  /* Number of reported tokens (one for the "unexpected", one per
1857
1899
                    break;
1858
1900
                  }
1859
1901
                yyarg[yycount++] = yytname[yyx];
1860
 
                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1861
 
                if (! (yysize <= yysize1
1862
 
                       && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1863
 
                  return 2;
1864
 
                yysize = yysize1;
 
1902
                {
 
1903
                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
 
1904
                  if (! (yysize <= yysize1
 
1905
                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
 
1906
                    return 2;
 
1907
                  yysize = yysize1;
 
1908
                }
1865
1909
              }
1866
1910
        }
1867
1911
    }
1881
1925
# undef YYCASE_
1882
1926
    }
1883
1927
 
1884
 
  yysize1 = yysize + yystrlen (yyformat);
1885
 
  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1886
 
    return 2;
1887
 
  yysize = yysize1;
 
1928
  {
 
1929
    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
 
1930
    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
 
1931
      return 2;
 
1932
    yysize = yysize1;
 
1933
  }
1888
1934
 
1889
1935
  if (*yymsg_alloc < yysize)
1890
1936
    {
1948
1994
    {
1949
1995
 
1950
1996
      default:
1951
 
        break;
 
1997
        break;
1952
1998
    }
1953
1999
}
1954
2000
 
1955
2001
 
 
2002
 
1956
2003
struct yypstate
1957
2004
  {
1958
2005
    /* Number of syntax errors so far.  */
1967
2014
       `yyvs': related to semantic values.
1968
2015
       `yyls': related to locations.
1969
2016
 
1970
 
       Refer to the stacks thru separate pointers, to allow yyoverflow
 
2017
       Refer to the stacks through separate pointers, to allow yyoverflow
1971
2018
       to reallocate them elsewhere.  */
1972
2019
 
1973
2020
    /* The state stack.  */
2008
2055
  yypstate *yyps;
2009
2056
  yyps = (yypstate *) malloc (sizeof *yyps);
2010
2057
  if (!yyps)
2011
 
    return 0;
 
2058
    return YY_NULL;
2012
2059
  yyps->yynew = 1;
2013
2060
  return yyps;
2014
2061
}
2055
2102
#if (defined __STDC__ || defined __C99__FUNC__ \
2056
2103
     || defined __cplusplus || defined _MSC_VER)
2057
2104
int
2058
 
yypush_parse (yypstate *yyps, int yypushed_char, YYSTYPE const *yypushed_val, YYLTYPE const *yypushed_loc, AmpAcScanner* scanner)
 
2105
yypush_parse (yypstate *yyps, int yypushed_char, YYSTYPE const *yypushed_val, YYLTYPE *yypushed_loc, AmpAcScanner* scanner)
2059
2106
#else
2060
2107
int
2061
2108
yypush_parse (yyps, yypushed_char, yypushed_val, yypushed_loc, scanner)
2062
2109
    yypstate *yyps;
2063
2110
    int yypushed_char;
2064
2111
    YYSTYPE const *yypushed_val;
2065
 
    YYLTYPE const *yypushed_loc;
 
2112
    YYLTYPE *yypushed_loc;
2066
2113
    AmpAcScanner* scanner;
2067
2114
#endif
2068
2115
{
2069
2116
/* The lookahead symbol.  */
2070
2117
int yychar;
2071
2118
 
 
2119
 
 
2120
#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
 
2121
/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
 
2122
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
 
2123
    _Pragma ("GCC diagnostic push") \
 
2124
    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
 
2125
    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
 
2126
# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
 
2127
    _Pragma ("GCC diagnostic pop")
 
2128
#else
 
2129
/* Default value used for initialization, for pacifying older GCCs
 
2130
   or non-GCC compilers.  */
 
2131
static YYSTYPE yyval_default;
 
2132
# define YY_INITIAL_VALUE(Value) = Value
 
2133
#endif
 
2134
static YYLTYPE yyloc_default
 
2135
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
 
2136
  = { 1, 1, 1, 1 }
 
2137
# endif
 
2138
;
 
2139
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 
2140
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 
2141
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
 
2142
#endif
 
2143
#ifndef YY_INITIAL_VALUE
 
2144
# define YY_INITIAL_VALUE(Value) /* Nothing. */
 
2145
#endif
 
2146
 
2072
2147
/* The semantic value of the lookahead symbol.  */
2073
 
YYSTYPE yylval;
 
2148
YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
2074
2149
 
2075
2150
/* Location data for the lookahead symbol.  */
2076
 
YYLTYPE yylloc;
 
2151
YYLTYPE yylloc = yyloc_default;
 
2152
 
2077
2153
 
2078
2154
  int yyn;
2079
2155
  int yyresult;
2080
2156
  /* Lookahead token as an internal (translated) token number.  */
2081
 
  int yytoken;
 
2157
  int yytoken = 0;
2082
2158
  /* The variables used to return semantic value and location from the
2083
2159
     action routines.  */
2084
2160
  YYSTYPE yyval;
2103
2179
      goto yyread_pushed_token;
2104
2180
    }
2105
2181
 
2106
 
  yytoken = 0;
2107
 
  yyss = yyssa;
2108
 
  yyvs = yyvsa;
2109
 
  yyls = yylsa;
 
2182
  yyssp = yyss = yyssa;
 
2183
  yyvsp = yyvs = yyvsa;
 
2184
  yylsp = yyls = yylsa;
2110
2185
  yystacksize = YYINITDEPTH;
2111
2186
 
2112
2187
  YYDPRINTF ((stderr, "Starting parse\n"));
2115
2190
  yyerrstatus = 0;
2116
2191
  yynerrs = 0;
2117
2192
  yychar = YYEMPTY; /* Cause a token to be read.  */
2118
 
 
2119
 
  /* Initialize stack pointers.
2120
 
     Waste one element of value and location stack
2121
 
     so that they stay on the same level as the state stack.
2122
 
     The wasted elements are never initialized.  */
2123
 
  yyssp = yyss;
2124
 
  yyvsp = yyvs;
2125
 
  yylsp = yyls;
2126
 
 
2127
 
#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
2128
 
  /* Initialize the default location before parsing starts.  */
2129
 
  yylloc.first_line   = yylloc.last_line   = 1;
2130
 
  yylloc.first_column = yylloc.last_column = 1;
2131
 
#endif
2132
 
 
 
2193
  yylsp[0] = *yypushed_loc;
2133
2194
  goto yysetstate;
2134
2195
 
2135
2196
/*------------------------------------------------------------.
2287
2348
  yychar = YYEMPTY;
2288
2349
 
2289
2350
  yystate = yyn;
 
2351
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2290
2352
  *++yyvsp = yylval;
 
2353
  YY_IGNORE_MAYBE_UNINITIALIZED_END
2291
2354
  *++yylsp = yylloc;
2292
2355
  goto yynewstate;
2293
2356
 
2325
2388
  switch (yyn)
2326
2389
    {
2327
2390
        case 8:
2328
 
 
2329
 
/* Line 1806 of yacc.c  */
 
2391
/* Line 1792 of yacc.c  */
2330
2392
#line 204 "ac-parser.y"
2331
2393
    {
2332
2394
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_DEFINITION, NULL);
2340
2402
    break;
2341
2403
 
2342
2404
  case 9:
2343
 
 
2344
 
/* Line 1806 of yacc.c  */
 
2405
/* Line 1792 of yacc.c  */
2345
2406
#line 213 "ac-parser.y"
2346
2407
    {
2347
2408
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_DEFINITION, NULL);
2354
2415
    break;
2355
2416
 
2356
2417
  case 17:
2357
 
 
2358
 
/* Line 1806 of yacc.c  */
 
2418
/* Line 1792 of yacc.c  */
2359
2419
#line 237 "ac-parser.y"
2360
2420
    {
2361
2421
                (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_LIST, NULL);
2364
2424
    break;
2365
2425
 
2366
2426
  case 18:
2367
 
 
2368
 
/* Line 1806 of yacc.c  */
 
2427
/* Line 1792 of yacc.c  */
2369
2428
#line 241 "ac-parser.y"
2370
2429
    {
2371
2430
                anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2373
2432
    break;
2374
2433
 
2375
2434
  case 58:
2376
 
 
2377
 
/* Line 1806 of yacc.c  */
 
2435
/* Line 1792 of yacc.c  */
2378
2436
#line 302 "ac-parser.y"
2379
2437
    {
2380
2438
                anjuta_token_set_type ((yyvsp[(2) - (2)]), ANJUTA_TOKEN_LAST);
2382
2440
    break;
2383
2441
 
2384
2442
  case 60:
2385
 
 
2386
 
/* Line 1806 of yacc.c  */
 
2443
/* Line 1792 of yacc.c  */
2387
2444
#line 309 "ac-parser.y"
2388
2445
    {
2389
2446
        anjuta_token_set_type ((yyvsp[(1) - (2)]), ANJUTA_TOKEN_NEXT);
2391
2448
    break;
2392
2449
 
2393
2450
  case 61:
2394
 
 
2395
 
/* Line 1806 of yacc.c  */
 
2451
/* Line 1792 of yacc.c  */
2396
2452
#line 312 "ac-parser.y"
2397
2453
    {
2398
2454
        anjuta_token_set_type ((yyvsp[(2) - (3)]), ANJUTA_TOKEN_NEXT);
2400
2456
    break;
2401
2457
 
2402
2458
  case 64:
2403
 
 
2404
 
/* Line 1806 of yacc.c  */
 
2459
/* Line 1792 of yacc.c  */
2405
2460
#line 323 "ac-parser.y"
2406
2461
    {
2407
2462
        anjuta_token_set_type ((yyvsp[(1) - (1)]), ANJUTA_TOKEN_OPERATOR);
2409
2464
    break;
2410
2465
 
2411
2466
  case 65:
2412
 
 
2413
 
/* Line 1806 of yacc.c  */
 
2467
/* Line 1792 of yacc.c  */
2414
2468
#line 329 "ac-parser.y"
2415
2469
    {
2416
2470
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_NAME, NULL);
2419
2473
    break;
2420
2474
 
2421
2475
  case 66:
2422
 
 
2423
 
/* Line 1806 of yacc.c  */
 
2476
/* Line 1792 of yacc.c  */
2424
2477
#line 333 "ac-parser.y"
2425
2478
    {
2426
2479
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2428
2481
    break;
2429
2482
 
2430
2483
  case 70:
2431
 
 
2432
 
/* Line 1806 of yacc.c  */
 
2484
/* Line 1792 of yacc.c  */
2433
2485
#line 348 "ac-parser.y"
2434
2486
    {
2435
2487
                (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_COMMENT, NULL);
2440
2492
    break;
2441
2493
 
2442
2494
  case 71:
2443
 
 
2444
 
/* Line 1806 of yacc.c  */
 
2495
/* Line 1792 of yacc.c  */
2445
2496
#line 357 "ac-parser.y"
2446
2497
    {
2447
2498
                (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_LIST, NULL);
2452
2503
    break;
2453
2504
 
2454
2505
  case 72:
2455
 
 
2456
 
/* Line 1806 of yacc.c  */
 
2506
/* Line 1792 of yacc.c  */
2457
2507
#line 367 "ac-parser.y"
2458
2508
    {
2459
2509
                (yyval) = anjuta_token_new_static (AC_TOKEN_PKG_CHECK_MODULES, NULL);
2464
2514
    break;
2465
2515
 
2466
2516
  case 73:
2467
 
 
2468
 
/* Line 1806 of yacc.c  */
 
2517
/* Line 1792 of yacc.c  */
2469
2518
#line 381 "ac-parser.y"
2470
2519
    {
2471
2520
                (yyval) = anjuta_token_new_static (amp_ac_autoconf_macro ((yyvsp[(1) - (2)])), NULL);
2476
2525
    break;
2477
2526
 
2478
2527
  case 74:
2479
 
 
2480
 
/* Line 1806 of yacc.c  */
 
2528
/* Line 1792 of yacc.c  */
2481
2529
#line 390 "ac-parser.y"
2482
2530
    {
2483
2531
                anjuta_token_set_type ((yyvsp[(1) - (1)]), amp_ac_autoconf_macro ((yyvsp[(1) - (1)])));
2486
2534
    break;
2487
2535
 
2488
2536
  case 75:
2489
 
 
2490
 
/* Line 1806 of yacc.c  */
 
2537
/* Line 1792 of yacc.c  */
2491
2538
#line 396 "ac-parser.y"
2492
2539
    {
2493
2540
                (yyval) = anjuta_token_new_static (AC_TOKEN_AC_SUBST, NULL);
2498
2545
    break;
2499
2546
 
2500
2547
  case 76:
2501
 
 
2502
 
/* Line 1806 of yacc.c  */
 
2548
/* Line 1792 of yacc.c  */
2503
2549
#line 405 "ac-parser.y"
2504
2550
    {
2505
2551
        anjuta_token_set_type ((yyvsp[(1) - (1)]), AC_TOKEN_AC_OUTPUT);
2507
2553
    break;
2508
2554
 
2509
2555
  case 77:
2510
 
 
2511
 
/* Line 1806 of yacc.c  */
 
2556
/* Line 1792 of yacc.c  */
2512
2557
#line 411 "ac-parser.y"
2513
2558
    {
2514
2559
                (yyval) = anjuta_token_new_static (AC_TOKEN_OBSOLETE_AC_OUTPUT, NULL);
2519
2564
    break;
2520
2565
 
2521
2566
  case 78:
2522
 
 
2523
 
/* Line 1806 of yacc.c  */
 
2567
/* Line 1792 of yacc.c  */
2524
2568
#line 420 "ac-parser.y"
2525
2569
    {
2526
2570
                (yyval) = anjuta_token_new_static (AC_TOKEN_AC_CONFIG_FILES, NULL);
2531
2575
    break;
2532
2576
 
2533
2577
  case 79:
2534
 
 
2535
 
/* Line 1806 of yacc.c  */
 
2578
/* Line 1792 of yacc.c  */
2536
2579
#line 432 "ac-parser.y"
2537
2580
    {
2538
2581
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_LAST, NULL);
2543
2586
    break;
2544
2587
 
2545
2588
  case 80:
2546
 
 
2547
 
/* Line 1806 of yacc.c  */
 
2589
/* Line 1792 of yacc.c  */
2548
2590
#line 438 "ac-parser.y"
2549
2591
    {
2550
2592
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_LAST, NULL);
2558
2600
    break;
2559
2601
 
2560
2602
  case 81:
2561
 
 
2562
 
/* Line 1806 of yacc.c  */
 
2603
/* Line 1792 of yacc.c  */
2563
2604
#line 450 "ac-parser.y"
2564
2605
    {
2565
2606
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_LIST, NULL);
2570
2611
    break;
2571
2612
 
2572
2613
  case 82:
2573
 
 
2574
 
/* Line 1806 of yacc.c  */
 
2614
/* Line 1792 of yacc.c  */
2575
2615
#line 456 "ac-parser.y"
2576
2616
    {
2577
2617
        //fprintf(stdout, "arg_list_body body\n");
2588
2628
    break;
2589
2629
 
2590
2630
  case 83:
2591
 
 
2592
 
/* Line 1806 of yacc.c  */
 
2631
/* Line 1792 of yacc.c  */
2593
2632
#line 471 "ac-parser.y"
2594
2633
    {
2595
2634
                (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_COMMENT, NULL);
2600
2639
    break;
2601
2640
 
2602
2641
  case 84:
2603
 
 
2604
 
/* Line 1806 of yacc.c  */
 
2642
/* Line 1792 of yacc.c  */
2605
2643
#line 480 "ac-parser.y"
2606
2644
    {
2607
2645
        (yyval) = NULL;
2609
2647
    break;
2610
2648
 
2611
2649
  case 85:
2612
 
 
2613
 
/* Line 1806 of yacc.c  */
 
2650
/* Line 1792 of yacc.c  */
2614
2651
#line 483 "ac-parser.y"
2615
2652
    {
2616
2653
        (yyval) = (yyvsp[(2) - (2)]);
2618
2655
    break;
2619
2656
 
2620
2657
  case 88:
2621
 
 
2622
 
/* Line 1806 of yacc.c  */
 
2658
/* Line 1792 of yacc.c  */
2623
2659
#line 494 "ac-parser.y"
2624
2660
    {
2625
2661
        anjuta_token_set_type ((yyvsp[(1) - (3)]), ANJUTA_TOKEN_OPEN_QUOTE);
2630
2666
    break;
2631
2667
 
2632
2668
  case 89:
2633
 
 
2634
 
/* Line 1806 of yacc.c  */
 
2669
/* Line 1792 of yacc.c  */
2635
2670
#line 503 "ac-parser.y"
2636
2671
    {
2637
2672
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
2639
2674
    break;
2640
2675
 
2641
2676
  case 90:
2642
 
 
2643
 
/* Line 1806 of yacc.c  */
 
2677
/* Line 1792 of yacc.c  */
2644
2678
#line 506 "ac-parser.y"
2645
2679
    {
2646
2680
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2648
2682
    break;
2649
2683
 
2650
2684
  case 106:
2651
 
 
2652
 
/* Line 1806 of yacc.c  */
 
2685
/* Line 1792 of yacc.c  */
2653
2686
#line 530 "ac-parser.y"
2654
2687
    {
2655
2688
        anjuta_token_set_type ((yyvsp[(1) - (3)]), ANJUTA_TOKEN_OPEN_QUOTE);
2660
2693
    break;
2661
2694
 
2662
2695
  case 107:
2663
 
 
2664
 
/* Line 1806 of yacc.c  */
 
2696
/* Line 1792 of yacc.c  */
2665
2697
#line 539 "ac-parser.y"
2666
2698
    {
2667
2699
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
2669
2701
    break;
2670
2702
 
2671
2703
  case 108:
2672
 
 
2673
 
/* Line 1806 of yacc.c  */
 
2704
/* Line 1792 of yacc.c  */
2674
2705
#line 542 "ac-parser.y"
2675
2706
    {
2676
2707
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2678
2709
    break;
2679
2710
 
2680
2711
  case 123:
2681
 
 
2682
 
/* Line 1806 of yacc.c  */
 
2712
/* Line 1792 of yacc.c  */
2683
2713
#line 565 "ac-parser.y"
2684
2714
    {
2685
2715
        anjuta_token_set_type ((yyvsp[(1) - (3)]), ANJUTA_TOKEN_OPEN_QUOTE);
2690
2720
    break;
2691
2721
 
2692
2722
  case 124:
2693
 
 
2694
 
/* Line 1806 of yacc.c  */
 
2723
/* Line 1792 of yacc.c  */
2695
2724
#line 574 "ac-parser.y"
2696
2725
    {
2697
2726
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
2699
2728
    break;
2700
2729
 
2701
2730
  case 125:
2702
 
 
2703
 
/* Line 1806 of yacc.c  */
 
2731
/* Line 1792 of yacc.c  */
2704
2732
#line 577 "ac-parser.y"
2705
2733
    {
2706
2734
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2708
2736
    break;
2709
2737
 
2710
2738
  case 126:
2711
 
 
2712
 
/* Line 1806 of yacc.c  */
 
2739
/* Line 1792 of yacc.c  */
2713
2740
#line 580 "ac-parser.y"
2714
2741
    {
2715
2742
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2717
2744
    break;
2718
2745
 
2719
2746
  case 127:
2720
 
 
2721
 
/* Line 1806 of yacc.c  */
 
2747
/* Line 1792 of yacc.c  */
2722
2748
#line 586 "ac-parser.y"
2723
2749
    {
2724
2750
        anjuta_token_set_type ((yyvsp[(1) - (3)]), ANJUTA_TOKEN_OPEN_QUOTE);
2729
2755
    break;
2730
2756
 
2731
2757
  case 128:
2732
 
 
2733
 
/* Line 1806 of yacc.c  */
 
2758
/* Line 1792 of yacc.c  */
2734
2759
#line 595 "ac-parser.y"
2735
2760
    {
2736
2761
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
2738
2763
    break;
2739
2764
 
2740
2765
  case 129:
2741
 
 
2742
 
/* Line 1806 of yacc.c  */
 
2766
/* Line 1792 of yacc.c  */
2743
2767
#line 598 "ac-parser.y"
2744
2768
    {
2745
2769
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2747
2771
    break;
2748
2772
 
2749
2773
  case 130:
2750
 
 
2751
 
/* Line 1806 of yacc.c  */
 
2774
/* Line 1792 of yacc.c  */
2752
2775
#line 601 "ac-parser.y"
2753
2776
    {
2754
2777
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2756
2779
    break;
2757
2780
 
2758
2781
  case 131:
2759
 
 
2760
 
/* Line 1806 of yacc.c  */
 
2782
/* Line 1792 of yacc.c  */
2761
2783
#line 607 "ac-parser.y"
2762
2784
    {
2763
2785
        anjuta_token_set_type ((yyvsp[(1) - (3)]), ANJUTA_TOKEN_OPEN_QUOTE);
2768
2790
    break;
2769
2791
 
2770
2792
  case 132:
2771
 
 
2772
 
/* Line 1806 of yacc.c  */
 
2793
/* Line 1792 of yacc.c  */
2773
2794
#line 616 "ac-parser.y"
2774
2795
    {
2775
2796
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
2777
2798
    break;
2778
2799
 
2779
2800
  case 133:
2780
 
 
2781
 
/* Line 1806 of yacc.c  */
 
2801
/* Line 1792 of yacc.c  */
2782
2802
#line 619 "ac-parser.y"
2783
2803
    {
2784
2804
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2786
2806
    break;
2787
2807
 
2788
2808
  case 134:
2789
 
 
2790
 
/* Line 1806 of yacc.c  */
 
2809
/* Line 1792 of yacc.c  */
2791
2810
#line 622 "ac-parser.y"
2792
2811
    {
2793
2812
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2795
2814
    break;
2796
2815
 
2797
2816
  case 135:
2798
 
 
2799
 
/* Line 1806 of yacc.c  */
 
2817
/* Line 1792 of yacc.c  */
2800
2818
#line 625 "ac-parser.y"
2801
2819
    {
2802
2820
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2804
2822
    break;
2805
2823
 
2806
2824
  case 136:
2807
 
 
2808
 
/* Line 1806 of yacc.c  */
 
2825
/* Line 1792 of yacc.c  */
2809
2826
#line 628 "ac-parser.y"
2810
2827
    {
2811
2828
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2813
2830
    break;
2814
2831
 
2815
2832
  case 137:
2816
 
 
2817
 
/* Line 1806 of yacc.c  */
 
2833
/* Line 1792 of yacc.c  */
2818
2834
#line 631 "ac-parser.y"
2819
2835
    {
2820
2836
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2822
2838
    break;
2823
2839
 
2824
2840
  case 138:
2825
 
 
2826
 
/* Line 1806 of yacc.c  */
 
2841
/* Line 1792 of yacc.c  */
2827
2842
#line 634 "ac-parser.y"
2828
2843
    {
2829
2844
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2831
2846
    break;
2832
2847
 
2833
2848
  case 139:
2834
 
 
2835
 
/* Line 1806 of yacc.c  */
 
2849
/* Line 1792 of yacc.c  */
2836
2850
#line 637 "ac-parser.y"
2837
2851
    {
2838
2852
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2840
2854
    break;
2841
2855
 
2842
2856
  case 140:
2843
 
 
2844
 
/* Line 1806 of yacc.c  */
 
2857
/* Line 1792 of yacc.c  */
2845
2858
#line 640 "ac-parser.y"
2846
2859
    {
2847
2860
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2849
2862
    break;
2850
2863
 
2851
2864
  case 141:
2852
 
 
2853
 
/* Line 1806 of yacc.c  */
 
2865
/* Line 1792 of yacc.c  */
2854
2866
#line 643 "ac-parser.y"
2855
2867
    {
2856
2868
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2858
2870
    break;
2859
2871
 
2860
2872
  case 142:
2861
 
 
2862
 
/* Line 1806 of yacc.c  */
 
2873
/* Line 1792 of yacc.c  */
2863
2874
#line 646 "ac-parser.y"
2864
2875
    {
2865
2876
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2867
2878
    break;
2868
2879
 
2869
2880
  case 143:
2870
 
 
2871
 
/* Line 1806 of yacc.c  */
 
2881
/* Line 1792 of yacc.c  */
2872
2882
#line 649 "ac-parser.y"
2873
2883
    {
2874
2884
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2876
2886
    break;
2877
2887
 
2878
2888
  case 144:
2879
 
 
2880
 
/* Line 1806 of yacc.c  */
 
2889
/* Line 1792 of yacc.c  */
2881
2890
#line 652 "ac-parser.y"
2882
2891
    {
2883
2892
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2885
2894
    break;
2886
2895
 
2887
2896
  case 145:
2888
 
 
2889
 
/* Line 1806 of yacc.c  */
 
2897
/* Line 1792 of yacc.c  */
2890
2898
#line 655 "ac-parser.y"
2891
2899
    {
2892
2900
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2894
2902
    break;
2895
2903
 
2896
2904
  case 146:
2897
 
 
2898
 
/* Line 1806 of yacc.c  */
 
2905
/* Line 1792 of yacc.c  */
2899
2906
#line 658 "ac-parser.y"
2900
2907
    {
2901
2908
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2903
2910
    break;
2904
2911
 
2905
2912
  case 149:
2906
 
 
2907
 
/* Line 1806 of yacc.c  */
 
2913
/* Line 1792 of yacc.c  */
2908
2914
#line 663 "ac-parser.y"
2909
2915
    {
2910
2916
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2912
2918
    break;
2913
2919
 
2914
2920
  case 150:
2915
 
 
2916
 
/* Line 1806 of yacc.c  */
 
2921
/* Line 1792 of yacc.c  */
2917
2922
#line 672 "ac-parser.y"
2918
2923
    {
2919
2924
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_ITEM, NULL);
2921
2926
    break;
2922
2927
 
2923
2928
  case 151:
2924
 
 
2925
 
/* Line 1806 of yacc.c  */
 
2929
/* Line 1792 of yacc.c  */
2926
2930
#line 675 "ac-parser.y"
2927
2931
    {
2928
2932
        //fprintf(stdout, "arg part\n");
2938
2942
    break;
2939
2943
 
2940
2944
  case 152:
2941
 
 
2942
 
/* Line 1806 of yacc.c  */
 
2945
/* Line 1792 of yacc.c  */
2943
2946
#line 689 "ac-parser.y"
2944
2947
    {
2945
2948
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_ITEM, NULL);
2947
2950
    break;
2948
2951
 
2949
2952
  case 153:
2950
 
 
2951
 
/* Line 1806 of yacc.c  */
 
2953
/* Line 1792 of yacc.c  */
2952
2954
#line 692 "ac-parser.y"
2953
2955
    {
2954
2956
        (yyval) = anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2956
2958
    break;
2957
2959
 
2958
2960
  case 171:
2959
 
 
2960
 
/* Line 1806 of yacc.c  */
 
2961
/* Line 1792 of yacc.c  */
2961
2962
#line 724 "ac-parser.y"
2962
2963
    {
2963
2964
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_NEXT, NULL);
2966
2967
    break;
2967
2968
 
2968
2969
  case 172:
2969
 
 
2970
 
/* Line 1806 of yacc.c  */
 
2970
/* Line 1792 of yacc.c  */
2971
2971
#line 728 "ac-parser.y"
2972
2972
    {
2973
2973
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_NEXT, NULL);
2985
2985
    break;
2986
2986
 
2987
2987
  case 173:
2988
 
 
2989
 
/* Line 1806 of yacc.c  */
 
2988
/* Line 1792 of yacc.c  */
2990
2989
#line 744 "ac-parser.y"
2991
2990
    {
2992
2991
        (yyval) = anjuta_token_merge_previous ((yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]));
2995
2994
    break;
2996
2995
 
2997
2996
  case 174:
2998
 
 
2999
 
/* Line 1806 of yacc.c  */
 
2997
/* Line 1792 of yacc.c  */
3000
2998
#line 751 "ac-parser.y"
3001
2999
    {
3002
3000
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
3004
3002
    break;
3005
3003
 
3006
3004
  case 175:
3007
 
 
3008
 
/* Line 1806 of yacc.c  */
 
3005
/* Line 1792 of yacc.c  */
3009
3006
#line 754 "ac-parser.y"
3010
3007
    {
3011
3008
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3013
3010
    break;
3014
3011
 
3015
3012
  case 176:
3016
 
 
3017
 
/* Line 1806 of yacc.c  */
 
3013
/* Line 1792 of yacc.c  */
3018
3014
#line 757 "ac-parser.y"
3019
3015
    {
3020
3016
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3022
3018
    break;
3023
3019
 
3024
3020
  case 178:
3025
 
 
3026
 
/* Line 1806 of yacc.c  */
 
3021
/* Line 1792 of yacc.c  */
3027
3022
#line 761 "ac-parser.y"
3028
3023
    {
3029
3024
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3031
3026
    break;
3032
3027
 
3033
3028
  case 179:
3034
 
 
3035
 
/* Line 1806 of yacc.c  */
 
3029
/* Line 1792 of yacc.c  */
3036
3030
#line 764 "ac-parser.y"
3037
3031
    {
3038
3032
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3040
3034
    break;
3041
3035
 
3042
3036
  case 180:
3043
 
 
3044
 
/* Line 1806 of yacc.c  */
 
3037
/* Line 1792 of yacc.c  */
3045
3038
#line 767 "ac-parser.y"
3046
3039
    {
3047
3040
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3049
3042
    break;
3050
3043
 
3051
3044
  case 181:
3052
 
 
3053
 
/* Line 1806 of yacc.c  */
 
3045
/* Line 1792 of yacc.c  */
3054
3046
#line 770 "ac-parser.y"
3055
3047
    {
3056
3048
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3058
3050
    break;
3059
3051
 
3060
3052
  case 182:
3061
 
 
3062
 
/* Line 1806 of yacc.c  */
 
3053
/* Line 1792 of yacc.c  */
3063
3054
#line 773 "ac-parser.y"
3064
3055
    {
3065
3056
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3067
3058
    break;
3068
3059
 
3069
3060
  case 183:
3070
 
 
3071
 
/* Line 1806 of yacc.c  */
 
3061
/* Line 1792 of yacc.c  */
3072
3062
#line 776 "ac-parser.y"
3073
3063
    {
3074
3064
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3076
3066
    break;
3077
3067
 
3078
3068
  case 184:
3079
 
 
3080
 
/* Line 1806 of yacc.c  */
 
3069
/* Line 1792 of yacc.c  */
3081
3070
#line 779 "ac-parser.y"
3082
3071
    {
3083
3072
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3085
3074
    break;
3086
3075
 
3087
3076
  case 185:
3088
 
 
3089
 
/* Line 1806 of yacc.c  */
 
3077
/* Line 1792 of yacc.c  */
3090
3078
#line 782 "ac-parser.y"
3091
3079
    {
3092
3080
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3094
3082
    break;
3095
3083
 
3096
3084
  case 186:
3097
 
 
3098
 
/* Line 1806 of yacc.c  */
 
3085
/* Line 1792 of yacc.c  */
3099
3086
#line 785 "ac-parser.y"
3100
3087
    {
3101
3088
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3103
3090
    break;
3104
3091
 
3105
3092
  case 188:
3106
 
 
3107
 
/* Line 1806 of yacc.c  */
 
3093
/* Line 1792 of yacc.c  */
3108
3094
#line 789 "ac-parser.y"
3109
3095
    {
3110
3096
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3112
3098
    break;
3113
3099
 
3114
3100
  case 189:
3115
 
 
3116
 
/* Line 1806 of yacc.c  */
 
3101
/* Line 1792 of yacc.c  */
3117
3102
#line 792 "ac-parser.y"
3118
3103
    {
3119
3104
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3121
3106
    break;
3122
3107
 
3123
3108
  case 190:
3124
 
 
3125
 
/* Line 1806 of yacc.c  */
 
3109
/* Line 1792 of yacc.c  */
3126
3110
#line 798 "ac-parser.y"
3127
3111
    {
3128
3112
                (yyval) = NULL;
3130
3114
    break;
3131
3115
 
3132
3116
  case 192:
3133
 
 
3134
 
/* Line 1806 of yacc.c  */
 
3117
/* Line 1792 of yacc.c  */
3135
3118
#line 805 "ac-parser.y"
3136
3119
    {
3137
3120
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_SPACE, NULL);
3140
3123
    break;
3141
3124
 
3142
3125
  case 193:
3143
 
 
3144
 
/* Line 1806 of yacc.c  */
 
3126
/* Line 1792 of yacc.c  */
3145
3127
#line 809 "ac-parser.y"
3146
3128
    {
3147
3129
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3149
3131
    break;
3150
3132
 
3151
3133
  case 194:
3152
 
 
3153
 
/* Line 1806 of yacc.c  */
 
3134
/* Line 1792 of yacc.c  */
3154
3135
#line 815 "ac-parser.y"
3155
3136
    {
3156
3137
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_SPACE, NULL);
3159
3140
    break;
3160
3141
 
3161
3142
  case 195:
3162
 
 
3163
 
/* Line 1806 of yacc.c  */
 
3143
/* Line 1792 of yacc.c  */
3164
3144
#line 819 "ac-parser.y"
3165
3145
    {
3166
3146
        (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_SPACE, NULL);
3169
3149
    break;
3170
3150
 
3171
3151
  case 196:
3172
 
 
3173
 
/* Line 1806 of yacc.c  */
 
3152
/* Line 1792 of yacc.c  */
3174
3153
#line 823 "ac-parser.y"
3175
3154
    {
3176
3155
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3178
3157
    break;
3179
3158
 
3180
3159
  case 197:
3181
 
 
3182
 
/* Line 1806 of yacc.c  */
 
3160
/* Line 1792 of yacc.c  */
3183
3161
#line 826 "ac-parser.y"
3184
3162
    {
3185
3163
        anjuta_token_merge ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
3187
3165
    break;
3188
3166
 
3189
3167
  case 306:
3190
 
 
3191
 
/* Line 1806 of yacc.c  */
 
3168
/* Line 1792 of yacc.c  */
3192
3169
#line 973 "ac-parser.y"
3193
3170
    {
3194
3171
                anjuta_token_set_type ((yyvsp[(1) - (1)]), ANJUTA_TOKEN_EOL);
3196
3173
    break;
3197
3174
 
3198
3175
 
3199
 
 
3200
 
/* Line 1806 of yacc.c  */
3201
 
#line 3202 "ac-parser.c"
 
3176
/* Line 1792 of yacc.c  */
 
3177
#line 3178 "ac-parser.c"
3202
3178
      default: break;
3203
3179
    }
3204
3180
  /* User semantic actions sometimes alter yychar, and that requires
3363
3339
      YY_STACK_PRINT (yyss, yyssp);
3364
3340
    }
3365
3341
 
 
3342
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3366
3343
  *++yyvsp = yylval;
 
3344
  YY_IGNORE_MAYBE_UNINITIALIZED_END
3367
3345
 
3368
3346
  yyerror_range[2] = yylloc;
3369
3347
  /* Using YYLLOC is tempting, but would change the location of
3392
3370
  yyresult = 1;
3393
3371
  goto yyreturn;
3394
3372
 
3395
 
#if !defined(yyoverflow) || YYERROR_VERBOSE
 
3373
#if !defined yyoverflow || YYERROR_VERBOSE
3396
3374
/*-------------------------------------------------.
3397
3375
| yyexhaustedlab -- memory exhaustion comes here.  |
3398
3376
`-------------------------------------------------*/
3437
3415
}
3438
3416
 
3439
3417
 
3440
 
 
3441
 
/* Line 2067 of yacc.c  */
 
3418
/* Line 2055 of yacc.c  */
3442
3419
#line 979 "ac-parser.y"
3443
3420
 
3444