Fade out and pause music on death and resume on restart of level, fixes #1064
[supertux.git] / src / lisp / parser.cpp
1 //  SuperTux
2 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
3 //
4 //  This program is free software: you can redistribute it and/or modify
5 //  it under the terms of the GNU General Public License as published by
6 //  the Free Software Foundation, either version 3 of the License, or
7 //  (at your option) any later version.
8 //
9 //  This program is distributed in the hope that it will be useful,
10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 //  GNU General Public License for more details.
13 //
14 //  You should have received a copy of the GNU General Public License
15 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
16
17 #include <sstream>
18 #include <stdexcept>
19 #include <tinygettext/tinygettext.hpp>
20 #include <physfs.h>
21
22 #include "lisp/lisp.hpp"
23 #include "lisp/parser.hpp"
24 #include "util/gettext.hpp"
25 #include "util/obstackpp.hpp"
26 #include "physfs/ifile_stream.hpp"
27 #include "physfs/ifile_streambuf.hpp"
28 #include "supertux/globals.hpp"
29
30 #include "supertux/gameconfig.hpp"
31
32 namespace lisp {
33
34 Parser::Parser(bool translate) :
35   lexer(0),
36   filename(),
37   dictionary_manager(0),
38   dictionary(0),
39   token(),
40   searchpath(),
41   obst()
42 {
43   if(translate) {
44     dictionary_manager = new tinygettext::DictionaryManager();
45     dictionary_manager->set_charset("UTF-8");
46     if (g_config) {
47       if (g_config->locale != "") {
48         dictionary_manager->set_language(tinygettext::Language::from_name(g_config->locale));
49       }
50       else if(g_dictionary_manager && g_dictionary_manager->get_language()) {
51         // Language set to auto-detect?
52         dictionary_manager->set_language(g_dictionary_manager->get_language());
53       }
54     }
55   }
56
57   obstack_init(&obst);
58   searchpath = PHYSFS_getSearchPath();
59 }
60
61 Parser::~Parser()
62 {
63   obstack_free(&obst, NULL);
64   delete lexer;
65   delete dictionary_manager;
66   PHYSFS_freeList(searchpath);
67 }
68
69 static std::string dirname(const std::string& filename)
70 {
71   std::string::size_type p = filename.find_last_of('/');
72   if(p == std::string::npos)
73     return "";
74
75   return filename.substr(0, p+1);
76 }
77
78 const Lisp*
79 Parser::parse(const std::string& filename_)
80 {
81   IFileStreambuf ins(filename_);
82   std::istream in(&ins);
83
84   if(!in.good()) {
85     std::stringstream msg;
86     msg << "Parser problem: Couldn't open file '" << filename_ << "'.";
87     throw std::runtime_error(msg.str());
88   }
89
90   if(dictionary_manager) {
91     std::string rel_dir = dirname (filename_);
92     for(char** i = searchpath; *i != NULL; i++)
93     {
94       std::string abs_dir = std::string (*i) + PHYSFS_getDirSeparator () + rel_dir;
95       dictionary_manager->add_directory (abs_dir);
96     }
97     dictionary = & (dictionary_manager->get_dictionary());
98   }
99
100   return parse(in, filename_);
101 }
102
103 const Lisp*
104 Parser::parse(std::istream& stream, const std::string& sourcename)
105 {
106   delete lexer;
107   lexer = new Lexer(stream);
108
109   this->filename = sourcename;
110   token = lexer->getNextToken();
111
112   Lisp* result = new(obst) Lisp(Lisp::TYPE_CONS);
113   result->v.cons.car = read();
114   result->v.cons.cdr = 0;
115
116   delete lexer;
117   lexer = 0;
118
119   return result;
120 }
121
122 void
123 Parser::parse_error(const char* msg) const
124 {
125   std::stringstream emsg;
126   emsg << "Parse Error at '" << filename << "' line " << lexer->getLineNumber()
127        << ": " << msg;
128   throw std::runtime_error(emsg.str());
129 }
130
131 const Lisp*
132 Parser::read()
133 {
134   Lisp* result;
135   switch(token) {
136     case Lexer::TOKEN_EOF: {
137       parse_error("Unexpected EOF.");
138     }
139     case Lexer::TOKEN_CLOSE_PAREN: {
140       parse_error("Unexpected ')'.");
141     }
142     case Lexer::TOKEN_OPEN_PAREN: {
143       result = new(obst) Lisp(Lisp::TYPE_CONS);
144
145       token = lexer->getNextToken();
146       if(token == Lexer::TOKEN_CLOSE_PAREN) {
147         result->v.cons.car = 0;
148         result->v.cons.cdr = 0;
149         break;
150       }
151
152       if(token == Lexer::TOKEN_SYMBOL &&
153          strcmp(lexer->getString(), "_") == 0) {
154         // evaluate translation function (_ str) in place here
155         token = lexer->getNextToken();
156         if(token != Lexer::TOKEN_STRING)
157           parse_error("Expected string after '(_'");
158
159         result = new(obst) Lisp(Lisp::TYPE_STRING);
160         if(dictionary) {
161           std::string translation = dictionary->translate(lexer->getString());
162           result->v.string = new(obst) char[translation.size()+1];
163           memcpy(result->v.string, translation.c_str(), translation.size()+1);
164         } else {
165           size_t len = strlen(lexer->getString()) + 1;
166           result->v.string = new(obst) char[len];
167           memcpy(result->v.string, lexer->getString(), len);
168         }
169         token = lexer->getNextToken();
170         if(token != Lexer::TOKEN_CLOSE_PAREN)
171           parse_error("Expected ')' after '(_ string'");
172         break;
173       }
174
175       Lisp* cur = result;
176       do {
177         cur->v.cons.car = read();
178         if(token == Lexer::TOKEN_CLOSE_PAREN) {
179           cur->v.cons.cdr = 0;
180           break;
181         }
182         Lisp *newcur = new(obst) Lisp(Lisp::TYPE_CONS);
183         cur->v.cons.cdr = newcur;
184         cur = newcur;
185       } while(1);
186
187       break;
188     }
189     case Lexer::TOKEN_SYMBOL: {
190       result = new(obst) Lisp(Lisp::TYPE_SYMBOL);
191       size_t len = strlen(lexer->getString()) + 1;
192       result->v.string = new(obst) char[len];
193       memcpy(result->v.string, lexer->getString(), len);
194       break;
195     }
196     case Lexer::TOKEN_STRING: {
197       result = new(obst) Lisp(Lisp::TYPE_STRING);
198       size_t len = strlen(lexer->getString()) + 1;
199       result->v.string = new(obst) char[len];
200       memcpy(result->v.string, lexer->getString(), len);
201       break;
202     }
203     case Lexer::TOKEN_INTEGER:
204       result = new(obst) Lisp(Lisp::TYPE_INTEGER);
205       result->v.integer = atoi(lexer->getString());
206       break;
207     case Lexer::TOKEN_REAL:
208       result = new(obst) Lisp(Lisp::TYPE_REAL);
209       result->v.real = strtof(lexer->getString(), NULL);
210       break;
211     case Lexer::TOKEN_TRUE:
212       result = new(obst) Lisp(Lisp::TYPE_BOOLEAN);
213       result->v.boolean = true;
214       break;
215     case Lexer::TOKEN_FALSE:
216       result = new(obst) Lisp(Lisp::TYPE_BOOLEAN);
217       result->v.boolean = false;
218       break;
219
220     default:
221       // this should never happen
222       result = NULL;
223       assert(false);
224   }
225
226   token = lexer->getNextToken();
227   return result;
228 }
229
230 } // end of namespace lisp
231
232 /* EOF */