Attachment #109287 for bug #165526

Lines 301-307 Link Here

(-)kdevelop-3.4.0.orig/buildtools/autotools/subprojectoptionsdlg.cpp (+4 lines)
301	{	301	{
302	QString dir = KFileDialog::getExistingDirectory();	302	QString dir = KFileDialog::getExistingDirectory();
303	if (!dir.isEmpty())	303	if (!dir.isEmpty())
		304	{
		305	if( !dir.startsWith( "-I" ) )
		306	dir = "-I"+dir;
304	new QListViewItem(outsideinc_listview, dir);	307	new QListViewItem(outsideinc_listview, dir);
		308	}
305	}	309	}
306		310
307		311





// -*-C++-*-
// FlexLexer.h -- define interfaces for lexical analyzer classes generated
// by flex

// Copyright (c) 1993 The Regents of the University of California.
// All rights reserved.
//
// This code is derived from software contributed to Berkeley by
// Kent Williams and Tom Epperly.
//
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions
//  are met:

//  1. Redistributions of source code must retain the above copyright
//  notice, this list of conditions and the following disclaimer.
//  2. Redistributions in binary form must reproduce the above copyright
//  notice, this list of conditions and the following disclaimer in the
//  documentation and/or other materials provided with the distribution.

//  Neither the name of the University nor the names of its contributors
//  may be used to endorse or promote products derived from this software
//  without specific prior written permission.

//  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
//  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
//  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
//  PURPOSE.

// This file defines FlexLexer, an abstract class which specifies the
// external interface provided to flex C++ lexer objects, and yyFlexLexer,
// which defines a particular lexer class.
//
// If you want to create multiple lexer classes, you use the -P flag
// to rename each yyFlexLexer to some other xxFlexLexer.  You then
// include <FlexLexer.h> in your other sources once per lexer class:
//
//	#undef yyFlexLexer
//	#define yyFlexLexer xxFlexLexer
//	#include <FlexLexer.h>
//
//	#undef yyFlexLexer
//	#define yyFlexLexer zzFlexLexer
//	#include <FlexLexer.h>
//	...

#ifndef __FLEX_LEXER_H
// Never included before - need to define base class.
#define __FLEX_LEXER_H

#include <iostream>
#  ifndef FLEX_STD
#    define FLEX_STD std::
#  endif

extern "C++" {

struct yy_buffer_state;
typedef int yy_state_type;

class FlexLexer {
public:
	virtual ~FlexLexer()	{ }

	const char* YYText() const	{ return yytext; }
	int YYLeng()	const	{ return yyleng; }

	virtual void
		yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
	virtual struct yy_buffer_state*
		yy_create_buffer( FLEX_STD istream* s, int size ) = 0;
	virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
	virtual void yyrestart( FLEX_STD istream* s ) = 0;

	virtual int yylex() = 0;

	// Call yylex with new input/output sources.
	int yylex( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0 )
		{
		switch_streams( new_in, new_out );
		return yylex();
		}

	// Switch to new input/output streams.  A nil stream pointer
	// indicates "keep the current one".
	virtual void switch_streams( FLEX_STD istream* new_in = 0,
					FLEX_STD ostream* new_out = 0 ) = 0;

	int lineno() const		{ return yylineno; }

	int debug() const		{ return yy_flex_debug; }
	void set_debug( int flag )	{ yy_flex_debug = flag; }

protected:
	char* yytext;
	int yyleng;
	int yylineno;		// only maintained if you use %option yylineno
	int yy_flex_debug;	// only has effect with -d or "%option debug"
};

}
#endif

#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
// Either this is the first time through (yyFlexLexerOnce not defined),
// or this is a repeated include to define a different flavor of
// yyFlexLexer, as discussed in the flex man page.
#define yyFlexLexerOnce

extern "C++" {

class yyFlexLexer : public FlexLexer {
public:
	// arg_yyin and arg_yyout default to the cin and cout, but we
	// only make that assignment when initializing in yylex().
	yyFlexLexer( FLEX_STD istream* arg_yyin = 0, FLEX_STD ostream* arg_yyout = 0 );

	virtual ~yyFlexLexer();

	void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
	struct yy_buffer_state* yy_create_buffer( FLEX_STD istream* s, int size );
	void yy_delete_buffer( struct yy_buffer_state* b );
	void yyrestart( FLEX_STD istream* s );

    void yypush_buffer_state( struct yy_buffer_state* new_buffer );
    void yypop_buffer_state(void);

	virtual int yylex();
	virtual void switch_streams( FLEX_STD istream* new_in, FLEX_STD ostream* new_out );

protected:
	virtual int LexerInput( char* buf, int max_size );
	virtual void LexerOutput( const char* buf, int size );
	virtual void LexerError( const char* msg );

	void yyunput( int c, char* buf_ptr );
	int yyinput();

	void yy_load_buffer_state();
	void yy_init_buffer( struct yy_buffer_state* b, FLEX_STD istream* s );
	void yy_flush_buffer( struct yy_buffer_state* b );

	int yy_start_stack_ptr;
	int yy_start_stack_depth;
	int* yy_start_stack;

	void yy_push_state( int new_state );
	void yy_pop_state();
	int yy_top_state();

	yy_state_type yy_get_previous_state();
	yy_state_type yy_try_NUL_trans( yy_state_type current_state );
	int yy_get_next_buffer();

	FLEX_STD istream* yyin;	// input source for default LexerInput
	FLEX_STD ostream* yyout;	// output sink for default LexerOutput

	// yy_hold_char holds the character lost when yytext is formed.
	char yy_hold_char;

	// Number of characters read into yy_ch_buf.
	int yy_n_chars;

	// Points to current character in buffer.
	char* yy_c_buf_p;

	int yy_init;		// whether we need to initialize
	int yy_start;		// start state number

	// Flag which is used to allow yywrap()'s to do buffer switches
	// instead of setting up a fresh yyin.  A bit of a hack ...
	int yy_did_buffer_switch_on_eof;


    size_t yy_buffer_stack_top; /**< index of top of stack. */
    size_t yy_buffer_stack_max; /**< capacity of stack. */
    struct yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
    void yyensure_buffer_stack(void);

	// The following are not always needed, but may be depending
	// on use of certain flex features (like REJECT or yymore()).

	yy_state_type yy_last_accepting_state;
	char* yy_last_accepting_cpos;

	yy_state_type* yy_state_buf;
	yy_state_type* yy_state_ptr;

	char* yy_full_match;
	int* yy_full_state;
	int yy_full_lp;

	int yy_lp;
	int yy_looking_for_trail_begin;

	int yy_more_flag;
	int yy_more_len;
	int yy_more_offset;
	int yy_prev_more_offset;
};

}

#endif




/* A Bison parser, made by GNU Bison 2.3.  */

/* Locations for Bison parsers in C++

   Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/**
 ** \file location.hh
 ** Define the QMake::location class.
 */

#ifndef BISON_LOCATION_HH
# define BISON_LOCATION_HH

# include <iostream>
# include <string>
# include "position.hh"

namespace QMake
{

  /// Abstract a location.
  class location
  {
  public:

    /// Construct a location.
    location ()
      : begin (), end ()
    {
    }


    /// Initialization.
    inline void initialize (std::string* fn)
    {
      begin.initialize (fn);
      end = begin;
    }

    /** \name Line and Column related manipulators
     ** \{ */
  public:
    /// Reset initial location to final location.
    inline void step ()
    {
      begin = end;
    }

    /// Extend the current location to the COUNT next columns.
    inline void columns (unsigned int count = 1)
    {
      end += count;
    }

    /// Extend the current location to the COUNT next lines.
    inline void lines (unsigned int count = 1)
    {
      end.lines (count);
    }
    /** \} */


  public:
    /// Beginning of the located region.
    position begin;
    /// End of the located region.
    position end;
  };

  /// Join two location objects to create a location.
  inline const location operator+ (const location& begin, const location& end)
  {
    location res = begin;
    res.end = end.end;
    return res;
  }

  /// Add two location objects.
  inline const location operator+ (const location& begin, unsigned int width)
  {
    location res = begin;
    res.columns (width);
    return res;
  }

  /// Add and assign a location.
  inline location& operator+= (location& res, unsigned int width)
  {
    res.columns (width);
    return res;
  }

  /** \brief Intercept output stream redirection.
   ** \param ostr the destination output stream
   ** \param loc a reference to the location to redirect
   **
   ** Avoid duplicate information.
   */
  inline std::ostream& operator<< (std::ostream& ostr, const location& loc)
  {
    position last = loc.end - 1;
    ostr << loc.begin;
    if (last.filename
	&& (!loc.begin.filename
	    || *loc.begin.filename != *last.filename))
      ostr << '-' << last;
    else if (loc.begin.line != last.line)
      ostr << '-' << last.line  << '.' << last.column;
    else if (loc.begin.column != last.column)
      ostr << '-' << last.column;
    return ostr;
  }

}

#endif // not BISON_LOCATION_HH




METASOURCES = AUTO
lib_LTLIBRARIES = libkdevqmakeparser.la
libkdevqmakeparser_la_LDFLAGS = -no-undefined $(all_libraries) $(LIB_KIO)
libkdevqmakeparser_la_SOURCES = qmake_lex.cpp qmake_yacc.cpp qmakeast.cpp \
	qmakeastvisitor.cpp qmakedriver.cpp

kdevelopbuildtoolsincludedir = $(includedir)/kdevelop/buildtools/parsers/qmake
kdevelopbuildtoolsinclude_HEADERS = qmakeast.h qmakedriver.h qmakeastvisitor.h

parser:
	cd $(srcdir) ; \
	bison -d qmake.yy -oqmake_yacc.cpp ; \
	mv -f qmake_yacc.hpp qmake_yacc.h ; \
	flex -oqmake_lex.cpp qmake.ll

parser_dbg:
	cd $(srcdir) ; \
	bison -d qmake.yy -r all -k -t -oqmake_yacc.cpp ; \
	mv -f qmake_yacc.hpp qmake_yacc.h ; \
	flex -d -oqmake_lex.cpp qmake.ll

EXTRA_DIST = qmake.yy qmake.ll

DOXYGEN_DOCDIRPREFIX = kdevparser
include ../../../../Doxyfile.am

noinst_HEADERS = qmake_lex.h




/* A Bison parser, made by GNU Bison 2.3.  */

/* Positions for Bison parsers in C++

   Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/**
 ** \file position.hh
 ** Define the QMake::position class.
 */

#ifndef BISON_POSITION_HH
# define BISON_POSITION_HH

# include <iostream>
# include <string>

namespace QMake
{
  /// Abstract a position.
  class position
  {
  public:

    /// Construct a position.
    position ()
      : filename (0), line (1), column (0)
    {
    }


    /// Initialization.
    inline void initialize (std::string* fn)
    {
      filename = fn;
      line = 1;
      column = 0;
    }

    /** \name Line and Column related manipulators
     ** \{ */
  public:
    /// (line related) Advance to the COUNT next lines.
    inline void lines (int count = 1)
    {
      column = 0;
      line += count;
    }

    /// (column related) Advance to the COUNT next columns.
    inline void columns (int count = 1)
    {
      int leftmost = 0;
      int current  = column;
      if (leftmost <= current + count)
	column += count;
      else
	column = 0;
    }
    /** \} */

  public:
    /// File name to which this position refers.
    std::string* filename;
    /// Current line number.
    unsigned int line;
    /// Current column number.
    unsigned int column;
  };

  /// Add and assign a position.
  inline const position&
  operator+= (position& res, const int width)
  {
    res.columns (width);
    return res;
  }

  /// Add two position objects.
  inline const position
  operator+ (const position& begin, const int width)
  {
    position res = begin;
    return res += width;
  }

  /// Add and assign a position.
  inline const position&
  operator-= (position& res, const int width)
  {
    return res += -width;
  }

  /// Add two position objects.
  inline const position
  operator- (const position& begin, const int width)
  {
    return begin + -width;
  }

  /** \brief Intercept output stream redirection.
   ** \param ostr the destination output stream
   ** \param pos a reference to the position to redirect
   */
  inline std::ostream&
  operator<< (std::ostream& ostr, const position& pos)
  {
    if (pos.filename)
      ostr << *pos.filename << ':';
    return ostr << pos.line << '.' << pos.column;
  }

}
#endif // not BISON_POSITION_HH




#include "qmakedriver.h"
#include "qmakeast.h"

#include <stdio.h>
#include <qvaluestack.h>
#include <kio/netaccess.h>

#include <iostream>
#include <fstream>
#include <sstream>

#include "qmake_lex.h"
#include "qmake_yacc.hpp"
extern QValueStack<QMake::ProjectAST *> projects;

namespace QMake {

int Driver::parseFile(const char *fileName, ProjectAST **ast, int debug)
{
    std::ifstream inf( fileName, std::ios::in );
    if ( !inf.is_open() )
    {
        *ast = 0;
        return 1;
    }
//     yydebug = 1;
    Lexer l(&inf);
    l.set_debug(debug);
    int depth = 0;
    QValueStack<ProjectAST*> stack;
    Parser p(&l, stack, depth);
    p.set_debug_level(debug);
    int ret = p.parse();
    *ast = stack.top();
    (*ast)->setFileName(fileName);
    return ret;
}

int Driver::parseFile(QString fileName, ProjectAST **ast, int debug)
{
    return parseFile(fileName.ascii(), ast, debug);
}

int Driver::parseFile(KURL fileName, ProjectAST **ast, int debug)
{
    QString tmpFile;
    int ret = 0;
    if (KIO::NetAccess::download(fileName, tmpFile, 0))
        ret = parseFile(tmpFile, ast, debug);
    KIO::NetAccess::removeTempFile(tmpFile);
    return ret;
}

int Driver::parseString( const char* string, ProjectAST **ast, int debug )
{
    std::istringstream ins;
    ins.str(string);
    Lexer l(&ins);
    l.set_debug(debug);
    int depth = 0;
    QValueStack<ProjectAST*> stack;
    Parser p(&l, stack, depth);
    p.set_debug_level(debug);
    int ret = p.parse();
    *ast = stack.top();
    (*ast)->setFileName("");
    yy_delete_buffer( state );
    return ret;
}





#ifndef QMAKEQMAKEDRIVER_H
#define QMAKEQMAKEDRIVER_H

class QString;
class KURL;
#include <qvaluelist.h>
#include <kurl.h>

namespace QMake {


    initialize it on its own.
    @return The result of parsing. Result is 0 on success and <> 0 on failure.
    */
    static int parseFile(const char *fileName, ProjectAST **ast, int debug);
    static int parseFile(QString fileName, ProjectAST **ast, int debug);
    static int parseFile(KURL fileName, ProjectAST **ast, int debug);
    static int parseString(const char* string, ProjectAST **ast, int debug);

/*    template<class Op>
    static void walkAST(Op &op, const ProjectAST *ast)
    {
//         op(ast);
        for (QValueList<QMake::AST*>::const_iterator it = ast->statements.constBegin();
                it != ast->statements.constEnd(); ++it)
        {
            const AST *child = *it;
            if (child->nodeType() == AST::ProjectAST)
                walkAST<Op>(op, static_cast<const QMake::ProjectAST*>(child));
            else
                op(child);
        }
    }
*/
};

}

Lines 14-26 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/qmake_lex.cpp (-510 / +426 lines)
14	#define FLEX_BETA	14	#define FLEX_BETA
15	#endif	15	#endif
16		16
		17	/* The c++ scanner is a mess. The FlexLexer.h header file relies on the
		18	* following macro. This is required in order to pass the c++-multiple-scanners
		19	* test in the regression suite. We get reports that it breaks inheritance.
		20	* We will address this in a future release of flex, or omit the C++ scanner
		21	* altogether.
		22	*/
		23	#define yyFlexLexer yyFlexLexer
		24
17	/* First, we deal with platform-specific or compiler-specific issues. */	25	/* First, we deal with platform-specific or compiler-specific issues. */
18		26
19	/* begin standard C headers. */	27	/* begin standard C headers. */
20	#include <stdio.h>
21	#include <string.h>
22	#include <errno.h>
23	#include <stdlib.h>
24		28
25	/* end standard C headers. */	29	/* end standard C headers. */
26		30
Lines 87-92 Link Here
87		91
88	#endif /* ! FLEXINT_H */	92	#endif /* ! FLEXINT_H */
89		93
		94	/* begin standard C++ headers. */
		95	#include <iostream>
		96	#include <errno.h>
		97	#include <cstdlib>
		98	#include <cstring>
		99	/* end standard C++ headers. */
		100
90	#ifdef __cplusplus	101	#ifdef __cplusplus
91		102
92	/* The "const" storage-class-modifier is valid. */	103	/* The "const" storage-class-modifier is valid. */
Lines 134-140 Link Here
134	#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)	145	#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
135		146
136	/* Special action meaning "start processing a new file". */	147	/* Special action meaning "start processing a new file". */
137	#define YY_NEW_FILE yyrestart(yyin )	148	#define YY_NEW_FILE yyrestart( yyin )
138		149
139	#define YY_END_OF_BUFFER_CHAR 0	150	#define YY_END_OF_BUFFER_CHAR 0
140		151
Lines 154-166 Link Here
154		165
155	extern int yyleng;	166	extern int yyleng;
156		167
157	extern FILE yyin, yyout;
158
159	#define EOB_ACT_CONTINUE_SCAN 0	168	#define EOB_ACT_CONTINUE_SCAN 0
160	#define EOB_ACT_END_OF_FILE 1	169	#define EOB_ACT_END_OF_FILE 1
161	#define EOB_ACT_LAST_MATCH 2	170	#define EOB_ACT_LAST_MATCH 2
162		171
163	#define YY_LESS_LINENO(n)	172	/* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
		173	* access to the local variable yy_act. Since yyless() is a macro, it would break
		174	* existing scanners that call yyless() from OUTSIDE yylex.
		175	* One obvious solution it to make yy_act a global. I tried that, and saw
		176	* a 5% performance hit in a non-yylineno scanner, because yy_act is
		177	* normally declared as a register variable-- so it is not worth it.
		178	*/
		179	#define YY_LESS_LINENO(n) \
		180	do { \
		181	int yyl;\
		182	for ( yyl = n; yyl < yyleng; ++yyl )\
		183	if ( yytext[yyl] == '\n' )\
		184	--yylineno;\
		185	}while(0)
164		186
165	/* Return all but the first "n" matched characters back to the input stream. */	187	/* Return all but the first "n" matched characters back to the input stream. */
166	#define yyless(n) \	188	#define yyless(n) \
Lines 192-198 Link Here
192	#define YY_STRUCT_YY_BUFFER_STATE	214	#define YY_STRUCT_YY_BUFFER_STATE
193	struct yy_buffer_state	215	struct yy_buffer_state
194	{	216	{
195	FILE *yy_input_file;	217
		218	std::istream* yy_input_file;
196		219
197	char yy_ch_buf; / input buffer */	220	char yy_ch_buf; / input buffer */
198	char yy_buf_pos; / current position in input buffer */	221	char yy_buf_pos; / current position in input buffer */
Lines 253-263 Link Here
253	};	276	};
254	#endif /* !YY_STRUCT_YY_BUFFER_STATE */	277	#endif /* !YY_STRUCT_YY_BUFFER_STATE */
255		278
256	/* Stack of input buffers. */
257	static size_t yy_buffer_stack_top = 0; /*< index of top of stack. /
258	static size_t yy_buffer_stack_max = 0; /*< capacity of stack. /
259	static YY_BUFFER_STATE * yy_buffer_stack = 0; /*< Stack as an array. /
260
261	/* We provide macros for accessing buffer states in case in the	279	/* We provide macros for accessing buffer states in case in the
262	* future we want to put the buffer states in a more general	280	* future we want to put the buffer states in a more general
263	* "scanner state".	281	* "scanner state".
Lines 273-311 Link Here
273	*/	291	*/
274	#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]	292	#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
275		293
276	/* yy_hold_char holds the character lost when yytext is formed. */
277	static char yy_hold_char;
278	static int yy_n_chars; /* number of characters read into yy_ch_buf */
279	int yyleng;
280
281	/* Points to current character in buffer. */
282	static char yy_c_buf_p = (char ) 0;
283	static int yy_init = 0; /* whether we need to initialize */
284	static int yy_start = 0; /* start state number */
285
286	/* Flag which is used to allow yywrap()'s to do buffer switches
287	* instead of setting up a fresh yyin. A bit of a hack ...
288	*/
289	static int yy_did_buffer_switch_on_eof;
290
291	void yyrestart (FILE *input_file );
292	void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
293	YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );
294	void yy_delete_buffer (YY_BUFFER_STATE b );
295	void yy_flush_buffer (YY_BUFFER_STATE b );
296	void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
297	void yypop_buffer_state (void );
298
299	static void yyensure_buffer_stack (void );
300	static void yy_load_buffer_state (void );
301	static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
302
303	#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
304
305	YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
306	YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
307	YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len );
308
309	void *yyalloc (yy_size_t );	294	void *yyalloc (yy_size_t );
310	void yyrealloc (void ,yy_size_t );	295	void yyrealloc (void ,yy_size_t );
311	void yyfree (void * );	296	void yyfree (void * );
Lines 317-323 Link Here
317	if ( ! YY_CURRENT_BUFFER ){ \	302	if ( ! YY_CURRENT_BUFFER ){ \
318	yyensure_buffer_stack (); \	303	yyensure_buffer_stack (); \
319	YY_CURRENT_BUFFER_LVALUE = \	304	YY_CURRENT_BUFFER_LVALUE = \
320	yy_create_buffer(yyin,YY_BUF_SIZE ); \	305	yy_create_buffer( yyin, YY_BUF_SIZE ); \
321	} \	306	} \
322	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \	307	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
323	}	308	}
Lines 327-333 Link Here
327	if ( ! YY_CURRENT_BUFFER ){\	312	if ( ! YY_CURRENT_BUFFER ){\
328	yyensure_buffer_stack (); \	313	yyensure_buffer_stack (); \
329	YY_CURRENT_BUFFER_LVALUE = \	314	YY_CURRENT_BUFFER_LVALUE = \
330	yy_create_buffer(yyin,YY_BUF_SIZE ); \	315	yy_create_buffer( yyin, YY_BUF_SIZE ); \
331	} \	316	} \
332	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \	317	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
333	}	318	}
Lines 341-361 Link Here
341		326
342	typedef unsigned char YY_CHAR;	327	typedef unsigned char YY_CHAR;
343		328
344	FILE yyin = (FILE ) 0, yyout = (FILE ) 0;
345
346	typedef int yy_state_type;
347
348	extern int yylineno;
349
350	int yylineno = 1;
351
352	extern char *yytext;
353	#define yytext_ptr yytext	329	#define yytext_ptr yytext
		330	#define YY_INTERACTIVE
354		331
355	static yy_state_type yy_get_previous_state (void );	332	#include <FlexLexer.h>
356	static yy_state_type yy_try_NUL_trans (yy_state_type current_state );	333	int yyFlexLexer::yylex()
357	static int yy_get_next_buffer (void );	334	{
358	static void yy_fatal_error (yyconst char msg[] );	335	LexerError( "yyFlexLexer::yylex invoked but %option yyclass used" );
		336	return 0;
		337	}
		338
		339	#define YY_DECL int QMake::Lexer::yylex()
