#include <config.h>
+#include "Encoding.h"
#include "Parser.h"
#include <iostream>
-#include <sstream>
using namespace std;
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")
{
}
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")
{
}
}
+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()
+// 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';
}
-void Parser::skip_spaces(bool skip_comments)
+bool Parser::skip_spaces(bool skip_comments)
{
// We just silently return if we have no more tokens.
// skip_spaces() should be callable at any time,
// the caller must check p::good() anyway.
+ bool skipped = false;
while (good()) {
get_token();
if (isParagraph()) {
putback();
break;
}
- if ( curr_token().cat() == catSpace ||
- curr_token().cat() == catNewline ||
- (curr_token().cat() == catComment && curr_token().cs().empty()))
+ if (curr_token().cat() == catSpace ||
+ curr_token().cat() == catNewline) {
+ skipped = true;
+ continue;
+ }
+ if ((curr_token().cat() == catComment && curr_token().cs().empty()))
continue;
if (skip_comments && curr_token().cat() == catComment)
cerr << " Ignoring comment: " << curr_token().asInput();
break;
}
}
+ return skipped;
}
{
if (!good())
error("The input stream is not well...");
- return tokens_[pos_++].character();
+ return get_token().character();
}
}
-string Parser::getOpt()
+string Parser::getOpt(bool keepws)
+{
+ string const res = getArg('[', ']');
+ if (res.empty()) {
+ if (keepws)
+ unskip_spaces(true);
+ return string();
+ }
+ return '[' + res + ']';
+}
+
+
+string Parser::getOptContent()
+// the same as getOpt but without the brackets
{
string const res = getArg('[', ']');
- return res.empty() ? string() : '[' + res + ']';
+ return res.empty() ? string() : res;
}
void Parser::tokenize_one()
{
catInit();
- char c;
+ 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)));
}
+ //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;