Debian Codegraph @

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