359		340
360	/* Done after the current pattern has been matched and before the	341	/* Done after the current pattern has been matched and before the
361	* corresponding action - sets up yytext.	342	* corresponding action - sets up yytext.
Lines 376-399 Link Here
376	flex_int32_t yy_verify;	357	flex_int32_t yy_verify;
377	flex_int32_t yy_nxt;	358	flex_int32_t yy_nxt;
378	};	359	};
379	static yyconst flex_int16_t yy_accept[79] =	360	static yyconst flex_int16_t yy_accept[82] =
380	{ 0,	361	{ 0,
381	0, 0, 0, 0, 0, 0, 0, 0, 25, 24,	362	0, 0, 0, 0, 0, 0, 0, 0, 25, 24,
382	1, 22, 5, 23, 19, 20, 5, 24, 5, 21,	363	1, 22, 5, 23, 19, 20, 5, 24, 5, 21,
383	11, 24, 16, 18, 24, 9, 2, 9, 9, 24,	364	11, 24, 16, 18, 24, 9, 2, 9, 9, 24,
384	2, 2, 6, 2, 24, 8, 1, 5, 5, 23,	365	2, 2, 6, 2, 24, 8, 1, 5, 23, 14,
385	14, 12, 13, 0, 17, 0, 4, 15, 9, 0,	366	12, 13, 0, 17, 0, 4, 4, 15, 9, 0,
386	2, 0, 9, 0, 9, 0, 7, 0, 3, 2,	367	2, 0, 9, 0, 0, 9, 0, 7, 7, 0,
387	3, 2, 6, 6, 6, 6, 2, 3, 0, 8,	368	3, 2, 3, 2, 6, 6, 6, 6, 2, 3,
388	9, 0, 9, 0, 0, 10, 0, 0	369	0, 8, 9, 0, 9, 0, 0, 10, 0, 7,
		370	0
389	} ;	371	} ;
390		372
391	static yyconst flex_int32_t yy_ec[256] =	373	static yyconst flex_int32_t yy_ec[256] =
392	{ 0,	374	{ 0,
393	1, 1, 1, 1, 1, 1, 1, 1, 2, 3,	375	1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
		376	1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
394	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	377	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
395	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	378	1, 2, 5, 6, 7, 8, 1, 1, 1, 9,
396	1, 4, 5, 6, 7, 8, 1, 1, 1, 9,
397	10, 11, 12, 1, 13, 14, 1, 15, 15, 15,	379	10, 11, 12, 1, 13, 14, 1, 15, 15, 15,
398	15, 15, 15, 15, 15, 15, 15, 16, 1, 1,	380	15, 15, 15, 15, 15, 15, 15, 16, 1, 1,
399	17, 1, 1, 1, 18, 18, 18, 18, 18, 18,	381	17, 1, 1, 1, 18, 18, 18, 18, 18, 18,
Lines 422-543 Link Here
422		404
423	static yyconst flex_int32_t yy_meta[25] =	405	static yyconst flex_int32_t yy_meta[25] =
424	{ 0,	406	{ 0,
425	1, 2, 3, 2, 1, 1, 1, 1, 1, 1,	407	1, 2, 3, 4, 1, 1, 1, 1, 1, 1,
426	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	408	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
427	1, 1, 1, 1	409	1, 1, 1, 1
428	} ;	410	} ;
429		411
430	static yyconst flex_int16_t yy_base[92] =	412	static yyconst flex_int16_t yy_base[95] =
431	{ 0,	413	{ 0,
432	0, 0, 23, 41, 29, 30, 25, 36, 144, 285,	414	0, 0, 23, 41, 26, 29, 31, 36, 157, 202,
433	36, 285, 56, 0, 285, 285, 125, 124, 123, 51,	415	154, 202, 56, 0, 202, 202, 138, 137, 135, 30,
434	285, 47, 285, 285, 122, 119, 50, 118, 77, 95,	416	202, 50, 202, 202, 132, 128, 48, 47, 77, 95,
435	80, 81, 54, 87, 126, 120, 61, 0, 0, 0,	417	55, 56, 71, 70, 131, 123, 129, 0, 0, 202,
436	285, 285, 285, 88, 285, 98, 285, 285, 106, 93,	418	202, 202, 35, 202, 80, 202, 98, 202, 76, 49,
437	101, 104, 113, 67, 131, 74, 285, 149, 285, 109,	419	84, 84, 83, 98, 90, 116, 90, 202, 102, 134,
438	72, 116, 0, 91, 0, 102, 120, 0, 56, 52,	420	202, 101, 107, 105, 0, 111, 0, 120, 114, 0,
439	167, 185, 203, 124, 221, 239, 127, 285, 258, 261,	421	55, 49, 121, 123, 126, 124, 142, 144, 132, 202,
440	264, 58, 40, 266, 269, 271, 273, 275, 278, 280,	422	202, 163, 167, 171, 37, 175, 177, 181, 183, 187,
441	282	423	189, 193, 195, 197
442		424
443	} ;	425	} ;
444		426
445	static yyconst flex_int16_t yy_def[92] =	427	static yyconst flex_int16_t yy_def[95] =
446	{ 0,	428	{ 0,
447	78, 1, 79, 79, 4, 4, 80, 80, 78, 78,	429	81, 1, 82, 82, 4, 4, 83, 83, 81, 81,
448	78, 78, 78, 81, 78, 78, 13, 78, 13, 78,	430	81, 81, 81, 84, 81, 81, 13, 81, 13, 81,
449	78, 78, 78, 78, 78, 82, 78, 83, 84, 82,	431	81, 81, 81, 81, 81, 85, 81, 86, 87, 85,
450	85, 78, 86, 85, 87, 87, 78, 13, 13, 81,	432	88, 81, 89, 88, 90, 90, 81, 13, 84, 81,
451	78, 78, 78, 78, 78, 78, 78, 78, 82, 82,	433	81, 81, 81, 81, 81, 81, 81, 81, 85, 85,
452	78, 88, 89, 83, 84, 88, 78, 84, 78, 85,	434	81, 91, 92, 93, 86, 87, 91, 81, 91, 87,
453	88, 78, 90, 86, 90, 86, 85, 90, 87, 87,	435	81, 88, 91, 81, 94, 89, 94, 89, 88, 94,
454	89, 91, 89, 89, 91, 91, 91, 0, 78, 78,	436	90, 90, 92, 93, 92, 92, 93, 93, 93, 81,
455	78, 78, 78, 78, 78, 78, 78, 78, 78, 78,	437	0, 81, 81, 81, 81, 81, 81, 81, 81, 81,
456	78	438	81, 81, 81, 81
457		439
458	} ;	440	} ;
459		441
460	static yyconst flex_int16_t yy_nxt[310] =	442	static yyconst flex_int16_t yy_nxt[227] =
461	{ 0,	443	{ 0,
462	10, 11, 12, 11, 13, 10, 14, 13, 15, 16,	444	10, 11, 12, 10, 13, 10, 14, 13, 15, 16,
463	17, 18, 19, 10, 13, 20, 21, 13, 22, 13,	445	17, 18, 19, 10, 13, 20, 21, 13, 22, 13,
464	23, 10, 24, 25, 27, 12, 27, 10, 28, 29,	446	23, 10, 24, 25, 27, 12, 10, 32, 28, 29,
465	32, 34, 32, 34, 36, 33, 33, 37, 10, 37,	447	34, 43, 33, 10, 10, 33, 43, 49, 10, 10,
466	53, 30, 31, 12, 31, 36, 28, 29, 46, 47,	448	36, 30, 31, 12, 10, 36, 28, 29, 54, 51,
467	46, 51, 44, 51, 44, 65, 52, 65, 49, 30,	449	44, 45, 46, 47, 52, 44, 62, 64, 72, 30,
468	38, 70, 37, 38, 37, 70, 38, 38, 39, 38,	450	38, 63, 65, 38, 72, 55, 38, 50, 38, 38,
469	38, 45, 66, 38, 57, 38, 57, 38, 56, 57,	451	38, 69, 67, 38, 67, 38, 70, 38, 57, 58,
470	56, 60, 62, 60, 62, 54, 61, 63, 67, 44,	452	59, 45, 46, 47, 74, 51, 58, 59, 75, 68,
471	67, 44, 65, 68, 65, 58, 46, 47, 46, 46,	453	52, 81, 58, 59, 50, 60, 45, 46, 47, 74,
472		454
473	47, 46, 51, 65, 51, 65, 57, 52, 45, 66,	455	46, 76, 62, 78, 80, 59, 64, 63, 55, 58,
474	60, 50, 60, 50, 72, 61, 72, 62, 73, 62,	456	59, 65, 67, 50, 67, 69, 79, 57, 58, 59,
475	66, 67, 63, 67, 50, 78, 68, 78, 78, 70,	457	70, 67, 74, 67, 74, 81, 75, 74, 78, 68,
476	78, 74, 56, 57, 56, 70, 54, 50, 48, 43,	458	37, 75, 72, 81, 60, 57, 58, 59, 68, 76,
477	42, 41, 74, 78, 78, 77, 78, 78, 78, 58,	459	72, 79, 76, 74, 76, 74, 50, 78, 48, 78,
478	56, 57, 56, 78, 78, 78, 78, 78, 78, 78,	460	79, 42, 60, 41, 40, 37, 81, 81, 81, 81,
479	78, 78, 78, 78, 78, 78, 78, 58, 72, 78,	461	79, 81, 79, 26, 26, 26, 26, 35, 35, 35,
480	72, 78, 73, 78, 78, 78, 78, 78, 78, 78,	462	35, 39, 39, 81, 39, 53, 53, 56, 56, 56,
481	78, 78, 78, 78, 78, 74, 72, 78, 72, 78,	463	56, 61, 61, 66, 66, 81, 66, 71, 71, 57,
482	76, 78, 78, 78, 78, 78, 78, 78, 78, 78,	464	57, 57, 57, 73, 73, 77, 77, 67, 67, 81,
483		465
484	78, 78, 78, 77, 72, 78, 72, 78, 73, 78,	466	67, 9, 81, 81, 81, 81, 81, 81, 81, 81,
485	78, 78, 78, 78, 78, 78, 78, 78, 78, 78,	467	81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
486	78, 74, 72, 78, 72, 78, 76, 78, 78, 78,	468	81, 81, 81, 81, 81, 81
487	78, 78, 78, 78, 78, 78, 78, 78, 78, 77,
488	72, 78, 72, 78, 76, 78, 78, 78, 78, 78,
489	78, 78, 78, 78, 78, 78, 78, 77, 26, 26,
490	26, 35, 35, 35, 40, 40, 55, 55, 55, 59,
491	59, 64, 64, 69, 69, 56, 56, 56, 71, 71,
492	65, 65, 75, 75, 9, 78, 78, 78, 78, 78,
493	78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
494
495	78, 78, 78, 78, 78, 78, 78, 78, 78
496	} ;	469	} ;
497		470
498	static yyconst flex_int16_t yy_chk[310] =	471	static yyconst flex_int16_t yy_chk[227] =
499	{ 0,	472	{ 0,
500	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	473	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
501	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	474	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
502	1, 1, 1, 1, 3, 3, 3, 7, 3, 3,	475	1, 1, 1, 1, 3, 3, 3, 5, 3, 3,
503	5, 6, 5, 6, 7, 5, 6, 11, 8, 11,	476	6, 20, 5, 7, 7, 6, 43, 85, 8, 8,
504	83, 3, 4, 4, 4, 8, 4, 4, 22, 22,	477	7, 3, 4, 4, 4, 8, 4, 4, 28, 27,
505	22, 27, 20, 27, 20, 33, 27, 33, 82, 4,	478	20, 22, 22, 22, 27, 43, 31, 32, 72, 4,
506	13, 70, 37, 13, 37, 69, 13, 13, 13, 13,	479	13, 31, 32, 13, 71, 28, 13, 50, 13, 13,
507	13, 20, 33, 13, 61, 13, 56, 13, 29, 29,	480	13, 34, 33, 13, 33, 13, 34, 13, 29, 29,
508	29, 31, 32, 31, 32, 54, 31, 32, 34, 44,	481	29, 45, 45, 45, 53, 51, 52, 52, 53, 33,
509	34, 44, 64, 34, 64, 29, 30, 30, 30, 46,	482	51, 55, 57, 57, 49, 29, 30, 30, 30, 54,
510		483
511	46, 46, 51, 66, 51, 66, 52, 51, 44, 64,	484	47, 53, 62, 54, 59, 59, 64, 62, 55, 63,
512	60, 50, 60, 30, 53, 60, 53, 62, 53, 62,	485	63, 64, 66, 30, 66, 69, 54, 56, 56, 56,
513	66, 67, 62, 67, 49, 74, 67, 74, 77, 36,	486	69, 68, 73, 68, 74, 76, 73, 75, 74, 66,
514	77, 53, 55, 55, 55, 35, 28, 26, 25, 19,	487	37, 75, 36, 79, 56, 60, 60, 60, 68, 73,
515	18, 17, 74, 9, 0, 77, 0, 0, 0, 55,	488	35, 74, 76, 77, 75, 78, 26, 77, 25, 78,
516	58, 58, 58, 0, 0, 0, 0, 0, 0, 0,	489	79, 19, 60, 18, 17, 11, 9, 0, 0, 0,
517	0, 0, 0, 0, 0, 0, 0, 58, 71, 0,	490	77, 0, 78, 82, 82, 82, 82, 83, 83, 83,
518	71, 0, 71, 0, 0, 0, 0, 0, 0, 0,	491	83, 84, 84, 0, 84, 86, 86, 87, 87, 87,
519	0, 0, 0, 0, 0, 71, 72, 0, 72, 0,	492	87, 88, 88, 89, 89, 0, 89, 90, 90, 91,
520	72, 0, 0, 0, 0, 0, 0, 0, 0, 0,	493	91, 91, 91, 92, 92, 93, 93, 94, 94, 0,
521		494
522	0, 0, 0, 72, 73, 0, 73, 0, 73, 0,	495	94, 81, 81, 81, 81, 81, 81, 81, 81, 81,
523	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	496	81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
524	0, 73, 75, 0, 75, 0, 75, 0, 0, 0,	497	81, 81, 81, 81, 81, 81
525	0, 0, 0, 0, 0, 0, 0, 0, 0, 75,
526	76, 0, 76, 0, 76, 0, 0, 0, 0, 0,
527	0, 0, 0, 0, 0, 0, 0, 76, 79, 79,
528	79, 80, 80, 80, 81, 81, 84, 84, 84, 85,
529	85, 86, 86, 87, 87, 88, 88, 88, 89, 89,
530	90, 90, 91, 91, 78, 78, 78, 78, 78, 78,
531	78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
532
533	78, 78, 78, 78, 78, 78, 78, 78, 78
534	} ;	498	} ;
535		499
536	static yy_state_type yy_last_accepting_state;	500	/* Table of booleans, true if rule could match eol. */
537	static char *yy_last_accepting_cpos;	501	static yyconst flex_int32_t yy_rule_can_match_eol[25] =
538		502	{ 0,
539	extern int yy_flex_debug;	503	0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
540	int yy_flex_debug = 0;	504	0, 0, 1, 0, 0, };
541		505
542	/* The intent behind this definition is that it'll catch	506	/* The intent behind this definition is that it'll catch
543	* any uses of REJECT which flex missed.	507	* any uses of REJECT which flex missed.
Lines 546-552 Link Here
546	#define yymore() yymore_used_but_not_detected	510	#define yymore() yymore_used_but_not_detected
547	#define YY_MORE_ADJ 0	511	#define YY_MORE_ADJ 0
548	#define YY_RESTORE_YY_MORE_OFFSET	512	#define YY_RESTORE_YY_MORE_OFFSET
549	char *yytext;
550	#line 1 "qmake.ll"	513	#line 1 "qmake.ll"
551	#line 2 "qmake.ll"	514	#line 2 "qmake.ll"
552	/***************************************************************************	515	/***************************************************************************
Lines 569-577 Link Here
569	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *	532	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
570	***************************************************************************/	533	***************************************************************************/
571		534
572	#include <qmake_yacc.h>
573	#include <stdlib.h>	535	#include <stdlib.h>
574		536
		537	#define DONT_INCLUDE_FLEXLEXER
		538
		539	#include "qmake_lex.h"
		540
575	/**	541	/**
576	@file qmake.ll	542	@file qmake.ll
577	QMake Lexer	543	QMake Lexer
Lines 598-604 Link Here
598		564
599		565
600		566
601	#line 602 "qmake_lex.cpp"	567	#line 568 "qmake_lex.cpp"
602		568
603	#define INITIAL 0	569	#define INITIAL 0
604	#define list 1	570	#define list 1
Lines 617-638 Link Here
617	#define YY_EXTRA_TYPE void *	583	#define YY_EXTRA_TYPE void *
618	#endif	584	#endif
619		585
620	static int yy_init_globals (void );
621
622	/* Macros after this point can all be overridden by user definitions in
623	* section 1.
624	*/
625
626	#ifndef YY_SKIP_YYWRAP
627	#ifdef __cplusplus
628	extern "C" int yywrap (void );
629	#else
630	extern int yywrap (void );
631	#endif
632	#endif
633
634	static void yyunput (int c,char *buf_ptr );
635
636	#ifndef yytext_ptr	586	#ifndef yytext_ptr
637	static void yy_flex_strncpy (char ,yyconst char ,int );	587	static void yy_flex_strncpy (char ,yyconst char ,int );
638	#endif	588	#endif
Lines 643-654 Link Here
643		593
644	#ifndef YY_NO_INPUT	594	#ifndef YY_NO_INPUT
645		595
646	#ifdef __cplusplus
647	static int yyinput (void );
648	#else
649	static int input (void );
650	#endif
651
652	#endif	596	#endif
653		597
654	/* Amount of stuff to slurp up with each read. */	598	/* Amount of stuff to slurp up with each read. */
Lines 658-667 Link Here
658		602
659	/* Copy whatever the last rule matched to the standard output. */	603	/* Copy whatever the last rule matched to the standard output. */
660	#ifndef ECHO	604	#ifndef ECHO
661	/* This used to be an fputs(), but since the string might contain NUL's,	605	#define ECHO LexerOutput( yytext, yyleng )
662	* we now use fwrite().
663	*/
664	#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
665	#endif	606	#endif
666		607
667	/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,	608	/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
Lines 669-702 Link Here
669	*/	610	*/
670	#ifndef YY_INPUT	611	#ifndef YY_INPUT
671	#define YY_INPUT(buf,result,max_size) \	612	#define YY_INPUT(buf,result,max_size) \
672	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
673	{ \
674	int c = '*'; \
675	size_t n; \
676	for ( n = 0; n < max_size && \
677	(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
678	buf[n] = (char) c; \
679	if ( c == '\n' ) \
680	buf[n++] = (char) c; \
681	if ( c == EOF && ferror( yyin ) ) \
682	YY_FATAL_ERROR( "input in flex scanner failed" ); \
683	result = n; \
684	} \
685	else \
686	{ \
687	errno=0; \
688	while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
689	{ \
690	if( errno != EINTR) \
691	{ \
692	YY_FATAL_ERROR( "input in flex scanner failed" ); \
693	break; \
694	} \
695	errno=0; \
696	clearerr(yyin); \
697	} \
698	}\
699	\	613	\
		614	if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
		615	YY_FATAL_ERROR( "input in flex scanner failed" );
700		616
701	#endif	617	#endif
702		618
Lines 715-721 Link Here
715		631
716	/* Report a fatal error. */	632	/* Report a fatal error. */
717	#ifndef YY_FATAL_ERROR	633	#ifndef YY_FATAL_ERROR
718	#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )	634	#define YY_FATAL_ERROR(msg) LexerError( msg )
719	#endif	635	#endif
720		636
721	/* end tables serialization structures and prototypes */	637	/* end tables serialization structures and prototypes */
Lines 725-734 Link Here
725	*/	641	*/
726	#ifndef YY_DECL	642	#ifndef YY_DECL
727	#define YY_DECL_IS_OURS 1	643	#define YY_DECL_IS_OURS 1
728		644	#define YY_DECL int yyFlexLexer::yylex()
729	extern int yylex (void);
730
731	#define YY_DECL int yylex (void)
732	#endif /* !YY_DECL */	645	#endif /* !YY_DECL */
733		646
734	/* Code executed at the beginning of each rule, after yytext and yyleng	647	/* Code executed at the beginning of each rule, after yytext and yyleng
Lines 757-765 Link Here
757	register char yy_cp, yy_bp;	670	register char yy_cp, yy_bp;
758	register int yy_act;	671	register int yy_act;
759		672
760	#line 72 "qmake.ll"	673	#line 78 "qmake.ll"
761		674
762	#line 763 "qmake_lex.cpp"	675	#line 676 "qmake_lex.cpp"
763		676
764	if ( !(yy_init) )	677	if ( !(yy_init) )
765	{	678	{
Lines 773-787 Link Here
773	(yy_start) = 1; /* first start state */	686	(yy_start) = 1; /* first start state */
774		687
775	if ( ! yyin )	688	if ( ! yyin )
776	yyin = stdin;	689	yyin = & std::cin;
777		690
778	if ( ! yyout )	691	if ( ! yyout )
779	yyout = stdout;	692	yyout = & std::cout;
780		693
781	if ( ! YY_CURRENT_BUFFER ) {	694	if ( ! YY_CURRENT_BUFFER ) {
782	yyensure_buffer_stack ();	695	yyensure_buffer_stack ();
783	YY_CURRENT_BUFFER_LVALUE =	696	YY_CURRENT_BUFFER_LVALUE =
784	yy_create_buffer(yyin,YY_BUF_SIZE );	697	yy_create_buffer( yyin, YY_BUF_SIZE );
785	}	698	}
786		699
787	yy_load_buffer_state( );	700	yy_load_buffer_state( );
Lines 813-825 Link Here
813	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )	726	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
814	{	727	{
815	yy_current_state = (int) yy_def[yy_current_state];	728	yy_current_state = (int) yy_def[yy_current_state];
816	if ( yy_current_state >= 79 )	729	if ( yy_current_state >= 82 )
817	yy_c = yy_meta[(unsigned int) yy_c];	730	yy_c = yy_meta[(unsigned int) yy_c];
818	}	731	}
819	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];	732	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
820	++yy_cp;	733	++yy_cp;
821	}	734	}
822	while ( yy_base[yy_current_state] != 285 );	735	while ( yy_base[yy_current_state] != 202 );
823		736
824	yy_find_action:	737	yy_find_action:
825	yy_act = yy_accept[yy_current_state];	738	yy_act = yy_accept[yy_current_state];
Lines 832-837 Link Here
832		745
833	YY_DO_BEFORE_ACTION;	746	YY_DO_BEFORE_ACTION;
834		747
		748	if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
		749	{
		750	int yyl;
		751	for ( yyl = 0; yyl < yyleng; ++yyl )
		752	if ( yytext[yyl] == '\n' )
		753
		754	yylineno++;
		755	;
		756	}
		757
835	do_action: /* This label is used only to access EOF actions. */	758	do_action: /* This label is used only to access EOF actions. */
836		759
837	switch ( yy_act )	760	switch ( yy_act )
Lines 845-991 Link Here
845		768
846	case 1:	769	case 1:
847	YY_RULE_SETUP	770	YY_RULE_SETUP
848	#line 73 "qmake.ll"	771	#line 79 "qmake.ll"
849	{}	772	{}
850	YY_BREAK	773	YY_BREAK
851	case 2:	774	case 2:
852	YY_RULE_SETUP	775	YY_RULE_SETUP
853	#line 74 "qmake.ll"	776	#line 81 "qmake.ll"
854	{ yylval.value = yytext; return LIST_WS; }	777	{
		778	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		779	return Parser::token::token::LIST_WS;
		780	}
855	YY_BREAK	781	YY_BREAK
856	case 3:	782	case 3:
857	YY_RULE_SETUP	783	YY_RULE_SETUP
858	#line 75 "qmake.ll"	784	#line 86 "qmake.ll"
859	{	785	{
860	yylval.value = yytext;	786	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
861	unput(char(yylval.value.at(yylval.value.length()-1).latin1()));	787	unput(char(mylval->value.at(mylval->value.length()-1).latin1()));
862	yylval.value = yylval.value.mid(0, yylval.value.length()-1);	788	mylval->value = mylval->value.mid(0, mylval->value.length()-1);
863	return INDENT;	789	return Parser::token::token::INDENT;
864	}	790	}
865	YY_BREAK	791	YY_BREAK
866	case 4:	792	case 4:
867	/* rule 4 can match eol */	793	/* rule 4 can match eol */
868	YY_RULE_SETUP	794	YY_RULE_SETUP
869	#line 82 "qmake.ll"	795	#line 93 "qmake.ll"
870	{ BEGIN(list); return CONT; }	796	{
		797	BEGIN(list);
		798	return Parser::token::token::CONT;
		799	}
871	YY_BREAK	800	YY_BREAK
872	case 5:	801	case 5:
873	YY_RULE_SETUP	802	YY_RULE_SETUP
874	#line 83 "qmake.ll"	803	#line 97 "qmake.ll"
875	{ yylval.value = yytext; return (ID_SIMPLE); }	804	{
		805	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		806	return (Parser::token::token::ID_SIMPLE);
		807	}
876	YY_BREAK	808	YY_BREAK
877	case 6:	809	case 6:
878	YY_RULE_SETUP	810	YY_RULE_SETUP
879	#line 85 "qmake.ll"	811	#line 102 "qmake.ll"
880	{	812	{
881	yylval.value = yytext;	813	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
882	BEGIN(list);	814	BEGIN(list);
883	return (LIST_COMMENT_WITHOUT_NEWLINE);	815	return (Parser::token::token::LIST_COMMENT_WITHOUT_NEWLINE);
884	}	816	}
885	YY_BREAK	817	YY_BREAK
886	case 7:	818	case 7:
887	/* rule 7 can match eol */	819	/* rule 7 can match eol */
888	YY_RULE_SETUP	820	YY_RULE_SETUP
889	#line 91 "qmake.ll"	821	#line 108 "qmake.ll"
890	{	822	{
891	yylval.value = yytext;	823	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
892	BEGIN(list);	824	BEGIN(list);
893	return (LIST_COMMENT);	825	return (Parser::token::token::LIST_COMMENT);
894	}	826	}
895	YY_BREAK	827	YY_BREAK
896	case 8:	828	case 8:
897	YY_RULE_SETUP	829	YY_RULE_SETUP
898	#line 97 "qmake.ll"	830	#line 114 "qmake.ll"
899	{	831	{
900	yylval.value = yytext;	832	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
901	yylval.value = yylval.value.mid(0, yylval.value.length()-1);	833	mylval->value = mylval->value.mid(0, mylval->value.length()-1);
902	unput(')');	834	unput(')');
903	BEGIN(INITIAL);	835	BEGIN(INITIAL);
904	return (ID_ARGS);	836	return (Parser::token::token::ID_ARGS);
905	}	837	}
906	YY_BREAK	838	YY_BREAK
907	case 9:	839	case 9:
908	YY_RULE_SETUP	840	YY_RULE_SETUP
909	#line 105 "qmake.ll"	841	#line 122 "qmake.ll"
910	{ BEGIN(list_with_comment); yylval.value = yytext; return VARIABLE_VALUE; }	842	{
		843	BEGIN(list_with_comment);
		844	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		845	return Parser::token::token::VARIABLE_VALUE;
		846	}
911	YY_BREAK	847	YY_BREAK
912	case 10:	848	case 10:
913	YY_RULE_SETUP	849	YY_RULE_SETUP
914	#line 106 "qmake.ll"	850	#line 128 "qmake.ll"
915	{ BEGIN(list_with_comment); yylval.value = yytext; return QUOTED_VARIABLE_VALUE; }	851	{
		852	BEGIN(list_with_comment);
		853	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		854	return Parser::token::token::QUOTED_VARIABLE_VALUE;
		855	}
916	YY_BREAK	856	YY_BREAK
917	case 11:	857	case 11:
918	YY_RULE_SETUP	858	YY_RULE_SETUP
919	#line 108 "qmake.ll"	859	#line 134 "qmake.ll"
920	{ BEGIN(list); yylval.value = yytext; return EQ; }	860	{
		861	BEGIN(list);
		862	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		863	return Parser::token::token::EQ;
		864	}
921	YY_BREAK	865	YY_BREAK
922	case 12:	866	case 12:
923	YY_RULE_SETUP	867	YY_RULE_SETUP
924	#line 109 "qmake.ll"	868	#line 140 "qmake.ll"
925	{ BEGIN(list); yylval.value = yytext; return PLUSEQ; }	869	{
		870	BEGIN(list);
		871	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		872	return Parser::token::token::PLUSEQ;
		873	}
926	YY_BREAK	874	YY_BREAK
927	case 13:	875	case 13:
928	YY_RULE_SETUP	876	YY_RULE_SETUP
929	#line 110 "qmake.ll"	877	#line 146 "qmake.ll"
930	{ BEGIN(list); yylval.value = yytext; return MINUSQE; }	878	{
		879	BEGIN(list);
		880	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		881	return Parser::token::token::MINUSEQ;
		882	}
931	YY_BREAK	883	YY_BREAK
932	case 14:	884	case 14:
933	YY_RULE_SETUP	885	YY_RULE_SETUP
934	#line 111 "qmake.ll"	886	#line 152 "qmake.ll"
935	{ BEGIN(list); yylval.value = yytext; return STAREQ; }	887	{
		888	BEGIN(list);
		889	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		890	return Parser::token::token::STAREQ;
		891	}
936	YY_BREAK	892	YY_BREAK
937	case 15:	893	case 15:
938	YY_RULE_SETUP	894	YY_RULE_SETUP
939	#line 112 "qmake.ll"	895	#line 158 "qmake.ll"
940	{ BEGIN(list); yylval.value = yytext; return TILDEEQ; }	896	{
		897	BEGIN(list);
		898	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		899	return Parser::token::token::TILDEEQ;
		900	}
