campo-sirio/include/strings.h

#ifndef __STRINGS_H
#define __STRINGS_H

#ifndef _INC_STRING
#include <string.h>
#endif

#ifndef __ARRAY_H
#include <array.h>
#endif

#define SAFE_PIPE_CHR '¦'

// @doc EXTERNAL

// @class Classe per la definizione della stringhe
//
// @base public | TObject
class TString : public TObject
// @author:(INTERNAL) Guido
{
  // @access Protected Member
protected:  
  // @cmember Puntatore alla stringa
  char* _str;   
  // @cmember Lunghezza della stringa
  int _size;    

  // @cmember Espande la stringa per altri caratteri
  int make_room(int size);
  // @cmember Inizializza con la stringa puntata da char* di lunghezza size
  TString& set(const char*); 

  // @cmember Costruttore per consentire la derivazione delle TFixed_string
  TString(char* str, int size) : _str(str), _size(size) 
  {}

  // @access Public member
public:
  // @cmember Cambia la dimensione della stringa eventualmente preservandone il contenuto iniziale
  virtual void resize(int size, bool cpy);

  // @cmember Costruttore
  TString();
  // @cmember Costruttore di default per una stringa data
  TString(int size, char c='\0');
  // @cmember Costruttore a partire da una stringa s
  TString(const char* s);
  // @cmember Costruttore da un oggetto TString s
  TString(const TString& s);
  // @cmember Distruttore
  virtual ~TString();

  // @cmember Ritorna il nome della classe
  virtual const char* class_name() const;
  // @cmember Ritorna l'identificatore della classe
  virtual word class_id() const;
  // @cmember Controlla se si tratta di una stringa valida (diversa da NULL)
  virtual bool ok() const
  { return _str != NULL; }
  // @cmember Duplica una stringa
  virtual TObject* dup() const;
  // @cmember Stampa una stringa
  virtual void print_on(ostream& out) const;
  // @cmember Legge una stringa
  virtual void read_from(istream& in);
  // @cmember Ritorna il valore hash della stringa
  virtual word hash() const;

  // @cmember const char * | operator const char*() | | Trasforma una stringa 
  //          in puntatore a carattere 
  operator const char*() const
  { return (const char*)_str; }
  // @cmember Ritorna un riferimento al carattere i-esimo della stringa
  char& operator[](int i)
  { 
    CHECKD(i >= 0 && i <= _size, "Bad string subscript: ", i);
    return _str[i]; 
  }
  // @cmember Ritorna il carattere i-esimo della stringa
  char operator[](int i) const
  { 
    CHECKD(i >= 0 && i <= _size, "Bad string subscript: ", i);
    return _str[i]; 
  }  

  // @cmember Ritorna la dimensione allocata della stringa
  int size() const
  { return _size; }
  // @cmember Ritorna la lunghezza della stringa (numero di caratteri)
  int len() const 
  { return _str ? strlen(_str) : 0; }
  // @cmember Controlla se la stringa e' vuota (true se non contiene caratteri)
  bool empty() const
  { return *_str == '\0'; }
  // @cmember Controlla se la stringa non e' vuota (true se contiene caratteri)
  bool not_empty() const
  { return *_str != '\0'; }
  // @cmember Controlla se la stringa e' vuota o contiene solo whitespace (true se vuota)
  bool blank() const;
  // @cmember Controlla se la stringa NON e' vuota o contiene solo whitespace (true se vuota)
  bool full() const;


  // @cmember Ritorna la posizione della prima occorrenza carattere char nell'oggetto TString
  int find(char, int from = 0) const;
  // @cmember Ritorna la posizione dell'ultima occorrenza carattere char nell'oggetto TString
  int rfind(char) const;
  // @cmember Ritorna la posizione della stringa s nell'oggetto TString
  int find(const char* s, int from = 0) const;
  // @cmember Sostituisce le occorrenze di <p find_char> col carattere <p replace_char>
  int replace(char find_char, char replace_char);

  // @cmember Ritorna l'oggetto TString composto dai count caratteri da sinistra
  const TString& left(int count) const;
  // @cmember Ritorna l'oggetto TString composto dai count caratteri a partire da from
  const TString& mid(int from, int count = -1) const;
  // @cmember Ritorna la stringa da from a to (escluso)
  const TString& sub(int from, int to = -1) const;
  // @cmember Ritorna l'oggetto TString composto dai count caratteri da destra
  const TString& right(int count) const;
  // @cmember Ritorna l'oggetto TString dopo la string passata
  const TString& after(char c) const;
  const TString& after(const char* str) const;
  // @cmember Ritorna l'oggetto TString prima della string passata
  const TString& before(char c) const;
  const TString& before(const char* str) const;

  // @cmember Ritorna un oggetto TString temporaneo composto dai count caratteri da sinistra
  TString sleft(int count) const 
  { return ((TString)left(count)); }
  // @cmember Ritorna un oggetto TString temporaneo composto dai count caratteri a partire da from
  TString smid(int from, int count = -1) const 
  { return ((TString)mid(from, count)); }
  // @cmember Ritorna un oggetto TString temporaneo composto dai caratteri da from a to (escluso)
  TString ssub(int from, int to = -1) const 
  { return ((TString)sub(from, to)); }
  // @cmember Ritorna un oggetto TString temporaneo composto dai count caratteri da destra
  TString sright(int count) const 
  { return ((TString)right(count)); }

  // @cmember Riempe la stringa con n caratteri c
  TString& fill(char c, int n = -1);
  // @cmember Riempe la stringa con n caratteri spazio (chiama <mf TString::resize>)
  TString& spaces(int n = -1)
  { return fill(' ', n); }
  // @cmember Sovrascrive la stringa s dalla posizione pos
  TString& overwrite(const char* s, int pos = 0, int len = 0);
  // @cmember Inserisce la stringa s dalla posizione pos
  TString& insert(const char* s, int pos = 0);

  // @cmember Elimina tutti i caratteri contenuti in k
  TString& strip(const char* k);
  // @cmember Elimina tutti gli spazi non contenuti tra apici singoli o doppi
  TString& strip_spaces();
  // @cmember Elimina tutti gli spazi doppi
  TString& strip_double_spaces();
  // @cmember Elimina gli spazi da sinistra o i primi n caratteri (da sinistra).
  TString& ltrim(int n = 0);
  // @cmember Elimina gli spazi da destra o i primi n caratteri (da destra).
  TString& rtrim(int n = 0);
  // @cmember Composizione di <mf TString::ltrim> e <mf TString::rtrim> per eliminare
  //          gli spazi iniziali e finali
  TString& trim();
  // @cmember Aggiunge spazi a destra fino alla dimensione indicata
  TString& rpad(const int n,const char c=' ');
  // @cmember Aggiunge spazi a sinistra fino alla dimensione indicata
  TString& lpad(const int n,const char c=' ');

  // @cmember Giustifica l'oggetto stringa a destra
  TString& right_just(int n = -1, char c = ' ');
  // @cmember Centra l'oggetto stringa
  TString& center_just(int n = -1, char c = ' ');
  // @cmember Giustifica l'oggetto stringa a sinistra
  TString& left_just(int n = -1, char c = ' ');

  // @cmember Formatta una stringa usando il formato dato da pic
  TString& picture(const char* pic, const char* s);
   
  // @cmember Copia n caratteri nella stringa oggetto
  int strncpy(const char* s, int n);

  // @cmember Manda un output formattato alla stringa oggetto
  virtual TString& format(const char* fmt, ...);

  // @cmember Tronca la stringa alla posizione n-esima.
  TString& cut(int n);
  
  // @cmember Ritorna il buffer interno della stringa (usare con attenzione!)
  char* get_buffer(int min_size = -1);

  // @cmember Converte la stringa in maiuscolo
  TString& upper(int from =0, int to=-1);
  // @cmember Converte la stringa in minuscolo
  TString& lower(int from =0, int to=-1);
  // @cmember Permette di trovare il plurale di una stringa
  TString& add_plural(long num, const char * name);

  // @cmember Assegna la stringa passata con indirizzo
  const TString& operator =(const TString& s)
  { return set(s._str); }
  // @cmember Assegna la stringa passata
  const TString& operator =(const char* s)
  { return set(s); }

  // @cmember Fa scorrere a sinistra la stringa e restituisce l'ultimo carattere scartato
  char shift(int n=1);
  // @cmember Fa scorrere a destra la stringa e restituisce l'ultimo carattere scartato
  char rshift(int n=1)
    {return shift(-n);}
  // @cmember Concatena una stringa all'oggetto stringa
  TString& operator <<(const char*);
  // @cmember Concatena un carattere all'oggetto stringa
  TString& operator <<(char);
  // @cmember Concatena un intero all'oggetto stringa
  TString& operator <<(int);
  // @cmember Concatena un long all'oggetto stringa
  TString& operator <<(long);
  // @cmember Concatena un double all'oggetto stringa
  TString& operator <<(double);
  // @cmember Concatena un oggetto all'oggetto stringa
  TString& operator <<(const TObject& obj);
  // @cmember Concatena una stringa all'oggetto stringa (usato per aumentare l'efficienza)
  TString& operator <<(const TString& str);


  // @cmember Controlla se due stringhe sono uguali
  bool operator ==(const char* s) const
  { return  s ? strcmp(_str, s) == 0 : empty();}
  // @cmember Controlla se due stringhe sono uguali
  bool operator ==(char* s) const
  { return s ? strcmp(_str, s) == 0 : empty();}
  // @cmember Controlla se due stringe sono uguali
  bool operator ==(const TString& s) const
  { return strcmp(_str, s._str) == 0; }
  // @cmember Controlla se due stringhe sono diverse
  bool operator !=(const char* s) const
  { return s ? strcmp(_str, s) != 0 : not_empty();}
  // @cmember Controlla se due stringhe sono diverse
  bool operator !=(char* s) const
  { return s ? strcmp(_str, s) != 0 : not_empty();}
  // @cmember Controlla se due stringhe sono diverse
  bool operator !=(const TString& s) const
  { return strcmp(_str, s._str) != 0; }
  // @cmember Controlla se una stringa e' minore di un'altra
  bool operator  <(const char* s) const
  { return s ? strcmp(_str, s)  < 0 : false;}
  // @cmember Controlla se una stringa e' maggiore di un'altra
  bool operator  >(const char* s) const
  { return s ? strcmp(_str, s)  > 0  : not_empty();}
  // @cmember Controlla se una stringa e' maggiore o uguale ad un'altra
  bool operator >=(const char* s) const
  { return s ? strcmp(_str, s) >= 0 : true;}
  // @cmember Controlla se una stringa e' minore o uguale ad un'altra
  bool operator <=(const char* s) const
  { return s ? strcmp(_str, s) <= 0 : empty();}
  // @cmember Controlla se una stringa e' minore di un'altra
  bool operator  <(const TString & s) const
  { return strcmp(_str, s._str)  < 0; }
  // @cmember Controlla se una stringa e' maggiore di un'altra
  bool operator  >(const TString & s) const
  { return strcmp(_str, s._str)  > 0; }
  // @cmember Controlla se una stringa e' maggiore o uguale ad un'altra
  bool operator >=(const TString & s) const
  { return strcmp(_str, s._str) >= 0; }
  // @cmember Controlla se una stringa e' minore o uguale ad un'altra
  bool operator <=(const TString & s) const
  { return strcmp(_str, s._str) <= 0; }
  // @cmember Confronta usando le regular expression
  bool match(const char* pat, bool ignorecase = false) const;
  // @cmember Compara due stringhe (o i primi max caratteri)
  int compare(const char* s, int max = -1, bool ignorecase = false) const;
  // @cmember Controlla se la strinvga comincia per s
	bool starts_with(const char* s, bool ignorecase = false) const;
  // @cmember Controlla se la strinvga finisce per s
	bool ends_with(const char* s, bool ignorecase = false) const;
};

