lisp::Parser Class Reference

#include <parser.hpp>

List of all members.

Public Member Functions
	Parser (bool translate=true)
	~Parser ()
const Lisp *	parse (const std::string &filename)
	Parses a lispfile and returns the s-expression structure.
const Lisp *	parse (std::istream &stream, const std::string &sourcename)
	Same as parse but reads from a generic std::istream.
Private Member Functions
void	parse_error (const char *msg) const __attribute__((__noreturn__))
const Lisp *	read ()
	Parser (const Parser &)
Parser &	operator= (const Parser &)
Private Attributes
Lexer *	lexer
std::string	filename
tinygettext::DictionaryManager *	dictionary_manager
tinygettext::Dictionary *	dictionary
Lexer::TokenType	token
obstack	obst

---

Detailed Description

Definition at line 34 of file parser.hpp.

---

Constructor & Destructor Documentation

lisp::Parser::Parser

(

bool

translate = true

)

Definition at line 33 of file parser.cpp.

References dictionary_manager, g_config, Config::locale, and obst.

                             :
  lexer(0), 
  filename(),
  dictionary_manager(0), 
  dictionary(0),
  token(),
  obst()
{
  if(translate) {
    dictionary_manager = new tinygettext::DictionaryManager();
    dictionary_manager->set_charset("UTF-8");
    if (g_config && (g_config->locale != "")) 
      dictionary_manager->set_language(tinygettext::Language::from_name(g_config->locale));
  }

  obstack_init(&obst);
}

lisp::Parser::~Parser

(

)

Definition at line 51 of file parser.cpp.

References dictionary_manager, lexer, and obst.

{
  obstack_free(&obst, NULL);
  delete lexer;
  delete dictionary_manager;
}

lisp::Parser::Parser

(

const Parser &

)

[private]

---

Member Function Documentation

const Lisp * lisp::Parser::parse

(

const std::string &

filename

)

Parses a lispfile and returns the s-expression structure.

Note that all memory is held by the parser so don't destroy the parser before you are finished with the lisp tree

Definition at line 68 of file parser.cpp.

References dictionary, dictionary_manager, and lisp::dirname().

Referenced by AddonManager::check_online(), ObjectFactory::create(), TitleScreen::get_level_name(), worldmap::WorldMap::get_level_title(), worldmap::WorldMap::load(), World::load(), Config::load(), SpriteManager::load(), Level::load(), CameraConfig::load(), load_music_file(), World::load_state(), Font::loadFontFile(), TileSetParser::parse(), Addon::parse(), and TextScroller::TextScroller().

{
  IFileStreambuf ins(filename);
  std::istream in(&ins);

  if(!in.good()) {
    std::stringstream msg;
    msg << "Parser problem: Couldn't open file '" << filename << "'.";
    throw std::runtime_error(msg.str());
  }

  if(dictionary_manager) {
    std::string rel_dir = dirname (filename);
    char **searchpath = PHYSFS_getSearchPath();
    for(char** i = searchpath; *i != NULL; i++)
    {
      std::string abs_dir = std::string (*i) + PHYSFS_getDirSeparator () + rel_dir;
      dictionary_manager->add_directory (abs_dir);
    }
    dictionary = & (dictionary_manager->get_dictionary());
  }

  return parse(in, filename);
}

const Lisp * lisp::Parser::parse	(	std::istream &	stream,
		const std::string &	sourcename
	)

Same as parse but reads from a generic std::istream.

The sourcename is used for errormessages to indicate the source of the data.

Definition at line 94 of file parser.cpp.

References lisp::Lisp::cons, filename, lisp::Lexer::getNextToken(), lexer, obst, read(), token, lisp::Lisp::TYPE_CONS, and lisp::Lisp::v.

{
  delete lexer;
  lexer = new Lexer(stream);

  this->filename = sourcename;
  token = lexer->getNextToken();

  Lisp* result = new(obst) Lisp(Lisp::TYPE_CONS);
  result->v.cons.car = read();
  result->v.cons.cdr = 0;

  delete lexer;
  lexer = 0;

  return result;
}

void lisp::Parser::parse_error

(

const char *

msg

)

const [private]

Definition at line 113 of file parser.cpp.

References filename, lisp::Lexer::getLineNumber(), and lexer.

Referenced by read().

{
  std::stringstream emsg;
  emsg << "Parse Error at '" << filename << "' line " << lexer->getLineNumber()
       << ": " << msg;
  throw std::runtime_error(emsg.str());
}

const Lisp * lisp::Parser::read

(

)

[private]

Definition at line 122 of file parser.cpp.