941	YY_BREAK	901	YY_BREAK
942	case 16:	902	case 16:
943	YY_RULE_SETUP	903	YY_RULE_SETUP
944	#line 113 "qmake.ll"	904	#line 164 "qmake.ll"
945	{ return LCURLY; }	905	{
		906	return Parser::token::token::LCURLY;
		907	}
946	YY_BREAK	908	YY_BREAK
947	case 17:	909	case 17:
948	YY_RULE_SETUP	910	YY_RULE_SETUP
949	#line 114 "qmake.ll"	911	#line 168 "qmake.ll"
950	{ return LCURLY; }	912	{
		913	return Parser::token::token::LCURLY;
		914	}
951	YY_BREAK	915	YY_BREAK
952	case 18:	916	case 18:
953	YY_RULE_SETUP	917	YY_RULE_SETUP
954	#line 115 "qmake.ll"	918	#line 172 "qmake.ll"
955	{ return RCURLY; }	919	{
		920	return Parser::token::token::RCURLY;
		921	}
956	YY_BREAK	922	YY_BREAK
957	case 19:	923	case 19:
958	YY_RULE_SETUP	924	YY_RULE_SETUP
959	#line 116 "qmake.ll"	925	#line 176 "qmake.ll"
960	{ BEGIN(funcargs); return LBRACE; }	926	{
		927	BEGIN(funcargs);
		928	return Parser::token::token::LBRACE;
		929	}
961	YY_BREAK	930	YY_BREAK
962	case 20:	931	case 20:
963	YY_RULE_SETUP	932	YY_RULE_SETUP
964	#line 117 "qmake.ll"	933	#line 181 "qmake.ll"
965	{ BEGIN(INITIAL); return RBRACE; }	934	{
		935	BEGIN(INITIAL);
		936	return Parser::token::token::RBRACE;
		937	}
966	YY_BREAK	938	YY_BREAK
967	case 21:	939	case 21:
968	YY_RULE_SETUP	940	YY_RULE_SETUP
969	#line 118 "qmake.ll"	941	#line 186 "qmake.ll"
970	{ yylval.value = yytext; return COLON; }	942	{
		943	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		944	return Parser::token::token::COLON;
		945	}
971	YY_BREAK	946	YY_BREAK
972	case 22:	947	case 22:
973	/* rule 22 can match eol */	948	/* rule 22 can match eol */
974	YY_RULE_SETUP	949	YY_RULE_SETUP
975	#line 119 "qmake.ll"	950	#line 191 "qmake.ll"
976	{ BEGIN(INITIAL); return NEWLINE; }	951	{
		952	BEGIN(INITIAL);
		953	return Parser::token::token::NEWLINE;
		954	}
977	YY_BREAK	955	YY_BREAK
978	case 23:	956	case 23:
979	YY_RULE_SETUP	957	YY_RULE_SETUP
980	#line 121 "qmake.ll"	958	#line 196 "qmake.ll"
981	{ yylval.value = yytext; return (COMMENT); }	959	{
		960	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		961	return (Parser::token::token::COMMENT);
		962	}
982	YY_BREAK	963	YY_BREAK
983	case 24:	964	case 24:
984	YY_RULE_SETUP	965	YY_RULE_SETUP
985	#line 123 "qmake.ll"	966	#line 201 "qmake.ll"
986	ECHO;	967	ECHO;
987	YY_BREAK	968	YY_BREAK
988	#line 989 "qmake_lex.cpp"	969	#line 970 "qmake_lex.cpp"
989	case YY_STATE_EOF(INITIAL):	970	case YY_STATE_EOF(INITIAL):
990	case YY_STATE_EOF(list):	971	case YY_STATE_EOF(list):
991	case YY_STATE_EOF(list_with_comment):	972	case YY_STATE_EOF(list_with_comment):
Lines 1121-1126 Link Here
1121	} /* end of scanning one token */	1102	} /* end of scanning one token */
1122	} /* end of yylex */	1103	} /* end of yylex */
1123		1104
		1105	yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
		1106	{
		1107	yyin = arg_yyin;
		1108	yyout = arg_yyout;
		1109	yy_c_buf_p = 0;
		1110	yy_init = 0;
		1111	yy_start = 0;
		1112	yy_flex_debug = 0;
		1113	yylineno = 1; // this will only get updated if %option yylineno
		1114
		1115	yy_did_buffer_switch_on_eof = 0;
		1116
		1117	yy_looking_for_trail_begin = 0;
		1118	yy_more_flag = 0;
		1119	yy_more_len = 0;
		1120	yy_more_offset = yy_prev_more_offset = 0;
		1121
		1122	yy_start_stack_ptr = yy_start_stack_depth = 0;
		1123	yy_start_stack = NULL;
		1124
		1125	(yy_buffer_stack) = 0;
		1126	(yy_buffer_stack_top) = 0;
		1127	(yy_buffer_stack_max) = 0;
		1128
		1129	yy_state_buf = 0;
		1130
		1131	}
		1132
		1133	void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
		1134	{
		1135	if ( new_in )
		1136	{
		1137	yy_delete_buffer( YY_CURRENT_BUFFER );
		1138	yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
		1139	}
		1140
		1141	if ( new_out )
		1142	yyout = new_out;
		1143	}
		1144
		1145	#ifdef YY_INTERACTIVE
		1146	int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
		1147	#else
		1148	int yyFlexLexer::LexerInput( char* buf, int max_size )
		1149	#endif
		1150	{
		1151	if ( yyin->eof() \|\| yyin->fail() )
		1152	return 0;
		1153
		1154	#ifdef YY_INTERACTIVE
		1155	yyin->get( buf[0] );
		1156
		1157	if ( yyin->eof() )
		1158	return 0;
		1159
		1160	if ( yyin->bad() )
		1161	return -1;
		1162
		1163	return 1;
		1164
		1165	#else
		1166	(void) yyin->read( buf, max_size );
		1167
		1168	if ( yyin->bad() )
1169	return -1;
1170	else
1171	return yyin->gcount();
1172	#endif
1173	}
1174
1175	void yyFlexLexer::LexerOutput( const char* buf, int size )
1176	{
1177	(void) yyout->write( buf, size );
1178	}
1179
1124	/* yy_get_next_buffer - try to read in a new buffer	1180	/* yy_get_next_buffer - try to read in a new buffer
1125	*	1181	*
1126	* Returns a code representing an action:	1182	* Returns a code representing an action:
Lines 1128-1134 Link Here
1128	* EOB_ACT_CONTINUE_SCAN - continue scanning from current position	1184	* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1129	* EOB_ACT_END_OF_FILE - end of file	1185	* EOB_ACT_END_OF_FILE - end of file
1130	*/	1186	*/
1131	static int yy_get_next_buffer (void)	1187	int yyFlexLexer::yy_get_next_buffer()
1132	{	1188	{
1133	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;	1189	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1134	register char *source = (yytext_ptr);	1190	register char *source = (yytext_ptr);
Lines 1229-1235 Link Here
1229	if ( number_to_move == YY_MORE_ADJ )	1285	if ( number_to_move == YY_MORE_ADJ )
1230	{	1286	{
1231	ret_val = EOB_ACT_END_OF_FILE;	1287	ret_val = EOB_ACT_END_OF_FILE;
1232	yyrestart(yyin );	1288	yyrestart( yyin );
1233	}	1289	}
1234		1290
1235	else	1291	else
Lines 1254-1260 Link Here
1254		1310
1255	/* yy_get_previous_state - get the state just before the EOB char was reached */	1311	/* yy_get_previous_state - get the state just before the EOB char was reached */
1256		1312
1257	static yy_state_type yy_get_previous_state (void)	1313	yy_state_type yyFlexLexer::yy_get_previous_state()
1258	{	1314	{
1259	register yy_state_type yy_current_state;	1315	register yy_state_type yy_current_state;
1260	register char *yy_cp;	1316	register char *yy_cp;
Lines 1273-1279 Link Here
1273	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )	1329	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1274	{	1330	{
1275	yy_current_state = (int) yy_def[yy_current_state];	1331	yy_current_state = (int) yy_def[yy_current_state];
1276	if ( yy_current_state >= 79 )	1332	if ( yy_current_state >= 82 )
1277	yy_c = yy_meta[(unsigned int) yy_c];	1333	yy_c = yy_meta[(unsigned int) yy_c];
1278	}	1334	}
1279	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];	1335	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
Lines 1287-1293 Link Here
1287	* synopsis	1343	* synopsis
1288	* next_state = yy_try_NUL_trans( current_state );	1344	* next_state = yy_try_NUL_trans( current_state );
1289	*/	1345	*/
1290	static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )	1346	yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
1291	{	1347	{
1292	register int yy_is_jam;	1348	register int yy_is_jam;
1293	register char *yy_cp = (yy_c_buf_p);	1349	register char *yy_cp = (yy_c_buf_p);
Lines 1301-1316 Link Here
1301	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )	1357	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1302	{	1358	{
1303	yy_current_state = (int) yy_def[yy_current_state];	1359	yy_current_state = (int) yy_def[yy_current_state];
1304	if ( yy_current_state >= 79 )	1360	if ( yy_current_state >= 82 )
1305	yy_c = yy_meta[(unsigned int) yy_c];	1361	yy_c = yy_meta[(unsigned int) yy_c];
1306	}	1362	}
1307	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];	1363	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1308	yy_is_jam = (yy_current_state == 78);	1364	yy_is_jam = (yy_current_state == 81);
1309		1365
1310	return yy_is_jam ? 0 : yy_current_state;	1366	return yy_is_jam ? 0 : yy_current_state;
1311	}	1367	}
1312		1368
1313	static void yyunput (int c, register char * yy_bp )	1369	void yyFlexLexer::yyunput( int c, register char* yy_bp)
1314	{	1370	{
1315	register char *yy_cp;	1371	register char *yy_cp;
1316		1372
Lines 1342-1359 Link Here
1342		1398
1343	*--yy_cp = (char) c;	1399	*--yy_cp = (char) c;
1344		1400
		1401	if ( c == '\n' ){
		1402	--yylineno;
		1403	}
		1404
1345	(yytext_ptr) = yy_bp;	1405	(yytext_ptr) = yy_bp;
1346	(yy_hold_char) = *yy_cp;	1406	(yy_hold_char) = *yy_cp;
1347	(yy_c_buf_p) = yy_cp;	1407	(yy_c_buf_p) = yy_cp;
1348	}	1408	}
1349		1409
1350	#ifndef YY_NO_INPUT	1410	int yyFlexLexer::yyinput()
1351	#ifdef __cplusplus
1352	static int yyinput (void)
1353	#else
1354	static int input (void)
1355	#endif
1356
1357	{	1411	{
1358	int c;	1412	int c;
1359		1413
Lines 1388-1394 Link Here
1388	*/	1442	*/
1389		1443
1390	/* Reset buffer status. */	1444	/* Reset buffer status. */
1391	yyrestart(yyin );	1445	yyrestart( yyin );
1392		1446
1393	/FALLTHROUGH/	1447	/FALLTHROUGH/
1394		1448
Lines 1418-1443 Link Here
1418	(yy_hold_char) = *++(yy_c_buf_p);	1472	(yy_hold_char) = *++(yy_c_buf_p);
1419		1473
1420	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');	1474	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
		1475	if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
		1476
		1477	yylineno++;
		1478	;
1421		1479
1422	return c;	1480	return c;
1423	}	1481	}
1424	#endif /* ifndef YY_NO_INPUT */
1425		1482
1426	/** Immediately switch to a different input stream.	1483	/** Immediately switch to a different input stream.
1427	* @param input_file A readable stream.	1484	* @param input_file A readable stream.
1428	*	1485	*
1429	* @note This function does not reset the start condition to @c INITIAL .	1486	* @note This function does not reset the start condition to @c INITIAL .
1430	*/	1487	*/
1431	void yyrestart (FILE * input_file )	1488	void yyFlexLexer::yyrestart( std::istream* input_file )
1432	{	1489	{
1433		1490
1434	if ( ! YY_CURRENT_BUFFER ){	1491	if ( ! YY_CURRENT_BUFFER ){
1435	yyensure_buffer_stack ();	1492	yyensure_buffer_stack ();
1436	YY_CURRENT_BUFFER_LVALUE =	1493	YY_CURRENT_BUFFER_LVALUE =
1437	yy_create_buffer(yyin,YY_BUF_SIZE );	1494	yy_create_buffer( yyin, YY_BUF_SIZE );
1438	}	1495	}
1439		1496
1440	yy_init_buffer(YY_CURRENT_BUFFER,input_file );	1497	yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1441	yy_load_buffer_state( );	1498	yy_load_buffer_state( );
1442	}	1499	}
1443		1500
Lines 1445-1451 Link Here
1445	* @param new_buffer The new input buffer.	1502	* @param new_buffer The new input buffer.
1446	*	1503	*
1447	*/	1504	*/
1448	void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )	1505	void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1449	{	1506	{
1450		1507
1451	/* TODO. We should be able to replace this entire function body	1508	/* TODO. We should be able to replace this entire function body
Lines 1476-1482 Link Here
1476	(yy_did_buffer_switch_on_eof) = 1;	1533	(yy_did_buffer_switch_on_eof) = 1;
1477	}	1534	}
1478		1535
1479	static void yy_load_buffer_state (void)	1536	void yyFlexLexer::yy_load_buffer_state()
1480	{	1537	{
1481	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;	1538	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1482	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;	1539	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
Lines 1490-1496 Link Here
1490	*	1547	*
1491	* @return the allocated buffer state.	1548	* @return the allocated buffer state.
1492	*/	1549	*/
1493	YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )	1550	YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
1494	{	1551	{
1495	YY_BUFFER_STATE b;	1552	YY_BUFFER_STATE b;
1496		1553
Lines 1509-1515 Link Here
1509		1566
1510	b->yy_is_our_buffer = 1;	1567	b->yy_is_our_buffer = 1;
1511		1568
1512	yy_init_buffer(b,file );	1569	yy_init_buffer( b, file );
1513		1570
1514	return b;	1571	return b;
1515	}	1572	}
Lines 1518-1524 Link Here
1518	* @param b a buffer created with yy_create_buffer()	1575	* @param b a buffer created with yy_create_buffer()
1519	*	1576	*
1520	*/	1577	*/
1521	void yy_delete_buffer (YY_BUFFER_STATE b )	1578	void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
1522	{	1579	{
1523		1580
1524	if ( ! b )	1581	if ( ! b )
Lines 1533-1552 Link Here
1533	yyfree((void *) b );	1590	yyfree((void *) b );
1534	}	1591	}
1535		1592
1536	#ifndef __cplusplus	1593	extern "C" int isatty (int );
1537	extern int isatty (int );
1538	#endif /* __cplusplus */
1539		1594
1540	/* Initializes or reinitializes a buffer.	1595	/* Initializes or reinitializes a buffer.
1541	* This function is sometimes called more than once on the same buffer,	1596	* This function is sometimes called more than once on the same buffer,
1542	* such as during a yyrestart() or at EOF.	1597	* such as during a yyrestart() or at EOF.
1543	*/	1598	*/
1544	static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )	1599	void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
1545		1600
1546	{	1601	{
1547	int oerrno = errno;	1602	int oerrno = errno;
1548		1603
1549	yy_flush_buffer(b );	1604	yy_flush_buffer( b );
1550		1605
1551	b->yy_input_file = file;	1606	b->yy_input_file = file;
1552	b->yy_fill_buffer = 1;	1607	b->yy_fill_buffer = 1;
Lines 1560-1567 Link Here
1560	b->yy_bs_column = 0;	1615	b->yy_bs_column = 0;
1561	}	1616	}
1562		1617
1563	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;	1618	b->yy_is_interactive = 0;
1564
1565	errno = oerrno;	1619	errno = oerrno;
1566	}	1620	}
1567		1621
Lines 1569-1575 Link Here
1569	* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.	1623	* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1570	*	1624	*
1571	*/	1625	*/
1572	void yy_flush_buffer (YY_BUFFER_STATE b )	1626	void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
1573	{	1627	{
1574	if ( ! b )	1628	if ( ! b )
1575	return;	1629	return;
Lines 1598-1604 Link Here
1598	* @param new_buffer The new state.	1652	* @param new_buffer The new state.
1599	*	1653	*
1600	*/	1654	*/
1601	void yypush_buffer_state (YY_BUFFER_STATE new_buffer )	1655	void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer)
1602	{	1656	{
1603	if (new_buffer == NULL)	1657	if (new_buffer == NULL)
1604	return;	1658	return;
Lines 1628-1634 Link Here
1628	* The next element becomes the new top.	1682	* The next element becomes the new top.
1629	*	1683	*
1630	*/	1684	*/
1631	void yypop_buffer_state (void)	1685	void yyFlexLexer::yypop_buffer_state (void)
1632	{	1686	{
1633	if (!YY_CURRENT_BUFFER)	1687	if (!YY_CURRENT_BUFFER)
1634	return;	1688	return;
Lines 1647-1653 Link Here
1647	/* Allocates the stack if it does not exist.	1701	/* Allocates the stack if it does not exist.
1648	* Guarantees space for at least one push.	1702	* Guarantees space for at least one push.
1649	*/	1703	*/
1650	static void yyensure_buffer_stack (void)	1704	void yyFlexLexer::yyensure_buffer_stack(void)
1651	{	1705	{
1652	int num_to_alloc;	1706	int num_to_alloc;
1653		1707
Lines 1686-1784 Link Here
1686	}	1740	}
1687	}	1741	}
1688		1742
1689	/** Setup the input buffer state to scan directly from a user-specified character buffer.	1743	void yyFlexLexer::yy_push_state( int new_state )
1690	* @param base the character buffer
1691	* @param size the size in bytes of the character buffer
1692	*
1693	* @return the newly allocated buffer state object.
1694	*/
1695	YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1696	{	1744	{
1697	YY_BUFFER_STATE b;	1745	if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
		1746	{
		1747	yy_size_t new_size;
1698		1748
1699	if ( size < 2 \|\|	1749	(yy_start_stack_depth) += YY_START_STACK_INCR;
1700	base[size-2] != YY_END_OF_BUFFER_CHAR \|\|	1750	new_size = (yy_start_stack_depth) * sizeof( int );
1701	base[size-1] != YY_END_OF_BUFFER_CHAR )
1702	/* They forgot to leave room for the EOB's. */
1703	return 0;
1704		1751
1705	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );	1752	if ( ! (yy_start_stack) )
1706	if ( ! b )	1753	(yy_start_stack) = (int *) yyalloc(new_size );
1707	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1708		1754
1709	b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */	1755	else
1710	b->yy_buf_pos = b->yy_ch_buf = base;	1756	(yy_start_stack) = (int ) yyrealloc((void ) (yy_start_stack),new_size );
1711	b->yy_is_our_buffer = 0;	1757
1712	b->yy_input_file = 0;	1758	if ( ! (yy_start_stack) )
1713	b->yy_n_chars = b->yy_buf_size;	1759	YY_FATAL_ERROR(
1714	b->yy_is_interactive = 0;	1760	"out of memory expanding start-condition stack" );
1715	b->yy_at_bol = 1;	1761	}
1716	b->yy_fill_buffer = 0;
1717	b->yy_buffer_status = YY_BUFFER_NEW;
1718		1762
1719	yy_switch_to_buffer(b );	1763	(yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
1720		1764
1721	return b;	1765	BEGIN(new_state);
1722	}	1766	}
1723		1767
1724	/** Setup the input buffer state to scan a string. The next call to yylex() will	1768	void yyFlexLexer::yy_pop_state()
1725	* scan from a @e copy of @a str.
1726	* @param yystr a NUL-terminated string to scan
1727	*
1728	* @return the newly allocated buffer state object.
1729	* @note If you want to scan bytes that may contain NUL values, then use
1730	* yy_scan_bytes() instead.
1731	*/
1732	YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1733	{	1769	{
		1770	if ( --(yy_start_stack_ptr) < 0 )
		1771	YY_FATAL_ERROR( "start-condition stack underflow" );
1734		1772
1735	return yy_scan_bytes(yystr,strlen(yystr) );	1773	BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
1736	}	1774	}
1737		1775
1738	/** Setup the input buffer state to scan the given bytes. The next call to yylex() will	1776	int yyFlexLexer::yy_top_state()
1739	* scan from a @e copy of @a bytes.
1740	* @param bytes the byte buffer to scan
1741	* @param len the number of bytes in the buffer pointed to by @a bytes.
1742	*
1743	* @return the newly allocated buffer state object.
1744	*/
1745	YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len )
1746	{	1777	{
1747	YY_BUFFER_STATE b;	1778	return (yy_start_stack)[(yy_start_stack_ptr) - 1];
1748	char *buf;
1749	yy_size_t n;
1750	int i;
1751
1752	/* Get memory for full buffer, including space for trailing EOB's. */
1753	n = _yybytes_len + 2;
1754	buf = (char *) yyalloc(n );
1755	if ( ! buf )
1756	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1757
1758	for ( i = 0; i < _yybytes_len; ++i )
1759	buf[i] = yybytes[i];
1760
1761	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1762
1763	b = yy_scan_buffer(buf,n );
1764	if ( ! b )
1765	YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1766
1767	/* It's okay to grow etc. this buffer, and we should throw it
1768	* away when we're done.
1769	*/
1770	b->yy_is_our_buffer = 1;
1771
1772	return b;
1773	}	1779	}
1774		1780
1775	#ifndef YY_EXIT_FAILURE	1781	#ifndef YY_EXIT_FAILURE
1776	#define YY_EXIT_FAILURE 2	1782	#define YY_EXIT_FAILURE 2
1777	#endif	1783	#endif
1778		1784
1779	static void yy_fatal_error (yyconst char* msg )	1785	void yyFlexLexer::LexerError( yyconst char msg[] )
1780	{	1786	{
1781	(void) fprintf( stderr, "%s\n", msg );	1787	std::cerr << msg << std::endl;
1782	exit( YY_EXIT_FAILURE );	1788	exit( YY_EXIT_FAILURE );
1783	}	1789	}
1784		1790
Lines 1801-1919 Link Here
1801		1807
1802	/* Accessor methods (get/set functions) to struct members. */	1808	/* Accessor methods (get/set functions) to struct members. */
1803		1809
1804	/** Get the current line number.	1810	yyFlexLexer::~yyFlexLexer()
1805	*
1806	*/
1807	int yyget_lineno (void)
1808	{
1809
1810	return yylineno;
1811	}
1812
1813	/** Get the input stream.
1814	*
1815	*/
1816	FILE *yyget_in (void)
1817	{
1818	return yyin;
1819	}
1820
1821	/** Get the output stream.
1822	*
1823	*/
1824	FILE *yyget_out (void)
1825	{
1826	return yyout;
1827	}
1828
1829	/** Get the length of the current token.
1830	*
1831	*/
1832	int yyget_leng (void)
1833	{
1834	return yyleng;
1835	}
1836
1837	/** Get the current token.
1838	*
1839	*/
1840
1841	char *yyget_text (void)
1842	{
1843	return yytext;
1844	}
1845
1846	/** Set the current line number.
1847	* @param line_number
1848	*
1849	*/
1850	void yyset_lineno (int line_number )
1851	{
1852
1853	yylineno = line_number;
1854	}
1855
1856	/** Set the input stream. This does not discard the current
1857	* input buffer.
1858	* @param in_str A readable stream.
1859	*
1860	* @see yy_switch_to_buffer
1861	*/
1862	void yyset_in (FILE * in_str )
1863	{
1864	yyin = in_str ;
1865	}
1866
1867	void yyset_out (FILE * out_str )
1868	{
1869	yyout = out_str ;
1870	}
1871
1872	int yyget_debug (void)
1873	{
1874	return yy_flex_debug;
1875	}
1876
1877	void yyset_debug (int bdebug )
1878	{
1879	yy_flex_debug = bdebug ;
1880	}
1881
1882	static int yy_init_globals (void)
1883	{
1884	/* Initialization is the same as for the non-reentrant scanner.
1885	* This function is called from yylex_destroy(), so don't allocate here.
1886	*/
1887
1888	(yy_buffer_stack) = 0;
1889	(yy_buffer_stack_top) = 0;
1890	(yy_buffer_stack_max) = 0;
1891	(yy_c_buf_p) = (char *) 0;
1892	(yy_init) = 0;
1893	(yy_start) = 0;
1894
1895	/* Defined in main.c */
1896	#ifdef YY_STDINIT
1897	yyin = stdin;
1898	yyout = stdout;
1899	#else
1900	yyin = (FILE *) 0;
1901	yyout = (FILE *) 0;
1902	#endif
1903
1904	/* For future reference: Set errno on error, since we are called by
1905	* yylex_init()
1906	*/
1907	return 0;
1908	}
1909
1910	/* yylex_destroy is for both reentrant and non-reentrant scanners. */
1911	int yylex_destroy (void)
1912	{	1811	{
1913		1812
1914	/* Pop the buffer stack, destroying each element. */	1813	/* Pop the buffer stack, destroying each element. */
1915	while(YY_CURRENT_BUFFER){	1814	while(YY_CURRENT_BUFFER){
1916	yy_delete_buffer(YY_CURRENT_BUFFER );	1815	yy_delete_buffer( YY_CURRENT_BUFFER );
1917	YY_CURRENT_BUFFER_LVALUE = NULL;	1816	YY_CURRENT_BUFFER_LVALUE = NULL;
1918	yypop_buffer_state();	1817	yypop_buffer_state();
1919	}	1818	}
Lines 1922-1932 Link Here
1922	yyfree((yy_buffer_stack) );	1821	yyfree((yy_buffer_stack) );
1923	(yy_buffer_stack) = NULL;	1822	(yy_buffer_stack) = NULL;
1924		1823
1925	/* Reset the globals. This is important in a non-reentrant scanner so the next time	1824	delete [] (yy_state_buf);
1926	* yylex() is called, initialization will occur. */	1825	yyfree((yy_start_stack) );
1927	yy_init_globals( );
1928		1826
1929	return 0;
1930	}	1827	}
1931		1828
1932	/*	1829	/*
Lines 1977-1983 Link Here
1977		1874
1978	#define YYTABLES_NAME "yytables"	1875	#define YYTABLES_NAME "yytables"
1979		1876
1980	#line 123 "qmake.ll"	1877	#line 201 "qmake.ll"
		1878
		1879
		1880	namespace QMake
		1881	{
		1882	Lexer::Lexer( std::istream* argin, std::ostream* argout )
		1883	: yyFlexLexer(argin, argout), mylval(0)
		1884	{
		1885	}
1981		1886
		1887	int Lexer::yylex( QMake::Parser::semantic_type* yylval )
		1888	{
		1889	mylval = yylval;
		1890	return yylex();
		1891	}
		1892	}
		1893
		1894	int QMakelex( QMake::Parser::semantic_type* yylval, QMake::Lexer* lexer)
		1895	{
		1896	return lexer->yylex( yylval );
		1897	}
1982		1898
1983		1899




/* KDevelop QMake Support
 *
 * Copyright 2007 Andreas Pakulat <apaku@gmx.de>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#ifndef QMAKE_LEX_H
#define QMAKE_LEX_H

#include "qmake_yacc.hpp"
#include <iostream>

#ifndef DONT_INCLUDE_FLEXLEXER
#include "FlexLexer.h"
#endif

namespace QMake
{
    class Lexer : public yyFlexLexer
    {
        public:
            Lexer( std::istream* argin = 0, std::ostream* argout = 0 );
            int yylex( QMake::Parser::semantic_type* yylval );
            int yylex();
        private:
            QMake::Parser::semantic_type* mylval;
    };
}

#endif

// kate: space-indent on; indent-width 4; tab-width: 4; replace-tabs on; auto-insert-doxygen on

Lines 19-27 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/qmake.ll (-36 / +133 lines)
19	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *	19	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
20	***************************************************************************/	20	***************************************************************************/
21		21
22	#include <qmake_yacc.h>
23	#include <stdlib.h>	22	#include <stdlib.h>
24		23
		24	#define DONT_INCLUDE_FLEXLEXER
		25
		26	#include "qmake_lex.h"
		27
25	/**	28	/**
26	@file qmake.ll	29	@file qmake.ll
27	QMake Lexer	30	QMake Lexer
Lines 48-53 Link Here
48	%}	51	%}
49		52
50	%option noyywrap	53	%option noyywrap
		54	%option yylineno
		55	%option c++
		56	%option yyclass="QMake::Lexer"
51		57
52	%x list	58	%x list
53	%x list_with_comment	59	%x list_with_comment
Lines 55-123 Link Here
55		61
56	delim [ \t]	62	delim [ \t]
57	ws {delim}+	63	ws {delim}+
58	begin_ws ^{delim}+[^\n\t ]	64	begin_ws ^{delim}+[^\r\n\t ]
59	quote "\""	65	quote "\""
60	var_value [^\n\t ]*[^\n\t \\]	66	var_value [^\r\n\t ]*[^\r\n\t \\]
61	quoted_var_value {quote}({var_value}\|[\t ])({var_value}\|[\t ])*{quote}	67	quoted_var_value {quote}({var_value}\|[\t ])({var_value}\|[\t ])*{quote}
62	letter [A-Za-z]	68	letter [A-Za-z]
63	digit [0-9]	69	digit [0-9]
64	id_simple ({digit}\|{letter}\|\!\|-\|_\|\\|\$)({letter}\|{digit}\|\\|\|\!\|-\|_\|\\|\$\|\.\|\+\|\-)*	70	id_simple ({digit}\|{letter}\|\!\|-\|_\|\\|\$)({letter}\|{digit}\|\\|\|\!\|-\|_\|\\|\$\|\.)*
65	id_args [^\n]*\)	71	id_args [^\r\n]*\)
66	number {digit}+	72	number {digit}+
67	comment #.*	73	comment #.*
68	comment_cont {ws}#.\n	74	comment_cont {ws}#.(\n\|\r\|\r\n)
69	comment_cont_nn {ws}#.	75	comment_cont_nn {ws}#.
70	cont \\{ws}*\n	76	cont \\{ws}*(\n\|\r\|\r\n)
71		77
72	%%	78	%%
73	<INITIAL>{ws} {}	79	<INITIAL>{ws} {}
74	<list,list_with_comment>{ws} { yylval.value = yytext; return LIST_WS; }	80
		81	<list,list_with_comment>{ws} {
		82	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		83	return Parser::token::token::LIST_WS;
		84	}
		85
75	<list,list_with_comment>{begin_ws} {	86	<list,list_with_comment>{begin_ws} {
76	yylval.value = yytext;	87	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
77	unput(char(yylval.value.at(yylval.value.length()-1).latin1()));	88	unput(char(mylval->value.at(mylval->value.length()-1).latin1()));
78	yylval.value = yylval.value.mid(0, yylval.value.length()-1);	89	mylval->value = mylval->value.mid(0, mylval->value.length()-1);
79	return INDENT;	90	return Parser::token::token::INDENT;
80	}	91	}
81		92
82	<list,list_with_comment,INITIAL>{cont} { BEGIN(list); return CONT; }	93	<list,list_with_comment,INITIAL>{cont} {
83	{id_simple} { yylval.value = yytext; return (ID_SIMPLE); }	94	BEGIN(list);
		95	return Parser::token::token::CONT;
		96	}
		97	{id_simple} {
		98	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		99	return (Parser::token::token::ID_SIMPLE);
		100	}
84		101
85	<list_with_comment>{comment_cont_nn} {	102	<list_with_comment>{comment_cont_nn} {
86	yylval.value = yytext;	103	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
87	BEGIN(list);	104	BEGIN(list);
88	return (LIST_COMMENT_WITHOUT_NEWLINE);	105	return (Parser::token::token::LIST_COMMENT_WITHOUT_NEWLINE);
89	}	106	}
90		107
91	<list>{comment_cont} {	108	<list>{comment_cont} {
92	yylval.value = yytext;	109	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
93	BEGIN(list);	110	BEGIN(list);
94	return (LIST_COMMENT);	111	return (Parser::token::token::LIST_COMMENT);
95	}	112	}
96		113
97	<funcargs>{id_args} {	114	<funcargs>{id_args} {
98	yylval.value = yytext;	115	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
99	yylval.value = yylval.value.mid(0, yylval.value.length()-1);	116	mylval->value = mylval->value.mid(0, mylval->value.length()-1);
100	unput(')');	117	unput(')');
101	BEGIN(INITIAL);	118	BEGIN(INITIAL);
102	return (ID_ARGS);	119	return (Parser::token::token::ID_ARGS);
103	}	120	}
104		121
105	<list,list_with_comment>{var_value} { BEGIN(list_with_comment); yylval.value = yytext; return VARIABLE_VALUE; }	122	<list,list_with_comment>{var_value} {
106	<list,list_with_comment>{quoted_var_value} { BEGIN(list_with_comment); yylval.value = yytext; return QUOTED_VARIABLE_VALUE; }	123	BEGIN(list_with_comment);
		124	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		125	return Parser::token::token::VARIABLE_VALUE;
		126	}
		127
		128	<list,list_with_comment>{quoted_var_value} {
		129	BEGIN(list_with_comment);
		130	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		131	return Parser::token::token::QUOTED_VARIABLE_VALUE;
		132	}
		133
		134	"=" {
		135	BEGIN(list);
		136	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		137	return Parser::token::token::EQ;
		138	}
		139
		140	"+=" {
		141	BEGIN(list);
		142	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		143	return Parser::token::token::PLUSEQ;
		144	}
		145
		146	"-=" {
		147	BEGIN(list);
		148	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		149	return Parser::token::token::MINUSEQ;
		150	}
		151
		152	"*=" {
		153	BEGIN(list);
		154	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		155	return Parser::token::token::STAREQ;
		156	}
		157
		158	"~=" {
		159	BEGIN(list);
		160	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		161	return Parser::token::token::TILDEEQ;
		162	}
		163
		164	"{" {
		165	return Parser::token::token::LCURLY;
		166	}
		167
		168	":"{delim}*"{" {
		169	return Parser::token::token::LCURLY;
		170	}
		171
		172	"}" {
		173	return Parser::token::token::RCURLY;
		174	}
		175
		176	"(" {
		177	BEGIN(funcargs);
		178	return Parser::token::token::LBRACE;
		179	}
		180
		181	<funcargs,INITIAL>")" {
		182	BEGIN(INITIAL);
		183	return Parser::token::token::RBRACE;
		184	}
		185
		186	":" {
		187	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
188	return Parser::token::token::COLON;
189	}
107		190
108	"=" { BEGIN(list); yylval.value = yytext; return EQ; }	191	<list,list_with_comment,INITIAL>"\n" {
109	"+=" { BEGIN(list); yylval.value = yytext; return PLUSEQ; }	192	BEGIN(INITIAL);
110	"-=" { BEGIN(list); yylval.value = yytext; return MINUSQE; }	193	return Parser::token::token::NEWLINE;
111	"*=" { BEGIN(list); yylval.value = yytext; return STAREQ; }	194	}
112	"~=" { BEGIN(list); yylval.value = yytext; return TILDEEQ; }
113	"{" { return LCURLY; }
114	":"{delim}*"{" { return LCURLY; }
115	"}" { return RCURLY; }
116	"(" { BEGIN(funcargs); return LBRACE; }
117	<funcargs,INITIAL>")" { BEGIN(INITIAL); return RBRACE; }
118	":" { yylval.value = yytext; return COLON; }
119	<list,list_with_comment,INITIAL>"\n" { BEGIN(INITIAL); return NEWLINE; }
120		195
121	{comment} { yylval.value = yytext; return (COMMENT); }	196	{comment} {
		197	mylval->value = QString::fromLocal8Bit( YYText(), YYLeng() );
		198	return (Parser::token::token::COMMENT);
		199	}
122		200
123	%%	201	%%
		202	namespace QMake
		203	{
		204	Lexer::Lexer( std::istream* argin, std::ostream* argout )
		205	: yyFlexLexer(argin, argout), mylval(0)
		206	{
		207	}
		208
		209	int Lexer::yylex( QMake::Parser::semantic_type* yylval )
		210	{
		211	mylval = yylval;
		212	return yylex();
		213	}
		214	}
		215
		216	int QMakelex( QMake::Parser::semantic_type* yylval, QMake::Lexer* lexer)
		217	{
		218	return lexer->yylex( yylval );
		219	}
		220




/* A Bison parser, made by GNU Bison 2.3.  */

/* Skeleton implementation for Bison LALR(1) parsers in C++

   Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
   Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

// Take the name prefix into account.
#define yylex   QMakelex

#include "qmake_yacc.hpp"
   infringing on user name space.  This should be done even for local
   variables, as they might otherwise be expanded by user macros.
   There are some unavoidable exceptions within include files to
   define necessary library symbols; they are noted "INFRINGES ON
   USER NAME SPACE" below.  */

/* Identify Bison output.  */
#define YYBISON 1

/* Bison version.  */
#define YYBISON_VERSION "2.3"

/* Skeleton name.  */
#define YYSKELETON_NAME "yacc.c"

/* Pure parsers.  */
#define YYPURE 0

/* Using locations.  */
#define YYLSP_NEEDED 0

/* User implementation prologue.  */


/* Line 317 of lalr1.cc.  */
#line 45 "qmake_yacc.cpp"
# define YYTOKENTYPE
   /* Put the tokens into the symbol table, so that GDB and other debuggers
      know about them.  */
   enum yytokentype {
     ID_SIMPLE = 258,
     EQ = 259,
     PLUSEQ = 260,
     MINUSQE = 261,
     STAREQ = 262,
     TILDEEQ = 263,
     LBRACE = 264,
     RBRACE = 265,
     COLON = 266,
     NUMSIGN = 267,
     NEWLINE = 268,
     NUMBER = 269,
     COMMENT = 270,
     CONT = 271,
     RCURLY = 272,
     LCURLY = 273,
     ID_ARGS = 274,
     LIST_COMMENT = 275,
     LIST_COMMENT_WITHOUT_NEWLINE = 276,
     QUOTED_VARIABLE_VALUE = 277,
     VARIABLE_VALUE = 278,
     INDENT = 279,
     LIST_WS = 280
   };
#endif
/* Tokens.  */
#define ID_SIMPLE 258
#define EQ 259
#define PLUSEQ 260
#define MINUSQE 261
#define STAREQ 262
#define TILDEEQ 263
#define LBRACE 264
#define RBRACE 265
#define COLON 266
#define NUMSIGN 267
#define NEWLINE 268
#define NUMBER 269
#define COMMENT 270
#define CONT 271
#define RCURLY 272
#define LCURLY 273
#define ID_ARGS 274
#define LIST_COMMENT 275
#define LIST_COMMENT_WITHOUT_NEWLINE 276
#define QUOTED_VARIABLE_VALUE 277
#define VARIABLE_VALUE 278
#define INDENT 279
#define LIST_WS 280




/* Copy the first part of user declarations.  */
#line 1 "qmake.yy"

/***************************************************************************
 *   Copyright (C) 2005 by Alexander Dymo                                  *
 *   adymo@kdevelop.org                                                    *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library General Public License as       *
 *   published by the Free Software Foundation; either version 2 of the    *
 *   License, or (at your option) any later version.                       *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

/**
@file qmake.yy
QMake Parser

Simple LALR parser which builds the syntax tree (see @ref QMake::AST).

@todo Recognize comments after statements like:
SOURCES = foo #regognize me

@fixme Parser fails on files that do not end with a newline
@fixme 1 shift/reduce conflict in "line_body" rule
*/

#include <qvaluestack.h>
#include "qmakeast.h"
#include <qregexp.h>

#define YYSTYPE_IS_DECLARED

using namespace QMake;

/**
The yylval type.
*/
struct Result {
    Result(): node(0) {}

    /**Type of semantic value for simple grammar rules.*/
    QString value;
    /**Type of semantic value for grammar rules which are parts of AST.*/
    AST *node;
    /**Type of semantic value for "multiline_values" grammar rule.
    Each line of multiline value is stored as a string in the list.

    For example we have in .pro file:
    @code
    SOURCE = foo1.cpp \
        foo2.cpp \
        foo3.cpp foo4.cpp
    @endcode
    The string list will be populated with three strings:
    <pre>
    foo1.cpp
    foo2.cpp
    foo3.cpp foo4.cpp
    </pre>
    */
    QStringList values;
    QString indent;
};

typedef Result YYSTYPE;

void yyerror(const char *str) {
    printf("%s\n", str);
}

int yylex();

/**
The stack to store ProjectAST pointers when a new child
ProjectAST is created and filled with statements.

Parser creates root ProjectAST for a .pro file, pushes it onto the stack and starts
adding statements. Each statement is added as a child StatementAST to the ProjectAST
currently on the top in the stack.

When a scope or function scope statement is parsed, the child ProjectAST is created
and pushed onto the stack. Therefore all statements which belong to the scope
or function scope are added as childs to their direct parent (scope or function scope).
*/
QValueStack<ProjectAST*> projects;

/**
The current depth of AST node is stored here.
AST depth is important to know because automatic indentation can
be easily implemented (the parser itself looses all information
about indentation).
*/
int depth = 0;

/*
To debug this parser, put the line below into the next bison file section.
Don't forget to uncomment "yydebug = 1" line in qmakedriver.cpp.
%debug
*/


/* Enabling traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif

/* Enabling verbose error messages.  */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 0
#endif

/* Enabling the token table.  */
#ifndef YYTOKEN_TABLE
# define YYTOKEN_TABLE 0
#endif

#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef int YYSTYPE;
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
# define YYSTYPE_IS_TRIVIAL 1
#endif



/* Copy the second part of user declarations.  */


/* Line 216 of yacc.c.  */
#line 265 "qmake_yacc.cpp"

#ifdef short
# undef short
#endif

#ifdef YYTYPE_UINT8
typedef YYTYPE_UINT8 yytype_uint8;
#else
typedef unsigned char yytype_uint8;
#endif

#ifdef YYTYPE_INT8
typedef YYTYPE_INT8 yytype_int8;
#elif (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
typedef signed char yytype_int8;
#else
typedef short int yytype_int8;
#endif

#ifdef YYTYPE_UINT16
typedef YYTYPE_UINT16 yytype_uint16;
#else
typedef unsigned short int yytype_uint16;
#endif

#ifdef YYTYPE_INT16
typedef YYTYPE_INT16 yytype_int16;
#else
typedef short int yytype_int16;
#endif

#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
#  define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
#  define YYSIZE_T size_t
# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
#  define YYSIZE_T size_t
# else
#  define YYSIZE_T unsigned int
# endif
#endif

#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)

#ifndef YY_
# if YYENABLE_NLS
#  if ENABLE_NLS
#   include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
#   define YY_(msgid) dgettext ("bison-runtime", msgid)
#  endif
# endif
# ifndef YY_
#  define YY_(msgid) msgid
# endif
#endif

/* Suppress unused-variable warnings by "using" E.  */
#if ! defined lint || defined __GNUC__
# define YYUSE(e) ((void) (e))
#else
# define YYUSE(e) /* empty */
#endif

/* Identity function, used to suppress warnings about constant conditions.  */
#ifndef lint
# define YYID(n) (n)
#else
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static int
YYID (int i)
#else
static int
YYID (i)
    int i;
#endif
{
  return i;
}
#endif

#if ! defined yyoverflow || YYERROR_VERBOSE

/* The parser invokes alloca or malloc; define the necessary symbols.  */

# ifdef YYSTACK_USE_ALLOCA
#  if YYSTACK_USE_ALLOCA
#   ifdef __GNUC__
#    define YYSTACK_ALLOC __builtin_alloca
#   elif defined __BUILTIN_VA_ARG_INCR
#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
#   elif defined _AIX
#    define YYSTACK_ALLOC __alloca
#   elif defined _MSC_VER
#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
#    define alloca _alloca
#   else
#    define YYSTACK_ALLOC alloca
#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
#     ifndef _STDLIB_H
#      define _STDLIB_H 1
#     endif
#    endif
#   endif
#  endif
# endif

# ifdef YYSTACK_ALLOC
   /* Pacify GCC's `empty if-body' warning.  */
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
#  ifndef YYSTACK_ALLOC_MAXIMUM
    /* The OS might guarantee only one guard page at the bottom of the stack,
       and a page size can be as small as 4096 bytes.  So we cannot safely
       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
       to allow for a few compiler-allocated temporary stack slots.  */
#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
#  endif
# else
#  define YYSTACK_ALLOC YYMALLOC
#  define YYSTACK_FREE YYFREE
#  ifndef YYSTACK_ALLOC_MAXIMUM
#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
#  endif
#  if (defined __cplusplus && ! defined _STDLIB_H \
       && ! ((defined YYMALLOC || defined malloc) \
	     && (defined YYFREE || defined free)))
#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
#   ifndef _STDLIB_H
#    define _STDLIB_H 1
#   endif
#  endif
#  ifndef YYMALLOC
#   define YYMALLOC malloc
#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
#  ifndef YYFREE
#   define YYFREE free
#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
void free (void *); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
# endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */


#if (! defined yyoverflow \
     && (! defined __cplusplus \
	 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

/* A type that is properly aligned for any stack member.  */
union yyalloc
{
  yytype_int16 yyss;
  YYSTYPE yyvs;
  };

/* The size of the maximum gap between one aligned stack and the next.  */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)

/* The size of an array large to enough to hold all stacks, each with
   N elements.  */
# define YYSTACK_BYTES(N) \
     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
      + YYSTACK_GAP_MAXIMUM)

