np_sdk/mozsrc/npupp.h

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: NPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Netscape Public License
   6  * Version 1.1 (the "License"); you may not use this file except in
   7  * compliance with the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/NPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the NPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the NPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39
  40 /*
  41  *  npupp.h $Revision: 1.2 $
  42  *  function call mecahnics needed by platform specific glue code.
  43  */
  44
  45
  46 #ifndef _NPUPP_H_
  47 #define _NPUPP_H_
  48
  49 #if defined(__OS2__)
  50 #pragma pack(1)
  51 #endif
  52
  53 #ifndef GENERATINGCFM
  54 #define GENERATINGCFM 0
  55 #endif
  56
  57 #ifndef _NPAPI_H_
  58 #include "npapi.h"
  59 #endif
  60
  61 #include "jri.h"
  62
  63 /******************************************************************************************
  64    plug-in function table macros
  65              for each function in and out of the plugin API we define
  66                     typedef NPP_FooUPP
  67                     #define NewNPP_FooProc
  68                     #define CallNPP_FooProc
  69             for mac, define the UPP magic for PPC/68K calling
  70  *******************************************************************************************/
  71
  72
  73 /* NPP_Initialize */
  74
  75 #define _NPUPP_USE_UPP_ (TARGET_RT_MAC_CFM && !TARGET_API_MAC_CARBON)
  76
  77 #if _NPUPP_USE_UPP_
  78 typedef UniversalProcPtr NPP_InitializeUPP;
  79
  80 enum {
  81     uppNPP_InitializeProcInfo = kThinkCStackBased
  82         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0))
  83         | RESULT_SIZE(SIZE_CODE(0))
  84 };
  85
  86 #define NewNPP_InitializeProc(FUNC)             \
  87         (NPP_InitializeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_InitializeProcInfo, GetCurrentArchitecture())
  88 #define CallNPP_InitializeProc(FUNC)            \
  89         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_InitializeProcInfo)
  90
  91 #else
  92
  93 typedef void (* NP_LOADDS NPP_InitializeUPP)(void);
  94 #define NewNPP_InitializeProc(FUNC)             \
  95         ((NPP_InitializeUPP) (FUNC))
  96 #define CallNPP_InitializeProc(FUNC)            \
  97         (*(FUNC))()
  98
  99 #endif
 100
 101
 102 /* NPP_Shutdown */
 103
 104 #if _NPUPP_USE_UPP_
 105 typedef UniversalProcPtr NPP_ShutdownUPP;
 106
 107 enum {
 108     uppNPP_ShutdownProcInfo = kThinkCStackBased
 109         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0))
 110         | RESULT_SIZE(SIZE_CODE(0))
 111 };
 112
 113 #define NewNPP_ShutdownProc(FUNC)               \
 114         (NPP_ShutdownUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_ShutdownProcInfo, GetCurrentArchitecture())
 115 #define CallNPP_ShutdownProc(FUNC)              \
 116         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_ShutdownProcInfo)
 117
 118 #else
 119
 120 typedef void (* NP_LOADDS NPP_ShutdownUPP)(void);
 121 #define NewNPP_ShutdownProc(FUNC)               \
 122         ((NPP_ShutdownUPP) (FUNC))
 123 #define CallNPP_ShutdownProc(FUNC)              \
 124         (*(FUNC))()
 125
 126 #endif
 127
 128
 129 /* NPP_New */
 130
 131 #if _NPUPP_USE_UPP_
 132 typedef UniversalProcPtr NPP_NewUPP;
 133
 134 enum {
 135     uppNPP_NewProcInfo = kThinkCStackBased
 136         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPMIMEType)))
 137         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPP)))
 138         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(uint16)))
 139         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int16)))
 140         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char **)))
 141         | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(char **)))
 142         | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(NPSavedData *)))
 143         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 144 };
 145
 146 #define NewNPP_NewProc(FUNC)            \
 147         (NPP_NewUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewProcInfo, GetCurrentArchitecture())
 148 #define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \
 149         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewProcInfo, \
 150                                    (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
 151 #else
 152
 153 typedef NPError (* NP_LOADDS NPP_NewUPP)(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved);
 154 #define NewNPP_NewProc(FUNC)            \
 155         ((NPP_NewUPP) (FUNC))
 156 #define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7)         \
 157         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
 158
 159 #endif
 160
 161
 162 /* NPP_Destroy */
 163
 164 #if _NPUPP_USE_UPP_
 165
 166 typedef UniversalProcPtr NPP_DestroyUPP;
 167 enum {
 168     uppNPP_DestroyProcInfo = kThinkCStackBased
 169         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 170         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPSavedData **)))
 171         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 172 };
 173 #define NewNPP_DestroyProc(FUNC)                \
 174         (NPP_DestroyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyProcInfo, GetCurrentArchitecture())
 175 #define CallNPP_DestroyProc(FUNC, ARG1, ARG2)           \
 176         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyProcInfo, (ARG1), (ARG2))
 177 #else
 178
 179 typedef NPError (* NP_LOADDS NPP_DestroyUPP)(NPP instance, NPSavedData** save);
 180 #define NewNPP_DestroyProc(FUNC)                \
 181         ((NPP_DestroyUPP) (FUNC))
 182 #define CallNPP_DestroyProc(FUNC, ARG1, ARG2)           \
 183         (*(FUNC))((ARG1), (ARG2))
 184
 185 #endif
 186
 187
 188 /* NPP_SetWindow */
 189
 190 #if _NPUPP_USE_UPP_
 191
 192 typedef UniversalProcPtr NPP_SetWindowUPP;
 193 enum {
 194     uppNPP_SetWindowProcInfo = kThinkCStackBased
 195         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 196         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPWindow *)))
 197         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 198 };
 199 #define NewNPP_SetWindowProc(FUNC)              \
 200         (NPP_SetWindowUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_SetWindowProcInfo, GetCurrentArchitecture())
 201 #define CallNPP_SetWindowProc(FUNC, ARG1, ARG2)         \
 202         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_SetWindowProcInfo, (ARG1), (ARG2))
 203
 204 #else
 205
 206 typedef NPError (* NP_LOADDS NPP_SetWindowUPP)(NPP instance, NPWindow* window);
 207 #define NewNPP_SetWindowProc(FUNC)              \
 208         ((NPP_SetWindowUPP) (FUNC))
 209 #define CallNPP_SetWindowProc(FUNC, ARG1, ARG2)         \
 210         (*(FUNC))((ARG1), (ARG2))
 211
 212 #endif
 213
 214
 215 /* NPP_NewStream */
 216
 217 #if _NPUPP_USE_UPP_
 218
 219 typedef UniversalProcPtr NPP_NewStreamUPP;
 220 enum {
 221     uppNPP_NewStreamProcInfo = kThinkCStackBased
 222         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 223         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType)))
 224         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPStream *)))
 225         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPBool)))
 226         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint16 *)))
 227         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 228 };
 229 #define NewNPP_NewStreamProc(FUNC)              \
 230         (NPP_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewStreamProcInfo, GetCurrentArchitecture())
 231 #define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5)               \
 232         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewStreamProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5))
 233 #else
 234
 235 typedef NPError (* NP_LOADDS NPP_NewStreamUPP)(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype);
 236 #define NewNPP_NewStreamProc(FUNC)              \
 237         ((NPP_NewStreamUPP) (FUNC))
 238 #define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \
 239         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5))
 240 #endif
 241
 242
 243 /* NPP_DestroyStream */
 244
 245 #if _NPUPP_USE_UPP_
 246
 247 typedef UniversalProcPtr NPP_DestroyStreamUPP;
 248 enum {
 249     uppNPP_DestroyStreamProcInfo = kThinkCStackBased
 250         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 251         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
 252         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason)))
 253         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 254 };
 255 #define NewNPP_DestroyStreamProc(FUNC)          \
 256         (NPP_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, GetCurrentArchitecture())
 257 #define CallNPP_DestroyStreamProc(FUNC,  NPParg, NPStreamPtr, NPReasonArg)              \
 258         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, (NPParg), (NPStreamPtr), (NPReasonArg))
 259
 260 #else
 261
 262 typedef NPError (* NP_LOADDS NPP_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason);
 263 #define NewNPP_DestroyStreamProc(FUNC)          \
 264         ((NPP_DestroyStreamUPP) (FUNC))
 265 #define CallNPP_DestroyStreamProc(FUNC,  NPParg, NPStreamPtr, NPReasonArg)              \
 266         (*(FUNC))((NPParg), (NPStreamPtr), (NPReasonArg))
 267
 268 #endif
 269
 270
 271 /* NPP_WriteReady */
 272
 273 #if _NPUPP_USE_UPP_
 274
 275 typedef UniversalProcPtr NPP_WriteReadyUPP;
 276 enum {
 277     uppNPP_WriteReadyProcInfo = kThinkCStackBased
 278         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 279         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
 280         | RESULT_SIZE(SIZE_CODE(sizeof(int32)))
 281 };
 282 #define NewNPP_WriteReadyProc(FUNC)             \
 283         (NPP_WriteReadyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, GetCurrentArchitecture())
 284 #define CallNPP_WriteReadyProc(FUNC,  NPParg, NPStreamPtr)              \
 285         (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, (NPParg), (NPStreamPtr))
 286
 287 #else
 288
 289 typedef int32 (* NP_LOADDS NPP_WriteReadyUPP)(NPP instance, NPStream* stream);
 290 #define NewNPP_WriteReadyProc(FUNC)             \
 291         ((NPP_WriteReadyUPP) (FUNC))
 292 #define CallNPP_WriteReadyProc(FUNC,  NPParg, NPStreamPtr)              \
 293         (*(FUNC))((NPParg), (NPStreamPtr))
 294
 295 #endif
 296
 297
 298 /* NPP_Write */
 299
 300 #if _NPUPP_USE_UPP_
 301
 302 typedef UniversalProcPtr NPP_WriteUPP;
 303 enum {
 304     uppNPP_WriteProcInfo = kThinkCStackBased
 305         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 306         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
 307         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32)))
 308         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int32)))
 309         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(void*)))
 310         | RESULT_SIZE(SIZE_CODE(sizeof(int32)))
 311 };
 312 #define NewNPP_WriteProc(FUNC)          \
 313         (NPP_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteProcInfo, GetCurrentArchitecture())
 314 #define CallNPP_WriteProc(FUNC,  NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr)             \
 315         (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteProcInfo, (NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr))
 316
 317 #else
 318
 319 typedef int32 (* NP_LOADDS NPP_WriteUPP)(NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer);
 320 #define NewNPP_WriteProc(FUNC)          \
 321         ((NPP_WriteUPP) (FUNC))
 322 #define CallNPP_WriteProc(FUNC,  NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr)             \
 323         (*(FUNC))((NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr))
 324
 325 #endif
 326
 327
 328 /* NPP_StreamAsFile */
 329
 330 #if _NPUPP_USE_UPP_
 331
 332 typedef UniversalProcPtr NPP_StreamAsFileUPP;
 333 enum {
 334     uppNPP_StreamAsFileProcInfo = kThinkCStackBased
 335         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 336         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
 337         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *)))
 338         | RESULT_SIZE(SIZE_CODE(0))
 339 };
 340 #define NewNPP_StreamAsFileProc(FUNC)           \
 341         (NPP_StreamAsFileUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, GetCurrentArchitecture())
 342 #define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3)                \
 343         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, (ARG1), (ARG2), (ARG3))
 344
 345 #else
 346
 347 typedef void (* NP_LOADDS NPP_StreamAsFileUPP)(NPP instance, NPStream* stream, const char* fname);
 348 #define NewNPP_StreamAsFileProc(FUNC)           \
 349         ((NPP_StreamAsFileUPP) (FUNC))
 350 #define CallNPP_StreamAsFileProc(FUNC,  ARG1, ARG2, ARG3)               \
 351         (*(FUNC))((ARG1), (ARG2), (ARG3))
 352 #endif
 353
 354
 355 /* NPP_Print */
 356
 357 #if _NPUPP_USE_UPP_
 358
 359 typedef UniversalProcPtr NPP_PrintUPP;
 360 enum {
 361     uppNPP_PrintProcInfo = kThinkCStackBased
 362         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 363         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPrint *)))
 364         | RESULT_SIZE(SIZE_CODE(0))
 365 };
 366 #define NewNPP_PrintProc(FUNC)          \
 367         (NPP_PrintUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_PrintProcInfo, GetCurrentArchitecture())
 368 #define CallNPP_PrintProc(FUNC,  NPParg, voidPtr)               \
 369         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_PrintProcInfo, (NPParg), (voidPtr))
 370
 371 #else
 372
 373 typedef void (* NP_LOADDS NPP_PrintUPP)(NPP instance, NPPrint* platformPrint);
 374 #define NewNPP_PrintProc(FUNC)          \
 375         ((NPP_PrintUPP) (FUNC))
 376 #define CallNPP_PrintProc(FUNC,  NPParg, NPPrintArg)            \
 377         (*(FUNC))((NPParg), (NPPrintArg))
 378
 379 #endif
 380
 381
 382 /* NPP_HandleEvent */
 383
 384 #if _NPUPP_USE_UPP_
 385
 386 typedef UniversalProcPtr NPP_HandleEventUPP;
 387 enum {
 388     uppNPP_HandleEventProcInfo = kThinkCStackBased
 389         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 390         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
 391         | RESULT_SIZE(SIZE_CODE(sizeof(int16)))
 392 };
 393 #define NewNPP_HandleEventProc(FUNC)            \
 394         (NPP_HandleEventUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_HandleEventProcInfo, GetCurrentArchitecture())
 395 #define CallNPP_HandleEventProc(FUNC,  NPParg, voidPtr)         \
 396         (int16)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_HandleEventProcInfo, (NPParg), (voidPtr))
 397
 398 #else
 399
 400 typedef int16 (* NP_LOADDS NPP_HandleEventUPP)(NPP instance, void* event);
 401 #define NewNPP_HandleEventProc(FUNC)            \
 402         ((NPP_HandleEventUPP) (FUNC))
 403 #define CallNPP_HandleEventProc(FUNC,  NPParg, voidPtr)         \
 404         (*(FUNC))((NPParg), (voidPtr))
 405
 406 #endif
 407
 408
 409 /* NPP_URLNotify */
 410
 411 #if _NPUPP_USE_UPP_
 412
 413 typedef UniversalProcPtr NPP_URLNotifyUPP;
 414 enum {
 415     uppNPP_URLNotifyProcInfo = kThinkCStackBased
 416         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 417         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
 418         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason)))
 419         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
 420         | RESULT_SIZE(SIZE_CODE(SIZE_CODE(0)))
 421 };
 422 #define NewNPP_URLNotifyProc(FUNC)              \
 423         (NPP_URLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, GetCurrentArchitecture())
 424 #define CallNPP_URLNotifyProc(FUNC,  ARG1, ARG2, ARG3, ARG4)            \
 425         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4))
 426
 427 #else
 428
 429 typedef void (* NP_LOADDS NPP_URLNotifyUPP)(NPP instance, const char* url, NPReason reason, void* notifyData);
 430 #define NewNPP_URLNotifyProc(FUNC)              \
 431         ((NPP_URLNotifyUPP) (FUNC))
 432 #define CallNPP_URLNotifyProc(FUNC,  ARG1, ARG2, ARG3, ARG4)            \
 433         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4))
 434
 435 #endif
 436
 437
 438 /* NPP_GetValue */
 439
 440 #if _NPUPP_USE_UPP_
 441
 442 typedef UniversalProcPtr NPP_GetValueUPP;
 443 enum {
 444     uppNPP_GetValueProcInfo = kThinkCStackBased
 445         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 446         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPVariable)))
 447         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
 448         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 449 };
 450 #define NewNPP_GetValueProc(FUNC)               \
 451         (NPP_GetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_GetValueProcInfo, GetCurrentArchitecture())
 452 #define CallNPP_GetValueProc(FUNC, ARG1, ARG2, ARG3) \
 453         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_GetValueProcInfo, (ARG1), (ARG2), (ARG3))
 454 #else
 455
 456 typedef NPError (* NP_LOADDS NPP_GetValueUPP)(NPP instance, NPPVariable variable, void *ret_alue);
 457 #define NewNPP_GetValueProc(FUNC)               \
 458         ((NPP_GetValueUPP) (FUNC))
 459 #define CallNPP_GetValueProc(FUNC, ARG1, ARG2, ARG3)            \
 460         (*(FUNC))((ARG1), (ARG2), (ARG3))
 461 #endif
 462
 463
 464 /* NPP_SetValue */
 465
 466 #if _NPUPP_USE_UPP_
 467
 468 typedef UniversalProcPtr NPP_SetValueUPP;
 469 enum {
 470     uppNPP_SetValueProcInfo = kThinkCStackBased
 471         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 472         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPNVariable)))
 473         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
 474         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 475 };
 476 #define NewNPP_SetValueProc(FUNC)               \
 477         (NPP_SetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_SetValueProcInfo, GetCurrentArchitecture())
 478 #define CallNPP_SetValueProc(FUNC, ARG1, ARG2, ARG3) \
 479         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_SetValueProcInfo, (ARG1), (ARG2), (ARG3))
 480 #else
 481
 482 typedef NPError (* NP_LOADDS NPP_SetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue);
 483 #define NewNPP_SetValueProc(FUNC)               \
 484         ((NPP_SetValueUPP) (FUNC))
 485 #define CallNPP_SetValueProc(FUNC, ARG1, ARG2, ARG3)            \
 486         (*(FUNC))((ARG1), (ARG2), (ARG3))
 487 #endif
 488
 489
 490
 491
 492 /*
 493  *  Netscape entry points
 494  */
 495
 496
 497 /* NPN_GetValue */
 498
 499 #if _NPUPP_USE_UPP_
 500
 501 typedef UniversalProcPtr NPN_GetValueUPP;
 502 enum {
 503     uppNPN_GetValueProcInfo = kThinkCStackBased
 504         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 505         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPNVariable)))
 506         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
 507         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 508 };
 509 #define NewNPN_GetValueProc(FUNC)               \
 510         (NPN_GetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetValueProcInfo, GetCurrentArchitecture())
 511 #define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3) \
 512         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetValueProcInfo, (ARG1), (ARG2), (ARG3))
 513 #else
 514
 515 typedef NPError (* NP_LOADDS NPN_GetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue);
 516 #define NewNPN_GetValueProc(FUNC)               \
 517         ((NPN_GetValueUPP) (FUNC))
 518 #define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3)            \
 519         (*(FUNC))((ARG1), (ARG2), (ARG3))
 520 #endif
 521
 522
 523 /* NPN_SetValue */
 524
 525 #if _NPUPP_USE_UPP_
 526
 527 typedef UniversalProcPtr NPN_SetValueUPP;
 528 enum {
 529     uppNPN_SetValueProcInfo = kThinkCStackBased
 530         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 531         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPVariable)))
 532         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
 533         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 534 };
 535 #define NewNPN_SetValueProc(FUNC)               \
 536         (NPN_SetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_SetValueProcInfo, GetCurrentArchitecture())
 537 #define CallNPN_SetValueProc(FUNC, ARG1, ARG2, ARG3) \
 538         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_SetValueProcInfo, (ARG1), (ARG2), (ARG3))
 539 #else
 540
 541 typedef NPError (* NP_LOADDS NPN_SetValueUPP)(NPP instance, NPPVariable variable, void *ret_alue);
 542 #define NewNPN_SetValueProc(FUNC)               \
 543         ((NPN_SetValueUPP) (FUNC))
 544 #define CallNPN_SetValueProc(FUNC, ARG1, ARG2, ARG3)            \
 545         (*(FUNC))((ARG1), (ARG2), (ARG3))
 546 #endif
 547
 548
 549 /* NPN_GetUrlNotify */
 550
 551 #if _NPUPP_USE_UPP_
 552
 553 typedef UniversalProcPtr NPN_GetURLNotifyUPP;
 554 enum {
 555     uppNPN_GetURLNotifyProcInfo = kThinkCStackBased
 556         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 557         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
 558         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
 559         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
 560         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 561 };
 562 #define NewNPN_GetURLNotifyProc(FUNC)           \
 563         (NPN_GetURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, GetCurrentArchitecture())
 564 #define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \
 565         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4))
 566 #else
 567
 568 typedef NPError (* NP_LOADDS NPN_GetURLNotifyUPP)(NPP instance, const char* url, const char* window, void* notifyData);
 569 #define NewNPN_GetURLNotifyProc(FUNC)           \
 570         ((NPN_GetURLNotifyUPP) (FUNC))
 571 #define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4)          \
 572         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4))
 573 #endif
 574
 575
 576 /* NPN_PostUrlNotify */
 577
 578 #if _NPUPP_USE_UPP_
 579
 580 typedef UniversalProcPtr NPN_PostURLNotifyUPP;
 581 enum {
 582     uppNPN_PostURLNotifyProcInfo = kThinkCStackBased
 583         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 584         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
 585         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
 586         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32)))
 587         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*)))
 588         | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool)))
 589         | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(void*)))
 590         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 591 };
 592 #define NewNPN_PostURLNotifyProc(FUNC)          \
 593         (NPN_PostURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, GetCurrentArchitecture())
 594 #define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \
 595         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
 596 #else
 597
 598 typedef NPError (* NP_LOADDS NPN_PostURLNotifyUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData);
 599 #define NewNPN_PostURLNotifyProc(FUNC)          \
 600         ((NPN_PostURLNotifyUPP) (FUNC))
 601 #define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \
 602         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
 603 #endif
 604
 605
 606 /* NPN_GetUrl */
 607
 608 #if _NPUPP_USE_UPP_
 609
 610 typedef UniversalProcPtr NPN_GetURLUPP;
 611 enum {
 612     uppNPN_GetURLProcInfo = kThinkCStackBased
 613         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 614         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
 615         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
 616         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 617 };
 618 #define NewNPN_GetURLProc(FUNC)         \
 619         (NPN_GetURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLProcInfo, GetCurrentArchitecture())
 620 #define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \
 621         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLProcInfo, (ARG1), (ARG2), (ARG3))
 622 #else
 623
 624 typedef NPError (* NP_LOADDS NPN_GetURLUPP)(NPP instance, const char* url, const char* window);
 625 #define NewNPN_GetURLProc(FUNC)         \
 626         ((NPN_GetURLUPP) (FUNC))
 627 #define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3)              \
 628         (*(FUNC))((ARG1), (ARG2), (ARG3))
 629 #endif
 630
 631
 632 /* NPN_PostUrl */
 633
 634 #if _NPUPP_USE_UPP_
 635
 636 typedef UniversalProcPtr NPN_PostURLUPP;
 637 enum {
 638     uppNPN_PostURLProcInfo = kThinkCStackBased
 639         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 640         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
 641         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
 642         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32)))
 643         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*)))
 644         | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool)))
 645         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 646 };
 647 #define NewNPN_PostURLProc(FUNC)                \
 648         (NPN_PostURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLProcInfo, GetCurrentArchitecture())
 649 #define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \
 650         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6))
 651 #else
 652
 653 typedef NPError (* NP_LOADDS NPN_PostURLUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file);
 654 #define NewNPN_PostURLProc(FUNC)                \
 655         ((NPN_PostURLUPP) (FUNC))
 656 #define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \
 657         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6))
 658 #endif
 659
 660
 661 /* NPN_RequestRead */
 662
 663 #if _NPUPP_USE_UPP_
 664
 665 typedef UniversalProcPtr NPN_RequestReadUPP;
 666 enum {
 667     uppNPN_RequestReadProcInfo = kThinkCStackBased
 668         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPStream *)))
 669         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPByteRange *)))
 670         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 671 };
 672 #define NewNPN_RequestReadProc(FUNC)            \
 673         (NPN_RequestReadUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RequestReadProcInfo, GetCurrentArchitecture())
 674 #define CallNPN_RequestReadProc(FUNC,  stream, range)           \
 675         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RequestReadProcInfo, (stream), (range))
 676
 677 #else
 678
 679 typedef NPError (* NP_LOADDS NPN_RequestReadUPP)(NPStream* stream, NPByteRange* rangeList);
 680 #define NewNPN_RequestReadProc(FUNC)            \
 681         ((NPN_RequestReadUPP) (FUNC))
 682 #define CallNPN_RequestReadProc(FUNC, stream, range)            \
 683         (*(FUNC))((stream), (range))
 684
 685 #endif
 686
 687
 688 /* NPN_NewStream */
 689
 690 #if _NPUPP_USE_UPP_
 691
 692 typedef UniversalProcPtr NPN_NewStreamUPP;
 693 enum {
 694     uppNPN_NewStreamProcInfo = kThinkCStackBased
 695         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 696         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType)))
 697         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *)))
 698         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPStream **)))
 699         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 700 };
 701 #define NewNPN_NewStreamProc(FUNC)              \
 702         (NPN_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_NewStreamProcInfo, GetCurrentArchitecture())
 703 #define CallNPN_NewStreamProc(FUNC, npp, type, window, stream)          \
 704         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_NewStreamProcInfo, (npp), (type), (window), (stream))
 705
 706 #else
 707
 708 typedef NPError (* NP_LOADDS NPN_NewStreamUPP)(NPP instance, NPMIMEType type, const char* window, NPStream** stream);
 709 #define NewNPN_NewStreamProc(FUNC)              \
 710         ((NPN_NewStreamUPP) (FUNC))
 711 #define CallNPN_NewStreamProc(FUNC, npp, type, window, stream)          \
 712         (*(FUNC))((npp), (type), (window), (stream))
 713
 714 #endif
 715
 716
 717 /* NPN_Write */
 718
 719 #if _NPUPP_USE_UPP_
 720
 721 typedef UniversalProcPtr NPN_WriteUPP;
 722 enum {
 723     uppNPN_WriteProcInfo = kThinkCStackBased
 724         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 725         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
 726         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32)))
 727         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
 728         | RESULT_SIZE(SIZE_CODE(sizeof(int32)))
 729 };
 730 #define NewNPN_WriteProc(FUNC)          \
 731         (NPN_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_WriteProcInfo, GetCurrentArchitecture())
 732 #define CallNPN_WriteProc(FUNC, npp, stream, len, buffer)               \
 733         (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_WriteProcInfo, (npp), (stream), (len), (buffer))
 734
 735 #else
 736
 737 typedef int32 (* NP_LOADDS NPN_WriteUPP)(NPP instance, NPStream* stream, int32 len, void* buffer);
 738 #define NewNPN_WriteProc(FUNC)          \
 739         ((NPN_WriteUPP) (FUNC))
 740 #define CallNPN_WriteProc(FUNC, npp, stream, len, buffer)               \
 741         (*(FUNC))((npp), (stream), (len), (buffer))
 742
 743 #endif
 744
 745
 746 /* NPN_DestroyStream */
 747
 748 #if _NPUPP_USE_UPP_
 749
 750 typedef UniversalProcPtr NPN_DestroyStreamUPP;
 751 enum {
 752     uppNPN_DestroyStreamProcInfo = kThinkCStackBased
 753         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP )))
 754         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
 755         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason)))
 756         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
 757 };
 758 #define NewNPN_DestroyStreamProc(FUNC)          \
 759         (NPN_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, GetCurrentArchitecture())
 760 #define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason)            \
 761         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, (npp), (stream), (reason))
 762
 763 #else
 764
 765 typedef NPError (* NP_LOADDS NPN_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason);
 766 #define NewNPN_DestroyStreamProc(FUNC)          \
 767         ((NPN_DestroyStreamUPP) (FUNC))
 768 #define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason)            \
 769         (*(FUNC))((npp), (stream), (reason))
 770
 771 #endif
 772
 773
 774 /* NPN_Status */
 775
 776 #if _NPUPP_USE_UPP_
 777
 778 typedef UniversalProcPtr NPN_StatusUPP;
 779 enum {
 780     uppNPN_StatusProcInfo = kThinkCStackBased
 781         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 782         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *)))
 783 };
 784
 785 #define NewNPN_StatusProc(FUNC)         \
 786         (NPN_StatusUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_StatusProcInfo, GetCurrentArchitecture())
 787 #define CallNPN_StatusProc(FUNC, npp, msg)              \
 788         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_StatusProcInfo, (npp), (msg))
 789
 790 #else
 791
 792 typedef void (* NP_LOADDS NPN_StatusUPP)(NPP instance, const char* message);
 793 #define NewNPN_StatusProc(FUNC)         \
 794         ((NPN_StatusUPP) (FUNC))
 795 #define CallNPN_StatusProc(FUNC, npp, msg)              \
 796         (*(FUNC))((npp), (msg))
 797
 798 #endif
 799
 800
 801 /* NPN_UserAgent */
 802 #if _NPUPP_USE_UPP_
 803
 804 typedef UniversalProcPtr NPN_UserAgentUPP;
 805 enum {
 806         uppNPN_UserAgentProcInfo = kThinkCStackBased
 807                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 808                 | RESULT_SIZE(SIZE_CODE(sizeof(const char *)))
 809 };
 810
 811 #define NewNPN_UserAgentProc(FUNC)              \
 812                 (NPN_UserAgentUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_UserAgentProcInfo, GetCurrentArchitecture())
 813 #define CallNPN_UserAgentProc(FUNC, ARG1)               \
 814                 (const char*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_UserAgentProcInfo, (ARG1))
 815
 816 #else
 817
 818 typedef const char*     (* NP_LOADDS NPN_UserAgentUPP)(NPP instance);
 819 #define NewNPN_UserAgentProc(FUNC)              \
 820                 ((NPN_UserAgentUPP) (FUNC))
 821 #define CallNPN_UserAgentProc(FUNC, ARG1)               \
 822                 (*(FUNC))((ARG1))
 823
 824 #endif
 825
 826
 827 /* NPN_MemAlloc */
 828 #if _NPUPP_USE_UPP_
 829
 830 typedef UniversalProcPtr NPN_MemAllocUPP;
 831 enum {
 832     uppNPN_MemAllocProcInfo = kThinkCStackBased
 833         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32)))
 834         | RESULT_SIZE(SIZE_CODE(sizeof(void *)))
 835 };
 836
 837 #define NewNPN_MemAllocProc(FUNC)               \
 838         (NPN_MemAllocUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemAllocProcInfo, GetCurrentArchitecture())
 839 #define CallNPN_MemAllocProc(FUNC, ARG1)                \
 840         (void*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemAllocProcInfo, (ARG1))
 841
 842 #else
 843
 844 typedef void* (* NP_LOADDS NPN_MemAllocUPP)(uint32 size);
 845 #define NewNPN_MemAllocProc(FUNC)               \
 846         ((NPN_MemAllocUPP) (FUNC))
 847 #define CallNPN_MemAllocProc(FUNC, ARG1)                \
 848         (*(FUNC))((ARG1))
 849
 850 #endif
 851
 852
 853 /* NPN__MemFree */
 854
 855 #if _NPUPP_USE_UPP_
 856
 857 typedef UniversalProcPtr NPN_MemFreeUPP;
 858 enum {
 859     uppNPN_MemFreeProcInfo = kThinkCStackBased
 860         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void *)))
 861 };
 862
 863 #define NewNPN_MemFreeProc(FUNC)                \
 864         (NPN_MemFreeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFreeProcInfo, GetCurrentArchitecture())
 865 #define CallNPN_MemFreeProc(FUNC, ARG1)         \
 866         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFreeProcInfo, (ARG1))
 867
 868 #else
 869
 870 typedef void (* NP_LOADDS NPN_MemFreeUPP)(void* ptr);
 871 #define NewNPN_MemFreeProc(FUNC)                \
 872         ((NPN_MemFreeUPP) (FUNC))
 873 #define CallNPN_MemFreeProc(FUNC, ARG1)         \
 874         (*(FUNC))((ARG1))
 875
 876 #endif
 877
 878
 879 /* NPN_MemFlush */
 880
 881 #if _NPUPP_USE_UPP_
 882
 883 typedef UniversalProcPtr NPN_MemFlushUPP;
 884 enum {
 885     uppNPN_MemFlushProcInfo = kThinkCStackBased
 886         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32)))
 887         | RESULT_SIZE(SIZE_CODE(sizeof(uint32)))
 888 };
 889
 890 #define NewNPN_MemFlushProc(FUNC)               \
 891         (NPN_MemFlushUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFlushProcInfo, GetCurrentArchitecture())
 892 #define CallNPN_MemFlushProc(FUNC, ARG1)                \
 893         (uint32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFlushProcInfo, (ARG1))
 894
 895 #else
 896
 897 typedef uint32 (* NP_LOADDS NPN_MemFlushUPP)(uint32 size);
 898 #define NewNPN_MemFlushProc(FUNC)               \
 899         ((NPN_MemFlushUPP) (FUNC))
 900 #define CallNPN_MemFlushProc(FUNC, ARG1)                \
 901         (*(FUNC))((ARG1))
 902
 903 #endif
 904
 905
 906
 907 /* NPN_ReloadPlugins */
 908
 909 #if _NPUPP_USE_UPP_
 910
 911 typedef UniversalProcPtr NPN_ReloadPluginsUPP;
 912 enum {
 913     uppNPN_ReloadPluginsProcInfo = kThinkCStackBased
 914         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPBool)))
 915         | RESULT_SIZE(SIZE_CODE(0))
 916 };
 917
 918 #define NewNPN_ReloadPluginsProc(FUNC)          \
 919         (NPN_ReloadPluginsUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, GetCurrentArchitecture())
 920 #define CallNPN_ReloadPluginsProc(FUNC, ARG1)           \
 921         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, (ARG1))
 922
 923 #else
 924
 925 typedef void (* NP_LOADDS NPN_ReloadPluginsUPP)(NPBool reloadPages);
 926 #define NewNPN_ReloadPluginsProc(FUNC)          \
 927         ((NPN_ReloadPluginsUPP) (FUNC))
 928 #define CallNPN_ReloadPluginsProc(FUNC, ARG1)           \
 929         (*(FUNC))((ARG1))
 930
 931 #endif
 932
 933
 934 /* NPN_GetJavaEnv */
 935
 936 #if _NPUPP_USE_UPP_
 937
 938 typedef UniversalProcPtr NPN_GetJavaEnvUPP;
 939 enum {
 940     uppNPN_GetJavaEnvProcInfo = kThinkCStackBased
 941         | RESULT_SIZE(SIZE_CODE(sizeof(JRIEnv*)))
 942 };
 943
 944 #define NewNPN_GetJavaEnvProc(FUNC)             \
 945         (NPN_GetJavaEnvUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo, GetCurrentArchitecture())
 946 #define CallNPN_GetJavaEnvProc(FUNC)            \
 947         (JRIEnv*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo)
 948
 949 #else
 950 typedef JRIEnv* (* NP_LOADDS NPN_GetJavaEnvUPP)(void);
 951 #define NewNPN_GetJavaEnvProc(FUNC)             \
 952         ((NPN_GetJavaEnvUPP) (FUNC))
 953 #define CallNPN_GetJavaEnvProc(FUNC)            \
 954         (*(FUNC))()
 955
 956 #endif
 957
 958
 959 /* NPN_GetJavaPeer */
 960
 961 #if _NPUPP_USE_UPP_
 962
 963 typedef UniversalProcPtr NPN_GetJavaPeerUPP;
 964 enum {
 965     uppNPN_GetJavaPeerProcInfo = kThinkCStackBased
 966         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 967         | RESULT_SIZE(SIZE_CODE(sizeof(jref)))
 968 };
 969
 970 #define NewNPN_GetJavaPeerProc(FUNC)            \
 971         (NPN_GetJavaPeerUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, GetCurrentArchitecture())
 972 #define CallNPN_GetJavaPeerProc(FUNC, ARG1)             \
 973         (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, (ARG1))
 974
 975 #else
 976
 977 typedef jref (* NP_LOADDS NPN_GetJavaPeerUPP)(NPP instance);
 978 #define NewNPN_GetJavaPeerProc(FUNC)            \
 979         ((NPN_GetJavaPeerUPP) (FUNC))
 980 #define CallNPN_GetJavaPeerProc(FUNC, ARG1)             \
 981         (*(FUNC))((ARG1))
 982
 983 #endif
 984
 985
 986 /* NPN_InvalidateRect */
 987
 988 #if _NPUPP_USE_UPP_
 989
 990 typedef UniversalProcPtr NPN_InvalidateRectUPP;
 991 enum {
 992     uppNPN_InvalidateRectProcInfo = kThinkCStackBased
 993         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
 994         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPRect *)))
 995         | RESULT_SIZE(SIZE_CODE(0))
 996 };
 997
 998 #define NewNPN_InvalidateRectProc(FUNC)         \
 999         (NPN_InvalidateRectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvalidateRectProcInfo, GetCurrentArchitecture())
