New Slovenian localisation from http://translationproject.org
[pspp] / src / libpspp / integer-format.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2006, 2010, 2011 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include "libpspp/integer-format.h"
20
21 #include <assert.h>
22
23 /* Returns true if FORMAT is a valid integer format. */
24 static inline bool
25 is_integer_format (enum integer_format format)
26 {
27   return (format == INTEGER_MSB_FIRST
28           || format == INTEGER_LSB_FIRST
29           || format == INTEGER_VAX);
30 }
31
32 /* Converts the CNT bytes in INTEGER from SRC integer_format to DST
33    integer_format. */
34 void
35 integer_convert (enum integer_format src, const void *from,
36                  enum integer_format dst, void *to,
37                  size_t cnt)
38 {
39   if (src != dst)
40     integer_put (integer_get (src, from, cnt), dst, to, cnt);
41   else if (from != to)
42     memcpy (to, from, cnt);
43 }
44
45 /* Returns the value of the CNT-byte integer at FROM, which is in
46    the given FORMAT. */
47 uint64_t
48 integer_get (enum integer_format format, const void *from_, size_t cnt)
49 {
50   const uint8_t *from = from_;
51   uint64_t value = 0;
52   size_t i;
53
54   assert (is_integer_format (format));
55   assert (cnt <= 8);
56
57   switch (format)
58     {
59     case INTEGER_MSB_FIRST:
60       for (i = 0; i < cnt; i++)
61         value = (value << 8) | from[i];
62       break;
63     case INTEGER_LSB_FIRST:
64       for (i = 0; i < cnt; i++)
65         value = (value << 8) | from[cnt - i - 1];
66       break;
67     case INTEGER_VAX:
68       for (i = 0; i < (cnt & ~1); i++)
69         value = (value << 8) | from[i ^ 1];
70       if (cnt & 1)
71         value = (value << 8) | from[cnt - 1];
72       break;
73     }
74
75   return value;
76 }
77
78 /* Stores VALUE as a CNT-byte integer at TO, in the given
79    FORMAT. */
80 void
81 integer_put (uint64_t value, enum integer_format format, void *to_, size_t cnt)
82 {
83   uint8_t *to = to_;
84   size_t i;
85
86   assert (is_integer_format (format));
87   assert (cnt < 8);
88
89   value <<= 8 * (8 - cnt);
90
91   switch (format)
92     {
93     case INTEGER_MSB_FIRST:
94       for (i = 0; i < cnt; i++)
95         {
96           to[i] = value >> 56;
97           value <<= 8;
98         }
99       break;
100     case INTEGER_LSB_FIRST:
101       for (i = 0; i < cnt; i++)
102         {
103           to[cnt - i - 1] = value >> 56;
104           value <<= 8;
105         }
106       break;
107     case INTEGER_VAX:
108       for (i = 0; i < (cnt & ~1); i++)
109         {
110           to[i ^ 1] = value >> 56;
111           value <<= 8;
112         }
113       if (cnt & 1)
114         to[cnt - 1] = value >> 56;
115       break;
116     }
117 }
118
119 /* Returns true if bytes with index IDX1 and IDX2 in VALUE differ
120    in value. */
121 static inline bool
122 bytes_differ (uint64_t value, unsigned int idx1, unsigned int idx2)
123 {
124   uint8_t byte1 = value >> (idx1 * 8);
125   uint8_t byte2 = value >> (idx2 * 8);
126   return byte1 != byte2;
127 }
128
129 /* Attempts to identify the integer format in which the LENGTH
130    bytes in INTEGER represent the given EXPECTED_VALUE.  Returns
131    true if successful, false otherwise.  On success, stores the
132    format in *FORMAT. */
133 bool
134 integer_identify (uint64_t expected_value, const void *integer, size_t length,
135                   enum integer_format *format)
136 {
137   /* Odd-length integers are confusing. */
138   assert (length % 2 == 0);
139
140   /* LENGTH must be greater than 2 because VAX format is
141      equivalent to little-endian for 2-byte integers. */
142   assert (length > 2);
143
144   /* EXPECTED_VALUE must contain different byte values, because
145      otherwise all formats are identical. */
146   assert (bytes_differ (expected_value, 0, 1)
147           || bytes_differ (expected_value, 0, 2)
148           || bytes_differ (expected_value, 0, 3)
149           || (length > 4
150               && (bytes_differ (expected_value, 0, 4)
151                   || bytes_differ (expected_value, 0, 5)))
152           || (length > 6
153               && (bytes_differ (expected_value, 0, 6)
154                   || bytes_differ (expected_value, 0, 7))));
155
156   if (integer_get (INTEGER_MSB_FIRST, integer, length) == expected_value)
157     *format = INTEGER_MSB_FIRST;
158   else if (integer_get (INTEGER_LSB_FIRST, integer, length) == expected_value)
159     *format = INTEGER_LSB_FIRST;
160   else if (integer_get (INTEGER_VAX, integer, length) == expected_value)
161     *format = INTEGER_VAX;
162   else
163     return false;
164
165   return true;
166 }