/* Copy COUNT objects from FROM to TO.  The source and destination do
   not overlap.  */
# ifndef YYCOPY
#  if defined __GNUC__ && 1 < __GNUC__
#   define YYCOPY(To, From, Count) \
      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
#  else
#   define YYCOPY(To, From, Count)		\
      do					\
	{					\
	  YYSIZE_T yyi;				\
	  for (yyi = 0; yyi < (Count); yyi++)	\
	    (To)[yyi] = (From)[yyi];		\
	}					\
      while (YYID (0))
#  endif
# endif

/* Relocate STACK from its old location to the new one.  The
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
   elements in the stack, and YYPTR gives the new location of the
   stack.  Advance YYPTR to a properly aligned location for the next
   stack.  */
# define YYSTACK_RELOCATE(Stack)					\
    do									\
      {									\
	YYSIZE_T yynewbytes;						\
	YYCOPY (&yyptr->Stack, Stack, yysize);				\
	Stack = &yyptr->Stack;						\
	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
	yyptr += yynewbytes / sizeof (*yyptr);				\
      }									\
    while (YYID (0))

#endif

/* YYFINAL -- State number of the termination state.  */
#define YYFINAL  3
/* YYLAST -- Last index in YYTABLE.  */
#define YYLAST   37

/* YYNTOKENS -- Number of terminals.  */
#define YYNTOKENS  27
/* YYNNTS -- Number of nonterminals.  */
#define YYNNTS  21
/* YYNRULES -- Number of rules.  */
#define YYNRULES  44
/* YYNRULES -- Number of states.  */
#define YYNSTATES  54

/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
#define YYUNDEFTOK  2
#define YYMAXUTOK   281

#define YYTRANSLATE(YYX)						\
  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
static const yytype_uint8 yytranslate[] =
{
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
      25,    26
};

#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
   YYRHS.  */
static const yytype_uint8 yyprhs[] =
{
       0,     0,     3,     4,     7,    10,    11,    13,    15,    17,
      19,    21,    25,    29,    30,    33,    35,    37,    39,    41,
      43,    45,    47,    49,    50,    52,    54,    56,    58,    60,
      62,    64,    65,    69,    70,    78,    80,    81,    85,    88,
      89,    90,    96,    97,   100
};

/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
static const yytype_int8 yyrhs[] =
{
      28,     0,    -1,    -1,    29,    30,    -1,    30,    31,    -1,
      -1,    32,    -1,    38,    -1,    40,    -1,    46,    -1,    47,
      -1,     3,    37,    33,    -1,    33,    34,    35,    -1,    -1,
      34,    36,    -1,    36,    -1,    16,    -1,    13,    -1,    25,
      -1,    24,    -1,    20,    -1,    10,    -1,    21,    -1,    -1,
      23,    -1,    22,    -1,     4,    -1,     5,    -1,     6,    -1,
       7,    -1,     8,    -1,    -1,     3,    39,    43,    -1,    -1,
       3,     9,    42,    10,    41,    43,    44,    -1,    19,    -1,
      -1,    18,    30,    17,    -1,    11,    31,    -1,    -1,    -1,
      26,    18,    45,    43,    17,    -1,    -1,    15,    13,    -1,
      13,    -1
};

/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
static const yytype_uint16 yyrline[] =
{
       0,   136,   136,   136,   143,   148,   151,   155,   159,   163,
     167,   173,   185,   193,   200,   201,   202,   203,   204,   205,
     211,   212,   215,   222,   227,   228,   231,   231,   231,   231,
     231,   235,   234,   249,   248,   273,   274,   277,   278,   283,
     287,   286,   300,   305,   313
};
#endif

#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
static const char *const yytname[] =
{
  "$end", "error", "$undefined", "ID_SIMPLE", "EQ", "PLUSEQ", "MINUSQE",
  "STAREQ", "TILDEEQ", "LBRACE", "RBRACE", "COLON", "NUMSIGN", "NEWLINE",
  "NUMBER", "COMMENT", "CONT", "RCURLY", "LCURLY", "ID_ARGS",
  "LIST_COMMENT", "LIST_COMMENT_WITHOUT_NEWLINE", "QUOTED_VARIABLE_VALUE",
  "VARIABLE_VALUE", "INDENT", "LIST_WS", "\"else\"", "$accept", "project",
  "@1", "statements", "statement", "variable_assignment",
  "multiline_values", "line_body", "opt_comment", "variable_value",
  "operator", "scope", "@2", "function_call", "@3", "function_args",
  "scope_body", "else_statement", "@4", "comment", "emptyline", 0
};
#endif

# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
   token YYLEX-NUM.  */
static const yytype_uint16 yytoknum[] =
{
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     275,   276,   277,   278,   279,   280,   281
};
# endif

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const yytype_uint8 yyr1[] =
{
       0,    27,    29,    28,    30,    30,    31,    31,    31,    31,
      31,    32,    33,    33,    34,    34,    34,    34,    34,    34,
      34,    34,    35,    35,    36,    36,    37,    37,    37,    37,
      37,    39,    38,    41,    40,    42,    42,    43,    43,    43,
      45,    44,    44,    46,    47
};

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
static const yytype_uint8 yyr2[] =
{
       0,     2,     0,     2,     2,     0,     1,     1,     1,     1,
       1,     3,     3,     0,     2,     1,     1,     1,     1,     1,
       1,     1,     1,     0,     1,     1,     1,     1,     1,     1,
       1,     0,     3,     0,     7,     1,     0,     3,     2,     0,
       0,     5,     0,     2,     1
};

/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
   means the default is an error.  */
static const yytype_uint8 yydefact[] =
{
       2,     0,     5,     1,     3,    31,    44,     0,     4,     6,
       7,     8,     9,    10,    26,    27,    28,    29,    30,    36,
      13,    39,    43,    35,     0,    11,     0,     5,    32,    33,
      21,    17,    16,    20,    25,    24,    19,    18,    23,    15,
      38,     0,    39,    22,    12,    14,    37,    42,     0,    34,
      40,    39,     0,    41
};

/* YYDEFGOTO[NTERM-NUM].  */
static const yytype_int8 yydefgoto[] =
{
      -1,     1,     2,     4,     8,     9,    25,    38,    44,    39,
      20,    10,    21,    11,    42,    24,    28,    49,    51,    12,
      13
};

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   STATE-NUM.  */
#define YYPACT_NINF -41
static const yytype_int8 yypact[] =
{
     -41,     1,   -41,   -41,     5,    18,   -41,    -9,   -41,   -41,
     -41,   -41,   -41,   -41,   -41,   -41,   -41,   -41,   -41,   -14,
     -41,    -2,   -41,   -41,    21,   -10,     5,   -41,   -41,   -41,
     -41,   -41,   -41,   -41,   -41,   -41,   -41,   -41,     7,   -41,
     -41,     4,    -2,   -41,   -41,   -41,   -41,     6,    15,   -41,
     -41,    -2,    17,   -41
};

/* YYPGOTO[NTERM-NUM].  */
static const yytype_int8 yypgoto[] =
{
     -41,   -41,   -41,     8,    10,   -41,   -41,   -41,   -41,    -1,
     -41,   -41,   -41,   -41,   -41,   -41,   -40,   -41,   -41,   -41,
     -41
};

/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
   positive, shift that token.  If negative, reduce the rule which
   number is the opposite.  If zero, do what YYDEFACT says.
   If YYTABLE_NINF, syntax error.  */
