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