Mercurial > pidgin3 / file comparison

comparison: libpurple/plugins/perl/perl-common.c

libpurple/plugins/perl/perl-common.c

changeset 15884
4de1981757fc
parent 15435
4b933b06d75e
child 16238
33bf2fd32108
child 17208
30553e3612f8
child 20478
46933dc62880
equal deleted inserted replaced
15883:969b74a3e27a 15884:4de1981757fc
5 5
6 extern PerlInterpreter *my_perl; 6 extern PerlInterpreter *my_perl;
7 7
8 static GHashTable *object_stashes = NULL; 8 static GHashTable *object_stashes = NULL;
9 9
10 void gaim_perl_normalize_script_name(char *name) 10 void purple_perl_normalize_script_name(char *name)
11 { 11 {
12 char *c; 12 char *c;
13 13
14 c = strrchr(name, '.'); 14 c = strrchr(name, '.');
15 15
63 63
64 return sv; 64 return sv;
65 } 65 }
66 66
67 SV * 67 SV *
68 gaim_perl_bless_object(void *object, const char *stash_name) 68 purple_perl_bless_object(void *object, const char *stash_name)
69 { 69 {
70 HV *stash; 70 HV *stash;
71 HV *hv; 71 HV *hv;
72 72
73 if (object == NULL) 73 if (object == NULL)
78 } 78 }
79 79
80 stash = gv_stashpv(stash_name, 1); 80 stash = gv_stashpv(stash_name, 1);
81 81
82 hv = newHV(); 82 hv = newHV();
83 hv_store(hv, "_gaim", 5, create_sv_ptr(object), 0); 83 hv_store(hv, "_purple", 5, create_sv_ptr(object), 0);
84 84
85 return sv_bless(newRV_noinc((SV *)hv), stash); 85 return sv_bless(newRV_noinc((SV *)hv), stash);
86 } 86 }
87 87
88 gboolean 88 gboolean
89 gaim_perl_is_ref_object(SV *o) 89 purple_perl_is_ref_object(SV *o)
90 { 90 {
91 SV **sv; 91 SV **sv;
92 HV *hv; 92 HV *hv;
93 93
94 hv = hvref(o); 94 hv = hvref(o);
95 95
96 if (hv != NULL) { 96 if (hv != NULL) {
97 sv = hv_fetch(hv, "_gaim", 5, 0); 97 sv = hv_fetch(hv, "_purple", 5, 0);
98 98
99 if (sv != NULL) 99 if (sv != NULL)
100 return TRUE; 100 return TRUE;
101 } 101 }
102 102
103 return FALSE; 103 return FALSE;
104 } 104 }
105 105
106 void * 106 void *
107 gaim_perl_ref_object(SV *o) 107 purple_perl_ref_object(SV *o)
108 { 108 {
109 SV **sv; 109 SV **sv;
110 HV *hv; 110 HV *hv;
111 void *p; 111 void *p;
112 112
116 hv = hvref(o); 116 hv = hvref(o);
117 117
118 if (hv == NULL) 118 if (hv == NULL)
119 return NULL; 119 return NULL;
120 120
121 sv = hv_fetch(hv, "_gaim", 5, 0); 121 sv = hv_fetch(hv, "_purple", 5, 0);
122 122
123 if (sv == NULL) 123 if (sv == NULL)
124 croak("variable is damaged"); 124 croak("variable is damaged");
125 125
126 p = GINT_TO_POINTER(SvIV(*sv)); 126 p = GINT_TO_POINTER(SvIV(*sv));
200 /* 200 /*
201 * Check for "die," make sure we have 1 argument, and set our 201 * Check for "die," make sure we have 1 argument, and set our
202 * return value. 202 * return value.
203 */ 203 */
204 if (SvTRUE(ERRSV)) { 204 if (SvTRUE(ERRSV)) {
205 gaim_debug(GAIM_DEBUG_ERROR, "perl", 205 purple_debug(PURPLE_DEBUG_ERROR, "perl",
206 "Perl function %s exited abnormally: %s\n", 206 "Perl function %s exited abnormally: %s\n",
207 function, SvPV(ERRSV, na)); 207 function, SvPV(ERRSV, na));
208 POPs; 208 POPs;
209 } else if (count != 1) { 209 } else if (count != 1) {
210 /* 210 /*
211 * This should NEVER happen. G_SCALAR ensures that we WILL 211 * This should NEVER happen. G_SCALAR ensures that we WILL
212 * have 1 parameter. 212 * have 1 parameter.
213 */ 213 */
214 gaim_debug(GAIM_DEBUG_ERROR, "perl", 214 purple_debug(PURPLE_DEBUG_ERROR, "perl",
215 "Perl error from %s: expected 1 return value, " 215 "Perl error from %s: expected 1 return value, "
216 "but got %d\n", function, count); 216 "but got %d\n", function, count);
217 } else 217 } else
218 ret_value = POPi; 218 ret_value = POPi;
219 219
243 return ret_value; 243 return ret_value;
244 } 244 }
245 245
246 #if 0 246 #if 0
247 gboolean 247 gboolean
248 gaim_perl_value_from_sv(GaimValue *value, SV *sv) 248 purple_perl_value_from_sv(PurpleValue *value, SV *sv)
249 { 249 {
250 switch (gaim_value_get_type(value)) 250 switch (purple_value_get_type(value))
251 { 251 {
252 case GAIM_TYPE_CHAR: 252 case PURPLE_TYPE_CHAR:
253 if ((tmp = SvGChar(sv)) != NULL) 253 if ((tmp = SvGChar(sv)) != NULL)
254 gaim_value_set_char(value, tmp[0]); 254 purple_value_set_char(value, tmp[0]);
255 else 255 else
256 return FALSE; 256 return FALSE;
257 break; 257 break;
258 258
259 case GAIM_TYPE_UCHAR: 259 case PURPLE_TYPE_UCHAR:
260 if ((tmp = SvPV_nolen(sv)) != NULL) 260 if ((tmp = SvPV_nolen(sv)) != NULL)
261 gaim_value_set_uchar(value, tmp[0]); 261 purple_value_set_uchar(value, tmp[0]);
262 else 262 else
263 return FALSE; 263 return FALSE;
264 break; 264 break;
265 265
266 case GAIM_TYPE_BOOLEAN: 266 case PURPLE_TYPE_BOOLEAN:
267 gaim_value_set_boolean(value, SvTRUE(sv)); 267 purple_value_set_boolean(value, SvTRUE(sv));
268 break; 268 break;
269 269
270 case GAIM_TYPE_INT: 270 case PURPLE_TYPE_INT:
271 gaim_value_set_int(value, SvIV(sv)); 271 purple_value_set_int(value, SvIV(sv));
272 break; 272 break;
273 273
274 case GAIM_TYPE_UINT: 274 case PURPLE_TYPE_UINT:
275 gaim_value_set_uint(value, SvIV(sv)); 275 purple_value_set_uint(value, SvIV(sv));
276 break; 276 break;
277 277
278 case GAIM_TYPE_LONG: 278 case PURPLE_TYPE_LONG:
279 gaim_value_set_long(value, SvIV(sv)); 279 purple_value_set_long(value, SvIV(sv));
280 break; 280 break;
281 281
282 case GAIM_TYPE_ULONG: 282 case PURPLE_TYPE_ULONG:
283 gaim_value_set_ulong(value, SvIV(sv)); 283 purple_value_set_ulong(value, SvIV(sv));
284 break; 284 break;
285 285
286 case GAIM_TYPE_INT64: 286 case PURPLE_TYPE_INT64:
287 gaim_value_set_int64(value, SvIV(sv)); 287 purple_value_set_int64(value, SvIV(sv));
288 break; 288 break;
289 289
290 case GAIM_TYPE_UINT64: 290 case PURPLE_TYPE_UINT64:
291 gaim_value_set_uint64(value, SvIV(sv)); 291 purple_value_set_uint64(value, SvIV(sv));
292 break; 292 break;
293 293
294 case GAIM_TYPE_STRING: 294 case PURPLE_TYPE_STRING:
295 gaim_value_set_string(value, SvGChar(sv)); 295 purple_value_set_string(value, SvGChar(sv));
296 break; 296 break;
297 297
298 case GAIM_TYPE_POINTER: 298 case PURPLE_TYPE_POINTER:
299 gaim_value_set_pointer(value, (void *)SvIV(sv)); 299 purple_value_set_pointer(value, (void *)SvIV(sv));
300 break; 300 break;
301 301
302 case GAIM_TYPE_BOXED: 302 case PURPLE_TYPE_BOXED:
303 if (!strcmp(gaim_value_get_specific_type(value), "SV")) 303 if (!strcmp(purple_value_get_specific_type(value), "SV"))
304 gaim_value_set_boxed(value, (sv == &PL_sv_undef ? NULL : sv)); 304 purple_value_set_boxed(value, (sv == &PL_sv_undef ? NULL : sv));
305 else 305 else
306 gaim_value_set_boxed(value, sv); 306 purple_value_set_boxed(value, sv);
307 break; 307 break;
308 308
309 default: 309 default:
310 return FALSE; 310 return FALSE;
311 } 311 }
312 312
313 return TRUE; 313 return TRUE;
314 } 314 }
315 315
316 SV * 316 SV *
317 gaim_perl_sv_from_value(const GaimValue *value, va_list list) 317 purple_perl_sv_from_value(const PurpleValue *value, va_list list)
318 { 318 {
319 switch (gaim_value_get_type(value)) 319 switch (purple_value_get_type(value))
320 { 320 {
321 case GAIM_TYPE_BOOLEAN: 321 case PURPLE_TYPE_BOOLEAN:
322 return newSViv(gaim_value_get_boolean(value)); 322 return newSViv(purple_value_get_boolean(value));
323 break; 323 break;
324 324
325 case GAIM_TYPE_INT: 325 case PURPLE_TYPE_INT:
326 return newSViv(gaim_value_get_int(value)); 326 return newSViv(purple_value_get_int(value));
327 break; 327 break;
328 328
329 case GAIM_TYPE_UINT: 329 case PURPLE_TYPE_UINT:
330 return newSVuv(gaim_value_get_uint(value)); 330 return newSVuv(purple_value_get_uint(value));
331 break; 331 break;
332 332
333 case GAIM_TYPE_LONG: 333 case PURPLE_TYPE_LONG:
334 return newSViv(gaim_value_get_long(value)); 334 return newSViv(purple_value_get_long(value));
335 break; 335 break;
336 336
337 case GAIM_TYPE_ULONG: 337 case PURPLE_TYPE_ULONG:
338 return newSVuv(gaim_value_get_ulong(value)); 338 return newSVuv(purple_value_get_ulong(value));
339 break; 339 break;
340 340
341 case GAIM_TYPE_INT64: 341 case PURPLE_TYPE_INT64:
342 return newSViv(gaim_value_get_int64(value)); 342 return newSViv(purple_value_get_int64(value));
343 break; 343 break;
344 344
345 case GAIM_TYPE_UINT64: 345 case PURPLE_TYPE_UINT64:
346 return newSVuv(gaim_value_get_int64(value)); 346 return newSVuv(purple_value_get_int64(value));
347 break; 347 break;
348 348
349 case GAIM_TYPE_STRING: 349 case PURPLE_TYPE_STRING:
350 return newSVGChar(gaim_value_get_string(value)); 350 return newSVGChar(purple_value_get_string(value));
351 break; 351 break;
352 352
353 case GAIM_TYPE_POINTER: 353 case PURPLE_TYPE_POINTER:
354 return newSViv((IV)gaim_value_get_pointer(value)); 354 return newSViv((IV)purple_value_get_pointer(value));
355 break; 355 break;
356 356
357 case GAIM_TYPE_BOXED: 357 case PURPLE_TYPE_BOXED:
358 if (!strcmp(gaim_value_get_specific_type(value), "SV")) 358 if (!strcmp(purple_value_get_specific_type(value), "SV"))
359 { 359 {
360 SV *sv = (SV *)gaim_perl_get_boxed(value); 360 SV *sv = (SV *)purple_perl_get_boxed(value);
361 361
362 return (sv == NULL ? &PL_sv_undef : sv); 362 return (sv == NULL ? &PL_sv_undef : sv);
363 } 363 }
364 364
365 /* Uh.. I dunno. Try this? */ 365 /* Uh.. I dunno. Try this? */
366 return sv_2mortal(gaim_perl_bless_object( 366 return sv_2mortal(purple_perl_bless_object(
367 gaim_perl_get_boxed(value), 367 purple_perl_get_boxed(value),
368 gaim_value_get_specific_type(value))); 368 purple_value_get_specific_type(value)));
369 369
370 default: 370 default:
371 return FALSE; 371 return FALSE;
372 } 372 }
373 373
374 return TRUE; 374 return TRUE;
375 } 375 }
376 #endif 376 #endif
377 377
378 void * 378 void *
379 gaim_perl_data_from_sv(GaimValue *value, SV *sv) 379 purple_perl_data_from_sv(PurpleValue *value, SV *sv)
380 { 380 {
381 STRLEN na; 381 STRLEN na;
382 382
383 switch (gaim_value_get_type(value)) { 383 switch (purple_value_get_type(value)) {
384 case GAIM_TYPE_BOOLEAN: return (void *)SvIV(sv); 384 case PURPLE_TYPE_BOOLEAN: return (void *)SvIV(sv);
385 case GAIM_TYPE_INT: return (void *)SvIV(sv); 385 case PURPLE_TYPE_INT: return (void *)SvIV(sv);
386 case GAIM_TYPE_UINT: return (void *)SvUV(sv); 386 case PURPLE_TYPE_UINT: return (void *)SvUV(sv);
387 case GAIM_TYPE_LONG: return (void *)SvIV(sv); 387 case PURPLE_TYPE_LONG: return (void *)SvIV(sv);
388 case GAIM_TYPE_ULONG: return (void *)SvUV(sv); 388 case PURPLE_TYPE_ULONG: return (void *)SvUV(sv);
389 case GAIM_TYPE_INT64: return (void *)SvIV(sv); 389 case PURPLE_TYPE_INT64: return (void *)SvIV(sv);
390 case GAIM_TYPE_UINT64: return (void *)SvUV(sv); 390 case PURPLE_TYPE_UINT64: return (void *)SvUV(sv);
391 case GAIM_TYPE_STRING: return g_strdup((void *)SvPV(sv, na)); 391 case PURPLE_TYPE_STRING: return g_strdup((void *)SvPV(sv, na));
392 case GAIM_TYPE_POINTER: return (void *)SvIV(sv); 392 case PURPLE_TYPE_POINTER: return (void *)SvIV(sv);
393 case GAIM_TYPE_BOXED: return (void *)SvIV(sv); 393 case PURPLE_TYPE_BOXED: return (void *)SvIV(sv);
394 394
395 default: 395 default:
396 return NULL; 396 return NULL;
397 } 397 }
398 398
399 return NULL; 399 return NULL;
400 } 400 }
401 401
402 static SV * 402 static SV *
403 gaim_perl_sv_from_subtype(const GaimValue *value, void *arg) 403 purple_perl_sv_from_subtype(const PurpleValue *value, void *arg)
404 { 404 {
405 const char *stash = NULL; 405 const char *stash = NULL;
406 406
407 switch (gaim_value_get_subtype(value)) { 407 switch (purple_value_get_subtype(value)) {
408 case GAIM_SUBTYPE_ACCOUNT: 408 case PURPLE_SUBTYPE_ACCOUNT:
409 stash = "Gaim::Account"; 409 stash = "Purple::Account";
410 break; 410 break;
411 case GAIM_SUBTYPE_BLIST: 411 case PURPLE_SUBTYPE_BLIST:
412 stash = "Gaim::BuddyList"; 412 stash = "Purple::BuddyList";
413 break; 413 break;
414 case GAIM_SUBTYPE_BLIST_BUDDY: 414 case PURPLE_SUBTYPE_BLIST_BUDDY:
415 stash = "Gaim::BuddyList::Buddy"; 415 stash = "Purple::BuddyList::Buddy";
416 break; 416 break;
417 case GAIM_SUBTYPE_BLIST_GROUP: 417 case PURPLE_SUBTYPE_BLIST_GROUP:
418 stash = "Gaim::BuddyList::Group"; 418 stash = "Purple::BuddyList::Group";
419 break; 419 break;
420 case GAIM_SUBTYPE_BLIST_CHAT: 420 case PURPLE_SUBTYPE_BLIST_CHAT:
421 stash = "Gaim::BuddyList::Chat"; 421 stash = "Purple::BuddyList::Chat";
422 break; 422 break;
423 case GAIM_SUBTYPE_BUDDY_ICON: 423 case PURPLE_SUBTYPE_BUDDY_ICON:
424 stash = "Gaim::Buddy::Icon"; 424 stash = "Purple::Buddy::Icon";
425 break; 425 break;
426 case GAIM_SUBTYPE_CONNECTION: 426 case PURPLE_SUBTYPE_CONNECTION:
427 stash = "Gaim::Connection"; 427 stash = "Purple::Connection";
428 break; 428 break;
429 case GAIM_SUBTYPE_CONVERSATION: 429 case PURPLE_SUBTYPE_CONVERSATION:
430 stash = "Gaim::Conversation"; 430 stash = "Purple::Conversation";
431 break; 431 break;
432 case GAIM_SUBTYPE_PLUGIN: 432 case PURPLE_SUBTYPE_PLUGIN:
433 stash = "Gaim::Plugin"; 433 stash = "Purple::Plugin";
434 break; 434 break;
435 case GAIM_SUBTYPE_BLIST_NODE: 435 case PURPLE_SUBTYPE_BLIST_NODE:
436 stash = "Gaim::BuddyList::Node"; 436 stash = "Purple::BuddyList::Node";
437 break; 437 break;
438 case GAIM_SUBTYPE_CIPHER: 438 case PURPLE_SUBTYPE_CIPHER:
439 stash = "Gaim::Cipher"; 439 stash = "Purple::Cipher";
440 break; 440 break;
441 case GAIM_SUBTYPE_STATUS: 441 case PURPLE_SUBTYPE_STATUS:
442 stash = "Gaim::Status"; 442 stash = "Purple::Status";
443 break; 443 break;
444 case GAIM_SUBTYPE_LOG: 444 case PURPLE_SUBTYPE_LOG:
445 stash = "Gaim::Log"; 445 stash = "Purple::Log";
446 break; 446 break;
447 case GAIM_SUBTYPE_XFER: 447 case PURPLE_SUBTYPE_XFER:
448 stash = "Gaim::Xfer"; 448 stash = "Purple::Xfer";
449 break; 449 break;
450 case GAIM_SUBTYPE_XMLNODE: 450 case PURPLE_SUBTYPE_XMLNODE:
451 stash = "Gaim::XMLNode"; 451 stash = "Purple::XMLNode";
452 break; 452 break;
453 453
454 default: 454 default:
455 stash = "Gaim"; /* ? */ 455 stash = "Purple"; /* ? */
456 } 456 }
457 457
458 return sv_2mortal(gaim_perl_bless_object(arg, stash)); 458 return sv_2mortal(purple_perl_bless_object(arg, stash));
459 } 459 }
460 460
461 SV * 461 SV *
462 gaim_perl_sv_from_vargs(const GaimValue *value, va_list *args, void ***copy_arg) 462 purple_perl_sv_from_vargs(const PurpleValue *value, va_list *args, void ***copy_arg)
463 { 463 {
464 if (gaim_value_is_outgoing(value)) { 464 if (purple_value_is_outgoing(value)) {
465 switch (gaim_value_get_type(value)) { 465 switch (purple_value_get_type(value)) {
466 case GAIM_TYPE_SUBTYPE: 466 case PURPLE_TYPE_SUBTYPE:
467 if ((*copy_arg = va_arg(*args, void **)) == NULL) 467 if ((*copy_arg = va_arg(*args, void **)) == NULL)
468 return &PL_sv_undef; 468 return &PL_sv_undef;
469 469
470 return gaim_perl_sv_from_subtype(value, *(void **)*copy_arg); 470 return purple_perl_sv_from_subtype(value, *(void **)*copy_arg);
471 471
472 case GAIM_TYPE_BOOLEAN: 472 case PURPLE_TYPE_BOOLEAN:
473 if ((*copy_arg = (void *)va_arg(*args, gboolean *)) == NULL) 473 if ((*copy_arg = (void *)va_arg(*args, gboolean *)) == NULL)
474 return &PL_sv_undef; 474 return &PL_sv_undef;
475 475
476 return newSViv(*(gboolean *)*copy_arg); 476 return newSViv(*(gboolean *)*copy_arg);
477 477
478 case GAIM_TYPE_INT: 478 case PURPLE_TYPE_INT:
479 if ((*copy_arg = (void *)va_arg(*args, int *)) == NULL) 479 if ((*copy_arg = (void *)va_arg(*args, int *)) == NULL)
480 return &PL_sv_undef; 480 return &PL_sv_undef;
481 481
482 return newSViv(*(int *)*copy_arg); 482 return newSViv(*(int *)*copy_arg);
483 483
484 case GAIM_TYPE_UINT: 484 case PURPLE_TYPE_UINT:
485 if ((*copy_arg = (void *)va_arg(*args, unsigned int *)) == NULL) 485 if ((*copy_arg = (void *)va_arg(*args, unsigned int *)) == NULL)
486 return &PL_sv_undef; 486 return &PL_sv_undef;
487 487
488 return newSVuv(*(unsigned int *)*copy_arg); 488 return newSVuv(*(unsigned int *)*copy_arg);
489 489
490 case GAIM_TYPE_LONG: 490 case PURPLE_TYPE_LONG:
491 if ((*copy_arg = (void *)va_arg(*args, long *)) == NULL) 491 if ((*copy_arg = (void *)va_arg(*args, long *)) == NULL)
492 return &PL_sv_undef; 492 return &PL_sv_undef;
493 493
494 return newSViv(*(long *)*copy_arg); 494 return newSViv(*(long *)*copy_arg);
495 495
496 case GAIM_TYPE_ULONG: 496 case PURPLE_TYPE_ULONG:
497 if ((*copy_arg = (void *)va_arg(*args, 497 if ((*copy_arg = (void *)va_arg(*args,
498 unsigned long *)) == NULL) 498 unsigned long *)) == NULL)
499 return &PL_sv_undef; 499 return &PL_sv_undef;
500 500
501 return newSVuv(*(unsigned long *)*copy_arg); 501 return newSVuv(*(unsigned long *)*copy_arg);
502 502
503 case GAIM_TYPE_INT64: 503 case PURPLE_TYPE_INT64:
504 if ((*copy_arg = (void *)va_arg(*args, gint64 *)) == NULL) 504 if ((*copy_arg = (void *)va_arg(*args, gint64 *)) == NULL)
505 return &PL_sv_undef; 505 return &PL_sv_undef;
506 506
507 return newSViv(*(gint64 *)*copy_arg); 507 return newSViv(*(gint64 *)*copy_arg);
508 508
509 case GAIM_TYPE_UINT64: 509 case PURPLE_TYPE_UINT64:
510 if ((*copy_arg = (void *)va_arg(*args, guint64 *)) == NULL) 510 if ((*copy_arg = (void *)va_arg(*args, guint64 *)) == NULL)
511 return &PL_sv_undef; 511 return &PL_sv_undef;
512 512
513 return newSVuv(*(guint64 *)*copy_arg); 513 return newSVuv(*(guint64 *)*copy_arg);
514 514
515 case GAIM_TYPE_STRING: 515 case PURPLE_TYPE_STRING:
516 if ((*copy_arg = (void *)va_arg(*args, char **)) == NULL) 516 if ((*copy_arg = (void *)va_arg(*args, char **)) == NULL)
517 return &PL_sv_undef; 517 return &PL_sv_undef;
518 518
519 return newSVGChar(*(char **)*copy_arg); 519 return newSVGChar(*(char **)*copy_arg);
520 520
521 case GAIM_TYPE_POINTER: 521 case PURPLE_TYPE_POINTER:
522 if ((*copy_arg = va_arg(*args, void **)) == NULL) 522 if ((*copy_arg = va_arg(*args, void **)) == NULL)
523 return &PL_sv_undef; 523 return &PL_sv_undef;
524 524
525 return newSViv((IV)*(void **)*copy_arg); 525 return newSViv((IV)*(void **)*copy_arg);
526 526
527 case GAIM_TYPE_BOXED: 527 case PURPLE_TYPE_BOXED:
528 /* Uh.. I dunno. Try this? */ 528 /* Uh.. I dunno. Try this? */
529 if ((*copy_arg = va_arg(*args, void **)) == NULL) 529 if ((*copy_arg = va_arg(*args, void **)) == NULL)
530 return &PL_sv_undef; 530 return &PL_sv_undef;
531 531
532 return sv_2mortal(gaim_perl_bless_object( 532 return sv_2mortal(purple_perl_bless_object(
533 *(void **)*copy_arg, 533 *(void **)*copy_arg,
534 gaim_value_get_specific_type(value))); 534 purple_value_get_specific_type(value)));
535 535
536 default: 536 default:
537 /* If this happens, things are going to get screwed up... */ 537 /* If this happens, things are going to get screwed up... */
538 return NULL; 538 return NULL;
539 } 539 }
540 } else { 540 } else {
541 switch (gaim_value_get_type(value)) { 541 switch (purple_value_get_type(value)) {
542 case GAIM_TYPE_SUBTYPE: 542 case PURPLE_TYPE_SUBTYPE:
543 if ((*copy_arg = va_arg(*args, void *)) == NULL) 543 if ((*copy_arg = va_arg(*args, void *)) == NULL)
544 return &PL_sv_undef; 544 return &PL_sv_undef;
545 545
546 return gaim_perl_sv_from_subtype(value, *copy_arg); 546 return purple_perl_sv_from_subtype(value, *copy_arg);
547 547
548 case GAIM_TYPE_BOOLEAN: 548 case PURPLE_TYPE_BOOLEAN:
549 *copy_arg = GINT_TO_POINTER( va_arg(*args, gboolean) ); 549 *copy_arg = GINT_TO_POINTER( va_arg(*args, gboolean) );
550 550
551 return newSViv((gboolean)GPOINTER_TO_INT(*copy_arg)); 551 return newSViv((gboolean)GPOINTER_TO_INT(*copy_arg));
552 552
553 case GAIM_TYPE_INT: 553 case PURPLE_TYPE_INT:
554 *copy_arg = GINT_TO_POINTER( va_arg(*args, int) ); 554 *copy_arg = GINT_TO_POINTER( va_arg(*args, int) );
555 555
556 return newSViv(GPOINTER_TO_INT(*copy_arg)); 556 return newSViv(GPOINTER_TO_INT(*copy_arg));
557 557
558 case GAIM_TYPE_UINT: 558 case PURPLE_TYPE_UINT:
559 *copy_arg = GUINT_TO_POINTER(va_arg(*args, unsigned int)); 559 *copy_arg = GUINT_TO_POINTER(va_arg(*args, unsigned int));
560 560
561 return newSVuv(GPOINTER_TO_UINT(*copy_arg)); 561 return newSVuv(GPOINTER_TO_UINT(*copy_arg));
562 562
563 case GAIM_TYPE_LONG: 563 case PURPLE_TYPE_LONG:
564 *copy_arg = (void *)va_arg(*args, long); 564 *copy_arg = (void *)va_arg(*args, long);
565 565
566 return newSViv((long)*copy_arg); 566 return newSViv((long)*copy_arg);
567 567
568 case GAIM_TYPE_ULONG: 568 case PURPLE_TYPE_ULONG:
569 *copy_arg = (void *)va_arg(*args, unsigned long); 569 *copy_arg = (void *)va_arg(*args, unsigned long);
570 570
571 return newSVuv((unsigned long)*copy_arg); 571 return newSVuv((unsigned long)*copy_arg);
572 572
573 case GAIM_TYPE_INT64: 573 case PURPLE_TYPE_INT64:
574 #if 0 574 #if 0
575 /* XXX This yells and complains. */ 575 /* XXX This yells and complains. */
576 *copy_arg = va_arg(*args, gint64); 576 *copy_arg = va_arg(*args, gint64);
577 577
578 return newSViv(*copy_arg); 578 return newSViv(*copy_arg);
579 #endif 579 #endif
580 break; 580 break;
581 581
582 case GAIM_TYPE_UINT64: 582 case PURPLE_TYPE_UINT64:
583 /* XXX This also yells and complains. */ 583 /* XXX This also yells and complains. */
584 #if 0 584 #if 0
585 *copy_arg = (void *)va_arg(*args, guint64); 585 *copy_arg = (void *)va_arg(*args, guint64);
586 586
587 return newSVuv(*copy_arg); 587 return newSVuv(*copy_arg);
588 #endif 588 #endif
589 break; 589 break;
590 590
591 case GAIM_TYPE_STRING: 591 case PURPLE_TYPE_STRING:
592 if ((*copy_arg = (void *)va_arg(*args, char *)) == NULL) 592 if ((*copy_arg = (void *)va_arg(*args, char *)) == NULL)
593 return &PL_sv_undef; 593 return &PL_sv_undef;
594 594
595 return newSVGChar((char *)*copy_arg); 595 return newSVGChar((char *)*copy_arg);
596 596
597 case GAIM_TYPE_POINTER: 597 case PURPLE_TYPE_POINTER:
598 if ((*copy_arg = (void *)va_arg(*args, void *)) == NULL) 598 if ((*copy_arg = (void *)va_arg(*args, void *)) == NULL)
599 return &PL_sv_undef; 599 return &PL_sv_undef;
600 600
601 return newSViv((IV)*copy_arg); 601 return newSViv((IV)*copy_arg);
602 602
603 case GAIM_TYPE_BOXED: 603 case PURPLE_TYPE_BOXED:
604 /* Uh.. I dunno. Try this? */ 604 /* Uh.. I dunno. Try this? */
605 if ((*copy_arg = (void *)va_arg(*args, void *)) == NULL) 605 if ((*copy_arg = (void *)va_arg(*args, void *)) == NULL)
606 return &PL_sv_undef; 606 return &PL_sv_undef;
607 607
608 return sv_2mortal(gaim_perl_bless_object(*copy_arg, 608 return sv_2mortal(purple_perl_bless_object(*copy_arg,
609 gaim_value_get_specific_type(value))); 609 purple_value_get_specific_type(value)));
610 610
611 default: 611 default:
612 /* If this happens, things are going to get screwed up... */ 612 /* If this happens, things are going to get screwed up... */
613 return NULL; 613 return NULL;
614 } 614 }

Mercurial Repository: pidgin3

mercurial