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