mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/ObjectType.cs

   1 //
   2 // ObjectType.cs
   3 //
   4 // Author:
   5 //   Chris J Breisch (cjbreisch@altavista.net)
   6 //   Francesco Delfino (pluto@tipic.com)
   7 //
   8 // (C) 2002 Chris J Breisch
   9 //     2002 Tipic, Inc (http://www.tipic.com)
  10 //
  11
  12 //
  13 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  14 //
  15 // Permission is hereby granted, free of charge, to any person obtaining
  16 // a copy of this software and associated documentation files (the
  17 // "Software"), to deal in the Software without restriction, including
  18 // without limitation the rights to use, copy, modify, merge, publish,
  19 // distribute, sublicense, and/or sell copies of the Software, and to
  20 // permit persons to whom the Software is furnished to do so, subject to
  21 // the following conditions:
  22 //
  23 // The above copyright notice and this permission notice shall be
  24 // included in all copies or substantial portions of the Software.
  25 //
  26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33 //
  34
  35 //using System;
  36 //
  37 //namespace Microsoft.VisualBasic.CompilerServices {
  38 //      [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
  39 //      sealed public class ObjectType {
  40 //              // Methods
  41 //              [MonoTODO]
  42 //              public static System.Int32 ObjTst (System.Object o1, System.Object o2, System.Boolean TextCompare) { throw new NotImplementedException (); }
  43 //              [MonoTODO]
  44 //              public static System.Object PlusObj (System.Object obj) { throw new NotImplementedException (); }
  45 //              [MonoTODO]
  46 //              public static System.Object NegObj (System.Object obj) { throw new NotImplementedException (); }
  47 //              [MonoTODO]
  48 //              public static System.Object NotObj (System.Object obj) { throw new NotImplementedException (); }
  49 //              [MonoTODO]
  50 //              public static System.Object BitAndObj (System.Object obj1, System.Object obj2) { throw new NotImplementedException (); }
  51 //              [MonoTODO]
  52 //              public static System.Object BitOrObj (System.Object obj1, System.Object obj2) { throw new NotImplementedException (); }
  53 //              [MonoTODO]
  54 //              public static System.Object BitXorObj (System.Object obj1, System.Object obj2) { throw new NotImplementedException (); }
  55 //              [MonoTODO]
  56 //              public static System.Object AddObj (System.Object o1, System.Object o2) { throw new NotImplementedException (); }
  57 //              [MonoTODO]
  58 //              public static System.Object SubObj (System.Object o1, System.Object o2) { throw new NotImplementedException (); }
  59 //              [MonoTODO]
  60 //              public static System.Object MulObj (System.Object o1, System.Object o2) { throw new NotImplementedException (); }
  61 //              [MonoTODO]
  62 //              public static System.Object DivObj (System.Object o1, System.Object o2) { throw new NotImplementedException (); }
  63 //              [MonoTODO]
  64 //              public static System.Object PowObj (System.Object obj1, System.Object obj2) { throw new NotImplementedException (); }
  65 //              [MonoTODO]
  66 //              public static System.Object ModObj (System.Object o1, System.Object o2) { throw new NotImplementedException (); }
  67 //              [MonoTODO]
  68 //              public static System.Object IDivObj (System.Object o1, System.Object o2) { throw new NotImplementedException (); }
  69 //              [MonoTODO]
  70 //              public static System.Object XorObj (System.Object obj1, System.Object obj2) { throw new NotImplementedException (); }
  71 //              [MonoTODO]
  72 //              public static System.Boolean LikeObj (System.Object vLeft, System.Object vRight, Microsoft.VisualBasic.CompareMethod CompareOption) { throw new NotImplementedException (); }
  73 //              [MonoTODO]
  74 //              public static System.Object StrCatObj (System.Object vLeft, System.Object vRight) { throw new NotImplementedException (); }
  75 //              [MonoTODO]
  76 //              public static System.Object GetObjectValuePrimitive (System.Object o) { throw new NotImplementedException (); }
  77 //      };
  78 //}
  79
  80
  81  //
  82 // ObjectType.cs
  83 //
  84 // Author:
  85 //   Chris J Breisch (cjbreisch@altavista.net)
  86 //   Francesco Delfino (pluto@tipic.com)
  87 //
  88 // (C) 2002 Chris J Breisch
  89 //     2002 Tipic, Inc (http://www.tipic.com)
  90 //
  91
  92 /*
  93   * Copyright (c) 2002-2003 Mainsoft Corporation.
  94   *
  95   * Permission is hereby granted, free of charge, to any person obtaining a
  96   * copy of this software and associated documentation files (the "Software"),
  97   * to deal in the Software without restriction, including without limitation
  98   * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  99   * and/or sell copies of the Software, and to permit persons to whom the
 100   * Software is furnished to do so, subject to the following conditions:
 101   *
 102   * The above copyright notice and this permission notice shall be included in
 103   * all copies or substantial portions of the Software.
 104   *
 105   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 106   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 107   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 108   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 109   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 110   * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 111   * DEALINGS IN THE SOFTWARE.
 112   */
 113
 114 using System;
 115 using System.Collections;
 116 using Microsoft.VisualBasic;
 117 namespace Microsoft.VisualBasic.CompilerServices {
 118         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
 119         sealed public class ObjectType {
 120
 121                 private static int[,] ConversionClassTable = new int[13,13];
 122                 private static Type[,] WiderType = new Type[12,12];
 123                 private static int [] VType2FromTypeCode  = new int[19];
 124                 private static Type [] tblTypeFromTypeCode  = new Type[19];//added tbl prefix to differencate field from method
 125                 private static int [] VTypeFromTypeCode  = new int[19];
 126                 private static int [] TypeCodeFromVType  = new int[13];
 127
 128                 //    static {
 129                 //        WiderType[VType.t_bad][VType.t_bad] = VType.t_bad;
 130                 //        WiderType[VType.t_bad][VType.t_bool] = VType.t_bad;
 131                 //        WiderType[VType.t_bad][VType.t_ui1] = VType.t_bad;
 132                 //        WiderType[VType.t_bad][VType.t_i2] = VType.t_bad;
 133                 //        WiderType[VType.t_bad][VType.t_i4] = VType.t_bad;
 134                 //        WiderType[VType.t_bad][VType.t_i8] = VType.t_bad;
 135                 //        WiderType[VType.t_bad][VType.t_dec] = VType.t_bad;
 136                 //        WiderType[VType.t_bad][VType.t_r4] = VType.t_bad;
 137                 //        WiderType[VType.t_bad][VType.t_r8] = VType.t_bad;
 138                 //        WiderType[VType.t_bad][VType.t_char] = VType.t_bad;
 139                 //        WiderType[VType.t_bad][VType.t_str] = VType.t_bad;
 140                 //        WiderType[VType.t_bad][VType.t_date] = VType.t_bad;
 141                 //
 142                 //        WiderType[VType.t_bool][VType.t_bad] = VType.t_bad;
 143                 //        WiderType[VType.t_bool][VType.t_bool] = VType.t_bool;
 144                 //        WiderType[VType.t_bool][VType.t_ui1] = VType.t_bool;
 145                 //        WiderType[VType.t_bool][VType.t_i2] = VType.t_i2;
 146                 //        WiderType[VType.t_bool][VType.t_i4] = VType.t_i4;
 147                 //        WiderType[VType.t_bool][VType.t_i8] = VType.t_i8;
 148                 //        WiderType[VType.t_bool][VType.t_dec] = VType.t_dec;
 149                 //        WiderType[VType.t_bool][VType.t_r4] = VType.t_r4;
 150                 //        WiderType[VType.t_bool][VType.t_r8] = VType.t_r8;
 151                 //        WiderType[VType.t_bool][VType.t_char] = VType.t_bad;
 152                 //        WiderType[VType.t_bool][VType.t_str] = VType.t_r8;
 153                 //        WiderType[VType.t_bool][VType.t_date] = VType.t_bad;
 154                 //
 155                 //        WiderType[VType.t_ui1][VType.t_bad] = VType.t_bad;
 156                 //        WiderType[VType.t_ui1][VType.t_bool] = VType.t_bool;
 157                 //        WiderType[VType.t_ui1][VType.t_ui1] = VType.t_ui1;
 158                 //        WiderType[VType.t_ui1][VType.t_i2] = VType.t_i2;
 159                 //        WiderType[VType.t_ui1][VType.t_i4] = VType.t_i4;
 160                 //        WiderType[VType.t_ui1][VType.t_i8] = VType.t_i8;
 161                 //        WiderType[VType.t_ui1][VType.t_dec] = VType.t_dec;
 162                 //        WiderType[VType.t_ui1][VType.t_r4] = VType.t_r4;
 163                 //        WiderType[VType.t_ui1][VType.t_r8] = VType.t_r8;
 164                 //        WiderType[VType.t_ui1][VType.t_char] = VType.t_bad;
 165                 //        WiderType[VType.t_ui1][VType.t_str] = VType.t_r8;
 166                 //        WiderType[VType.t_ui1][VType.t_date] = VType.t_bad;
 167                 //
 168                 //        WiderType[VType.t_i2][VType.t_bad] = VType.t_bad;
 169                 //        WiderType[VType.t_i2][VType.t_bool] = VType.t_i2;
 170                 //        WiderType[VType.t_i2][VType.t_ui1] = VType.t_i2;
 171                 //        WiderType[VType.t_i2][VType.t_i2] = VType.t_i2;
 172                 //        WiderType[VType.t_i2][VType.t_i4] = VType.t_i4;
 173                 //        WiderType[VType.t_i2][VType.t_i8] = VType.t_i8;
 174                 //        WiderType[VType.t_i2][VType.t_dec] = VType.t_dec;
 175                 //        WiderType[VType.t_i2][VType.t_r4] = VType.t_r4;
 176                 //        WiderType[VType.t_i2][VType.t_r8] = VType.t_r8;
 177                 //        WiderType[VType.t_i2][VType.t_char] = VType.t_bad;
 178                 //        WiderType[VType.t_i2][VType.t_str] = VType.t_r8;
 179                 //        WiderType[VType.t_i2][VType.t_date] = VType.t_bad;
 180                 //
 181                 //        WiderType[VType.t_i4][VType.t_bad] = VType.t_bad;
 182                 //        WiderType[VType.t_i4][VType.t_bool] = VType.t_i4;
 183                 //        WiderType[VType.t_i4][VType.t_ui1] = VType.t_i4;
 184                 //        WiderType[VType.t_i4][VType.t_i2] = VType.t_i4;
 185                 //        WiderType[VType.t_i4][VType.t_i4] = VType.t_i4;
 186                 //        WiderType[VType.t_i4][VType.t_i8] = VType.t_i8;
 187                 //        WiderType[VType.t_i4][VType.t_dec] = VType.t_dec;
 188                 //        WiderType[VType.t_i4][VType.t_r4] = VType.t_r4;
 189                 //        WiderType[VType.t_i4][VType.t_r8] = VType.t_r8;
 190                 //        WiderType[VType.t_i4][VType.t_char] = VType.t_bad;
 191                 //        WiderType[VType.t_i4][VType.t_str] = VType.t_r8;
 192                 //        WiderType[VType.t_i4][VType.t_date] = VType.t_bad;
 193                 //
 194                 //        WiderType[VType.t_i8][VType.t_bad] = VType.t_bad;
 195                 //        WiderType[VType.t_i8][VType.t_bool] = VType.t_i8;
 196                 //        WiderType[VType.t_i8][VType.t_ui1] = VType.t_i8;
 197                 //        WiderType[VType.t_i8][VType.t_i2] = VType.t_i8;
 198                 //        WiderType[VType.t_i8][VType.t_i4] = VType.t_i8;
 199                 //        WiderType[VType.t_i8][VType.t_i8] = VType.t_i8;
 200                 //        WiderType[VType.t_i8][VType.t_dec] = VType.t_dec;
 201                 //        WiderType[VType.t_i8][VType.t_r4] = VType.t_r4;
 202                 //        WiderType[VType.t_i8][VType.t_r8] = VType.t_r8;
 203                 //        WiderType[VType.t_i8][VType.t_char] = VType.t_bad;
 204                 //        WiderType[VType.t_i8][VType.t_str] = VType.t_r8;
 205                 //        WiderType[VType.t_i8][VType.t_date] = VType.t_bad;
 206                 //
 207                 //        WiderType[VType.t_dec][VType.t_bad] = VType.t_bad;
 208                 //        WiderType[VType.t_dec][VType.t_bool] = VType.t_dec;
 209                 //        WiderType[VType.t_dec][VType.t_ui1] = VType.t_dec;
 210                 //        WiderType[VType.t_dec][VType.t_i2] = VType.t_dec;
 211                 //        WiderType[VType.t_dec][VType.t_i4] = VType.t_dec;
 212                 //        WiderType[VType.t_dec][VType.t_i8] = VType.t_dec;
 213                 //        WiderType[VType.t_dec][VType.t_dec] = VType.t_dec;
 214                 //        WiderType[VType.t_dec][VType.t_r4] = VType.t_r4;
 215                 //        WiderType[VType.t_dec][VType.t_r8] = VType.t_r8;
 216                 //        WiderType[VType.t_dec][VType.t_char] = VType.t_bad;
 217                 //        WiderType[VType.t_dec][VType.t_str] = VType.t_r8;
 218                 //        WiderType[VType.t_dec][VType.t_date] = VType.t_bad;
 219                 //
 220                 //        WiderType[VType.t_r4][VType.t_bad] = VType.t_bad;
 221                 //        WiderType[VType.t_r4][VType.t_bool] = VType.t_r4;
 222                 //        WiderType[VType.t_r4][VType.t_ui1] = VType.t_r4;
 223                 //        WiderType[VType.t_r4][VType.t_i2] = VType.t_r4;
 224                 //        WiderType[VType.t_r4][VType.t_i4] = VType.t_r4;
 225                 //        WiderType[VType.t_r4][VType.t_i8] = VType.t_r4;
 226                 //        WiderType[VType.t_r4][VType.t_dec] = VType.t_r4;
 227                 //        WiderType[VType.t_r4][VType.t_r4] = VType.t_r4;
 228                 //        WiderType[VType.t_r4][VType.t_r8] = VType.t_r8;
 229                 //        WiderType[VType.t_r4][VType.t_char] = VType.t_bad;
 230                 //        WiderType[VType.t_r4][VType.t_str] = VType.t_r8;
 231                 //        WiderType[VType.t_r4][VType.t_date] = VType.t_bad;
 232                 //
 233                 //        WiderType[VType.t_r8][VType.t_bad] = VType.t_bad;
 234                 //        WiderType[VType.t_r8][VType.t_bool] = VType.t_r8;
 235                 //        WiderType[VType.t_r8][VType.t_ui1] = VType.t_r8;
 236                 //        WiderType[VType.t_r8][VType.t_i2] = VType.t_r8;
 237                 //        WiderType[VType.t_r8][VType.t_i4] = VType.t_r8;
 238                 //        WiderType[VType.t_r8][VType.t_i8] = VType.t_r8;
 239                 //        WiderType[VType.t_r8][VType.t_dec] = VType.t_r8;
 240                 //        WiderType[VType.t_r8][VType.t_r4] = VType.t_r8;
 241                 //        WiderType[VType.t_r8][VType.t_r8] = VType.t_r8;
 242                 //        WiderType[VType.t_r8][VType.t_char] = VType.t_bad;
 243                 //        WiderType[VType.t_r8][VType.t_str] = VType.t_r8;
 244                 //        WiderType[VType.t_r8][VType.t_date] = VType.t_bad;
 245                 //
 246                 //        WiderType[VType.t_char][VType.t_bad] = VType.t_bad;
 247                 //        WiderType[VType.t_char][VType.t_bool] = VType.t_bad;
 248                 //        WiderType[VType.t_char][VType.t_ui1] = VType.t_bad;
 249                 //        WiderType[VType.t_char][VType.t_i2] = VType.t_bad;
 250                 //        WiderType[VType.t_char][VType.t_i4] = VType.t_bad;
 251                 //        WiderType[VType.t_char][VType.t_i8] = VType.t_bad;
 252                 //        WiderType[VType.t_char][VType.t_dec] = VType.t_bad;
 253                 //        WiderType[VType.t_char][VType.t_r4] = VType.t_bad;
 254                 //        WiderType[VType.t_char][VType.t_r8] = VType.t_bad;
 255                 //        WiderType[VType.t_char][VType.t_char] = VType.t_char;
 256                 //        WiderType[VType.t_char][VType.t_str] = VType.t_str;
 257                 //        WiderType[VType.t_char][VType.t_date] = VType.t_bad;
 258                 //
 259                 //        WiderType[VType.t_str][VType.t_bad] = VType.t_bad;
 260                 //        WiderType[VType.t_str][VType.t_bool] = VType.t_r8;
 261                 //        WiderType[VType.t_str][VType.t_ui1] = VType.t_r8;
 262                 //        WiderType[VType.t_str][VType.t_i2] = VType.t_r8;
 263                 //        WiderType[VType.t_str][VType.t_i4] = VType.t_r8;
 264                 //        WiderType[VType.t_str][VType.t_i8] = VType.t_r8;
 265                 //        WiderType[VType.t_str][VType.t_dec] = VType.t_r8;
 266                 //        WiderType[VType.t_str][VType.t_r4] = VType.t_r8;
 267                 //        WiderType[VType.t_str][VType.t_r8] = VType.t_r8;
 268                 //        WiderType[VType.t_str][VType.t_char] = VType.t_str;
 269                 //        WiderType[VType.t_str][VType.t_str] = VType.t_str;
 270                 //        WiderType[VType.t_str][VType.t_date] = VType.t_date;
 271                 //
 272                 //        WiderType[VType.t_date][VType.t_bad] = VType.t_bad;
 273                 //        WiderType[VType.t_date][VType.t_bool] = VType.t_bad;
 274                 //        WiderType[VType.t_date][VType.t_ui1] = VType.t_bad;
 275                 //        WiderType[VType.t_date][VType.t_i2] = VType.t_bad;
 276                 //        WiderType[VType.t_date][VType.t_i4] = VType.t_bad;
 277                 //        WiderType[VType.t_date][VType.t_i8] = VType.t_bad;
 278                 //        WiderType[VType.t_date][VType.t_dec] = VType.t_bad;
 279                 //        WiderType[VType.t_date][VType.t_r4] = VType.t_bad;
 280                 //        WiderType[VType.t_date][VType.t_r8] = VType.t_bad;
 281                 //        WiderType[VType.t_date][VType.t_char] = VType.t_bad;
 282                 //        WiderType[VType.t_date][VType.t_str] = VType.t_date;
 283                 //        WiderType[VType.t_date][VType.t_date] = VType.t_date;
 284                 //
 285                 //        ConversionClassTable[VType2.t_bad][VType2.t_bad] = VType2.t_bad;
 286                 //        ConversionClassTable[VType2.t_bad][VType2.t_bool] = VType2.t_bad;
 287                 //        ConversionClassTable[VType2.t_bad][VType2.t_ui1] = VType2.t_bad;
 288                 //        ConversionClassTable[VType2.t_bad][VType2.t_char] = VType2.t_bad;
 289                 //        ConversionClassTable[VType2.t_bad][VType2.t_i2] = VType2.t_bad;
 290                 //        ConversionClassTable[VType2.t_bad][VType2.t_i4] = VType2.t_bad;
 291                 //        ConversionClassTable[VType2.t_bad][VType2.t_i8] = VType2.t_bad;
 292                 //        ConversionClassTable[VType2.t_bad][VType2.t_r4] = VType2.t_bad;
 293                 //        ConversionClassTable[VType2.t_bad][VType2.t_r8] = VType2.t_bad;
 294                 //        ConversionClassTable[VType2.t_bad][VType2.t_date] = VType2.t_bad;
 295                 //        ConversionClassTable[VType2.t_bad][VType2.t_dec] = VType2.t_bad;
 296                 //        ConversionClassTable[VType2.t_bad][VType2.t_ref] = VType2.t_bad;
 297                 //        ConversionClassTable[VType2.t_bad][VType2.t_str] = VType2.t_bad;
 298                 //
 299                 //        ConversionClassTable[VType2.t_bool][VType2.t_bad] = VType2.t_bad;
 300                 //        ConversionClassTable[VType2.t_bool][VType2.t_bool] = VType2.t_bool;
 301                 //        ConversionClassTable[VType2.t_bool][VType2.t_ui1] = VType2.t_ui1;
 302                 //        ConversionClassTable[VType2.t_bool][VType2.t_char] = VType2.t_bad;
 303                 //        ConversionClassTable[VType2.t_bool][VType2.t_i2] = VType2.t_ui1;
 304                 //        ConversionClassTable[VType2.t_bool][VType2.t_i4] = VType2.t_ui1;
 305                 //        ConversionClassTable[VType2.t_bool][VType2.t_i8] = VType2.t_ui1;
 306                 //        ConversionClassTable[VType2.t_bool][VType2.t_r4] = VType2.t_ui1;
 307                 //        ConversionClassTable[VType2.t_bool][VType2.t_r8] = VType2.t_ui1;
 308                 //        ConversionClassTable[VType2.t_bool][VType2.t_bad] = VType2.t_bad;
 309                 //        ConversionClassTable[VType2.t_bool][VType2.t_dec] = VType2.t_ui1;
 310                 //        ConversionClassTable[VType2.t_bool][VType2.t_dec] = VType2.t_bad;
 311                 //        ConversionClassTable[VType2.t_bool][VType2.t_str] = VType2.t_ui1;
 312                 //
 313                 //        ConversionClassTable[VType2.t_ui1][VType2.t_bad] = VType2.t_bad;
 314                 //        ConversionClassTable[VType2.t_ui1][VType2.t_bool] = VType2.t_ui1;
 315                 //        ConversionClassTable[VType2.t_ui1][VType2.t_ui1] = VType2.t_bool;
 316                 //        ConversionClassTable[VType2.t_ui1][VType2.t_char] = VType2.t_bad;
 317                 //        ConversionClassTable[VType2.t_ui1][VType2.t_i2] = VType2.t_ui1;
 318                 //        ConversionClassTable[VType2.t_ui1][VType2.t_i4] = VType2.t_ui1;
 319                 //        ConversionClassTable[VType2.t_ui1][VType2.t_i8] = VType2.t_ui1;
 320                 //        ConversionClassTable[VType2.t_ui1][VType2.t_r4] = VType2.t_ui1;
 321                 //        ConversionClassTable[VType2.t_ui1][VType2.t_r8] = VType2.t_ui1;
 322                 //        ConversionClassTable[VType2.t_ui1][VType2.t_bad] = VType2.t_bad;
 323                 //        ConversionClassTable[VType2.t_ui1][VType2.t_dec] = VType2.t_ui1;
 324                 //        ConversionClassTable[VType2.t_ui1][VType2.t_dec] = VType2.t_bad;
 325                 //        ConversionClassTable[VType2.t_ui1][VType2.t_str] = VType2.t_ui1;
 326                 //
 327                 //        ConversionClassTable[VType2.t_char][VType2.t_bad] = VType2.t_bad;
 328                 //        ConversionClassTable[VType2.t_char][VType2.t_bool] = VType2.t_bad;
 329                 //        ConversionClassTable[VType2.t_char][VType2.t_ui1] = VType2.t_bad;
 330                 //        ConversionClassTable[VType2.t_char][VType2.t_char] = VType2.t_bool;
 331                 //        ConversionClassTable[VType2.t_char][VType2.t_i2] = VType2.t_bad;
 332                 //        ConversionClassTable[VType2.t_char][VType2.t_i4] = VType2.t_bad;
 333                 //        ConversionClassTable[VType2.t_char][VType2.t_i8] = VType2.t_bad;
 334                 //        ConversionClassTable[VType2.t_char][VType2.t_r4] = VType2.t_bad;
 335                 //        ConversionClassTable[VType2.t_char][VType2.t_r8] = VType2.t_bad;
 336                 //        ConversionClassTable[VType2.t_char][VType2.t_bad] = VType2.t_bad;
 337                 //        ConversionClassTable[VType2.t_char][VType2.t_dec] = VType2.t_bad;
 338                 //        ConversionClassTable[VType2.t_char][VType2.t_dec] = VType2.t_bad;
 339                 //        ConversionClassTable[VType2.t_char][VType2.t_str] = VType2.t_ui1;
 340                 //
 341                 //        ConversionClassTable[VType2.t_i2][VType2.t_bad] = VType2.t_bad;
 342                 //        ConversionClassTable[VType2.t_i2][VType2.t_bool] = VType2.t_ui1;
 343                 //        ConversionClassTable[VType2.t_i2][VType2.t_ui1] = VType2.t_char;
 344                 //        ConversionClassTable[VType2.t_i2][VType2.t_char] = VType2.t_bad;
 345                 //        ConversionClassTable[VType2.t_i2][VType2.t_i2] = VType2.t_bool;
 346                 //        ConversionClassTable[VType2.t_i2][VType2.t_i4] = VType2.t_ui1;
 347                 //        ConversionClassTable[VType2.t_i2][VType2.t_i8] = VType2.t_ui1;
 348                 //        ConversionClassTable[VType2.t_i2][VType2.t_r4] = VType2.t_ui1;
 349                 //        ConversionClassTable[VType2.t_i2][VType2.t_r8] = VType2.t_ui1;
 350                 //        ConversionClassTable[VType2.t_i2][VType2.t_bad] = VType2.t_bad;
 351                 //        ConversionClassTable[VType2.t_i2][VType2.t_dec] = VType2.t_ui1;
 352                 //        ConversionClassTable[VType2.t_i2][VType2.t_dec] = VType2.t_bad;
 353                 //        ConversionClassTable[VType2.t_i2][VType2.t_str] = VType2.t_ui1;
 354                 //
 355                 //        ConversionClassTable[VType2.t_i4][VType2.t_bad] = VType2.t_bad;
 356                 //        ConversionClassTable[VType2.t_i4][VType2.t_bool] = VType2.t_ui1;
 357                 //        ConversionClassTable[VType2.t_i4][VType2.t_ui1] = VType2.t_char;
 358                 //        ConversionClassTable[VType2.t_i4][VType2.t_char] = VType2.t_bad;
 359                 //        ConversionClassTable[VType2.t_i4][VType2.t_i2] = VType2.t_char;
 360                 //        ConversionClassTable[VType2.t_i4][VType2.t_i4] = VType2.t_bool;
 361                 //        ConversionClassTable[VType2.t_i4][VType2.t_i8] = VType2.t_ui1;
 362                 //        ConversionClassTable[VType2.t_i4][VType2.t_r4] = VType2.t_ui1;
 363                 //        ConversionClassTable[VType2.t_i4][VType2.t_r8] = VType2.t_ui1;
 364                 //        ConversionClassTable[VType2.t_i4][VType2.t_bad] = VType2.t_bad;
 365                 //        ConversionClassTable[VType2.t_i4][VType2.t_dec] = VType2.t_ui1;
 366                 //        ConversionClassTable[VType2.t_i4][VType2.t_dec] = VType2.t_bad;
 367                 //        ConversionClassTable[VType2.t_i4][VType2.t_str] = VType2.t_ui1;
 368                 //
 369                 //        ConversionClassTable[VType2.t_i8][VType2.t_bad] = VType2.t_bad;
 370                 //        ConversionClassTable[VType2.t_i8][VType2.t_bool] = VType2.t_ui1;
 371                 //        ConversionClassTable[VType2.t_i8][VType2.t_ui1] = VType2.t_char;
 372                 //        ConversionClassTable[VType2.t_i8][VType2.t_char] = VType2.t_bad;
 373                 //        ConversionClassTable[VType2.t_i8][VType2.t_i2] = VType2.t_char;
 374                 //        ConversionClassTable[VType2.t_i8][VType2.t_i4] = VType2.t_char;
 375                 //        ConversionClassTable[VType2.t_i8][VType2.t_i8] = VType2.t_bool;
 376                 //        ConversionClassTable[VType2.t_i8][VType2.t_r4] = VType2.t_ui1;
 377                 //        ConversionClassTable[VType2.t_i8][VType2.t_r8] = VType2.t_ui1;
 378                 //        ConversionClassTable[VType2.t_i8][VType2.t_bad] = VType2.t_bad;
 379                 //        ConversionClassTable[VType2.t_i8][VType2.t_dec] = VType2.t_ui1;
 380                 //        ConversionClassTable[VType2.t_i8][VType2.t_dec] = VType2.t_bad;
 381                 //        ConversionClassTable[VType2.t_i8][VType2.t_str] = VType2.t_ui1;
 382                 //
 383                 //        ConversionClassTable[VType2.t_r4][VType2.t_bad] = VType2.t_bad;
 384                 //        ConversionClassTable[VType2.t_r4][VType2.t_bool] = VType2.t_ui1;
 385                 //        ConversionClassTable[VType2.t_r4][VType2.t_ui1] = VType2.t_char;
 386                 //        ConversionClassTable[VType2.t_r4][VType2.t_char] = VType2.t_bad;
 387                 //        ConversionClassTable[VType2.t_r4][VType2.t_i2] = VType2.t_char;
 388                 //        ConversionClassTable[VType2.t_r4][VType2.t_i4] = VType2.t_char;
 389                 //        ConversionClassTable[VType2.t_r4][VType2.t_i8] = VType2.t_char;
 390                 //        ConversionClassTable[VType2.t_r4][VType2.t_r4] = VType2.t_bool;
 391                 //        ConversionClassTable[VType2.t_r4][VType2.t_r8] = VType2.t_ui1;
 392                 //        ConversionClassTable[VType2.t_r4][VType2.t_bad] = VType2.t_bad;
 393                 //        ConversionClassTable[VType2.t_r4][VType2.t_dec] = VType2.t_char;
 394                 //        ConversionClassTable[VType2.t_r4][VType2.t_dec] = VType2.t_bad;
 395                 //        ConversionClassTable[VType2.t_r4][VType2.t_str] = VType2.t_ui1;
 396                 //
 397                 //        ConversionClassTable[VType2.t_r8][VType2.t_bad] = VType2.t_bad;
 398                 //        ConversionClassTable[VType2.t_r8][VType2.t_bool] = VType2.t_ui1;
 399                 //        ConversionClassTable[VType2.t_r8][VType2.t_ui1] = VType2.t_char;
 400                 //        ConversionClassTable[VType2.t_r8][VType2.t_char] = VType2.t_bad;
 401                 //        ConversionClassTable[VType2.t_r8][VType2.t_i2] = VType2.t_char;
 402                 //        ConversionClassTable[VType2.t_r8][VType2.t_i4] = VType2.t_char;
 403                 //        ConversionClassTable[VType2.t_r8][VType2.t_i8] = VType2.t_char;
 404                 //        ConversionClassTable[VType2.t_r8][VType2.t_r4] = VType2.t_char;
 405                 //        ConversionClassTable[VType2.t_r8][VType2.t_r8] = VType2.t_bool;
 406                 //        ConversionClassTable[VType2.t_r8][VType2.t_bad] = VType2.t_bad;
 407                 //        ConversionClassTable[VType2.t_r8][VType2.t_dec] = VType2.t_char;
 408                 //        ConversionClassTable[VType2.t_r8][VType2.t_dec] = VType2.t_bad;
 409                 //        ConversionClassTable[VType2.t_r8][VType2.t_str] = VType2.t_ui1;
 410                 //
 411                 //        ConversionClassTable[VType2.t_bad][VType2.t_bad] = VType2.t_bad;
 412                 //        ConversionClassTable[VType2.t_bad][VType2.t_bool] = VType2.t_bad;
 413                 //        ConversionClassTable[VType2.t_bad][VType2.t_ui1] = VType2.t_bad;
 414                 //        ConversionClassTable[VType2.t_bad][VType2.t_char] = VType2.t_bad;
 415                 //        ConversionClassTable[VType2.t_bad][VType2.t_i2] = VType2.t_bad;
 416                 //        ConversionClassTable[VType2.t_bad][VType2.t_i4] = VType2.t_bad;
 417                 //        ConversionClassTable[VType2.t_bad][VType2.t_i8] = VType2.t_bad;
 418                 //        ConversionClassTable[VType2.t_bad][VType2.t_r4] = VType2.t_bad;
 419                 //        ConversionClassTable[VType2.t_bad][VType2.t_r8] = VType2.t_bad;
 420                 //        ConversionClassTable[VType2.t_bad][VType2.t_bad] = VType2.t_bool;
 421                 //        ConversionClassTable[VType2.t_bad][VType2.t_dec] = VType2.t_bad;
 422                 //        ConversionClassTable[VType2.t_bad][VType2.t_dec] = VType2.t_bad;
 423                 //        ConversionClassTable[VType2.t_bad][VType2.t_str] = VType2.t_ui1;
 424                 //
 425                 //        ConversionClassTable[VType2.t_dec][VType2.t_bad] = VType2.t_bad;
 426                 //        ConversionClassTable[VType2.t_dec][VType2.t_bool] = VType2.t_ui1;
 427                 //        ConversionClassTable[VType2.t_dec][VType2.t_ui1] = VType2.t_char;
 428                 //        ConversionClassTable[VType2.t_dec][VType2.t_char] = VType2.t_bad;
 429                 //        ConversionClassTable[VType2.t_dec][VType2.t_i2] = VType2.t_char;
 430                 //        ConversionClassTable[VType2.t_dec][VType2.t_i4] = VType2.t_char;
 431                 //        ConversionClassTable[VType2.t_dec][VType2.t_i8] = VType2.t_char;
 432                 //        ConversionClassTable[VType2.t_dec][VType2.t_r4] = VType2.t_ui1;
 433                 //        ConversionClassTable[VType2.t_dec][VType2.t_r8] = VType2.t_ui1;
 434                 //        ConversionClassTable[VType2.t_dec][VType2.t_bad] = VType2.t_bad;
 435                 //        ConversionClassTable[VType2.t_dec][VType2.t_dec] = VType2.t_bool;
 436                 //        ConversionClassTable[VType2.t_dec][VType2.t_dec] = VType2.t_bad;
 437                 //        ConversionClassTable[VType2.t_dec][VType2.t_str] = VType2.t_ui1;
 438                 //
 439                 //        ConversionClassTable[VType2.t_dec][VType2.t_bad] = VType2.t_bad;
 440                 //        ConversionClassTable[VType2.t_dec][VType2.t_bool] = VType2.t_bad;
 441                 //        ConversionClassTable[VType2.t_dec][VType2.t_ui1] = VType2.t_bad;
 442                 //        ConversionClassTable[VType2.t_dec][VType2.t_char] = VType2.t_bad;
 443                 //        ConversionClassTable[VType2.t_dec][VType2.t_i2] = VType2.t_bad;
 444                 //        ConversionClassTable[VType2.t_dec][VType2.t_i4] = VType2.t_bad;
 445                 //        ConversionClassTable[VType2.t_dec][VType2.t_i8] = VType2.t_bad;
 446                 //        ConversionClassTable[VType2.t_dec][VType2.t_r4] = VType2.t_bad;
 447                 //        ConversionClassTable[VType2.t_dec][VType2.t_r8] = VType2.t_bad;
 448                 //        ConversionClassTable[VType2.t_dec][VType2.t_bad] = VType2.t_bad;
 449                 //        ConversionClassTable[VType2.t_dec][VType2.t_dec] = VType2.t_bad;
 450                 //        ConversionClassTable[VType2.t_dec][VType2.t_dec] = VType2.t_bad;
 451                 //        ConversionClassTable[VType2.t_dec][VType2.t_str] = VType2.t_bad;
 452                 //
 453                 //        ConversionClassTable[VType2.t_str][VType2.t_bad] = VType2.t_bad;
 454                 //        ConversionClassTable[VType2.t_str][VType2.t_bool] = VType2.t_ui1;
 455                 //        ConversionClassTable[VType2.t_str][VType2.t_ui1] = VType2.t_ui1;
 456                 //        ConversionClassTable[VType2.t_str][VType2.t_char] = VType2.t_char;
 457                 //        ConversionClassTable[VType2.t_str][VType2.t_i2] = VType2.t_ui1;
 458                 //        ConversionClassTable[VType2.t_str][VType2.t_i4] = VType2.t_ui1;
 459                 //        ConversionClassTable[VType2.t_str][VType2.t_i8] = VType2.t_ui1;
 460                 //        ConversionClassTable[VType2.t_str][VType2.t_r4] = VType2.t_ui1;
 461                 //        ConversionClassTable[VType2.t_str][VType2.t_r8] = VType2.t_ui1;
 462                 //        ConversionClassTable[VType2.t_str][VType2.t_bad] = VType2.t_ui1;
 463                 //        ConversionClassTable[VType2.t_str][VType2.t_dec] = VType2.t_ui1;
 464                 //        ConversionClassTable[VType2.t_str][VType2.t_dec] = VType2.t_bad;
 465                 //        ConversionClassTable[VType2.t_str][VType2.t_str] = VType2.t_bool;
 466                 //
 467                 //        VType2FromTypeCode[TypeCode.Boolean] = VType2.t_bool;
 468                 //        VType2FromTypeCode[TypeCode.Byte] = VType2.t_ui1;
 469                 //        VType2FromTypeCode[TypeCode.Int16] = VType2.t_i2;
 470                 //        VType2FromTypeCode[TypeCode.Int32] = VType2.t_i4;
 471                 //        VType2FromTypeCode[TypeCode.Int64] = VType2.t_i8;
 472                 //        VType2FromTypeCode[TypeCode.Decimal] = VType2.t_dec;
 473                 //        VType2FromTypeCode[TypeCode.Single] = VType2.t_r4;
 474                 //        VType2FromTypeCode[TypeCode.Double] = VType2.t_r8;
 475                 //        VType2FromTypeCode[TypeCode.Char] = VType2.t_char;
 476                 //        VType2FromTypeCode[TypeCode.string] = VType2.t_str;
 477                 //        VType2FromTypeCode[TypeCode.DateTime] = VType2.t_date;
 478                 //
 479                 //        VTypeFromTypeCode[TypeCode.Boolean] = VType.t_bool;
 480                 //        VTypeFromTypeCode[TypeCode.Byte] = VType.t_ui1;
 481                 //        VTypeFromTypeCode[TypeCode.Int16] = VType.t_i2;
 482                 //        VTypeFromTypeCode[TypeCode.Int32] = VType.t_i4;
 483                 //        VTypeFromTypeCode[TypeCode.Int64] = VType.t_i8;
 484                 //        VTypeFromTypeCode[TypeCode.Decimal] = VType.t_dec;
 485                 //        VTypeFromTypeCode[TypeCode.Single] = VType.t_r4;
 486                 //        VTypeFromTypeCode[TypeCode.Double] = VType.t_r8;
 487                 //        VTypeFromTypeCode[TypeCode.Char] = VType.t_char;
 488                 //        VTypeFromTypeCode[TypeCode.string] = VType.t_str;
 489                 //        VTypeFromTypeCode[TypeCode.DateTime] = VType.t_date;
 490                 //
 491                 //        TypeCodeFromVType[VType.t_bool] = TypeCode.Boolean;
 492                 //        TypeCodeFromVType[VType.t_ui1] = TypeCode.Byte;
 493                 //        TypeCodeFromVType[VType.t_i2] = TypeCode.Int16;
 494                 //        TypeCodeFromVType[VType.t_i4] = TypeCode.Int32;
 495                 //        TypeCodeFromVType[VType.t_i8] = TypeCode.Int64;
 496                 //        TypeCodeFromVType[VType.t_dec] = TypeCode.Decimal;
 497                 //        TypeCodeFromVType[VType.t_r4] = TypeCode.Single;
 498                 //        TypeCodeFromVType[VType.t_r8] = TypeCode.Double;
 499                 //        TypeCodeFromVType[VType.t_char] = TypeCode.Char;
 500                 //        TypeCodeFromVType[VType.t_str] = TypeCode.string;
 501                 //        TypeCodeFromVType[VType.t_date] = TypeCode.DateTime;
 502                 //
 503                 //        TypeFromTypeCode[TypeCode.Boolean] = Type.BooleanType;
 504                 //        TypeFromTypeCode[TypeCode.Byte] = Type.ByteType;
 505                 //        TypeFromTypeCode[TypeCode.Int16] = Type.Int16Type;
 506                 //        TypeFromTypeCode[TypeCode.Int32] = Type.Int32Type;
 507                 //        TypeFromTypeCode[TypeCode.Int64] = Type.Int64Type;
 508                 //        TypeFromTypeCode[TypeCode.Decimal] = Type.DecimalType;
 509                 //        TypeFromTypeCode[TypeCode.Single] = Type.SingleType;
 510                 //        TypeFromTypeCode[TypeCode.Double] = Type.DoubleType;
 511                 //        TypeFromTypeCode[TypeCode.Char] = Type.CharType;
 512                 //        TypeFromTypeCode[TypeCode.string] = Type.StringType;
 513                 //        TypeFromTypeCode[TypeCode.DateTime] = Type.DateTimeType;
 514                 //        TypeFromTypeCode[TypeCode.SByte] = Type.SByteType;
 515                 //        TypeFromTypeCode[TypeCode.UInt16] = Type.UInt16Type;
 516                 //        TypeFromTypeCode[TypeCode.UInt32] = Type.UInt32Type;
 517                 //        TypeFromTypeCode[TypeCode.UInt64] = Type.UInt64Type;
 518                 //        TypeFromTypeCode[TypeCode.object] = Type.ObjectType;
 519                 //        TypeFromTypeCode[TypeCode.DBNull] = Type.DBNullType;
 520                 //    }
 521
 522                 private static void checkIfAddValidObjects(
 523                         object obj1,
 524                         object obj2,
 525                         TypeCode tc1,
 526                         TypeCode tc2) {
 527                         if (tc1 == TypeCode.Object    || tc1 == TypeCode.SByte
 528                                 || tc1 == TypeCode.UInt16 || tc1 == TypeCode.UInt32
 529                                 || tc1 == TypeCode.UInt64)
 530                                 throwNoValidOperator(obj1, obj2);
 531                         if (tc2 == TypeCode.Object    || tc2 == TypeCode.SByte
 532                                 || tc2 == TypeCode.UInt16 || tc2 == TypeCode.UInt32
 533                                 || tc2 == TypeCode.UInt64)
 534                                 throwNoValidOperator(obj1, obj2);
 535                 }
 536
 537                 //checked
 538                 public static object AddObj(object obj1, object obj2) {
 539                         TypeCode tc1 = getTypeCode(obj1);
 540                         if (obj1 != null && (obj1 is char[]))
 541                                 obj1 = new string((char[]) obj1);
 542
 543                         TypeCode tc2 = getTypeCode(obj2);
 544                         if (obj2 != null && (obj2 is char[]))
 545                                 obj2 = new string((char[]) obj2);
 546
 547                         checkIfAddValidObjects(obj1,obj2,tc1,tc2);
 548
 549                         if (tc1 == TypeCode.DBNull || tc2 == TypeCode.DBNull)
 550                                 return getAddDBNull(obj1,obj2,tc1,tc2);
 551                         else if (tc1 == TypeCode.DateTime || tc2 == TypeCode.DateTime)
 552                                 return getAddDateTime(obj1,obj2,tc1,tc2);
 553                         else if (tc1 == TypeCode.Char || tc2 == TypeCode.Char)
 554                                 return getAddChar(obj1,obj2,tc1,tc2);
 555
 556                         if (tc1 == TypeCode.Empty)
 557                                 return obj2;
 558                         else if (tc2 == TypeCode.Empty)
 559                                 return obj1;
 560
 561                         if (tc1 == TypeCode.String && tc2 == TypeCode.String)
 562                                 return StringType.FromObject(obj1) + StringType.FromObject(obj2);
 563                         else if (tc1 == TypeCode.String || tc2 == TypeCode.String )
 564                                 return getAddStringObject(obj1,obj2,tc1,tc2);
 565
 566                         if (tc1 == TypeCode.Double || tc2 == TypeCode.Double)
 567                                 return getAddDouble(obj1,obj2,tc1,tc2);
 568                         else if (tc1 == TypeCode.Single || tc2 == TypeCode.Single)
 569                                 return getAddSingle(obj1,obj2,tc1,tc2);
 570                         else if(tc1 == TypeCode.Decimal || tc2 == TypeCode.Decimal)
 571                                 return getAddDecimal(obj1,obj2,tc1,tc2);
 572                         else if (tc1 == TypeCode.Int64 || tc2 == TypeCode.Int64)
 573                                 return getAddInt64(obj1,obj2,tc1,tc2);
 574                         else if (tc1 == TypeCode.Int32 || tc2 == TypeCode.Int32)
 575                                 return getAddInt32(obj1,obj2,tc1,tc2);
 576                         else if (tc1 == TypeCode.Int16 || tc2 == TypeCode.Int16)
 577                                 return getAddInt16(obj1,obj2,tc1,tc2);
 578                         else if (tc1 == TypeCode.Boolean || tc2 == TypeCode.Boolean)
 579                                 return getAddInt16(obj1,obj2,tc1,tc2);
 580                         else if (tc1 == TypeCode.Byte || tc2 == TypeCode.Byte)
 581                                 return getAddByte(obj1,obj2,tc1,tc2);
 582
 583                         throwNoValidOperator(obj1, obj2);
 584                         return null;
 585                 }
 586
 587                 private static object getAddDBNull(object obj1,object obj2,TypeCode tc1,TypeCode tc2) {
 588                         if (tc1 == TypeCode.DBNull) {
 589                                 if (tc2 == TypeCode.String)
 590                                         return obj2;
 591                                 else
 592                                         throwNoValidOperator(obj1, obj2);
 593                         }
 594                         else if (tc1 == TypeCode.String)
 595                                 return obj1;
 596                         else
 597                                 throwNoValidOperator(obj1, obj2);
 598                         return null;
 599                 }
 600
 601                 private static object getAddChar(object obj1,object obj2,TypeCode tc1,TypeCode tc2) {
 602                         if (tc1 == TypeCode.Char) {
 603                                 if (tc2 == TypeCode.Char || tc2 == TypeCode.String)
 604                                         return StringType.FromObject(obj1) + StringType.FromObject(obj2);
 605                                 else
 606                                         throwNoValidOperator(obj1, obj2);
 607                         }
 608                         else if (tc2 == TypeCode.Char) {
 609                                 if (tc1 == TypeCode.Char || tc1 == TypeCode.String)
 610                                         return StringType.FromObject(obj1) + StringType.FromObject(obj2);
 611                                 else
 612                                         throwNoValidOperator(obj1, obj2);
 613                         }
 614                         return null;
 615                 }
 616
 617                 private static object getAddDateTime(object obj1,object obj2,TypeCode tc1,TypeCode tc2) {
 618                         if (tc1 == TypeCode.DateTime) {
 619                                 if (tc2 == TypeCode.DateTime || tc2 == TypeCode.String)
 620                                         return obj1.ToString() + obj2.ToString();
 621                                 else
 622                                         throwNoValidOperator(obj1, obj2);
 623                         }
 624                         else if (tc2 == TypeCode.DateTime) {
 625                                 if (tc1 == TypeCode.DateTime || tc1 == TypeCode.String)
 626                                         return obj1.ToString() + obj2.ToString();
 627                                 else
 628                                         throwNoValidOperator(obj1, obj2);
 629                         }
 630                         return null;
 631                 }
 632
 633                 private static object getAddByte(object obj1,object obj2,TypeCode tc1,TypeCode tc2) {
 634                         byte d1 = convertObjectToByte(obj1,tc1);
 635                         byte d2 = convertObjectToByte(obj2,tc2);
 636                         short s = (short) (d1 + d2);
 637                         if (s >= 0 && s <= 255)
 638                                 return (byte) s;
 639                         return s;
 640                 }
 641
 642                 private static object getAddDouble(object obj1,object obj2,TypeCode tc1,TypeCode tc2) {
 643                         double d1 = convertObjectToDouble(obj1,tc1);
 644                         double d2 = convertObjectToDouble(obj2,tc2);
 645                         return d1+d2;
 646                 }
 647
 648                 private static object getAddDecimal(object obj1,object obj2,TypeCode tc1,TypeCode tc2) {
 649                         Decimal d1 = convertObjectToDecimal(obj1,tc1);
 650                         Decimal d2 = convertObjectToDecimal(obj2,tc2);
 651                         return Decimal.Add(d1,d2);
 652                 }
 653
 654                 private static object getAddInt64(object obj1,object obj2,TypeCode tc1,TypeCode tc2) {
 655                         Decimal d1 = convertObjectToDecimal(obj1,tc1);
 656                         Decimal d2 = convertObjectToDecimal(obj2,tc2);
 657                         Decimal sum = Decimal.Add(d1,d2);
 658                         if (
 659                                 Decimal.Compare(sum, new Decimal(long.MaxValue)) <= 0
 660                                 && Decimal.Compare(sum, new Decimal(long.MinValue))
 661                                 >= 0)
 662                                 return Decimal.ToInt64(sum);
 663
 664                         return sum;
 665                 }
 666
 667                 private static object getAddInt32(object obj1,object obj2,TypeCode tc1,TypeCode tc2) {
 668                         long d1 = convertObjectToLong(obj1,tc1);
 669                         long d2 = convertObjectToLong(obj2,tc2);
 670                         long sum = d1+ d2;
 671                         if (sum >= Int32.MinValue && sum <= Int32.MaxValue)
 672                                 return (Int32)sum;
 673                         return sum;
 674                 }
 675
 676                 private static object getAddInt16(object obj1,object obj2,TypeCode tc1,TypeCode tc2) {
 677                         int d1 = convertObjectToInt(obj1,tc1);
 678                         int d2 = convertObjectToInt(obj2,tc2);
 679                         int sum = d1+ d2;
 680                         if (sum >= short.MinValue && sum <= short.MaxValue)
 681                                 return (short)sum;
 682                         return sum;
 683                 }
 684
 685
 686                 private static object getAddSingle(object obj1,object obj2,TypeCode tc1,TypeCode tc2) {
 687                         float d1 = convertObjectToFloat(obj1,tc1);
 688                         float d2 = convertObjectToFloat(obj2,tc2);
 689
 690                         double sum = (double) d1 + (double) d2;
 691                         if (sum <= 3.40282e+038 &&  sum>= -3.40282e+038)
 692                                 return (Single)sum;
 693                         if (Double.IsInfinity(sum) &&
 694                                 (Single.IsInfinity(d1) || Single.IsInfinity(d2)))
 695                                 return (Single)sum;
 696                         return (Double)sum;
 697                 }
 698
 699                 //checked
 700                 private static int toVBBool(IConvertible conv) {
 701                         if (conv.ToBoolean(null))
 702                                 return -1;
 703                         return 0;
 704                 }
 705
 706
 707                 // checked
 708                 private static object getAddStringObject(object s1, object s2,TypeCode tc1,TypeCode tc2) {
 709                         double d1 = convertObjectToDouble(s1,tc1);
 710                         double d2 = convertObjectToDouble(s1,tc2);
 711                         return d1 + d2;
 712                 }
 713
 714                 //checked !!
 715                 public static object BitAndObj(object obj1, object obj2) {
 716                         Type type1 = obj1.GetType();
 717                         Type type2 = obj2.GetType();
 718                         TypeCode typeCode = GetWidestType(obj1, obj2, false);
 719
 720                         if (obj1 == null && obj2 == null)
 721                                 return (int)0;
 722                         else if (typeCode == TypeCode.Boolean) {
 723                                 if (type1 == type2)
 724                                         return ((bool)obj1) & ((bool)obj2);
 725                                 return ((short)obj1) & ((short)obj2);
 726                         }
 727                         else if (typeCode == TypeCode.Byte) {
 728                                 byte val = (byte)(ByteType.FromObject(obj1)
 729                                         & ByteType.FromObject(obj2));
 730                                 return createByteAccordingToEnumCond(val,type1,type2,obj1,obj2);
 731                         }
 732                         else if (typeCode == TypeCode.Int16) {
 733                                 short val =
 734                                         (short)(ShortType.FromObject(obj1)
 735                                         & ShortType.FromObject(obj2));
 736                                 return createShortAccordingToEnumCond(val,type1,type2,obj1,obj2);
 737                         }
 738                         else if (typeCode == TypeCode.Int32) {
 739                                 Int32 val = IntegerType.FromObject(obj1) & IntegerType.FromObject(obj2);
 740                                 return createIntAccordingToEnumCond(val,type1,type2,obj1,obj2);
 741                         }
 742                         else if (typeCode == TypeCode.Int64) {
 743                                 long val = LongType.FromObject(obj1) & LongType.FromObject(obj2);
 744                                 return createLongAccordingToEnumCond(val, type1, type2, obj1, obj2);
 745                         }
 746                         else if (typeCode == TypeCode.Single  || typeCode == TypeCode.Double
 747                                 || typeCode == TypeCode.Decimal || typeCode == TypeCode.String) {
 748                                 long val = LongType.FromObject(obj1) & LongType.FromObject(obj2);
 749                                 return val;
 750                         }
 751                         else
 752                                 throw new InvalidCastException(
 753                                         Utils.GetResourceString(
 754                                         "NoValidOperator_TwoOperands",
 755                                         Utils.VBFriendlyName(obj1),
 756                                         Utils.VBFriendlyName(obj2)));
 757                 }
 758
 759                 private static object createByteAccordingToEnumCond(
 760                         byte val,
 761                         Type type1,
 762                         Type type2,
 763                         object obj1,
 764                         object obj2) {
 765                         bool isEnum1 = type1.IsEnum;
 766                         bool isEmum2 = type2.IsEnum;
 767                         if (isEnum1 && isEmum2 && type1 != type2)
 768                                 return (byte)val;
 769                         if (isEnum1)
 770                                 return Enum.ToObject(type1, val);
 771                         if (!(isEmum2))
 772                                 throw new InvalidCastException(
 773                                         Utils.GetResourceString(
 774                                         "NoValidOperator_TwoOperands",
 775                                         Utils.VBFriendlyName(obj1),
 776                                         Utils.VBFriendlyName(obj2)));
 777                         return Enum.ToObject(type2, val);
 778                 }
 779
 780                 private static object createShortAccordingToEnumCond(
 781                         short val,
 782                         Type type1,
 783                         Type type2,
 784                         object obj1,
 785                         object obj2) {
 786                         bool isEnum1 = type1.IsEnum;
 787                         bool isEmum2 = type2.IsEnum;
 788                         if (isEnum1 && isEmum2 && type1 != type2)
 789                                 return val;
 790                         if (isEnum1)
 791                                 return Enum.ToObject(type1, val);
 792                         if (!(isEmum2))
 793                                 throw new InvalidCastException(
 794                                         Utils.GetResourceString(
 795                                         "NoValidOperator_TwoOperands",
 796                                         Utils.VBFriendlyName(obj1),
 797                                         Utils.VBFriendlyName(obj2)));
 798                         return Enum.ToObject(type2, val);
 799                 }
 800
 801                 private static object createIntAccordingToEnumCond(
 802                         int val,
 803                         Type type1,
 804                         Type type2,
 805                         object obj1,
 806                         object obj2) {
 807                         bool isEnum1 = type1.IsEnum;
 808                         bool isEmum2 = type2.IsEnum;
 809                         if (isEnum1 && isEmum2 && type1 != type2)
 810                                 return val;
 811                         if (isEnum1)
 812                                 return Enum.ToObject(type1, val);
 813                         if (!(isEmum2))
 814                                 throw new InvalidCastException(
 815                                         Utils.GetResourceString(
 816                                         "NoValidOperator_TwoOperands",
 817                                         Utils.VBFriendlyName(obj1),
 818                                         Utils.VBFriendlyName(obj2)));
 819                         return Enum.ToObject(type2, val);
 820                 }
 821
 822                 private static object createLongAccordingToEnumCond(
 823                         long val,
 824                         Type type1,
 825                         Type type2,
 826                         object obj1,
 827                         object obj2) {
 828                         bool isEnum1 = type1.IsEnum;
 829                         bool isEmum2 = type2.IsEnum;
 830                         if (isEnum1 && isEmum2 && type1 != type2)
 831                                 return val;
 832                         if (isEnum1)
 833                                 return Enum.ToObject(type1, val);
 834                         if (!(isEmum2))
 835                                 throw new InvalidCastException(
 836                                         Utils.GetResourceString(
 837                                         "NoValidOperator_TwoOperands",
 838                                         Utils.VBFriendlyName(obj1),
 839                                         Utils.VBFriendlyName(obj2)));
 840                         return Enum.ToObject(type2, val);
 841                 }
 842
 843                 //checked !!
 844                 public static object BitOrObj(object obj1, object obj2) {
 845                         Type type1 = obj1.GetType();
 846                         Type type2 = obj2.GetType();
 847                         TypeCode typeCode = GetWidestType(obj1, obj2, false);
 848
 849                         if (obj1 == null && obj2 == null)
 850                                 return (int)0;
 851                         else if (typeCode == TypeCode.Boolean) {
 852                                 if (type1 == type2)
 853                                         return BooleanType.FromObject(obj1)| BooleanType.FromObject(obj2);
 854                                 return (short)( (ushort)ShortType.FromObject(obj1) | (ushort)ShortType.FromObject(obj2));
 855                         }
 856                         else if (typeCode == TypeCode.Byte) {
 857                                 byte val = (byte)(ByteType.FromObject(obj1)
 858                                         | ByteType.FromObject(obj2));
 859                                 return createByteAccordingToEnumCond(val,type1,type2,obj1,obj2);
 860                         }
 861                         else if (typeCode == TypeCode.Int16) {
 862                                 short val = (short) ((ushort) ShortType.FromObject(obj1)
 863                                         | (ushort)ShortType.FromObject(obj2));
 864                                 return createShortAccordingToEnumCond(val,type1,type2,obj1,obj2);
 865                         }
 866                         else if (typeCode == TypeCode.Int32) {
 867                                 Int32 val = IntegerType.FromObject(obj1) | IntegerType.FromObject(obj2);
 868                                 return createIntAccordingToEnumCond(val,type1,type2,obj1,obj2);
 869                         }
 870                         else if (typeCode == TypeCode.Int64) {
 871                                 long val = LongType.FromObject(obj1) | LongType.FromObject(obj2);
 872                                 return createLongAccordingToEnumCond(val, type1, type2, obj1, obj2);
 873                         }
 874                         else if (typeCode == TypeCode.Single  || typeCode == TypeCode.Double
 875                                 || typeCode == TypeCode.Decimal || typeCode == TypeCode.String) {
 876                                 long val = LongType.FromObject(obj1) | LongType.FromObject(obj2);
 877                                 return val;
 878                         }
 879                         else
 880                                 throw new InvalidCastException(
 881                                         Utils.GetResourceString(
 882                                         "NoValidOperator_TwoOperands",
 883                                         Utils.VBFriendlyName(obj1),
 884                                         Utils.VBFriendlyName(obj2)));
 885                 }
 886
 887                 //checked !!
 888                 public static object BitXorObj(object obj1, object obj2) {
 889                         Type type1 = obj1.GetType();
 890                         Type type2 = obj2.GetType();
 891                         TypeCode typeCode = GetWidestType(obj1, obj2, false);
 892
 893                         if (obj1 == null && obj2 == null)
 894                                 return (int)0;
 895                         else if (typeCode == TypeCode.Boolean) {
 896                                 if (type1 == type2)
 897                                         return BooleanType.FromObject(obj1)^ BooleanType.FromObject(obj2);
 898                                 return (short) (ShortType.FromObject(obj1) ^ ShortType.FromObject(obj2));
 899                         }
 900                         else if (typeCode == TypeCode.Byte) {
 901                                 byte val = (Byte) (ByteType.FromObject(obj1)
 902                                         ^ ByteType.FromObject(obj2));
 903                                 return createByteAccordingToEnumCond(val,type1,type2,obj1,obj2);
 904                         }
 905                         else if (typeCode == TypeCode.Int16) {
 906                                 short val =
 907                                         (short) (ShortType.FromObject(obj1)
 908                                         ^ ShortType.FromObject(obj2));
 909                                 return createShortAccordingToEnumCond(val,type1,type2,obj1,obj2);
 910                         }
 911                         else if (typeCode == TypeCode.Int32) {
 912                                 Int32 val = IntegerType.FromObject(obj1) ^ IntegerType.FromObject(obj2);
 913                                 return createIntAccordingToEnumCond(val,type1,type2,obj1,obj2);
 914                         }
 915                         else if (typeCode == TypeCode.Int64) {
 916                                 long val = LongType.FromObject(obj1) ^ LongType.FromObject(obj2);
 917                                 return createLongAccordingToEnumCond(val, type1, type2, obj1, obj2);
 918                         }
 919                         else if (typeCode == TypeCode.Single  || typeCode == TypeCode.Double
 920                                 || typeCode == TypeCode.Decimal || typeCode == TypeCode.String) {
 921                                 long val = LongType.FromObject(obj1) ^ LongType.FromObject(obj2);
 922                                 return (Int64)val;
 923                         }
 924                         else
 925                                 throw new InvalidCastException(
 926                                         Utils.GetResourceString(
 927                                         "NoValidOperator_TwoOperands",
 928                                         Utils.VBFriendlyName(obj1),
 929                                         Utils.VBFriendlyName(obj2)));
 930                 }
 931
 932                 internal static object CTypeHelper(object obj, TypeCode toType) {
 933                         if (obj == null)
 934                                 return null;
 935                         switch (toType) {
 936                                 case TypeCode.Boolean :
 937                                         return BooleanType.FromObject(obj);
 938                                 case TypeCode.Byte :
 939                                         return ByteType.FromObject(obj);
 940                                 case TypeCode.Int16 :
 941                                         return ShortType.FromObject(obj);
 942                                 case TypeCode.Int32 :
 943                                         return IntegerType.FromObject(obj);
 944                                 case TypeCode.Int64 :
 945                                         return LongType.FromObject(obj);
 946                                 case TypeCode.Decimal :
 947                                         return DecimalType.FromObject(obj);
 948                                 case TypeCode.Single :
 949                                         return SingleType.FromObject(obj);
 950                                 case TypeCode.Double :
 951                                         return DoubleType.FromObject(obj);
 952                                 case TypeCode.String :
 953                                         return StringType.FromObject(obj);
 954                                 case TypeCode.Char :
 955                                         return CharType.FromObject(obj);
 956                                 case TypeCode.DateTime :
 957                                         return DateType.FromObject(obj);
 958
 959                         }
 960
 961                         throw new InvalidCastException(// ClassCastException(
 962                                 Utils.GetResourceString(
 963                                 "InvalidCast_FromTo",
 964                                 Utils.VBFriendlyName(obj),
 965                                 Utils.VBFriendlyName(ObjectType.TypeFromTypeCode(toType))));
 966
 967                 }
 968
 969                 //checked + string
 970                 internal static object CTypeHelper(object obj, Type toType) {
 971                         if (obj == null)
 972                                 return null;
 973
 974                         //TODO: how to tell if is truly type of object\r
 975                         //if (toType == Type.ObjectType)\r
 976                         //      return obj;
 977
 978                         Type type = obj.GetType();
 979                         if (toType.IsByRef) {
 980                                 toType = toType.GetElementType();
 981                         }
 982                         //    if (type.IsByRef)
 983                         //        local1 = local1.GetElementType();
 984                         if (type == toType)
 985                                 return obj;
 986
 987                         TypeCode tc = Type.GetTypeCode(toType);
 988                         if (tc == TypeCode.Object) {
 989                                 if (toType.IsAssignableFrom(type))
 990                                         return obj;
 991                                 if (obj is string
 992                                     && toType == typeof (char[])) {
 993                                         return CharArrayType.FromString((string) obj);
 994                                 }
 995
 996                                 throw new InvalidCastException(
 997                                         Utils.GetResourceString(
 998                                         "InvalidCast_FromTo",
 999                                         Utils.VBFriendlyName(type),
1000                                         Utils.VBFriendlyName(toType)));
1001                         }
1002
1003                         object retVal = CTypeHelper(obj, tc);
1004                         if (toType.IsEnum)
1005                                 return Enum.ToObject(toType,retVal);
1006                         return retVal;
1007                 }
1008
1009                 //checked + string//make typecode
1010                 internal static TypeCode GetWidestType(TypeCode type1, TypeCode type2) {
1011                         if (type1 == type2)
1012                                 return type1;
1013
1014                         if (type1 == TypeCode.Char || type2 == TypeCode.Char) {
1015                                 if (type1 == TypeCode.Char && type2 == TypeCode.String)
1016                                         return TypeCode.String;
1017                                 if (type2 == TypeCode.Char && type1 == TypeCode.String)
1018                                         return TypeCode.String;
1019                                 return TypeCode.Empty;
1020                         }
1021                         if (type1 == TypeCode.DateTime || type2 == TypeCode.DateTime) {
1022                                 if (type1 == TypeCode.String && type2 == TypeCode.DateTime)
1023                                         return TypeCode.DateTime;
1024                                 if (type2 == TypeCode.String && type1 == TypeCode.DateTime)
1025                                         return TypeCode.DateTime;
1026                                 return TypeCode.Empty;
1027                         }
1028
1029                         switch (type1) {
1030                         case TypeCode.Boolean :
1031                                 switch (type2) {
1032                                 case TypeCode.Byte :
1033                                         return type1;
1034                                 case TypeCode.String:
1035                                         return TypeCode.Double;
1036                                 }
1037                                 return type2;
1038                         case TypeCode.Byte :
1039                                 switch (type2) {
1040                                 case TypeCode.String:
1041                                         return TypeCode.Double;
1042                                 }
1043                                 return type2;
1044                         case TypeCode.Int16 :
1045                                 switch (type2) {
1046                                 case TypeCode.Boolean:
1047                                 case TypeCode.Byte:
1048                                         return type1;
1049                                 case TypeCode.String:
1050                                         return TypeCode.Double;
1051                                 }
1052                                 return type2;
1053                         case TypeCode.Int32 :
1054                                 switch (type2) {
1055                                 case TypeCode.Boolean:
1056                                 case TypeCode.Byte:
1057                                 case TypeCode.Int16:
1058                                         return type1;
1059                                 case TypeCode.String:
1060                                         return TypeCode.Double;
1061                                 }
1062                                 return type2;
1063                         case TypeCode.Int64 :
1064                                 switch (type2) {
1065                                 case TypeCode.Single:
1066                                 case TypeCode.Double:
1067                                 case TypeCode.Decimal:
1068                                         return type1;
1069                                 case TypeCode.String:
1070                                         return TypeCode.Double;
1071                                 }
1072                                 return type1;
1073                         case TypeCode.Decimal :
1074                                 switch (type2) {
1075                                 case TypeCode.Single:
1076                                 case TypeCode.Double:
1077                                         return type2;
1078                                 case TypeCode.String:
1079                                         return TypeCode.Double;
1080                                 }
1081                                 return type1;
1082                         case TypeCode.Single :
1083                                 switch (type2) {
1084                                 case TypeCode.Double:
1085                                         return type2;
1086                                 case TypeCode.String:
1087                                         return TypeCode.Double;
1088                                 }
1089                                 return type1;
1090                         case TypeCode.Double :
1091                                 switch (type2) {
1092                                 case TypeCode.String:
1093                                         return type1;
1094                                 }
1095                                 return type1;
1096                         case TypeCode.String :
1097                                 return TypeCode.Double;
1098                         }
1099                         return TypeCode.Object;
1100                 }
1101
1102                 internal static TypeCode GetWidestType(object obj1, TypeCode typeCode2) {
1103                         if (obj1 == null)
1104                                 return typeCode2;
1105                         TypeCode tc1 = getTypeCode(obj1);
1106                         return GetWidestType(tc1,typeCode2);
1107                 }
1108
1109                 private static TypeCode getTypeCode(object obj) {
1110                         IConvertible iConvertible = null;
1111                         TypeCode typeCode;
1112                         if (obj is IConvertible) {
1113                                 iConvertible = (IConvertible)obj;
1114                         }
1115                         if (iConvertible != null) {
1116                                 typeCode = iConvertible.GetTypeCode();
1117                         }
1118                         else if (obj == null) {
1119                                 typeCode = TypeCode.Empty;
1120                         }
1121                         else if (obj is string) {
1122                                 typeCode = TypeCode.String;
1123                         }
1124                         else if (obj is char[]) {
1125                                 typeCode = TypeCode.String;
1126                         }
1127                         else {
1128                                 typeCode = TypeCode.Object;
1129                         }
1130                         return typeCode;
1131                 }
1132
1133                 internal static TypeCode GetWidestType(object obj1, object obj2, bool IsAdd) {
1134                         TypeCode typeCode1 = getTypeCode(obj1);
1135                         TypeCode typeCode2 = getTypeCode(obj1);
1136
1137                         if (obj1 == null)
1138                                 return typeCode2;
1139                         if (obj2 == null)
1140                                 return typeCode1;
1141                         if ( IsAdd &&
1142                                 ((typeCode1 == TypeCode.DBNull && typeCode2 == TypeCode.String) ||
1143                                 (typeCode1 == TypeCode.String && typeCode2 == TypeCode.DBNull)))
1144                                 return TypeCode.DBNull;
1145                         else
1146                                 return GetWidestType(typeCode1,typeCode2);
1147                 }
1148
1149                 //checked !!
1150                 [MonoTODO]
1151                 private static TypeCode getTypeCodeFromVType(int vartype) {
1152                         throw new NotImplementedException("get typecode from vtype needs help");
1153                         //TODO:
1154                         //return TypeCodeFromVType[vartype];
1155                 }
1156
1157                 //checked !!
1158                 private static int getVTypeFromTypeCode(TypeCode type) {
1159                         throw new NotImplementedException("get typecode from vtype needs help");
1160                         //TODO:
1161                         //return VTypeFromTypeCode[type];
1162                 }
1163
1164                 //checked !!
1165                 public static object GetObjectValuePrimitive(object o) {
1166                         if (o == null || !(o is IConvertible))
1167                                 return o;
1168                         IConvertible iConv = (IConvertible)o;
1169                         TypeCode tc = getTypeCode(o);
1170                         switch (tc) {
1171                                         //this four type code are converted in this way since they can also
1172                                         //be enum.
1173                                 case TypeCode.Byte :
1174                                         return iConv.ToByte(null);
1175                                 case TypeCode.Int16 :
1176                                         return iConv.ToInt16(null);
1177                                 case TypeCode.Int32 :
1178                                         return iConv.ToInt32(null);
1179                                 case TypeCode.Int64 :
1180                                         return iConv.ToInt64(null);
1181                                 default :
1182                                         return o;
1183                         }
1184                 }
1185
1186                 //checked !!
1187                 private static object getDivDecimal(object obj1, object obj2,TypeCode tc1,TypeCode tc2) {
1188                         Decimal dec1 = convertObjectToDecimal(obj1,tc1);
1189                         Decimal dec2 = convertObjectToDecimal(obj2,tc2);
1190                         try {
1191                                 return Decimal.Divide(dec1, dec2);
1192                         }
1193                         catch(OverflowException e) {
1194                                 e.ToString();//TODO: Dumb way to fix compiler warning about unused e
1195                                 float val1 = Convert.ToSingle(dec1);
1196                                 float val2 = Convert.ToSingle(dec2);
1197                                 float val3 = val1/val2;
1198                                 return val3;
1199                         }
1200
1201                 }
1202
1203                 //checked !!
1204                 private static object getDivDouble(object s1, object s2, TypeCode tc1 ,TypeCode tc2) {
1205                         double d1 = convertObjectToDouble(s1,tc1);
1206                         double d2 = convertObjectToDouble(s2,tc2);
1207                         return d1 / d2;
1208                 }
1209
1210                 //checked !!
1211                 private static object getDivSingle(object obj1, object obj2,TypeCode tc1 , TypeCode tc2) {
1212                         float d1 = convertObjectToFloat(obj1,tc1);
1213                         float d2 = convertObjectToFloat(obj2,tc2);
1214
1215                         float sum = d1 / d2;
1216                         if (float.IsInfinity(d1)) {
1217                                 if (float.IsInfinity(d1) || float.IsInfinity(d2))
1218                                         return sum;
1219                                 return (double) d1 / (double) d2;
1220                         }
1221                         return sum;
1222                 }
1223
1224                 private static void checkIfValidObjects(
1225                         object obj1,
1226                         object obj2,
1227                         TypeCode tc1,
1228                         TypeCode tc2) {
1229                         if (tc1 == TypeCode.Object    || tc1 == TypeCode.DBNull
1230                                 || tc1 == TypeCode.Char   || tc1 == TypeCode.SByte
1231                                 || tc1 == TypeCode.UInt16 || tc1 == TypeCode.UInt32
1232                                 || tc1 == TypeCode.UInt64 || tc1 == TypeCode.DateTime)
1233                                 throwNoValidOperator(obj1, obj2);
1234                         if (tc2 == TypeCode.Object    || tc2 == TypeCode.DBNull
1235                                 || tc2 == TypeCode.Char   || tc2 == TypeCode.SByte
1236                                 || tc2 == TypeCode.UInt16 || tc2 == TypeCode.UInt32
1237                                 || tc2 == TypeCode.UInt64 || tc2 == TypeCode.DateTime)
1238                                 throwNoValidOperator(obj1, obj2);
1239                 }
1240
1241                 //checked !!
1242                 public static object DivObj(object o1, object o2) {
1243                         TypeCode tc1 = getTypeCode(o1);
1244                         TypeCode tc2 = getTypeCode(o2);
1245
1246                         checkIfValidObjects(o1,o2,tc1,tc2);
1247
1248                         if (tc2 == TypeCode.Empty)
1249                                 throw new DivideByZeroException(
1250                                         /*Environment.GetResourceString(*/"Arg_DivideByZero")/*)*/;
1251
1252                         if (tc1 == TypeCode.String || tc2 == TypeCode.String)
1253                                 return getDivDouble(o1,o2,tc1,tc2);
1254                         else if (tc1 == TypeCode.Empty)
1255                                 return getDivDouble((double)0, o2,TypeCode.Double,tc2);
1256                         else if (tc1 == TypeCode.Double || tc2 == TypeCode.Double)
1257                                 return getDivDouble(o1,o2,tc1,tc2);
1258                         else if (tc1 == TypeCode.Single || tc2 == TypeCode.Single)
1259                                 return getDivSingle(o1, o2,tc1,tc2);
1260                         else if (tc1 == TypeCode.Decimal || tc2 == TypeCode.Decimal)
1261                                 return getDivDecimal(o1, o2,tc1,tc2);
1262                         else
1263                                 return getDivDouble(o1, o2,tc1,tc2);
1264                 }
1265
1266                 //checked
1267                 private static IConvertible toVBBoolConv(IConvertible conv) {
1268                         if (conv.ToBoolean(null))
1269                                 return (int)-1;
1270                         return (int)0;
1271                 }
1272
1273                 private static object getIDivideByte(object o1, object o2,TypeCode tc1,TypeCode tc2) {
1274                         byte d1 = convertObjectToByte(o1,tc1);
1275                         byte d2 = convertObjectToByte(o2,tc2);
1276                         return d1 / d2;
1277                 }
1278
1279                 private static object getIDivideInt16(object o1, object o2,TypeCode tc1,TypeCode tc2) {
1280                         short d1 = convertObjectToShort(o1,tc1);
1281                         short d2 = convertObjectToShort(o2,tc2);
1282                         return (int)((short) (d1 / d2));
1283                 }
1284
1285                 private static object getIDivideInt32(object o1, object o2,TypeCode tc1,TypeCode tc2) {
1286                         int d1 = convertObjectToInt(o1,tc1);
1287                         int d2 = convertObjectToInt(o2,tc2);
1288                         return d1 / d2;
1289                 }
1290
1291                 private static object getIDivideInt64(object o1, object o2,TypeCode tc1,TypeCode tc2) {
1292                         long d1 = convertObjectToLong(o1,tc1);
1293                         long d2 = convertObjectToLong(o2,tc2);
1294                         return d1 / d2;
1295                 }
1296
1297
1298                 public static object IDivObj(object o1, object o2) {
1299                         TypeCode tc1 = getTypeCode(o1);
1300                         TypeCode tc2 = getTypeCode(o2);
1301                         checkIfValidObjects(o1,o2,tc1,tc2);
1302
1303                         if (tc2 == TypeCode.Empty)
1304                                 throw new DivideByZeroException(
1305                                         /*Environment.GetResourceString(*/"Arg_DivideByZero")/*)*/;
1306                         else if (tc1 == TypeCode.Empty) {
1307                                 if (tc2 == TypeCode.Byte)
1308                                         return (byte)0;
1309                                 else if (tc2 == TypeCode.Int16)
1310                                         return (short)0;
1311                                 else if (tc2 == TypeCode.Int32)
1312                                         return (Int32)0;
1313                                 else
1314                                         return (long)0;
1315                         }
1316                         else if (tc1 == TypeCode.String || tc2 == TypeCode.String ||
1317                                 tc1 == TypeCode.Decimal || tc2 == TypeCode.Decimal ||
1318                                 tc1 == TypeCode.Double || tc2 == TypeCode.Double ||
1319                                 tc1 == TypeCode.Single || tc2 == TypeCode.Single ||
1320                                 tc1 == TypeCode.Int64 || tc2 == TypeCode.Int64)
1321                                 return getIDivideInt64(o1,o2,tc1,tc2);
1322                         else if (tc1 == TypeCode.Int32 || tc2 == TypeCode.Int32)
1323                                 return getIDivideInt32(o1,o2,tc1,tc2);
1324                         else if (tc1 == TypeCode.Int16 || tc2 == TypeCode.Int16)
1325                                 return getIDivideInt16(o1,o2,tc1,tc2);
1326                         else if (tc1 == TypeCode.Byte || tc2 == TypeCode.Byte)
1327                                 return getIDivideByte(o1,o2,tc1,tc2);
1328                         else
1329                                 return getIDivideInt16(o1,o2,tc1,tc2);
1330                 }
1331
1332                 private static object negObj(
1333                         object obj,
1334                         TypeCode tc) {
1335                         IConvertible conv;
1336
1337                         switch (tc) {
1338                                 case TypeCode.Empty :
1339                                         return (Int32)0;
1340                                 case TypeCode.Boolean :
1341                                         if(((bool)obj) == true)return (short)1;
1342                                         //else
1343                                         //int boolValue = (((ClrBoolean)obj).ToBoolean(null) == true)? 1 :0;
1344                                         //return (short)boolValue;
1345                                         return (short)0;
1346                                 case TypeCode.Byte :
1347                                         conv = (IConvertible)obj;
1348                                         short byteValue = (short) (0 - conv.ToByte(null));
1349                                         return (short)byteValue;
1350                                 case TypeCode.Int16 :
1351                                         conv = (IConvertible)obj;
1352                                         int shortValue =  (0 - conv.ToInt16(null));
1353                                         return (int)shortValue;
1354                                 case TypeCode.Int32 :
1355                                         conv = (IConvertible)obj;
1356                                         long intValue = (0 - conv.ToInt32(null));
1357                                         return intValue;
1358                                 case TypeCode.Int64 :
1359                                         conv = (IConvertible)obj;
1360                                         Int64 longValue = conv.ToInt64(null);
1361                                         if (longValue == Int64.MinValue)return Decimal.Negate(conv.ToDecimal(null));
1362                                         return -longValue;
1363                                 case TypeCode.Decimal :
1364                                         return Decimal.Negate((Decimal) obj);
1365                                 case TypeCode.Single :
1366                                         return -(float)obj;
1367                                 case TypeCode.Double :
1368                                         return (double)(0 - (double) obj);
1369                                 case TypeCode.String :
1370                                         return (double)(0 - DoubleType.FromString((string) obj));
1371                         }
1372
1373                         throw new InvalidCastException(
1374                                 Utils.GetResourceString(
1375                                 "NoValidOperator_OneOperand",
1376                                 Utils.VBFriendlyName(obj)));
1377
1378                 }
1379
1380
1381                 internal static bool IsTypeOf(Type typSrc, Type typParent) {
1382                         if (typSrc == typParent)
1383                                 return true;
1384                         return typSrc.IsSubclassOf(typParent);
1385                 }
1386
1387                 internal static Type GetTypeFromTypeCode (TypeCode tc) {
1388                         switch (tc) {
1389                         case TypeCode.Boolean:
1390                                 return typeof (bool);
1391                         case TypeCode.Byte:
1392                                 return typeof (byte);
1393                         case TypeCode.Char:
1394                                 return typeof (char);
1395                         case TypeCode.DateTime:
1396                                 return typeof (DateTime);
1397                         case TypeCode.DBNull:
1398                                 return typeof (System.DBNull);
1399                         case TypeCode.Decimal:
1400                                 return typeof (decimal);
1401                         case TypeCode.Double:
1402                                 return typeof (double);
1403                         case TypeCode.Int16:
1404                                 return typeof (short);
1405                         case TypeCode.Int32:
1406                                 return typeof (int);
1407                         case TypeCode.Int64:
1408                                 return typeof (long);
1409                         case TypeCode.Object:
1410                                 return typeof (object);
1411                         case TypeCode.SByte:
1412                                 return typeof (sbyte);
1413                         case TypeCode.Single:
1414                                 return typeof (float);
1415                         case TypeCode.String:
1416                                 return typeof (string);
1417                         }
1418                         return null;
1419                 }
1420
1421                 internal static bool ImplicitConversionExists (Type FromType, Type ToType) {
1422                         if (FromType == null)
1423                                 return true;
1424                         if (ToType == typeof (object))
1425                                 return true;
1426                         if (FromType.IsEnum)
1427                                 FromType = GetTypeFromTypeCode (Type.GetTypeCode (FromType));
1428                         if (ToType.IsEnum)
1429                                 ToType = GetTypeFromTypeCode (Type.GetTypeCode (ToType));
1430
1431                         if (Utils.IsNumericType (FromType) && Utils.IsNumericType (ToType))
1432                                 return true;
1433
1434                         if (IsWideningConversion (FromType, ToType)) {
1435                                 return true;
1436                         }
1437
1438                         if (IsNarrowingConversion (FromType, ToType))
1439                                 return true;
1440                         return false;
1441                 }
1442
1443                 internal static bool IsNarrowingConversion (Type FromType, Type ToType) {
1444
1445                         if (IsWiderNumeric (FromType, ToType)) // Narrowing Conversion
1446                                 return true;
1447
1448                         if (FromType == typeof (object)) // Object can be converted to any type
1449                                 return true;
1450
1451                         if (FromType.IsArray || ToType.IsArray)
1452                                 return false;
1453
1454                         TypeCode src_type = Type.GetTypeCode (FromType);
1455                         TypeCode dest_type = Type.GetTypeCode (ToType);
1456                         switch (dest_type) {
1457                         case TypeCode.String:
1458                                 switch (src_type) {
1459                                 case TypeCode.Byte:
1460                                 case TypeCode.SByte:
1461                                 case TypeCode.Int16:
1462                                 case TypeCode.Int32:
1463                                 case TypeCode.Int64:
1464                                 case TypeCode.Decimal:
1465                                 case TypeCode.Single:
1466                                 case TypeCode.Double:
1467                                 case TypeCode.Char:
1468                                 case TypeCode.Boolean:
1469                                 case TypeCode.DateTime:
1470                                 case TypeCode.Object:
1471                                         return true;
1472                                 }
1473                                 break;
1474                         case TypeCode.Byte:
1475                         case TypeCode.SByte:
1476                         case TypeCode.Int16:
1477                         case TypeCode.Int32:
1478                         case TypeCode.Int64:
1479                         case TypeCode.Decimal:
1480                         case TypeCode.Single:
1481                         case TypeCode.Double:
1482                         case TypeCode.Char:
1483                         case TypeCode.Boolean:
1484                         case TypeCode.DateTime:
1485                                 switch (src_type) {
1486                                         case TypeCode.String:
1487                                         case TypeCode.Object :
1488                                                 return true;
1489                                 }
1490                                 break;
1491                         }
1492                         if (src_type == TypeCode.String && ToType == typeof (char []))
1493                                 return true;
1494                         return false;
1495                 }
1496
1497                 internal static bool IsWideningConversion(Type FromType, Type ToType) {
1498                         if (FromType == null)
1499                                 return true;
1500                         TypeCode typeCode1 = Type.GetTypeCode(FromType);
1501                         TypeCode typeCode2 = Type.GetTypeCode(ToType);
1502
1503                         if (FromType == ToType)
1504                                 return true;
1505
1506                         if (ToType == typeof (object))
1507                                 return true;
1508                         if (IsWiderNumeric (ToType, FromType))
1509                                 return true;
1510
1511                         if (typeCode2 == TypeCode.String) {
1512                                 if (typeCode1 == TypeCode.Char || FromType == typeof (char[]))
1513                                         return true;
1514                                 return false;
1515                         }
1516
1517                         if (typeCode1 == TypeCode.String)
1518                                 return false;
1519
1520                         if (typeCode1 == TypeCode.DateTime || typeCode2 == TypeCode.DateTime)
1521                                 return false;
1522
1523                         if (typeCode1 == TypeCode.Char || typeCode2 == TypeCode.Char)
1524                                 return false;
1525
1526                         if (! FromType.IsValueType ) {
1527                                 if (ToType.IsValueType)
1528                                         return false;
1529                                 if (!FromType.IsArray || !ToType.IsArray)
1530                                 {
1531                                         return ToType.IsAssignableFrom(FromType);
1532                                 }
1533                                 if (FromType.GetArrayRank() == ToType.GetArrayRank())
1534                                     return ToType.GetElementType().IsAssignableFrom(FromType.GetElementType());
1535                                 else
1536                                         return false;
1537                         }
1538                         if (! ToType.IsValueType) {
1539                                 return ToType.IsAssignableFrom(FromType);
1540                         }
1541                         return false;
1542                 }
1543
1544                 //checked
1545                 [MonoTODO]
1546                 internal  static bool IsWiderNumeric(Type Type1, Type Type2) {
1547                         if (Type1 == null)
1548                                 return true;
1549                         TypeCode typeCode1 = Type.GetTypeCode(Type1);
1550                         TypeCode typeCode2 = Type.GetTypeCode(Type2);
1551                         if (!Utils.IsNumericType(Type1) || !Utils.IsNumericType(Type2)) {
1552                                 return false;
1553                         }
1554
1555                         if (Type1 == Type2)
1556                                 return true;
1557                         switch (typeCode1) {
1558
1559                         case TypeCode.Empty :
1560                                 return true;
1561                         case TypeCode.Boolean:
1562                                         if (typeCode2 == TypeCode.Byte)
1563                                                 return true;
1564                                         return false;
1565                         case TypeCode.Byte :
1566                                         return false;
1567                         case TypeCode.Int16 :
1568                                 switch (typeCode2) {
1569                                 case TypeCode.Boolean:
1570                                 case TypeCode.Byte:
1571                                         return true;
1572                                 default :
1573                                         return false;
1574                                 }
1575                         case TypeCode.Int32 :
1576                                 switch (typeCode2) {
1577                                 case TypeCode.Boolean:
1578                                 case TypeCode.Byte:
1579                                 case TypeCode.Int16:
1580                                         return true;
1581                                 default:
1582                                         return false;
1583                                 }
1584                         case TypeCode.Int64 :
1585                                 switch (typeCode2) {
1586                                 case TypeCode.Boolean:
1587                                 case TypeCode.Byte:
1588                                 case TypeCode.Int16:
1589                                 case TypeCode.Int32:
1590                                         return true;
1591                                 default:
1592                                         return false;
1593                                 }
1594                         case TypeCode.Decimal :
1595                                 switch (typeCode2) {
1596                                 case TypeCode.Single:
1597                                 case TypeCode.Double:
1598                                 case TypeCode.Empty:
1599                                         return false;
1600                                 default:
1601                                         return true;
1602                                 }
1603                         case TypeCode.Single :
1604                                 switch (typeCode2) {
1605                                 case TypeCode.Double:
1606                                 case TypeCode.Empty:
1607                                         return false;
1608                                 default :
1609                                         return true;
1610                                 }
1611                         case TypeCode.Double :
1612                                 return true;
1613                         }
1614
1615                         return false;
1616                 }
1617
1618                 //checked
1619                 public static bool LikeObj(
1620                         object vLeft,
1621                         object vRight,
1622                         CompareMethod compareOption) {
1623                         return StringType.StrLike(
1624                                 StringType.FromObject(vLeft),
1625                                 StringType.FromObject(vRight),
1626                                 compareOption);
1627                 }
1628
1629                 private static object getModByte(object o1,object o2,TypeCode tc1,TypeCode tc2) {
1630                         byte i1 = convertObjectToByte(o1,tc1);
1631                         byte i2 = convertObjectToByte(o2,tc2);
1632                         return (byte) (i1 % i2);
1633                 }
1634
1635                 private static object getModDecimal(object o1,object o2,TypeCode tc1,TypeCode tc2) {
1636                         Decimal dec1 = convertObjectToDecimal(o1,tc1);
1637                         Decimal dec2 = convertObjectToDecimal(o2,tc2);
1638                         return Decimal.Remainder(dec1, dec2);
1639                 }
1640
1641                 private static object getModDouble(object o1, object o2 , TypeCode tc1,TypeCode tc2) {
1642                         double d1 = convertObjectToDouble(o1,tc1);
1643                         double d2 = convertObjectToDouble(o1,tc1);
1644                         return d1 % d2;
1645                 }
1646
1647                 private static object getModInt16(object o1, object o2 , TypeCode tc1,TypeCode tc2) {
1648                         short i1 = convertObjectToShort(o1,tc1);
1649                         short i2 = convertObjectToShort(o2,tc2);
1650                         Int32 mod = i1 % i2;
1651                         if (mod < -32768 || mod > 32767)
1652                                 return mod;
1653                         return (short) mod;
1654                 }
1655
1656                 private static object getModInt32(object o1, object o2 , TypeCode tc1,TypeCode tc2) {
1657                         int i1 = convertObjectToInt(o1,tc1);
1658                         int i2 = convertObjectToInt(o1,tc1);
1659                         long mod = (long) i1 % (long) i2;
1660                         if (mod < 2147483648L || mod > 2147483647L)
1661                                 return (Int64)mod;
1662                         return (Int32)mod;
1663                 }
1664
1665                 private static object getModInt64(object o1, object o2 , TypeCode tc1,TypeCode tc2) {
1666                         long l1 = convertObjectToLong(o1,tc1);
1667                         long l2 = convertObjectToLong(o2,tc2);
1668                         long mod = l1 % l2;
1669                         return mod;
1670                 }
1671
1672                 public static object ModObj(object o1, object o2) {
1673                         TypeCode tc1 = getTypeCode(o1);
1674                         TypeCode tc2 = getTypeCode(o2);
1675
1676                         checkIfValidObjects(o1,o2,tc1,tc2);
1677
1678                         if (tc2 == TypeCode.Empty)
1679                                 throw new DivideByZeroException(
1680                                         /*Environment.GetResourceString(*/"Arg_DivideByZero"/*)*/);
1681                         else if (tc1 == TypeCode.Empty)
1682                                 return createZero(tc2);
1683                         else if (tc1 == TypeCode.String || tc2 == TypeCode.String)
1684                                 return getModDouble(o1,o2,tc1,tc2);
1685                         else if (tc1 == TypeCode.Double || tc2 == TypeCode.Double)
1686                                 return getModDouble(o1,o2,tc1,tc2);
1687                         else if (tc1 == TypeCode.Single || tc2 == TypeCode.Single)
1688                                 return getModSingle(o1,o2,tc1,tc2);
1689                         else if (tc1 == TypeCode.Decimal || tc2 == TypeCode.Decimal)
1690                                 return getModDecimal(o1,o2,tc1,tc2);
1691                         else if (tc1 == TypeCode.Int64 || tc2 == TypeCode.Int64)
1692                                 return getModInt64(o1,o2,tc1,tc2);
1693                         else if (tc1 == TypeCode.Int32 || tc2 == TypeCode.Int32)
1694                                 return getModInt32(o1,o2,tc1,tc2);
1695                         else if (tc1 == TypeCode.Int16 || tc2 == TypeCode.Int16)
1696                                 return getModInt16(o1,o2,tc1,tc2);
1697                         else if (tc1 == TypeCode.Byte && tc2 == TypeCode.Byte)
1698                                 return getModByte(o1,o2,tc1,tc2);
1699                         else
1700                                 return getModInt16(o1,o2,tc1,tc2);
1701                 }
1702
1703
1704                 //checked
1705                 private static int getVType2FromTypeCode(TypeCode typeCode) {
1706                         return VType2FromTypeCode[(int)typeCode];
1707                 }
1708
1709                 private static object getModSingle(object o1, object o2,TypeCode tc1,TypeCode tc2) {
1710                         float sng1 = convertObjectToFloat(o1,tc1);
1711                         float sng2 = convertObjectToFloat(o2,tc2);
1712                         return (float)(sng1 % sng2);
1713                 }
1714
1715                 private static object getMulByte(object o1, object o2,TypeCode tc1,TypeCode tc2) {
1716                         byte b1 = convertObjectToByte(o1,tc1);
1717                         byte b2 = convertObjectToByte(o2,tc2);
1718                         int i1 = b1 * b2;
1719                         if (i1 >= 0 && i1 <= 255)
1720                                 return (byte) i1;
1721                         if (i1 >= -32768 && i1 <= 32767)
1722                                 return (short) i1;
1723                         return (int)i1;
1724                 }
1725
1726                 private static object getMulDouble(object o1, object o2,TypeCode tc1,TypeCode tc2) {
1727                         double d1 = convertObjectToDouble(o1,tc1);
1728                         double d2 = convertObjectToDouble(o2,tc2);
1729                         return (double)(d1 * d2);
1730                 }
1731
1732                 private static object getMulInt16(object o1,object o2,TypeCode tc1,TypeCode tc2) {
1733                         short s1 = convertObjectToShort(o1,tc1);
1734                         short s2 = convertObjectToShort(o2,tc2);
1735                         int i1 = s1 * s2;
1736                         if (i1 >= -32768 && i1 <= 32767)
1737                                 return (short) i1;
1738                         return (int)i1;
1739                 }
1740
1741                 private static object getMulInt32(object o1,object o2,TypeCode tc1,TypeCode tc2) {
1742                         int i1 = convertObjectToInt(o1,tc1);
1743                         int i2 = convertObjectToInt(o2,tc2);
1744                         long l1 = (long) i1 * (long) i2;
1745                         if (l1 >= 2147483648L && l1 <= 2147483647L)
1746                                 return (int) l1;
1747                         return l1;
1748                 }
1749
1750                 private static object getMulSingle(object o1, object o2 , TypeCode tc1,TypeCode tc2) {
1751                         float f1 = convertObjectToFloat(o1,tc1);
1752                         float f2 = convertObjectToFloat(o2,tc2);
1753                         double d = (double) f1 * (double) f2;
1754                         if (d <= 3.40282e+038 && d >= -3.40282e+038)
1755                                 return (float) d;
1756                         if (double.IsInfinity(d)
1757                                 && float.IsInfinity(f1)
1758                                 || float.IsInfinity(f2))
1759                                 return (float) d;
1760                         return d;
1761                 }
1762
1763                 private static object getMulDecimal(object o1, object o2,TypeCode tc1,TypeCode tc2) {
1764                         Decimal dec1 = convertObjectToDecimal(o1,tc1);
1765                         Decimal dec2 = convertObjectToDecimal(o1,tc1);
1766
1767                         try {
1768                                 Decimal dec3 = Decimal.Multiply(dec1, dec2);
1769                                 return dec3;
1770                         }
1771                         catch (OverflowException exp) {
1772                                 exp.ToString();//dumb way to fix compiler warning about exp not used
1773                                 double d1 = Convert.ToDouble(dec1);
1774                                 double d2 = Convert.ToDouble(dec2);
1775
1776                                 return (float)(d1 * d2);
1777                         }
1778                 }
1779
1780                 private static object getMulInt64(object o1,object o2 , TypeCode tc1,TypeCode tc2) {
1781                         long l1 = convertObjectToLong(o1,tc1);
1782                         long l2 = convertObjectToLong(o2,tc2);
1783                         if (long.MaxValue / Math.Abs(l1) >= Math.Abs(l2))
1784                                 return l1 * l2;
1785
1786                         Decimal dec1 = new Decimal(l1);
1787                         Decimal dec2 = new Decimal(l2);
1788
1789                         try {
1790                                 Decimal dec3 = Decimal.Multiply(dec1, dec2);
1791                                 return dec3;
1792                         }
1793                         catch (OverflowException exp) {
1794                                 exp.ToString();//dumb way to fix exp not used compiler warning
1795                                 double d1 = (double) l1 * (double) l2;
1796
1797                                 return d1;
1798                         }
1799                 }
1800
1801                 private static object createZero(TypeCode tc) {
1802                         switch(tc) {
1803                                 case TypeCode.Boolean:
1804                                         return (short)0;
1805                                 case TypeCode.Byte:
1806                                         return (byte)0;
1807                                 case TypeCode.Int16:
1808                                         return (short)0;
1809                                 case TypeCode.Int32:
1810                                         return (int)0;
1811                                 case TypeCode.Int64:
1812                                         return (long)0;
1813                                 case TypeCode.Single:
1814                                         return (float)(0.0f);
1815                                 case TypeCode.Double:
1816                                         return (double)0.0;
1817                                 case TypeCode.Decimal:
1818                                         return Decimal.Zero;
1819                                 case TypeCode.String:
1820                                         return (double)0.0;
1821                                 default:
1822                                         return null;
1823                         }
1824                 }
1825
1826                 public static object MulObj(object o1, object o2) {
1827                         TypeCode tc1 = getTypeCode(o1);
1828                         TypeCode tc2 = getTypeCode(o2);
1829                         checkIfValidObjects(o1,o2,tc1,tc2);
1830
1831                         if (tc1 == TypeCode.Empty && tc2 == TypeCode.Empty)
1832                                 return (int)0;
1833                         else if (tc1 == TypeCode.Empty)
1834                                 return createZero(tc2);
1835                         else if (tc2 == TypeCode.Empty)
1836                                 return createZero(tc1);
1837                         else if (tc1 == TypeCode.String || tc1 == TypeCode.String)
1838                                 return getMulDouble(o1,o2,tc1,tc2);
1839                         else if (tc1 == TypeCode.Double || tc1 == TypeCode.Double)
1840                                 return getMulDouble(o1,o2,tc1,tc2);
1841                         else if (tc1 == TypeCode.Single || tc1 == TypeCode.Single)
1842                                 return getMulSingle(o1,o2,tc1,tc2);
1843                         else if (tc1 == TypeCode.Decimal || tc1 == TypeCode.Decimal)
1844                                 return getMulDecimal(o1,o2,tc1,tc2);
1845                         else if (tc1 == TypeCode.Int64 || tc1 == TypeCode.Int64)
1846                                 return getMulInt64(o1,o2,tc1,tc2);
1847                         else if (tc1 == TypeCode.Int32 || tc1 == TypeCode.Int32)
1848                                 return getMulInt32(o1,o2,tc1,tc2);
1849                         else if (tc1 == TypeCode.Int16 || tc1 == TypeCode.Int16)
1850                                 return getMulInt16(o1,o2,tc1,tc2);
1851                         else if (tc1 == TypeCode.Byte || tc1 == TypeCode.Byte)
1852                                 return getMulByte(o1,o2,tc1,tc2);
1853                         else
1854                                 return getMulInt16(o1,o2,tc1,tc2);
1855                 }
1856
1857                 //checked !!
1858                 public static object NegObj(object obj) {
1859                         TypeCode tc = getTypeCode(obj);
1860                         return negObj(obj, tc);
1861                 }
1862
1863                 public static object NotObj(object obj) {
1864                         IConvertible conv;
1865                         Type type;
1866                         TypeCode tc = getTypeCode(obj);
1867
1868                         if (obj == null)
1869                                 return (int)-1;
1870                         long val = 0;
1871                         switch (tc) {
1872                                 case TypeCode.Boolean :
1873                                         return !(bool)obj;
1874                                                 //new ClrBoolean(!((ClrBoolean)obj).ToBoolean(null));
1875                                 case TypeCode.Byte :
1876                                         type = obj.GetType();
1877                                         conv = (IConvertible)obj;
1878                                         byte byteVal = (byte) ~(conv.ToByte(null));
1879                                         if (type.IsEnum)
1880                                                 return Enum.ToObject(type, byteVal);
1881                                         return byteVal;
1882                                 case TypeCode.Int16 :
1883                                         type = obj.GetType();
1884                                         conv = (IConvertible)obj;
1885                                         short shortVal = (short) ~(conv.ToInt16(null));
1886                                         if (type.IsEnum)
1887                                                 return Enum.ToObject(type, shortVal);
1888                                         return shortVal;
1889                                 case TypeCode.Int32 :
1890                                         type = obj.GetType();
1891                                         conv = (IConvertible)obj;
1892                                         int intVal = ~(conv.ToInt32(null));
1893                                         if (type.IsEnum)
1894                                                 return Enum.ToObject(type, intVal);
1895                                         return intVal;
1896                                 case TypeCode.Int64 :
1897                                         type = obj.GetType();
1898                                         conv = (IConvertible)obj;
1899                                         long longVal = ~(conv.ToInt64(null));
1900                                         if (type.IsEnum)
1901                                                 return Enum.ToObject(type, longVal);
1902                                         return longVal;
1903                                 case TypeCode.Single :
1904                                         val = LongType.FromObject(obj);
1905                                         return ~val;
1906                                 case TypeCode.Double :
1907                                         val = LongType.FromObject(obj);
1908                                         return ~val;
1909                                 case TypeCode.Decimal :
1910                                         val = LongType.FromObject(obj);
1911                                         return ~val;
1912                                 case TypeCode.String :
1913                                         val = LongType.FromObject(obj);
1914                                         return ~val;
1915                         }
1916
1917                         throw new InvalidCastException(
1918                                 Utils.GetResourceString(
1919                                 "NoValidOperator_OneOperand",
1920                                 Utils.VBFriendlyName(obj)));
1921                 }
1922
1923                 private static object createZeroForCompare(TypeCode tc) {
1924                         switch(tc) {
1925                                 case TypeCode.Boolean:
1926                                         return false ;
1927                                 case TypeCode.Char:
1928                                         return (char)0;
1929                                 case TypeCode.Byte:
1930                                         return (byte)0;
1931                                 case TypeCode.Int16:
1932                                         return (short)0;
1933                                 case TypeCode.Int32:
1934                                         return (int)0;
1935                                 case TypeCode.Int64:
1936                                         return (long)0;
1937                                 case TypeCode.Single:
1938                                         return (float)0.0f;
1939                                 case TypeCode.Double:
1940                                         return (double)0.0;
1941                                 case TypeCode.Decimal:
1942                                         return Decimal.Zero;
1943                                 case TypeCode.DateTime:
1944                                         return null;
1945                                 case TypeCode.String:
1946                                         return "";
1947                                 default:
1948                                         return null;
1949                         }
1950                 }
1951
1952                 public static int ObjTst(object o1, object o2, bool textCompare) {
1953                         TypeCode tc1 = getTypeCode(o1);
1954                         TypeCode tc2 = getTypeCode(o2);
1955                         IComparable icomp1 = (IComparable)o1;
1956                         IComparable icomp2 = (IComparable)o2;
1957
1958                         if (tc1 == TypeCode.Empty && tc2 == TypeCode.Empty)
1959                                 return 0;
1960                         else if (tc1 == TypeCode.Empty)
1961                                 return icomp2.CompareTo(createZeroForCompare(tc2));
1962                         else if (tc2 == TypeCode.Empty)
1963                                 return icomp1.CompareTo(createZeroForCompare(tc1));
1964                         else if (tc1 == TypeCode.DateTime || tc2 == TypeCode.DateTime)
1965                                 return getObjTstDateTime(o1,o2,tc1,tc2);
1966                         else if (tc1 == TypeCode.Char && tc2 == TypeCode.Char)
1967                                 return getObjTstChar(o1,o2,tc1,tc2);
1968                         else if ((tc1 == TypeCode.Boolean && tc2 == TypeCode.String)||
1969                                 (tc2 == TypeCode.Boolean && tc1 == TypeCode.String) )
1970                                 return getObjTstBoolean(o1,o2,tc1,tc2);
1971                         else if (tc1 == TypeCode.Double || tc2 == TypeCode.Double)
1972                                 return getObjTstDouble(o1,o2,tc1,tc2);
1973                         else if (tc1 == TypeCode.Single || tc2 == TypeCode.Single)
1974                                 return getObjTstSingle(o1,o2,tc1,tc2);
1975                         else if (tc1 == TypeCode.Decimal || tc2 == TypeCode.Decimal)
1976                                 return getObjTstDecimal(o1,o2,tc1,tc2);
1977                         else if (tc1 == TypeCode.Int64 || tc2 == TypeCode.Int64)
1978                                 return getObjTstInt64(o1,o2,tc1,tc2);
1979                         else if (tc1 == TypeCode.Int32 || tc2 == TypeCode.Int32)
1980                                 return getObjTstInt32(o1,o2,tc1,tc2);
1981                         else if (tc1 == TypeCode.Int16 || tc2 == TypeCode.Int16)
1982                                 return getObjTstInt16(o1,o2,tc1,tc2);
1983                         else if (tc1 == TypeCode.Byte && tc2 == TypeCode.Byte)
1984                                 return getObjTstByte(o1,o2,tc1,tc2);
1985                         else if (tc1 == TypeCode.String || tc2 == TypeCode.String)
1986                                 return getObjTstString(o1,o2,tc1,tc2);
1987                         else
1988                                 return getObjTstInt16(o1,o2,tc1,tc2);
1989                 }
1990
1991                 private static int getObjTstString(object o1,object o2,TypeCode tc1,TypeCode tc2) {
1992                         string s1 = (tc1 == TypeCode.String)?(string)o1:o1.ToString();
1993                         string s2 = (tc2 == TypeCode.String)?(string)o2:o2.ToString();
1994                         return s1.CompareTo(s2);
1995                 }
1996
1997                 private static int getObjTstBoolean(object o1,object o2,TypeCode tc1,TypeCode tc2) {
1998                         IConvertible iconv1 = (IConvertible)o1;
1999                         IConvertible iconv2 = (IConvertible)o2;
2000                         bool b1 = iconv1.ToBoolean(null);
2001                         bool b2 = iconv2.ToBoolean(null);
2002                         if (b1 == b2)
2003                                 return 0;
2004                         if (b1 == false)
2005                                 return 1;
2006                         return -1;
2007                 }
2008
2009                 private static int getObjTstByte(object o1,object o2,TypeCode tc1,TypeCode tc2) {
2010                         byte by1 = convertObjectToByte(o1,tc1);
2011                         byte by2 = convertObjectToByte(o2,tc2);
2012                         if (by1 < by2)
2013                                 return -1;
2014                         if (by1 > by2)
2015                                 return 1;
2016                         return 0;
2017                 }
2018
2019                 private static int getObjTstChar(object o1,object o2,TypeCode tc1,TypeCode tc2) {
2020                         char ch1 = convertObjectToChar(o1,tc1);
2021                         char ch2 = convertObjectToChar(o2,tc2);
2022                         if (ch1 < ch2)
2023                                 return -1;
2024                         if (ch1 > ch2)
2025                                 return 1;
2026                         return 0;
2027                 }
2028
2029                 private static int getObjTstDateTime(object o1,object o2,TypeCode tc1,TypeCode tc2) {
2030                         DateTime var1 = convertObjectToDateTime(o1,tc1);
2031                         DateTime var2 = convertObjectToDateTime(o2,tc2);
2032                         long time1 = Convert.ToInt32(var1);//Java code var1.getCalendar().getTime().getTime();
2033                         long time2 = Convert.ToInt32(var2);//Java code var2.getCalendar().getTime().getTime();
2034                         if (time1 < time2)
2035                                 return -1;
2036                         if (time1 > time2)
2037                                 return 1;
2038                         return 0;
2039                 }
2040
2041                 private static int getObjTstDecimal(object o1,object o2,TypeCode tc1,TypeCode tc2) {
2042                         Decimal dec1 = convertObjectToDecimal(o1,tc1);
2043                         Decimal dec2 = convertObjectToDecimal(o2,tc2);
2044                         int res = Decimal.Compare(dec1, dec2);
2045                         if (res < 0)
2046                                 return -1;
2047                         if (res > 0)
2048                                 return 1;
2049                         return 0;
2050                 }
2051
2052                 private static int getObjTstDouble(object o1,object o2,TypeCode tc1,TypeCode tc2) {
2053                         double d1 = convertObjectToDouble(o1,tc1);
2054                         double d2 = convertObjectToDouble(o2,tc2);
2055                         if (d1 < d2)
2056                                 return -1;
2057                         if (d1 > d2)
2058                                 return 1;
2059                         return 0;
2060                 }
2061
2062                 private static int getObjTstInt16(object o1,object o2,TypeCode tc1,TypeCode tc2) {
2063                         short s1 = convertObjectToShort(o1,tc1);
2064                         short s2 = convertObjectToShort(o2,tc2);
2065                         if (s1 < s2)
2066                                 return -1;
2067                         if (s1 > s2)
2068                                 return 1;
2069                         return 0;
2070                 }
2071
2072                 private static int getObjTstInt32(object o1,object o2,TypeCode tc1,TypeCode tc2) {
2073                         int i1 = convertObjectToInt(o1,tc1);
2074                         int i2 = convertObjectToInt(o2,tc2);
2075                         if (i1 < i2)
2076                                 return -1;
2077                         if (i1 > i2)
2078                                 return 1;
2079                         return 0;
2080                 }
2081
2082                 private static int getObjTstInt64(object o1,object o2,TypeCode tc1,TypeCode tc2) {
2083                         long l1 = convertObjectToLong(o1,tc1);
2084                         long l2 = convertObjectToLong(o1,tc1);
2085                         if (l1 < l2)
2086                                 return -1;
2087                         if (l1 > l2)
2088                                 return 1;
2089                         return 0;
2090                 }
2091
2092                 private static int getObjTstSingle(object o1,object o2,TypeCode tc1,TypeCode tc2) {
2093                         float f1 = convertObjectToFloat(o1,tc1);
2094                         float f2 = convertObjectToFloat(o2,tc2);
2095                         if (f1 < f2)
2096                                 return -1;
2097                         if (f1 > f2)
2098                                 return 1;
2099                         return 0;
2100                 }
2101
2102                 public static object PlusObj(object obj) {
2103                         TypeCode tc = getTypeCode(obj);
2104                         if (tc == TypeCode.Empty)
2105                                 return (int)0;
2106                         else if (tc == TypeCode.Boolean) {
2107                                 IConvertible conv =     (IConvertible)obj;
2108                                 //java return new short((short) conv.ToInt16(null));
2109                                 return (short)conv.ToInt16(null);//cast to short probably not needed.
2110                         }
2111                         else if (tc == TypeCode.String)
2112                                 return DoubleType.FromObject(obj);
2113                         else if (tc == TypeCode.Byte || tc == TypeCode.Int16
2114                                 || tc == TypeCode.Int32  || tc == TypeCode.Int64
2115                                 || tc == TypeCode.Single || tc == TypeCode.Double
2116                                 || tc == TypeCode.Decimal)
2117                                 return obj;
2118                         else
2119                                 throw new InvalidCastException(
2120                                         Utils.GetResourceString(
2121                                         "NoValidOperator_OneOperand",
2122                                         Utils.VBFriendlyName(obj)));
2123                 }
2124
2125                 public static object PowObj(object obj1, object obj2) {
2126                         if (obj1 == null || obj2 == null)
2127                                 return (int)1;
2128                         TypeCode tc1 = getTypeCode(obj1);
2129                         TypeCode tc2 = getTypeCode(obj2);
2130                         TypeCode widestType =  GetWidestType(tc1,tc2);
2131
2132                         if (widestType == TypeCode.Byte      || widestType == TypeCode.Boolean
2133                                 || widestType == TypeCode.Int16  || widestType == TypeCode.Int32
2134                                 || widestType == TypeCode.Int64  || widestType == TypeCode.Single
2135                                 || widestType == TypeCode.Double || widestType == TypeCode.Decimal
2136                                 || widestType == TypeCode.String)
2137                                 return (double)Math.Pow(DoubleType.FromObject(obj1),DoubleType.FromObject(obj2));
2138                                 //return new ClrDouble(
2139                                 //      java.lang.Math.pow(
2140                                 //      DoubleType.FromObject(obj1),
2141                                 //      DoubleType.FromObject(obj2)));
2142                         else
2143                         throw new InvalidCastException(
2144                                 Utils.GetResourceString(
2145                                 "NoValidOperator_OneOperand",
2146                                 Utils.VBFriendlyName(obj1)));
2147                 }
2148
2149                 //checked
2150                 public static object StrCatObj(object vLeft, object vRight) {
2151                         if (vLeft is DBNull && vRight is DBNull)
2152                                 return DBNull.Value;
2153                         return StringType.FromObject(vLeft) + StringType.FromObject(vRight);
2154                 }
2155
2156                 private static object getSubByte(object o1, object o2 , TypeCode tc1,TypeCode tc2) {
2157                         byte byte1 = convertObjectToByte(o1,tc1);
2158                         byte byte2 = convertObjectToByte(o2,tc2);
2159                         short s = (short) (byte1 - byte2);
2160                         if (s >= 0 && s <= 255)
2161                                 return (byte) s;
2162                         return s;
2163                 }
2164
2165                 private static object getSubDecimal(object o1, object o2,TypeCode tc1,TypeCode tc2) {
2166                         Decimal dec1 = convertObjectToDecimal(o1,tc1);
2167                         Decimal dec2 = convertObjectToDecimal(o2,tc2);
2168                         try {
2169                                 Decimal dec3 = Decimal.Subtract(dec1, dec2);
2170                                 return dec3;
2171                         }
2172                         catch (OverflowException exp) {
2173                                 exp.ToString();//dumb way to fix compiler warning about exp not used
2174
2175                                 double d1 = Decimal.ToDouble(dec1);
2176                                 double d2 = Decimal.ToDouble(dec2);
2177
2178                                 return (double)(d1 * d2);
2179                         }
2180                 }
2181
2182                 private static object getSubInt16(object o1, object o2,TypeCode tc1,TypeCode tc2) {
2183                         short s1 = convertObjectToShort(o1,tc1);
2184                         short s2 = convertObjectToShort(o2,tc2);
2185                         int res = s1 - s2;
2186                         if (res >= -32768 && res <= 32767)
2187                                 return (short) res;
2188                         return res;
2189                 }
2190
2191                 private static object getSubInt32(object o1, object o2,TypeCode tc1,TypeCode tc2) {
2192                         int i1 = convertObjectToInt(o1,tc1);
2193                         int i2 = convertObjectToInt(o2,tc2);
2194                         long res = (long) i1 - (long) i2;
2195                         if (res >= 2147483648L && res <= 2147483647L)
2196                                 return (int) res;
2197                         return res;
2198                 }
2199
2200                 private static object getSubInt64(object o1, object o2,TypeCode tc1,TypeCode tc2) {
2201                         long l1 = convertObjectToLong(o1,tc1);
2202                         long l2 = convertObjectToLong(o2,tc2);
2203
2204                         //Java code if (Long.MAX_VALUE - java.lang.Math.abs(l1) <= java.lang.Math.abs(l2))
2205                         if (long.MaxValue - Math.Abs(l1) <= Math.Abs(l2))
2206                                 return l1 - l2;
2207
2208                         Decimal dec1 = new Decimal(l1);
2209                         Decimal dec2 = new Decimal(l2);
2210
2211                         Decimal dec3 = Decimal.Subtract(dec1, dec2);
2212                         return dec3;
2213                 }
2214
2215                 private static object getSubSingle(object o1, object o2 ,TypeCode tc1 ,TypeCode tc2) {
2216                         float d1 = convertObjectToFloat(o1,tc1);
2217                         float d2 = convertObjectToFloat(o2,tc2);
2218                         double res = (double) d1 - (double) d2;
2219                         if (res <= 3.40282e+038 && res >= -3.40282e+038)
2220                                 return (float) res;
2221                         if (double.IsInfinity(res)
2222                                 && float.IsInfinity(d1)
2223                                 || float.IsInfinity(d2))
2224                                 return (float) res;
2225                         return res;
2226                 }
2227
2228                 private static DateTime convertObjectToDateTime(object o1, TypeCode tc1) {
2229                         DateTime dateTime = new DateTime(0);//java code null
2230                         if (o1 != null) {
2231                                 if (o1 is string)
2232                                         dateTime = DateType.FromString((string) o1);
2233                                 else if (o1 is IConvertible) {
2234                                         dateTime = ((IConvertible) o1).ToDateTime(null);
2235                                 }
2236                         }
2237                         return dateTime;
2238                 }
2239
2240                 private static char convertObjectToChar(object o1 , TypeCode tc1) {
2241                         char char1 = (char)0;
2242                         if (o1 != null) {
2243                                 if (o1 is string)
2244                                         char1 = CharType.FromString((string)o1);
2245                                 else if (o1 is IConvertible) {
2246                                         if (tc1 == TypeCode.Boolean) {
2247                                                 char1 = (char)toVBBool((IConvertible)o1);
2248                                         }
2249                                         else
2250                                                 char1 = (char)((IConvertible)o1).ToChar(null);
2251                                 }
2252                         }
2253                         return char1;
2254                 }
2255
2256                 private static byte convertObjectToByte(object o1 , TypeCode tc1) {
2257                         byte byte1 = 0;
2258                         if (o1 != null) {
2259                                 if (o1 is string)
2260                                         byte1 = (byte)ByteType.FromString((string)o1);
2261                                 else if (o1 is IConvertible) {
2262                                         if (tc1 == TypeCode.Boolean) {
2263                                                 byte1 = (byte)toVBBool((IConvertible)o1);
2264                                         }
2265                                         else
2266                                                 byte1 = (byte)((IConvertible)o1).ToByte(null);
2267                                 }
2268                         }
2269                         return byte1;
2270                 }
2271
2272                 private static short convertObjectToShort(object o1 , TypeCode tc1) {
2273                         short s1 = 0;
2274                         if (o1 != null) {
2275                                 if (o1 is string)
2276                                         s1 = ShortType.FromString((string)o1);
2277                                 else if (o1 is IConvertible) {
2278                                         if (tc1 == TypeCode.Boolean) {
2279                                                 s1 = (short)toVBBool((IConvertible)o1);
2280                                         }
2281                                         else
2282                                                 s1 = ((IConvertible)o1).ToInt16(null);
2283                                 }
2284                         }
2285                         return s1;
2286                 }
2287
2288                 private static int convertObjectToInt(object o1 , TypeCode tc1) {
2289                         int i1=0;
2290                         if (o1 != null) {
2291                                 if (o1 is string)
2292                                         i1 = IntegerType.FromString((string)o1);
2293                                 else if (o1 is IConvertible) {
2294                                         if (tc1 == TypeCode.Boolean) {
2295                                                 i1 = (int)toVBBool((IConvertible)o1);
2296                                         }
2297                                         else
2298                                                 i1 = ((IConvertible)o1).ToInt32(null);
2299                                 }
2300                         }
2301                         return i1;
2302                 }
2303
2304                 private static Decimal convertObjectToDecimal(object o1 , TypeCode tc1) {
2305                         Decimal dec1 = 0;//java code null;
2306                         if (o1 != null) {
2307                                 if (o1 is string)
2308                                         dec1 = DecimalType.FromString((string)o1);
2309                                 else if (o1 is IConvertible) {
2310                                         if (tc1 == TypeCode.Boolean) {
2311                                                 dec1 = toVBBoolConv((IConvertible)o1).ToDecimal(null);
2312                                         }
2313                                         else
2314                                                 dec1 = ((IConvertible)o1).ToDecimal(null);
2315                                 }
2316                         }
2317                         return dec1;
2318                 }
2319
2320                 private static long convertObjectToLong(object o1 , TypeCode tc1) {
2321                         long l1 = 0;
2322                         if (o1 != null) {
2323                                 if (o1 is string)
2324                                         l1 = LongType.FromString((string)o1);
2325                                 else if (o1 is IConvertible) {
2326                                         if (tc1 == TypeCode.Boolean) {
2327                                                 l1 = (long)toVBBool((IConvertible)o1);
2328                                         }
2329                                         else
2330                                                 l1 = ((IConvertible)o1).ToInt64(null);
2331                                 }
2332                         }
2333                         return l1;
2334                 }
2335
2336                 private static float convertObjectToFloat(object o1 , TypeCode tc1) {
2337                         float d1 = 0;
2338                         if (o1 != null) {
2339                                 if (o1 is string)
2340                                         d1 = SingleType.FromString((string)o1);
2341                                 else if (o1 is IConvertible) {
2342                                         if (tc1 == TypeCode.Boolean) {
2343                                                 d1 = (float)toVBBool((IConvertible)o1);
2344                                         }
2345                                         else
2346                                                 d1 = ((IConvertible)o1).ToSingle(null);
2347                                 }
2348                         }
2349                         return d1;
2350                 }
2351
2352                 private static double convertObjectToDouble(object o1 , TypeCode tc1) {
2353                         double d1 = 0;
2354                         if (o1 != null) {
2355                                 if (o1 is string)
2356                                         d1 = DoubleType.FromString((string)o1);
2357                                 else if (o1 is IConvertible) {
2358                                         if (tc1 == TypeCode.Boolean) {
2359                                                 d1 = (double) toVBBool((IConvertible)o1);
2360                                         }
2361                                         else
2362                                                 d1 = ((IConvertible)o1).ToDouble(null);
2363                                 }
2364                         }
2365                         return d1;
2366                 }
2367
2368                 private static object getSubDouble(object s1, object s2,TypeCode tc1,TypeCode tc2) {
2369                         double d1 = convertObjectToDouble(s1,tc1);
2370                         double d2 = convertObjectToDouble(s2,tc2);
2371                         return d1 - d2;
2372                 }
2373
2374
2375                 public static object SubObj(object o1, object o2) {
2376                         TypeCode tc1 = getTypeCode(o1);
2377                         TypeCode tc2 = getTypeCode(o2);
2378                         checkIfValidObjects(o1,o2,tc1,tc2);
2379
2380                         if (tc1 == TypeCode.Empty && tc2 == TypeCode.Empty)
2381                                 return (int)0;
2382                         else if (tc2 == TypeCode.Empty)
2383                                 return o1;
2384                         else if (tc1 == TypeCode.Empty)
2385                                 return  negObj(o2, tc2);
2386                         else if (tc1 == TypeCode.Double || tc2 == TypeCode.Double)
2387                                 return getSubDouble(o1,o2,tc1,tc2);
2388                         else if (tc1 == TypeCode.String || tc2 == TypeCode.String)
2389                                 return getSubDouble(o1,o2,tc1,tc2);
2390                         else if (tc1 == TypeCode.Single || tc2 == TypeCode.Single)
2391                                 return getSubSingle(o1,o2,tc1,tc2);
2392                         else if (tc1 == TypeCode.Decimal || tc2 == TypeCode.Decimal)
2393                                 return getSubDecimal(o1,o2,tc1,tc2);
2394                         else if (tc1 == TypeCode.Int64 || tc2 == TypeCode.Int64)
2395                                 return getSubInt64(o1,o2,tc1,tc2);
2396                         else if (tc1 == TypeCode.Int32 || tc2 == TypeCode.Int32)
2397                                 return getSubInt32(o1,o2,tc1,tc2);
2398                         else if (tc1 == TypeCode.Int16 || tc2 == TypeCode.Int16)
2399                                 return getSubInt16(o1,o2,tc1,tc2);
2400                         else if (tc1 == TypeCode.Byte && tc2 == TypeCode.Byte)
2401                                 return getSubByte(o1,o2,tc1,tc2);
2402                         else
2403                                 return getSubInt16(o1,o2,tc1,tc2);
2404
2405                 }
2406
2407                 //checked
2408                 private static void throwNoValidOperator(object obj1, object obj2) {
2409                         string obj1MsgStr = "'Nothing'";
2410                         string obj2MsgStr = "'Nothing'";
2411                         string obj1Name = Utils.VBFriendlyName(obj1);
2412                         string obj2Name = Utils.VBFriendlyName(obj2);
2413                         if (obj1 is string)
2414                                 obj1MsgStr =
2415                                         Utils.GetResourceString(
2416                                         "NoValidOperator_StringType1",
2417                                         (string) obj1);
2418                         else if (obj1 != null)
2419                                 obj1MsgStr =
2420                                         Utils.GetResourceString(
2421                                         "NoValidOperator_NonStringType1",
2422                                         obj1Name);
2423                         if (obj2 is string)
2424                                 obj2MsgStr =
2425                                         Utils.GetResourceString(
2426                                         "NoValidOperator_StringType1",
2427                                         (string) obj2);
2428                         else if (obj2 != null)
2429                                 obj2MsgStr =
2430                                         Utils.GetResourceString(
2431                                         "NoValidOperator_NonStringType1",
2432                                         obj2Name);
2433
2434                         throw new InvalidCastException(
2435                                 Utils.GetResourceString(
2436                                 "NoValidOperator_TwoOperands",
2437                                 obj1MsgStr,
2438                                 obj2MsgStr));
2439                 }
2440
2441                 public static object ShiftLeftObj (object o1, int amount) {
2442                         IConvertible convertible1 = (IConvertible)o1;
2443                         TypeCode tc = getTypeCode(o1);
2444                         //TypeCode code2;
2445                         if (tc == TypeCode.Empty)
2446                                 return (int)0;
2447                         else if (tc == TypeCode.Boolean)
2448                                 return (short) ((((short) - convertible1.ToInt16(null))
2449                                         << (amount & 15)));
2450                         else if (tc == TypeCode.Byte)
2451                                 return (byte) ((convertible1.ToByte(null) << (amount & 7)));
2452                         else if (tc == TypeCode.Int16)
2453                                 return (short) ((convertible1.ToInt16(null) << (amount & 15)));
2454                         else if (tc == TypeCode.Int32)
2455                                 return (int)convertible1.ToInt32(null) << (amount & 31);
2456                         else if (
2457                                 tc == TypeCode.Int64
2458                                 || tc == TypeCode.Single
2459                                 || tc == TypeCode.Double
2460                                 || tc == TypeCode.Decimal)
2461                                 return (Int64)(convertible1.ToInt64(null) << (amount & 63));
2462                         else if (tc == TypeCode.String)
2463                                 return (long)((LongType.FromString(convertible1.ToString(null))
2464                                         << (amount & 63)));
2465                         else
2466                                 throw new InvalidCastException(
2467                                         Utils.GetResourceString(
2468                                         "NoValidOperator_OneOperand",
2469                                         Utils.VBFriendlyName(o1)));
2470                 }
2471
2472                 public static object ShiftRightObj (object o1, int amount) {
2473                         IConvertible convertible1 = (IConvertible)o1;
2474                         TypeCode tc = getTypeCode(o1);
2475                         //TypeCode code2;
2476                         if (tc == TypeCode.Empty)
2477                                 return (int)0;
2478                         else if (tc == TypeCode.Boolean)
2479                                 return (short) ((((short) - convertible1.ToInt16(null))
2480                                         >> (amount & 15)));
2481                         else if (tc == TypeCode.Byte)
2482                                 return (byte) ((convertible1.ToByte(null) >> (amount & 7)));
2483                         else if (tc == TypeCode.Int16)
2484                                 return (short) ((convertible1.ToInt16(null) >> (amount & 15)));
2485                         else if (tc == TypeCode.Int32)
2486                                 return (int)convertible1.ToInt32(null) >> (amount & 31);
2487                         else if (
2488                                 tc == TypeCode.Int64
2489                                 || tc == TypeCode.Single
2490                                 || tc == TypeCode.Double
2491                                 || tc == TypeCode.Decimal)
2492                                 return (long)(convertible1.ToInt64(null) >> (amount & 63));
2493                         else if (tc == TypeCode.String)
2494                                 return (long)(LongType.FromString(convertible1.ToString(null))  >> (amount & 63));
2495                         else
2496                                 throw new InvalidCastException(
2497                                         Utils.GetResourceString(
2498                                         "NoValidOperator_OneOperand",
2499                                         Utils.VBFriendlyName(o1)));
2500                 }
2501
2502
2503                 internal static Type TypeFromTypeCode(TypeCode vartype) {
2504                         return TypeFromTypeCode((int)vartype);
2505                 }
2506
2507                 internal static Type TypeFromTypeCode(int vartype) {
2508                         return tblTypeFromTypeCode[vartype];
2509                 }
2510
2511                 public static object XorObj(object obj1, object obj2) {
2512                         if (obj1 == null && obj2 == null)
2513                                 return (int)0;
2514                         TypeCode tc1 = getTypeCode(obj1);
2515                         TypeCode tc2 = getTypeCode(obj2);
2516                         TypeCode widestType = GetWidestType(tc1, tc2);
2517                         if (widestType == TypeCode.Boolean    || widestType == TypeCode.Byte
2518                                 || widestType == TypeCode.Int16   || widestType == TypeCode.Int32
2519                                 || widestType == TypeCode.Int64   || widestType == TypeCode.Single
2520                                 || widestType == TypeCode.Double  || widestType == TypeCode.Decimal
2521                                 || widestType == TypeCode.String) {
2522                                 bool b1 = BooleanType.FromObject(obj1);
2523                                 bool b2 = BooleanType.FromObject(obj2);
2524                                 return (bool)(b1 ^ b2);
2525                         }
2526                         else
2527                                 throw new InvalidCastException(
2528                                         Utils.GetResourceString(
2529                                         "NoValidOperator_TwoOperands",
2530                                         Utils.VBFriendlyName(obj1),
2531                                         Utils.VBFriendlyName(obj2)));
2532                 }
2533                 //TODO:
2534                 //    static class VType extends Enum implements IClrInt
2535                 //    {
2536                 //        public int value__;
2537                 //
2538                 //        public static final int t_bad = 0;
2539                 //        public static final VType _t_bad = new VType(0);
2540                 //
2541                 //        public static final int t_bool = 1;
2542                 //        public static final VType _t_bool = new VType(1);
2543                 //
2544                 //        public static final int t_ui1 = 2;
2545                 //        public static final VType _t_ui1 = new VType(2);
2546                 //
2547                 //        public static final int t_i2 = 3;
2548                 //        public static final VType _t_i2 = new VType(3);
2549                 //
2550                 //        public static final int t_i4 = 4;
2551                 //        public static final VType _t_i4 = new VType(4);
2552                 //
2553                 //        public static final int t_i8 = 5;
2554                 //        public static final VType _t_i8 = new VType(5);
2555                 //
2556                 //        public static final int t_dec = 6;
2557                 //        public static final VType _t_dec = new VType(6);
2558                 //
2559                 //        public static final int t_r4 = 7;
2560                 //        public static final VType _t_r4 = new VType(7);
2561                 //
2562                 //        public static final int t_r8 = 8;
2563                 //        public static final VType _t_r8 = new VType(8);
2564                 //
2565                 //        public static final int t_char = 9;
2566                 //        public static final VType _t_char = new VType(9);
2567                 //
2568                 //        public static final int t_str = 10;
2569                 //        public static final VType _t_str = new VType(10);
2570                 //
2571                 //        public static final int t_date = 11;
2572                 //        public static final VType _t_date = new VType(11);
2573                 //
2574                 //        public VType()
2575                 //        {}
2576                 //
2577                 //        private VType(int value)
2578                 //        {
2579                 //            value__ = value;
2580                 //        }
2581                 //
2582                 //        public void __ZeroInit__()
2583                 //        {
2584                 //            value__ = 0;
2585                 //        }
2586                 //
2587                 //        public void __RealCtor__()
2588                 //        {
2589                 //            value__ = 0;
2590                 //        }
2591                 //
2592                 //        public VType __Clone__()
2593                 //        {
2594                 //            return new VType(value__);
2595                 //        }
2596                 //
2597                 //
2598                 //        public int getValue()
2599                 //        {
2600                 //            return value__;
2601                 //        }
2602                 //
2603                 //        public void setValue(int value)
2604                 //        {
2605                 //            value__ = value;
2606                 //        }
2607                 //
2608                 //        public static VType getEnumForValue(int value)
2609                 //        {
2610                 //            switch(value)
2611                 //            {
2612                 //                case t_bad:   return _t_bad;
2613                 //                case t_bool:  return _t_bool;
2614                 //                case t_ui1:   return _t_ui1;
2615                 //                case t_i2:    return _t_i2;
2616                 //                case t_i4:    return _t_i4;
2617                 //                case t_i8:    return _t_i8;
2618                 //                case t_dec:   return _t_dec;
2619                 //                case t_r4:    return _t_r4;
2620                 //                case t_r8:    return _t_r8;
2621                 //                case t_char:  return _t_char;
2622                 //                case t_str:   return _t_str;
2623                 //                case t_date:  return _t_date;
2624                 //            }
2625                 //
2626                 //            throw new IllegalArgumentException("The value " + value + " is not" +
2627                 //                " valid for enumeration VType");
2628                 //        }
2629                 //
2630                 //        protected object GetValue()
2631                 //        {
2632                 //            return new system.ClrInt32(getValue());
2633                 //        }
2634                 //    }
2635                 //
2636                 //    static class VType2 extends Enum implements IClrInt
2637                 //    {
2638                 //        public int value__;
2639                 //
2640                 //        public static final int t_bad = 0;
2641                 //        public static final VType2 _t_bad = new VType2(0);
2642                 //
2643                 //        public static final int t_bool = 1;
2644                 //        public static final VType2 _t_bool = new VType2(1);
2645                 //
2646                 //        public static final int t_ui1 = 2;
2647                 //        public static final VType2 _t_ui1 = new VType2(2);
2648                 //
2649                 //        public static final int t_char = 3;
2650                 //        public static final VType2 _t_char = new VType2(3);
2651                 //
2652                 //        public static final int t_i2 = 4;
2653                 //        public static final VType2 _t_i2 = new VType2(4);
2654                 //
2655                 //        public static final int t_i4 = 5;
2656                 //        public static final VType2 _t_i4 = new VType2(5);
2657                 //
2658                 //        public static final int t_i8 = 6;
2659                 //        public static final VType2 _t_i8 = new VType2(6);
2660                 //
2661                 //        public static final int t_r4 = 7;
2662                 //        public static final VType2 _t_r4 = new VType2(7);
2663                 //
2664                 //        public static final int t_r8 = 8;
2665                 //        public static final VType2 _t_r8 = new VType2(8);
2666                 //
2667                 //        public static final int t_date = 9;
2668                 //        public static final VType2 _t_date = new VType2(9);
2669                 //
2670                 //        public static final int t_dec = 10;
2671                 //        public static final VType2 _t_dec = new VType2(10);
2672                 //
2673                 //        public static final int t_ref = 11;
2674                 //        public static final VType2 _t_ref = new VType2(11);
2675                 //
2676                 //        public static final int t_str = 12;
2677                 //        public static final VType2 _t_str = new VType2(12);
2678                 //
2679                 //        public VType2()
2680                 //        {}
2681                 //
2682                 //        private VType2(int value)
2683                 //        {
2684                 //            value__ = value;
2685                 //        }
2686                 //
2687                 //        public void __ZeroInit__()
2688                 //        {
2689                 //            value__ = 0;
2690                 //        }
2691                 //
2692                 //        public void __RealCtor__()
2693                 //        {
2694                 //            value__ = 0;
2695                 //        }
2696                 //
2697                 //        public VType2 __Clone__()
2698                 //        {
2699                 //            return new VType2(value__);
2700                 //        }
2701                 //
2702                 //
2703                 //        public int getValue()
2704                 //        {
2705                 //            return value__;
2706                 //        }
2707                 //
2708                 //        public void setValue(int value)
2709                 //        {
2710                 //            value__ = value;
2711                 //        }
2712                 //
2713                 //        public static VType2 getEnumForValue(int value)
2714                 //        {
2715                 //            switch(value)
2716                 //            {
2717                 //                case t_bad:   return _t_bad;
2718                 //                case t_bool:  return _t_bool;
2719                 //                case t_ui1:   return _t_ui1;
2720                 //                case t_char:  return _t_char;
2721                 //                case t_i2:    return _t_i2;
2722                 //                case t_i4:    return _t_i4;
2723                 //                case t_i8:    return _t_i8;
2724                 //                case t_r4:    return _t_r4;
2725                 //                case t_r8:    return _t_r8;
2726                 //                case t_date:  return _t_date;
2727                 //                case t_dec:   return _t_dec;
2728                 //                case t_ref:   return _t_ref;
2729                 //                case t_str:   return _t_str;
2730                 //            }
2731                 //
2732                 //            throw new IllegalArgumentException("The value " + value + " is not" +
2733                 //                " valid for enumeration VType2");
2734                 //        }
2735                 //
2736                 //        protected object GetValue()
2737                 //        {
2738                 //            return new system.ClrInt32(getValue());
2739                 //        }
2740                 //    }
2741                 //
2742                 //    static class CC extends Enum implements IClrInt
2743                 //    {
2744                 //        public int value__;
2745                 //
2746                 //        public static final int Err = 0;
2747                 //        public static final CC _Err = new CC(0);
2748                 //
2749                 //        public static final int Same = 1;
2750                 //        public static final CC _Same = new CC(1);
2751                 //
2752                 //        public static final int Narr = 2;
2753                 //        public static final CC _Narr = new CC(2);
2754                 //
2755                 //        public static final int Wide = 3;
2756                 //        public static final CC _Wide = new CC(3);
2757                 //
2758                 //        public CC()
2759                 //        {}
2760                 //
2761                 //        private CC(int value)
2762                 //        {
2763                 //            value__ = value;
2764                 //        }
2765                 //
2766                 //        public void __ZeroInit__()
2767                 //        {
2768                 //            value__ = 0;
2769                 //        }
2770                 //
2771                 //        public void __RealCtor__()
2772                 //        {
2773                 //            value__ = 0;
2774                 //        }
2775                 //
2776                 //        public CC __Clone__()
2777                 //        {
2778                 //            return new CC(value__);
2779                 //        }
2780                 //
2781                 //        public int getValue()
2782                 //        {
2783                 //            return value__;
2784                 //        }
2785                 //
2786                 //        public void setValue(int value)
2787                 //        {
2788                 //            value__ = value;
2789                 //        }
2790                 //
2791                 //        public static CC getEnumForValue(int value)
2792                 //        {
2793                 //            switch(value)
2794                 //            {
2795                 //                case Err:     return _Err;
2796                 //                case Same:    return _Same;
2797                 //                case Narr:    return _Narr;
2798                 //                case Wide:    return _Wide;
2799                 //            }
2800                 //
2801                 //            throw new IllegalArgumentException("The value " + value + " is not" +
2802                 //                " valid for enumeration CC");
2803                 //        }
2804                 //
2805                 //        protected object GetValue()
2806                 //        {
2807                 //            return new system.ClrInt32(getValue());
2808                 //        }
2809                 //    }
2810         }
2811 }