#define YYTABLE_NINF -1
static const yytype_uint8 yytable[] =
{
      30,     3,    47,    31,    22,    23,    32,     5,     5,    26,
      33,    52,    34,    35,    36,    37,    27,     6,     6,     7,
       7,    46,    14,    15,    16,    17,    18,    19,    43,    34,
      35,    29,    48,    50,    53,    41,    40,    45
};

static const yytype_uint8 yycheck[] =
{
      10,     0,    42,    13,    13,    19,    16,     3,     3,    11,
      20,    51,    22,    23,    24,    25,    18,    13,    13,    15,
      15,    17,     4,     5,     6,     7,     8,     9,    21,    22,
      23,    10,    26,    18,    17,    27,    26,    38
};

/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
   symbol of state STATE-NUM.  */
static const yytype_uint8 yystos[] =
{
       0,    28,    29,     0,    30,     3,    13,    15,    31,    32,
      38,    40,    46,    47,     4,     5,     6,     7,     8,     9,
      37,    39,    13,    19,    42,    33,    11,    18,    43,    10,
      10,    13,    16,    20,    22,    23,    24,    25,    34,    36,
      31,    30,    41,    21,    35,    36,    17,    43,    26,    44,
      18,    45,    43,    17
};

#define yyerrok		(yyerrstatus = 0)
#define yyclearin	(yychar = YYEMPTY)
#define YYEMPTY		(-2)
#define YYEOF		0

#define YYACCEPT	goto yyacceptlab
#define YYABORT		goto yyabortlab
#define YYERROR		goto yyerrorlab


/* Like YYERROR except do call yyerror.  This remains here temporarily
   to ease the transition to the new meaning of YYERROR, for GCC.
   Once GCC version 2 has supplanted version 1, this can go.  */

#define YYFAIL		goto yyerrlab

#define YYRECOVERING()  (!!yyerrstatus)

#define YYBACKUP(Token, Value)					\
do								\
  if (yychar == YYEMPTY && yylen == 1)				\
    {								\
      yychar = (Token);						\
      yylval = (Value);						\
      yytoken = YYTRANSLATE (yychar);				\
      YYPOPSTACK (1);						\
      goto yybackup;						\
    }								\
  else								\
    {								\
      yyerror (YY_("syntax error: cannot back up")); \
      YYERROR;							\
    }								\
while (YYID (0))


#define YYTERROR	1
#define YYERRCODE	256


/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
   If N is 0, then set CURRENT to the empty location which ends
   the previous symbol: RHS[0] (always defined).  */

#define YYRHSLOC(Rhs, K) ((Rhs)[K])
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)				\
    do									\
      if (YYID (N))                                                    \
	{								\
	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
	}								\
      else								\
	{								\
	  (Current).first_line   = (Current).last_line   =		\
	    YYRHSLOC (Rhs, 0).last_line;				\
	  (Current).first_column = (Current).last_column =		\
	    YYRHSLOC (Rhs, 0).last_column;				\
	}								\
    while (YYID (0))
#endif


/* YY_LOCATION_PRINT -- Print the location on the stream.
   This macro was not mandated originally: define only if we know
   we won't break user code: when these are the locations we know.  */

#ifndef YY_LOCATION_PRINT
# if YYLTYPE_IS_TRIVIAL
#  define YY_LOCATION_PRINT(File, Loc)			\
     fprintf (File, "%d.%d-%d.%d",			\
	      (Loc).first_line, (Loc).first_column,	\
	      (Loc).last_line,  (Loc).last_column)
# else
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif


/* YYLEX -- calling `yylex' with the right arguments.  */

#ifdef YYLEX_PARAM
# define YYLEX yylex (YYLEX_PARAM)
#else
# define YYLEX yylex ()
#endif

/* Enable debugging if requested.  */
#if YYDEBUG

# ifndef YYFPRINTF
#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
#  define YYFPRINTF fprintf
# endif

# define YYDPRINTF(Args)			\
do {						\
  if (yydebug)					\
    YYFPRINTF Args;				\
} while (YYID (0))

# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
do {									  \
  if (yydebug)								  \
    {									  \
      YYFPRINTF (stderr, "%s ", Title);					  \
      yy_symbol_print (stderr,						  \
		  Type, Value); \
      YYFPRINTF (stderr, "\n");						  \
    }									  \
} while (YYID (0))


/*--------------------------------.
| Print this symbol on YYOUTPUT.  |
`--------------------------------*/

/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
#else
static void
yy_symbol_value_print (yyoutput, yytype, yyvaluep)
    FILE *yyoutput;
    int yytype;
    YYSTYPE const * const yyvaluep;
#endif
{
  if (!yyvaluep)
    return;
# ifdef YYPRINT
  if (yytype < YYNTOKENS)
    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
# else
  YYUSE (yyoutput);
# endif
  switch (yytype)
    {
      default:
	break;
    }
}


/*--------------------------------.
| Print this symbol on YYOUTPUT.  |
`--------------------------------*/

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
#else
static void
yy_symbol_print (yyoutput, yytype, yyvaluep)
    FILE *yyoutput;
    int yytype;
    YYSTYPE const * const yyvaluep;
#endif
{
  if (yytype < YYNTOKENS)
    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
  else
    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);

  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
  YYFPRINTF (yyoutput, ")");
}

/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included).                                                   |
`------------------------------------------------------------------*/

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
#else
static void
yy_stack_print (bottom, top)
    yytype_int16 *bottom;
    yytype_int16 *top;
#endif
{
  YYFPRINTF (stderr, "Stack now");
  for (; bottom <= top; ++bottom)
    YYFPRINTF (stderr, " %d", *bottom);
  YYFPRINTF (stderr, "\n");
}

# define YY_STACK_PRINT(Bottom, Top)				\
do {								\
  if (yydebug)							\
    yy_stack_print ((Bottom), (Top));				\
} while (YYID (0))


/*------------------------------------------------.
| Report that the YYRULE is going to be reduced.  |
`------------------------------------------------*/

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
#else
static void
yy_reduce_print (yyvsp, yyrule)
    YYSTYPE *yyvsp;
    int yyrule;
#endif
{
  int yynrhs = yyr2[yyrule];
  int yyi;
  unsigned long int yylno = yyrline[yyrule];
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
	     yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      fprintf (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
		       &(yyvsp[(yyi + 1) - (yynrhs)])
		       		       );
      fprintf (stderr, "\n");
    }
}

# define YY_REDUCE_PRINT(Rule)		\
do {					\
  if (yydebug)				\
    yy_reduce_print (yyvsp, Rule); \
} while (YYID (0))

/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */


/* YYINITDEPTH -- initial size of the parser's stacks.  */
#ifndef	YYINITDEPTH
# define YYINITDEPTH 200
#endif

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif



#if YYERROR_VERBOSE

# ifndef yystrlen
#  if defined __GLIBC__ && defined _STRING_H
#   define yystrlen strlen
#  else
/* Return the length of YYSTR.  */
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static YYSIZE_T
yystrlen (const char *yystr)
#else
static YYSIZE_T
yystrlen (yystr)
    const char *yystr;
#endif
{
  YYSIZE_T yylen;
  for (yylen = 0; yystr[yylen]; yylen++)
    continue;
  return yylen;
}
#  endif
# endif

# ifndef yystpcpy
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
#   define yystpcpy stpcpy
#  else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
   YYDEST.  */
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static char *
yystpcpy (char *yydest, const char *yysrc)
#else
static char *
yystpcpy (yydest, yysrc)
    char *yydest;
    const char *yysrc;
#endif
{
  char *yyd = yydest;
  const char *yys = yysrc;

  while ((*yyd++ = *yys++) != '\0')
    continue;

  return yyd - 1;
}
#  endif
# endif

# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
   quotes and backslashes, so that it's suitable for yyerror.  The
   heuristic is that double-quoting is unnecessary unless the string
   contains an apostrophe, a comma, or backslash (other than
   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
   null, do not copy; instead, return the length of what the result
   would have been.  */
static YYSIZE_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      YYSIZE_T yyn = 0;
      char const *yyp = yystr;

      for (;;)
	switch (*++yyp)
	  {
	  case '\'':
	  case ',':
	    goto do_not_strip_quotes;

	  case '\\':
	    if (*++yyp != '\\')
	      goto do_not_strip_quotes;
	    /* Fall through.  */
	  default:
	    if (yyres)
	      yyres[yyn] = *yyp;
	    yyn++;
	    break;

	  case '"':
	    if (yyres)
	      yyres[yyn] = '\0';
	    return yyn;
	  }
    do_not_strip_quotes: ;
    }

  if (! yyres)
    return yystrlen (yystr);

  return yystpcpy (yyres, yystr) - yyres;
}
# endif

/* Copy into YYRESULT an error message about the unexpected token
   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
   including the terminating null byte.  If YYRESULT is null, do not
   copy anything; just return the number of bytes that would be
   copied.  As a special case, return 0 if an ordinary "syntax error"
   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
   size calculation.  */
static YYSIZE_T
yysyntax_error (char *yyresult, int yystate, int yychar)
{
  int yyn = yypact[yystate];

  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
    return 0;
  else
    {
      int yytype = YYTRANSLATE (yychar);
      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
      YYSIZE_T yysize = yysize0;
      YYSIZE_T yysize1;
      int yysize_overflow = 0;
      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
      int yyx;

# if 0
      /* This is so xgettext sees the translatable formats that are
	 constructed on the fly.  */
      YY_("syntax error, unexpected %s");
      YY_("syntax error, unexpected %s, expecting %s");
      YY_("syntax error, unexpected %s, expecting %s or %s");
      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
# endif
      char *yyfmt;
      char const *yyf;
      static char const yyunexpected[] = "syntax error, unexpected %s";
      static char const yyexpecting[] = ", expecting %s";
      static char const yyor[] = " or %s";
      char yyformat[sizeof yyunexpected
		    + sizeof yyexpecting - 1
		    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
		       * (sizeof yyor - 1))];
      char const *yyprefix = yyexpecting;

      /* Start YYX at -YYN if negative to avoid negative indexes in
	 YYCHECK.  */
      int yyxbegin = yyn < 0 ? -yyn : 0;

      /* Stay within bounds of both yycheck and yytname.  */
      int yychecklim = YYLAST - yyn + 1;
      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
      int yycount = 1;

      yyarg[0] = yytname[yytype];
      yyfmt = yystpcpy (yyformat, yyunexpected);

      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
	  {
	    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
	      {
		yycount = 1;
		yysize = yysize0;
		yyformat[sizeof yyunexpected - 1] = '\0';
		break;
	      }
	    yyarg[yycount++] = yytname[yyx];
	    yysize1 = yysize + yytnamerr (0, yytname[yyx]);
	    yysize_overflow |= (yysize1 < yysize);
	    yysize = yysize1;
	    yyfmt = yystpcpy (yyfmt, yyprefix);
	    yyprefix = yyor;
	  }

      yyf = YY_(yyformat);
      yysize1 = yysize + yystrlen (yyf);
      yysize_overflow |= (yysize1 < yysize);
      yysize = yysize1;

      if (yysize_overflow)
	return YYSIZE_MAXIMUM;

      if (yyresult)
	{
	  /* Avoid sprintf, as that infringes on the user's name space.
	     Don't have undefined behavior even if the translation
	     produced a string with the wrong number of "%s"s.  */
	  char *yyp = yyresult;
	  int yyi = 0;
	  while ((*yyp = *yyf) != '\0')
	    {
	      if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
		{
		  yyp += yytnamerr (yyp, yyarg[yyi++]);
		  yyf += 2;
		}
	      else
		{
		  yyp++;
		  yyf++;
		}
	    }
	}
      return yysize;
    }
}
#endif /* YYERROR_VERBOSE */


/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
#else
static void
yydestruct (yymsg, yytype, yyvaluep)
    const char *yymsg;
    int yytype;
    YYSTYPE *yyvaluep;
#endif
{
  YYUSE (yyvaluep);

  if (!yymsg)
    yymsg = "Deleting";
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

  switch (yytype)
    {

      default:
	break;
    }
}


/* Prevent warnings from -Wmissing-prototypes.  */

#ifdef YYPARSE_PARAM
#if defined __STDC__ || defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
#else
int yyparse ();
#endif
#else /* ! YYPARSE_PARAM */
#if defined __STDC__ || defined __cplusplus
int yyparse (void);
#else
int yyparse ();
#endif
#endif /* ! YYPARSE_PARAM */



/* The look-ahead symbol.  */
int yychar;

/* The semantic value of the look-ahead symbol.  */
YYSTYPE yylval;

/* Number of syntax errors so far.  */
int yynerrs;



/*----------.
| yyparse.  |
`----------*/

#ifdef YYPARSE_PARAM
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
int
yyparse (void *YYPARSE_PARAM)
#else
int
yyparse (YYPARSE_PARAM)
    void *YYPARSE_PARAM;
#endif
#else /* ! YYPARSE_PARAM */
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
int
yyparse (void)
#else
int
yyparse ()

#endif
#endif
{
  
  int yystate;
  int yyn;
  int yyresult;
  /* Number of tokens to shift before error messages enabled.  */
  int yyerrstatus;
  /* Look-ahead token as an internal (translated) token number.  */
  int yytoken = 0;
#if YYERROR_VERBOSE
  /* Buffer for error messages, and its allocated size.  */
  char yymsgbuf[128];
  char *yymsg = yymsgbuf;
  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif

/* Suppress unused-variable warnings by "using" E.  */
#define YYUSE(e) ((void) (e))
     `yyvs': related to semantic values,
     `yyls': related to locations.

     Refer to the stacks thru separate pointers, to allow yyoverflow
     to reallocate them elsewhere.  */

/* A pseudo ostream that takes yydebug_ into account.  */
# define YYCDEBUG							\
  for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false)	\
    (*yycdebug_)

/* Enable debugging if requested.  */
#if YYDEBUG
  YYSTYPE *yyvs = yyvsa;
  YYSTYPE *yyvsp;

# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
do {									  \
  if (yydebug_)						\
    {									  \
      *yycdebug_ << Title << ' ';			\
      yy_symbol_print_ ((Type), (Value), (Location));	\
      *yycdebug_ << std::endl;				\
    }									  \
} while (false)

# define YY_REDUCE_PRINT(Rule)		\
do {								\
  if (yydebug_)				\
    yy_reduce_print_ (Rule);		\
} while (false)

# define YY_STACK_PRINT()		\
do {					\
  if (yydebug_)				\
    yystack_print_ ();			\
} while (false)

#else /* !YYDEBUG */

# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_REDUCE_PRINT(Rule)
# define YY_STACK_PRINT()

#endif /* !YYDEBUG */

#define YYACCEPT	goto yyacceptlab
#define YYABORT		goto yyabortlab
#define YYERROR		goto yyerrorlab

namespace QMake
{
#if YYERROR_VERBOSE

  /* Return YYSTR after stripping away unnecessary quotes and
     backslashes, so that it's suitable for yyerror.  The heuristic is
     that double-quoting is unnecessary unless the string contains an
     apostrophe, a comma, or backslash (other than backslash-backslash).
     YYSTR is taken from yytname.  */
  std::string
  Parser::yytnamerr_ (const char *yystr)
  {
  if (*yystr == '"')
    {
        std::string yyr = "";
      char const *yyp = yystr;

      for (;;)
	switch (*++yyp)
	  {
	  case '\'':
	  case ',':
	    goto do_not_strip_quotes;

	  case '\\':
	    if (*++yyp != '\\')
	      goto do_not_strip_quotes;
	    /* Fall through.  */
	  default:
              yyr += *yyp;
	    break;

	  case '"':
              return yyr;
	  }
    do_not_strip_quotes: ;
    }

    return yystr;
  }
`------------------------------------------------------------*/
 yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed.  So pushing a state here evens the stacks.  */
  yyssp++;

#endif
  *yyssp = yystate;

  /// Build a parser object.
  Parser::Parser (QMake::Lexer* lexer_yyarg, QValueStack<ProjectAST*>& projects_yyarg, int depth_yyarg)
    : yydebug_ (false),
      yycdebug_ (&std::cerr),
      lexer (lexer_yyarg),
      projects (projects_yyarg),
      depth (depth_yyarg)
    {
  }
      YYSIZE_T yysize = yyssp - yyss + 1;

  Parser::~Parser ()
	      {
	      }
	   these so that the &'s don't force the real ones into
	   memory.  */
	YYSTYPE *yyvs1 = yyvs;
	yytype_int16 *yyss1 = yyss;


	/* Each stack pointer address is followed by the size of the
	   data in use in that stack, in bytes.  This used to be a
	   conditional around just the two extra args, but that might
	   be undefined if yyoverflow is a macro.  */
	yyoverflow (YY_("memory exhausted"),
		    &yyss1, yysize * sizeof (*yyssp),
		    &yyvs1, yysize * sizeof (*yyvsp),

		    &yystacksize);

	yyss = yyss1;
	yyvs = yyvs1;
      }
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
      goto yyexhaustedlab;
# else
      /* Extend the stack our own way.  */
      if (YYMAXDEPTH <= yystacksize)
	goto yyexhaustedlab;
      yystacksize *= 2;
      if (YYMAXDEPTH < yystacksize)
	yystacksize = YYMAXDEPTH;

#if YYDEBUG
  /*--------------------------------.
  | Print this symbol on YYOUTPUT.  |
  `--------------------------------*/

  inline void
  Parser::yy_symbol_value_print_ (int yytype,
			   const semantic_type* yyvaluep, const location_type* yylocationp)
		{
    YYUSE (yylocationp);
    YYUSE (yyvaluep);
    switch (yytype)
		{
         default:
	  break;
	}
    }


  void
  Parser::yy_symbol_print_ (int yytype,
			   const semantic_type* yyvaluep, const location_type* yylocationp)
  {
    *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
	       << ' ' << yytname_[yytype] << " ("
	       << *yylocationp << ": ";
    yy_symbol_value_print_ (yytype, yyvaluep, yylocationp);
    *yycdebug_ << ')';
  }
#endif /* ! YYDEBUG */

  void
  Parser::yydestruct_ (const char* yymsg,
			   int yytype, semantic_type* yyvaluep, location_type* yylocationp)
  {
    YYUSE (yylocationp);
    YYUSE (yymsg);
  YYUSE (yyvaluep);

  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

  switch (yytype)
    {

      default:
	break;
    }
  }

  void
  Parser::yypop_ (unsigned int n)
  {
    yystate_stack_.pop (n);
    yysemantic_stack_.pop (n);
    yylocation_stack_.pop (n);
  }

  std::ostream&
  Parser::debug_stream () const
  {
    return *yycdebug_;
  }

  void
  Parser::set_debug_stream (std::ostream& o)
  {
    yycdebug_ = &o;
  }


  Parser::debug_level_type
  Parser::debug_level () const
  {
    return yydebug_;
  }

  void
  Parser::set_debug_level (debug_level_type l)
  {
    yydebug_ = l;
  }


  int
  Parser::parse ()
  {
    /// Look-ahead and look-ahead in internal form.
    int yychar = yyempty_;
    int yytoken = 0;

    /* State.  */
    int yyn;
  int yylen = 0;
    int yystate = 0;

    /* Error handling.  */
    int yynerrs_ = 0;
    int yyerrstatus_ = 0;

    /// Semantic value of the look-ahead.
    semantic_type yylval;
    /// Location of the look-ahead.
    location_type yylloc;
    /// The locations where the error started and ended.
    location yyerror_range[2];

    /// $$.
    semantic_type yyval;
    /// @$.
    location_type yyloc;

    int yyresult;

    YYCDEBUG << "Starting parse" << std::endl;


    /* Initialize the stacks.  The initial state will be pushed in
       yynewstate, since the latter expects the semantical and the
       location values to have been already stored, initialize these
       stacks with a primary value.  */
    yystate_stack_ = state_stack_type (0);
    yysemantic_stack_ = semantic_stack_type (0);
    yylocation_stack_ = location_stack_type (0);
    yysemantic_stack_.push (yylval);
    yylocation_stack_.push (yylloc);

    /* New state.  */
  yynewstate:
    yystate_stack_.push (yystate);
    YYCDEBUG << "Entering state " << yystate << std::endl;
  goto yybackup;

    /* Backup.  */
  yybackup:
`-----------*/
yybackup:

  /* Do appropriate processing given the current state.  Read a
     look-ahead token if we need one and don't already have one.  */

  /* First try to decide what to do without reference to look-ahead token.  */
  yyn = yypact[yystate];
  if (yyn == YYPACT_NINF)
    goto yydefault;

    /* Try to take a decision without look-ahead.  */
    yyn = yypact_[yystate];
    if (yyn == yypact_ninf_)
      goto yydefault;

    /* Read a look-ahead token.  */
    if (yychar == yyempty_)
    {
	YYCDEBUG << "Reading a token: ";
	yychar = yylex (&yylval, lexer);
    }


    /* Convert token to internal form.  */
    if (yychar <= yyeof_)
    {
	yychar = yytoken = yyeof_;
	YYCDEBUG << "Now at end of input." << std::endl;
    }
  else
    {
	yytoken = yytranslate_ (yychar);
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    }

  /* If the proper action on seeing token YYTOKEN is to reduce or to
     detect an error, take that action.  */
  yyn += yytoken;
    if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
    goto yydefault;

    /* Reduce or error.  */
    yyn = yytable_[yyn];
  if (yyn <= 0)
    {
	if (yyn == 0 || yyn == yytable_ninf_)
	goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }

    /* Accept?  */
    if (yyn == yyfinal_)
      goto yyacceptlab;
  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (yyerrstatus)
    yyerrstatus--;

  /* Shift the look-ahead token.  */
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);

    /* Discard the token being shifted unless it is eof.  */
    if (yychar != yyeof_)
      yychar = yyempty_;

    yysemantic_stack_.push (yylval);
    yylocation_stack_.push (yylloc);

    /* Count tokens shifted since error; after three, turn off error
       status.  */
    if (yyerrstatus_)
      --yyerrstatus_;

    yystate = yyn;
    goto yynewstate;

  /*-----------------------------------------------------------.
  | yydefault -- do the default action for the current state.  |
  `-----------------------------------------------------------*/
  yydefault:
    yyn = yydefact_[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;

  /*-----------------------------.
  | yyreduce -- Do a reduction.  |
  `-----------------------------*/
  yyreduce:
    yylen = yyr2_[yyn];
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
       `$$ = $1'.  Otherwise, use the top of the stack.

     Otherwise, the following line sets YYVAL to garbage.
     This behavior is undocumented and Bison
       users should not rely upon it.  */
    if (yylen)
      yyval = yysemantic_stack_[yylen - 1];
    else
      yyval = yysemantic_stack_[0];

    {
      slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
      YYLLOC_DEFAULT (yyloc, slice, yylen);
    }
  YY_REDUCE_PRINT (yyn);
  switch (yyn)
    {
        case 2:
#line 147 "qmake.yy"
    {
        ProjectAST *projectAST = new ProjectAST();
        projects.push(projectAST);

    break;

  case 4:
#line 155 "qmake.yy"
    {
            projects.top()->addChildAST((yysemantic_stack_[(2) - (2)].node));
            (yysemantic_stack_[(2) - (2)].node)->setDepth(depth);
        ;}
    break;

  case 6:
#line 163 "qmake.yy"
    {
            (yyval.node) = (yysemantic_stack_[(1) - (1)].node);
        ;}
    break;

  case 7:
#line 167 "qmake.yy"
    {
            (yyval.node) = (yysemantic_stack_[(1) - (1)].node);
        ;}
    break;

  case 8:
#line 171 "qmake.yy"
    {
            (yyval.node) = (yysemantic_stack_[(1) - (1)].node);
        ;}
    break;

  case 9:
#line 175 "qmake.yy"
    {
            (yyval.node) = (yysemantic_stack_[(1) - (1)].node);
        ;}
    break;

  case 10:
#line 179 "qmake.yy"
    {
            (yyval.node) = new NewLineAST();
        ;}
    break;

  case 11:
#line 185 "qmake.yy"
    {
            AssignmentAST *node = new AssignmentAST();
            node->scopedID = (yysemantic_stack_[(3) - (1)].value);
            node->op = (yysemantic_stack_[(3) - (2)].value);
            node->values = (yysemantic_stack_[(3) - (3)].values);
            node->indent = (yysemantic_stack_[(3) - (3)].indent);
	        node->commentnode = (yysemantic_stack_[(3) - (3)].node);
            (yyval.node) = node;
        ;}
    break;

  case 12:
#line 197 "qmake.yy"
    {
            (yyval.values) += (yysemantic_stack_[(3) - (2)].values);
            if( (yysemantic_stack_[(3) - (2)].indent) != "" && (yyval.indent) == "" )
                (yyval.indent) = (yysemantic_stack_[(3) - (2)].indent);
            (yyval.node) = (yysemantic_stack_[(3) - (3)].node);
        ;}
    break;

  case 13:
#line 204 "qmake.yy"
    {
            (yyval.values).clear();
            (yyval.indent) = "";

    break;

  case 14:
#line 211 "qmake.yy"
    { (yyval.values).append( (yysemantic_stack_[(2) - (2)].value) ); ;}
    break;

  case 15:
#line 212 "qmake.yy"
    { (yyval.values).append( (yysemantic_stack_[(1) - (1)].value) ); ;}
    break;

  case 16:
#line 213 "qmake.yy"
    { (yyval.values).append("\\\n"); ;}
    break;

  case 17:
#line 214 "qmake.yy"
    { (yyval.values).append("\n"); ;}
    break;

  case 18:
#line 215 "qmake.yy"
    { (yyval.values).append((yysemantic_stack_[(1) - (1)].value)); ;}
    break;

  case 19:
#line 217 "qmake.yy"
    {
            (yyval.values).append((yysemantic_stack_[(1) - (1)].value));
            if( (yyval.indent) == "" && (yysemantic_stack_[(1) - (1)].value) != "" )
                (yyval.indent) = (yysemantic_stack_[(1) - (1)].value);
        ;}
    break;

  case 22:
#line 227 "qmake.yy"
    {
            CommentAST* node = new CommentAST();
            node->comment = (yysemantic_stack_[(1) - (1)].value) + "\n";
	        (yyval.node) = node;
        ;}
    break;

  case 23:
#line 233 "qmake.yy"
    {
            (yyval.node) = 0;
        ;}
    break;

  case 24:
#line 238 "qmake.yy"
    { (yyval.value) = (yysemantic_stack_[(1) - (1)].value); ;}
    break;

  case 25:
#line 239 "qmake.yy"
    { (yyval.value) = (yysemantic_stack_[(1) - (1)].value); ;}
    break;

  case 31:
#line 246 "qmake.yy"
    {
            ProjectAST *projectAST = new ProjectAST(ProjectAST::Scope);
            projects.push(projectAST);
            projects.top()->scopedID = (yysemantic_stack_[(1) - (1)].value);
            depth++;
        ;}
    break;

  case 32:
#line 253 "qmake.yy"
    {
            (yyval.node) = projects.pop();
            depth--;

    break;

  case 33:
#line 260 "qmake.yy"
    {
            ProjectAST *projectAST = new ProjectAST(ProjectAST::FunctionScope);
            projects.push(projectAST);
            projects.top()->scopedID = (yysemantic_stack_[(4) - (1)].value);
            projects.top()->args = (yysemantic_stack_[(4) - (3)].value);
            depth++;

            //qWarning("%s", $<value>1.ascii());
            if ((yysemantic_stack_[(4) - (1)].value).contains("include"))
            {
                IncludeAST *includeAST = new IncludeAST();
                includeAST->projectName = (yysemantic_stack_[(4) - (3)].value);
                projects.top()->addChildAST(includeAST);
                includeAST->setDepth(depth);
            }

    break;

  case 34:
#line 278 "qmake.yy"
    {
            (yyval.node) = projects.pop();
            depth--;

    break;

  case 35:
#line 284 "qmake.yy"
    { (yyval.value) = (yysemantic_stack_[(1) - (1)].value); ;}
    break;

  case 36:
#line 285 "qmake.yy"
    { (yyval.value) = ""; ;}
    break;

  case 38:
#line 290 "qmake.yy"
    {
            projects.top()->addChildAST((yysemantic_stack_[(2) - (2)].node));
            (yysemantic_stack_[(2) - (2)].node)->setDepth(depth);
        ;}
    break;

  case 40:
#line 298 "qmake.yy"
    {
            ProjectAST *projectAST = new ProjectAST(ProjectAST::FunctionScope);
            projects.push(projectAST);

    break;

  case 41:
#line 306 "qmake.yy"
    {
            (yyval.node) = projects.pop();
            depth--;

    break;

  case 42:
#line 311 "qmake.yy"
    {
            (yyval.node) = new ProjectAST();
        ;}
    break;

  case 43:
#line 317 "qmake.yy"
    {
            CommentAST *node = new CommentAST();
            node->comment = (yysemantic_stack_[(2) - (1)].value) + "\n";
            (yyval.node) = node;
        ;}
    break;


    /* Line 675 of lalr1.cc.  */
#line 635 "qmake_yacc.cpp"
      default: break;
    }
    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);

    yypop_ (yylen);
  yylen = 0;
    YY_STACK_PRINT ();

  *++yyvsp = yyval;


  /* Now `shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */

    yysemantic_stack_.push (yyval);
    yylocation_stack_.push (yyloc);

    /* Shift the result of the reduction.  */
    yyn = yyr1_[yyn];
    yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
    if (0 <= yystate && yystate <= yylast_
	&& yycheck_[yystate] == yystate_stack_[0])
      yystate = yytable_[yystate];
  else
      yystate = yydefgoto_[yyn - yyntokens_];

  goto yynewstate;

  /*------------------------------------.
  | yyerrlab -- here on detecting error |
  `------------------------------------*/
  yyerrlab:
yyerrlab:
  /* If not already recovering from an error, report this error.  */
    if (!yyerrstatus_)
    {
      ++yynerrs;
#if ! YYERROR_VERBOSE
      yyerror (YY_("syntax error"));
#else
      {
	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
	  {
	++yynerrs_;
	error (yylloc, yysyntax_error_ (yystate));
	      yyalloc = YYSTACK_ALLOC_MAXIMUM;
	    if (yymsg != yymsgbuf)
	      YYSTACK_FREE (yymsg);
	    yymsg = (char *) YYSTACK_ALLOC (yyalloc);
	    if (yymsg)
	      yymsg_alloc = yyalloc;
	    else
	      {
		yymsg = yymsgbuf;
		yymsg_alloc = sizeof yymsgbuf;
	      }
	  }

	if (0 < yysize && yysize <= yymsg_alloc)
	  {
	    (void) yysyntax_error (yymsg, yystate, yychar);
	    yyerror (yymsg);
	  }
	else
	  {
	    yyerror (YY_("syntax error"));
	    if (yysize != 0)
	      goto yyexhaustedlab;
	  }
      }
#endif
    }



    yyerror_range[0] = yylloc;
    if (yyerrstatus_ == 3)
    {
      /* If just tried and failed to reuse look-ahead token after an
	 error, discard it.  */

	if (yychar <= yyeof_)
	{
	  /* Return failure if at end of input.  */
	  if (yychar == yyeof_)
	    YYABORT;
	}
      else
	{
	    yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
	    yychar = yyempty_;
	  yychar = YYEMPTY;
	}
    }


  goto yyerrlab1;


  /*---------------------------------------------------.
  | yyerrorlab -- error raised explicitly by YYERROR.  |
  `---------------------------------------------------*/
  yyerrorlab:

  /* Pacify compilers like GCC when the user code never invokes
     YYERROR and the label yyerrorlab therefore never appears in user
     code.  */
    if (false)
     goto yyerrorlab;

    yyerror_range[0] = yylocation_stack_[yylen - 1];
  /* Do not reclaim the symbols of the rule which action triggered
     this YYERROR.  */
    yypop_ (yylen);
  yylen = 0;
    yystate = yystate_stack_[0];
  yystate = *yyssp;
  goto yyerrlab1;

  /*-------------------------------------------------------------.
  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
  `-------------------------------------------------------------*/
  yyerrlab1:
    yyerrstatus_ = 3;	/* Each real token shifted decrements this.  */
  yyerrstatus = 3;	/* Each real token shifted decrements this.  */

  for (;;)
    {
	yyn = yypact_[yystate];
	if (yyn != yypact_ninf_)
	{
	  yyn += yyterror_;
	  if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
	    {
	      yyn = yytable_[yyn];
	      if (0 < yyn)
		break;
	    }
	}

      /* Pop the current state because it cannot handle the error token.  */
	if (yystate_stack_.height () == 1)
	YYABORT;

	yyerror_range[0] = yylocation_stack_[0];
	yydestruct_ ("Error: popping",
		     yystos_[yystate],
		     &yysemantic_stack_[0], &yylocation_stack_[0]);
	yypop_ ();
	yystate = yystate_stack_[0];
	YY_STACK_PRINT ();
      }

    if (yyn == yyfinal_)
      goto yyacceptlab;
      YYPOPSTACK (1);
      yystate = *yyssp;
      YY_STACK_PRINT (yyss, yyssp);
    }

  if (yyn == YYFINAL)
    YYACCEPT;

  *++yyvsp = yylval;

    yyerror_range[1] = yylloc;
    // Using YYLLOC is tempting, but would change the location of
    // the look-ahead.  YYLOC is available though.
    YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
    yysemantic_stack_.push (yylval);
    yylocation_stack_.push (yyloc);

  /* Shift the error token.  */
    YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
		   &yysemantic_stack_[0], &yylocation_stack_[0]);

