URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [lib/] [include/] [chain.h] - Blame information for rev 493

Go to most recent revision | Details | Compare with Previous | View Log


/*  chain.h
 *
 *  This include file contains all the constants and structures associated
 *  with doubly linked chains.  This file actually just provides an
 *  interface to the chain object in rtems.
 *
 *  COPYRIGHT (c) 1989-1997.
 *  On-Line Applications Research Corporation (OAR).
 *  Copyright assigned to U.S. Government, 1994.
 *
 *  The license and distribution terms for this file may in
 *  the file LICENSE in this distribution or at
 *  http://www.OARcorp.com/rtems/license.html.
 *
 * $ld:
 */
 
#ifndef __CHAIN_h
#define __CHAIN_h
 
#include <rtems.h>
 
/*
 *  Chain_Initialize
 *
 *  This routine initializes the_chain structure to manage the
 *  contiguous array of number_nodes nodes which starts at
 *  starting_address.  Each node is of node_size bytes.
 *
 *  Chain_Control                    *the_chain,                 * IN  *
 *  void                             *starting_address,          * IN  *
 *  rtems_unsigned32                  number_nodes,              * IN  *
 *  rtems_unsigned32                  node_size                  * IN  *
 */
 
#define Chain_Initialize( the_chain, starting_address, \
                          number_nodes, node_size ) \
       _Chain_Initialize( the_chain, starting_address, \
                          number_nodes, node_size ) \
 
 
/*
 *  Chain_Initialize_empty
 *
 *  This routine initializes the specified chain to contain zero nodes.
 *
 *  Chain_Control                    *the_chain                  * IN  *
 */
 
#define Chain_Initialize_empty( the_chain ) \
       _Chain_Initialize_empty( the_chain )
 
 
/*
 *  Chain_Are_nodes_equal
 *
 *  This function returns TRUE if LEFT and RIGHT are equal,
 *  and FALSE otherwise.
 *
 *  Chain_Node                       *left,                      * IN  *
 *  Chain_Node                       *right                      * IN  *
 */
 
#define Chain_Are_nodes_equal( left, right ) \
       _Chain_Are_nodes_equal( left, right )
 
 
/*
 *  Chain_Extract_unprotected
 *
 *  This routine extracts the_node from the chain on which it resides.
 *  It does NOT disable interrupts to insure the atomicity of the
 *  extract operation.
 *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Extract_unprotected( the_node ) \
       _Chain_Extract_unprotected( the_node )
 
 
/*
 *  Chain_Extract
 *
 *  This routine extracts the_node from the chain on which it resides.
 *  It disables interrupts to insure the atomicity of the
 *  extract operation.
 *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Extract( the_node ) \
       _Chain_Extract( the_node )
 
 
/*
 *  Chain_Get_unprotected
 *
 *  This function removes the first node from the_chain and returns
 *  a pointer to that node.  If the_chain is empty, then NULL is returned.
 *  It does NOT disable interrupts to insure the atomicity of the
 *  get operation.
 *
 *  Chain_Control                    *the_chain                  * IN  *
 */
 
#define Chain_Get_unprotected( the_chain ) \
       _Chain_Get_unprotected( the_chain )
 
 
/*
 *  Chain_Get
 *
 *  This function removes the first node from the_chain and returns
 *  a pointer to that node.  If the_chain is empty, then NULL is returned.
 *  It disables interrupts to insure the atomicity of the
 *  get operation.
 *
 *  Chain_Control                    *the_chain                  * IN  *
 */
 
#define Chain_Get( the_chain ) \
       _Chain_Get( the_chain )
 
 
/*
 *  Chain_Get_first_unprotected
 *
 *  This function removes the first node from the_chain and returns
 *  a pointer to that node.  It does NOT disable interrupts to insure
 *  the atomicity of the get operation.
 *
 *  Chain_Control                    *the_chain                  * IN  *
 */
 
#define Chain_Get_first_unprotected( the_chain ) \
       _Chain_Get_first_unprotected( the_chain )
 
 
