parser.cpp

Go to the documentation of this file.

#include "../include/parser.hpp"
#include "../include/util.hpp"

namespace csdbg {

/* Static member variable definition */

parser *parser::m_default = NULL;

style *parser::m_fallback = NULL;


void parser::on_lib_load()
{
  try {
    /* Create the default parser */
    m_default = new parser;

    /*
     * Equip the default parser with dictionaries for C++ keywords, intrinsic
     * types and file extensions
     */
    string path("%s/etc/keywords.dict", util::prefix());
    m_default->add_dictionary("keywords", path.cstr(), false);

    path.set("%s/etc/types.dict", util::prefix());
    m_default->add_dictionary("types", path.cstr(), false);

    path.set("%s/etc/extensions.dict", util::prefix());
    m_default->add_dictionary("extensions", path.cstr(), true);

    /*
     * Create the default, fallback style. When a highlighter can't determine or
     * create/obtain the correct style for a token, it uses the fallback
     */
    m_fallback = new style("fallback");

    /* Add styles for all kinds of trace tokens to the default parser */
    style *s = m_fallback->clone();
    s->set_name("delimiter");
    m_default->add_style(s);

    s = m_fallback->clone();
    s->set_name("number");
    s->set_fgcolor(HLT_NUMBER_FG);
    s->set_attr_enabled(style::BOLD, true);
    m_default->add_style(s);

    s = m_fallback->clone();
    s->set_name("keyword");
    s->set_fgcolor(HLT_KEYWORD_FG);
    m_default->add_style(s);

    s = m_fallback->clone();
    s->set_name("type");
    s->set_fgcolor(HLT_TYPE_FG);
    s->set_attr_enabled(style::BOLD, true);
    m_default->add_style(s);

    s = m_fallback->clone();
    s->set_name("file");
    s->set_fgcolor(HLT_FILE_FG);
    m_default->add_style(s);

    s = m_fallback->clone();
    s->set_name("scope");
    s->set_fgcolor(HLT_SCOPE_FG);
    m_default->add_style(s);

    s = m_fallback->clone();
    s->set_name("function");
    s->set_fgcolor(HLT_FUNCTION_FG);
    s->set_attr_enabled(style::BOLD, true);
    m_default->add_style(s);

    util::dbg_info("default C++ stack trace parser/highlighter initialized");
    return;
  }

  catch (exception &x) {
    std::cerr << x;
  }

  catch (std::exception &x) {
    std::cerr << x;
  }

  exit(EXIT_FAILURE);
}


void parser::on_lib_unload()
{
  delete m_default;
  delete m_fallback;
  m_default = NULL;
  m_fallback = NULL;

  util::dbg_info("default C++ stack trace parser/highlighter finalized");
}


std::ostream& operator<<(std::ostream &lval, const parser &rval)
{
  util::lock();

  /* If an exception occurs, output its details instead of rval */
  try {
    string *buf = rval.highlight();
    lval << *buf;
    delete buf;
  }

  catch (exception &x) {
    lval << x;
  }

  catch (std::exception &x) {
    lval << x;
  }

  util::unlock();
  return lval;
}


parser::parser()
try:
string(),
m_dictionaries(NULL),
m_styles(NULL)
{
  try {
    m_dictionaries = new chain<dictionary>;
    m_styles = new chain<style>;
  }

  catch (...) {
    delete m_dictionaries;
    throw;
  }
}

catch (...) {
  delete[] m_data;
  m_data = NULL;
  m_dictionaries = NULL;
  m_styles = NULL;
}


parser::parser(const parser &src)
try:
string(src),
m_dictionaries(NULL),
m_styles(NULL)
{
  try {
    m_dictionaries = src.m_dictionaries->clone();
    m_styles = src.m_styles->clone();
  }

  catch (...) {
    delete m_dictionaries;
    throw;
  }
}

catch (...) {
  delete[] m_data;
  m_data = NULL;
  m_dictionaries = NULL;
  m_styles = NULL;
}


parser::~parser()
{
  delete m_dictionaries;
  delete m_styles;
  m_dictionaries = NULL;
  m_styles = NULL;
}


inline parser* parser::clone() const
{
  return new parser(*this);
}


parser* parser::get_default()
{
  return m_default;
}


style* parser::get_fallback_style()
{
  return m_fallback;
}


parser& parser::operator=(const parser &rval)
{
  if ( unlikely(this == &rval) )
    return *this;

  /* Copy the buffer */
  string::operator=(rval);

  *m_dictionaries = *rval.m_dictionaries;
  *m_styles = *rval.m_styles;
  return *this;
}


dictionary* parser::add_dictionary(const i8 *nm, const i8 *path, bool mode)
{
  dictionary *retval = NULL;
  try {
    retval = new dictionary(nm, path, mode);
    m_dictionaries->add(retval);
    return retval;
  }

  catch (...) {
    delete retval;
    throw;
  }
}


inline parser& parser::add_dictionary(dictionary *dict)
{
  m_dictionaries->add(dict);
  return *this;
}


parser& parser::remove_dictionary(const i8 *nm)
{
  __D_ASSERT(nm != NULL);
  if ( unlikely(nm == NULL) )
    return *this;

  for (u32 i = 0, sz = m_dictionaries->size(); likely(i < sz); i++) {
    dictionary *dict = m_dictionaries->at(i);
    if ( unlikely(strcmp(dict->name(), nm) == 0) ) {
      m_dictionaries->remove(i);
      break;
    }
  }

  return *this;
}


inline parser& parser::remove_all_dictionaries()
{
  m_dictionaries->clear();
  return *this;
}


dictionary* parser::get_dictionary(const i8 *nm) const
{
  __D_ASSERT(nm != NULL);
  if ( unlikely(nm == NULL) )
    return NULL;

  for (u32 i = 0, sz = m_dictionaries->size(); likely(i < sz); i++) {
    dictionary *dict = m_dictionaries->at(i);
    if ( unlikely(strcmp(dict->name(), nm) == 0) )
      return dict;
  }

  return NULL;
}


chain<string>* parser::get_dictionary_names() const
{
  chain<string> *retval = new chain<string>;
  string *nm = NULL;

  try {
    for (u32 i = 0, sz = m_dictionaries->size(); likely(i < sz); i++) {
      nm = new string(m_dictionaries->at(i)->name());
      retval->add(nm);
      nm = NULL;
    }

    return retval;
  }

  catch (...) {
    delete retval;
    delete nm;
    throw;
  }
}


style* parser::add_style(const i8 *nm, color_t fg, color_t bg, attrset_t set)
{
  style *retval = NULL;
  try {
    retval = new style(nm, fg, bg, set);
    m_styles->add(retval);
    return retval;
  }

  catch (...) {
    delete retval;
    throw;
  }
}


inline parser& parser::add_style(style *stl)
{
  m_styles->add(stl);
  return *this;
}


parser& parser::remove_style(const i8 *nm)
{
  __D_ASSERT(nm != NULL);
  if ( unlikely(nm == NULL) )
    return *this;

  for (u32 i = 0, sz = m_styles->size(); likely(i < sz); i++) {
    style *stl = m_styles->at(i);
    if ( unlikely(strcmp(stl->name(), nm) == 0) ) {
      m_styles->remove(i);
      break;
    }
  }

  return *this;
}


inline parser& parser::remove_all_styles()
{
  m_styles->clear();
  return *this;
}


style* parser::get_style(const i8 *nm) const
{
  __D_ASSERT(nm != NULL);
  if ( unlikely(nm == NULL) )
    return m_fallback;

  for (u32 i = 0, sz = m_styles->size(); likely(i < sz); i++) {
    style *stl = m_styles->at(i);
    if ( unlikely(strcmp(stl->name(), nm) == 0) )
      return stl;
  }

  return m_fallback;
}


chain<string>* parser::get_style_names() const
{
  chain<string> *retval = new chain<string>;
  string *nm = NULL;

  try {
    for (u32 i = 0, sz = m_styles->size(); likely(i < sz); i++) {
      nm = new string(m_styles->at(i)->name());
      retval->add(nm);
      nm = NULL;
    }

    return retval;
  }

  catch (...) {
    delete retval;
    delete nm;
    throw;
  }
}


inline chain<string>* parser::parse(const i8 *syntax, bool icase) const
{
  if ( likely(syntax == NULL) )
    syntax = g_trace_syntax;

  return split(syntax, false, icase);
}


string* parser::highlight(const i8 *syntax, bool icase) const
{
  const i8 *num = "^0x[0-9a-f]+$|^[0-9]+$";

  string *retval = new string;
  chain<string> *tokens = NULL;

  /* If an exception occurs, release resources and rethrow it */
  try {
    /* Parse the buffer */
    tokens = parse(syntax, icase);

    /* Highlight and append each token in the result */
    for (u32 i = 0, sz = tokens->size(); likely(i < sz); i++) {
      string *token = tokens->at(i);

      /* Select the style for the current token */
      style *cur = NULL;
      if ( likely(i % 2 == 1) )
        cur = get_style("delimiter");

      else if ( unlikely(token->match(num, true)) )
        cur = get_style("number");

      else if ( unlikely(lookup(*token, "keywords")) )
        cur = get_style("keyword");

      else if ( unlikely(lookup(*token, "types")) )
        cur = get_style("type");

      /* Ignore case for extension (regexp) lookups */
      else if ( unlikely(lookup(*token, "extensions", true)) )
        cur = get_style("file");

      /* Select the style based on the next delimiter */
      else if ( likely(i < sz - 1) ) {
        string *delim = tokens->at(i + 1);
        i8 ch = delim->at(0);

        if ( unlikely(delim->cmp("::") == 0) )
          cur = get_style("scope");

        else if ( unlikely(ch == '(' || ch == '<' || ch == '\r') )
          cur = get_style("function");
      }

      /* If the token was not identified (plain text) */
      if ( unlikely(cur == NULL) )
        cur = m_fallback;

      /* Apply the style to the token and append it to the result buffer */
      cur->apply(*token);
      retval->append(*token);
    }

    delete tokens;
    return retval;
  }

  catch (...) {
    delete tokens;
    delete retval;
    throw;
  }
}


inline bool parser::lookup(const string &exp, const i8 *nm, bool icase) const
{
  dictionary *dict = get_dictionary(nm);
  if ( unlikely(dict == NULL) )
    return false;

  return dict->lookup(exp, icase) != NULL;
}


const i8* parser::lookup(const string &exp, bool icase) const
{
  for (u32 i = 0, sz = m_dictionaries->size(); likely(i < sz); i++) {
    dictionary *dict = m_dictionaries->at(i);
    if ( unlikely(dict->lookup(exp, icase) != NULL) )
      return dict->name();
  }

  return NULL;
}

}