SDDS ToolKit Programs and Libraries for C and Python
Loading...
Searching...
No Matches
sddsconvert.c
Go to the documentation of this file.
1/**
2 * @file sddsconvert.c
3 * @brief A utility for converting, copying, and manipulating SDDS files.
4 *
5 * @details
6 * This program performs a variety of operations on SDDS (Self Describing Data Sets) files, including:
7 * - Format conversion between ASCII and binary.
8 * - Element filtering, renaming, deletion, and retention.
9 * - Unit conversions for specified elements.
10 * - Layout configuration with options for rows, pages, and major order.
11 *
12 * The utility also supports wildcard-based matching, selective element operations, and custom descriptions.
13 *
14 * @section Usage
15 * ```
16 * sddsconvert [<source-file>] [<target-file>]
17 * [-pipe=[input][,output]]
18 * [-binary]
19 * [-ascii]
20 * [-description=<text>,<contents>]
21 * [-fromPage=<pageNumber>]
22 * [-toPage=<pageNumber>]
23 * [-removePages=<listOfNumbers>]
24 * [-keepPages=<listOfNumbers>]
25 * [-linesperrow=<integer>]
26 * [-nowarnings]
27 * [-recover[=clip]]
28 * [-delete={column|parameter|array},<matching-string>[,...]]
29 * [-retain={column|parameter|array},<matching-string>[,...]]
30 * [-rename={column|parameter|array},<oldname>=<newname>[,...]]
31 * [-editnames={column|parameter|array},<wildcard-string>,<edit-string>]
32 * [-convertUnits={column|parameter|array},<name>,<new-units>[,<old-units>[,<factor>]]]
33 * [-acceptAllNames]
34 * [-rowlimit=<number>]
35 * [-majorOrder=row|column]
36 * ```
37 *
38 * @section Options
39 * | Option | Description |
40 * |-----------------------------------|----------------------------------------------------------|
41 * | `-pipe` | Use pipes for input and output. |
42 * | `-binary` | Convert output to binary format. |
43 * | `-ascii` | Convert output to ASCII format. |
44 * | `-description` | Set a description for the output file. |
45 * | `-fromPage` | Specify the starting page for operations. |
46 * | `-toPage` | Specify the ending page for operations. |
47 * | `-removePages` | Remove specified pages from the output. |
48 * | `-keepPages` | Keep only the specified pages in the output. |
49 * | `-linesperrow` | Set the number of lines per row in output. |
50 * | `-nowarnings` | Suppress warning messages. |
51 * | `-recover` | Recover from file corruption; optionally clip pages. |
52 * | `-delete` | Delete specified elements. |
53 * | `-retain` | Retain only specified elements. |
54 * | `-rename` | Rename specified elements. |
55 * | `-editnames` | Edit names of elements using patterns. |
56 * | `-convertUnits` | Convert units of specified elements. |
57 * | `-acceptAllNames` | Relax naming restrictions in the SDDS library. |
58 * | `-rowlimit` | Limit the number of rows in the output. |
59 * | `-majorOrder` | Set major order to row or column. |
60 * | `-xzLevel` | Set LZMA compression level when writing .xz files. |
61 *
62 * @subsection Incompatibilities
63 * - `-binary` and `-ascii` are mutually exclusive.
64 * - `-delete` and `-retain` have overlapping purposes and require careful specification.
65 * - `-editnames` requires valid wildcard patterns and edit strings.
66 * - When using `-convertUnits`, valid old units and a factor are necessary for precise conversion.
67 *
68 * @copyright
69 * - (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
70 * - (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.
71 *
72 * @license
73 * This file is distributed under the terms of the Software License Agreement
74 * found in the file LICENSE included with this distribution.
75 *
76 * @authors
77 * M. Borland,
78 * C. Saunders,
79 * R. Soliday,
80 * H. Shang
81 */
82
83#include "mdb.h"
84#include "SDDS.h"
85#include "scan.h"
86
87#define COLUMN_MODE 0
88#define PARAMETER_MODE 1
89#define ARRAY_MODE 2
90#define MODES 3
91static char *mode_name[MODES] = {
92 "column",
93 "parameter",
94 "array",
95};
96
97#define SET_BINARY 0
98#define SET_ASCII 1
99#define SET_DELETE 2
100#define SET_RETAIN 3
101#define SET_RENAME 4
102#define SET_DESCRIPTION 5
103/* -table is retained for backward compatibility: */
104#define SET_TABLE 6
105#define SET_EDIT_NAMES 7
106#define SET_LINES_PER_ROW 8
107#define SET_NOWARNINGS 9
108#define SET_RECOVER 10
109#define SET_PIPE 11
110#define SET_FROMPAGE 12
111#define SET_TOPAGE 13
112#define SET_ACCEPT_ALL_NAMES 14
113#define SET_REMOVEPAGES 15
114#define SET_KEEPPAGES 16
115#define SET_ROWLIMIT 17
116#define SET_MAJOR_ORDER 18
117#define SET_CONVERT_UNITS 19
118#define SET_XZLEVEL 20
119#define N_OPTIONS 21
120
121char *option[N_OPTIONS] = {
122 "binary",
123 "ascii",
124 "delete",
125 "retain",
126 "rename",
127 "description",
128 "table",
129 "editnames",
130 "linesperrow",
131 "nowarnings",
132 "recover",
133 "pipe",
134 "frompage",
135 "topage",
136 "acceptallnames",
137 "removepages",
138 "keeppages",
139 "rowlimit",
140 "majororder",
141 "convertunits",
142 "xzlevel"};
143
144char *USAGE = "sddsconvert [<source-file>] [<target-file>]\n\
145[-pipe=[input][,output]]\n\
146[-binary] [-ascii] [-description=<text>,<contents>]\n\
147[-fromPage=<pageNumber>] [-toPage=<pageNumber>]\n\
148[-removePages=<listOfNumbers>] [-keepPages=<listOfNumbers>]\n\
149[-linesperrow=<integer>] [-nowarnings] [-recover[=clip]]\n\
150[-delete={column|parameter|array},<matching-string>[,...]]\n\
151[-retain={column|parameter|array},<matching-string>[,...]]\n\
152[-rename={column|parameter|array},<oldname>=<newname>[,...]]\n\
153[-editnames={column|parameter|array},<wildcard-string>,<edit-string>]\n\
154[-convertUnits={column|parameter|array},<name>,<new-units>,[<old-units>[,<factor>]]\n\
155[-acceptAllNames] [-rowlimit=<number>]\n\
156[-majorOrder=row|column]\n\
157[-xzLevel=<0-9>]\n\n\
158sddsconvert converts SDDS files between ASCII and binary, and allows wildcard-based filtering.\n\
159Any element matched by a deletion string is deleted unless matched by a retention string.\n\
160The -acceptAllNames option may force the SDDS library to accept unusual names.\n\
161Program by Michael Borland. (" __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION ")\n";
162
163typedef char *STRING_PAIR[2];
164
165typedef struct
166{
167 char *match_string, *edit_string;
168} EDIT_NAME_REQUEST;
169
170typedef struct {
171 char *name;
172 char *new_units;
173 char *old_units;
174 double factor;
175} CONVERT_UNITS;
176
177static char **process_name_options(char **orig_name, long **orig_flag, long orig_names,
178 char **delete, long deletes, char **retain, long retains,
179 STRING_PAIR *rename, long renames,
180 EDIT_NAME_REQUEST *edit_request, long edit_requests);
181
182static int set_units_conversion(SDDS_DATASET *SDDS_orig, CONVERT_UNITS *convert_units_array,
183 long convert_units_arrays, CONVERT_UNITS *convert_units_column,
184 long convert_units_columns, CONVERT_UNITS *convert_units_parameter,
185 long convert_units_parameters) {
186 long i;
187 for (i = 0; i < convert_units_arrays; i++) {
188 if (SDDS_SetArrayUnitsConversion(SDDS_orig, convert_units_array[i].name,
189 convert_units_array[i].new_units,
190 convert_units_array[i].old_units,
191 convert_units_array[i].factor) == 0)
192 return 0;
193 }
194 for (i = 0; i < convert_units_columns; i++) {
195 if (SDDS_SetColumnUnitsConversion(SDDS_orig, convert_units_column[i].name,
196 convert_units_column[i].new_units,
197 convert_units_column[i].old_units,
198 convert_units_column[i].factor) == 0)
199 return 0;
200 }
201 for (i = 0; i < convert_units_parameters; i++) {
202 if (SDDS_SetParameterUnitsConversion(SDDS_orig, convert_units_parameter[i].name,
203 convert_units_parameter[i].new_units,
204 convert_units_parameter[i].old_units,
205 convert_units_parameter[i].factor) == 0)
206 return 0;
207 }
208 return 1;
209}
210
211int main(int argc, char **argv) {
212 SDDS_DATASET SDDS_dataset, SDDS_orig;
213 long i, i_arg;
214 SCANNED_ARG *s_arg;
215 char *description_text, *description_contents;
216 long tmpfile_used, noWarnings;
217 char *input, *output, *ptr, *buffer;
218 long ascii_output, binary_output, recover, recovered;
219 unsigned long pipeFlags, majorOrderFlag;
220
221 char **retain_column, **delete_column;
222 long retain_columns, delete_columns, rename_columns, edit_column_requests;
223 EDIT_NAME_REQUEST *edit_column_request;
224 STRING_PAIR *rename_column;
225 char **orig_column_name, **new_column_name;
226 long *orig_column_flag = NULL;
227 int32_t orig_column_names;
228
229 char **retain_parameter, **delete_parameter;
230 long retain_parameters, delete_parameters, rename_parameters, edit_parameter_requests;
231 EDIT_NAME_REQUEST *edit_parameter_request;
232 STRING_PAIR *rename_parameter;
233 char **orig_parameter_name, **new_parameter_name;
234 long *orig_parameter_flag = NULL;
235 int32_t orig_parameter_names;
236
237 char **retain_array, **delete_array;
238 long retain_arrays, delete_arrays, rename_arrays, edit_array_requests;
239 EDIT_NAME_REQUEST *edit_array_request;
240 STRING_PAIR *rename_array;
241 char **orig_array_name, **new_array_name;
242 long *orig_array_flag = NULL;
243 int32_t orig_array_names;
244
245 long lines_per_row, pageNumber = 0, fromPage, toPage;
246 int64_t rows;
247 long max_size;
248 //long output_columns;
249 long *removePage, *keepPage;
250 long removePages, keepPages, keep;
251 int64_t rowLimit;
252 short column_major = -1;
253 long xzLevel = SDDS_GetLZMACompressionLevel();
254
255 long convert_units_arrays = 0, convert_units_columns = 0, convert_units_parameters = 0;
256 CONVERT_UNITS *convert_units_array = NULL, *convert_units_column = NULL, *convert_units_parameter = NULL;
257
258 new_column_name = new_parameter_name = new_array_name = NULL;
259
260 SDDS_RegisterProgramName(argv[0]);
261 argc = scanargs(&s_arg, argc, argv);
262 if (argc < 3) {
263 fprintf(stderr, "%s\n", USAGE);
264 return 1;
265 }
266 input = output = NULL;
267 ascii_output = binary_output = noWarnings = 0;
268
269 retain_column = delete_column = NULL;
270 retain_columns = delete_columns = rename_columns = edit_column_requests = 0;
271 rename_column = NULL;
272 edit_column_request = NULL;
273
274 retain_parameter = delete_parameter = NULL;
275 retain_parameters = delete_parameters = rename_parameters = edit_parameter_requests = 0;
276 rename_parameter = NULL;
277 edit_parameter_request = NULL;
278
279 retain_array = delete_array = NULL;
280 retain_arrays = delete_arrays = rename_arrays = edit_array_requests = 0;
281 rename_array = NULL;
282 edit_array_request = NULL;
283
284 tmpfile_used = 0;
285 description_text = description_contents = NULL;
286 fromPage = toPage = recover = 0;
287 removePage = keepPage = NULL;
288 removePages = keepPages = 0;
289 lines_per_row = 1;
290 pipeFlags = 0;
291
292 for (i_arg = 1; i_arg < argc; i_arg++) {
293 if (s_arg[i_arg].arg_type == OPTION) {
294 delete_chars(s_arg[i_arg].list[0], "_");
295 switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
296 case SET_MAJOR_ORDER:
297 majorOrderFlag = 0;
298 s_arg[i_arg].n_items -= 1;
299 if (s_arg[i_arg].n_items > 0 &&
300 (!scanItemList(&majorOrderFlag, s_arg[i_arg].list + 1,
301 &s_arg[i_arg].n_items, 0,
302 "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER,
303 "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER,
304 NULL)))
305 SDDS_Bomb("invalid -majorOrder syntax/values");
306 if (majorOrderFlag & SDDS_COLUMN_MAJOR_ORDER)
307 column_major = 1;
308 if (majorOrderFlag & SDDS_ROW_MAJOR_ORDER)
309 column_major = 0;
310 break;
311 case SET_XZLEVEL:
312 if (s_arg[i_arg].n_items != 2 || sscanf(s_arg[i_arg].list[1], "%ld", &xzLevel) != 1 || xzLevel < 0 || xzLevel > 9)
313 SDDS_Bomb("invalid -xzLevel syntax");
314 SDDS_SetLZMACompressionLevel(xzLevel);
315 break;
316 case SET_BINARY:
317 binary_output = 1;
318 ascii_output = 0;
319 break;
320 case SET_ASCII:
321 ascii_output = 1;
322 binary_output = 0;
323 break;
324 case SET_CONVERT_UNITS:
325 if ((s_arg[i_arg].n_items != 4) && (s_arg[i_arg].n_items != 5) &&
326 (s_arg[i_arg].n_items != 6)) {
327 fprintf(stderr, "Error (%s): invalid -convertUnits syntax\n", argv[0]);
328 return 1;
329 }
330 switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) {
331 case ARRAY_MODE:
332 convert_units_array = trealloc(convert_units_array,
333 sizeof(*convert_units_array) * (convert_units_arrays + 1));
334 convert_units_array[convert_units_arrays].name = s_arg[i_arg].list[2];
335 convert_units_array[convert_units_arrays].new_units = s_arg[i_arg].list[3];
336 if (s_arg[i_arg].n_items >= 5)
337 convert_units_array[convert_units_arrays].old_units = s_arg[i_arg].list[4];
338 else
339 convert_units_array[convert_units_arrays].old_units = NULL;
340 if (s_arg[i_arg].n_items == 6) {
341 if (sscanf(s_arg[i_arg].list[5], "%lf",
342 &(convert_units_array[convert_units_arrays].factor)) != 1) {
343 fprintf(stderr, "Error (%s): invalid -convertUnits syntax or value\n", argv[0]);
344 return 1;
345 }
346 } else
347 convert_units_array[convert_units_arrays].factor = 1.0;
348 convert_units_arrays++;
349 break;
350 case COLUMN_MODE:
351 convert_units_column = trealloc(convert_units_column,
352 sizeof(*convert_units_column) * (convert_units_columns + 1));
353 convert_units_column[convert_units_columns].name = s_arg[i_arg].list[2];
354 convert_units_column[convert_units_columns].new_units = s_arg[i_arg].list[3];
355 if (s_arg[i_arg].n_items >= 5)
356 convert_units_column[convert_units_columns].old_units = s_arg[i_arg].list[4];
357 else
358 convert_units_column[convert_units_columns].old_units = NULL;
359 if (s_arg[i_arg].n_items == 6) {
360 if (sscanf(s_arg[i_arg].list[5], "%lf",
361 &(convert_units_column[convert_units_columns].factor)) != 1) {
362 fprintf(stderr, "Error (%s): invalid -convertUnits syntax or value\n", argv[0]);
363 return 1;
364 }
365 } else
366 convert_units_column[convert_units_columns].factor = 1.0;
367 convert_units_columns++;
368 break;
369 case PARAMETER_MODE:
370 convert_units_parameter = trealloc(convert_units_parameter,
371 sizeof(*convert_units_parameter) * (convert_units_parameters + 1));
372 convert_units_parameter[convert_units_parameters].name = s_arg[i_arg].list[2];
373 convert_units_parameter[convert_units_parameters].new_units = s_arg[i_arg].list[3];
374 if (s_arg[i_arg].n_items >= 5)
375 convert_units_parameter[convert_units_parameters].old_units = s_arg[i_arg].list[4];
376 else
377 convert_units_parameter[convert_units_parameters].old_units = NULL;
378 if (s_arg[i_arg].n_items == 6) {
379 if (sscanf(s_arg[i_arg].list[5], "%lf",
380 &(convert_units_parameter[convert_units_parameters].factor)) != 1) {
381 fprintf(stderr, "Error (%s): invalid -convertUnits syntax or value\n", argv[0]);
382 return 1;
383 }
384 } else
385 convert_units_parameter[convert_units_parameters].factor = 1.0;
386 convert_units_parameters++;
387 break;
388 default:
389 fprintf(stderr, "Error (%s): invalid -convertUnits syntax: specify column, parameter or array\n", argv[0]);
390 return 1;
391 }
392 break;
393 case SET_DELETE:
394 if (s_arg[i_arg].n_items < 3) {
395 fprintf(stderr, "Error (%s): invalid -delete syntax\n", argv[0]);
396 return 1;
397 }
398 switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) {
399 case COLUMN_MODE:
400 delete_column = trealloc(delete_column,
401 sizeof(*delete_column) * (delete_columns + s_arg[i_arg].n_items - 2));
402 for (i = 2; i < s_arg[i_arg].n_items; i++)
403 delete_column[i - 2 + delete_columns] = s_arg[i_arg].list[i];
404 delete_columns += s_arg[i_arg].n_items - 2;
405 break;
406 case PARAMETER_MODE:
407 delete_parameter = trealloc(delete_parameter,
408 sizeof(*delete_parameter) * (delete_parameters + s_arg[i_arg].n_items - 2));
409 for (i = 2; i < s_arg[i_arg].n_items; i++)
410 delete_parameter[i - 2 + delete_parameters] = s_arg[i_arg].list[i];
411 delete_parameters += s_arg[i_arg].n_items - 2;
412 break;
413 case ARRAY_MODE:
414 delete_array = trealloc(delete_array,
415 sizeof(*delete_array) * (delete_arrays + s_arg[i_arg].n_items - 2));
416 for (i = 2; i < s_arg[i_arg].n_items; i++)
417 delete_array[i - 2 + delete_arrays] = s_arg[i_arg].list[i];
418 delete_arrays += s_arg[i_arg].n_items - 2;
419 break;
420 default:
421 fprintf(stderr, "Error (%s): invalid -delete syntax: specify column, parameter or array\n", argv[0]);
422 return 1;
423 }
424 break;
425 case SET_RETAIN:
426 if (s_arg[i_arg].n_items < 3) {
427 fprintf(stderr, "Error (%s): invalid -retain syntax\n", argv[0]);
428 return 1;
429 }
430 switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) {
431 case COLUMN_MODE:
432 retain_column = trealloc(retain_column,
433 sizeof(*retain_column) * (retain_columns + s_arg[i_arg].n_items - 2));
434 for (i = 2; i < s_arg[i_arg].n_items; i++)
435 retain_column[i - 2 + retain_columns] = s_arg[i_arg].list[i];
436 retain_columns += s_arg[i_arg].n_items - 2;
437 break;
438 case PARAMETER_MODE:
439 retain_parameter = trealloc(retain_parameter,
440 sizeof(*retain_parameter) * (retain_parameters + s_arg[i_arg].n_items - 2));
441 for (i = 2; i < s_arg[i_arg].n_items; i++)
442 retain_parameter[i - 2 + retain_parameters] = s_arg[i_arg].list[i];
443 retain_parameters += s_arg[i_arg].n_items - 2;
444 break;
445 case ARRAY_MODE:
446 retain_array = trealloc(retain_array,
447 sizeof(*retain_array) * (retain_arrays + s_arg[i_arg].n_items - 2));
448 for (i = 2; i < s_arg[i_arg].n_items; i++)
449 retain_array[i - 2 + retain_arrays] = s_arg[i_arg].list[i];
450 retain_arrays += s_arg[i_arg].n_items - 2;
451 break;
452 default:
453 fprintf(stderr, "Error (%s): invalid -retain syntax: specify column, parameter or array\n", argv[0]);
454 return 1;
455 }
456 break;
457 case SET_RENAME:
458 if (s_arg[i_arg].n_items < 3) {
459 fprintf(stderr, "Error (%s): invalid -rename syntax\n", argv[0]);
460 return 1;
461 }
462 switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) {
463 case COLUMN_MODE:
464 rename_column = trealloc(rename_column,
465 sizeof(*rename_column) * (rename_columns + s_arg[i_arg].n_items - 2));
466 for (i = 2; i < s_arg[i_arg].n_items; i++) {
467 if (!(ptr = strchr(s_arg[i_arg].list[i], '='))) {
468 fprintf(stderr, "Error (%s): invalid -rename syntax\n", argv[0]);
469 return 1;
470 }
471 *ptr++ = 0;
472 rename_column[i - 2 + rename_columns][0] = s_arg[i_arg].list[i];
473 rename_column[i - 2 + rename_columns][1] = ptr;
474 }
475 rename_columns += s_arg[i_arg].n_items - 2;
476 break;
477 case PARAMETER_MODE:
478 rename_parameter = trealloc(rename_parameter,
479 sizeof(*rename_parameter) * (rename_parameters + s_arg[i_arg].n_items - 2));
480 for (i = 2; i < s_arg[i_arg].n_items; i++) {
481 if (!(ptr = strchr(s_arg[i_arg].list[i], '='))) {
482 fprintf(stderr, "Error (%s): invalid -rename syntax\n", argv[0]);
483 return 1;
484 }
485 *ptr++ = 0;
486 rename_parameter[i - 2 + rename_parameters][0] = s_arg[i_arg].list[i];
487 rename_parameter[i - 2 + rename_parameters][1] = ptr;
488 }
489 rename_parameters += s_arg[i_arg].n_items - 2;
490 break;
491 case ARRAY_MODE:
492 rename_array = trealloc(rename_array,
493 sizeof(*rename_array) * (rename_arrays + s_arg[i_arg].n_items - 2));
494 for (i = 2; i < s_arg[i_arg].n_items; i++) {
495 if (!(ptr = strchr(s_arg[i_arg].list[i], '='))) {
496 fprintf(stderr, "Error (%s): invalid -rename syntax\n", argv[0]);
497 return 1;
498 }
499 *ptr++ = 0;
500 rename_array[i - 2 + rename_arrays][0] = s_arg[i_arg].list[i];
501 rename_array[i - 2 + rename_arrays][1] = ptr;
502 }
503 rename_arrays += s_arg[i_arg].n_items - 2;
504 break;
505 default:
506 fprintf(stderr, "Error (%s): invalid -rename syntax: specify column, parameter or array\n", argv[0]);
507 return 1;
508 }
509 break;
510 case SET_DESCRIPTION:
511 if (s_arg[i_arg].n_items != 3) {
512 fprintf(stderr, "Error (%s): invalid -description syntax\n", argv[0]);
513 return 1;
514 }
515 description_text = s_arg[i_arg].list[1];
516 description_contents = s_arg[i_arg].list[2];
517 break;
518 case SET_TABLE:
519 if (s_arg[i_arg].n_items < 2) {
520 fprintf(stderr, "Error (%s): invalid -table syntax\n", argv[0]);
521 return 1;
522 }
523 if (pageNumber != 0) {
524 fprintf(stderr, "Error (%s): specify -table once only\n", argv[0]);
525 return 1;
526 }
527 if (sscanf(s_arg[i_arg].list[1], "%ld", &pageNumber) != 1 || pageNumber <= 0) {
528 fprintf(stderr, "Error (%s): invalid -table value\n", argv[0]);
529 return 1;
530 }
531 fromPage = toPage = pageNumber;
532 break;
533 case SET_FROMPAGE:
534 if (s_arg[i_arg].n_items < 2) {
535 fprintf(stderr, "Error (%s): invalid -fromPage syntax\n", argv[0]);
536 return 1;
537 }
538 if (fromPage != 0) {
539 fprintf(stderr, "Error (%s): specify -fromPage once only\n", argv[0]);
540 return 1;
541 }
542 if (sscanf(s_arg[i_arg].list[1], "%ld", &fromPage) != 1 || fromPage <= 0) {
543 fprintf(stderr, "Error (%s): invalid -fromPage value\n", argv[0]);
544 return 1;
545 }
546 break;
547 case SET_TOPAGE:
548 if (s_arg[i_arg].n_items < 2) {
549 fprintf(stderr, "Error (%s): invalid -toPage syntax\n", argv[0]);
550 return 1;
551 }
552 if (toPage != 0) {
553 fprintf(stderr, "Error (%s): specify -toPage once only\n", argv[0]);
554 return 1;
555 }
556 if (sscanf(s_arg[i_arg].list[1], "%ld", &toPage) != 1 || toPage <= 0) {
557 fprintf(stderr, "Error (%s): invalid -toPage value\n", argv[0]);
558 return 1;
559 }
560 break;
561 case SET_REMOVEPAGES:
562 if (s_arg[i_arg].n_items < 2) {
563 fprintf(stderr, "Error (%s): invalid -removePages syntax\n", argv[0]);
564 return 1;
565 }
566 if (removePage != NULL) {
567 fprintf(stderr, "Error (%s): specify -removePages once only\n", argv[0]);
568 return 1;
569 }
570 removePages = s_arg[i_arg].n_items - 1;
571 removePage = trealloc(removePage, sizeof(*removePage) * (removePages));
572 for (i = 0; i < removePages; i++) {
573 if (sscanf(s_arg[i_arg].list[i + 1], "%ld", &removePage[i]) != 1 || removePage[i] <= 0) {
574 fprintf(stderr, "Error (%s): invalid -removePages value\n", argv[0]);
575 return 1;
576 }
577 }
578 break;
579 case SET_KEEPPAGES:
580 if (s_arg[i_arg].n_items < 2) {
581 fprintf(stderr, "Error (%s): invalid -keepPages syntax\n", argv[0]);
582 return 1;
583 }
584 if (keepPage != NULL) {
585 fprintf(stderr, "Error (%s): specify -keepPages once only\n", argv[0]);
586 return 1;
587 }
588 keepPages = s_arg[i_arg].n_items - 1;
589 keepPage = trealloc(keepPage, sizeof(*keepPage) * (keepPages));
590 for (i = 0; i < keepPages; i++) {
591 if (sscanf(s_arg[i_arg].list[i + 1], "%ld", &keepPage[i]) != 1 || keepPage[i] <= 0) {
592 fprintf(stderr, "Error (%s): invalid -keepPages value\n", argv[0]);
593 return 1;
594 }
595 }
596 break;
597 case SET_EDIT_NAMES:
598 if (s_arg[i_arg].n_items < 4) {
599 fprintf(stderr, "Error (%s): invalid -editnames syntax\n", argv[0]);
600 return 1;
601 }
602 switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) {
603 case COLUMN_MODE:
604 edit_column_request = trealloc(edit_column_request,
605 sizeof(*edit_column_request) * (edit_column_requests + 1));
606 edit_column_request[edit_column_requests].match_string = s_arg[i_arg].list[2];
607 edit_column_request[edit_column_requests].edit_string = s_arg[i_arg].list[3];
608 edit_column_requests++;
609 break;
610 case PARAMETER_MODE:
611 edit_parameter_request = trealloc(edit_parameter_request,
612 sizeof(*edit_parameter_request) * (edit_parameter_requests + 1));
613 edit_parameter_request[edit_parameter_requests].match_string = s_arg[i_arg].list[2];
614 edit_parameter_request[edit_parameter_requests].edit_string = s_arg[i_arg].list[3];
615 edit_parameter_requests++;
616 break;
617 case ARRAY_MODE:
618 edit_array_request = trealloc(edit_array_request,
619 sizeof(*edit_array_request) * (edit_array_requests + 1));
620 edit_array_request[edit_array_requests].match_string = s_arg[i_arg].list[2];
621 edit_array_request[edit_array_requests].edit_string = s_arg[i_arg].list[3];
622 edit_array_requests++;
623 break;
624 default:
625 fprintf(stderr, "Error (%s): invalid -editnames syntax\n", argv[0]);
626 return 1;
627 }
628 break;
629 case SET_LINES_PER_ROW:
630 if (s_arg[i_arg].n_items != 2 ||
631 sscanf(s_arg[i_arg].list[1], "%ld", &lines_per_row) != 1 ||
632 lines_per_row <= 0) {
633 fprintf(stderr, "Error (%s): invalid -linesperrow syntax\n", argv[0]);
634 return 1;
635 }
636 break;
637 case SET_NOWARNINGS:
638 if (s_arg[i_arg].n_items != 1) {
639 fprintf(stderr, "Error (%s): invalid -nowarnings syntax\n", argv[0]);
640 return 1;
641 }
642 noWarnings = 1;
643 break;
644 case SET_RECOVER:
645 recover = 1;
646 if (s_arg[i_arg].n_items != 1) {
647 recover = 2;
648 if (s_arg[i_arg].n_items > 2 ||
649 strncmp(s_arg[i_arg].list[1], "clip", strlen(s_arg[i_arg].list[1])) != 0) {
650 fprintf(stderr, "Error (%s): invalid -recover syntax\n", argv[0]);
651 return 1;
652 }
653 }
654 break;
655 case SET_PIPE:
656 if (!processPipeOption(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1, &pipeFlags)) {
657 fprintf(stderr, "Error (%s): invalid -pipe syntax\n", argv[0]);
658 return 1;
659 }
660 break;
661 case SET_ACCEPT_ALL_NAMES:
662 SDDS_SetNameValidityFlags(SDDS_ALLOW_ANY_NAME);
663 break;
664 case SET_ROWLIMIT:
665 if (s_arg[i_arg].n_items != 2 ||
666 sscanf(s_arg[i_arg].list[1], "%" SCNd64, &rowLimit) != 1 ||
667 rowLimit < 0) {
668 fprintf(stderr, "Error (%s): invalid -rowLimit syntax\n", argv[0]);
669 return 1;
670 }
671 SDDS_SetRowLimit(rowLimit);
672 break;
673 default:
674 fprintf(stderr, "Error (%s): unknown switch: %s\n", argv[0], s_arg[i_arg].list[0]);
675 return 1;
676 }
677 } else {
678 if (input == NULL)
679 input = s_arg[i_arg].list[0];
680 else if (output == NULL)
681 output = s_arg[i_arg].list[0];
682 else {
683 fprintf(stderr, "Error (%s): too many filenames\n", argv[0]);
684 return 1;
685 }
686 }
687 }
688
689 if (fromPage && toPage && fromPage > toPage) {
690 fprintf(stderr, "Error (%s): invalid -fromPage and -toPage\n", argv[0]);
691 return 1;
692 }
693
694 processFilenames("sddsconvert", &input, &output, pipeFlags, noWarnings, &tmpfile_used);
695
696#ifdef DEBUG
697 fprintf(stderr, "Initializing input and output files.\n");
698#endif
699 if (!SDDS_InitializeInput(&SDDS_orig, input)) {
700 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
701 return 1;
702 }
703
704 if (!set_units_conversion(&SDDS_orig, convert_units_array, convert_units_arrays,
705 convert_units_column, convert_units_columns,
706 convert_units_parameter, convert_units_parameters)) {
707 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
708 return 1;
709 }
710
711 if (!description_text)
712 SDDS_GetDescription(&SDDS_orig, &description_text, &description_contents);
713
714 if (!SDDS_InitializeOutput(&SDDS_dataset,
715 ascii_output ? SDDS_ASCII : (binary_output ? SDDS_BINARY : SDDS_orig.layout.data_mode.mode),
716 lines_per_row, description_text, description_contents, output)) {
717 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
718 return 1;
719 }
720
721 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
722
723 if (column_major != -1)
724 SDDS_dataset.layout.data_mode.column_major = column_major;
725 else
726 SDDS_dataset.layout.data_mode.column_major = SDDS_orig.layout.data_mode.column_major;
727
728#ifdef DEBUG
729 fprintf(stderr, "Getting column, parameter, and array names from input file.\n");
730#endif
731 if (!(orig_column_name = SDDS_GetColumnNames(&SDDS_orig, &orig_column_names))) {
732 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
733 return 1;
734 }
735 if (orig_column_names &&
736 !(new_column_name = process_name_options(orig_column_name, &orig_column_flag, orig_column_names,
737 delete_column, delete_columns,
738 retain_column, retain_columns,
739 rename_column, rename_columns,
740 edit_column_request, edit_column_requests)))
741 return 1;
742
743 if (!(orig_parameter_name = SDDS_GetParameterNames(&SDDS_orig, &orig_parameter_names))) {
744 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
745 return 1;
746 }
747
748#ifdef DEBUG
749 fprintf(stderr, "processing name options\n");
750#endif
751 if (orig_parameter_names &&
752 !(new_parameter_name = process_name_options(orig_parameter_name, &orig_parameter_flag, orig_parameter_names,
753 delete_parameter, delete_parameters,
754 retain_parameter, retain_parameters,
755 rename_parameter, rename_parameters,
756 edit_parameter_request, edit_parameter_requests)))
757 return 1;
758
759 if (!(orig_array_name = SDDS_GetArrayNames(&SDDS_orig, &orig_array_names))) {
760 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
761 return 1;
762 }
763 if (orig_array_names &&
764 !(new_array_name = process_name_options(orig_array_name, &orig_array_flag, orig_array_names,
765 delete_array, delete_arrays,
766 retain_array, retain_arrays,
767 rename_array, rename_arrays,
768 edit_array_request, edit_array_requests)))
769 return 1;
770
771#ifdef DEBUG
772 for (i = 0; i < orig_parameter_names; i++)
773 fprintf(stderr, "parameter %s goes to %s\n", orig_parameter_name[i],
774 orig_parameter_flag[i] ? new_parameter_name[i] : "<deleted>");
775 for (i = 0; i < orig_array_names; i++)
776 fprintf(stderr, "array %s goes to %s\n", orig_array_name[i],
777 orig_array_flag[i] ? new_array_name[i] : "<deleted>");
778 for (i = 0; i < orig_column_names; i++)
779 fprintf(stderr, "column %s goes to %s\n", orig_column_name[i],
780 orig_column_flag[i] ? new_column_name[i] : "<deleted>");
781#endif
782
783#ifdef DEBUG
784 fprintf(stderr, "Transferring definitions to new file\n");
785#endif
786 for (i = 0; i < orig_parameter_names; i++) {
787 if (orig_parameter_flag[i]) {
788 if (!SDDS_TransferParameterDefinition(&SDDS_dataset, &SDDS_orig,
789 orig_parameter_name[i], new_parameter_name[i])) {
790 fprintf(stderr, "unable to transfer parameter %s to %s\n",
791 orig_parameter_name[i], new_parameter_name[i]);
792 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
793 return 1;
794 }
795 }
796 }
797 for (i = 0; i < orig_array_names; i++) {
798 if (orig_array_flag[i]) {
799 if (!SDDS_TransferArrayDefinition(&SDDS_dataset, &SDDS_orig,
800 orig_array_name[i], new_array_name[i])) {
801 fprintf(stderr, "unable to transfer array %s to %s\n",
802 orig_array_name[i], new_array_name[i]);
803 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
804 return 1;
805 }
806 }
807 }
808 //output_columns = 0;
809 for (i = 0; i < orig_column_names; i++) {
810 if (orig_column_flag[i]) {
811 //output_columns++;
812 if (!SDDS_TransferColumnDefinition(&SDDS_dataset, &SDDS_orig,
813 orig_column_name[i], new_column_name[i])) {
814 fprintf(stderr, "unable to transfer column %s to %s\n",
815 orig_column_name[i], new_column_name[i]);
816 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
817 return 1;
818 }
819 }
820 }
821
822#ifdef DEBUG
823 fprintf(stderr, "Writing layout.\n");
824#endif
825 if (!SDDS_WriteLayout(&SDDS_dataset)) {
826 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
827 return 1;
828 }
829
830 max_size = 0;
831 for (i = 0; i < SDDS_NUM_TYPES; i++)
832 if (max_size < SDDS_type_size[i])
833 max_size = SDDS_type_size[i];
834 buffer = tmalloc(max_size * sizeof(char));
835
836 recovered = 0;
837#ifdef DEBUG
838 fprintf(stderr, "Reading file\n");
839#endif
840 while (!recovered && (pageNumber = SDDS_ReadPage(&SDDS_orig)) >= 0) {
841 if (pageNumber == 0) {
842 if (!recover) {
843 fprintf(stderr, "error: SDDS data garbled--consider using -recover option\n");
844 fprintf(stderr, "warning: one or more data pages may be missing\n");
845 break;
846 } else {
847 if (recover != 2 && SDDS_ReadRecoveryPossible(&SDDS_orig))
848 recovered = 1;
849 else {
850 if (recover != 2)
851 fprintf(stderr, "warning: unable to recover data--pages may be missing\n");
852 break;
853 }
854 }
855 }
856 if (fromPage && pageNumber < fromPage)
857 continue;
858 if (removePages) {
859 keep = 1;
860 for (i = 0; i < removePages; i++) {
861 if (removePage[i] == pageNumber) {
862 keep = 0;
863 break;
864 }
865 }
866 if (!keep)
867 continue;
868 }
869 if (keepPages) {
870 keep = 0;
871 for (i = 0; i < keepPages; i++) {
872 if (keepPage[i] == pageNumber) {
873 keep = 1;
874 break;
875 }
876 }
877 if (!keep)
878 continue;
879 }
880 if ((rows = SDDS_RowCount(&SDDS_orig)) < 0) {
881 fprintf(stderr, "error: problem counting rows in input page\n");
882 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
883 return 1;
884 }
885 if (!SDDS_StartPage(&SDDS_dataset, rows)) {
886 fprintf(stderr, "error: problem starting output page\n");
887 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
888 return 1;
889 }
890
891 if (!set_units_conversion(&SDDS_orig, convert_units_array, convert_units_arrays,
892 convert_units_column, convert_units_columns,
893 convert_units_parameter, convert_units_parameters)) {
894 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
895 return 1;
896 }
897
898 for (i = 0; i < orig_parameter_names; i++) {
899 if (orig_parameter_flag[i]) {
900 if (!SDDS_GetParameter(&SDDS_orig, orig_parameter_name[i], buffer)) {
901 fprintf(stderr, "error: problem getting parameter %s\n", orig_parameter_name[i]);
902 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
903 return 1;
904 }
905 if (!SDDS_SetParameters(&SDDS_dataset, SDDS_SET_BY_NAME | SDDS_PASS_BY_REFERENCE,
906 new_parameter_name[i], buffer, NULL)) {
907 fprintf(stderr, "error: problem setting parameter %s\n", new_parameter_name[i]);
908 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
909 return 1;
910 }
911 }
912 }
913 for (i = 0; i < orig_array_names; i++) {
914 SDDS_ARRAY *array;
915 if (orig_array_flag[i]) {
916 if (!(array = SDDS_GetArray(&SDDS_orig, orig_array_name[i], NULL))) {
917 fprintf(stderr, "error: problem getting array %s\n", orig_array_name[i]);
918 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
919 return 1;
920 }
921 if (!SDDS_SetArray(&SDDS_dataset, new_array_name[i], SDDS_CONTIGUOUS_DATA,
922 array->data, array->dimension)) {
923 fprintf(stderr, "error: problem setting array %s\n", new_array_name[i]);
924 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
925 return 1;
926 }
927 SDDS_FreeArray(array);
928 }
929 }
930
931 if (SDDS_CountRowsOfInterest(&SDDS_orig)) {
932 for (i = 0; i < orig_column_names; i++) {
933 if (orig_column_flag[i]) {
934 if (!(ptr = SDDS_GetInternalColumn(&SDDS_orig, orig_column_name[i]))) {
935 fprintf(stderr, "error: problem getting column %s\n", orig_column_name[i]);
936 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
937 return 1;
938 }
939 if (!SDDS_SetColumn(&SDDS_dataset, SDDS_SET_BY_NAME, ptr, rows, new_column_name[i])) {
940 fprintf(stderr, "error: problem setting column %s\n", new_column_name[i]);
941 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
942 return 1;
943 }
944 }
945 }
946 }
947 if (!SDDS_WritePage(&SDDS_dataset)) {
948 fprintf(stderr, "error: problem writing page to file %s\n", output);
949 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
950 return 1;
951 }
952 if (toPage && pageNumber >= toPage)
953 break;
954 }
955
956 if (!SDDS_Terminate(&SDDS_orig) || !SDDS_Terminate(&SDDS_dataset)) {
957 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
958 return 1;
959 }
960
961 if (tmpfile_used && !replaceFileAndBackUp(input, output))
962 return 1;
963
964 for (i = 0; i < orig_parameter_names; i++) {
965 if (orig_parameter_name[i])
966 free(orig_parameter_name[i]);
967 if (new_parameter_name[i])
968 free(new_parameter_name[i]);
969 }
970 if (orig_parameter_name)
971 free(orig_parameter_name);
972 if (new_parameter_name)
973 free(new_parameter_name);
974 if (orig_parameter_flag)
975 free(orig_parameter_flag);
976
977 for (i = 0; i < orig_column_names; i++) {
978 if (orig_column_name[i])
979 free(orig_column_name[i]);
980 if (new_column_name[i])
981 free(new_column_name[i]);
982 }
983 if (orig_column_name)
984 free(orig_column_name);
985 if (new_column_name)
986 free(new_column_name);
987 if (orig_column_flag)
988 free(orig_column_flag);
989
990 for (i = 0; i < orig_array_names; i++) {
991 if (orig_array_name[i])
992 free(orig_array_name[i]);
993 if (new_array_name[i])
994 free(new_array_name[i]);
995 }
996 if (orig_array_name)
997 free(orig_array_name);
998 if (new_array_name)
999 free(new_array_name);
1000 if (orig_array_flag)
1001 free(orig_array_flag);
1002
1003 return 0;
1004}
1005
1006static char **process_name_options(char **orig_name, long **orig_flag, long orig_names,
1007 char **delete, long deletes, char **retain, long retains,
1008 STRING_PAIR *rename, long renames,
1009 EDIT_NAME_REQUEST *edit_request, long edit_requests) {
1010 long i, j;
1011 char **new_name;
1012 char *ptr;
1013
1014 *orig_flag = tmalloc(sizeof(**orig_flag) * orig_names);
1015 for (i = 0; i < orig_names; i++)
1016 (*orig_flag)[i] = 1;
1017
1018 if (deletes) {
1019 for (i = 0; i < deletes; i++) {
1020 ptr = expand_ranges(delete[i]);
1021 free(delete[i]);
1022 delete[i] = ptr;
1023 }
1024 for (j = 0; j < orig_names; j++) {
1025 for (i = 0; i < deletes; i++) {
1026 if (wild_match(orig_name[j], delete[i])) {
1027 (*orig_flag)[j] = 0;
1028 break;
1029 }
1030 }
1031 }
1032 }
1033
1034 if (retains) {
1035 for (i = 0; i < retains; i++) {
1036 ptr = expand_ranges(retain[i]);
1037 free(retain[i]);
1038 retain[i] = ptr;
1039 }
1040 if (!deletes)
1041 for (j = 0; j < orig_names; j++)
1042 (*orig_flag)[j] = 0;
1043 for (j = 0; j < orig_names; j++) {
1044 if ((*orig_flag)[j])
1045 continue;
1046 for (i = 0; i < retains; i++) {
1047 if (wild_match(orig_name[j], retain[i])) {
1048 (*orig_flag)[j] = 1;
1049 break;
1050 }
1051 }
1052 }
1053 }
1054
1055 new_name = tmalloc(sizeof(*new_name) * orig_names);
1056 for (j = 0; j < orig_names; j++) {
1057 for (i = 0; i < renames; i++) {
1058 if (strcmp(rename[i][0], orig_name[j]) == 0) {
1059 SDDS_CopyString(new_name + j, rename[i][1]);
1060 break;
1061 }
1062 }
1063 if (i == renames)
1064 SDDS_CopyString(new_name + j, orig_name[j]);
1065 for (i = 0; i < edit_requests; i++) {
1066 char edit_buffer[256];
1067 ptr = expand_ranges(edit_request[i].match_string);
1068 free(edit_request[i].match_string);
1069 edit_request[i].match_string = ptr;
1070 if (wild_match(new_name[j], edit_request[i].match_string)) {
1071 strcpy(edit_buffer, new_name[j]);
1072 if (!edit_string(edit_buffer, edit_request[i].edit_string))
1073 SDDS_Bomb("error editing name");
1074 free(new_name[j]);
1075 SDDS_CopyString(&new_name[j], edit_buffer);
1076 }
1077 }
1078 }
1079
1080 return new_name;
1081}
SDDS.h
SDDS (Self Describing Data Set) Data Types Definitions and Function Prototypes.
SDDS_ReadRecoveryPossible
int32_t SDDS_ReadRecoveryPossible(SDDS_DATASET *SDDS_dataset)
Checks if any data in an SDDS page was recovered after an error was detected.
Definition SDDS_binary.c:2075
SDDS_type_size
int32_t SDDS_type_size[SDDS_NUM_TYPES]
Array of sizes for each supported data type.
Definition SDDS_data.c:62
SDDS_StartPage
int32_t SDDS_StartPage(SDDS_DATASET *SDDS_dataset, int64_t expected_n_rows)
Definition SDDS_dataprep.c:70
SDDS_SetParameters
int32_t SDDS_SetParameters(SDDS_DATASET *SDDS_dataset, int32_t mode,...)
Definition SDDS_dataprep.c:375
SDDS_SetColumn
int32_t SDDS_SetColumn(SDDS_DATASET *SDDS_dataset, int32_t mode, void *data, int64_t rows,...)
Sets the values for one data column in the current data table of an SDDS dataset.
Definition SDDS_dataprep.c:1542
SDDS_SetArray
int32_t SDDS_SetArray(SDDS_DATASET *SDDS_dataset, char *array_name, int32_t mode, void *data_pointer, int32_t *dimension)
Sets the values of an array variable in the SDDS dataset using specified dimensions.
Definition SDDS_dataprep.c:1284
SDDS_CountRowsOfInterest
int64_t SDDS_CountRowsOfInterest(SDDS_DATASET *SDDS_dataset)
Counts the number of rows marked as "of interest" in the current data table.
Definition SDDS_extract.c:364
SDDS_SetParameterUnitsConversion
int32_t SDDS_SetParameterUnitsConversion(SDDS_DATASET *SDDS_dataset, char *parameter_name, char *new_units, char *old_units, double factor)
Sets unit conversions for a specified parameter in an SDDS dataset.
Definition SDDS_extract.c:4904
SDDS_SetColumnUnitsConversion
int32_t SDDS_SetColumnUnitsConversion(SDDS_DATASET *SDDS_dataset, char *column_name, char *new_units, char *old_units, double factor)
Sets unit conversions for a specified column in an SDDS dataset.
Definition SDDS_extract.c:4789
SDDS_GetArray
SDDS_ARRAY * SDDS_GetArray(SDDS_DATASET *SDDS_dataset, char *array_name, SDDS_ARRAY *memory)
Retrieves an array from the current data table of an SDDS dataset.
Definition SDDS_extract.c:4210
SDDS_GetInternalColumn
void * SDDS_GetInternalColumn(SDDS_DATASET *SDDS_dataset, char *column_name)
Retrieves an internal pointer to the data of a specified column, including all rows.
Definition SDDS_extract.c:688
SDDS_GetParameter
void * SDDS_GetParameter(SDDS_DATASET *SDDS_dataset, char *parameter_name, void *memory)
Retrieves the value of a specified parameter from the current data table of a data set.
Definition SDDS_extract.c:2482
SDDS_GetDescription
int32_t SDDS_GetDescription(SDDS_DATASET *SDDS_dataset, char **text, char **contents)
Retrieves the text and contents descriptions from an SDDS dataset.
Definition SDDS_extract.c:4627
SDDS_SetArrayUnitsConversion
int32_t SDDS_SetArrayUnitsConversion(SDDS_DATASET *SDDS_dataset, char *array_name, char *new_units, char *old_units, double factor)
Sets unit conversions for a specified array in an SDDS dataset.
Definition SDDS_extract.c:4676
SDDS_SetRowLimit
int64_t SDDS_SetRowLimit(int64_t limit)
Definition SDDS_input.c:1243
SDDS_InitializeInput
int32_t SDDS_InitializeInput(SDDS_DATASET *SDDS_dataset, char *filename)
Definition SDDS_input.c:50
SDDS_Terminate
int32_t SDDS_Terminate(SDDS_DATASET *SDDS_dataset)
Definition SDDS_input.c:1471
SDDS_ReadPage
int32_t SDDS_ReadPage(SDDS_DATASET *SDDS_dataset)
Definition SDDS_input.c:1007
SDDS_InitializeOutput
int32_t SDDS_InitializeOutput(SDDS_DATASET *SDDS_dataset, int32_t data_mode, int32_t lines_per_row, const char *description, const char *contents, const char *filename)
Initializes the SDDS output dataset.
Definition SDDS_output.c:602
SDDS_SetNameValidityFlags
int32_t SDDS_SetNameValidityFlags(uint32_t flags)
Sets the validity flags for parameter and column names in the SDDS dataset.
Definition SDDS_output.c:2060
SDDS_WritePage
int32_t SDDS_WritePage(SDDS_DATASET *SDDS_dataset)
Writes the current data table to the output file.
Definition SDDS_output.c:1229
SDDS_WriteLayout
int32_t SDDS_WriteLayout(SDDS_DATASET *SDDS_dataset)
Writes the SDDS layout header to the output file.
Definition SDDS_output.c:900
SDDS_TransferColumnDefinition
int32_t SDDS_TransferColumnDefinition(SDDS_DATASET *target, SDDS_DATASET *source, char *name, char *newName)
Transfers a column definition from a source dataset to a target dataset.
Definition SDDS_transfer.c:35
SDDS_TransferArrayDefinition
int32_t SDDS_TransferArrayDefinition(SDDS_DATASET *target, SDDS_DATASET *source, char *name, char *newName)
Transfers an array definition from a source dataset to a target dataset.
Definition SDDS_transfer.c:111
SDDS_TransferParameterDefinition
int32_t SDDS_TransferParameterDefinition(SDDS_DATASET *target, SDDS_DATASET *source, char *name, char *newName)
Transfers a parameter definition from a source dataset to a target dataset.
Definition SDDS_transfer.c:73
SDDS_FreeArray
void SDDS_FreeArray(SDDS_ARRAY *array)
Frees memory allocated for an SDDS array structure.
Definition SDDS_utils.c:2832
SDDS_GetParameterNames
char ** SDDS_GetParameterNames(SDDS_DATASET *SDDS_dataset, int32_t *number)
Retrieves the names of all parameters in the SDDS dataset.
Definition SDDS_utils.c:2567
SDDS_GetColumnNames
char ** SDDS_GetColumnNames(SDDS_DATASET *SDDS_dataset, int32_t *number)
Retrieves the names of all columns in the SDDS dataset.
Definition SDDS_utils.c:2526
SDDS_PrintErrors
void SDDS_PrintErrors(FILE *fp, int32_t mode)
Prints recorded error messages to a specified file stream.
Definition SDDS_utils.c:474
SDDS_RegisterProgramName
void SDDS_RegisterProgramName(const char *name)
Registers the executable program name for use in error messages.
Definition SDDS_utils.c:318
SDDS_Bomb
void SDDS_Bomb(char *message)
Terminates the program after printing an error message and recorded errors.
Definition SDDS_utils.c:380
SDDS_GetArrayNames
char ** SDDS_GetArrayNames(SDDS_DATASET *SDDS_dataset, int32_t *number)
Retrieves the names of all arrays in the SDDS dataset.
Definition SDDS_utils.c:2605
SDDS_CopyString
int32_t SDDS_CopyString(char **target, const char *source)
Copies a source string to a target string with memory allocation.
Definition SDDS_utils.c:922
edit_string
long edit_string(char *text, char *edit)
Edits the provided text based on the specified edit commands.
Definition edit_string.c:75
SDDS_NUM_TYPES
#define SDDS_NUM_TYPES
Total number of defined SDDS data types.
Definition SDDStypes.h:97
trealloc
void * trealloc(void *old_ptr, uint64_t size_of_block)
Reallocates a memory block to a new size.
Definition array.c:190
tmalloc
void * tmalloc(uint64_t size_of_block)
Allocates a memory block of the specified size with zero initialization.
Definition array.c:65
delete_chars
char * delete_chars(char *s, char *t)
Removes all occurrences of characters found in string t from string s.
Definition delete_chars.c:28
match_string
long match_string(char *string, char **option, long n_options, long mode)
Matches a given string against an array of option strings based on specified modes.
Definition match_string.c:34
replaceFileAndBackUp
long replaceFileAndBackUp(char *file, char *replacement)
Replaces a file with a replacement file and creates a backup of the original.
Definition replacefile.c:78
scanargs
int scanargs(SCANNED_ARG **scanned, int argc, char **argv)
Definition scanargs.c:36
processPipeOption
long processPipeOption(char **item, long items, unsigned long *flags)
Definition scanargs.c:357
processFilenames
void processFilenames(char *programName, char **input, char **output, unsigned long pipeFlags, long noWarnings, long *tmpOutputUsed)
Definition scanargs.c:391
scanItemList
long scanItemList(unsigned long *flags, char **item, long *items, unsigned long mode,...)
Scans a list of items and assigns values based on provided keywords and types.
Definition scanitemlist.c:41
CONVERT_UNITS
Definition sddsconvert.c:170
EDIT_NAME_REQUEST
Definition sddsconvert.c:166
SDDS_ARRAY
Definition SDDS.h:290
SDDS_DATASET
Definition SDDS.h:308
expand_ranges
char * expand_ranges(char *template)
Expand range specifiers in a wildcard template into explicit character lists.
Definition wild_match.c:429
wild_match
int wild_match(char *string, char *template)
Determine whether one string is a wildcard match for another.
Definition wild_match.c:49
Generated by doxygen 1.12.0