Util/Mork.cs

   1 //
   2 // Mork.cs: A parser for mork files (used by software such as Firefox and Thunderbird)
   3 //
   4 // Copyright (C) 2006 Pierre Östlund
   5 //
   6
   7 //
   8 // Permission is hereby granted, free of charge, to any person obtaining a copy
   9 // of this software and associated documentation files (the "Software"), to deal
  10 // in the Software without restriction, including without limitation the rights
  11 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12 // copies of the Software, and to permit persons to whom the Software is
  13 // furnished to do so, subject to the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be included in all
  16 // copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24 // SOFTWARE.
  25 //
  26
  27 using System;
  28 using System.IO;
  29 using System.Text;
  30 using System.Collections;
  31 using System.Text.RegularExpressions;
  32
  33 namespace Beagle.Util
  34 {
  35         public class MorkDatabase : IEnumerable {
  36                 protected string mork_file;
  37                 protected string enum_namespace;
  38                 protected string mork_version;
  39
  40                 protected Hashtable dicts;
  41                 protected Hashtable metadicts;
  42                 protected Hashtable rows;
  43                 protected Hashtable tables;
  44
  45                 protected string regex_row = @"(?<action>[-!+]?)\[(-|)(?<roid>[0-9A-Za-z:\^]+)(?<cells>(?>[^\[\]]+)?)\]";
  46                 protected string regex_cell = @"\^(?<key>[0-9A-Fa-f]+)(\^(?<pvalue>[0-9A-Fa-f]+)|=(?<value>[0-9A-Fa-f]+))";
  47                 protected string regex_table = @"{.*?:(?<ns>[0-9A-Fa-f\^]+) {\(k\^(?<tbl>[0-9A-Fa-f]+):c\)";
  48
  49                 public MorkDatabase (string mork_file)
  50                 {
  51                         this.mork_file = mork_file;
  52                         this.dicts = new Hashtable ();
  53                         this.metadicts = new Hashtable ();
  54                         this.rows = new Hashtable ();
  55                         this.tables = new Hashtable ();
  56                 }
  57
  58                 public void Read ()
  59                 {
  60                         string content;
  61                         StreamReader reader = new StreamReader (mork_file);;
  62
  63                         // Check if this is a mork file and save database version if it is. We assume the first line will tell us this.
  64                         if (!IsValid (reader.ReadLine (), out mork_version)) {
  65                                 reader.Close ();
  66                                 throw new InvalidMorkDatabaseException ("This file is missing a valid mork header");
  67                         }
  68
  69                         content  = reader.ReadToEnd ();
  70                         reader.Close ();
  71
  72                         Reset ();
  73                         Read (content);
  74                 }
  75
  76                 protected bool IsValid (string header, out string version)
  77                 {
  78                         version = null;
  79                         Regex reg = new Regex (@"<!-- <mdb:mork:z v=\""(?<version>(.*))\""/> -->");
  80
  81                         if (header == null || header == string.Empty)
  82                                 return false;
  83
  84                         Match m = reg.Match (header);
  85                         if (!m.Success)
  86                                 return false;
  87
  88                         version = m.Result ("${version}");
  89                         return true;
  90                 }
  91
  92                 protected void Read (string content)
  93                 {
  94                         int position = -1;
  95
  96                         while (++position != content.Length) {
  97
  98                                 if (content [position].Equals ('/') && content [position].Equals ('/'))
  99                                         // Ignore comments
 100                                         position = content.IndexOf ('\n', position);
 101                                 else if (content [position].Equals ('<') && content [position+2].Equals ('<'))
 102                                         // Parse metadict information
 103                                         ParseMetaDict (Read (content, ref position, "<(", ")>"));
 104                                 else if (content [position].Equals ('<'))
 105                                         // Parse dict information
 106                                         ParseDict (Read (content, ref position, "<(", ")>"));
 107                                 else if (content [position].Equals ('{')) {
 108                                         // Parse table information
 109                                         ParseTable (Read (content, ref position, "{", "}"));
 110                                  }else if (content [position].Equals ('['))
 111                                         // Parse rows
 112                                         ParseRows (Read (content, ref position, "[", "]"), null, null);
 113                                 else if (content [position].Equals ('@') && content [position+1].Equals ('$'))
 114                                         // Parse groups
 115                                         ParseGroups (Read (content, ref position, "@$${", "@$$}"));
 116                         }
 117                 }
 118
 119                 protected string Read (string content, ref int position, string start, string end)
 120                 {
 121                         int tmp = position, start_position = position;
 122
 123                         do {
 124                                 position = content.IndexOf (end, position+1);
 125                                 if ((tmp = content.IndexOf (start, tmp+1)) < 0)
 126                                         break;
 127                         } while (tmp < position);
 128
 129                         return content.Substring (start_position, position-start_position+1);
 130                 }
 131
 132                 protected virtual void ParseDict (string dict)
 133                 {
 134                         Regex reg = new Regex (@"(?<id>[0-9A-Fa-f]+)\s*=(?<value>(.*))", RegexOptions.Compiled);
 135
 136                         // This is sooo lame that, but it's an easy solution that works. It seems like regex fails
 137                         // here when dealing with big amounts of data.
 138                         foreach (string t in Regex.Replace (dict.Substring (2, dict.Length-3).Replace ("\\\n", "").
 139                                 Replace ("\n", ""), @"\)\s*\(", "\n").Split ('\n')) {
 140
 141                                 Match m = reg.Match (t);
 142                                 if (m.Success)
 143                                         dicts [m.Result ("${id}")] = m.Result ("${value}");
 144                         }
 145                 }
 146
 147                 protected virtual void ParseMetaDict (string metadict)
 148                 {
 149                         Regex reg = new Regex (@"(?<id>[0-9A-Fa-f]+)=(?<value>[^()]+)", RegexOptions.Compiled);
 150
 151                         foreach (Match m in reg.Matches (metadict))
 152                                 metadicts [m.Result ("${id}")] = m.Result ("${value}");
 153                 }
 154
 155                 protected virtual void ParseTable (string table)
 156                 {
 157                         int start = table.IndexOf ('}')+1;
 158                         Match m = new Regex (regex_table, RegexOptions.Compiled).Match (table);
 159
 160                         ParseRows (table.Substring (start, table.Length-start-1), m.Result ("${ns}"), m.Result ("${tbl}"));
 161                 }
 162
 163                 protected virtual void ParseRows (string rows, string ns, string table)
 164                 {
 165                         Regex reg = new Regex (regex_row, RegexOptions.Compiled);
 166
 167                         foreach (Match m in reg.Matches (Clean (rows))) {
 168                                 // tmp [0] == id, tmp [1] == ns
 169                                 string[] tmp = m.Result ("${roid}").Split (':');
 170
 171                                 if (m.Result ("${action}") == "-" || m.Result ("${cells}") == string.Empty)
 172                                         RemoveRow (tmp [0], (tmp.Length > 1 ? tmp [1] : ns));
 173                                 else
 174                                         AddRow (tmp [0], (tmp.Length > 1 ? tmp [1] : ns), table, m.Result ("${cells}"));
 175                         }
 176                 }
 177
 178                 protected virtual void ParseGroups (string groups)
 179                 {
 180                         int start = groups.IndexOf ("{@")+2;
 181
 182                         Read (groups.Substring (start, groups.Length-start-1));
 183                 }
 184
 185                 protected string Clean (string str)
 186                 {
 187                         return str.Replace ("\n", "").Replace (" ", "");
 188                 }
 189
 190                 public string ParseNamespace (string ns)
 191                 {
 192                         if (ns == null || ns == string.Empty)
 193                                 return string.Empty;
 194                         if (ns.StartsWith ("^"))
 195                                 return ns;
 196                         else {
 197                                 foreach (string key in metadicts.Keys)
 198                                         if ((metadicts [key] as string) == ns)
 199                                                 return String.Format ("^{0}", key);
 200                         }
 201
 202                         return ns;
 203                 }
 204
 205                 public void AddRow (string id, string ns, string table, string cells)
 206                 {
 207                         string ns2 = ParseNamespace (ns);
 208
 209                         if (id == string.Empty || ns2 == string.Empty || table == string.Empty || cells == string.Empty)
 210                                 return;
 211                         else if (!rows.ContainsKey (ns2))
 212                                 rows [ns2] = new Hashtable ();
 213
 214                         (rows [ns2] as Hashtable) [id] = (Exists (id, ns2) ? String.Concat (cells, GetCells (id, ns2)) : cells);
 215
 216                         if (!tables.ContainsKey (id))
 217                                 tables [id] = table;
 218                 }
 219
 220                 public void RemoveRow (string id, string ns)
 221                 {
 222                         string ns2 = ParseNamespace (ns);
 223
 224                         if (!rows.ContainsKey (ns2))
 225                                 return;
 226
 227                         (rows [ns2] as Hashtable).Remove (id);
 228                         tables.Remove (id);
 229                 }
 230
 231                 public string GetCells (string id, string ns)
 232                 {
 233                         string ns2 = ParseNamespace (ns);
 234
 235                         return (ns2 != null ?(rows [ns2] as Hashtable) [id] as string : null);
 236                 }
 237
 238                 public Hashtable Compile (string id, string ns)
 239                 {
 240                         string ns2 = ParseNamespace (ns);
 241
 242                         if (!Exists (id, ns2))
 243                                 return null;
 244
 245                         Hashtable tbl = new Hashtable ();
 246                         Regex reg = new Regex (regex_cell, RegexOptions.Compiled);
 247
 248                         foreach (Match m in reg.Matches (GetCells (id, ns2))) {
 249                                 string value = (string) (m.Result ("${pvalue}") != string.Empty ?
 250                                                         dicts [m.Result("${pvalue}")] : m.Result ("${value}"));
 251
 252                                 tbl [metadicts [m.Result ("${key}")]] = Decode (value, Encoding);
 253                         }
 254
 255                         tbl ["id"] = id;
 256                         tbl ["table"] = tables [id];
 257
 258                         return tbl;
 259                 }
 260
 261                 public bool Exists (string id, string ns)
 262                 {
 263                         string ns2 = ParseNamespace (ns);
 264
 265                         return (ns2 != null ? (rows [ns] as Hashtable).ContainsKey (id) : false);
 266                 }
 267
 268                 public int GetRowCount (string ns)
 269                 {
 270                         string ns2 = ParseNamespace (ns);
 271
 272                         if (ns2 == null || rows [ns2] == null)
 273                                 return -1;
 274
 275                         return (rows [ns2] as Hashtable).Count;
 276                 }
 277
 278                 public int GetRowCount (string ns, string table)
 279                 {
 280                         int count = 0;
 281                         string ns2 = ParseNamespace (ns);
 282
 283                         if (ns2 == null || rows [ns2] == null)
 284                                 return -1;
 285
 286                         foreach (string id in (rows [ns2] as Hashtable).Keys) {
 287                                 if ((string) tables [id] == table)
 288                                         count++;
 289                         }
 290
 291                         return count;
 292                 }
 293
 294                 public IEnumerator GetEnumerator ()
 295                 {
 296                         string ns = ParseNamespace (EnumNamespace);
 297
 298                         if (ns == null || (rows [ns] as Hashtable) == null || Empty)
 299                                 return null;
 300
 301                         return (rows [ns] as Hashtable).Keys.GetEnumerator ();
 302                 }
 303
 304                 public void Reset ()
 305                 {
 306                         dicts.Clear ();
 307                         metadicts.Clear ();
 308                         rows.Clear ();
 309                         tables.Clear ();
 310                         mork_version = string.Empty;
 311                 }
 312
 313                 public static string Convert (int char1, int char2, System.Text.Encoding to_encoding)
 314                 {
 315                         byte[] bytes;
 316                         System.Text.Encoding from;
 317
 318                         if (char2 == -1) {
 319                                 from = System.Text.Encoding.UTF7;
 320                                 bytes = new byte[] { System.Convert.ToByte (char1) };
 321                         } else {
 322                                 from = System.Text.Encoding.UTF8;
 323                                 bytes = new byte[] { System.Convert.ToByte (char1), System.Convert.ToByte (char2) };
 324                         }
 325
 326                         return to_encoding.GetString (System.Text.Encoding.Convert (from, to_encoding, bytes));
 327                 }
 328
 329                 public static string Decode (string str, System.Text.Encoding to_encoding)
 330                 {
 331                         if (str == null || str == string.Empty || to_encoding == null || str.IndexOf ('$') == -1)
 332                                 return str;
 333
 334                         foreach (Match m in Regex.Matches (str, @"\$(?<1>[0-9A-F]{2})\$(?<2>[0-9A-F]{2})|\$(?<3>[0-9A-F]{2})")) {
 335                                 string char1 = m.Result ("${1}"), char2 = m.Result ("${2}"), char3 = m.Result ("${3}");
 336
 337                                 if (char1 != string.Empty) {
 338                                         str = str.Replace (String.Format (@"${0}${1}", char1, char2),
 339                                                 Convert (Thunderbird.Hex2Dec (char1), Thunderbird.Hex2Dec (char2), to_encoding));
 340                                 } else {
 341                                         str = str.Replace (String.Format (@"${0}", char3),
 342                                                 Convert (Thunderbird.Hex2Dec (char3), -1, to_encoding));
 343                                 }
 344                         }
 345
 346                         return str;
 347                 }
 348
 349                 public int Rows {
 350                         get {
 351                                 int count = 0;
 352
 353                                 foreach (Hashtable r in rows.Values)
 354                                         count += r.Count;
 355
 356                                 return count;
 357                         }
 358                 }
 359
 360                 public string EnumNamespace {
 361                         get { return enum_namespace; }
 362                         set { enum_namespace = value; }
 363                 }
 364
 365                 public string Filename {
 366                         get { return mork_file; }
 367                 }
 368
 369                 public string Version {
 370                         get { return mork_version; }
 371                 }
 372
 373                 // There will always exist an item with id 1 in namespace 80, which means
 374                 // that when there are less than two items in the database, it's empty
 375                 public bool Empty {
 376                         get { return (rows.Count > 1 ? false : true); }
 377                 }
 378
 379                 public System.Text.Encoding Encoding {
 380                         get {
 381                                 System.Text.Encoding encoding;
 382
 383                                 try {
 384                                         encoding = System.Text.Encoding.GetEncoding ((string) metadicts ["f"]);
 385                                 } catch {
 386                                         encoding = System.Text.Encoding.GetEncoding ("iso-8859-1");
 387                                 }
 388
 389                                 return encoding;
 390                         }
 391                 }
 392         }
 393
 394         public class InvalidMorkDatabaseException : System.Exception {
 395
 396                 public InvalidMorkDatabaseException (string message) : base (message)
 397                 {
 398                 }
 399         }
 400 }