slexer.hpp

Go to the documentation of this file.

// +-------------------------------------------------------------------------+
// |               I__n__t__e__L__i__b           0.6.10 development          |
// | Copyright (c) Andrey Vikt. Stolyarov <crocodil_AT_croco.net> 2000-2007. |
// |                                                                         |
// | This is free software. The library part is available under              |
// |                               GNU LESSER GENERAL PUBLIC LICENSE v.2.1.  |
// | GNU LGPL v2.1 is found in docs/gnu_gpl2.txt,  or at  http://www.gnu.org |
// |     Please see also docs/readme.txt and visit http://www.intelib.org    |
// |                                                                         |
// | !!! THERE IS NO WARRANTY OF ANY KIND, NEITHER EXPRESSED NOR IMPLIED !!! |
// +-------------------------------------------------------------------------+




#ifndef INTELIB_SLEXER_HPP_SENTRY
#define INTELIB_SLEXER_HPP_SENTRY

#include "../sexpress/sexpress.hpp"
#include "../sexpress/sstring.hpp"

extern SLabel LexemaEof;

    /* this paranoia check should in fact never be positive, but... */
#if defined(EOF) && EOF != -1
#error This version assumes EOF is -1 and that is not true for your situation
    /* in case it is, edit slexer.cpp, remove the definition of EOF and
       add ``#include <stdio.h>'' instead... and, well, be sure to 
       report this :) */
#endif



class IntelibSLexAnalyser {

    struct SpecChar {
        char ch;
        enum {
            non_term, term, non_delim, read_rest, read_string, ignore_until
        } status : 8;
        SpecChar *sub;     
        SpecChar *next;    
        char closer[4];    

        SReference token;  
        SReference (*makestring)(const char *str);

        SpecChar() : ch(0), status(non_term), sub(0), next(0),
                     token(), makestring(0)
            { closer[0] = 0; }
    } *specchars, **special_state;

    SString delimiter_chars;

    enum State { 
        home,        // the home state
        string,      // reading a string constant until a closer
        stringq,     // within a string, reading escaped char
        token,       // reading a token (either a number or a symbol)
        token_force, // force reading one char, then go on as for a token
        special,     // special lexic element
        special2,    // check the next char, there can be longer delimiter
        special3,    // check the next char, make the non-delim token if
                     //    and only if the next char is a space or
                     //    delimiter
        comment      // ignore everything until the closer is found
    } state;
    const char *closer;    
    SReference (*string_finalizer)(const char *);
    int comment_closer_index; 
    int postponed_char;
    SString buf;

    int line, lexline;
    SReference lex;
    const char *error_message;
public:
    IntelibSLexAnalyser();
    ~IntelibSLexAnalyser();

    bool AddDelimiter(const char *prefix, const SReference &token);
    bool AddNonDelimiter(const char *prefix, const SReference &token);

    bool AddTokenStarter(const char *prefix,
                         SReference (*fun)(const char *str) = 0);
    bool AddStringStarter(const char *prefix, int closer_char,
                          SReference (*fun)(const char *str) = 0);
    bool AddCommentStarter(const char *prefix, const char *closer = "\n");

    enum FeedResult { 
        res_empty,    
        res_ready,    
        res_continue, 
        res_eof,      
        res_error     
    };


    FeedResult FeedChar(int c);

    SReference Get() const;

    int GetLine() const { return line; }
    void SetLine(int l) { line = l; }
    const char *GetErrorMessage() const { return error_message; }

    void Drop();

private:
    SpecChar *AddSpecial(const char *prefix, bool extendable);
    SpecChar *DoAddSpecial(SpecChar **p, const char *str, bool ex);

    FeedResult Home(int c);
    FeedResult String(int c);
    FeedResult Stringq(int c);
    FeedResult Token(int c);
    FeedResult Special(int c);
    FeedResult Special3(int c);
    FeedResult Comment(int c);

    SReference ProcessToken(const char *s);

    bool IsDelimiterChar(int c);
};

#endif

---