  yystate = yyn;
  goto yynewstate;

    /* Accept.  */
  yyacceptlab:
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;

    /* Abort.  */
  yyabortlab:
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;

  yyreturn:
    if (yychar != yyeof_ && yychar != yyempty_)
      yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
`-------------------------------------------------*/
yyexhaustedlab:
  yyerror (YY_("memory exhausted"));
  yyresult = 2;
  /* Fall through.  */
#endif

yyreturn:
  if (yychar != YYEOF && yychar != YYEMPTY)
     yydestruct ("Cleanup: discarding lookahead",
		 yytoken, &yylval);
  /* Do not reclaim the symbols of the rule which action triggered
     this YYABORT or YYACCEPT.  */
    yypop_ (yylen);
    while (yystate_stack_.height () != 1)
      {
	yydestruct_ ("Cleanup: popping",
		   yystos_[yystate_stack_[0]],
		   &yysemantic_stack_[0],
		   &yylocation_stack_[0]);
	yypop_ ();
      }

    return yyresult;
  }

  // Generate an error message.
  std::string
  Parser::yysyntax_error_ (int yystate)
  {
    std::string res;
    YYUSE (yystate);
#if YYERROR_VERBOSE
    int yyn = yypact_[yystate];
    if (yypact_ninf_ < yyn && yyn <= yylast_)
      {
	/* Start YYX at -YYN if negative to avoid negative indexes in
	   YYCHECK.  */
	int yyxbegin = yyn < 0 ? -yyn : 0;

	/* Stay within bounds of both yycheck and yytname.  */
	int yychecklim = yylast_ - yyn + 1;
	int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
	int count = 0;
	for (int x = yyxbegin; x < yyxend; ++x)
	  if (yycheck_[x + yyn] == x && x != yyterror_)
	    ++count;

	// FIXME: This method of building the message is not compatible
	// with internationalization.  It should work like yacc.c does it.
	// That is, first build a string that looks like this:
	// "syntax error, unexpected %s or %s or %s"
	// Then, invoke YY_ on this string.
	// Finally, use the string as a format to output
	// yytname_[tok], etc.
	// Until this gets fixed, this message appears in English only.
	res = "syntax error, unexpected ";
	res += yytnamerr_ (yytname_[tok]);
	if (count < 5)
	  {
	    count = 0;
	    for (int x = yyxbegin; x < yyxend; ++x)
	      if (yycheck_[x + yyn] == x && x != yyterror_)
		{
		  res += (!count++) ? ", expecting " : " or ";
		  res += yytnamerr_ (yytname_[x]);
		}
	  }
      }
    else
#endif
      res = YY_("syntax error");
    return res;
  }


  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
     STATE-NUM.  */
  const signed char Parser::yypact_ninf_ = -41;
  const signed char
  Parser::yypact_[] =
  {
       -41,     1,   -41,   -41,     5,    18,   -41,    -9,   -41,   -41,
     -41,   -41,   -41,   -41,   -41,   -41,   -41,   -41,   -41,   -14,
     -41,    -2,   -41,   -41,    21,   -10,     5,   -41,   -41,   -41,
     -41,   -41,   -41,   -41,   -41,   -41,   -41,   -41,     7,   -41,
     -41,     4,    -2,   -41,   -41,   -41,   -41,     6,    15,   -41,
     -41,    -2,    17,   -41
  };

  /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
     doesn't specify something else to do.  Zero means the default is an
     error.  */
  const unsigned char
  Parser::yydefact_[] =
  {
         2,     0,     5,     1,     3,    31,    44,     0,     4,     6,
       7,     8,     9,    10,    26,    27,    28,    29,    30,    36,
      13,    39,    43,    35,     0,    11,     0,     5,    32,    33,
      21,    17,    16,    20,    25,    24,    19,    18,    23,    15,
      38,     0,    39,    22,    12,    14,    37,    42,     0,    34,
      40,    39,     0,    41
  };

  /* YYPGOTO[NTERM-NUM].  */
  const signed char
  Parser::yypgoto_[] =
  {
       -41,   -41,   -41,     8,    10,   -41,   -41,   -41,   -41,    -1,
     -41,   -41,   -41,   -41,   -41,   -41,   -40,   -41,   -41,   -41,
     -41
  };

  /* YYDEFGOTO[NTERM-NUM].  */
  const signed char
  Parser::yydefgoto_[] =
  {
        -1,     1,     2,     4,     8,     9,    25,    38,    44,    39,
      20,    10,    21,    11,    42,    24,    28,    49,    51,    12,
      13
  };

  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
     positive, shift that token.  If negative, reduce the rule which
     number is the opposite.  If zero, do what YYDEFACT says.  */
  const signed char Parser::yytable_ninf_ = -1;
  const unsigned char
  Parser::yytable_[] =
  {
        30,     3,    47,    31,    22,    23,    32,     5,     5,    26,
      33,    52,    34,    35,    36,    37,    27,     6,     6,     7,
       7,    46,    14,    15,    16,    17,    18,    19,    43,    34,
      35,    29,    48,    50,    53,    41,    40,    45
  };

  /* YYCHECK.  */
  const unsigned char
  Parser::yycheck_[] =
  {
        10,     0,    42,    13,    13,    19,    16,     3,     3,    11,
      20,    51,    22,    23,    24,    25,    18,    13,    13,    15,
      15,    17,     4,     5,     6,     7,     8,     9,    21,    22,
      23,    10,    26,    18,    17,    27,    26,    38
  };

  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
     symbol of state STATE-NUM.  */
  const unsigned char
  Parser::yystos_[] =
  {
         0,    28,    29,     0,    30,     3,    13,    15,    31,    32,
      38,    40,    46,    47,     4,     5,     6,     7,     8,     9,
      37,    39,    13,    19,    42,    33,    11,    18,    43,    10,
      10,    13,    16,    20,    22,    23,    24,    25,    34,    36,
      31,    30,    41,    21,    35,    36,    17,    43,    26,    44,
      18,    45,    43,    17
  };

#if YYDEBUG
  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
     to YYLEX-NUM.  */
  const unsigned short int
  Parser::yytoken_number_[] =
  {
         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     275,   276,   277,   278,   279,   280,   281
  };
#endif

  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
  const unsigned char
  Parser::yyr1_[] =
  {
         0,    27,    29,    28,    30,    30,    31,    31,    31,    31,
      31,    32,    33,    33,    34,    34,    34,    34,    34,    34,
      34,    34,    35,    35,    36,    36,    37,    37,    37,    37,
      37,    39,    38,    41,    40,    42,    42,    43,    43,    43,
      45,    44,    44,    46,    47
  };

  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
  const unsigned char
  Parser::yyr2_[] =
  {
         0,     2,     0,     2,     2,     0,     1,     1,     1,     1,
       1,     3,     3,     0,     2,     1,     1,     1,     1,     1,
       1,     1,     1,     0,     1,     1,     1,     1,     1,     1,
       1,     0,     3,     0,     7,     1,     0,     3,     2,     0,
       0,     5,     0,     2,     1
  };

#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
     First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
  const char*
  const Parser::yytname_[] =
  {
    "$end", "error", "$undefined", "ID_SIMPLE", "EQ", "PLUSEQ", "MINUSEQ",
  "STAREQ", "TILDEEQ", "LBRACE", "RBRACE", "COLON", "NUMSIGN", "NEWLINE",
  "NUMBER", "COMMENT", "CONT", "RCURLY", "LCURLY", "ID_ARGS",
  "LIST_COMMENT", "LIST_COMMENT_WITHOUT_NEWLINE", "QUOTED_VARIABLE_VALUE",
  "VARIABLE_VALUE", "INDENT", "LIST_WS", "\"else\"", "$accept", "project",
  "@1", "statements", "statement", "variable_assignment",
  "multiline_values", "line_body", "opt_comment", "variable_value",
  "operator", "scope", "@2", "function_call", "@3", "function_args",
  "scope_body", "else_statement", "@4", "comment", "emptyline", 0
  };
#endif

#if YYDEBUG
  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
  const Parser::rhs_number_type
  Parser::yyrhs_[] =
  {
        28,     0,    -1,    -1,    29,    30,    -1,    30,    31,    -1,
      -1,    32,    -1,    38,    -1,    40,    -1,    46,    -1,    47,
      -1,     3,    37,    33,    -1,    33,    34,    35,    -1,    -1,
      34,    36,    -1,    36,    -1,    16,    -1,    13,    -1,    25,
      -1,    24,    -1,    20,    -1,    10,    -1,    21,    -1,    -1,
      23,    -1,    22,    -1,     4,    -1,     5,    -1,     6,    -1,
       7,    -1,     8,    -1,    -1,     3,    39,    43,    -1,    -1,
       3,     9,    42,    10,    41,    43,    44,    -1,    19,    -1,
      -1,    18,    30,    17,    -1,    11,    31,    -1,    -1,    -1,
      26,    18,    45,    43,    17,    -1,    -1,    15,    13,    -1,
      13,    -1
  };

  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
     YYRHS.  */
  const unsigned char
  Parser::yyprhs_[] =
  {
         0,     0,     3,     4,     7,    10,    11,    13,    15,    17,
      19,    21,    25,    29,    30,    33,    35,    37,    39,    41,
      43,    45,    47,    49,    50,    52,    54,    56,    58,    60,
      62,    64,    65,    69,    70,    78,    80,    81,    85,    88,
      89,    90,    96,    97,   100
  };

  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
  const unsigned short int
  Parser::yyrline_[] =
  {
         0,   147,   147,   147,   154,   159,   162,   166,   170,   174,
     178,   184,   196,   204,   211,   212,   213,   214,   215,   216,
     222,   223,   226,   233,   238,   239,   242,   242,   242,   242,
     242,   246,   245,   260,   259,   284,   285,   288,   289,   294,
     298,   297,   311,   316,   324
  };

  // Print the state stack on the debug stream.
  void
  Parser::yystack_print_ ()
  {
    *yycdebug_ << "Stack now";
    for (state_stack_type::const_iterator i = yystate_stack_.begin ();
	 i != yystate_stack_.end (); ++i)
      *yycdebug_ << ' ' << *i;
    *yycdebug_ << std::endl;
  }

  // Report on the debug stream that the rule \a yyrule is going to be reduced.
  void
  Parser::yy_reduce_print_ (int yyrule)
  {
    unsigned int yylno = yyrline_[yyrule];
    int yynrhs = yyr2_[yyrule];
    /* Print the symbols being reduced, and their result.  */
    *yycdebug_ << "Reducing stack by rule " << yyrule - 1
	       << " (line " << yylno << "), ";
    /* The symbols being reduced.  */
    for (int yyi = 0; yyi < yynrhs; yyi++)
      YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
		       yyrhs_[yyprhs_[yyrule] + yyi],
		       &(yysemantic_stack_[(yynrhs) - (yyi + 1)]),
		       &(yylocation_stack_[(yynrhs) - (yyi + 1)]));
  }
#endif // YYDEBUG

  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
  Parser::token_number_type
  Parser::yytranslate_ (int t)
  {
    static
    const token_number_type
    translate_table[] =
    {
           0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
      25,    26
    };
    if ((unsigned int) t <= yyuser_token_number_max_)
      return translate_table[t];
    else
      return yyundef_token_;
  }

  const int Parser::yyeof_ = 0;
  const int Parser::yylast_ = 37;
  const int Parser::yynnts_ = 21;
  const int Parser::yyempty_ = -2;
  const int Parser::yyfinal_ = 3;
  const int Parser::yyterror_ = 1;
  const int Parser::yyerrcode_ = 256;
  const int Parser::yyntokens_ = 27;

  const unsigned int Parser::yyuser_token_number_max_ = 281;
  const Parser::token_number_type Parser::yyundef_token_ = 2;

} // namespace QMake

#line 327 "qmake.yy"



namespace QMake
{
    void Parser::error(const location_type& /*l*/, const std::string& m)
    {
        std::cerr << m << std::endl;
    }
}





/* A Bison parser, made by GNU Bison 2.3.  */

/* Skeleton interface for Bison's Yacc-like parsers in C

   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* Tokens.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
   /* Put the tokens into the symbol table, so that GDB and other debuggers
      know about them.  */
   enum yytokentype {
     ID_SIMPLE = 258,
     EQ = 259,
     PLUSEQ = 260,
     MINUSQE = 261,
     STAREQ = 262,
     TILDEEQ = 263,
     LBRACE = 264,
     RBRACE = 265,
     COLON = 266,
     NUMSIGN = 267,
     NEWLINE = 268,
     NUMBER = 269,
     COMMENT = 270,
     CONT = 271,
     RCURLY = 272,
     LCURLY = 273,
     ID_ARGS = 274,
     LIST_COMMENT = 275,
     LIST_COMMENT_WITHOUT_NEWLINE = 276,
     QUOTED_VARIABLE_VALUE = 277,
     VARIABLE_VALUE = 278,
     INDENT = 279,
     LIST_WS = 280
   };
#endif
/* Tokens.  */
#define ID_SIMPLE 258
#define EQ 259
#define PLUSEQ 260
#define MINUSQE 261
#define STAREQ 262
#define TILDEEQ 263
#define LBRACE 264
#define RBRACE 265
#define COLON 266
#define NUMSIGN 267
#define NEWLINE 268
#define NUMBER 269
#define COMMENT 270
#define CONT 271
#define RCURLY 272
#define LCURLY 273
#define ID_ARGS 274
#define LIST_COMMENT 275
#define LIST_COMMENT_WITHOUT_NEWLINE 276
#define QUOTED_VARIABLE_VALUE 277
#define VARIABLE_VALUE 278
#define INDENT 279
#define LIST_WS 280




#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef int YYSTYPE;
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
# define YYSTYPE_IS_TRIVIAL 1
#endif

extern YYSTYPE yylval;





/* A Bison parser, made by GNU Bison 2.3.  */

/* Skeleton interface for Bison LALR(1) parsers in C++

   Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* C++ LALR(1) parser skeleton written by Akim Demaille.  */

#ifndef PARSER_HEADER_H
# define PARSER_HEADER_H

#include <string>
#include <iostream>
#include "stack.hh"

namespace QMake
{
  class position;
  class location;
}

/* First part of user declarations.  */
#line 1 "qmake.yy"

/***************************************************************************
 *   Copyright (C) 2005 by Alexander Dymo                                  *
 *   adymo@kdevelop.org                                                    *
 *   Copyright (C) 2006 by Andreas Pakulat                                 *
 *   apaku@gmx.de                                                          *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library General Public License as       *
 *   published by the Free Software Foundation; either version 2 of the    *
 *   License, or (at your option) any later version.                       *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

/**
@file qmake.yy
QMake Parser

Simple LALR parser which builds the syntax tree (see @ref QMake::AST).

@todo Recognize comments after statements like:
SOURCES = foo #regognize me

@fixme Parser fails on files that do not end with a newline
@fixme 1 shift/reduce conflict in "line_body" rule
*/

#include <qvaluestack.h>
#include "qmakeast.h"
#include <qregexp.h>

#define YYSTYPE_IS_DECLARED

namespace QMake
{
    class Lexer;

/**
The yylval type.
*/
struct Result {
    Result(): node(0) {}

    /**Type of semantic value for simple grammar rules.*/
    QString value;
    /**Type of semantic value for grammar rules which are parts of AST.*/
    AST *node;
    /**Type of semantic value for "multiline_values" grammar rule.
    Each line of multiline value is stored as a string in the list.

    For example we have in .pro file:
    @code
    SOURCE = foo1.cpp \
        foo2.cpp \
        foo3.cpp foo4.cpp
    @endcode
    The string list will be populated with three strings:
    <pre>
    foo1.cpp
    foo2.cpp
    foo3.cpp foo4.cpp
    </pre>
    */
    QStringList values;
    QString indent;
};

#define YYSTYPE Result
typedef Result YYSTYPE;
}

extern int QMakelex( QMake::Result* yylval, QMake::Lexer* lexer );

/**
The stack to store ProjectAST pointers when a new child
ProjectAST is created and filled with statements.

Parser creates root ProjectAST for a .pro file, pushes it onto the stack and starts
adding statements. Each statement is added as a child StatementAST to the ProjectAST
currently on the top in the stack.

When a scope or function scope statement is parsed, the child ProjectAST is created
and pushed onto the stack. Therefore all statements which belong to the scope
or function scope are added as childs to their direct parent (scope or function scope).
*/
//QValueStack<ProjectAST*> projects;

/**
The current depth of AST node is stored here.
AST depth is important to know because automatic indentation can
be easily implemented (the parser itself looses all information
about indentation).
*/
// int depth = 0;

/*
To debug this parser, put the line below into the next bison file section.
Don't forget to uncomment "yydebug = 1" line in qmakedriver.cpp.
%debug
*/


/* Line 35 of lalr1.cc.  */
#line 165 "qmake_yacc.hpp"

#include "location.hh"

/* Enabling traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif

/* Enabling verbose error messages.  */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 0
#endif

/* Enabling the token table.  */
#ifndef YYTOKEN_TABLE
# define YYTOKEN_TABLE 0
#endif

/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
   If N is 0, then set CURRENT to the empty location which ends
   the previous symbol: RHS[0] (always defined).  */

#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)		\
do {							\
  if (N)						\
    {							\
      (Current).begin = (Rhs)[1].begin;			\
      (Current).end   = (Rhs)[N].end;			\
    }							\
  else							\
    {							\
      (Current).begin = (Current).end = (Rhs)[0].end;	\
    }							\
} while (false)
#endif

namespace QMake
{

  /// A Bison parser.
  class Parser
  {
  public:
    /// Symbol semantic values.
#ifndef YYSTYPE
    typedef int semantic_type;
#else
    typedef YYSTYPE semantic_type;
#endif
    /// Symbol locations.
    typedef location location_type;
    /// Tokens.
    struct token
    {
      /* Tokens.  */
   enum yytokentype {
     ID_SIMPLE = 258,
     EQ = 259,
     PLUSEQ = 260,
     MINUSEQ = 261,
     STAREQ = 262,
     TILDEEQ = 263,
     LBRACE = 264,
     RBRACE = 265,
     COLON = 266,
     NUMSIGN = 267,
     NEWLINE = 268,
     NUMBER = 269,
     COMMENT = 270,
     CONT = 271,
     RCURLY = 272,
     LCURLY = 273,
     ID_ARGS = 274,
     LIST_COMMENT = 275,
     LIST_COMMENT_WITHOUT_NEWLINE = 276,
     QUOTED_VARIABLE_VALUE = 277,
     VARIABLE_VALUE = 278,
     INDENT = 279,
     LIST_WS = 280
   };

    };
    /// Token type.
    typedef token::yytokentype token_type;

    /// Build a parser object.
    Parser (QMake::Lexer* lexer_yyarg, QValueStack<ProjectAST*>& projects_yyarg, int depth_yyarg);
    virtual ~Parser ();

    /// Parse.
    /// \returns  0 iff parsing succeeded.
    virtual int parse ();

    /// The current debugging stream.
    std::ostream& debug_stream () const;
    /// Set the current debugging stream.
    void set_debug_stream (std::ostream &);

    /// Type for debugging levels.
    typedef int debug_level_type;
    /// The current debugging level.
    debug_level_type debug_level () const;
    /// Set the current debugging level.
    void set_debug_level (debug_level_type l);

  private:
    /// Report a syntax error.
    /// \param loc    where the syntax error is found.
    /// \param msg    a description of the syntax error.
    virtual void error (const location_type& loc, const std::string& msg);

    /// Generate an error message.
    /// \param state   the state where the error occurred.
    /// \param tok     the look-ahead token.
    virtual std::string yysyntax_error_ (int yystate);

#if YYDEBUG
    /// \brief Report a symbol value on the debug stream.
    /// \param yytype       The token type.
    /// \param yyvaluep     Its semantic value.
    /// \param yylocationp  Its location.
    virtual void yy_symbol_value_print_ (int yytype,
					 const semantic_type* yyvaluep,
					 const location_type* yylocationp);
    /// \brief Report a symbol on the debug stream.
    /// \param yytype       The token type.
    /// \param yyvaluep     Its semantic value.
    /// \param yylocationp  Its location.
    virtual void yy_symbol_print_ (int yytype,
				   const semantic_type* yyvaluep,
				   const location_type* yylocationp);
#endif /* ! YYDEBUG */


    /// State numbers.
    typedef int state_type;
    /// State stack type.
    typedef stack<state_type>    state_stack_type;
    /// Semantic value stack type.
    typedef stack<semantic_type> semantic_stack_type;
    /// location stack type.
    typedef stack<location_type> location_stack_type;

    /// The state stack.
    state_stack_type yystate_stack_;
    /// The semantic value stack.
    semantic_stack_type yysemantic_stack_;
    /// The location stack.
    location_stack_type yylocation_stack_;

    /// Internal symbol numbers.
    typedef unsigned char token_number_type;
    /* Tables.  */
    /// For a state, the index in \a yytable_ of its portion.
    static const signed char yypact_[];
    static const signed char yypact_ninf_;

    /// For a state, default rule to reduce.
    /// Unless\a  yytable_ specifies something else to do.
    /// Zero means the default is an error.
    static const unsigned char yydefact_[];

    static const signed char yypgoto_[];
    static const signed char yydefgoto_[];

    /// What to do in a state.
    /// \a yytable_[yypact_[s]]: what to do in state \a s.
    /// - if positive, shift that token.
    /// - if negative, reduce the rule which number is the opposite.
    /// - if zero, do what YYDEFACT says.
    static const unsigned char yytable_[];
    static const signed char yytable_ninf_;

    static const unsigned char yycheck_[];

    /// For a state, its accessing symbol.
    static const unsigned char yystos_[];

    /// For a rule, its LHS.
    static const unsigned char yyr1_[];
    /// For a rule, its RHS length.
    static const unsigned char yyr2_[];

#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
    /// For a symbol, its name in clear.
    static const char* const yytname_[];
#endif

#if YYERROR_VERBOSE
    /// Convert the symbol name \a n to a form suitable for a diagnostic.
    virtual std::string yytnamerr_ (const char *n);
#endif

#if YYDEBUG
    /// A type to store symbol numbers and -1.
    typedef signed char rhs_number_type;
    /// A `-1'-separated list of the rules' RHS.
    static const rhs_number_type yyrhs_[];
    /// For each rule, the index of the first RHS symbol in \a yyrhs_.
    static const unsigned char yyprhs_[];
    /// For each rule, its source line number.
    static const unsigned short int yyrline_[];
    /// For each scanner token number, its symbol number.
    static const unsigned short int yytoken_number_[];
    /// Report on the debug stream that the rule \a r is going to be reduced.
    virtual void yy_reduce_print_ (int r);
    /// Print the state stack on the debug stream.
    virtual void yystack_print_ ();
#endif