// @doc EXTERNAL

// @class TFixed_string | Classe per la definizione di stringhe di lunghezza
//                        fissa e non rilocabili dinamicamente
//
// @base public | TString
class TFixed_string : public TString
// @author:(INTERNAL) Guido
{

  // @access Protected Member
protected:
  // @cmember Causa un erroe fatale
  virtual void resize(int size, bool cpy);

  // @access Public Member
public:
  // @cmember Costruttore
  TFixed_string(const char* str, int size = -1);
  // @cmember Distruttore
  virtual ~TFixed_string();

	// @cmember Manda un output formattato alla stringa oggetto
  virtual TString& format(const char* fmt, ...);

  // @cmember Assegna la stringa passata con indirizzo
  const TString& operator =(const TString& s)
  { return set((const char*)s); }
  // @cmember Assegna la stringa passata
  const TString& operator =(const char* str)
  { return set(str); }
};


// @doc EXTERNAL

// @class TString4 | Definisce le stringhe di 4 caratteri
//
// @base public | TFixed_string
//
// @author:(INTERNAL) Augusto
//
// @comm Questa classe e' identica alla <c TString16> per quanto riguarda i public member e quindi
//       si rimanda a tale classe per ulteriori spiegazioni.
class TString4 : public TFixed_string
{
  char _str4[5];

public:
  TString4(const char* s = "") : TFixed_string(_str4, 5) { set(s); }
  TString4(const TString& s) : TFixed_string(_str4, 5) { set(s); }
  TString4(const TString4& s) : TFixed_string(_str4, 5) { set(s); }
  const TString& operator =(const char* s) { return set(s); }
  const TString& operator =(const TString& s) { return set((const char*)s); }
  const TString& operator =(const TString4& s) { return set((const char*)s); }
};


