← Back to branch summary

~ubuntu-branches/debian/jessie/ion/jessie

« back to all changes in this revision

Viewing changes to ici/sdr/sdrtable.c

  • Committer: Package Import Robot
  • Author(s): Leo Iannacone
  • Date: 2012-02-01 09:46:31 UTC
  • Revision ID: package-import@ubuntu.com-20120201094631-qpfwehc1b7ftkjgx
Tags: upstream-2.5.3~dfsg1
Import upstream version 2.5.3~dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
ici/sdr/sdrtable.c
 
1
/*
 
2
 *      sdrtable.c:     simple data recorder table management
 
3
 *                      library.
 
4
 *
 
5
 *      Copyright (c) 2001-2007, California Institute of Technology.
 
6
 *      ALL RIGHTS RESERVED.  U.S. Government Sponsorship
 
7
 *      acknowledged.
 
8
 *
 
9
 *      Author: Scott Burleigh, JPL
 
10
 *
 
11
 *      This library implements the Simple Data Recorder system's
 
12
 *      self-delimiting tables.
 
13
 *
 
14
 *      Modification History:
 
15
 *      Date      Who   What
 
16
 *      4-3-96    APS   Abstracted IPC services and task control.
 
17
 *      5-1-96    APS   Ported to sparc-sunos4.
 
18
 *      12-20-00  SCB   Revised for sparc-sunos5.
 
19
 *      6-8-07    SCB   Divided sdr.c library into separable components.
 
20
 */
 
21
 
 
22
#include "sdrP.h"
 
23
#include "sdrtable.h"
 
24
 
 
25
/*              Private definition of SDR table structure.              */
 
26
 
 
27
typedef struct
 
28
{
 
29
        Address         userData;
 
30
        int             rowSize;
 
31
        int             rowCount;
 
32
        Object          rows;   /*      an array                        */
 
33
} SdrTable;
 
34
 
 
35
/*      *       *       Table management functions      *       *       */
 
36
 
 
37
Object  Sdr_table_create(char *file, int line, Sdr sdrv, int rowSize,
 
38
                int rowCount)
 
39
{
 
40
        SdrTable        tableBuffer;
 
41
        Object          table;
 
42
 
 
43
        if (!(sdr_in_xn(sdrv)))
 
44
        {
 
45
                oK(_iEnd(file, line, _notInXnMsg()));
 
46
                return 0;
 
47
        }
 
48
 
 
49
        joinTrace(sdrv, file, line);
 
50
        if (rowSize < 1 || rowCount < 1)
 
51
        {
 
52
                oK(_xniEnd(file, line, _apiErrMsg(), sdrv));
 
53
                return 0;
 
54
        }
 
55
 
 
56
        tableBuffer.userData = 0;
 
57
        tableBuffer.rowSize = rowSize;
 
58
        tableBuffer.rowCount = rowCount;
 
59
        tableBuffer.rows = _sdrmalloc(sdrv, rowSize * rowCount);
 
60
        if (tableBuffer.rows == 0)
 
61
        {
 
62
                oK(_iEnd(file, line, "tableBuffer.rows"));
 
63
                return 0;
 
64
        }
 
65
 
 
66
        table = _sdrzalloc(sdrv, sizeof tableBuffer);
 
67
        if (table == 0)
 
68
        {
 
69
                oK(_iEnd(file, line, "table"));
 
70
                return 0;
 
71
        }
 
72
 
 
73
        sdrPut((Address) table, tableBuffer);
 
74
        return table;
 
75
}
 
76
 
 
77
Address sdr_table_user_data(Sdr sdrv, Object table)
 
78
{
 
79
        SdrState        *sdr;
 
80
        SdrTable        tableBuffer;
 
81
 
 
82
        CHKZERO(sdrv);
 
83
        CHKZERO(table);
 
84
        sdr = sdrv->sdr;
 
85
        CHKZERO(takeSdr(sdr) == 0);
 
86
        sdrFetch(tableBuffer, (Address) table);
 
87
        releaseSdr(sdr);
 
88
        return tableBuffer.userData;
 
89
}
 
