File: gjbf_emxutil.c

    1   /*
    2    * gjbf_emxutil.c
    3    *
    4    * Code generation for function 'gjbf_emxutil'
    5    *
    6    */
    7   
    8   /* Include files */
    9   #include "rt_nonfinite.h"
   10   #include "gjbf.h"
   11   #include "gjbf_emxutil.h"
   12   #include "blas.h"
   13   
   14   /* Function Definitions */
   15   void emxEnsureCapacity(const emlrtStack *sp, emxArray__common *emxArray, int32_T
   16     oldNumel, int32_T elementSize, const emlrtRTEInfo *srcLocation)
   17   {
   18     int32_T newNumel;
   19     int32_T i;
   20     void *newData;
   21     newNumel = 1;
   22     for (i = 0; i < emxArray->numDimensions; i++) {
   23       newNumel = (int32_T)emlrtSizeMulR2012b((uint32_T)newNumel, (uint32_T)
   24         emxArray->size[i], srcLocation, sp);
   25     }
   26   
   27     if (newNumel > emxArray->allocatedSize) {
   28       i = emxArray->allocatedSize;
   29       if (i < 16) {
   30         i = 16;
   31       }
   32   
   33       while (i < newNumel) {
   34         if (i > 1073741823) {
   35           i = MAX_int32_T;
   36         } else {
   37           i <<= 1;
   38         }
   39       }
   40   
   41       newData = emlrtCallocMex((uint32_T)i, (uint32_T)elementSize);
   42       if (newData == NULL) {
   43         emlrtHeapAllocationErrorR2012b(srcLocation, sp);
   44       }
   45   
   46       if (emxArray->data != NULL) {
   47         memcpy(newData, emxArray->data, (uint32_T)(elementSize * oldNumel));
   48         if (emxArray->canFreeData) {
   49           emlrtFreeMex(emxArray->data);
   50         }
   51       }
   52   
   53       emxArray->data = newData;
   54       emxArray->allocatedSize = i;
   55       emxArray->canFreeData = true;
   56     }
   57   }
   58   
   59   void emxFree_boolean_T(emxArray_boolean_T **pEmxArray)
   60   {
   61     if (*pEmxArray != (emxArray_boolean_T *)NULL) {
   62       if (((*pEmxArray)->data != (boolean_T *)NULL) && (*pEmxArray)->canFreeData)
   63       {
   64         emlrtFreeMex((void *)(*pEmxArray)->data);
   65       }
   66   
   67       emlrtFreeMex((void *)(*pEmxArray)->size);
   68       emlrtFreeMex((void *)*pEmxArray);
   69       *pEmxArray = (emxArray_boolean_T *)NULL;
   70     }
   71   }
   72   
   73   void emxFree_int32_T(emxArray_int32_T **pEmxArray)
   74   {
   75     if (*pEmxArray != (emxArray_int32_T *)NULL) {
   76       if (((*pEmxArray)->data != (int32_T *)NULL) && (*pEmxArray)->canFreeData) {
   77         emlrtFreeMex((void *)(*pEmxArray)->data);
   78       }
   79   
   80       emlrtFreeMex((void *)(*pEmxArray)->size);
   81       emlrtFreeMex((void *)*pEmxArray);
   82       *pEmxArray = (emxArray_int32_T *)NULL;
   83     }
   84   }
   85   
   86   void emxFree_real_T(emxArray_real_T **pEmxArray)
   87   {
   88     if (*pEmxArray != (emxArray_real_T *)NULL) {
   89       if (((*pEmxArray)->data != (real_T *)NULL) && (*pEmxArray)->canFreeData) {
   90         emlrtFreeMex((void *)(*pEmxArray)->data);
   91       }
   92   
   93       emlrtFreeMex((void *)(*pEmxArray)->size);
   94       emlrtFreeMex((void *)*pEmxArray);
   95       *pEmxArray = (emxArray_real_T *)NULL;
   96     }
   97   }
   98   
   99   void emxInit_boolean_T(const emlrtStack *sp, emxArray_boolean_T **pEmxArray,
  100     int32_T numDimensions, const emlrtRTEInfo *srcLocation, boolean_T doPush)
  101   {
  102     emxArray_boolean_T *emxArray;
  103     int32_T i;
  104     *pEmxArray = (emxArray_boolean_T *)emlrtMallocMex(sizeof(emxArray_boolean_T));
  105     if ((void *)*pEmxArray == NULL) {
  106       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  107     }
  108   
  109     if (doPush) {
  110       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  111         emxFree_boolean_T);
  112     }
  113   
  114     emxArray = *pEmxArray;
  115     emxArray->data = (boolean_T *)NULL;
  116     emxArray->numDimensions = numDimensions;
  117     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  118       * numDimensions));
  119     if ((void *)emxArray->size == NULL) {
  120       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  121     }
  122   
  123     emxArray->allocatedSize = 0;
  124     emxArray->canFreeData = true;
  125     for (i = 0; i < numDimensions; i++) {
  126       emxArray->size[i] = 0;
  127     }
  128   }
  129   
  130   void emxInit_int32_T(const emlrtStack *sp, emxArray_int32_T **pEmxArray, int32_T
  131                        numDimensions, const emlrtRTEInfo *srcLocation, boolean_T
  132                        doPush)
  133   {
  134     emxArray_int32_T *emxArray;
  135     int32_T i;
  136     *pEmxArray = (emxArray_int32_T *)emlrtMallocMex(sizeof(emxArray_int32_T));
  137     if ((void *)*pEmxArray == NULL) {
  138       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  139     }
  140   
  141     if (doPush) {
  142       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  143         emxFree_int32_T);
  144     }
  145   
  146     emxArray = *pEmxArray;
  147     emxArray->data = (int32_T *)NULL;
  148     emxArray->numDimensions = numDimensions;
  149     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  150       * numDimensions));
  151     if ((void *)emxArray->size == NULL) {
  152       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  153     }
  154   
  155     emxArray->allocatedSize = 0;
  156     emxArray->canFreeData = true;
  157     for (i = 0; i < numDimensions; i++) {
  158       emxArray->size[i] = 0;
  159     }
  160   }
  161   
  162   void emxInit_real_T(const emlrtStack *sp, emxArray_real_T **pEmxArray, int32_T
  163                       numDimensions, const emlrtRTEInfo *srcLocation, boolean_T
  164                       doPush)
  165   {
  166     emxArray_real_T *emxArray;
  167     int32_T i;
  168     *pEmxArray = (emxArray_real_T *)emlrtMallocMex(sizeof(emxArray_real_T));
  169     if ((void *)*pEmxArray == NULL) {
  170       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  171     }
  172   
  173     if (doPush) {
  174       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  175         emxFree_real_T);
  176     }
  177   
  178     emxArray = *pEmxArray;
  179     emxArray->data = (real_T *)NULL;
  180     emxArray->numDimensions = numDimensions;
  181     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  182       * numDimensions));
  183     if ((void *)emxArray->size == NULL) {
  184       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  185     }
  186   
  187     emxArray->allocatedSize = 0;
  188     emxArray->canFreeData = true;
  189     for (i = 0; i < numDimensions; i++) {
  190       emxArray->size[i] = 0;
  191     }
  192   }
  193   
  194   void emxInit_real_T1(const emlrtStack *sp, emxArray_real_T **pEmxArray, int32_T
  195                        numDimensions, const emlrtRTEInfo *srcLocation, boolean_T
  196                        doPush)
  197   {
  198     emxArray_real_T *emxArray;
  199     int32_T i;
  200     *pEmxArray = (emxArray_real_T *)emlrtMallocMex(sizeof(emxArray_real_T));
  201     if ((void *)*pEmxArray == NULL) {
  202       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  203     }
  204   
  205     if (doPush) {
  206       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  207         emxFree_real_T);
  208     }
  209   
  210     emxArray = *pEmxArray;
  211     emxArray->data = (real_T *)NULL;
  212     emxArray->numDimensions = numDimensions;
  213     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  214       * numDimensions));
  215     if ((void *)emxArray->size == NULL) {
  216       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  217     }
  218   
  219     emxArray->allocatedSize = 0;
  220     emxArray->canFreeData = true;
  221     for (i = 0; i < numDimensions; i++) {
  222       emxArray->size[i] = 0;
  223     }
  224   }
  225   
  226   void emxInit_real_T2(const emlrtStack *sp, emxArray_real_T **pEmxArray, int32_T
  227                        numDimensions, const emlrtRTEInfo *srcLocation, boolean_T
  228                        doPush)
  229   {
  230     emxArray_real_T *emxArray;
  231     int32_T i;
  232     *pEmxArray = (emxArray_real_T *)emlrtMallocMex(sizeof(emxArray_real_T));
  233     if ((void *)*pEmxArray == NULL) {
  234       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  235     }
  236   
  237     if (doPush) {
  238       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  239         emxFree_real_T);
  240     }
  241   
  242     emxArray = *pEmxArray;
  243     emxArray->data = (real_T *)NULL;
  244     emxArray->numDimensions = numDimensions;
  245     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  246       * numDimensions));
  247     if ((void *)emxArray->size == NULL) {
  248       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  249     }
  250   
  251     emxArray->allocatedSize = 0;
  252     emxArray->canFreeData = true;
  253     for (i = 0; i < numDimensions; i++) {
  254       emxArray->size[i] = 0;
  255     }
  256   }
  257   
  258   /* End of code generation (gjbf_emxutil.c) */
  259