Add a Buffer::fully_loaded member function, returning true only when

[lyx.git] / src / tex2lyx / texparser.C

diff --git a/src/tex2lyx/texparser.C b/src/tex2lyx/texparser.C
index e9a9b9e6dce342203ac03e5a65e3092d95e154ba..e5612667d2ce3a2a8f1283c349ba545f6c5baf16 100644 (file)
--- a/src/tex2lyx/texparser.C
+++ b/src/tex2lyx/texparser.C
@@ -1,20 +1,27 @@
+/**
+ * \file texparser.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author André Pönitz
+ *
+ * Full author contact details are available in file CREDITS.
+ */
 
 #include <config.h>
 
 #include "texparser.h"
-#include "Lsstream.h"
 
 #include <iostream>
+#include <sstream>
 
 using std::cerr;
 using std::endl;
 using std::fill;
-using std::ios;
 using std::istream;
 using std::istringstream;
 using std::ostream;
 using std::string;
-using std::vector;
 
 
 namespace {
@@ -38,30 +45,30 @@ void catInit()
        fill(theCatcode + 'a', theCatcode + 'z' + 1, catLetter);
        fill(theCatcode + 'A', theCatcode + 'Z' + 1, catLetter);
 
-       theCatcode['\\'] = catEscape;
-       theCatcode['{']  = catBegin;
-       theCatcode['}']  = catEnd;
-       theCatcode['$']  = catMath;
-       theCatcode['&']  = catAlign;
+       theCatcode[int('\\')] = catEscape;
+       theCatcode[int('{')]  = catBegin;
+       theCatcode[int('}')]  = catEnd;
+       theCatcode[int('$')]  = catMath;
+       theCatcode[int('&')]  = catAlign;
        theCatcode[10]   = catNewline;
-       theCatcode['#']  = catParameter;
-       theCatcode['^']  = catSuper;
-       theCatcode['_']  = catSub;
-       theCatcode['\7f'] = catIgnore;
-       theCatcode[' ']  = catSpace;
-       theCatcode['\t'] = catSpace;
+       theCatcode[int('#')]  = catParameter;
+       theCatcode[int('^')]  = catSuper;
+       theCatcode[int('_')]  = catSub;
+       theCatcode[0x7f] = catIgnore;
+       theCatcode[int(' ')]  = catSpace;
+       theCatcode[int('\t')] = catSpace;
        theCatcode[13]   = catIgnore;
-       theCatcode['~']  = catActive;
-       theCatcode['%']  = catComment;
+       theCatcode[int('~')]  = catActive;
+       theCatcode[int('%')]  = catComment;
 
        // This is wrong!
-       theCatcode['@']  = catLetter;
+       theCatcode[int('@')]  = catLetter;
 }
 
 }
 
 
-// 
+//
 // catcodes
 //
 
@@ -92,6 +99,8 @@ ostream & operator<<(ostream & os, Token const & t)
                os << '\\' << t.cs() << ' ';
        else if (t.cat() == catLetter)
                os << t.character();
+       else if (t.cat() == catNewline)
+               os << "[\\n," << t.cat() << "]\n";
        else
                os << '[' << t.character() << ',' << t.cat() << ']';
        return os;
@@ -121,6 +130,7 @@ Parser::Parser(istream & is)
        tokenize(is);
 }
 
+
 Parser::Parser(string const & s)
        : lineno_(0), pos_(0)
 {
@@ -141,21 +151,21 @@ void Parser::pop_back()
 }
 
 
-Token const & Parser::prevToken() const
+Token const & Parser::prev_token() const
 {
        static const Token dummy;
        return pos_ > 0 ? tokens_[pos_ - 1] : dummy;
 }
 
 
-Token const & Parser::nextToken() const
+Token const & Parser::next_token() const
 {
        static const Token dummy;
        return good() ? tokens_[pos_] : dummy;
 }
 
 
-Token const & Parser::getToken()
+Token const & Parser::get_token()
 {
        static const Token dummy;
        //cerr << "looking at token " << tokens_[pos_] << " pos: " << pos_ << '\n';
@@ -163,14 +173,14 @@ Token const & Parser::getToken()
 }
 
 
