home *** CD-ROM | disk | FTP | other *** search
/ WinWares 1 / WINWARES.ISO / database / gupta / demodll.c / demodll.c
Encoding:
C/C++ Source or Header  |  1993-12-11  |  18.3 KB  |  749 lines
  1.  
  2.  
  3. /* DEMODLL - SQLWindows Demo Dynamic Link Library routines */
  4.  
  5. #define NOCOMM
  6. #include <windows.h>
  7.  
  8. #include <string.h>
  9. #include <memory.h>
  10. #include <dos.h>
  11.  
  12. #include  "swtype.h"
  13. #include  "swin.h"
  14.  
  15. #pragma hdrstop
  16.  
  17. #define EXPORTAPI _far _pascal _export _loadds
  18.  
  19. /* Function Prototypes */
  20.  
  21. BYTE EXPORTAPI    Multiplyx(int, int, LPINT);
  22. void EXPORTAPI    ShowBox(void);
  23. void EXPORTAPI    CopyField(HWND, HWND);
  24. int  EXPORTAPI     Multiply(int, int);
  25. void EXPORTAPI    ShowString(LPSTR);
  26. BOOL EXPORTAPI    ReturnBOOL(BOOL);
  27. char EXPORTAPI    ReturnChar(char);
  28. BYTE EXPORTAPI    ReturnBYTE(BYTE);
  29. int  EXPORTAPI     ReturnInt(int);
  30. WORD EXPORTAPI    ReturnWORD(WORD);
  31. LONG EXPORTAPI    ReturnLONG(LONG);
  32. DWORD EXPORTAPI    ReturnDWORD(DWORD);
  33.  
  34. #if 0 // No longer supported, the MS C 7.0 changed
  35.  
  36. float EXPORTAPI    ReturnFloat(float);
  37. double EXPORTAPI    ReturnDouble(double);
  38.  
  39. #else
  40. int EXPORTAPI    ReturnFloat(float);
  41. int EXPORTAPI    ReturnDouble(double);
  42.  
  43. #endif
  44.  
  45. HWND EXPORTAPI    ReturnHWND(HWND);
  46. SQLHANDLENUMBER EXPORTAPI    ReturnSQLHANDLENUMBER(SQLHANDLENUMBER);
  47. VOID EXPORTAPI    ReturnVOID(void);
  48. BOOL EXPORTAPI    ReturnLPSTR(LPSTR, LPSTR, LPSTR);
  49. BOOL EXPORTAPI    ReturnLPBOOL(LPBOOL, BOOL, BOOL);
  50. BOOL EXPORTAPI    ReturnLPCHAR(LPCHAR, char, char);
  51. BOOL EXPORTAPI    ReturnLPBYTE(LPBYTE, BYTE, BYTE);
  52. BOOL EXPORTAPI    ReturnLPINT(LPINT, int, int);
  53. void EXPORTAPI    ReturnLPHWND(LPHWND, HWND);
  54. BOOL EXPORTAPI    ReturnLPWORD(LPWORD, WORD, WORD);
  55. BOOL EXPORTAPI    ReturnLPLONG(LPLONG, LONG, LONG);
  56. BOOL EXPORTAPI    ReturnLPDWORD(LPDWORD, DWORD, DWORD);
  57. BOOL EXPORTAPI    ReturnLPFLOAT(LPFLOAT, float, float);
  58. BOOL EXPORTAPI    ReturnLPDOUBLE(LPDOUBLE, double, double);
  59. void EXPORTAPI    SetMultilineText(HWND);
  60. BOOL EXPORTAPI    ReturnMixed1(LPINT, int, int,
  61.                  LPLONG, long, long,
  62.                  LPINT, int, int,
  63.                  LPLONG, long, long);
  64. BOOL EXPORTAPI    ReturnLPVOID(LPVOID, int, LPVOID, int, LPVOID, int);
  65. void EXPORTAPI    SetLPVOID(LPVOID, LPSTR, int);
  66. void EXPORTAPI    SortArray(HARRAY);
  67. void EXPORTAPI  ShowArray(HARRAY);
  68. BOOL EXPORTAPI    CombineStrings( HSTRING, HSTRING, LPHSTRING );
  69.  
  70. VOID EXPORTAPI WEP ( int );
  71.  
  72. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  73.  
  74. /*
  75.  * FUNCTION: LibMain(HANDLE, WORD, WORD, LPSTR)
  76.  *
  77.  * PURPOSE:  Is called by LibEntry.  LibEntry is called by Windows when
  78.  *           the DLL is loaded.  The LibEntry routine is provided in
  79.  *           the LIBENTRY.OBJ in the SDK Link Libraries disk.  (The
  80.  *           source LIBENTRY.ASM is also provided.)  
  81.  *
  82.  *           LibEntry initializes the DLL's heap, if a HEAPSIZE value is
  83.  *           specified in the DLL's DEF file.  Then LibEntry calls
  84.  *           LibMain.  The LibMain function below satisfies that call.
  85.  *
  86.  *           The LibMain function should perform additional initialization
  87.  *           tasks required by the DLL.  In this example, no initialization
  88.  *           tasks are required.  LibMain should return a value of 1 if
  89.  *           the initialization is successful.
  90.  */
  91. int EXPORTAPI LibMain( HANDLE hModule,
  92.             WORD wDataSeg,
  93.             WORD cbHeapSize,
  94.                 LPSTR   lpszCmdLine )
  95. {
  96.   hModule;
  97.   wDataSeg;
  98.   cbHeapSize;
  99.   lpszCmdLine;
  100.   return 1;
  101. }
  102.  
  103. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  104.  
  105. Windows DLL exit procedure.
  106. */
  107.  
  108. VOID EXPORTAPI WEP (bSystemExit)
  109. int  bSystemExit;
  110. {
  111.   bSystemExit;
  112. }
  113.  
  114.  
  115.  
  116. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  117. Multiplies parameter 1 and parameter 2 together and passes the result back
  118. in parameter 3.
  119. */
  120.  
  121. BYTE EXPORTAPI    Multiplyx(nNum1, nNum2, lpnResult)
  122. int        nNum1;
  123. int        nNum2;
  124. LPINT        lpnResult;
  125. {
  126.   *lpnResult = nNum1 * nNum2;
  127.  
  128.   return 0;
  129. }
  130.  
  131. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  132. Calling a message box from a DLL.
  133. */
  134.  
  135. void EXPORTAPI ShowBox()
  136. {
  137.   MessageBox(GetActiveWindow(), "I'm in DEMODLL!", "ShowBox",
  138.          MB_OK | MB_ICONASTERISK);
  139. }
  140.  
  141. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  142. Copies the first 99 chars from field hWndTo to field hWndFrom.
  143. */
  144.  
  145. void EXPORTAPI CopyField( hWndTo, hWndFrom )
  146.     HWND    hWndTo;
  147.     HWND    hWndFrom;
  148. {
  149.     char    Buf[100];
  150.  
  151.     GetWindowText( hWndFrom, Buf, sizeof(Buf)-1 );
  152.     SetWindowText( hWndTo, Buf );
  153. }
  154.  
  155. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  156. Returns parameter 1 multiplied by parameter 2.
  157. */
  158.  
  159. int EXPORTAPI Multiply(a, b)
  160. int    a, b;
  161. {
  162.   return a * b;
  163. }
  164.  
  165. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  166. Displays the string passed in a message box.
  167. */
  168.  
  169. void EXPORTAPI ShowString(lpszString)
  170. LPSTR    lpszString;
  171. {
  172.   MessageBox(GetActiveWindow(), lpszString, "ShowString",
  173.          MB_OK | MB_ICONASTERISK);
  174. }
  175.  
  176. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  177.  
  178. char SetMultilineTextString[] =
  179. "now is the time for all good men to come to the aid of their country\r\nnow is the time for all good men to come to the aid of their country";
  180.  
  181. void EXPORTAPI    SetMultilineText(hWnd)
  182. HWND        hWnd;
  183. {
  184.   SetWindowText(hWnd, SetMultilineTextString);
  185. }
  186.  
  187. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  188. Examples of returning each of the SQLWindows Data Types passed as parameters.
  189. */
  190.  
  191. BOOL EXPORTAPI    ReturnBOOL(varBOOL)
  192. BOOL        varBOOL;
  193. {
  194.   return varBOOL;
  195. }
  196.  
  197. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  198.  
  199. char EXPORTAPI    ReturnChar(varChar)
  200. char        varChar;
  201. {
  202.   return varChar;
  203. }
  204.  
  205. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  206.  
  207. BYTE EXPORTAPI    ReturnBYTE(varBYTE)
  208. BYTE        varBYTE;
  209. {
  210.   return varBYTE;
  211. }
  212.  
  213. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  214.  
  215. int EXPORTAPI     ReturnInt(varInt)
  216. int        varInt;
  217. {
  218.   return varInt;
  219. }
  220.  
  221. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  222.  
  223. WORD EXPORTAPI    ReturnWORD(varWORD)
  224. WORD        varWORD;
  225. {
  226.   return varWORD;
  227. }
  228.  
  229. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  230.  
  231. LONG EXPORTAPI    ReturnLONG(varLONG)
  232. LONG        varLONG;
  233. {
  234.   return varLONG;
  235. }
  236.  
  237. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  238.  
  239. DWORD EXPORTAPI    ReturnDWORD(varDWORD)
  240. DWORD        varDWORD;
  241. {
  242.   return varDWORD;
  243. }
  244.  
  245. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  246.  
  247. #if 0 // EMS=0 We need to handle the C compiler support for this differently
  248.  
  249. float EXPORTAPI    ReturnFloat(float varFloat)
  250. {
  251.  
  252. return varFloat;
  253.  
  254. }
  255.  
  256.  
  257. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  258.  
  259. double EXPORTAPI    ReturnDouble(varDouble)
  260. double        varDouble;
  261. {
  262.   return varDouble;
  263. }
  264.  
  265. #else
  266.  
  267. int EXPORTAPI    ReturnFloat(float varFloat)
  268. {
  269.  
  270. return (int)varFloat;
  271.  
  272. }
  273.  
  274.  
  275. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  276.  
  277. int EXPORTAPI    ReturnDouble(varDouble)
  278. double        varDouble;
  279. {
  280.   return (int)varDouble;
  281. }
  282.  
  283. #endif
  284. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  285.  
  286. HWND EXPORTAPI    ReturnHWND(varHWND)
  287. HWND        varHWND;
  288. {
  289.   return varHWND;
  290. }
  291.  
  292. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  293.  
  294. SQLHANDLENUMBER EXPORTAPI ReturnSQLHANDLENUMBER(varSQLHANDLENUMBER)
  295. SQLHANDLENUMBER        varSQLHANDLENUMBER;
  296. {
  297.   return varSQLHANDLENUMBER;
  298. }
  299.  
  300. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  301.  
  302. VOID EXPORTAPI    ReturnVOID()
  303. {
  304. }
  305.  
  306. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  307. For each ReturnLPxxx function below, var1 must equal var3. The function
  308. returns var2 in var1.
  309. */
  310.  
  311. BOOL EXPORTAPI    ReturnLPSTR(varLPSTR, varLPSTR2, varLPSTR3)
  312. LPSTR        varLPSTR;
  313. LPSTR        varLPSTR2;
  314. LPSTR        varLPSTR3;
  315. {
  316. BOOL        bResult;
  317.  
  318.   bResult = !lstrcmp(varLPSTR, varLPSTR3);
  319.   lstrcpy(varLPSTR, varLPSTR2);
  320.  
  321.   return bResult;
  322. }
  323.  
  324. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  325.  
  326. BOOL EXPORTAPI    ReturnLPBOOL(varLPBOOL, varBOOL, varBOOLTEST)
  327. LPBOOL        varLPBOOL;
  328. BOOL        varBOOL;
  329. BOOL        varBOOLTEST;
  330. {
  331. BOOL        bResult;
  332.  
  333.   bResult = *varLPBOOL == varBOOLTEST;
  334.   *varLPBOOL = varBOOL;
  335.  
  336.   return bResult;
  337. }
  338.  
  339. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  340.  
  341. BOOL EXPORTAPI    ReturnLPCHAR(varLPCHAR, varCHAR, varCHARTEST)
  342. LPCHAR        varLPCHAR;
  343. char        varCHAR;
  344. char        varCHARTEST;
  345. {
  346. BOOL        bResult;
  347.  
  348.   bResult = *varLPCHAR == varCHARTEST;
  349.   *varLPCHAR = varCHAR;
  350.  
  351.   return bResult;
  352. }
  353.  
  354. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  355.  
  356. BOOL EXPORTAPI    ReturnLPBYTE(varLPBYTE, varBYTE, varBYTETEST)
  357. LPBYTE        varLPBYTE;
  358. BYTE        varBYTE;
  359. BYTE        varBYTETEST;
  360. {
  361. BOOL        bResult;
  362.  
  363.   bResult = *varLPBYTE == varBYTETEST;
  364.   *varLPBYTE = varBYTE;
  365.  
  366.   return bResult;
  367. }
  368.  
  369. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  370.  
  371. BOOL EXPORTAPI    ReturnLPINT(varLPINT, varINT, varINTTEST)
  372. LPINT        varLPINT;
  373. int        varINT;
  374. int        varINTTEST;
  375. {
  376. BOOL        bResult;
  377.  
  378.   bResult = *varLPINT == varINTTEST;
  379.   *varLPINT = varINT;
  380.  
  381.   return bResult;
  382. }
  383.  
  384. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  385.  
  386. BOOL EXPORTAPI    ReturnLPWORD(varLPWORD, varWORD, varWORDTEST)
  387. LPWORD        varLPWORD;
  388. WORD        varWORD;
  389. WORD        varWORDTEST;
  390. {
  391. BOOL        bResult;
  392.  
  393.   bResult = *varLPWORD == varWORDTEST;
  394.   *varLPWORD = varWORD;
  395.  
  396.   return bResult;
  397. }
  398.  
  399. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  400.  
  401. BOOL EXPORTAPI    ReturnLPLONG(varLPLONG, varLONG, varLONGTEST)
  402. LPLONG        varLPLONG;
  403. LONG        varLONG;
  404. LONG        varLONGTEST;
  405. {
  406. BOOL        bResult;
  407.  
  408.   bResult = *varLPLONG == varLONGTEST;
  409.   *varLPLONG = varLONG;
  410.  
  411.   return bResult;
  412. }
  413.  
  414. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  415.  
  416. BOOL EXPORTAPI    ReturnLPDWORD(varLPDWORD, varDWORD, varDWORDTEST)
  417. LPDWORD     varLPDWORD;
  418. DWORD        varDWORD;
  419. DWORD        varDWORDTEST;
  420. {
  421. BOOL        bResult;
  422.  
  423.   bResult = *varLPDWORD == varDWORDTEST;
  424.   *varLPDWORD = varDWORD;
  425.  
  426.   return bResult;
  427. }
  428.  
  429. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  430.  
  431. BOOL EXPORTAPI    ReturnLPFLOAT(LPFLOAT varLPFLOAT, float varFLOAT,
  432.                   float varFLOATTEST)
  433. {
  434. BOOL        bResult;
  435.  
  436.   bResult = *varLPFLOAT == varFLOATTEST;
  437.   *varLPFLOAT = varFLOAT;
  438.  
  439.   return bResult;
  440. }
  441.  
  442. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  443.  
  444. BOOL EXPORTAPI    ReturnLPDOUBLE(varLPDOUBLE, varDOUBLE, varDOUBLETEST)
  445. LPDOUBLE    varLPDOUBLE;
  446. double        varDOUBLE;
  447. double        varDOUBLETEST;
  448. {
  449. BOOL        bResult;
  450.  
  451.   bResult = *varLPDOUBLE == varDOUBLETEST;
  452.   *varLPDOUBLE = varDOUBLE;
  453.  
  454.   return bResult;
  455. }
  456.  
  457. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  458.  
  459. void EXPORTAPI    ReturnLPHWND(varLPHWND, varHWND)
  460. LPHWND        varLPHWND;
  461. HWND        varHWND;
  462. {
  463.   *varLPHWND = varHWND;
  464. }
  465.  
  466. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  467. This function follows the pattern of the ReturnLPxxx functions above: For
  468. each set of 3 parameters the 1st must equal the 3rd; the 2nd is then passed
  469. back to the caller in the 1st parameter.
  470. */
  471.  
  472. BOOL EXPORTAPI    ReturnMixed1(
  473.         LPINT  varLPINT1,  int varINT1,   int varINT1TEST,
  474.         LPLONG varLPLONG1, long varLONG1, long varLONG1TEST,
  475.         LPINT  varLPINT2,  int varINT2,   int varINT2TEST,
  476.         LPLONG varLPLONG2, long varLONG2, long varLONG2TEST)
  477. {
  478. BOOL    bResult;
  479.  
  480.   bResult = *varLPINT1 == varINT1TEST &&
  481.         *varLPINT2 == varINT2TEST &&
  482.         *varLPLONG1 == varLONG1TEST &&
  483.         *varLPLONG2 == varLONG2TEST;
  484.  
  485.   *varLPINT1 = varINT1;
  486.   *varLPINT2 = varINT2;
  487.   *varLPLONG1 = varLONG1;
  488.   *varLPLONG2 = varLONG2;
  489.  
  490.   return bResult;
  491. }
  492.  
  493. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  494. var1 must equal var3, and return var2 in var1; but the difference in
  495. lengths are passed for everything.
  496. */
  497.  
  498. BOOL EXPORTAPI    ReturnLPVOID(varLPVOID1, nLen1,
  499.                  varLPVOID2, nLen2,
  500.                  varLPVOID3, nLen3)
  501. LPVOID        varLPVOID1;
  502. int        nLen1;
  503. LPVOID        varLPVOID2;
  504. int        nLen2;
  505. LPVOID        varLPVOID3;
  506. int        nLen3;
  507. {
  508. BOOL        bResult;
  509. LPSTR        lp1Save;
  510. LPSTR        lp2End;
  511. LPSTR        varLPVOID1LPSTR;
  512. LPSTR        varLPVOID2LPSTR;
  513. LPSTR        varLPVOID3LPSTR;
  514. int        nLength;
  515.  
  516.   varLPVOID1LPSTR = varLPVOID1;
  517.   varLPVOID2LPSTR = varLPVOID2;
  518.   varLPVOID3LPSTR = varLPVOID3;
  519.  
  520.   lp1Save = varLPVOID1;
  521.  
  522.   nLength = min(nLen1, nLen3);
  523.  
  524.   bResult = TRUE;
  525.   for (; nLength > 0; nLength--)
  526.     if (*varLPVOID1LPSTR++ != *varLPVOID3LPSTR++)
  527.     {
  528.       bResult = FALSE;
  529.       break;
  530.     }
  531.  
  532.   for (lp2End = varLPVOID2LPSTR + nLen2; varLPVOID2LPSTR < lp2End; )
  533.     *lp1Save++ = *varLPVOID2LPSTR++;
  534.  
  535.   return bResult;
  536. }
  537.  
  538. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  539. Help routines for LPVOID calls.  This sets the first arg to a string
  540. consisting of the second string followed by nulls and junk up to length given.
  541. */
  542.  
  543. void EXPORTAPI SetLPVOID(varLPVOID, strStart, nLength)
  544. LPVOID    varLPVOID;
  545. LPSTR    strStart;
  546. int    nLength;
  547. {
  548. int    nStringLength;
  549. int    n;
  550. LPSTR    lpV;
  551. LPSTR    varLPVOIDLPSTR;
  552. char    VOIDSTR[512];
  553.  
  554.   lstrcpy( VOIDSTR, "\000\001\002\003\004\005\006\007\000\008\009\010\011\012\000\000\000\001\002\003\004\005\006\007" );
  555.   lstrcat( VOIDSTR, "\000\008\009\010\011\012\000\000\000\001\002\003\004\005\006\007\000\008\009\010\011\012\000\000" );
  556.   lstrcat( VOIDSTR, "\000\001\002\003\004\005\006\007\000\008\009\010\011\012\000\000\000\001\002\003\004\005\006\007" );
  557.   lstrcat( VOIDSTR, "\000\008\009\010\011\012\000\000\000\001\002\003\004\005\006\007\000\008\009\010\011\012\000\000" );
  558.  
  559.   varLPVOIDLPSTR = varLPVOID;
  560.  
  561.   nStringLength = lstrlen(strStart);
  562.   lstrcpy(varLPVOID, strStart);     /* copy first part */
  563.  
  564.   for (varLPVOIDLPSTR += nStringLength, lpV = VOIDSTR, n = 0;
  565.        n < nLength - nStringLength;
  566.        n++)
  567.     *varLPVOIDLPSTR++ = *lpV++;
  568. }
  569.  
  570. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  571.  
  572. /*
  573.  * Simple shuffle sort to sort array
  574.  */
  575. void EXPORTAPI SortArray(HARRAY hArray)
  576. {
  577.   BOOL     bDirty;
  578.   LONG     lLowerLimit;
  579.   LONG     lUpperLimit;
  580.   LONG     lCurrent;
  581.   INT     nLow;
  582.   INT     nHigh;
  583.   NUMBER numValueLow;
  584.   NUMBER numValueHigh;
  585.  
  586.   SalQueryArrayBounds( hArray, &lLowerLimit, &lUpperLimit );
  587.   bDirty = TRUE;
  588.   while( bDirty )
  589.   {
  590.     bDirty = FALSE;
  591.     for( lCurrent = lLowerLimit; lCurrent < lUpperLimit; lCurrent++ )
  592.     {
  593.       SWinArrayGetNumber( hArray, lCurrent, &numValueLow );
  594.       SWinCvtNumberToInt( &numValueLow, &nLow );
  595.       SWinArrayGetNumber( hArray, lCurrent + 1, &numValueHigh );
  596.       SWinCvtNumberToInt( &numValueHigh, &nHigh );
  597.  
  598.       if( nLow > nHigh )
  599.       {
  600.     /* Switch the numbers */
  601.  
  602.     bDirty = TRUE;
  603.     SWinArrayPutNumber( hArray, lCurrent,     &numValueHigh );
  604.     SWinArrayPutNumber( hArray, lCurrent + 1, &numValueLow );
  605.       }
  606.     }
  607.   }
  608. }
  609.  
  610. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  611.  
  612. /*
  613.  * Display some information about a string array
  614.  */
  615. void EXPORTAPI ShowArray(HARRAY hArray)
  616. {
  617.   LONG     lLowerLimit;
  618.   LONG     lUpperLimit;
  619.   LONG     lCurrent;
  620.   LONG   lLength;
  621.   LPSTR  lpStrItem;
  622.   char   cBuff[128];
  623.   BOOL   bStopped;
  624.   HSTRING hString;
  625.   int    nRet;
  626.  
  627.   /* Get the current array bounds */
  628.   
  629.   SalQueryArrayBounds( hArray, &lLowerLimit, &lUpperLimit );
  630.   
  631.   /* Display the array bounds */
  632.   
  633.   wsprintf(cBuff, "This array boundries are: %ld - %ld", lLowerLimit,
  634.                              lUpperLimit);
  635.   SalMessageBox(cBuff, "ShowArray", MB_Ok);
  636.   
  637.   bStopped = FALSE;
  638.   lCurrent = lLowerLimit;
  639.     
  640.   while (!bStopped)
  641.   {
  642.     /*
  643.       Now loop through each of the elements, and display until the
  644.       user says stop or we are at the end of the array.
  645.     */
  646.     
  647.     if (lCurrent > lUpperLimit)
  648.       break;
  649.     
  650.     /* Retrieve the element of the array */
  651.     
  652.     SWinArrayGetHString(hArray, lCurrent, &hString);
  653.     
  654.     /* Now that we have the hString, we need to get a pointer to it. */
  655.     
  656.     lpStrItem = SWinHStringLock(hString, &lLength);
  657.     
  658.     /* Now display it. */
  659.     
  660.     wsprintf(cBuff, "String Array element %ld: %.50s\n\rContinue?",
  661.                     lCurrent, lpStrItem);
  662.     nRet = MessageBox(NULL, cBuff, "ShowArray", MB_YESNO | MB_ICONQUESTION);
  663.     
  664.     if (nRet == IDNO)
  665.       bStopped = TRUE;
  666.     
  667.     /* Now unlock the string pointer */
  668.     
  669.     SWinHStringUnlock(hString);
  670.     
  671.     /*
  672.       For this example, lets also change this string.  You should not
  673.       write directly into a string, since there may be other's pointing
  674.       to it.  So, you need to dereference this one and get a new one.
  675.       That is what SWinInitLpHstringParam() is for.
  676.     */
  677.     
  678.     SWinInitLPHSTRINGParam(&hString, 128L);
  679.     
  680.     /* Now hString contains a new string that I can write into. */
  681.     
  682.     lpStrItem = SWinHStringLock(hString, &lLength);
  683.     lstrcpy(lpStrItem, "String replaced in ShowArray");
  684.     SWinHStringUnlock(hString);
  685.     
  686.     /* Now we need to put this hString into the array. */
  687.     
  688.     SWinArrayPutHString(hArray, lCurrent, hString);
  689.     
  690.     /* Look at the next element */
  691.     
  692.     lCurrent++;
  693.   }
  694. }
  695.  
  696. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  697.  
  698. /*
  699.  * Concatenate two strings and put the resultant string into lphDestination
  700.  */
  701. BOOL EXPORTAPI  CombineStrings( hString1, hString2, lphDestination )
  702. HSTRING   hString1;
  703. HSTRING   hString2;
  704. LPHSTRING lphDestination;
  705. {
  706.   LONG         lLength;
  707.   char huge *lpString1;
  708.   char huge *lpString2;
  709.   char huge *lpDestination;
  710.   LONG         lDummy;
  711.  
  712.  
  713.   /* Get length of both source strings (without zero delimiter */
  714.  
  715.   lLength  = SalStrGetBufferLength( hString1 ) - 1;
  716.   lLength += SalStrGetBufferLength( hString2 ) - 1;
  717.   
  718.  
  719.   /*
  720.    * SWinInitLpHSTRINGParam() conditions the destination to receive the
  721.    * destination string data.  It must be called on a LPHSTRING data
  722.    * type to condition the data.  Not calling it would cause the
  723.    * application to become corrupted.
  724.    */
  725.  
  726.   if (!SWinInitLPHSTRINGParam(lphDestination, lLength + 1))
  727.     return FALSE;
  728.   
  729.   lpDestination = SWinHStringLock(*lphDestination, &lDummy);
  730.  
  731.   lpString1 = SWinHStringLock(hString1, &lDummy);
  732.   while( *lpDestination++ = *lpString1++ )
  733.     ;
  734.   SWinHStringUnlock(hString1);
  735.  
  736.   lpDestination--;
  737.  
  738.   lpString2 = SWinHStringLock(hString2, &lDummy);
  739.   while( *lpDestination++ = *lpString2++ )
  740.     ;
  741.   SWinHStringUnlock(hString2);
  742.   
  743.   SWinHStringUnlock(*lphDestination);
  744.  
  745.   return TRUE;
  746. }
  747.  
  748. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  749.