decnumber_sys/
lib.rs

Help
1// Copyright Materialize, Inc. All rights reserved.
2//
3// This software is made available under the terms of the
4// ICU license -- ICU 1.8.1 and later.
5
6#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7
8//! Bindings to libdecnumber.
9//!
10//! This crate provides raw bindings to [libdecnumber], an implementation of the
11//! [General Decimal Arithmetic][gda] specification.
12//!
13//! This crate bundles the latest release of libdecnumber, v3.68.
14//!
15//! [gda]: http://speleotrove.com/decimal/
16//! [libdecnumber]: http://speleotrove.com/decimal/
17
18use libc::{c_char, c_uint};
19
20pub type rounding = c_uint;
21pub const DEC_ROUND_CEILING: rounding = 0;
22pub const DEC_ROUND_UP: rounding = 1;
23pub const DEC_ROUND_HALF_UP: rounding = 2;
24pub const DEC_ROUND_HALF_EVEN: rounding = 3;
25pub const DEC_ROUND_HALF_DOWN: rounding = 4;
26pub const DEC_ROUND_DOWN: rounding = 5;
27pub const DEC_ROUND_FLOOR: rounding = 6;
28pub const DEC_ROUND_05UP: rounding = 7;
29pub const DEC_ROUND_MAX: rounding = 8;
30
31pub type decClass = c_uint;
32pub const DEC_CLASS_SNAN: decClass = 0;
33pub const DEC_CLASS_QNAN: decClass = 1;
34pub const DEC_CLASS_NEG_INF: decClass = 2;
35pub const DEC_CLASS_NEG_NORMAL: decClass = 3;
36pub const DEC_CLASS_NEG_SUBNORMAL: decClass = 4;
37pub const DEC_CLASS_NEG_ZERO: decClass = 5;
38pub const DEC_CLASS_POS_ZERO: decClass = 6;
39pub const DEC_CLASS_POS_SUBNORMAL: decClass = 7;
40pub const DEC_CLASS_POS_NORMAL: decClass = 8;
41pub const DEC_CLASS_POS_INF: decClass = 9;
42
43pub const DEC_INIT_BASE: i32 = 0;
44pub const DEC_INIT_DECIMAL32: i32 = 32;
45pub const DEC_INIT_DECIMAL64: i32 = 64;
46pub const DEC_INIT_DECSINGLE: i32 = 32;
47pub const DEC_INIT_DECIMAL128: i32 = 128;
48pub const DEC_INIT_DECDOUBLE: i32 = 64;
49pub const DEC_INIT_DECQUAD: i32 = 128;
50
51pub const DEC_Conversion_syntax: u32 = 0x00000001;
52pub const DEC_Division_by_zero: u32 = 0x00000002;
53pub const DEC_Division_impossible: u32 = 0x00000004;
54pub const DEC_Division_undefined: u32 = 0x00000008;
55pub const DEC_Insufficient_storage: u32 = 0x00000010;
56pub const DEC_Inexact: u32 = 0x00000020;
57pub const DEC_Invalid_context: u32 = 0x00000040;
58pub const DEC_Invalid_operation: u32 = 0x00000080;
59pub const DEC_Overflow: u32 = 0x00000200;
60pub const DEC_Clamped: u32 = 0x00000400;
61pub const DEC_Rounded: u32 = 0x00000800;
62pub const DEC_Subnormal: u32 = 0x00001000;
63pub const DEC_Underflow: u32 = 0x00002000;
64
65#[repr(C)]
66#[derive(Debug, Copy, Clone)]
67pub struct decContext {
68    pub digits: i32,
69    pub emax: i32,
70    pub emin: i32,
71    pub round: rounding,
72    pub traps: u32,
73    pub status: u32,
74    pub clamp: u8,
75}
76
77extern "C" {
78    pub fn decContextClearStatus(arg1: *mut decContext, arg2: u32) -> *mut decContext;
79    pub fn decContextDefault(arg1: *mut decContext, arg2: i32) -> *mut decContext;
80    pub fn decContextGetRounding(arg1: *mut decContext) -> rounding;
81    pub fn decContextGetStatus(arg1: *mut decContext) -> u32;
82    pub fn decContextRestoreStatus(arg1: *mut decContext, arg2: u32, arg3: u32) -> *mut decContext;
83    pub fn decContextSaveStatus(arg1: *mut decContext, arg2: u32) -> u32;
84    pub fn decContextSetRounding(arg1: *mut decContext, arg2: rounding) -> *mut decContext;
85    pub fn decContextSetStatus(arg1: *mut decContext, arg2: u32) -> *mut decContext;
86    pub fn decContextSetStatusFromString(
87        arg1: *mut decContext,
88        arg2: *const c_char,
89    ) -> *mut decContext;
90    pub fn decContextSetStatusFromStringQuiet(
91        arg1: *mut decContext,
92        arg2: *const c_char,
93    ) -> *mut decContext;
94    pub fn decContextSetStatusQuiet(arg1: *mut decContext, arg2: u32) -> *mut decContext;
95    pub fn decContextStatusToString(arg1: *const decContext) -> *const c_char;
96    pub fn decContextTestEndian(arg1: u8) -> i32;
97    pub fn decContextTestSavedStatus(arg1: u32, arg2: u32) -> u32;
98    pub fn decContextTestStatus(arg1: *mut decContext, arg2: u32) -> u32;
99    pub fn decContextZeroStatus(arg1: *mut decContext) -> *mut decContext;
100}
101
102pub const DECNEG: u8 = 0x80;
103pub const DECINF: u8 = 0x40;
104pub const DECNAN: u8 = 0x20;
105pub const DECSNAN: u8 = 0x10;
106pub const DECSPECIAL: u8 = DECINF | DECNAN | DECSNAN;
107
108pub const DECDPUN: usize = 3;
109
110#[repr(C)]
111#[derive(Debug, Copy, Clone, Default)]
112pub struct decNumber {
113    pub digits: i32,
114    pub exponent: i32,
115    pub bits: u8,
116    pub lsu: [u16; 12usize],
117}
118
119extern "C" {
120    pub fn decNumberFromInt32(arg1: *mut decNumber, arg2: i32) -> *mut decNumber;
121    pub fn decNumberFromUInt32(arg1: *mut decNumber, arg2: u32) -> *mut decNumber;
122    pub fn decNumberFromString(
123        arg1: *mut decNumber,
124        arg2: *const c_char,
125        arg3: *mut decContext,
126    ) -> *mut decNumber;
127    pub fn decNumberToString(arg1: *const decNumber, arg2: *mut c_char) -> *mut c_char;
128    pub fn decNumberToEngString(arg1: *const decNumber, arg2: *mut c_char) -> *mut c_char;
129    pub fn decNumberToUInt32(arg1: *const decNumber, arg2: *mut decContext) -> u32;
130    pub fn decNumberToInt32(arg1: *const decNumber, arg2: *mut decContext) -> i32;
131    pub fn decNumberGetBCD(arg1: *const decNumber, arg2: *mut u8) -> *mut u8;
132    pub fn decNumberSetBCD(arg1: *mut decNumber, arg2: *const u8, arg3: u32) -> *mut decNumber;
133    pub fn decNumberAbs(
134        arg1: *mut decNumber,
135        arg2: *const decNumber,
136        arg3: *mut decContext,
137    ) -> *mut decNumber;
138    pub fn decNumberAdd(
139        arg1: *mut decNumber,
140        arg2: *const decNumber,
141        arg3: *const decNumber,
142        arg4: *mut decContext,
143    ) -> *mut decNumber;
144    pub fn decNumberAnd(
145        arg1: *mut decNumber,
146        arg2: *const decNumber,
147        arg3: *const decNumber,
148        arg4: *mut decContext,
149    ) -> *mut decNumber;
150    pub fn decNumberCompare(
151        arg1: *mut decNumber,
152        arg2: *const decNumber,
153        arg3: *const decNumber,
154        arg4: *mut decContext,
155    ) -> *mut decNumber;
156    pub fn decNumberCompareSignal(
157        arg1: *mut decNumber,
158        arg2: *const decNumber,
159        arg3: *const decNumber,
160        arg4: *mut decContext,
161    ) -> *mut decNumber;
162    pub fn decNumberCompareTotal(
163        arg1: *mut decNumber,
164        arg2: *const decNumber,
165        arg3: *const decNumber,
166        arg4: *mut decContext,
167    ) -> *mut decNumber;
168    pub fn decNumberCompareTotalMag(
169        arg1: *mut decNumber,
170        arg2: *const decNumber,
171        arg3: *const decNumber,
172        arg4: *mut decContext,
173    ) -> *mut decNumber;
174    pub fn decNumberDivide(
175        arg1: *mut decNumber,
176        arg2: *const decNumber,
177        arg3: *const decNumber,
178        arg4: *mut decContext,
179    ) -> *mut decNumber;
180    pub fn decNumberDivideInteger(
181        arg1: *mut decNumber,
182        arg2: *const decNumber,
183        arg3: *const decNumber,
184        arg4: *mut decContext,
185    ) -> *mut decNumber;
186    pub fn decNumberExp(
187        arg1: *mut decNumber,
188        arg2: *const decNumber,
189        arg3: *mut decContext,
190    ) -> *mut decNumber;
191    pub fn decNumberFMA(
192        arg1: *mut decNumber,
193        arg2: *const decNumber,
194        arg3: *const decNumber,
195        arg4: *const decNumber,
196        arg5: *mut decContext,
197    ) -> *mut decNumber;
198    pub fn decNumberInvert(
199        arg1: *mut decNumber,
200        arg2: *const decNumber,
201        arg3: *mut decContext,
202    ) -> *mut decNumber;
203    pub fn decNumberLn(
204        arg1: *mut decNumber,
205        arg2: *const decNumber,
206        arg3: *mut decContext,
207    ) -> *mut decNumber;
208    pub fn decNumberLogB(
209        arg1: *mut decNumber,
210        arg2: *const decNumber,
211        arg3: *mut decContext,
212    ) -> *mut decNumber;
213    pub fn decNumberLog10(
214        arg1: *mut decNumber,
215        arg2: *const decNumber,
216        arg3: *mut decContext,
217    ) -> *mut decNumber;
218    pub fn decNumberMax(
219        arg1: *mut decNumber,
220        arg2: *const decNumber,
221        arg3: *const decNumber,
222        arg4: *mut decContext,
223    ) -> *mut decNumber;
224    pub fn decNumberMaxMag(
225        arg1: *mut decNumber,
226        arg2: *const decNumber,
227        arg3: *const decNumber,
228        arg4: *mut decContext,
229    ) -> *mut decNumber;
230    pub fn decNumberMin(
231        arg1: *mut decNumber,
232        arg2: *const decNumber,
233        arg3: *const decNumber,
234        arg4: *mut decContext,
235    ) -> *mut decNumber;
236    pub fn decNumberMinMag(
237        arg1: *mut decNumber,
238        arg2: *const decNumber,
239        arg3: *const decNumber,
240        arg4: *mut decContext,
241    ) -> *mut decNumber;
242    pub fn decNumberMinus(
243        arg1: *mut decNumber,
244        arg2: *const decNumber,
245        arg3: *mut decContext,
246    ) -> *mut decNumber;
247    pub fn decNumberMultiply(
248        arg1: *mut decNumber,
249        arg2: *const decNumber,
250        arg3: *const decNumber,
251        arg4: *mut decContext,
252    ) -> *mut decNumber;
253    pub fn decNumberNormalize(
254        arg1: *mut decNumber,
255        arg2: *const decNumber,
256        arg3: *mut decContext,
257    ) -> *mut decNumber;
258    pub fn decNumberOr(
259        arg1: *mut decNumber,
260        arg2: *const decNumber,
261        arg3: *const decNumber,
262        arg4: *mut decContext,
263    ) -> *mut decNumber;
264    pub fn decNumberPlus(
265        arg1: *mut decNumber,
266        arg2: *const decNumber,
267        arg3: *mut decContext,
268    ) -> *mut decNumber;
269    pub fn decNumberPower(
270        arg1: *mut decNumber,
271        arg2: *const decNumber,
272        arg3: *const decNumber,
273        arg4: *mut decContext,
274    ) -> *mut decNumber;
275    pub fn decNumberQuantize(
276        arg1: *mut decNumber,
277        arg2: *const decNumber,
278        arg3: *const decNumber,
279        arg4: *mut decContext,
280    ) -> *mut decNumber;
281    pub fn decNumberReduce(
282        arg1: *mut decNumber,
283        arg2: *const decNumber,
284        arg3: *mut decContext,
285    ) -> *mut decNumber;
286    pub fn decNumberRemainder(
287        arg1: *mut decNumber,
288        arg2: *const decNumber,
289        arg3: *const decNumber,
290        arg4: *mut decContext,
291    ) -> *mut decNumber;
292    pub fn decNumberRemainderNear(
293        arg1: *mut decNumber,
294        arg2: *const decNumber,
295        arg3: *const decNumber,
296        arg4: *mut decContext,
297    ) -> *mut decNumber;
298    pub fn decNumberRescale(
299        arg1: *mut decNumber,
300        arg2: *const decNumber,
301        arg3: *const decNumber,
302        arg4: *mut decContext,
303    ) -> *mut decNumber;
304    pub fn decNumberRotate(
305        arg1: *mut decNumber,
306        arg2: *const decNumber,
307        arg3: *const decNumber,
308        arg4: *mut decContext,
309    ) -> *mut decNumber;
310    pub fn decNumberSameQuantum(
311        arg1: *mut decNumber,
312        arg2: *const decNumber,
313        arg3: *const decNumber,
314    ) -> *mut decNumber;
315    pub fn decNumberScaleB(
316        arg1: *mut decNumber,
317        arg2: *const decNumber,
318        arg3: *const decNumber,
319        arg4: *mut decContext,
320    ) -> *mut decNumber;
321    pub fn decNumberShift(
322        arg1: *mut decNumber,
323        arg2: *const decNumber,
324        arg3: *const decNumber,
325        arg4: *mut decContext,
326    ) -> *mut decNumber;
327    pub fn decNumberSquareRoot(
328        arg1: *mut decNumber,
329        arg2: *const decNumber,
330        arg3: *mut decContext,
331    ) -> *mut decNumber;
332    pub fn decNumberSubtract(
333        arg1: *mut decNumber,
334        arg2: *const decNumber,
335        arg3: *const decNumber,
336        arg4: *mut decContext,
337    ) -> *mut decNumber;
338    pub fn decNumberToIntegralExact(
339        arg1: *mut decNumber,
340        arg2: *const decNumber,
341        arg3: *mut decContext,
342    ) -> *mut decNumber;
343    pub fn decNumberToIntegralValue(
344        arg1: *mut decNumber,
345        arg2: *const decNumber,
346        arg3: *mut decContext,
347    ) -> *mut decNumber;
348    pub fn decNumberXor(
349        arg1: *mut decNumber,
350        arg2: *const decNumber,
351        arg3: *const decNumber,
352        arg4: *mut decContext,
353    ) -> *mut decNumber;
354    pub fn decNumberClass(arg1: *const decNumber, arg2: *mut decContext) -> decClass;
355    pub fn decNumberClassToString(arg1: decClass) -> *const c_char;
356    pub fn decNumberCopy(arg1: *mut decNumber, arg2: *const decNumber) -> *mut decNumber;
357    pub fn decNumberCopyAbs(arg1: *mut decNumber, arg2: *const decNumber) -> *mut decNumber;
358    pub fn decNumberCopyNegate(arg1: *mut decNumber, arg2: *const decNumber) -> *mut decNumber;
359    pub fn decNumberCopySign(
360        arg1: *mut decNumber,
361        arg2: *const decNumber,
362        arg3: *const decNumber,
363    ) -> *mut decNumber;
364    pub fn decNumberNextMinus(
365        arg1: *mut decNumber,
366        arg2: *const decNumber,
367        arg3: *mut decContext,
368    ) -> *mut decNumber;
369    pub fn decNumberNextPlus(
370        arg1: *mut decNumber,
371        arg2: *const decNumber,
372        arg3: *mut decContext,
373    ) -> *mut decNumber;
374    pub fn decNumberNextToward(
375        arg1: *mut decNumber,
376        arg2: *const decNumber,
377        arg3: *const decNumber,
378        arg4: *mut decContext,
379    ) -> *mut decNumber;
380    pub fn decNumberTrim(arg1: *mut decNumber) -> *mut decNumber;
381    pub fn decNumberVersion() -> *const c_char;
382    pub fn decNumberZero(arg1: *mut decNumber) -> *mut decNumber;
383    pub fn decNumberIsNormal(arg1: *const decNumber, arg2: *mut decContext) -> i32;
384    pub fn decNumberIsSubnormal(arg1: *const decNumber, arg2: *mut decContext) -> i32;
385}
386
387pub const DECSINGLE_Bytes: usize = 4;
388pub const DECSINGLE_Pmax: usize = 7;
389pub const DECSINGLE_Emin: isize = -95;
390pub const DECSINGLE_Emax: usize = 96;
391pub const DECSINGLE_EmaxD: usize = 3;
392pub const DECSINGLE_Bias: usize = 101;
393pub const DECSINGLE_String: usize = 16;
394pub const DECSINGLE_EconL: usize = 6;
395pub const DECSINGLE_Declets: usize = 2;
396pub const DECSINGLE_Ehigh: usize = DECSINGLE_Emax + DECSINGLE_Bias - (DECSINGLE_Pmax - 1);
397
398pub type decSingle = decimal32;
399
400extern "C" {
401    pub fn decSingleFromBCD(
402        arg1: *mut decSingle,
403        arg2: i32,
404        arg3: *const u8,
405        arg4: i32,
406    ) -> *mut decSingle;
407    pub fn decSingleFromPacked(arg1: *mut decSingle, arg2: i32, arg3: *const u8) -> *mut decSingle;
408    pub fn decSingleFromPackedChecked(
409        arg1: *mut decSingle,
410        arg2: i32,
411        arg3: *const u8,
412    ) -> *mut decSingle;
413    pub fn decSingleFromString(
414        arg1: *mut decSingle,
415        arg2: *const c_char,
416        arg3: *mut decContext,
417    ) -> *mut decSingle;
418    pub fn decSingleFromWider(
419        arg1: *mut decSingle,
420        arg2: *const decDouble,
421        arg3: *mut decContext,
422    ) -> *mut decSingle;
423    pub fn decSingleGetCoefficient(arg1: *const decSingle, arg2: *mut u8) -> i32;
424    pub fn decSingleGetExponent(arg1: *const decSingle) -> i32;
425    pub fn decSingleSetCoefficient(
426        arg1: *mut decSingle,
427        arg2: *const u8,
428        arg3: i32,
429    ) -> *mut decSingle;
430    pub fn decSingleSetExponent(
431        arg1: *mut decSingle,
432        arg2: *mut decContext,
433        arg3: i32,
434    ) -> *mut decSingle;
435    pub fn decSingleShow(arg1: *const decSingle, arg2: *const c_char);
436    pub fn decSingleToBCD(arg1: *const decSingle, arg2: *mut i32, arg3: *mut u8) -> i32;
437    pub fn decSingleToEngString(arg1: *const decSingle, arg2: *mut c_char) -> *mut c_char;
438    pub fn decSingleToPacked(arg1: *const decSingle, arg2: *mut i32, arg3: *mut u8) -> i32;
439    pub fn decSingleToString(arg1: *const decSingle, arg2: *mut c_char) -> *mut c_char;
440    pub fn decSingleToWider(arg1: *const decSingle, arg2: *mut decDouble) -> *mut decDouble;
441    pub fn decSingleZero(arg1: *mut decSingle) -> *mut decSingle;
442    pub fn decSingleRadix(arg1: *const decSingle) -> u32;
443    pub fn decSingleVersion() -> *const c_char;
444}
445
446pub const DECDOUBLE_Bytes: usize = 8;
447pub const DECDOUBLE_Pmax: usize = 16;
448pub const DECDOUBLE_Emin: isize = -383;
449pub const DECDOUBLE_Emax: usize = 384;
450pub const DECDOUBLE_EmaxD: usize = 3;
451pub const DECDOUBLE_Bias: usize = 398;
452pub const DECDOUBLE_String: usize = 25;
453pub const DECDOUBLE_EconL: usize = 8;
454pub const DECDOUBLE_Declets: usize = 5;
455pub const DECDOUBLE_Ehigh: usize = DECDOUBLE_Emax + DECDOUBLE_Bias - (DECDOUBLE_Pmax - 1);
456
457pub type decDouble = decimal64;
458
459extern "C" {
460    pub fn decDoubleFromBCD(
461        arg1: *mut decDouble,
462        arg2: i32,
463        arg3: *const u8,
464        arg4: i32,
465    ) -> *mut decDouble;
466    pub fn decDoubleFromInt32(arg1: *mut decDouble, arg2: i32) -> *mut decDouble;
467    pub fn decDoubleFromPacked(arg1: *mut decDouble, arg2: i32, arg3: *const u8) -> *mut decDouble;
468    pub fn decDoubleFromPackedChecked(
469        arg1: *mut decDouble,
470        arg2: i32,
471        arg3: *const u8,
472    ) -> *mut decDouble;
473    pub fn decDoubleFromString(
474        arg1: *mut decDouble,
475        arg2: *const c_char,
476        arg3: *mut decContext,
477    ) -> *mut decDouble;
478    pub fn decDoubleFromUInt32(arg1: *mut decDouble, arg2: u32) -> *mut decDouble;
479    pub fn decDoubleFromWider(
480        arg1: *mut decDouble,
481        arg2: *const decQuad,
482        arg3: *mut decContext,
483    ) -> *mut decDouble;
484    pub fn decDoubleGetCoefficient(arg1: *const decDouble, arg2: *mut u8) -> i32;
485    pub fn decDoubleGetExponent(arg1: *const decDouble) -> i32;
486    pub fn decDoubleSetCoefficient(
487        arg1: *mut decDouble,
488        arg2: *const u8,
489        arg3: i32,
490    ) -> *mut decDouble;
491    pub fn decDoubleSetExponent(
492        arg1: *mut decDouble,
493        arg2: *mut decContext,
494        arg3: i32,
495    ) -> *mut decDouble;
496    pub fn decDoubleShow(arg1: *const decDouble, arg2: *const c_char);
497    pub fn decDoubleToBCD(arg1: *const decDouble, arg2: *mut i32, arg3: *mut u8) -> i32;
498    pub fn decDoubleToEngString(arg1: *const decDouble, arg2: *mut c_char) -> *mut c_char;
499    pub fn decDoubleToInt32(arg1: *const decDouble, arg2: *mut decContext, arg3: rounding) -> i32;
500    pub fn decDoubleToInt32Exact(
501        arg1: *const decDouble,
502        arg2: *mut decContext,
503        arg3: rounding,
504    ) -> i32;
505    pub fn decDoubleToPacked(arg1: *const decDouble, arg2: *mut i32, arg3: *mut u8) -> i32;
506    pub fn decDoubleToString(arg1: *const decDouble, arg2: *mut c_char) -> *mut c_char;
507    pub fn decDoubleToUInt32(arg1: *const decDouble, arg2: *mut decContext, arg3: rounding) -> u32;
508    pub fn decDoubleToUInt32Exact(
509        arg1: *const decDouble,
510        arg2: *mut decContext,
511        arg3: rounding,
512    ) -> u32;
513    pub fn decDoubleToWider(arg1: *const decDouble, arg2: *mut decQuad) -> *mut decQuad;
514    pub fn decDoubleZero(arg1: *mut decDouble) -> *mut decDouble;
515    pub fn decDoubleAbs(
516        arg1: *mut decDouble,
517        arg2: *const decDouble,
518        arg3: *mut decContext,
519    ) -> *mut decDouble;
520    pub fn decDoubleAdd(
521        arg1: *mut decDouble,
522        arg2: *const decDouble,
523        arg3: *const decDouble,
524        arg4: *mut decContext,
525    ) -> *mut decDouble;
526    pub fn decDoubleAnd(
527        arg1: *mut decDouble,
528        arg2: *const decDouble,
529        arg3: *const decDouble,
530        arg4: *mut decContext,
531    ) -> *mut decDouble;
532    pub fn decDoubleDivide(
533        arg1: *mut decDouble,
534        arg2: *const decDouble,
535        arg3: *const decDouble,
536        arg4: *mut decContext,
537    ) -> *mut decDouble;
538    pub fn decDoubleDivideInteger(
539        arg1: *mut decDouble,
540        arg2: *const decDouble,
541        arg3: *const decDouble,
542        arg4: *mut decContext,
543    ) -> *mut decDouble;
544    pub fn decDoubleFMA(
545        arg1: *mut decDouble,
546        arg2: *const decDouble,
547        arg3: *const decDouble,
548        arg4: *const decDouble,
549        arg5: *mut decContext,
550    ) -> *mut decDouble;
551    pub fn decDoubleInvert(
552        arg1: *mut decDouble,
553        arg2: *const decDouble,
554        arg3: *mut decContext,
555    ) -> *mut decDouble;
556    pub fn decDoubleLogB(
557        arg1: *mut decDouble,
558        arg2: *const decDouble,
559        arg3: *mut decContext,
560    ) -> *mut decDouble;
561    pub fn decDoubleMax(
562        arg1: *mut decDouble,
563        arg2: *const decDouble,
564        arg3: *const decDouble,
565        arg4: *mut decContext,
566    ) -> *mut decDouble;
567    pub fn decDoubleMaxMag(
568        arg1: *mut decDouble,
569        arg2: *const decDouble,
570        arg3: *const decDouble,
571        arg4: *mut decContext,
572    ) -> *mut decDouble;
573    pub fn decDoubleMin(
574        arg1: *mut decDouble,
575        arg2: *const decDouble,
576        arg3: *const decDouble,
577        arg4: *mut decContext,
578    ) -> *mut decDouble;
579    pub fn decDoubleMinMag(
580        arg1: *mut decDouble,
581        arg2: *const decDouble,
582        arg3: *const decDouble,
583        arg4: *mut decContext,
584    ) -> *mut decDouble;
585    pub fn decDoubleMinus(
586        arg1: *mut decDouble,
587        arg2: *const decDouble,
588        arg3: *mut decContext,
589    ) -> *mut decDouble;
590    pub fn decDoubleMultiply(
591        arg1: *mut decDouble,
592        arg2: *const decDouble,
593        arg3: *const decDouble,
594        arg4: *mut decContext,
595    ) -> *mut decDouble;
596    pub fn decDoubleNextMinus(
597        arg1: *mut decDouble,
598        arg2: *const decDouble,
599        arg3: *mut decContext,
600    ) -> *mut decDouble;
601    pub fn decDoubleNextPlus(
602        arg1: *mut decDouble,
603        arg2: *const decDouble,
604        arg3: *mut decContext,
605    ) -> *mut decDouble;
606    pub fn decDoubleNextToward(
607        arg1: *mut decDouble,
608        arg2: *const decDouble,
609        arg3: *const decDouble,
610        arg4: *mut decContext,
611    ) -> *mut decDouble;
612    pub fn decDoubleOr(
613        arg1: *mut decDouble,
614        arg2: *const decDouble,
615        arg3: *const decDouble,
616        arg4: *mut decContext,
617    ) -> *mut decDouble;
618    pub fn decDoublePlus(
619        arg1: *mut decDouble,
620        arg2: *const decDouble,
621        arg3: *mut decContext,
622    ) -> *mut decDouble;
623    pub fn decDoubleQuantize(
624        arg1: *mut decDouble,
625        arg2: *const decDouble,
626        arg3: *const decDouble,
627        arg4: *mut decContext,
628    ) -> *mut decDouble;
629    pub fn decDoubleReduce(
630        arg1: *mut decDouble,
631        arg2: *const decDouble,
632        arg3: *mut decContext,
633    ) -> *mut decDouble;
634    pub fn decDoubleRemainder(
635        arg1: *mut decDouble,
636        arg2: *const decDouble,
637        arg3: *const decDouble,
638        arg4: *mut decContext,
639    ) -> *mut decDouble;
640    pub fn decDoubleRemainderNear(
641        arg1: *mut decDouble,
642        arg2: *const decDouble,
643        arg3: *const decDouble,
644        arg4: *mut decContext,
645    ) -> *mut decDouble;
646    pub fn decDoubleRotate(
647        arg1: *mut decDouble,
648        arg2: *const decDouble,
649        arg3: *const decDouble,
650        arg4: *mut decContext,
651    ) -> *mut decDouble;
652    pub fn decDoubleScaleB(
653        arg1: *mut decDouble,
654        arg2: *const decDouble,
655        arg3: *const decDouble,
656        arg4: *mut decContext,
657    ) -> *mut decDouble;
658    pub fn decDoubleShift(
659        arg1: *mut decDouble,
660        arg2: *const decDouble,
661        arg3: *const decDouble,
662        arg4: *mut decContext,
663    ) -> *mut decDouble;
664    pub fn decDoubleSubtract(
665        arg1: *mut decDouble,
666        arg2: *const decDouble,
667        arg3: *const decDouble,
668        arg4: *mut decContext,
669    ) -> *mut decDouble;
670    pub fn decDoubleToIntegralValue(
671        arg1: *mut decDouble,
672        arg2: *const decDouble,
673        arg3: *mut decContext,
674        arg4: rounding,
675    ) -> *mut decDouble;
676    pub fn decDoubleToIntegralExact(
677        arg1: *mut decDouble,
678        arg2: *const decDouble,
679        arg3: *mut decContext,
680    ) -> *mut decDouble;
681    pub fn decDoubleXor(
682        arg1: *mut decDouble,
683        arg2: *const decDouble,
684        arg3: *const decDouble,
685        arg4: *mut decContext,
686    ) -> *mut decDouble;
687    pub fn decDoubleCompare(
688        arg1: *mut decDouble,
689        arg2: *const decDouble,
690        arg3: *const decDouble,
691        arg4: *mut decContext,
692    ) -> *mut decDouble;
693    pub fn decDoubleCompareSignal(
694        arg1: *mut decDouble,
695        arg2: *const decDouble,
696        arg3: *const decDouble,
697        arg4: *mut decContext,
698    ) -> *mut decDouble;
699    pub fn decDoubleCompareTotal(
700        arg1: *mut decDouble,
701        arg2: *const decDouble,
702        arg3: *const decDouble,
703    ) -> *mut decDouble;
704    pub fn decDoubleCompareTotalMag(
705        arg1: *mut decDouble,
706        arg2: *const decDouble,
707        arg3: *const decDouble,
708    ) -> *mut decDouble;
709    pub fn decDoubleCanonical(arg1: *mut decDouble, arg2: *const decDouble) -> *mut decDouble;
710    pub fn decDoubleCopy(arg1: *mut decDouble, arg2: *const decDouble) -> *mut decDouble;
711    pub fn decDoubleCopyAbs(arg1: *mut decDouble, arg2: *const decDouble) -> *mut decDouble;
712    pub fn decDoubleCopyNegate(arg1: *mut decDouble, arg2: *const decDouble) -> *mut decDouble;
713    pub fn decDoubleCopySign(
714        arg1: *mut decDouble,
715        arg2: *const decDouble,
716        arg3: *const decDouble,
717    ) -> *mut decDouble;
718    pub fn decDoubleClass(arg1: *const decDouble) -> decClass;
719    pub fn decDoubleClassString(arg1: *const decDouble) -> *const c_char;
720    pub fn decDoubleDigits(arg1: *const decDouble) -> u32;
721    pub fn decDoubleIsCanonical(arg1: *const decDouble) -> u32;
722    pub fn decDoubleIsFinite(arg1: *const decDouble) -> u32;
723    pub fn decDoubleIsInfinite(arg1: *const decDouble) -> u32;
724    pub fn decDoubleIsInteger(arg1: *const decDouble) -> u32;
725    pub fn decDoubleIsLogical(arg1: *const decDouble) -> u32;
726    pub fn decDoubleIsNaN(arg1: *const decDouble) -> u32;
727    pub fn decDoubleIsNegative(arg1: *const decDouble) -> u32;
728    pub fn decDoubleIsNormal(arg1: *const decDouble) -> u32;
729    pub fn decDoubleIsPositive(arg1: *const decDouble) -> u32;
730    pub fn decDoubleIsSignaling(arg1: *const decDouble) -> u32;
731    pub fn decDoubleIsSignalling(arg1: *const decDouble) -> u32;
732    pub fn decDoubleIsSigned(arg1: *const decDouble) -> u32;
733    pub fn decDoubleIsSubnormal(arg1: *const decDouble) -> u32;
734    pub fn decDoubleIsZero(arg1: *const decDouble) -> u32;
735    pub fn decDoubleRadix(arg1: *const decDouble) -> u32;
736    pub fn decDoubleSameQuantum(arg1: *const decDouble, arg2: *const decDouble) -> u32;
737    pub fn decDoubleVersion() -> *const c_char;
738}
739
740pub const DECQUAD_Bytes: usize = 16;
741pub const DECQUAD_Pmax: usize = 34;
742pub const DECQUAD_Emin: isize = -6143;
743pub const DECQUAD_Emax: usize = 6144;
744pub const DECQUAD_EmaxD: usize = 4;
745pub const DECQUAD_Bias: usize = 6176;
746pub const DECQUAD_String: usize = 43;
747pub const DECQUAD_EconL: usize = 12;
748pub const DECQUAD_Declets: usize = 11;
749pub const DECQUAD_Ehigh: usize = DECQUAD_Emax + DECQUAD_Bias - (DECQUAD_Pmax - 1);
750
751pub type decQuad = decimal128;
752
753extern "C" {
754    pub fn decQuadFromBCD(
755        arg1: *mut decQuad,
756        arg2: i32,
757        arg3: *const u8,
758        arg4: i32,
759    ) -> *mut decQuad;
760    pub fn decQuadFromInt32(arg1: *mut decQuad, arg2: i32) -> *mut decQuad;
761    pub fn decQuadFromPacked(arg1: *mut decQuad, arg2: i32, arg3: *const u8) -> *mut decQuad;
762    pub fn decQuadFromPackedChecked(arg1: *mut decQuad, arg2: i32, arg3: *const u8)
763        -> *mut decQuad;
764    pub fn decQuadFromString(
765        arg1: *mut decQuad,
766        arg2: *const c_char,
767        arg3: *mut decContext,
768    ) -> *mut decQuad;
769    pub fn decQuadFromUInt32(arg1: *mut decQuad, arg2: u32) -> *mut decQuad;
770    pub fn decQuadGetCoefficient(arg1: *const decQuad, arg2: *mut u8) -> i32;
771    pub fn decQuadGetExponent(arg1: *const decQuad) -> i32;
772    pub fn decQuadSetCoefficient(arg1: *mut decQuad, arg2: *const u8, arg3: i32) -> *mut decQuad;
773    pub fn decQuadSetExponent(arg1: *mut decQuad, arg2: *mut decContext, arg3: i32)
774        -> *mut decQuad;
775    pub fn decQuadShow(arg1: *const decQuad, arg2: *const c_char);
776    pub fn decQuadToBCD(arg1: *const decQuad, arg2: *mut i32, arg3: *mut u8) -> i32;
777    pub fn decQuadToEngString(arg1: *const decQuad, arg2: *mut c_char) -> *mut c_char;
778    pub fn decQuadToInt32(arg1: *const decQuad, arg2: *mut decContext, arg3: rounding) -> i32;
779    pub fn decQuadToInt32Exact(arg1: *const decQuad, arg2: *mut decContext, arg3: rounding) -> i32;
780    pub fn decQuadToPacked(arg1: *const decQuad, arg2: *mut i32, arg3: *mut u8) -> i32;
781    pub fn decQuadToString(arg1: *const decQuad, arg2: *mut c_char) -> *mut c_char;
782    pub fn decQuadToUInt32(arg1: *const decQuad, arg2: *mut decContext, arg3: rounding) -> u32;
783    pub fn decQuadToUInt32Exact(arg1: *const decQuad, arg2: *mut decContext, arg3: rounding)
784        -> u32;
785    pub fn decQuadZero(arg1: *mut decQuad) -> *mut decQuad;
786    pub fn decQuadAbs(
787        arg1: *mut decQuad,
788        arg2: *const decQuad,
789        arg3: *mut decContext,
790    ) -> *mut decQuad;
791    pub fn decQuadAdd(
792        arg1: *mut decQuad,
793        arg2: *const decQuad,
794        arg3: *const decQuad,
795        arg4: *mut decContext,
796    ) -> *mut decQuad;
797    pub fn decQuadAnd(
798        arg1: *mut decQuad,
799        arg2: *const decQuad,
800        arg3: *const decQuad,
801        arg4: *mut decContext,
802    ) -> *mut decQuad;
803    pub fn decQuadDivide(
804        arg1: *mut decQuad,
805        arg2: *const decQuad,
806        arg3: *const decQuad,
807        arg4: *mut decContext,
808    ) -> *mut decQuad;
809    pub fn decQuadDivideInteger(
810        arg1: *mut decQuad,
811        arg2: *const decQuad,
812        arg3: *const decQuad,
813        arg4: *mut decContext,
814    ) -> *mut decQuad;
815    pub fn decQuadFMA(
816        arg1: *mut decQuad,
817        arg2: *const decQuad,
818        arg3: *const decQuad,
819        arg4: *const decQuad,
820        arg5: *mut decContext,
821    ) -> *mut decQuad;
822    pub fn decQuadInvert(
823        arg1: *mut decQuad,
824        arg2: *const decQuad,
825        arg3: *mut decContext,
826    ) -> *mut decQuad;
827    pub fn decQuadLogB(
828        arg1: *mut decQuad,
829        arg2: *const decQuad,
830        arg3: *mut decContext,
831    ) -> *mut decQuad;
832    pub fn decQuadMax(
833        arg1: *mut decQuad,
834        arg2: *const decQuad,
835        arg3: *const decQuad,
836        arg4: *mut decContext,
837    ) -> *mut decQuad;
838    pub fn decQuadMaxMag(
839        arg1: *mut decQuad,
840        arg2: *const decQuad,
841        arg3: *const decQuad,
842        arg4: *mut decContext,
843    ) -> *mut decQuad;
844    pub fn decQuadMin(
845        arg1: *mut decQuad,
846        arg2: *const decQuad,
847        arg3: *const decQuad,
848        arg4: *mut decContext,
849    ) -> *mut decQuad;
850    pub fn decQuadMinMag(
851        arg1: *mut decQuad,
852        arg2: *const decQuad,
853        arg3: *const decQuad,
854        arg4: *mut decContext,
855    ) -> *mut decQuad;
856    pub fn decQuadMinus(
857        arg1: *mut decQuad,
858        arg2: *const decQuad,
859        arg3: *mut decContext,
860    ) -> *mut decQuad;
861    pub fn decQuadMultiply(
862        arg1: *mut decQuad,
863        arg2: *const decQuad,
864        arg3: *const decQuad,
865        arg4: *mut decContext,
866    ) -> *mut decQuad;
867    pub fn decQuadNextMinus(
868        arg1: *mut decQuad,
869        arg2: *const decQuad,
870        arg3: *mut decContext,
871    ) -> *mut decQuad;
872    pub fn decQuadNextPlus(
873        arg1: *mut decQuad,
874        arg2: *const decQuad,
875        arg3: *mut decContext,
876    ) -> *mut decQuad;
877    pub fn decQuadNextToward(
878        arg1: *mut decQuad,
879        arg2: *const decQuad,
880        arg3: *const decQuad,
881        arg4: *mut decContext,
882    ) -> *mut decQuad;
883    pub fn decQuadOr(
884        arg1: *mut decQuad,
885        arg2: *const decQuad,
886        arg3: *const decQuad,
887        arg4: *mut decContext,
888    ) -> *mut decQuad;
889    pub fn decQuadPlus(
890        arg1: *mut decQuad,
891        arg2: *const decQuad,
892        arg3: *mut decContext,
893    ) -> *mut decQuad;
894    pub fn decQuadQuantize(
895        arg1: *mut decQuad,
896        arg2: *const decQuad,
897        arg3: *const decQuad,
898        arg4: *mut decContext,
899    ) -> *mut decQuad;
900    pub fn decQuadReduce(
901        arg1: *mut decQuad,
902        arg2: *const decQuad,
903        arg3: *mut decContext,
904    ) -> *mut decQuad;
905    pub fn decQuadRemainder(
906        arg1: *mut decQuad,
907        arg2: *const decQuad,
908        arg3: *const decQuad,
909        arg4: *mut decContext,
910    ) -> *mut decQuad;
911    pub fn decQuadRemainderNear(
912        arg1: *mut decQuad,
913        arg2: *const decQuad,
914        arg3: *const decQuad,
915        arg4: *mut decContext,
916    ) -> *mut decQuad;
917    pub fn decQuadRotate(
918        arg1: *mut decQuad,
919        arg2: *const decQuad,
920        arg3: *const decQuad,
921        arg4: *mut decContext,
922    ) -> *mut decQuad;
923    pub fn decQuadScaleB(
924        arg1: *mut decQuad,
925        arg2: *const decQuad,
926        arg3: *const decQuad,
927        arg4: *mut decContext,
928    ) -> *mut decQuad;
929    pub fn decQuadShift(
930        arg1: *mut decQuad,
931        arg2: *const decQuad,
932        arg3: *const decQuad,
933        arg4: *mut decContext,
934    ) -> *mut decQuad;
935    pub fn decQuadSubtract(
936        arg1: *mut decQuad,
937        arg2: *const decQuad,
938        arg3: *const decQuad,
939        arg4: *mut decContext,
940    ) -> *mut decQuad;
941    pub fn decQuadToIntegralValue(
942        arg1: *mut decQuad,
943        arg2: *const decQuad,
944        arg3: *mut decContext,
945        arg4: rounding,
946    ) -> *mut decQuad;
947    pub fn decQuadToIntegralExact(
948        arg1: *mut decQuad,
949        arg2: *const decQuad,
950        arg3: *mut decContext,
951    ) -> *mut decQuad;
952    pub fn decQuadXor(
953        arg1: *mut decQuad,
954        arg2: *const decQuad,
955        arg3: *const decQuad,
956        arg4: *mut decContext,
957    ) -> *mut decQuad;
958    pub fn decQuadCompare(
959        arg1: *mut decQuad,
960        arg2: *const decQuad,
961        arg3: *const decQuad,
962        arg4: *mut decContext,
963    ) -> *mut decQuad;
964    pub fn decQuadCompareSignal(
965        arg1: *mut decQuad,
966        arg2: *const decQuad,
967        arg3: *const decQuad,
968        arg4: *mut decContext,
969    ) -> *mut decQuad;
970    pub fn decQuadCompareTotal(
971        arg1: *mut decQuad,
972        arg2: *const decQuad,
973        arg3: *const decQuad,
974    ) -> *mut decQuad;
975    pub fn decQuadCompareTotalMag(
976        arg1: *mut decQuad,
977        arg2: *const decQuad,
978        arg3: *const decQuad,
979    ) -> *mut decQuad;
980    pub fn decQuadCanonical(arg1: *mut decQuad, arg2: *const decQuad) -> *mut decQuad;
981    pub fn decQuadCopy(arg1: *mut decQuad, arg2: *const decQuad) -> *mut decQuad;
982    pub fn decQuadCopyAbs(arg1: *mut decQuad, arg2: *const decQuad) -> *mut decQuad;
983    pub fn decQuadCopyNegate(arg1: *mut decQuad, arg2: *const decQuad) -> *mut decQuad;
984    pub fn decQuadCopySign(
985        arg1: *mut decQuad,
986        arg2: *const decQuad,
987        arg3: *const decQuad,
988    ) -> *mut decQuad;
989    pub fn decQuadClass(arg1: *const decQuad) -> decClass;
990    pub fn decQuadClassString(arg1: *const decQuad) -> *const c_char;
991    pub fn decQuadDigits(arg1: *const decQuad) -> u32;
992    pub fn decQuadIsCanonical(arg1: *const decQuad) -> u32;
993    pub fn decQuadIsFinite(arg1: *const decQuad) -> u32;
994    pub fn decQuadIsInteger(arg1: *const decQuad) -> u32;
995    pub fn decQuadIsLogical(arg1: *const decQuad) -> u32;
996    pub fn decQuadIsInfinite(arg1: *const decQuad) -> u32;
997    pub fn decQuadIsNaN(arg1: *const decQuad) -> u32;
998    pub fn decQuadIsNegative(arg1: *const decQuad) -> u32;
999    pub fn decQuadIsNormal(arg1: *const decQuad) -> u32;
1000    pub fn decQuadIsPositive(arg1: *const decQuad) -> u32;
1001    pub fn decQuadIsSignaling(arg1: *const decQuad) -> u32;
1002    pub fn decQuadIsSignalling(arg1: *const decQuad) -> u32;
1003    pub fn decQuadIsSigned(arg1: *const decQuad) -> u32;
1004    pub fn decQuadIsSubnormal(arg1: *const decQuad) -> u32;
1005    pub fn decQuadIsZero(arg1: *const decQuad) -> u32;
1006    pub fn decQuadRadix(arg1: *const decQuad) -> u32;
1007    pub fn decQuadSameQuantum(arg1: *const decQuad, arg2: *const decQuad) -> u32;
1008    pub fn decQuadVersion() -> *const c_char;
1009}
1010
1011#[repr(C, align(4))]
1012#[derive(Debug, Copy, Clone)]
1013pub struct decimal32 {
1014    pub bytes: [u8; 4usize],
1015}
1016
1017extern "C" {
1018    pub fn decimal32FromString(
1019        arg1: *mut decimal32,
1020        arg2: *const c_char,
1021        arg3: *mut decContext,
1022    ) -> *mut decimal32;
1023    pub fn decimal32ToString(arg1: *const decimal32, arg2: *mut c_char) -> *mut c_char;
1024    pub fn decimal32ToEngString(arg1: *const decimal32, arg2: *mut c_char) -> *mut c_char;
1025    pub fn decimal32FromNumber(
1026        arg1: *mut decimal32,
1027        arg2: *const decNumber,
1028        arg3: *mut decContext,
1029    ) -> *mut decimal32;
1030    pub fn decimal32ToNumber(arg1: *const decimal32, arg2: *mut decNumber) -> *mut decNumber;
1031    pub fn decimal32IsCanonical(arg1: *const decimal32) -> u32;
1032    pub fn decimal32Canonical(arg1: *mut decimal32, arg2: *const decimal32) -> *mut decimal32;
1033    pub fn decPackedFromNumber(
1034        arg1: *mut u8,
1035        arg2: i32,
1036        arg3: *mut i32,
1037        arg4: *const decNumber,
1038    ) -> *mut u8;
1039    pub fn decPackedToNumber(
1040        arg1: *const u8,
1041        arg2: i32,
1042        arg3: *const i32,
1043        arg4: *mut decNumber,
1044    ) -> *mut decNumber;
1045}
1046
1047#[repr(C, align(4))]
1048#[derive(Debug, Copy, Clone)]
1049pub struct decimal64 {
1050    pub bytes: [u8; 8usize],
1051}
1052
1053extern "C" {
1054    pub fn decimal64FromString(
1055        arg1: *mut decimal64,
1056        arg2: *const c_char,
1057        arg3: *mut decContext,
1058    ) -> *mut decimal64;
1059    pub fn decimal64ToString(arg1: *const decimal64, arg2: *mut c_char) -> *mut c_char;
1060    pub fn decimal64ToEngString(arg1: *const decimal64, arg2: *mut c_char) -> *mut c_char;
1061    pub fn decimal64FromNumber(
1062        arg1: *mut decimal64,
1063        arg2: *const decNumber,
1064        arg3: *mut decContext,
1065    ) -> *mut decimal64;
1066    pub fn decimal64ToNumber(arg1: *const decimal64, arg2: *mut decNumber) -> *mut decNumber;
1067    pub fn decimal64IsCanonical(arg1: *const decimal64) -> u32;
1068    pub fn decimal64Canonical(arg1: *mut decimal64, arg2: *const decimal64) -> *mut decimal64;
1069}
1070
1071#[repr(C, align(4))]
1072#[derive(Debug, Copy, Clone)]
1073pub struct decimal128 {
1074    pub bytes: [u8; 16usize],
1075}
1076
1077extern "C" {
1078    pub fn decimal128FromString(
1079        arg1: *mut decimal128,
1080        arg2: *const c_char,
1081        arg3: *mut decContext,
1082    ) -> *mut decimal128;
1083    pub fn decimal128ToString(arg1: *const decimal128, arg2: *mut c_char) -> *mut c_char;
1084    pub fn decimal128ToEngString(arg1: *const decimal128, arg2: *mut c_char) -> *mut c_char;
1085    pub fn decimal128FromNumber(
1086        arg1: *mut decimal128,
1087        arg2: *const decNumber,
1088        arg3: *mut decContext,
1089    ) -> *mut decimal128;
1090    pub fn decimal128ToNumber(arg1: *const decimal128, arg2: *mut decNumber) -> *mut decNumber;
1091    pub fn decimal128IsCanonical(arg1: *const decimal128) -> u32;
1092    pub fn decimal128Canonical(arg1: *mut decimal128, arg2: *const decimal128) -> *mut decimal128;
1093}
1094
1095// Constants used for efficiently decoding decimal coefficients.
1096extern "C" {
1097    pub static DPD2BIN: [u16; 1024];
1098    pub static DPD2BINK: [u32; 1024];
1099    pub static DPD2BINM: [u32; 1024];
1100    pub static DECCOMBMSD: [u32; 64];
1101    pub static BIN2CHAR: [u8; 4001];
1102}
decnumber_sys/lib.rs

decnumber_sys/
lib.rs
