ruby-sfst 0.4.3 → 0.4.4

data/ext/sfst_machine/fst.h

@@ -1,369 +0,0 @@
-/*******************************************************************/
-/*                                                                 */
-/*  FILE     fst.h                                                 */
-/*  MODULE   fst                                                   */
-/*  PROGRAM  SFST                                                  */
-/*  AUTHOR   Helmut Schmid, IMS, University of Stuttgart           */
-/*                                                                 */
-/*  PURPOSE  finite state tools                                    */
-/*                                                                 */
-/*******************************************************************/
-
-#ifndef _FST_H_
-#define _FST_H_
-
-#include "alphabet.h"
-
-
-/*******************************************************************/
-/* include commands                                                */
-/*******************************************************************/
-
-#include <string>
-
-#include <vector>
-
-#include "mem.h"
-
-typedef unsigned short VType;
-
-extern int Quiet;
-
-class Node;
-class Arc;
-class Arcs;
-class Transducer;
-
-
-struct hashf {
-  size_t operator()(const Node *n) const { return (size_t) n; }
-};
-struct equalf {
-  int operator()(const Node *n1, const Node *n2) const { return n1==n2; }
-};
-typedef hash_set<Node*, hashf, equalf> NodeHashSet;
-
-
-/*****************  class Arc  *************************************/
-
-class Arc {
-
- private:
-  Label l;
-  Node *target;
-  Arc *next;
-
- public:
-  void init( Label ll, Node *node ) { l=ll; target=node; };
-  Label label( void ) const { return l; };
-  Node *target_node( void ) { return target; };
-  const Node *target_node( void ) const { return target; };
-
-  friend class Arcs;
-  friend class ArcsIter;
-};
-
-
-/*****************  class Arcs  ************************************/
-
-class Arcs {
-
- private:
-  Arc *first_arcp;
-  Arc *first_epsilon_arcp;
-
- public:
-  void init( void ) { first_arcp = first_epsilon_arcp = NULL; };
-  Arcs( void ) { init(); };
-  Node *target_node( Label l );
-  const Node *target_node( Label l ) const;
-  void add_arc( Label, Node*, Transducer* );
-  int remove_arc( Arc* );
-  bool is_empty( void ) const { return !(first_arcp || first_epsilon_arcp); };
-  bool epsilon_transition_exists( void ) const { return first_epsilon_arcp != NULL; };
-  bool non_epsilon_transition_exists( void ) const { return first_arcp != NULL; };
-  int size( void ) const;
-
-  friend class ArcsIter;
-};
-
-
-/*****************  class ArcsIter  ********************************/
-
-class ArcsIter {
-
-  // ArcsIter iterates over the arcs starting with epsilon arcs
-
- private:
-  Arc *current_arcp;
-  Arc *more_arcs;
-
- public:
-  typedef enum {all,non_eps,eps}  IterType;
-
-  ArcsIter( const Arcs *arcs, IterType type=all ) {
-    more_arcs = NULL;
-    if (type == all) {
-      if (arcs->first_epsilon_arcp) {
-	current_arcp = arcs->first_epsilon_arcp;
-	more_arcs = arcs->first_arcp;
-      }
-      else
-	current_arcp = arcs->first_arcp;
-    }
-    else if (type == non_eps)
-      current_arcp = arcs->first_arcp;
-    else
-      current_arcp = arcs->first_epsilon_arcp;
-  };
-  
-  void operator++( int ) {
-    if (current_arcp) {
-      current_arcp = current_arcp->next;
-      if (!current_arcp && more_arcs) {
-	current_arcp = more_arcs;
-	more_arcs = NULL;
-      }
-    }
-  };
-  operator Arc*( void ) { return current_arcp; };
-  
-};
-
-
-/*****************  class Node  ************************************/
-
-class Node {
-
- private:
-  bool final;
-  VType visited;
-  Arcs arcsp;
-  Node *forwardp;
-
- public:
-  Node( void ) { init(); };
-  void init( void );
-  bool is_final( void ) const { return final; };
-  void set_final( bool flag ) { final = flag; };
-  void set_forward( Node *node ) { forwardp = node; };
-  const Node *target_node( Label l ) const { return arcs()->target_node(l); };
-  Node *target_node( Label l ) { return arcs()->target_node(l); };
-  void add_arc( Label l, Node *n, Transducer *a ) { arcs()->add_arc(l, n, a); };
-  Arcs *arcs( void ) { return &arcsp; };
-  const Arcs *arcs( void ) const { return &arcsp; };
-  Node *forward( void ) { return forwardp; };
-  void clear_visited( NodeHashSet &nodeset );
-  bool was_visited( VType vmark ) {
-    if (visited == vmark)
-      return true;
-    visited = vmark;
-    return false;
-  };
-  bool check_visited( VType vm ) // leaves the visited flag unchanged
-    { return (visited==vm); };
-};
-
-
-/*****************  class Node2Int *********************************/
-
-class Node2Int {
-
-  struct hashf {
-    size_t operator()(const Node *node) const { 
-      return (size_t)node;
-    }
-  };
-  struct equalf {
-    int operator()(const Node *n1, const Node *n2) const {
-      return (n1 == n2);
-    }
-  };
-  typedef hash_map<Node*, int, hashf, equalf> NL;
-
- private:
-  int current_number;
-  NL number;
-
-public:
-  int &operator[]( Node *node ) {
-    NL::iterator it=number.find(node);
-    if (it == number.end())
-      return number.insert(NL::value_type(node, 0)).first->second;
-    return it->second;
-  };
-};
-
-
-/*****************  class NodeNumbering ****************************/
-
-class NodeNumbering {
-
- private:
-  std::vector<Node*> nodes;
-  Node2Int nummap;
-  void number_node( Node*, Transducer& );
-
- public:
-  NodeNumbering( Transducer& );
-  int operator[]( Node *node ) { return nummap[node]; };
-  size_t number_of_nodes( void ) { return nodes.size(); };
-  Node *get_node( size_t n ) { return nodes[n]; };
-};
-
-
-/*****************  class PairMapping  ****************************/
-
-class PairMapping {
-  // This class is used to map a node pair from two transducers
-  // to a single node in another transducer
-
-  typedef std::pair<Node*, Node*> NodePair;
-
- private:
-  struct hashf {
-    size_t operator()(const NodePair p) const { 
-      return (size_t)p.first ^ (size_t)p.second;
-    }
-  };
-  struct equalf {
-    int operator()(const NodePair p1, const NodePair p2) const {
-      return (p1.first==p2.first && p1.second == p2.second);
-    }
-  };
-  typedef hash_map<NodePair, Node*, hashf, equalf> PairMap;
-  PairMap pm;
-  
- public:
-  typedef PairMap::iterator iterator;
-  iterator begin( void ) { return pm.begin(); };
-  iterator end( void ) { return pm.end(); };
-  iterator find( Node *n1, Node *n2 )
-    { return pm.find( NodePair(n1,n2) ); };
-  Node* &operator[]( NodePair p ) { return pm.operator[](p); };
-  
-};
-
-
-/*****************  class Transducer  *******************************/
-
-class Transducer {
-
- private:
-  bool deterministic;
-  bool minimised;
-  Node root;
-  Mem mem;
-
-  typedef std::set<Label, Label::label_cmp> LabelSet;
-  typedef hash_map<Character, char*> SymbolMap;
-
-  void incr_vmark( void ) {
-    if (++vmark == 0) {
-      NodeHashSet nodes;
-      root.clear_visited( nodes );
-      fprintf(stderr,"clearing flags\n");
-      vmark = 1;
-    }
-  };
-  void reverse_node( Node *old_node, Transducer *new_node );
-  Label recode_label( Label, bool lswitch, bool recode, Alphabet& );
-  Node *copy_nodes( Node *n, Transducer *a, 
-		    bool lswitch=false, bool recode=false );
-  void rec_cat_nodes( Node*, Node* );
-  bool productive_node( Node* );
-  bool prune_nodes( Node* );
-  void negate_nodes( Node*, Node* );
-  bool compare_nodes( Node *node, Node *node2, Transducer &a2 );
-  void map_nodes( Node *node, Node *node2, Transducer *a, Level level );
-  void freely_insert_at_node( Node *node, Label l );
-  int print_strings_node(Node *node, char *buffer, int pos, FILE *file, bool);
-  bool infinitely_ambiguous_node( Node* );
-  bool is_cyclic_node( Node*, NodeHashSet &visited );
-  bool is_automaton_node( Node* );
-  bool generate1( Node*, Node2Int&, char*, int, char*, int, FILE* );
-  void store_symbols( Node*, SymbolMap&, LabelSet& );
-
-  void splice_nodes(Node*, Node*, Label sl, Transducer*, Transducer*);
-  void splice_arc( Node*, Node*, Node*, Transducer* );
-  void enumerate_paths_node( Node*, std::vector<Label>&, NodeHashSet&, 
-			     std::vector<Transducer*>& );
-  void replace_char2( Node*, Node*, Character, Character, Transducer* );
-  Node *create_node( std::vector<Node*>&, char*, size_t line );
-  void read_transducer_binary( FILE* );
-  void read_transducer_text( FILE* );
-
- public:
-  VType vmark;
-  Alphabet alphabet; // The set of all labels, i.e. character pairs
-
-  Transducer( void ) : root(), mem()
-    { vmark = 0; deterministic = minimised = false; };
-  // convertion of a string to an transducer
-  Transducer( char *s, const Alphabet *a=NULL, bool extended=false );
-  // reads a word list from a file and stores it in the transducer
-  Transducer( std::istream&, const Alphabet *a=NULL, bool verbose=false );
-  // reads a transducer from a binary or text file
-  Transducer( FILE*, bool binary=true );
-  // turns a sequence of labels into a transducer
-  Transducer( std::vector<Label>& );
-
-  Node *root_node( void ) { return &root; };  // returns the root node
-  const Node *root_node( void ) const { return &root; };  // returns the root node
-  Node *new_node( void );                // memory alocation for a new node
-  Arc *new_arc( Label l, Node *target ); // memory alocation for a new arc
-  void add_string( char *s, bool extended=false, Alphabet *a=NULL );
-  void complete_alphabet( void );
-  void minimise_alphabet( void );
-  void prune( void );  // remove unnecessary arcs
-
-  int print_strings( FILE*, bool with_brackets=true ); //enumerate all strings
-
-  bool analyze_string( char *s, FILE *file, bool with_brackets=true );
-  bool generate_string( char *s, FILE *file, bool with_brackets=true );
-  bool generate( FILE *file, bool separate=false );
-
-  void clear( void );      // clears the transducer. The resulting transducer
-                           // is like one created with Transducer()
-  // copy duplicates an transducer
-  // if called with a non-zero argument, upper and lower level are switched
-  Transducer &copy( bool lswitch=false, const Alphabet *al=NULL );
-  Transducer &switch_levels( void ) { return copy( true ); };
-  Transducer &splice( Label l, Transducer *a);
-  Transducer &freely_insert( Label l );
-  Transducer &replace_char( Character c, Character nc );
-  Transducer &level( Level );
-  Transducer &lower_level( void )   // creates an transducer for the "lower" language
-    { return level(lower); };
-  Transducer &upper_level( void )   // creates an transducer for the "upper" language
-    { return level(upper); };
-  Transducer &determinise( void );  // creates a deterministic transducer
-  Transducer &minimise( bool verbose=true ); // creates a minimised transducer
-  void store( FILE* );       // stores the transducer in binary format
-  void store_lowmem( FILE* );
-  void read( FILE* );        // reads an transducer in binary format
-  bool enumerate_paths( std::vector<Transducer*>& );
-
-  Transducer &reverse( void );            // reverse language
-  Transducer &operator|( Transducer& );   // union, disjunction
-  Transducer &operator+( Transducer& );   // concatenation
-  Transducer &operator/( Transducer& );   // subtraction
-  Transducer &operator&( Transducer& );   // intersection, conjunction
-  Transducer &operator||( Transducer& );  // composition
-  Transducer &operator!( void );          // complement, negation
-  Transducer &kleene_star( void );
-  bool operator==( Transducer& );         // minimises its arguments first
-
-  bool is_cyclic( void );
-  bool is_automaton( void );
-  bool is_infinitely_ambiguous( void );
-  bool is_empty( void );	      // For efficiency reasons, these functions
-  bool generates_empty_string( void );// are better called after minimisation
-  
-  friend class NodeNumbering;
-  friend class EdgeCount;
-  friend class MakeCompactTransducer;
-  friend std::ostream &operator<<(std::ostream&, Transducer&);
-};
-
-#endif