// @doc EXTERNAL

// @class TString8 | Definisce le stringhe di 8 caratteri
//
// @base public | TFixed_string
//
// @author:(INTERNAL) Augusto
//
// @comm Questa classe e' identica alla <c TString16> per quanto riguarda i public member e quindi
//       si rimanda a tale classe per ulteriori spiegazioni.
class TString8 : public TFixed_string
{
  char _str8[9];

public:
  TString8(const char* s = "") : TFixed_string(_str8, 9) { set(s); }
  TString8(const TString& s) : TFixed_string(_str8, 9) { set(s); }
  TString8(const TString8& s) : TFixed_string(_str8, 9) { set(s); }
  const TString& operator =(const char* s) { return set(s); }
  const TString& operator =(const TString& s) { return set((const char*)s); }
  const TString& operator =(const TString8& s) { return set((const char*)s); }
};


// @doc EXTERNAL

// @class TString16 | Definisce le stringhe di 16 caratteri
//
// @base public | TFixed_string
class TString16 : public TFixed_string
// @author:(INTERNAL) Guido
{
  // @access:(INTERNAL) Private member

  // @cmember:(INTERNAL) Stringa di 16 caratteri
  char _str16[17];

  // @access Public Member
public:
  // @cmember Duplica una stringa di 16 caratteri
  virtual TObject* dup() const { return new TString16(_str16); }

  // @cmember Costruttore
  TString16(const char* s = "") : TFixed_string(_str16, 17)
  { set(s); }
  // @cmember Costruttore
  TString16(const TString& s) : TFixed_string(_str16, 17)
  { set(s); }
  // @cmember Costruttore
  TString16(const TString16& s) : TFixed_string(_str16, 17)
  { set(s); }
  // @cmember Assegna una stringa
  const TString& operator =(const char* s)
  { return set(s); }
  // @cmember Assegna una stringa
  const TString& operator =(const TString& s)
  { return set((const char*)s); }
  // @cmember Assegna una stringa
  const TString& operator =(const TString16& s)
  { return set((const char*)s); }

  // @comm Sono definite anche le classi <c TString80> e <c TString256> per le
  //       stringhe rispettivamente di 80 e 256 caratteri. I class member sono
  //       gli stessi, la differenza e' solo nel numero di caratteri della stringa.
};

