开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 能源行业(电力石油煤炭) > 查看源码
dpl_list.h
资源名称：Profibus.rar　[点击查看]
上传用户：hualang
上传日期：2022-04-11
资源大小：104k
文件大小：20k
源码类别：

能源行业(电力石油煤炭)

开发平台：

C/C++

dpl_list.h：源码内容
  1. /************************** Filename: dp_list.h ******************************/
  2. /* ========================================================================= */
  3. /*                                                                           */
  4. /* 0000  000   000  00000 0  000  0   0 0 0000                               */
  5. /* 0   0 0  0 0   0 0     0 0   0 0   0 0 0   0                              */
  6. /* 0   0 0  0 0   0 0     0 0     0   0 0 0   0      Einsteinstra遝 6        */
  7. /* 0000  000  0   0 000   0 0     00000 0 0000       91074 Herzogenaurach    */
  8. /* 0     00   0   0 0     0 0     0   0 0 0                                  */
  9. /* 0     0 0  0   0 0     0 0   0 0   0 0 0          Tel: ++49-9132-744-200  */
  10. /* 0     0  0  000  0     0  000  0   0 0 0    GmbH  Fax: ++49-9132-744-204  */
  11. /*                                                                           */
  12. /* ========================================================================= */
  13. /*                                                                           */
  14. /* Description: macros for double pointered list                             */
  15. /*                                                                           */
  16. /* ------------------------------------------------------------------------- */
  17. /*                                                                           */
  18. /* Technical support:       P. Fredehorst                                    */
  19. /*                          Tel. : ++49-9132/744-214                         */
  20. /*                          Fax. :              -204                         */
  21. /*                          eMail: pfredehorst@profichip.com                 */
  22. /*                                                                           */
  23. /*****************************************************************************/
  26. /*****************************************************************************/
  27. /* contents:
  29.     dpl_init_list__                  (list_ptr)
  31.     dpl_list_empty__                 (list_ptr)
  32.     dpl_list_not_empty__             (list_ptr)
  34.     dpl_put_blk_to_list_start__      (list_ptr, blk_ptr)
  35.     dpl_put_blk_to_list_end__        (list_ptr, blk_ptr)
  36.     dpl_put_blk_queue_to_list_end__  (list_ptr, blk_start_ptr, blk_end_ptr)
  38.     dpl_get_blk_from_list__          (list_ptr, adr_blk_ptr)
  39.     dpl_remove_blk_from_list__       (list_ptr)
  40.     dpl_get_remove_blk_from_list__   (list_ptr, adr_blk_ptr)
  41.     dpl_remove_blk__                 (blk_ptr)
  43. */
  44. /*****************************************************************************/
  45. /* reinclude protection */
  48. #ifndef DPLLIST_H
  49. #define DPLLIST_H
  52. /*****************************************************************************/
  53. /*  CHECK PARAMETER                                                          */
  54. /*****************************************************************************/
  55. #define DPL_PTR_ATTR PTR_ATTR
  56. #define DPL_HOST_PTR_COMPARE_TYPE   void *
  58. #ifdef  DPL_PTR_ATTR
  61. /*****************************************************************************/
  62. /*  ANCHOR                                                                   */
  63. /*****************************************************************************/
  65. typedef struct dpl_list_cb
  66. {
  67.     struct dpl_list_cb DPL_PTR_ATTR *next_blk_ptr;
  68.     struct dpl_list_cb DPL_PTR_ATTR *prev_blk_ptr;
  70. }   DPL_STRUC_LIST_CB;
  72. #define DPL_STRUC_LIST_CB_PTR            DPL_STRUC_LIST_CB DPL_PTR_ATTR *
  74. /*****************************************************************************/
  75. /*  CASTS                                                                    */
  76. /*****************************************************************************/
  79. #define DPL_LIST_CB_PTR                                                       
  80.         DPL_STRUC_LIST_CB DPL_PTR_ATTR *
  82. #define DPL_LIST_CB_PTR_PTR                                                   
  83.         DPL_STRUC_LIST_CB DPL_PTR_ATTR * DPL_PTR_ATTR *
  86. /*****************************************************************************/
  87. /*  LIST HANDLING                                                            */
  88. /*****************************************************************************/
  91. /*****************************************************************************/
  92. /*                                                                           */
  93. /*                           double pointered list                           */
  94. /*                                                                           */
  95. /*         +-------------------------------------------------------+         */
  96. /*         |                                                       |         */
  97. /*         |   list-anchor                                         |         */
  98. /*         |    +------+     +------+     +------+     +------+    |         */
  99. /*         +--> | next | --> | next | --> | next | ... | next | ---+         */
  100. /*         +--- | prev | <-- | prev | <-- | prev | ... | prev | <--+         */
  101. /*         |    +------+     | ...  |     | ...  |     | ...  |    |         */
  102. /*         |                 +------+     +------+     +------+    |         */
  103. /*         |                                                       |         */
  104. /*         +-------------------------------------------------------+         */
  105. /*                                                                           */
  106. /*****************************************************************************/
  109. /*****************************************************************************/
  110. /*  D e s c r i p t i o n :                                                  */
  111. /*                                                                           */
  112. /*  initialize desired double pointered list.                                */
  113. /*                                                                           */
  114. /*****************************************************************************/
  117. #define dpl_init_list__(list_ptr)                                             
  118. {                                                                             
  119.   /* list.next = list.prev = list */                                          
  120.   ((DPL_LIST_CB_PTR) (list_ptr)) -> next_blk_ptr                              
  121.   = ((DPL_LIST_CB_PTR) (list_ptr)) -> prev_blk_ptr                            
  122.   = (DPL_LIST_CB_PTR) (list_ptr);                                             
  123. }                                                                             
  126. /*****************************************************************************/
  127. /*  D e s c r i p t i o n :                                                  */
  128. /*                                                                           */
  129. /*  check if desired double pointered list is empty.                         */
  130. /*                                                                           */
  131. /*****************************************************************************/
  134. #define dpl_list_empty__(list_ptr)                                            
  135. (                                                                             
  136.   /* list.next == list */                                                     
  137.   ((DPL_HOST_PTR_COMPARE_TYPE)                                                
  138.   (((DPL_LIST_CB_PTR) (list_ptr)) -> next_blk_ptr))                           
  139.   ==                                                                          
  140.   ((DPL_HOST_PTR_COMPARE_TYPE)                                                
  141.   (list_ptr))                                                                 
  142. )
  145. /*****************************************************************************/
  146. /*  D e s c r i p t i o n :                                                  */
  147. /*                                                                           */
  148. /*  check if desired double pointered list is not empty.                     */
  149. /*                                                                           */
  150. /*****************************************************************************/
  153. #define dpl_list_not_empty__(list_ptr)                                        
  154. (                                                                             
  155.   /* list.next != list */                                                     
  156.   ((DPL_HOST_PTR_COMPARE_TYPE)                                                
  157.   (((DPL_LIST_CB_PTR) (list_ptr)) -> next_blk_ptr))                           
  158.   !=                                                                          
  159.   ((DPL_HOST_PTR_COMPARE_TYPE)                                                
  160.   (list_ptr))                                                                 
  161. )
  164. /*****************************************************************************/
  165. /*  D e s c r i p t i o n :                                                  */
  166. /*                                                                           */
  167. /*  put block to start of double pointered list.                             */
  168. /*                                                                           */
  169. /*****************************************************************************/
  172. #define dpl_put_blk_to_list_start__(list_ptr, blk_ptr)                        
  173. {                                                                             
  174.   /* list.next -> prev = blk */                                               
  175.   ((DPL_LIST_CB_PTR) (list_ptr)) -> next_blk_ptr -> prev_blk_ptr              
  176.   = (DPL_LIST_CB_PTR) (blk_ptr);                                              
  177.                                                                               
  178.   /* blk.next = list.next */                                                  
  179.   ((DPL_LIST_CB_PTR) (blk_ptr)) -> next_blk_ptr                               
  180.   = ((DPL_LIST_CB_PTR) (list_ptr)) -> next_blk_ptr;                           
  181.                                                                               
  182.   /* list.next = blk */                                                       
  183.   ((DPL_LIST_CB_PTR) (list_ptr)) -> next_blk_ptr                              
  184.   = (DPL_LIST_CB_PTR) (blk_ptr);                                              
  185.                                                                               
  186.   /* blk.prev = list */                                                       
  187.   ((DPL_LIST_CB_PTR) (blk_ptr)) -> prev_blk_ptr                               
  188.   = (DPL_LIST_CB_PTR) (list_ptr);                                             
  189. }                                                                             
  192. /*****************************************************************************/
  193. /*  D e s c r i p t i o n :                                                  */
  194. /*                                                                           */
  195. /*  put block to end of double pointered list.                               */
  196. /*                                                                           */
  197. /*****************************************************************************/
  200. #define dpl_put_blk_to_list_end__(list_ptr, blk_ptr)                          
  201. {                                                                             
  202.   /* blk.next = list */                                                       
  203.   ((DPL_LIST_CB_PTR) (blk_ptr)) -> next_blk_ptr                               
  204.   = (DPL_LIST_CB_PTR) (list_ptr);                                             
  205.                                                                               
  206.   /* list.prev -> next = blk */                                               
  207.   ((DPL_LIST_CB_PTR) (list_ptr)) -> prev_blk_ptr -> next_blk_ptr              
  208.   = (DPL_LIST_CB_PTR) (blk_ptr);                                              
  209.                                                                               
  210.   /* blk.prev = list.prev */                                                  
  211.   ((DPL_LIST_CB_PTR) (blk_ptr)) -> prev_blk_ptr                               
  212.   = ((DPL_LIST_CB_PTR) (list_ptr)) -> prev_blk_ptr;                           
  213.                                                                               
  214.   /* list.prev = blk */                                                       
  215.   ((DPL_LIST_CB_PTR) (list_ptr)) -> prev_blk_ptr                              
  216.   = (DPL_LIST_CB_PTR) (blk_ptr);                                              
  217. }                                                                             
  220. /*****************************************************************************/
  221. /*  D e s c r i p t i o n :                                                  */
  222. /*                                                                           */
  223. /*  put queue of blocks to end of double pointered list.                     */
  224. /*                                                                           */
  225. /*****************************************************************************/
  228. #define dpl_put_blk_queue_to_list_end__(list_ptr, blk_start_ptr, blk_end_ptr)
  229. {                                                                             
  230.   /* list.prev -> next = first blk */                                         
  231.   ((DPL_LIST_CB_PTR) (list_ptr)) -> prev_blk_ptr -> next_blk_ptr              
  232.   = (DPL_LIST_CB_PTR) (blk_start_ptr);                                        
  233.                                                                               
  234.   /* first blk.prev = list.prev */                                            
  235.   ((DPL_LIST_CB_PTR) (blk_start_ptr)) -> prev_blk_ptr                         
  236.   = ((DPL_LIST_CB_PTR) (list_ptr)) -> prev_blk_ptr;                           
  237.                                                                               
  238.   /* list.prev = last blk */                                                  
  239.   ((DPL_LIST_CB_PTR) (list_ptr)) -> prev_blk_ptr                              
  240.   = (DPL_LIST_CB_PTR) (blk_end_ptr);                                          
  241.                                                                               
  242.   /* last blk.next = list */                                                  
  243.   ((DPL_LIST_CB_PTR) (blk_end_ptr)) -> next_blk_ptr                           
  244.   = (DPL_LIST_CB_PTR) (list_ptr);                                             
  245. }                                                                             
  248. /*****************************************************************************/
  249. /*  D e s c r i p t i o n :                                                  */
  250. /*                                                                           */
  251. /*  get block from start of desired double pointered list.                   */
  252. /*                                                                           */
  253. /*****************************************************************************/
  256. #define dpl_get_blk_from_list__(list_ptr, adr_blk_ptr)                        
  257. {                                                                             
  258.   /* blk = list.next */                                                       
  259.   *((DPL_LIST_CB_PTR_PTR) (adr_blk_ptr))                                      
  260.   = ((DPL_LIST_CB_PTR) (list_ptr)) -> next_blk_ptr;                           
  261. }                                                                             
  264. /*****************************************************************************/
  265. /*  D e s c r i p t i o n :                                                  */
  266. /*                                                                           */
  267. /*  remove block from start of desired double pointered list.                */
  268. /*                                                                           */
  269. /*****************************************************************************/
  272. #define dpl_remove_blk_from_list__(list_ptr)                                  
  273. {                                                                             
  274.   /* list.next = list.next -> next */                                         
  275.   ((DPL_LIST_CB_PTR) (list_ptr)) -> next_blk_ptr                              
  276.   = ((DPL_LIST_CB_PTR) (list_ptr)) -> next_blk_ptr -> next_blk_ptr;           
  277.                                                                               
  278.   /* list.next -> prev = list */                                              
  279.   ((DPL_LIST_CB_PTR) (list_ptr)) -> next_blk_ptr -> prev_blk_ptr              
  280.   = (DPL_LIST_CB_PTR) (list_ptr);                                             
  281. }                                                                             
  284. /*****************************************************************************/
  285. /*  D e s c r i p t i o n :                                                  */
  286. /*                                                                           */
  287. /*  get and remove block from start of desired double pointered list.        */
  288. /*                                                                           */
  289. /*****************************************************************************/
  292. #define dpl_get_remove_blk_from_list__(list_ptr, adr_blk_ptr)                 
  293. {                                                                             
  294.   dpl_get_blk_from_list__((list_ptr), (adr_blk_ptr));                         
  295.                                                                               
  296.   dpl_remove_blk_from_list__(list_ptr);                                       
  297. }                                                                             
  300. /*****************************************************************************/
  301. /*  D e s c r i p t i o n :                                                  */
  302. /*                                                                           */
  303. /*  remove block from anywhere inside a double pointered list.               */
  304. /*                                                                           */
  305. /*****************************************************************************/
  308. #define dpl_remove_blk__(blk_ptr)                                             
  309. {                                                                             
  310.   /* blk.prev -> next = blk.next */                                           
  311.   ((DPL_LIST_CB_PTR) (blk_ptr)) -> prev_blk_ptr -> next_blk_ptr               
  312.   = ((DPL_LIST_CB_PTR) (blk_ptr)) -> next_blk_ptr;                            
  313.                                                                               
  314.   /* blk.next -> prev = blk.prev */                                           
  315.   ((DPL_LIST_CB_PTR) (blk_ptr)) -> next_blk_ptr -> prev_blk_ptr               
  316.   = ((DPL_LIST_CB_PTR) (blk_ptr)) -> prev_blk_ptr;                            
  317. }                                                                             
  320. /*****************************************************************************/
  321. /* parameter check */
  324. #else
  325.     #error dplist handler: no list handling data attribute DPL_PTR_ATTR defined !
  326. #endif
  329. /*****************************************************************************/
  330. /* reinclude-protection */
  333. #else
  334.     #pragma message ("The header DPLLIST.H is included twice or more !")
  335. #endif
  338. /*****************************************************************************/
  339. /*  Copyright (C) profichip GmbH 2004. Confidential.                         */
  340. /*****************************************************************************/