File: Datalogger4ChConverter_ErrInsensitiveSound_emxutil.c

    1   /*
    2    * Datalogger4ChConverter_ErrInsensitiveSound_emxutil.c
    3    *
    4    * Code generation for function 'Datalogger4ChConverter_ErrInsensitiveSound_emxutil'
    5    *
    6    */
    7   
    8   /* Include files */
    9   #include "rt_nonfinite.h"
   10   #include "Datalogger4ChConverter_ErrInsensitiveSound.h"
   11   #include "Datalogger4ChConverter_ErrInsensitiveSound_emxutil.h"
   12   #include <stdio.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_char_T(emxArray_char_T **pEmxArray)
   74   {
   75     if (*pEmxArray != (emxArray_char_T *)NULL) {
   76       if (((*pEmxArray)->data != (char_T *)NULL) && (*pEmxArray)->canFreeData) {
   77         emlrtFreeMex((void *)(*pEmxArray)->data);
   78       }
   79   
   80       emlrtFreeMex((void *)(*pEmxArray)->size);
   81       emlrtFreeMex((void *)*pEmxArray);
   82       *pEmxArray = (emxArray_char_T *)NULL;
   83     }
   84   }
   85   
   86   void emxFree_int32_T(emxArray_int32_T **pEmxArray)
   87   {
   88     if (*pEmxArray != (emxArray_int32_T *)NULL) {
   89       if (((*pEmxArray)->data != (int32_T *)NULL) && (*pEmxArray)->canFreeData) {
   90         emlrtFreeMex((void *)(*pEmxArray)->data);
   91       }
   92   
   93       emlrtFreeMex((void *)(*pEmxArray)->size);
   94       emlrtFreeMex((void *)*pEmxArray);
   95       *pEmxArray = (emxArray_int32_T *)NULL;
   96     }
   97   }
   98   
   99   void emxFree_real32_T(emxArray_real32_T **pEmxArray)
  100   {
  101     if (*pEmxArray != (emxArray_real32_T *)NULL) {
  102       if (((*pEmxArray)->data != (real32_T *)NULL) && (*pEmxArray)->canFreeData) {
  103         emlrtFreeMex((void *)(*pEmxArray)->data);
  104       }
  105   
  106       emlrtFreeMex((void *)(*pEmxArray)->size);
  107       emlrtFreeMex((void *)*pEmxArray);
  108       *pEmxArray = (emxArray_real32_T *)NULL;
  109     }
  110   }
  111   
  112   void emxFree_real_T(emxArray_real_T **pEmxArray)
  113   {
  114     if (*pEmxArray != (emxArray_real_T *)NULL) {
  115       if (((*pEmxArray)->data != (real_T *)NULL) && (*pEmxArray)->canFreeData) {
  116         emlrtFreeMex((void *)(*pEmxArray)->data);
  117       }
  118   
  119       emlrtFreeMex((void *)(*pEmxArray)->size);
  120       emlrtFreeMex((void *)*pEmxArray);
  121       *pEmxArray = (emxArray_real_T *)NULL;
  122     }
  123   }
  124   
  125   void emxFree_uint16_T(emxArray_uint16_T **pEmxArray)
  126   {
  127     if (*pEmxArray != (emxArray_uint16_T *)NULL) {
  128       if (((*pEmxArray)->data != (uint16_T *)NULL) && (*pEmxArray)->canFreeData) {
  129         emlrtFreeMex((void *)(*pEmxArray)->data);
  130       }
  131   
  132       emlrtFreeMex((void *)(*pEmxArray)->size);
  133       emlrtFreeMex((void *)*pEmxArray);
  134       *pEmxArray = (emxArray_uint16_T *)NULL;
  135     }
  136   }
  137   
  138   void emxFree_uint8_T(emxArray_uint8_T **pEmxArray)
  139   {
  140     if (*pEmxArray != (emxArray_uint8_T *)NULL) {
  141       if (((*pEmxArray)->data != (uint8_T *)NULL) && (*pEmxArray)->canFreeData) {
  142         emlrtFreeMex((void *)(*pEmxArray)->data);
  143       }
  144   
  145       emlrtFreeMex((void *)(*pEmxArray)->size);
  146       emlrtFreeMex((void *)*pEmxArray);
  147       *pEmxArray = (emxArray_uint8_T *)NULL;
  148     }
  149   }
  150   
  151   void emxInit_boolean_T(const emlrtStack *sp, emxArray_boolean_T **pEmxArray,
  152     int32_T numDimensions, const emlrtRTEInfo *srcLocation, boolean_T doPush)
  153   {
  154     emxArray_boolean_T *emxArray;
  155     int32_T i;
  156     *pEmxArray = (emxArray_boolean_T *)emlrtMallocMex(sizeof(emxArray_boolean_T));
  157     if ((void *)*pEmxArray == NULL) {
  158       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  159     }
  160   
  161     if (doPush) {
  162       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  163         emxFree_boolean_T);
  164     }
  165   
  166     emxArray = *pEmxArray;
  167     emxArray->data = (boolean_T *)NULL;
  168     emxArray->numDimensions = numDimensions;
  169     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  170       * numDimensions));
  171     if ((void *)emxArray->size == NULL) {
  172       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  173     }
  174   
  175     emxArray->allocatedSize = 0;
  176     emxArray->canFreeData = true;
  177     for (i = 0; i < numDimensions; i++) {
  178       emxArray->size[i] = 0;
  179     }
  180   }
  181   
  182   void emxInit_char_T(const emlrtStack *sp, emxArray_char_T **pEmxArray, int32_T
  183                       numDimensions, const emlrtRTEInfo *srcLocation, boolean_T
  184                       doPush)
  185   {
  186     emxArray_char_T *emxArray;
  187     int32_T i;
  188     *pEmxArray = (emxArray_char_T *)emlrtMallocMex(sizeof(emxArray_char_T));
  189     if ((void *)*pEmxArray == NULL) {
  190       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  191     }
  192   
  193     if (doPush) {
  194       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  195         emxFree_char_T);
  196     }
  197   
  198     emxArray = *pEmxArray;
  199     emxArray->data = (char_T *)NULL;
  200     emxArray->numDimensions = numDimensions;
  201     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  202       * numDimensions));
  203     if ((void *)emxArray->size == NULL) {
  204       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  205     }
  206   
  207     emxArray->allocatedSize = 0;
  208     emxArray->canFreeData = true;
  209     for (i = 0; i < numDimensions; i++) {
  210       emxArray->size[i] = 0;
  211     }
  212   }
  213   
  214   void emxInit_int32_T(const emlrtStack *sp, emxArray_int32_T **pEmxArray, int32_T
  215                        numDimensions, const emlrtRTEInfo *srcLocation, boolean_T
  216                        doPush)
  217   {
  218     emxArray_int32_T *emxArray;
  219     int32_T i;
  220     *pEmxArray = (emxArray_int32_T *)emlrtMallocMex(sizeof(emxArray_int32_T));
  221     if ((void *)*pEmxArray == NULL) {
  222       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  223     }
  224   
  225     if (doPush) {
  226       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  227         emxFree_int32_T);
  228     }
  229   
  230     emxArray = *pEmxArray;
  231     emxArray->data = (int32_T *)NULL;
  232     emxArray->numDimensions = numDimensions;
  233     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  234       * numDimensions));
  235     if ((void *)emxArray->size == NULL) {
  236       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  237     }
  238   
  239     emxArray->allocatedSize = 0;
  240     emxArray->canFreeData = true;
  241     for (i = 0; i < numDimensions; i++) {
  242       emxArray->size[i] = 0;
  243     }
  244   }
  245   
  246   void emxInit_int32_T1(const emlrtStack *sp, emxArray_int32_T **pEmxArray,
  247                         int32_T numDimensions, const emlrtRTEInfo *srcLocation,
  248                         boolean_T doPush)
  249   {
  250     emxArray_int32_T *emxArray;
  251     int32_T i;
  252     *pEmxArray = (emxArray_int32_T *)emlrtMallocMex(sizeof(emxArray_int32_T));
  253     if ((void *)*pEmxArray == NULL) {
  254       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  255     }
  256   
  257     if (doPush) {
  258       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  259         emxFree_int32_T);
  260     }
  261   
  262     emxArray = *pEmxArray;
  263     emxArray->data = (int32_T *)NULL;
  264     emxArray->numDimensions = numDimensions;
  265     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  266       * numDimensions));
  267     if ((void *)emxArray->size == NULL) {
  268       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  269     }
  270   
  271     emxArray->allocatedSize = 0;
  272     emxArray->canFreeData = true;
  273     for (i = 0; i < numDimensions; i++) {
  274       emxArray->size[i] = 0;
  275     }
  276   }
  277   
  278   void emxInit_real32_T(const emlrtStack *sp, emxArray_real32_T **pEmxArray,
  279                         int32_T numDimensions, const emlrtRTEInfo *srcLocation,
  280                         boolean_T doPush)
  281   {
  282     emxArray_real32_T *emxArray;
  283     int32_T i;
  284     *pEmxArray = (emxArray_real32_T *)emlrtMallocMex(sizeof(emxArray_real32_T));
  285     if ((void *)*pEmxArray == NULL) {
  286       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  287     }
  288   
  289     if (doPush) {
  290       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  291         emxFree_real32_T);
  292     }
  293   
  294     emxArray = *pEmxArray;
  295     emxArray->data = (real32_T *)NULL;
  296     emxArray->numDimensions = numDimensions;
  297     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  298       * numDimensions));
  299     if ((void *)emxArray->size == NULL) {
  300       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  301     }
  302   
  303     emxArray->allocatedSize = 0;
  304     emxArray->canFreeData = true;
  305     for (i = 0; i < numDimensions; i++) {
  306       emxArray->size[i] = 0;
  307     }
  308   }
  309   
  310   void emxInit_real32_T1(const emlrtStack *sp, emxArray_real32_T **pEmxArray,
  311     int32_T numDimensions, const emlrtRTEInfo *srcLocation, boolean_T doPush)
  312   {
  313     emxArray_real32_T *emxArray;
  314     int32_T i;
  315     *pEmxArray = (emxArray_real32_T *)emlrtMallocMex(sizeof(emxArray_real32_T));
  316     if ((void *)*pEmxArray == NULL) {
  317       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  318     }
  319   
  320     if (doPush) {
  321       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  322         emxFree_real32_T);
  323     }
  324   
  325     emxArray = *pEmxArray;
  326     emxArray->data = (real32_T *)NULL;
  327     emxArray->numDimensions = numDimensions;
  328     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  329       * numDimensions));
  330     if ((void *)emxArray->size == NULL) {
  331       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  332     }
  333   
  334     emxArray->allocatedSize = 0;
  335     emxArray->canFreeData = true;
  336     for (i = 0; i < numDimensions; i++) {
  337       emxArray->size[i] = 0;
  338     }
  339   }
  340   
  341   void emxInit_real_T(const emlrtStack *sp, emxArray_real_T **pEmxArray, int32_T
  342                       numDimensions, const emlrtRTEInfo *srcLocation, boolean_T
  343                       doPush)
  344   {
  345     emxArray_real_T *emxArray;
  346     int32_T i;
  347     *pEmxArray = (emxArray_real_T *)emlrtMallocMex(sizeof(emxArray_real_T));
  348     if ((void *)*pEmxArray == NULL) {
  349       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  350     }
  351   
  352     if (doPush) {
  353       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  354         emxFree_real_T);
  355     }
  356   
  357     emxArray = *pEmxArray;
  358     emxArray->data = (real_T *)NULL;
  359     emxArray->numDimensions = numDimensions;
  360     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  361       * numDimensions));
  362     if ((void *)emxArray->size == NULL) {
  363       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  364     }
  365   
  366     emxArray->allocatedSize = 0;
  367     emxArray->canFreeData = true;
  368     for (i = 0; i < numDimensions; i++) {
  369       emxArray->size[i] = 0;
  370     }
  371   }
  372   
  373   void emxInit_real_T1(const emlrtStack *sp, emxArray_real_T **pEmxArray, int32_T
  374                        numDimensions, const emlrtRTEInfo *srcLocation, boolean_T
  375                        doPush)
  376   {
  377     emxArray_real_T *emxArray;
  378     int32_T i;
  379     *pEmxArray = (emxArray_real_T *)emlrtMallocMex(sizeof(emxArray_real_T));
  380     if ((void *)*pEmxArray == NULL) {
  381       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  382     }
  383   
  384     if (doPush) {
  385       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  386         emxFree_real_T);
  387     }
  388   
  389     emxArray = *pEmxArray;
  390     emxArray->data = (real_T *)NULL;
  391     emxArray->numDimensions = numDimensions;
  392     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  393       * numDimensions));
  394     if ((void *)emxArray->size == NULL) {
  395       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  396     }
  397   
  398     emxArray->allocatedSize = 0;
  399     emxArray->canFreeData = true;
  400     for (i = 0; i < numDimensions; i++) {
  401       emxArray->size[i] = 0;
  402     }
  403   }
  404   
  405   void emxInit_uint16_T(const emlrtStack *sp, emxArray_uint16_T **pEmxArray,
  406                         int32_T numDimensions, const emlrtRTEInfo *srcLocation,
  407                         boolean_T doPush)
  408   {
  409     emxArray_uint16_T *emxArray;
  410     int32_T i;
  411     *pEmxArray = (emxArray_uint16_T *)emlrtMallocMex(sizeof(emxArray_uint16_T));
  412     if ((void *)*pEmxArray == NULL) {
  413       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  414     }
  415   
  416     if (doPush) {
  417       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  418         emxFree_uint16_T);
  419     }
  420   
  421     emxArray = *pEmxArray;
  422     emxArray->data = (uint16_T *)NULL;
  423     emxArray->numDimensions = numDimensions;
  424     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  425       * numDimensions));
  426     if ((void *)emxArray->size == NULL) {
  427       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  428     }
  429   
  430     emxArray->allocatedSize = 0;
  431     emxArray->canFreeData = true;
  432     for (i = 0; i < numDimensions; i++) {
  433       emxArray->size[i] = 0;
  434     }
  435   }
  436   
  437   void emxInit_uint8_T(const emlrtStack *sp, emxArray_uint8_T **pEmxArray, int32_T
  438                        numDimensions, const emlrtRTEInfo *srcLocation, boolean_T
  439                        doPush)
  440   {
  441     emxArray_uint8_T *emxArray;
  442     int32_T i;
  443     *pEmxArray = (emxArray_uint8_T *)emlrtMallocMex(sizeof(emxArray_uint8_T));
  444     if ((void *)*pEmxArray == NULL) {
  445       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  446     }
  447   
  448     if (doPush) {
  449       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  450         emxFree_uint8_T);
  451     }
  452   
  453     emxArray = *pEmxArray;
  454     emxArray->data = (uint8_T *)NULL;
  455     emxArray->numDimensions = numDimensions;
  456     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  457       * numDimensions));
  458     if ((void *)emxArray->size == NULL) {
  459       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  460     }
  461   
  462     emxArray->allocatedSize = 0;
  463     emxArray->canFreeData = true;
  464     for (i = 0; i < numDimensions; i++) {
  465       emxArray->size[i] = 0;
  466     }
  467   }
  468   
  469   void emxInit_uint8_T1(const emlrtStack *sp, emxArray_uint8_T **pEmxArray,
  470                         int32_T numDimensions, const emlrtRTEInfo *srcLocation,
  471                         boolean_T doPush)
  472   {
  473     emxArray_uint8_T *emxArray;
  474     int32_T i;
  475     *pEmxArray = (emxArray_uint8_T *)emlrtMallocMex(sizeof(emxArray_uint8_T));
  476     if ((void *)*pEmxArray == NULL) {
  477       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  478     }
  479   
  480     if (doPush) {
  481       emlrtPushHeapReferenceStackR2012b(sp, (void *)pEmxArray, (void (*)(void *))
  482         emxFree_uint8_T);
  483     }
  484   
  485     emxArray = *pEmxArray;
  486     emxArray->data = (uint8_T *)NULL;
  487     emxArray->numDimensions = numDimensions;
  488     emxArray->size = (int32_T *)emlrtMallocMex((uint32_T)(sizeof(int32_T)
  489       * numDimensions));
  490     if ((void *)emxArray->size == NULL) {
  491       emlrtHeapAllocationErrorR2012b(srcLocation, sp);
  492     }
  493   
  494     emxArray->allocatedSize = 0;
  495     emxArray->canFreeData = true;
  496     for (i = 0; i < numDimensions; i++) {
  497       emxArray->size[i] = 0;
  498     }
  499   }
  500   
  501   /* End of code generation (Datalogger4ChConverter_ErrInsensitiveSound_emxutil.c) */
  502