lily/includable-lexer.cc

   1 /*
   2   includable-lexer.cc -- implement Includable_lexer
   3
   4   source file of the LilyPond music typesetter
   5
   6   (c)  1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8
   9 #include <strstream.h>
  10
  11
  12 #include "file-path.hh"
  13 #include "includable-lexer.hh"
  14 #include "source-file.hh"
  15 #include "source.hh"
  16 #include "debug.hh"
  17
  18 #ifndef YY_BUF_SIZE
  19 #define YY_BUF_SIZE 16384
  20 #endif
  21
  22 #ifndef YY_START
  23 #define YY_START ((yy_start - 1) / 2)
  24 #define YYSTATE YY_START
  25 #endif
  26
  27 Includable_lexer::Includable_lexer ()
  28 {
  29   yy_current_buffer = 0;
  30   allow_includes_b_ = true;
  31 }
  32
  33 /** set the  new input to s, remember old file.
  34 */
  35 void
  36 Includable_lexer::new_input (String s, Sources  * global_sources)
  37 {
  38   if (!allow_includes_b_)
  39     {
  40       LexerError ("include files are disallowed.");
  41       return;
  42     }
  43
  44   Source_file * sl = global_sources->get_file_l (s);
  45   if (!sl)
  46     {
  47       String msg = _f ("Can't find file: `%s'", s);
  48       msg += "\n";
  49       msg += _f ("(search path: `%s')", global_sources->path_C_->str ().ch_C());
  50       msg += "\n";
  51       LexerError (msg.ch_C ());
  52
  53       return;
  54     }
  55   filename_str_arr_.push (sl->name_str ());
  56
  57   char_count_stack_.push (0);
  58   if (yy_current_buffer)
  59     state_stack_.push (yy_current_buffer);
  60   *mlog << "[" << s<< flush;
  61   include_stack_.push (sl);
  62
  63   /*
  64     ugh. We'd want to create a buffer from the bytes directly.
  65
  66     Whoops. The size argument to yy_create_buffer is not the
  67     filelength but a BUFFERSIZE. Maybe this is why reading stdin fucks up.
  68
  69   */
  70   yy_switch_to_buffer (yy_create_buffer (sl->istream_l (), YY_BUF_SIZE));
  71
  72 }
  73 void
  74 Includable_lexer::new_input (String name, String data, Sources* sources)
  75 {
  76   Source_file* file = new Source_file (name, data);
  77   sources->add (file);
  78   filename_str_arr_.push (name);
  79
  80   char_count_stack_.push (0);
  81   if (yy_current_buffer)
  82     state_stack_.push (yy_current_buffer);
  83   *mlog << "[" << name << flush;
  84   include_stack_.push (file);
  85
  86   yy_switch_to_buffer (yy_create_buffer (file->istream_l (), YY_BUF_SIZE));
  87 }
  88
  89 /** pop the inputstack.  conceptually this is a destructor, but it
  90   does not destruct the Source_file that Includable_lexer::new_input creates.  */
  91 bool
  92 Includable_lexer::close_input ()
  93 {
  94   include_stack_.pop ();
  95   char_count_stack_.pop ();
  96   *mlog << "]"<<flush;
  97   yy_delete_buffer (yy_current_buffer);
  98   yy_current_buffer = 0;
  99   if (state_stack_.empty ())
 100     {
 101       yy_current_buffer = 0;
 102       return false;
 103     }
 104   else
 105     {
 106       yy_switch_to_buffer (state_stack_.pop ());
 107       return true;
 108     }
 109 }
 110
 111 char const*
 112 Includable_lexer::here_ch_C () const
 113 {
 114   if (include_stack_.empty ())
 115     return 0;
 116   return include_stack_.top ()->ch_C () + char_count_stack_.top ();
 117 }
 118
 119 Includable_lexer::~Includable_lexer ()
 120 {
 121   while (!include_stack_.empty ())
 122     {
 123       close_input ();
 124     }
 125 }
 126 /**
 127   Since we don't create the buffer state from the bytes directly, we
 128   don't know about the location of the lexer. Add this as a
 129   YY_USER_ACTION */
 130 void
 131 Includable_lexer::add_lexed_char (int count)
 132 {
 133   char_count_stack_.top () += count;
 134 }
 135
 136 Source_file*
 137 Includable_lexer::source_file_l () const
 138 {
 139   if (include_stack_.empty ())
 140     return 0;
 141   else
 142     return include_stack_.top ();
 143 }