// @doc EXTERNAL

// @class TString80 | Definisce le stringhe di 80 caratteri
//
// @base public | TFixed_string
//
// @author:(INTERNAL) Guido
//
// @comm Questa classe e' identica alla <c TString16> per quanto riguarda i public member e quindi
//       si rimanda a tale classe per ulteriori spiegazioni.
class TString80 : public TFixed_string
{
  char _str80[81];

public:
  // @cmember Duplica una stringa di 80 caratteri
  virtual TObject* dup() const { return new TString80(_str80); }

  TString80(const char* s = "") : TFixed_string(_str80, 81) { set(s); }
  TString80(const TString& s) : TFixed_string(_str80, 81) { set(s); }
  TString80(const TString80& s) : TFixed_string(_str80, 81) { set(s); }
  const TString& operator =(const char* s) { return set(s); }
  const TString& operator =(const TString& s) { return set((const char*)s); }
  const TString& operator =(const TString80& s) { return set((const char*)s); }
};

// @doc EXTERNAL

// @class TString256 | Definisce le stringhe di 256 caratteri
//
// @base public | TFixed_string
//
// @author:(INTERNAL) Guido
//
// @comm Questa classe e' identica alla <c TString16> per quanto riguarda i public member e quindi
//       si rimanda a tale classe per ulteriori spiegazioni.
class TString256 : public TFixed_string
{
  char _str256[257];

public:
  // @cmember Duplica una stringa di 256 caratteri
  virtual TObject* dup() const { return new TString256(_str256); }

