home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Programmer's Library 1.3 / Microsoft-Programers-Library-v1.3.iso / sampcode / os2sdk / os2sdk12 / ddeml / dmgdb.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-22  |  28.9 KB  |  1,163 lines
  1. /****************************** Module Header ******************************\
  2. * Module Name: DMGDB.C
  3. *
  4. * DDE manager data handling routines
  5. *
  6. * Created: 12/14/88 Sanford Staab
  7. *
  8. * Copyright (c) 1988, 1989  Microsoft Corporation
  9. \***************************************************************************/
  10. #include "ddemlp.h"
  11.  
  12. /***************************** Private Function ****************************\
  13. * PAPPINFO GetCurrentAppInfo()
  14. *
  15. * DESCRIPTION:
  16. * This routine uses the pid of the current thread to locate the information
  17. * pertaining to that thread.  If not found, 0 is returned.
  18. *
  19. * This call fails if the DLL is in a callback state to prevent recursion.
  20. * if fChkCallback is set.
  21. *
  22. * History:      1/1/89  Created         sanfords
  23. \***************************************************************************/
  24. PAPPINFO GetCurrentAppInfo(fChkCallback)
  25. BOOL fChkCallback;
  26. {
  27.     PAPPINFO pai;
  28.  
  29.     SemEnter();
  30.     if (pAppInfoList == NULL || !CheckSel(SELECTOROF(pAppInfoList))) {
  31.         SemLeave();
  32.         return(0);
  33.     }
  34.     pai = pAppInfoList;
  35.     while (pai) {
  36.         if (pai->pid == FSRSemDmg.pid && pai->tid == FSRSemDmg.tid) {
  37.             if (fChkCallback && pai->cInCallback > MAX_RECURSE) {
  38.                 pai->LastError = DMGERR_REENTRANCY;
  39.                 break;
  40.             } else {
  41.                 SemLeave();
  42.                 return(pai);
  43.             }
  44.         }
  45.         pai = pai->next;
  46.     }
  47.     SemLeave();
  48.     return(0);
  49. }
  50.  
  51.  
  52. /***************************** Private Function ****************************\
  53. * void UnlinkAppInfo(pai)
  54. * PAPPINFO pai;
  55. *
  56. * DESCRIPTION:
  57. *   unlinks an pai safely.  Does nothing if not linked.
  58. *
  59. * History:      1/1/89  Created         sanfords
  60. \***************************************************************************/
  61. void UnlinkAppInfo(pai)
  62. PAPPINFO pai;
  63. {
  64.     PAPPINFO paiT;
  65.  
  66.     AssertF(pai != NULL, "UnlinkAppInfo - NULL input");
  67.     SemEnter();
  68.     if (pai == pAppInfoList) {
  69.         pAppInfoList = pai->next;
  70.         SemLeave();
  71.         return;
  72.     }
  73.     paiT = pAppInfoList;
  74.     while (paiT && paiT->next != pai)
  75.         paiT = paiT->next;
  76.     if (paiT)
  77.         paiT->next = pai->next;
  78.     SemLeave();
  79.     return;
  80. }
  81.  
  82.  
  83.  
  84.  
  85.  
  86. /***************************** Private Functions ***************************\
  87. * General List management functions.
  88. *
  89. * History:
  90. *   Created     12/15/88    sanfords
  91. \***************************************************************************/
  92. PLST CreateLst(hheap, cbItem)
  93. HHEAP hheap;
  94. USHORT cbItem;
  95. {
  96.     PLST pLst;
  97.  
  98.     SemEnter();
  99.     if (!(pLst = (PLST)FarAllocMem(hheap, sizeof(LST)))) {
  100.         SemLeave();
  101.         return(NULL);
  102.     }
  103.     pLst->hheap = hheap;
  104.     pLst->cbItem = cbItem;
  105.     pLst->pItemFirst = (PLITEM)NULL;
  106.     SemLeave();
  107.     return(pLst);
  108. }
  109.  
  110.  
  111.  
  112. void FlushLst(pLst)
  113. PLST pLst;
  114. {
  115.     if (pLst == NULL)
  116.         return;
  117.     SemEnter();
  118.     while (pLst->pItemFirst) 
  119.         RemoveLstItem(pLst, pLst->pItemFirst);
  120.     SemLeave();
  121. }
  122.  
  123.  
  124.  
  125. void DestroyLst(pLst)
  126. PLST pLst;
  127. {
  128.     if (pLst == NULL)
  129.         return;
  130.     SemEnter();
  131.     while (pLst->pItemFirst) 
  132.         RemoveLstItem(pLst, pLst->pItemFirst);
  133.     FarFreeMem(pLst->hheap, pLst, sizeof(LST));
  134.     SemLeave();
  135. }
  136.  
  137.  
  138.  
  139. PLITEM FindLstItem(pLst, npfnCmp, piSearch)
  140. PLST pLst;
  141. NPFNCMP npfnCmp;
  142. PLITEM piSearch;
  143. {
  144.     PLITEM pi;
  145.  
  146.     if (pLst == NULL)
  147.         return(NULL);
  148.     SemEnter();
  149.     pi = pLst->pItemFirst;
  150.     while (pi) {
  151.         if ((*npfnCmp)
  152.                 ((PBYTE)pi + sizeof(LITEM), (PBYTE)piSearch + sizeof(LITEM))) {
  153.             SemLeave();
  154.             return(pi);
  155.         }
  156.         pi = pi->next;
  157.     }
  158.     SemLeave();
  159. }
  160.  
  161.  
  162.  
  163. /*
  164.  * Comparison functions for FindLstItem() and FindPileItem()
  165.  */
  166.  
  167. BOOL CmpULONG(pb1, pb2)
  168. PBYTE pb1;
  169. PBYTE pb2;
  170. {
  171.     return(*(PULONG)pb1 == *(PULONG)pb2);
  172. }
  173.  
  174. BOOL CmppHsz(pb1, pb2)
  175. PBYTE pb1;
  176. PBYTE pb2;
  177. {
  178.     return(CmpHsz(*(PHSZ)pb1, *(PHSZ)pb2) ? FALSE : TRUE);
  179. }
  180.  
  181.  
  182.  
  183.  
  184. /***************************** Private Function ****************************\
  185. * This routine creates a new list item for pLst and links it in according
  186. * to the ILST_ constant in afCmd.  Returns a pointer to the new item
  187. * or NULL on failure.
  188. *
  189. * Note:  This MUST be in the semaphore for use since the new list item
  190. * is filled with garbage on return yet is linked in.  
  191. * 
  192. *
  193. * History:
  194. *   Created     9/12/89    Sanfords
  195. \***************************************************************************/
  196. PLITEM NewLstItem(pLst, afCmd)
  197. PLST pLst;
  198. USHORT afCmd;
  199. {
  200.     PLITEM pi, piT;
  201.  
  202.     if (pLst == NULL)
  203.         return(NULL);
  204.     SemCheckIn();
  205.     
  206.     pi = (PLITEM)FarAllocMem(pLst->hheap, pLst->cbItem + sizeof(LITEM));
  207.     if (pi == NULL) {
  208.         AssertF(FALSE, "NewLstItem - memory failure");    
  209.         return(NULL);
  210.     }
  211.  
  212.     if (afCmd & ILST_NOLINK) 
  213.         return(pi);
  214.         
  215.     if (((piT = pLst->pItemFirst) == NULL) || (afCmd & ILST_FIRST)) {
  216.         pi->next = piT;
  217.         pLst->pItemFirst = pi;
  218.     } else {                            /* ILST_LAST assumed */
  219.         while (piT->next != NULL) 
  220.             piT = piT->next;
  221.         piT->next = pi;
  222.         pi->next = NULL;
  223.     }
  224.     return(pi);
  225. }
  226.  
  227.  
  228.  
  229. /***************************** Private Function ****************************\
  230. * This routine unlinks and frees pi from pLst.  If pi cannot be located
  231. * within pLst, it is freed anyway.
  232. *
  233. * History:
  234. *   Created     9/12/89    Sanfords
  235. \***************************************************************************/
  236. BOOL RemoveLstItem(pLst, pi)
  237. PLST pLst;
  238. PLITEM pi;
  239. {
  240.     PLITEM piT;
  241.  
  242.     if (pLst == NULL || pi == NULL)
  243.         return(FALSE);
  244.         
  245.     SemCheckIn();
  246.     
  247.     if ((piT = pLst->pItemFirst) != NULL) {
  248.         if (pi == piT) {
  249.             pLst->pItemFirst = pi->next;
  250.         } else {
  251.             while (piT->next != pi && piT->next != NULL)
  252.                 piT = piT->next;
  253.             if (piT->next != NULL)
  254.                 piT->next = pi->next; /* unlink */
  255.         }
  256.     } else {
  257.         AssertF(pi == NULL, "Improper list item removal");
  258.     }
  259.     FarFreeMem(pLst->hheap, pi, pLst->cbItem + sizeof(LITEM));
  260.     return(TRUE);
  261. }
  262.  
  263.  
  264.  
  265. /***************************** Private Function ****************************\
  266. * This routine uses ILST_ constants to insert a list item into the apropriate
  267. * spot of the pLst given.  Only ILST_FIRST or ILST_LAST are allowed.
  268. *
  269. * History:
  270. *   Created     9/11/89    Sanfords
  271. \***************************************************************************/
  272. BOOL InsertLstItem(pLst, pi, afCmd)
  273. PLST pLst;
  274. PLITEM pi;
  275. USHORT afCmd;
  276. {
  277.     PLITEM piT;
  278.  
  279.     if (pLst == NULL)
  280.         return(FALSE);
  281.         
  282.     SemEnter();
  283.     
  284.     if (pLst->pItemFirst == NULL || afCmd & ILST_FIRST) {
  285.         pi->next = pLst->pItemFirst;
  286.         pLst->pItemFirst = pi;
  287.     } else {                    /* ILST_LAST assumed */
  288.         piT = pLst->pItemFirst;
  289.         while (piT->next) 
  290.             piT = piT->next;
  291.         piT->next = pi;
  292.         pi->next = NULL;
  293.     }
  294.     
  295.     SemLeave();
  296.     return(TRUE);
  297. }
  298.  
  299.  
  300.  
  301.  
  302. /*
  303.  * ------------- Specific list routines -------------
  304.  */
  305.  
  306. /*
  307.  * This function is HIGHLY dependent on the ADVLI structure.
  308.  * This will match an exact hsz/fmt pair with a 0 format being wild.
  309.  */
  310. BOOL CmpAdv(pb1, pb2)
  311. PBYTE pb1;
  312. PBYTE pb2;
  313. {
  314.     USHORT usFmt;
  315.     
  316.     if (*(PHSZ)pb1 == *(PHSZ)pb2) {
  317.         if ((usFmt = *(PUSHORT)(pb2 + 4)) == 0)
  318.             return(TRUE);
  319.         if (usFmt == *(PUSHORT)(pb1 + 4))
  320.             return(TRUE);
  321.     }
  322.     return(FALSE);
  323. }
  324.  
  325.  
  326.  
  327. BOOL fSearchHwndList(pLst, hwnd)
  328. PLST pLst;
  329. HWND hwnd;
  330. {
  331.     HWNDLI hwndi;
  332.  
  333.     hwndi.hwnd = hwnd;
  334.     return((BOOL)FindLstItem(pLst, CmpHwnd, (PLITEM)&hwndi));
  335. }
  336.  
  337.  
  338.  
  339. void AddHwndList(hwnd, pLst)
  340. HWND hwnd;
  341. PLST pLst;
  342. {
  343.     HWNDLI hwndli;
  344.     PHWNDLI pli;
  345.  
  346.     AssertF(pLst != NULL, "AddHwndList - NULL pLst");
  347.     AssertF(pLst->cbItem == sizeof(HWNDLI), "AddHwndList - Bad item size");
  348.     SemEnter();
  349.     hwndli.hwnd = hwnd;
  350.     if ((hwnd == NULL) || FindLstItem(pLst, CmpHwnd, (PLITEM)&hwndli)) {
  351.         SemLeave();
  352.         return;
  353.     }
  354.     pli = (PHWNDLI)NewLstItem(pLst, ILST_FIRST);
  355.     pli->hwnd = hwnd;
  356.     SemLeave();
  357. }
  358.  
  359.  
  360.  
  361. /*
  362.  * Insert the given data into the list if one does not already exist
  363.  * under the given hwnd.
  364.  */
  365. void AddAckHwndList(hwnd, hszApp, hszTopic, pLst)
  366. HWND hwnd;
  367. HSZ hszApp;
  368. HSZ hszTopic;
  369. PLST pLst;
  370. {
  371.     HWNDLI hwndli;
  372.     PACKHWNDLI pli;
  373.  
  374.     AssertF(pLst != NULL, "AddAckHwndList - NULL pLst");
  375.     AssertF(pLst->cbItem == sizeof(ACKHWNDLI), "AddAckHwndList - Bad item size");
  376.     SemEnter();
  377.     hwndli.hwnd = hwnd;
  378.     if ((hwnd == NULL) || FindLstItem(pLst, CmpHwnd, (PLITEM)&hwndli)) {
  379.         SemLeave();
  380.         return;
  381.     }
  382.     pli = (PACKHWNDLI)NewLstItem(pLst, ILST_FIRST);
  383.     pli->hwnd = hwnd;
  384.     pli->hszApp = hszApp;
  385.     pli->hszTopic = hszTopic;
  386.     SemLeave();
  387. }
  388.  
  389.  
  390.  
  391.  
  392. /***************************** Private Function ****************************\
  393. * hwnd-hsz list functions
  394. *
  395. * History:      1/20/89     Created         sanfords
  396. \***************************************************************************/
  397. void AddHwndHszList(hsz, hwnd, pLst)
  398. HSZ hsz;
  399. HWND hwnd;
  400. PLST pLst;
  401. {
  402.     PHWNDHSZLI phhi;
  403.  
  404.     AssertF(pLst->cbItem == sizeof(HWNDHSZLI), "AddHwndHszList - Bad item size");
  405.     SemEnter();
  406.     if ((hsz == NULL) || (BOOL)HwndFromHsz(hsz, pLst)) {
  407.         SemLeave();
  408.         return;
  409.     }
  410.     phhi = (PHWNDHSZLI)NewLstItem(pLst, ILST_FIRST);
  411.     phhi->hwnd = hwnd;
  412.     phhi->hsz = hsz;
  413.     IncHszCount(hsz);
  414.     SemLeave();
  415. }
  416.  
  417.  
  418. void DestroyHwndHszList(pLst)
  419. PLST pLst;
  420. {
  421.     AssertF(pLst->cbItem == sizeof(HWNDHSZLI), "DestroyHwndHszList - Bad item size");
  422.     SemEnter();
  423.     while(pLst->pItemFirst) {
  424.         FreeHsz(((PHWNDHSZLI)pLst->pItemFirst)->hsz);
  425.         RemoveLstItem(pLst, pLst->pItemFirst);
  426.     }
  427.     FarFreeMem(pLst->hheap, pLst, sizeof(LST));
  428.     SemLeave();
  429. }
  430.  
  431.  
  432.  
  433. HWND HwndFromHsz(hsz, pLst)
  434. HSZ hsz;
  435. PLST pLst;
  436. {
  437.     HWNDHSZLI hhli;
  438.     PHWNDHSZLI phhli;
  439.  
  440.     hhli.hsz = hsz;
  441.     if (!(phhli = (PHWNDHSZLI)FindLstItem(pLst, CmppHsz, (PLITEM)&hhli)))
  442.         return(NULL);
  443.     return(phhli->hwnd);
  444. }
  445.  
  446.  
  447.  
  448. /***************************** Private Function ****************************\
  449. * DESCRIPTION:
  450. *   Advise list helper functions.
  451. *
  452. * History:      1/20/89     Created         sanfords
  453. \***************************************************************************/
  454. BOOL AddAdvList(pLst, hszItem, fsStatus, usFmt)
  455. PLST pLst;
  456. HSZ hszItem;
  457. USHORT fsStatus;
  458. USHORT usFmt;
  459. {
  460.     PADVLI pali;
  461.  
  462.     AssertF(pLst->cbItem == sizeof(ADVLI), "AddAdvList - bad item size");
  463.     if (hszItem == NULL) 
  464.         return(TRUE);
  465.     SemEnter();
  466.     if (!(pali = FindAdvList(pLst, hszItem, usFmt))) {
  467.         IncHszCount(hszItem);
  468.         pali = (PADVLI)NewLstItem(pLst, ILST_FIRST);
  469.     }
  470.     AssertF((BOOL)pali, "AddAdvList - NewLstItem() failed")
  471.     if (pali != NULL) {
  472.         pali->hszItem = hszItem;
  473.         pali->usFmt = usFmt;
  474.         pali->fsStatus = fsStatus;
  475.     }
  476.     SemLeave();
  477.     return((BOOL)pali);    
  478. }
  479.  
  480.  
  481.  
  482. /*
  483.  * This will delete the matching Advise loop entry.  If usFmt is 0, all
  484.  * entries with the same hszItem are deleted.  Returns fNotEmptyAfterDelete.
  485.  */
  486. BOOL DeleteAdvList(pLst, hszItem, usFmt)
  487. PLST pLst;
  488. HSZ hszItem;
  489. USHORT usFmt;
  490. {
  491.     PADVLI pali;
  492.  
  493.     if (hszItem == NULL) 
  494.         return((BOOL)pLst->pItemFirst);
  495.     SemEnter();
  496.     while (pali = (PADVLI)FindAdvList(pLst, hszItem, usFmt)) {
  497.         FreeHsz((pali)->hszItem);
  498.         RemoveLstItem(pLst, (PLITEM)pali);
  499.     }
  500.     SemLeave();
  501.     return((BOOL)pLst->pItemFirst);
  502. }
  503.  
  504.  
  505.  
  506. /***************************** Private Function ****************************\
  507. * This routine searches the advise list for and entry in hszItem.  It returns
  508. * pAdvli only if the item is found.
  509. *
  510. * History:
  511. *   Created     9/12/89    Sanfords
  512. \***************************************************************************/
  513. PADVLI FindAdvList(pLst, hszItem, usFmt)
  514. PLST pLst;
  515. HSZ hszItem;
  516. USHORT usFmt;
  517. {
  518.     ADVLI advli;
  519.  
  520.     advli.hszItem = hszItem;
  521.     advli.usFmt = usFmt;
  522.     return((PADVLI)FindLstItem(pLst, CmpAdv, (PLITEM)&advli));
  523. }
  524.  
  525.  
  526. /***************************** Private Function ****************************\
  527. * This routine searches for the next entry for hszItem.  It returns
  528. * pAdvli only if the item is found.
  529. *
  530. * History:
  531. *   Created     11/15/89    Sanfords
  532. \***************************************************************************/
  533. PADVLI FindNextAdv(padvli, hszItem)
  534. PADVLI padvli;
  535. HSZ hszItem;
  536. {
  537.     
  538.     SemEnter();
  539.     while ((padvli = (PADVLI)padvli->next) != NULL) {
  540.         if (padvli->hszItem == hszItem) {
  541.             SemLeave();
  542.             return(padvli);
  543.         }
  544.     }
  545.     SemLeave();
  546.     return(NULL);
  547. }
  548.  
  549.  
  550.  
  551. /***************************** Pile Functions ********************************\
  552. *
  553. *  A pile is a list where each item is an array of subitems.  This allows
  554. *  a more memory efficient method of handling unordered lists.
  555. *
  556. \*****************************************************************************/
  557.  
  558. PPILE CreatePile(hheap, cbItem, cItemsPerBlock)
  559. HHEAP hheap;
  560. USHORT cbItem;
  561. USHORT cItemsPerBlock;
  562. {
  563.     PPILE ppile;
  564.  
  565.     if (!(ppile = (PPILE)FarAllocMem(hheap, sizeof(PILE)))) {
  566.         SemLeave();
  567.         return(NULL);
  568.     }
  569.     ppile->pBlockFirst = (PLITEM)NULL;
  570.     ppile->hheap = hheap;
  571.     ppile->cbBlock = cbItem * cItemsPerBlock + sizeof(PILEB);
  572.     ppile->cSubItemsMax = cItemsPerBlock;
  573.     ppile->cbSubItem = cbItem;
  574.     return(ppile);
  575. }
  576.  
  577.  
  578. PPILE DestroyPile(pPile)
  579. PPILE pPile;
  580. {
  581.     if (pPile == NULL)
  582.         return(NULL);
  583.     SemEnter();
  584.     while (pPile->pBlockFirst) 
  585.         RemoveLstItem((PLST)pPile, (PLITEM)pPile->pBlockFirst);
  586.     FarFreeMem(pPile->hheap, pPile, sizeof(PILE));
  587.     SemLeave();
  588.     return(NULL);
  589. }
  590.  
  591. void FlushPile(pPile)
  592. PPILE pPile;
  593. {
  594.     if (pPile == NULL)
  595.         return;
  596.     SemEnter();
  597.     while (pPile->pBlockFirst) 
  598.         RemoveLstItem((PLST)pPile, (PLITEM)pPile->pBlockFirst);
  599.     SemLeave();
  600. }
  601.  
  602.  
  603. USHORT QPileItemCount(pPile)
  604. PPILE pPile;
  605. {
  606.     register USHORT c;
  607.     PPILEB pBlock;
  608.  
  609.     if (pPile == NULL)
  610.         return(0);
  611.  
  612.     SemEnter();
  613.     pBlock = pPile->pBlockFirst;
  614.     c = 0;
  615.     while (pBlock) {
  616.         c += pBlock->cItems;
  617.         pBlock = pBlock->next;
  618.     }
  619.     SemLeave();
  620.     return(c);
  621. }
  622.  
  623.  
  624. BOOL CopyPileItems(pPile, pDst)
  625. PPILE pPile;
  626. PBYTE pDst;
  627. {
  628.     PPILEB pBlock;
  629.     
  630.     AssertF(pDst != NULL, "CopyPileItems - NULL destination");
  631.     if (pPile == NULL)
  632.         return(FALSE);
  633.  
  634.     SemEnter();
  635.     pBlock = pPile->pBlockFirst;
  636.     while (pBlock) {
  637.         CopyBlock((PBYTE)pBlock + sizeof(PILEB), pDst,
  638.                 pBlock->cItems * pPile->cbSubItem);
  639.         pDst += pBlock->cItems * pPile->cbSubItem;
  640.         pBlock = pBlock->next;
  641.     }
  642.     SemLeave();
  643.  
  644.     return(TRUE);
  645. }
  646.  
  647.  
  648.  
  649.  
  650. /***************************** Private Function ****************************\
  651. * Locate and return the pointer to the pile subitem who's key fields match
  652. * pbSearch using npfnCmp to compare the fields.  If pbSearch == NULL, or
  653. * npfnCmp == NULL, the first subitem is returned.
  654. *
  655. * afCmd may be:
  656. * FPI_DELETE - delete the located item
  657. * FPI_COUNT - count number of items that match
  658. * In this case, the returned pointer is not valid.
  659. *
  660. * pppb points to where to store a pointer to the block which contained
  661. * the located item.
  662. *
  663. * if pppb == NULL, it is ignored.
  664. *
  665. * NULL is returned if pbSearch was not found or if the list was empty.
  666. *
  667. * History:
  668. *   Created     9/12/89    Sanfords
  669. \***************************************************************************/
  670. PBYTE FindPileItem(pPile, npfnCmp, pbSearch, afCmd)
  671. PPILE pPile;
  672. NPFNCMP npfnCmp;
  673. PBYTE pbSearch;
  674. USHORT afCmd;
  675. {
  676.     PBYTE pb;
  677.     PPILEB ppbT;
  678.     register int i;
  679.     register int c;
  680.  
  681.     if (pPile == NULL)
  682.         return(NULL);
  683.     c = 0;
  684.     SemEnter();
  685.     ppbT = pPile->pBlockFirst;
  686.     while (ppbT) {
  687.         /*
  688.          * for each block...
  689.          */
  690.         for (pb = (PBYTE)ppbT + sizeof(PILEB), i = 0;
  691.                 i < ppbT->cItems; pb += pPile->cbSubItem, i++) {
  692.             /*
  693.              * and each item within that block..
  694.              */
  695.             if (pbSearch == NULL || npfnCmp == NULL ||
  696.                     (*npfnCmp)(pb, pbSearch)) {
  697.                 /*
  698.                  * If it matches or we don't care...
  699.                  */
  700.                 if (afCmd & FPI_DELETE) {
  701.                     /*
  702.                      * remove entire block if this was the last subitem in it.
  703.                      */
  704.                     if (--ppbT->cItems == 0) {
  705.                         RemoveLstItem((PLST)pPile, (PLITEM)ppbT);
  706.                     } else {
  707.                         /*
  708.                          * copy last subitem in the block over the removed item.
  709.                          */
  710.                         CopyBlock((PBYTE)ppbT + sizeof(PILEB) +
  711.                                 pPile->cbSubItem * ppbT->cItems,
  712.                                 pb, pPile->cbSubItem);
  713.                     }
  714.                 }
  715.                 if (afCmd & FPI_COUNT) {
  716.                     c++;
  717.                 } else {
  718.                     SemLeave();
  719.                     return(pb);
  720.                 }
  721.                 if (afCmd & FPI_DELETE) {
  722.                     pb = (PBYTE)ppbT + sizeof(PILEB);
  723.                     i = 0;
  724.                 }
  725.             }
  726.         }
  727.         ppbT = (PPILEB)ppbT->next;
  728.     }
  729.     SemLeave();
  730.     return((PBYTE)(ULONG)c);
  731. }
  732.  
  733.  
  734. /***************************** Private Function ****************************\
  735. * Places a copy of the subitem pointed to by pb into the first available
  736. * spot in the pile pPile.  If npfnCmp != NULL, the pile is first searched
  737. * for a pb match.  If found, pb replaces the located data but FALSE is
  738. * returned to show that no real addition took place.
  739. *
  740. * History:
  741. *   Created     9/12/89    Sanfords
  742. \***************************************************************************/
  743. BOOL AddPileItem(pPile, pb, npfnCmp)
  744. PPILE pPile;
  745. PBYTE pb;
  746. BOOL (*npfnCmp)(PBYTE pb, PBYTE pbSearch);
  747. {
  748.     PBYTE pbDst;
  749.     PPILEB ppb;
  750.  
  751.     if (pPile == NULL)
  752.         return(FALSE);
  753.     SemEnter();
  754.     if (npfnCmp != NULL &&
  755.             (pbDst = FindPileItem(pPile, npfnCmp, pb, 0)) != NULL) {
  756.         CopyBlock(pb, pbDst, pPile->cbSubItem);
  757.         SemLeave();
  758.         return(FALSE);
  759.     }
  760.     ppb = pPile->pBlockFirst;
  761.     /*
  762.      * locate a block with room
  763.      */
  764.     while ((ppb != NULL) && ppb->cItems == pPile->cSubItemsMax) {
  765.         ppb = (PPILEB)ppb->next;
  766.     }
  767.     /*
  768.      * If all full or no blocks, make a new one, link it on the bottom.
  769.      */
  770.     if (ppb == NULL) {
  771.         if ((ppb = (PPILEB)NewLstItem((PLST)pPile, ILST_LAST)) == NULL) {
  772.             SemLeave();
  773.             return(FALSE);
  774.         }
  775.         ppb->cItems = 0;
  776.     }
  777.     /*
  778.      * add the subitem
  779.      */
  780.     CopyBlock(pb, (PBYTE)ppb + sizeof(PILEB) + pPile->cbSubItem * ppb->cItems++,
  781.         pPile->cbSubItem);
  782.      
  783.     SemLeave();
  784.     return(TRUE);
  785. }
  786.  
  787.  
  788.  
  789.  
  790. /***************************** Private Function ****************************\
  791. * Fills pb with a copy of the top item's data and removes it from the pile.
  792. * returns FALSE if the pile was empty.
  793. *
  794. * History:
  795. *   Created     9/12/89    Sanfords
  796. \***************************************************************************/
  797. BOOL PopPileSubitem(pPile, pb)
  798. PPILE pPile;
  799. PBYTE pb;
  800. {
  801.     PPILEB ppb;
  802.     PBYTE pSrc;
  803.  
  804.     
  805.     if ((pPile == NULL) || ((ppb = pPile->pBlockFirst) == NULL))
  806.         return(FALSE);
  807.         
  808.     SemEnter();
  809.     pSrc = (PBYTE)pPile->pBlockFirst + sizeof(PILEB);
  810.     CopyBlock(pSrc, pb, pPile->cbSubItem);
  811.     /*
  812.      * remove entire block if this was the last subitem in it.
  813.      */
  814.     if (pPile->pBlockFirst->cItems == 1) {
  815.         RemoveLstItem((PLST)pPile, (PLITEM)pPile->pBlockFirst);
  816.     } else {
  817.         /*
  818.          * move last item in block to replace copied subitem and decrement
  819.          * subitem count.
  820.          */
  821.         CopyBlock(pSrc + pPile->cbSubItem * --pPile->pBlockFirst->cItems,
  822.                 pSrc, pPile->cbSubItem);
  823.     }
  824.     SemLeave();
  825.     return(TRUE);
  826. }
  827.     
  828.  
  829. /***************************** Semaphore Functions *************************\
  830. * SemEnter() and SemLeave() are macros.
  831. *
  832. * History:      1/1/89  Created         sanfords
  833. \***************************************************************************/
  834. void SemInit()
  835. {
  836.     PBYTE pSem;
  837.     SHORT c;
  838.  
  839.     pSem = (PBYTE)&FSRSemDmg;
  840.     c = 0;
  841.     while (c++ < sizeof(DOSFSRSEM)) {
  842.         *pSem++ = 0;
  843.     }
  844.     FSRSemDmg.cb = sizeof(DOSFSRSEM);
  845. }
  846.  
  847. #ifdef DEBUG
  848. void SemCheckIn()
  849. {                                                                
  850.     PIDINFO pi;
  851.     BOOL fin;
  852.  
  853.     DosGetPID(&pi);
  854.     fin = (FSRSemDmg.cUsage > 0) &&
  855.             (FSRSemDmg.pid == pi.pid) &&
  856.             ((FSRSemDmg.tid == pi.tid) || (FSRSemDmg.tid == -1));
  857.     /*
  858.      * !!! NOTE: during exitlists processing, semaphore TIDs are set to -1
  859.      */
  860.     AssertF(fin, "SemCheckIn - Out of Semaphore");
  861.     if (!fin)
  862.         SemEnter();
  863. }
  864.  
  865. void SemCheckOut()
  866. {
  867.     PIDINFO pi;
  868.     BOOL fOut;
  869.  
  870.     DosGetPID(&pi);
  871.     fOut = FSRSemDmg.cUsage == 0 || FSRSemDmg.pid != pi.pid ||
  872.                 FSRSemDmg.tid != pi.tid;
  873.     AssertF(fOut, "SemCheckOut - In Semaphore");
  874.     if (!fOut)
  875.         while (FSRSemDmg.cUsage)
  876.             SemLeave();
  877.         
  878. }
  879. #endif
  880.  
  881.  
  882. void SemEnter()
  883. {
  884.     DosFSRamSemRequest(&FSRSemDmg, SEM_INDEFINITE_WAIT);
  885. }
  886.  
  887.  
  888. void SemLeave()
  889. {
  890.     DosFSRamSemClear(&FSRSemDmg);
  891. }
  892.  
  893.  
  894.  
  895. void EXPENTRY ExlstAbort(usTermCode)
  896. USHORT usTermCode;
  897. {
  898.     PAPPINFO pai;
  899.     usTermCode;
  900.     
  901.     SemEnter();     /* get any other processes out of the semaphore */
  902.     if (pai = GetCurrentAppInfo(FALSE)) {
  903.         pai->cInCallback = 0;  /* so Unregister call will work */
  904.         DdeUninitialize();
  905.     } else {
  906.         SemLeave();
  907.         DosExitList(EXLST_REMOVE, (PFNEXITLIST)ExlstAbort);
  908.     }
  909.     DosExitList(EXLST_EXIT, 0);
  910. }
  911.  
  912. BOOL CopyHugeBlock(pSrc, pDst, cb)
  913. PBYTE pSrc;
  914. PBYTE pDst;
  915. ULONG cb;
  916. {
  917.     ULONG cFirst;
  918.     /*
  919.      *  |____________|   |___________|   |____________|  |____________|
  920.      *     ^src                                 ^
  921.      *
  922.      *  |____________|   |___________|   |____________|  |____________|
  923.      *             ^dst                                   ^
  924.      */
  925.     cFirst = (ULONG)min((~(USHORT)pSrc), (~(USHORT)pDst)) + 1L;
  926.     if (cb < cFirst) {
  927.         CopyBlock(pSrc, pDst, (USHORT)cb);
  928.         return(TRUE);
  929.     }
  930.  
  931.     goto copyit;
  932.         
  933.     /*
  934.      * Now at least one of the pointers is on a segment boundry.
  935.      */
  936.     while (cb) {
  937.         cFirst = min(0x10000 - ((USHORT)pSrc | (USHORT)pDst), cb);
  938. copyit:
  939.         if (HIUSHORT(cFirst)) {
  940.             /*
  941.              * special case where pSrc and pDst both are on segment
  942.              * bounds.  Copy half at a time.
  943.              */
  944.             /*
  945.              *  |___________|   |____________|  |____________|
  946.              *  ^src                               ^
  947.              *
  948.              *  |___________|   |____________|  |____________|
  949.              *  ^dst                               ^
  950.              */
  951.             cFirst >>= 1;
  952.             CopyBlock(pSrc, pDst, (USHORT)cFirst);
  953.             pSrc += cFirst;
  954.             pDst += cFirst;
  955.             cb -= cFirst;
  956.         }
  957.         CopyBlock(pSrc, pDst, (USHORT)cFirst);
  958.         pSrc = HugeOffset(pSrc, cFirst);
  959.         pDst = HugeOffset(pDst, cFirst);
  960.         cb -= cFirst;
  961.     /*
  962.      *  |____________|   |___________|   |____________|  |____________|
  963.      *           ^src                           ^
  964.      *
  965.      *  |____________|   |___________|   |____________|  |____________|
  966.      *                   ^dst                             ^
  967.      */
  968.     }
  969.     return(TRUE);
  970. }
  971.  
  972.  
  973.  
  974.  
  975. /***************************************************************************\
  976. * Kills windows but avoids invalid window rips in debugger.
  977. \***************************************************************************/
  978. BOOL DestroyWindow(hwnd)
  979. HWND hwnd;
  980. {
  981.     if (WinIsWindow(DMGHAB, hwnd))
  982.         return(WinDestroyWindow(hwnd));
  983.     return(TRUE);
  984. }
  985.  
  986.  
  987. /***************************** Private Function ****************************\
  988. * Returns hConv of the window passed in is one of the ddeml windows.
  989. *
  990. * History:
  991. *   Created     9/1/89    Sanfords
  992. \***************************************************************************/
  993. HCONV IsDdeWindow(hwnd)
  994. HWND hwnd;
  995. {
  996.     PAPPINFO pai;
  997.  
  998.     pai = pAppInfoList;
  999.     
  1000.     while (pai && WinIsChild(hwnd, pai->hwndDmg)) 
  1001.         pai = pai->next;
  1002.         
  1003.     if (pai)
  1004.         return((HCONV)hwnd);
  1005.     else
  1006.         return(0L);
  1007. }
  1008.  
  1009.  
  1010. /***************************** Private Function ****************************\
  1011. * This routine only frees a MYDDES segment if this process is not the owner.
  1012. *
  1013. * History:
  1014. *   Created     9/12/89    Sanfords
  1015. \***************************************************************************/
  1016. void FreeData(
  1017. PMYDDES pmyddes,
  1018. PAPPINFO pai)
  1019. {
  1020.     TID tid;
  1021.     if (!CheckSel(SELECTOROF(pmyddes)) ||
  1022.             (   pmyddes->offszItemName == sizeof(MYDDES) &&
  1023.                 pmyddes->magic == MYDDESMAGIC &&
  1024.                 pmyddes->fs & HDATA_APPOWNED &&
  1025.                 pmyddes->pai == pai) )
  1026.         return;
  1027.  
  1028.     SemEnter();
  1029.     FindPileItem(pai->pHDataPile, CmpULONG, (PBYTE)&pmyddes, FPI_DELETE);
  1030.     tid = pai->tid;
  1031.     do {
  1032.         if (FindPileItem(pai->pHDataPile, CmpULONG, (PBYTE)&pmyddes, FPI_COUNT)) {
  1033.             SemLeave();
  1034.             return;
  1035.         }
  1036.         pai = pai->nextThread;
  1037.     } while (pai && pai->tid != tid);
  1038.     SemLeave();
  1039.     DosFreeSeg(SELECTOROF(pmyddes));
  1040. }
  1041.  
  1042.  
  1043.  
  1044. #ifdef DEBUG
  1045. int APIENTRY DebugOutput(PCH);
  1046. void fAssert(f, pszComment, line, szfile)
  1047. BOOL f;
  1048. PSZ pszComment;
  1049. USHORT line;
  1050. PSZ szfile;
  1051. {
  1052.     char szT[90];
  1053.     PSZ psz, pszLast;
  1054.  
  1055.     if (!f) {
  1056.         szT[0] = '\000';
  1057.         psz = szT;
  1058.         pszLast = &szT[89];
  1059.         psz = lstrcat(psz, "\n\rAssertion failure: ", pszLast);
  1060.         psz = lstrcat(psz, szfile, pszLast);
  1061.         psz = lstrcat(psz, ":", pszLast);
  1062.         psz = dtoa(psz, line, FALSE);
  1063.         psz = lstrcat(psz, " ", pszLast);
  1064.         psz = lstrcat(psz, pszComment, pszLast);
  1065.         psz = lstrcat(psz, "\n\r", pszLast);
  1066.         DebugOutput(szT);
  1067.         DebugBreak(); 
  1068.     }
  1069. }
  1070. #endif
  1071.  
  1072.  
  1073.  
  1074. HDMGDATA PutData(pSrc, cb, cbOff, hszItem, usFmt, afCmd, pai)
  1075. PBYTE pSrc;
  1076. ULONG cb;
  1077. ULONG cbOff;
  1078. HSZ hszItem;
  1079. USHORT usFmt;
  1080. USHORT afCmd;
  1081. PAPPINFO pai;
  1082. {
  1083.     PMYDDES pmyddes;
  1084.     
  1085.     if ((pmyddes = (PMYDDES)AllocDDESel(0, usFmt, hszItem, cb + cbOff, pai))
  1086.             == NULL) {
  1087.         pai->LastError = DMGERR_MEMORY_ERROR;
  1088.         return(0L);
  1089.     }
  1090.     pmyddes->fs = afCmd;
  1091.     
  1092.     if (afCmd & HDATA_APPFREEABLE) {
  1093.         if (!AddPileItem(pai->pHDataPile, (PBYTE)&pmyddes, CmpULONG)) {
  1094.             DosFreeSeg(SELECTOROF(pmyddes));
  1095.             pai->LastError = DMGERR_MEMORY_ERROR;
  1096.             return(0L);
  1097.         } 
  1098.     }
  1099.     if (pSrc)
  1100.         CopyHugeBlock(pSrc, HugeOffset(DDES_PABDATA(pmyddes), cbOff), cb);
  1101.     return(pmyddes);
  1102. }
  1103.  
  1104.  
  1105. /*
  1106.  * This routine adds all HSZ/HAPP pairs it finds for the given pai matching
  1107.  * hszApp to hDataAdd.
  1108.  * poffAdd is the offset into the hDataAdd to start inserting HSZ/HAPP
  1109.  * pairs.  It then truncates the list with a 0 HSZ and returns the offset
  1110.  * to the terminator (ready to be called again to add more).
  1111.  *
  1112.  * returns 0L on error.
  1113.  */
  1114. ULONG
  1115. QueryAppNames(
  1116. PAPPINFO pai,
  1117. HDMGDATA hDataAdd,
  1118. HSZ hszApp,
  1119. ULONG offAdd)
  1120. {
  1121.     USHORT chsz;
  1122.     PHSZ phsz, phszPile;
  1123.     PPILEB pBlock;
  1124.  
  1125.     AssertF(sizeof(HSZ) == sizeof(HAPP), "Type size conflict");
  1126.         
  1127.     SemEnter();
  1128.     if (chsz = (USHORT)FindPileItem(pai->pAppNamePile,
  1129.             hszApp ? CmpULONG : NULL, (PBYTE)&hszApp, FPI_COUNT)) {
  1130.         /*
  1131.          * allocate for additions.
  1132.          */
  1133.         if (!DdeAddData(hDataAdd, NULL,
  1134.                 (chsz + 1L) * (sizeof(HSZ) + sizeof(HDMGDATA)), offAdd)) {
  1135.             offAdd = 0L;
  1136.             GetCurrentAppInfo(FALSE)->LastError = DMGERR_MEMORY_ERROR;
  1137.             goto Exit;
  1138.         }
  1139.         
  1140.         phsz = DDES_PABDATA((PDDESTRUCT)hDataAdd) + offAdd;
  1141.         if (hszApp) {
  1142.             *phsz++ = hszApp;       /* only one per thread expected */
  1143.             *phsz++ = (HSZ)pai->hwndFrame;
  1144.         } else {
  1145.             pBlock = pai->pAppNamePile->pBlockFirst;
  1146.             while (pBlock) {
  1147.                 phszPile = (PHSZ)(pBlock + 1);
  1148.                 for (chsz = 0; chsz < pBlock->cItems; chsz++) {
  1149.                     *(phsz++) = *(phszPile++);
  1150.                     *(phsz++) = (HSZ)pai->hwndFrame;
  1151.                 }
  1152.                 pBlock = pBlock->next;
  1153.             }
  1154.         }
  1155.         *phsz = 0L;
  1156.         offAdd = phsz - DDES_PABDATA((PDDESTRUCT)hDataAdd);
  1157.     }
  1158. Exit:    
  1159.     SemLeave();
  1160.     return(offAdd);
  1161. }
  1162.  
  1163.