/*
 *  Chain_Insert_unprotected
 *
 *  This routine inserts the_node on a chain immediately following
 *  after_node.  It does NOT disable interrupts to insure the atomicity
 *  of the extract operation.
 *
 *  Chain_Node                       *after_node,                * IN  *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Insert_unprotected( after_node, the_node ) \
       _Chain_Insert_unprotected( after_node, the_node )
 
 
/*
 *  Chain_Insert
 *
 *  This routine inserts the_node on a chain immediately following
 *  after_node.  It disables interrupts to insure the atomicity
 *  of the extract operation.
 *
 *  Chain_Node                       *after_node,                * IN  *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Insert( after_node, the_node ) \
       _Chain_Insert( after_node, the_node )
 
 
/*
 *  Chain_Append_unprotected
 *
 *  This routine appends the_node onto the end of the_chain.
 *  It does NOT disable interrupts to insure the atomicity of the
 *  append operation.
 *
 *  Chain_Control                    *the_chain,                 * IN  *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Append_unprotected( the_chain, the_node ) \
       _Chain_Append_unprotected( the_chain, the_node )
 
 
/*
 *  Chain_Append
 *
 *  This routine appends the_node onto the end of the_chain.
 *  It disables interrupts to insure the atomicity of the
 *  append operation.
 *
 *  Chain_Control                    *the_chain,                 * IN  *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Append( the_chain, the_node ) \
       _Chain_Append( the_chain, the_node )
 
 
/*
 *  Chain_Prepend_unprotected
 *
 *  This routine prepends the_node onto the front of the_chain.
 *  It does NOT disable interrupts to insure the atomicity of the
 *  prepend operation.
 *
 *  Chain_Control                    *the_chain,                 * IN  *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Prepend_unprotected( the_chain, the_node ) \
       _Chain_Prepend_unprotected( the_chain, the_node )
 
 
/*
 *  Chain_Prepend
 *
 *  This routine prepends the_node onto the front of the_chain.
 *  It disables interrupts to insure the atomicity of the
 *  prepend operation.
 *
 *  Chain_Control                    *the_chain,                 * IN  *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Prepend( the_chain, the_node ) \
       _Chain_Prepend( the_chain, the_node )
 
 
/*
 *  Chain_Head
 *
 *  This function returns a pointer to the first node on the chain.
 *
 *  Chain_Control                    *the_chain                  * IN  *
 */
 
#define Chain_Head( the_chain ) \
       _Chain_Head( the_chain )
 
 
/*
 *  Chain_Tail
 *
 *  This function returns a pointer to the last node on the chain.
 *
 *  Chain_Control                    *the_chain                  * IN  *
 */
 
#define Chain_Tail( the_chain ) \
       _Chain_Tail( the_chain )
 
 
/*
 *  Chain_Is_head
 *
 *  This function returns TRUE if the_node is the head of the_chain and
 *  FALSE otherwise.
 *
 *  Chain_Control                    *the_chain,                 * IN  *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Is_head( the_chain, the_node ) \
       _Chain_Is_head( the_chain, the_node )
 
 
/*
 *  Chain_Is_tail
 *
 *  This function returns TRUE if the_node is the tail of the_chain and
 *  FALSE otherwise.
 *
 *  Chain_Control                    *the_chain,                 * IN  *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Is_tail( the_chain, the_node ) \
       _Chain_Is_tail( the_chain, the_node )
 
 
/*
 *  Chain_Is_first
 *
 *  This function returns TRUE if the_node is the first node on a chain and
 *  FALSE otherwise.
 *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Is_first( the_node ) \
       _Chain_Is_first( the_node )
 
 
/*
 *  Chain_Is_last
 *
 *  This function returns TRUE if the_node is the last node on a chain and
 *  FALSE otherwise.
 *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Is_last( the_node ) \
       _Chain_Is_last( the_node )
 
 
/*
 *  Chain_Is_empty
 *
 *  This function returns TRUE if there are no nodes on the_chain and
 *  FALSE otherwise.
 *
 *  Chain_Control                    *the_chain                  * IN  *
 */
 
#define Chain_Is_empty( the_chain ) \
       _Chain_Is_empty( the_chain )
 
 
/*
 *  Chain_Has_only_one_node
 *
 *  This function returns TRUE if there is only one node on the_chain and
 *  FALSE otherwise.
 *
 *  Chain_Control                    *the_chain                  * IN  *
 */
 
