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