diff options
Diffstat (limited to 'devel/kdevelop-base/patches/patch-bl')
| -rw-r--r-- | devel/kdevelop-base/patches/patch-bl | 426 |
1 files changed, 426 insertions, 0 deletions
diff --git a/devel/kdevelop-base/patches/patch-bl b/devel/kdevelop-base/patches/patch-bl new file mode 100644 index 00000000000..f56321adc5e --- /dev/null +++ b/devel/kdevelop-base/patches/patch-bl @@ -0,0 +1,426 @@ +$NetBSD: patch-bl,v 1.1 2007/03/24 14:01:31 markd Exp $ + +--- buildtools/lib/parsers/qmake/qmake_yacc.hpp.orig 2007-03-22 00:44:35.000000000 +1200 ++++ buildtools/lib/parsers/qmake/qmake_yacc.hpp +@@ -0,0 +1,421 @@ ++/* 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 */ |