SDDS ToolKit Programs and Libraries for C and Python
Loading...
Searching...
No Matches
sddsprocess.c
Go to the documentation of this file.
1/**
2 * @file sddsprocess.c
3 * @brief Processes SDDS files by applying various transformations to columns and parameters.
4 *
5 * This program reads an input SDDS (Self Describing Data Sets) file, processes its columns and parameters
6 * based on the specified options, and writes the results to a new SDDS output file. It supports a wide
7 * range of operations including filtering, matching, editing, defining new parameters or columns,
8 * converting units, and more.
9 *
10 * @section Usage
11 * ```
12 * sddsprocess [<SDDSinputfile>] [<SDDSoutputfile>]
13 * -pipe=[input][,output]
14 * -ifis={column|parameter},<name>[,...]
15 * -ifnot={column|parameter},<name>[,...]
16 * -match={column|parameter},<match-test>[,<match-test>[,<logic-operation>...]]
17 * -filter={column|parameter},<range-spec>[,<range-spec>[,<logic-operation>...]]
18 * -timeFilter={parameter|column},[,before=YYYY/MM/DD@HH:MM:SS][,after=YYYY/MM/DD@HH:MM:SS][,invert]
19 * -clip=<head>,<tail>,[invert]
20 * -sparse=<interval>[,<offset>]
21 * -sample=<fraction>
22 * -fclip=<head>,<tail>,[invert]
23 * -test={column|parameter},<test>[,autostop][,algebraic]
24 * -numberTest={column|parameter},<name>[,invert]
25 * -rpndefinitionsfiles=<filename>[,...]
26 * -rpnexpression=<expression>[,repeat][,algebraic]
27 * -convertunits={column|parameter},<name>,<new-units>,<old-units>[,<factor>]
28 * -define={column|parameter},<name>,{<equation>|@<parameterName>}[,<definition_entries>][,algebraic]
29 * -redefine={column|parameter},<name>,{<equation>|@<parameterName>}[,<definition_entries>][,algebraic]
30 * -cast={column|parameter},<newName>,<sourceName>,<newType>
31 * -scan={column|parameter},<new-name>,<source-name>,<sscanf-string>[,<definition-entries>][,edit=<string>]
32 * -edit={column|parameter},<new-name>,<source-name>,<edit-string>[,<definition-entries>]
33 * -reedit={column|parameter},<name>,<edit-string>[,<definition-entries>]
34 * -print={column|parameter},<new-name>,<sprintf-string>,<source-name>[,...][,<definition-entries>]
35 * -reprint={column|parameter},<new-name>,<sprintf-string>,<source-name>[,...][,<definition-entries>]
36 * -format={column|parameter},<new-name>,<source-name>[,stringFormat=<sprintfString>][,doubleFormat=<sprintfString>][,longFormat=<sprintfString>]
37 * -system={column|parameter},<new-name>,<command-name>[,<definition_entries>]
38 * -evaluate={column|parameter},<new-name>,<expression-name>[,<definition_entries>]
39 * -process=<column-name>,<analysis-name>,<result-name>[,description=<string>][,symbol=<string>][,weightBy=<column-name>][,functionOf=<column-name>[,lowerLimit=<value>][,upperLimit=<value>][,position]][,head=<number>][,tail=<number>][fhead=<fraction>][ftail=<fraction>][,topLimit=<value>][,bottomLimit=<value>][,offset=<value>][,factor=<value>][match=<column-name>,value=<string>][,overwrite],[default=<value>]
40 * -summarize
41 * -verbose
42 * -nowarnings
43 * -delete={column|parameter|array},<matching-string>[,...]
44 * -retain={column|parameter|array},<matching-string>[,...]
45 * -description=[text=<string>][,contents=<string>]
46 * -majorOrder=row|column
47 * -xzLevel=<0-9>
48 * -threads=<number>
49 * ```
50 *
51 * @section Options
52 * | Optional | Description |
53 * |-------------------------------------|----------------------------------------------------------------------------------|
54 * | `-pipe` | Directs input/output via pipes. |
55 * | `-ifis` | Include only the specified columns or parameters. |
56 * | `-ifnot` | Exclude the specified columns or parameters. |
57 * | `-match` | Filter data based on matching criteria for columns or parameters. |
58 * | `-filter` | Apply range-based filtering on specified columns or parameters. |
59 * | `-timeFilter` | Filter data based on time constraints. |
60 * | `-clip` | Clip the dataset by removing a specified number of rows from the head and tail. |
61 * | `-sparse` | Retain every `<interval>`-th row starting from `<offset>`. |
62 * | `-sample` | Randomly sample rows based on the specified fraction. |
63 * | `-fclip` | Fractional clipping based on the fraction of rows. |
64 * | `-test` | Apply RPN-based tests on columns or parameters with optional autostop. |
65 * | `-numberTest` | Perform numerical tests on specified columns or parameters. |
66 * | `-rpndefinitionsfiles` | Specify files containing RPN definitions. |
67 * | `-rpnexpression` | Define RPN expressions to be evaluated. |
68 * | `-convertunits` | Convert units of a specified column or parameter. |
69 * | `-define` | Define new columns or parameters based on equations or existing parameters. |
70 * | `-redefine` | Redefine existing columns or parameters. |
71 * | `-cast` | Cast a column or parameter to a new data type. |
72 * | `-scan` | Scan and parse data from a source column or parameter. |
73 * | `-edit` | Edit values of a column or parameter based on specified rules. |
74 * | `-reedit` | Re-edit existing columns or parameters. |
75 * | `-print` | Print formatted data from a source to a new column or parameter. |
76 * | `-reprint` | Reprint existing columns or parameters with new formatting. |
77 * | `-format` | Apply formatting to columns or parameters. |
78 * | `-system` | Execute system commands and capture their output. |
79 * | `-evaluate` | Evaluate expressions to compute new columns or parameters. |
80 * | `-process` | Perform various processing operations on specified columns. |
81 * | `-summarize` | Display a summary of the processing operations performed. |
82 * | `-verbose` | Enable verbose output for detailed processing information. |
83 * | `-nowarnings` | Suppress warning messages. |
84 * | `-delete` | Delete specified columns, parameters, or arrays. |
85 * | `-retain` | Retain only the specified columns, parameters, or arrays. |
86 * | `-description` | Add or modify the description of the output SDDS file. |
87 * | `-majorOrder` | Set the major order of the output data (row-major or column-major). |
88 * | `-xzLevel` | Set LZMA compression level when writing .xz files. |
89 * | `-threads` | Specify the number of threads to use for processing. |
90 *
91 * @section processingModes Processing Modes
92 * | Modes | | | |
93 * |----------------|---------------|--------------|---------------------|
94 * | average | rms | sum | standarddeviation |
95 * | mad | minimum | maximum | smallest |
96 * | largest | first | last | count |
97 * | spread | median | baselevel | toplevel |
98 * | amplitude | risetime | falltime | fwhm |
99 * | fwtm | center | zerocrossing | fwha |
100 * | fwta | sigma | slope | intercept |
101 * | lfsd | qrange | drange | percentile |
102 * | mode | integral | product | prange |
103 * | signedsmallest | signedlargest | gmintegral | correlation |
104 *
105 * @subsection additonalInformation Additional Information
106 * - `<match-test>` is of the form `<name>=<matching-string>[,!]`, where ! signifies logical negation.
107 * - `<logic-operation>` is one of & (logical and) or | (logical or), optionally followed by a ! to logically negate the value of the expression.
108 * - `<range-spec>` is of the form `<name>,<lower-value>,<upper-value>[,!]`.
109 * - `<test>` is an RPN expression leaving a value on the logic stack.
110 * - `<definition-entry>` is of the form `<entry-name>=<value>`, where `<entry-name>` is one of "symbol", "units", "description", "format_string", and "type".
111 *
112 * @copyright
113 * - (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
114 * - (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.
115 *
116 * @license
117 * This file is distributed under the terms of the Software License Agreement
118 * found in the file LICENSE included with this distribution.
119 *
120 * @author M. Borland, C. Saunders, R. Soliday, H. Shang
121 */
122
123#include "mdb.h"
124#include "scan.h"
125#include "SDDS.h"
126#include "SDDSaps.h"
127#include "rpn.h"
128#include <sys/types.h>
129#if !defined(_WIN32)
130# include <sys/time.h>
131#endif
132
133#define COLUMN_MODE 0
134#define PARAMETER_MODE 1
135#define ARRAY_MODE 2
136#define MODES 3
137 static char *mode_name[MODES] = {
138 "column",
139 "parameter",
140 "array",
141 };
142
143/* Enumeration for option types */
144enum option_type {
145 SET_PROCESS,
146 SET_MATCH,
147 SET_FILTER,
148 SET_RPN_DEFNS_FILES,
149 SET_RPN_EXPRESSION,
150 SET_DEFINITION,
151 SET_TEST,
152 SET_SUMMARIZE,
153 SET_VERBOSE,
154 SET_CONVERT_UNITS,
155 SET_SCAN,
156 SET_PRINT,
157 SET_EDIT,
158 SET_SYSTEM,
159 SET_REDEFINITION,
160 SET_NOWARNINGS,
161 SET_IFNOT,
162 SET_IFIS,
163 SET_CLIP,
164 SET_SPARSE,
165 SET_SAMPLE,
166 SET_PIPE,
167 SET_NUMBERTEST,
168 SET_REEDIT,
169 SET_FORMAT,
170 SET_CAST,
171 SET_REPRINT,
172 SET_DELETE,
173 SET_RETAIN,
174 SET_DESCRIPTION,
175 SET_FCLIP,
176 SET_TIME_FILTER,
177 SET_MAJOR_ORDER,
178 SET_EVALUATE,
179 SET_THREADS,
180 SET_XZLEVEL,
181 N_OPTIONS
182};
183
184char *option[N_OPTIONS] = {
185 "process",
186 "match",
187 "filter",
188 "rpndefinitionsfiles",
189 "rpnexpression",
190 "define",
191 "test",
192 "summarize",
193 "verbose",
194 "convertunits",
195 "scan",
196 "print",
197 "edit",
198 "system",
199 "redefine",
200 "nowarnings",
201 "ifnot",
202 "ifis",
203 "clip",
204 "sparse",
205 "sample",
206 "pipe",
207 "numbertest",
208 "reedit",
209 "format",
210 "cast",
211 "reprint",
212 "delete",
213 "retain",
214 "description",
215 "fclip",
216 "timeFilter",
217 "majorOrder",
218 "evaluate",
219 "threads",
220 "xzlevel",
221};
222
223char *usageArray[] = {
224 "Usage:\n",
225 " sddsprocess [<SDDSinputfile>] [<SDDSoutputfile>] [OPTIONS]\n",
226 "\n",
227 "Options:\n",
228 " -pipe=[input][,output]\n",
229 " Use pipe mode with optional input and output streams.\n",
230 " -ifis={column|parameter},<name>[,...]\n",
231 " Include only the specified columns or parameters.\n",
232 " -ifnot={column|parameter},<name>[,...]\n",
233 " Exclude the specified columns or parameters.\n",
234 " -match={column|parameter},<match-test>[,<match-test>,...]\n",
235 " Filter data based on matching criteria for columns or parameters.\n",
236 " -filter={column|parameter},<range-spec>[,<range-spec>,...]\n",
237 " Apply range-based filtering on specified columns or parameters.\n",
238 " -timeFilter={parameter|column},[,before=YYYY/MM/DD@HH:MM:SS][,after=YYYY/MM/DD@HH:MM:SS][,invert]\n",
239 " Filter data based on time constraints.\n",
240 " -clip=<head>,<tail>,[invert]\n",
241 " Clip the dataset by removing a specified number of rows from the head and tail.\n",
242 " -sparse=<interval>[,<offset>]\n",
243 " Retain every <interval>-th row starting from <offset>.\n",
244 " -sample=<fraction>\n",
245 " Randomly sample rows based on the specified fraction.\n",
246 " -fclip=<head>,<tail>,[invert]\n",
247 " Fractional clipping based on the fraction of rows.\n",
248 " -test={column|parameter},<test>[,autostop][,algebraic]\n",
249 " Apply RPN-based tests on columns or parameters with optional autostop.\n",
250 " -numberTest={column|parameter},<name>[,invert]\n",
251 " Perform numerical tests on specified columns or parameters.\n",
252 " -rpndefinitionsfiles=<filename>[,...]\n",
253 " Specify files containing RPN definitions.\n",
254 " -rpnexpression=<expression>[,repeat][,algebraic]\n",
255 " Define RPN expressions to be evaluated.\n",
256 " -convertunits={column|parameter},<name>,<new-units>,<old-units>[,<factor>]\n",
257 " Convert units of a specified column or parameter.\n",
258 " -define={column|parameter},<name>,{<equation>|@<parameterName>}[,<definition_entries>][,algebraic]\n",
259 " Define new columns or parameters based on equations or existing parameters.\n",
260 " -redefine={column|parameter},<name>,{<equation>|@<parameterName>}[,<definition_entries>][,algebraic]\n",
261 " Redefine existing columns or parameters.\n",
262 " -cast={column|parameter},<newName>,<sourceName>,<newType>\n",
263 " Cast a column or parameter to a new data type.\n",
264 " -scan={column|parameter},<new-name>,<source-name>,<sscanf-string>[,<definition-entries>][,edit=<string>]\n",
265 " Scan and parse data from a source column or parameter.\n",
266 " -edit={column|parameter},<new-name>,<source-name>,<edit-string>[,<definition-entries>]\n",
267 " Edit values of a column or parameter based on specified rules.\n",
268 " -reedit={column|parameter},<name>,<edit-string>[,<definition-entries>]\n",
269 " Re-edit existing columns or parameters.\n",
270 " -print={column|parameter},<new-name>,<sprintf-string>,<source-name>[,...][,<definition-entries>]\n",
271 " Print formatted data from a source to a new column or parameter.\n",
272 " -reprint={column|parameter},<new-name>,<sprintf-string>,<source-name>[,...][,<definition-entries>]\n",
273 " Reprint existing columns or parameters with new formatting.\n",
274 " -format={column|parameter},<new-name>,<source-name>[,stringFormat=<sprintfString>][,doubleFormat=<sprintfString>][,longFormat=<sprintfString>]\n",
275 " Apply formatting to columns or parameters.\n",
276 " -system={column|parameter},<new-name>,<command-name>[,<definition_entries>]\n",
277 " Execute system commands and capture their output.\n",
278 " -evaluate={column|parameter},<new-name>,<expression-name>[,<definition_entries>]\n",
279 " Evaluate expressions to compute new columns or parameters.\n",
280 " -process=<column-name>,<analysis-name>,<result-name>[,description=<string>][,symbol=<string>][,weightBy=<column-name>][,functionOf=<column-name>[,lowerLimit=<value>][,upperLimit=<value>][,position]][,head=<number>][,tail=<number>][fhead=<fraction>][ftail=<fraction>][,topLimit=<value>][,bottomLimit=<value>][,offset=<value>][,factor=<value>][match=<column-name>,value=<string>][,overwrite],[default=<value>]\n",
281 " Perform various processing operations on specified columns.\n",
282 " -summarize\n",
283 " Display a summary of the processing operations performed.\n",
284 " -verbose\n",
285 " Enable verbose output for detailed processing information.\n",
286 " -nowarnings\n",
287 " Suppress warning messages.\n",
288 " -delete={column|parameter|array},<matching-string>[,...]\n",
289 " Delete specified columns, parameters, or arrays.\n",
290 " -retain={column|parameter|array},<matching-string>[,...]\n",
291 " Retain only the specified columns, parameters, or arrays.\n",
292 " -description=[text=<string>][,contents=<string>]\n",
293 " Add or modify the description of the output SDDS file.\n",
294 " -majorOrder=row|column\n",
295 " Set the major order of the output data (row-major or column-major).\n",
296 " -xzLevel=<0-9>\n",
297 " Set LZMA compression level when writing .xz files.\n",
298 " -threads=<number>\n",
299 " Specify the number of threads to use for processing.\n",
300 "\n",
301 "Additional Information:\n",
302 " A <match-test> is of the form <name>=<matching-string>[,!], where ! signifies logical negation.\n",
303 " A <logic-operation> is one of & (logical and) or | (logical or), optionally followed by a ! to logically negate the value of the expression.\n",
304 " A <range-spec> is of the form <name>,<lower-value>,<upper-value>[,!].\n",
305 " A <test> is an RPN expression leaving a value on the logic stack.\n",
306 " A <definition-entry> is of the form <entry-name>=<value>, where <entry-name> is one of \"symbol\", \"units\", \"description\", \"format_string\", and \"type\".\n",
307 "\n",
308 "Description:\n",
309 " sddsprocess reads data from an SDDS file, processes it according to the specified options, and writes the results to a new SDDS file.\n",
310 "Program by Michael Borland. (" __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION ")\n",
311 NULL};
312
313#define PARAMETER_OR_COLUMN(is_param) ((is_param) ? "parameter" : "column")
314
315#define REDEFINABLE_TYPE(type) (SDDS_NUMERIC_TYPE(type) || (type) == SDDS_CHARACTER)
316
317/*
318 static char *colpar_choice[2] = {"column", "parameter"};
319*/
320static RPN_THREAD_LOCAL long table_number_mem = -1, i_page_mem = -1, n_rows_mem = -1, i_row_mem = -1;
321
322typedef char *STRING_PAIR[2];
323
324typedef struct
325{
326 char *match_string, *edit_string;
327} EDIT_NAME_REQUEST;
328
329char **process_name_options(char **orig_name, long **orig_flag, long orig_names, char **delete, long deletes,
330 char **retain, long retains, STRING_PAIR *rename, long renames,
331 EDIT_NAME_REQUEST *edit_request, long edit_requests);
332long SDDS_ComputeSetOfColumns(SDDS_DATASET *SDDS_dataset, long equ_begin, long equ_end, DEFINITION *definition);
333void free_processing_definiton(PROCESSING_DEFINITION **processing_definition, long n);
334void free_equation_definition(EQUATION_DEFINITION **equation_definition, long n);
335long SDDS_EvaluateColumn(SDDS_DATASET *SDDS_dataset, EVALUATE_DEFINITION *definition);
336long SDDS_EvaluateParameter(SDDS_DATASET *SDDS_dataset, EVALUATE_DEFINITION *definition);
337
338int main(int argc, char **argv) {
339 SDDS_DATASET SDDS_input, SDDS_output;
340 PARAMETER_DEFINITION *pardefptr;
341 //long output_columns;
342 char *description_text, *description_contents;
343 unsigned long flags;
344
345 PROCESSING_DEFINITION **processing_definition, *processing_ptr;
346 long processing_definitions;
347 CONVERSION_DEFINITION **conversion, *conversion_ptr;
348 long conversions;
349 EDIT_DEFINITION **edit_definition, *edit_ptr;
350 long edit_definitions;
351 EQUATION_DEFINITION **equation_definition, *equation_ptr;
352 long equation_definitions;
353 EVALUATE_DEFINITION **evaluate_definition, *evaluate_ptr;
354 long evaluate_definitions;
355 SCAN_DEFINITION **scan_definition, *scan_ptr;
356 long scan_definitions;
357 PRINT_DEFINITION **print_definition, *print_ptr;
358 long print_definitions;
359 FORMAT_DEFINITION **format_definition, *format_ptr;
360 long format_definitions;
361 FILTER_TERM *filter_term;
362 FILTER_DEFINITION **filter_definition, *filter_ptr;
363 long filter_definitions;
364 TIME_FILTER_DEFINITION **time_filter_definition, *time_filter_ptr;
365 long time_filter_definitions;
366 MATCH_TERM *match_term;
367 MATCH_DEFINITION **match_definition, *match_ptr;
368 long match_definitions;
369 RPNTEST_DEFINITION **rpntest_definition, *rpntest_ptr;
370 long rpntest_definitions;
371 NUMBERTEST_DEFINITION **numbertest_definition, *numbertest_ptr;
372 long numbertest_definitions;
373 SYSTEM_DEFINITION **system_definition, *system_ptr;
374 long system_definitions;
375 RPNEXPRESSION_DEFINITION **rpnexpression_definition, *rpnexpression_ptr;
376 long rpnexpression_definitions;
377 CLIP_DEFINITION **clip_definition, *clip_ptr;
378 FCLIP_DEFINITION **fclip_definition, *fclip_ptr;
379 long clip_definitions, fclip_definitions;
380 SPARSE_DEFINITION **sparse_definition, *sparse_ptr;
381 long sparse_definitions;
382 SAMPLE_DEFINITION **sample_definition, *sample_ptr;
383 long sample_definitions;
384 DEFINITION *definition;
385 long definitions;
386 CAST_DEFINITION **cast_definition, *cast_ptr;
387 long cast_definitions;
388
389 IFITEM_LIST ifnot_item, ifis_item;
390 char *inputfile, *outputfile;
391
392 int64_t n_rows, j;
393 long i, k, i_arg, summarize, verbose, index = 0, tmpfile_used, nowarnings, udfCounter;
394 long page_number, accept;
395 SCANNED_ARG *s_arg;
396 char s[SDDS_MAXLINE];
397
398 char **rpn_definitions_file, *stringResult;
399 long rpn_definitions_files;
400 int32_t test_result;
401 long original_parameters;
402 double result;
403 long i_page_memory, table_number_memory, n_rows_memory, row_deletion, skip_page;
404 long random_number_seed;
405 unsigned long pipeFlags, majorOrderFlag;
406 long xzLevel = SDDS_GetLZMACompressionLevel();
407
408 char **retain_column, **delete_column;
409 long retain_columns, delete_columns, rename_columns, edit_column_requests;
410 EDIT_NAME_REQUEST *edit_column_request;
411 STRING_PAIR *rename_column;
412 char **orig_column_name, **new_column_name;
413 long *orig_column_flag;
414 int32_t orig_column_names;
415
416 char **retain_parameter, **delete_parameter;
417 long retain_parameters, delete_parameters, rename_parameters, edit_parameter_requests;
418 EDIT_NAME_REQUEST *edit_parameter_request;
419 STRING_PAIR *rename_parameter;
420 char **orig_parameter_name, **new_parameter_name;
421 long *orig_parameter_flag;
422 int32_t orig_parameter_names;
423
424 char **retain_array, **delete_array;
425 long retain_arrays, delete_arrays, rename_arrays, edit_array_requests;
426 EDIT_NAME_REQUEST *edit_array_request;
427 STRING_PAIR *rename_array;
428 char **orig_array_name, **new_array_name;
429 long *orig_array_flag;
430 int32_t orig_array_names;
431 short columnMajorOrder = -1;
432
433 int threads = 1;
434
435 char buffer[SDDS_MAXLINE];
436
437 SDDS_RegisterProgramName(argv[0]);
438
439 argc = scanargs(&s_arg, argc, argv);
440 argc = add_sddsfile_arguments(&s_arg, argc);
441
442 random_number_seed = (long)time((time_t *)NULL);
443 random_number_seed = 2 * (random_number_seed / 2) + 1;
444#if defined(_WIN32)
445 random_1(-labs((double)random_number_seed));
446#else
447 random_1(-FABS((double)random_number_seed));
448#endif
449
450 retain_column = delete_column = NULL;
451 retain_columns = delete_columns = rename_columns = edit_column_requests = 0;
452 rename_column = NULL;
453 edit_column_request = NULL;
454
455 retain_parameter = delete_parameter = NULL;
456 retain_parameters = delete_parameters = rename_parameters = edit_parameter_requests = 0;
457 rename_parameter = NULL;
458 edit_parameter_request = NULL;
459
460 retain_array = delete_array = NULL;
461 retain_arrays = delete_arrays = rename_arrays = edit_array_requests = 0;
462 rename_array = NULL;
463 edit_array_request = NULL;
464
465 description_text = description_contents = NULL;
466 new_parameter_name = new_column_name = new_array_name = NULL;
467
468 if (argc < 3) {
469 char **ptr;
470 ptr = usageArray;
471 while (*ptr) {
472 fprintf(stderr, "%s", *ptr);
473 ptr++;
474 }
475 show_process_modes(stderr);
476 exit(EXIT_FAILURE);
477 }
478
479 inputfile = outputfile = NULL;
480 rpn_definitions_file = NULL;
481 rpn_definitions_files = 0;
482 summarize = verbose = nowarnings = udfCounter = 0;
483
484 processing_definition = NULL;
485 processing_definitions = 0;
486 conversion = NULL;
487 conversions = 0;
488 edit_definition = NULL;
489 edit_definitions = 0;
490 equation_definition = NULL;
491 equation_definitions = 0;
492 evaluate_definition = NULL;
493 evaluate_definitions = 0;
494 scan_definition = NULL;
495 scan_definitions = 0;
496 print_definition = NULL;
497 print_definitions = 0;
498 format_definition = NULL;
499 format_definitions = 0;
500 filter_definition = NULL;
501 filter_definitions = 0;
502 time_filter_definition = NULL;
503 time_filter_definitions = 0;
504 match_definition = NULL;
505 match_definitions = 0;
506 rpntest_definition = NULL;
507 rpntest_definitions = 0;
508 numbertest_definition = NULL;
509 numbertest_definitions = 0;
510 system_definition = NULL;
511 system_definitions = 0;
512 rpnexpression_definition = NULL;
513 rpnexpression_definitions = 0;
514 clip_definition = NULL;
515 fclip_definition = NULL;
516 clip_definitions = fclip_definitions = 0;
517 sparse_definition = NULL;
518 sparse_definitions = 0;
519 sample_definition = NULL;
520 sample_definitions = 0;
521 cast_definition = NULL;
522 cast_definitions = 0;
523 definition = NULL;
524 definitions = 0;
525 ifnot_item.items = 0;
526 ifis_item.items = 0;
527 pipeFlags = 0;
528
529 for (i_arg = 1; i_arg < argc; i_arg++) {
530 if (s_arg[i_arg].arg_type == OPTION) {
531 delete_chars(s_arg[i_arg].list[0], "_");
532 switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
533 case SET_MAJOR_ORDER:
534 majorOrderFlag = 0;
535 s_arg[i_arg].n_items--;
536 if (s_arg[i_arg].n_items > 0 &&
537 (!scanItemList(&majorOrderFlag, s_arg[i_arg].list + 1, &s_arg[i_arg].n_items, 0,
538 "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER,
539 "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL)))
540 SDDS_Bomb("invalid -majorOrder syntax/values");
541 if (majorOrderFlag & SDDS_COLUMN_MAJOR_ORDER)
542 columnMajorOrder = 1;
543 else if (majorOrderFlag & SDDS_ROW_MAJOR_ORDER)
544 columnMajorOrder = 0;
545 break;
546 case SET_XZLEVEL:
547 if (s_arg[i_arg].n_items != 2 || sscanf(s_arg[i_arg].list[1], "%ld", &xzLevel) != 1 || xzLevel < 0 || xzLevel > 9)
548 SDDS_Bomb("invalid -xzLevel syntax");
549 SDDS_SetLZMACompressionLevel(xzLevel);
550 break;
551 case SET_MATCH:
552 if (s_arg[i_arg].n_items < 3)
553 SDDS_Bomb("invalid -match syntax");
554 match_definition = (MATCH_DEFINITION **)trealloc(match_definition, sizeof(*match_definition) * (match_definitions + 1));
555 if (!(match_definition[match_definitions] = process_new_match_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
556 SDDS_Bomb("invalid -match syntax");
557 add_definition(&definition, &definitions, (void *)match_definition[match_definitions], IS_MATCH_DEFINITION);
558 match_definitions++;
559 break;
560 case SET_FILTER:
561 if (s_arg[i_arg].n_items < 3)
562 SDDS_Bomb("invalid -filter syntax");
563 filter_definition = (FILTER_DEFINITION **)trealloc(filter_definition, sizeof(*filter_definition) * (filter_definitions + 1));
564 if (!(filter_definition[filter_definitions] = process_new_filter_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
565 SDDS_Bomb("invalid -filter syntax");
566 add_definition(&definition, &definitions, (void *)filter_definition[filter_definitions], IS_FILTER_DEFINITION);
567 filter_definitions++;
568 break;
569 case SET_TIME_FILTER:
570 if (s_arg[i_arg].n_items < 3)
571 SDDS_Bomb("invalid -timeFilter syntax");
572 time_filter_definition = (TIME_FILTER_DEFINITION **)trealloc(time_filter_definition, sizeof(*time_filter_definition) * (filter_definitions + 1));
573 if (!(time_filter_definition[time_filter_definitions] = process_new_time_filter_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
574 SDDS_Bomb("invalid -timeFilter syntax");
575 add_definition(&definition, &definitions, (void *)time_filter_definition[time_filter_definitions], IS_TIME_FILTER_DEFINITION);
576 time_filter_definitions++;
577 break;
578 case SET_RPN_DEFNS_FILES:
579 if (s_arg[i_arg].n_items < 2)
580 SDDS_Bomb("invalid -rpndefinitionsfiles syntax");
581 rpn_definitions_file = trealloc(rpn_definitions_file, sizeof(*rpn_definitions_file) * (rpn_definitions_files + s_arg[i_arg].n_items));
582 for (i = 1; i < s_arg[i_arg].n_items; i++)
583 if (!fexists(rpn_definitions_file[rpn_definitions_files + i - 1] = s_arg[i_arg].list[i]))
584 SDDS_Bomb("one or more rpn definitions files do not exist");
585 rpn_definitions_files += s_arg[i_arg].n_items - 1;
586 break;
587 case SET_RPN_EXPRESSION:
588 if (s_arg[i_arg].n_items < 2 && s_arg[i_arg].n_items > 4)
589 SDDS_Bomb("invalid -rpnexpression syntax");
590 rpnexpression_definition = (RPNEXPRESSION_DEFINITION **)trealloc(rpnexpression_definition, sizeof(*rpnexpression_definition) * (rpnexpression_definitions + 1));
591 if (!(rpnexpression_definition[rpnexpression_definitions] = process_new_rpnexpression_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
592 SDDS_Bomb("invalid -rpnexpression syntax");
593 add_definition(&definition, &definitions, (void *)rpnexpression_definition[rpnexpression_definitions], IS_RPNEXPRESSION_DEFINITION);
594 rpnexpression_definitions++;
595 break;
596 case SET_DEFINITION:
597 if (s_arg[i_arg].n_items < 4)
598 SDDS_Bomb("invalid -definition syntax");
599 equation_definition = (EQUATION_DEFINITION **)trealloc(equation_definition, sizeof(*equation_definition) * (equation_definitions + 1));
600 if (!(equation_definition[equation_definitions] = process_new_equation_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
601 SDDS_Bomb("invalid -definition syntax");
602 equation_definition[equation_definitions]->redefinition = 0;
603 add_definition(&definition, &definitions, (void *)equation_definition[equation_definitions], IS_EQUATION_DEFINITION);
604 equation_definitions++;
605 break;
606 case SET_REDEFINITION:
607 if (s_arg[i_arg].n_items < 4)
608 SDDS_Bomb("invalid -redefinition syntax");
609 equation_definition = (EQUATION_DEFINITION **)trealloc(equation_definition, sizeof(*equation_definition) * (equation_definitions + 1));
610 if (!(equation_definition[equation_definitions] = process_new_equation_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
611 SDDS_Bomb("invalid -redefinition syntax");
612 equation_definition[equation_definitions]->redefinition = 1;
613 add_definition(&definition, &definitions, (void *)equation_definition[equation_definitions], IS_EQUATION_DEFINITION);
614 equation_definitions++;
615 break;
616 case SET_EVALUATE:
617 if (s_arg[i_arg].n_items < 4)
618 SDDS_Bomb("invalid -evaluate syntax");
619 evaluate_definition = (EVALUATE_DEFINITION **)trealloc(evaluate_definition, sizeof(*evaluate_definition) * (evaluate_definitions + 1));
620 if (!(evaluate_definition[evaluate_definitions] = process_new_evaluate_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
621 SDDS_Bomb("invalid -definition syntax");
622 add_definition(&definition, &definitions, (void *)evaluate_definition[evaluate_definitions], IS_EVALUATE_DEFINITION);
623 evaluate_definitions++;
624 break;
625 case SET_TEST:
626 if (s_arg[i_arg].n_items < 3 && s_arg[i_arg].n_items > 5)
627 SDDS_Bomb("invalid -test syntax");
628 rpntest_definition = (RPNTEST_DEFINITION **)trealloc(rpntest_definition, sizeof(*rpntest_definition) * (rpntest_definitions + 1));
629 if (!(rpntest_definition[rpntest_definitions] = process_new_rpntest_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
630 SDDS_Bomb("invalid -test syntax");
631 add_definition(&definition, &definitions, (void *)rpntest_definition[rpntest_definitions], IS_RPNTEST_DEFINITION);
632 rpntest_definitions++;
633 break;
634 case SET_SUMMARIZE:
635 summarize = 1;
636 break;
637 case SET_VERBOSE:
638 verbose = 1;
639 break;
640 case SET_NOWARNINGS:
641 nowarnings = 1;
642 break;
643 case SET_PROCESS:
644 processing_definition = (PROCESSING_DEFINITION **)trealloc(processing_definition, sizeof(*processing_definition) * (processing_definitions + 1));
645 if (!(processing_definition[processing_definitions] = record_processing_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
646 SDDS_Bomb("invalid -process syntax--parsing problem");
647 add_definition(&definition, &definitions, (void *)processing_definition[processing_definitions], IS_PROCESSING_DEFINITION);
648 processing_definitions++;
649 break;
650 case SET_CONVERT_UNITS:
651 if (s_arg[i_arg].n_items != 6)
652 SDDS_Bomb("invalid -convertunits syntax--wrong number of items");
653 conversion = (CONVERSION_DEFINITION **)trealloc(conversion, sizeof(*conversion) * (conversions + 1));
654 if (!(conversion[conversions] = process_conversion_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
655 SDDS_Bomb("invalid -convertunits syntax");
656 add_definition(&definition, &definitions, (void *)conversion[conversions], IS_CONVERSION_DEFINITION);
657 conversions++;
658 break;
659 case SET_NUMBERTEST:
660 /* -numberTest={col | param},<name>[,invert] */
661 if (s_arg[i_arg].n_items < 3)
662 SDDS_Bomb("invalid -numberTest syntax");
663 numbertest_definition = (NUMBERTEST_DEFINITION **)trealloc(numbertest_definition, sizeof(*numbertest_definition) * (numbertest_definitions + 1));
664 if (!(numbertest_definition[numbertest_definitions] = process_new_numbertest_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
665 SDDS_Bomb("invalid -numberTest syntax");
666 add_definition(&definition, &definitions, (void *)numbertest_definition[numbertest_definitions], IS_NUMBERTEST_DEFINITION);
667 numbertest_definitions++;
668 break;
669 case SET_SCAN:
670 if (s_arg[i_arg].n_items < 5)
671 SDDS_Bomb("invalid -scan syntax");
672 scan_definition = (SCAN_DEFINITION **)trealloc(scan_definition, sizeof(*scan_definition) * (scan_definitions + 1));
673 if (!(scan_definition[scan_definitions] = process_new_scan_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
674 SDDS_Bomb("invalid -scan syntax");
675 add_definition(&definition, &definitions, (void *)scan_definition[scan_definitions], IS_SCAN_DEFINITION);
676 scan_definitions++;
677 break;
678 case SET_PRINT:
679 if (s_arg[i_arg].n_items < 4)
680 SDDS_Bomb("invalid -print syntax");
681 print_definition = (PRINT_DEFINITION **)trealloc(print_definition, sizeof(*print_definition) * (print_definitions + 1));
682 if (!(print_definition[print_definitions] = process_new_print_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
683 SDDS_Bomb("invalid -print syntax");
684 print_definition[print_definitions]->reprint = 0;
685 add_definition(&definition, &definitions, (void *)print_definition[print_definitions], IS_PRINT_DEFINITION);
686 print_definitions++;
687 break;
688 case SET_REPRINT:
689 if (s_arg[i_arg].n_items < 4)
690 SDDS_Bomb("invalid -print syntax");
691 print_definition = (PRINT_DEFINITION **)trealloc(print_definition, sizeof(*print_definition) * (print_definitions + 1));
692 if (!(print_definition[print_definitions] = process_new_print_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
693 SDDS_Bomb("invalid -print syntax");
694 print_definition[print_definitions]->reprint = 1;
695 add_definition(&definition, &definitions, (void *)print_definition[print_definitions], IS_PRINT_DEFINITION);
696 print_definitions++;
697 break;
698 case SET_EDIT:
699 if (s_arg[i_arg].n_items < 5)
700 SDDS_Bomb("invalid -edit syntax");
701 edit_definition = (EDIT_DEFINITION **)trealloc(edit_definition, sizeof(*edit_definition) * (edit_definitions + 1));
702 if (!(edit_definition[edit_definitions] = process_new_edit_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1, 0)))
703 SDDS_Bomb("invalid -edit syntax");
704 add_definition(&definition, &definitions, (void *)edit_definition[edit_definitions], IS_EDIT_DEFINITION);
705 edit_definitions++;
706 break;
707 case SET_REEDIT:
708 if (s_arg[i_arg].n_items < 4)
709 SDDS_Bomb("invalid -reedit syntax");
710 edit_definition = (EDIT_DEFINITION **)trealloc(edit_definition, sizeof(*edit_definition) * (edit_definitions + 1));
711 if (!(edit_definition[edit_definitions] = process_new_edit_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1, 1)))
712 SDDS_Bomb("invalid -reedit syntax");
713 edit_definition[edit_definitions]->reedit = 1;
714 add_definition(&definition, &definitions, (void *)edit_definition[edit_definitions], IS_EDIT_DEFINITION);
715 edit_definitions++;
716 break;
717 case SET_SYSTEM:
718 if (s_arg[i_arg].n_items < 4)
719 SDDS_Bomb("invalid -system syntax");
720 system_definition = (SYSTEM_DEFINITION **)trealloc(system_definition, sizeof(*system_definition) * (system_definitions + 1));
721 if (!(system_definition[system_definitions] = process_new_system_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
722 SDDS_Bomb("invalid -system syntax");
723 add_definition(&definition, &definitions, (void *)system_definition[system_definitions], IS_SYSTEM_DEFINITION);
724 system_definitions++;
725 break;
726 case SET_IFNOT:
727 if (s_arg[i_arg].n_items < 3)
728 SDDS_Bomb("invalid -ifnot syntax");
729 add_ifitem(&ifnot_item, s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1);
730 break;
731 case SET_IFIS:
732 if (s_arg[i_arg].n_items < 3)
733 SDDS_Bomb("invalid -ifis syntax");
734 add_ifitem(&ifis_item, s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1);
735 break;
736 case SET_CLIP:
737 clip_definition = (CLIP_DEFINITION **)trealloc(clip_definition, sizeof(*clip_definition) * (clip_definitions + 1));
738 if (!(clip_definition[clip_definitions] = process_new_clip_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
739 SDDS_Bomb("invalid -clip syntax");
740 add_definition(&definition, &definitions, (void *)clip_definition[clip_definitions], IS_CLIP_DEFINITION);
741 clip_definitions++;
742 break;
743 case SET_FCLIP:
744 fclip_definition = (FCLIP_DEFINITION **)trealloc(fclip_definition, sizeof(*fclip_definition) * (fclip_definitions + 1));
745 if (!(fclip_definition[fclip_definitions] = process_new_fclip_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
746 SDDS_Bomb("invalid -fclip syntax");
747 add_definition(&definition, &definitions, (void *)fclip_definition[fclip_definitions], IS_FCLIP_DEFINITION);
748 fclip_definitions++;
749 break;
750 case SET_SPARSE:
751 sparse_definition = (SPARSE_DEFINITION **)trealloc(sparse_definition, sizeof(*sparse_definition) * (sparse_definitions + 1));
752 if (!(sparse_definition[sparse_definitions] = process_new_sparse_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
753 SDDS_Bomb("invalid -sparse syntax");
754 add_definition(&definition, &definitions, (void *)sparse_definition[sparse_definitions], IS_SPARSE_DEFINITION);
755 sparse_definitions++;
756 break;
757 case SET_SAMPLE:
758 sample_definition = (SAMPLE_DEFINITION **)trealloc(sample_definition, sizeof(*sample_definition) * (sample_definitions + 1));
759 if (!(sample_definition[sample_definitions] = process_new_sample_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
760 SDDS_Bomb("invalid -sample syntax");
761 add_definition(&definition, &definitions, (void *)sample_definition[sample_definitions], IS_SAMPLE_DEFINITION);
762 sample_definitions++;
763 break;
764 case SET_PIPE:
765 if (!processPipeOption(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1, &pipeFlags))
766 SDDS_Bomb("invalid -pipe syntax");
767 break;
768 case SET_FORMAT:
769 if (s_arg[i_arg].n_items < 4)
770 SDDS_Bomb("invalid -format syntax");
771 format_definition = (FORMAT_DEFINITION **)trealloc(format_definition, sizeof(*format_definition) * (format_definitions + 1));
772 if (!(format_definition[format_definitions] = process_new_format_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
773 SDDS_Bomb("invalid -format syntax");
774 add_definition(&definition, &definitions, (void *)format_definition[format_definitions], IS_FORMAT_DEFINITION);
775 format_definitions++;
776 break;
777 case SET_CAST:
778 if (s_arg[i_arg].n_items != 5)
779 SDDS_Bomb("invalid -cast syntax");
780 cast_definition = (CAST_DEFINITION **)trealloc(cast_definition, sizeof(*cast_definition) * (cast_definitions + 1));
781 if (!(cast_definition[cast_definitions] = process_new_cast_definition(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1)))
782 SDDS_Bomb("invalid -cast syntax");
783 add_definition(&definition, &definitions, (void *)cast_definition[cast_definitions], IS_CAST_DEFINITION);
784 cast_definitions++;
785 break;
786 case SET_DELETE:
787 if (s_arg[i_arg].n_items < 3)
788 SDDS_Bomb("invalid -delete syntax");
789 switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) {
790 case COLUMN_MODE:
791 delete_column = trealloc(delete_column, sizeof(*delete_column) * (delete_columns + s_arg[i_arg].n_items - 2));
792 for (i = 2; i < s_arg[i_arg].n_items; i++)
793 delete_column[i - 2 + delete_columns] = s_arg[i_arg].list[i];
794 delete_columns += s_arg[i_arg].n_items - 2;
795 break;
796 case PARAMETER_MODE:
797 delete_parameter = trealloc(delete_parameter, sizeof(*delete_parameter) * (delete_parameters + s_arg[i_arg].n_items - 2));
798 for (i = 2; i < s_arg[i_arg].n_items; i++)
799 delete_parameter[i - 2 + delete_parameters] = s_arg[i_arg].list[i];
800 delete_parameters += s_arg[i_arg].n_items - 2;
801 break;
802 case ARRAY_MODE:
803 delete_array = trealloc(delete_array, sizeof(*delete_array) * (delete_arrays + s_arg[i_arg].n_items - 2));
804 for (i = 2; i < s_arg[i_arg].n_items; i++)
805 delete_array[i - 2 + delete_arrays] = s_arg[i_arg].list[i];
806 delete_arrays += s_arg[i_arg].n_items - 2;
807 break;
808 default:
809 SDDS_Bomb("invalid -delete syntax: specify column or parameter keyword");
810 break;
811 }
812 break;
813 case SET_RETAIN:
814 if (s_arg[i_arg].n_items < 3)
815 SDDS_Bomb("invalid -retain syntax");
816 switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) {
817 case COLUMN_MODE:
818 retain_column = trealloc(retain_column, sizeof(*retain_column) * (retain_columns + s_arg[i_arg].n_items - 2));
819 for (i = 2; i < s_arg[i_arg].n_items; i++)
820 retain_column[i - 2 + retain_columns] = s_arg[i_arg].list[i];
821 retain_columns += s_arg[i_arg].n_items - 2;
822 break;
823 case PARAMETER_MODE:
824 retain_parameter = trealloc(retain_parameter, sizeof(*retain_parameter) * (retain_parameters + s_arg[i_arg].n_items - 2));
825 for (i = 2; i < s_arg[i_arg].n_items; i++)
826 retain_parameter[i - 2 + retain_parameters] = s_arg[i_arg].list[i];
827 retain_parameters += s_arg[i_arg].n_items - 2;
828 break;
829 case ARRAY_MODE:
830 retain_array = trealloc(retain_array, sizeof(*retain_array) * (retain_arrays + s_arg[i_arg].n_items - 2));
831 for (i = 2; i < s_arg[i_arg].n_items; i++)
832 retain_array[i - 2 + retain_arrays] = s_arg[i_arg].list[i];
833 retain_arrays += s_arg[i_arg].n_items - 2;
834 break;
835 default:
836 SDDS_Bomb("invalid -retain syntax: specify column or parameter keyword");
837 break;
838 }
839 break;
840 case SET_DESCRIPTION:
841 s_arg[i_arg].n_items -= 1;
842 if (!scanItemList(&flags, s_arg[i_arg].list + 1, &s_arg[i_arg].n_items, 0,
843 "text", SDDS_STRING, &description_text, 1, 0,
844 "contents", SDDS_STRING, &description_contents, 1, 0, NULL))
845 SDDS_Bomb("invalid -description syntax");
846 break;
847 case SET_THREADS:
848 if (s_arg[i_arg].n_items != 2 ||
849 !sscanf(s_arg[i_arg].list[1], "%d", &threads) || threads < 1)
850 SDDS_Bomb("invalid -threads syntax");
851 break;
852 default:
853 snprintf(buffer, SDDS_MAXLINE, "unknown switch: %s", s_arg[i_arg].list[0]);
854 SDDS_Bomb(buffer);
855 break;
856 }
857 } else {
858 if (inputfile == NULL)
859 inputfile = s_arg[i_arg].list[0];
860 else if (outputfile == NULL)
861 outputfile = s_arg[i_arg].list[0];
862 else {
863 fprintf(stderr, "argument %s is invalid: too many filenames (sddsprocess)\n", s_arg[i_arg].list[0]);
864 exit(EXIT_FAILURE);
865 }
866 }
867 }
868
869 processFilenames("sddsprocess", &inputfile, &outputfile, pipeFlags, nowarnings, &tmpfile_used);
870
871 if (rpn_definitions_files) {
872 rpn(rpn_definitions_file[0]);
873 if (rpn_check_error())
874 exit(EXIT_FAILURE);
875 for (i = 1; i < rpn_definitions_files; i++) {
876 sprintf(s, "\"%s,s\" @", rpn_definitions_file[i]);
877 rpn(s);
878 if (rpn_check_error())
879 exit(EXIT_FAILURE);
880 }
881 } else {
882 rpn(getenv("RPN_DEFNS"));
883 if (rpn_check_error())
884 exit(EXIT_FAILURE);
885 }
886 i_page_memory = rpn_create_mem("i_page", 0);
887 table_number_memory = rpn_create_mem("table_number", 0);
888 n_rows_memory = rpn_create_mem("n_rows", 0);
889
890 if (!SDDS_InitializeInput(&SDDS_input, inputfile)) {
891 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
892 exit(EXIT_FAILURE);
893 }
894 if (!check_ifitems(&SDDS_input, &ifnot_item, 0, !nowarnings) ||
895 !check_ifitems(&SDDS_input, &ifis_item, 1, !nowarnings))
896 exit(EXIT_SUCCESS);
897 original_parameters = SDDS_input.layout.n_parameters;
898
899 if (!description_text)
900 SDDS_GetDescription(&SDDS_input, &description_text, &description_contents);
901 if (!SDDS_InitializeOutput(&SDDS_output, SDDS_input.layout.data_mode.mode, 1, description_text, description_contents, outputfile)) {
902 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
903 exit(EXIT_FAILURE);
904 }
905 if (columnMajorOrder != -1)
906 SDDS_output.layout.data_mode.column_major = columnMajorOrder;
907 else
908 SDDS_output.layout.data_mode.column_major = SDDS_input.layout.data_mode.column_major;
909 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
910
911#ifdef DEBUG
912 fprintf(stderr, "Getting column, parameter, and array names from input file.\n");
913#endif
914 if (!(orig_column_name = SDDS_GetColumnNames(&SDDS_input, &orig_column_names))) {
915 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
916 exit(EXIT_FAILURE);
917 }
918 if (orig_column_names && !(new_column_name = process_name_options(orig_column_name, &orig_column_flag, orig_column_names, delete_column, delete_columns, retain_column, retain_columns, rename_column, rename_columns, edit_column_request, edit_column_requests)))
919 exit(EXIT_FAILURE);
920
921 if (!(orig_parameter_name = SDDS_GetParameterNames(&SDDS_input, &orig_parameter_names))) {
922 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
923 exit(EXIT_FAILURE);
924 }
925
926#ifdef DEBUG
927 fprintf(stderr, "processing name options\n");
928#endif
929 if (orig_parameter_names && !(new_parameter_name = process_name_options(orig_parameter_name, &orig_parameter_flag, orig_parameter_names, delete_parameter, delete_parameters, retain_parameter, retain_parameters, rename_parameter, rename_parameters, edit_parameter_request, edit_parameter_requests)))
930 exit(EXIT_FAILURE);
931
932 if (!(orig_array_name = SDDS_GetArrayNames(&SDDS_input, &orig_array_names))) {
933 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
934 exit(EXIT_FAILURE);
935 }
936 if (orig_array_names && !(new_array_name = process_name_options(orig_array_name, &orig_array_flag, orig_array_names, delete_array, delete_arrays, retain_array, retain_arrays, rename_array, rename_arrays, edit_array_request, edit_array_requests)))
937 exit(EXIT_FAILURE);
938
939#ifdef DEBUG
940 for (i = 0; i < orig_parameter_names; i++) {
941 fprintf(stderr, "parameter %s goes to %s\n", orig_parameter_name[i], orig_parameter_flag[i] ? new_parameter_name[i] : "<deleted>");
942 }
943 for (i = 0; i < orig_array_names; i++) {
944 fprintf(stderr, "array %s goes to %s\n", orig_array_name[i], orig_array_flag[i] ? new_array_name[i] : "<deleted>");
945 }
946 for (i = 0; i < orig_column_names; i++) {
947 fprintf(stderr, "column %s goes to %s\n", orig_column_name[i], orig_column_flag[i] ? new_column_name[i] : "<deleted>");
948 }
949#endif
950
951#ifdef DEBUG
952 fprintf(stderr, "Transferring definitions to new file.\n");
953#endif
954 for (i = 0; i < orig_parameter_names; i++) {
955 if (orig_parameter_flag[i]) {
956 if (!SDDS_TransferParameterDefinition(&SDDS_output, &SDDS_input, orig_parameter_name[i], new_parameter_name[i])) {
957 fprintf(stderr, "unable to transfer parameter %s to %s\n", orig_parameter_name[i], new_parameter_name[i]);
958 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
959 exit(EXIT_FAILURE);
960 }
961 }
962 }
963 for (i = 0; i < orig_array_names; i++) {
964 if (orig_array_flag[i]) {
965 if (!SDDS_TransferArrayDefinition(&SDDS_output, &SDDS_input, orig_array_name[i], new_array_name[i])) {
966 fprintf(stderr, "unable to transfer array %s to %s\n", orig_array_name[i], new_array_name[i]);
967 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
968 exit(EXIT_FAILURE);
969 }
970 }
971 }
972 //output_columns = 0;
973 for (i = 0; i < orig_column_names; i++) {
974 if (orig_column_flag[i]) {
975 //output_columns++;
976 if (!SDDS_TransferColumnDefinition(&SDDS_output, &SDDS_input, orig_column_name[i], new_column_name[i])) {
977 fprintf(stderr, "unable to transfer column %s to %s\n", orig_column_name[i], new_column_name[i]);
978 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
979 exit(EXIT_FAILURE);
980 }
981 }
982 }
983 for (i = 0; i < orig_column_names; i++) {
984 free(new_column_name[i]);
985 free(orig_column_name[i]);
986 }
987 free(new_column_name);
988 free(orig_column_name);
989
990 expandDefinitions(&definition, &definitions, &SDDS_output);
991
992 for (i = 0; i < definitions; i++) {
993 switch (definition[i].type) {
994 case IS_EQUATION_DEFINITION:
995 equation_ptr = (EQUATION_DEFINITION *)definition[i].structure;
996 sprintf(s, "%sUDF%ld", equation_ptr->name, udfCounter++);
997 delete_chars(s, " ");
998 if (!SDDS_CopyString(&equation_ptr->udf_name, s))
999 SDDS_Bomb("string copying failed (making udf name)");
1000 if (equation_ptr->equation[0] == '@') {
1001 if (equation_ptr->equation[1] == '@') {
1002 /* parameter contains algebraic notation */
1003 if ((index = SDDS_GetParameterIndex(&SDDS_output, equation_ptr->equation + 2)) < 0 ||
1004 SDDS_GetParameterType(&SDDS_input, index) != SDDS_STRING) {
1005 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1006 fprintf(stderr, "Error (sddsprocess): parameter %s does not exist or is not string type\n", equation_ptr->equation + 2);
1007 exit(EXIT_FAILURE);
1008 }
1009 } else {
1010 if ((index = SDDS_GetParameterIndex(&SDDS_output, equation_ptr->equation + 1)) < 0 ||
1011 SDDS_GetParameterType(&SDDS_input, index) != SDDS_STRING) {
1012 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1013 fprintf(stderr, "Error (sddsprocess): parameter %s does not exist or is not string type\n", equation_ptr->equation + 1);
1014 exit(EXIT_FAILURE);
1015 }
1016 }
1017 } else {
1018 if (strstr(equation_ptr->equation, "xstr") == NULL)
1019 create_udf(equation_ptr->udf_name, equation_ptr->equation);
1020 else
1021 /* This works around a bug in rpn that results in a stack overflow for definitions that use the 'xstr' function */
1022 equation_ptr->udf_name = equation_ptr->equation;
1023 }
1024 if (equation_ptr->redefinition) {
1025 if (equation_ptr->is_parameter) {
1026 if ((index = SDDS_GetParameterIndex(&SDDS_output, equation_ptr->name)) < 0)
1027 equation_ptr->redefinition = 0;
1028 } else if ((index = SDDS_GetColumnIndex(&SDDS_output, equation_ptr->name)) < 0)
1029 equation_ptr->redefinition = 0;
1030 }
1031 if (equation_ptr->redefinition == 0) {
1032 if (equation_ptr->is_parameter) {
1033 if (!SDDS_ProcessParameterString(&SDDS_output, equation_ptr->text, SDDS_WRITEONLY_DEFINITION)) {
1034 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1035 fprintf(stderr, "Bad parameter string: %s\n", equation_ptr->text);
1036 exit(EXIT_FAILURE);
1037 }
1038 } else if (!SDDS_ProcessColumnString(&SDDS_output, equation_ptr->text, SDDS_WRITEONLY_DEFINITION)) {
1039 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1040 fprintf(stderr, "Bad column string: %s\n", equation_ptr->text);
1041 exit(EXIT_FAILURE);
1042 }
1043 } else {
1044 if (equation_ptr->is_parameter) {
1045 if (!REDEFINABLE_TYPE(SDDS_GetParameterType(&SDDS_output, index))) {
1046 fprintf(stderr, "can't redefine parameter %s--non-numeric\n", equation_ptr->name);
1047 exit(EXIT_FAILURE);
1048 }
1049 if (equation_ptr->argc && !SDDS_RedefineParameterCL(&SDDS_output, equation_ptr->name, equation_ptr->argv, equation_ptr->argc)) {
1050 fprintf(stderr, "can't redefine parameter %s as requested\n", equation_ptr->name);
1051 exit(EXIT_FAILURE);
1052 }
1053 } else {
1054 if (!REDEFINABLE_TYPE(SDDS_GetColumnType(&SDDS_output, index))) {
1055 fprintf(stderr, "can't redefine column %s--non-numeric\n", equation_ptr->name);
1056 exit(EXIT_FAILURE);
1057 }
1058 if (equation_ptr->argc && !SDDS_RedefineColumnCL(&SDDS_output, equation_ptr->name, equation_ptr->argv, equation_ptr->argc)) {
1059 fprintf(stderr, "can't redefine column %s as requested\n", equation_ptr->name);
1060 exit(EXIT_FAILURE);
1061 }
1062 }
1063 }
1064 break;
1065 case IS_EDIT_DEFINITION:
1066 edit_ptr = (EDIT_DEFINITION *)definition[i].structure;
1067 index = edit_ptr->is_parameter ? SDDS_GetParameterIndex(&SDDS_output, edit_ptr->new_name) : SDDS_GetColumnIndex(&SDDS_output, edit_ptr->new_name);
1068 if (index < 0)
1069 edit_ptr->reedit = 0;
1070 else if (!edit_ptr->reedit) {
1071 fprintf(stderr, "Can't define new -edit %s %s--already exists (sddsprocess)\n", edit_ptr->is_parameter ? "parameter" : "column", edit_ptr->new_name);
1072 exit(EXIT_FAILURE);
1073 }
1074 if (!edit_ptr->reedit) {
1075 if (!(edit_ptr->is_parameter ? SDDS_ProcessParameterString(&SDDS_output, edit_ptr->text, SDDS_WRITEONLY_DEFINITION) : SDDS_ProcessColumnString(&SDDS_output, edit_ptr->text, SDDS_WRITEONLY_DEFINITION))) {
1076 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1077 exit(EXIT_FAILURE);
1078 }
1079 } else {
1080 if ((edit_ptr->is_parameter ? SDDS_GetParameterType(&SDDS_output, index) : SDDS_GetColumnType(&SDDS_output, index)) != SDDS_STRING) {
1081 fprintf(stderr, "Can't reedit %s %s--not string type (sddsprocess)\n", edit_ptr->is_parameter ? "parameter" : "column", edit_ptr->new_name);
1082 exit(EXIT_FAILURE);
1083 }
1084 if (edit_ptr->argc && !(edit_ptr->is_parameter ? SDDS_RedefineParameterCL(&SDDS_output, edit_ptr->new_name, edit_ptr->argv, edit_ptr->argc) : SDDS_RedefineColumnCL(&SDDS_output, edit_ptr->new_name, edit_ptr->argv, edit_ptr->argc))) {
1085 fprintf(stderr, "Can't reedit %s %s as requested (sddsprocess)\n", edit_ptr->is_parameter ? "parameter" : "column", edit_ptr->new_name);
1086 exit(EXIT_FAILURE);
1087 }
1088 }
1089 break;
1090 case IS_SCAN_DEFINITION:
1091 scan_ptr = (SCAN_DEFINITION *)definition[i].structure;
1092 if (scan_ptr->is_parameter) {
1093 if (!SDDS_ProcessParameterString(&SDDS_output, scan_ptr->text, SDDS_WRITEONLY_DEFINITION)) {
1094 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1095 exit(EXIT_FAILURE);
1096 }
1097 } else if (!SDDS_ProcessColumnString(&SDDS_output, scan_ptr->text, SDDS_WRITEONLY_DEFINITION)) {
1098 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1099 exit(EXIT_FAILURE);
1100 }
1101 break;
1102 case IS_PRINT_DEFINITION:
1103 print_ptr = (PRINT_DEFINITION *)definition[i].structure;
1104 index = print_ptr->is_parameter ? SDDS_GetParameterIndex(&SDDS_output, print_ptr->new_name) : SDDS_GetColumnIndex(&SDDS_output, print_ptr->new_name);
1105 if (index < 0)
1106 print_ptr->reprint = 0;
1107 else if (!print_ptr->reprint) {
1108 fprintf(stderr, "Can't define new -print %s %s--already exists (sddsprocess)\n", print_ptr->is_parameter ? "parameter" : "column", print_ptr->new_name);
1109 exit(EXIT_FAILURE);
1110 }
1111 if (!print_ptr->reprint) {
1112 if (!(print_ptr->is_parameter ? SDDS_ProcessParameterString(&SDDS_output, print_ptr->text, SDDS_WRITEONLY_DEFINITION) : SDDS_ProcessColumnString(&SDDS_output, print_ptr->text, SDDS_WRITEONLY_DEFINITION))) {
1113 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1114 exit(EXIT_FAILURE);
1115 }
1116 } else {
1117 if ((print_ptr->is_parameter ? SDDS_GetParameterType(&SDDS_output, index) : SDDS_GetColumnType(&SDDS_output, index)) != SDDS_STRING) {
1118 fprintf(stderr, "Can't reprint %s %s--not string type (sddsprocess)\n", print_ptr->is_parameter ? "parameter" : "column", print_ptr->new_name);
1119 exit(EXIT_FAILURE);
1120 }
1121 }
1122 break;
1123 case IS_PROCESSING_DEFINITION:
1124 processing_ptr = (PROCESSING_DEFINITION *)definition[i].structure;
1125 if (!complete_processing_definitions(&processing_ptr, 1, &SDDS_output)) {
1126 fprintf(stderr, "error: problem completing processing definition\n");
1127 if (SDDS_NumberOfErrors())
1128 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1129 exit(EXIT_FAILURE);
1130 }
1131 break;
1132 case IS_CONVERSION_DEFINITION:
1133 conversion_ptr = (CONVERSION_DEFINITION *)definition[i].structure;
1134 if (conversion_ptr->is_parameter) {
1135 if ((j = SDDS_GetParameterIndex(&SDDS_output, conversion_ptr->name)) < 0)
1136 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1137 if (SDDS_CheckParameter(&SDDS_output, conversion_ptr->name, conversion_ptr->old_units, SDDS_GetParameterType(&SDDS_output, j), stderr) != SDDS_CHECK_OKAY)
1138 exit(EXIT_FAILURE);
1139 if (!SDDS_ChangeParameterInformation(&SDDS_output, "units", conversion_ptr->new_units, SDDS_SET_BY_NAME, conversion_ptr->name)) {
1140 if (SDDS_NumberOfErrors())
1141 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1142 else
1143 fprintf(stderr, "error: unknown error processing conversion for parameter %s\n", conversion_ptr->name);
1144 exit(EXIT_FAILURE);
1145 }
1146 } else {
1147 if ((j = SDDS_GetColumnIndex(&SDDS_output, conversion_ptr->name)) < 0)
1148 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1149 if (SDDS_CheckColumn(&SDDS_output, conversion_ptr->name, conversion_ptr->old_units, SDDS_GetColumnType(&SDDS_output, j), stderr) != SDDS_CHECK_OKAY)
1150 exit(EXIT_FAILURE);
1151 if (!SDDS_ChangeColumnInformation(&SDDS_output, "units", conversion_ptr->new_units, SDDS_SET_BY_NAME, conversion_ptr->name)) {
1152 if (SDDS_NumberOfErrors())
1153 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1154 else
1155 fprintf(stderr, "error: unknown error processing conversion for column %s\n", conversion_ptr->name);
1156 exit(EXIT_FAILURE);
1157 }
1158 }
1159 break;
1160 case IS_SYSTEM_DEFINITION:
1161 system_ptr = (SYSTEM_DEFINITION *)definition[i].structure;
1162 if (system_ptr->is_parameter) {
1163 if (!SDDS_ProcessParameterString(&SDDS_output, system_ptr->text, SDDS_WRITEONLY_DEFINITION)) {
1164 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1165 exit(EXIT_FAILURE);
1166 }
1167 } else if (!SDDS_ProcessColumnString(&SDDS_output, system_ptr->text, SDDS_WRITEONLY_DEFINITION)) {
1168 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1169 exit(EXIT_FAILURE);
1170 }
1171 break;
1172 case IS_FORMAT_DEFINITION:
1173 format_ptr = (FORMAT_DEFINITION *)definition[i].structure;
1174 if (strcmp(format_ptr->source, format_ptr->target)) {
1175 if (format_ptr->is_parameter) {
1176 if (!SDDS_TransferParameterDefinition(&SDDS_output, &SDDS_output, format_ptr->source, format_ptr->target)) {
1177 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1178 exit(EXIT_FAILURE);
1179 }
1180 } else if (!SDDS_TransferColumnDefinition(&SDDS_output, &SDDS_output, format_ptr->source, format_ptr->target)) {
1181 fprintf(stderr, "Problem setting up to format %s from %s\n", format_ptr->target, format_ptr->source);
1182 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1183 exit(EXIT_FAILURE);
1184 }
1185 }
1186 break;
1187 case IS_EVALUATE_DEFINITION:
1188 evaluate_ptr = (EVALUATE_DEFINITION *)definition[i].structure;
1189 index = evaluate_ptr->is_parameter ? SDDS_GetParameterIndex(&SDDS_output, evaluate_ptr->name) : SDDS_GetColumnIndex(&SDDS_output, evaluate_ptr->name);
1190 if (index >= 0) {
1191 fprintf(stderr, "Can't define new -evaluate %s %s--already exists (sddsprocess)\n", evaluate_ptr->is_parameter ? "parameter" : "column", evaluate_ptr->name);
1192 exit(EXIT_FAILURE);
1193 }
1194 if ((index = evaluate_ptr->is_parameter ? SDDS_GetParameterIndex(&SDDS_output, evaluate_ptr->source) : SDDS_GetColumnIndex(&SDDS_output, evaluate_ptr->source)) < 0) {
1195 fprintf(stderr, "Can't evaluate %s %s--doesn't exist (sddsprocess)\n", evaluate_ptr->is_parameter ? "parameter" : "column", evaluate_ptr->source);
1196 exit(EXIT_FAILURE);
1197 }
1198 if ((evaluate_ptr->is_parameter ? SDDS_GetParameterType(&SDDS_output, index) : SDDS_GetColumnType(&SDDS_output, index)) != SDDS_STRING) {
1199 fprintf(stderr, "Can't evaluate %s %s--not string type (sddsprocess)\n", evaluate_ptr->is_parameter ? "parameter" : "column", evaluate_ptr->source);
1200 exit(EXIT_FAILURE);
1201 }
1202 if (!(evaluate_ptr->is_parameter ? SDDS_ProcessParameterString(&SDDS_output, evaluate_ptr->text, SDDS_WRITEONLY_DEFINITION) : SDDS_ProcessColumnString(&SDDS_output, evaluate_ptr->text, SDDS_WRITEONLY_DEFINITION))) {
1203 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1204 exit(EXIT_FAILURE);
1205 }
1206 break;
1207 case IS_FILTER_DEFINITION:
1208 case IS_MATCH_DEFINITION:
1209 case IS_RPNTEST_DEFINITION:
1210 case IS_RPNEXPRESSION_DEFINITION:
1211 case IS_CLIP_DEFINITION:
1212 case IS_FCLIP_DEFINITION:
1213 case IS_SPARSE_DEFINITION:
1214 case IS_SAMPLE_DEFINITION:
1215 case IS_NUMBERTEST_DEFINITION:
1216 case IS_TIME_FILTER_DEFINITION:
1217 break;
1218 case IS_CAST_DEFINITION:
1219 if (!complete_cast_definition(&SDDS_output, (CAST_DEFINITION *)definition[i].structure, &SDDS_input)) {
1220 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1221 exit(EXIT_FAILURE);
1222 }
1223 break;
1224 default:
1225 fprintf(stderr, "error: unknown definition type code %ld seen--this shouldn't happen!\n", definition[i].type);
1226 exit(EXIT_FAILURE);
1227 break;
1228 }
1229 }
1230
1231 if (!SDDS_DeleteParameterFixedValues(&SDDS_output)) {
1232 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1233 exit(EXIT_FAILURE);
1234 }
1235
1236 if (!SDDS_WriteLayout(&SDDS_output)) {
1237 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1238 exit(EXIT_FAILURE);
1239 }
1240
1241 if (summarize) {
1242 for (i = 0; i < definitions; i++) {
1243 switch (definition[i].type) {
1244 case IS_EQUATION_DEFINITION:
1245 equation_ptr = (EQUATION_DEFINITION *)definition[i].structure;
1246 fprintf(stderr, "%s %s created from equation %s:\n %s\n", equation_ptr->is_parameter ? "parameter" : "column", equation_ptr->name, equation_ptr->equation, equation_ptr->text);
1247 break;
1248 case IS_EVALUATE_DEFINITION:
1249 evaluate_ptr = (EVALUATE_DEFINITION *)definition[i].structure;
1250 fprintf(stderr, "evaluating to %s %s from %s\n", evaluate_ptr->is_parameter ? "parameter" : "column", evaluate_ptr->name, evaluate_ptr->source);
1251 break;
1252 case IS_EDIT_DEFINITION:
1253 edit_ptr = (EDIT_DEFINITION *)definition[i].structure;
1254 fprintf(stderr, "%s %s edit from %s using %s:\n %s\n", edit_ptr->is_parameter ? "parameter" : "column", edit_ptr->new_name, edit_ptr->source, edit_ptr->edit_command, edit_ptr->text);
1255 break;
1256 case IS_SCAN_DEFINITION:
1257 scan_ptr = (SCAN_DEFINITION *)definition[i].structure;
1258 fprintf(stderr, "%s %s scanned from %s using %s:\n %s\n", scan_ptr->is_parameter ? "parameter" : "column", scan_ptr->new_name, scan_ptr->source, scan_ptr->sscanf_string, scan_ptr->text);
1259 break;
1260 case IS_PRINT_DEFINITION:
1261 print_ptr = (PRINT_DEFINITION *)definition[i].structure;
1262 fprintf(stderr, "printing to %s %s from ", print_ptr->is_parameter ? "parameter" : "column", print_ptr->new_name);
1263 for (j = 0; j < print_ptr->sources; j++)
1264 fprintf(stderr, "%s ", print_ptr->source[j]);
1265 fprintf(stderr, ":\n %s\n", print_ptr->text);
1266 break;
1267 case IS_PROCESSING_DEFINITION:
1268 processing_ptr = (PROCESSING_DEFINITION *)definition[i].structure;
1269 fprintf(stderr, "column %s will be processed to give %s in parameter %s\n", processing_ptr->column_name, processing_ptr->description, processing_ptr->parameter_name);
1270 break;
1271 case IS_CONVERSION_DEFINITION:
1272 conversion_ptr = (CONVERSION_DEFINITION *)definition[i].structure;
1273 fprintf(stderr, "%s %s will be converted to %s using factor %e\n", conversion_ptr->is_parameter ? "parameter" : "column", conversion_ptr->name, conversion_ptr->new_units, conversion_ptr->factor);
1274 break;
1275 case IS_FILTER_DEFINITION:
1276 filter_ptr = (FILTER_DEFINITION *)definition[i].structure;
1277 show_filters(filter_ptr->is_parameter ? "parameter" : "column", filter_ptr->filter_term, filter_ptr->filter_terms);
1278 break;
1279 case IS_TIME_FILTER_DEFINITION:
1280 time_filter_ptr = (TIME_FILTER_DEFINITION *)definition[i].structure;
1281 fprintf(stderr, "Time filter: <%s> %22.15e, %22.15e\n", time_filter_ptr->name, time_filter_ptr->before, time_filter_ptr->after);
1282 case IS_MATCH_DEFINITION:
1283 match_ptr = (MATCH_DEFINITION *)definition[i].structure;
1284 show_matches(match_ptr->is_parameter ? "parameter" : "column", match_ptr->match_term, match_ptr->match_terms);
1285 break;
1286 case IS_RPNTEST_DEFINITION:
1287 rpntest_ptr = (RPNTEST_DEFINITION *)definition[i].structure;
1288 if (rpntest_ptr->autostop)
1289 fprintf(stderr, "%s-based autostop rpn test:\n %s\n", rpntest_ptr->is_parameter ? "parameter" : "column", rpntest_ptr->expression);
1290 else
1291 fprintf(stderr, "%s-based rpn test:\n %s\n", rpntest_ptr->is_parameter ? "parameter" : "column", rpntest_ptr->expression);
1292 break;
1293 case IS_NUMBERTEST_DEFINITION:
1294 numbertest_ptr = (NUMBERTEST_DEFINITION *)definition[i].structure;
1295 fprintf(stderr, "%s-based number test:\n %s %s%s\n", numbertest_ptr->is_parameter ? "parameter" : "column", numbertest_ptr->name, numbertest_ptr->flags & NUMSCANFILTER_INVERT ? " inverted" : "", numbertest_ptr->flags & NUMSCANFILTER_STRICT ? " strict" : "");
1296 break;
1297 case IS_RPNEXPRESSION_DEFINITION:
1298 rpnexpression_ptr = (RPNEXPRESSION_DEFINITION *)definition[i].structure;
1299 fprintf(stderr, "%srepeated rpn expression:\n %s\n", (rpnexpression_ptr->repeat ? "" : "un"), rpnexpression_ptr->expression);
1300 break;
1301 case IS_SYSTEM_DEFINITION:
1302 system_ptr = (SYSTEM_DEFINITION *)definition[i].structure;
1303 fprintf(stderr, "%s %s system-call from %s:\n %s\n", system_ptr->is_parameter ? "parameter" : "column", system_ptr->new_name, system_ptr->source, system_ptr->text);
1304 break;
1305 case IS_FORMAT_DEFINITION:
1306 format_ptr = (FORMAT_DEFINITION *)definition[i].structure;
1307 fprintf(stderr, "formating %s %s from %s using ", format_ptr->is_parameter ? "parameter" : "column", format_ptr->target, format_ptr->source);
1308 fprintf(stderr, "string: %s double: %s long: %s\n", format_ptr->stringFormat ? format_ptr->stringFormat : "<none>", format_ptr->doubleFormat ? format_ptr->doubleFormat : "<none>", format_ptr->longFormat ? format_ptr->longFormat : "<none>");
1309 break;
1310 case IS_CLIP_DEFINITION:
1311 clip_ptr = (CLIP_DEFINITION *)definition[i].structure;
1312 fprintf(stderr, "page clip operation:\n head = %" PRId64 " tail = %" PRId64 " invert = %hd\n", clip_ptr->head, clip_ptr->tail, clip_ptr->invert);
1313 break;
1314 case IS_FCLIP_DEFINITION:
1315 fclip_ptr = (FCLIP_DEFINITION *)definition[i].structure;
1316 fprintf(stderr, "page clip operation:\n head = %f tail = %f invert = %hd\n", fclip_ptr->fhead, fclip_ptr->ftail, fclip_ptr->invert);
1317 break;
1318 case IS_SPARSE_DEFINITION:
1319 sparse_ptr = (SPARSE_DEFINITION *)definition[i].structure;
1320 fprintf(stderr, "page sparse operation:\n interval = %" PRId64 " offset = %" PRId64 "\n", sparse_ptr->interval, sparse_ptr->offset);
1321 break;
1322 case IS_SAMPLE_DEFINITION:
1323 sample_ptr = (SAMPLE_DEFINITION *)definition[i].structure;
1324 fprintf(stderr, "page sample operation:\n fraction = %.8g\n", sample_ptr->fraction);
1325 break;
1326 case IS_CAST_DEFINITION:
1327 cast_ptr = (CAST_DEFINITION *)definition[i].structure;
1328 fprintf(stderr, "%s %s cast from %s to type %s\n", cast_ptr->isParameter ? "parameter" : "column", cast_ptr->newName, cast_ptr->source, cast_ptr->newTypeName);
1329 break;
1330 default:
1331 fprintf(stderr, "error: unknown definition type code %ld seen--this shouldn't happen!\n", definition[i].type);
1332 exit(EXIT_FAILURE);
1333 break;
1334 }
1335 }
1336 }
1337
1338 while ((page_number = SDDS_ReadPage(&SDDS_input)) > 0) {
1339 if (!SDDS_CopyPage(&SDDS_output, &SDDS_input)) {
1340 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1341 exit(EXIT_FAILURE);
1342 }
1343 if (!SDDS_SetRowFlags(&SDDS_output, 1)) {
1344 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1345 exit(EXIT_FAILURE);
1346 }
1347 if ((n_rows = SDDS_CountRowsOfInterest(&SDDS_output)) <= 0 && SDDS_ColumnCount(&SDDS_output) != 0) {
1348 if (!nowarnings)
1349 fprintf(stderr, "warning: no rows selected for page %" PRId32 "\n", SDDS_output.page_number);
1350 if (n_rows == 0)
1351 SDDS_ClearErrors();
1352 else
1353 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1354 }
1355 if (verbose) {
1356 fprintf(stderr, "page number %ld read in, with %" PRId64 " rows of data\n", page_number, n_rows);
1357 for (i = 0; i < original_parameters; i++) {
1358 SDDS_PrintTypedValue(SDDS_output.parameter[i], 0, SDDS_output.layout.parameter_definition[i].type, NULL, stderr, 0);
1359 fputc('\n', stderr);
1360 }
1361 }
1362 rpn_store((double)page_number, NULL, table_number_memory);
1363 rpn_store((double)page_number, NULL, i_page_memory);
1364 row_deletion = skip_page = 0;
1365 i = -1;
1366 while (++i < definitions && !skip_page) {
1367 rpn_store((double)n_rows, NULL, n_rows_memory);
1368 switch (definition[i].type) {
1369 case IS_CONVERSION_DEFINITION:
1370 conversion_ptr = (CONVERSION_DEFINITION *)definition[i].structure;
1371 if (conversion_ptr->is_parameter) {
1372 if (!SDDS_ApplyFactorToParameter(&SDDS_output, conversion_ptr->name, conversion_ptr->factor)) {
1373 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1374 exit(EXIT_FAILURE);
1375 }
1376 } else if (n_rows && !SDDS_ApplyFactorToColumn(&SDDS_output, conversion_ptr->name, conversion_ptr->factor)) {
1377 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1378 exit(EXIT_FAILURE);
1379 }
1380 if (verbose)
1381 fprintf(stderr, "conversion done: %s %s from %s to %s using factor %e\n", conversion_ptr->is_parameter ? "parameter" : "column", conversion_ptr->name, conversion_ptr->old_units, conversion_ptr->new_units, conversion_ptr->factor);
1382 break;
1383 case IS_PROCESSING_DEFINITION:
1384 processing_ptr = (PROCESSING_DEFINITION *)definition[i].structure;
1385 if (processing_ptr->type != SDDS_STRING) {
1386 if (!process_column(&SDDS_output, processing_ptr, &result, &stringResult, !nowarnings, threads))
1387 exit(EXIT_FAILURE);
1388 if (processing_ptr->outputType != SDDS_STRING) {
1389 if (!SDDS_SetParameters(&SDDS_output, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, processing_ptr->parameter_name, result, NULL)) {
1390 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1391 exit(EXIT_FAILURE);
1392 }
1393 rpn_store(result, NULL, processing_ptr->memory_number);
1394 if (verbose)
1395 fprintf(stderr, "processing result: %s = %e\n", processing_ptr->parameter_name, result);
1396 } else {
1397 if (!SDDS_SetParameters(&SDDS_output, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, processing_ptr->parameter_name, stringResult, NULL)) {
1398 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1399 exit(EXIT_FAILURE);
1400 }
1401 if (verbose)
1402 fprintf(stderr, "processing result: %s = %s\n", processing_ptr->parameter_name, stringResult);
1403 free(stringResult);
1404 }
1405 } else {
1406 if (!(stringResult = process_string_column(&SDDS_output, processing_ptr, !nowarnings)) ||
1407 !SDDS_SetParameters(&SDDS_output, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, processing_ptr->parameter_name, stringResult, NULL)) {
1408 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1409 exit(EXIT_FAILURE);
1410 }
1411 free(stringResult);
1412 }
1413 break;
1414 case IS_EDIT_DEFINITION:
1415 edit_ptr = (EDIT_DEFINITION *)definition[i].structure;
1416 if (edit_ptr->is_parameter) {
1417 if (!edit_parameter_value(&SDDS_output, edit_ptr->new_name, edit_ptr->source, edit_ptr->edit_command)) {
1418 fprintf(stderr, "couldn't edit %s to make %s\n", edit_ptr->source, edit_ptr->new_name);
1419 exit(EXIT_FAILURE);
1420 }
1421 } else if (n_rows && !edit_column_value(&SDDS_output, edit_ptr->new_name, edit_ptr->source, edit_ptr->edit_command)) {
1422 fprintf(stderr, "couldn't edit %s to make %s\n", edit_ptr->source, edit_ptr->new_name);
1423 exit(EXIT_FAILURE);
1424 }
1425 if (verbose)
1426 fprintf(stderr, "edited %s %s to produce %s, using edit-command %s\n", edit_ptr->is_parameter ? "parameter" : "column", edit_ptr->source, edit_ptr->new_name, edit_ptr->edit_command);
1427 break;
1428 case IS_SCAN_DEFINITION:
1429 scan_ptr = (SCAN_DEFINITION *)definition[i].structure;
1430 if (scan_ptr->is_parameter) {
1431 if (!scan_parameter_value(&SDDS_output, scan_ptr->new_name, scan_ptr->source, scan_ptr->sscanf_string, scan_ptr->edit)) {
1432 fprintf(stderr, "couldn't scan %s to make %s\n", scan_ptr->source, scan_ptr->new_name);
1433 exit(EXIT_FAILURE);
1434 }
1435 } else if (n_rows && !scan_column_value(&SDDS_output, scan_ptr->new_name, scan_ptr->source, scan_ptr->sscanf_string, scan_ptr->edit)) {
1436 fprintf(stderr, "couldn't scan %s to make %s\n", scan_ptr->source, scan_ptr->new_name);
1437 exit(EXIT_FAILURE);
1438 }
1439 if (verbose)
1440 fprintf(stderr, "scanned %s %s to produce %s, using sscanf string %s\n", scan_ptr->is_parameter ? "parameter" : "column", scan_ptr->source, scan_ptr->new_name, scan_ptr->sscanf_string);
1441 break;
1442 case IS_PRINT_DEFINITION:
1443 print_ptr = (PRINT_DEFINITION *)definition[i].structure;
1444 if (print_ptr->is_parameter) {
1445 if (!print_parameter_value(&SDDS_output, print_ptr->new_name, print_ptr->source, print_ptr->sources, print_ptr->printf_string)) {
1446 fprintf(stderr, "couldn't print to make parameter %s\n", print_ptr->new_name);
1447 exit(EXIT_FAILURE);
1448 }
1449 } else if (n_rows && !print_column_value(&SDDS_output, print_ptr->new_name, print_ptr->source, print_ptr->sources, print_ptr->printf_string)) {
1450 fprintf(stderr, "couldn't print to make column %s\n", print_ptr->new_name);
1451 exit(EXIT_FAILURE);
1452 }
1453 break;
1454 case IS_EQUATION_DEFINITION:
1455 equation_ptr = (EQUATION_DEFINITION *)definition[i].structure;
1456 if (equation_ptr->is_parameter) {
1457 if (!SDDS_ComputeParameter(&SDDS_output, SDDS_GetParameterIndex(&SDDS_output, equation_ptr->name), equation_ptr->udf_name)) {
1458 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1459 exit(EXIT_FAILURE);
1460 }
1461 } else if (n_rows) {
1462 k = i++;
1463 while (i < definitions && definition[i].type == IS_EQUATION_DEFINITION) {
1464 equation_ptr = (EQUATION_DEFINITION *)definition[i].structure;
1465 if (equation_ptr->is_parameter)
1466 break;
1467 else
1468 i++;
1469 }
1470 if (!SDDS_ComputeSetOfColumns(&SDDS_output, k, i, definition)) {
1471 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1472 exit(EXIT_FAILURE);
1473 }
1474 i--;
1475 }
1476 if (verbose)
1477 fprintf(stderr, "computed %s %s using expression %s\n", equation_ptr->is_parameter ? "parameter" : "column", equation_ptr->name, equation_ptr->equation);
1478 break;
1479 case IS_EVALUATE_DEFINITION:
1480 evaluate_ptr = (EVALUATE_DEFINITION *)definition[i].structure;
1481 if (evaluate_ptr->is_parameter) {
1482 if (!SDDS_EvaluateParameter(&SDDS_output, evaluate_ptr)) {
1483 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1484 exit(EXIT_FAILURE);
1485 }
1486 } else if (n_rows) {
1487 if (!SDDS_EvaluateColumn(&SDDS_output, evaluate_ptr)) {
1488 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1489 exit(EXIT_FAILURE);
1490 }
1491 }
1492 if (verbose)
1493 fprintf(stderr, "computed %s %s using expressions from %s\n", evaluate_ptr->is_parameter ? "parameter" : "column", evaluate_ptr->name, evaluate_ptr->source);
1494 break;
1495 case IS_FORMAT_DEFINITION:
1496 format_ptr = (FORMAT_DEFINITION *)definition[i].structure;
1497 if (format_ptr->is_parameter) {
1498 if (!format_parameter_value(&SDDS_output, format_ptr)) {
1499 fprintf(stderr, "couldn't format parameter %s\n", format_ptr->target);
1500 exit(EXIT_FAILURE);
1501 }
1502 } else if (n_rows && !format_column_value(&SDDS_output, format_ptr)) {
1503 fprintf(stderr, "couldn't format column %s\n", format_ptr->target);
1504 exit(EXIT_FAILURE);
1505 }
1506 if (verbose)
1507 fprintf(stderr, "formatted %s %s\n", format_ptr->is_parameter ? "parameter" : "column", format_ptr->target);
1508 break;
1509 case IS_TIME_FILTER_DEFINITION:
1510 time_filter_ptr = (TIME_FILTER_DEFINITION *)definition[i].structure;
1511 if (time_filter_ptr->is_parameter) {
1512 if (!(pardefptr = SDDS_GetParameterDefinition(&SDDS_output, time_filter_ptr->name)) ||
1513 (pardefptr->type == SDDS_STRING || pardefptr->type == SDDS_CHARACTER)) {
1514 fprintf(stderr, "error: unknown or non-numeric parameter %s given for time filter\n", time_filter_ptr->name);
1515 exit(EXIT_FAILURE);
1516 }
1517 accept = SDDS_ItemInsideWindow(SDDS_GetParameter(&SDDS_output, time_filter_ptr->name, &result), 0, pardefptr->type, time_filter_ptr->after, time_filter_ptr->before);
1518
1519 if (!accept)
1520 skip_page = 1;
1521 if (time_filter_ptr->flags & TIMEFILTER_INVERT_GIVEN)
1522 skip_page = !skip_page;
1523 if (skip_page) {
1524 if (verbose)
1525 fputs(" * page outside parameter filter--continuing to next page", stderr);
1526 continue;
1527 }
1528 } else if (n_rows) {
1529 int64_t nleft;
1530 if (verbose) {
1531 fprintf(stderr, " * applying time filter (column %s)", time_filter_ptr->name);
1532 fflush(stderr);
1533 }
1534 if ((nleft = SDDS_FilterRowsOfInterest(&SDDS_output, time_filter_ptr->name, time_filter_ptr->after, time_filter_ptr->before, time_filter_ptr->flags & TIMEFILTER_INVERT_GIVEN ? SDDS_NEGATE_EXPRESSION : SDDS_AND)) < 0) {
1535 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1536 exit(EXIT_FAILURE);
1537 }
1538 if (verbose) {
1539 fprintf(stderr, "---%" PRId64 " rows left\n", nleft);
1540 fflush(stderr);
1541 }
1542 row_deletion = 1;
1543 }
1544 break;
1545 case IS_FILTER_DEFINITION:
1546 filter_ptr = (FILTER_DEFINITION *)definition[i].structure;
1547 filter_term = filter_ptr->filter_term;
1548 for (j = 0; j < filter_ptr->filter_terms; j++) {
1549 if (filter_term[j].lowerPar && !SDDS_GetParameterAsDouble(&SDDS_input, filter_term[j].lowerPar, &(filter_term[j].lower))) {
1550 fprintf(stderr, "Error: unable to get parameter %s value for the lower filter from input file.\n", filter_term[j].lowerPar);
1551 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1552 exit(EXIT_FAILURE);
1553 }
1554 if (filter_term[j].upperPar && !SDDS_GetParameterAsDouble(&SDDS_input, filter_term[j].upperPar, &(filter_term[j].upper))) {
1555 fprintf(stderr, "Error: unable to get parameter %s value for the upper filter from input file.\n", filter_term[j].upperPar);
1556 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1557 exit(EXIT_FAILURE);
1558 }
1559 if (filter_term[j].upper < filter_term[j].lower) {
1560 fprintf(stderr, "Error: invalid %s filter provided.\n", filter_term[j].name);
1561 exit(EXIT_FAILURE);
1562 }
1563 }
1564 if (filter_ptr->is_parameter) {
1565 accept = 1;
1566 filter_term = filter_ptr->filter_term;
1567 for (j = 0; j < filter_ptr->filter_terms; j++) {
1568 if (!(pardefptr = SDDS_GetParameterDefinition(&SDDS_output, filter_term[j].name)) ||
1569 (pardefptr->type == SDDS_STRING || pardefptr->type == SDDS_CHARACTER)) {
1570 fprintf(stderr, "error: unknown or non-numeric parameter %s given for filter\n", filter_term[j].name);
1571 exit(EXIT_FAILURE);
1572 }
1573 accept = SDDS_Logic(accept, SDDS_ItemInsideWindow(SDDS_GetParameter(&SDDS_output, filter_term[j].name, &result), 0, pardefptr->type, filter_term[j].lower, filter_term[j].upper), filter_term[j].logic);
1574 }
1575 if (!accept) {
1576 if (verbose)
1577 fputs(" * page failed parameter matching--continuing to next page", stderr);
1578 skip_page = 1;
1579 continue;
1580 }
1581 } else if (n_rows) {
1582 int64_t nleft;
1583 filter_term = filter_ptr->filter_term;
1584 for (j = 0; j < filter_ptr->filter_terms; j++) {
1585 if (verbose) {
1586 fprintf(stderr, " * applying filter term %" PRId64 " (column %s)", j, filter_term[j].name);
1587 fflush(stderr);
1588 }
1589 if ((nleft = SDDS_FilterRowsOfInterest(&SDDS_output, filter_term[j].name, filter_term[j].lower, filter_term[j].upper, filter_term[j].logic)) < 0) {
1590 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1591 exit(EXIT_FAILURE);
1592 }
1593 if (verbose) {
1594 fprintf(stderr, "---%" PRId64 " rows left\n", nleft);
1595 fflush(stderr);
1596 }
1597 }
1598 row_deletion = 1;
1599 }
1600 if (verbose)
1601 fprintf(stderr, "applied %s filter\n", filter_ptr->is_parameter ? "parameter" : "column");
1602 break;
1603 case IS_MATCH_DEFINITION:
1604 match_ptr = (MATCH_DEFINITION *)definition[i].structure;
1605 if (match_ptr->is_parameter) {
1606 accept = 1;
1607 match_term = match_ptr->match_term;
1608 for (j = 0; j < match_ptr->match_terms; j++) {
1609 if (!(pardefptr = SDDS_GetParameterDefinition(&SDDS_output, match_term[j].name)) ||
1610 !(pardefptr->type == SDDS_STRING || pardefptr->type == SDDS_CHARACTER)) {
1611 fprintf(stderr, "error: unknown or numeric parameter %s given for match\n", match_term[j].name);
1612 exit(EXIT_FAILURE);
1613 }
1614 if (pardefptr->type == SDDS_STRING) {
1615 char **ppc;
1616 ppc = SDDS_GetParameter(&SDDS_output, match_term[j].name, NULL);
1617 strcpy(s, *ppc);
1618 } else {
1619 char *pc;
1620 pc = SDDS_GetParameter(&SDDS_output, match_term[j].name, NULL);
1621 sprintf(s, "%c", *pc);
1622 }
1623 accept = SDDS_Logic(accept, (match_term[j].logic & SDDS_NOCASE_COMPARE ? wild_match_ci(s, match_term[j].string) : wild_match(s, match_term[j].string)), match_term[j].logic);
1624 }
1625 if (!accept) {
1626 if (verbose)
1627 fputs(" * page failed parameter matching--continuing to next page", stderr);
1628 skip_page = 1;
1629 continue;
1630 }
1631 } else if (n_rows) {
1632 match_term = match_ptr->match_term;
1633 for (j = 0; j < match_ptr->match_terms; j++)
1634 if (SDDS_MatchRowsOfInterest(&SDDS_output, match_term[j].name, match_term[j].string, match_term[j].logic) < 0) {
1635 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1636 exit(EXIT_FAILURE);
1637 }
1638 row_deletion = 1;
1639 }
1640 if (verbose)
1641 fprintf(stderr, "applied %s match\n", match_ptr->is_parameter ? "parameter" : "column");
1642 break;
1643 case IS_RPNTEST_DEFINITION:
1644 rpntest_ptr = (RPNTEST_DEFINITION *)definition[i].structure;
1645 rpn_lock();
1646 SDDS_StoreParametersInRpnMemories(&SDDS_output);
1647 if (rpntest_ptr->is_parameter) {
1648 rpn_clear();
1649 rpn(rpntest_ptr->expression);
1650 if (rpn_check_error()) {
1651 rpn_unlock();
1652 exit(EXIT_FAILURE);
1653 }
1654 if (!pop_log(&test_result)) {
1655 rpn_unlock();
1656 SDDS_Bomb("aborted due to rpn logical stack/result error for parameter-based test");
1657 }
1658 rpn_clear();
1659 if (!test_result) {
1660 if (!rpntest_ptr->autostop) {
1661 if (verbose)
1662 fputs(" * page failed rpn test--continuing to next page", stderr);
1663 skip_page = 1;
1664 rpn_unlock();
1665 continue;
1666 } else {
1667 if (verbose)
1668 fputs(" * page failed rpn test--ignore remainder of file", stderr);
1669 rpn_unlock();
1670 exit(EXIT_FAILURE);
1671 }
1672 }
1673 } else if (n_rows) {
1674 if (!SDDS_FilterRowsWithRpnTest(&SDDS_output, rpntest_ptr->expression)) {
1675 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1676 rpn_unlock();
1677 exit(EXIT_FAILURE);
1678 }
1679 row_deletion = 1;
1680 }
1681 rpn_unlock();
1682 if (verbose)
1683 fprintf(stderr, "applied %s-based rpn test:\n %s\n", rpntest_ptr->is_parameter ? "parameter" : "column", rpntest_ptr->expression);
1684 break;
1685 case IS_NUMBERTEST_DEFINITION:
1686 numbertest_ptr = (NUMBERTEST_DEFINITION *)definition[i].structure;
1687 if (numbertest_ptr->is_parameter) {
1688 skip_page = !ParameterScansAsNumber(&SDDS_output, numbertest_ptr->name, numbertest_ptr->flags & NUMSCANFILTER_INVERT);
1689 } else if (n_rows) {
1690 if (SDDS_FilterRowsByNumScan(&SDDS_output, numbertest_ptr->name, numbertest_ptr->flags) == -1) {
1691 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1692 exit(EXIT_FAILURE);
1693 }
1694 row_deletion = 1;
1695 }
1696 if (verbose)
1697 fprintf(stderr, "applied %s-based %s%snumber test\n", numbertest_ptr->is_parameter ? "parameter" : "column", numbertest_ptr->flags & NUMSCANFILTER_INVERT ? " inverted " : "", numbertest_ptr->flags & NUMSCANFILTER_STRICT ? " strict " : "");
1698 break;
1699 case IS_SYSTEM_DEFINITION:
1700 system_ptr = (SYSTEM_DEFINITION *)definition[i].structure;
1701 if (system_ptr->is_parameter) {
1702 if (!system_parameter_value(&SDDS_output, system_ptr->new_name, system_ptr->source)) {
1703 fprintf(stderr, "couldn't system %s to make %s\n", system_ptr->source, system_ptr->new_name);
1704 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1705 exit(EXIT_FAILURE);
1706 }
1707 } else if (n_rows && !system_column_value(&SDDS_output, system_ptr->new_name, system_ptr->source)) {
1708 fprintf(stderr, "couldn't system %s to make %s\n", system_ptr->source, system_ptr->new_name);
1709 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1710 exit(EXIT_FAILURE);
1711 }
1712 if (verbose)
1713 fprintf(stderr, "systemed %s %s to produce %s\n", system_ptr->is_parameter ? "parameter" : "column", system_ptr->source, system_ptr->new_name);
1714 break;
1715 case IS_RPNEXPRESSION_DEFINITION:
1716 rpnexpression_ptr = (RPNEXPRESSION_DEFINITION *)definition[i].structure;
1717 if (rpnexpression_ptr->repeat == -1)
1718 continue;
1719 rpn_lock();
1720 SDDS_StoreParametersInRpnMemories(&SDDS_output);
1721 SDDS_StoreColumnsInRpnArrays(&SDDS_output);
1722 rpn(rpnexpression_ptr->expression);
1723 if (rpn_check_error()) {
1724 rpn_unlock();
1725 exit(EXIT_FAILURE);
1726 }
1727 rpn_clear();
1728 rpn_unlock();
1729 if (verbose)
1730 fprintf(stderr, "executed rpn expression:\n %s\n", rpnexpression_ptr->expression);
1731 if (!rpnexpression_ptr->repeat)
1732 rpnexpression_ptr->repeat = -1; /* already done, don't repeat */
1733 break;
1734 case IS_CLIP_DEFINITION:
1735 if (n_rows) {
1736 clip_ptr = (CLIP_DEFINITION *)definition[i].structure;
1737 if (!SDDS_SetRowFlags(&SDDS_output, clip_ptr->invert ? 0 : 1) ||
1738 (clip_ptr->head &&
1739 !SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, (int64_t)0, (int64_t)(clip_ptr->head - 1), clip_ptr->invert ? 1 : 0)) ||
1740 (n_rows >= clip_ptr->tail && clip_ptr->tail && !SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, (int64_t)(n_rows - clip_ptr->tail), (int64_t)(n_rows - 1), clip_ptr->invert ? 1 : 0))) {
1741 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1742 exit(EXIT_FAILURE);
1743 }
1744 row_deletion = 1;
1745 }
1746 break;
1747 case IS_FCLIP_DEFINITION:
1748 if (n_rows) {
1749 fclip_ptr = (FCLIP_DEFINITION *)definition[i].structure;
1750 fclip_ptr->head = fclip_ptr->fhead * n_rows;
1751 fclip_ptr->tail = fclip_ptr->ftail * n_rows;
1752 if (!SDDS_SetRowFlags(&SDDS_output, fclip_ptr->invert ? 0 : 1) ||
1753 (fclip_ptr->head &&
1754 !SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, (int64_t)0, (int64_t)(fclip_ptr->head - 1), fclip_ptr->invert ? 1 : 0)) ||
1755 (n_rows >= fclip_ptr->tail && fclip_ptr->tail && !SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, (int64_t)(n_rows - fclip_ptr->tail), (int64_t)(n_rows - 1), fclip_ptr->invert ? 1 : 0))) {
1756 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1757 exit(EXIT_FAILURE);
1758 }
1759 row_deletion = 1;
1760 }
1761 break;
1762 case IS_SPARSE_DEFINITION:
1763 if (n_rows) {
1764 int32_t *sparse_row_flag;
1765 sparse_ptr = (SPARSE_DEFINITION *)definition[i].structure;
1766 sparse_row_flag = tmalloc(sizeof(*sparse_row_flag) * n_rows);
1767 for (j = 0; j < n_rows; j++)
1768 sparse_row_flag[j] = 0;
1769 for (j = sparse_ptr->offset; j < n_rows; j += sparse_ptr->interval)
1770 sparse_row_flag[j] = 1;
1771 if (!SDDS_AssertRowFlags(&SDDS_output, SDDS_FLAG_ARRAY, sparse_row_flag, n_rows)) {
1772 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1773 exit(EXIT_FAILURE);
1774 }
1775 free(sparse_row_flag);
1776 row_deletion = 1;
1777 }
1778 break;
1779 case IS_SAMPLE_DEFINITION:
1780 if (n_rows) {
1781 int32_t *sample_row_flag;
1782 sample_ptr = (SAMPLE_DEFINITION *)definition[i].structure;
1783 sample_row_flag = tmalloc(sizeof(*sample_row_flag) * n_rows);
1784 for (j = 0; j < n_rows; j++)
1785 sample_row_flag[j] = random_1(1) < sample_ptr->fraction ? 1 : 0;
1786 if (!SDDS_AssertRowFlags(&SDDS_output, SDDS_FLAG_ARRAY, sample_row_flag, n_rows)) {
1787 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1788 exit(EXIT_FAILURE);
1789 }
1790 free(sample_row_flag);
1791 row_deletion = 1;
1792 }
1793 break;
1794 case IS_CAST_DEFINITION:
1795 cast_ptr = (CAST_DEFINITION *)definition[i].structure;
1796 if (cast_ptr->isParameter) {
1797 if (!cast_parameter_value(&SDDS_output, cast_ptr))
1798 exit(EXIT_FAILURE);
1799 } else if (n_rows && !cast_column_value(&SDDS_output, cast_ptr)) {
1800 exit(EXIT_FAILURE);
1801 }
1802 break;
1803 default:
1804 fprintf(stderr, "error: unknown definition type code %ld seen--this shouldn't happen!\n", definition[i].type);
1805 exit(EXIT_FAILURE);
1806 break;
1807 }
1808 if (n_rows && row_deletion) {
1809 if (i != (definitions - 1) && !SDDS_DeleteUnsetRows(&SDDS_output)) {
1810 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1811 exit(EXIT_FAILURE);
1812 }
1813 if ((n_rows = SDDS_CountRowsOfInterest(&SDDS_output)) <= 0 &&
1814 SDDS_ColumnCount(&SDDS_output) != 0) {
1815 if (!nowarnings)
1816 fprintf(stderr, "warning: no rows selected for page %" PRId32 "\n", SDDS_output.page_number);
1817 if (SDDS_NumberOfErrors())
1818 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1819 continue;
1820 }
1821 if (verbose)
1822 fprintf(stderr, " %" PRId64 " rows left\n", n_rows);
1823 }
1824 }
1825 if (skip_page)
1826 continue;
1827 if (verbose)
1828 fprintf(stderr, " %" PRId64 " rows selected for output\n", n_rows);
1829 if (!SDDS_WritePage(&SDDS_output)) {
1830 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1831 exit(EXIT_FAILURE);
1832 }
1833 }
1834
1835 if (page_number == 0) {
1836 fprintf(stderr, "Error: problem reading input file\n");
1837 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1838 exit(EXIT_FAILURE);
1839 }
1840
1841 if (!SDDS_Terminate(&SDDS_input) || !SDDS_Terminate(&SDDS_output)) {
1842 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1843 exit(EXIT_FAILURE);
1844 }
1845
1846 if (tmpfile_used && !replaceFileAndBackUp(inputfile, outputfile))
1847 exit(EXIT_FAILURE);
1848 free_scanargs(&s_arg, argc);
1849
1850 if (processing_definition)
1851 free_processing_definiton(processing_definition, processing_definitions);
1852 if (equation_definition)
1853 free_equation_definition(equation_definition, equation_definitions);
1854
1855 return EXIT_SUCCESS;
1856}
1857
1858void free_processing_definiton(PROCESSING_DEFINITION **processing_definition, long n) {
1859 long i;
1860 for (i = 0; i < n; i++) {
1861 if (processing_definition[i]->parameter_name)
1862 free(processing_definition[i]->parameter_name);
1863 if (processing_definition[i]->column_name)
1864 free(processing_definition[i]->column_name);
1865 if (processing_definition[i]->description)
1866 free(processing_definition[i]->description);
1867 if (processing_definition[i]->symbol)
1868 free(processing_definition[i]->symbol);
1869 if (processing_definition[i]->functionOf)
1870 free(processing_definition[i]->functionOf);
1871 if (processing_definition[i]->weightBy)
1872 free(processing_definition[i]->weightBy);
1873 if (processing_definition[i]->match_value)
1874 free(processing_definition[i]->match_value);
1875 if (processing_definition[i]->match_column)
1876 free(processing_definition[i]->match_column);
1877 free(processing_definition[i]);
1878 }
1879 if (processing_definition)
1880 free(processing_definition);
1881}
1882
1883void free_equation_definition(EQUATION_DEFINITION **equation_definition, long n) {
1884 long i, j;
1885 for (i = 0; i < n; i++) {
1886 if (equation_definition[i]->text)
1887 free(equation_definition[i]->text);
1888 if (equation_definition[i]->name)
1889 free(equation_definition[i]->name);
1890 if (equation_definition[i]->equation)
1891 free(equation_definition[i]->equation);
1892 if (equation_definition[i]->udf_name && equation_definition[i]->udf_name != equation_definition[i]->equation)
1893 free(equation_definition[i]->udf_name);
1894 if (equation_definition[i]->editSelection)
1895 free(equation_definition[i]->editSelection);
1896 if (equation_definition[i]->select)
1897 free(equation_definition[i]->select);
1898 if (equation_definition[i]->argv) {
1899 for (j = 0; j < equation_definition[i]->argc; j++)
1900 free(equation_definition[i]->argv[j]);
1901 free(equation_definition[i]->argv);
1902 }
1903 free(equation_definition[i]);
1904 }
1905 if (equation_definition)
1906 free(equation_definition);
1907}
1908
1909typedef struct
1910{
1911 long column;
1912 char *equation;
1913} COLUMN_LIST;
1914
1915long SDDS_ComputeSetOfColumns(SDDS_DATASET *SDDS_dataset, long equ_begin, long equ_end, DEFINITION *definition) {
1916 EQUATION_DEFINITION *equation_ptr;
1917 long column;
1918 SDDS_LAYOUT *layout;
1919 double value;
1920 long equations_present;
1921 COLUMN_LIST *column_list;
1922 long column_list_ptr, max_column_list_counter, column_list_entries;
1923 long return_value;
1924 int64_t j;
1925
1926 column_list = NULL;
1927 column_list_ptr = -1;
1928 max_column_list_counter = 0;
1929 column_list_entries = 0;
1930 return_value = 0;
1931 if (!SDDS_CheckDataset(SDDS_dataset, "SDDS_ComputeColumn"))
1932 return (0);
1933 rpn_lock();
1934 layout = &SDDS_dataset->layout;
1935 column_list = NULL;
1936 column_list_ptr = -1;
1937 max_column_list_counter = 0;
1938 for (equations_present = equ_begin; equations_present < equ_end; equations_present++) {
1939 equation_ptr = (EQUATION_DEFINITION *)definition[equations_present].structure;
1940
1941 if (++column_list_ptr >= max_column_list_counter || !column_list)
1942 column_list = trealloc(column_list, sizeof(*column_list) * (max_column_list_counter += 4));
1943 column_list[column_list_ptr].column = SDDS_GetColumnIndex(SDDS_dataset, equation_ptr->name);
1944 if (equation_ptr->equation[0] == '@') {
1945 char **equation, *ptr, pfix[IFPF_BUF_SIZE];
1946 if (equation_ptr->equation[1] == '@') {
1947 /* Parameter contains algebraic notation */
1948 if (!(equation = SDDS_GetParameter(SDDS_dataset, equation_ptr->equation + 2, NULL)))
1949 SDDS_Bomb("unable to read parameter for equation definition");
1950 ptr = addOuterParentheses(*equation);
1951 if2pf(pfix, ptr, sizeof pfix);
1952 free(ptr);
1953 free(*equation);
1954 *equation = NULL;
1955 if (!SDDS_CopyString(equation, pfix)) {
1956 free(equation);
1957 fprintf(stderr, "error: problem copying argument string\n");
1958 goto cleanup;
1959 }
1960 } else {
1961 if (!(equation = SDDS_GetParameter(SDDS_dataset, equation_ptr->equation + 1, NULL)))
1962 SDDS_Bomb("unable to read parameter for equation definition");
1963 }
1964
1965 create_udf(equation_ptr->udf_name, *equation);
1966 free(*equation);
1967 free(equation);
1968 }
1969 cp_str(&column_list[column_list_ptr].equation, equation_ptr->udf_name);
1970 column_list_entries++;
1971 if (column_list[column_list_ptr].column < 0 || column_list[column_list_ptr].column >= layout->n_columns)
1972 goto cleanup;
1973 }
1974
1975 if (table_number_mem == -1) {
1976 table_number_mem = rpn_create_mem("table_number", 0);
1977 i_page_mem = rpn_create_mem("i_page", 0);
1978 n_rows_mem = rpn_create_mem("n_rows", 0);
1979 i_row_mem = rpn_create_mem("i_row", 0);
1980 }
1981
1982 rpn_store((double)SDDS_dataset->page_number, NULL, table_number_mem);
1983 rpn_store((double)SDDS_dataset->page_number, NULL, i_page_mem);
1984 rpn_store((double)SDDS_dataset->n_rows, NULL, n_rows_mem);
1985
1986 /*
1987 Preserve command-line evaluation order for consecutive column definitions.
1988 In particular, expressions using array access (e.g. "&column [") must see
1989 the fully materialized results of earlier definitions on the current page,
1990 not a stale snapshot from before the batch started.
1991 */
1992 column_list_ptr = 0;
1993 for (equations_present = equ_begin; equations_present < equ_end; equations_present++, column_list_ptr++) {
1994 if (!SDDS_StoreParametersInRpnMemories(SDDS_dataset))
1995 goto cleanup;
1996 if (!SDDS_StoreColumnsInRpnArrays(SDDS_dataset))
1997 goto cleanup;
1998
1999 column = column_list[column_list_ptr].column;
2000 for (j = 0; j < SDDS_dataset->n_rows; j++) {
2001#if defined(DEBUG)
2002 fprintf(stderr, "Working on row %ld\n", j);
2003#endif
2004 if (!SDDS_StoreRowInRpnMemories(SDDS_dataset, j))
2005 goto cleanup;
2006 rpn_clear();
2007 rpn_store((double)j, NULL, i_row_mem);
2008 value = rpn(column_list[column_list_ptr].equation);
2009 rpn_store(value, NULL, layout->column_definition[column].memory_number);
2010 if (rpn_check_error()) {
2011 SDDS_SetError("Unable to compute rpn expression--rpn error (SDDS_ComputeDefinedColumn)");
2012 goto cleanup;
2013 }
2014#if defined(DEBUG)
2015 fprintf(stderr, "computed row value: %s = %e\n", layout->column_definition[column].name, value);
2016#endif
2017 switch (layout->column_definition[column].type) {
2018 case SDDS_CHARACTER:
2019 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (char)value, -1);
2020 break;
2021 case SDDS_SHORT:
2022 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (short)value, -1);
2023 break;
2024 case SDDS_USHORT:
2025 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (unsigned short)value, -1);
2026 break;
2027 case SDDS_LONG:
2028 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (int32_t)value, -1);
2029 break;
2030 case SDDS_ULONG:
2031 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (uint32_t)value, -1);
2032 break;
2033 case SDDS_LONG64:
2034 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (int64_t)value, -1);
2035 break;
2036 case SDDS_ULONG64:
2037 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (uint64_t)value, -1);
2038 break;
2039 case SDDS_FLOAT:
2040 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (float)value, -1);
2041 break;
2042 case SDDS_DOUBLE:
2043 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (double)value, -1);
2044 break;
2045 case SDDS_LONGDOUBLE:
2046 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (long double)value, -1);
2047 break;
2048 }
2049 }
2050 }
2051
2052 return_value = 1;
2053
2054cleanup:
2055 if (column_list) {
2056 for (column_list_ptr = 0; column_list_ptr < column_list_entries; column_list_ptr++) {
2057 if (column_list[column_list_ptr].equation) {
2058 free(column_list[column_list_ptr].equation);
2059 column_list[column_list_ptr].equation = NULL;
2060 }
2061 }
2062 free(column_list);
2063 }
2064
2065 rpn_unlock();
2066 return (return_value);
2067}
2068
2069long SDDS_EvaluateColumn(SDDS_DATASET *SDDS_dataset, EVALUATE_DEFINITION *definition) {
2070 double value;
2071 char **equation;
2072 long type, column;
2073 int64_t j, equationIndex, equationRows;
2074 long return_value = 0;
2075
2076 equation = NULL;
2077 equationIndex = 0;
2078 equationRows = 0;
2079 if (!SDDS_CheckDataset(SDDS_dataset, "SDDS_ComputeColumn"))
2080 return (0);
2081 rpn_lock();
2082 if (!SDDS_StoreParametersInRpnMemories(SDDS_dataset))
2083 goto cleanup;
2084 if (!SDDS_StoreColumnsInRpnArrays(SDDS_dataset))
2085 goto cleanup;
2086
2087 if (table_number_mem == -1) {
2088 table_number_mem = rpn_create_mem("table_number", 0);
2089 i_page_mem = rpn_create_mem("i_page", 0);
2090 n_rows_mem = rpn_create_mem("n_rows", 0);
2091 i_row_mem = rpn_create_mem("i_row", 0);
2092 }
2093
2094 rpn_store((double)SDDS_dataset->page_number, NULL, table_number_mem);
2095 rpn_store((double)SDDS_dataset->page_number, NULL, i_page_mem);
2096 rpn_store((double)SDDS_dataset->n_rows, NULL, n_rows_mem);
2097
2098 if (!(equation = (char **)SDDS_GetColumn(SDDS_dataset, definition->source)))
2099 goto cleanup;
2100 equationRows = SDDS_CountRowsOfInterest(SDDS_dataset);
2101
2102 type = SDDS_GetColumnType(SDDS_dataset, column = SDDS_GetColumnIndex(SDDS_dataset, definition->name));
2103
2104 for (j = 0; j < SDDS_dataset->n_rows; j++) {
2105 if (!SDDS_dataset->row_flag[j])
2106 continue;
2107 if (equationIndex >= equationRows) {
2108 SDDS_SetError("Unable to compute rpn expression--row count mismatch (SDDS_EvaluateColumn)");
2109 goto cleanup;
2110 }
2111 if (!SDDS_StoreRowInRpnMemories(SDDS_dataset, j))
2112 goto cleanup;
2113 rpn_clear();
2114 rpn_store((double)j, NULL, i_row_mem);
2115 value = rpn(equation[equationIndex++]);
2116 if (rpn_check_error()) {
2117 SDDS_SetError("Unable to compute rpn expression--rpn error (SDDS_EvaluateColumn)");
2118 goto cleanup;
2119 }
2120 switch (type) {
2121 case SDDS_CHARACTER:
2122 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (char)value, -1);
2123 break;
2124 case SDDS_SHORT:
2125 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (short)value, -1);
2126 break;
2127 case SDDS_USHORT:
2128 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (unsigned short)value, -1);
2129 break;
2130 case SDDS_LONG:
2131 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (int32_t)value, -1);
2132 break;
2133 case SDDS_ULONG:
2134 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (uint32_t)value, -1);
2135 break;
2136 case SDDS_LONG64:
2137 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (int64_t)value, -1);
2138 break;
2139 case SDDS_ULONG64:
2140 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (uint64_t)value, -1);
2141 break;
2142 case SDDS_FLOAT:
2143 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (float)value, -1);
2144 break;
2145 case SDDS_DOUBLE:
2146 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (double)value, -1);
2147 break;
2148 case SDDS_LONGDOUBLE:
2149 SDDS_SetRowValues(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, column, (long double)value, -1);
2150 break;
2151 }
2152 }
2153 if (equationIndex != equationRows) {
2154 SDDS_SetError("Unable to compute rpn expression--row count mismatch (SDDS_EvaluateColumn)");
2155 goto cleanup;
2156 }
2157
2158 return_value = 1;
2159
2160cleanup:
2161 if (equation) {
2162 for (j = 0; j < equationRows; j++)
2163 free(equation[j]);
2164 free(equation);
2165 }
2166 rpn_unlock();
2167 return return_value;
2168}
2169
2170long SDDS_EvaluateParameter(SDDS_DATASET *SDDS_dataset, EVALUATE_DEFINITION *definition) {
2171 double value;
2172 char **equation;
2173 long parameter;
2174 long return_value = 0;
2175
2176 equation = NULL;
2177 rpn_lock();
2178 if (!SDDS_StoreParametersInRpnMemories(SDDS_dataset))
2179 goto cleanup;
2180
2181 if (table_number_mem == -1) {
2182 table_number_mem = rpn_create_mem("table_number", 0);
2183 i_page_mem = rpn_create_mem("i_page", 0);
2184 n_rows_mem = rpn_create_mem("n_rows", 0);
2185 i_row_mem = rpn_create_mem("i_row", 0);
2186 }
2187
2188 rpn_store((double)SDDS_dataset->page_number, NULL, table_number_mem);
2189 rpn_store((double)SDDS_dataset->page_number, NULL, i_page_mem);
2190 rpn_store((double)SDDS_dataset->n_rows, NULL, n_rows_mem);
2191
2192 if (!(equation = (char **)SDDS_GetParameter(SDDS_dataset, definition->source, NULL)))
2193 goto cleanup;
2194
2195 rpn_clear();
2196 value = rpn(*equation);
2197 fprintf(stderr, "value = %e\n", value);
2198 free(*equation);
2199 *equation = NULL;
2200 if (rpn_check_error()) {
2201 SDDS_SetError("Unable to compute rpn expression--rpn error (SDDS_EvaluateParameter)");
2202 goto cleanup;
2203 }
2204 switch (SDDS_GetParameterType(SDDS_dataset, parameter = SDDS_GetParameterIndex(SDDS_dataset, definition->name))) {
2205 case SDDS_CHARACTER:
2206 SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, parameter, (char)value, -1);
2207 break;
2208 case SDDS_SHORT:
2209 SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, parameter, (short)value, -1);
2210 break;
2211 case SDDS_USHORT:
2212 SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, parameter, (unsigned short)value, -1);
2213 break;
2214 case SDDS_LONG:
2215 SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, parameter, (int32_t)value, -1);
2216 break;
2217 case SDDS_ULONG:
2218 SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, parameter, (uint32_t)value, -1);
2219 break;
2220 case SDDS_LONG64:
2221 SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, parameter, (int64_t)value, -1);
2222 break;
2223 case SDDS_ULONG64:
2224 SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, parameter, (uint64_t)value, -1);
2225 break;
2226 case SDDS_FLOAT:
2227 SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, parameter, (float)value, -1);
2228 break;
2229 case SDDS_DOUBLE:
2230 SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, parameter, (double)value, -1);
2231 break;
2232 case SDDS_LONGDOUBLE:
2233 SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, parameter, (long double)value, -1);
2234 break;
2235 }
2236
2237 return_value = 1;
2238
2239cleanup:
2240 if (equation) {
2241 free(*equation);
2242 free(equation);
2243 }
2244 rpn_unlock();
2245 return return_value;
2246}
2247
2248char **process_name_options(char **orig_name, long **orig_flag, long orig_names, char **delete, long deletes, char **retain,
2249 long retains, STRING_PAIR *rename, long renames, EDIT_NAME_REQUEST *edit_request, long edit_requests) {
2250 long i, j;
2251 char **new_name;
2252 char *ptr;
2253
2254 *orig_flag = tmalloc(sizeof(**orig_flag) * orig_names);
2255 for (i = 0; i < orig_names; i++)
2256 (*orig_flag)[i] = 1;
2257
2258 if (deletes) {
2259 for (i = 0; i < deletes; i++) {
2260 ptr = expand_ranges(delete[i]);
2261 /* free(delete[i]); */
2262 delete[i] = ptr;
2263 }
2264 for (j = 0; j < orig_names; j++) {
2265 for (i = 0; i < deletes; i++) {
2266 if (wild_match(orig_name[j], delete[i])) {
2267 (*orig_flag)[j] = 0;
2268 break;
2269 }
2270 }
2271 }
2272 }
2273
2274 if (retains) {
2275 for (i = 0; i < retains; i++) {
2276 ptr = expand_ranges(retain[i]);
2277 /* free(retain[i]); */
2278 retain[i] = ptr;
2279 }
2280 if (!deletes)
2281 for (j = 0; j < orig_names; j++)
2282 (*orig_flag)[j] = 0;
2283 for (j = 0; j < orig_names; j++) {
2284 if ((*orig_flag)[j])
2285 continue;
2286 for (i = 0; i < retains; i++) {
2287 if (wild_match(orig_name[j], retain[i])) {
2288 (*orig_flag)[j] = 1;
2289 break;
2290 }
2291 }
2292 }
2293 }
2294
2295 new_name = tmalloc(sizeof(*new_name) * orig_names);
2296 for (j = 0; j < orig_names; j++) {
2297 for (i = 0; i < renames; i++) {
2298 if (strcmp(rename[i][0], orig_name[j]) == 0) {
2299 SDDS_CopyString(new_name + j, rename[i][1]);
2300 break;
2301 }
2302 }
2303 if (i == renames)
2304 SDDS_CopyString(new_name + j, orig_name[j]);
2305 for (i = 0; i < edit_requests; i++) {
2306 char edit_buffer[256];
2307 ptr = expand_ranges(edit_request[i].match_string);
2308 /*free(edit_request[i].match_string); */
2309 edit_request[i].match_string = ptr;
2310 if (wild_match(new_name[j], edit_request[i].match_string)) {
2311 strcpy(edit_buffer, new_name[j]);
2312 if (!edit_string(edit_buffer, edit_request[i].edit_string))
2313 SDDS_Bomb("error editing name");
2314 /*free(new_name[j]); */
2315 SDDS_CopyString(&new_name[j], edit_buffer);
2316 }
2317 }
2318 }
2319
2320 return (new_name);
2321}
SDDS.h
SDDS (Self Describing Data Set) Data Types Definitions and Function Prototypes.
SDDS_CopyPage
int32_t SDDS_CopyPage(SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source)
Definition SDDS_copy.c:578
SDDS_SetRowValues
int32_t SDDS_SetRowValues(SDDS_DATASET *SDDS_dataset, int32_t mode, int64_t row,...)
Definition SDDS_dataprep.c:994
SDDS_SetParameters
int32_t SDDS_SetParameters(SDDS_DATASET *SDDS_dataset, int32_t mode,...)
Definition SDDS_dataprep.c:375
SDDS_AssertRowFlags
int32_t SDDS_AssertRowFlags(SDDS_DATASET *SDDS_dataset, uint32_t mode,...)
Sets acceptance flags for rows based on specified criteria.
Definition SDDS_extract.c:148
SDDS_GetColumn
void * SDDS_GetColumn(SDDS_DATASET *SDDS_dataset, char *column_name)
Retrieves a copy of the data for a specified column, including only rows marked as "of interest".
Definition SDDS_extract.c:611
SDDS_GetParameterAsDouble
double * SDDS_GetParameterAsDouble(SDDS_DATASET *SDDS_dataset, char *parameter_name, double *memory)
Retrieves the value of a specified parameter as a double from the current data table of an SDDS datas...
Definition SDDS_extract.c:2783
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_FilterRowsByNumScan
int64_t SDDS_FilterRowsByNumScan(SDDS_DATASET *SDDS_dataset, char *filter_column, uint32_t mode)
Filters rows of interest in an SDDS dataset based on numeric scanning of a specified column.
Definition SDDS_extract.c:3698
SDDS_SetRowFlags
int32_t SDDS_SetRowFlags(SDDS_DATASET *SDDS_dataset, int32_t row_flag_value)
Sets the acceptance flags for all rows in the current data table of a data set.
Definition SDDS_extract.c:46
SDDS_ItemInsideWindow
int32_t SDDS_ItemInsideWindow(void *data, int64_t index, int32_t type, double lower_limit, double upper_limit)
Checks whether a data item is within a specified numeric window.
Definition SDDS_extract.c:4078
SDDS_MatchRowsOfInterest
int64_t SDDS_MatchRowsOfInterest(SDDS_DATASET *SDDS_dataset, char *selection_column, char *label_to_match, int32_t logic)
Matches and marks rows of interest in an SDDS dataset based on label matching.
Definition SDDS_extract.c:3507
SDDS_Logic
int32_t SDDS_Logic(int32_t previous, int32_t match, uint32_t logic)
Applies logical operations to determine the new state of a row flag based on previous and current mat...
Definition SDDS_extract.c:4166
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_DeleteUnsetRows
int32_t SDDS_DeleteUnsetRows(SDDS_DATASET *SDDS_dataset)
Deletes rows from an SDDS dataset that are not marked as "of interest".
Definition SDDS_extract.c:3761
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_FilterRowsOfInterest
int64_t SDDS_FilterRowsOfInterest(SDDS_DATASET *SDDS_dataset, char *filter_column, double lower_limit, double upper_limit, int32_t logic)
Filters rows of interest in an SDDS dataset based on numeric ranges in a specified column.
Definition SDDS_extract.c:3629
SDDS_ChangeParameterInformation
int32_t SDDS_ChangeParameterInformation(SDDS_DATASET *SDDS_dataset, char *field_name, void *memory, int32_t mode,...)
Modifies a specific field in a parameter definition within the SDDS dataset.
Definition SDDS_info.c:485
SDDS_ChangeColumnInformation
int32_t SDDS_ChangeColumnInformation(SDDS_DATASET *SDDS_dataset, char *field_name, void *memory, int32_t mode,...)
Modifies a specific field in a column definition within the SDDS dataset.
Definition SDDS_info.c:364
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_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_ProcessParameterString
int32_t SDDS_ProcessParameterString(SDDS_DATASET *SDDS_dataset, char *string, int32_t mode)
Process a parameter definition string.
Definition SDDS_process.c:323
SDDS_ProcessColumnString
int32_t SDDS_ProcessColumnString(SDDS_DATASET *SDDS_dataset, char *string, int32_t mode)
Process a column definition string.
Definition SDDS_process.c:283
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_SetError
void SDDS_SetError(char *error_text)
Records an error message in the SDDS error stack.
Definition SDDS_utils.c:421
SDDS_GetParameterType
int32_t SDDS_GetParameterType(SDDS_DATASET *SDDS_dataset, int32_t index)
Retrieves the data type of a parameter in the SDDS dataset by its index.
Definition SDDS_utils.c:2317
SDDS_GetParameterDefinition
PARAMETER_DEFINITION * SDDS_GetParameterDefinition(SDDS_DATASET *SDDS_dataset, char *name)
Retrieves the definition of a specified parameter from the SDDS dataset.
Definition SDDS_utils.c:1141
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_GetParameterIndex
int32_t SDDS_GetParameterIndex(SDDS_DATASET *SDDS_dataset, char *name)
Retrieves the index of a named parameter in the SDDS dataset.
Definition SDDS_utils.c:1404
SDDS_GetColumnIndex
int32_t SDDS_GetColumnIndex(SDDS_DATASET *SDDS_dataset, char *name)
Retrieves the index of a named column in the SDDS dataset.
Definition SDDS_utils.c:1375
SDDS_ColumnCount
int32_t SDDS_ColumnCount(SDDS_DATASET *page)
Retrieves the number of columns in the SDDS dataset.
Definition SDDS_utils.c:5098
SDDS_CheckColumn
int32_t SDDS_CheckColumn(SDDS_DATASET *SDDS_dataset, char *name, char *units, int32_t type, FILE *fp_message)
Checks if a column exists in the SDDS dataset with the specified name, units, and type.
Definition SDDS_utils.c:4646
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_CheckDataset
int32_t SDDS_CheckDataset(SDDS_DATASET *SDDS_dataset, const char *caller)
Validates the SDDS dataset pointer.
Definition SDDS_utils.c:618
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_DeleteParameterFixedValues
int32_t SDDS_DeleteParameterFixedValues(SDDS_DATASET *SDDS_dataset)
Deletes fixed values from all parameters in the SDDS dataset.
Definition SDDS_utils.c:4974
SDDS_ClearErrors
void SDDS_ClearErrors()
Clears all recorded error messages from the SDDS error stack.
Definition SDDS_utils.c:354
SDDS_ApplyFactorToColumn
int32_t SDDS_ApplyFactorToColumn(SDDS_DATASET *SDDS_dataset, char *name, double factor)
Applies a scaling factor to all elements of a specific column in the SDDS dataset.
Definition SDDS_utils.c:3198
SDDS_RegisterProgramName
void SDDS_RegisterProgramName(const char *name)
Registers the executable program name for use in error messages.
Definition SDDS_utils.c:318
SDDS_NumberOfErrors
int32_t SDDS_NumberOfErrors()
Retrieves the number of errors recorded by SDDS library routines.
Definition SDDS_utils.c:340
SDDS_ApplyFactorToParameter
int32_t SDDS_ApplyFactorToParameter(SDDS_DATASET *SDDS_dataset, char *name, double factor)
Applies a scaling factor to a specific parameter in the SDDS dataset.
Definition SDDS_utils.c:3121
SDDS_GetColumnType
int32_t SDDS_GetColumnType(SDDS_DATASET *SDDS_dataset, int32_t index)
Retrieves the data type of a column in the SDDS dataset by its index.
Definition SDDS_utils.c:2219
SDDS_Bomb
void SDDS_Bomb(char *message)
Terminates the program after printing an error message and recorded errors.
Definition SDDS_utils.c:380
SDDS_CheckParameter
int32_t SDDS_CheckParameter(SDDS_DATASET *SDDS_dataset, char *name, char *units, int32_t type, FILE *fp_message)
Checks if a parameter exists in the SDDS dataset with the specified name, units, and type.
Definition SDDS_utils.c:4737
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
SDDS_PrintTypedValue
int32_t SDDS_PrintTypedValue(void *data, int64_t index, int32_t type, char *format, FILE *fp, uint32_t mode)
Prints a data value of a specified type using an optional printf format string.
Definition SDDS_utils.c:67
SDDSaps.h
Header file for routines used by SDDS command-line applications.
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_ULONG
#define SDDS_ULONG
Identifier for the unsigned 32-bit integer data type.
Definition SDDStypes.h:67
SDDS_FLOAT
#define SDDS_FLOAT
Identifier for the float data type.
Definition SDDStypes.h:43
SDDS_STRING
#define SDDS_STRING
Identifier for the string data type.
Definition SDDStypes.h:85
SDDS_ULONG64
#define SDDS_ULONG64
Identifier for the unsigned 64-bit integer data type.
Definition SDDStypes.h:55
SDDS_LONG
#define SDDS_LONG
Identifier for the signed 32-bit integer data type.
Definition SDDStypes.h:61
SDDS_SHORT
#define SDDS_SHORT
Identifier for the signed short integer data type.
Definition SDDStypes.h:73
SDDS_CHARACTER
#define SDDS_CHARACTER
Identifier for the character data type.
Definition SDDStypes.h:91
SDDS_USHORT
#define SDDS_USHORT
Identifier for the unsigned short integer data type.
Definition SDDStypes.h:79
SDDS_DOUBLE
#define SDDS_DOUBLE
Identifier for the double data type.
Definition SDDStypes.h:37
SDDS_LONGDOUBLE
#define SDDS_LONGDOUBLE
Identifier for the long double data type.
Definition SDDStypes.h:31
SDDS_LONG64
#define SDDS_LONG64
Identifier for the signed 64-bit integer data type.
Definition SDDStypes.h:49
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
cp_str
char * cp_str(char **s, char *t)
Copies a string, allocating memory for storage.
Definition cp_str.c:28
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
random_1
double random_1(long iseed)
Generate a uniform random double in [0,1] using a custom seed initialization.
Definition drand.c:230
fexists
long fexists(const char *filename)
Checks if a file exists.
Definition fexists.c:27
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
free_scanargs
void free_scanargs(SCANNED_ARG **scanned, int argc)
Definition scanargs.c:588
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
CAST_DEFINITION
Definition SDDSaps.h:201
CLIP_DEFINITION
Definition SDDSaps.h:172
COLUMN_LIST
Definition sddslocaldensity.c:156
CONVERSION_DEFINITION
Definition SDDSaps.h:124
EDIT_DEFINITION
Definition SDDSaps.h:73
EDIT_NAME_REQUEST
Definition sddsconvert.c:166
EQUATION_DEFINITION
Definition SDDSaps.h:58
EVALUATE_DEFINITION
Definition SDDSaps.h:227
FCLIP_DEFINITION
Definition SDDSaps.h:208
FILTER_DEFINITION
Definition SDDSaps.h:142
FILTER_TERM
Definition SDDSaps.h:136
FORMAT_DEFINITION
Definition SDDSaps.h:195
IFITEM_LIST
Definition SDDSaps.h:49
MATCH_DEFINITION
Definition SDDSaps.h:148
MATCH_TERM
Definition SDDSaps.h:131
NUMBERTEST_DEFINITION
Definition SDDSaps.h:188
PARAMETER_DEFINITION
Definition SDDS.h:171
PRINT_DEFINITION
Definition SDDSaps.h:81
PROCESSING_DEFINITION
Definition SDDSaps.h:88
RPNEXPRESSION_DEFINITION
Definition SDDSaps.h:166
RPNTEST_DEFINITION
Definition SDDSaps.h:154
SAMPLE_DEFINITION
Definition SDDSaps.h:183
SCAN_DEFINITION
Definition SDDSaps.h:67
SDDS_DATASET
Definition SDDS.h:308
SDDS_LAYOUT
Definition SDDS.h:257
SPARSE_DEFINITION
Definition SDDSaps.h:178
SYSTEM_DEFINITION
Definition SDDSaps.h:160
TIME_FILTER_DEFINITION
Definition SDDSaps.h:215
wild_match_ci
int wild_match_ci(char *string, char *template)
Determine whether one string is a case-insensitive wildcard match for another.
Definition wild_match.c:220
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