patches/frameworks/compile/mclinker/0001-Revert-Update-FlexLinker.h-to-current-version-of-fle.patch

From e6c2552e60db1443867762dd62f51f9370dfb23d Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Thu, 31 May 2018 14:38:54 -0700
Subject: [PATCH] Revert "Update FlexLinker.h to current version of flex."

This reverts commit a0a36870d5b5a66b7f7d04ea1aa15488b396d42d.
---
 include/mcld/Script/FlexLexer.h | 133 ++++++++++++++------------------
 1 file changed, 56 insertions(+), 77 deletions(-)

diff --git a/include/mcld/Script/FlexLexer.h b/include/mcld/Script/FlexLexer.h
index cbc95f9..3514ee1 100644
--- a/include/mcld/Script/FlexLexer.h
+++ b/include/mcld/Script/FlexLexer.h
@@ -44,141 +44,122 @@
 // 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 xxFlexLexer
+//	#include <FlexLexer.h>
 //
-//      #undef yyFlexLexer
-//      #define yyFlexLexer zzFlexLexer
-//      #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()        { }
+class FlexLexer {
+ public:
+  virtual ~FlexLexer() {}
 
-  const char* YYText() const  { return yytext; }
-  int YYLeng()        const   { return yyleng; }
+  const char* YYText() const { return yytext; }
+  int YYLeng() const { return yyleng; }
 
-  virtual void
-  yy_switch_to_buffer( yy_buffer_state* new_buffer ) = 0;
-  virtual yy_buffer_state* yy_create_buffer( std::istream* s, int size ) = 0;
-  virtual yy_buffer_state* yy_create_buffer( std::istream& s, int size ) = 0;
-  virtual void yy_delete_buffer( yy_buffer_state* b ) = 0;
-  virtual void yyrestart( std::istream* s ) = 0;
-  virtual void yyrestart( std::istream& s ) = 0;
+  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( std::istream& new_in, std::ostream& new_out )
-  {
-    switch_streams( new_in, new_out );
-    return yylex();
-  }
-
-  int yylex( std::istream* new_in, std::ostream* new_out = 0)
-  {
-    switch_streams( new_in, new_out );
+  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( std::istream* new_in,
-                               std::ostream* new_out ) = 0;
-  virtual void switch_streams( std::istream& new_in,
-                               std::ostream& new_out ) = 0;
+  virtual void switch_streams(FLEX_STD istream* new_in = 0,
+                              FLEX_STD ostream* new_out = 0) = 0;
 
-  int lineno() const          { return yylineno; }
+  int lineno() const { return yylineno; }
 
-  int debug() const           { return yy_flex_debug; }
-  void set_debug( int flag )  { yy_flex_debug = flag; }
+  int debug() const { return yy_flex_debug; }
+  void set_debug(int flag) { yy_flex_debug = flag; }
 
-protected:
+ 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 // FLEXLEXER_H
+#endif  // FLEXLEXER_H
 
-#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
+#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 manual.
-# define yyFlexLexerOnce
+#define yyFlexLexerOnce
 
 extern "C++" {
-
 class yyFlexLexer : public FlexLexer {
-public:
+ public:
   // arg_yyin and arg_yyout default to the cin and cout, but we
   // only make that assignment when initializing in yylex().
-  yyFlexLexer( std::istream& arg_yyin, std::ostream& arg_yyout );
-  yyFlexLexer( std::istream* arg_yyin = 0, std::ostream* arg_yyout = 0 );
-private:
-  void ctor_common();
-
-public:
+  yyFlexLexer(FLEX_STD istream* arg_yyin = 0, FLEX_STD ostream* arg_yyout = 0);
 
   virtual ~yyFlexLexer();
 
-  void yy_switch_to_buffer( yy_buffer_state* new_buffer );
-  yy_buffer_state* yy_create_buffer( std::istream* s, int size );
-  yy_buffer_state* yy_create_buffer( std::istream& s, int size );
-  void yy_delete_buffer( yy_buffer_state* b );
-  void yyrestart( std::istream* s );
-  void yyrestart( std::istream& s );
+  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( yy_buffer_state* new_buffer );
+  void yypush_buffer_state(struct yy_buffer_state* new_buffer);
   void yypop_buffer_state();
 
   virtual int yylex();
-  virtual void switch_streams( std::istream& new_in, std::ostream& new_out );
-  virtual void switch_streams( std::istream* new_in = 0, std::ostream* new_out = 0 );
+  virtual void switch_streams(FLEX_STD istream* new_in,
+                              FLEX_STD ostream* new_out = 0);
   virtual int yywrap();
 
-protected:
-  virtual int LexerInput( char* buf, int max_size );
-  virtual void LexerOutput( const char* buf, int size );
-  virtual void LexerError( const char* msg );
+ 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 );
+  void yyunput(int c, char* buf_ptr);
   int yyinput();
 
   void yy_load_buffer_state();
-  void yy_init_buffer( yy_buffer_state* b, std::istream& s );
-  void yy_flush_buffer( yy_buffer_state* b );
+  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_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 );
+  yy_state_type yy_try_NUL_trans(yy_state_type current_state);
   int yy_get_next_buffer();
 
-  std::istream yyin;  // input source for default LexerInput
-  std::ostream yyout; // output sink for default LexerOutput
+  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;
@@ -189,17 +170,16 @@ protected:
   // 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
+  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. */
-  yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
+  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
@@ -223,7 +203,6 @@ protected:
   int yy_more_offset;
   int yy_prev_more_offset;
 };
-
 }
 
 #endif  // yyFlexLexer || ! yyFlexLexerOnce
-- 
2.17.1