#define Chain_Has_only_one_node( the_chain ) \
       _Chain_Has_only_one_node( the_chain )
 
 
/*
 *  Chain_Is_null
 *
 *  This function returns TRUE if the_chain is NULL and FALSE otherwise.
 *
 *  Chain_Control                    *the_chain                  * IN  *
 */
 
#define Chain_Is_null( the_chain ) \
       _Chain_Is_null( the_chain )
 
 
/*
 *  Chain_Is_null_node
 *
 *  This function returns TRUE if the_node is NULL and FALSE otherwise.
 *
 *  Chain_Node                       *the_node                   * IN  *
 */
 
#define Chain_Is_null_node( the_node ) \
       _Chain_Is_null_node( the_node )
 
 
#undef __RTEMS_APPLICATION__
#include <rtems/score/chain.inl>
#define __RTEMS_APPLICATION__
#endif
/* end of include file */

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [lib/] [include/] [chain.h] - Blame information for rev 493

Line No.	Rev	Author	Line
1	30	unneback	`/* chain.h`
2			`*`
3			`* This include file contains all the constants and structures associated`
4			`* with doubly linked chains. This file actually just provides an`
5			`* interface to the chain object in rtems.`
6			`*`
7			`* COPYRIGHT (c) 1989-1997.`
8			`* On-Line Applications Research Corporation (OAR).`
9			`* Copyright assigned to U.S. Government, 1994.`
10			`*`
11			`* The license and distribution terms for this file may in`
12			`* the file LICENSE in this distribution or at`
13			`* http://www.OARcorp.com/rtems/license.html.`
14			`*`
15			`* $ld:`
16			`*/`
17
18			`#ifndef __CHAIN_h`
19			`#define __CHAIN_h`
20
21			`#include <rtems.h>`
22
23			`/*`
24			`* Chain_Initialize`
25			`*`
26			`* This routine initializes the_chain structure to manage the`
27			`* contiguous array of number_nodes nodes which starts at`
28			`* starting_address. Each node is of node_size bytes.`
29			`*`
30			`* Chain_Control the_chain, IN *`
31			`* void starting_address, IN *`
32			`* rtems_unsigned32 number_nodes, * IN *`
33			`* rtems_unsigned32 node_size * IN *`
34			`*/`
35
36			`#define Chain_Initialize( the_chain, starting_address, \`
37			`number_nodes, node_size ) \`
38			`_Chain_Initialize( the_chain, starting_address, \`
39			`number_nodes, node_size ) \`
40
41
42			`/*`
43			`* Chain_Initialize_empty`
44			`*`
45			`* This routine initializes the specified chain to contain zero nodes.`
46			`*`
47			`* Chain_Control the_chain IN *`
48			`*/`
49
50			`#define Chain_Initialize_empty( the_chain ) \`
51			`_Chain_Initialize_empty( the_chain )`
52
53
54			`/*`
55			`* Chain_Are_nodes_equal`
56			`*`
57			`* This function returns TRUE if LEFT and RIGHT are equal,`
58			`* and FALSE otherwise.`
59			`*`
60			`* Chain_Node left, IN *`
61			`* Chain_Node right IN *`
62			`*/`
63
64			`#define Chain_Are_nodes_equal( left, right ) \`
65			`_Chain_Are_nodes_equal( left, right )`
66
67
68			`/*`
69			`* Chain_Extract_unprotected`
70			`*`
71			`* This routine extracts the_node from the chain on which it resides.`
72			`* It does NOT disable interrupts to insure the atomicity of the`
73			`* extract operation.`
74			`*`
75			`* Chain_Node the_node IN *`
76			`*/`
77
78			`#define Chain_Extract_unprotected( the_node ) \`
79			`_Chain_Extract_unprotected( the_node )`
80
81
82			`/*`
83			`* Chain_Extract`
84			`*`
85			`* This routine extracts the_node from the chain on which it resides.`
86			`* It disables interrupts to insure the atomicity of the`
87			`* extract operation.`
88			`*`
89			`* Chain_Node the_node IN *`
90			`*/`
91
92			`#define Chain_Extract( the_node ) \`
93			`_Chain_Extract( the_node )`
94
95
96			`/*`
97			`* Chain_Get_unprotected`
98			`*`
99			`* This function removes the first node from the_chain and returns`
100			`* a pointer to that node. If the_chain is empty, then NULL is returned.`
101			`* It does NOT disable interrupts to insure the atomicity of the`
102			`* get operation.`
103			`*`
104			`* Chain_Control the_chain IN *`
105			`*/`
106
107			`#define Chain_Get_unprotected( the_chain ) \`
108			`_Chain_Get_unprotected( the_chain )`
109
110
111			`/*`
112			`* Chain_Get`
113			`*`
114			`* This function removes the first node from the_chain and returns`
115			`* a pointer to that node. If the_chain is empty, then NULL is returned.`
116			`* It disables interrupts to insure the atomicity of the`
117			`* get operation.`
118			`*`
119			`* Chain_Control the_chain IN *`
120			`*/`
121
122			`#define Chain_Get( the_chain ) \`
123			`_Chain_Get( the_chain )`
124
125
126			`/*`
127			`* Chain_Get_first_unprotected`
128			`*`
129			`* This function removes the first node from the_chain and returns`
130			`* a pointer to that node. It does NOT disable interrupts to insure`
131			`* the atomicity of the get operation.`
132			`*`
133			`* Chain_Control the_chain IN *`
134			`*/`
135
136			`#define Chain_Get_first_unprotected( the_chain ) \`
137			`_Chain_Get_first_unprotected( the_chain )`
138
139
140			`/*`
141			`* Chain_Insert_unprotected`
142			`*`
143			`* This routine inserts the_node on a chain immediately following`
144			`* after_node. It does NOT disable interrupts to insure the atomicity`
145			`* of the extract operation.`
146			`*`
147			`* Chain_Node after_node, IN *`
148			`* Chain_Node the_node IN *`
149			`*/`
150
151			`#define Chain_Insert_unprotected( after_node, the_node ) \`
152			`_Chain_Insert_unprotected( after_node, the_node )`
153
154
155			`/*`
156			`* Chain_Insert`
157			`*`
158			`* This routine inserts the_node on a chain immediately following`
159			`* after_node. It disables interrupts to insure the atomicity`
160			`* of the extract operation.`
161			`*`
162			`* Chain_Node after_node, IN *`
163			`* Chain_Node the_node IN *`
164			`*/`
165
166			`#define Chain_Insert( after_node, the_node ) \`
167			`_Chain_Insert( after_node, the_node )`
168
169
170			`/*`
171			`* Chain_Append_unprotected`
172			`*`
173			`* This routine appends the_node onto the end of the_chain.`
174			`* It does NOT disable interrupts to insure the atomicity of the`
175			`* append operation.`
176			`*`
177			`* Chain_Control the_chain, IN *`
178			`* Chain_Node the_node IN *`
179			`*/`
180
181			`#define Chain_Append_unprotected( the_chain, the_node ) \`
182			`_Chain_Append_unprotected( the_chain, the_node )`
183
184
185			`/*`
186			`* Chain_Append`
187			`*`
188			`* This routine appends the_node onto the end of the_chain.`
189			`* It disables interrupts to insure the atomicity of the`
190			`* append operation.`
191			`*`
192			`* Chain_Control the_chain, IN *`
193			`* Chain_Node the_node IN *`
194			`*/`
195
196			`#define Chain_Append( the_chain, the_node ) \`
197			`_Chain_Append( the_chain, the_node )`
198
199
200			`/*`
201			`* Chain_Prepend_unprotected`
202			`*`
203			`* This routine prepends the_node onto the front of the_chain.`
204			`* It does NOT disable interrupts to insure the atomicity of the`
205			`* prepend operation.`
206			`*`
207			`* Chain_Control the_chain, IN *`
208			`* Chain_Node the_node IN *`
209			`*/`
210
211			`#define Chain_Prepend_unprotected( the_chain, the_node ) \`
212			`_Chain_Prepend_unprotected( the_chain, the_node )`
213
214
215			`/*`
216			`* Chain_Prepend`
217			`*`
218			`* This routine prepends the_node onto the front of the_chain.`
219			`* It disables interrupts to insure the atomicity of the`
220			`* prepend operation.`
221			`*`
222			`* Chain_Control the_chain, IN *`
223			`* Chain_Node the_node IN *`
224			`*/`
225
226			`#define Chain_Prepend( the_chain, the_node ) \`
227			`_Chain_Prepend( the_chain, the_node )`
228
229
230			`/*`
231			`* Chain_Head`
232			`*`
233			`* This function returns a pointer to the first node on the chain.`
234			`*`
235			`* Chain_Control the_chain IN *`
236			`*/`
237
238			`#define Chain_Head( the_chain ) \`
239			`_Chain_Head( the_chain )`
240
241
242			`/*`
243			`* Chain_Tail`
244			`*`
245			`* This function returns a pointer to the last node on the chain.`
246			`*`
247			`* Chain_Control the_chain IN *`
248			`*/`
249
250			`#define Chain_Tail( the_chain ) \`
251			`_Chain_Tail( the_chain )`
252
253
254			`/*`
255			`* Chain_Is_head`
256			`*`
257			`* This function returns TRUE if the_node is the head of the_chain and`
258			`* FALSE otherwise.`
259			`*`
260			`* Chain_Control the_chain, IN *`
261			`* Chain_Node the_node IN *`
262			`*/`
263
264			`#define Chain_Is_head( the_chain, the_node ) \`
265			`_Chain_Is_head( the_chain, the_node )`
266
267
268			`/*`
269			`* Chain_Is_tail`
270			`*`
271			`* This function returns TRUE if the_node is the tail of the_chain and`
272			`* FALSE otherwise.`
273			`*`
274			`* Chain_Control the_chain, IN *`
275			`* Chain_Node the_node IN *`
276			`*/`
277
278			`#define Chain_Is_tail( the_chain, the_node ) \`
279			`_Chain_Is_tail( the_chain, the_node )`
280
281
282			`/*`
283			`* Chain_Is_first`
284			`*`
285			`* This function returns TRUE if the_node is the first node on a chain and`
286			`* FALSE otherwise.`
287			`*`
288			`* Chain_Node the_node IN *`
289			`*/`
290
291			`#define Chain_Is_first( the_node ) \`
292			`_Chain_Is_first( the_node )`
293
294
295			`/*`
296			`* Chain_Is_last`
297			`*`
298			`* This function returns TRUE if the_node is the last node on a chain and`
299			`* FALSE otherwise.`
300			`*`
301			`* Chain_Node the_node IN *`
302			`*/`
303
304			`#define Chain_Is_last( the_node ) \`
305			`_Chain_Is_last( the_node )`
306
307
308			`/*`
309			`* Chain_Is_empty`
310			`*`
311			`* This function returns TRUE if there are no nodes on the_chain and`
312			`* FALSE otherwise.`
313			`*`
314			`* Chain_Control the_chain IN *`
315			`*/`
316
317			`#define Chain_Is_empty( the_chain ) \`
318			`_Chain_Is_empty( the_chain )`
319
320
321			`/*`
322			`* Chain_Has_only_one_node`
323			`*`
324			`* This function returns TRUE if there is only one node on the_chain and`
325			`* FALSE otherwise.`
326			`*`
327			`* Chain_Control the_chain IN *`
328			`*/`
329
330			`#define Chain_Has_only_one_node( the_chain ) \`
331			`_Chain_Has_only_one_node( the_chain )`
332
333
334			`/*`
335			`* Chain_Is_null`
336			`*`
337			`* This function returns TRUE if the_chain is NULL and FALSE otherwise.`
338			`*`
339			`* Chain_Control the_chain IN *`
340			`*/`
341
342			`#define Chain_Is_null( the_chain ) \`
343			`_Chain_Is_null( the_chain )`
344
345
346			`/*`
347			`* Chain_Is_null_node`
348			`*`
349			`* This function returns TRUE if the_node is NULL and FALSE otherwise.`
350			`*`
351			`* Chain_Node the_node IN *`
352			`*/`
353
354			`#define Chain_Is_null_node( the_node ) \`
355			`_Chain_Is_null_node( the_node )`
356
357
358			`#undef __RTEMS_APPLICATION__`
359			`#include <rtems/score/chain.inl>`
360			`#define __RTEMS_APPLICATION__`
361			`#endif`
362			`/* end of include file */`