-void Parser::skipSpaces()
+void Parser::skip_spaces()
 {
        while (1) {
-               if (nextToken().cat() == catSpace || nextToken().cat() == catNewline)
-                       getToken();
-               else if (nextToken().cat() == catComment) 
-                       while (nextToken().cat() != catNewline)
-                               getToken();
+               if (next_token().cat() == catSpace || next_token().cat() == catNewline)
+                       get_token();
+               else if (next_token().cat() == catComment)
+                       while (next_token().cat() != catNewline)
+                               get_token();
                else
                        break;
        }
@@ -199,7 +209,7 @@ char Parser::getChar()
 
 string Parser::getArg(char left, char right)
 {
-       skipSpaces();
+       skip_spaces();
 
        string result;
        char c = getChar();
@@ -216,7 +226,7 @@ string Parser::getArg(char left, char right)
 
 string Parser::getOpt()
 {
-       string res = getArg('[', ']');
+       string const res = getArg('[', ']');
        return res.size() ? '[' + res + ']' : string();
 }
 
@@ -238,23 +248,33 @@ void Parser::tokenize(istream & is)
                        case catNewline: {
                                ++lineno_;
                                is.get(c);
-                               if (catcode(c) == catNewline)
+                               if (catcode(c) == catNewline) {
+                                       //do {
+                                               is.get(c);
+                                       //} while (catcode(c) == catNewline);
                                        push_back(Token("par"));
-                               else {
+                               } else {
                                        push_back(Token('\n', catNewline));
-                                       is.putback(c);
                                }
+                               is.putback(c);
                                break;
                        }
 
-/*
                        case catComment: {
+                               push_back(Token(c, catComment));
                                while (is.get(c) && catcode(c) != catNewline)
-                                       ;
+                                       push_back(Token(c, catLetter));
+                               push_back(Token(c, catNewline));
                                ++lineno_;
+                               is.get(c);
+                               if (catcode(c) == catNewline) {
+                                       push_back(Token("par"));
+                                       ++lineno_;
+                               } else {
+                                       is.putback(c);
+                               }
                                break;
                        }
-*/
 
                        case catEscape: {
                                is.get(c);
@@ -317,12 +337,12 @@ void Parser::error(string const & msg)
 string Parser::verbatimOption()
 {
        string res;
-       if (nextToken().character() == '[') {
-               Token t = getToken();
-               for (Token t = getToken(); t.character() != ']' && good(); t = getToken()) {
+       if (next_token().character() == '[') {
+               Token t = get_token();
+               for (Token t = get_token(); t.character() != ']' && good(); t = get_token()) {
                        if (t.cat() == catBegin) {
                                putback();
-                               res += '{' + verbatimItem() + '}';
+                               res += '{' + verbatim_item() + '}';
                        } else
                                res += t.asString();
                }
@@ -331,35 +351,35 @@ string Parser::verbatimOption()
 }
 
 
-string Parser::verbatimItem()
+string Parser::verbatim_item()
 {
        if (!good())
                error("stream bad");
-       skipSpaces();
-       if (nextToken().cat() == catBegin) {
-               Token t = getToken(); // skip brace
+       skip_spaces();
+       if (next_token().cat() == catBegin) {
+               Token t = get_token(); // skip brace
                string res;
-               for (Token t = getToken(); t.cat() != catEnd && good(); t = getToken()) {
+               for (Token t = get_token(); t.cat() != catEnd && good(); t = get_token()) {
                        if (t.cat() == catBegin) {
                                putback();
-                               res += '{' + verbatimItem() + '}';
+                               res += '{' + verbatim_item() + '}';
                        }
                        else
                                res += t.asInput();
                }
                return res;
        }
-       return getToken().asInput();
+       return get_token().asInput();
 }
 
 
 void Parser::setCatCode(char c, CatCode cat)
 {
-       theCatcode[c] = cat;    
+       theCatcode[(unsigned char)c] = cat;
 }
 
 
 CatCode Parser::getCatCode(char c) const
 {
-       return theCatcode[c];
+       return theCatcode[(unsigned char)c];
 }