← Back to branch summary

~ubuntu-branches/ubuntu/karmic/firebird2.1/karmic

« back to all changes in this revision

Viewing changes to src/jrd/que.h

  • Committer: Bazaar Package Importer
  • Author(s): Damyan Ivanov
  • Date: 2008-05-26 23:59:25 UTC
  • Revision ID: james.westby@ubuntu.com-20080526235925-2pnqj6nxpppoeaer
Tags: upstream-2.1.0.17798-0.ds2
Import upstream version 2.1.0.17798-0.ds2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/jrd/que.h
 
1
/*
 
2
 *      PROGRAM:        JRD Access Method
 
3
 *      MODULE:         que.h
 
4
 *      DESCRIPTION:    Que manipulation macros
 
5
 *
 
6
 * The contents of this file are subject to the Interbase Public
 
7
 * License Version 1.0 (the "License"); you may not use this file
 
8
 * except in compliance with the License. You may obtain a copy
 
9
 * of the License at http://www.Inprise.com/IPL.html
 
10
 *
 
11
 * Software distributed under the License is distributed on an
 
12
 * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
 
13
 * or implied. See the License for the specific language governing
 
14
 * rights and limitations under the License.
 
15
 *
 
16
 * The Original Code was created by Inprise Corporation
 
17
 * and its predecessors. Portions created by Inprise Corporation are
 
18
 * Copyright (C) Inprise Corporation.
 
19
 *
 
20
 * All Rights Reserved.
 
21
 * Contributor(s): ______________________________________.
 
22
 */
 
23
 
 
24
#ifndef JRD_QUE_H
 
25
#define JRD_QUE_H
 
26
 
 
27
#define QUE_INIT(que) {\
 
28
        (que).que_backward = &(que);\
 
29
        (que).que_forward = &(que);}
 
30
 
 
31
 
 
32
#define QUE_DELETE(node) {\
 
33
        (node).que_backward->que_forward = (node).que_forward;\
 
34
        (node).que_forward->que_backward = (node).que_backward;}
 
35
 
 
36
/* QUE_INSERT adds node to queue head. */
 
37
 
 
38
#define QUE_INSERT(que, node) {\
 
39
        (node).que_forward = (que).que_forward;\
 
40
        (node).que_backward = &(que);\
 
41
        (que).que_forward->que_backward = &(node);\
 
42
        (que).que_forward = &(node);}
 
43
 
 
44
/* QUE_APPEND adds node to queue tail. */
 
45
 
 
46
#define QUE_APPEND(que, node) {\
 
47
        (node).que_forward = &(que);\
 
48
        (node).que_backward = (que).que_backward;\
 
49
        (que).que_backward->que_forward = &(node);\
 
50
        (que).que_backward = &(node);}
 
51
 
 
52
/* QUE_LOOP to visit every node. */
 
53
 
 
54
#define QUE_LOOP(que, node) {\
 
55
        for (node = (que).que_forward; node != &(que); node = (node)->que_forward)
 
56
 
 
57
#define QUE_LOOPA(que, node) {\
 
58
        for (node = (que)->que_forward; node != que; node = (node)->que_forward)
 
59
 
 
60
#define QUE_NOT_EMPTY(que) ((que).que_forward != &(que))
 
61
#define QUE_EMPTY(que) ((que).que_forward == &(que))
 
62
 
 
63
#define QUE_MOST_RECENTLY_USED(in_use_que) {\
 
64
        QUE_DELETE (in_use_que);\
 
65
        QUE_INSERT (bcb->bcb_in_use, in_use_que);}
 
66
 
 
67
#define QUE_LEAST_RECENTLY_USED(in_use_que) {\
 
68
        QUE_DELETE (in_use_que);\
 
69
        QUE_APPEND (bcb->bcb_in_use, in_use_que);}
 
70
 
 
71
//
 
72
// general purpose queue
 
73
//
 
74
namespace Jrd {
 
75
 
 
76
struct que {
 
77
        struct que* que_forward;
 
78
        struct que* que_backward;
 
79
};
 
80
 
 
81
typedef que *QUE;
 
82
 
 
83
}
 
84
// Self-relative queue BASE should be defined in the source which includes this
 
85
#define SRQ_PTR SLONG
 
86
 
 
87
#define SRQ_REL_PTR(item)           (SRQ_PTR) ((UCHAR*) item - SRQ_BASE)
 
88
#define SRQ_ABS_PTR(item)           (SRQ_BASE + item)
 
89
 
 
90
#define SRQ_INIT(que)   {que.srq_forward = que.srq_backward = SRQ_REL_PTR (&que);}
 
91
#define SRQ_EMPTY(que)  (que.srq_forward == SRQ_REL_PTR (&que))
 
92
#define SRQ_NEXT(que)   (srq*) SRQ_ABS_PTR (que.srq_forward)
 
93
#define SRQ_PREV(que)   (srq*) SRQ_ABS_PTR (que.srq_backward)
 
94
 
 
95
#define SRQ_LOOP(header, que)    for (que = SRQ_NEXT (header);\
 
96
        que != &header; que = SRQ_NEXT ((*que)))
 
97
#define SRQ_LOOP_BACK(header, que)      for (que = SRQ_PREV (header);\
 
98
        que != &header; que = SRQ_PREV ((*que)))
 
99
 
 
100
/* Self-relative que block.  Offsets are from the block itself. */
 
101
 
 
102
struct srq {
 
103
        SRQ_PTR srq_forward;                    /* Forward offset */
 
104
        SRQ_PTR srq_backward;                   /* Backward offset */
 
105
};
 
106
 
 
107
typedef srq *SRQ;
 
108
 
 
109
 
 
110
#endif /* JRD_QUE_H */