  TString256(const char* s = "") : TFixed_string(_str256, 257) { set(s); }
  TString256(const TString& s) : TFixed_string(_str256, 257) { set(s); }
  TString256(const TString256& s) : TFixed_string(_str256, 257) { set(s); }
  const TString& operator =(const char* s) { return set(s); }
  const TString& operator =(const TString& s) { return set((const char*)s); }
  const TString& operator =(const TString256& s) { return set((const char*)s); }
};

// @doc EXTERNAL

// @class TFilename | Classe per la gestione dei nome dei file
//
// @base public | TString
class TFilename : public TString
// @author:(INTERNAL) Guido

{
  // @comm Nel caso di utilizzo di Windows 95 occorre cambiare le classe base in <c TString256>

  // @access Public Member
public:
  // @cmember Costruttore
  TFilename(const char* n = "") : TString(256)
  { set(n); }
  // @cmember Costruttore
  TFilename(const TString& n) : TString(256)
  { set(n); }
  // @cmember Costruttore
  TFilename(const TFilename& n) : TString(256)
  { set(n); }

  // @cmember Assegnazione tra TFilename e stringa
  const TString& operator =(const char* s)
  { return set(s); }
  // @cmember Assegnazione tra TFilename e TString
  const TString& operator =(const TString& s)
  { return set((const char*)s); }
  // @cmember Assegnazione tra TFilename e TFilename
  const TString& operator =(const TFilename& s)
  { return set((const char*)s); }
  
  // @cmember Controlla il formato del nome del file
  virtual bool ok() const;

  // @cmember Ritorna l'estensione del file
  const char* ext() const;
  // @cmember Imposta come estensione la stringa puntata da char*
  void ext(const char*);
  
  // @cmember Concatena un nome di file ad una directory
  TFilename& add(const char* n);
  
  // @cmember Controlla se si tratta di un path assoluto
  bool is_absolute_path() const;
  // @cmember Controlla se si tratta di un path relativo
  bool is_relative_path() const { return !is_absolute_path(); }
  // @cmember Trasforma un path da relativo ad assoluto
  const TFilename& make_absolute_path();
  // @cmember Testa se il file esiste
  bool exist() const;
  // @cmember Cancella il file
  bool fremove() const;
  // @cmember Cerca nel path il nome del file corrente e scrive il path assoluto in path
  bool search_in_path(TFilename& path) const;
  // @cmember Richiede all'utente il nome di un file
  bool input();
  // @cmember Ritorna il nome del file
  const char* name() const;
  // @cmember Ritorna il nome del direttorio
  const char* path() const;
  // @cmember Genera il nome di un file temporaneo
  const TFilename& temp(const char* prefix = NULL, const char* extension = NULL);
  // @cmember Genera il nome della directory temporanea
  const TFilename& tempdir();
  // @cmember Genera il nome della directory corrente
  const TFilename& currdir();
  // @cmember Prepone il nome della dir custom 
	bool custom_path(const char* path_list = NULL);
};

