#include <config.h>
+#include "Encoding.h"
#include "Parser.h"
#include <iostream>
-#include <sstream>
using namespace std;
void catInit()
{
+ static bool init_done = false;
+ if (init_done)
+ return;
+ init_done = true;
+
fill(theCatcode, theCatcode + 256, catOther);
fill(theCatcode + 'a', theCatcode + 'z' + 1, catLetter);
fill(theCatcode + 'A', theCatcode + 'Z' + 1, catLetter);
theCatcode[int('@')] = catLetter;
}
-
/*!
* Translate a line ending to '\n'.
* \p c must have catcode catNewline, and it must be the last character read
* from \p is.
*/
-char getNewline(istream & is, char c)
+char_type getNewline(idocstream & is, char_type c)
{
// we have to handle 3 different line endings:
// - UNIX (\n)
// - DOS (\r\n)
if (c == '\r') {
// MAC or DOS
- if (is.get(c) && c != '\n') {
+ char_type wc;
+ if (is.get(wc) && wc != '\n') {
// MAC
- is.putback(c);
+ is.putback(wc);
}
return '\n';
}
return c;
}
-}
-
-
-//
-// catcodes
-//
-
-CatCode catcode(unsigned char c)
+CatCode catcode(char_type c)
{
- return theCatcode[c];
+ if (c < 256)
+ return theCatcode[(unsigned char)c];
+ return catOther;
}
+}
//
else if (t.cat() == catEscape)
os << '\\' << t.cs() << ' ';
else if (t.cat() == catLetter)
- os << t.character();
+ os << t.cs();
else if (t.cat() == catNewline)
os << "[" << t.cs().size() << "\\n," << t.cat() << "]\n";
else
- os << '[' << t.character() << ',' << t.cat() << ']';
+ os << '[' << t.cs() << ',' << t.cat() << ']';
return os;
}
-string Token::asString() const
-{
- return cs_.size() ? cs_ : string(1, char_);
-}
-
-
string Token::asInput() const
{
if (cat_ == catComment)
return '%' + cs_ + '\n';
- if (cat_ == catSpace || cat_ == catNewline)
- return cs_;
- return char_ ? string(1, char_) : '\\' + cs_;
+ if (cat_ == catEscape)
+ return '\\' + cs_;
+ return cs_;
}
//
-Parser::Parser(istream & is)
- : lineno_(0), pos_(0), iss_(0), is_(is)
+Parser::Parser(idocstream & is)
+ : lineno_(0), pos_(0), iss_(0), is_(is), encoding_latex_("utf8")
{
- tokenize();
}
Parser::Parser(string const & s)
- : lineno_(0), pos_(0), iss_(new istringstream(s)), is_(*iss_)
+ : lineno_(0), pos_(0),
+ iss_(new idocstringstream(from_utf8(s))), is_(*iss_),
+ encoding_latex_("utf8")
{
- tokenize();
}
}
+void Parser::setEncoding(std::string const & e)
+{
+ Encoding const * enc = encodings.fromLaTeXName(e);
+ if (!enc) {
+ cerr << "Unknown encoding " << e << ". Ignoring." << std::endl;
+ return;
+ }
+ //cerr << "setting encoding to " << enc->iconvName() << std::endl;
+ is_ << lyx::setEncoding(enc->iconvName());
+ encoding_latex_ = e;
+}
+
+
void Parser::push_back(Token const & t)
{
tokens_.push_back(t);
}
-Token const & Parser::prev_token() const
+// We return a copy here because the tokens_ vector may get reallocated
+Token const Parser::prev_token() const
{
static const Token dummy;
return pos_ > 1 ? tokens_[pos_ - 2] : dummy;
}
-Token const & Parser::curr_token() const
+// We return a copy here because the tokens_ vector may get reallocated
+Token const Parser::curr_token() const
{
static const Token dummy;
return pos_ > 0 ? tokens_[pos_ - 1] : dummy;
}
-Token const & Parser::next_token() const
+// We return a copy here because the tokens_ vector may get reallocated
+Token const Parser::next_token()
{
static const Token dummy;
return good() ? tokens_[pos_] : dummy;
}
-Token const & Parser::get_token()
+// We return a copy here because the tokens_ vector may get reallocated
+Token const Parser::get_token()
{
static const Token dummy;
//cerr << "looking at token " << tokens_[pos_] << " pos: " << pos_ << '\n';
}
-bool Parser::isParagraph() const
+bool Parser::isParagraph()
{
// A new paragraph in TeX ist started
// - either by a newline, following any amount of whitespace
}
-bool Parser::good() const
+bool Parser::good()
{
+ if (pos_ < tokens_.size())
+ return true;
+ tokenize_one();
return pos_ < tokens_.size();
}
{
if (!good())
error("The input stream is not well...");
- return tokens_[pos_++].character();
+ return get_token().character();
}
}
+string Parser::getOptContent()
+// the same as getOpt but without the brackets
+{
+ string const res = getArg('[', ']');
+ return res.empty() ? string() : res;
+}
+
+
string Parser::getFullParentheseArg()
{
Arg arg = getFullArg('(', ')');
void Parser::tokenize_one()
{
- char c;
+ catInit();
+ char_type c;
if (!is_.get(c))
return;
- //cerr << "reading c: " << c << "\n";
switch (catcode(c)) {
case catSpace: {
- string s(1, c);
+ docstring s(1, c);
while (is_.get(c) && catcode(c) == catSpace)
s += c;
if (catcode(c) != catSpace)
case catNewline: {
++lineno_;
- string s(1, getNewline(is_, c));
+ docstring s(1, getNewline(is_, c));
while (is_.get(c) && catcode(c) == catNewline) {
++lineno_;
s += getNewline(is_, c);
case catComment: {
// We don't treat "%\n" combinations here specially because
// we want to preserve them in the preamble
- string s;
+ docstring s;
while (is_.get(c) && catcode(c) != catNewline)
s += c;
// handle possible DOS line ending
if (!is_) {
error("unexpected end of input");
} else {
- string s(1, c);
+ docstring s(1, c);
if (catcode(c) == catLetter) {
// collect letters
while (is_.get(c) && catcode(c) == catLetter)
}
case catIgnore: {
- cerr << "ignoring a char: " << int(c) << "\n";
+ cerr << "ignoring a char: " << c << "\n";
break;
}
default:
- push_back(Token(c, catcode(c)));
+ push_back(Token(docstring(1, c), catcode(c)));
}
-}
-
-
-void Parser::tokenize()
-{
- static bool init_done = false;
-
- if (!init_done) {
- catInit();
- init_done = true;
- }
-
- while (is_)
- tokenize_one();
+ //cerr << tokens_.back();
}
string res;
if (next_token().character() == '[') {
Token t = get_token();
- for (Token t = get_token(); t.character() != ']' && good(); t = get_token()) {
+ for (t = get_token(); t.character() != ']' && good(); t = get_token()) {
if (t.cat() == catBegin) {
putback();
res += '{' + verbatim_item() + '}';
} else
- res += t.asString();
+ res += t.cs();
}
}
return res;
projects / lyx.git / blobdiff