home *** CD-ROM | disk | FTP | other *** search
/ .net 2002 March / DotNetMagazine-Issue107-Coverdisc-NET107-02-03-PCMac.bin / pc / PC Software / picks / HTTrack / httrack-3.22-3.exe / {app} / src / htsnostatic.h < prev    next >
Encoding:
C/C++ Source or Header  |  2002-11-17  |  5.9 KB  |  228 lines
  1. /* ------------------------------------------------------------ */
  2. /*
  3. HTTrack Website Copier, Offline Browser for Windows and Unix
  4. Copyright (C) Xavier Roche and other contributors
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20.  
  21. Important notes:
  22.  
  23. - We hereby ask people using this source NOT to use it in purpose of grabbing
  24. emails addresses, or collecting any other private information on persons.
  25. This would disgrace our work, and spoil the many hours we spent on it.
  26.  
  27.  
  28. Please visit our Website: http://www.httrack.com
  29. */
  30.  
  31.  
  32. /* ------------------------------------------------------------ */
  33. /* File: htsnostatic.c subroutines:                             */
  34. /*       thread-safe routines for reentrancy                    */
  35. /* Author: Xavier Roche                                         */
  36. /* ------------------------------------------------------------ */
  37.  
  38. /*
  39.   Okay, with these routines, the engine should be fully reentrant (thread-safe)
  40.   All static references have been changed:
  41.  
  42.   from
  43.   function foo() {
  44.     static bartype bar;
  45.   }
  46.   to:
  47.   function foo() {
  48.     bartype* bar;
  49.     NOSTATIC_RESERVE(bar, bartype, 1);
  50.   }
  51. */
  52.  
  53. #ifndef HTSNOSTATIC_DEFH
  54. #define HTSNOSTATIC_DEFH 
  55.  
  56. #include "htscore.h"
  57. #include "htsthread.h"
  58.  
  59. /*
  60. #if USE_PTHREAD
  61. #if HTS_WIN
  62. #undef HTS_REENTRANT
  63. #else
  64. #define HTS_REENTRANT
  65. #endif
  66. #else
  67. #undef HTS_REENTRANT
  68. #endif
  69. */
  70.  
  71. #define HTS_VAR_MAIN_HASH 127
  72.  
  73. /*
  74.   MutEx
  75. */
  76.  
  77.  
  78. /* Magic per-thread variables functions 
  79.  
  80.   Example:
  81.   hts_lockvar();
  82.   hts_setvar("MyFoo", (long int)(void*)&foo);
  83.   hts_unlockvar();
  84.   ..
  85.   foo=(void*)(long int)hts_directgetvar("MyFoo");
  86.  
  87.   Do not forget to initialize (hts_initvar()) the library once per thread
  88. */
  89. int hts_initvar(void);
  90. int hts_freevar(void);
  91. HTSEXT_API int hts_resetvar(void);
  92. int hts_maylockvar(void);
  93. int hts_lockvar(void);
  94. int hts_unlockvar(void);
  95.  
  96. int hts_setvar(char* name, long int value);
  97. int hts_getvar(char* name, long int* ptrvalue);
  98. long int hts_directgetvar(char* name);
  99.  
  100. int hts_setblkvar(char* name, void* value);
  101. int hts_getblkvar(char* name, void** ptrvalue);
  102. void* hts_directgetblkvar(char* name);
  103.  
  104. /* Internal */
  105. int hts_setextvar(char* name, long int value, int flag);
  106. int hts_getextvar(char* name, long int* ptrvalue, int flag);
  107. void hts_destroyvar(void* ptrkey);
  108. void hts_destroyvar_key(void* adr);
  109.  
  110. /* 
  111.   Ensure that the variable 'name' has 'nelts' of type 'type' reserved 
  112.   fnc is an UNIQUE function name
  113. */
  114. #define NOSTATIC_RESERVE(name, type, nelt) NOSTATIC_XRESERVE(name, type, nelt)
  115.  
  116. /*
  117.   Note:
  118.   Yes, we first read the localInit flag variable without MutEx protection,
  119.   for optimization purpose, because the flag is set once initialization DONE.
  120.   If the first read fails, we *securely* re-check and initialize *if* necessary.
  121.   The abort() things should NEVER be called, and are here for safety reasons
  122. */
  123. /*
  124.   function-specific static cKey:
  125.   cKey = { localKey, localInit }
  126.               ||        \
  127.               \/          \ ==1 upon initialization
  128.          thread variable
  129.               ||
  130.               \/
  131.              void*
  132.               ||
  133.               \/
  134.       'thread-static' value
  135.  
  136.   the function-specific static cKey is also referenced in the global 
  137.   hashtable for free() purpose: (see hts_destroyvar())
  138.  
  139.       global static key variable
  140.         'hts_static_key'
  141.                ||
  142.                \/
  143.          thread variable
  144.                ||
  145.                \/
  146.               void*
  147.                ||
  148.                \/
  149.             hashtable
  150.                ||
  151.                \/
  152.      function-specific hash key
  153.                ||
  154.                \/
  155.               &cKey
  156.  
  157. */
  158. #if HTS_WIN
  159.  
  160. /* Windows: handled by the compiler */
  161. #define NOSTATIC_XRESERVE(name, type, nelt) do { \
  162.   __declspec( thread ) static type thValue[nelt]; \
  163.   __declspec( thread ) int  static initValue = 0; \
  164.   name = thValue; \
  165.   if (!initValue) { \
  166.     initValue = 1; \
  167.     memset(&thValue, 0, sizeof(thValue)); \
  168.   } \
  169. } while(0)
  170.  
  171. #else
  172.  
  173. /* Un*x : slightly more complex, we have to create a thread-key */
  174. typedef struct {
  175.   PTHREAD_KEY_TYPE localKey;
  176.   unsigned char localInit;
  177. } hts_NostaticComplexKey;
  178. #define NOSTATIC_XRESERVE(name, type, nelt) do { \
  179. static hts_NostaticComplexKey cKey={0,0}; \
  180. name = NULL; \
  181. if ( cKey.localInit ) { \
  182.   PTHREAD_KEY_GET(cKey.localKey, &name, type*); \
  183. } \
  184. if ( ( ! cKey.localInit ) || ( name == NULL ) ) { \
  185.   if (!hts_maylockvar()) { \
  186.     abortLog("unable to lock mutex (not initialized?!)"); \
  187.     abort(); \
  188.   } \
  189.   hts_lockvar(); \
  190.   { \
  191.     { \
  192.       name = (type *) calloc((nelt), sizeof(type)); \
  193.       if (name == NULL) { \
  194.         abortLog("unable to allocate memory for variable!"); \
  195.         abort(); \
  196.       } \
  197.       { \
  198.         char elt_name[64+8]; \
  199.         sprintf(elt_name, #name "_%d", (int) __LINE__); \
  200.         PTHREAD_KEY_CREATE(&(cKey.localKey), NULL); \
  201.         hts_setblkvar(elt_name, &cKey); \
  202.       } \
  203.       PTHREAD_KEY_SET(cKey.localKey, name, type*); \
  204.       name = NULL; \
  205.       PTHREAD_KEY_GET(cKey.localKey, &name, type*); \
  206.       if (name == NULL) { \
  207.         abortLog("unable to load thread key!"); \
  208.         abort(); \
  209.       } \
  210.       if ( ! cKey.localInit ) { \
  211.         cKey.localInit = 1; \
  212.       } \
  213.     } \
  214.   } \
  215.   hts_unlockvar(); \
  216. } \
  217. else { \
  218.   PTHREAD_KEY_GET(cKey.localKey, &name, type*); \
  219.   if (name == NULL) { \
  220.     abortLog("unable to load thread key! (2)"); \
  221.     abort(); \
  222.   } \
  223. } \
  224. } while(0)
  225. #endif
  226.  
  227. #endif
  228.