sprint/archive/archive.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::archive
*
*   Copyright (C) 2002-2011  Paolo Medici <www.pmx.it>
*
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 of the License, or (at your option) any later version.
*
*  This library is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
*  Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*******************************************************************************/

#ifndef _SPRINT_ARCHIVE_H
#define _SPRINT_ARCHIVE_H

#include <cstdio>
#include <cstring>
#include <sprint/sysdef.h>
#include <sprint/container/alias.h>

namespace sprint {

/* -1 reserved for Parse Unknown */
#define ARCHIVE_OK              0

#define ARCHIVE_EOF             -2

#define ARCHIVE_EOS             -3

#define ARCHIVE_BOS             -4

#define ARCHIVE_ERROR           -5

typedef const char *SEMANTHIC[];

#define PRIVATESEMANTHIC static SEMANTHIC

class BaseArchive {
protected:

        char filename[32];              
        char relativepath[64];  

        BaseArchive *prev;

        FILE *fp;
        UINT curline;

        UINT format;
        int level;

protected:
        BaseArchive *Push();
        BOOL Pop();
    
        inline bool IsNested() const
        {
                return prev!=NULL;
        }

public:
        
        BaseArchive();
        ~BaseArchive();

        void Rewind();

        void setpath(const char *path);

        void setfilename(const char *file);
        
    char *get_full_pathname(char *buffer);

        
        inline long GetCurPos() { 
           return ftell(fp); 
           }
        inline long SetCurPos(long pos) { 
           return fseek(fp, pos, SEEK_SET); 
           }

        inline void DeepLevel() { 
          level++; 
          }
        inline void RaiseLevel() { 
           level--; 
           }

        long GetFileSize();
        
        void move_to_the_end();

        void crop_file();

        inline bool IsValid() const  {
               return fp!=NULL;
           }

        void printerror(const char *string);

        BOOL close();

        inline UINT GetCurLine() const  { 
             return curline;
             }
        inline const char *GetCurFile() const { 
             return filename;
             }

};

class ArchiveOut:public BaseArchive {
        const char **semanthic;
public:

        const char **set_semanthic(const char **newsemanthic);

        BOOL create(const char *file, UINT format);

        void writecomment(const char *comment);
        void writeversion();

    /*{*/
        void rawwrite(const char *string);

        void write(unsigned int key, const char *string);
        void write(unsigned int key, unsigned int number);

        inline void write(unsigned int key, unsigned long number) {
                write(key, (unsigned int) number);
        }
 
        void write(unsigned int key, int number);
        void writef(unsigned int key, const char *format, ...);

        void writeflagalias(unsigned int key, unsigned int value, const char **alias);

        void writeflag(unsigned int key, unsigned int flag);
        void writebytevector(unsigned int key, unsigned char *, unsigned int size, char separator);
    void writevector(unsigned int key, const void *, unsigned int count, unsigned int c_size);
        void writehexbytevector(unsigned int key, unsigned char *, int size);
    /*}*/
    
        void create_object(unsigned int key, const char *param);
        void close_object(unsigned int key);

        /* > da questo punto in poi scrive su un files secondario */
        void include_files(const char *filename);

};

struct DefineList {
        DefineList *next;
        char *def;
        char *value;
};

class ArchiveInBase : public BaseArchive {
        char multilinesupport;

        int skiplevel;  /* ToDo: nel caso di ELSE IF END IF ANNIDATI */

        DefineList *dlroot;     /* macro */

    // SPLIT CORRENTE (memoria relativa a g_buffer o buffer utente)
        char *m_id;
        char *m_param;

public:
        ArchiveInBase();

    
    
        bool open(const char *file);

    // riapro il file precedentemente aperto con open
        bool Reopen();
        
        inline void DisableMultilineSupport() {
                multilinesupport=0;
        };
        inline void EnableMultilineSupport(char multilinechar) {
                multilinesupport=multilinechar;
        };

        bool Define(const char *def, const char *value);
        bool Undefine(const char *def);
        const char *IsDefined(const char *def);


        char *readnakedline(char *buffer=NULL, unsigned int buffer_size=0);

    /* Restituisce un puntatore all'inizio della linea, senza spazi all'inizio, alla fine,      
         *  rimuove i commenti e unisce linee multiple 
     * @note usa il buffer globale
     */
        char *readvalidline(void);
        
    /* legge una linea e rimuove l'endl finali, gli spazi iniziali e i commenti */
        /* legge una linea e salta linee con commenti, e esegue linee con comandi della libreria */
        int read();
        
        inline const char *id() const { return m_id; }
        inline const char *param() const { return m_param; }
    bool is(const char *str) const { return !strcmp(m_id, str); }       

        inline bool successread()       {
                int ret = read();
                return (ret==ARCHIVE_OK)||(ret==ARCHIVE_BOS);
        };

        inline bool successread(int &ret)       {
                ret = read();
                return (ret==ARCHIVE_OK)||(ret==ARCHIVE_BOS);
        };


        bool deep();
        /* legge una linea e riempi l'id e il param (se presente),
                restituisce EOF,EOS,OK*/

        int parse(const char **semanthic);

        int readparse(char **param, const char **semanthic);

        int skip_section_ex(unsigned int *level_item, unsigned int *all_item);
        inline int skip_section()
        {
                return skip_section_ex(NULL, NULL);
        }

        void script(const char *data);


};

class ArchiveImporter {
public:
        virtual bool Parse(ArchiveInBase *a) = 0;
        bool Import(ArchiveInBase *a);
};

class ArchiveIn:public ArchiveInBase {
        const char **semanthic;
public:

        const char **set_semanthic(const char **newsemanthic);
        
        inline int parse(char **data)   {
                return readparse(data, semanthic);
        }
};


/* 

void ArchiveConvert(ArchiveOut *out, ArchiveIn *in);

  più che altro serve una callback per la semantica di ingresso e di uscita al
  cambio di */

/***** FILE FORMAT ****/
#define AF_TEXT         0
#define AF_BINARY       1
#define AF_XML          2
#define AF_JSON     3

/**** FLAGS ****/
#define FLAG_OPENFORWRITE       0x01
#define FLAG_ROOT                       0x02
#define FLAG_BINARY                     0x80

#define SIT_UNKNOWN             0
#define SIT_SECTION             1
#define SIT_STRING              2


// C LIke solution (1 pointer)
#define PUSHSEMANTHIC(a,s);             const char **__oldsem = (a)->set_semanthic(s);
#define POPSEMANTHIC(a);                (a)->set_semanthic(__oldsem);

// C++ Solution (2 pointers) (ma si spera che vengano ottimizzati)
template<class T>
class SemanthicContext {
        T m_a;
    const char **m_oldsem;
    public:
      SemanthicContext(T _a, const char **newsemanthic) : 
                                        m_a(_a),
                                        m_oldsem(_a->set_semanthic(newsemanthic)) { }
      ~SemanthicContext()
        {
          m_a->set_semanthic(m_oldsem);
        }    
};    

#define SEMANTHICSCOPE(a,s);    sprint::SemanthicContext<typeof(a)> _ctx(a, s);

BOOL ArchiveGenericExport(ArchiveOut *a, const BYTE *priv, const char **semanthic);

BOOL ArchiveGenericImport(ArchiveIn *a, BYTE *priv, const char **semanthic);

void ArchiveSetServerName(const char *name);

} // namespace

#endif