include/basix/source_track.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : source_track.hpp
* DESCRIPTION: Tracking the source location of a generic object
* COPYRIGHT  : (C) 2007  Gregoire Lecerf and Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __MMX_SOURCE_TRACK_HPP
#define __MMX_SOURCE_TRACK_HPP
#include <basix/string.hpp>
#include <basix/identifiers.hpp>


namespace mmx {

/******************************************************************************
* Positions in source files
* IMPORTANT: all positions are counted from 0 internally.
******************************************************************************/

class source_position {
MMX_ALLOCATORS
public:
  // This storage is redundant but helpful.
  nat position;
  nat line;
  nat column;
  source_position (void) : position (0), line (0), column (0) {}
  source_position (nat p, nat l, nat c):
    position (p), line (l), column (c) {}
  source_position (const source_position& p):
    position (p.position), line (p.line), column (p.column) {}
  inline source_position& operator= (const source_position& p) {
    position = p.position;
    line = p.line;
    column = p.column;
    return *this;
  }
};

inline source_position
min (const source_position& p1, const source_position& p2) {
  return p1.position < p2.position? p1: p2;
};
  
inline source_position
max (const source_position& p1, const source_position& p2) {
  return p1.position > p2.position? p1: p2;
};

/******************************************************************************
* Locations in source files (object + file name + range)
******************************************************************************/

class source_location {
MMX_ALLOCATORS
public:
  generic obj; // located object
  string file_name; // file_name of the source_location
  nat input_number; // input number if file is stdin
  source_position begin;
  source_position end;

  inline source_location () : obj (), file_name (""),
                              input_number (0), begin (), end () {}
  inline source_location (generic g, string f, nat i,
                          const source_position& b,
                          const source_position& e) : 
    obj (g), file_name (f),
    input_number (i), begin (b), end(e) {}
  inline source_location (const source_location& l) : 
    obj (l.obj), file_name (l.file_name),
    input_number (l.input_number),
    begin (l.begin), end (l.end) {}
  inline source_location& operator= (const source_location& l) {
    obj = l.obj;
    file_name = l.file_name;
    input_number = l.input_number;
    begin = l.begin;
    end = l.end;
    return *this;
  }
};

inline bool
is_nil (const source_location& l) {
  return (l.end.line == 0 && l.end.position == 0);
};

inline syntactic
flatten (const source_location& l) {
  return flatten (gen (GEN_TUPLE, l.obj, l.file_name, l.input_number,
                       gen (GEN_TUPLE, l.begin.line, l.begin.column),
                       gen (GEN_TUPLE, l.end.line, l.end.column)));
}

/******************************************************************************
* Keeping track of all source files
******************************************************************************/

void store_interactive_number (nat n);
  // set the current input number

nat get_interactive_number (void);
  // retrieve the current interactive input number

void store_interactive_source (const string& data,
                               nat n= get_interactive_number ());
  // store next interactive input

string get_interactive_source (nat i);
  // return a specific innteractive source

void store_file_source (const string& file_name, const string& data);
  // store source 'data' for 'file_name'

string get_file_source (const string& file_name);
  // retrieve stored source for 'file_name'

string get_source (const string& file_name, nat input_number, nat line);
  // return a line in a file.
  // Empty file_name means interactive input. In this only situation
  // we use the input_number.

/******************************************************************************
* Associating source locations to objects
******************************************************************************/
  
void source_insert (const generic& g, const source_location& l);
  // Insert g into source_source_location with source_location l.

void source_delete (const generic& g);
  // Delete g from source_source_location.

generic source_link (const generic& g, const generic& h, const generic& kind);
  // Link g (usually the result of some computation) to h (the source
  // input for the computation), while specifying a kind (the kind of
  // computation). As a side effect, linking copies the source location of h.

generic source_extend (const generic& g1, const generic& g2);
  // Set the source_location of g1 in order to contain g1 and g2.
  // Delete g2 in source_source_location and return g1.

generic source_assign (const generic& g1, const generic& g2);
  // Set the source_location of g1 to the source location of g2
  // Return g1

inline generic
source_extend (const generic& g1, const generic& g2, const generic& g3) {
  return source_extend (source_extend (g1, g2), g3);
}

/******************************************************************************
* Tracking the source locations of objects
******************************************************************************/

void source_locate (const generic& g, source_location& l);
  // Return the source_location of g in l. If l is already a valid
  // source_location in input, then the returned value for l is the
  // minimal interval containing both g and l.
  // WARNING: g must not share subexpressions in different files or inputs

source_location source_locate (const generic& g);
  // Return the source_location of g or nil.

bool   source_has_exact (const generic& g);
  // Does the expression g itself admit a source location?

bool   source_exists (const generic& g);
  // Can we find a source location for g?

string source_file (const generic& g);
  // The source file for g occurs or ""

int    source_line (const generic& g, const bool& last);
  // The first or last source line for g or 0

int    source_column (const generic& g, const bool& last);
  // The first or last source column for g or 0

string source_begin (const generic& g);
  // String with starting position of source or "unknown"

string source_end (const generic& g);
  // String with end position of source or "unknown"

string source_string (const generic& g);
  // The source string for g or ""

string source_string_unindented (const generic& g);
  // The unindented source string for g or ""

string source_underlined (const generic& g);
  // The source string for g, underlined within its context, or ""

string source_error (const string& msg, const generic& where);
  // Build an error message which occurred in 'where'

string source_exception (const exception& e);
  // Build (backtraced) error message for the exception 'e'

} // namespace mmx
#endif // __MMX_SOURCE_TRACK_HPP

---