// Forward declaration for TToken_string::get(int n, real& r) const
class real;

// @doc EXTERNAL

// @class TToken_string | Contiene una stringa formata da piu' stringhe
//                        separate da un carattere (di solito il pipe)
//
// @base public | TString
class TToken_string : public TString
// @author:(INTERNAL) Guido
{
  // @access:(INTERNAL) Private Member

  // @cmember:(INTERNAL) Carattere separatore
  char _separator;
  // @cmember:(INTERNAL) Puntatore all'ultimo
  int _last;

  // @access Protected Member
protected:
  // @cmember Inserisce l'n-esima stringa 
  bool set_item(const char* v, int n);
  
  // @access Public Member
public:
  // @cmember Costruttore
  TToken_string(const char* = "", char separator = '|');
  // @cmember Costruttore
  TToken_string(int n, char separator = '|');
  // @cmember Costruttore
  TToken_string(const TToken_string& s);
  // @cmember Distruttore
  ~TToken_string();

  // @cmember Crea un duplicato della token string
  virtual TObject* dup() const;
  // @cmember Setta il carattere separatore a s
  void separator(char s);
  // @cmember Ritorna il carattere separatore
  char separator() const { return _separator; }

  // @cmember Rimette all'inizio il puntatore
  void restart()
  { _last = empty() ? -1 : 0; }
  // @cmember Assegna una stringa
  const TString& operator =(const char* s)
  { set(s);restart();return *this; }
  // @cmember Assegna una stringa
  const TString& operator =(const TString& s)
  { set(s);restart();return *this; }
  // @cmember Assegna una stringa
  const TToken_string& operator =(const TToken_string& s);

  // @cmember Aggiunge una stringa
  void add(const char* s, int n = -1);
  // @cmember Aggiunge un carattere
  void add(char c, int pos = -1);
  // @cmember Aggiunge un long
  void add(long n, int pos = -1);
  // @cmember Aggiunge un intero
  void add(int n, int pos = -1);
  // @cmember Inserisce una stringa
  void insert_at(const char* s, int n);
  // @cmember Toglie la stringa di posizione pos
  void destroy(int pos);
  
  // @cmember Ritorna il prossimo token
  const char* get();
  // @cmember Ritorna un token
  const char* get(int n);
  // @cmember Ritorna un carattere (chiama <mf TToken_string::get>)
  char get_char(int n = -1);
  // @cmember Ritorna un intero (chiama <mf TToken_string::get>)
  int get_int(int n = -1);
  // @cmember Ritorna un intero esteso (chiama <mf TToken_string::get>)
  long get_long(int n = -1);
  
  // TToken_string new age: const methods;
  // @cmember Ritorna l'ennesimo token
  bool get(int n, TString& tok) const;
  // @cmember Ritorna l'ennesimo char
  bool get(int n, char& tok) const;
  // @cmember Ritorna l'ennesimo int
  bool get(int n, int& tok) const;
  // @cmember Ritorna l'ennesimo long
  bool get(int n, long& tok) const;
  // @cmember Ritorna l'ennesimo real
  bool get(int n, real& tok) const;
  
  // @cmember Ritorna la posizione dell'item s
  int get_pos(const char* s);
  // @cmember Ritorna la posizione dell'item s
  int get_pos(long s);
  // @cmember Ritorna il numero di token presenti
  int items() const;
  // @cmember Controlla se tutti i token sono nulli
  bool empty_items() const;
};

#define FOR_EACH_TOKEN(__tok, __str) \
  for (const char* __str = __tok.get(0); __str; __str = __tok.get())
#define FOR_EACH_STR_TOKEN(__tok, __str)                                  \
  TString __str;for (int __t=0;__tok.get(__t,__str);__t++) 
  
///////////////////////////////////////////////////////////
// Mitica token string che sceglie da sola il separatore
///////////////////////////////////////////////////////////

