1 /* -*- Mode: C; tab-width: 4; -*- */ 2 /* 3 * npupp.h $Revision: 1.3 $ 4 * function call mecahnics needed by platform specific glue code. 5 */ 6 7 8 #ifndef _NPUPP_H_ 9 #define _NPUPP_H_ 10 11 #ifndef GENERATINGCFM 12 #define GENERATINGCFM 0 13 #endif 14 15 #ifndef _NPAPI_H_ 16 #include "npapi.h" 17 #endif 18 19 #include "jri.h" 20 21 /****************************************************************************************** 22 plug-in function table macros 23 for each function in and out of the plugin API we define 24 typedef NPP_FooUPP 25 #define NewNPP_FooProc 26 #define CallNPP_FooProc 27 for mac, define the UPP magic for PPC/68K calling 28 *******************************************************************************************/ 29 30 31 /* NPP_Initialize */ 32 33 #if GENERATINGCFM 34 typedef UniversalProcPtr NPP_InitializeUPP; 35 36 enum { 37 uppNPP_InitializeProcInfo = kThinkCStackBased 38 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0)) 39 | RESULT_SIZE(SIZE_CODE(0)) 40 }; 41 42 #define NewNPP_InitializeProc(FUNC) \ 43 (NPP_InitializeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_InitializeProcInfo, GetCurrentArchitecture()) 44 #define CallNPP_InitializeProc(FUNC) \ 45 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_InitializeProcInfo) 46 47 #else 48 49 typedef void (*NPP_InitializeUPP)(void); 50 #define NewNPP_InitializeProc(FUNC) \ 51 ((NPP_InitializeUPP) (FUNC)) 52 #define CallNPP_InitializeProc(FUNC) \ 53 (*(FUNC))() 54 55 #endif 56 57 58 /* NPP_Shutdown */ 59 60 #if GENERATINGCFM 61 typedef UniversalProcPtr NPP_ShutdownUPP; 62 63 enum { 64 uppNPP_ShutdownProcInfo = kThinkCStackBased 65 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0)) 66 | RESULT_SIZE(SIZE_CODE(0)) 67 }; 68 69 #define NewNPP_ShutdownProc(FUNC) \ 70 (NPP_ShutdownUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_ShutdownProcInfo, GetCurrentArchitecture()) 71 #define CallNPP_ShutdownProc(FUNC) \ 72 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_ShutdownProcInfo) 73 74 #else 75 76 typedef void (*NPP_ShutdownUPP)(void); 77 #define NewNPP_ShutdownProc(FUNC) \ 78 ((NPP_ShutdownUPP) (FUNC)) 79 #define CallNPP_ShutdownProc(FUNC) \ 80 (*(FUNC))() 81 82 #endif 83 84 85 /* NPP_New */ 86 87 #if GENERATINGCFM 88 typedef UniversalProcPtr NPP_NewUPP; 89 90 enum { 91 uppNPP_NewProcInfo = kThinkCStackBased 92 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPMIMEType))) 93 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPP))) 94 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(uint16))) 95 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int16))) 96 | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char **))) 97 | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(char **))) 98 | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(NPSavedData *))) 99 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 100 }; 101 102 #define NewNPP_NewProc(FUNC) \ 103 (NPP_NewUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewProcInfo, GetCurrentArchitecture()) 104 #define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ 105 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewProcInfo, \ 106 (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) 107 #else 108 109 typedef NPError (*NPP_NewUPP)(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved); 110 #define NewNPP_NewProc(FUNC) \ 111 ((NPP_NewUPP) (FUNC)) 112 #define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ 113 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) 114 115 #endif 116 117 118 /* NPP_Destroy */ 119 120 #if GENERATINGCFM 121 122 typedef UniversalProcPtr NPP_DestroyUPP; 123 enum { 124 uppNPP_DestroyProcInfo = kThinkCStackBased 125 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 126 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPSavedData **))) 127 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 128 }; 129 #define NewNPP_DestroyProc(FUNC) \ 130 (NPP_DestroyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyProcInfo, GetCurrentArchitecture()) 131 #define CallNPP_DestroyProc(FUNC, ARG1, ARG2) \ 132 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyProcInfo, (ARG1), (ARG2)) 133 #else 134 135 typedef NPError (*NPP_DestroyUPP)(NPP instance, NPSavedData** save); 136 #define NewNPP_DestroyProc(FUNC) \ 137 ((NPP_DestroyUPP) (FUNC)) 138 #define CallNPP_DestroyProc(FUNC, ARG1, ARG2) \ 139 (*(FUNC))((ARG1), (ARG2)) 140 141 #endif 142 143 144 /* NPP_SetWindow */ 145 146 #if GENERATINGCFM 147 148 typedef UniversalProcPtr NPP_SetWindowUPP; 149 enum { 150 uppNPP_SetWindowProcInfo = kThinkCStackBased 151 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 152 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPWindow *))) 153 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 154 }; 155 #define NewNPP_SetWindowProc(FUNC) \ 156 (NPP_SetWindowUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_SetWindowProcInfo, GetCurrentArchitecture()) 157 #define CallNPP_SetWindowProc(FUNC, ARG1, ARG2) \ 158 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_SetWindowProcInfo, (ARG1), (ARG2)) 159 160 #else 161 162 typedef NPError (*NPP_SetWindowUPP)(NPP instance, NPWindow* window); 163 #define NewNPP_SetWindowProc(FUNC) \ 164 ((NPP_SetWindowUPP) (FUNC)) 165 #define CallNPP_SetWindowProc(FUNC, ARG1, ARG2) \ 166 (*(FUNC))((ARG1), (ARG2)) 167 168 #endif 169 170 171 /* NPP_NewStream */ 172 173 #if GENERATINGCFM 174 175 typedef UniversalProcPtr NPP_NewStreamUPP; 176 enum { 177 uppNPP_NewStreamProcInfo = kThinkCStackBased 178 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 179 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType))) 180 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPStream *))) 181 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPBool))) 182 | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint16 *))) 183 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 184 }; 185 #define NewNPP_NewStreamProc(FUNC) \ 186 (NPP_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewStreamProcInfo, GetCurrentArchitecture()) 187 #define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ 188 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewStreamProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) 189 #else 190 191 typedef NPError (*NPP_NewStreamUPP)(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype); 192 #define NewNPP_NewStreamProc(FUNC) \ 193 ((NPP_NewStreamUPP) (FUNC)) 194 #define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ 195 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) 196 #endif 197 198 199 /* NPP_DestroyStream */ 200 201 #if GENERATINGCFM 202 203 typedef UniversalProcPtr NPP_DestroyStreamUPP; 204 enum { 205 uppNPP_DestroyStreamProcInfo = kThinkCStackBased 206 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 207 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) 208 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason))) 209 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 210 }; 211 #define NewNPP_DestroyStreamProc(FUNC) \ 212 (NPP_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, GetCurrentArchitecture()) 213 #define CallNPP_DestroyStreamProc(FUNC, NPParg, NPStreamPtr, NPReasonArg) \ 214 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, (NPParg), (NPStreamPtr), (NPReasonArg)) 215 216 #else 217 218 typedef NPError (*NPP_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason); 219 #define NewNPP_DestroyStreamProc(FUNC) \ 220 ((NPP_DestroyStreamUPP) (FUNC)) 221 #define CallNPP_DestroyStreamProc(FUNC, NPParg, NPStreamPtr, NPReasonArg) \ 222 (*(FUNC))((NPParg), (NPStreamPtr), (NPReasonArg)) 223 224 #endif 225 226 227 /* NPP_WriteReady */ 228 229 #if GENERATINGCFM 230 231 typedef UniversalProcPtr NPP_WriteReadyUPP; 232 enum { 233 uppNPP_WriteReadyProcInfo = kThinkCStackBased 234 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 235 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) 236 | RESULT_SIZE(SIZE_CODE(sizeof(int32))) 237 }; 238 #define NewNPP_WriteReadyProc(FUNC) \ 239 (NPP_WriteReadyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, GetCurrentArchitecture()) 240 #define CallNPP_WriteReadyProc(FUNC, NPParg, NPStreamPtr) \ 241 (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, (NPParg), (NPStreamPtr)) 242 243 #else 244 245 typedef int32 (*NPP_WriteReadyUPP)(NPP instance, NPStream* stream); 246 #define NewNPP_WriteReadyProc(FUNC) \ 247 ((NPP_WriteReadyUPP) (FUNC)) 248 #define CallNPP_WriteReadyProc(FUNC, NPParg, NPStreamPtr) \ 249 (*(FUNC))((NPParg), (NPStreamPtr)) 250 251 #endif 252 253 254 /* NPP_Write */ 255 256 #if GENERATINGCFM 257 258 typedef UniversalProcPtr NPP_WriteUPP; 259 enum { 260 uppNPP_WriteProcInfo = kThinkCStackBased 261 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 262 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) 263 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32))) 264 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int32))) 265 | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(void*))) 266 | RESULT_SIZE(SIZE_CODE(sizeof(int32))) 267 }; 268 #define NewNPP_WriteProc(FUNC) \ 269 (NPP_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteProcInfo, GetCurrentArchitecture()) 270 #define CallNPP_WriteProc(FUNC, NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr) \ 271 (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteProcInfo, (NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr)) 272 273 #else 274 275 typedef int32 (*NPP_WriteUPP)(NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer); 276 #define NewNPP_WriteProc(FUNC) \ 277 ((NPP_WriteUPP) (FUNC)) 278 #define CallNPP_WriteProc(FUNC, NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr) \ 279 (*(FUNC))((NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr)) 280 281 #endif 282 283 284 /* NPP_StreamAsFile */ 285 286 #if GENERATINGCFM 287 288 typedef UniversalProcPtr NPP_StreamAsFileUPP; 289 enum { 290 uppNPP_StreamAsFileProcInfo = kThinkCStackBased 291 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 292 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) 293 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *))) 294 | RESULT_SIZE(SIZE_CODE(0)) 295 }; 296 #define NewNPP_StreamAsFileProc(FUNC) \ 297 (NPP_StreamAsFileUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, GetCurrentArchitecture()) 298 #define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3) \ 299 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, (ARG1), (ARG2), (ARG3)) 300 301 #else 302 303 typedef void (*NPP_StreamAsFileUPP)(NPP instance, NPStream* stream, const char* fname); 304 #define NewNPP_StreamAsFileProc(FUNC) \ 305 ((NPP_StreamAsFileUPP) (FUNC)) 306 #define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3) \ 307 (*(FUNC))((ARG1), (ARG2), (ARG3)) 308 #endif 309 310 311 /* NPP_Print */ 312 313 #if GENERATINGCFM 314 315 typedef UniversalProcPtr NPP_PrintUPP; 316 enum { 317 uppNPP_PrintProcInfo = kThinkCStackBased 318 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 319 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPrint *))) 320 | RESULT_SIZE(SIZE_CODE(0)) 321 }; 322 #define NewNPP_PrintProc(FUNC) \ 323 (NPP_PrintUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_PrintProcInfo, GetCurrentArchitecture()) 324 #define CallNPP_PrintProc(FUNC, NPParg, voidPtr) \ 325 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_PrintProcInfo, (NPParg), (voidPtr)) 326 327 #else 328 329 typedef void (*NPP_PrintUPP)(NPP instance, NPPrint* platformPrint); 330 #define NewNPP_PrintProc(FUNC) \ 331 ((NPP_PrintUPP) (FUNC)) 332 #define CallNPP_PrintProc(FUNC, NPParg, NPPrintArg) \ 333 (*(FUNC))((NPParg), (NPPrintArg)) 334 335 #endif 336 337 338 /* NPP_HandleEvent */ 339 340 #if GENERATINGCFM 341 342 typedef UniversalProcPtr NPP_HandleEventUPP; 343 enum { 344 uppNPP_HandleEventProcInfo = kThinkCStackBased 345 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 346 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *))) 347 | RESULT_SIZE(SIZE_CODE(sizeof(int16))) 348 }; 349 #define NewNPP_HandleEventProc(FUNC) \ 350 (NPP_HandleEventUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_HandleEventProcInfo, GetCurrentArchitecture()) 351 #define CallNPP_HandleEventProc(FUNC, NPParg, voidPtr) \ 352 (int16)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_HandleEventProcInfo, (NPParg), (voidPtr)) 353 354 #else 355 356 typedef int16 (*NPP_HandleEventUPP)(NPP instance, void* event); 357 #define NewNPP_HandleEventProc(FUNC) \ 358 ((NPP_HandleEventUPP) (FUNC)) 359 #define CallNPP_HandleEventProc(FUNC, NPParg, voidPtr) \ 360 (*(FUNC))((NPParg), (voidPtr)) 361 362 #endif 363 364 365 /* NPP_URLNotify */ 366 367 #if GENERATINGCFM 368 369 typedef UniversalProcPtr NPP_URLNotifyUPP; 370 enum { 371 uppNPP_URLNotifyProcInfo = kThinkCStackBased 372 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 373 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) 374 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason))) 375 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) 376 | RESULT_SIZE(SIZE_CODE(SIZE_CODE(0))) 377 }; 378 #define NewNPP_URLNotifyProc(FUNC) \ 379 (NPP_URLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, GetCurrentArchitecture()) 380 #define CallNPP_URLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ 381 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) 382 383 #else 384 385 typedef void (*NPP_URLNotifyUPP)(NPP instance, const char* url, NPReason reason, void* notifyData); 386 #define NewNPP_URLNotifyProc(FUNC) \ 387 ((NPP_URLNotifyUPP) (FUNC)) 388 #define CallNPP_URLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ 389 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) 390 391 #endif 392 393 394 395 396 /* 397 * Netscape entry points 398 */ 399 400 #ifdef XP_UNIX 401 402 /* NPN_GetValue */ 403 404 #if GENERATINGCFM 405 406 typedef UniversalProcPtr NPN_GetValueUPP; 407 enum { 408 uppNPN_GetValueProcInfo = kThinkCStackBased 409 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 410 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPNVariable))) 411 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) 412 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 413 }; 414 #define NewNPN_GetValueProc(FUNC) \ 415 (NPN_GetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetValueProcInfo, GetCurrentArchitecture()) 416 #define CallNPN_GetURNotifyLProc(FUNC, ARG1, ARG2, ARG3) \ 417 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetValueProcInfo, (ARG1), (ARG2), (ARG3)) 418 #else 419 420 typedef NPError (*NPN_GetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue); 421 #define NewNPN_GetValueProc(FUNC) \ 422 ((NPN_GetValueUPP) (FUNC)) 423 #define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ 424 (*(FUNC))((ARG1), (ARG2), (ARG3)) 425 #endif 426 427 #endif /* XP_UNIX */ 428 429 430 431 /* NPN_GetUrlNotify */ 432 433 #if GENERATINGCFM 434 435 typedef UniversalProcPtr NPN_GetURLNotifyUPP; 436 enum { 437 uppNPN_GetURLNotifyProcInfo = kThinkCStackBased 438 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 439 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) 440 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) 441 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) 442 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 443 }; 444 #define NewNPN_GetURLNotifyProc(FUNC) \ 445 (NPN_GetURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, GetCurrentArchitecture()) 446 #define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ 447 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) 448 #else 449 450 typedef NPError (*NPN_GetURLNotifyUPP)(NPP instance, const char* url, const char* window, void* notifyData); 451 #define NewNPN_GetURLNotifyProc(FUNC) \ 452 ((NPN_GetURLNotifyUPP) (FUNC)) 453 #define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ 454 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) 455 #endif 456 457 458 /* NPN_PostUrlNotify */ 459 460 #if GENERATINGCFM 461 462 typedef UniversalProcPtr NPN_PostURLNotifyUPP; 463 enum { 464 uppNPN_PostURLNotifyProcInfo = kThinkCStackBased 465 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 466 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) 467 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) 468 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32))) 469 | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*))) 470 | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool))) 471 | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(void*))) 472 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 473 }; 474 #define NewNPN_PostURLNotifyProc(FUNC) \ 475 (NPN_PostURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, GetCurrentArchitecture()) 476 #define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ 477 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) 478 #else 479 480 typedef NPError (*NPN_PostURLNotifyUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData); 481 #define NewNPN_PostURLNotifyProc(FUNC) \ 482 ((NPN_PostURLNotifyUPP) (FUNC)) 483 #define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ 484 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) 485 #endif 486 487 488 /* NPN_GetUrl */ 489 490 #if GENERATINGCFM 491 492 typedef UniversalProcPtr NPN_GetURLUPP; 493 enum { 494 uppNPN_GetURLProcInfo = kThinkCStackBased 495 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 496 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) 497 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) 498 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 499 }; 500 #define NewNPN_GetURLProc(FUNC) \ 501 (NPN_GetURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLProcInfo, GetCurrentArchitecture()) 502 #define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \ 503 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLProcInfo, (ARG1), (ARG2), (ARG3)) 504 #else 505 506 typedef NPError (*NPN_GetURLUPP)(NPP instance, const char* url, const char* window); 507 #define NewNPN_GetURLProc(FUNC) \ 508 ((NPN_GetURLUPP) (FUNC)) 509 #define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \ 510 (*(FUNC))((ARG1), (ARG2), (ARG3)) 511 #endif 512 513 514 /* NPN_PostUrl */ 515 516 #if GENERATINGCFM 517 518 typedef UniversalProcPtr NPN_PostURLUPP; 519 enum { 520 uppNPN_PostURLProcInfo = kThinkCStackBased 521 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 522 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) 523 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) 524 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32))) 525 | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*))) 526 | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool))) 527 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 528 }; 529 #define NewNPN_PostURLProc(FUNC) \ 530 (NPN_PostURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLProcInfo, GetCurrentArchitecture()) 531 #define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ 532 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) 533 #else 534 535 typedef NPError (*NPN_PostURLUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file); 536 #define NewNPN_PostURLProc(FUNC) \ 537 ((NPN_PostURLUPP) (FUNC)) 538 #define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ 539 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) 540 #endif 541 542 543 /* NPN_RequestRead */ 544 545 #if GENERATINGCFM 546 547 typedef UniversalProcPtr NPN_RequestReadUPP; 548 enum { 549 uppNPN_RequestReadProcInfo = kThinkCStackBased 550 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPStream *))) 551 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPByteRange *))) 552 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 553 }; 554 #define NewNPN_RequestReadProc(FUNC) \ 555 (NPN_RequestReadUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RequestReadProcInfo, GetCurrentArchitecture()) 556 #define CallNPN_RequestReadProc(FUNC, stream, range) \ 557 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RequestReadProcInfo, (stream), (range)) 558 559 #else 560 561 typedef NPError (*NPN_RequestReadUPP)(NPStream* stream, NPByteRange* rangeList); 562 #define NewNPN_RequestReadProc(FUNC) \ 563 ((NPN_RequestReadUPP) (FUNC)) 564 #define CallNPN_RequestReadProc(FUNC, stream, range) \ 565 (*(FUNC))((stream), (range)) 566 567 #endif 568 569 570 /* NPN_NewStream */ 571 572 #if GENERATINGCFM 573 574 typedef UniversalProcPtr NPN_NewStreamUPP; 575 enum { 576 uppNPN_NewStreamProcInfo = kThinkCStackBased 577 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 578 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType))) 579 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *))) 580 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPStream **))) 581 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 582 }; 583 #define NewNPN_NewStreamProc(FUNC) \ 584 (NPN_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_NewStreamProcInfo, GetCurrentArchitecture()) 585 #define CallNPN_NewStreamProc(FUNC, npp, type, window, stream) \ 586 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_NewStreamProcInfo, (npp), (type), (window), (stream)) 587 588 #else 589 590 typedef NPError (*NPN_NewStreamUPP)(NPP instance, NPMIMEType type, const char* window, NPStream** stream); 591 #define NewNPN_NewStreamProc(FUNC) \ 592 ((NPN_NewStreamUPP) (FUNC)) 593 #define CallNPN_NewStreamProc(FUNC, npp, type, window, stream) \ 594 (*(FUNC))((npp), (type), (window), (stream)) 595 596 #endif 597 598 599 /* NPN_Write */ 600 601 #if GENERATINGCFM 602 603 typedef UniversalProcPtr NPN_WriteUPP; 604 enum { 605 uppNPN_WriteProcInfo = kThinkCStackBased 606 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 607 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) 608 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32))) 609 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) 610 | RESULT_SIZE(SIZE_CODE(sizeof(int32))) 611 }; 612 #define NewNPN_WriteProc(FUNC) \ 613 (NPN_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_WriteProcInfo, GetCurrentArchitecture()) 614 #define CallNPN_WriteProc(FUNC, npp, stream, len, buffer) \ 615 (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_WriteProcInfo, (npp), (stream), (len), (buffer)) 616 617 #else 618 619 typedef int32 (*NPN_WriteUPP)(NPP instance, NPStream* stream, int32 len, void* buffer); 620 #define NewNPN_WriteProc(FUNC) \ 621 ((NPN_WriteUPP) (FUNC)) 622 #define CallNPN_WriteProc(FUNC, npp, stream, len, buffer) \ 623 (*(FUNC))((npp), (stream), (len), (buffer)) 624 625 #endif 626 627 628 /* NPN_DestroyStream */ 629 630 #if GENERATINGCFM 631 632 typedef UniversalProcPtr NPN_DestroyStreamUPP; 633 enum { 634 uppNPN_DestroyStreamProcInfo = kThinkCStackBased 635 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP ))) 636 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) 637 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason))) 638 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 639 }; 640 #define NewNPN_DestroyStreamProc(FUNC) \ 641 (NPN_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, GetCurrentArchitecture()) 642 #define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason) \ 643 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, (npp), (stream), (reason)) 644 645 #else 646 647 typedef NPError (*NPN_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason); 648 #define NewNPN_DestroyStreamProc(FUNC) \ 649 ((NPN_DestroyStreamUPP) (FUNC)) 650 #define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason) \ 651 (*(FUNC))((npp), (stream), (reason)) 652 653 #endif 654 655 656 /* NPN_Status */ 657 658 #if GENERATINGCFM 659 660 typedef UniversalProcPtr NPN_StatusUPP; 661 enum { 662 uppNPN_StatusProcInfo = kThinkCStackBased 663 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 664 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *))) 665 }; 666 667 #define NewNPN_StatusProc(FUNC) \ 668 (NPN_StatusUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_StatusProcInfo, GetCurrentArchitecture()) 669 #define CallNPN_StatusProc(FUNC, npp, msg) \ 670 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_StatusProcInfo, (npp), (msg)) 671 672 #else 673 674 typedef void (*NPN_StatusUPP)(NPP instance, const char* message); 675 #define NewNPN_StatusProc(FUNC) \ 676 ((NPN_StatusUPP) (FUNC)) 677 #define CallNPN_StatusProc(FUNC, npp, msg) \ 678 (*(FUNC))((npp), (msg)) 679 680 #endif 681 682 683 /* NPN_UserAgent */ 684 #if GENERATINGCFM 685 686 typedef UniversalProcPtr NPN_UserAgentUPP; 687 enum { 688 uppNPN_UserAgentProcInfo = kThinkCStackBased 689 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 690 | RESULT_SIZE(SIZE_CODE(sizeof(const char *))) 691 }; 692 693 #define NewNPN_UserAgentProc(FUNC) \ 694 (NPN_UserAgentUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_UserAgentProcInfo, GetCurrentArchitecture()) 695 #define CallNPN_UserAgentProc(FUNC, ARG1) \ 696 (const char*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_UserAgentProcInfo, (ARG1)) 697 698 #else 699 700 typedef const char* (*NPN_UserAgentUPP)(NPP instance); 701 #define NewNPN_UserAgentProc(FUNC) \ 702 ((NPN_UserAgentUPP) (FUNC)) 703 #define CallNPN_UserAgentProc(FUNC, ARG1) \ 704 (*(FUNC))((ARG1)) 705 706 #endif 707 708 709 /* NPN_MemAlloc */ 710 #if GENERATINGCFM 711 712 typedef UniversalProcPtr NPN_MemAllocUPP; 713 enum { 714 uppNPN_MemAllocProcInfo = kThinkCStackBased 715 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32))) 716 | RESULT_SIZE(SIZE_CODE(sizeof(void *))) 717 }; 718 719 #define NewNPN_MemAllocProc(FUNC) \ 720 (NPN_MemAllocUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemAllocProcInfo, GetCurrentArchitecture()) 721 #define CallNPN_MemAllocProc(FUNC, ARG1) \ 722 (void*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemAllocProcInfo, (ARG1)) 723 724 #else 725 726 typedef void* (*NPN_MemAllocUPP)(uint32 size); 727 #define NewNPN_MemAllocProc(FUNC) \ 728 ((NPN_MemAllocUPP) (FUNC)) 729 #define CallNPN_MemAllocProc(FUNC, ARG1) \ 730 (*(FUNC))((ARG1)) 731 732 #endif 733 734 735 /* NPN__MemFree */ 736 737 #if GENERATINGCFM 738 739 typedef UniversalProcPtr NPN_MemFreeUPP; 740 enum { 741 uppNPN_MemFreeProcInfo = kThinkCStackBased 742 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void *))) 743 }; 744 745 #define NewNPN_MemFreeProc(FUNC) \ 746 (NPN_MemFreeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFreeProcInfo, GetCurrentArchitecture()) 747 #define CallNPN_MemFreeProc(FUNC, ARG1) \ 748 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFreeProcInfo, (ARG1)) 749 750 #else 751 752 typedef void (*NPN_MemFreeUPP)(void* ptr); 753 #define NewNPN_MemFreeProc(FUNC) \ 754 ((NPN_MemFreeUPP) (FUNC)) 755 #define CallNPN_MemFreeProc(FUNC, ARG1) \ 756 (*(FUNC))((ARG1)) 757 758 #endif 759 760 761 /* NPN_MemFlush */ 762 763 #if GENERATINGCFM 764 765 typedef UniversalProcPtr NPN_MemFlushUPP; 766 enum { 767 uppNPN_MemFlushProcInfo = kThinkCStackBased 768 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32))) 769 | RESULT_SIZE(SIZE_CODE(sizeof(uint32))) 770 }; 771 772 #define NewNPN_MemFlushProc(FUNC) \ 773 (NPN_MemFlushUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFlushProcInfo, GetCurrentArchitecture()) 774 #define CallNPN_MemFlushProc(FUNC, ARG1) \ 775 (uint32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFlushProcInfo, (ARG1)) 776 777 #else 778 779 typedef uint32 (*NPN_MemFlushUPP)(uint32 size); 780 #define NewNPN_MemFlushProc(FUNC) \ 781 ((NPN_MemFlushUPP) (FUNC)) 782 #define CallNPN_MemFlushProc(FUNC, ARG1) \ 783 (*(FUNC))((ARG1)) 784 785 #endif 786 787 788 789 /* NPN_ReloadPlugins */ 790 791 #if GENERATINGCFM 792 793 typedef UniversalProcPtr NPN_ReloadPluginsUPP; 794 enum { 795 uppNPN_ReloadPluginsProcInfo = kThinkCStackBased 796 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPBool))) 797 | RESULT_SIZE(SIZE_CODE(0)) 798 }; 799 800 #define NewNPN_ReloadPluginsProc(FUNC) \ 801 (NPN_ReloadPluginsUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, GetCurrentArchitecture()) 802 #define CallNPN_ReloadPluginsProc(FUNC, ARG1) \ 803 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, (ARG1)) 804 805 #else 806 807 typedef void (*NPN_ReloadPluginsUPP)(NPBool reloadPages); 808 #define NewNPN_ReloadPluginsProc(FUNC) \ 809 ((NPN_ReloadPluginsUPP) (FUNC)) 810 #define CallNPN_ReloadPluginsProc(FUNC, ARG1) \ 811 (*(FUNC))((ARG1)) 812 813 #endif 814 815 816 /* NPN_GetJavaEnv */ 817 818 #if GENERATINGCFM 819 820 typedef UniversalProcPtr NPN_GetJavaEnvUPP; 821 enum { 822 uppNPN_GetJavaEnvProcInfo = kThinkCStackBased 823 | RESULT_SIZE(SIZE_CODE(sizeof(JRIEnv*))) 824 }; 825 826 #define NewNPN_GetJavaEnvProc(FUNC) \ 827 (NPN_GetJavaEnvUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo, GetCurrentArchitecture()) 828 #define CallNPN_GetJavaEnvProc(FUNC) \ 829 (JRIEnv*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo) 830 831 #else 832 833 typedef JRIEnv* (*NPN_GetJavaEnvUPP)(void); 834 #define NewNPN_GetJavaEnvProc(FUNC) \ 835 ((NPN_GetJavaEnvUPP) (FUNC)) 836 #define CallNPN_GetJavaEnvProc(FUNC) \ 837 (*(FUNC))() 838 839 #endif 840 841 842 /* NPN_GetJavaPeer */ 843 844 #if GENERATINGCFM 845 846 typedef UniversalProcPtr NPN_GetJavaPeerUPP; 847 enum { 848 uppNPN_GetJavaPeerProcInfo = kThinkCStackBased 849 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) 850 | RESULT_SIZE(SIZE_CODE(sizeof(jref))) 851 }; 852 853 #define NewNPN_GetJavaPeerProc(FUNC) \ 854 (NPN_GetJavaPeerUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, GetCurrentArchitecture()) 855 #define CallNPN_GetJavaPeerProc(FUNC, ARG1) \ 856 (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, (ARG1)) 857 858 #else 859 860 typedef jref (*NPN_GetJavaPeerUPP)(NPP instance); 861 #define NewNPN_GetJavaPeerProc(FUNC) \ 862 ((NPN_GetJavaPeerUPP) (FUNC)) 863 #define CallNPN_GetJavaPeerProc(FUNC, ARG1) \ 864 (*(FUNC))((ARG1)) 865 866 #endif 867 868 869 870 871 /****************************************************************************************** 872 * The actual plugin function table definitions 873 *******************************************************************************************/ 874 875 typedef struct _NPPluginFuncs { 876 uint16 size; 877 uint16 version; 878 NPP_NewUPP newp; 879 NPP_DestroyUPP destroy; 880 NPP_SetWindowUPP setwindow; 881 NPP_NewStreamUPP newstream; 882 NPP_DestroyStreamUPP destroystream; 883 NPP_StreamAsFileUPP asfile; 884 NPP_WriteReadyUPP writeready; 885 NPP_WriteUPP write; 886 NPP_PrintUPP print; 887 NPP_HandleEventUPP event; 888 NPP_URLNotifyUPP urlnotify; 889 JRIGlobalRef javaClass; 890 } NPPluginFuncs; 891 892 typedef struct _NPNetscapeFuncs { 893 uint16 size; 894 uint16 version; 895 NPN_GetURLUPP geturl; 896 NPN_PostURLUPP posturl; 897 NPN_RequestReadUPP requestread; 898 NPN_NewStreamUPP newstream; 899 NPN_WriteUPP write; 900 NPN_DestroyStreamUPP destroystream; 901 NPN_StatusUPP status; 902 NPN_UserAgentUPP uagent; 903 NPN_MemAllocUPP memalloc; 904 NPN_MemFreeUPP memfree; 905 NPN_MemFlushUPP memflush; 906 NPN_ReloadPluginsUPP reloadplugins; 907 NPN_GetJavaEnvUPP getJavaEnv; 908 NPN_GetJavaPeerUPP getJavaPeer; 909 NPN_GetURLNotifyUPP geturlnotify; 910 NPN_PostURLNotifyUPP posturlnotify; 911 #ifdef XP_UNIX 912 NPN_GetValueUPP getvalue; 913 #endif /* XP_UNIX */ 914 } NPNetscapeFuncs; 915 916 917 918 #ifdef XP_MAC 919 /****************************************************************************************** 920 * Mac platform-specific plugin glue stuff 921 *******************************************************************************************/ 922 923 /* 924 * Main entry point of the plugin. 925 * This routine will be called when the plugin is loaded. The function 926 * tables are passed in and the plugin fills in the NPPluginFuncs table 927 * and NPPShutdownUPP for Netscape's use. 928 */ 929 930 #if GENERATINGCFM 931 932 typedef UniversalProcPtr NPP_MainEntryUPP; 933 enum { 934 uppNPP_MainEntryProcInfo = kThinkCStackBased 935 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPNetscapeFuncs*))) 936 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPluginFuncs*))) 937 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPP_ShutdownUPP*))) 938 | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) 939 }; 940 #define NewNPP_MainEntryProc(FUNC) \ 941 (NPP_MainEntryUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_MainEntryProcInfo, GetCurrentArchitecture()) 942 #define CallNPP_MainEntryProc(FUNC, netscapeFunc, pluginFunc, shutdownUPP) \ 943 CallUniversalProc((UniversalProcPtr)(FUNC), (ProcInfoType)uppNPP_MainEntryProcInfo, (netscapeFunc), (pluginFunc), (shutdownUPP)) 944 945 #else 946 947 typedef NPError (*NPP_MainEntryUPP)(NPNetscapeFuncs*, NPPluginFuncs*, NPP_ShutdownUPP*); 948 #define NewNPP_MainEntryProc(FUNC) \ 949 ((NPP_MainEntryUPP) (FUNC)) 950 #define CallNPP_MainEntryProc(FUNC, netscapeFunc, pluginFunc, shutdownUPP) \ 951 (*(FUNC))((netscapeFunc), (pluginFunc), (shutdownUPP)) 952 953 #endif 954 #endif /* MAC */ 955 956 957 #ifdef _WINDOWS 958 959 #ifdef __cplusplus 960 extern "C" { 961 #endif 962 963 /* plugin meta member functions */ 964 965 NPError WINAPI NP_GetEntryPoints(NPPluginFuncs* pFuncs); 966 967 NPError WINAPI NP_Initialize(NPNetscapeFuncs* pFuncs); 968 969 NPError WINAPI NP_Shutdown(); 970 971 #ifdef __cplusplus 972 } 973 #endif 974 975 #endif /* _WINDOWS */ 976 977 #ifdef XP_UNIX 978 979 #ifdef __cplusplus 980 extern "C" { 981 #endif 982 983 /* plugin meta member functions */ 984 985 char* NP_GetMIMEDescription(void); 986 NPError NP_Initialize(NPNetscapeFuncs*, NPPluginFuncs*); 987 NPError NP_Shutdown(void); 988 989 #ifdef __cplusplus 990 } 991 #endif 992 993 #endif /* XP_UNIX */ 994 995 #endif /* _NPUPP_H_ */ 996