parser_stack.hpp

Go to the documentation of this file.

//  This file is part of jdl_parser.
//
//  jdl_parser 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 3 of the License, or
//  (at your option) any later version.
//
//  jdl_parser 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 jdl_parser.  If not, see <http://www.gnu.org/licenses/>.

// Copyright Simone Pellegrini 2007-2008; e-mail: motonacciu@gmail.com

#ifndef PARSER_STACK_HPP_
#define PARSER_STACK_HPP_

#include "defs.hpp"

namespace jdl{

template <class T>
class parser_stack{
        vector<T> operand_stack;
        vector<int> index_stack;
        
        void check_invariant() const;
        public:
                parser_stack(){ index_stack.push_back(0); }
                
                void push(T val, bool new_activation = false);
                
                void new_ar(){ index_stack.push_back(0);  }
                
                vector<T>& pop();
                
                size_t size() const { return operand_stack.size(); }
                
                T top() const { return operand_stack.back(); } 
                
                void clear(){ 
//                      for(size_t i=0; i<operand_stack.size(); i++)
//                              delete operand_stack[i];
                        operand_stack.clear();
                        index_stack.clear(); 
                }
                
                void print(ostream& out) const;
                
                ~parser_stack(){
//                      for(size_t i=0; i<operand_stack.size(); i++)
//                              delete operand_stack[i];
                }
};

template <class T>
inline void parser_stack<T>::check_invariant() const {
        assert(((size_t)accumulate(index_stack.begin(),index_stack.end(),0)) == operand_stack.size());
}

template <class T>
inline vector<T>& parser_stack<T>::pop(){
        int size = index_stack.back();
        index_stack.pop_back();
        vector<T>* v = new vector<T>();
        for(int i=0; i<size; i++){
                v->push_back(operand_stack.back());
                operand_stack.pop_back();
        }
        check_invariant();
        return *v;
}

template <class T>
inline void parser_stack<T>::push(T val, bool new_activation){
        if(new_activation || index_stack.empty())
                index_stack.push_back(0);
        operand_stack.push_back(val);
        index_stack.back()++;
        check_invariant();
}

template <class T>
inline void parser_stack<T>::print(ostream& out) const {
        out << "Stack size: " << size() << endl;
        out << "Activation records: " << endl;
        out << "\tStack:" << endl;
        //vector<T>::iterator iterator = operand_stack.begin();
//      while(it != operand_stack.end())
//              cout << "\t\t" << *(it++) << endl;
                
        for(size_t i=0; i<operand_stack.size(); i++)
                out << "\t\t" << operand_stack[i] << endl;
        out << endl << "\n\tIndexes: " << endl;
        vector<int>::const_iterator it2 = index_stack.begin();
        while(it2 != index_stack.end())
                out << "\t\t" << *(it2++) << endl;
}

}
#endif /*PARSER_STACK_HPP_*/

---