File: gjbf_emxutil.c1 /* 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 |