    /// Convert a scanner token number \a t to a symbol number.
    token_number_type yytranslate_ (int t);

    /// \brief Reclaim the memory associated to a symbol.
    /// \param yymsg        Why this token is reclaimed.
    /// \param yytype       The symbol type.
    /// \param yyvaluep     Its semantic value.
    /// \param yylocationp  Its location.
    inline void yydestruct_ (const char* yymsg,
			     int yytype,
			     semantic_type* yyvaluep,
			     location_type* yylocationp);

    /// Pop \a n symbols the three stacks.
    inline void yypop_ (unsigned int n = 1);

    /* Constants.  */
    static const int yyeof_;
    /* LAST_ -- Last index in TABLE_.  */
    static const int yylast_;
    static const int yynnts_;
    static const int yyempty_;
    static const int yyfinal_;
    static const int yyterror_;
    static const int yyerrcode_;
    static const int yyntokens_;
    static const unsigned int yyuser_token_number_max_;
    static const token_number_type yyundef_token_;

    /* Debugging.  */
    int yydebug_;
    std::ostream* yycdebug_;


    /* User arguments.  */
    QMake::Lexer* lexer;
    QValueStack<ProjectAST*>& projects;
    int depth;
  };
}


#endif /* ! defined PARSER_HEADER_H */

Lines 2-7 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/qmake.yy (-10 / +28 lines)
2	/***************************************************************************	2	/***************************************************************************
3	* Copyright (C) 2005 by Alexander Dymo *	3	* Copyright (C) 2005 by Alexander Dymo *
4	* adymo@kdevelop.org *	4	* adymo@kdevelop.org *
		5	* Copyright (C) 2006 by Andreas Pakulat *
		6	* apaku@gmx.de *
5	* *	7	* *
6	* This program is free software; you can redistribute it and/or modify *	8	* This program is free software; you can redistribute it and/or modify *
7	* it under the terms of the GNU Library General Public License as *	9	* it under the terms of the GNU Library General Public License as *
Lines 38-44 Link Here
38		40
39	#define YYSTYPE_IS_DECLARED	41	#define YYSTYPE_IS_DECLARED
40		42
41	using namespace QMake;	43	namespace QMake
		44	{
		45	class Lexer;
42		46
43	/**	47	/**
44	The yylval type.	48	The yylval type.
Lines 70-82 Link Here
70	QString indent;	74	QString indent;
71	};	75	};
72		76
		77	#define YYSTYPE Result
73	typedef Result YYSTYPE;	78	typedef Result YYSTYPE;
74
75	void yyerror(const char *str) {
76	printf("%s\n", str);
77	}	79	}
78		80
79	int yylex();	81	extern int QMakelex( QMake::Result* yylval, QMake::Lexer* lexer );
80		82
81	/**	83	/**
82	The stack to store ProjectAST pointers when a new child	84	The stack to store ProjectAST pointers when a new child
Lines 90-96 Link Here
90	and pushed onto the stack. Therefore all statements which belong to the scope	92	and pushed onto the stack. Therefore all statements which belong to the scope
91	or function scope are added as childs to their direct parent (scope or function scope).	93	or function scope are added as childs to their direct parent (scope or function scope).
92	*/	94	*/
93	QValueStack<ProjectAST*> projects;	95	//QValueStack<ProjectAST*> projects;
94		96
95	/**	97	/**
96	The current depth of AST node is stored here.	98	The current depth of AST node is stored here.
Lines 98-104 Link Here
98	be easily implemented (the parser itself looses all information	100	be easily implemented (the parser itself looses all information
99	about indentation).	101	about indentation).
100	*/	102	*/
101	int depth = 0;	103	// int depth = 0;
102		104
103	/*	105	/*
104	To debug this parser, put the line below into the next bison file section.	106	To debug this parser, put the line below into the next bison file section.
Lines 107-116 Link Here
107	*/	109	*/
108	%}	110	%}
109		111
		112	%skeleton "lalr1.cc"
		113	%define "parser_class_name" "Parser"
		114	%name-prefix="QMake"
		115	%parse-param { QMake::Lexer* lexer }
		116	%parse-param { QValueStack<ProjectAST*>& projects }
		117	%parse-param { int depth }
		118	%lex-param { QMake::Lexer* lexer }
		119	%start project
		120
110	%token ID_SIMPLE	121	%token ID_SIMPLE
111	%token EQ	122	%token EQ
112	%token PLUSEQ	123	%token PLUSEQ
113	%token MINUSQE	124	%token MINUSEQ
114	%token STAREQ	125	%token STAREQ
115	%token TILDEEQ	126	%token TILDEEQ
116	%token LBRACE	127	%token LBRACE
Lines 228-234 Link Here
228	\| QUOTED_VARIABLE_VALUE { $<value>$ = $<value>1; }	239	\| QUOTED_VARIABLE_VALUE { $<value>$ = $<value>1; }
229	;	240	;
230		241
231	operator : EQ \| PLUSEQ \| MINUSQE \| STAREQ \| TILDEEQ	242	operator : EQ \| PLUSEQ \| MINUSEQ \| STAREQ \| TILDEEQ
232	;	243	;
233		244
234	scope : ID_SIMPLE	245	scope : ID_SIMPLE
Lines 315-318 Link Here
315		326
316	%%	327	%%
317		328
318	#include "qmake_lex.cpp"	329
		330	namespace QMake
		331	{
		332	void Parser::error(const location_type& /l/, const std::string& m)
		333	{
		334	std::cerr << m << std::endl;
		335	}
		336	}




/* A Bison parser, made by GNU Bison 2.3.  */

/* Stack handling for Bison parsers in C++

   Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

#ifndef BISON_STACK_HH
# define BISON_STACK_HH

#include <deque>

namespace QMake
{
  template <class T, class S = std::deque<T> >
  class stack
  {
  public:

    // Hide our reversed order.
    typedef typename S::reverse_iterator iterator;
    typedef typename S::const_reverse_iterator const_iterator;

    stack () : seq_ ()
    {
    }

    stack (unsigned int n) : seq_ (n)
    {
    }

    inline
    T&
    operator [] (unsigned int i)
    {
      return seq_[i];
    }

    inline
    const T&
    operator [] (unsigned int i) const
    {
      return seq_[i];
    }

    inline
    void
    push (const T& t)
    {
      seq_.push_front (t);
    }

    inline
    void
    pop (unsigned int n = 1)
    {
      for (; n; --n)
	seq_.pop_front ();
    }

    inline
    unsigned int
    height () const
    {
      return seq_.size ();
    }

    inline const_iterator begin () const { return seq_.rbegin (); }
    inline const_iterator end () const { return seq_.rend (); }

  private:

    S seq_;
  };

  /// Present a slice of the top of a stack.
  template <class T, class S = stack<T> >
  class slice
  {
  public:

    slice (const S& stack,
	   unsigned int range) : stack_ (stack),
				 range_ (range)
    {
    }

    inline
    const T&
    operator [] (unsigned int i) const
    {
      return stack_[range_ - i];
    }

  private:

    const S& stack_;
    unsigned int range_;
  };
}

#endif // not BISON_STACK_HH

Lines 17-26 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/tests/runner.cpp (-9 / +40 lines)
17	* Free Software Foundation, Inc., *	17	* Free Software Foundation, Inc., *
18	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *	18	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19	***************************************************************************/	19	***************************************************************************/
20	#include <qmakeast.h>	20
21	#include <qmakeastvisitor.h>	21	#include <cstdlib>
22	#include <qmakedriver.h>	22	#include <iostream>
		23	#include <stdio.h>
		24	#include "qmakedriver.h"
		25	#include "qmakeastvisitor.h"
		26
		27	#include <qstring.h>
		28
23	#include <kdebug.h>	29	#include <kdebug.h>
		30	#include <kcmdlineargs.h>
		31	#include <kurl.h>
		32
		33	static const KCmdLineOptions options[] =
		34	{
		35	{"silent", "Enable Parser debug output", 0},
		36	{"!debug", "Disable output of the generated AST", 0},
		37	{"!+files", "QMake project files", 0}
		38	};
		39
24		40
25	class PrintAST : QMake::ASTVisitor	41	class PrintAST : QMake::ASTVisitor
26	{	42	{
Lines 120-133 Link Here
120	};	136	};
121	int main(int argc, char *argv[])	137	int main(int argc, char *argv[])
122	{	138	{
123	QMake::ProjectAST *projectAST;	139	KCmdLineArgs::init( argc, argv, "QMake Parser", "qmake-parser", "Parse QMake project files", "1.0.0");
124	int ret;	140	KCmdLineArgs::addCmdLineOptions(options);
125	if (argc > 1)	141
		142	KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
		143
		144	if( args->count() < 1 )
		145	{
		146	KCmdLineArgs::usage(0);
		147	}
		148
		149	int debug = 0;
		150	bool silent = false;
		151
		152	if( args->isSet("silent") )
		153	silent = true;
		154	if( args->isSet("debug") )
		155	debug = 1;
		156	for( int i = 0 ; i < args->count() ; i++ )
126	{	157	{
127	ret = QMake::Driver::parseFile(argv[1], &projectAST);	158	QMake::ProjectAST *projectAST;
		159	int ret = QMake::Driver::parseFile(argv[1], &projectAST, debug);
128	PrintAST pa;	160	PrintAST pa;
129	if ( ret == 0 )	161	if ( ret == 0 )
130	if ((argc < 3) \|\| ((argc == 3) && (strcmp(argv[2], "--silent") != 0)))	162	if ( !silent )
131	{	163	{
132	pa.processProject(projectAST);	164	pa.processProject(projectAST);
133	QString profile;	165	QString profile;
Lines 136-141 Link Here
136	}	168	}
137	return ret;	169	return ret;
138	}	170	}
139	else
140	return 0;	171	return 0;
141	}	172	}

