Fennel: /home/pub/open/dev/fennel/calculator/InstructionRegisterSwitchCast.h Source File

00001 /*
00002 // $Id: //open/dev/fennel/calculator/InstructionRegisterSwitchCast.h#3 $
00003 // Fennel is a library of data storage and processing components.
00004 // Copyright (C) 2004-2009 The Eigenbase Project
00005 // Copyright (C) 2004-2009 SQLstream, Inc.
00006 // Copyright (C) 2009-2009 LucidEra, Inc.
00007 //
00008 // This program is free software; you can redistribute it and/or modify it
00009 // under the terms of the GNU General Public License as published by the Free
00010 // Software Foundation; either version 2 of the License, or (at your option)
00011 // any later version approved by The Eigenbase Project.
00012 //
00013 // This program is distributed in the hope that it will be useful,
00014 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00015 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016 // GNU General Public License for more details.
00017 //
00018 // You should have received a copy of the GNU General Public License
00019 // along with this program; if not, write to the Free Software
00020 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00021 */
00022 
00023 #if 0
00024 void dummy()
00025 {
00026 #endif
00027 
00028     if (type1 == STANDARD_TYPE_INT_8 && type2 == STANDARD_TYPE_INT_8) {
00029         InstructionRegister::registerInstance2<int8_t, int8_t, INSTCLASS2>(
00030             type1, type2);
00031     } else if (type1 == STANDARD_TYPE_INT_8 && type2 == STANDARD_TYPE_UINT_8) {
00032         InstructionRegister::registerInstance2<int8_t, uint8_t, INSTCLASS2>(
00033             type1, type2);
00034     } else if (type1 == STANDARD_TYPE_INT_8 && type2 == STANDARD_TYPE_INT_16) {
00035         InstructionRegister::registerInstance2<int8_t, int16_t, INSTCLASS2>(
00036             type1, type2);
00037     } else if (type1 == STANDARD_TYPE_INT_8 && type2 == STANDARD_TYPE_UINT_16) {
00038         InstructionRegister::registerInstance2<int8_t, uint16_t, INSTCLASS2>(
00039             type1, type2);
00040     } else if (type1 == STANDARD_TYPE_INT_8 && type2 == STANDARD_TYPE_INT_32) {
00041         InstructionRegister::registerInstance2<int8_t, int32_t, INSTCLASS2>(
00042             type1, type2);
00043     } else if (type1 == STANDARD_TYPE_INT_8 && type2 == STANDARD_TYPE_UINT_32) {
00044         InstructionRegister::registerInstance2<int8_t, uint32_t, INSTCLASS2>(
00045             type1, type2);
00046     } else if (type1 == STANDARD_TYPE_INT_8 && type2 == STANDARD_TYPE_INT_64) {
00047         InstructionRegister::registerInstance2<int8_t, int64_t, INSTCLASS2>(
00048             type1, type2);
00049     } else if (type1 == STANDARD_TYPE_INT_8 && type2 == STANDARD_TYPE_UINT_64) {
00050         InstructionRegister::registerInstance2<int8_t, uint64_t, INSTCLASS2>(
00051             type1, type2);
00052     } else if (type1 == STANDARD_TYPE_INT_8 && type2 == STANDARD_TYPE_REAL) {
00053         InstructionRegister::registerInstance2<int8_t, float, INSTCLASS2>(
00054             type1, type2);
00055     } else if (type1 == STANDARD_TYPE_INT_8 && type2 == STANDARD_TYPE_DOUBLE) {
00056         InstructionRegister::registerInstance2<int8_t, double, INSTCLASS2>(
00057             type1, type2);
00058     } else if (type1 == STANDARD_TYPE_UINT_8 && type2 == STANDARD_TYPE_INT_8) {
00059         InstructionRegister::registerInstance2<uint8_t, int8_t, INSTCLASS2>(
00060             type1, type2);
00061     } else if (type1 == STANDARD_TYPE_UINT_8 && type2 == STANDARD_TYPE_UINT_8) {
00062         InstructionRegister::registerInstance2<uint8_t, uint8_t, INSTCLASS2>(
00063             type1, type2);
00064     } else if (type1 == STANDARD_TYPE_UINT_8 && type2 == STANDARD_TYPE_INT_16) {
00065         InstructionRegister::registerInstance2<uint8_t, int16_t, INSTCLASS2>(
00066             type1, type2);
00067     } else if (type1 == STANDARD_TYPE_UINT_8
00068         && type2 == STANDARD_TYPE_UINT_16)
00069     {
00070         InstructionRegister::registerInstance2<uint8_t, uint16_t, INSTCLASS2>(
00071             type1, type2);
00072     } else if (type1 == STANDARD_TYPE_UINT_8 && type2 == STANDARD_TYPE_INT_32) {
00073         InstructionRegister::registerInstance2<uint8_t, int32_t, INSTCLASS2>(
00074             type1, type2);
00075     } else if (type1 == STANDARD_TYPE_UINT_8
00076         && type2 == STANDARD_TYPE_UINT_32)
00077     {
00078         InstructionRegister::registerInstance2<uint8_t, uint32_t, INSTCLASS2>(
00079             type1, type2);
00080     } else if (type1 == STANDARD_TYPE_UINT_8 && type2 == STANDARD_TYPE_INT_64) {
00081         InstructionRegister::registerInstance2<uint8_t, int64_t, INSTCLASS2>(
00082             type1, type2);
00083     } else if (type1 == STANDARD_TYPE_UINT_8
00084         && type2 == STANDARD_TYPE_UINT_64)
00085     {
00086         InstructionRegister::registerInstance2<uint8_t, uint64_t, INSTCLASS2>(
00087             type1, type2);
00088     } else if (type1 == STANDARD_TYPE_UINT_8 && type2 == STANDARD_TYPE_REAL) {
00089         InstructionRegister::registerInstance2<uint8_t, float, INSTCLASS2>(
00090             type1, type2);
00091     } else if (type1 == STANDARD_TYPE_UINT_8 && type2 == STANDARD_TYPE_DOUBLE) {
00092         InstructionRegister::registerInstance2<uint8_t, double, INSTCLASS2>(
00093             type1, type2);
00094     } else if (type1 == STANDARD_TYPE_INT_16 && type2 == STANDARD_TYPE_INT_8) {
00095         InstructionRegister::registerInstance2<int16_t, int8_t, INSTCLASS2>(
00096             type1, type2);
00097     } else if (type1 == STANDARD_TYPE_INT_16 && type2 == STANDARD_TYPE_UINT_8) {
00098         InstructionRegister::registerInstance2<int16_t, uint8_t, INSTCLASS2>(
00099             type1, type2);
00100     } else if (type1 == STANDARD_TYPE_INT_16 && type2 == STANDARD_TYPE_INT_16) {
00101         InstructionRegister::registerInstance2<int16_t, int16_t, INSTCLASS2>(
00102             type1, type2);
00103     } else if (type1 == STANDARD_TYPE_INT_16
00104         && type2 == STANDARD_TYPE_UINT_16)
00105     {
00106         InstructionRegister::registerInstance2<int16_t, uint16_t, INSTCLASS2>(
00107             type1, type2);
00108     } else if (type1 == STANDARD_TYPE_INT_16 && type2 == STANDARD_TYPE_INT_32) {
00109         InstructionRegister::registerInstance2<int16_t, int32_t, INSTCLASS2>(
00110             type1, type2);
00111     } else if (type1 == STANDARD_TYPE_INT_16
00112         && type2 == STANDARD_TYPE_UINT_32)
00113     {
00114         InstructionRegister::registerInstance2<int16_t, uint32_t, INSTCLASS2>(
00115             type1, type2);
00116     } else if (type1 == STANDARD_TYPE_INT_16 && type2 == STANDARD_TYPE_INT_64) {
00117         InstructionRegister::registerInstance2<int16_t, int64_t, INSTCLASS2>(
00118             type1, type2);
00119     } else if (type1 == STANDARD_TYPE_INT_16
00120         && type2 == STANDARD_TYPE_UINT_64)
00121     {
00122         InstructionRegister::registerInstance2<int16_t, uint64_t, INSTCLASS2>(
00123             type1, type2);
00124     } else if (type1 == STANDARD_TYPE_INT_16 && type2 == STANDARD_TYPE_REAL) {
00125         InstructionRegister::registerInstance2<int16_t, float, INSTCLASS2>(
00126             type1, type2);
00127     } else if (type1 == STANDARD_TYPE_INT_16 && type2 == STANDARD_TYPE_DOUBLE) {
00128         InstructionRegister::registerInstance2<int16_t, double, INSTCLASS2>(
00129             type1, type2);
00130     } else if (type1 == STANDARD_TYPE_UINT_16 && type2 == STANDARD_TYPE_INT_8) {
00131         InstructionRegister::registerInstance2<uint16_t, int8_t, INSTCLASS2>(
00132             type1, type2);
00133     } else if (type1 == STANDARD_TYPE_UINT_16
00134         && type2 == STANDARD_TYPE_UINT_8)
00135     {
00136         InstructionRegister::registerInstance2<uint16_t, uint8_t, INSTCLASS2>(
00137             type1, type2);
00138     } else if (type1 == STANDARD_TYPE_UINT_16
00139         && type2 == STANDARD_TYPE_INT_16)
00140     {
00141         InstructionRegister::registerInstance2<uint16_t, int16_t, INSTCLASS2>(
00142             type1, type2);
00143     } else if (type1 == STANDARD_TYPE_UINT_16
00144         && type2 == STANDARD_TYPE_UINT_16)
00145     {
00146         InstructionRegister::registerInstance2<uint16_t, uint16_t, INSTCLASS2>(
00147             type1, type2);
00148     } else if (type1 == STANDARD_TYPE_UINT_16
00149         && type2 == STANDARD_TYPE_INT_32)
00150     {
00151         InstructionRegister::registerInstance2<uint16_t, int32_t, INSTCLASS2>(
00152             type1, type2);
00153     } else if (type1 == STANDARD_TYPE_UINT_16
00154         && type2 == STANDARD_TYPE_UINT_32)
00155     {
00156         InstructionRegister::registerInstance2<uint16_t, uint32_t, INSTCLASS2>(
00157             type1, type2);
00158     } else if (type1 == STANDARD_TYPE_UINT_16
00159         && type2 == STANDARD_TYPE_INT_64)
00160     {
00161         InstructionRegister::registerInstance2<uint16_t, int64_t, INSTCLASS2>(
00162             type1, type2);
00163     } else if (type1 == STANDARD_TYPE_UINT_16
00164         && type2 == STANDARD_TYPE_UINT_64)
00165     {
00166         InstructionRegister::registerInstance2<uint16_t, uint64_t, INSTCLASS2>(
00167             type1, type2);
00168     } else if (type1 == STANDARD_TYPE_UINT_16 && type2 == STANDARD_TYPE_REAL) {
00169         InstructionRegister::registerInstance2<uint16_t, float, INSTCLASS2>(
00170             type1, type2);
00171     } else if (type1 == STANDARD_TYPE_UINT_16
00172         && type2 == STANDARD_TYPE_DOUBLE)
00173     {
00174         InstructionRegister::registerInstance2<uint16_t, double, INSTCLASS2>(
00175             type1, type2);
00176     } else if (type1 == STANDARD_TYPE_INT_32 && type2 == STANDARD_TYPE_INT_8) {
00177         InstructionRegister::registerInstance2<int32_t, int8_t, INSTCLASS2>(
00178             type1, type2);
00179     } else if (type1 == STANDARD_TYPE_INT_32 && type2 == STANDARD_TYPE_UINT_8) {
00180         InstructionRegister::registerInstance2<int32_t, uint8_t, INSTCLASS2>(
00181             type1, type2);
00182     } else if (type1 == STANDARD_TYPE_INT_32 && type2 == STANDARD_TYPE_INT_16) {
00183         InstructionRegister::registerInstance2<int32_t, int16_t, INSTCLASS2>(
00184             type1, type2);
00185     } else if (type1 == STANDARD_TYPE_INT_32
00186         && type2 == STANDARD_TYPE_UINT_16)
00187     {
00188         InstructionRegister::registerInstance2<int32_t, uint16_t, INSTCLASS2>(
00189             type1, type2);
00190     } else if (type1 == STANDARD_TYPE_INT_32 && type2 == STANDARD_TYPE_INT_32) {
00191         InstructionRegister::registerInstance2<int32_t, int32_t, INSTCLASS2>(
00192             type1, type2);
00193     } else if (type1 == STANDARD_TYPE_INT_32
00194         && type2 == STANDARD_TYPE_UINT_32)
00195     {
00196         InstructionRegister::registerInstance2<int32_t, uint32_t, INSTCLASS2>(
00197             type1, type2);
00198     } else if (type1 == STANDARD_TYPE_INT_32 && type2 == STANDARD_TYPE_INT_64) {
00199         InstructionRegister::registerInstance2<int32_t, int64_t, INSTCLASS2>(
00200             type1, type2);
00201     } else if (type1 == STANDARD_TYPE_INT_32
00202         && type2 == STANDARD_TYPE_UINT_64)
00203     {
00204         InstructionRegister::registerInstance2<int32_t, uint64_t, INSTCLASS2>(
00205             type1, type2);
00206     } else if (type1 == STANDARD_TYPE_INT_32 && type2 == STANDARD_TYPE_REAL) {
00207         InstructionRegister::registerInstance2<int32_t, float, INSTCLASS2>(
00208             type1, type2);
00209     } else if (type1 == STANDARD_TYPE_INT_32 && type2 == STANDARD_TYPE_DOUBLE) {
00210         InstructionRegister::registerInstance2<int32_t, double, INSTCLASS2>(
00211             type1, type2);
00212     } else if (type1 == STANDARD_TYPE_UINT_32 && type2 == STANDARD_TYPE_INT_8) {
00213         InstructionRegister::registerInstance2<uint32_t, int8_t, INSTCLASS2>(
00214             type1, type2);
00215     } else if (type1 == STANDARD_TYPE_UINT_32
00216         && type2 == STANDARD_TYPE_UINT_8)
00217     {
00218         InstructionRegister::registerInstance2<uint32_t, uint8_t, INSTCLASS2>(
00219             type1, type2);
00220     } else if (type1 == STANDARD_TYPE_UINT_32
00221         && type2 == STANDARD_TYPE_INT_16)
00222     {
00223         InstructionRegister::registerInstance2<uint32_t, int16_t, INSTCLASS2>(
00224             type1, type2);
00225     } else if (type1 == STANDARD_TYPE_UINT_32
00226         && type2 == STANDARD_TYPE_UINT_16)
00227     {
00228         InstructionRegister::registerInstance2<uint32_t, uint16_t, INSTCLASS2>(
00229             type1, type2);
00230     } else if (type1 == STANDARD_TYPE_UINT_32
00231         && type2 == STANDARD_TYPE_INT_32)
00232     {
00233         InstructionRegister::registerInstance2<uint32_t, int32_t, INSTCLASS2>(
00234             type1, type2);
00235     } else if (type1 == STANDARD_TYPE_UINT_32
00236         && type2 == STANDARD_TYPE_UINT_32)
00237     {
00238         InstructionRegister::registerInstance2<uint32_t, uint32_t, INSTCLASS2>(
00239             type1, type2);
00240     } else if (type1 == STANDARD_TYPE_UINT_32
00241         && type2 == STANDARD_TYPE_INT_64)
00242     {
00243         InstructionRegister::registerInstance2<uint32_t, int64_t, INSTCLASS2>(
00244             type1, type2);
00245     } else if (type1 == STANDARD_TYPE_UINT_32
00246         && type2 == STANDARD_TYPE_UINT_64)
00247     {
00248         InstructionRegister::registerInstance2<uint32_t, uint64_t, INSTCLASS2>(
00249             type1, type2);
00250     } else if (type1 == STANDARD_TYPE_UINT_32 && type2 == STANDARD_TYPE_REAL) {
00251         InstructionRegister::registerInstance2<uint32_t, float, INSTCLASS2>(
00252             type1, type2);
00253     } else if (type1 == STANDARD_TYPE_UINT_32
00254         && type2 == STANDARD_TYPE_DOUBLE)
00255     {
00256         InstructionRegister::registerInstance2<uint32_t, double, INSTCLASS2>(
00257             type1, type2);
00258     } else if (type1 == STANDARD_TYPE_INT_64 && type2 == STANDARD_TYPE_INT_8) {
00259         InstructionRegister::registerInstance2<int64_t, int8_t, INSTCLASS2>(
00260             type1, type2);
00261     } else if (type1 == STANDARD_TYPE_INT_64 && type2 == STANDARD_TYPE_UINT_8) {
00262         InstructionRegister::registerInstance2<int64_t, uint8_t, INSTCLASS2>(
00263             type1, type2);
00264     } else if (type1 == STANDARD_TYPE_INT_64 && type2 == STANDARD_TYPE_INT_16) {
00265         InstructionRegister::registerInstance2<int64_t, int16_t, INSTCLASS2>(
00266             type1, type2);
00267     } else if (type1 == STANDARD_TYPE_INT_64
00268         && type2 == STANDARD_TYPE_UINT_16)
00269     {
00270         InstructionRegister::registerInstance2<int64_t, uint16_t, INSTCLASS2>(
00271             type1, type2);
00272     } else if (type1 == STANDARD_TYPE_INT_64 && type2 == STANDARD_TYPE_INT_32) {
00273         InstructionRegister::registerInstance2<int64_t, int32_t, INSTCLASS2>(
00274             type1, type2);
00275     } else if (type1 == STANDARD_TYPE_INT_64
00276         && type2 == STANDARD_TYPE_UINT_32)
00277     {
00278         InstructionRegister::registerInstance2<int64_t, uint32_t, INSTCLASS2>(
00279             type1, type2);
00280     } else if (type1 == STANDARD_TYPE_INT_64 && type2 == STANDARD_TYPE_INT_64) {
00281         InstructionRegister::registerInstance2<int64_t, int64_t, INSTCLASS2>(
00282             type1, type2);
00283     } else if (type1 == STANDARD_TYPE_INT_64
00284         && type2 == STANDARD_TYPE_UINT_64)
00285     {
00286         InstructionRegister::registerInstance2<int64_t, uint64_t, INSTCLASS2>(
00287             type1, type2);
00288     } else if (type1 == STANDARD_TYPE_INT_64 && type2 == STANDARD_TYPE_REAL) {
00289         InstructionRegister::registerInstance2<int64_t, float, INSTCLASS2>(
00290             type1, type2);
00291     } else if (type1 == STANDARD_TYPE_INT_64 && type2 == STANDARD_TYPE_DOUBLE) {
00292         InstructionRegister::registerInstance2<int64_t, double, INSTCLASS2>(
00293             type1, type2);
00294     } else if (type1 == STANDARD_TYPE_UINT_64 && type2 == STANDARD_TYPE_INT_8) {
00295         InstructionRegister::registerInstance2<uint64_t, int8_t, INSTCLASS2>(
00296             type1, type2);
00297     } else if (type1 == STANDARD_TYPE_UINT_64
00298         && type2 == STANDARD_TYPE_UINT_8)
00299     {
00300         InstructionRegister::registerInstance2<uint64_t, uint8_t, INSTCLASS2>(
00301             type1, type2);
00302     } else if (type1 == STANDARD_TYPE_UINT_64
00303         && type2 == STANDARD_TYPE_INT_16)
00304     {
00305         InstructionRegister::registerInstance2<uint64_t, int16_t, INSTCLASS2>(
00306             type1, type2);
00307     } else if (type1 == STANDARD_TYPE_UINT_64
00308         && type2 == STANDARD_TYPE_UINT_16)
00309     {
00310         InstructionRegister::registerInstance2<uint64_t, uint16_t, INSTCLASS2>(
00311             type1, type2);
00312     } else if (type1 == STANDARD_TYPE_UINT_64
00313         && type2 == STANDARD_TYPE_INT_32)
00314     {
00315         InstructionRegister::registerInstance2<uint64_t, int32_t, INSTCLASS2>(
00316             type1, type2);
00317     } else if (type1 == STANDARD_TYPE_UINT_64
00318         && type2 == STANDARD_TYPE_UINT_32)
00319     {
00320         InstructionRegister::registerInstance2<uint64_t, uint32_t, INSTCLASS2>(
00321             type1, type2);
00322     } else if (type1 == STANDARD_TYPE_UINT_64
00323         && type2 == STANDARD_TYPE_INT_64)
00324     {
00325         InstructionRegister::registerInstance2<uint64_t, int64_t, INSTCLASS2>(
00326             type1, type2);
00327     } else if (type1 == STANDARD_TYPE_UINT_64
00328         && type2 == STANDARD_TYPE_UINT_64)
00329     {
00330         InstructionRegister::registerInstance2<uint64_t, uint64_t, INSTCLASS2>(
00331             type1, type2);
00332     } else if (type1 == STANDARD_TYPE_UINT_64 && type2 == STANDARD_TYPE_REAL) {
00333         InstructionRegister::registerInstance2<uint64_t, float, INSTCLASS2>(
00334             type1, type2);
00335     } else if (type1 == STANDARD_TYPE_UINT_64
00336         && type2 == STANDARD_TYPE_DOUBLE)
00337     {
00338         InstructionRegister::registerInstance2<uint64_t, double, INSTCLASS2>(
00339             type1, type2);
00340     } else if (type1 == STANDARD_TYPE_REAL && type2 == STANDARD_TYPE_INT_8) {
00341         InstructionRegister::registerInstance2<float, int8_t, INSTCLASS2>(
00342             type1, type2);
00343     } else if (type1 == STANDARD_TYPE_REAL && type2 == STANDARD_TYPE_UINT_8) {
00344         InstructionRegister::registerInstance2<float, uint8_t, INSTCLASS2>(
00345             type1, type2);
00346     } else if (type1 == STANDARD_TYPE_REAL && type2 == STANDARD_TYPE_INT_16) {
00347         InstructionRegister::registerInstance2<float, int16_t, INSTCLASS2>(
00348             type1, type2);
00349     } else if (type1 == STANDARD_TYPE_REAL && type2 == STANDARD_TYPE_UINT_16) {
00350         InstructionRegister::registerInstance2<float, uint16_t, INSTCLASS2>(
00351             type1, type2);
00352     } else if (type1 == STANDARD_TYPE_REAL && type2 == STANDARD_TYPE_INT_32) {
00353         InstructionRegister::registerInstance2<float, int32_t, INSTCLASS2>(
00354             type1, type2);
00355     } else if (type1 == STANDARD_TYPE_REAL && type2 == STANDARD_TYPE_UINT_32) {
00356         InstructionRegister::registerInstance2<float, uint32_t, INSTCLASS2>(
00357             type1, type2);
00358     } else if (type1 == STANDARD_TYPE_REAL && type2 == STANDARD_TYPE_INT_64) {
00359         InstructionRegister::registerInstance2<float, int64_t, INSTCLASS2>(
00360             type1, type2);
00361     } else if (type1 == STANDARD_TYPE_REAL && type2 == STANDARD_TYPE_UINT_64) {
00362         InstructionRegister::registerInstance2<float, uint64_t, INSTCLASS2>(
00363             type1, type2);
00364     } else if (type1 == STANDARD_TYPE_REAL && type2 == STANDARD_TYPE_REAL) {
00365         InstructionRegister::registerInstance2<float, float, INSTCLASS2>(
00366             type1, type2);
00367     } else if (type1 == STANDARD_TYPE_REAL && type2 == STANDARD_TYPE_DOUBLE) {
00368         InstructionRegister::registerInstance2<float, double, INSTCLASS2>(
00369             type1, type2);
00370     } else if (type1 == STANDARD_TYPE_DOUBLE && type2 == STANDARD_TYPE_INT_8) {
00371         InstructionRegister::registerInstance2<double, int8_t, INSTCLASS2>(
00372             type1, type2);
00373     } else if (type1 == STANDARD_TYPE_DOUBLE && type2 == STANDARD_TYPE_UINT_8) {
00374         InstructionRegister::registerInstance2<double, uint8_t, INSTCLASS2>(
00375             type1, type2);
00376     } else if (type1 == STANDARD_TYPE_DOUBLE && type2 == STANDARD_TYPE_INT_16) {
00377         InstructionRegister::registerInstance2<double, int16_t, INSTCLASS2>(
00378             type1, type2);
00379     } else if (type1 == STANDARD_TYPE_DOUBLE
00380         && type2 == STANDARD_TYPE_UINT_16)
00381     {
00382         InstructionRegister::registerInstance2<double, uint16_t, INSTCLASS2>(
00383             type1, type2);
00384     } else if (type1 == STANDARD_TYPE_DOUBLE && type2 == STANDARD_TYPE_INT_32) {
00385         InstructionRegister::registerInstance2<double, int32_t, INSTCLASS2>(
00386             type1, type2);
00387     } else if (type1 == STANDARD_TYPE_DOUBLE
00388         && type2 == STANDARD_TYPE_UINT_32)
00389     {
00390         InstructionRegister::registerInstance2<double, uint32_t, INSTCLASS2>(
00391             type1, type2);
00392     } else if (type1 == STANDARD_TYPE_DOUBLE && type2 == STANDARD_TYPE_INT_64) {
00393         InstructionRegister::registerInstance2<double, int64_t, INSTCLASS2>(
00394             type1, type2);
00395     } else if (type1 == STANDARD_TYPE_DOUBLE
00396         && type2 == STANDARD_TYPE_UINT_64)
00397     {
00398         InstructionRegister::registerInstance2<double, uint64_t, INSTCLASS2>(
00399             type1, type2);
00400     } else if (type1 == STANDARD_TYPE_DOUBLE && type2 == STANDARD_TYPE_REAL) {
00401         InstructionRegister::registerInstance2<double, float, INSTCLASS2>(
00402             type1, type2);
00403     } else if (type1 == STANDARD_TYPE_DOUBLE && type2 == STANDARD_TYPE_DOUBLE) {
00404         InstructionRegister::registerInstance2<double, double, INSTCLASS2>(
00405             type1, type2);
00406     } else {
00407         throw std::logic_error("InstructionRegisterSwitchCast.h");
00408     }
00409 
00410 #if 0
00411 }
00412 #endif
00413 
00414 // End InstructionRegisterSwitchCast.h