src/source_track.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : source_track.cpp
* 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.
******************************************************************************/

#include <basix/source_track.hpp>
#include <basix/literal.hpp>
#include <basix/compound.hpp>
#include <basix/system.hpp>

namespace mmx {

nat backtrace_depth= 8;

string repeated (const string& s, nat n);
nat get_indentation (const string& s);
string add_indentation (const string& s, int delta);

/******************************************************************************
* Keep track of interactive sources and source files
******************************************************************************/

static vector< vector<string> > interactive_sources;
static table< vector<string>, string > file_sources;

void
store_interactive_number (nat n) {
  ASSERT (n <= N(interactive_sources), "input number out of range");
  interactive_sources= range (interactive_sources, 0, n);
}

nat
get_interactive_number (void) {
  return N(interactive_sources) ;
}

void
store_interactive_source (const string& data, nat n) {
  ASSERT (n <= get_interactive_number (), "input number out of range");
  vector<string> v= tokenize (data, "\n");
  if (n == get_interactive_number ()) interactive_sources << v;
  else interactive_sources[n]= v;
}

string
get_interactive_source (nat i) {
  ASSERT (i < N (interactive_sources), "source out of range");
  return recompose (interactive_sources[i], '\n');
}

static string
get_interactive_source (nat i, nat l) {
  ASSERT (i < N (interactive_sources), "source out of range");
  ASSERT (l < N (interactive_sources[i]), "source out of range");
  return interactive_sources[i][l];
}

void
store_file_source (const string& file_name, const string& data) {
  file_sources [file_name] = tokenize (data, "\n");
}

string
get_file_source (const string& file_name) {
  return recompose (file_sources [file_name], "\n");
}

static string
get_file_source (const string& file_name, nat line) {
  if (!file_sources->contains (file_name)) return "";
  ASSERT (line < N (read (file_sources, file_name)), "source out of range");
  return read (file_sources, file_name) [line];
}

string
get_source (const string& file_name, nat i) {
  if (file_name == "") return get_interactive_source (i);
  return get_file_source (file_name);
}

string
get_source (const string& file_name, nat i, nat line) {
  if (file_name == "") return get_interactive_source (i, line);
  return get_file_source (file_name, line);
}

/******************************************************************************
* Keep track of locations in source code
******************************************************************************/

struct gen_eq_op { // equality for unique symbols
  static generic name () { return generic ("gen_eq"); }
  static inline bool
  op (const generic& x, const generic& y) { return gen_eq (x, y); }
  static inline bool
  not_op (const generic& x, const generic& y) { return gen_neq (x, y); }
  static inline nat
  hash_op (const generic& x) { return gen_hash (x); }
};

struct gen_eq_table {
  typedef gen_eq_op key_op;
  typedef equal_op val_op;
};

table<source_location, generic, gen_eq_table>&
source_locs () {
  static table<source_location, generic, gen_eq_table> t=
    table<source_location, generic, gen_eq_table> ();
  return t;
}

// l = source_locs () [g] means that the
// location of the generic g in the source code is stored in l.

void
source_insert (const generic& g, const source_location& l) {
  source_locs () [g] = l;
}

void
source_delete (const generic& g) {
  reset (source_locs (), g);
}

generic
source_link (const generic& g1, const generic& g2, const generic& kind) {
  (void) kind;
  table<source_location, generic, gen_eq_table>& t= source_locs ();
  if (!contains (t, g1) && contains (t, g2)) t[g1] = t[g2];
  return g1;
}

generic
source_assign (const generic& g1, const generic& g2) {
  source_location l= source_locate (g2);
  if (!is_nil (l)) source_insert (g1, l);
  return g1;
}

generic
source_extend (const generic& g1, const generic& g2) {
  //mmout << "source extending " << g1 << " with " << g2 <<"\n";
  source_location l;
  source_locate (g1, l);
  source_locate (g2, l);
  source_delete (g1);
  source_delete (g2);
  l.obj = g1;
  source_insert (g1, l);
  return g1;
}

/******************************************************************************
* Obtaining source information about a generic object
******************************************************************************/
  
void
source_locate (const generic& g, source_location& l) {
  // mmout << "source_locate: " << g << " @ " << inside (g) << "\n";
  source_location arg_l = l;
  if (source_locs () -> contains (g)) {
    source_location l1 = read (source_locs (), g);
    if (is_nil (l))
      l = l1;
    else 
      if (!is_nil (l1)) {
        l.obj = l1.obj;
        if (l.file_name == l1.file_name && l.input_number == l1.input_number) {
          l.begin = min (l.begin, l1.begin);
          l.end = max (l.end, l1.end);
        }
        // If the location is not 'connected', we leave l unchanged. 
      }
    return;
  }
  if (is<compound> (g))
    for (nat i=0; i<N(g); i++)
      source_locate (g[i], l);
  l.obj = g;
}

source_location
source_locate (const generic& g) {
  source_location l;
  source_locate (g, l);
  return l;
}

/******************************************************************************
* Get high level information about source locations
******************************************************************************/

bool
source_has_exact (const generic& g) {
  return (source_locs () -> contains (g));
}

bool
source_exists (const generic& g) {
  return !is_nil (source_locate (g));
}

string
source_file (const generic& g) {
  source_location l= source_locate (g);
  if (is_nil (l)) return "";
  else if (l.file_name == "")
    return "input[" * as_string (l.input_number + 1) * "]";
  else return l.file_name;
}

int
source_line (const generic& g, const bool& last) {
  source_location l= source_locate (g);
  if (is_nil (l)) return 0;
  else if (last) return l.end.line;
  else return l.begin.line;
}

int
source_column (const generic& g, const bool& last) {
  source_location l= source_locate (g);
  if (is_nil (l)) return 0;
  else if (last) return l.end.column;
  else return l.begin.column;
}

string
source_begin (const generic& g) {
  if (!source_exists (g)) return "Unknown location";
  return source_file (g) * ":" *
         as_string (source_line (g, false)) * ":" *
         as_string (source_column (g, false));
}

string
source_end (const generic& g) {
  if (!source_exists (g)) return "Unknown location";
  return source_file (g) * ":" *
         as_string (source_line (g, true)) * ":" *
         as_string (source_column (g, true));
}

string
source_string (const generic& g) {
  source_location l= source_locate (g);
  if (is_nil (l)) return "";
  else {
    string src= get_source (l.file_name, l.input_number);
    return src (l.begin.position, l.end.position);
  }
}

string
source_string_unindented (const generic& g) {
  source_location l= source_locate (g);
  if (is_nil (l)) return "";
  else {
    string src= get_source (l.file_name, l.input_number);
    string sub= src (l.begin.position, l.end.position);
    string bis= repeated (" ", l.begin.column) * sub;
    return add_indentation (bis, -((int) get_indentation (bis)));
  }
}

/******************************************************************************
* Underline part of a source
******************************************************************************/

static string
underlined (const string& file_name, const nat& n,
            const source_position& b, const source_position& e)
{
  // empty file_name means interactive input. In this only situation
  // n means the input number. n is not used for a regular file.
  nat j;
  string line;
  string sout;

  line = get_source (file_name, n, b.line);

  sout << line << "\n";
  for (j=0; j < b.column; ++j)
    sout << " ";
  if (b.line == e.line) {
    for (; j < e.column; ++j)
      sout << "~";
  }
  else {
    if (e.line == b.line+1 && e.column == 0)
      sout << "^";
    else {
      for (; j < N(line); ++j)
        sout << "~";
      sout << "\n";
      if (e.column == 0) {
        if (e.line - 1 > b.line + 1)
          sout << "...\n";
        line = get_source (file_name, n, e.line-1);
        sout << line << "\n";
        for (j=0; j < N(line); ++j)
          sout << "~";
        if (N(line) == 0)
          sout << "^";
      }
      else {
        if (e.line > b.line + 1)
          sout << "...\n";
        line = get_source (file_name, n, e.line);
        sout << line << "\n";
        for (j=0; j < e.column; ++j)
          sout << "~";
      }
    }
  }
  sout << "\n";
  return sout;
}

string
source_underlined (const generic& g) {
  source_location l= source_locate (g);
  if (is_nil (l)) return "";
  else return underlined (l.file_name, l.input_number, l.begin, l.end);
}

string
source_error (const string& msg, const generic& g) {
  mmerr << ">>> g= " << g << "\n";
  string s;
  source_location l= source_locate (g);
  if (is_nil (l) && is<literal> (g))
    s << "Inside " << literal_to_string (g) << ": ";
  else if (is_nil (l))
    s << "Unknown location: ";
  else
    s << strip_directory (source_file (g)) << ":"
      << as_string (l.begin.line + 1) << ":" 
      << as_string (l.begin.column + 1) << ": ";
  s << msg << "\n"
    << source_underlined (g);
  return s;
}

string
backtrace (const generic& g) {
  if (has_trace (g))
    return backtrace (trace_pull (g)) * backtrace (trace_top (g));
  else return source_exception (as<exception> (g));
}

string
source_exception (const exception& e) {
  generic g= as<generic> (e);
  if (has_trace (g))
    return backtrace (trace_bottom (g, backtrace_depth));
  else {
    generic err= *e;
    if (is<literal> (err[1]))
      return source_error (literal_to_string (err[1]), err[N(err)-1]);
    else return source_error ("unknown", err[N(err)-1]);
  }
}

} // namespace mmx

---