90
 
 
91
void    Sdr_table_user_data_set(char *file, int line, Sdr sdrv, Object table,
 
92
                Address data)
 
93
{
 
94
        SdrTable        tableBuffer;
 
95
 
 
96
        if (!(sdr_in_xn(sdrv)))
 
97
        {
 
98
                oK(_iEnd(file, line, _notInXnMsg()));
 
99
                return;
 
100
        }
 
101
 
 
102
        joinTrace(sdrv, file, line);
 
103
        if (table == 0)
 
104
        {
 
105
                oK(_xniEnd(file, line, "table", sdrv));
 
106
                return;
 
107
        }
 
108
 
 
109
        sdrFetch(tableBuffer, (Address) table);
 
110
        tableBuffer.userData = data;
 
111
        sdrPut((Address) table, tableBuffer);
 
112
}
 
113
 
 
114
void    sdr_table_dimensions(Sdr sdrv, Object table, int *rowSize,
 
115
                int *rowCount)
 
116
{
 
117
        SdrState        *sdr;
 
118
        SdrTable        tableBuffer;
 
119
 
 
120
        CHKVOID(sdrv);
 
121
        CHKVOID(table);
 
122
        CHKVOID(rowSize);
 
123
        CHKVOID(rowCount);
 
124
        sdr = sdrv->sdr;
 
125
        CHKVOID(takeSdr(sdr) == 0);
 
126
        sdrFetch(tableBuffer, (Address) table);
 
127
        releaseSdr(sdr);
 
128
        *rowSize = tableBuffer.rowSize;
 
129
        *rowCount = tableBuffer.rowCount;
 
130
}
 
131
 
 
132
void    sdr_table_stage(Sdr sdrv, Object table)
 
133
{
 
134
        SdrState        *sdr;
 
135
        SdrTable        tableBuffer;
 
136
 
 
137
        CHKVOID(sdrv);
 
138
        CHKVOID(table);
 
139
        sdr = sdrv->sdr;
 
140
        CHKVOID(takeSdr(sdr) == 0);
 
141
        sdrFetch(tableBuffer, (Address) table);
 
142
        sdr_stage(sdrv, NULL, tableBuffer.rows, 0);
 
143
        releaseSdr(sdr);
 
144
}
 
145
 
 
146
Address sdr_table_row(Sdr sdrv, Object table, unsigned int rowNbr)
 
147
{
 
148
        SdrState        *sdr;
 
149
        SdrTable        tableBuffer;
 
150
        Address         addr;
 
151
 
 
152
        CHKERR(sdrv);
 
153
        CHKERR(table);
 
154
        sdr = sdrv->sdr;
 
155
        CHKERR(takeSdr(sdr) == 0);
 
156
        sdrFetch(tableBuffer, (Address) table);
 
157
        releaseSdr(sdr);
 
158
        CHKERR(rowNbr < tableBuffer.rowCount);
 
159
        addr = ((Address) (tableBuffer.rows)) + (rowNbr * tableBuffer.rowSize);
 
160
        return addr;
 
161
}
 
162
 
 
163
void    Sdr_table_destroy(char *file, int line, Sdr sdrv, Object table)
 
164
{
 
165
        SdrTable        tableBuffer;
 
166
 
 
167
        if (!(sdr_in_xn(sdrv)))
 
168
        {
 
169
                oK(_iEnd(file, line, _notInXnMsg()));
 
170
                return;
 
171
        }
 
172
 
 
173
        joinTrace(sdrv, file, line);
 
174
        if (table == 0)
 
175
        {
 
176
                oK(_xniEnd(file, line, _apiErrMsg(), sdrv));
 
177
                return;
 
178
        }
 
179
 
 
180
        sdrFetch(tableBuffer, (Address) table);
 
181
        sdrFree(tableBuffer.rows);
 
182
 
 
183
        /* just in case user mistakenly accesses later... */
 
184
        tableBuffer.rowSize = 0;
 
185
        tableBuffer.rowCount = 0;
 
186
        tableBuffer.rows = 0;
 
187
        sdrPut((Address) table, tableBuffer);
 
188
        sdrFree(table);
 
189
}