lttoolbox/compiler.h

   1 /*
   2  * Copyright (C) 2005 Universitat d'Alacant / Universidad de Alicante
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  17  * 02111-1307, USA.
  18  */
  19 #ifndef _MYCOMPILER_
  20 #define _MYCOMPILER_
  21
  22 #include <lttoolbox/alphabet.h>
  23 #include <lttoolbox/regexp_compiler.h>
  24 #include <lttoolbox/entry_token.h>
  25 #include <lttoolbox/ltstr.h>
  26 #include <lttoolbox/transducer.h>
  27
  28 #include <map>
  29 #include <string>
  30 #include <set>
  31 #include <libxml/xmlreader.h>
  32
  33 using namespace std;
  34
  35 /**
  36  * A compiler of dictionaries to letter transducers
  37  */
  38 class Compiler
  39 {
  40 private:
  41   /**
  42    * The libxml2's XML reader
  43    */
  44   xmlTextReaderPtr reader;
  45
  46   /**
  47    * The paradigm being compiled
  48    */
  49   wstring current_paradigm;
  50
  51   /**
  52    * The dictionary section being compiled
  53    */
  54   wstring current_section;
  55
  56   /**
  57    * The direction of the compilation, 'lr' (left-to-right) or 'rl'
  58    * (right-to-left)
  59    */
  60   wstring direction;
  61
  62   /**
  63    * List of characters to be considered alphabetic
  64    */
  65   wstring letters;
  66
  67   /**
  68    * Identifier of all the symbols during the compilation
  69    */
  70   Alphabet alphabet;
  71
  72   /**
  73    * List of named transducers-paradigms
  74    */
  75   map<wstring, Transducer, Ltstr> paradigms;
  76
  77   /**
  78    * List of named dictionary sections
  79    */
  80   map<wstring, Transducer, Ltstr> sections;
  81
  82   /**
  83    * List of named prefix copy of a paradigm
  84    */
  85   map<wstring, map<wstring, int, Ltstr>, Ltstr> prefix_paradigms;
  86
  87   /**
  88    * List of named suffix copy of a paradigm
  89    */
  90   map<wstring, map<wstring, int, Ltstr>, Ltstr> suffix_paradigms;
  91
  92   /**
  93    * List of named endings of a suffix copy of a paradgim
  94    */
  95   map<wstring, map<wstring, int, Ltstr>, Ltstr> postsuffix_paradigms;
  96
  97   /**
  98    * Mapping of aliases of characters specified in ACX files
  99    */
 100   map<int, set<int> > acx_map;
 101
 102   /**
 103    * Original char being mapped
 104    */
 105   int acx_current_char;
 106
 107   /*
 108   static string range(char const a, char const b);
 109   string readAlphabet();
 110   */
 111
 112   /**
 113    * Method to parse an XML Node
 114    */
 115   void procNode();
 116
 117   /**
 118    * Method to parse an XML Node in ACX files
 119    */
 120   void procNodeACX();
 121
 122
 123   /**
 124    * Parse the &lt;alphabet&gt; element
 125    */
 126   void procAlphabet();
 127
 128   /**
 129    * Parse the &lt;sdef&lt; element
 130    */
 131   void procSDef();
 132
 133   /**
 134    * Parse the &lt;pardef&gt; element
 135    */
 136   void procParDef();
 137
 138   /**
 139    * Parse the &lt;e&gt; element
 140    */
 141   void procEntry();
 142
 143   /**
 144    * Parse the &lt;re&gt; element
 145    * @return a list of tokens from the dictionary's entry
 146    */
 147   EntryToken procRegexp();
 148
 149   /**
 150    * Parse the &lt;section&gt; element
 151    */
 152   void procSection();
 153
 154   /**
 155    * Gets an attribute value with their name and the current context
 156    * @param name the name of the attribute
 157    * @return the value of the attribute
 158    */
 159   wstring attrib(wstring const &name);
 160
 161   /**
 162    * Construct symbol pairs by align left side of both parts and insert
 163    * them into a transducer
 164    * @param lp left part of the transduction
 165    * @param rp right part of the transduction
 166    * @param state the state from wich insert the new transduction
 167    * @param t the transducer
 168    * @return the last state of the inserted transduction
 169    */
 170   int matchTransduction(list<int> const &lp, list<int> const &rp,
 171                             int state, Transducer &t);
 172   /**
 173    * Parse the &lt;p&lt; element
 174    * @return a list of tokens from the dictionary's entry
 175    */
 176   EntryToken procTransduction();
 177
 178   /**
 179    * Parse the &lt;i&lt; element
 180    * @return a list of tokens from the dictionary's entry
 181    */
 182   EntryToken procIdentity();
 183
 184   /**
 185    * Parse the &lt;par&gt; element
 186    * @return a list of tokens from the dictionary's entry
 187    */
 188   EntryToken procPar();
 189
 190   /**
 191    * Insert a list of tokens into the paradigm / section being processed
 192    * @param elements the list
 193    */
 194   void insertEntryTokens(vector<EntryToken> const &elements);
 195
 196   /**
 197    * Skip all document #text nodes before "elem"
 198    * @param name the name of the node
 199    * @param elem the name of the expected node
 200    */
 201   void skip(wstring &name, wstring const &elem);
 202
 203   /**
 204    * Skip all blank #text nodes before "name"
 205    * @param name the name of the node
 206    */
 207   void skipBlanks(wstring &name);
 208
 209
 210   void readString(list<int> &result, wstring const &name);
 211
 212   /**
 213    * Force an element to be empty, and check for it
 214    * @param name the element
 215    */
 216   void requireEmptyError(wstring const &name);
 217
 218   /**
 219    * Force an attribute to be specified, amd check for it
 220    * @param value the value of the attribute
 221    * @param attrname the name of the attribute
 222    * @param elemname the parent of the attribute
 223    */
 224   void requireAttribute(wstring const &value, wstring const &attrname,
 225                         wstring const &elemname);
 226
 227   /**
 228    * True if all the elements in the current node are blanks
 229    * @return true if all are blanks
 230    */
 231   bool allBlanks();
 232
 233 public:
 234
 235   /*
 236    * Constants to represent the element and the attributes of
 237    * dictionaries
 238    */
 239   static wstring const COMPILER_DICTIONARY_ELEM;
 240   static wstring const COMPILER_ALPHABET_ELEM;
 241   static wstring const COMPILER_SDEFS_ELEM;
 242   static wstring const COMPILER_SDEF_ELEM;
 243   static wstring const COMPILER_N_ATTR;
 244   static wstring const COMPILER_PARDEFS_ELEM;
 245   static wstring const COMPILER_PARDEF_ELEM;
 246   static wstring const COMPILER_PAR_ELEM;
 247   static wstring const COMPILER_ENTRY_ELEM;
 248   static wstring const COMPILER_RESTRICTION_ATTR;
 249   static wstring const COMPILER_RESTRICTION_LR_VAL;
 250   static wstring const COMPILER_RESTRICTION_RL_VAL;
 251   static wstring const COMPILER_PAIR_ELEM;
 252   static wstring const COMPILER_LEFT_ELEM;
 253   static wstring const COMPILER_RIGHT_ELEM;
 254   static wstring const COMPILER_S_ELEM;
 255   static wstring const COMPILER_REGEXP_ELEM;
 256   static wstring const COMPILER_SECTION_ELEM;
 257   static wstring const COMPILER_ID_ATTR;
 258   static wstring const COMPILER_TYPE_ATTR;
 259   static wstring const COMPILER_IDENTITY_ELEM;
 260   static wstring const COMPILER_JOIN_ELEM;
 261   static wstring const COMPILER_BLANK_ELEM;
 262   static wstring const COMPILER_POSTGENERATOR_ELEM;
 263   static wstring const COMPILER_GROUP_ELEM;
 264   static wstring const COMPILER_LEMMA_ATTR;
 265   static wstring const COMPILER_IGNORE_ATTR;
 266   static wstring const COMPILER_IGNORE_YES_VAL;
 267
 268
 269   /**
 270    * Copnstructor
 271    */
 272   Compiler();
 273
 274   /**
 275    * Destructor
 276    */
 277   ~Compiler();
 278
 279   /**
 280    * Compile dictionary to letter transducers
 281    */
 282   void parse(string const &fichero, wstring const &dir);
 283
 284   /**
 285    * Read ACX file
 286    */
 287   void parseACX(string const &fichero, wstring const &dir);
 288
 289
 290   /**
 291    * Write the result of compilation
 292    * @param fd the stream where write the result
 293    */
 294   void write(FILE *fd);
 295 };
 296
 297
 298 #endif