Line data Source code
1 : /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 : Copyright (c) 2018-2023 The plumed team
3 : (see the PEOPLE file at the root of the distribution for a list of names)
4 :
5 : See http://www.plumed.org for more information.
6 :
7 : This file is part of plumed, version 2.
8 :
9 : plumed is free software: you can redistribute it and/or modify
10 : it under the terms of the GNU Lesser General Public License as published by
11 : the Free Software Foundation, either version 3 of the License, or
12 : (at your option) any later version.
13 :
14 : plumed is distributed in the hope that it will be useful,
15 : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : GNU Lesser General Public License for more details.
18 :
19 : You should have received a copy of the GNU Lesser General Public License
20 : along with plumed. If not, see <http://www.gnu.org/licenses/>.
21 : +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
22 : #include "h36.h"
23 : #include <vector>
24 : #include "Exception.h"
25 :
26 : namespace PLMD {
27 :
28 : /// Tiny namespace for hybrid36 format.
29 : /// This namespace includes freely available tools for h36 format.
30 : namespace h36 {
31 :
32 :
33 : /*! C port of the hy36encode() and hy36decode() functions in the
34 : hybrid_36.py Python prototype/reference implementation.
35 : See the Python script for more information.
36 :
37 : This file has no external dependencies, NOT even standard C headers.
38 : Optionally, use hybrid_36_c.h, or simply copy the declarations
39 : into your code.
40 :
41 : This file is unrestricted Open Source (cctbx.sf.net).
42 : Please send corrections and enhancements to cctbx@cci.lbl.gov .
43 :
44 : See also: http://cci.lbl.gov/hybrid_36/
45 :
46 : Ralf W. Grosse-Kunstleve, Feb 2007.
47 : */
48 :
49 : /* The following #include may be commented out.
50 : It is here only to enforce consistency of the declarations
51 : and the definitions.
52 : */
53 : // #include <iotbx/pdb/hybrid_36_c.h>
54 :
55 : /* All static functions below are implementation details
56 : (and not accessible from other translation units).
57 : */
58 :
59 : static
60 : const char*
61 111612 : digits_upper() {
62 111612 : return "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
63 : }
64 :
65 : static
66 : const char*
67 9361 : digits_lower() {
68 9361 : return "0123456789abcdefghijklmnopqrstuvwxyz";
69 : }
70 :
71 : static
72 : const char*
73 0 : value_out_of_range() {
74 0 : return "value out of range.";
75 : }
76 :
77 : static
78 2 : const char* invalid_number_literal() {
79 2 : return "invalid number literal.";
80 : }
81 :
82 : static
83 0 : const char* unsupported_width() {
84 0 : return "unsupported width.";
85 : }
86 :
87 : static
88 : void
89 0 : fill_with_stars(unsigned width, char* result) {
90 0 : while (width) {
91 0 : *result++ = '*';
92 0 : width--;
93 : }
94 0 : *result = '\0';
95 0 : }
96 :
97 : static
98 : void
99 102253 : encode_pure(
100 : const char* digits,
101 : unsigned digits_size,
102 : unsigned width,
103 : int value,
104 : char* result) {
105 : char buf[16];
106 : int rest;
107 : unsigned i, j;
108 : i = 0;
109 : j = 0;
110 102253 : if (value < 0) {
111 : j = 1;
112 0 : value = -value;
113 : }
114 : while (1) {
115 492778 : rest = value / digits_size;
116 492778 : buf[i++] = digits[value - rest * digits_size];
117 492778 : if (rest == 0) {
118 : break;
119 : }
120 : value = rest;
121 : }
122 102253 : if (j) {
123 0 : buf[i++] = '-';
124 : }
125 120739 : for(j=i; j<width; j++) {
126 18486 : *result++ = ' ';
127 : }
128 595031 : while (i != 0) {
129 492778 : *result++ = buf[--i];
130 : }
131 102253 : *result = '\0';
132 102253 : }
133 :
134 : static
135 : const char*
136 915300 : decode_pure(
137 : const int* digits_values,
138 : unsigned digits_size,
139 : const char* s,
140 : unsigned s_size,
141 : int* result) {
142 : int si, dv;
143 : int have_minus = 0;
144 : int have_non_blank = 0;
145 : int value = 0;
146 : unsigned i = 0;
147 5034149 : for(; i<s_size; i++) {
148 4118850 : si = s[i];
149 4118850 : if (si < 0 || si > 127) {
150 0 : *result = 0;
151 0 : return invalid_number_literal();
152 : }
153 4118850 : if (si == ' ') {
154 1252835 : if (!have_non_blank) {
155 1252835 : continue;
156 : }
157 0 : value *= digits_size;
158 2866015 : } else if (si == '-') {
159 0 : if (have_non_blank) {
160 0 : *result = 0;
161 0 : return invalid_number_literal();
162 : }
163 : have_non_blank = 1;
164 : have_minus = 1;
165 0 : continue;
166 : } else {
167 : have_non_blank = 1;
168 2866015 : dv = digits_values[si];
169 2866015 : if (dv < 0 || dv >= digits_size) {
170 1 : *result = 0;
171 1 : return invalid_number_literal();
172 : }
173 2866014 : value *= digits_size;
174 2866014 : value += dv;
175 : }
176 : }
177 915299 : if (have_minus) {
178 0 : value = -value;
179 : }
180 915299 : *result = value;
181 915299 : return 0;
182 : }
183 :
184 : /*! hybrid-36 encoder: converts integer value to string result
185 :
186 : width: must be 4 (e.g. for residue sequence numbers)
187 : or 5 (e.g. for atom serial numbers)
188 :
189 : value: integer value to be converted
190 :
191 : result: pointer to char array of size width+1 or greater
192 : on return result is null-terminated
193 :
194 : return value: pointer to error message, if any,
195 : or 0 on success
196 :
197 : Example usage (from C++):
198 : char result[4+1];
199 : const char* errmsg = hy36encode(4, 12345, result);
200 : if (errmsg) throw std::runtime_error(errmsg);
201 : */
202 : const char*
203 102253 : hy36encode(unsigned width, int value, char* result) {
204 : int i = value;
205 102253 : if (width == 4U) {
206 1 : if (i >= -999) {
207 1 : if (i < 10000) {
208 0 : encode_pure(digits_upper(), 10U, 4U, i, result);
209 0 : return 0;
210 : }
211 1 : i -= 10000;
212 1 : if (i < 1213056 /* 26*36**3 */) {
213 1 : i += 466560 /* 10*36**3 */;
214 1 : encode_pure(digits_upper(), 36U, 0U, i, result);
215 1 : return 0;
216 : }
217 0 : i -= 1213056;
218 0 : if (i < 1213056) {
219 0 : i += 466560;
220 0 : encode_pure(digits_lower(), 36U, 0U, i, result);
221 0 : return 0;
222 : }
223 : }
224 102252 : } else if (width == 5U) {
225 102252 : if (i >= -9999) {
226 102252 : if (i < 100000) {
227 102143 : encode_pure(digits_upper(), 10U, 5U, i, result);
228 102143 : return 0;
229 : }
230 109 : i -= 100000;
231 109 : if (i < 43670016 /* 26*36**4 */) {
232 108 : i += 16796160 /* 10*36**4 */;
233 108 : encode_pure(digits_upper(), 36U, 0U, i, result);
234 108 : return 0;
235 : }
236 1 : i -= 43670016;
237 1 : if (i < 43670016) {
238 1 : i += 16796160;
239 1 : encode_pure(digits_lower(), 36U, 0U, i, result);
240 1 : return 0;
241 : }
242 : }
243 : } else {
244 0 : fill_with_stars(width, result);
245 0 : return unsupported_width();
246 : }
247 0 : fill_with_stars(width, result);
248 0 : return value_out_of_range();
249 : }
250 :
251 : /*! hybrid-36 decoder: converts string s to integer result
252 :
253 : width: must be 4 (e.g. for residue sequence numbers)
254 : or 5 (e.g. for atom serial numbers)
255 :
256 : s: string to be converted
257 : does not have to be null-terminated
258 :
259 : s_size: size of s
260 : must be equal to width, or an error message is
261 : returned otherwise
262 :
263 : result: integer holding the conversion result
264 :
265 : return value: pointer to error message, if any,
266 : or 0 on success
267 :
268 : Example usage (from C++):
269 : int result;
270 : const char* errmsg = hy36decode(width, "A1T5", 4, &result);
271 : if (errmsg) throw std::runtime_error(errmsg);
272 : */
273 : const char*
274 915300 : hy36decode(unsigned width, const char* s, unsigned s_size, int* result) {
275 260 : static const std::vector<int> digits_values_upper_vector([]() {
276 260 : std::vector<int> ret(128U,-1);
277 9620 : for(unsigned i=0; i<36U; i++) {
278 9360 : int di = digits_upper()[i];
279 9360 : if (di < 0 || di > 127) {
280 0 : plumed_error()<<"internal error hy36decode: integer value out of range";
281 : }
282 9360 : ret[di] = i;
283 : }
284 260 : return ret;
285 : }
286 915300 : ());
287 915300 : static const int* digits_values_upper=digits_values_upper_vector.data();
288 260 : static const std::vector<int> digits_values_lower_vector([]() {
289 260 : std::vector<int> ret(128U,-1);
290 9620 : for(unsigned i=0; i<36U; i++) {
291 9360 : int di = digits_lower()[i];
292 9360 : if (di < 0 || di > 127) {
293 0 : plumed_error()<<"internal error hy36decode: integer value out of range";
294 : }
295 9360 : ret[di] = i;
296 : }
297 260 : return ret;
298 : }
299 915300 : ());
300 915300 : static const int* digits_values_lower=digits_values_lower_vector.data();
301 : int di;
302 : const char* errmsg;
303 915300 : if (s_size == width) {
304 915300 : di = s[0];
305 915300 : if (di >= 0 && di <= 127) {
306 915300 : if (digits_values_upper[di] >= 10) {
307 14 : errmsg = decode_pure(digits_values_upper, 36U, s, s_size, result);
308 14 : if (errmsg == 0) {
309 : /* result - 10*36**(width-1) + 10**width */
310 13 : if (width == 4U) {
311 7 : (*result) -= 456560;
312 6 : } else if (width == 5U) {
313 6 : (*result) -= 16696160;
314 : } else {
315 0 : *result = 0;
316 0 : return unsupported_width();
317 : }
318 13 : return 0;
319 : }
320 915286 : } else if (digits_values_lower[di] >= 10) {
321 0 : errmsg = decode_pure(digits_values_lower, 36U, s, s_size, result);
322 0 : if (errmsg == 0) {
323 : /* result + 16*36**(width-1) + 10**width */
324 0 : if (width == 4U) {
325 0 : (*result) += 756496;
326 0 : } else if (width == 5U) {
327 0 : (*result) += 26973856;
328 : } else {
329 0 : *result = 0;
330 0 : return unsupported_width();
331 : }
332 0 : return 0;
333 : }
334 : } else {
335 915286 : errmsg = decode_pure(digits_values_upper, 10U, s, s_size, result);
336 915286 : if (errmsg) {
337 : return errmsg;
338 : }
339 915286 : if (!(width == 4U || width == 5U)) {
340 0 : *result = 0;
341 0 : return unsupported_width();
342 : }
343 : return 0;
344 : }
345 : }
346 : }
347 1 : *result = 0;
348 1 : return invalid_number_literal();
349 : }
350 :
351 : }
352 :
353 : }
354 :
|