Lines 78-84 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/tests/viewer.cpp (-1 / +1 lines)
78	source->setText(str.read());	78	source->setText(str.read());
79	f.close();	79	f.close();
80		80
81	int result = QMake::Driver::parseFile(item->text().ascii(), &projectAST);	81	int result = QMake::Driver::parseFile(item->text().ascii(), &projectAST, 0);
82	if (projectAST && (result == 0))	82	if (projectAST && (result == 0))
83	{	83	{
84	processAST(projectAST);	84	processAST(projectAST);

Lines 147-153 Link Here

(-)kdevelop-3.4.0.orig/buildtools/qmake/scope.cpp (-1 / +1 lines)
147		147
148	bool Scope::loadFromFile( const QString& filename )	148	bool Scope::loadFromFile( const QString& filename )
149	{	149	{
150	if ( !QFileInfo(filename).exists() \|\| QMake::Driver::parseFile( filename, &m_root ) != 0 )	150	if ( !QFileInfo(filename).exists() \|\| QMake::Driver::parseFile( filename, &m_root, 0 ) != 0 )
151	{	151	{
152	kdDebug( 9024 ) << "Couldn't parse project: " << filename << endl;	152	kdDebug( 9024 ) << "Couldn't parse project: " << filename << endl;
153	m_root = 0;	153	m_root = 0;

Return to bug 165526

Line 0 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/FlexLexer.h (+205 lines)
		1
		2	// --C++--
		3	// FlexLexer.h -- define interfaces for lexical analyzer classes generated
		4	// by flex
		5
		6	// Copyright (c) 1993 The Regents of the University of California.
		7	// All rights reserved.
		8	//
		9	// This code is derived from software contributed to Berkeley by
		10	// Kent Williams and Tom Epperly.
		11	//
		12	// Redistribution and use in source and binary forms, with or without
		13	// modification, are permitted provided that the following conditions
		14	// are met:
		15
		16	// 1. Redistributions of source code must retain the above copyright
		17	// notice, this list of conditions and the following disclaimer.
		18	// 2. Redistributions in binary form must reproduce the above copyright
		19	// notice, this list of conditions and the following disclaimer in the
		20	// documentation and/or other materials provided with the distribution.
		21
		22	// Neither the name of the University nor the names of its contributors
		23	// may be used to endorse or promote products derived from this software
		24	// without specific prior written permission.
		25
		26	// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
		27	// IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
		28	// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		29	// PURPOSE.
		30
		31	// This file defines FlexLexer, an abstract class which specifies the
		32	// external interface provided to flex C++ lexer objects, and yyFlexLexer,
		33	// which defines a particular lexer class.
		34	//
		35	// If you want to create multiple lexer classes, you use the -P flag
		36	// to rename each yyFlexLexer to some other xxFlexLexer. You then
		37	// include <FlexLexer.h> in your other sources once per lexer class:
		38	//
		39	// #undef yyFlexLexer
		40	// #define yyFlexLexer xxFlexLexer
		41	// #include <FlexLexer.h>
		42	//
		43	// #undef yyFlexLexer
		44	// #define yyFlexLexer zzFlexLexer
		45	// #include <FlexLexer.h>
		46	// ...
		47
		48	#ifndef __FLEX_LEXER_H
		49	// Never included before - need to define base class.
		50	#define __FLEX_LEXER_H
		51
		52	#include <iostream>
		53	# ifndef FLEX_STD
		54	# define FLEX_STD std::
		55	# endif
		56
		57	extern "C++" {
		58
		59	struct yy_buffer_state;
		60	typedef int yy_state_type;
		61
		62	class FlexLexer {
		63	public:
		64	virtual ~FlexLexer() { }
65
66	const char* YYText() const { return yytext; }
67	int YYLeng() const { return yyleng; }
68
69	virtual void
70	yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
71	virtual struct yy_buffer_state*
72	yy_create_buffer( FLEX_STD istream* s, int size ) = 0;
73	virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
74	virtual void yyrestart( FLEX_STD istream* s ) = 0;
75
76	virtual int yylex() = 0;
77
78	// Call yylex with new input/output sources.
79	int yylex( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0 )
80	{
81	switch_streams( new_in, new_out );
82	return yylex();
83	}
84
85	// Switch to new input/output streams. A nil stream pointer
86	// indicates "keep the current one".
87	virtual void switch_streams( FLEX_STD istream* new_in = 0,
88	FLEX_STD ostream* new_out = 0 ) = 0;
89
90	int lineno() const { return yylineno; }
91
92	int debug() const { return yy_flex_debug; }
93	void set_debug( int flag ) { yy_flex_debug = flag; }
94
95	protected:
96	char* yytext;
97	int yyleng;
98	int yylineno; // only maintained if you use %option yylineno
99	int yy_flex_debug; // only has effect with -d or "%option debug"
100	};
101
102	}
103	#endif
104
105	#if defined(yyFlexLexer) \|\| ! defined(yyFlexLexerOnce)
106	// Either this is the first time through (yyFlexLexerOnce not defined),
107	// or this is a repeated include to define a different flavor of
108	// yyFlexLexer, as discussed in the flex man page.
109	#define yyFlexLexerOnce
110
111	extern "C++" {
112
113	class yyFlexLexer : public FlexLexer {
114	public:
115	// arg_yyin and arg_yyout default to the cin and cout, but we
116	// only make that assignment when initializing in yylex().
117	yyFlexLexer( FLEX_STD istream* arg_yyin = 0, FLEX_STD ostream* arg_yyout = 0 );
118
119	virtual ~yyFlexLexer();
120
121	void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
122	struct yy_buffer_state* yy_create_buffer( FLEX_STD istream* s, int size );
123	void yy_delete_buffer( struct yy_buffer_state* b );
124	void yyrestart( FLEX_STD istream* s );
125
126	void yypush_buffer_state( struct yy_buffer_state* new_buffer );
127	void yypop_buffer_state(void);
128
129	virtual int yylex();
130	virtual void switch_streams( FLEX_STD istream* new_in, FLEX_STD ostream* new_out );
131
132	protected:
133	virtual int LexerInput( char* buf, int max_size );
134	virtual void LexerOutput( const char* buf, int size );
135	virtual void LexerError( const char* msg );
136
137	void yyunput( int c, char* buf_ptr );
138	int yyinput();
139
140	void yy_load_buffer_state();
141	void yy_init_buffer( struct yy_buffer_state* b, FLEX_STD istream* s );
142	void yy_flush_buffer( struct yy_buffer_state* b );
143
144	int yy_start_stack_ptr;
145	int yy_start_stack_depth;
146	int* yy_start_stack;
147
148	void yy_push_state( int new_state );
149	void yy_pop_state();
150	int yy_top_state();
151
152	yy_state_type yy_get_previous_state();
153	yy_state_type yy_try_NUL_trans( yy_state_type current_state );
154	int yy_get_next_buffer();
155
156	FLEX_STD istream* yyin; // input source for default LexerInput
157	FLEX_STD ostream* yyout; // output sink for default LexerOutput
158
159	// yy_hold_char holds the character lost when yytext is formed.
160	char yy_hold_char;
161
162	// Number of characters read into yy_ch_buf.
163	int yy_n_chars;
164
165	// Points to current character in buffer.
166	char* yy_c_buf_p;
167
168	int yy_init; // whether we need to initialize
169	int yy_start; // start state number
170
171	// Flag which is used to allow yywrap()'s to do buffer switches
172	// instead of setting up a fresh yyin. A bit of a hack ...
173	int yy_did_buffer_switch_on_eof;
174
175
176	size_t yy_buffer_stack_top; /*< index of top of stack. /
177	size_t yy_buffer_stack_max; /*< capacity of stack. /
178	struct yy_buffer_state yy_buffer_stack; /< Stack as an array. */
179	void yyensure_buffer_stack(void);
180
181	// The following are not always needed, but may be depending
182	// on use of certain flex features (like REJECT or yymore()).
183
184	yy_state_type yy_last_accepting_state;
185	char* yy_last_accepting_cpos;
186
187	yy_state_type* yy_state_buf;
188	yy_state_type* yy_state_ptr;
189
190	char* yy_full_match;
191	int* yy_full_state;
192	int yy_full_lp;
193
194	int yy_lp;
195	int yy_looking_for_trail_begin;
196
197	int yy_more_flag;
198	int yy_more_len;
199	int yy_more_offset;
200	int yy_prev_more_offset;
201	};
202
203	}
204
205	#endif

Line 0 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/location.hh (+145 lines)
		1	/* A Bison parser, made by GNU Bison 2.3. */
		2
		3	/* Locations for Bison parsers in C++
		4
		5	Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
		6
		7	This program is free software; you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation; either version 2, or (at your option)
		10	any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 51 Franklin Street, Fifth Floor,
		20	Boston, MA 02110-1301, USA. */
		21
		22	/* As a special exception, you may create a larger work that contains
		23	part or all of the Bison parser skeleton and distribute that work
		24	under terms of your choice, so long as that work isn't itself a
		25	parser generator using the skeleton or a modified version thereof
		26	as a parser skeleton. Alternatively, if you modify or redistribute
		27	the parser skeleton itself, you may (at your option) remove this
		28	special exception, which will cause the skeleton and the resulting
		29	Bison output files to be licensed under the GNU General Public
		30	License without this special exception.
		31
		32	This special exception was added by the Free Software Foundation in
		33	version 2.2 of Bison. */
		34
		35	/**
		36	** \file location.hh
		37	** Define the QMake::location class.
		38	*/
		39
		40	#ifndef BISON_LOCATION_HH
		41	# define BISON_LOCATION_HH
		42
		43	# include <iostream>
		44	# include <string>
		45	# include "position.hh"
		46
		47	namespace QMake
		48	{
		49
		50	/// Abstract a location.
		51	class location
		52	{
		53	public:
		54
		55	/// Construct a location.
		56	location ()
		57	: begin (), end ()
		58	{
		59	}
		60
		61
		62	/// Initialization.
		63	inline void initialize (std::string* fn)
		64	{
65	begin.initialize (fn);
66	end = begin;
67	}
68
69	/** \name Line and Column related manipulators
70	** \{ */
71	public:
72	/// Reset initial location to final location.
73	inline void step ()
74	{
75	begin = end;
76	}
77
78	/// Extend the current location to the COUNT next columns.
79	inline void columns (unsigned int count = 1)
80	{
81	end += count;
82	}
83
84	/// Extend the current location to the COUNT next lines.
85	inline void lines (unsigned int count = 1)
86	{
87	end.lines (count);
88	}
89	/** \} */
90
91
92	public:
93	/// Beginning of the located region.
94	position begin;
95	/// End of the located region.
96	position end;
97	};
98
99	/// Join two location objects to create a location.
100	inline const location operator+ (const location& begin, const location& end)
101	{
102	location res = begin;
103	res.end = end.end;
104	return res;
105	}
106
107	/// Add two location objects.
108	inline const location operator+ (const location& begin, unsigned int width)
109	{
110	location res = begin;
111	res.columns (width);
112	return res;
113	}
114
115	/// Add and assign a location.
116	inline location& operator+= (location& res, unsigned int width)
117	{
118	res.columns (width);
119	return res;
120	}
121
122	/** \brief Intercept output stream redirection.
123	** \param ostr the destination output stream
124	** \param loc a reference to the location to redirect
125	**
126	** Avoid duplicate information.
127	*/
128	inline std::ostream& operator<< (std::ostream& ostr, const location& loc)
129	{
130	position last = loc.end - 1;
131	ostr << loc.begin;
132	if (last.filename
133	&& (!loc.begin.filename
134	\|\| loc.begin.filename != last.filename))
135	ostr << '-' << last;
136	else if (loc.begin.line != last.line)
137	ostr << '-' << last.line << '.' << last.column;
138	else if (loc.begin.column != last.column)
139	ostr << '-' << last.column;
140	return ostr;
141	}
142
143	}
144
145	#endif // not BISON_LOCATION_HH

Lines 10-31 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/Makefile.am (-6 / +5 lines)
10	METASOURCES = AUTO	10	METASOURCES = AUTO
11	lib_LTLIBRARIES = libkdevqmakeparser.la	11	lib_LTLIBRARIES = libkdevqmakeparser.la
12	libkdevqmakeparser_la_LDFLAGS = -no-undefined $(all_libraries) $(LIB_KIO)	12	libkdevqmakeparser_la_LDFLAGS = -no-undefined $(all_libraries) $(LIB_KIO)
13	libkdevqmakeparser_la_SOURCES = qmakeast.cpp qmakedriver.cpp qmake_yacc.cpp \	13	libkdevqmakeparser_la_SOURCES = qmake_lex.cpp qmake_yacc.cpp qmakeast.cpp \
14	qmakeastvisitor.cpp	14	qmakeastvisitor.cpp qmakedriver.cpp
15		15
16	kdevelopbuildtoolsincludedir = $(includedir)/kdevelop/buildtools/parsers/qmake	16	kdevelopbuildtoolsincludedir = $(includedir)/kdevelop/buildtools/parsers/qmake
17	kdevelopbuildtoolsinclude_HEADERS = qmakeast.h qmakedriver.h qmakeastvisitor.h	17	kdevelopbuildtoolsinclude_HEADERS = qmakeast.h qmakedriver.h qmakeastvisitor.h
18		18
19	parser:	19	parser:
20	cd $(srcdir) ; \	20	cd $(srcdir) ; \
21	bison -d qmake.yy -o qmake_yacc.cpp ; \	21	bison -d qmake.yy -oqmake_yacc.cpp ; \
22	mv -f qmake_yacc.hpp qmake_yacc.h ; \
23	flex -oqmake_lex.cpp qmake.ll	22	flex -oqmake_lex.cpp qmake.ll
24		23
25	parser_dbg:	24	parser_dbg:
26	cd $(srcdir) ; \	25	cd $(srcdir) ; \
27	bison -d qmake.yy -r all -k -t -o qmake_yacc.cpp ; \	26	bison -d qmake.yy -r all -k -t -oqmake_yacc.cpp ; \
28	mv -f qmake_yacc.hpp qmake_yacc.h ; \
29	flex -d -oqmake_lex.cpp qmake.ll	27	flex -d -oqmake_lex.cpp qmake.ll
30		28
31	EXTRA_DIST = qmake.yy qmake.ll	29	EXTRA_DIST = qmake.yy qmake.ll
Lines 35-37 Link Here
35	DOXYGEN_DOCDIRPREFIX = kdevparser	33	DOXYGEN_DOCDIRPREFIX = kdevparser
36	include ../../../../Doxyfile.am	34	include ../../../../Doxyfile.am
37		35
		36	noinst_HEADERS = qmake_lex.h

Line 0 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/position.hh (+142 lines)
		1	/* A Bison parser, made by GNU Bison 2.3. */
		2
		3	/* Positions for Bison parsers in C++
		4
		5	Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
		6
		7	This program is free software; you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation; either version 2, or (at your option)
		10	any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 51 Franklin Street, Fifth Floor,
		20	Boston, MA 02110-1301, USA. */
		21
		22	/* As a special exception, you may create a larger work that contains
		23	part or all of the Bison parser skeleton and distribute that work
		24	under terms of your choice, so long as that work isn't itself a
		25	parser generator using the skeleton or a modified version thereof
		26	as a parser skeleton. Alternatively, if you modify or redistribute
		27	the parser skeleton itself, you may (at your option) remove this
		28	special exception, which will cause the skeleton and the resulting
		29	Bison output files to be licensed under the GNU General Public
		30	License without this special exception.
		31
		32	This special exception was added by the Free Software Foundation in
		33	version 2.2 of Bison. */
		34
		35	/**
		36	** \file position.hh
		37	** Define the QMake::position class.
		38	*/
		39
		40	#ifndef BISON_POSITION_HH
		41	# define BISON_POSITION_HH
		42
		43	# include <iostream>
		44	# include <string>
		45
		46	namespace QMake
		47	{
		48	/// Abstract a position.
		49	class position
		50	{
		51	public:
		52
		53	/// Construct a position.
		54	position ()
		55	: filename (0), line (1), column (0)
		56	{
		57	}
		58
		59
		60	/// Initialization.
		61	inline void initialize (std::string* fn)
		62	{
		63	filename = fn;
		64	line = 1;
65	column = 0;
66	}
67
68	/** \name Line and Column related manipulators
69	** \{ */
70	public:
71	/// (line related) Advance to the COUNT next lines.
72	inline void lines (int count = 1)
73	{
74	column = 0;
75	line += count;
76	}
77
78	/// (column related) Advance to the COUNT next columns.
79	inline void columns (int count = 1)
80	{
81	int leftmost = 0;
82	int current = column;
83	if (leftmost <= current + count)
84	column += count;
85	else
86	column = 0;
87	}
88	/** \} */
89
90	public:
91	/// File name to which this position refers.
92	std::string* filename;
93	/// Current line number.
94	unsigned int line;
95	/// Current column number.
96	unsigned int column;
97	};
98
99	/// Add and assign a position.
100	inline const position&
101	operator+= (position& res, const int width)
102	{
103	res.columns (width);
104	return res;
105	}
106
107	/// Add two position objects.
108	inline const position
109	operator+ (const position& begin, const int width)
110	{
111	position res = begin;
112	return res += width;
113	}
114
115	/// Add and assign a position.
116	inline const position&
117	operator-= (position& res, const int width)
118	{
119	return res += -width;
120	}
121
122	/// Add two position objects.
123	inline const position
124	operator- (const position& begin, const int width)
125	{
126	return begin + -width;
127	}
128
129	/** \brief Intercept output stream redirection.
130	** \param ostr the destination output stream
131	** \param pos a reference to the position to redirect
132	*/
133	inline std::ostream&
134	operator<< (std::ostream& ostr, const position& pos)
135	{
136	if (pos.filename)
137	ostr << *pos.filename << ':';
138	return ostr << pos.line << '.' << pos.column;
139	}
140
141	}
142	#endif // not BISON_POSITION_HH

Lines 20-29 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/qmakedriver.h (-24 / +7 lines)
20	#ifndef QMAKEQMAKEDRIVER_H	20	#ifndef QMAKEQMAKEDRIVER_H
21	#define QMAKEQMAKEDRIVER_H	21	#define QMAKEQMAKEDRIVER_H
22		22
23	#include "qmakeast.h"	23	class QString;
24		24	class KURL;
25	#include <qvaluelist.h>
26	#include <kurl.h>
27		25
28	namespace QMake {	26	namespace QMake {
29		27
Lines 45-70 Link Here
45	initialize it on its own.	43	initialize it on its own.
46	@return The result of parsing. Result is 0 on success and <> 0 on failure.	44	@return The result of parsing. Result is 0 on success and <> 0 on failure.
47	*/	45	*/
48	static int parseFile(const char fileName, ProjectAST *ast);	46	static int parseFile(const char fileName, ProjectAST *ast, int debug);
49	static int parseFile(QString fileName, ProjectAST **ast);	47	static int parseFile(QString fileName, ProjectAST **ast, int debug);
50	static int parseFile(KURL fileName, ProjectAST **ast);	48	static int parseFile(KURL fileName, ProjectAST **ast, int debug);
51	static int parseString(const char* string, ProjectAST **ast);	49	static int parseString(const char* string, ProjectAST **ast, int debug);
52		50
53	/* template<class Op>
54	static void walkAST(Op &op, const ProjectAST *ast)
55	{
56	// op(ast);
57	for (QValueList<QMake::AST*>::const_iterator it = ast->statements.constBegin();
58	it != ast->statements.constEnd(); ++it)
59	{
60	const AST child = it;
61	if (child->nodeType() == AST::ProjectAST)
62	walkAST<Op>(op, static_cast<const QMake::ProjectAST*>(child));
63	else
64	op(child);
65	}
66	}
67	*/
68	};	51	};
69		52
70	}	53	}

Line 0 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/qmake_lex.h (+45 lines)
	1	/* KDevelop QMake Support
	2	*
	3	* Copyright 2007 Andreas Pakulat <apaku@gmx.de>
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License
	7	* as published by the Free Software Foundation; either version 2
	8	* of the License, or (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	18	* 02110-1301, USA.
	19	*/
	20	#ifndef QMAKE_LEX_H
	21	#define QMAKE_LEX_H
	22
	23	#include "qmake_yacc.hpp"
	24	#include <iostream>
	25
	26	#ifndef DONT_INCLUDE_FLEXLEXER
	27	#include "FlexLexer.h"
	28	#endif
	29
	30	namespace QMake
	31	{
	32	class Lexer : public yyFlexLexer
	33	{
	34	public:
	35	Lexer( std::istream* argin = 0, std::ostream* argout = 0 );
	36	int yylex( QMake::Parser::semantic_type* yylval );
	37	int yylex();
	38	private:
	39	QMake::Parser::semantic_type* mylval;
	40	};
	41	}
	42
	43	#endif
	44
	45	// kate: space-indent on; indent-width 4; tab-width: 4; replace-tabs on; auto-insert-doxygen on

Lines 1-103 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/qmake_yacc.h (-103 lines)
1	/* A Bison parser, made by GNU Bison 2.3. */
2
3	/* Skeleton interface for Bison's Yacc-like parsers in C
4
5	Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6	Free Software Foundation, Inc.
7
8	This program is free software; you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation; either version 2, or (at your option)
11	any later version.
12
13	This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.
17
18	You should have received a copy of the GNU General Public License
19	along with this program; if not, write to the Free Software
20	Foundation, Inc., 51 Franklin Street, Fifth Floor,
21	Boston, MA 02110-1301, USA. */
22
23	/* As a special exception, you may create a larger work that contains
24	part or all of the Bison parser skeleton and distribute that work
25	under terms of your choice, so long as that work isn't itself a
26	parser generator using the skeleton or a modified version thereof
27	as a parser skeleton. Alternatively, if you modify or redistribute
28	the parser skeleton itself, you may (at your option) remove this
29	special exception, which will cause the skeleton and the resulting
30	Bison output files to be licensed under the GNU General Public
31	License without this special exception.
32
33	This special exception was added by the Free Software Foundation in
34	version 2.2 of Bison. */
35
36	/* Tokens. */
37	#ifndef YYTOKENTYPE
38	# define YYTOKENTYPE
39	/* Put the tokens into the symbol table, so that GDB and other debuggers
40	know about them. */
41	enum yytokentype {
42	ID_SIMPLE = 258,
43	EQ = 259,
44	PLUSEQ = 260,
45	MINUSQE = 261,
46	STAREQ = 262,
47	TILDEEQ = 263,
48	LBRACE = 264,
49	RBRACE = 265,
50	COLON = 266,
51	NUMSIGN = 267,
52	NEWLINE = 268,
53	NUMBER = 269,
54	COMMENT = 270,
55	CONT = 271,
56	RCURLY = 272,
57	LCURLY = 273,
58	ID_ARGS = 274,
59	LIST_COMMENT = 275,
60	LIST_COMMENT_WITHOUT_NEWLINE = 276,
61	QUOTED_VARIABLE_VALUE = 277,
62	VARIABLE_VALUE = 278,
63	INDENT = 279,
64	LIST_WS = 280
65	};
66	#endif
67	/* Tokens. */
68	#define ID_SIMPLE 258
69	#define EQ 259
70	#define PLUSEQ 260
71	#define MINUSQE 261
72	#define STAREQ 262
73	#define TILDEEQ 263
74	#define LBRACE 264
75	#define RBRACE 265
76	#define COLON 266
77	#define NUMSIGN 267
78	#define NEWLINE 268
79	#define NUMBER 269
80	#define COMMENT 270
81	#define CONT 271
82	#define RCURLY 272
83	#define LCURLY 273
84	#define ID_ARGS 274
85	#define LIST_COMMENT 275
86	#define LIST_COMMENT_WITHOUT_NEWLINE 276
87	#define QUOTED_VARIABLE_VALUE 277
88	#define VARIABLE_VALUE 278
89	#define INDENT 279
90	#define LIST_WS 280
91
92
93
94
95	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
96	typedef int YYSTYPE;
97	# define yystype YYSTYPE /* obsolescent; will be withdrawn */
98	# define YYSTYPE_IS_DECLARED 1
99	# define YYSTYPE_IS_TRIVIAL 1
100	#endif
101
102	extern YYSTYPE yylval;
103

Line 0 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/qmake_yacc.hpp (+421 lines)
		1	/* A Bison parser, made by GNU Bison 2.3. */
		2
		3	/* Skeleton interface for Bison LALR(1) parsers in C++
		4
		5	Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
		6
		7	This program is free software; you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation; either version 2, or (at your option)
		10	any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 51 Franklin Street, Fifth Floor,
		20	Boston, MA 02110-1301, USA. */
		21
		22	/* As a special exception, you may create a larger work that contains
		23	part or all of the Bison parser skeleton and distribute that work
		24	under terms of your choice, so long as that work isn't itself a
		25	parser generator using the skeleton or a modified version thereof
		26	as a parser skeleton. Alternatively, if you modify or redistribute
		27	the parser skeleton itself, you may (at your option) remove this
		28	special exception, which will cause the skeleton and the resulting
		29	Bison output files to be licensed under the GNU General Public
		30	License without this special exception.
		31
		32	This special exception was added by the Free Software Foundation in
		33	version 2.2 of Bison. */
		34
		35	/* C++ LALR(1) parser skeleton written by Akim Demaille. */
		36
		37	#ifndef PARSER_HEADER_H
		38	# define PARSER_HEADER_H
		39
		40	#include <string>
		41	#include <iostream>
		42	#include "stack.hh"
		43
		44	namespace QMake
		45	{
		46	class position;
		47	class location;
		48	}
		49
		50	/* First part of user declarations. */
		51	#line 1 "qmake.yy"
		52
		53	/***************************************************************************
		54	* Copyright (C) 2005 by Alexander Dymo *
		55	* adymo@kdevelop.org *
		56	* Copyright (C) 2006 by Andreas Pakulat *
		57	* apaku@gmx.de *
		58	* *
		59	* This program is free software; you can redistribute it and/or modify *
		60	* it under the terms of the GNU Library General Public License as *
		61	* published by the Free Software Foundation; either version 2 of the *
		62	* License, or (at your option) any later version. *
		63	* *
		64	* This program is distributed in the hope that it will be useful, *
65	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
66	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
67	* GNU General Public License for more details. *
68	* *
69	* You should have received a copy of the GNU Library General Public *
70	* License along with this program; if not, write to the *
71	* Free Software Foundation, Inc., *
72	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
73	***************************************************************************/
74
75	/**
76	@file qmake.yy
77	QMake Parser
78
79	Simple LALR parser which builds the syntax tree (see @ref QMake::AST).
80
81	@todo Recognize comments after statements like:
82	SOURCES = foo #regognize me
83
84	@fixme Parser fails on files that do not end with a newline
85	@fixme 1 shift/reduce conflict in "line_body" rule
86	*/
87
88	#include <qvaluestack.h>
89	#include "qmakeast.h"
90	#include <qregexp.h>
91
92	#define YYSTYPE_IS_DECLARED
93
94	namespace QMake
95	{
96	class Lexer;
97
98	/**
99	The yylval type.
100	*/
101	struct Result {
102	Result(): node(0) {}
103
104	/*Type of semantic value for simple grammar rules./
105	QString value;
106	/*Type of semantic value for grammar rules which are parts of AST./
107	AST *node;
108	/**Type of semantic value for "multiline_values" grammar rule.
109	Each line of multiline value is stored as a string in the list.
110
111	For example we have in .pro file:
112	@code
113	SOURCE = foo1.cpp \
114	foo2.cpp \
115	foo3.cpp foo4.cpp
116	@endcode
117	The string list will be populated with three strings:
118	<pre>
119	foo1.cpp
120	foo2.cpp
121	foo3.cpp foo4.cpp
122	</pre>
123	*/
124	QStringList values;
125	QString indent;
126	};
127
128	#define YYSTYPE Result
129	typedef Result YYSTYPE;
130	}
131
132	extern int QMakelex( QMake::Result* yylval, QMake::Lexer* lexer );
133
134	/**
135	The stack to store ProjectAST pointers when a new child
136	ProjectAST is created and filled with statements.
137
138	Parser creates root ProjectAST for a .pro file, pushes it onto the stack and starts
139	adding statements. Each statement is added as a child StatementAST to the ProjectAST
140	currently on the top in the stack.
141
142	When a scope or function scope statement is parsed, the child ProjectAST is created
143	and pushed onto the stack. Therefore all statements which belong to the scope
144	or function scope are added as childs to their direct parent (scope or function scope).
145	*/
146	//QValueStack<ProjectAST*> projects;
147
148	/**
149	The current depth of AST node is stored here.
150	AST depth is important to know because automatic indentation can
151	be easily implemented (the parser itself looses all information
152	about indentation).
153	*/
154	// int depth = 0;
155
156	/*
157	To debug this parser, put the line below into the next bison file section.
158	Don't forget to uncomment "yydebug = 1" line in qmakedriver.cpp.
159	%debug
160	*/
161
162
163	/* Line 35 of lalr1.cc. */
164	#line 165 "qmake_yacc.hpp"
165
166	#include "location.hh"
167
168	/* Enabling traces. */
169	#ifndef YYDEBUG
170	# define YYDEBUG 0
171	#endif
172
173	/* Enabling verbose error messages. */
174	#ifdef YYERROR_VERBOSE
175	# undef YYERROR_VERBOSE
176	# define YYERROR_VERBOSE 1
177	#else
178	# define YYERROR_VERBOSE 0
179	#endif
180
181	/* Enabling the token table. */
182	#ifndef YYTOKEN_TABLE
183	# define YYTOKEN_TABLE 0
184	#endif
185
186	/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
187	If N is 0, then set CURRENT to the empty location which ends
188	the previous symbol: RHS[0] (always defined). */
189
190	#ifndef YYLLOC_DEFAULT
191	# define YYLLOC_DEFAULT(Current, Rhs, N) \
192	do { \
193	if (N) \
194	{ \
195	(Current).begin = (Rhs)[1].begin; \
196	(Current).end = (Rhs)[N].end; \
197	} \
198	else \
199	{ \
200	(Current).begin = (Current).end = (Rhs)[0].end; \
201	} \
202	} while (false)
203	#endif
204
205	namespace QMake
206	{
207
208	/// A Bison parser.
209	class Parser
210	{
211	public:
212	/// Symbol semantic values.
213	#ifndef YYSTYPE
214	typedef int semantic_type;
215	#else
216	typedef YYSTYPE semantic_type;
217	#endif
218	/// Symbol locations.
219	typedef location location_type;
220	/// Tokens.
221	struct token
222	{
223	/* Tokens. */
224	enum yytokentype {
225	ID_SIMPLE = 258,
226	EQ = 259,
227	PLUSEQ = 260,
228	MINUSEQ = 261,
229	STAREQ = 262,
230	TILDEEQ = 263,
231	LBRACE = 264,
232	RBRACE = 265,
233	COLON = 266,
234	NUMSIGN = 267,
235	NEWLINE = 268,
236	NUMBER = 269,
237	COMMENT = 270,
238	CONT = 271,
239	RCURLY = 272,
240	LCURLY = 273,
241	ID_ARGS = 274,
242	LIST_COMMENT = 275,
243	LIST_COMMENT_WITHOUT_NEWLINE = 276,
244	QUOTED_VARIABLE_VALUE = 277,
245	VARIABLE_VALUE = 278,
246	INDENT = 279,
247	LIST_WS = 280
248	};
249
250	};
251	/// Token type.
252	typedef token::yytokentype token_type;
253
254	/// Build a parser object.
255	Parser (QMake::Lexer* lexer_yyarg, QValueStack<ProjectAST*>& projects_yyarg, int depth_yyarg);
256	virtual ~Parser ();
257
258	/// Parse.
259	/// \returns 0 iff parsing succeeded.
260	virtual int parse ();
261
262	/// The current debugging stream.
263	std::ostream& debug_stream () const;
264	/// Set the current debugging stream.
265	void set_debug_stream (std::ostream &);
266
267	/// Type for debugging levels.
268	typedef int debug_level_type;
269	/// The current debugging level.
270	debug_level_type debug_level () const;
271	/// Set the current debugging level.
272	void set_debug_level (debug_level_type l);
273
274	private:
275	/// Report a syntax error.
276	/// \param loc where the syntax error is found.
277	/// \param msg a description of the syntax error.
278	virtual void error (const location_type& loc, const std::string& msg);
279
280	/// Generate an error message.
281	/// \param state the state where the error occurred.
282	/// \param tok the look-ahead token.
283	virtual std::string yysyntax_error_ (int yystate);
284
285	#if YYDEBUG
286	/// \brief Report a symbol value on the debug stream.
287	/// \param yytype The token type.
288	/// \param yyvaluep Its semantic value.
289	/// \param yylocationp Its location.
290	virtual void yy_symbol_value_print_ (int yytype,
291	const semantic_type* yyvaluep,
292	const location_type* yylocationp);
293	/// \brief Report a symbol on the debug stream.
294	/// \param yytype The token type.
295	/// \param yyvaluep Its semantic value.
296	/// \param yylocationp Its location.
297	virtual void yy_symbol_print_ (int yytype,
298	const semantic_type* yyvaluep,
299	const location_type* yylocationp);
300	#endif /* ! YYDEBUG */
301
302
303	/// State numbers.
304	typedef int state_type;
305	/// State stack type.
306	typedef stack<state_type> state_stack_type;
307	/// Semantic value stack type.
308	typedef stack<semantic_type> semantic_stack_type;
309	/// location stack type.
310	typedef stack<location_type> location_stack_type;
311
312	/// The state stack.
313	state_stack_type yystate_stack_;
314	/// The semantic value stack.
315	semantic_stack_type yysemantic_stack_;
316	/// The location stack.
317	location_stack_type yylocation_stack_;
318
319	/// Internal symbol numbers.
320	typedef unsigned char token_number_type;
321	/* Tables. */
322	/// For a state, the index in \a yytable_ of its portion.
323	static const signed char yypact_[];
324	static const signed char yypact_ninf_;
325
326	/// For a state, default rule to reduce.
327	/// Unless\a yytable_ specifies something else to do.
328	/// Zero means the default is an error.
329	static const unsigned char yydefact_[];
330
331	static const signed char yypgoto_[];
332	static const signed char yydefgoto_[];
333
334	/// What to do in a state.
335	/// \a yytable_[yypact_[s]]: what to do in state \a s.
336	/// - if positive, shift that token.
337	/// - if negative, reduce the rule which number is the opposite.
338	/// - if zero, do what YYDEFACT says.
339	static const unsigned char yytable_[];
340	static const signed char yytable_ninf_;
341
342	static const unsigned char yycheck_[];
343
344	/// For a state, its accessing symbol.
345	static const unsigned char yystos_[];
346
347	/// For a rule, its LHS.
348	static const unsigned char yyr1_[];
349	/// For a rule, its RHS length.
350	static const unsigned char yyr2_[];
351
352	#if YYDEBUG \|\| YYERROR_VERBOSE \|\| YYTOKEN_TABLE
353	/// For a symbol, its name in clear.
354	static const char* const yytname_[];
355	#endif
356
357	#if YYERROR_VERBOSE
358	/// Convert the symbol name \a n to a form suitable for a diagnostic.
359	virtual std::string yytnamerr_ (const char *n);
360	#endif
361
362	#if YYDEBUG
363	/// A type to store symbol numbers and -1.
364	typedef signed char rhs_number_type;
365	/// A `-1'-separated list of the rules' RHS.
366	static const rhs_number_type yyrhs_[];
367	/// For each rule, the index of the first RHS symbol in \a yyrhs_.
368	static const unsigned char yyprhs_[];
369	/// For each rule, its source line number.
370	static const unsigned short int yyrline_[];
371	/// For each scanner token number, its symbol number.
372	static const unsigned short int yytoken_number_[];
373	/// Report on the debug stream that the rule \a r is going to be reduced.
374	virtual void yy_reduce_print_ (int r);
375	/// Print the state stack on the debug stream.
376	virtual void yystack_print_ ();
377	#endif
378
379	/// Convert a scanner token number \a t to a symbol number.
380	token_number_type yytranslate_ (int t);
381
382	/// \brief Reclaim the memory associated to a symbol.
383	/// \param yymsg Why this token is reclaimed.
384	/// \param yytype The symbol type.
385	/// \param yyvaluep Its semantic value.
386	/// \param yylocationp Its location.
387	inline void yydestruct_ (const char* yymsg,
388	int yytype,
389	semantic_type* yyvaluep,
390	location_type* yylocationp);
391
392	/// Pop \a n symbols the three stacks.
393	inline void yypop_ (unsigned int n = 1);
394
395	/* Constants. */
396	static const int yyeof_;
397	/* LAST_ -- Last index in TABLE_. */
398	static const int yylast_;
399	static const int yynnts_;
400	static const int yyempty_;
401	static const int yyfinal_;
402	static const int yyterror_;
403	static const int yyerrcode_;
404	static const int yyntokens_;
405	static const unsigned int yyuser_token_number_max_;
406	static const token_number_type yyundef_token_;
407
408	/* Debugging. */
409	int yydebug_;
410	std::ostream* yycdebug_;
411
412
413	/* User arguments. */
414	QMake::Lexer* lexer;
415	QValueStack<ProjectAST*>& projects;
416	int depth;
417	};
418	}
419
420
421	#endif /* ! defined PARSER_HEADER_H */

Line 0 Link Here

(-)kdevelop-3.4.0.orig/buildtools/lib/parsers/qmake/stack.hh (+129 lines)
		1	/* A Bison parser, made by GNU Bison 2.3. */
		2
		3	/* Stack handling for Bison parsers in C++
		4
		5	Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
		6
		7	This program is free software; you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation; either version 2, or (at your option)
		10	any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 51 Franklin Street, Fifth Floor,
		20	Boston, MA 02110-1301, USA. */
		21
		22	/* As a special exception, you may create a larger work that contains
		23	part or all of the Bison parser skeleton and distribute that work
		24	under terms of your choice, so long as that work isn't itself a
		25	parser generator using the skeleton or a modified version thereof
		26	as a parser skeleton. Alternatively, if you modify or redistribute
		27	the parser skeleton itself, you may (at your option) remove this
		28	special exception, which will cause the skeleton and the resulting
		29	Bison output files to be licensed under the GNU General Public
		30	License without this special exception.
		31
		32	This special exception was added by the Free Software Foundation in
		33	version 2.2 of Bison. */
		34
		35	#ifndef BISON_STACK_HH
		36	# define BISON_STACK_HH
		37
		38	#include <deque>
		39
		40	namespace QMake
		41	{
		42	template <class T, class S = std::deque<T> >
		43	class stack
		44	{
		45	public:
		46
		47	// Hide our reversed order.
		48	typedef typename S::reverse_iterator iterator;
		49	typedef typename S::const_reverse_iterator const_iterator;
		50
		51	stack () : seq_ ()
		52	{
		53	}
		54
		55	stack (unsigned int n) : seq_ (n)
		56	{
		57	}
		58
		59	inline
		60	T&
		61	operator [] (unsigned int i)
		62	{
		63	return seq_[i];
		64	}
65
66	inline
67	const T&
68	operator [] (unsigned int i) const
69	{
70	return seq_[i];
71	}
72
73	inline
74	void
75	push (const T& t)
76	{
77	seq_.push_front (t);
78	}
79
80	inline
81	void
82	pop (unsigned int n = 1)
83	{
84	for (; n; --n)
85	seq_.pop_front ();
86	}
87
88	inline
89	unsigned int
90	height () const
91	{
92	return seq_.size ();
93	}
94
95	inline const_iterator begin () const { return seq_.rbegin (); }
96	inline const_iterator end () const { return seq_.rend (); }
97
98	private:
99
100	S seq_;
101	};
102
103	/// Present a slice of the top of a stack.
104	template <class T, class S = stack<T> >
105	class slice
106	{
107	public:
108
109	slice (const S& stack,
110	unsigned int range) : stack_ (stack),
111	range_ (range)
112	{
113	}
114
115	inline
116	const T&
117	operator [] (unsigned int i) const
118	{
119	return stack_[range_ - i];
120	}
121
122	private:
123
124	const S& stack_;
125	unsigned int range_;
126	};
127	}
128
129	#endif // not BISON_STACK_HH