References lisp::Lisp::boolean, lisp::Lisp::cons, dictionary, lisp::Lexer::getNextToken(), lisp::Lexer::getString(), lisp::Lisp::integer, lexer, obst, parse_error(), lisp::Lisp::real, lisp::Lisp::string, token, lisp::Lexer::TOKEN_CLOSE_PAREN, lisp::Lexer::TOKEN_EOF, lisp::Lexer::TOKEN_FALSE, lisp::Lexer::TOKEN_INTEGER, lisp::Lexer::TOKEN_OPEN_PAREN, lisp::Lexer::TOKEN_REAL, lisp::Lexer::TOKEN_STRING, lisp::Lexer::TOKEN_SYMBOL, lisp::Lexer::TOKEN_TRUE, lisp::Lisp::TYPE_BOOLEAN, lisp::Lisp::TYPE_CONS, lisp::Lisp::TYPE_INTEGER, lisp::Lisp::TYPE_REAL, lisp::Lisp::TYPE_STRING, lisp::Lisp::TYPE_SYMBOL, and lisp::Lisp::v.

Referenced by parse().

{
  Lisp* result;
  switch(token) {
    case Lexer::TOKEN_EOF: {
      parse_error("Unexpected EOF.");
    }
    case Lexer::TOKEN_CLOSE_PAREN: {
      parse_error("Unexpected ')'.");
    }
    case Lexer::TOKEN_OPEN_PAREN: {
      result = new(obst) Lisp(Lisp::TYPE_CONS);

      token = lexer->getNextToken();
      if(token == Lexer::TOKEN_CLOSE_PAREN) {
        result->v.cons.car = 0;
        result->v.cons.cdr = 0;
        break;
      }

      if(token == Lexer::TOKEN_SYMBOL &&
         strcmp(lexer->getString(), "_") == 0) {
        // evaluate translation function (_ str) in place here
        token = lexer->getNextToken();
        if(token != Lexer::TOKEN_STRING)
          parse_error("Expected string after '(_'");

        result = new(obst) Lisp(Lisp::TYPE_STRING);
        if(dictionary) {
          std::string translation = dictionary->translate(lexer->getString());
          result->v.string = new(obst) char[translation.size()+1];
          memcpy(result->v.string, translation.c_str(), translation.size()+1);
        } else {
          size_t len = strlen(lexer->getString()) + 1;
          result->v.string = new(obst) char[len];
          memcpy(result->v.string, lexer->getString(), len);
        }
        token = lexer->getNextToken();
        if(token != Lexer::TOKEN_CLOSE_PAREN)
          parse_error("Expected ')' after '(_ string'");
        break;
      }

      Lisp* cur = result;
      do {
        cur->v.cons.car = read();
        if(token == Lexer::TOKEN_CLOSE_PAREN) {
          cur->v.cons.cdr = 0;
          break;
        }
        Lisp *newcur = new(obst) Lisp(Lisp::TYPE_CONS);
        cur->v.cons.cdr = newcur;
        cur = newcur;
      } while(1);

      break;
    }
    case Lexer::TOKEN_SYMBOL: {
      result = new(obst) Lisp(Lisp::TYPE_SYMBOL);
      size_t len = strlen(lexer->getString()) + 1;
      result->v.string = new(obst) char[len];
      memcpy(result->v.string, lexer->getString(), len);
      break;
    }
    case Lexer::TOKEN_STRING: {
      result = new(obst) Lisp(Lisp::TYPE_STRING);
      size_t len = strlen(lexer->getString()) + 1;
      result->v.string = new(obst) char[len];
      memcpy(result->v.string, lexer->getString(), len);
      break;
    }
    case Lexer::TOKEN_INTEGER:
      result = new(obst) Lisp(Lisp::TYPE_INTEGER);
      sscanf(lexer->getString(), "%d", &result->v.integer);
      break;
    case Lexer::TOKEN_REAL:
      result = new(obst) Lisp(Lisp::TYPE_REAL);
      sscanf(lexer->getString(), "%f", &result->v.real);
      break;
    case Lexer::TOKEN_TRUE:
      result = new(obst) Lisp(Lisp::TYPE_BOOLEAN);
      result->v.boolean = true;
      break;
    case Lexer::TOKEN_FALSE:
      result = new(obst) Lisp(Lisp::TYPE_BOOLEAN);
      result->v.boolean = false;
      break;

    default:
      // this should never happen
      result = NULL;
      assert(false);
  }

  token = lexer->getNextToken();
  return result;
}

Parser& lisp::Parser::operator=

(

const Parser &

)

[private]

---

Member Data Documentation

Lexer* lisp::Parser::lexer [private]

Definition at line 58 of file parser.hpp.

Referenced by parse(), parse_error(), read(), and ~Parser().

std::string lisp::Parser::filename [private]

Definition at line 59 of file parser.hpp.

Referenced by parse(), and parse_error().

tinygettext::DictionaryManager* lisp::Parser::dictionary_manager [private]

Definition at line 60 of file parser.hpp.

Referenced by parse(), Parser(), and ~Parser().

tinygettext::Dictionary* lisp::Parser::dictionary [private]

Definition at line 61 of file parser.hpp.

Referenced by parse(), and read().

Lexer::TokenType lisp::Parser::token [private]

Definition at line 62 of file parser.hpp.

Referenced by parse(), and read().

struct obstack lisp::Parser::obst [private]

Definition at line 64 of file parser.hpp.

Referenced by parse(), Parser(), read(), and ~Parser().

---

The documentation for this class was generated from the following files:

• src/lisp/parser.hpp
• src/lisp/parser.cpp

---