compiler.h

// Copyright (c) 1999-2018 David Muse
// See the COPYING file for more information.
 
#ifndef RUDIMENTS_COMPILER_H
#define RUDIMENTS_COMPILER_H
 
#include <rudiments/private/compilerincludes.h>
 
class compilermodule;
class compilerpreprocessor;
class compilerprocessor;
class compilerpostprocessor;
 
class RUDIMENTS_DLLSPEC compiler : virtual public object {
        public:
 
                compiler();
 
                virtual ~compiler();
 
 
                void    appendModulePath(const char *path);
 
                void    clearModulePaths();
 
                linkedlist<char *>      *getModulePaths();
 
 
                void    appendPreProcessor(compilerpreprocessor *module);
 
                bool    appendPreProcessor(const char *filename,
                                                const char *classname,
                                                const char *id,
                                                domnode *parameters);
 
                bool    appendPreProcessor(const char *filename,
                                                const char *classname,
                                                const char *id,
                                                const char *parameters);
 
                void    clearPreProcessors();
 
                linkedlist<compilermodule *>    *getPreProcessors();
 
 
 
                void    appendProcessor(compilerprocessor *module);
 
                bool    appendProcessor(const char *filename,
                                                const char *classname,
                                                const char *id,
                                                domnode *parameters);
 
                bool    appendProcessor(const char *filename,
                                                const char *classname,
                                                const char *id,
                                                const char *parameters);
 
                void    clearProcessors();
 
                linkedlist<compilermodule *>    *getProcessors();
 
 
 
                void    appendPostProcessor(compilerpostprocessor *module);
 
                bool    appendPostProcessor(const char *filename,
                                                const char *classname,
                                                const char *id,
                                                domnode *parameters);
 
                bool    appendPostProcessor(const char *filename,
                                                const char *classname,
                                                const char *id,
                                                const char *parameters);
 
                void    clearPostProcessors();
 
                linkedlist<compilermodule *>    *getPostProcessors();
 
 
 
                bool    setInputGrammar(const char *grammar,
                                        const char *startsymbol);
 
                bool    setOutputGrammar(const char *grammar);
 
 
 
                void    setMetaData(domnode *metadata);
 
 
                bool    compile(const char *input, stringbuffer *output);
 
 
                bool    process(domnode *root);
 
 
                const char      *getError();
 
 
                void    setDebugLevel(uint8_t debuglevel);
 
        #include <rudiments/private/compiler.h>
};
 
 
 
class RUDIMENTS_DLLSPEC compilermodule : public object {
        public:
                compilermodule();
 
                virtual ~compilermodule();
 
                void    setId(const char *id);
 
                bool    setParameters(const char *parameters);
 
                void    setParameters(domnode *parameters);
 
                const char      *getId();
 
                domnode *getParameters();
 
        protected:
                const char      *id;
                domnode *parameters;
 
        private:
                dom             *xmld;
};
 
 
class RUDIMENTS_DLLSPEC compilerpreprocessor : public compilermodule {
        public:
                compilerpreprocessor();
 
                virtual ~compilerpreprocessor();
 
                virtual bool    process(const char *input,
                                        stringbuffer *output,
                                        domnode *metadata)=0;
};
 
 
class RUDIMENTS_DLLSPEC compilerprocessor : public compilermodule {
        public:
                compilerprocessor();
 
                virtual ~compilerprocessor();
 
                virtual bool    process(domnode *tree,
                                        domnode *metadata)=0;
};
 
 
class RUDIMENTS_DLLSPEC compilerpostprocessor : public compilermodule {
        public:
                compilerpostprocessor();
 
                virtual ~compilerpostprocessor();
 
                virtual bool    process(const char *input,
                                        stringbuffer *output,
                                        domnode *metadata)=0;
};
 
#endif