a1a90aaf |
1 | # ---?--- |
2 | # |
3 | # $Id$ |
4 | # |
5 | # Field abstraction |
6 | # |
7 | # (c) 2001 Straylight/Edgeware |
8 | # |
9 | |
10 | #----- Licensing notice ----------------------------------------------------- |
11 | # |
12 | # This file is part of the Perl interface to Catacomb. |
13 | # |
14 | # Catacomb/Perl is free software; you can redistribute it and/or modify |
15 | # it under the terms of the GNU General Public License as published by |
16 | # the Free Software Foundation; either version 2 of the License, or |
17 | # (at your option) any later version. |
18 | # |
19 | # Catacomb/Perl is distributed in the hope that it will be useful, |
20 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
21 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
22 | # GNU General Public License for more details. |
23 | # |
24 | # You should have received a copy of the GNU General Public License |
25 | # along with Catacomb/Perl; if not, write to the Free Software Foundation, |
26 | # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
27 | |
28 | MODULE = Catacomb PACKAGE = Catacomb::Field PREFIX = field_ |
29 | |
30 | Field * |
31 | field_prime(me, p) |
32 | SV *me |
33 | mp *p |
34 | C_ARGS: |
35 | p |
36 | |
37 | Field * |
38 | field_niceprime(me, p) |
39 | SV *me |
40 | mp *p |
41 | C_ARGS: |
42 | p |
43 | |
44 | Field * |
45 | field_binpoly(me, p) |
46 | SV *me |
47 | gf *p |
48 | C_ARGS: |
49 | p |
50 | |
51 | Field * |
52 | field_binnorm(me, p, beta) |
53 | SV *me |
54 | gf *p |
55 | gf *beta |
56 | C_ARGS: |
57 | p, beta |
58 | |
59 | Field * |
60 | byname(me, str) |
61 | SV *me |
62 | char *str |
63 | PREINIT: |
64 | qd_parse qd; |
65 | CODE: |
66 | qd.e = 0; |
67 | qd.p = str; |
68 | if ((RETVAL = field_parse(&qd)) == 0) |
69 | croak("bad field spec: %s", qd.e); |
70 | else if (!qd_eofp(&qd)) { |
71 | F_DESTROY(RETVAL); |
72 | croak("junk at end of field spec"); |
73 | } |
74 | OUTPUT: |
75 | RETVAL |
76 | |
77 | SV * |
78 | DESTROY(f) |
79 | Field *f |
80 | CODE: |
81 | F_DESTROY(f); |
82 | XSRETURN_YES; |
83 | |
84 | char * |
85 | name(f) |
86 | Field *f |
87 | CODE: |
88 | RETVAL = (char *)F_NAME(f); |
89 | OUTPUT: |
90 | RETVAL |
91 | |
92 | UV |
93 | type(f) |
94 | Field *f |
95 | CODE: |
96 | RETVAL = F_TYPE(f); |
97 | OUTPUT: |
98 | RETVAL |
99 | |
100 | mp * |
101 | zero(f) |
102 | Field *f |
103 | CODE: |
104 | RETVAL = MP_COPY(f->zero); |
105 | OUTPUT: |
106 | RETVAL |
107 | |
108 | mp * |
109 | one(f) |
110 | Field *f |
111 | CODE: |
112 | RETVAL = MP_COPY(f->one); |
113 | OUTPUT: |
114 | RETVAL |
115 | |
116 | mp * |
117 | m(f) |
118 | Field *f |
119 | CODE: |
120 | RETVAL = MP_COPY(f->m); |
121 | OUTPUT: |
122 | RETVAL |
123 | |
124 | UV |
125 | nbits(f) |
126 | Field *f |
127 | CODE: |
128 | RETVAL = f->nbits; |
129 | OUTPUT: |
130 | RETVAL |
131 | |
132 | UV |
133 | noctets(f) |
134 | Field *f |
135 | CODE: |
136 | RETVAL = f->noctets; |
137 | OUTPUT: |
138 | RETVAL |
139 | |
140 | mp * |
141 | rand(f, r = &rand_global) |
142 | Field *f |
143 | grand *r |
144 | CODE: |
145 | RETVAL = F_RAND(f, MP_NEW, r); |
146 | OUTPUT: |
147 | RETVAL |
148 | |
149 | bool |
150 | samep(f, ff) |
151 | Field *f |
152 | Field *ff |
153 | CODE: |
154 | RETVAL = F_SAMEP(f, ff); |
155 | OUTPUT: |
156 | RETVAL |
157 | |
158 | mp * |
159 | in(f, x) |
160 | Field *f |
161 | mp *x |
162 | CODE: |
163 | RETVAL = F_IN(f, MP_NEW, x); |
164 | OUTPUT: |
165 | RETVAL |
166 | |
167 | mp * |
168 | out(f, x) |
169 | Field *f |
170 | mp *x |
171 | CODE: |
172 | RETVAL = F_OUT(f, MP_NEW, x); |
173 | OUTPUT: |
174 | RETVAL |
175 | |
176 | bool |
177 | zerop(f, x) |
178 | Field *f |
179 | mp *x |
180 | CODE: |
181 | RETVAL = F_ZEROP(f, x); |
182 | OUTPUT: |
183 | RETVAL |
184 | |
185 | mp * |
186 | neg(f, x) |
187 | Field *f |
188 | mp *x |
189 | CODE: |
190 | RETVAL = F_NEG(f, MP_NEW, x); |
191 | OUTPUT: |
192 | RETVAL |
193 | |
194 | mp * |
195 | add(f, x, y) |
196 | Field *f |
197 | mp *x |
198 | mp *y |
199 | CODE: |
200 | RETVAL = F_ADD(f, MP_NEW, x, y); |
201 | OUTPUT: |
202 | RETVAL |
203 | |
204 | mp * |
205 | sub(f, x, y) |
206 | Field *f |
207 | mp *x |
208 | mp *y |
209 | CODE: |
210 | RETVAL = F_SUB(f, MP_NEW, x, y); |
211 | OUTPUT: |
212 | RETVAL |
213 | |
214 | mp * |
215 | mul(f, x, y) |
216 | Field *f |
217 | mp *x |
218 | mp *y |
219 | CODE: |
220 | RETVAL = F_MUL(f, MP_NEW, x, y); |
221 | OUTPUT: |
222 | RETVAL |
223 | |
224 | mp * |
225 | sqr(f, x) |
226 | Field *f |
227 | mp *x |
228 | CODE: |
229 | RETVAL = F_SQR(f, MP_NEW, x); |
230 | OUTPUT: |
231 | RETVAL |
232 | |
233 | mp * |
234 | inv(f, x) |
235 | Field *f |
236 | mp *x |
237 | CODE: |
238 | RETVAL = F_INV(f, MP_NEW, x); |
239 | OUTPUT: |
240 | RETVAL |
241 | |
242 | mp * |
243 | reduce(f, x) |
244 | Field *f |
245 | mp *x |
246 | CODE: |
247 | RETVAL = F_REDUCE(f, MP_NEW, x); |
248 | OUTPUT: |
249 | RETVAL |
250 | |
251 | mp * |
252 | sqrt(f, x) |
253 | Field *f |
254 | mp *x |
255 | CODE: |
256 | RETVAL = F_SQRT(f, MP_NEW, x); |
257 | OUTPUT: |
258 | RETVAL |
259 | |
260 | mp * |
261 | quadsolve(f, x) |
262 | Field *f |
263 | mp *x |
264 | CODE: |
265 | if (F_TYPE(f) != FTY_BINARY) |
266 | croak("quadsolve only works on binary fields"); |
267 | RETVAL = F_QUADSOLVE(f, MP_NEW, x); |
268 | OUTPUT: |
269 | RETVAL |
270 | |
271 | mp * |
272 | dbl(f, x) |
273 | Field *f |
274 | mp *x |
275 | CODE: |
276 | if (F_TYPE(f) != FTY_PRIME) |
277 | croak("dbl only works on prime fields"); |
278 | RETVAL = F_DBL(f, MP_NEW, x); |
279 | OUTPUT: |
280 | RETVAL |
281 | |
282 | mp * |
283 | tpl(f, x) |
284 | Field *f |
285 | mp *x |
286 | CODE: |
287 | if (F_TYPE(f) != FTY_PRIME) |
288 | croak("tpl only works on prime fields"); |
289 | RETVAL = F_TPL(f, MP_NEW, x); |
290 | OUTPUT: |
291 | RETVAL |
292 | |
293 | mp * |
294 | qdl(f, x) |
295 | Field *f |
296 | mp *x |
297 | CODE: |
298 | if (F_TYPE(f) != FTY_PRIME) |
299 | croak("qdl only works on prime fields"); |
300 | RETVAL = F_QDL(f, MP_NEW, x); |
301 | OUTPUT: |
302 | RETVAL |
303 | |
304 | mp * |
305 | hlv(f, x) |
306 | Field *f |
307 | mp *x |
308 | CODE: |
309 | if (F_TYPE(f) != FTY_PRIME) |
310 | croak("hlv only works on prime fields"); |
311 | RETVAL = F_HLV(f, MP_NEW, x); |
312 | OUTPUT: |
313 | RETVAL |
314 | |