1/* 2 * Helper methods for the XML metadata testcases - global function edition 3 * 4 * This file has the same structure as generated for inline function by 5 * the metadata tool. 6 */ 7#include "Python.h" 8#include "pyobjc-api.h" 9#include <stdarg.h> 10 11#import <Foundation/Foundation.h> 12 13static int* makeIntArrayOf5(void) 14{ 15 static int result[5]; 16 int i; 17 for (i = 0; i < 5; i++) { 18 result[i] = i*i; 19 } 20 return result; 21} 22 23static char** makeStringArray(void) 24{ 25 static char* result[] = { 26 "hello", 27 "world", 28 "out", 29 "there", 30 NULL 31 }; 32 return result; 33} 34 35 36static int* makeIntArrayOf_(int count) 37{ 38 static int* result = NULL; 39 int i; 40 41 if (result) { 42 free(result); 43 } 44 result = malloc(sizeof(int) * count); 45 if (result == NULL) { 46 return NULL; 47 } 48 for (i = 0; i < count; i++) { 49 result[i] = i * i * i; 50 } 51 return result; 52} 53 54static int* nullIntArrayOf5(void) 55{ 56 return NULL; 57} 58 59static char** nullStringArray(void) 60{ 61 return NULL; 62} 63 64static int* nullIntArrayOf_(int count __attribute__((__unused__))) 65{ 66 return NULL; 67} 68 69static NSArray* makeIntArray_count_(int* data, unsigned count) 70{ 71 NSMutableArray* array; 72 unsigned i; 73 74 array = [NSMutableArray arrayWithCapacity:count]; 75 76 for (i = 0; i < count; i++) { 77 [array addObject: [NSNumber numberWithInt:data[i]]]; 78 } 79 return array; 80} 81 82static NSArray* nullIntArray_count_(int* data, unsigned count) 83{ 84 if (data) { 85 return makeIntArray_count_(data, count); 86 } else { 87 return nil; 88 } 89} 90 91static NSArray* makeIntArray_countPtr_(int* data, unsigned* countPtr) 92{ 93 return makeIntArray_count_(data, *countPtr); 94} 95 96 97static NSArray* make4Tuple_(double* data) 98{ 99 NSMutableArray* array; 100 unsigned i; 101 102 array = [NSMutableArray array]; 103 104 for (i = 0; i < 4; i++) { 105 [array addObject: [NSNumber numberWithDouble:data[i]]]; 106 } 107 return array; 108} 109 110static NSArray* null4Tuple_(double* data) 111{ 112 if (data) { 113 return make4Tuple_(data); 114 } else { 115 return nil; 116 } 117} 118 119 120 121static NSArray* makeStringArray_(char** data) 122{ 123 NSMutableArray* array; 124 125 array = [NSMutableArray array]; 126 127 while (*data != NULL) { 128 [array addObject: [NSString stringWithCString: *data]]; 129 data ++; 130 } 131 return array; 132} 133 134static NSArray* nullStringArray_(char** data) 135{ 136 if (data) { 137 return makeStringArray_(data); 138 } else { 139 return nil; 140 } 141} 142 143static NSArray* makeObjectArray_(id* data) 144{ 145 NSMutableArray* array; 146 147 array = [NSMutableArray array]; 148 149 while (*data != NULL) { 150 [array addObject: *data]; 151 data ++; 152 } 153 return array; 154} 155 156static void fillArray_count_(int* data, int count) 157{ 158 int i; 159 for (i = 0; i < count; i++) { 160 data[i] = i*i; 161 } 162} 163 164static int nullfillArray_count_(int* data, int count) 165{ 166 if (data == NULL) { 167 return 0; 168 } else { 169 fillArray_count_(data, count); 170 return 1; 171 } 172} 173 174static void fill4Tuple_(int* data) 175{ 176 int i; 177 for (i = 0; i < 4; i++) { 178 data[i] = - i * i * i; 179 } 180} 181 182static int nullfill4Tuple_(int* data) 183{ 184 if (data == NULL) { 185 return 0; 186 } else { 187 fill4Tuple_(data); 188 return 1; 189 } 190} 191 192static int fillStringArray_(char** data __attribute__((__unused__))) 193{ 194 return -1; 195} 196 197static int nullfillStringArray_(char** data) 198{ 199 if (data == NULL) return 0; 200 fillStringArray_(data); 201 return 1; 202} 203 204static void reverseArray_count_(float* data, int count) 205{ 206 float t; 207 int i; 208 for (i = 0; i < count / 2; i++) { 209 t = data[i]; 210 data[i] = data[count - 1 - i]; 211 data[count - 1 -i] = t; 212 } 213} 214 215static int nullreverseArray_count_(float* data, int count) 216{ 217 if (data == NULL) return 0; 218 reverseArray_count_(data, count); 219 return 1; 220} 221 222static void reverseStrings_(char** data) 223{ 224 int count, i; 225 char* t; 226 227 for (count = 0; data[count] != NULL; count++) { 228 ; 229 } 230 231 for (i = 0; i < count / 2 ; i++) { 232 t = data[i]; 233 data[i] = data[count-1-i]; 234 data[count-1-i] = t; 235 } 236} 237 238static int nullreverseStrings_(char** data) 239{ 240 if (data == NULL) return 0; 241 reverseStrings_(data); 242 return 1; 243} 244 245static void reverse4Tuple_(short* data) 246{ 247 short t; 248 249 t = data[0]; 250 data[0] = data[3]; 251 data[3] = t; 252 253 t = data[1]; 254 data[1] = data[2]; 255 data[2] = t; 256} 257 258static int nullreverse4Tuple_(short* data) 259{ 260 if (data == NULL) return 0; 261 reverse4Tuple_(data); 262 return 1; 263} 264 265 266static int sumX_andY_(int* x, int* y) 267{ 268 return *x + *y; 269} 270 271static int divBy5_remainder_(int x, int* r) 272{ 273 *r = x % 5; 274 return x / 5; 275} 276 277static void swapX_andY_(double* x, double* y) 278{ 279 int t = *x; 280 *x = *y; 281 *y = t; 282} 283 284static NSArray* input_output_inputAndOutput_(int* x, int* y, int* z) 285{ 286 char buf[64]; 287 NSMutableArray* result = [NSMutableArray array]; 288 289 snprintf(buf, sizeof(buf), "%p", x); 290 [result addObject: [NSString stringWithCString:buf]]; 291 292 snprintf(buf, sizeof(buf), "%p", y); 293 [result addObject: [NSString stringWithCString:buf]]; 294 295 snprintf(buf, sizeof(buf), "%p", z); 296 [result addObject: [NSString stringWithCString:buf]]; 297 298 if (y) { 299 if (x) { 300 if (z) { 301 *y = *x + *z; 302 } else { 303 *y = *x + 42; 304 } 305 } else if (z) { 306 *y = 42 - *z; 307 } else { 308 *y = -1; 309 } 310 } 311 312 if (z) { 313 if (x) { 314 *z = *x - *z; 315 } else { 316 *z = -*z; 317 } 318 } 319 320 return result; 321} 322 323static int fillArray_uptoCount_(int* data, int count) 324{ 325 int i; 326 for (i = 0; i < count / 2; i++) { 327 data[i] = i + 2; 328 } 329 for (i = count/2; i < count; i++) { 330 data[i] = -42; 331 } 332 return count/2; 333} 334 335static int maybyFillArray_(int *data) 336{ 337 int i; 338 for (i = 0; i < 2; i++) { 339 data[i] = i + 10; 340 } 341 for (i = 2; i < 4; i++) { 342 data[i] = -42; 343 } 344 return 2; 345} 346 347static int reverseArray_uptoCount_(float* data, int count) 348{ 349 reverseArray_count_(data, count); 350 return count/2; 351} 352 353static int maybeReverseArray_(short* data) 354{ 355 reverse4Tuple_(data); 356 return 2; 357} 358 359 360static NSArray* makeArrayWithFormat_(NSString* fmt, ...) 361{ 362 va_list ap; 363 char buffer[2048]; 364 365 va_start(ap, fmt); 366 vsnprintf(buffer, sizeof(buffer), [fmt UTF8String], ap); 367 va_end(ap); 368 369 return [NSArray arrayWithObjects: 370 fmt, 371 [NSString stringWithUTF8String:buffer], 372 NULL]; 373} 374 375static NSArray* makeArrayWithCFormat_(char* fmt, ...) 376{ 377 va_list ap; 378 char buffer[2048]; 379 380 va_start(ap, fmt); 381 vsnprintf(buffer, sizeof(buffer), fmt, ap); 382 va_end(ap); 383 384 return [NSArray arrayWithObjects: 385 [NSString stringWithUTF8String:fmt], 386 [NSString stringWithUTF8String:buffer], 387 NULL]; 388} 389 390static int maybeFillArray_(int* data) 391{ 392 int i; 393 for (i = 0; i < 2; i++) { 394 data[i] = i + 10; 395 } 396 for (i = 2; i < 4; i++) { 397 data[i] = -42; 398 } 399 return 2; 400} 401 402 403typedef void (*F)(void); 404static struct function { 405 char* name; 406 F function; 407} gFunctionMap[] = { 408 { "makeIntArrayOf5", (F)makeIntArrayOf5 }, 409 { "makeStringArray", (F)makeStringArray }, 410 { "makeIntArrayOf_", (F)makeIntArrayOf_ }, 411 { "nullIntArrayOf5", (F)nullIntArrayOf5 }, 412 { "nullStringArray", (F)nullStringArray }, 413 { "nullIntArrayOf_", (F)nullIntArrayOf_ }, 414 { "nullIntArray_count_", (F)nullIntArray_count_ }, 415 { "makeIntArray_countPtr_", (F)makeIntArray_countPtr_ }, 416 { "makeIntArray_count_", (F)makeIntArray_count_ }, 417 { "make4Tuple_", (F)make4Tuple_ }, 418 { "null4Tuple_", (F)null4Tuple_ }, 419 { "nullStringArray_", (F)nullStringArray_ }, 420 { "makeStringArray_", (F)makeStringArray_ }, 421 { "makeObjectArray_", (F)makeObjectArray_ }, 422 { "fillArray_count_", (F)fillArray_count_ }, 423 { "nullfillArray_count_", (F)nullfillArray_count_ }, 424 { "fill4Tuple_", (F)fill4Tuple_ }, 425 { "nullfill4Tuple_", (F)nullfill4Tuple_ }, 426 { "fillStringArray_", (F)fillStringArray_ }, 427 { "nullfillStringArray_", (F)nullfillStringArray_ }, 428 { "reverseArray_count_", (F)reverseArray_count_ }, 429 { "nullreverseArray_count_", (F)nullreverseArray_count_ }, 430 { "reverseStrings_", (F)reverseStrings_ }, 431 { "nullreverseStrings_", (F)nullreverseStrings_ }, 432 { "reverse4Tuple_", (F)reverse4Tuple_ }, 433 { "nullreverse4Tuple_", (F)nullreverse4Tuple_ }, 434 { "sumX_andY_", (F)sumX_andY_ }, 435 { "divBy5_remainder_", (F)divBy5_remainder_ }, 436 { "swapX_andY_", (F)swapX_andY_ }, 437 { "input_output_inputAndOutput_", (F)input_output_inputAndOutput_ }, 438 { "fillArray_uptoCount_", (F)fillArray_uptoCount_ }, 439 { "maybyFillArray_", (F)maybyFillArray_ }, 440 { "reverseArray_uptoCount_", (F)reverseArray_uptoCount_ }, 441 { "maybeReverseArray_", (F)maybeReverseArray_ }, 442 { "makeArrayWithFormat_", (F)makeArrayWithFormat_ }, 443 { "makeArrayWithCFormat_", (F)makeArrayWithCFormat_ }, 444 { "maybeFillArray_", (F)maybeFillArray_ }, 445 446 { NULL, NULL } 447}; 448 449 450static PyMethodDef mod_methods[] = { 451 { 0, 0, 0, 0 } 452}; 453 454void initmetadatafunction(void); 455void initmetadatafunction(void) 456{ 457 PyObject* m; 458 PyObject* v; 459 460 m = Py_InitModule4("metadatafunction", mod_methods, NULL, NULL, PYTHON_API_VERSION); 461 462 PyObjC_ImportAPI(m); 463 464 v = PyCObject_FromVoidPtr(gFunctionMap, NULL); 465 PyModule_AddObject(m, "function_list", v); 466} 467