1000 #define CallNPN_InvalidateRectProc(FUNC, ARG1, ARG2)            \
1001         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvalidateRectProcInfo, (ARG1), (ARG2))
1002
1003 #else
1004
1005 typedef void (* NP_LOADDS NPN_InvalidateRectUPP)(NPP instance, NPRect *rect);
1006 #define NewNPN_InvalidateRectProc(FUNC)         \
1007         ((NPN_InvalidateRectUPP) (FUNC))
1008 #define CallNPN_InvalidateRectProc(FUNC, ARG1, ARG2)            \
1009         (*(FUNC))((ARG1), (ARG2))
1010
1011 #endif
1012
1013
1014 /* NPN_InvalidateRegion */
1015
1016 #if _NPUPP_USE_UPP_
1017
1018 typedef UniversalProcPtr NPN_InvalidateRegionUPP;
1019 enum {
1020     uppNPN_InvalidateRegionProcInfo = kThinkCStackBased
1021         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
1022         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPRegion)))
1023         | RESULT_SIZE(SIZE_CODE(0))
1024 };
1025
1026 #define NewNPN_InvalidateRegionProc(FUNC)               \
1027         (NPN_InvalidateRegionUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvalidateRegionProcInfo, GetCurrentArchitecture())
1028 #define CallNPN_InvalidateRegionProc(FUNC, ARG1, ARG2)          \
1029         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvalidateRegionProcInfo, (ARG1), (ARG2))
1030
1031 #else
1032
1033 typedef void (* NP_LOADDS NPN_InvalidateRegionUPP)(NPP instance, NPRegion region);
1034 #define NewNPN_InvalidateRegionProc(FUNC)               \
1035         ((NPN_InvalidateRegionUPP) (FUNC))
1036 #define CallNPN_InvalidateRegionProc(FUNC, ARG1, ARG2)          \
1037         (*(FUNC))((ARG1), (ARG2))
1038
1039 #endif
1040
1041 /* NPN_ForceRedraw */
1042
1043 #if _NPUPP_USE_UPP_
1044
1045 typedef UniversalProcPtr NPN_ForceRedrawUPP;
1046 enum {
1047     uppNPN_ForceRedrawProcInfo = kThinkCStackBased
1048         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
1049         | RESULT_SIZE(SIZE_CODE(sizeof(0)))
1050 };
1051
1052 #define NewNPN_ForceRedrawProc(FUNC)            \
1053         (NPN_ForceRedrawUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ForceRedrawProcInfo, GetCurrentArchitecture())
1054 #define CallNPN_ForceRedrawProc(FUNC, ARG1)             \
1055         (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ForceRedrawProcInfo, (ARG1))
1056
1057 #else
1058
1059 typedef void (* NP_LOADDS NPN_ForceRedrawUPP)(NPP instance);
1060 #define NewNPN_ForceRedrawProc(FUNC)            \
1061         ((NPN_ForceRedrawUPP) (FUNC))
1062 #define CallNPN_ForceRedrawProc(FUNC, ARG1)             \
1063         (*(FUNC))((ARG1))
1064
1065 #endif
1066
1067
1068 /******************************************************************************************
1069  * The actual plugin function table definitions
1070  *******************************************************************************************/
1071
1072 #ifdef XP_MAC
1073 #if PRAGMA_STRUCT_ALIGN
1074 #pragma options align=mac68k
1075 #endif
1076 #endif
1077
1078 typedef struct _NPPluginFuncs {
1079     uint16 size;
1080     uint16 version;
1081     NPP_NewUPP newp;
1082     NPP_DestroyUPP destroy;
1083     NPP_SetWindowUPP setwindow;
1084     NPP_NewStreamUPP newstream;
1085     NPP_DestroyStreamUPP destroystream;
1086     NPP_StreamAsFileUPP asfile;
1087     NPP_WriteReadyUPP writeready;
1088     NPP_WriteUPP write;
1089     NPP_PrintUPP print;
1090     NPP_HandleEventUPP event;
1091     NPP_URLNotifyUPP urlnotify;
1092     JRIGlobalRef javaClass;
1093     NPP_GetValueUPP getvalue;
1094     NPP_SetValueUPP setvalue;
1095 } NPPluginFuncs;
1096
1097 typedef struct _NPNetscapeFuncs {
1098     uint16 size;
1099     uint16 version;
1100     NPN_GetURLUPP geturl;
1101     NPN_PostURLUPP posturl;
1102     NPN_RequestReadUPP requestread;
1103     NPN_NewStreamUPP newstream;
1104     NPN_WriteUPP write;
1105     NPN_DestroyStreamUPP destroystream;
1106     NPN_StatusUPP status;
1107     NPN_UserAgentUPP uagent;
1108     NPN_MemAllocUPP memalloc;
1109     NPN_MemFreeUPP memfree;
1110     NPN_MemFlushUPP memflush;
1111     NPN_ReloadPluginsUPP reloadplugins;
1112     NPN_GetJavaEnvUPP getJavaEnv;
1113     NPN_GetJavaPeerUPP getJavaPeer;
1114     NPN_GetURLNotifyUPP geturlnotify;
1115     NPN_PostURLNotifyUPP posturlnotify;
1116     NPN_GetValueUPP getvalue;
1117     NPN_SetValueUPP setvalue;
1118     NPN_InvalidateRectUPP invalidaterect;
1119     NPN_InvalidateRegionUPP invalidateregion;
1120     NPN_ForceRedrawUPP forceredraw;
1121 } NPNetscapeFuncs;
1122
1123 #ifdef XP_MAC
1124 #if PRAGMA_STRUCT_ALIGN
1125 #pragma options align=reset
1126 #endif
1127 #endif
1128
1129
1130 #ifdef XP_MAC
1131 /******************************************************************************************
1132  * Mac platform-specific plugin glue stuff
1133  *******************************************************************************************/
1134
1135 /*
1136  * Main entry point of the plugin.
1137  * This routine will be called when the plugin is loaded. The function
1138  * tables are passed in and the plugin fills in the NPPluginFuncs table
1139  * and NPPShutdownUPP for Netscape's use.
1140  */
1141
1142 #if _NPUPP_USE_UPP_
1143
1144 typedef UniversalProcPtr NPP_MainEntryUPP;
1145 enum {
1146     uppNPP_MainEntryProcInfo = kThinkCStackBased
1147         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPNetscapeFuncs*)))
1148         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPluginFuncs*)))
1149         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPP_ShutdownUPP*)))
1150         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
1151 };
1152 #define NewNPP_MainEntryProc(FUNC)              \
1153         (NPP_MainEntryUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_MainEntryProcInfo, GetCurrentArchitecture())
1154 #define CallNPP_MainEntryProc(FUNC,  netscapeFunc, pluginFunc, shutdownUPP)             \
1155         CallUniversalProc((UniversalProcPtr)(FUNC), (ProcInfoType)uppNPP_MainEntryProcInfo, (netscapeFunc), (pluginFunc), (shutdownUPP))
1156
1157 #else
1158
1159 typedef NPError (* NP_LOADDS NPP_MainEntryUPP)(NPNetscapeFuncs*, NPPluginFuncs*, NPP_ShutdownUPP*);
1160 #define NewNPP_MainEntryProc(FUNC)              \
1161         ((NPP_MainEntryUPP) (FUNC))
1162 #define CallNPP_MainEntryProc(FUNC,  netscapeFunc, pluginFunc, shutdownUPP)             \
1163         (*(FUNC))((netscapeFunc), (pluginFunc), (shutdownUPP))
1164
1165 #endif
1166
1167
1168 /*
1169  * Mac version(s) of NP_GetMIMEDescription(const char *)
1170  * These can be called to retreive MIME information from the plugin dynamically
1171  *
1172  * Note: For compatibility with Quicktime, BPSupportedMIMEtypes is another way
1173  *       to get mime info from the plugin only on OSX and may not be supported
1174  *       in furture version--use NP_GetMIMEDescription instead
1175  */
1176
1177 enum
1178 {
1179  kBPSupportedMIMETypesStructVers_1    = 1
1180 };
1181
1182 typedef struct _BPSupportedMIMETypes
1183 {
1184  SInt32    structVersion;      // struct version
1185  Handle    typeStrings;        // STR# formated handle, allocated by plug-in
1186  Handle    infoStrings;        // STR# formated handle, allocated by plug-in
1187 } BPSupportedMIMETypes;
1188 OSErr BP_GetSupportedMIMETypes(BPSupportedMIMETypes *mimeInfo, UInt32 flags);
1189
1190 #if _NPUPP_USE_UPP_
1191
1192 #define NP_GETMIMEDESCRIPTION_NAME "NP_GetMIMEDescriptionRD"
1193 typedef UniversalProcPtr NP_GetMIMEDescriptionUPP;
1194 enum {
1195     uppNP_GetMIMEDescEntryProc = kThinkCStackBased
1196         | RESULT_SIZE(SIZE_CODE(sizeof(const char *)))
1197 };
1198 #define NewNP_GetMIMEDescEntryProc(FUNC)                \
1199         (NP_GetMIMEDescriptionUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNP_GetMIMEDescEntryProc, GetCurrentArchitecture())
1200 #define CallNP_GetMIMEDescEntryProc(FUNC)               \
1201         (const char *)CallUniversalProc((UniversalProcPtr)(FUNC), (ProcInfoType)uppNP_GetMIMEDescEntryProc)
1202
1203
1204 #else  // !_NPUPP_USE_UPP_
1205
1206  // NP_GetMIMEDescription
1207 #define NP_GETMIMEDESCRIPTION_NAME "NP_GetMIMEDescription"
1208 typedef const char* (* NP_LOADDS NP_GetMIMEDescriptionUPP)();
1209 #define NewNP_GetMIMEDescEntryProc(FUNC)                \
1210         ((NP_GetMIMEDescriptionUPP) (FUNC))
1211 #define CallNP_GetMIMEDescEntryProc(FUNC)               \
1212         (*(FUNC))()
1213 // BP_GetSupportedMIMETypes
1214 typedef OSErr (* NP_LOADDS BP_GetSupportedMIMETypesUPP)(BPSupportedMIMETypes*, UInt32);
1215 #define NewBP_GetSupportedMIMETypesEntryProc(FUNC)              \
1216         ((BP_GetSupportedMIMETypesUPP) (FUNC))
1217 #define CallBP_GetMIMEDescEntryProc(FUNC,  mimeInfo, flags)             \
1218         (*(FUNC))((mimeInfo), (flags))
1219
1220 #endif
1221 #endif /* MAC */
1222
1223 #if defined(_WINDOWS)
1224 #define OSCALL WINAPI
1225 #else
1226 #if defined(__OS2__)
1227 #define OSCALL _System
1228 #else
1229 #define OSCALL
1230 #endif
1231 #endif
1232
1233 #if defined( _WINDOWS ) || defined (__OS2__)
1234
1235 #ifdef __cplusplus
1236 extern "C" {
1237 #endif
1238
1239 /* plugin meta member functions */
1240 #if defined(__OS2__)
1241
1242 typedef struct _NPPluginData {   /* Alternate OS2 Plugin interface */
1243     char *pMimeTypes;
1244     char *pFileExtents;
1245     char *pFileOpenTemplate;
1246     char *pProductName;
1247     char *pProductDescription;
1248     unsigned long dwProductVersionMS;
1249     unsigned long dwProductVersionLS;
1250 } NPPluginData;
1251
1252 NPError OSCALL NP_GetPluginData(NPPluginData * pPluginData);
1253
1254 #endif
1255
1256 NPError OSCALL NP_GetEntryPoints(NPPluginFuncs* pFuncs);
1257
1258 NPError OSCALL NP_Initialize(NPNetscapeFuncs* pFuncs);
1259
1260 NPError OSCALL NP_Shutdown();
1261
1262 char*   NP_GetMIMEDescription();
1263
1264 #ifdef __cplusplus
1265 }
1266 #endif
1267
1268 #endif /* _WINDOWS || __OS2__ */
1269
1270 #if defined(__OS2__)
1271 #pragma pack()
1272 #endif
1273
1274 #ifdef XP_UNIX
1275
1276 #ifdef __cplusplus
1277 extern "C" {
1278 #endif
1279
1280 /* plugin meta member functions */
1281
1282 char*   NP_GetMIMEDescription(void);
1283 NPError NP_Initialize(NPNetscapeFuncs*, NPPluginFuncs*);
1284 NPError NP_Shutdown(void);
1285
1286 #ifdef __cplusplus
1287 }
1288 #endif
1289
1290 #endif /* XP_UNIX */
1291
1292 #endif /* _NPUPP_H_ */