/*
www.sourceforge.net/projects/tinyxpath
Copyright (c) 2002-2004 Yves Berquin (yvesb@users.sourceforge.net)

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.

Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source
distribution.
*/

/**
   \file tokenlist.h
   \author Yves Berquin
   XPath Syntax analyzer for TinyXPath project : token list handling
*/

#ifndef __TOKENLIST_H
#define __TOKENLIST_H

#include "lex_util.h"
#include "lex_token.h"

namespace TinyXPath
{

/**
   A token list class. This is the output of the lexical analysis  \n
   Note that the empty list consist of a single null element in order to speed
   up later insertions
*/
class token_list 
{
protected :
   /// Pointer to first element
   lex_token * ltp_first;
   /// Pointer to last element
   lex_token * ltp_last;
   /// Pointer to current element. This is for external usage : we keep track of where it
   /// is, but it's not needed to manage the list structure
   lex_token * ltp_current;
public :
   /// constructor
   token_list () 
   {
      ltp_first = new lex_token (lex_null, NULL, 0);
      ltp_last = ltp_first;
      ltp_first -> v_set_prev (ltp_first);
      ltp_first -> v_set_next (ltp_first);
      ltp_current = NULL;
   }
   /// destructor
   virtual ~ token_list ()
   {
      ltp_current = ltp_first -> ltp_get_next ();
      while (ltp_current -> o_is_valid ())
         v_delete_current ();
      delete ltp_first;
   }
   /// Adds a lexical token
   void v_add_token (lexico l_in_enum, const _byte_ * bp_in_value, unsigned u_in_size)
   {
      lex_token * ltp_new;

      ltp_new = new lex_token (l_in_enum, bp_in_value, u_in_size);
      ltp_last    -> v_set_next (ltp_new);
      ltp_new     -> v_set_next (ltp_first);
      ltp_first   -> v_set_prev (ltp_new);
      ltp_new     -> v_set_prev (ltp_last);
      ltp_last = ltp_new;
   }

   /// Set current to first real element
   void v_set_current_top ()
   {
      ltp_current = ltp_first -> ltp_get_next (1);
   }

   /// Set current 
   void v_set_current (lex_token * ltp_cur)
   {
      ltp_current = ltp_cur;
   }

   /// Return the current token
   lex_token * ltp_freeze ()
   {
      return ltp_current;
   }

   /// Get next X linear token
   lex_token * ltp_get (int i_offset) 
   {
      if (! ltp_current)
         return NULL;
      return ltp_current -> ltp_get_next (i_offset);
   }

   /// Increments the linear counter
   void v_inc_current (int i_rel)
   {
      if (! ltp_current)
         return;
      ltp_current = ltp_current -> ltp_get_next (i_rel);
   }

   /// Replaces the current element 
   void v_replace_current (lexico lex_in, const char * cp_rep)
   {
      if (! ltp_current)
         return;
      ltp_current -> v_set (lex_in, cp_rep);
   }

   /// Deletes the current element
   void v_delete_current ()
   {
      lex_token * ltp_temp;

      assert (ltp_current);
      ltp_temp = ltp_current;
      ltp_temp -> ltp_get_prev () -> v_set_next (ltp_temp -> ltp_get_next ());
      ltp_temp -> ltp_get_next () -> v_set_prev (ltp_temp -> ltp_get_prev ());
      ltp_current = ltp_temp -> ltp_get_next ();
      delete ltp_temp;
   }

   /// Deletes the next element
   void v_delete_next ()
   {
      lex_token * ltp_temp;

      assert (ltp_current);
      ltp_temp = ltp_current -> ltp_get_next ();
      ltp_current -> v_set_next (ltp_temp -> ltp_get_next ());
      ltp_temp -> ltp_get_next () -> v_set_prev (ltp_current);
      delete ltp_temp;
   }
   void v_tokenize_expression ();
} ;

}

#endif