Changeset 1886


Ignore:
Timestamp:
Apr 6, 2013 2:13:35 PM (7 years ago)
Author:
stefan
Message:

fix compiler (gcc 4.6.2) warnings in optimized mode, mainly about unused variables

Location:
trunk/Cbc/src
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcBranchLotsize.cpp

    r1573 r1886  
    183183        bound_[0] = points[sort[0] * 2];
    184184        bound_[1] = points[sort[0] * 2 + 1];
    185         double lo = bound_[0];
    186185        double hi = bound_[1];
    187         assert (hi >= lo);
     186        assert (hi >= bound_[0]);
    188187        for (i = 1; i < numberPoints; i++) {
    189188            double thisLo = points[sort[i] * 2];
     
    194193                bound_[2*numberRanges_+1] = thisHi;
    195194                numberRanges_++;
    196                 lo = thisLo;
    197195                hi = thisHi;
    198196            } else {
  • trunk/Cbc/src/CbcFathomDynamicProgramming.cpp

    r1641 r1886  
    760760    int n2 = 0;
    761761    int mask[40];
    762     int nextbit[40];
    763762    int adjust[40];
    764763    assert (numberElements <= 40);
     
    784783            adjust[n2] = start * hi2;
    785784            mask2 += start * gap;
    786             nextbit[n2] = startBit + numberBits;
    787785            mask[n2++] = start * (size - 1);
    788786        }
  • trunk/Cbc/src/CbcHeuristic.cpp

    r1880 r1886  
    716716    getHistoryStatistics_ = false;
    717717#endif
     718#ifdef COIN_DEVELOP
    718719    int status = 0;
     720#endif
    719721    int logLevel = model_->logLevel();
    720722#define LEN_PRINT 250
     
    13201322                }
    13211323                if (model.status() == 5)
    1322                     model_->sayEventHappened();
     1324                   model_->sayEventHappened();
     1325#ifdef COIN_DEVELOP
    13231326                if (model.isProvenInfeasible())
    13241327                    status = 1;
    13251328                else if (model.isProvenOptimal())
    13261329                    status = 2;
     1330#endif
    13271331            }
    13281332        }
  • trunk/Cbc/src/CbcHeuristicGreedy.cpp

    r1876 r1886  
    13621362      int nL=0;
    13631363      int nG=0;
    1364       int iUnder=-1;
    13651364      int nUnder=0;
    13661365      for (iRow = 0; iRow < numberRows; iRow++) {
     
    13721371          gap += rowLower[iRow]-rowActivity[iRow];
    13731372          nUnder++;
    1374           iUnder=iRow;
    13751373          rowWeight[iRow] *= 1.1;
    13761374        } else if (rowActivity[iRow] > rowUpper[iRow] + 10.0*primalTolerance) {
  • trunk/Cbc/src/CbcLinked.cpp

    r1876 r1886  
    404404        if (returnCode == 0)
    405405            OsiClpSolverInterface::resolve();
    406         if (!allFixed && (specialOptions2_&1) != 0) {
    407             const double * solution = getColSolution();
    408             bool satisfied = true;
    409             for (int i = 0; i < numberVariables_; i++) {
    410                 int iColumn = info_[i].variable();
    411                 double value = solution[iColumn];
    412                 if (fabs(value - floor(value + 0.5)) > 0.0001)
    413                     satisfied = false;
    414             }
    415             //if (satisfied)
    416             //printf("satisfied but not fixed\n");
    417         }
    418406        int satisfied = 2;
    419407        const double * solution = getColSolution();
     
    18921880            char * pos = temp;
    18931881            bool ifFirst = true;
    1894             double linearTerm = 0.0;
    18951882            while (*pos) {
    18961883                double value;
     
    18991886                if (jColumn >= 0) {
    19001887                    markNonlinear[jColumn] = 1;
    1901                 } else if (jColumn == -2) {
    1902                     linearTerm = value;
    1903                 } else {
     1888                } else if (jColumn != -2) {
    19041889                    printf("bad nonlinear term %s\n", temp);
    19051890                    abort();
     
    19201905                char * pos = temp;
    19211906                bool ifFirst = true;
    1922                 double linearTerm = 0.0;
    19231907                while (*pos) {
    19241908                    double value;
     
    19271911                    if (jColumn >= 0) {
    19281912                        markNonlinear[jColumn] = 1;
    1929                     } else if (jColumn == -2) {
    1930                         linearTerm = value;
    1931                     } else {
     1913                    } else if (jColumn != -2) {
    19321914                        printf("bad nonlinear term %s\n", temp);
    19331915                        abort();
     
    28642846    else
    28652847        cbcModel->setCutoff(cbcModel_->getCutoff());
    2866     // to change exits
    2867     bool isFeasible = false;
    28682848    int saveLogLevel = clpModel->logLevel();
    28692849    clpModel->setLogLevel(0);
     2850#ifndef NDEBUG
    28702851    int returnCode = 0;
     2852#endif
    28712853    if (clpModel->tightenPrimalBounds() != 0) {
    28722854        clpModel->setLogLevel(saveLogLevel);
     2855#ifndef NDEBUG
    28732856        returnCode = -1; // infeasible//std::cout<<"Problem is infeasible - tightenPrimalBounds!"<<std::endl;
     2857#endif
    28742858        //clpModel->writeMps("infeas2.mps");
    28752859    } else {
     
    29112895            std::cout << "Pre-processing says infeasible!" << std::endl;
    29122896            delete saveSolver;
     2897#ifndef NDEBUG
    29132898            returnCode = -1;
     2899#endif
    29142900        } else {
    29152901            std::cout << "processed model has " << solver2->getNumRows()
     
    29332919                // put back in original solver
    29342920                newSolver.setColSolution(cbcModel->bestSolution());
    2935                 isFeasible = true;
    29362921            } else {
    29372922                delete saveSolver;
     
    40164001        // weights must be increasing
    40174002        int i;
    4018         double last = -COIN_DBL_MAX;
    4019         for (i = 0; i < numberMembers_; i++) {
    4020             assert (weights_[i] > last + 1.0e-12);
    4021             last = weights_[i];
    4022         }
     4003#ifndef NDEBUG
     4004        for (i = 1; i < numberMembers_; i++)
     4005            assert (weights_[i] > weights_[i-1] + 1.0e-12);
     4006#endif
    40234007        for (i = 0; i < numberMembers_*numberLinks_; i++) {
    40244008            members_[i] = first + i;
     
    40504034        // weights must be increasing
    40514035        int i;
    4052         double last = -COIN_DBL_MAX;
    4053         for (i = 0; i < numberMembers_; i++) {
    4054             assert (weights_[i] > last + 1.0e-12);
    4055             last = weights_[i];
    4056         }
     4036#ifndef NDEBUG
     4037        for (i = 1; i < numberMembers_; i++)
     4038            assert (weights_[i] > weights_[i-1] + 1.0e-12);
     4039#endif
    40574040        for (i = 0; i < numberMembers_*numberLinks_; i++) {
    40584041            members_[i] = which[i];
     
    51355118                // make sure y equal
    51365119                double rhs = 0.0;
    5137                 CoinBigIndex starts[2];
    51385120                int index[4];
    51395121                double element[4] = {1.0, 1.0, -1.0, -1.0};
    5140                 starts[0] = 0;
    5141                 starts[1] = 4;
    51425122                index[0] = firstLambda_ + 0;
    51435123                index[1] = firstLambda_ + 1;
     
    51505130                // make sure x equal
    51515131                double rhs = 0.0;
    5152                 CoinBigIndex starts[2];
    51535132                int index[4];
    51545133                double element[4] = {1.0, 1.0, -1.0, -1.0};
    5155                 starts[0] = 0;
    5156                 starts[1] = 4;
    51575134                index[0] = firstLambda_ + 0;
    51585135                index[1] = firstLambda_ + 2;
     
    69086885    // get original bounds
    69096886    double xB[2];
    6910     double yB[2];
    69116887    const double * lower = solver->getColLower();
    69126888    const double * upper = solver->getColUpper();
     
    69146890    xB[1] = upper[xColumn_];
    69156891    assert (fabs((xB[1] - xB[0]) - xMeshSize_*(numberPoints_ - 1)) < 1.0e-7);
    6916     yB[0] = lower[yColumn_];
    6917     yB[1] = upper[yColumn_];
    69186892    double mesh = 0.0;
    69196893    int i;
     
    77597733            char * pos = temp;
    77607734            bool ifFirst = true;
    7761             double linearTerm = 0.0;
    77627735            while (*pos) {
    77637736                double value;
     
    77667739                if (jColumn >= 0) {
    77677740                    maximumQuadraticElements++;
    7768                 } else if (jColumn == -2) {
    7769                     linearTerm = value;
    7770                 } else {
     7741                } else if (jColumn != -2) {
    77717742                    printf("bad nonlinear term %s\n", temp);
    77727743                    abort();
     
    77977768                char * pos = temp;
    77987769                bool ifFirst = true;
    7799                 double linearTerm = 0.0;
    78007770                while (*pos) {
    78017771                    double value;
     
    78047774                    if (jColumn >= 0) {
    78057775                        numberQuadratic++;
    7806                     } else if (jColumn == -2) {
    7807                         linearTerm = value;
    7808                     } else {
     7776                    } else if (jColumn != -2) {
    78097777                        printf("bad nonlinear term %s\n", temp);
    78107778                        abort();
     
    79787946        model->setObjective(quadObj);
    79797947    delete quadObj;
     7948#ifndef NDEBUG
    79807949    int returnCode;
    79817950    if (numberConstraints) {
     
    79877956        returnCode = model->nonlinearSLP(numberPasses, deltaTolerance);
    79887957    }
     7958    assert (!returnCode);
     7959#else
     7960    if (numberConstraints) {
     7961        model->nonlinearSLP(numberConstraints, constraints, numberPasses, deltaTolerance);
     7962        for (iConstraint = 0; iConstraint < saveNumber; iConstraint++)
     7963            delete constraints[iConstraint];
     7964    } else {
     7965        model->nonlinearSLP(numberPasses, deltaTolerance);
     7966    }
     7967#endif
    79897968    delete [] constraints;
    7990     assert (!returnCode);
    79917969    return model;
    79927970#else
  • trunk/Cbc/src/CbcLinkedUtils.cpp

    r1885 r1886  
    340340    if (model)
    341341        assert (model->optimizationDirection() == 1.0);
    342     bool scaling = false;
    343     if (model && (model->rowScale() ||
    344                   model->objectiveScale() != 1.0 || model->optimizationDirection() != 1.0))
    345         scaling = true;
     342#ifndef NDEBUG
     343    bool scaling = model && (model->rowScale() || model->objectiveScale() != 1.0 || model->optimizationDirection() != 1.0);
     344#endif
    346345    const double * cost = NULL;
    347346    if (model)
     
    350349        // not in solve
    351350        cost = objective_;
     351#ifndef NDEBUG
    352352        scaling = false;
     353#endif
    353354    }
    354355    assert (!scaling);
  • trunk/Cbc/src/CbcMipStartIO.cpp

    r1854 r1886  
    2020bool isNumericStr( const char *str )
    2121{
    22    const int l = strlen(str);
    23 
    24    for ( int i=0 ; (i<l) ; ++i )
     22   const size_t l = strlen(str);
     23
     24   for ( size_t i=0 ; i<l ; ++i )
    2525      if (!(isdigit(str[i])||(str[i]=='.')))
    2626         return false;
     
    170170      babModel.setMaximumSeconds( 60 );
    171171      babModel.branchAndBound();
    172       clock_t end = clock();
    173172      if (babModel.bestSolution())
    174173      {
  • trunk/Cbc/src/CbcModel.cpp

    r1881 r1886  
    398398        int numberColumns = solver_->getNumCols() ;
    399399        // Column copy of matrix
    400         bool allPlusOnes = true;
    401         bool allOnes = true;
    402400        int problemType = -1;
    403401        const double * element = solver_->getMatrixByCol()->getElements();
     
    670668                        } else if (value == -1.0) {
    671669                            rhs[row[j]] = -0.5;
    672                             allPlusOnes = false;
    673670                        } else {
    674671                            rhs[row[j]] = -COIN_DBL_MAX;
    675                             allOnes = false;
    676672                        }
    677673                    }
     
    20702066    */
    20712067    // Convert to Osi if wanted
    2072     bool useOsiBranching = false;
    20732068    //OsiBranchingInformation * persistentInfo = NULL;
    20742069    if (branchingMethod_ && branchingMethod_->chooseMethod()) {
    2075         useOsiBranching = true;
    20762070        //persistentInfo = new OsiBranchingInformation(solver_);
    20772071        if (numberOriginalObjects) {
     
    38813875      this node is still live, push it onto the heap that holds the live set.
    38823876    */
    3883     double bestValue = 0.0 ;
    38843877    if (newNode) {
    3885         bestValue = newNode->objectiveValue();
    38863878        if (newNode->branchingObject()) {
    38873879            newNode->initializeInfo() ;
     
    77997791#ifdef CHECK_DEBUGGER
    78007792                if ((specialOptions_&1) != 0 ) {
    7801                   const OsiRowCutDebugger * debugger =
    7802                     solver_->getRowCutDebuggerAlways();
    7803                   CoinAssert (!debugger->invalidCut(*thisCut));
     7793                  CoinAssert (!solver_->getRowCutDebuggerAlways()->invalidCut(*thisCut));
    78047794                }
    78057795#endif
     
    1187711867                int iAway = -1;
    1187811868                double largestInfeasibility = tolerance;
     11869#if COIN_DEVELOP>1
    1187911870                int iInfeas = -1;
     11871#endif
    1188011872                const double * columnLower = continuousSolver_->getColLower();
    1188111873                const double * columnUpper = continuousSolver_->getColUpper();
     
    1188411876                    double value = solution2[i];
    1188511877                    if (value > columnUpper[i] + largestInfeasibility) {
     11878#if COIN_DEVELOP>1
    1188611879                        iInfeas = i;
     11880#endif
    1188711881                        largestInfeasibility = value - columnUpper[i];
    1188811882                    } else if (value < columnLower[i] - largestInfeasibility) {
     11883#if COIN_DEVELOP>1
    1188911884                        iInfeas = i;
     11885#endif
    1189011886                        largestInfeasibility = columnLower[i] - value;
    1189111887                    }
     
    1465614652        numberCutGenerators_=0; // so can dive and branch
    1465714653    }
    14658     int currentNumberCuts = 0 ;
    1465914654    currentNode_ = node; // so can be accessed elsewhere
    1466014655    double bestObjective = bestObjective_;
     
    1479014785        phase_ = 2;
    1479114786        OsiCuts cuts ;
    14792         currentNumberCuts = solver_->getNumRows() - numberRowsAtContinuous_ ;
    1479314787        int saveNumber = numberIterations_;
    1479414788        if (solverCharacteristics_->solutionAddsCuts()) {
     
    1516315157                  solver_->writeMpsNative("infeas2.mps", NULL, NULL, 2);
    1516415158                  solver_->getRowCutDebuggerAlways()->printOptimalSolution(*solver_);
     15159#ifndef NDEBUG
    1516515160                  const OsiRowCutDebugger * debugger = solver_->getRowCutDebugger() ;
     15161#endif
    1516615162                  assert (debugger) ;
    1516715163                  int numberRows0=continuousSolver_->getNumRows();
  • trunk/Cbc/src/CbcNode.cpp

    r1880 r1886  
    14761476                //if (smallestNumberInfeasibilities>=numberIntegerInfeasibilities)
    14771477                //numberNodes=1000000; // switch off search for better solution
    1478                 int numberNodes = 1000000; // switch off anyway
    14791478                averageCostPerIteration /= totalNumberIterations;
    14801479                // all feasible - choose best bet
     
    27012700            int saveLimit2;
    27022701            solver->getIntParam(OsiMaxNumIterationHotStart, saveLimit2);
    2703             bool doQuickly = false; // numberToDo>2*numberStrong;
    2704             if (searchStrategy == 2)
    2705                 doQuickly = true;
    27062702            int numberTest = numberNotTrusted > 0 ? numberStrong : (numberStrong + 1) / 2;
    27072703            if (searchStrategy == 3) {
    27082704                // Previously decided we need strong
    2709                 doQuickly = false;
    27102705                numberTest = numberStrong;
    27112706            }
     
    27162711                    if ((model->specialOptions()&8) == 0) {
    27172712                        numberTest = 0;
    2718                         doQuickly = true;
    27192713                    }
    27202714                    //} else {
    2721                     //doQuickly=false;
    27222715                    //numberTest=2*numberStrong;
    27232716                    //skipAll=0;
     
    27262719            } else {
    27272720                // Just take first
    2728                 doQuickly = true;
    27292721                numberTest = 1;
    27302722            }
     
    27322724            if (depth_ < testDepth && numberStrong) {
    27332725                if (searchStrategy != 2) {
    2734                     doQuickly = false;
    27352726                    int numberRows = solver->getNumRows();
    27362727                    // whether to do this or not is important - think
     
    27512742                if (skipAll) {
    27522743                    numberTest = 0;
    2753                     doQuickly = true;
    27542744                }
    27552745            } else {
     
    27602750            if (skipAll < 0) {
    27612751                numberTest = 0;
    2762                 doQuickly = true;
    27632752            }
    27642753            int realMaxHotIterations = 999999;
     
    35253514                if (hitMaxTime) {
    35263515                    // make sure rest are fast
    3527                     doQuickly = true;
    35283516                    for ( int jDo = iDo + 1; jDo < numberToDo; jDo++) {
    35293517                        int iObject = whichObject[iDo];
     
    37783766    double * saveUpper = new double[numberColumns];
    37793767    double * saveLower = new double[numberColumns];
    3780     int anyAction = 0;
    37813768    // Save solution in case heuristics need good solution later
    37823769
     
    40784065            } else {
    40794066                // up feasible, down infeasible
    4080                 anyAction = -1;
    40814067                if (!satisfied)
    40824068                    needResolve = true;
     
    40894075            if (choice.downMovement < 1.0e100) {
    40904076                // down feasible, up infeasible
    4091                 anyAction = -1;
    40924077                if (!satisfied)
    40934078                    needResolve = true;
     
    40984083            } else {
    40994084                // neither side feasible
    4100                 anyAction = -2;
    41014085                COIN_DETAIL_PRINT(printf("Both infeasible for choice %d sequence %d\n", i,
    41024086                                         model->object(choice.objectNumber)->columnNumber()));
  • trunk/Cbc/src/CbcSimpleIntegerDynamicPseudoCost.cpp

    r1854 r1886  
    736736        double minValue = CoinMin(downCost, upCost);
    737737        double maxValue = CoinMax(downCost, upCost);
     738#ifdef COIN_DEVELOP
    738739        char where;
     740#endif
    739741        // was <= 10
    740742        //if (stateOfSearch<=1||model_->currentNode()->depth()<=-10 /* was ||maxValue>0.2*distanceToCutoff*/) {
    741743        if (stateOfSearch <= 2) {
    742744            // no branching solution
     745#ifdef COIN_DEVELOP
    743746            where = 'i';
     747#endif
    744748            returnValue = WEIGHT_BEFORE * minValue + (1.0 - WEIGHT_BEFORE) * maxValue;
    745749            if (0) {
     
    768772        } else {
    769773            // some solution
     774#ifdef COIN_DEVELOP
    770775            where = 'I';
     776#endif
    771777#ifndef WEIGHT_PRODUCT
    772778            returnValue = WEIGHT_AFTER * minValue + (1.0 - WEIGHT_AFTER) * maxValue;
  • trunk/Cbc/src/CbcSolver.cpp

    r1880 r1886  
    49524952                                   int status = computeCompleteSolution( babModel_, colNames, mipStart, &x[0], obj );
    49534953                                   if (!status)
    4954                                      babModel_->setBestSolution( &x[0], x.size(), obj, false );
     4954                                     babModel_->setBestSolution( &x[0], static_cast<int>(x.size()), obj, false );
    49554955                                }
    49564956
     
    85598559                                  assert (clpSolver->getModelPtr()==saveLpSolver);
    85608560                                  lpSolver = new ClpSimplex(*saveLpSolver);
     8561#ifndef NDEBUG
    85618562                                  ClpSimplex * oldSimplex = clpSolver->swapModelPtr(lpSolver);
    85628563                                  assert (oldSimplex==saveLpSolver);
     8564#else
     8565              clpSolver->swapModelPtr(lpSolver);
     8566#endif
    85638567                                  double * solution = lpSolver->primalColumnSolution();
    85648568                                  double * lower = lpSolver->columnLower();
  • trunk/Cbc/src/CbcSolverExpandKnapsack.cpp

    r1854 r1886  
    552552   for (iKnapsack=0;iKnapsack<numberKnapsack;iKnapsack++) {
    553553      int k=-1;
    554       double value=0.0;
    555554      for (iColumn=knapsackStart[iKnapsack];iColumn<knapsackStart[iKnapsack+1];iColumn++) {
    556555         if (knapsackSolution[iColumn]>1.0e-5) {
     
    561560            }
    562561            k=iColumn;
    563             value=floor(knapsackSolution[iColumn]+0.5);
    564             assert (fabs(value-knapsackSolution[iColumn])<1.0e-5);
     562            assert (fabs(floor(knapsackSolution[iColumn]+0.5)-knapsackSolution[iColumn])<1.0e-5);
    565563         }
    566564      }
  • trunk/Cbc/src/CbcSolverHeuristics.cpp

    r1880 r1886  
    636636#define MAXPROB 2
    637637        ClpSimplex models[MAXPROB];
    638         int pass[MAXPROB];
    639638        int kPass = -1;
    640639        int kLayer = 0;
     
    866865                }
    867866            }
    868             pass[kPass] = iPass;
    869867            double maxCostUp = COIN_DBL_MAX;
    870868            objective = lpSolver->getObjCoefficients() ;
  • trunk/Cbc/src/CbcThread.cpp

    r1880 r1886  
    175175    struct timespec absTime2;
    176176    my_gettime(&absTime2);
    177     double time2 = absTime2.tv_sec + 1.0e-9 * absTime2.tv_nsec;
     177    double time2 = (double)absTime2.tv_sec + 1.0e-9 * (double)absTime2.tv_nsec;
    178178    return time2;
    179179}
     
    244244{
    245245#ifdef CBC_PTHREAD
    246     return threadId_.status;
     246    return static_cast<int>(threadId_.status);
    247247#else
    248248#endif
     
    879879            children_[i].setReturnCode( 0);
    880880            children_[i].unlockFromMaster();
    881             int returnCode;
    882             returnCode = children_[i].exit();
     881#ifndef NDEBUG
     882            int returnCode = children_[i].exit();
     883            assert (!returnCode);
     884#else
     885            children_[i].exit();
     886#endif
    883887            children_[i].setStatus( 0);
    884             assert (!returnCode);
    885888            //else
    886889            threadModel_[i]->moveToModel(baseModel, 2);
  • trunk/Cbc/src/Cbc_C_Interface.cpp

    r1573 r1886  
    22732273
    22742274    assert(1 > 0);// this is probably broken
    2275     int i, j, l;
    2276     const int *w;
     2275    int i, j;
    22772276    // I think this is a different model due to overriding = operator
    22782277    CbcModel m = *(model->model_);
     
    22972296        // Make a CbcSOS and assign it to objects
    22982297        if (VERBOSE > 1) printf("%s len[%i] = %i\n", prefix, i, len[i]);
    2299         l = len[i];
    2300         w = which[i];
    23012298        if (VERBOSE > 1) printf("%s new CbcSOS()\n", prefix);
    23022299        // ***
  • trunk/Cbc/src/Cbc_ampl.cpp

    r1869 r1886  
    441441                sos_kludge(nsos, sosbeg, sosref, sosind);
    442442                for (int i = 0; i < nsos; i++) {
    443                     int ichar = sostype[i];
     443                    char ichar = sostype[i];
    444444                    assert (ichar == '1' || ichar == '2');
    445                     info->sosType[i] = ichar - '0';
     445                    info->sosType[i] = static_cast<char>(ichar - '0');
    446446                }
    447447                memcpy(info->sosPriority, sospri, nsos*sizeof(int));
     
    619619            fprintf(stderr, "You can copy .nl file %s for debug purposes or attach debugger\n", saveArgv[1]);
    620620            fprintf(stderr, "Type q to quit, anything else to continue\n");
    621             char getChar = getc(stdin);
     621            int getChar = getc(stdin);
    622622            if (getChar == 'q' || getChar == 'Q')
    623623                exit(1);
     
    988988        // quadratic
    989989        asl = ASL_alloc(ASL_read_fg);
    990         nl = jac0dim(stub, (long) strlen(stub));
     990        nl = jac0dim(stub, (ftnlen) strlen(stub));
    991991        free(stub);
    992992        suf_declare(suftab, sizeof(suftab) / sizeof(SufDecl));
     
    10941094        //ASL_pfgh* asl = (ASL_pfgh*)ASL_alloc(ASL_read_pfgh);
    10951095        asl = ASL_alloc(ASL_read_pfgh);
    1096         nl = jac0dim(stub, (long) strlen(stub));
     1096        nl = jac0dim(stub, (ftnlen) strlen(stub));
    10971097        free(stub);
    10981098        suf_declare(suftab, sizeof(suftab) / sizeof(SufDecl));
Note: See TracChangeset for help on using the changeset viewer.