data/ext/sfst_machine/interface.cc

@@ -1,1842 +0,0 @@
-/*******************************************************************/
-/*                                                                 */
-/*  FILE     interface.C                                           */
-/*  MODULE   interface                                             */
-/*  PROGRAM  SFST                                                  */
-/*  AUTHOR   Helmut Schmid, IMS, University of Stuttgart           */
-/*                                                                 */
-/*******************************************************************/
-
-#include "interface.h"
-
-#include <fstream>
-using std::ifstream;
-using std::ofstream;
-
-#include <set>
-using std::set;
-
-#include "sgi.h"
-
-using std::cerr;
-using std::cout;
-using std::vector;
-
-struct ltstr {
-  bool operator()(const char* s1, const char* s2) const
-  { return strcmp(s1, s2) < 0; }
-};
-
-struct eqstr {
-  bool operator()(const char* s1, const char* s2) const
-  { return strcmp(s1, s2) == 0; }
-};
-
-typedef set<char*, ltstr> RVarSet;
-
-typedef hash_map<char*, Transducer*, hash<const char*>, eqstr> VarMap;
-
-typedef hash_map<char*, Range*, hash<const char*>, eqstr> SVarMap;
-
-bool Verbose=false;
-
-Alphabet TheAlphabet;
-
-static VarMap VM;
-static SVarMap SVM;
-static RVarSet RS;
-static RVarSet RSS;
-static int Alphabet_Defined=0;
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  error                                                          */
-/*                                                                 */
-/*******************************************************************/
-
-static void error( const char *message )
-
-{
-  cerr << "\nError: " << message << "\naborted.\n";
-  exit(1);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  error2                                                         */
-/*                                                                 */
-/*******************************************************************/
-
-void error2( char *message, char *input )
-
-{
-  cerr << "\nError: " << message << ": " << input << "\naborted.\n";
-  exit(1);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  symbol_code                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-Character symbol_code( char *symbol )
-
-{
-  int c=TheAlphabet.symbol2code(symbol);
-  if (c == EOF)
-    c = TheAlphabet.add_symbol( symbol );
-  free(symbol);
-  return (Character)c;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  character_code                                                 */
-/*                                                                 */
-/*******************************************************************/
-
-Character character_code( unsigned int uc )
-
-{
-  if (TheAlphabet.utf8)
-    return symbol_code(fst_strdup(int2utf8(uc)));
-
-  unsigned char *buffer=(unsigned char*)malloc(2);
-  buffer[0] = (unsigned char)uc;
-  buffer[1] = 0;
-  return symbol_code((char*)buffer);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  add_value                                                      */
-/*                                                                 */
-/*******************************************************************/
-
-Range *add_value( Character c, Range *r )
-
-{
-  Range *result=new Range;
-  result->character = c;
-  result->next = r;
-  return result;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  add_values                                                     */
-/*                                                                 */
-/*******************************************************************/
-
-Range *add_values( unsigned int c1, unsigned int c2, Range *r )
-
-{
-  for( unsigned int c=c2; c>=c1; c-- )
-    r = add_value(character_code(c), r);
-  return r;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  append_values                                                  */
-/*                                                                 */
-/*******************************************************************/
-
-Range *append_values( Range *r2, Range *r )
-
-{
-  if (r2 == NULL)
-    return r;
-  return add_value(r2->character, append_values(r2->next, r));
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  add_var_values                                                 */
-/*                                                                 */
-/*******************************************************************/
-
-Range *add_var_values( char *name, Range *r )
-
-{
-  return append_values(svar_value(name), r);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  in_range                                                       */
-/*                                                                 */
-/*******************************************************************/
-
-static bool in_range( unsigned int c, Range *r )
-
-{
-  while (r) {
-    if (r->character == c)
-      return true;
-    r = r->next;
-  }
-  return false;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  free_values                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-static void free_values( Range *r )
-
-{
-  if (r) {
-    free_values(r->next);
-    delete r;
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  free_values                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-static void free_values( Ranges *r )
-
-{
-  if (r) {
-    free_values(r->next);
-    delete r;
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  free_contexts                                                  */
-/*                                                                 */
-/*******************************************************************/
-
-static void free_contexts( Contexts *c )
-
-{
-  if (c) {
-    free_contexts(c->next);
-    delete c; 
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  copy_values                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-static Range *copy_values( const Range *r )
-
-{
-  if (r == NULL)
-    return NULL;
-  return add_value( r->character, copy_values(r->next));
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  complement_range                                               */
-/*                                                                 */
-/*******************************************************************/
-
-Range *complement_range( Range *r )
-
-{
-  vector<Character> sym;
-  for( Range *p=r; p; p=p->next)
-    sym.push_back( p->character );
-  free_values( r );
-
-  TheAlphabet.complement(sym);
-  if (sym.size() == 0)
-    error("Empty character range!");
-    
-
-  Range *result=NULL;
-  for( size_t i=0; i<sym.size(); i++ ) {
-    Range *tmp = new Range;
-    tmp->character = sym[i];
-    tmp->next = result;
-    result = tmp;
-  }
-
-  return result;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  make_transducer                                                */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *make_transducer( Range *r1, Range *r2 )
-
-{
-  Transducer *t=new Transducer();
-  Node *node=t->new_node();
-  node->set_final(1);
-
-  if (r1 == NULL || r2 == NULL) {
-    if (!Alphabet_Defined)
-      error("The wildcard symbol '.' requires the definition of an alphabet");
-
-    // one of the ranges was '.'
-    for(Alphabet::const_iterator it=TheAlphabet.begin(); 
-	it!=TheAlphabet.end(); it++)
-      if ((r1 == NULL || in_range(it->lower_char(), r1)) &&
-	  (r2 == NULL || in_range(it->upper_char(), r2)))
-	t->root_node()->add_arc( *it, node, t );
-  }
-  else {
-    for (;;) {
-      Label l(r1->character, r2->character);
-      // TheAlphabet.insert(l);
-      t->root_node()->add_arc( l, node, t );
-      if (!r1->next && !r2->next)
-	break;
-      if (r1->next)
-	r1 = r1->next;
-      if (r2->next)
-	r2 = r2->next;
-    }
-  }
-
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  empty_transducer                                               */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *empty_transducer()
-
-{
-  Transducer *t=new Transducer();
-  t->root_node()->set_final(1);
-
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  one_label_transducer                                           */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *one_label_transducer( Label l )
-
-{
-  Transducer *t = new Transducer();
-  Node *last = t->new_node();
-  t->root_node()->add_arc( l, last, t );
-  last->set_final(1);
-
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  new_transducer                                                 */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *new_transducer( Range *r1, Range *r2 )
-
-{
-  Transducer *t=make_transducer( r1, r2);
-  if (r1 != r2)
-    free_values(r1);
-  free_values(r2);
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  read_words                                                     */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *read_words( char *filename )
-
-{
-  if (Verbose)
-    fprintf(stderr,"\nreading words from %s...", filename);
-  ifstream is(filename);
-  if (!is.is_open()) {
-    static char message[1000];
-    sprintf(message,"Error: Cannot open file \"%s\"!", filename);
-    throw message;
-  }
-  free( filename );
-  Transducer *t = new Transducer(is, &TheAlphabet, Verbose);
-  is.close();
-  TheAlphabet.insert_symbols(t->alphabet);
-  if (Verbose)
-    fprintf(stderr,"finished\n");
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  read_transducer                                                */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *read_transducer( char *filename )
-
-{
-  if (Verbose)
-    fprintf(stderr,"\nreading transducer from %s...", filename);
-  FILE *file = fopen(filename,"rb");
-  if (file == NULL) {
-    static char message[1000];
-    sprintf(message,"Error: Cannot open file \"%s\"!",filename);
-    throw message;
-  }
-  Transducer t(file);
-  fclose(file);
-  if (t.alphabet.utf8 != TheAlphabet.utf8) {
-    static char message[1000];
-    sprintf(message,"Error: incompatible character encoding in file \"%s\"!",
-	    filename);
-    throw message;
-  }
-  free( filename );
-  Transducer *nt = &t.copy(false, &TheAlphabet);
-  TheAlphabet.insert_symbols(nt->alphabet);
-  if (Verbose)
-    fprintf(stderr,"finished\n");
-  return nt;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  def_alphabet                                                   */
-/*                                                                 */
-/*******************************************************************/
-
-void def_alphabet( Transducer *t )
-
-{
-  t = explode(t);
-  t = minimise(t);
-  t->alphabet.clear_char_pairs();
-  t->complete_alphabet();
-  TheAlphabet.clear_char_pairs();
-  TheAlphabet.copy(t->alphabet);
-  Alphabet_Defined = 1;
-  delete t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  def_svar  definition of a value range variable                 */
-/*                                                                 */
-/*******************************************************************/
-
-bool def_svar( char *name, Range *r )
-
-{
-  // delete the old value of the variable
-  SVarMap::iterator it=SVM.find(name);
-  if (it != SVM.end()) {
-    char *n=it->first;
-    Range *v=it->second;
-    SVM.erase(it);
-    delete v;
-    free(n);
-  }
-  SVM[name] = r;
-  return r == NULL;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  svar_value                                                     */
-/*                                                                 */
-/*******************************************************************/
-
-Range *svar_value( char *name )
-
-{
-  SVarMap::iterator it=SVM.find(name);
-  if (it == SVM.end())
-    error2("undefined variable", name);
-  free(name);
-  return copy_values(it->second);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  rsvar_value                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-Range *rsvar_value( char *name )
-
-{
-  if (RSS.find(name) == RSS.end())
-    RSS.insert(fst_strdup(name));
-  return add_value(symbol_code(name), NULL);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  def_var  definition of an transducer variable                  */
-/*                                                                 */
-/*******************************************************************/
-
-bool def_var( char *name, Transducer *t )
-
-{
-  // delete the old value of the variable
-  VarMap::iterator it=VM.find(name);
-  if (it != VM.end()) {
-    char *n=it->first;
-    Transducer *v=it->second;
-    VM.erase(it);
-    delete v;
-    free(n);
-  }
-
-  t = explode(t);
-  t = minimise(t);
-
-  VM[name] = t;
-  return t->is_empty();
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  def_rvar  definition of an agreement variable for automata     */
-/*                                                                 */
-/*******************************************************************/
-
-bool def_rvar( char *name, Transducer *t )
-
-{
-  if (t->is_cyclic())
-    error2("cyclic transducer assigned to", name);
-  return def_var( name, t );
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  var_value                                                      */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *var_value( char *name )
-
-{
-  VarMap::iterator it=VM.find(name);
-  if (it == VM.end())
-    error2("undefined variable", name);
-  free(name);
-  return &(it->second->copy());
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  rvar_value                                                     */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *rvar_value( char *name )
-
-{
-  if (RS.find(name) == RS.end())
-    RS.insert(fst_strdup(name));
-  Range *r=add_value(symbol_code(name), NULL);
-  return new_transducer(r,r);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  explode                                                        */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *explode( Transducer *t )
-
-{
-  if (RS.size() == 0 && RSS.size() == 0)
-    return t;
-
-  t = minimise(t);
-
-  vector<char*> name;
-  for( RVarSet::iterator it=RS.begin(); it!=RS.end(); it++)
-    name.push_back(*it);
-  RS.clear();
-
-  // replace all agreement variables
-  for( size_t i=0; i<name.size(); i++ ) {
-    Transducer *nt = NULL;
-    Label l(TheAlphabet.symbol2code(name[i]));
-    Transducer *vt=var_value(name[i]);
-
-    // enumerate all paths of the transducer
-    vector<Transducer*> it;
-    vt->enumerate_paths(it);
-    delete vt;
-
-    // insert each path
-    for( size_t i=0; i<it.size(); i++ ) {
-
-      // insertion
-      Transducer *t1 = &t->splice(l, it[i]);
-      delete it[i];
-
-      if (nt == NULL)
-	nt = t1;
-      else
-	nt = disjunction(nt, t1);
-    }
-    delete t;
-    t = nt;
-  }
-
-  name.clear();
-  for( RVarSet::iterator it=RSS.begin(); it!=RSS.end(); it++)
-    name.push_back(*it);
-  RSS.clear();
-
-  // replace all agreement variables
-  for( size_t i=0; i<name.size(); i++ ) {
-    Transducer *nt = NULL;
-    Character c=TheAlphabet.symbol2code(name[i]);
-    Range *r=svar_value(name[i]);
-
-    // insert each character
-    while (r != NULL) {
-
-      // insertion
-      Transducer *t1 = &t->replace_char(c, r->character);
-
-      if (nt == NULL)
-	nt = t1;
-      else
-	nt = disjunction(nt, t1);
-
-      Range *next = r->next;
-      delete r;
-      r = next;
-    }
-    delete t;
-    t = nt;
-  }
-
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  catenate                                                       */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *catenate( Transducer *t1, Transducer *t2 )
-
-{
-  Transducer *t = &(*t1 + *t2);
-  delete t1;
-  delete t2;
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  add_range                                                      */
-/*                                                                 */
-/*******************************************************************/
-
-Ranges *add_range( Range *r, Ranges *l )
-
-{
-  Ranges *result = new Ranges;
-  result->range = r;
-  result->next = l;
-  return result;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  make_mapping                                                   */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *make_mapping( Ranges *list1, Ranges *list2 )
-
-{
-  Ranges *l1=list1;
-  Ranges *l2=list2;
-  Transducer *t=new Transducer();
-
-  Node *node=t->root_node();
-  while (l1 && l2) {
-    Node *nn=t->new_node();
-    for( Range *r1=l1->range; r1; r1=r1->next )
-      for( Range *r2=l2->range; r2; r2=r2->next )
-	node->add_arc( Label(r1->character, r2->character), nn, t );
-    node = nn;
-    l1 = l1->next;
-    l2 = l2->next;
-  }
-  while (l1) {
-    Node *nn=t->new_node();
-    for( Range *r1=l1->range; r1; r1=r1->next )
-      node->add_arc( Label(r1->character, Label::epsilon), nn, t );
-    node = nn;
-    l1 = l1->next;
-  }
-  while (l2) {
-    Node *nn=t->new_node();
-    for( Range *r2=l2->range; r2; r2=r2->next )
-      node->add_arc( Label(Label::epsilon, r2->character), nn, t );
-    node = nn;
-    l2 = l2->next;
-  }
-  node->set_final(1);
-
-  free_values(list1);
-  free_values(list2);
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  disjunction                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *disjunction( Transducer *t1, Transducer *t2 )
-
-{
-  Transducer *t = &(*t1 | *t2);
-  delete t1;
-  delete t2;
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  conjunction                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *conjunction( Transducer *t1, Transducer *t2 )
-
-{
-  if (RS.size() > 0 || RSS.size() > 0)
-    cerr << "\nWarning: agreement operation inside of conjunction!\n";
-  Transducer *t = &(*t1 & *t2);
-  delete t1;
-  delete t2;
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  subtraction                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *subtraction( Transducer *t1, Transducer *t2 )
-
-{
-  if (RS.size() > 0 || RSS.size() > 0)
-    cerr << "\nWarning: agreement operation inside of conjunction!\n";
-  Transducer *t = &(*t1 / *t2);
-  delete t1;
-  delete t2;
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  composition                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *composition( Transducer *t1, Transducer *t2 )
-
-{
-  if (RS.size() > 0 || RSS.size() > 0)
-    cerr << "\nWarning: agreement operation inside of composition!\n";
-  Transducer *t = &(*t1 || *t2);
-  delete t1;
-  delete t2;
-  return t;
-}
-
-/*******************************************************************/
-/*                                                                 */
-/*  freely_insert                                                  */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *freely_insert( Transducer *t, Character lc, Character uc )
-
-{
-  return &t->freely_insert(Label(lc,uc));
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  negation                                                       */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *negation( Transducer *t )
-
-{
-  if (RS.size() > 0 || RSS.size() > 0)
-    cerr << "\nWarning: agreement operation inside of negation!\n";
-  if (!Alphabet_Defined)
-    error("Negation requires the definition of an alphabet");
-  t->alphabet.clear_char_pairs();
-  t->alphabet.copy(TheAlphabet);
-  Transducer *nt = &(!*t);
-  delete t;
-  return nt;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  upper_level                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *upper_level( Transducer *t )
-
-{
-  Transducer *nt = &t->upper_level();
-  delete t;
-  return nt;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  lower_level                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *lower_level( Transducer *t )
-
-{
-  Transducer *nt = &t->lower_level();
-  delete t;
-  return nt;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  minimise                                                       */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *minimise( Transducer *t )
-
-{
-  t->alphabet.copy(TheAlphabet);
-  Transducer *nt = &t->minimise( Verbose );
-  delete t;
-  return nt;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  switch_levels                                                  */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *switch_levels( Transducer *t )
-
-{
-  Transducer *nt = &t->switch_levels();
-  delete t;
-  return nt;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  repetition                                                     */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *repetition( Transducer *t )
-
-{
-  Transducer *nt = &(t->kleene_star());
-  delete t;
-  return nt;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  repetition2                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *repetition2( Transducer *t )
-
-{
-  Transducer *t1 = &(t->kleene_star());
-  Transducer *nt = &(*t + *t1);
-  delete t;
-  delete t1;
-  return nt;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  optional                                                       */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *optional( Transducer *t )
-
-{
-  Transducer *nt = &(t->copy());
-  nt->root_node()->set_final(1);
-  delete t;
-  return nt;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  add_pi_transitions                                             */
-/*                                                                 */
-/*******************************************************************/
-
-static void add_pi_transitions( Transducer *t, Node *node, Alphabet &alph )
-
-{
-  for( Alphabet::const_iterator it=alph.begin(); it!=alph.end(); it++)
-    node->add_arc( *it, node, t );
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  pi_machine                                                     */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *pi_machine( Alphabet &alph )
-
-{
-  Transducer *t=new Transducer();
-  t->root_node()->set_final(1);
-  add_pi_transitions( t, t->root_node(), alph );
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  cp                                                             */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *cp( Range *lower_range, Range *upper_range )
-
-{
-  return make_transducer(lower_range, upper_range);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  anti_cp                                                        */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *anti_cp( Range *lower_range, Range *upper_range )
-
-{
-  Transducer *cpt = cp(lower_range, upper_range);
-  Transducer *t=new Transducer();
-  Node *node=t->new_node();
-
-  node->set_final(1);
-  for(Alphabet::const_iterator it=TheAlphabet.begin(); 
-      it!=TheAlphabet.end(); it++){
-    Label l=*it;
-    if (in_range(l.lower_char(), lower_range) &&
-	!cpt->root_node()->target_node(l))
-      t->root_node()->add_arc( l, node, t );
-  }
-  if (in_range(Label::epsilon, lower_range) &&
-      !cpt->root_node()->target_node(Label()))
-      t->root_node()->add_arc( Label(), node, t );
-
-  delete cpt;
-  return t;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  twol_right_rule                                                */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *twol_right_rule( Transducer *lc, Range *lower_range, 
-				   Range *upper_range, Transducer *rc )
-
-{
-  // Build the rule transducer
-  Transducer *cpt = cp(lower_range, upper_range);
-  Transducer *pi=pi_machine(TheAlphabet);
-
-  // First unwanted language
-
-  lc->alphabet.copy(TheAlphabet);
-  Transducer *notlc = &(!*lc);
-  Transducer *tmp = &(*notlc + *cpt);
-  delete notlc;
-  Transducer *t1 = &(*tmp + *pi);
-  delete tmp;
-
-  // Second unwanted language
-  rc->alphabet.copy(TheAlphabet);
-  Transducer *notrc = &(!*rc);
-  tmp = &(*cpt + *notrc);
-  delete cpt;
-  delete notrc;
-  Transducer *t2 = &(*pi + *tmp);
-  delete pi;
-  delete tmp;
-
-  tmp = &(*t1|*t2); 
-  delete t1; 
-  delete t2; 
-
-  tmp->alphabet.copy(TheAlphabet);
-  t1 = &(!*tmp); 
-  delete tmp; 
-
-  return t1;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  twol_left_rule                                                 */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *twol_left_rule( Transducer *lc, Range *lower_range,
-				  Range *upper_range, Transducer *rc )
-
-{
-  // check for problematic insertion operations like "$L <> <= a $R"
-  // where either $L or $R includes the empty string
-  if (in_range(Label::epsilon, lower_range)) {
-    if (lc->generates_empty_string())
-      error("in two level rule: insertion operation with deletable left context!");
-    if (rc->generates_empty_string())
-      error("in two level rule: insertion operation with deletable right context!");
-    cerr << "\nWarning: two level rule used for insertion operation (might produce unexpected results)\n";
-  }
-
-  // Build the rule transducer
-  Transducer *t1 = anti_cp(lower_range, upper_range);
-
-  // Add the left context;
-  Transducer *t2 = &(*lc + *t1);
-  delete t1;
-
-  // Add the right context;
-  t1 = &(*t2 + *rc);
-  delete t2;
-
-  // Form the complement
-  t1->alphabet.copy(TheAlphabet);
-  t2 = &(!*t1);
-  delete t1;
-
-  return t2;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  make_rule                                                      */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *make_rule( Transducer *lc, Range *lower_range, Twol_Type type, 
-		      Range *upper_range, Transducer *rc )
-
-{
-  if (RS.size() > 0 || RSS.size() > 0)
-    cerr << "\nWarning: agreement operation inside of replacement rule!\n";
-
-  if (!Alphabet_Defined)
-    error("Two level rules require the definition of an alphabet");
-
-  // expand the left and the right contexts to their full length
-  Transducer *pi=pi_machine(TheAlphabet);
-
-  if (lc == NULL)
-    lc = pi_machine(TheAlphabet);
-  else {
-    Transducer *tmp = &(*pi + *lc);
-    delete lc;
-    lc = tmp;
-  }
-  if (rc == NULL)
-    rc = pi_machine(TheAlphabet);
-  else {
-    Transducer *tmp = &(*rc + *pi);
-    delete rc;
-    rc = tmp;
-  }
-  delete pi;
-
-  Transducer *result = NULL;
-
-  switch (type) {
-  case twol_left:
-    result = twol_left_rule(lc, lower_range, upper_range, rc);
-    break;
-  case twol_right:
-    result = twol_right_rule(lc, lower_range, upper_range, rc);
-    break;
-  case twol_both:
-    {
-      Transducer *t1 = twol_left_rule(lc, lower_range, upper_range, rc);
-      Transducer *t2 = twol_right_rule(lc, lower_range, upper_range, rc);
-      result = &(*t1 & *t2);
-      delete t1;
-      delete t2;
-    }
-  }
-  delete lc;
-  delete rc;
-  if (lower_range != upper_range)
-    free_values(lower_range);
-  free_values(upper_range);
-
-  return minimise(result);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  make_context                                                   */
-/*                                                                 */
-/*******************************************************************/
-
-Contexts *make_context( Transducer *l, Transducer *r )
-
-{
-  if (l == NULL)
-    l = empty_transducer();
-  if (r == NULL)
-    r = empty_transducer();
-
-  Contexts *c=new Contexts();
-  c->left = l;
-  c->right = r;
-  c->next = NULL;
-
-  return c;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  add_context                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-Contexts *add_context( Contexts *nc, Contexts *c )
-
-{
-  nc->next = c;
-  return nc;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  restriction_transducer                                         */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *restriction_transducer( Transducer *l1, Transducer *l2,
-					   Character marker )
-
-{
-  l1->alphabet.copy(TheAlphabet);
-  Transducer *t1 = &(*l1 / *l2);
-
-  Transducer *t2 = &t1->replace_char(marker, Label::epsilon);
-  delete t1;
-
-  t2->alphabet.copy(TheAlphabet);
-  t1 = &(!*t2);
-  delete t2;
-
-  return t1;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  marker_transducer                                              */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *marker_transducer( Transducer *t, Contexts *c,
-				      Character &marker )
-{
-  marker = TheAlphabet.new_marker();
-  Transducer *result = one_label_transducer( Label(marker) );
-
-  // build the alphabet with a new marker
-  result->alphabet.insert_symbols(t->alphabet);
-  while (c) {
-    result->alphabet.insert_symbols(c->left->alphabet);
-    result->alphabet.insert_symbols(c->right->alphabet);
-    c = c->next;
-  }
-
-  return result;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  center_transducer                                              */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *center_transducer( Transducer *t, Transducer *pi, 
-				      Transducer *mt )
-{
-  // create the concatenation   pi + mt + *t + mt + pi
-  Transducer *t1=&(*pi + *mt);
-  Transducer *t2=&(*t1 + *t);
-  delete t1;
-  t1 = &(*t2 + *mt);
-  delete t2;
-  t2 = &(*t1 + *pi);
-  delete t1;
-  return t2;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  context_transducer                                             */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *context_transducer( Transducer *t, Transducer *pi,
-				       Transducer *mt, Contexts *c )
-{
-  // pi + left[i] + mt + pi + mt + right[i] + pi
-  
-  Transducer *t1 = &(*mt + *t);
-  Transducer *tmp = &(*t1 + *mt);
-  delete t1;
-  Transducer *result=NULL;
-
-  while (c) {
-    t1 = &(*pi + *c->left);
-    Transducer *t2 = &(*t1 + *tmp);
-    delete t1;
-    t1 = &(*t2 + *c->right);
-    delete t2;
-    t2 = &(*t1 + *pi);
-    delete t1;
-
-    if (result) {
-      t1 = &(*result | *t2);
-      delete t2;
-      result = t1;
-    }
-    else 
-      result = t2;
-
-    c = c->next;
-  }
-  delete tmp;
-
-  return result;
-}
-
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  result_transducer                                              */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *result_transducer( Transducer *l1, Transducer *l2,
-				      Twol_Type type, Character marker )
-{
-  Transducer *result=NULL;
-  if (type == twol_right)
-    result = restriction_transducer( l1, l2, marker );
-  else if (type == twol_left)
-    result = restriction_transducer( l2, l1, marker );
-  else if (type == twol_both) {
-    Transducer *t1 = restriction_transducer( l1, l2, marker );
-    Transducer *t2 = restriction_transducer( l2, l1, marker );
-    result = &(*t1 & *t2);
-    delete t1;
-    delete t2;
-  }
-
-  return result;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  restriction                                                    */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *restriction( Transducer *t, Twol_Type type, Contexts *c, 
-			 int direction )
-{
-  Character marker;
-  Transducer *mt=marker_transducer( t, c, marker );
-  Transducer *pi=pi_machine(TheAlphabet);
-  Transducer *l1=center_transducer( t, pi, mt );
-
-  Transducer *tmp;
-  if (direction == 0)
-    tmp = pi;
-  else if (direction == 1) {
-    // compute  _t || .*
-    Transducer *t1 = &t->lower_level();
-    tmp = &(*t1 || *pi);
-    delete t1;
-  }
-  else {
-    // compute  ^t || .*
-    Transducer *t1 = &t->upper_level();
-    tmp = &(*pi || *t1);
-    delete t1;
-  }
-  delete t;
-
-  Transducer *l2=context_transducer( tmp, pi, mt, c );
-  if (tmp != pi)
-    delete tmp;
-  delete pi;
-  delete mt;
-
-  Transducer *result=result_transducer( l1, l2, type, marker );
-  delete l1;
-  delete l2;
-
-  free_contexts( c );
-
-  return result;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  constrain_boundary_transducer                                  */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *constrain_boundary_transducer( Character leftm, 
-						  Character rightm )
-{
-  // create the transducer  (.|<L>|<R>)*
-
-  Transducer *tmp=pi_machine(TheAlphabet);
-
-  // create the transducer  (.|<L>|<R>)* <L><R> (.|<L>|<R>)*
-  Node *root = tmp->root_node();
-  Node *node = tmp->new_node();
-  Node *last = tmp->new_node();
-
-  root->set_final(0);
-  last->set_final(1);
-
-  root->add_arc( Label(leftm), node, tmp);
-  node->add_arc( Label(rightm), last, tmp);
-
-  add_pi_transitions( tmp, last, TheAlphabet );
-
-  // create the transducer  !((.|<L>|<R>)* <L><R> (.|<L>|<R>)*)
-  tmp->alphabet.copy(TheAlphabet);
-  Transducer *result = &(!*tmp);
-  delete tmp;
-
-  return result;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  extended_left_transducer                                       */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *extended_left_transducer( Transducer *t, 
-					     Character m1, Character m2 )
-{
-  if (t == NULL) // empty context
-    return pi_machine(TheAlphabet);
-
-  // Extended left context transducer
-
-  // <R> >> (<L> >> $T$)
-  Transducer *tmp=&t->freely_insert( Label(m1) );
-  delete t;
-  t = &tmp->freely_insert( Label(m2) );
-  delete tmp;
-
-  // .* (<R> >> (<L> >> $T$))
-  add_pi_transitions( t, t->root_node(), TheAlphabet );
-
-  // !(.*<L>)
-  tmp = one_label_transducer(Label(m1));
-  add_pi_transitions( tmp, tmp->root_node(), TheAlphabet );
-  tmp->alphabet.copy(TheAlphabet);
-  Transducer *t2 = &(!*tmp);
-  delete tmp;
-    
-  // .* (<R> >> (<L> >> $T$)) || !(.*<L>)
-  tmp = &(*t || *t2);
-  delete t;
-  delete t2;
-
-  return tmp;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  left_context                                                   */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *left_context( Transducer *t, Character m1, Character m2 )
-
-{
-  // .* (<R> >> (<L> >> $T$)) || !(.*<L>)
-  Transducer *ct = extended_left_transducer(t, m1, m2);
-
-  // <R>* <L> .*
-  Transducer *mt = one_label_transducer(Label(m1));
-  mt->root_node()->add_arc(Label(m2), mt->root_node(), mt );
-  add_pi_transitions(mt, mt->root_node()->target_node(Label(m1)),TheAlphabet);
-
-  ct->alphabet.copy(TheAlphabet);
-  Transducer *no_ct = &!*ct;
-
-  mt->alphabet.copy(TheAlphabet);
-  Transducer *no_mt = &!*mt;
-
-  {
-    static int print=1;
-    if (print) {
-      print = 0;
-      Transducer *temp = &(ct->copy());
-      temp = &(no_ct->copy());
-      temp = &(mt->copy());
-      temp = &(no_mt->copy());
-    }
-  }
-      
-  Transducer *t1 = &(*no_ct + *mt);
-  delete no_ct;
-  delete mt;
-
-  Transducer *t2 = &(*ct + *no_mt);
-  delete ct;
-  delete no_mt;
-
-  Transducer *tmp = &(*t1 | *t2);
-  delete t1;
-  delete t2;
-
-  tmp->alphabet.copy(TheAlphabet);
-  t1 = &!*tmp;
-  delete tmp;
-
-  return t1;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  make_optional                                                  */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *make_optional( Transducer *t )
-
-{
-  Transducer *t1 = pi_machine(TheAlphabet);
-  Transducer *t2 = &(*t | *t1);
-  delete t;
-  delete t1;
-  return t2;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  replace                                                        */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *replace( Transducer *ct, Repl_Type type, bool optional )
-
-{
-  // compute the no-center transducer
-  Transducer *tmp;
-
-  if (type == repl_up)
-    // _ct
-    tmp = &ct->lower_level();
-  else if (type == repl_down)
-    // ^ct
-    tmp = &ct->upper_level();
-  else
-    error("Invalid type of replace operator");
-
-  // .* _ct
-  add_pi_transitions( tmp, tmp->root_node(), TheAlphabet );
-
-  // .*  _ct .*
-  Transducer *t2 = pi_machine(TheAlphabet);
-  Transducer *t3 = &(*tmp + *t2);
-  delete tmp;
-  delete t2;
-
-  // no_ct = !(.*  _ct .*)
-  t3->alphabet.copy(TheAlphabet);
-  Transducer *no_ct = &(!*t3);
-  delete t3;
-
-  // compute the unconditional replacement transducer
-
-  // no-ct ct
-  tmp = &(*no_ct + *ct);
-  delete ct;
-
-  // (no-ct ct)*
-  t2 = &(tmp->kleene_star());
-  delete tmp;
-
-  // (no-ct ct)* no-ct
-  tmp = &(*t2 + *no_ct);
-  delete t2;
-  delete no_ct;
-
-  if (optional)
-    tmp = make_optional(tmp);
-
-  return tmp;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  replace_transducer                                             */
-/*                                                                 */
-/*******************************************************************/
-
-static Transducer *replace_transducer( Transducer *ct, Character lm, 
-				       Character rm, Repl_Type type )
-{
-  // insert boundary markers into the center transducer
-
-  // <L> >> (<R> >> $Center$)
-  Transducer *tmp = &ct->freely_insert(Label(lm));
-  delete ct;
-  ct = &tmp->freely_insert(Label(rm));
-  delete tmp;
-  
-  // add surrounding boundary markers to the center transducer
-
-  // <L> (<L> >> (<R> >> $Center$))
-  Transducer *t2 = one_label_transducer( Label(lm) );
-  tmp = &(*t2 + *ct);
-  delete t2;
-  delete ct;
-      
-  // $CenterB$ = <L> (<L> >> (<R> >> $Center$)) <R>
-  t2 = one_label_transducer( Label(rm) );
-  ct = &(*tmp + *t2);
-  delete tmp;
-  delete t2;
-
-  return replace(ct, type, false);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  replace_in_context                                             */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *replace_in_context( Transducer *t, Repl_Type type, Contexts *c,
-				bool optional )
-{
-  // The implementation of the replace operators is based on
-  // "The Replace Operator" by Lauri Karttunen
-
-  if (!Alphabet_Defined)
-    error("The replace operators require the definition of an alphabet");
-
-  if (!c->left->is_automaton() || !c->right->is_automaton())
-    error("The replace operators require automata as context expressions!");
-
-  // create the marker symbols
-  Character leftm = TheAlphabet.new_marker();
-  Character rightm = TheAlphabet.new_marker();
-
-  /////////////////////////////////////////////////////////////
-  // Create the insert boundaries transducer (.|<>:<L>|<>:<R>)*
-  /////////////////////////////////////////////////////////////
-  
-  Transducer *ibt=pi_machine(TheAlphabet);
-  Node *root=ibt->root_node();
-  root->add_arc( Label(Label::epsilon, leftm), root, ibt);
-  root->add_arc( Label(Label::epsilon, rightm),root, ibt);
-
-  /////////////////////////////////////////////////////////////
-  // Create the remove boundaries transducer (.|<L>:<>|<R>:<>)*
-  /////////////////////////////////////////////////////////////
-
-  Transducer *rbt=pi_machine(TheAlphabet);
-  root = rbt->root_node();
-  root->add_arc( Label(leftm, Label::epsilon), root, rbt);
-  root->add_arc( Label(rightm,Label::epsilon), root, rbt);
-
-  // Add the markers to the alphabet
-  TheAlphabet.insert(Label(leftm));
-  TheAlphabet.insert(Label(rightm));
-
-  /////////////////////////////////////////////////////////////
-  // Create the constrain boundaries transducer !(.*<L><R>.*)
-  /////////////////////////////////////////////////////////////
-
-  Transducer *cbt=constrain_boundary_transducer(leftm, rightm);
-
-  /////////////////////////////////////////////////////////////
-  // Create the extended context transducers
-  /////////////////////////////////////////////////////////////
-
-  // left context transducer:  .* (<R> >> (<L> >> $T$)) || !(.*<L>)
-  Transducer *lct = left_context(c->left, leftm, rightm);
-
-  // right context transducer:  (<R> >> (<L> >> $T$)) .* || !(<R>.*)
-  Transducer *tmp = &c->right->reverse();
-  delete c->right;
-  Transducer *t2 = left_context(tmp, rightm, leftm);
-  Transducer *rct = &t2->reverse();
-  delete t2;
-
-  /////////////////////////////////////////////////////////////
-  // unconditional replace transducer
-  /////////////////////////////////////////////////////////////
-
-  Transducer *rt;
-  if (type == repl_up || type == repl_right || type == repl_left)
-    rt = replace_transducer( t, leftm, rightm, repl_up );
-  else
-    rt = replace_transducer( t, leftm, rightm, repl_down );
-
-  /////////////////////////////////////////////////////////////
-  // build the conditional replacement transducer
-  /////////////////////////////////////////////////////////////
-
-  tmp = &(ibt->copy());
-  tmp = &(cbt->copy());
-  tmp = &(lct->copy());
-  tmp = &(rct->copy());
-  tmp = &(rt->copy());
-  tmp = &(rbt->copy());
-
-  tmp = ibt;
-  tmp = &(*ibt || *cbt);
-  delete(ibt);
-  delete(cbt);
-
-  if (type == repl_up || type == repl_left) {
-    t2 = &(*tmp || *lct);
-    delete tmp;
-    delete lct;
-    tmp = t2;
-  }
-  if (type == repl_up || type == repl_right) {
-    t2 = &(*tmp || *rct);
-    delete tmp;
-    delete rct;
-    tmp = t2;
-  }
-
-  t2 = &(*tmp || *rt);
-  delete tmp;
-  delete rt;
-  tmp = t2;
-    
-  if (type == repl_down || type == repl_right) {
-    t2 = &(*tmp || *lct);
-    delete tmp;
-    delete lct;
-    tmp = t2;
-  }
-  if (type == repl_down || type == repl_left) {
-    t2 = &(*tmp || *rct);
-    delete tmp;
-    delete rct;
-    tmp = t2;
-  }
-
-  t2 = &(*tmp || *rbt);
-  delete tmp;
-  delete rbt;
-
-  // Remove the markers from the alphabet
-  TheAlphabet.delete_markers();
-
-  if (optional)
-    t2 = make_optional(t2);
-
-  free_contexts( c );
-
-  return t2;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  add_alphabet                                                   */
-/*                                                                 */
-/*******************************************************************/
-
-void add_alphabet( Transducer *t )
-
-{
-  t->alphabet.copy(TheAlphabet);
-  t->complete_alphabet();
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  write_to_file                                                  */
-/*                                                                 */
-/*******************************************************************/
-
-void write_to_file( Transducer *t, char *filename)
-
-{
-  FILE *file;
-  if ((file = fopen(filename,"wb")) == NULL) {
-    fprintf(stderr,"\nError: Cannot open output file \"%s\"\n\n", filename);
-    exit(1);
-  }
-  free( filename );
-
-  t = explode(t);
-  add_alphabet(t);
-  t = minimise(t);
-  t->store(file);
-  fclose(file);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  result                                                         */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer *result( Transducer *t, bool switch_flag )
-
-{
-  t = explode(t);
-
-  // delete the variable values
-  vector<char*> s;
-  for( VarMap::iterator it=VM.begin(); it != VM.end(); it++ ) {
-    s.push_back(it->first);
-    delete it->second;
-    it->second = NULL;
-  }
-  VM.clear();
-  for( size_t i=0; i<s.size(); i++ )
-    free(s[i]);
-  s.clear();
-
-  if (switch_flag)
-    t = switch_levels(t);
-  add_alphabet(t);
-  t = minimise(t);
-  return t;
-}