class TAuto_token_string : public TToken_string
{ 
protected:
  TAuto_token_string& create(const char* ts);

public:                            
  TAuto_token_string& operator=(const char* ts) { return create(ts); }
  TAuto_token_string& operator=(const TString& ts) { return create(ts); }
  TAuto_token_string& operator=(const TToken_string& ts) { return create(ts); }
  TAuto_token_string& operator=(const TAuto_token_string& ts) { return create(ts); }
  TAuto_token_string(int sz = 50) : TToken_string(sz) { }
  TAuto_token_string(const char* ts) { create(ts); }
  virtual ~TAuto_token_string() { }
};    

///////////////////////////////////////////////////////////
// TParagraph_string
///////////////////////////////////////////////////////////

// @doc EXTERNAL

// @class TParagraph_string | Classe che serve per spezzare le stringhe in paragrafi
//                            lunghi al massimo la lunghezza fissata
//
// @base public | TToken_string
class TParagraph_string : public TToken_string
// @author:(INTERNAL) Guido 
{
  // @access:(INTERNAL) Private Member

  // @cmember:(INTERNAL) Lunghezza massima del paragrafo
  int _width;

  // @access Protected Member
protected:
  // @cmember Spezza la stringa in paragrafi di lunghezza massima fissata
  void tokenize();

  // @access Public Member
public:
  // @cmember Costruttore
  TParagraph_string(const char* s, int width);

  // @cmember Distruttore
  virtual ~TParagraph_string() { }

  // @cmember Assegna una stringa
  const TString& operator =(const char* s);
  // @cmember Assegna un oggetto stringa
  const TString& operator =(const TString & s)
  { return operator=((const char *) s);}
  // @cmember Permette di assegnare la lunghezza massima del paragrafo
  void set_width(int width)
  { _width = width; }
};

///////////////////////////////////////////////////////////
// DES TString_array
///////////////////////////////////////////////////////////

// @doc EXTERNAL

// @class TString_array | Array di stringhe
//
// @base public | TArray
class TString_array : public TArray
// @author:(INTERNAL) Guido
{
  // @access Public Member
public:
  // @cmember Ritorna la stringa n dell'array (se non c'e' ritorna errore)
  TToken_string& row(int n)
  { return (TToken_string&)operator[](n); }
  // @cmember Ritorna la stringa n dell'array (se non c'e' ritorna errore)
  const TToken_string& row(int n) const
  { return (const TToken_string&)operator[](n); }
  // @cmember Restituisce il puntatore alla stringa n dell'array (NULL se non esiste)
  TToken_string* rowptr(int n)
  { return (TToken_string*)objptr(n); }
  // @cmember assegnamento di un array
  const TString_array& operator=(const TString_array& a);
  // @cmember Aggiunge una Token string all'array (chiama <mf TArray::add>)
  int add(TToken_string* s, int n = -1)
  { return TArray::add(s, n); }
  // @cmember Aggiunge un oggetto stringa all'array (chiama <mf TArray::add>)
  int add(const TToken_string& s, int n = -1);
  // @cmember Aggiunge una stringa all'array (chiama <mf TArray::add>)
  int add(const char* s, int n = -1);
  // @cmember Cerca una stringa nell'array
  int find(const char* s, int from = 0) const;
  // @cmember Ordina alfabeticamente l'array
  void sort(bool ascendig = true);

  // @cmember Costruttore
  TString_array(int size = 8) : TArray(size)
  {}
  // @cmember Distruttore
  virtual ~TString_array()
  {}
};

TString& user();

TToken_string& get_tmp_string(int len = -1);

const TToken_string& empty_string();
#define EMPTY_STRING empty_string()

#define FOR_EACH_ARRAY_ROW(__arr, __r, __riga)               \
  TToken_string* __riga;                                     \
  int __r;                              \
  for (__r = (__arr).first();                              \
       (__riga = (TToken_string*)(__arr).objptr(__r));           \
       __r = (__arr).succ(__r))

#define FOR_EACH_ARRAY_ROW_BACK(__arr, __r, __riga)          \
  TToken_string* __riga;                                     \
  int __r;                               \
  for (__r = (__arr).last();                               \
       (__riga = (TToken_string*)(__arr).objptr(__r));           \
       __r = (__arr).pred(__r))

const char SLASH =
#if XVT_OS == XVT_OS_WIN32
'\\';
#else                   
'/';
#endif

#endif