chiark / gitweb /
math/group-parse.c (group-parse): Parse binary-group descriptions.
[catacomb] / math / mp-io.c
CommitLineData
d3409d5e 1/* -*-c-*-
d3409d5e 2 *
3 * Loading and storing of multiprecision integers
4 *
5 * (c) 1999 Straylight/Edgeware
6 */
7
45c0fd36 8/*----- Licensing notice --------------------------------------------------*
d3409d5e 9 *
10 * This file is part of Catacomb.
11 *
12 * Catacomb is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU Library General Public License as
14 * published by the Free Software Foundation; either version 2 of the
15 * License, or (at your option) any later version.
45c0fd36 16 *
d3409d5e 17 * Catacomb is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU Library General Public License for more details.
45c0fd36 21 *
d3409d5e 22 * You should have received a copy of the GNU Library General Public
23 * License along with Catacomb; if not, write to the Free
24 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
25 * MA 02111-1307, USA.
26 */
27
d3409d5e 28/*----- Header files ------------------------------------------------------*/
29
30#include "mp.h"
31
32/*----- Main code ---------------------------------------------------------*/
33
34/* --- @mp_octets@ --- *
35 *
36 * Arguments: @const mp *m@ = a multiprecision integer
37 *
38 * Returns: The number of octets required to represent @m@.
39 *
40 * Use: Calculates the external storage required for a multiprecision
41 * integer.
42 */
43
44size_t mp_octets(const mp *m)
45{
46 size_t sz;
47 MPX_OCTETS(sz, m->v, m->vl);
48 return (sz);
49}
50
f09e814a 51/* --- @mp_octets2c@ --- *
52 *
53 * Arguments: @const mp *m@ = a multiprecision integer
54 *
55 * Returns: The number of octets required to represent @m@.
56 *
57 * Use: Calculates the external storage required for a multiprecision
58 * integer represented as two's complement.
59 */
60
61size_t mp_octets2c(const mp *m)
62{
63 size_t sz;
64 MPX_OCTETS2C(sz, m->v, m->vl);
65 return (sz);
66}
67
24e1e862 68/* --- @mp_bits@ --- *
69 *
70 * Arguments: @const mp *m@ = a multiprecision integer
71 *
72 * Returns: The number of bits required to represent @m@.
73 *
74 * Use: Calculates the external storage required for a multiprecision
75 * integer.
76 */
77
78unsigned long mp_bits(const mp *m)
79{
80 unsigned long bits;
81 MPX_BITS(bits, m->v, m->vl);
82 return (bits);
83}
84
d3409d5e 85/* --- @mp_loadl@ --- *
86 *
87 * Arguments: @mp *d@ = destination
88 * @const void *pv@ = pointer to source data
89 * @size_t sz@ = size of the source data
90 *
91 * Returns: Resulting multiprecision number.
92 *
93 * Use: Loads a multiprecision number from an array of octets. The
94 * first byte in the array is the least significant. More
95 * formally, if the bytes are %$b_0, b_1, \ldots, b_{n-1}$%
96 * then the result is %$N = \sum_{0 \le i < n} b_i 2^{8i}$%.
97 */
98
99mp *mp_loadl(mp *d, const void *pv, size_t sz)
100{
d34decd2 101 MP_DEST(d, MPW_RQ(sz), MP_UNDEF);
d3409d5e 102 mpx_loadl(d->v, d->vl, pv, sz);
8857f8eb 103 d->f &= ~(MP_UNDEF | MP_NEG);
d3409d5e 104 mp_shrink(d);
105 return (d);
106}
107
108/* --- @mp_storel@ --- *
109 *
110 * Arguments: @const mp *m@ = source
111 * @void *pv@ = pointer to output array
112 * @size_t sz@ = size of the output array
113 *
114 * Returns: ---
115 *
116 * Use: Stores a multiprecision number in an array of octets. The
117 * first byte in the array is the least significant. If the
118 * array is too small to represent the number, high-order bits
119 * are truncated; if the array is too large, high order bytes
120 * are filled with zeros. More formally, if the number is
121 * %$N = \sum{0 \le i} b_i 2^{8i}$% where %$0 \le b_i < 256$%,
122 * then the array is %$b_0, b_1, \ldots, b_{n-1}$%.
123 */
124
125void mp_storel(const mp *m, void *pv, size_t sz)
126{
127 mpx_storel(m->v, m->vl, pv, sz);
128}
129
130/* --- @mp_loadb@ --- *
131 *
132 * Arguments: @mp *d@ = destination
133 * @const void *pv@ = pointer to source data
134 * @size_t sz@ = size of the source data
135 *
136 * Returns: Resulting multiprecision number.
137 *
138 * Use: Loads a multiprecision number from an array of octets. The
139 * last byte in the array is the least significant. More
140 * formally, if the bytes are %$b_{n-1}, b_{n-2}, \ldots, b_0$%
141 * then the result is %$N = \sum_{0 \le i < n} b_i 2^{8i}$%.
142 */
143
144mp *mp_loadb(mp *d, const void *pv, size_t sz)
145{
d34decd2 146 MP_DEST(d, MPW_RQ(sz), MP_UNDEF);
d3409d5e 147 mpx_loadb(d->v, d->vl, pv, sz);
8857f8eb 148 d->f &= ~(MP_UNDEF | MP_NEG);
d3409d5e 149 mp_shrink(d);
150 return (d);
151}
152
153/* --- @mp_storeb@ --- *
154 *
155 * Arguments: @const mp *m@ = source
156 * @void *pv@ = pointer to output array
157 * @size_t sz@ = size of the output array
158 *
159 * Returns: ---
160 *
161 * Use: Stores a multiprecision number in an array of octets. The
162 * last byte in the array is the least significant. If the
163 * array is too small to represent the number, high-order bits
164 * are truncated; if the array is too large, high order bytes
165 * are filled with zeros. More formally, if the number is
166 * %$N = \sum{0 \le i} b_i 2^{8i}$% where %$0 \le b_i < 256$%,
167 * then the array is %$b_{n-1}, b_{n-2}, \ldots, b_0$%.
168 */
169
170void mp_storeb(const mp *m, void *pv, size_t sz)
171{
172 mpx_storeb(m->v, m->vl, pv, sz);
173}
174
f09e814a 175/* --- @mp_loadl2c@ --- *
176 *
177 * Arguments: @mp *d@ = destination
178 * @const void *pv@ = pointer to source data
179 * @size_t sz@ = size of the source data
180 *
181 * Returns: Resulting multiprecision number.
182 *
183 * Use: Loads a multiprecision number from an array of octets as
184 * two's complement. The first byte in the array is the least
185 * significant.
186 */
187
188mp *mp_loadl2c(mp *d, const void *pv, size_t sz)
189{
190 const octet *ov = pv;
191 MP_DEST(d, MPW_RQ(sz), MP_UNDEF);
192 if (!sz || !(ov[sz - 1] & 0x80)) {
193 mpx_loadl(d->v, d->vl, pv, sz);
194 d->f &= ~MP_NEG;
195 } else {
196 mpx_loadl2cn(d->v, d->vl, pv, sz);
197 d->f |= MP_NEG;
198 }
199 d->f &= ~MP_UNDEF;
200 mp_shrink(d);
201 return (d);
202}
203
204/* --- @mp_storel2c@ --- *
205 *
206 * Arguments: @const mp *m@ = source
207 * @void *pv@ = pointer to output array
208 * @size_t sz@ = size of the output array
209 *
210 * Returns: ---
211 *
212 * Use: Stores a multiprecision number in an array of octets as two's
213 * complement. The first byte in the array is the least
214 * significant. If the array is too small to represent the
215 * number, high-order bits are truncated; if the array is too
216 * large, high order bytes are sign-extended.
217 */
218
219void mp_storel2c(const mp *m, void *pv, size_t sz)
220{
a69a3efd 221 if (MP_NEGP(m))
f09e814a 222 mpx_storel2cn(m->v, m->vl, pv, sz);
223 else
224 mpx_storel(m->v, m->vl, pv, sz);
225}
226
227/* --- @mp_loadb2c@ --- *
228 *
229 * Arguments: @mp *d@ = destination
230 * @const void *pv@ = pointer to source data
231 * @size_t sz@ = size of the source data
232 *
233 * Returns: Resulting multiprecision number.
234 *
235 * Use: Loads a multiprecision number from an array of octets as
236 * two's complement. The last byte in the array is the least
237 * significant.
238 */
239
240mp *mp_loadb2c(mp *d, const void *pv, size_t sz)
241{
242 const octet *ov = pv;
243 MP_DEST(d, MPW_RQ(sz), MP_UNDEF);
244 if (!sz || !(ov[0] & 0x80)) {
2bd53494 245 mpx_loadb(d->v, d->vl, pv, sz);
f09e814a 246 d->f &= ~MP_NEG;
247 } else {
2bd53494 248 mpx_loadb2cn(d->v, d->vl, pv, sz);
f09e814a 249 d->f |= MP_NEG;
250 }
251 d->f &= ~MP_UNDEF;
252 mp_shrink(d);
253 return (d);
254}
255
256/* --- @mp_storeb2c@ --- *
257 *
258 * Arguments: @const mp *m@ = source
259 * @void *pv@ = pointer to output array
260 * @size_t sz@ = size of the output array
261 *
262 * Returns: ---
263 *
264 * Use: Stores a multiprecision number in an array of octets, as
265 * two's complement. The last byte in the array is the least
266 * significant. If the array is too small to represent the
267 * number, high-order bits are truncated; if the array is too
268 * large, high order bytes are sign-extended.
269 */
270
271void mp_storeb2c(const mp *m, void *pv, size_t sz)
272{
a69a3efd 273 if (MP_NEGP(m))
f09e814a 274 mpx_storeb2cn(m->v, m->vl, pv, sz);
275 else
276 mpx_storeb(m->v, m->vl, pv, sz);
277}
278
d3409d5e 279/*----- That's all, folks -------------------------------------------------*/