sreader.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_SREADER_HPP_SENTRY
#define INTELIB_SREADER_HPP_SENTRY

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


class IntelibPackage {
public:
    virtual ~IntelibPackage() {}

    virtual SReference MakeSymbol(const char *name) = 0;
};


class IntelibDummyPackage : public IntelibPackage {
public:
    IntelibDummyPackage() {}
    virtual SReference MakeSymbol(const char *name);
};

extern IntelibDummyPackage TheDummyPackage;



class IntelibGenericReader {
public:
    typedef SReference (*process_function)(const SReference&);
private:
    class IntelibSLexAnalyser *lexer;
    struct SpecialLexic {
        SString id; 
        enum sl_type { quoter, sequence, seq_closer, cons_sign } t;
            /* for quoter, process is given the expression which follows
                 the quoter lexem 
               for sequence, process is given the list of members of the
                 sequence
               for seq_closer and cons_sign, process is ignored (should be 0)
             */
        process_function process;
        SReference the_closer; 
        SReference the_cons_sign; 
        SpecialLexic *next;
    } *first_sl;
    SpecialLexic* AddSpecialLexic(const char *str,
                                  SpecialLexic::sl_type t,
                                  process_function proc);

    IntelibPackage *the_package;
    bool uppercase;

    SQueue parts;
    SQueue ready;
    int unclosed_brackets;
    SString file_name;
public:
    IntelibGenericReader();
    ~IntelibGenericReader();

    void AddDelimiter(const char *str, const SReference &tok);

    void AddToken(const char *str, const SReference &tok);

    void AddTokenType(const char *str, SReference (*fun)(const char*));

    void AddStringLiteral(const char *str, int closing_char,
                          SReference (*fun)(const char*) = 0);

    void AddQuoter(const char *str, process_function proc);

    void AddSequenceOpener(const char *str,
                           process_function proc,
                           const char *closer,
                           const char *cons_sign = 0,
                           bool cons_sign_delimiter = false);

    void AddTailSeparator(const char *str, bool is_delimiter = false);


    void AddComment(const char *starter, const char *closer = "\n");


    IntelibPackage* SetPackage(IntelibPackage *a_package)
    {
        IntelibPackage *old = the_package;
        the_package = a_package;
        return old;
    } 

    void SetUppercase(bool u) { uppercase = u; }


    void SetLine(int l, const SString &afn = "");
    int GetLine() const;
    const SString& GetFileName() const { return file_name; }

    void FeedChar(int c);
    void FeedString(const char *s);
    void FeedEof() { FeedChar(-1); }


    bool IsEmpty() const { return parts.IsEmpty() && ready.IsEmpty(); }
    bool IsReady() const { return !ready.IsEmpty(); }


    SReference Get();

    void Drop();


    SReference Read(const SStreamRef& stream);


    static SLabel& EofMarker;

private:
    void HandleLexema(const SReference &lexpair); // lexpair is (lex . line)
    void HandleSpecialLex(SpecialLexic *sp, int line);
    SReference DoMakeSymbol(const char *s) const;
    void HandleEof();
    void FinishParts();
    SReference DoFinishParts();
    SReference DoFinishPartsSeq(const SReference& closer,
                                const SReference& conser,
                                int begline);
};


class IntelibReader : public IntelibGenericReader {
public:
    IntelibReader();
};


class IntelibX_reader_error : public IntelibX {
    int line, beg_line;
    SString fname;
public:

    IntelibX_reader_error(SReference a_param,
                          int a_line,
                          int a_begline = -1,
                          const SString &afn = "");
    int Line() const { return line; }
    int ExpBegLine() const { return beg_line; }
    const SString& FileName() const { return fname; }
};


class IntelibX_reader_not_ready : public IntelibX {
public:
    IntelibX_reader_not_ready();
};


class IntelibX_read_eof : public IntelibX {
public:
    IntelibX_read_eof(SReference a_param);
};



extern IntelibGenericReader *PTheIntelibReader;



void add_vectors_to_reader(class IntelibReader &reader);


void add_hashtables_to_reader(class IntelibReader &reader);

#endif // sentry

---