home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / hugstr / hugearr.his < prev    next >
Encoding:
Text File  |  1992-04-01  |  6.6 KB  |  171 lines
  1. HUGEARR.HIS -- History of Public Modifications to HUGEARR.DLL
  2.  
  3. Microsoft Customer Support uploaded to the MSL a DLL to support huge
  4. arrays from Visual BASIC v1.0.  Because the source was included, and
  5. no copyright posted, HUGEARR.DLL has a lot of educational potential.
  6. I found a small bug in HUGEARRY.DLL, or rather an oversight, in that
  7. HugeUbound was defined as an integer function, thus preventing its
  8. use on...huge arrays.  The bug fix was simple and this ZIP file
  9. contains the modified files.  It occurred to me that there were a
  10. number of array related functions that might be added to the DLL
  11. so I started this history file in hopes that modifications could
  12. be made in one place and re-posted over this file.
  13. Jonathan Zuck, User Friendly, Inc. 06/26/91
  14.  
  15.  
  16.  
  17. 06/10/91        Original Files:         MS Customer Support
  18.  
  19. HUGEARR.BAS     05/13/91
  20. HUGEARR.C       06/10/91
  21. HUGEARR.DEF     05/09/91
  22. HUGEARR.DLL     06/10/91
  23. HUGEARR.H       05/10/91
  24. HUGEARR.TXT     06/04/91
  25. MAKEFILE        05/10/91
  26.  
  27. 06/26/91        HUGEUBOUND now returns LONG     User Friendly, Inc.
  28.  
  29. Changed Files:
  30.  
  31. HUGEARR.BAS     06/26/91
  32. HUGEARR.TXT     06/26/91
  33. HUGEARR.C       06/26/91
  34. HUGEARR.H       06/26/91
  35. HUGEARR.DLL     06/26/91
  36.  
  37. New Files:
  38.  
  39. History.TXT     06/26/91
  40.  
  41. Remarks:
  42. The purpose of HUGEARR.DLL was to support huge arrays.  However,
  43. HugeUbound was defined as an integer function, making it impossible
  44. to get consistent results when the array had more than 32k elements.
  45. The changes here are quite simple:
  46.  
  47. HUGEARR.BAS
  48.         Changed the Declare statment for HugeUbound
  49. HUGEARR.TXT
  50.         Modified HugeUbound example
  51. HUGEARR.C
  52.         Changed the function return to LONG
  53.         Changed the ubound variable declaration to LONG
  54. HUGEARR.H
  55.         Changed the HugeUbound declaration to LONG
  56. HUGEARR.DLL
  57.         Re-built using NMAKE
  58.  
  59. ************************************************************************
  60.  
  61. Date:  12/31/1991
  62. From:  Stephen Schmidt, CompuServe ID 73200,3207
  63. Subj:  HUGEARR V1.2 Modifications to support any integer sized element
  64.  
  65. VB Users:
  66.      HUGEARR can now store and retrieve individual array elements with lengths
  67. of between 1 and 32,767 bytes.  (It is no longer limited to array elements
  68. whose size is a power of two.)
  69.  
  70. C Developers:
  71.      HUGEARR now stores as many elements as possible within each segment of
  72. memory allocated for the array.  Unused space is left at the end of each
  73. segment so that individual elements will not span multiple segments.
  74.      This should result in less unused space per segment when the element size
  75. is small, and it relieves the user from having to pad elements so that their
  76. size is a power of two.
  77.  
  78. ************************************************************************
  79.  
  80. Date:  2/22/92
  81. From:  Stephen Schmidt, CompuServe ID 73200,3207
  82. Subj:  HUGEARR V1.3 Modifications to return non-zero array handles
  83.  
  84. VB Users:
  85.      HUGEARR will no longer return an array handle of zero, so that you can
  86. store array handles in variables and assume that a handle value of zero does
  87. NOT refer to a dimensioned array.  If you use this approach, and you will be
  88. erasing and dimensioning arrays using the same array handle variable, then I
  89. suggest that you set the array handle variable to zero after it's array has
  90. been erased.
  91.  
  92. C Developers:
  93.      Within the DLL, handles still range between 0 and MaxNumArrays - 1,
  94. whereas outside of the DLL, handles range between 1 and MaxNumArrays.  The
  95. array handle is decremented by one at key entry points within the functions.
  96.  
  97.      Also, if the Windows GlobalRealloc() function fails during a call to
  98. HugeRedim(), HUGEARR will transparently attempt to create a new array and copy
  99. the elements from the existing array over to it.
  100.  
  101. ************************************************************************
  102.  
  103. 02/23/91        HUGESAVE and HUGELOAD added     End User Computing Ltd.
  104.  
  105. Changed Files:
  106.  
  107. HUGEARR.BAS     02/23/92
  108. HUGEARR.TXT     02/23/92
  109. HUGEARR.C       02/23/92
  110. HUGEARR.H       02/23/92
  111. HUGEARR.DLL     02/23/92
  112. HUGEARR.DEF     02/23/92
  113. HISTORY.TXT     02/23/92
  114.  
  115. Remarks:
  116. In order to speed up the saving and loading of Huge Arrays the two
  117. functions HugeLoad and HugeSave were added.
  118.  
  119. HUGEARR.BAS
  120.         Added the Declare statments for HugeSave and HugeLoad
  121. HUGEARR.TXT
  122.         Added HugeSave and HugeLoad examples
  123. HUGEARR.C
  124.         Added HugeSave and hugeLoad functions
  125. HUGEARR.H
  126.         Added function prototypes for HugeLoad and HugeSave
  127.         Added constants HA_FILEOPENERROR, HA_FILEREADERROR and
  128.         HA_FILEWRITEERROR
  129. HUGEARR.DEF
  130.         Added declarations for HugeLoad and HugeSave
  131. HUGEARR.DLL
  132.         Re-built using MAKE
  133.  
  134. ************************************************************************
  135.  
  136. Date:  4/2/92
  137. From:  Stephen Schmidt, CompuServe ID 73200,3207
  138. Subj:  HUGEARR V1.6 Modifications to add multiple-element assignment functions
  139.  
  140. VB Users:
  141.      Added the VBHugeGetNum which will copy several contiguous elements from a
  142. huge array into some part of a VB array, and added the related VBHugeSetNum
  143. function which will copy several contiguous elements from a VB array into a
  144. huge array.  Renamed most of the functions to be more consistent.  Merged the
  145. HugeSave and HugeLoad functions from End User Computing, Ltd.
  146.      I've been using most of the huge array functions within my VB programs
  147. since I first posted them on CompuServe, and I don't know of any problems.
  148. Let me know if find any problems--no fixes guaranteed though.
  149.  
  150. C Developers:
  151.      I changed the program so that it will now compile with only a few warnings
  152. at level 4, and replaced some of the more redundant blocks of code with C
  153. preprocessor macros.  Most of the exported functions were placed in their own
  154. source file and segment. THIS FILE was renamed from HISTORY.TXT to HUGEARR.HIS.
  155.      I compiled the DLL to work in non-protected Windows mode also--there may
  156. be problems when using this DLL in non-protected mode stemming from my
  157. assumptions about how many elements will fit within a segment--test these
  158. functions thouroughly before using them in your important non-protected
  159. applications.
  160.      The DLL was compiled in medium model with Microsoft Quick C for Windows.
  161.  
  162. ----------
  163.  
  164. These changes are hereby released into the public domain by Stephen Schmidt.
  165.  
  166. USERS OF THIS SOFTWARE MUST ACCEPT THIS DISCLAIMER OF WARRANTY:  "THIS SOFTWARE
  167. IS SUPPLIED AS IS.  THE AUTHORS DISCLAIM ALL WARRANTIES, EXPRESSED OR IMPLIED,
  168. INCLUDING, WITHOUT LIMITATION, THE WARRANTIES OF MERCHANTABILITY AND OF FITNESS
  169. FOR ANY PURPOSE.  THE AUTHORS ASSUME NO LIABILITY FOR DAMAGES, DIRECT OR
  170. CONSEQUENTIAL, WHICH MAY RESULT FROM THE USE OF THIS SOFTWARE."
  171.