summaryrefslogtreecommitdiffstats
path: root/cpukit/score/inline/rtems/score/chain.inl
blob: e47242bf70705f38a51e129aa4960250da8ef8a1 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
/**
 *  @file  rtems/score/chain.inl
 *
 *  This include file contains the bodies of the routines which are
 *  associated with doubly linked chains and inlined.
 *
 *  @note  The routines in this file are ordered from simple
 *         to complex.  No other Chain Handler routine is referenced
 *         unless it has already been defined.
 */

/*
 *  COPYRIGHT (c) 1989-2006.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.rtems.com/license/LICENSE.
 *
 *  $Id$
 */

#ifndef _RTEMS_SCORE_CHAIN_INL
#define _RTEMS_SCORE_CHAIN_INL

/**
 *  @addtogroup ScoreChain 
 *  @{
 */

/** @brief Are Two Nodes Equal
 *
 *  This function returns TRUE if @a left and @a right are equal,
 *  and FALSE otherwise.
 *
 *  @param[in] left is the node on the left hand side of the comparison.
 *  @param[in] right is the node on the left hand side of the comparison.
 *
 *  @return This function returns TRUE if @a left and @a right are equal,
 *          and FALSE otherwise.
 */
RTEMS_INLINE_ROUTINE boolean _Chain_Are_nodes_equal(
  const Chain_Node *left,
  const Chain_Node *right
)
{
  return left == right;
}

/** @brief Is this Chain Control Pointer Null
 *
 *  This function returns TRUE if the_chain is NULL and FALSE otherwise.
 *
 *  @param[in] the_chain is the chain to be checked for empty status.
 *
 *  @return This method returns TRUE if the_chain is NULL and FALSE otherwise.
 */
RTEMS_INLINE_ROUTINE boolean _Chain_Is_null(
  const Chain_Control *the_chain
)
{
  return (the_chain == NULL);
}

/** @brief Is the Chain Node Pointer NULL
 *
 *  This function returns TRUE if the_node is NULL and FALSE otherwise.
 *
 *  @param[in] the_node is the node pointer to check.
 *
 *  @return This method returns TRUE if the_node is NULL and FALSE otherwise.
 */
RTEMS_INLINE_ROUTINE boolean _Chain_Is_null_node(
  const Chain_Node *the_node
)
{
  return (the_node == NULL);
}

/** @brief Return pointer to Chain Head
 *
 *  This function returns a pointer to the first node on the chain.
 *
 *  @param[in] the_chain is the chain to be operated upon.
 *
 *  @return This method returns the permanent head node of the chain.
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) the_chain;
}

/** @brief Return pointer to Chain Tail
 *
 *  This function returns a pointer to the last node on the chain.
 *
 *  @param[in] the_chain is the chain to be operated upon.
 *
 *  @return This method returns the permanent tail node of the chain.
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
}

/** @brief Is the Chain Empty
 *
 *  This function returns TRUE if there a no nodes on @a the_chain and
 *  FALSE otherwise.
 *
 *  @param[in] the_chain is the chain to be operated upon.
 *
 *  @return This function returns TRUE if there a no nodes on @a the_chain and
 *  FALSE otherwise.
 */
RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
}

/** @brief Is this the First Node on the Chain
 *
 *  This function returns TRUE if the_node is the first node on a chain and
 *  FALSE otherwise.
 *
 *  @param[in] the_node is the node the caller wants to know if it is
 *             the first node on a chain.
 *
 *  @return This function returns TRUE if @a the_node is the first node on
 *          a chain and FALSE otherwise.
 */
RTEMS_INLINE_ROUTINE boolean _Chain_Is_first(
  const Chain_Node *the_node
)
{
  return (the_node->previous == NULL);
}

/** @brief Is this the Last Node on the Chain
 *
 *  This function returns TRUE if @a the_node is the last node on a chain and
 *  FALSE otherwise.
 *
 *  @param[in] the_node is the node to check as the last node.
 *
 *  @return This function returns TRUE if @a the_node is the last node on
 *          a chain and FALSE otherwise.
 */
RTEMS_INLINE_ROUTINE boolean _Chain_Is_last(
  const Chain_Node *the_node
)
{
  return (the_node->next == NULL);
}

/** @brief Does this Chain have only One Node
 *
 *  This function returns TRUE if there is only one node on @a the_chain and
 *  FALSE otherwise.
 *
 *  @param[in] the_chain is the chain to be operated upon.
 *
 *  @return This function returns TRUE if there is only one node on
 *          @a the_chain and FALSE otherwise.
 */
RTEMS_INLINE_ROUTINE boolean _Chain_Has_only_one_node(
  const Chain_Control *the_chain
)
{
  return (the_chain->first == the_chain->last);
}

