Changeset 1082b9 in git


Ignore:
Timestamp:
Jan 19, 2017, 2:57:38 PM (6 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '5bec8f88c9ee2573d328cf7c3aff2bcb301d2395')
Children:
b08fbfc7220b87075c808c15b35900abd6636899
Parents:
0091f520ce1d05c31263015fbc74956dd9b73454
Message:
use of gfan::initializeCddlibIfRequired in polymake_wrapper
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • Singular/dyn_modules/polymake/polymake_wrapper.cc

    r0091f5 r1082b9  
    2727      if (i2->Typ()==polytopeID || i2->Typ()==coneID)
    2828      {
     29        gfan::initializeCddlibIfRequired();
    2930        gfan::ZCone* zq = (gfan::ZCone*) i2->Data();
    3031        gfan::ZCone* ms;
     
    4142        catch (const std::exception& ex)
    4243        {
     44          gfan::deinitializeCddlibIfRequired();
    4345          WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    4446          return TRUE;
    4547        }
     48        gfan::deinitializeCddlibIfRequired();
    4649        res->rtyp = polytopeID;
    4750        res->data = (void*) ms;
     
    5457      if (i2->Typ()==INT_CMD)
    5558      {
     59        gfan::initializeCddlibIfRequired();
    5660        int s = (int)(long) i2->Data();
    5761        gfan::ZMatrix zm = zp->extremeRays();
     
    6165        gfan::ZCone* zs = new gfan::ZCone();
    6266        *zs = gfan::ZCone::givenByRays(zm,gfan::ZMatrix(0, zm.getWidth()));
     67        gfan::deinitializeCddlibIfRequired();
    6368        res->rtyp = polytopeID;
    6469        res->data = (void*) zs;
     
    7176      if (i2->Typ()==polytopeID)
    7277      {
     78        gfan::initializeCddlibIfRequired();
    7379        gfan::ZCone* zq = (gfan::ZCone*) i2->Data();
    7480        int d1 = zp->ambientDimension();
     
    7682        if (d1 != d2)
    7783        {
     84          gfan::deinitializeCddlibIfRequired();
    7885          WerrorS("mismatching ambient dimensions");
    7986          return TRUE;
     
    8289        *zs = gfan::intersection(*zp, *zq);
    8390        zs->canonicalize();
     91        gfan::deinitializeCddlibIfRequired();
    8492        res->rtyp = polytopeID;
    8593        res->data = (void*) zs;
     
    92100      if(i2->Typ()==polytopeID)
    93101      {
     102        gfan::initializeCddlibIfRequired();
    94103        gfan::ZCone* zq = (gfan::ZCone*) i2->Data();
    95104        int d1 = zp->ambientDimension();
     
    97106        if (d1 != d2)
    98107        {
     108          gfan::deinitializeCddlibIfRequired();
    99109          WerrorS("mismatching ambient dimensions");
    100110          return TRUE;
     
    107117        *zs = gfan::ZCone::givenByRays(rays,lineality);
    108118        zs->canonicalize();
     119        gfan::deinitializeCddlibIfRequired();
    109120        res->rtyp = polytopeID;
    110121        res->data = (void*) zs;
     
    117128      if(i2->Typ()==polytopeID)
    118129      {
     130        gfan::initializeCddlibIfRequired();
    119131        gfan::ZCone* zq = (gfan::ZCone*) i2->Data();
    120132        zp->canonicalize();
    121133        zq->canonicalize();
    122134        bool b = !((*zp)!=(*zq));
     135        gfan::deinitializeCddlibIfRequired();
    123136        res->rtyp = INT_CMD;
    124137        res->data = (char*) (long) b;
     
    203216  if ((u != NULL) && (u->Typ() == polytopeID))
    204217  {
     218    gfan::initializeCddlibIfRequired();
    205219    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    206220    bool b;
     
    213227    catch (const std::exception& ex)
    214228    {
    215       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    216       return TRUE;
    217     }
     229      gfan::deinitializeCddlibIfRequired();
     230      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     231      return TRUE;
     232    }
     233    gfan::deinitializeCddlibIfRequired();
    218234    res->rtyp = INT_CMD;
    219235    res->data = (char*) (long) b;
     
    230246  if ((u != NULL) && (u->Typ() == polytopeID))
    231247  {
     248    gfan::initializeCddlibIfRequired();
    232249    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    233250    bool b;
     
    240257    catch (const std::exception& ex)
    241258    {
    242       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    243       return TRUE;
    244     }
     259      gfan::deinitializeCddlibIfRequired();
     260      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     261      return TRUE;
     262    }
     263    gfan::deinitializeCddlibIfRequired();
    245264    res->rtyp = INT_CMD;
    246265    res->data = (char*) (long) b;
     
    257276  if ((u != NULL) && (u->Typ() == polytopeID))
    258277  {
     278    gfan::initializeCddlibIfRequired();
    259279    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    260280    bool b;
     
    267287    catch (const std::exception& ex)
    268288    {
    269       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    270       return TRUE;
    271     }
     289      gfan::deinitializeCddlibIfRequired();
     290      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     291      return TRUE;
     292    }
     293    gfan::deinitializeCddlibIfRequired();
    272294    res->rtyp = INT_CMD;
    273295    res->data = (char*) (long) b;
     
    284306  if ((u != NULL) && (u->Typ() == polytopeID))
    285307  {
     308    gfan::initializeCddlibIfRequired();
    286309    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    287310    bool b;
     
    294317    catch (const std::exception& ex)
    295318    {
    296       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    297       return TRUE;
    298     }
     319      gfan::deinitializeCddlibIfRequired();
     320      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     321      return TRUE;
     322    }
     323    gfan::deinitializeCddlibIfRequired();
    299324    res->rtyp = INT_CMD;
    300325    res->data = (char*) (long) b;
     
    311336  if ((u != NULL) && (u->Typ() == polytopeID))
    312337  {
     338    gfan::initializeCddlibIfRequired();
    313339    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    314340    int gi;
     
    327353      {
    328354        delete p;
     355        gfan::deinitializeCddlibIfRequired();
    329356        WerrorS("gorensteinIndex: input polytope not gorenstein");
    330357        return TRUE;
     
    333360    catch (const std::exception& ex)
    334361    {
    335       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    336       return TRUE;
    337     }
     362      gfan::deinitializeCddlibIfRequired();
     363      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     364      return TRUE;
     365    }
     366    gfan::deinitializeCddlibIfRequired();
    338367    if (!ok)
    339368    {
     
    355384  if ((u != NULL) && (u->Typ() == polytopeID))
    356385  {
     386    gfan::initializeCddlibIfRequired();
    357387    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    358388    intvec* gv;
     
    371401      {
    372402        delete p;
     403        gfan::deinitializeCddlibIfRequired();
    373404        WerrorS("gorensteinVector: input polytope not gorenstein");
    374405        return TRUE;
     
    377408    catch (const std::exception& ex)
    378409    {
    379       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    380       return TRUE;
    381     }
     410      gfan::deinitializeCddlibIfRequired();
     411      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     412      return TRUE;
     413    }
     414    gfan::deinitializeCddlibIfRequired();
    382415    if (!ok)
    383416    {
     
    399432  if ((u != NULL) && (u->Typ() == polytopeID))
    400433  {
     434    gfan::initializeCddlibIfRequired();
    401435    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    402436    bool b;
     
    409443    catch (const std::exception& ex)
    410444    {
    411       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    412       return TRUE;
    413     }
     445      gfan::deinitializeCddlibIfRequired();
     446      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     447      return TRUE;
     448    }
     449    gfan::deinitializeCddlibIfRequired();
    414450    res->rtyp = INT_CMD;
    415451    res->data = (char*) (long) b;
     
    426462  if ((u != NULL) && (u->Typ() == polytopeID))
    427463  {
     464    gfan::initializeCddlibIfRequired();
    428465    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    429466    bool b;
     
    436473    catch (const std::exception& ex)
    437474    {
    438       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    439       return TRUE;
    440     }
     475      gfan::deinitializeCddlibIfRequired();
     476      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     477      return TRUE;
     478    }
     479    gfan::deinitializeCddlibIfRequired();
    441480    res->rtyp = INT_CMD;
    442481    res->data = (char*) (long) b;
     
    453492  if ((u != NULL) && (u->Typ() == polytopeID))
    454493  {
     494    gfan::initializeCddlibIfRequired();
    455495    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    456496    bool b;
     
    463503    catch (const std::exception& ex)
    464504    {
    465       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    466       return TRUE;
    467     }
     505      gfan::deinitializeCddlibIfRequired();
     506      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     507      return TRUE;
     508    }
     509    gfan::deinitializeCddlibIfRequired();
    468510    res->rtyp = INT_CMD;
    469511    res->data = (char*) (long) b;
     
    480522  if ((u != NULL) && (u->Typ() == polytopeID))
    481523  {
     524    gfan::initializeCddlibIfRequired();
    482525    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    483526    int lv;
     
    492535    catch (const std::exception& ex)
    493536    {
    494       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    495       return TRUE;
    496     }
     537      gfan::deinitializeCddlibIfRequired();
     538      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     539      return TRUE;
     540    }
     541    gfan::deinitializeCddlibIfRequired();
    497542    if (!ok)
    498543    {
     
    514559  if ((u != NULL) && (u->Typ() == polytopeID))
    515560  {
     561    gfan::initializeCddlibIfRequired();
    516562    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    517563    int ld;
     
    526572    catch (const std::exception& ex)
    527573    {
    528       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    529       return TRUE;
    530     }
     574      gfan::deinitializeCddlibIfRequired();
     575      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     576      return TRUE;
     577    }
     578    gfan::deinitializeCddlibIfRequired();
    531579    if (!ok)
    532580    {
     
    548596  if ((u != NULL) && (u->Typ() == polytopeID))
    549597  {
     598    gfan::initializeCddlibIfRequired();
    550599    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    551600    int lc;
     
    560609    catch (const std::exception& ex)
    561610    {
    562       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    563       return TRUE;
    564     }
     611      gfan::deinitializeCddlibIfRequired();
     612      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     613      return TRUE;
     614    }
     615    gfan::deinitializeCddlibIfRequired();
    565616    if (!ok)
    566617    {
     
    582633  if ((u != NULL) && (u->Typ() == polytopeID))
    583634  {
     635    gfan::initializeCddlibIfRequired();
    584636    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    585637    intvec* ec;
     
    594646    catch (const std::exception& ex)
    595647    {
    596       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    597       return TRUE;
    598     }
     648      gfan::deinitializeCddlibIfRequired();
     649      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     650      return TRUE;
     651    }
     652    gfan::deinitializeCddlibIfRequired();
    599653    if (!ok)
    600654    {
     
    616670  if ((u != NULL) && (u->Typ() == polytopeID))
    617671  {
     672    gfan::initializeCddlibIfRequired();
    618673    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    619674    intvec* hv;
     
    628683    catch (const std::exception& ex)
    629684    {
    630       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    631       return TRUE;
    632     }
     685      gfan::deinitializeCddlibIfRequired();
     686      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     687      return TRUE;
     688    }
     689    gfan::deinitializeCddlibIfRequired();
    633690    if (!ok)
    634691    {
     
    650707  if ((u != NULL) && (u->Typ() == polytopeID))
    651708  {
     709    gfan::initializeCddlibIfRequired();
    652710    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    653711    intvec* hv;
     
    662720    catch (const std::exception& ex)
    663721    {
    664       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    665       return TRUE;
    666     }
     722      gfan::deinitializeCddlibIfRequired();
     723      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     724      return TRUE;
     725    }
     726    gfan::deinitializeCddlibIfRequired();
    667727    if (!ok)
    668728    {
     
    684744  if ((u != NULL) && (u->Typ() == polytopeID))
    685745  {
     746    gfan::initializeCddlibIfRequired();
    686747    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    687748    intvec* hv;
     
    696757    catch (const std::exception& ex)
    697758    {
    698       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    699       return TRUE;
    700     }
     759      gfan::deinitializeCddlibIfRequired();
     760      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     761      return TRUE;
     762    }
     763    gfan::deinitializeCddlibIfRequired();
    701764    if (!ok)
    702765    {
     
    718781  if ((u != NULL) && (u->Typ() == polytopeID))
    719782  {
     783    gfan::initializeCddlibIfRequired();
    720784    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    721785    bool b;
     
    728792    catch (const std::exception& ex)
    729793    {
    730       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    731       return TRUE;
    732     }
     794      gfan::deinitializeCddlibIfRequired();
     795      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     796      return TRUE;
     797    }
     798    gfan::deinitializeCddlibIfRequired();
    733799    res->rtyp = INT_CMD;
    734800    res->data = (char*) (long) b;
     
    745811  if ((u != NULL) && (u->Typ() == polytopeID))
    746812  {
     813    gfan::initializeCddlibIfRequired();
    747814    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    748815    intvec* fw;
     
    757824    catch (const std::exception& ex)
    758825    {
    759       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    760       return TRUE;
    761     }
     826      gfan::deinitializeCddlibIfRequired();
     827      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     828      return TRUE;
     829    }
     830    gfan::deinitializeCddlibIfRequired();
    762831    if (!ok)
    763832    {
     
    779848  if ((u != NULL) && (u->Typ() == polytopeID))
    780849  {
     850    gfan::initializeCddlibIfRequired();
    781851    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    782852    int fw;
     
    791861    catch (const std::exception& ex)
    792862    {
    793       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    794       return TRUE;
    795     }
     863      gfan::deinitializeCddlibIfRequired();
     864      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     865      return TRUE;
     866    }
     867    gfan::deinitializeCddlibIfRequired();
    796868    if (!ok)
    797869    {
     
    813885  if ((u != NULL) && (u->Typ() == polytopeID))
    814886  {
     887    gfan::initializeCddlibIfRequired();
    815888    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    816889    intvec* ld;
     
    825898    catch (const std::exception& ex)
    826899    {
    827       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    828       return TRUE;
    829     }
     900      gfan::deinitializeCddlibIfRequired();
     901      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     902      return TRUE;
     903    }
     904    gfan::deinitializeCddlibIfRequired();
    830905    if (!ok)
    831906    {
     
    847922  if ((u != NULL) && (u->Typ() == polytopeID))
    848923  {
     924    gfan::initializeCddlibIfRequired();
    849925    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    850926    bool b;
     
    857933    catch (const std::exception& ex)
    858934    {
    859       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    860       return TRUE;
    861     }
     935      gfan::deinitializeCddlibIfRequired();
     936      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     937      return TRUE;
     938    }
     939    gfan::deinitializeCddlibIfRequired();
    862940    res->rtyp = INT_CMD;
    863941    res->data = (char*) (long) b;
     
    874952  if ((u != NULL) && (u->Typ() == coneID))
    875953  {
     954    gfan::initializeCddlibIfRequired();
    876955    gfan::ZCone* zc = (gfan::ZCone*)u->Data();
    877956    bool b;
     
    884963    catch (const std::exception& ex)
    885964    {
    886       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    887       return TRUE;
    888     }
     965      gfan::deinitializeCddlibIfRequired();
     966      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     967      return TRUE;
     968    }
     969    gfan::deinitializeCddlibIfRequired();
    889970    res->rtyp = INT_CMD;
    890971    res->data = (char*) (long) b;
     
    893974  if ((u != NULL) && (u->Typ() == polytopeID))
    894975  {
     976    gfan::initializeCddlibIfRequired();
    895977    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    896978    bool b;
     
    903985    catch (const std::exception& ex)
    904986    {
    905       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    906       return TRUE;
    907     }
     987      gfan::deinitializeCddlibIfRequired();
     988      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     989      return TRUE;
     990    }
     991    gfan::deinitializeCddlibIfRequired();
    908992    res->rtyp = INT_CMD;
    909993    res->data = (char*) (long) b;
     
    912996  if ((u != NULL) && (u->Typ() == fanID))
    913997  {
     998    gfan::initializeCddlibIfRequired();
    914999    gfan::ZFan* zf = (gfan::ZFan*)u->Data();
    9151000    bool b;
     
    9221007    catch (const std::exception& ex)
    9231008    {
    924       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    925       return TRUE;
    926     }
     1009      gfan::deinitializeCddlibIfRequired();
     1010      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1011      return TRUE;
     1012    }
     1013    gfan::deinitializeCddlibIfRequired();
    9271014    res->rtyp = INT_CMD;
    9281015    res->data = (char*) (long) b;
     
    9391026  if ((u != NULL) && (u->Typ() == polytopeID))
    9401027  {
     1028    gfan::initializeCddlibIfRequired();
    9411029    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    9421030    bool b;
     
    9491037    catch (const std::exception& ex)
    9501038    {
    951       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    952       return TRUE;
    953     }
     1039      gfan::deinitializeCddlibIfRequired();
     1040      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1041      return TRUE;
     1042    }
     1043    gfan::deinitializeCddlibIfRequired();
    9541044    res->rtyp = INT_CMD;
    9551045    res->data = (char*) (long) b;
     
    9661056  if ((u != NULL) && (u->Typ() == polytopeID))
    9671057  {
     1058    gfan::initializeCddlibIfRequired();
    9681059    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    9691060    intvec* iv;
     
    9841075    catch (const std::exception& ex)
    9851076    {
    986       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    987       return TRUE;
    988     }
     1077      gfan::deinitializeCddlibIfRequired();
     1078      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1079      return TRUE;
     1080    }
     1081    gfan::deinitializeCddlibIfRequired();
    9891082    if (!ok)
    9901083    {
     
    10061099  if ((u != NULL) && (u->Typ() == polytopeID))
    10071100  {
     1101    gfan::initializeCddlibIfRequired();
    10081102    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    10091103    int n;
     
    10181112    catch (const std::exception& ex)
    10191113    {
    1020       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1021       return TRUE;
    1022     }
     1114      gfan::deinitializeCddlibIfRequired();
     1115      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1116      return TRUE;
     1117    }
     1118    gfan::deinitializeCddlibIfRequired();
    10231119    if (!ok)
    10241120    {
     
    10401136  if ((u != NULL) && (u->Typ() == polytopeID))
    10411137  {
     1138    gfan::initializeCddlibIfRequired();
    10421139    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    10431140    intvec* iv;
     
    10521149    catch (const std::exception& ex)
    10531150    {
    1054       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1055       return TRUE;
    1056     }
     1151      gfan::deinitializeCddlibIfRequired();
     1152      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1153      return TRUE;
     1154    }
     1155    gfan::deinitializeCddlibIfRequired();
    10571156    if (!ok)
    10581157    {
     
    10741173  if ((u != NULL) && (u->Typ() == polytopeID))
    10751174  {
     1175    gfan::initializeCddlibIfRequired();
    10761176    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    10771177    int n;
     
    10861186    catch (const std::exception& ex)
    10871187    {
    1088       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1089       return TRUE;
    1090     }
     1188      gfan::deinitializeCddlibIfRequired();
     1189      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1190      return TRUE;
     1191    }
     1192    gfan::deinitializeCddlibIfRequired();
    10911193    if (!ok)
    10921194    {
     
    11081210  if ((u != NULL) && (u->Typ() == polytopeID))
    11091211  {
     1212    gfan::initializeCddlibIfRequired();
    11101213    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    11111214    intvec* iv;
     
    11201223    catch (const std::exception& ex)
    11211224    {
    1122       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1123       return TRUE;
    1124     }
     1225      gfan::deinitializeCddlibIfRequired();
     1226      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1227      return TRUE;
     1228    }
     1229    gfan::deinitializeCddlibIfRequired();
    11251230    if (!ok)
    11261231    {
     
    11421247  if ((u != NULL) && (u->Typ() == polytopeID))
    11431248  {
     1249    gfan::initializeCddlibIfRequired();
    11441250    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    11451251    int n;
     
    11541260    catch (const std::exception& ex)
    11551261    {
    1156       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1157       return TRUE;
    1158     }
     1262      gfan::deinitializeCddlibIfRequired();
     1263      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1264      return TRUE;
     1265    }
     1266    gfan::deinitializeCddlibIfRequired();
    11591267    if (!ok)
    11601268    {
     
    11761284  if ((u != NULL) && (u->Typ() == coneID))
    11771285  {
     1286    gfan::initializeCddlibIfRequired();
    11781287    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    11791288    intvec* iv;
     
    11941303    catch (const std::exception& ex)
    11951304    {
    1196       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1197       return TRUE;
    1198     }
     1305      gfan::deinitializeCddlibIfRequired();
     1306      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1307      return TRUE;
     1308    }
     1309    gfan::deinitializeCddlibIfRequired();
    11991310    if (!ok)
    12001311    {
     
    12161327  if ((u != NULL) && (u->Typ() == coneID))
    12171328  {
     1329    gfan::initializeCddlibIfRequired();
    12181330    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    12191331    int n;
     
    12281340    catch (const std::exception& ex)
    12291341    {
    1230       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1231       return TRUE;
    1232     }
     1342      gfan::deinitializeCddlibIfRequired();
     1343      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1344      return TRUE;
     1345    }
     1346    gfan::deinitializeCddlibIfRequired();
    12331347    if (!ok)
    12341348    {
     
    12531367    if ((v != NULL) && (v->Typ() == polytopeID))
    12541368    {
     1369      gfan::initializeCddlibIfRequired();
    12551370      gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    12561371      gfan::ZCone* zq = (gfan::ZCone*)v->Data();
     
    12681383      catch (const std::exception& ex)
    12691384      {
     1385        gfan::deinitializeCddlibIfRequired();
    12701386        WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    12711387        return TRUE;
    12721388      }
     1389      gfan::deinitializeCddlibIfRequired();
    12731390      res->rtyp = polytopeID;
    12741391      res->data = (char*) ms;
     
    12771394    if ((v != NULL) && (v->Typ() == coneID))
    12781395    {
     1396      gfan::initializeCddlibIfRequired();
    12791397      gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    12801398      gfan::ZCone* zc = (gfan::ZCone*)v->Data();
     
    12931411      catch (const std::exception& ex)
    12941412      {
     1413        delete zq;
     1414        gfan::deinitializeCddlibIfRequired();
    12951415        WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1296         delete zq;
    12971416        return TRUE;
    12981417      }
     1418      delete zq;
     1419      gfan::deinitializeCddlibIfRequired();
    12991420      res->rtyp = polytopeID;
    13001421      res->data = (char*) ms;
    1301       delete zq;
    13021422      return FALSE;
    13031423    }
     
    13081428    if ((v != NULL) && (v->Typ() == polytopeID))
    13091429    {
     1430      gfan::initializeCddlibIfRequired();
    13101431      gfan::ZCone* zc = (gfan::ZCone*)u->Data();
    13111432      gfan::ZCone* zp = new gfan::ZCone(liftUp(*zc));
     
    13241445      catch (const std::exception& ex)
    13251446      {
     1447        delete zp;
     1448        gfan::deinitializeCddlibIfRequired();
    13261449        WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1327         delete zp;
    13281450        return TRUE;
    13291451      }
     1452      delete zp;
     1453      gfan::deinitializeCddlibIfRequired();
    13301454      res->rtyp = polytopeID;
    13311455      res->data = (char*) ms;
    1332       delete zp;
    13331456      return FALSE;
    13341457    }
    13351458    if ((v != NULL) && (v->Typ() == coneID))
    13361459    {
     1460      gfan::initializeCddlibIfRequired();
    13371461      gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    13381462      gfan::ZCone* zq = (gfan::ZCone*)v->Data();
     
    13511475      {
    13521476        WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1477        gfan::deinitializeCddlibIfRequired();
    13531478        return TRUE;
    13541479      }
     1480      gfan::deinitializeCddlibIfRequired();
    13551481      res->rtyp = coneID;
    13561482      res->data = (char*) ms;
     
    13891515    if ((v != NULL) && (v->Typ() == INTVEC_CMD))
    13901516    {
     1517      gfan::initializeCddlibIfRequired();
    13911518      gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    13921519      intvec* iv = (intvec*) v->Data();
     
    14071534      {
    14081535        WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1536        gfan::deinitializeCddlibIfRequired();
    14091537        return TRUE;
    14101538      }
     1539      gfan::deinitializeCddlibIfRequired();
    14111540      if (!ok)
    14121541      {
     
    14321561    if ((v != NULL) && (v->Typ() == INTVEC_CMD))
    14331562    {
     1563      gfan::initializeCddlibIfRequired();
    14341564      gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    14351565      intvec* iv = (intvec*) v->Data();
     
    14501580      {
    14511581        WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1582        gfan::deinitializeCddlibIfRequired();
    14521583        return TRUE;
    14531584      }
     1585      gfan::deinitializeCddlibIfRequired();
    14541586      if (!ok)
    14551587      {
     
    14751607    if ((v != NULL) && (v->Typ() == INTVEC_CMD))
    14761608    {
     1609      gfan::initializeCddlibIfRequired();
    14771610      gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    14781611      intvec* iv = (intvec*) v->Data();
     
    14951628        {
    14961629          WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1630          gfan::deinitializeCddlibIfRequired();
    14971631          return TRUE;
    14981632        }
     1633        gfan::deinitializeCddlibIfRequired();
    14991634        if (!ok)
    15001635        {
     
    15221657    if ((v != NULL) && (v->Typ() == INTVEC_CMD))
    15231658    {
     1659      gfan::initializeCddlibIfRequired();
    15241660      gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    15251661      intvec* iv = (intvec*) v->Data();
     
    15421678        {
    15431679          WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1680          gfan::deinitializeCddlibIfRequired();
    15441681          return TRUE;
    15451682        }
     1683        gfan::deinitializeCddlibIfRequired();
    15461684        if (!ok)
    15471685        {
     
    15671705  if ((u != NULL) && (u->Typ() == polytopeID))
    15681706  {
     1707    gfan::initializeCddlibIfRequired();
    15691708    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    15701709    try
     
    15771716    {
    15781717      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1579       return TRUE;
    1580     }
     1718      gfan::deinitializeCddlibIfRequired();
     1719      return TRUE;
     1720    }
     1721    gfan::deinitializeCddlibIfRequired();
    15811722    res->rtyp = NONE;
    15821723    res->data = NULL;
     
    15851726  if ((u != NULL) && (u->Typ() == fanID))
    15861727  {
     1728    gfan::initializeCddlibIfRequired();
    15871729    gfan::ZFan* zf = (gfan::ZFan*)u->Data();
    15881730    try
     
    15931735    catch (const std::exception& ex)
    15941736    {
    1595       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1596       return TRUE;
    1597     }
     1737      gfan::deinitializeCddlibIfRequired();
     1738      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1739      return TRUE;
     1740    }
     1741    gfan::deinitializeCddlibIfRequired();
    15981742    res->rtyp = NONE;
    15991743    res->data = NULL;
     
    16091753  if ((u != NULL) && (u->Typ() == polytopeID))
    16101754  {
     1755    gfan::initializeCddlibIfRequired();
    16111756    gfan::ZCone* zp = (gfan::ZCone*)u->Data();
    16121757    gfan::ZFan* zf = new gfan::ZFan(0);
     
    16211766    catch (const std::exception& ex)
    16221767    {
    1623       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1624       return TRUE;
    1625     }
     1768      gfan::deinitializeCddlibIfRequired();
     1769      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1770      return TRUE;
     1771    }
     1772    gfan::deinitializeCddlibIfRequired();
    16261773    res->rtyp = fanID;
    16271774    res->data = (char*) zf;
     
    16371784  if ((u != NULL) && (u->Typ() == INTMAT_CMD))
    16381785  {
     1786    gfan::initializeCddlibIfRequired();
    16391787    polymake::perl::Object pc("Cone<Rational>");
    16401788    intvec* hlines = (intvec*) u->Data(); // these will are half lines in the cone
     
    16571805    }
    16581806    gfan::ZCone* zc = PmCone2ZCone(&pc);
     1807    gfan::deinitializeCddlibIfRequired();
    16591808    res->rtyp = coneID;
    16601809    res->data = (char*) zc;
     
    16711820  if ((u != NULL) && (u->Typ() == INTMAT_CMD))
    16721821  {
     1822    gfan::initializeCddlibIfRequired();
    16731823    polymake::perl::Object pp("Polytope<Rational>");
    16741824    intvec* points = (intvec*) u->Data(); // these will be vertices of or points in the polytope
     
    16901840
    16911841    gfan::ZCone* zp = PmPolytope2ZPolytope(&pp);
     1842    gfan::deinitializeCddlibIfRequired();
    16921843    res->rtyp = polytopeID;
    16931844    res->data = (char*) zp;
     
    17041855  if ((u != NULL) && (u->Typ() == polytopeID))
    17051856  {
     1857    gfan::initializeCddlibIfRequired();
    17061858    gfan::ZCone* zp = (gfan::ZCone*) u->Data();
    17071859    lists output=(lists)omAllocBin(slists_bin); output->Init(2);
     
    17231875    catch (const std::exception& ex)
    17241876    {
    1725       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1726       return TRUE;
    1727     }
     1877      gfan::deinitializeCddlibIfRequired();
     1878      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1879      return TRUE;
     1880    }
     1881    gfan::deinitializeCddlibIfRequired();
    17281882    res->rtyp = LIST_CMD;
    17291883    res->data = (void*) output;
     
    17401894  if ((u != NULL) && (u->Typ() == polytopeID))
    17411895  {
     1896    gfan::initializeCddlibIfRequired();
    17421897    gfan::ZCone* zp = (gfan::ZCone*) u->Data();
    17431898    lists output=(lists)omAllocBin(slists_bin); output->Init(2);
     
    17591914    catch (const std::exception& ex)
    17601915    {
    1761       WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
    1762       return TRUE;
    1763     }
     1916      gfan::deinitializeCddlibIfRequired();
     1917      WerrorS("ERROR: "); WerrorS(ex.what()); WerrorS("\n");
     1918      return TRUE;
     1919    }
     1920    gfan::deinitializeCddlibIfRequired();
    17641921    res->rtyp = LIST_CMD;
    17651922    res->data = (void*) output;
  • gfanlib/gfanlib_zcone.cpp

    r0091f5 r1082b9  
    1313
    1414#include <config.h>
     15extern "C"
     16{
    1517#ifdef HAVE_CDD_SETOPER_H
    1618#include <cdd/setoper.h>
     
    2527#endif //HAVE_CDDLIB_SETOPER_H
    2628#endif //HAVE_CDD_SETOPER_H
    27 
     29}
     30extern "C" time_t dd_statStartTime; /*cddlib*/
    2831
    2932namespace gfan{
     
    3437        void initializeCddlibIfRequired() // calling this frequently will cause memory leaks because deinitialisation is not possible with old versions of cddlib.
    3538        {
     39          if (dd_statStartTime==0)
     40          {
    3641                dd_set_global_constants();
     42                printf("dd_set_global_constansts\n");
     43          }
    3744        }
    3845        void deinitializeCddlibIfRequired()
    3946        {
    4047        #ifdef HAVE_DD_FREE_GLOBAL_CONSTANTS
    41                 dd_free_global_constants();
     48        //        dd_free_global_constants();
    4249        #endif
    4350        }
Note: See TracChangeset for help on using the changeset viewer.