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