src/tinyap.h

Go to the documentation of this file.

/* Tinya(J)P : this is not yet another (Java) parser.
 * Copyright (C) 2007 Damien Leroux
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#ifndef _TINYAP_H__
#define _TINYAP_H__

#define TINYAP_VERSION PACKAGE_VERSION

#ifdef __cplusplus
extern "C" {
#endif
#ifndef _TINYAP_AST_H__
#endif
        typedef struct _tinyap_t* tinyap_t;
#ifndef _WAST_DEFINED
        typedef struct _walkable_ast_t* wast_t;
        typedef struct _wast_iter_t* wast_iterator_t;
        #define _WAST_DEFINED
#endif

#include "bootstrap.h"


        void tinyap_init();

        tinyap_t        tinyap_new();

        const char*     tinyap_get_whitespace(tinyap_t);
        void            tinyap_set_whitespace(tinyap_t,const char*);
        void            tinyap_set_whitespace_regexp(tinyap_t,const char*);

        const char*     tinyap_get_grammar(tinyap_t);
        void            tinyap_set_grammar(tinyap_t,const char*);

        ast_node_t      tinyap_get_grammar_ast(tinyap_t);
        void            tinyap_set_grammar_ast(tinyap_t,ast_node_t);

        const char*     tinyap_get_source_file(tinyap_t);
        const char*     tinyap_get_source_buffer(tinyap_t);
        unsigned int    tinyap_get_source_buffer_length(tinyap_t);
        void            tinyap_set_source_file(tinyap_t,const char*);
        void            tinyap_set_source_buffer(tinyap_t,const char*,const unsigned int);

        //void          

        int tinyap_parse(tinyap_t);
        int tinyap_parse_as_grammar(tinyap_t);

        int             tinyap_parsed_ok(const tinyap_t);

        ast_node_t      tinyap_get_output(const tinyap_t);

        int             tinyap_get_error_col(const tinyap_t);
        int             tinyap_get_error_row(const tinyap_t);

        const char*     tinyap_get_error(const tinyap_t);

        void            tinyap_delete(tinyap_t);

        void tinyap_plug(tinyap_t parser, const char*plugin, const char*plug);

        void tinyap_plug_node(tinyap_t parser, ast_node_t pin, const char*plugin, const char* plug);

        void tinyap_append_grammar(tinyap_t parser, ast_node_t supp);
        int             tinyap_node_is_nil(const ast_node_t);
        int             tinyap_node_is_list(const ast_node_t);
        unsigned int    tinyap_list_get_size(const ast_node_t);
        ast_node_t      tinyap_list_get_element(const ast_node_t,int);
        int             tinyap_node_is_string(const ast_node_t);
        const char*     tinyap_node_get_string(const ast_node_t);
        ast_node_t      tinyap_node_get_operand(const ast_node_t,int);
        int             tinyap_node_get_operand_count(const ast_node_t);
        const char*     tinyap_node_get_operator(const ast_node_t);

        int             tinyap_node_get_row(const ast_node_t);
        int             tinyap_node_get_col(const ast_node_t);

        void            tinyap_serialize_to_file(const ast_node_t,const char*);
        const char*     tinyap_serialize_to_string(const ast_node_t);

        wast_t          tinyap_make_wast(const ast_node_t);

        ast_node_t      tinyap_make_ast(const wast_t);

        void            tinyap_free_wast(const wast_t);

        wast_iterator_t tinyap_wi_new(const wast_t);
        #define wi_new tinyap_wi_new

        wast_iterator_t tinyap_wi_reset(wast_iterator_t);
        #define wi_reset tinyap_wi_reset

        void            tinyap_wi_delete(wast_iterator_t);
        #define wi_delete tinyap_wi_delete

        wast_t          tinyap_wi_node(wast_iterator_t);
        #define wi_node tinyap_wi_node

        wast_iterator_t tinyap_wi_up(wast_iterator_t);
        #define wi_up tinyap_wi_up

        wast_iterator_t tinyap_wi_down(wast_iterator_t);
        #define wi_down tinyap_wi_down

        wast_iterator_t tinyap_wi_next(wast_iterator_t);
        #define wi_next tinyap_wi_next

        wast_iterator_t tinyap_wi_backup(wast_iterator_t);
        #define wi_backup tinyap_wi_backup

        wast_iterator_t tinyap_wi_restore(wast_iterator_t);
        #define wi_restore tinyap_wi_restore

        wast_iterator_t tinyap_wi_validate(wast_iterator_t);
        #define wi_validate tinyap_wi_validate

        wast_t          tinyap_wi_root(wast_iterator_t);
        #define wi_root tinyap_wi_root

        wast_t          tinyap_wi_parent(wast_iterator_t);
        #define wi_root tinyap_wi_root

        wast_iterator_t tinyap_wi_dup(const wast_iterator_t);
        #define wi_dup tinyap_wi_dup

        int             tinyap_wi_on_root(wast_iterator_t);
        #define wi_on_root tinyap_wi_on_root

        int             tinyap_wi_on_leaf(wast_iterator_t);
        #define wi_on_leaf tinyap_wi_on_leaf

        int             tinyap_wi_has_next(wast_iterator_t);
        #define wi_has_next tinyap_wi_has_next

        const char*     tinyap_unparse(wast_t grammar, wast_t ast);

        void*           tinyap_walk_output(const char* pilot_name, void* pilot_init_data);

        void*           tinyap_walk(const wast_t subtree, const char* pilot_name, void* pilot_init_data);
#ifdef __cplusplus
}

namespace TinyaP {

        class AstNode {
        public:
                AstNode(ast_node_t ptr)
                { handle=ptr; initCache(ptr,0); }
                AstNode()
                { handle=0; cache=0; }
                ~AstNode()
                { if(cache) delete[] cache; }
                bool isNil() const
                { return tinyap_node_is_nil(handle); }
                bool isList() const
                { return tinyap_node_is_list(handle); }
                bool isOp() const
                { return tinyap_node_is_list(handle)&&tinyap_node_is_string(tinyap_list_get_element(handle,0)); }
                bool isString() const
                { return tinyap_node_is_string(handle); }
                const char* getString() const
                { return tinyap_node_get_string(handle); }
                AstNode* getOperand(const int n) const
                { return cache[n+1]; }
                int getOperandCount() const
                { return cache_sz-1; }
                const char* getOperator() const
                { return tinyap_node_get_string(tinyap_list_get_element(handle,0)); }
                AstNode* getElement(const int n) const
                { return cache[n]; }
                const char*toString() const
                { return tinyap_serialize_to_string(handle); }
                void toFile(const char*fnam) const
                { return tinyap_serialize_to_file(handle,fnam); }

                int getRow() const
                { return tinyap_node_get_row(handle); }

                int getCol() const
                { return tinyap_node_get_col(handle); }

                ast_node_t getHandle() const
                { return handle; }
        private:
                ast_node_t handle;
                AstNode**cache;
                int cache_sz;
                void initCache(ast_node_t ptr,int length)
                {
                        if(tinyap_node_is_string(ptr))
                        {
                                if(length==0)
                                {
                                        cache=0;
                                } else
                                {
                                        cache_sz=length+1;
                                        cache=new AstNode* [cache_sz];
                                        cache[length]=new AstNode(ptr);
                                }
                        } else if(tinyap_node_is_list(ptr))
                        {
                                initCache(tinyap_list_get_element(ptr,1),length+1);
                        } else if(ptr==0)
                        {
                                cache_sz=length;
                                cache = new AstNode* [cache_sz];
                        }
                }
        };

        class Parser {
        public: Parser()
                { handle=tinyap_new(); grammar=output=0; }
        static Parser& New()
                { return *new Parser(); }
        ~Parser()
                {
                        tinyap_delete(handle);
                        if(grammar) delete grammar;
                        if(output) delete output;
                }

                const char*getGrammar() const
                { return tinyap_get_grammar(handle); }

                Parser& setGrammar(const char*gs)
                {
                       tinyap_set_grammar(handle,gs);
                       if(grammar) delete grammar;
                       grammar=new AstNode(tinyap_get_grammar_ast(handle));
                       return *this;
                }

                const char*getWhitespace() const
                { return tinyap_get_whitespace(handle); }

                Parser& setWhitespace(const char* ws)
                { tinyap_set_whitespace(handle, ws); return *this; }

                Parser& setWhitespaceRegexp(const char*wsre)
                { tinyap_set_whitespace_regexp(handle,wsre); return *this; }

                AstNode* getGrammarAst() const
                { return grammar; }

                Parser& setGrammarAST(const AstNode*gast)
                {
                        if(grammar) delete grammar;
                        tinyap_set_grammar_ast(handle,gast->getHandle());
                        grammar=new AstNode(gast->getHandle());
                        return *this;
                }

                const char*getSourceFile() const
                { return tinyap_get_source_file(handle); }

                const char*getSourceBuffer() const
                { return tinyap_get_source_buffer(handle); }

                unsigned int getSourceBufferLength() const
                { return tinyap_get_source_buffer_length(handle); }

                Parser& setSourceFile(const char*fnam)
                { tinyap_set_source_file(handle,fnam); return *this; }

                Parser& setSourceBuffer(const char*buf,const unsigned int len)
                { tinyap_set_source_buffer(handle,buf,len); return *this; }

                bool parse()
                {
                        tinyap_parse(handle);
                        if(output) delete output;
                        output=new AstNode(tinyap_get_output(handle));
                        return tinyap_parsed_ok(handle);
                }

                bool parseAsGrammar()
                {
                        if(tinyap_parse_as_grammar(handle))
                        {
                                if(grammar) delete grammar;
                                grammar=new AstNode(tinyap_get_grammar_ast(handle));
                                if(output) delete output;
                                output=new AstNode(tinyap_get_output(handle));
                        }
                        return tinyap_parsed_ok(handle);
                }

                bool parsedOK() const
                { return tinyap_parsed_ok(handle); }

                AstNode* getOutput() const
                { return output; }

                int getErrorCol() const
                { return tinyap_get_error_col(handle); }

                int getErrorRow() const
                { return tinyap_get_error_row(handle); }

                const char* getError() const
                { return tinyap_get_error(handle); }

                tinyap_t getHandle() const
                { return handle; }
        private:
                tinyap_t handle;
                AstNode*grammar,*output;
        };
}


#endif
#endif

---