home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / winbase / security / crypto / cfiler / table.c < prev    next >
C/C++ Source or Header  |  1997-10-08  |  13KB  |  546 lines
  1.  
  2. /******************************************************************************\
  3. *       This is a part of the Microsoft Source Code Samples. 
  4. *       Copyright 1996-1997 Microsoft Corporation.
  5. *       All rights reserved. 
  6. *       This source code is only intended as a supplement to 
  7. *       Microsoft Development Tools and/or WinHelp documentation.
  8. *       See these sources for detailed information regarding the 
  9. *       Microsoft samples programs.
  10. \******************************************************************************/
  11.  
  12. // TABLE.C
  13.  
  14. #include "cfiler.h"
  15. #include <malloc.h>
  16.  
  17. /******************************************************************\
  18. * CheckHeap()
  19. *
  20. * input: 
  21. *
  22. * message - buffer containing information to display on the
  23. * debug window
  24. *
  25. * purpose:
  26. *
  27. * Calls _heapchk and outputs a formatted message onto the
  28. * debug window.
  29. \******************************************************************/
  30.  
  31. VOID CheckHeap(LPTSTR message) {
  32.     INT rv = _heapchk();
  33.  
  34.     if (rv == _HEAPBADBEGIN) {
  35.         ErrorMsg(message);
  36.         ErrorMsg(TEXT("Initial header information is bad or cannot be found."));
  37.         return;
  38.     }
  39.     else if (rv == _HEAPBADNODE) {
  40.         ErrorMsg(message);
  41.         ErrorMsg(TEXT("Bad node has been found or heap is damaged."));
  42.         return;
  43.     }
  44.     else if (rv == _HEAPBADPTR) {
  45.         ErrorMsg(message);
  46.         ErrorMsg(TEXT("Pointer into heap is not valid."));
  47.         return;
  48.     }
  49.     else if (rv == _HEAPEMPTY) {
  50.         ErrorMsg(message);
  51.         ErrorMsg(TEXT("Heap has not been initialized."));
  52.         return;
  53.     }
  54.     else if (rv == _HEAPOK) {
  55.         ErrorMsg(message);
  56.         ErrorMsg(TEXT("Heap appears to be consistent."));
  57.         return;
  58.     }
  59.     else {
  60.         ErrorMsg(message);
  61.         ErrorMsg(TEXT("_heapcheck did not return a valid value."));
  62.     }
  63.     return;
  64. }
  65.  
  66. /******************************************************************\
  67. * GetSize()
  68. *
  69. * in parameters:
  70. * pTable - pointer to string table
  71. *
  72. * returns
  73. * number of elements of pTable
  74. * -1 if error
  75. \******************************************************************/
  76.  
  77. INT GetSize(TABLE pTable) {
  78.     if (!pTable) {
  79.         ErrorMsg(TEXT("GetSize: pTable is NULL."));
  80.         return -1;
  81.     }
  82.     
  83.     return pTable->iNumElems;
  84. }
  85.  
  86. /******************************************************************\
  87. * TableNew()
  88. *
  89. * Returns a new string table with no elements or NULL
  90. * if unsuccessful
  91. \******************************************************************/
  92.  
  93. TABLE TableNew(VOID) {
  94.     TABLE pTable;
  95.  
  96.     pTable = malloc(sizeof(*pTable) + 100);
  97.     
  98.     if (!pTable) {
  99.         ErrorMsg(TEXT("TableNew: malloc failed."));
  100.         return FALSE;
  101.     }
  102.     
  103.     pTable->iNumElems = 0;
  104.     pTable->pCurrentFiles = NULL;
  105.     
  106.     return pTable;
  107. }
  108.  
  109. /******************************************************************\
  110. * TableFree()
  111. *
  112. * input: pTable - pointer to a table
  113. *
  114. * purpose:
  115. * 
  116. * Frees the string table pointed to by pTable.
  117. *
  118. * return value:
  119. *
  120. * TRUE if successful
  121. * FALSE if unsuccessful
  122. \******************************************************************/
  123.  
  124. BOOL TableFree(TABLE pTable) {
  125.     ELEM *p, *q;
  126.  
  127.     if (!pTable) {
  128.         ErrorMsg(TEXT("TableFree: pTable is NULL."));
  129.         return FALSE;
  130.     }
  131.     
  132.     for (p = pTable->pCurrentFiles; p; p = q) {
  133.         q = p->next;
  134.         free(p->hidden);
  135.         free(p->displayed);
  136.         free(p);
  137.         p = NULL;
  138.     }
  139.  
  140.     free(pTable);
  141.  
  142.     pTable = NULL;
  143.  
  144.     return TRUE;
  145. }
  146.  
  147. /******************************************************************\
  148. * TableFind()
  149. *
  150. * input: pTable - pointer to a table
  151. * szFindString - string in question.
  152. *
  153. * purpose:
  154. * Searches for szFindString in table pTable.
  155. *
  156. * return value:
  157. *
  158. * TRUE if szFindString is in table
  159. * FALSE if otherwise
  160. \******************************************************************/
  161.  
  162. BOOL TableFind(TABLE pTable, LPTSTR szFindString) {
  163.     ELEM *p, *q;
  164.  
  165.     if (!pTable) {
  166.         ErrorMsg(TEXT("TableFree: pTable is NULL."));
  167.         return FALSE;
  168.     }
  169.     
  170.     for (p = pTable->pCurrentFiles; p; p = q) {
  171.         q = p->next;
  172.         if (!CFilerlstrcmp(p->displayed, szFindString)) {
  173.             return TRUE;
  174.         }
  175.     }
  176.  
  177.     return FALSE;
  178. }
  179.  
  180. /******************************************************************\
  181. * TableAdd()
  182. *
  183. * input:
  184. *
  185. * pTable - pointer to a string table
  186. *
  187. * szHidden, szDisplayed: pair of strings to insert into table
  188. *
  189. *
  190. * purpose:
  191. *
  192. * Inserts a string pair at the end of the string table pointed
  193. * to by pTable.
  194. \******************************************************************/
  195.  
  196. BOOL TableAdd(TABLE pTable, TCHAR *szHidden, LPTSTR szDisplayed) {
  197.     return TableInsert(pTable, szHidden, szDisplayed, pTable->iNumElems);
  198. }
  199.  
  200. /******************************************************************\
  201. * TableInsert()
  202. *
  203. * input:
  204. *
  205. * pTable - pointer to a string table
  206. * szHidden, szDisplayed : string pair to be inserted
  207. * i - position to insert the string pair.
  208. *
  209. * purpose:
  210. * inserts a string pair into the table pointed to by pTable
  211. * at position indicated by i.
  212. \******************************************************************/
  213.  
  214. BOOL TableInsert(TABLE pTable, LPTSTR szHidden, LPTSTR szDisplayed, INT i) {
  215.     ELEM *new, *p = NULL, *q = NULL;
  216.     INT j;
  217.  
  218.     if (!pTable) {
  219.         ErrorMsg(TEXT("TableInsert: pTable is NULL."));
  220.         return FALSE;
  221.     }
  222.     
  223.     new = malloc(sizeof(*new) + 2);
  224.  
  225.     new->hidden = malloc(3 + sizeof(*szHidden) * lstrlen(szHidden));
  226.     new->displayed = malloc(3 + sizeof(*szDisplayed) * lstrlen(szDisplayed));
  227.     new->next = NULL;
  228.  
  229.     lstrcpy(new->hidden, szHidden);
  230.     lstrcpy(new->displayed, szDisplayed);
  231.         
  232.     if (!pTable->pCurrentFiles) {
  233.         pTable->pCurrentFiles = new;
  234.         pTable->iNumElems++;
  235.         return TRUE;
  236.     }
  237.     
  238.     if (!i) {
  239.         ELEM *t;
  240.         t = pTable->pCurrentFiles;
  241.         pTable->pCurrentFiles = new;
  242.         new->next = t;
  243.         pTable->iNumElems++;
  244.         return TRUE;
  245.     }    
  246.  
  247.     for (j = 0, p = pTable->pCurrentFiles; j < i; j++, p = p->next)
  248.         q = p;
  249.         
  250.     q->next = new;
  251.     new->next = p;
  252.  
  253.     pTable->iNumElems++;
  254.     
  255.     return TRUE;
  256. }
  257.  
  258. /******************************************************************\
  259. * TableRemove()
  260. *
  261. * input: 
  262. * pTable - pointer to a string table
  263. * i - index of element to be removed
  264. *
  265. * purpose: 
  266. * Removes the element at position i in the string table 
  267. * pointed to by pTable.
  268. *
  269. * Return values:
  270. * TRUE if successful
  271. * FALSE if unsuccessful
  272. \******************************************************************/
  273.  
  274. BOOL TableRemove(TABLE pTable, INT i) {
  275.     INT j;
  276.     ELEM *p, *q;
  277.         
  278.     if (!pTable) {
  279.         ErrorMsg(TEXT("TableRemove: pTable is NULL."));
  280.         return FALSE;
  281.     }
  282.     
  283.     if (!pTable->pCurrentFiles) {
  284.         pTable->iNumElems = 0;
  285.         return TRUE;
  286.     }
  287.  
  288.     if (!i) {
  289.         ELEM *t = pTable->pCurrentFiles->next;
  290.         p = pTable->pCurrentFiles;
  291.         free(p->hidden);
  292.         free(p->displayed);
  293.         free(p);
  294.         pTable->pCurrentFiles = t;
  295.         pTable->iNumElems--;
  296.         return TRUE;
  297.     }
  298.  
  299.     for (j = 0, p = pTable->pCurrentFiles; j < i; j++, p = p->next) {
  300.         q = p;
  301.     }
  302.     
  303.     q->next = p->next;
  304.     free(p->hidden);
  305.     free(p->displayed);
  306.     free(p);
  307.  
  308.     pTable->iNumElems--;
  309.  
  310.     return TRUE;
  311. }
  312.  
  313. /******************************************************************\
  314. * TableSort()
  315. *
  316. * input:
  317. * pTable - pointer to a string table
  318. * compare - pointer to a compare function to be used in the
  319. * sort process
  320. *
  321. * Purpose: 
  322. * sorts the elements of the string table pointed to by pTable
  323. * on the displayed field.
  324. *
  325. * Return values:
  326. * TRUE if successful
  327. * FALSE if unsuccessful
  328. \******************************************************************/
  329.  
  330. BOOL TableSort(TABLE pTable, INT compare(LPCTSTR , LPCTSTR)) {
  331.     ELEM *p, *q, *min, *t;
  332.     INT i, j;
  333.  
  334.     if (!pTable) {
  335.         ErrorMsg(TEXT("TableSort: pTable is NULL."));
  336.         return FALSE;
  337.     }
  338.     
  339.     t = malloc(sizeof(*t));
  340.     
  341.     for (i = 0, p = pTable->pCurrentFiles; p && i < pTable->iNumElems - 1; i++, p = p->next) {
  342.         min = p;
  343.         for (q = p->next, j = 0; q && j < pTable->iNumElems; j++, q = q->next) {
  344.             if (!q->displayed || !p->displayed) {
  345.                 ErrorMsg(TEXT("TableSort: parameters to compare are null."));
  346.                 return FALSE;
  347.             }
  348.             if (compare(q->displayed, min->displayed) < 0) min = q;
  349.         }
  350.         t->displayed = min->displayed;
  351.         t->hidden = min->hidden; 
  352.         min->displayed = p->displayed; 
  353.         min->hidden = p->hidden;
  354.         p->displayed = t->displayed;
  355.         p->hidden = t->hidden;
  356.     }
  357.  
  358.     free(t);
  359.  
  360.     return TRUE;
  361. }
  362.  
  363. /******************************************************************\
  364. * TableSend()
  365. *
  366. * input:
  367. * pTable - pointer to a string table
  368. * mybox - handle to the listbox to which LB_ADDSTRING
  369. * messages are to be sent
  370. *
  371. * Purpose:
  372. * Sends the displayed members of the string table pointed to by
  373. * pTable to the listbox whose handle is mybox
  374. * by sending LB_ADDSTRING messages to the listbox for each
  375. * element of the table.
  376. *
  377. * Return values:
  378. * TRUE if successful
  379. * FALSE if unsuccessful
  380. \******************************************************************/
  381.  
  382. BOOL TableSend(TABLE pTable, HWND mybox) {
  383.     int j;
  384.     ELEM *p;
  385.     LRESULT result;
  386.  
  387.     if (!pTable) {
  388.         ErrorMsg(TEXT("TableSend: pTable is NULL."));
  389.         return FALSE;
  390.     }
  391.     
  392.     for (j = 0, p = pTable->pCurrentFiles; j < pTable->iNumElems; j++, p = p->next) {
  393.         result = SendMessage(mybox, LB_ADDSTRING, (WPARAM)0, (LPARAM)p->displayed);
  394.         
  395.         if (result == LB_ERR) {
  396.             ErrorMsg(TEXT("TableSend: LB_ADDSTRING failed."));
  397.             return FALSE;
  398.         }
  399.     }
  400.     
  401.     return TRUE;
  402. }
  403.  
  404. /******************************************************************\
  405. * TableGetHidden()
  406. *
  407. * input:
  408. * pTable - pointer to a string table
  409. * i - index of hidden element to retrieve
  410. * rv - (out parameter): buffer to store the hidden string
  411. *
  412. * Purpose:
  413. * Retrieves the hidden memeber of the table stored at position i
  414. * in the string table pointed to by pTable.
  415. *
  416. * Returns:
  417. * TRUE if successful
  418. * FALSE if unsuccessful
  419. \******************************************************************/
  420.  
  421. BOOL TableGetHidden(TABLE pTable, INT i, LPTSTR rv) {
  422.     INT j;
  423.     ELEM *p, *q;
  424.  
  425.     if (!pTable) {
  426.         ErrorMsg(TEXT("TableGetHidden: pTable is NULL."));
  427.         return FALSE;
  428.     }
  429.     
  430.     q = pTable->pCurrentFiles;
  431.     
  432.     if (q) {
  433.         for (p = pTable->pCurrentFiles, j = 0; j <= i; j++, p = p->next)
  434.             q = p;
  435.     }
  436.     else {
  437.         ErrorMsg(TEXT("TableGetHidden: pTable->pCurrentFiles is NULL."));
  438.         lstrcpy(rv, TEXT("error"));
  439.         return FALSE;
  440.     }
  441.  
  442.     if (q && q->hidden)
  443.         lstrcpy(rv, q->hidden);
  444.  
  445.     return TRUE;
  446. }
  447.  
  448. /******************************************************************\
  449. * SimplifyFileName()
  450. *
  451. * input:
  452. * szFileName - buffer of string to be "simplified"
  453. * rv - (out parameter) - buffer where simplified string
  454. * is to be stored
  455. *
  456. * purpose:
  457. * strips the characters [, ], >, |, and ; from szFileName and
  458. * stores the result in rv.
  459. *
  460. * returns:
  461. * TRUE if successful
  462. * FALSE if unsuccessful
  463. \******************************************************************/
  464.  
  465. BOOL SimplifyFileName(LPTSTR szFileName, LPTSTR rv) {
  466.     INT i, j;
  467.  
  468.     for (i = 0, j = 0; szFileName[i]; ) {
  469.         if (szFileName[i] == TEXT('[') || 
  470.             szFileName[i] == TEXT(']') || 
  471.             szFileName[i] == TEXT('|') || 
  472.             szFileName[i] == TEXT('>') ||
  473.             szFileName[i] == TEXT(';'))
  474.             i++;
  475.         else {
  476.             rv[j] = szFileName[i];
  477.             i++;
  478.             j++;
  479.         }
  480.     }
  481.  
  482.     rv[j] = TEXT('\0');
  483.     return TRUE;
  484. }
  485.  
  486. /******************************************************************\
  487. * ReplaceEscapeCharacters()
  488. *
  489. * input:
  490. * szFileName - input buffer
  491. * rv - (out parameter) - output buffer
  492. *
  493. * purpose:
  494. * replaces '&' characters in szFileName with '\&' and stores
  495. * the result in rv.
  496. *
  497. * returns:
  498. * TRUE if successful
  499. * FALSE if unsuccessful
  500. \******************************************************************/
  501.  
  502. BOOL ReplaceEscapeCharacters(LPTSTR szFileName, LPTSTR rv) {
  503.     INT i, j;
  504.  
  505.     for (i = 0, j = 0; szFileName[i]; ) {
  506.         if (szFileName[i] == TEXT('&')) {
  507.             rv[j] = TEXT('&');
  508.             rv[j + 1] = TEXT('&');
  509.             i++;
  510.             j += 2;
  511.         }
  512.         else {
  513.             rv[j] = szFileName[i];
  514.             i++;
  515.             j++;
  516.         }
  517.     }
  518.  
  519.     rv[j] = TEXT('\0');
  520.     return TRUE;
  521. }
  522.  
  523. /******************************************************************\
  524. * CFilerlstrcmp: Case-insensitive comparison of the strings s and t.
  525. * foo and |foo are the same.
  526. * [foo] and |[foo] are the same.
  527. * [foo] and foo are not the same.
  528. \******************************************************************/
  529.  
  530. INT CFilerlstrcmp(LPCTSTR s, LPCTSTR t)
  531. {
  532.     int i = 0, j = 0;
  533.  
  534.     if (s[0] == TEXT('|') || s[0] == TEXT('>') || s[0] == TEXT(';'))
  535.         i++;
  536.     
  537.     if (t[0] == TEXT('|') || t[0] == TEXT('>') || t[0] == TEXT(';'))
  538.         j++;
  539.         
  540.     for ( ; toupper(s[i]) == toupper(t[j]); i++, j++)
  541.         if (toupper(s[i]) == TEXT('\0'))
  542.             return 0;
  543.  
  544.     return toupper(s[i]) - toupper(t[j]);
  545. }
  546.