/** @brief Is this Node the Chain Head
 *
 *  This function returns TRUE if @a the_node is the head of the_chain and
 *  FALSE otherwise.
 *
 *  @param[in] the_chain is the chain to be operated upon.
 *  @param[in] the_node is the node to check for being the Chain Head.
 *
 *  @return This function returns TRUE if @a the_node is the head of
 *          @a the_chain and FALSE otherwise.
 */
RTEMS_INLINE_ROUTINE boolean _Chain_Is_head(
  Chain_Control *the_chain,
  const Chain_Node    *the_node
)
{
   return (the_node == _Chain_Head(the_chain));
}

/** @brief Is this Node the Chail Tail
 *
 *  This function returns TRUE if the_node is the tail of the_chain and
 *  FALSE otherwise.
 *
 *  @param[in] the_chain is the chain to be operated upon.
 *  @param[in] the_node is the node to check for being the Chain Tail.
 */
RTEMS_INLINE_ROUTINE boolean _Chain_Is_tail(
  Chain_Control *the_chain,
  const Chain_Node    *the_node
)
{
   return (the_node == _Chain_Tail(the_chain));
}

/** @brief Initialize this Chain as Empty
 *
 *  This routine initializes the specified chain to contain zero nodes.
 *
 *  @param[in] the_chain is the chain to be initialized.
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
}

/** @brief Extract this Node (unprotected)
 *
 *  This routine extracts the_node from the chain on which it resides.
 *  It does NOT disable interrupts to ensure the atomicity of the
 *  extract operation.
 *
 *  @param[in] the_node is the node to be extracted.
 */
RTEMS_INLINE_ROUTINE void _Chain_Extract_unprotected(
  Chain_Node *the_node
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
  previous->next = next;
}

/** @brief Get the First Node (unprotected)
 *
 *  This function removes the first node from the_chain and returns
 *  a pointer to that node.  It does NOT disable interrupts to ensure
 *  the atomicity of the get operation.
 *
 *  @param[in] the_chain is the chain to attempt to get the first node from.
 *
 *  @return This method returns the first node on the chain even if it is
 *          the Chain Tail.
 *
 *  @note This routine assumes that there is at least one node on the chain
 *        and always returns a node even if it is the Chain Tail.
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
  Chain_Control *the_chain
)
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
  the_chain->first    = new_first;
  new_first->previous = _Chain_Head(the_chain);

  return return_node;
}

/** @brief Get the First Node (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.
 *
 *  @param[in] the_chain is the chain to attempt to get the first node from.
 *
 *  @return This method returns the first node on the chain or NULL if the
 *          chain is empty.
 *
 *  @note It does NOT disable interrupts to ensure the atomicity of the
 *        get operation.
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
    return _Chain_Get_first_unprotected(the_chain);
  else
    return NULL;
}

/** @brief Insert a Node (unprotected)
 *
 *  This routine inserts the_node on a chain immediately following
 *  after_node.
 *
 *  @param[in] after_node is the node which will precede @a the_node on the
 *             chain.
 *  @param[in] the_node is the node to be inserted.
 *
 *  @note It does NOT disable interrupts to ensure the atomicity
 *        of the extract operation.
 */
RTEMS_INLINE_ROUTINE void _Chain_Insert_unprotected(
  Chain_Node *after_node,
  Chain_Node *the_node
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
  after_node->next      = the_node;
  the_node->next        = before_node;
  before_node->previous = the_node;
}

/** @brief Append a Node (unprotected) 
 *
 *  This routine appends the_node onto the end of the_chain.
 *
 *  @param[in] the_chain is the chain to be operated upon.
 *  @param[in] the_node is the node to be appended.
 *
 *  @note It does NOT disable interrupts to ensure the atomicity of the
 *        append operation.
 */
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
  Chain_Control *the_chain,
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
  old_last_node       = the_chain->last;
  the_chain->last     = the_node;
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
}

/** @brief Prepend a Node (unprotected)
 *
 *  This routine prepends the_node onto the front of the_chain.
 *
 *  @param[in] the_chain is the chain to be operated upon.
 *  @param[in] the_node is the node to be prepended.
 *
 *  @note It does NOT disable interrupts to ensure the atomicity of the
 *        prepend operation.
 */
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
  Chain_Control *the_chain,
  Chain_Node    *the_node
)
{
  _Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
}

/** @brief Prepend a Node (protected)
 *
 *  This routine prepends the_node onto the front of the_chain.
 *
 *  @param[in] the_chain is the chain to be operated upon.
 *  @param[in] the_node is the node to be prepended.
 *
 *  @note It disables interrupts to ensure the atomicity of the
 *        prepend operation.
 */
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
  Chain_Control *the_chain,
  Chain_Node    *the_node
)
{
  _Chain_Insert(_Chain_Head(the_chain), the_node);
}

/**@}*/

#endif
/* end of include file */