Debian Codegraph @

lang/perl/BerkeleyDB/typemap

raw
1 # typemap for Perl 5 interface to Berkeley DB version 2 & 3
2 #
3 # SCCS: %I%, %G%
4 #
5 # written by Paul Marquess <[email protected]>
6 #
7 #################################### DB SECTION
8 #
9 #
10
11 SVnull* T_SV_NULL
12 void * T_PV
13 db_seq_t T_PV_64
14 u_int T_U_INT
15 u_int32_t T_U_INT
16 int32_t T_U_INT
17 db_timeout_t T_U_INT
18 const char * T_PV_NULL
19 PV_or_NULL T_PV_NULL
20 IO_or_NULL T_IO_NULL
21
22 AV * T_AV
23
24 BerkeleyDB T_PTROBJ
25 BerkeleyDB::Common T_PTROBJ_AV
26 BerkeleyDB::Hash T_PTROBJ_AV
27 BerkeleyDB::Btree T_PTROBJ_AV
28 BerkeleyDB::Heap T_PTROBJ_AV
29 BerkeleyDB::Recno T_PTROBJ_AV
30 BerkeleyDB::Queue T_PTROBJ_AV
31 BerkeleyDB::Cursor T_PTROBJ_AV
32 BerkeleyDB::TxnMgr T_PTROBJ_AV
33 BerkeleyDB::Txn T_PTROBJ_AV
34 BerkeleyDB::Log T_PTROBJ_AV
35 BerkeleyDB::Lock T_PTROBJ_AV
36 BerkeleyDB::Env T_PTROBJ_AV
37 BerkeleyDB::Sequence T_PTROBJ_NULL
38
39 BerkeleyDB::Raw T_RAW
40 BerkeleyDB::Common::Raw T_RAW
41 BerkeleyDB::Hash::Raw T_RAW
42 BerkeleyDB::Btree::Raw T_RAW
43 BerkeleyDB::Heap::Raw T_RAW
44 BerkeleyDB::Recno::Raw T_RAW
45 BerkeleyDB::Queue::Raw T_RAW
46 BerkeleyDB::Cursor::Raw T_RAW
47 BerkeleyDB::TxnMgr::Raw T_RAW
48 BerkeleyDB::Txn::Raw T_RAW
49 BerkeleyDB::Log::Raw T_RAW
50 BerkeleyDB::Lock::Raw T_RAW
51 BerkeleyDB::Env::Raw T_RAW
52
53 BerkeleyDB::Env::Inner T_INNER
54 BerkeleyDB::Common::Inner T_INNER
55 BerkeleyDB::Txn::Inner T_INNER
56 BerkeleyDB::TxnMgr::Inner T_INNER
57 # BerkeleyDB__Env T_PTR
58 DBT T_dbtdatum
59 DBT_OPT T_dbtdatum_opt
60 DBT_B T_dbtdatum_btree
61 DBTKEY T_dbtkeydatum
62 DBTKEY_B T_dbtkeydatum_btree
63 DBTKEY_Br T_dbtkeydatum_btree_r
64 DBTKEY_Bpr T_dbtkeydatum_btree_pr
65 DBTKEY_seq T_dbtkeydatum_seq
66 DBTYPE T_U_INT
67 DualType T_DUAL
68 BerkeleyDB_type * T_IV
69 BerkeleyDB_ENV_type * T_IV
70 BerkeleyDB_TxnMgr_type * T_IV
71 BerkeleyDB_Txn_type * T_IV
72 BerkeleyDB__Cursor_type * T_IV
73 DB * T_IV
74 DB_ENV * T_IV
75
76 INPUT
77
78 T_AV
79 if (SvROK($arg) && SvTYPE(SvRV($arg)) == SVt_PVAV)
80 /* if (sv_isa($arg, \"${ntype}\")) */
81 $var = (AV*)SvRV($arg);
82 else
83 croak(\"$var is not an array reference\")
84
85 T_RAW
86 $var = INT2PTR($type,SvIV($arg)
87
88 T_U_INT
89 $var = SvUV($arg)
90
91 T_INT
92 $var = SvIV($arg)
93
94 T_SV_REF_NULL
95 if ($arg == &PL_sv_undef)
96 $var = NULL ;
97 else if (sv_derived_from($arg, \"${ntype}\")) {
98 IV tmp = SvIV((SV *)GetInternalObject($arg));
99 $var = INT2PTR($type, tmp);
100 }
101 else
102 croak(\"$var is not of type ${ntype}\")
103
104 T_SV_NULL
105 if ($arg == NULL || $arg == &PL_sv_undef)
106 $var = NULL ;
107 else
108 $var = $arg ;
109
110 T_HV_REF_NULL
111 if ($arg == &PL_sv_undef)
112 $var = NULL ;
113 else if (sv_derived_from($arg, \"${ntype}\")) {
114 HV * hv = (HV *)GetInternalObject($arg);
115 SV ** svp = hv_fetch(hv, \"db\", 2, FALSE);
116 IV tmp = SvIV(*svp);
117 $var = INT2PTR($type, tmp);
118 }
119 else
120 croak(\"$var is not of type ${ntype}\")
121
122 T_HV_REF
123 if (sv_derived_from($arg, \"${ntype}\")) {
124 HV * hv = (HV *)GetInternalObject($arg);
125 SV ** svp = hv_fetch(hv, \"db\", 2, FALSE);
126 IV tmp = SvIV(*svp);
127 $var = INT2PTR($type, tmp);
128 }
129 else
130 croak(\"$var is not of type ${ntype}\")
131
132
133 T_P_REF
134 if (sv_derived_from($arg, \"${ntype}\")) {
135 IV tmp = SvIV((SV*)SvRV($arg));
136 $var = INT2PTR($type, tmp);
137 }
138 else
139 croak(\"$var is not of type ${ntype}\")
140
141
142 T_INNER
143 {
144 HV * hv = (HV *)SvRV($arg);
145 SV ** svp = hv_fetch(hv, \"db\", 2, FALSE);
146 IV tmp = SvIV(*svp);
147 $var = INT2PTR($type, tmp);
148 }
149
150 T_PV_NULL
151 if ($arg == &PL_sv_undef)
152 $var = NULL ;
153 else {
154 STRLEN len;
155 $var = ($type)SvPV($arg,len) ;
156 if (len == 0)
157 $var = NULL ;
158 }
159
160 T_PV_64
161 if ($arg == &PL_sv_undef)
162 $var = 0 ;
163 else {
164 STRLEN len;
165 $var = ($type)SvPV($arg,len) ;
166 if (len == 0)
167 $var = NULL ;
168 }
169
170 T_IO_NULL
171 if ($arg == &PL_sv_undef)
172 $var = NULL ;
173 else
174 $var = IoOFP(sv_2io($arg))
175
176 T_PTROBJ_NULL
177 if ($arg == &PL_sv_undef)
178 $var = NULL ;
179 else if (sv_derived_from($arg, \"${ntype}\")) {
180 IV tmp = SvIV((SV*)SvRV($arg));
181 $var = INT2PTR($type, tmp);
182 }
183 else
184 croak(\"$var is not of type ${ntype}\")
185
186 T_PTROBJ_SELF
187 if ($arg == &PL_sv_undef)
188 $var = NULL ;
189 else if (sv_derived_from($arg, \"${ntype}\")) {
190 IV tmp = SvIV((SV*)SvRV($arg));
191 $var = INT2PTR($type, tmp);
192 }
193 else
194 croak(\"$var is not of type ${ntype}\")
195
196 T_PTROBJ_AV
197 if ($arg == &PL_sv_undef || $arg == NULL)
198 $var = NULL ;
199 else if (sv_derived_from($arg, \"${ntype}\")) {
200 IV tmp = SvIV(getInnerObject($arg)) ;
201 $var = INT2PTR($type, tmp);
202 }
203 else
204 croak(\"$var is not of type ${ntype}\")
205
206 T_dbtkeydatum
207 if (! isHeapDb(db))
208 {
209 SV* my_sv = $arg ;
210 DBM_ckFilter(my_sv, filter_store_key, \"filter_store_key\");
211 DBT_clear($var) ;
212 SvGETMAGIC($arg) ;
213 if (db->recno_or_queue) {
214 Value = GetRecnoKey(db, SvIV(my_sv)) ;
215 $var.data = & Value;
216 $var.size = (int)sizeof(db_recno_t);
217 }
218 else {
219 STRLEN len;
220 $var.data = SvPV(my_sv, len);
221 $var.size = (int)len;
222 }
223 }
224 else
225 {
226 SvGETMAGIC($arg) ;
227 SvUPGRADE($arg, SVt_PV); SvOOK_off($arg); SvPOK_only($arg);
228 /* SvPOK_only($arg); */
229 SvGROW($arg, DB_HEAP_RID_SZ);
230 DBT_clear($var) ;
231 $var.data = SvPVX($arg);
232 $var.size = DB_HEAP_RID_SZ;
233 }
234
235 T_dbtkeydatum_seq
236 InputKey_seq($arg, $var)
237
238
239 T_dbtkeydatum_btree
240 {
241 SV* my_sv = $arg ;
242 if (! isHeapDb(db))
243 DBM_ckFilter(my_sv, filter_store_key, \"filter_store_key\");
244 DBT_clear($var) ;
245 SvGETMAGIC($arg) ;
246 if (db->recno_or_queue ||
247 (db->type == DB_BTREE && flagSet(DB_SET_RECNO))) {
248 Value = GetRecnoKey(db, SvIV(my_sv)) ;
249 $var.data = & Value;
250 $var.size = (int)sizeof(db_recno_t);
251 }
252 else {
253 STRLEN len;
254 $var.data = SvPV(my_sv, len);
255 $var.size = (int)len;
256 }
257 }
258
259 T_dbtkeydatum_btree_r
260 {
261 SV* my_sv = $arg ;
262 DBM_ckFilter(my_sv, filter_store_key, \"filter_store_key\");
263 DBT_clear($var) ;
264 SvGETMAGIC($arg) ;
265 if (db->recno_or_queue ||
266 (db->type == DB_BTREE && flagSet(DB_SET_RECNO))) {
267 Value = GetRecnoKey(db, SvIV(my_sv)) ;
268 $var.data = & Value;
269 $var.size = (int)sizeof(db_recno_t);
270 }
271 else {
272 STRLEN len;
273 $var.data = SvPV(my_sv, len);
274 $var.size = (int)len;
275 }
276 }
277
278 T_dbtkeydatum_btree_pr
279 {
280 if(flagSet(DB_GET_BOTH))
281 {
282 SV* my_sv = $arg ;
283 DBM_ckFilter(my_sv, filter_store_key, \"filter_store_key\");
284 DBT_clear($var) ;
285 SvGETMAGIC($arg) ;
286 if (db->recno_or_queue ||
287 (db->type == DB_BTREE && flagSet(DB_SET_RECNO))) {
288 Value = GetRecnoKey(db, SvIV(my_sv)) ;
289 $var.data = & Value;
290 $var.size = (int)sizeof(db_recno_t);
291 }
292 else {
293 STRLEN len;
294 $var.data = SvPV(my_sv, len);
295 $var.size = (int)len;
296 }
297 }
298 else
299 {
300 DBT_clear($var) ;
301 }
302 }
303
304 T_dbtdatum
305 {
306 SV* my_sv = $arg ;
307 STRLEN len;
308 DBM_ckFilter(my_sv, filter_store_value, \"filter_store_value\");
309 DBT_clear($var) ;
310 SvGETMAGIC($arg) ;
311 $var.data = SvPV(my_sv, len);
312 $var.size = (int)len;
313 $var.flags = db->partial ;
314 $var.dlen = db->dlen ;
315 $var.doff = db->doff ;
316 }
317
318 T_dbtdatum_opt
319 DBT_clear($var) ;
320 if (flagSetBoth()) {
321 SV* my_sv = $arg ;
322 STRLEN len;
323 DBM_ckFilter(my_sv, filter_store_value, \"filter_store_value\");
324 SvGETMAGIC($arg) ;
325 $var.data = SvPV(my_sv, len);
326 $var.size = (int)len;
327 $var.flags = db->partial ;
328 $var.dlen = db->dlen ;
329 $var.doff = db->doff ;
330 }
331
332 T_dbtdatum_btree
333 DBT_clear($var) ;
334 if (flagSetBoth()) {
335 SV* my_sv = $arg ;
336 STRLEN len;
337 DBM_ckFilter(my_sv, filter_store_value, \"filter_store_value\");
338 SvGETMAGIC($arg) ;
339 $var.data = SvPV(my_sv, len);
340 $var.size = (int)len;
341 $var.flags = db->partial ;
342 $var.dlen = db->dlen ;
343 $var.doff = db->doff ;
344 }
345
346
347 OUTPUT
348
349 T_SV_NULL
350 $arg = $var;
351
352 T_RAW
353 sv_setiv($arg, PTR2IV($var));
354
355 T_SV_REF_NULL
356 sv_setiv($arg, PTR2IV($var));
357
358 T_HV_REF_NULL
359 sv_setiv($arg, PTR2IV($var));
360
361 T_HV_REF
362 sv_setiv($arg, PTR2IV($var));
363
364 T_P_REF
365 sv_setiv($arg, PTR2IV($var));
366
367 T_DUAL
368 setDUALerrno($arg, $var) ;
369
370 T_U_INT
371 sv_setuv($arg, (UV)$var);
372
373 T_INT
374 sv_setiv($arg, (UV)$var);
375
376 T_PV_NULL
377 sv_setpv((SV*)$arg, $var);
378
379 T_PV_64
380 sv_setpvn((SV*)$arg, (char*)&$var, sizeof(db_seq_t));
381
382 T_dbtkeydatum_btree
383 OutputKey_B($arg, $var)
384 T_dbtkeydatum_btree_r
385 OutputKey_Br($arg, $var)
386 T_dbtkeydatum_btree_pr
387 OutputKey_Bpr($arg, $var)
388 T_dbtkeydatum_seq
389 OutputKey_seq($arg, $var)
390 T_dbtkeydatum
391 OutputKey($arg, $var)
392 T_dbtdatum
393 OutputValue($arg, $var)
394 T_dbtdatum_opt
395 OutputValue($arg, $var)
396 T_dbtdatum_btree
397 OutputValue_B($arg, $var)
398
399 T_PTROBJ_NULL
400 sv_setref_pv($arg, \"${ntype}\", (void*)$var);
401
402 T_PTROBJ_SELF
403 sv_setref_pv($arg, self, (void*)$var);