---

precompiler.h

Go to the documentation of this file.

#ifndef precompiler_h
#define precompiler_h

#include <fstream>

#include "file.h"
#include "lexer.h"
#include "error.h"
#include "macro.h"
#include "sitemap.h"
#include "strings.h"
#include <cstdio>
#include "tmp.h"
#include <Format.hh>
#include "init.h"
#include "ih.h"
#include "user.h"

class Precompiler
{
 private:

  typedef struct Macros; 
  
  bool eof_reached;

  File in;
  File out;

 public:
  typedef std::list<Line> line_list;
  typedef line_list::iterator line_list_it;

 private:
  typedef struct Where_link
  {
    Where_link() {}
    Link where;
    line_list_it line;
  };
  
  typedef std::list<Where_link> where_link_list;
  typedef where_link_list::iterator where_link_list_it;

  typedef struct Where
  {
    SitemapBase where;
    line_list_it line;
  };

  typedef std::list<Where> where_list;
  typedef std::list<Where>::iterator where_list_it;

  Tmp *temp;

  typedef std::list<InitTableEntry> init_list;
  typedef init_list::iterator init_list_it;
  
  init_list init_table;
  
  InterpreterHandler ip_handler;

  UserHandler::def_list defines;
  Strings::string_list  user_scans; 

  std::string current_path;

  bool use_default_init_table;

  struct Init_Scan
  {
    enum Mode
      {
        NONE,
        RESET,
        INSERT,
        APPEND,
        DELETE
      };

    Mode mode;
    init_list table;
  };

  typedef std::list<Init_Scan> init_scan_list;
  typedef init_scan_list::iterator init_scan_list_it;

 public:
  class Error;

  class tmp_parse_error;

  class cannot_open_file;

  class cannot_create_tmp_file;

 private:
  macro_list predef_soft_macros; 
  macro_list predef_hard_macros; 
  Strings::string_list locale_list;

  bool use_tmp;
  bool auto_init_detection;

 public:
  Precompiler( std::string infile, std::string outfile, bool use_tmp, bool no_erase );
  Precompiler( std::string infile, std::string outfile,
               macro_list predef_soft_macros,   
               macro_list predef_hard_macros,   
               Strings::string_list locale,     
               bool use_tmp,                    
               bool no_erase                    
               );
  ~Precompiler();

  void compile();
  
  static void warning( std::string message );
  static void warning( Line line, std::string message );

  static bool emacs_warning; 

  // print init level infos
  static bool init_info;

  std::string get_tmp_file();

 private:
  Line read_line( File &in );
  
  inline void write_line( const Line &line, File& out );
  
  void lex_file( File in, File out );
  
  void include_scan( File in, File out, std::string last_cur_dir = "" );
  
  Macros read_macros( File in, Init::Range range );
  
  void rebuilt_file( File in, File out );
  
  void substitude_soft_macros( Macros &macros, File in , File out, Init::Range range );
  
  void substitude_hard_macros( Macros &macros, File in, File out, Init::Range range );
  
  bool built_menu( File in, File out );
  
  bool locale_support( File in, File out ); 
  line_list_it find_locale_start( line_list& ll, line_list_it start ); 
  line_list_it find_locale_end( line_list& ll, line_list_it start ); 

  friend bool operator == ( const Line& l1, const Line& l2 );

  void script_support( File in  );

  void image_scan( File in, File out, Init::Range range );
  void filelink_scan( File in, File out );
  void filelist_scan( File in, File out );

  init_scan_list init_scan( File in, File out );

  bool script_function_scan( File in, File out );

  void compile( File in, File out );

  void include_at_line( Line line, File out );

  void char_set_scan( File in, File out );

  inline void set( Init::Type  type );

  inline void auto_init_check( std::string& tag_type );

  bool delete_scan( File in, File out, Init::Range range );

  void define_scan( File in );

  bool user_scan( File in, File out, std::string init_name );

  std::string get_path( std::string file );

  static std::string simplify_path( std::string path );

  init_list get_default_init_table();

  void init_check( File in, File out ); 
};

bool operator == ( const Line& l1, const Line& l2 );

class Precompiler::Error : public ::Error
{
 public:
  Error( std::string error_string ) 
    : ::Error( Line(), "Precompiler", error_string ) {}
  template <class T>Error( std::string error_string, T what )
                           : ::Error( Line(), "Precompiler", error_string, what ) {}
  template <class T>Error( Line line, std::string error_string, T what )
                           : ::Error( line, "Precompiler", error_string, what ) {}
  Error( Line line, std::string error_string ) 
    : ::Error( line, "Precompiler", error_string ) {}
};

class Precompiler::tmp_parse_error : public Precompiler::Error
{
 public:
  tmp_parse_error()
    : Error( _("Parse error at tmp file") )
    {}
  template <class T> tmp_parse_error( T what )
    : Error( _("Parse error at tmp file"), what )
    {}

  template <class T> tmp_parse_error( Line line, T what )
    : Error( line, _("Parse error at tmp file"), what )
    {}

  tmp_parse_error( Line line )
    : Error( line, _("Parse error at tmp file") )
    {}
};

class Precompiler::cannot_open_file : public Precompiler::Error
{
 public:
  cannot_open_file( std::string file )
    : Error( _("Cannot open file"), file )
    { }

  cannot_open_file( Line line, std::string file )
    : Error( line, _("Cannot open file"), file )
    { }
};

class Precompiler::cannot_create_tmp_file : public Precompiler::Error
{
 public:
  cannot_create_tmp_file( std::string file )
    : Error( _("Cannot create tmp file"), file )
    { }
};

#endif

---