Mercurial > pidgin
comparison libpurple/plugins/perl/perl-common.c @ 15822:32c366eeeb99
sed -ie 's/gaim/purple/g'
author | Sean Egan <seanegan@gmail.com> |
---|---|
date | Mon, 19 Mar 2007 07:01:17 +0000 |
parents | 5fe8042783c1 |
children | c4237e963099 |
comparison
equal
deleted
inserted
replaced
15821:84b0f9b23ede | 15822:32c366eeeb99 |
---|---|
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 } |