update the ACM SIGPLAN files to latest layout and fileformat

[lyx.git] / src / Lexer.h

diff --git a/src/Lexer.h b/src/Lexer.h
index fbe27602c812fd49ca586a63768ec4d6cbe754c8..7f1f1a00f091735cfaf6105b74ab05b144d92392 100644 (file)
--- a/src/Lexer.h
+++ b/src/Lexer.h
@@ -19,21 +19,26 @@
 
 #include "support/strfwd.h"
 
-#include <iosfwd>
-
 
 namespace lyx {
 
 namespace support { class FileName; }
 
-///
-struct keyword_item {
-       ///
+class PushPopHelper;
+
+/** A helper structure to describe a keyword for the Lexer.
+       Usually used bundled in C style arrays and passed to the 
+       Lexer using a LexerKeywordTable object.
+*/
+struct LexerKeyword
+{
+       /// the string to be recognized
        char const * tag;
-       ///
+       /// a corresponding numerical id
        int code;
 };
 
+
 /** Generalized simple lexical analizer.
        Use the method isOK() to check if there is still data available
        for lexing. Use one of the the operators void* or ! to test if
@@ -41,22 +46,29 @@ struct keyword_item {
 
        Example:
 
-       int readParam(LyxLex &lex) {
-               int param = 1; // default value
+       int readParam(LyxLex & lex)
+       {
+               int param = 1;    // default value
                if (lex.isOK()) { // the lexer has data to read
-                       int p;    // temporary variable
+                       int p;          // temporary variable
                        lex >> p;
-                       if (lex) param = p; // only use the input if reading was successful
+                       if (lex)
+                               param = p; // only use the input if reading was successful
                }
                return param;
        }
 
     @see LyXRC.cpp for an example of usage.
   */
-class Lexer {
+class Lexer
+{
 public:
-       ///
-       Lexer(keyword_item *, int);
+       /// initialize Lexer with no special keywords.
+       Lexer(); 
+       /// initialize Lexer with a bunch of keywords
+       template<int N> Lexer(LexerKeyword (&table)[N])
+               : pimpl_(0) { init(table, N); }
+
        ///
        ~Lexer();
 
@@ -73,7 +85,7 @@ public:
        };
 
        /// stream is open and end of stream is not reached
-       /// FIXME: test also if pushTok is not empty
+       /// FIXME: test also if pushToken is not empty
        /// FIXME: the method should be renamed to something like
        ///        dataAvailable(), in order to reflect the real behavior
        bool isOK() const;
@@ -91,7 +103,7 @@ public:
        ///
        std::istream & getStream();
        /// Danger! Don't use it unless you know what you are doing.
-       void setLineNo(int l);
+       void setLineNumber(int l);
        /// Change the character that begins a comment. Default is '#'
        void setCommentChar(char c);
 
@@ -99,7 +111,7 @@ public:
        int lex();
 
        /** Just read the next word. If esc is true remember that
-           some chars might be escaped: "\ atleast
+           some chars might be escaped: "\ at least
        */
        bool next(bool esc = false);
 
@@ -111,8 +123,8 @@ public:
        /// Push a token, that next token got from lyxlex.
        void pushToken(std::string const &);
 
-       ///
-       int getLineNo() const;
+       /// return the current line number
+       int lineNumber() const;
 
        ///
        int getInteger() const;
@@ -139,7 +151,8 @@ public:
        bool eatLine();
 
        /// Pushes a token list on a stack and replaces it with a new one.
-       void pushTable(keyword_item *, int);
+       template<int N> void pushTable(LexerKeyword (&table)[N])
+               { pushTable(table, N); }
 
        /** Pops a token list into void and replaces it with the one now
            on top of the stack.
@@ -154,6 +167,8 @@ public:
 
        /// Prints the current token table on the supplied ostream.
        void printTable(std::ostream &);
+       /// Used to dispaly context information in case of errors.
+       void setContext(std::string const & functionName);
 
        /// extract string
        Lexer & operator>>(std::string &);
@@ -167,16 +182,30 @@ public:
        Lexer & operator>>(unsigned int &);
        /// extract bool
        Lexer & operator>>(bool &);
+       /// extract first char of the string
+       Lexer & operator>>(char &);
+
+       /// read and check a required token
+       Lexer & operator>>(char const * required);
+       /// check for an optional token and swallow it if present.
+       bool checkFor(char const * required);
 
        /// Quotes a string so that reading it again with Lexer::next(true)
        /// gets the original string
-       static std::string const quoteString(std::string const &);
+       static std::string quoteString(std::string const &);
 
 private:
-       /// noncopiable
+       /// noncopyable
        Lexer(Lexer const &);
        void operator=(Lexer const &);
 
+       ///
+       friend class PushPopHelper;
+
+       ///
+       void init(LexerKeyword *, int);
+       void pushTable(LexerKeyword *, int);
+
        ///
        class Pimpl;
        ///
@@ -186,20 +215,35 @@ private:
 };
 
 
+/// extract something constructable from a string, i.e. a LaTeX length
+template <class T>
+Lexer & operator>>(Lexer & lex, T & t)
+{
+       if (lex.next())
+               t = T(lex.getString());
+       return lex;
+}
+
+
 /** Use to enable multiple exit points.
     This is needed to ensure that the pop is done upon exit from methods
     with more than one exit point or that can return as a response to
     exceptions.
     @author Lgb
 */
-class PushPopHelper {
+class PushPopHelper
+{
 public:
        ///
-       PushPopHelper(Lexer & lexrc, keyword_item * i, int s) : lex(lexrc) {
-               lex.pushTable(i, s);
+       template<int N>
+       PushPopHelper(Lexer & l, LexerKeyword (&table)[N])
+               : lex(l)
+       {
+               lex.pushTable(table, N);
        }
        ///
-       ~PushPopHelper() {
+       ~PushPopHelper()
+       {
                lex.popTable();
        }
        ///