Go to the documentation of this file.
11 #ifndef __GA_IntrinsicMacros__
12 #define __GA_IntrinsicMacros__
125 #define GA_START_INTRINSIC_DEF(CLASS, NUM_INTRINSICS) \
128 class _ga_intrinsicEvaluator##CLASS \
131 typedef GA_Size (*cbTupleSize)(const CLASS *obj); \
132 typedef GA_Size (*cbEvalI)(const CLASS *obj, int64 *v, GA_Size size); \
133 typedef GA_Size (*cbEvalF)(const CLASS *obj, fpreal64 *v, GA_Size size); \
134 typedef GA_Size (*cbEvalS)(const CLASS *obj, UT_String &s); \
135 typedef GA_Size (*cbEvalSA)(const CLASS *obj, UT_StringArray &s); \
136 typedef GA_Size (*cbEvalD)(const CLASS *obj, UT_OptionsHolder &s); \
137 typedef GA_Size (*cbEvalDA)(const CLASS *obj, UT_Array<UT_OptionsHolder> &s); \
138 typedef GA_Size (*cbSetI)(CLASS *obj, const int64 *v, GA_Size size); \
139 typedef GA_Size (*cbSetF)(CLASS *obj, const fpreal64 *v, GA_Size size); \
140 typedef GA_Size (*cbSetS)(CLASS *obj, const char **v, GA_Size size); \
141 typedef GA_Size (*cbSetSA)(CLASS *obj, const UT_StringArray &v); \
142 typedef GA_Size (*cbSetD)(CLASS *obj, const UT_OptionsHolder *v, GA_Size size); \
143 typedef GA_Size (*cbSetDA)(CLASS *obj, const UT_Array<UT_OptionsHolder> &v); \
144 static GA_Size failTS(const CLASS *) { return 0; } \
145 static GA_Size failI(const CLASS *, int64 *, GA_Size) { UT_ASSERT(0); return 0; } \
146 static GA_Size failF(const CLASS *, fpreal64 *, GA_Size) { UT_ASSERT(0); return 0; } \
147 static GA_Size failS(const CLASS *, UT_String &) { UT_ASSERT(0); return 0; } \
148 static GA_Size failSA(const CLASS *, UT_StringArray &) { UT_ASSERT(0); return 0; } \
149 static GA_Size failD(const CLASS *, UT_OptionsHolder &) { UT_ASSERT(0); return 0; } \
150 static GA_Size failDA(const CLASS *, UT_Array<UT_OptionsHolder> &) { UT_ASSERT(0); return 0; } \
151 static GA_Size failI(CLASS *, const int64 *, GA_Size) { UT_ASSERT(0); return 0; } \
152 static GA_Size failF(CLASS *, const fpreal64 *, GA_Size) { UT_ASSERT(0); return 0; } \
153 static GA_Size failS(CLASS *, const char **, GA_Size) { UT_ASSERT(0); return 0; } \
154 static GA_Size failSA(CLASS *, const UT_StringArray &) { UT_ASSERT(0); return 0; } \
155 static GA_Size failD(CLASS *, const UT_OptionsHolder *, GA_Size) { UT_ASSERT(0); return 0; } \
156 static GA_Size failDA(CLASS *, const UT_Array<UT_OptionsHolder> &) { UT_ASSERT(0); return 0; } \
164 , myStore(GA_STORECLASS_INVALID) \
165 , myTupleSizeCB(failTS) \
182 GA_Size getTupleSize(const CLASS *o) const \
184 if (myTupleSize > 0) return myTupleSize; \
185 return myTupleSizeCB(o); \
188 fprintf(stderr, "Intrinsic[%d] := {\n", myId); \
189 fprintf(stderr, " 'name' : '%s'\n", myName); \
190 fprintf(stderr, " 'tuple' : %d\n", (int)myTupleSize); \
191 fprintf(stderr, " 'storage' : %s\n", GAstorageClass(myStore));\
192 fprintf(stderr, " 'ro' : %d\n", myReadOnly); \
193 fprintf(stderr, " 'tuple()' : %p\n", myTupleSizeCB); \
194 fprintf(stderr, " 'options' : %p\n", myOptions); \
195 fprintf(stderr, " 'I()' : %p\n", myI); \
196 fprintf(stderr, " 'F()' : %p\n", myF); \
197 fprintf(stderr, " 'S()' : %p\n", myS); \
198 fprintf(stderr, " 'SA()' : %p\n", mySA); \
199 fprintf(stderr, " 'D()' : %p\n", myD); \
200 fprintf(stderr, " 'DA()' : %p\n", myDA); \
201 fprintf(stderr, " 'setI()' : %p\n", mySetI); \
202 fprintf(stderr, " 'setF()' : %p\n", mySetF); \
203 fprintf(stderr, " 'setSS()' : %p\n", mySetSS); \
204 fprintf(stderr, " 'setSA()' : %p\n", mySetSA); \
205 fprintf(stderr, " 'setDS()' : %p\n", mySetDS); \
206 fprintf(stderr, " 'setDA()' : %p\n", mySetDA); \
208 bool valid(int index) const \
210 if (myName && myId >= 0 && myStore != GA_STORECLASS_INVALID \
211 && (myTupleSize > 0 || myTupleSizeCB) \
212 && (myI || myF || myS || mySA)) \
214 fprintf(stderr, "Warning: missing intrinsic for %s[%d]\n", \
218 cbTupleSize myTupleSizeCB; \
231 const char *myName; \
232 const UT_Options *myOptions; \
233 GA_Size myTupleSize; \
235 GA_StorageClass myStore; \
238 Eval myEval[NUM_INTRINSICS]; \
239 int entries() const { return NUM_INTRINSICS; } \
240 bool valid(int i) const { return myEval[i].valid(i); } \
241 GA_Size getTupleSize(int i, const CLASS *o) const \
242 { return myEval[i].getTupleSize(o); } \
243 GA_Size evalI(int i, const CLASS *o, int64 *v, GA_Size n) const \
244 { return myEval[i].myI(o, v, n); } \
245 GA_Size evalF(int i, const CLASS *o, fpreal64 *v, GA_Size n) const \
246 { return myEval[i].myF(o, v, n); } \
247 GA_Size evalS(int i, const CLASS *o, UT_String &v) const \
248 { return myEval[i].myS(o, v); } \
249 GA_Size evalSA(int i, const CLASS *o, UT_StringArray &v) const \
250 { return myEval[i].mySA(o, v); } \
251 GA_Size evalD(int i, const CLASS *o, UT_OptionsHolder &v) const \
252 { return myEval[i].myD(o, v); } \
253 GA_Size evalDA(int i, const CLASS *o, UT_Array<UT_OptionsHolder> &v) const \
254 { return myEval[i].myDA(o, v); } \
255 GA_Size setI(int i, CLASS *o, const int64 *v, GA_Size n) const \
256 { return myEval[i].mySetI(o, v, n); } \
257 GA_Size setF(int i, CLASS *o, const fpreal64 *v, GA_Size n) const \
258 { return myEval[i].mySetF(o, v, n); } \
259 GA_Size setSS(int i, CLASS *o, const char **v, GA_Size n) const \
260 { return myEval[i].mySetSS(o, v, n); } \
261 GA_Size setSA(int i, CLASS *o, const UT_StringArray &v) const \
262 { return myEval[i].mySetSA(o, v); } \
263 GA_Size setDS(int i, CLASS *o, const UT_OptionsHolder *v, GA_Size n) const \
264 { return myEval[i].mySetDS(o, v, n); } \
265 GA_Size setDA(int i, CLASS *o, const UT_Array<UT_OptionsHolder> &v) const \
266 { return myEval[i].mySetDA(o, v); } \
267 GA_StorageClass getStorageClass(int i) const \
268 { return myEval[i].myStore; } \
269 const char *getName(int i) const { return myEval[i].myName; } \
270 int getId(int i) const { return myEval[i].myId; } \
271 bool getReadOnly(int i) const { return myEval[i].myReadOnly; } \
272 const UT_Options *getOptions(int i) const \
273 { return myEval[i].myOptions; } \
274 _ga_intrinsicEvaluator##CLASS() {
276 #define GA_END_INTRINSIC_DEF(CLASS, BASECLASS) \
279 static GA_IntrinsicDef _theIntrinsics##CLASS; \
280 static _ga_intrinsicEvaluator##CLASS _theEval##CLASS; \
282 GA_IntrinsicManager::Registrar \
283 CLASS::registerIntrinsics(GA_PrimitiveDefinition &defn) \
285 GA_IntrinsicManager::Registrar r(BASECLASS::registerIntrinsics(defn)); \
286 if (r.start(_theIntrinsics##CLASS)) \
288 for (int i = 0; i < _theEval##CLASS.entries(); ++i) \
290 UT_ASSERT(_theEval##CLASS.getName(i)); \
291 if (_theEval##CLASS.valid(i)) \
293 r.addAttribute(_theEval##CLASS.getStorageClass(i), \
294 _theEval##CLASS.getName(i), \
295 _theEval##CLASS.getId(i), \
296 _theEval##CLASS.getReadOnly(i), \
297 _theEval##CLASS.getOptions(i)); \
304 CLASS::localIntrinsicTupleSize(const GA_IntrinsicEval &eval) const \
306 int id = eval.getUserId(_theIntrinsics##CLASS); \
307 if (id >= 0 && id < _theEval##CLASS.entries()) \
308 return _theEval##CLASS.getTupleSize(id, this); \
309 return BASECLASS::localIntrinsicTupleSize(eval); \
312 CLASS::localGetIntrinsicI(const GA_IntrinsicEval &eval, \
313 int64 *v, GA_Size size) const \
315 int id = eval.getUserId(_theIntrinsics##CLASS); \
316 if (id >= 0 && id < _theEval##CLASS.entries()) \
317 return _theEval##CLASS.evalI(id, this, v, size); \
318 return BASECLASS::localGetIntrinsicI(eval, v, size); \
321 CLASS::localGetIntrinsicF(const GA_IntrinsicEval &eval, \
322 fpreal64 *v, GA_Size size) const \
324 int id = eval.getUserId(_theIntrinsics##CLASS); \
325 if (id >= 0 && id < _theEval##CLASS.entries()) \
326 return _theEval##CLASS.evalF(id, this, v, size); \
327 return BASECLASS::localGetIntrinsicF(eval, v, size); \
330 CLASS::localGetIntrinsicS(const GA_IntrinsicEval &eval, \
331 UT_String &v) const \
333 int id = eval.getUserId(_theIntrinsics##CLASS); \
334 if (id >= 0 && id < _theEval##CLASS.entries()) \
335 return _theEval##CLASS.evalS(id, this, v); \
336 return BASECLASS::localGetIntrinsicS(eval, v); \
339 CLASS::localGetIntrinsicSA(const GA_IntrinsicEval &eval, \
340 UT_StringArray &v) const \
342 int id = eval.getUserId(_theIntrinsics##CLASS); \
343 if (id >= 0 && id < _theEval##CLASS.entries()) \
344 return _theEval##CLASS.evalSA(id, this, v); \
345 return BASECLASS::localGetIntrinsicSA(eval, v); \
348 CLASS::localGetIntrinsicD(const GA_IntrinsicEval &eval, \
349 UT_OptionsHolder &v) const \
351 int id = eval.getUserId(_theIntrinsics##CLASS); \
352 if (id >= 0 && id < _theEval##CLASS.entries()) \
353 return _theEval##CLASS.evalD(id, this, v); \
354 return BASECLASS::localGetIntrinsicD(eval, v); \
357 CLASS::localGetIntrinsicDA(const GA_IntrinsicEval &eval, \
358 UT_Array<UT_OptionsHolder> &v) const \
360 int id = eval.getUserId(_theIntrinsics##CLASS); \
361 if (id >= 0 && id < _theEval##CLASS.entries()) \
362 return _theEval##CLASS.evalDA(id, this, v); \
363 return BASECLASS::localGetIntrinsicDA(eval, v); \
366 CLASS::localSetIntrinsicI(const GA_IntrinsicEval &eval, \
367 const int64 *v, GA_Size size) \
369 int id = eval.getUserId(_theIntrinsics##CLASS); \
370 if (id >= 0 && id < _theEval##CLASS.entries()) \
371 return _theEval##CLASS.setI(id, this, v, size); \
372 return BASECLASS::localSetIntrinsicI(eval, v, size); \
375 CLASS::localSetIntrinsicF(const GA_IntrinsicEval &eval, \
376 const fpreal64 *v, GA_Size size) \
378 int id = eval.getUserId(_theIntrinsics##CLASS); \
379 if (id >= 0 && id < _theEval##CLASS.entries()) \
380 return _theEval##CLASS.setF(id, this, v, size); \
381 return BASECLASS::localSetIntrinsicF(eval, v, size); \
384 CLASS::localSetIntrinsicSS(const GA_IntrinsicEval &eval, \
385 const char **v, GA_Size size) \
387 int id = eval.getUserId(_theIntrinsics##CLASS); \
388 if (id >= 0 && id < _theEval##CLASS.entries()) \
389 return _theEval##CLASS.setSS(id, this, v, size); \
390 return BASECLASS::localSetIntrinsicSS(eval, v, size); \
393 CLASS::localSetIntrinsicSA(const GA_IntrinsicEval &eval, \
394 const UT_StringArray &v) \
396 int id = eval.getUserId(_theIntrinsics##CLASS); \
397 if (id >= 0 && id < _theEval##CLASS.entries()) \
398 return _theEval##CLASS.setSA(id, this, v); \
399 return BASECLASS::localSetIntrinsicSA(eval, v); \
402 CLASS::localSetIntrinsicDS(const GA_IntrinsicEval &eval, \
403 const UT_OptionsHolder *v, GA_Size size) \
405 int id = eval.getUserId(_theIntrinsics##CLASS); \
406 if (id >= 0 && id < _theEval##CLASS.entries()) \
407 return _theEval##CLASS.setDS(id, this, v, size); \
408 return BASECLASS::localSetIntrinsicDS(eval, v, size); \
411 CLASS::localSetIntrinsicDA(const GA_IntrinsicEval &eval, \
412 const UT_Array<UT_OptionsHolder> &v) \
414 int id = eval.getUserId(_theIntrinsics##CLASS); \
415 if (id >= 0 && id < _theEval##CLASS.entries()) \
416 return _theEval##CLASS.setDA(id, this, v); \
417 return BASECLASS::localSetIntrinsicDA(eval, v); \
421 #define GA_INTRINSIC_DEF(ID, NAME, TUPLESIZE, STORAGE) \
422 myEval[ID].myId = ID; \
423 myEval[ID].myName = NAME; \
424 myEval[ID].myStore = STORAGE; \
425 myEval[ID].myTupleSize = TUPLESIZE;
426 #define GA_INTRINSIC_DEF_VARYING(ID, NAME, TUPLESIZE_FUNC, STORAGE) \
427 myEval[ID].myId = ID; \
428 myEval[ID].myName = NAME; \
429 myEval[ID].myStore = STORAGE; \
430 myEval[ID].myTupleSizeCB = TUPLESIZE_FUNC;
435 #define GA_INTRINSIC_OPTIONS(ID, OPTIONS) \
436 myEval[ID].myOptions = &OPTIONS;
439 #define GA_INTRINSIC_DEF_I(ID, NAME, TUPLESIZE) \
440 GA_INTRINSIC_DEF(ID, NAME, TUPLESIZE, GA_STORECLASS_INT)
442 #define GA_INTRINSIC_DEF_VARYING_I(ID, NAME, TUPLESIZE_FUNC) \
443 GA_INTRINSIC_DEF_VARYING(ID, NAME, TUPLESIZE_FUNC, GA_STORECLASS_INT)
445 #define GA_INTRINSIC_I(CLASS, ID, NAME, EVAL) { \
447 static GA_Size eval(const CLASS *o, int64 *v, GA_Size) \
448 { v[0] = EVAL(o); return 1; } \
449 static GA_Size evalF(const CLASS *o, fpreal64 *v, GA_Size) \
450 { v[0] = EVAL(o); return 1; } \
452 GA_INTRINSIC_DEF_I(ID, NAME, 1) \
453 myEval[ID].myI = callbacks::eval; \
454 myEval[ID].myF = callbacks::evalF; \
456 #define GA_INTRINSIC_CONST_I(CLASS, ID, NAME, VALUE) { \
458 static GA_Size eval(const CLASS *, int64 *v, GA_Size) \
459 { v[0] = VALUE; return 1; } \
460 static GA_Size evalF(const CLASS *, fpreal64 *v, GA_Size) \
461 { v[0] = VALUE; return 1; } \
463 GA_INTRINSIC_DEF_I(ID, NAME, 1) \
464 myEval[ID].myI = callbacks::eval; \
465 myEval[ID].myF = callbacks::evalF; \
467 #define GA_INTRINSIC_METHOD_I(CLASS, ID, NAME, METHOD) { \
469 static GA_Size eval(const CLASS *o, int64 *v, GA_Size) \
470 { v[0] = o->METHOD(); return 1; } \
471 static GA_Size evalF(const CLASS *o, fpreal64 *v, GA_Size) \
472 { v[0] = o->METHOD(); return 1; } \
474 GA_INTRINSIC_DEF_I(ID, NAME, 1) \
475 myEval[ID].myI = callbacks::eval; \
476 myEval[ID].myF = callbacks::evalF; \
478 #define GA_INTRINSIC_TUPLE_I(CLASS, ID, NAME, TUPLESIZE, EVAL) { \
480 static GA_Size evalF(const CLASS *o, fpreal64 *v, GA_Size sz) \
481 { int64 tmp[TUPLESIZE]; \
482 int result = EVAL(o, tmp, SYSmin(sz, TUPLESIZE)); \
483 for (int i = 0; i < SYSmin(sz, TUPLESIZE); i++) \
487 GA_INTRINSIC_DEF_I(ID, NAME, TUPLESIZE) \
488 myEval[ID].myI = EVAL; \
489 myEval[ID].myF = callbacks::evalF; \
491 #define GA_INTRINSIC_TUPLE_METHOD_I(CLASS, ID, NAME, TUPLESIZE, EVAL) { \
493 static GA_Size eval(const CLASS *o, int64 *v, GA_Size sz) \
494 { return o->EVAL(v, sz); } \
495 static GA_Size evalF(const CLASS *o, fpreal64 *v, GA_Size sz) \
496 { int64 tmp[TUPLESIZE]; \
497 int result = o->EVAL(tmp, SYSmin(sz, TUPLESIZE)); \
498 for (exint i = 0; i < SYSmin(sz, TUPLESIZE); i++) { v[i] = tmp[i]; } \
501 GA_INTRINSIC_DEF_I(ID, NAME, TUPLESIZE) \
502 myEval[ID].myI = callbacks::eval; \
504 #define GA_INTRINSIC_ARRAY_I(CLASS, ID, NAME, ARRAY_TYPE, METHOD) { \
506 static GA_Size tsize(const CLASS *o) { return o->METHOD().entries(); } \
507 static GA_Size eval(const CLASS *o, int64 *v, GA_Size size) \
509 const ARRAY_TYPE &array = o->METHOD(); \
510 size = SYSmin(size, array.entries()); \
511 for (exint i = 0; i < size; ++i) { v[i] = array(i); } \
515 GA_INTRINSIC_DEF_VARYING_I(ID, NAME, callbacks::tsize) \
516 myEval[ID].myI = callbacks::eval; \
518 #define GA_INTRINSIC_VARYING_I(CLASS, ID, NAME, TSIZE, EVAL) { \
519 GA_INTRINSIC_DEF_VARYING_I(ID, NAME, TSIZE) \
520 myEval[ID].myI = EVAL; \
523 #define GA_INTRINSIC_SET_I(CLASS, ID, SETFUNC) { \
525 static GA_Size setFunc(CLASS *o, const int64 *v, GA_Size sz) \
526 { return SETFUNC(o, v[0]) ? 1 : 0; } \
527 static GA_Size setFuncF(CLASS *o, const fpreal64 *v, GA_Size sz) \
528 { return SETFUNC(o, v[0]) ? 1 : 0; } \
530 myEval[ID].mySetI = callbacks::setFunc; \
531 myEval[ID].mySetF = callbacks::setFuncF; \
532 myEval[ID].myReadOnly = false; \
534 #define GA_INTRINSIC_SET_METHOD_I(CLASS, ID, METHOD) { \
536 static GA_Size setFunc(CLASS *o, const int64 *v, GA_Size sz) \
537 { return o->METHOD(v[0]) ? 1 : 0; } \
538 static GA_Size setFuncF(CLASS *o, const fpreal64 *v, GA_Size sz) \
539 { return o->METHOD(v[0]) ? 1 : 0; } \
541 myEval[ID].mySetI = callbacks::setFunc; \
542 myEval[ID].mySetF = callbacks::setFuncF; \
543 myEval[ID].myReadOnly = false; \
545 #define GA_INTRINSIC_SET_TUPLE_I(CLASS, ID, SETFUNC) { \
547 static GA_Size setFunc(CLASS *o, const int64 *v, GA_Size sz) \
548 { return SETFUNC(o, v, sz); } \
549 static GA_Size setFuncF(CLASS *o, const fpreal64 *v, GA_Size sz) \
551 int64 *tmp = (int64 *)UTstackAlloc(sizeof(int64) * sz); \
552 for (exint i = 0; i < sz; i++) { tmp[i] = v[i]; } \
553 int result = SETFUNC(o, tmp, sz); \
558 myEval[ID].mySetI = callbacks::setFunc; \
559 myEval[ID].mySetF = callbacks::setFuncF; \
560 myEval[ID].myReadOnly = false; \
562 #define GA_INTRINSIC_SET_TUPLE_METHOD_I(CLASS, ID, METHOD) { \
564 static GA_Size setFunc(CLASS *o, const int64 *v, GA_Size sz) \
565 { return o->METHOD(v[0], sz); } \
566 static GA_Size setFuncF(CLASS *o, const fpreal64 *v, GA_Size sz) \
568 int64 *tmp = (int64 *)UTstackAlloc(sizeof(int64) * sz); \
569 for (exint i = 0; i < sz; i++) { tmp[i] = v[i]; } \
570 int result = o->SETFUNC(tmp, sz); \
575 myEval[ID].mySetI = callbacks::setFunc; \
576 myEval[ID].mySetF = callbacks::setFuncF; \
577 myEval[ID].myReadOnly = false; \
581 #define GA_INTRINSIC_DEF_F(ID, NAME, TUPLESIZE) \
582 GA_INTRINSIC_DEF(ID, NAME, TUPLESIZE, GA_STORECLASS_FLOAT)
584 #define GA_INTRINSIC_DEF_VARYING_F(ID, NAME, TUPLESIZE_FUNC) \
585 GA_INTRINSIC_DEF_VARYING(ID, NAME, TUPLESIZE_FUNC, GA_STORECLASS_FLOAT)
587 #define GA_INTRINSIC_F(CLASS, ID, NAME, EVAL) { \
589 static GA_Size eval(const CLASS *o, fpreal64 *v, GA_Size) \
590 { v[0] = EVAL(o); return 1; } \
592 GA_INTRINSIC_DEF_F(ID, NAME, 1) \
593 myEval[ID].myF = callbacks::eval; \
595 #define GA_INTRINSIC_CONST_F(CLASS, ID, NAME, VALUE) { \
597 static GA_Size eval(const CLASS *, fpreal64 *v, GA_Size) \
598 { v[0] = VALUE; return 1; } \
600 GA_INTRINSIC_DEF_F(ID, NAME, 1) \
601 myEval[ID].myF = callbacks::eval; \
603 #define GA_INTRINSIC_METHOD_F(CLASS, ID, NAME, METHOD) { \
605 static GA_Size eval(const CLASS *o, fpreal64 *v, GA_Size) \
606 { v[0] = o->METHOD(); return 1; } \
608 GA_INTRINSIC_DEF_F(ID, NAME, 1) \
609 myEval[ID].myF = callbacks::eval; \
611 #define GA_INTRINSIC_TUPLE_F(CLASS, ID, NAME, TUPLESIZE, EVAL) { \
612 GA_INTRINSIC_DEF_F(ID, NAME, TUPLESIZE) \
613 myEval[ID].myF = EVAL; \
615 #define GA_INTRINSIC_TUPLE_METHOD_F(CLASS, ID, NAME, TUPLESIZE, EVAL) { \
617 static GA_Size eval(const CLASS *o, fpreal64 *v, GA_Size sz) \
618 { return o->EVAL(v, sz); } \
620 GA_INTRINSIC_DEF_F(ID, NAME, TUPLESIZE) \
621 myEval[ID].myF = callbacks::eval; \
623 #define GA_INTRINSIC_ARRAY_F(CLASS, ID, NAME, ARRAY_TYPE, METHOD) { \
625 static GA_Size tsize(const CLASS *o) { return o->METHOD().entries(); } \
626 static GA_Size eval(const CLASS *o, fpreal64 *v, GA_Size size) \
628 const ARRAY_TYPE &array = o->METHOD(); \
629 size = SYSmin(size, array.entries()); \
630 for (exint i = 0; i < size; ++i) { v[i] = array(i); } \
634 GA_INTRINSIC_DEF_VARYING_F(ID, NAME, callbacks::tsize) \
635 myEval[ID].myF = callbacks::eval; \
637 #define GA_INTRINSIC_VARYING_F(CLASS, ID, NAME, TSIZE, EVAL) { \
638 GA_INTRINSIC_DEF_VARYING_F(ID, NAME, TSIZE) \
639 myEval[ID].myF = EVAL; \
642 #define GA_INTRINSIC_SET_F(CLASS, ID, SETFUNC) { \
644 static GA_Size setFunc(CLASS *o, const fpreal64 *v, GA_Size sz) \
645 { SETFUNC(o, v[0]); return 1; } \
647 myEval[ID].mySetF = callbacks::setFunc; \
648 myEval[ID].myReadOnly = false; \
650 #define GA_INTRINSIC_SET_METHOD_F(CLASS, ID, METHOD) { \
652 static GA_Size setFunc(CLASS *o, const fpreal64 *v, GA_Size sz) \
653 { o->METHOD(v[0]); return 1; } \
655 myEval[ID].mySetF = callbacks::setFunc; \
656 myEval[ID].myReadOnly = false; \
658 #define GA_INTRINSIC_SET_TUPLE_F(CLASS, ID, SETFUNC) { \
660 static GA_Size setFunc(CLASS *o, const fpreal64 *v, GA_Size sz) \
661 { return SETFUNC(o, v, sz); } \
663 myEval[ID].mySetF = callbacks::setFunc; \
664 myEval[ID].myReadOnly = false; \
666 #define GA_INTRINSIC_SET_TUPLE_METHOD_F(CLASS, ID, METHOD) { \
668 static GA_Size setFunc(CLASS *o, const fpreal64 *v, GA_Size sz) \
669 { return o->METHOD(v[0], sz); } \
671 myEval[ID].mySetF = callbacks::setFunc; \
672 myEval[ID].myReadOnly = false; \
676 #define GA_INTRINSIC_DEF_S(ID, NAME, TUPLESIZE) \
677 GA_INTRINSIC_DEF(ID, NAME, TUPLESIZE, GA_STORECLASS_STRING)
679 #define GA_INTRINSIC_DEF_VARYING_S(ID, NAME, TUPLESIZE_FUNC) \
680 GA_INTRINSIC_DEF_VARYING(ID, NAME, TUPLESIZE_FUNC, GA_STORECLASS_STRING)
682 #define GA_INTRINSIC_S(CLASS, ID, NAME, EVAL) { \
684 static GA_Size evalS(const CLASS *o, UT_String &v) \
685 { v = EVAL(o); return 1; } \
686 static GA_Size evalSA(const CLASS *o, UT_StringArray &v) \
687 { v.append(EVAL(o)); return 1; } \
689 GA_INTRINSIC_DEF_S(ID, NAME, 1) \
690 myEval[ID].myS = callbacks::evalS; \
691 myEval[ID].mySA = callbacks::evalSA; \
693 #define GA_INTRINSIC_CONST_S(CLASS, ID, NAME, VALUE) { \
695 static GA_Size evalS(const CLASS *, UT_String &v) \
696 { v = VALUE; return 1; } \
697 static GA_Size evalSA(const CLASS *, UT_StringArray &v) \
698 { v.append(VALUE); return 1; } \
700 GA_INTRINSIC_DEF_S(ID, NAME, 1) \
701 myEval[ID].myS = callbacks::evalS; \
702 myEval[ID].mySA = callbacks::evalSA; \
704 #define GA_INTRINSIC_METHOD_S(CLASS, ID, NAME, METHOD) { \
706 static GA_Size evalS(const CLASS *o, UT_String &v) \
707 { v = o->METHOD(); return 1; } \
708 static GA_Size evalSA(const CLASS *o, UT_StringArray &v) \
709 { v.append(o->METHOD()); return 1; } \
711 GA_INTRINSIC_DEF_S(ID, NAME, 1) \
712 myEval[ID].myS = callbacks::evalS; \
713 myEval[ID].mySA = callbacks::evalSA; \
715 #define GA_INTRINSIC_TUPLE_S(CLASS, ID, NAME, TUPLESIZE, EVAL) { \
716 GA_INTRINSIC_DEF_S(ID, NAME, TUPLESIZE) \
717 myEval[ID].mySA = EVAL; \
719 #define GA_INTRINSIC_TUPLE_METHOD_S(CLASS, ID, NAME, TUPLESIZE, EVAL) { \
721 static GA_Size evalSA(const CLASS *o, UT_StringArray &v) \
722 { o->EVAL(v); return v.entries(); } \
724 GA_INTRINSIC_DEF_S(ID, NAME, TUPLESIZE) \
725 myEval[ID].mySA = callbacks::eval; \
727 #define GA_INTRINSIC_ARRAY_S(CLASS, ID, NAME, ARRAY_TYPE, METHOD) { \
729 static GA_Size tsize(const CLASS *o) { return o->METHOD().entries(); } \
730 static GA_Size eval(const CLASS *o, UT_StringArray &v) \
732 const ARRAY_TYPE &array = o->METHOD(); \
733 for (exint i = 0; i < size; ++i) { v[i].append(array(i)); } \
734 return v.entries(); \
737 GA_INTRINSIC_DEF_VARYING_S(ID, NAME, callbacks::tsize) \
738 myEval[ID].mySA = callbacks::eval; \
740 #define GA_INTRINSIC_VARYING_S(CLASS, ID, NAME, TSIZE, EVAL) { \
741 GA_INTRINSIC_DEF_VARYING_S(ID, NAME, TSIZE) \
742 myEval[ID].mySA = EVAL; \
745 #define GA_INTRINSIC_SET_S(CLASS, ID, SETFUNC) { \
747 static GA_Size setSS(CLASS *o, const char **v, GA_Size sz) \
748 { return SETFUNC(o, v[0]) ? 1 : 0; } \
749 static GA_Size setSA(CLASS *o, const UT_StringArray &a) \
750 { return SETFUNC(o, a(0)) ? 1 : 0; } \
752 myEval[ID].mySetSS = callbacks::setSS; \
753 myEval[ID].mySetSA = callbacks::setSA; \
754 myEval[ID].myReadOnly = false; \
756 #define GA_INTRINSIC_SET_METHOD_S(CLASS, ID, METHOD) { \
758 static GA_Size setSS(CLASS *o, const char **v, GA_Size) \
759 { return o->METHOD(v[0]) ? 1 : 0; } \
760 static GA_Size setSA(CLASS *o, const UT_StringArray &a) \
761 { return o->METHOD(a(0)) ? 1 : 0; } \
763 myEval[ID].mySetSS = callbacks::setSS; \
764 myEval[ID].mySetSA = callbacks::setSA; \
765 myEval[ID].myReadOnly = false; \
767 #define GA_INTRINSIC_SET_TUPLE_S(CLASS, ID, SETFUNC) { \
769 static GA_Size setSA(CLASS *o, const UT_StringArray &a) \
770 { return SETFUNC(o, a); } \
771 static GA_Size setSS(CLASS *o, const char **v, GA_Size sz) \
773 UT_StringArray array; \
775 for (exint i = 0; i < sz; ++i) array(i) = v[i]; \
776 return SETFUNC(o, array); \
779 myEval[ID].mySetSS = callbacks::setSS; \
780 myEval[ID].mySetSA = callbacks::setSA; \
781 myEval[ID].myReadOnly = false; \
783 #define GA_INTRINSIC_SET_TUPLE_METHOD_S(CLASS, ID, METHOD) { \
785 static GA_Size setSA(CLASS *o, const UT_StringArray &a) \
786 { return o->METHOD(a); } \
787 static GA_Size setSS(CLASS *o, const char **v, GA_Size sz) \
789 UT_StringArray array; \
791 for (exint i = 0; i < sz; ++i) array(i) = v[i]; \
792 return o->METHOD(array); \
795 myEval[ID].mySetSS = callbacks::setSS; \
796 myEval[ID].mySetSA = callbacks::setSA; \
797 myEval[ID].myReadOnly = false; \
801 #define GA_INTRINSIC_DEF_D(ID, NAME, TUPLESIZE) \
802 GA_INTRINSIC_DEF(ID, NAME, TUPLESIZE, GA_STORECLASS_DICT)
804 #define GA_INTRINSIC_DEF_VARYING_D(ID, NAME, TUPLESIZE_FUNC) \
805 GA_INTRINSIC_DEF_VARYING(ID, NAME, TUPLESIZE_FUNC, GA_STORECLASS_DICT)
807 #define GA_INTRINSIC_D(CLASS, ID, NAME, EVAL) { \
809 static GA_Size evalD(const CLASS *o, UT_OptionsHolder &v) \
810 { v = EVAL(o); return 1; } \
811 static GA_Size evalDA(const CLASS *o, UT_Array<UT_OptionsHolder> &v) \
812 { v.append(EVAL(o)); return 1; } \
814 GA_INTRINSIC_DEF_D(ID, NAME, 1) \
815 myEval[ID].myD = callbacks::evalD; \
816 myEval[ID].myDA = callbacks::evalDA; \
818 #define GA_INTRINSIC_CONST_D(CLASS, ID, NAME, VALUE) { \
820 static GA_Size evalD(const CLASS *, UT_OptionsHolder &v) \
821 { v = VALUE; return 1; } \
822 static GA_Size evalDA(const CLASS *, UT_Array<UT_OptionsHolder> &v) \
823 { v.append(VALUE); return 1; } \
825 GA_INTRINSIC_DEF_D(ID, NAME, 1) \
826 myEval[ID].myD = callbacks::evalD; \
827 myEval[ID].myDA = callbacks::evalDA; \
829 #define GA_INTRINSIC_METHOD_D(CLASS, ID, NAME, METHOD) { \
831 static GA_Size evalD(const CLASS *o, UT_OptionsHolder &v) \
832 { v = o->METHOD(); return 1; } \
833 static GA_Size evalDA(const CLASS *o, UT_Array<UT_OptionsHolder> &v) \
834 { v.append(o->METHOD()); return 1; } \
836 GA_INTRINSIC_DEF_D(ID, NAME, 1) \
837 myEval[ID].myD = callbacks::evalD; \
838 myEval[ID].myDA = callbacks::evalDA; \
840 #define GA_INTRINSIC_TUPLE_D(CLASS, ID, NAME, TUPLESIZE, EVAL) { \
841 GA_INTRINSIC_DEF_D(ID, NAME, TUPLESIZE) \
842 myEval[ID].myDA = EVAL; \
844 #define GA_INTRINSIC_TUPLE_METHOD_D(CLASS, ID, NAME, TUPLESIZE, EVAL) { \
846 static GA_Size evalDA(const CLASS *o, UT_Array<UT_OptionsHolder> &v) \
847 { o->EVAL(v); return v.entries(); } \
849 GA_INTRINSIC_DEF_D(ID, NAME, TUPLESIZE) \
850 myEval[ID].myDA = callbacks::eval; \
852 #define GA_INTRINSIC_ARRAY_D(CLASS, ID, NAME, ARRAY_TYPE, METHOD) { \
854 static GA_Size tsize(const CLASS *o) { return o->METHOD().entries(); } \
855 static GA_Size eval(const CLASS *o, UT_Array<UT_OptionsHolder> &v) \
857 const ARRAY_TYPE &array = o->METHOD(); \
858 for (exint i = 0; i < size; ++i) { v[i].append(array(i)); } \
859 return v.entries(); \
862 GA_INTRINSIC_DEF_VARYING_D(ID, NAME, callbacks::tsize) \
863 myEval[ID].myDA = callbacks::eval; \
865 #define GA_INTRINSIC_VARYING_D(CLASS, ID, NAME, TSIZE, EVAL) { \
866 GA_INTRINSIC_DEF_VARYING_D(ID, NAME, TSIZE) \
867 myEval[ID].myDA = EVAL; \
870 #define GA_INTRINSIC_SET_D(CLASS, ID, SETFUNC) { \
872 static GA_Size setDS(CLASS *o, const UT_OptionsHolder *v, GA_Size sz) \
873 { return SETFUNC(o, v[0]) ? 1 : 0; } \
874 static GA_Size setDA(CLASS *o, const UT_Array<UT_OptionsHolder> &a) \
875 { return SETFUNC(o, a(0)) ? 1 : 0; } \
877 myEval[ID].mySetDS = callbacks::setDS; \
878 myEval[ID].mySetDA = callbacks::setDA; \
879 myEval[ID].myReadOnly = false; \
881 #define GA_INTRINSIC_SET_METHOD_D(CLASS, ID, METHOD) { \
883 static GA_Size setDS(CLASS *o, const UT_OptionsHolder *v, GA_Size) \
884 { return o->METHOD(v[0]) ? 1 : 0; } \
885 static GA_Size setDA(CLASS *o, const UT_Array<UT_OptionsHolder> &a) \
886 { return o->METHOD(a(0)) ? 1 : 0; } \
888 myEval[ID].mySetDS = callbacks::setDS; \
889 myEval[ID].mySetDA = callbacks::setDA; \
890 myEval[ID].myReadOnly = false; \
892 #define GA_INTRINSIC_SET_TUPLE_D(CLASS, ID, SETFUNC) { \
894 static GA_Size setDA(CLASS *o, const UT_Array<UT_OptionsHolder> &a) \
895 { return SETFUNC(o, a); } \
896 static GA_Size setDS(CLASS *o, const UT_OptionsHolder *v, GA_Size sz) \
898 UT_Array<UT_OptionsHolder> array; \
900 for (exint i = 0; i < sz; ++i) array(i) = v[i]; \
901 return SETFUNC(o, array); \
904 myEval[ID].mySetDS = callbacks::setDS; \
905 myEval[ID].mySetDA = callbacks::setDA; \
906 myEval[ID].myReadOnly = false; \
908 #define GA_INTRINSIC_SET_TUPLE_METHOD_D(CLASS, ID, METHOD) { \
910 static GA_Size setDA(CLASS *o, const UT_Array<UT_OptionsHolder> &a) \
911 { return o->METHOD(a); } \
912 static GA_Size setDS(CLASS *o, const UT_OptionsHolder *v, GA_Size sz) \
914 UT_Array<UT_OptionsHolder> array; \
916 for (exint i = 0; i < sz; ++i) array(i) = v[i]; \
917 return o->METHOD(array); \
920 myEval[ID].mySetDS = callbacks::setDS; \
921 myEval[ID].mySetDA = callbacks::setDA; \
922 myEval[ID].myReadOnly = false; \