SDDS ToolKit Programs and Libraries for C and Python
Loading...
Searching...
No Matches
Typedefs | Functions
sddsxref.c File Reference

Detailed Description

Cross-references and merges SDDS data sets based on column matching and filtering.

This program merges data from multiple SDDS (Self Describing Data Set) files into a single output file. It performs cross-referencing based on column matching, and supports selective transfer of columns, parameters, and arrays. The program also includes options for renaming and editing names to customize the output dataset.

Usage

sddsxref [<input1>] <input2> [<input3>...] [<output>]
[-pipe[=input][,output]]
[-ifis={column|parameter|array},<name>[,...]]
[-ifnot={parameter|column|array},<name>[,...]]
[-transfer={parameter|array},<name>[,...]]
[-take=<column-name>[,...]]
[-leave=<column-name>[,...]]
[-replace=column|parameter|array,<name list>]
[-fillIn]
[-reuse[=[rows][,page]]]
[-match=<column-name>[=<column-name>]]
[-wildMatch=<column-name>[=<column-name>]]
[-rename={column|parameter|array},<oldname>=<newname>[,...]]
[-editnames={column|parameter|array},<wildcard-string>,<edit-string>]
[-equate=<column-name>[=<column-name>]]
[-majorOrder=row|column]
[-threads=<number>]

Options

Required Description
<input2> The second input file for cross-referencing.
Optional Description
-pipe Use standard input/output streams.
-ifis Filters data that must exist in the input files.
-ifnot Filters data that must not exist in the input files.
-transfer Specifies parameters or arrays to transfer from reference files into the output.
-take Specifies columns to be taken from reference files and added to the output dataset.
-leave Specifies columns not to be taken from reference files. Overrides the -take option for these columns.
-replace Replaces data in the output based on the specified types and names.
-fillIn Fills in NULL or zero values for unmatched rows in the output.
-reuse Allows reusing rows or pages from the reference file during cross-referencing.
-match Matches columns between input files for data integration.
-wildMatch Matches columns using wildcard patterns.
-rename Renames specified columns, parameters, or arrays in the output.
-editnames Edits names of specified entities.
-equate Matches columns based on equality conditions.
-majorOrder Specifies the major order of data in the output. Defaults to the input's order.
-threads Number of reference files to read concurrently.

Incompatibilities

  • -equate is incompatible with:
    • -match
  • Only one of the following may be specified:
    • -wildMatch
    • -match
  • For -reuse:
    • Requires specifying rows, pages, or both.
Copyright
  • (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
  • (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.
License
This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.
Author
M. Borland, C. Saunders, R. Soliday, L. Emery, H. Shang

Definition in file sddsxref.c.

#include "mdb.h"
#include "SDDS.h"
#include "SDDSaps.h"
#include "scan.h"
#include <ctype.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>

Go to the source code of this file.

Typedefs

typedef char * STRING_PAIR[2]
 

Functions

long expandTransferRequests (char ***match, int32_t *matches, long type, TRANSFER_DEFINITION *transfer, long transfers, SDDS_DATASET *inSet)
 
void add_newnames (SDDS_DATASET *SDDS_dataset, REFDATA *new_data, REFDATA rename_data, EDIT_NAME_REQUEST *edit_column_request, long edit_column_requests, EDIT_NAME_REQUEST *edit_parameter_request, long edit_parameter_requests, EDIT_NAME_REQUEST *edit_array_request, long edit_array_requests, long filenumber)
 
char ** process_editnames (char **orig_name, long **orig_flags, long orig_names, EDIT_NAME_REQUEST *edit_request, long edit_requests, long filenumber)
 
long CopyRowToNewColumn (SDDS_DATASET *target, int64_t target_row, SDDS_DATASET *source, int64_t source_row, REFDATA new_data, long columns, char *input2)
 
long CopyParametersFromSecondInput (SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source, REFDATA new_data)
 
long CopyArraysFromSecondInput (SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source, REFDATA new_data)
 
int main (int argc, char **argv)
 

Typedef Documentation

◆ STRING_PAIR

typedef char* STRING_PAIR[2]

Definition at line 174 of file sddsxref.c.

Function Documentation

◆ add_newnames()

void add_newnames ( SDDS_DATASET * SDDS_dataset,
REFDATA * new_data,
REFDATA rename_data,
EDIT_NAME_REQUEST * edit_column_request,
long edit_column_requests,
EDIT_NAME_REQUEST * edit_parameter_request,
long edit_parameter_requests,
EDIT_NAME_REQUEST * edit_array_request,
long edit_array_requests,
long filenumber )

Definition at line 1573 of file sddsxref.c.

1576 {
1577 long i, k = 0, *orig_columnflags;
1578 int32_t columns, parameters, arrays;
1579 long *orig_parameterflags, *orig_arrayflags;
1580 char **column_names, **parameter_names, **array_names, **new_names;
1581
1582 columns = parameters = arrays = 0;
1583 column_names = parameter_names = array_names = new_names = NULL;
1584 orig_columnflags = orig_parameterflags = orig_arrayflags = NULL;
1585 new_data->columns = new_data->parameters = new_data->arrays = 0;
1586 new_data->new_column = new_data->orig_column = NULL;
1587 new_data->new_parameter = new_data->orig_parameter = NULL;
1588 new_data->new_array = new_data->orig_array = NULL;
1589
1590 /* No edit requests at all */
1591 if (!edit_column_requests && !edit_parameter_requests && !edit_array_requests &&
1592 !rename_data.columns && !rename_data.parameters && !rename_data.arrays)
1593 return;
1594
1595 /* Transfer renames to new_data */
1596 (*new_data).columns = rename_data.columns;
1597 (*new_data).parameters = rename_data.parameters;
1598 (*new_data).arrays = rename_data.arrays;
1599 if (rename_data.columns) {
1600 (*new_data).new_column = (char **)malloc(sizeof(char *) * rename_data.columns);
1601 (*new_data).orig_column = (char **)malloc(sizeof(char *) * rename_data.columns);
1602 for (i = 0; i < rename_data.columns; i++) {
1603 SDDS_CopyString(&(*new_data).new_column[i], rename_data.new_column[i]);
1604 SDDS_CopyString(&(*new_data).orig_column[i], rename_data.orig_column[i]);
1605 }
1606 }
1607 if (rename_data.parameters) {
1608 (*new_data).new_parameter = (char **)malloc(sizeof(char *) * rename_data.parameters);
1609 (*new_data).orig_parameter = (char **)malloc(sizeof(char *) * rename_data.parameters);
1610 for (i = 0; i < rename_data.parameters; i++) {
1611 SDDS_CopyString(&(*new_data).new_parameter[i], rename_data.new_parameter[i]);
1612 SDDS_CopyString(&(*new_data).orig_parameter[i], rename_data.orig_parameter[i]);
1613 }
1614 }
1615 if (rename_data.arrays) {
1616 (*new_data).new_array = (char **)malloc(sizeof(char *) * rename_data.arrays);
1617 (*new_data).orig_array = (char **)malloc(sizeof(char *) * rename_data.arrays);
1618 for (i = 0; i < rename_data.arrays; i++) {
1619 SDDS_CopyString(&(*new_data).new_array[i], rename_data.new_array[i]);
1620 SDDS_CopyString(&(*new_data).orig_array[i], rename_data.orig_array[i]);
1621 }
1622 }
1623
1624 if (!(column_names = SDDS_GetColumnNames(SDDS_dataset, &columns))) {
1625 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1626 exit(EXIT_FAILURE);
1627 }
1628 if (!(parameter_names = SDDS_GetParameterNames(SDDS_dataset, &parameters))) {
1629 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1630 exit(EXIT_FAILURE);
1631 }
1632
1633 if (!(array_names = SDDS_GetArrayNames(SDDS_dataset, &arrays))) {
1634 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1635 exit(EXIT_FAILURE);
1636 }
1637
1638 /* Process edit names */
1639 if (edit_column_requests) {
1640 if ((new_names = process_editnames(column_names, &orig_columnflags, columns, edit_column_request, edit_column_requests, filenumber))) {
1641 for (i = 0; i < columns; i++) {
1642 if (orig_columnflags[i]) {
1643 k = (*new_data).columns;
1644 (*new_data).new_column = trealloc((*new_data).new_column, sizeof(char *) * (k + 1));
1645 (*new_data).orig_column = trealloc((*new_data).orig_column, sizeof(char *) * (k + 1));
1646 SDDS_CopyString(&(*new_data).new_column[k], new_names[i]);
1647 SDDS_CopyString(&(*new_data).orig_column[k], column_names[i]);
1648 (*new_data).columns++;
1649 }
1650 free(new_names[i]);
1651 }
1652 free(new_names);
1653 }
1654 }
1655
1656 if (edit_parameter_requests) {
1657 if ((new_names = process_editnames(parameter_names, &orig_parameterflags, parameters, edit_parameter_request, edit_parameter_requests, filenumber))) {
1658 for (i = 0; i < parameters; i++) {
1659 if (orig_parameterflags[i]) {
1660 k = (*new_data).parameters;
1661 (*new_data).new_parameter = trealloc((*new_data).new_parameter, sizeof(char *) * (k + 1));
1662 (*new_data).orig_parameter = trealloc((*new_data).orig_parameter, sizeof(char *) * (k + 1));
1663 SDDS_CopyString(&(*new_data).new_parameter[k], new_names[i]);
1664 SDDS_CopyString(&(*new_data).orig_parameter[k], parameter_names[i]);
1665 (*new_data).parameters++;
1666 }
1667 free(new_names[i]);
1668 }
1669 free(new_names);
1670 }
1671 }
1672
1673 if (edit_array_requests) {
1674 if ((new_names = process_editnames(array_names, &orig_arrayflags, arrays, edit_array_request, edit_array_requests, filenumber))) {
1675 for (i = 0; i < arrays; i++) {
1676 if (orig_arrayflags[i]) {
1677 k = (*new_data).arrays;
1678 (*new_data).new_array = trealloc((*new_data).new_array, sizeof(char *) * (k + 1));
1679 (*new_data).orig_array = trealloc((*new_data).orig_array, sizeof(char *) * (k + 1));
1680 SDDS_CopyString(&(*new_data).new_array[k], new_names[i]);
1681 SDDS_CopyString(&(*new_data).orig_array[k], array_names[i]);
1682 (*new_data).arrays++;
1683 }
1684 free(new_names[i]);
1685 }
1686 free(new_names);
1687 }
1688 }
1689
1690 if (orig_columnflags)
1691 free(orig_columnflags);
1692 if (orig_parameterflags)
1693 free(orig_parameterflags);
1694 if (orig_arrayflags)
1695 free(orig_arrayflags);
1696 for (i = 0; i < columns; i++)
1697 free(column_names[i]);
1698 free(column_names);
1699 for (i = 0; i < parameters; i++)
1700 free(parameter_names[i]);
1701 free(parameter_names);
1702 for (i = 0; i < arrays; i++)
1703 free(array_names[i]);
1704 free(array_names);
1705}
SDDS_GetParameterNames
char ** SDDS_GetParameterNames(SDDS_DATASET *SDDS_dataset, int32_t *number)
Retrieves the names of all parameters in the SDDS dataset.
Definition SDDS_utils.c:2567
SDDS_GetColumnNames
char ** SDDS_GetColumnNames(SDDS_DATASET *SDDS_dataset, int32_t *number)
Retrieves the names of all columns in the SDDS dataset.
Definition SDDS_utils.c:2526
SDDS_PrintErrors
void SDDS_PrintErrors(FILE *fp, int32_t mode)
Prints recorded error messages to a specified file stream.
Definition SDDS_utils.c:474
SDDS_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
trealloc
void * trealloc(void *old_ptr, uint64_t size_of_block)
Reallocates a memory block to a new size.
Definition array.c:190

◆ CopyArraysFromSecondInput()

long CopyArraysFromSecondInput ( SDDS_DATASET * SDDS_target,
SDDS_DATASET * SDDS_source,
REFDATA new_data )

Definition at line 1839 of file sddsxref.c.

1839 {
1840 long i, j, k, m;
1841 char s[1024];
1842
1843 if (new_data.arrays == 0)
1844 return 1;
1845 for (i = 0; i < new_data.arrays; i++) {
1846 if ((j = SDDS_GetArrayIndex(SDDS_source, new_data.orig_array[i])) < 0)
1847 continue;
1848 if ((k = SDDS_GetArrayIndex(SDDS_target, new_data.new_array[i])) < 0) {
1849 sprintf(s, "Warning, array %s not defined in output.\n", new_data.new_array[i]);
1850 SDDS_SetError(s);
1851 continue;
1852 }
1853 if (SDDS_source->layout.array_definition[j].type != SDDS_target->layout.array_definition[k].type) {
1854 SDDS_SetError("Can't copy arrays between different types (SDDS_CopyArrays)");
1855 return 0;
1856 }
1857 SDDS_target->array[k].definition = SDDS_target->layout.array_definition + k;
1858 SDDS_target->array[k].elements = SDDS_source->array[j].elements;
1859 if (!(SDDS_target->array[k].dimension = (int32_t *)SDDS_Malloc(sizeof(*SDDS_target->array[k].dimension) * SDDS_target->array[k].definition->dimensions)) ||
1860 !(SDDS_target->array[k].data = SDDS_Realloc(SDDS_target->array[k].data, SDDS_type_size[SDDS_target->array[k].definition->type - 1] * SDDS_target->array[k].elements))) {
1861 SDDS_SetError("Unable to copy arrays--allocation failure (SDDS_CopyArrays)");
1862 return (0);
1863 }
1864 for (m = 0; m < SDDS_target->array[k].definition->dimensions; m++)
1865 SDDS_target->array[k].dimension[m] = SDDS_source->array[j].dimension[m];
1866
1867 if (SDDS_target->array[k].definition->type != SDDS_STRING)
1868 memcpy(SDDS_target->array[k].data, SDDS_source->array[j].data, SDDS_type_size[SDDS_target->array[k].definition->type - 1] * SDDS_target->array[k].elements);
1869 else if (!SDDS_CopyStringArray(SDDS_target->array[k].data, SDDS_source->array[j].data, SDDS_target->array[k].elements)) {
1870 SDDS_SetError("Unable to copy arrays (SDDS_CopyArrays)");
1871 return (0);
1872 }
1873 }
1874 return 1;
1875}
SDDS_type_size
int32_t SDDS_type_size[SDDS_NUM_TYPES]
Array of sizes for each supported data type.
Definition SDDS_data.c:62
SDDS_SetError
void SDDS_SetError(char *error_text)
Records an error message in the SDDS error stack.
Definition SDDS_utils.c:421
SDDS_GetArrayIndex
int32_t SDDS_GetArrayIndex(SDDS_DATASET *SDDS_dataset, char *name)
Retrieves the index of a named array in the SDDS dataset.
Definition SDDS_utils.c:1433
SDDS_CopyStringArray
int32_t SDDS_CopyStringArray(char **target, char **source, int64_t n_strings)
Copies an array of strings from source to target.
Definition SDDS_utils.c:2903
SDDS_Malloc
void * SDDS_Malloc(size_t size)
Allocates memory of a specified size.
Definition SDDS_utils.c:705
SDDS_Realloc
void * SDDS_Realloc(void *old_ptr, size_t new_size)
Reallocates memory to a new size.
Definition SDDS_utils.c:743
SDDS_STRING
#define SDDS_STRING
Identifier for the string data type.
Definition SDDStypes.h:85

◆ CopyParametersFromSecondInput()

long CopyParametersFromSecondInput ( SDDS_DATASET * SDDS_target,
SDDS_DATASET * SDDS_source,
REFDATA new_data )

Definition at line 1813 of file sddsxref.c.

1813 {
1814 long i, j, k;
1815 char s[1024];
1816
1817 if (new_data.parameters == 0)
1818 return 1;
1819 if (new_data.parameters) {
1820 for (i = 0; i < new_data.parameters; i++) {
1821 if ((j = SDDS_GetParameterIndex(SDDS_source, new_data.orig_parameter[i])) < 0) {
1822 continue;
1823 }
1824
1825 if ((k = SDDS_GetParameterIndex(SDDS_target, new_data.new_parameter[i])) < 0) {
1826 fprintf(stderr, "Warning, parameter %s not defined in output.\n", new_data.new_parameter[i]);
1827 continue;
1828 }
1829 if (!SDDS_SetParameters(SDDS_target, SDDS_SET_BY_INDEX | SDDS_PASS_BY_REFERENCE, k, SDDS_source->parameter[j], -1)) {
1830 sprintf(s, "Unable to copy parameters for parameter %s", new_data.new_parameter[i]);
1831 SDDS_SetError(s);
1832 return (0);
1833 }
1834 }
1835 }
1836 return 1;
1837}
SDDS_SetParameters
int32_t SDDS_SetParameters(SDDS_DATASET *SDDS_dataset, int32_t mode,...)
Definition SDDS_dataprep.c:375
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

◆ CopyRowToNewColumn()

long CopyRowToNewColumn ( SDDS_DATASET * target,
int64_t target_row,
SDDS_DATASET * source,
int64_t source_row,
REFDATA new_data,
long columns,
char * input2 )

Definition at line 1778 of file sddsxref.c.

1779 {
1780 long i, j, k, type, size;
1781 char s[1024];
1782
1783 if (!columns)
1784 return 1;
1785
1786 for (i = 0; i < columns; i++) {
1787 if ((j = SDDS_GetColumnIndex(source, new_data.orig_column[i])) < 0) {
1788 sprintf(s, "error: column %s not found in file %s\n", new_data.orig_column[i], input2);
1789 SDDS_SetError(s);
1790 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1791 continue;
1792 }
1793 if ((k = SDDS_GetColumnIndex(target, new_data.new_column[i])) < 0) {
1794 sprintf(s, "error: column %s not defined in output\n", new_data.new_column[i]);
1795 SDDS_SetError(s);
1796 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1797 continue;
1798 }
1799
1800 if ((type = SDDS_GetColumnType(target, k)) == SDDS_STRING) {
1801 if (!SDDS_CopyString(((char ***)target->data)[k] + target_row, ((char ***)source->data)[j][source_row])) {
1802 SDDS_SetError("Unable to copy row--string copy failed (SDDS_CopyRow)");
1803 return (0);
1804 }
1805 } else {
1806 size = SDDS_type_size[type - 1];
1807 memcpy((char *)target->data[k] + size * target_row, (char *)source->data[j] + size * source_row, size);
1808 }
1809 }
1810 return (1);
1811}
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_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

◆ expandTransferRequests()

long expandTransferRequests ( char *** match,
int32_t * matches,
long type,
TRANSFER_DEFINITION * transfer,
long transfers,
SDDS_DATASET * inSet )

Definition at line 1540 of file sddsxref.c.

1541 {
1542 long i, first;
1543 int32_t (*matchRoutine)(SDDS_DATASET *SDDS_dataset, char ***nameReturn, int32_t matchMode, int32_t typeMode, ...);
1544
1545 *matches = 0;
1546 *match = NULL;
1547 if (!transfers)
1548 return 1;
1549 switch (type) {
1550 case PARAMETER_TRANSFER:
1551 matchRoutine = SDDS_MatchParameters;
1552 break;
1553 case ARRAY_TRANSFER:
1554 matchRoutine = SDDS_MatchArrays;
1555 break;
1556 default:
1557 SDDS_Bomb("invalid transfer type--this shouldn't happen");
1558 exit(EXIT_FAILURE);
1559 break;
1560 }
1561 first = 0;
1562 for (i = 0; i < transfers; i++) {
1563 if (transfer[i].type == type) {
1564 if ((*matches = (*matchRoutine)(inSet, match, SDDS_MATCH_STRING, FIND_ANY_TYPE, transfer[i].name, SDDS_OR | (first ? SDDS_0_PREVIOUS : 0))) == -1) {
1565 return 0;
1566 }
1567 first = 0;
1568 }
1569 }
1570 return 1;
1571}
SDDS_MatchParameters
int32_t SDDS_MatchParameters(SDDS_DATASET *SDDS_dataset, char ***nameReturn, int32_t matchMode, int32_t typeMode,...)
Matches and retrieves parameter names from an SDDS dataset based on specified criteria.
Definition SDDS_utils.c:3840
SDDS_Bomb
void SDDS_Bomb(char *message)
Terminates the program after printing an error message and recorded errors.
Definition SDDS_utils.c:380
SDDS_MatchArrays
int32_t SDDS_MatchArrays(SDDS_DATASET *SDDS_dataset, char ***nameReturn, int32_t matchMode, int32_t typeMode,...)
Matches and retrieves array names from an SDDS dataset based on specified criteria.
Definition SDDS_utils.c:4121
SDDS_DATASET
Definition SDDS.h:308

◆ main()

int main ( int argc,
char ** argv )

Definition at line 221 of file sddsxref.c.

221 {
222 SDDS_DATASET SDDS_1, SDDS_output;
223 SDDS_DATASET *SDDS_ref;
224 REFDATA *new_data, rename_data, *take_RefData, *replace_RefData;
225 long j, i_arg, reuse, reusePage, endWarning, k;
226 int64_t i, i1, i2, i3, rows1, rows2, rows2Max;
227 SCANNED_ARG *s_arg;
228 char s[200], *ptr;
229
230 char **take_column, **leave_column, **replace_column, **replace_parameter, **replace_array, **output_column = NULL;
231 char **inputfile, **referfile;
232 char **match_column, **equate_column;
233 long take_columns, replace_columns, leave_columns, match_columns, equate_columns, leave_all_columns, replace_parameters, replace_arrays;
234 int32_t output_columns = 0;
235 char *input1, *input2, *output;
236 long tmpfile_used, retval1, retval2, inputfiles, referfiles;
237 long wildMatch;
238 TRANSFER_DEFINITION *transfer;
239 long transfers;
240 long warnings;
241 IFITEM_LIST ifnot_item, ifis_item;
242 unsigned long pipeFlags, majorOrderFlag;
243 long fillIn, keyGroups = 0;
244 KEYED_EQUIVALENT **keyGroup = NULL;
245 long outputInitialized;
246 int z, it, itm, datatype1, datatype2;
247 long col;
248 int firstRun, copyInput1Only;
249 char **string1, **string2;
250 double *value1, *value2;
251 long matched;
252 short columnMajorOrder = -1;
253 long useHashLookup = 0;
254 int threads = 1;
255 long *refReadCode = NULL;
256
257 EDIT_NAME_REQUEST *edit_column_request, *edit_parameter_request, *edit_array_request;
258 long edit_column_requests, edit_parameter_requests, edit_array_requests;
259
260 SDDS_RegisterProgramName(argv[0]);
261 argc = scanargs(&s_arg, argc, argv);
262 if (argc < 3) {
263 fprintf(stderr, "%s", USAGE);
264 exit(EXIT_FAILURE);
265 }
266
267 SDDS_ref = NULL;
268 take_RefData = replace_RefData = NULL;
269 new_data = NULL;
270
271 rename_data.columns = rename_data.parameters = rename_data.arrays = 0;
272 rename_data.new_column = rename_data.orig_column = rename_data.new_parameter = rename_data.orig_parameter = rename_data.new_array = rename_data.orig_array = NULL;
273 edit_column_request = edit_parameter_request = edit_array_request = NULL;
274 edit_column_requests = edit_parameter_requests = edit_array_requests = 0;
275
276 input1 = input2 = output = NULL;
277 take_column = leave_column = replace_column = replace_parameter = replace_array = NULL;
278 match_column = equate_column = NULL;
279 inputfile = referfile = NULL;
280 take_columns = leave_columns = replace_columns = match_columns = equate_columns = reuse = reusePage = replace_parameters = replace_arrays = 0;
281 tmpfile_used = inputfiles = referfiles = 0;
282 transfer = NULL;
283 transfers = 0;
284 ifnot_item.items = ifis_item.items = 0;
285 warnings = 1;
286 pipeFlags = 0;
287 fillIn = 0;
288 outputInitialized = 0;
289 rows1 = rows2 = output_columns = 0;
290 string1 = string2 = NULL;
291 wildMatch = 0;
292
293 for (i_arg = 1; i_arg < argc; i_arg++) {
294 if (s_arg[i_arg].arg_type == OPTION) {
295 delete_chars(s_arg[i_arg].list[0], "_");
296 switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
297 case SET_MAJOR_ORDER:
298 majorOrderFlag = 0;
299 s_arg[i_arg].n_items--;
300 if (s_arg[i_arg].n_items > 0 &&
301 (!scanItemList(&majorOrderFlag, s_arg[i_arg].list + 1, &s_arg[i_arg].n_items, 0,
302 "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER,
303 "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL)))
304 SDDS_Bomb("invalid -majorOrder syntax/values");
305 if (majorOrderFlag & SDDS_COLUMN_MAJOR_ORDER)
306 columnMajorOrder = 1;
307 else if (majorOrderFlag & SDDS_ROW_MAJOR_ORDER)
308 columnMajorOrder = 0;
309 break;
310 case SET_LEAVE_COLUMNS:
311 if (s_arg[i_arg].n_items < 2)
312 SDDS_Bomb("invalid -leave syntax");
313 leave_column = trealloc(leave_column, sizeof(*leave_column) * (leave_columns + s_arg[i_arg].n_items - 1));
314 for (i = 1; i < s_arg[i_arg].n_items; i++)
315 leave_column[i - 1 + leave_columns] = s_arg[i_arg].list[i];
316 leave_columns += s_arg[i_arg].n_items - 1;
317 break;
318 case SET_TAKE_COLUMNS:
319 if (s_arg[i_arg].n_items < 2)
320 SDDS_Bomb("invalid -take syntax");
321 take_column = trealloc(take_column, sizeof(*take_column) * (take_columns + s_arg[i_arg].n_items - 1));
322 for (i = 1; i < s_arg[i_arg].n_items; i++)
323 take_column[i - 1 + take_columns] = s_arg[i_arg].list[i];
324 take_columns += s_arg[i_arg].n_items - 1;
325 break;
326 case SET_WILD_MATCH:
327 wildMatch = 1;
328 /* fall-through to SET_MATCH_COLUMN */
329 case SET_MATCH_COLUMN:
330 if (s_arg[i_arg].n_items != 2)
331 SDDS_Bomb("invalid -match or -wildMatch syntax");
332 if (match_columns != 0)
333 SDDS_Bomb("only one -match or -wildMatch option may be given");
334 match_column = tmalloc(sizeof(*match_column) * 2);
335 if ((ptr = strchr(s_arg[i_arg].list[1], '=')))
336 *ptr++ = 0;
337 else
338 ptr = s_arg[i_arg].list[1];
339 match_column[0] = s_arg[i_arg].list[1];
340 match_column[1] = ptr;
341 match_columns = 1;
342 break;
343 case SET_EQUATE_COLUMN:
344 if (s_arg[i_arg].n_items != 2)
345 SDDS_Bomb("invalid -equate syntax");
346 if (equate_columns != 0)
347 SDDS_Bomb("only one -equate option may be given");
348 equate_column = tmalloc(sizeof(*equate_column) * 2);
349 if ((ptr = strchr(s_arg[i_arg].list[1], '=')))
350 *ptr++ = 0;
351 else
352 ptr = s_arg[i_arg].list[1];
353 equate_column[0] = s_arg[i_arg].list[1];
354 equate_column[1] = ptr;
355 equate_columns = 1;
356 break;
357 case SET_REPLACE:
358 if (s_arg[i_arg].n_items < 3)
359 SDDS_Bomb("invalid -replace syntax");
360 switch (match_string(s_arg[i_arg].list[1], replace_type, REPLACE_TYPES, 0)) {
361 case COLUMN_REPLACE:
362 replace_column = trealloc(replace_column, sizeof(*replace_column) * (replace_columns + s_arg[i_arg].n_items - 2));
363 for (i = 2; i < s_arg[i_arg].n_items; i++)
364 replace_column[i - 2 + replace_columns] = s_arg[i_arg].list[i];
365 replace_columns += s_arg[i_arg].n_items - 2;
366 break;
367 case PARAMETER_REPLACE:
368 replace_parameter = trealloc(replace_parameter, sizeof(*replace_parameter) * (replace_parameters + s_arg[i_arg].n_items - 2));
369 for (i = 2; i < s_arg[i_arg].n_items; i++)
370 replace_parameter[i - 2 + replace_parameters] = s_arg[i_arg].list[i];
371 replace_parameters += s_arg[i_arg].n_items - 2;
372 break;
373 case ARRAY_REPLACE:
374 replace_array = trealloc(replace_array, sizeof(*replace_array) * (replace_arrays + s_arg[i_arg].n_items - 2));
375 for (i = 2; i < s_arg[i_arg].n_items; i++)
376 replace_array[i - 2 + replace_arrays] = s_arg[i_arg].list[i];
377 replace_arrays += s_arg[i_arg].n_items - 2;
378 break;
379 default:
380 SDDS_Bomb("unknown type of transfer");
381 break;
382 }
383 break;
384 case SET_TRANSFER:
385 if (s_arg[i_arg].n_items < 3)
386 SDDS_Bomb("invalid -transfer syntax");
387 transfer = trealloc(transfer, sizeof(*transfer) * (transfers + s_arg[i_arg].n_items - 2));
388 switch (match_string(s_arg[i_arg].list[1], transfer_type, TRANSFER_TYPES, 0)) {
389 case PARAMETER_TRANSFER:
390 for (i = 2; i < s_arg[i_arg].n_items; i++) {
391 transfer[i - 2 + transfers].type = PARAMETER_TRANSFER;
392 transfer[i - 2 + transfers].name = s_arg[i_arg].list[i];
393 }
394 break;
395 case ARRAY_TRANSFER:
396 for (i = 2; i < s_arg[i_arg].n_items; i++) {
397 transfer[i - 2 + transfers].type = ARRAY_TRANSFER;
398 transfer[i - 2 + transfers].name = s_arg[i_arg].list[i];
399 }
400 break;
401 default:
402 SDDS_Bomb("unknown type of transfer");
403 break;
404 }
405 transfers += s_arg[i_arg].n_items - 2;
406 break;
407 case SET_REUSE:
408 if (s_arg[i_arg].n_items == 1)
409 reuse = 1;
410 else {
411 char *reuseOptions[2] = {"rows", "page"};
412 for (i = 1; i < s_arg[i_arg].n_items; i++) {
413 switch (match_string(s_arg[i_arg].list[i], reuseOptions, 2, 0)) {
414 case 0:
415 reuse = 1;
416 break;
417 case 1:
418 reusePage = 1;
419 break;
420 default:
421 SDDS_Bomb("unknown reuse keyword");
422 break;
423 }
424 }
425 }
426 break;
427 case SET_IFNOT:
428 if (s_arg[i_arg].n_items < 3)
429 SDDS_Bomb("invalid -ifnot usage");
430 add_ifitem(&ifnot_item, s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1);
431 break;
432 case SET_NOWARNINGS:
433 warnings = 0;
434 break;
435 case SET_IFIS:
436 if (s_arg[i_arg].n_items < 3)
437 SDDS_Bomb("invalid -ifis usage");
438 add_ifitem(&ifis_item, s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1);
439 break;
440 case SET_PIPE:
441 if (!processPipeOption(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1, &pipeFlags))
442 SDDS_Bomb("invalid -pipe syntax");
443 break;
444 case SET_FILLIN:
445 fillIn = 1;
446 break;
447 case SET_RENAME:
448 if (s_arg[i_arg].n_items < 3)
449 SDDS_Bomb("invalid -rename syntax");
450 switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) {
451 case COLUMN_MODE:
452 k = rename_data.columns;
453 rename_data.new_column = trealloc(rename_data.new_column, sizeof(char *) * (k + s_arg[i_arg].n_items - 2));
454 rename_data.orig_column = trealloc(rename_data.orig_column, sizeof(char *) * (k + s_arg[i_arg].n_items - 2));
455 for (i = 2; i < s_arg[i_arg].n_items; i++) {
456 if (!(ptr = strchr(s_arg[i_arg].list[i], '=')))
457 SDDS_Bomb("invalid -rename syntax");
458 *ptr++ = 0;
459 rename_data.orig_column[k + i - 2] = s_arg[i_arg].list[i];
460 rename_data.new_column[k + i - 2] = ptr;
461 }
462 rename_data.columns += s_arg[i_arg].n_items - 2;
463 break;
464 case PARAMETER_MODE:
465 k = rename_data.parameters;
466 rename_data.new_parameter = trealloc(rename_data.new_parameter, sizeof(char *) * (k + s_arg[i_arg].n_items - 2));
467 rename_data.orig_parameter = trealloc(rename_data.orig_parameter, sizeof(char *) * (k + s_arg[i_arg].n_items - 2));
468 for (i = 2; i < s_arg[i_arg].n_items; i++) {
469 if (!(ptr = strchr(s_arg[i_arg].list[i], '=')))
470 SDDS_Bomb("invalid -rename syntax");
471 *ptr++ = 0;
472 rename_data.orig_parameter[k + i - 2] = s_arg[i_arg].list[i];
473 rename_data.new_parameter[k + i - 2] = ptr;
474 }
475 rename_data.parameters += s_arg[i_arg].n_items - 2;
476 break;
477 case ARRAY_MODE:
478 k = rename_data.arrays;
479 rename_data.new_array = trealloc(rename_data.new_array, sizeof(char *) * (k + s_arg[i_arg].n_items - 2));
480 rename_data.orig_array = trealloc(rename_data.orig_array, sizeof(char *) * (k + s_arg[i_arg].n_items - 2));
481 for (i = 2; i < s_arg[i_arg].n_items; i++) {
482 if (!(ptr = strchr(s_arg[i_arg].list[i], '=')))
483 SDDS_Bomb("invalid -rename syntax");
484 *ptr++ = 0;
485 rename_data.orig_array[k + i - 2] = s_arg[i_arg].list[i];
486 rename_data.new_array[k + i - 2] = ptr;
487 }
488 rename_data.arrays += s_arg[i_arg].n_items - 2;
489 break;
490 default:
491 SDDS_Bomb("invalid -rename syntax: specify column, parameter, or array keyword");
492 break;
493 }
494 break;
495 case SET_EDIT_NAMES:
496 if (s_arg[i_arg].n_items != 4)
497 SDDS_Bomb("invalid -editnames syntax");
498 switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) {
499 case COLUMN_MODE:
500 edit_column_request = trealloc(edit_column_request, sizeof(*edit_column_request) * (edit_column_requests + 1));
501 edit_column_request[edit_column_requests].match_string = s_arg[i_arg].list[2];
502 edit_column_request[edit_column_requests].edit_string = s_arg[i_arg].list[3];
503 edit_column_requests++;
504 break;
505 case PARAMETER_MODE:
506 edit_parameter_request = trealloc(edit_parameter_request, sizeof(*edit_parameter_request) * (edit_parameter_requests + 1));
507 edit_parameter_request[edit_parameter_requests].match_string = s_arg[i_arg].list[2];
508 edit_parameter_request[edit_parameter_requests].edit_string = s_arg[i_arg].list[3];
509 edit_parameter_requests++;
510 break;
511 case ARRAY_MODE:
512 edit_array_request = trealloc(edit_array_request, sizeof(*edit_array_request) * (edit_array_requests + 1));
513 edit_array_request[edit_array_requests].match_string = s_arg[i_arg].list[2];
514 edit_array_request[edit_array_requests].edit_string = s_arg[i_arg].list[3];
515 edit_array_requests++;
516 break;
517 default:
518 SDDS_Bomb("invalid -editnames syntax: specify column, parameter, or array keyword");
519 break;
520 }
521 break;
522 case SET_HASH_LOOKUP:
523 useHashLookup = 1;
524 break;
525 case SET_THREADS:
526 if (s_arg[i_arg].n_items != 2 ||
527 sscanf(s_arg[i_arg].list[1], "%d", &threads) != 1 || threads < 1)
528 SDDS_Bomb("invalid -threads syntax");
529 break;
530 default:
531 fprintf(stderr, "error: unknown switch: %s\n", s_arg[i_arg].list[0]);
532 SDDS_Bomb(NULL);
533 break;
534 }
535 } else {
536 inputfile = trealloc(inputfile, sizeof(*inputfile) * (inputfiles + 1));
537 inputfile[inputfiles++] = s_arg[i_arg].list[0];
538 }
539 }
540
541 if (inputfiles == 0) {
542 SDDS_Bomb("too few reference files given");
543 } else {
544 if (!(pipeFlags & USE_STDIN) && !(pipeFlags & USE_STDOUT)) {
545 if (inputfiles < 2) {
546 SDDS_Bomb("too few reference files given");
547 } else if (inputfiles == 2) {
548 input1 = output = inputfile[0];
549 referfile = trealloc(referfile, sizeof(*referfile) * (referfiles + 1));
550 referfile[0] = inputfile[1];
551 referfiles++;
552 } else {
553 input1 = inputfile[0];
554 output = inputfile[--inputfiles];
555 for (z = 1; z < inputfiles; z++) {
556 referfile = trealloc(referfile, sizeof(*referfile) * (referfiles + 1));
557 referfile[z - 1] = inputfile[z];
558 referfiles++;
559 }
560 }
561 } else if (!(pipeFlags & USE_STDIN) && (pipeFlags & USE_STDOUT)) {
562 if (inputfiles < 2) {
563 SDDS_Bomb("too few reference files given");
564 } else {
565 input1 = inputfile[0];
566 for (z = 1; z < inputfiles; z++) {
567 referfile = trealloc(referfile, sizeof(*referfile) * (referfiles + 1));
568 referfile[z - 1] = inputfile[z];
569 referfiles++;
570 }
571 }
572 } else if ((pipeFlags & USE_STDIN) && !(pipeFlags & USE_STDOUT)) {
573 if (inputfiles < 2) {
574 SDDS_Bomb("too few reference files given");
575 } else {
576 output = inputfile[--inputfiles];
577 for (z = 0; z < inputfiles; z++) {
578 referfile = trealloc(referfile, sizeof(*referfile) * (referfiles + 1));
579 referfile[z] = inputfile[z];
580 referfiles++;
581 }
582 }
583 } else {
584 for (z = 0; z < inputfiles; z++) {
585 referfile = trealloc(referfile, sizeof(*referfile) * (referfiles + 1));
586 referfile[z] = inputfile[z];
587 referfiles++;
588 }
589 }
590 }
591
592 processFilenames("sddsxref", &input1, &output, pipeFlags, !warnings, &tmpfile_used);
593
594 if (equate_columns && match_columns)
595 SDDS_Bomb("only one of -equate or -match may be given");
596 if (threads > referfiles)
597 threads = referfiles;
598
599 if (!SDDS_InitializeInput(&SDDS_1, input1)) {
600 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
601 exit(EXIT_FAILURE);
602 }
603
604 if (!check_ifitems(&SDDS_1, &ifnot_item, 0, warnings) || !check_ifitems(&SDDS_1, &ifis_item, 1, warnings))
605 exit(EXIT_SUCCESS);
606
607 for (it = 0; it < ifnot_item.items; it++) {
608 switch (ifnot_item.type[it]) {
609 case COLUMN_BASED:
610 leave_column = trealloc(leave_column, sizeof(*leave_column) * (leave_columns + 1));
611 leave_column[leave_columns] = ifnot_item.name[it];
612 leave_columns++;
613 break;
614 case PARAMETER_BASED:
615 for (itm = 0; itm < transfers; itm++) {
616 if (strcmp(transfer[itm].name, ifnot_item.name[it]) == 0) {
617 SDDS_Bomb("Excluded item is a part of -transfer list.");
618 exit(EXIT_FAILURE);
619 }
620 }
621 break;
622 case ARRAY_BASED:
623 for (itm = 0; itm < transfers; itm++) {
624 if (strcmp(transfer[itm].name, ifnot_item.name[it]) == 0) {
625 SDDS_Bomb("Excluded item is a part of -transfer list.");
626 exit(EXIT_FAILURE);
627 }
628 }
629 break;
630 default:
631 SDDS_Bomb("internal error---unknown ifitem type");
632 exit(EXIT_FAILURE);
633 break;
634 }
635 }
636
637 /* Allocate memory for new_data */
638 new_data = malloc(sizeof(*new_data) * referfiles);
639 for (z = 0; z < referfiles; z++) {
640 SDDS_ref = trealloc(SDDS_ref, sizeof(*SDDS_ref) * (z + 1));
641 input2 = referfile[z];
642 if (!SDDS_InitializeInput(&SDDS_ref[z], input2)) {
643 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
644 exit(EXIT_FAILURE);
645 }
646
647 take_RefData = trealloc(take_RefData, sizeof(*take_RefData) * (z + 1));
648 take_RefData[z].columns = 0;
649 replace_RefData = trealloc(replace_RefData, sizeof(*replace_RefData) * (z + 1));
650 replace_RefData[z].columns = replace_RefData[z].parameters = replace_RefData[z].arrays = 0;
651
652 add_newnames(&SDDS_ref[z], &new_data[z], rename_data, edit_column_request, edit_column_requests,
653 edit_parameter_request, edit_parameter_requests, edit_array_request, edit_array_requests, z + 1);
654
655 if (SDDS_ColumnCount(&SDDS_ref[z])) {
656 SDDS_SetColumnFlags(&SDDS_ref[z], 1);
657 if (take_columns) {
658 SDDS_SetColumnFlags(&SDDS_ref[z], 0);
659 for (i = 0; i < take_columns; i++) {
660 if (!has_wildcards(take_column[i]) && SDDS_GetColumnIndex(&SDDS_ref[z], take_column[i]) < 0) {
661 sprintf(s, "error: column %s not found in file %s take_columns %ld SDDS_ref[z] %" PRId64 "\n", take_column[i], input2, take_columns, SDDS_ref[z].n_rows);
662 SDDS_SetError(s);
663 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
664 }
665 if (!SDDS_SetColumnsOfInterest(&SDDS_ref[z], SDDS_MATCH_STRING, take_column[i], SDDS_OR))
666 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
667 }
668 }
669
670 leave_all_columns = 0;
671 if (leave_columns == 1 && strcmp(leave_column[0], "*") == 0)
672 leave_all_columns = 1;
673 else {
674 if (!take_columns)
675 SDDS_SetColumnFlags(&SDDS_ref[z], 1);
676 for (i = 0; i < leave_columns; i++) {
677 if (!has_wildcards(leave_column[i]) &&
678 SDDS_GetColumnIndex(&SDDS_ref[z], leave_column[i]) < 0)
679 continue;
680 if (!SDDS_SetColumnsOfInterest(&SDDS_ref[z], SDDS_MATCH_STRING, leave_column[i], SDDS_AND | SDDS_NEGATE_MATCH))
681 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
682 }
683
684 if (!(take_RefData[z].orig_column = (char **)SDDS_GetColumnNames(&SDDS_ref[z], &take_RefData[z].columns))) {
685 SDDS_SetError("error: no columns selected to take from input file");
686 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
687 }
688 }
689 if (replace_columns) {
690 SDDS_SetColumnFlags(&SDDS_ref[z], 0);
691 for (i = 0; i < replace_columns; i++) {
692 if (!has_wildcards(replace_column[i]) && SDDS_GetColumnIndex(&SDDS_ref[z], replace_column[i]) < 0) {
693 sprintf(s, "error: column %s not found in file %s replace_columns %ld SDDS_ref[z] %" PRId64 "\n", replace_column[i], input2, replace_columns, SDDS_ref[z].n_rows);
694 SDDS_SetError(s);
695 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
696 }
697 if (!SDDS_SetColumnsOfInterest(&SDDS_ref[z], SDDS_MATCH_STRING, replace_column[i], SDDS_OR))
698 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
699 }
700 if (!(replace_RefData[z].orig_column = (char **)SDDS_GetColumnNames(&SDDS_ref[z], &replace_RefData[z].columns))) {
701 SDDS_SetError("error: no columns selected to replace from input file");
702 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
703 }
704 }
705 if (match_columns) {
706 if ((j = SDDS_GetColumnIndex(&SDDS_1, match_column[0])) < 0 ||
707 SDDS_GetColumnType(&SDDS_1, j) != SDDS_STRING) {
708 sprintf(s, "error: column %s not found or not string type in file %s", match_column[0], input1 ? input1 : "stdin");
709 SDDS_SetError(s);
710 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
711 }
712 if ((j = SDDS_GetColumnIndex(&SDDS_ref[z], match_column[1])) < 0 ||
713 SDDS_GetColumnType(&SDDS_ref[z], j) != SDDS_STRING) {
714 sprintf(s, "error: column %s not found or not string type in file %s", match_column[1], input2);
715 SDDS_SetError(s);
716 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
717 }
718 }
719 if (equate_columns) {
720 if ((j = SDDS_GetColumnIndex(&SDDS_1, equate_column[0])) < 0 ||
721 !SDDS_NUMERIC_TYPE(SDDS_GetColumnType(&SDDS_1, j))) {
722 sprintf(s, "error: column %s not found or not numeric type in file %s", equate_column[0], input1 ? input1 : "stdin");
723 SDDS_SetError(s);
724 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
725 }
726 if ((j = SDDS_GetColumnIndex(&SDDS_ref[z], equate_column[1])) < 0 ||
727 !SDDS_NUMERIC_TYPE(SDDS_GetColumnType(&SDDS_ref[z], j))) {
728 sprintf(s, "error: column %s not found or not numeric type in file %s", equate_column[1], input2);
729 SDDS_SetError(s);
730 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
731 }
732 }
733 } else {
734 take_RefData[z].columns = 0;
735 leave_all_columns = 1;
736 }
737 if (!take_RefData[z].columns && !leave_all_columns && warnings)
738 fprintf(stderr, "warning: there are no columns being taken from %s that are not already in %s\n", input2, input1 ? input1 : "stdin");
739
740 if (leave_all_columns)
741 take_RefData[z].columns = 0;
742
743 if (!outputInitialized) {
744 if (!SDDS_InitializeCopy(&SDDS_output, &SDDS_1, output, "w")) {
745 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
746 exit(EXIT_FAILURE);
747 }
748 outputInitialized = 1;
749 if (columnMajorOrder != -1)
750 SDDS_output.layout.data_mode.column_major = columnMajorOrder;
751 else
752 SDDS_output.layout.data_mode.column_major = SDDS_1.layout.data_mode.column_major;
753 }
754
755 /* Get the new name for new_data if there is a match of original name */
756 if (take_RefData[z].columns)
757 take_RefData[z].new_column = (char **)malloc(sizeof(char *) * take_RefData[z].columns);
758
759 for (i = 0; i < take_RefData[z].columns; i++) {
760 k = 0;
761 /* If there are new names (renamed or edited), find the corresponding original name index,
762 and assign the new name to take_RefData */
763 if (new_data[z].columns) {
764 k = match_string(take_RefData[z].orig_column[i], new_data[z].orig_column, new_data[z].columns, EXACT_MATCH);
765 if (k == -1)
766 SDDS_CopyString(&take_RefData[z].new_column[i], take_RefData[z].orig_column[i]);
767 else
768 SDDS_CopyString(&take_RefData[z].new_column[i], new_data[z].new_column[k]);
769 } else
770 SDDS_CopyString(&take_RefData[z].new_column[i], take_RefData[z].orig_column[i]);
771 if (SDDS_GetColumnIndex(&SDDS_output, take_RefData[z].new_column[i]) >= 0) {
772 free(take_RefData[z].new_column[i]);
773 free(take_RefData[z].orig_column[i]);
774 for (j = i; j < take_RefData[z].columns - 1; j++)
775 take_RefData[z].orig_column[j] = take_RefData[z].orig_column[j + 1];
776 take_RefData[z].columns -= 1;
777 i--;
778 if (take_RefData[z].columns == 0)
779 break;
780 } else {
781 /* Transfer column definition */
782 if (!SDDS_TransferColumnDefinition(&SDDS_output, &SDDS_ref[z], take_RefData[z].orig_column[i], take_RefData[z].new_column[i]))
783 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
784 }
785 }
786
787 if (!take_RefData[z].columns && !leave_all_columns && warnings)
788 fprintf(stderr, "warning: there are no columns being taken from %s that are not already in %s\n", input2, input1 ? input1 : "stdin");
789 output_columns = 0;
790 if (take_RefData[z].columns &&
791 (!(output_column = (char **)SDDS_GetColumnNames(&SDDS_output, &output_columns)) || output_columns == 0)) {
792 SDDS_SetError("Problem getting output column names");
793 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
794 }
795 if (output_columns) {
796 for (i = 0; i < output_columns; i++)
797 free(output_column[i]);
798 free(output_column);
799 }
800 /* Check if the column in replace_column exists in the output file */
801 for (i = 0; i < replace_RefData[z].columns; i++) {
802 if (SDDS_GetColumnIndex(&SDDS_1, replace_RefData[z].orig_column[i]) < 0) {
803 if (warnings) {
804 fprintf(stderr, "Warning, %s replace column does not exist in the input1, ignore.\n", replace_RefData[z].orig_column[i]);
805 }
806 } else {
807 /* Check if column types are the same */
808 j = SDDS_GetColumnIndex(&SDDS_ref[z], replace_RefData[z].orig_column[i]);
809 k = SDDS_GetColumnIndex(&SDDS_output, replace_RefData[z].orig_column[i]);
810 datatype1 = SDDS_GetColumnType(&SDDS_ref[z], j);
811 datatype2 = SDDS_GetColumnType(&SDDS_output, k);
812 if (datatype1 != datatype2 && (datatype1 == SDDS_STRING || datatype2 == SDDS_STRING)) {
813 if (warnings) {
814 if (datatype1 == SDDS_STRING)
815 fprintf(stderr, "Warning: cannot replace a numeric column with a string column, replace %s ignored.\n", replace_RefData[z].orig_column[i]);
816 if (datatype2 == SDDS_STRING)
817 fprintf(stderr, "Warning: cannot replace a string column with a numeric column, replace %s ignored.\n", replace_RefData[z].orig_column[i]);
818 }
819 } else {
820 if (datatype1 != datatype2) {
821 if (warnings)
822 fprintf(stderr, "Warning, replace column %s has different data type as the column in input1; redefining the column type\n", replace_RefData[z].orig_column[i]);
823 if (!SDDS_ChangeColumnInformation(&SDDS_output, "type", SDDS_type_name[datatype1 - 1], SDDS_PASS_BY_STRING | SDDS_SET_BY_NAME, replace_RefData[z].orig_column[i])) {
824 fprintf(stderr, "Problem redefining column type for %s\n", replace_RefData[z].orig_column[i]);
825 exit(EXIT_FAILURE);
826 }
827 }
828 /* Add replace_column to take_column, while the orig_name and new_name are the same */
829 take_RefData[z].orig_column = trealloc(take_RefData[z].orig_column, sizeof(*(take_RefData[z].orig_column)) * (take_RefData[z].columns + 1));
830 take_RefData[z].new_column = trealloc(take_RefData[z].new_column, sizeof(*(take_RefData[z].new_column)) * (take_RefData[z].columns + 1));
831 SDDS_CopyString(&take_RefData[z].orig_column[take_RefData[z].columns], replace_RefData[z].orig_column[i]);
832 SDDS_CopyString(&take_RefData[z].new_column[take_RefData[z].columns], replace_RefData[z].orig_column[i]);
833 take_RefData[z].columns++;
834 }
835 }
836 free(replace_RefData[z].orig_column[i]);
837 }
838
839 take_RefData[z].parameters = take_RefData[z].arrays = 0;
840 if (transfers) {
841 if (!expandTransferRequests(&take_RefData[z].orig_parameter, &take_RefData[z].parameters, PARAMETER_TRANSFER, transfer, transfers, &SDDS_ref[z]) ||
842 !expandTransferRequests(&take_RefData[z].orig_array, &take_RefData[z].arrays, ARRAY_TRANSFER, transfer, transfers, &SDDS_ref[z]))
843 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
844 }
845
846 /* Get the new name for parameters, define parameters for output */
847 if (take_RefData[z].parameters)
848 take_RefData[z].new_parameter = (char **)malloc(sizeof(char *) * take_RefData[z].parameters);
849 if (take_RefData[z].arrays)
850 take_RefData[z].new_array = (char **)malloc(sizeof(char *) * take_RefData[z].arrays);
851
852 for (i = 0; i < take_RefData[z].parameters; i++) {
853 k = 0;
854 if (new_data[z].parameters) {
855 k = match_string(take_RefData[z].orig_parameter[i], new_data[z].orig_parameter, new_data[z].parameters, EXACT_MATCH);
856 if (k != -1)
857 SDDS_CopyString(&take_RefData[z].new_parameter[i], new_data[z].new_parameter[k]);
858 else
859 SDDS_CopyString(&take_RefData[z].new_parameter[i], take_RefData[z].orig_parameter[i]);
860 } else
861 SDDS_CopyString(&take_RefData[z].new_parameter[i], take_RefData[z].orig_parameter[i]);
862 if (SDDS_GetParameterIndex(&SDDS_output, take_RefData[z].new_parameter[i]) >= 0) {
863 free(take_RefData[z].orig_parameter[i]);
864 free(take_RefData[z].new_parameter[i]);
865 for (col = i; col < take_RefData[z].parameters - 1; col++)
866 take_RefData[z].orig_parameter[col] = take_RefData[z].orig_parameter[col + 1];
867 take_RefData[z].parameters -= 1;
868 i--;
869 if (take_RefData[z].parameters == 0)
870 break;
871 } else {
872 if (!SDDS_TransferParameterDefinition(&SDDS_output, &SDDS_ref[z], take_RefData[z].orig_parameter[i], take_RefData[z].new_parameter[i]))
873 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
874 }
875 }
876 /* Get the new name for arrays, and define arrays for output */
877 for (i = 0; i < take_RefData[z].arrays; i++) {
878 k = 0;
879 if (new_data[z].arrays) {
880 k = match_string(take_RefData[z].orig_array[i], new_data[z].orig_array, new_data[z].arrays, EXACT_MATCH);
881 if (k == -1)
882 SDDS_CopyString(&take_RefData[z].new_array[i], take_RefData[z].orig_array[i]);
883 else
884 SDDS_CopyString(&take_RefData[z].new_array[i], new_data[z].new_array[k]);
885 } else
886 SDDS_CopyString(&take_RefData[z].new_array[i], take_RefData[z].orig_array[i]);
887 if (SDDS_GetArrayIndex(&SDDS_output, take_RefData[z].new_array[i]) >= 0) {
888 free(take_RefData[z].orig_array[i]);
889 free(take_RefData[z].new_array[i]);
890 for (col = i; col < take_RefData[z].arrays - 1; col++)
891 take_RefData[z].orig_array[col] = take_RefData[z].orig_array[col + 1];
892 take_RefData[z].arrays -= 1;
893 i--;
894 if (take_RefData[z].arrays == 0)
895 break;
896 } else {
897 if (!SDDS_TransferArrayDefinition(&SDDS_output, &SDDS_ref[z], take_RefData[z].orig_array[i], take_RefData[z].new_array[i]))
898 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
899 }
900 }
901
902 /* Check replace parameters and arrays, adding them to take_refData */
903 if (replace_parameters) {
904 for (i = 0; i < replace_parameters; i++) {
905 replace_RefData[z].parameters += SDDS_MatchParameters(&SDDS_ref[z], &replace_RefData[z].orig_parameter, SDDS_MATCH_STRING, FIND_ANY_TYPE, replace_parameter[i], SDDS_OR | SDDS_1_PREVIOUS);
906 }
907
908 /* Check if replace parameters exist in input1 */
909 for (i = 0; i < replace_RefData[z].parameters; i++) {
910 if (SDDS_GetParameterIndex(&SDDS_1, replace_RefData[z].orig_parameter[i]) < 0) {
911 if (warnings) {
912 fprintf(stderr, "Warning, parameter %s replace parameter does not exist in the input1, ignore.\n", replace_RefData[z].orig_parameter[i]);
913 }
914 } else {
915 /* Check if parameter types are the same */
916 j = SDDS_GetParameterIndex(&SDDS_ref[z], replace_RefData[z].orig_parameter[i]);
917 k = SDDS_GetParameterIndex(&SDDS_output, replace_RefData[z].orig_parameter[i]);
918 datatype1 = SDDS_GetParameterType(&SDDS_ref[z], j);
919 datatype2 = SDDS_GetParameterType(&SDDS_output, k);
920 if (datatype1 != datatype2 && (datatype1 == SDDS_STRING || datatype2 == SDDS_STRING)) {
921 if (warnings) {
922 if (datatype1 == SDDS_STRING)
923 fprintf(stderr, "Warning: cannot replace a numeric parameter with a string parameter, replace %s ignored.\n", replace_RefData[z].orig_parameter[i]);
924 if (datatype2 == SDDS_STRING)
925 fprintf(stderr, "Warning: cannot replace a string parameter with a numeric parameter, replace %s ignored.\n", replace_RefData[z].orig_parameter[i]);
926 }
927 } else {
928 if (datatype1 != datatype2) {
929 if (warnings)
930 fprintf(stderr, "Warning, replace parameter %s type is different from input1, redefining parameter type.\n", replace_RefData[z].orig_parameter[i]);
931
932 if (!SDDS_ChangeParameterInformation(&SDDS_output, "type", SDDS_type_name[datatype1 - 1], SDDS_PASS_BY_STRING | SDDS_SET_BY_NAME, replace_RefData[z].orig_parameter[i])) {
933 fprintf(stderr, "Problem redefining parameter type for %s\n", replace_RefData[z].orig_parameter[i]);
934 exit(EXIT_FAILURE);
935 }
936 }
937 /* Add replace_parameter to take_parameter, while the orig_name and new_name are the same */
938 take_RefData[z].orig_parameter = trealloc(take_RefData[z].orig_parameter, sizeof(*(take_RefData[z].orig_parameter)) * (take_RefData[z].parameters + 1));
939 take_RefData[z].new_parameter = trealloc(take_RefData[z].new_parameter, sizeof(*(take_RefData[z].new_parameter)) * (take_RefData[z].parameters + 1));
940 SDDS_CopyString(&take_RefData[z].orig_parameter[take_RefData[z].parameters], replace_RefData[z].orig_parameter[i]);
941 SDDS_CopyString(&take_RefData[z].new_parameter[take_RefData[z].parameters], replace_RefData[z].orig_parameter[i]);
942 take_RefData[z].parameters++;
943 }
944 }
945 free(replace_RefData[z].orig_parameter[i]);
946 }
947
948 if (replace_arrays) {
949 for (i = 0; i < replace_arrays; i++) {
950 replace_RefData[z].arrays += SDDS_MatchArrays(&SDDS_ref[z], &replace_RefData[z].orig_array, SDDS_MATCH_STRING, FIND_ANY_TYPE, replace_array[i], SDDS_OR | SDDS_1_PREVIOUS);
951 }
952 /* Check if replace arrays exist in input1 */
953 for (i = 0; i < replace_RefData[z].arrays; i++) {
954 if (SDDS_GetArrayIndex(&SDDS_1, replace_RefData[z].orig_array[i]) < 0) {
955 if (warnings) {
956 fprintf(stderr, "Warning, array %s replace array does not exist in the input, ignore.\n", replace_RefData[z].orig_array[i]);
957 }
958 } else {
959 /* Check if array types are the same */
960 j = SDDS_GetArrayIndex(&SDDS_ref[z], replace_RefData[z].orig_array[i]);
961 k = SDDS_GetArrayIndex(&SDDS_output, replace_RefData[z].orig_array[i]);
962 datatype1 = SDDS_GetArrayType(&SDDS_ref[z], j);
963 datatype2 = SDDS_GetArrayType(&SDDS_output, k);
964 if (datatype1 != datatype2 && (datatype1 == SDDS_STRING || datatype2 == SDDS_STRING)) {
965 if (warnings) {
966 if (datatype1 == SDDS_STRING)
967 fprintf(stderr, "Warning: cannot replace a numeric array with a string array, replace %s ignored.\n", replace_RefData[z].orig_array[i]);
968 if (datatype2 == SDDS_STRING)
969 fprintf(stderr, "Warning: cannot replace a string array with a numeric array, replace %s ignored.\n", replace_RefData[z].orig_array[i]);
970 }
971 } else {
972 if (datatype1 != datatype2) {
973 if (warnings)
974 fprintf(stderr, "Warning, replace array %s has different data type as the array in input1; redefining\n", replace_RefData[z].orig_array[i]);
975 if (!SDDS_ChangeArrayInformation(&SDDS_output, "type", SDDS_type_name[datatype1 - 1], SDDS_PASS_BY_STRING | SDDS_SET_BY_NAME, replace_RefData[z].orig_array[i])) {
976 fprintf(stderr, "Problem redefining array type for %s\n", replace_RefData[z].orig_array[i]);
977 exit(EXIT_FAILURE);
978 }
979 }
980 /* Add replace_array to take_array, while the orig_name and new_name are the same */
981 take_RefData[z].orig_array = trealloc(take_RefData[z].orig_array, sizeof(*(take_RefData[z].orig_array)) * (take_RefData[z].arrays + 1));
982 SDDS_CopyString(&take_RefData[z].orig_array[take_RefData[z].arrays], replace_RefData[z].orig_array[i]);
983 SDDS_CopyString(&take_RefData[z].new_array[take_RefData[z].arrays], replace_RefData[z].orig_array[i]);
984 take_RefData[z].arrays++;
985 }
986 }
987 free(replace_RefData[z].orig_array[i]);
988 }
989 }
990 }
991 }
992
993 if (!SDDS_WriteLayout(&SDDS_output))
994 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
995
996 refReadCode = malloc(sizeof(*refReadCode) * referfiles);
997 if (!refReadCode)
998 SDDS_Bomb("memory allocation failure");
999
1000 free(leave_column);
1001 if (take_columns) {
1002 SDDS_FreeStringArray(take_column, take_columns);
1003 free(take_column);
1004 }
1005
1006 endWarning = 0;
1007
1008 while ((retval1 = SDDS_ReadPage(&SDDS_1)) > 0) {
1009 copyInput1Only = 0;
1010 rows1 = SDDS_CountRowsOfInterest(&SDDS_1);
1011 if (!SDDS_StartPage(&SDDS_output, rows1)) {
1012 SDDS_SetError("Problem starting output page");
1013 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1014 }
1015 if (fillIn && !SDDS_ClearPage(&SDDS_output)) {
1016 SDDS_SetError("Problem clearing output page");
1017 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1018 }
1019 if (!SDDS_CopyParameters(&SDDS_output, &SDDS_1) ||
1020 !SDDS_CopyArrays(&SDDS_output, &SDDS_1)) {
1021 SDDS_SetError("Problem copying parameter or array data from first input file");
1022 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1023 }
1024
1025 if (!reusePage || retval1 == 1) {
1026#pragma omp parallel for if (threads > 1 && referfiles > 1) num_threads(threads) schedule(dynamic)
1027 for (z = 0; z < referfiles; z++)
1028 refReadCode[z] = SDDS_ReadPage(&SDDS_ref[z]);
1029 } else {
1030 for (z = 0; z < referfiles; z++)
1031 refReadCode[z] = 1;
1032 }
1033
1034 for (z = 0; z < referfiles; z++) {
1035 input2 = referfile[z];
1036 if (!reusePage) {
1037 if ((retval2 = refReadCode[z]) <= 0 && !endWarning) {
1038 if (warnings)
1039 fprintf(stderr, "warning: %s ends prematurely\n", input2 ? input2 : "stdin");
1040 endWarning = 1;
1041 }
1042 } else {
1043 if (retval1 == 1 && (retval2 = refReadCode[z]) <= 0) {
1044 if (!endWarning && warnings)
1045 fprintf(stderr, "warning: %s has no data\n", input2 ? input2 : "stdin");
1046 endWarning = 1;
1047 } else
1048 SDDS_SetRowFlags(&SDDS_ref[z], 1);
1049 }
1050
1051 if (take_RefData[z].columns &&
1052 (!SDDS_SetColumnFlags(&SDDS_ref[z], 0) ||
1053 !SDDS_SetColumnsOfInterest(&SDDS_ref[z], SDDS_NAME_ARRAY, take_RefData[z].columns, take_RefData[z].orig_column)))
1054 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1055
1056 /* Copy parameters and arrays */
1057 if (!CopyParametersFromSecondInput(&SDDS_output, &SDDS_ref[z], take_RefData[z])) {
1058 SDDS_SetError("Problem copying parameter from second input file");
1059 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1060 }
1061 if (!CopyArraysFromSecondInput(&SDDS_output, &SDDS_ref[z], take_RefData[z])) {
1062 SDDS_SetError("Problem copying parameter from second input file");
1063 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1064 }
1065 }
1066
1067 firstRun = 1;
1068 for (z = rows2Max = 0; z < referfiles; z++) {
1069 input2 = referfile[z];
1070 rows2 = SDDS_CountRowsOfInterest(&SDDS_ref[z]);
1071 rows2Max = rows2 > rows2Max ? rows2 : rows2Max;
1072
1073 if (!firstRun) {
1074 /* DO NOT USE SDDS_CountRowsOfInterest because
1075 CopyRowToNewColumn and SDDS_AssertRowFlags expect
1076 the real row index and not the index of rows of interest */
1077 rows1 = SDDS_RowCount(&SDDS_output);
1078 }
1079 if (take_RefData[z].columns) {
1080 if (!rows2) {
1081 if (!SDDS_SetRowFlags(&SDDS_output, fillIn)) {
1082 SDDS_SetError("Problem setting row flags for output file.");
1083 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1084 }
1085 } else if (rows1) {
1086 if (match_columns) {
1087 if (firstRun) {
1088 if (!(string1 = (char **)SDDS_GetColumn(&SDDS_1, match_column[0]))) {
1089 fprintf(stderr, "Error: problem getting column %s from file %s\n", match_column[0], input1 ? input1 : "stdin");
1090 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1091 }
1092 } else {
1093 if (!(string1 = (char **)SDDS_GetColumn(&SDDS_output, match_column[0]))) {
1094 fprintf(stderr, "Error: problem getting column %s from file %s\n", match_column[0], input1 ? input1 : "stdin");
1095 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1096 }
1097 }
1098 if (!(string2 = (char **)SDDS_GetColumn(&SDDS_ref[z], match_column[1]))) {
1099 fprintf(stderr, "Error: problem getting column %s from file %s\n", match_column[1], input2);
1100 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1101 }
1102 StrHash *strHash = NULL;
1103 if (!wildMatch) {
1104 if (useHashLookup)
1105 strHash = SDDS_BuildStrHash(string2, rows2);
1106 else
1107 keyGroup = MakeSortedKeyGroups(&keyGroups, SDDS_STRING, string2, rows2);
1108 }
1109 i3 = 0;
1110 for (i1 = 0; i1 < rows1; i1++) {
1111 if (firstRun) {
1112 if (!SDDS_CopyRowDirect(&SDDS_output, i1, &SDDS_1, i1)) {
1113 sprintf(s, "Problem copying row %" PRId64 " of first data set", i1);
1114 SDDS_SetError(s);
1115 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1116 }
1117 }
1118 matched = 0;
1119 if ((&SDDS_output)->row_flag[i1]) {
1120 if (!wildMatch) {
1121 if (useHashLookup) {
1122 int64_t hv = SDDS_LookupStr(strHash, string1[i3], reuse);
1123 if (hv >= 0) {
1124 i2 = hv;
1125 matched = 1;
1126 }
1127 } else {
1128 if ((i2 = FindMatchingKeyGroup(keyGroup, keyGroups, SDDS_STRING, string1 + i3, reuse)) >= 0)
1129 matched = 1;
1130 }
1131 } else {
1132 if ((i2 = match_string(string1[i3], string2, rows2, WILDCARD_MATCH)) >= 0)
1133 matched = 1;
1134 }
1135 if (matched) {
1136 if (!CopyRowToNewColumn(&SDDS_output, i1, &SDDS_ref[z], i2, take_RefData[z], take_RefData[z].columns, input2)) {
1137 fprintf(stderr, "error in copying data to output!\n");
1138 exit(EXIT_FAILURE);
1139 }
1140 } else {
1141 if (!fillIn && !SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, i1, i1, (int32_t)0))
1142 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1143 if (warnings)
1144 fprintf(stderr, "warning: no match for row %" PRId64 " (%s = \"%s\")\n", i3, match_column[0], string1[i3]);
1145 }
1146 i3++;
1147 }
1148 }
1149 firstRun = 0;
1150 if (string1) {
1151 for (i = 0; i < i3; i++)
1152 free(string1[i]);
1153 free(string1);
1154 }
1155 if (string2) {
1156 for (i = 0; i < rows2; i++)
1157 free(string2[i]);
1158 free(string2);
1159 }
1160
1161 if (!wildMatch) {
1162 if (useHashLookup) {
1163 SDDS_FreeStrHash(strHash);
1164 } else {
1165 for (i = 0; i < keyGroups; i++) {
1166 free(keyGroup[i]->equivalent);
1167 free(keyGroup[i]);
1168 }
1169 free(keyGroup);
1170 }
1171 }
1172 } else if (equate_columns) {
1173 if (firstRun) {
1174 if (!(value1 = SDDS_GetColumnInDoubles(&SDDS_1, equate_column[0]))) {
1175 fprintf(stderr, "Error: problem getting column %s from file %s\n", equate_column[0], input1 ? input1 : "stdin");
1176 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1177 }
1178 } else {
1179 if (!(value1 = SDDS_GetColumnInDoubles(&SDDS_output, equate_column[0]))) {
1180 fprintf(stderr, "Error: problem getting column %s from file %s\n", equate_column[0], input1 ? input1 : "stdin");
1181 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1182 }
1183 }
1184 if (!(value2 = SDDS_GetColumnInDoubles(&SDDS_ref[z], equate_column[1]))) {
1185 fprintf(stderr, "Error: problem getting column %s from file %s\n", equate_column[1], input2);
1186 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1187 }
1188
1189 i3 = 0;
1190 NumHash *numHash = NULL;
1191 if (useHashLookup)
1192 numHash = SDDS_BuildNumHash(value2, rows2);
1193 else
1194 keyGroup = MakeSortedKeyGroups(&keyGroups, SDDS_DOUBLE, value2, rows2);
1195 for (i1 = 0; i1 < rows1; i1++) {
1196 if (firstRun) {
1197 if (!SDDS_CopyRowDirect(&SDDS_output, i1, &SDDS_1, i1)) {
1198 sprintf(s, "Problem copying row %" PRId64 " of first data set", i1);
1199 SDDS_SetError(s);
1200 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1201 }
1202 }
1203 if ((&SDDS_output)->row_flag[i1]) {
1204 int matchedEq = 0;
1205 if (useHashLookup) {
1206 int64_t hv = SDDS_LookupNum(numHash, value1[i3], reuse);
1207 if (hv >= 0) {
1208 i2 = hv;
1209 matchedEq = 1;
1210 }
1211 } else {
1212 if ((i2 = FindMatchingKeyGroup(keyGroup, keyGroups, SDDS_DOUBLE, value1 + i3, reuse)) >= 0)
1213 matchedEq = 1;
1214 }
1215 if (matchedEq) {
1216 if (!CopyRowToNewColumn(&SDDS_output, i1, &SDDS_ref[z], i2, take_RefData[z], take_RefData[z].columns, input2)) {
1217 fprintf(stderr, "error in copying data to output!\n");
1218 exit(EXIT_FAILURE);
1219 }
1220 } else {
1221 if (!fillIn && !SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, i1, i1, (int32_t)0))
1222 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1223 if (warnings)
1224 fprintf(stderr, "warning: no equal for row %" PRId64 " (%s = %g)\n", i3, equate_column[0], value1[i3]);
1225 }
1226 i3++;
1227 }
1228 }
1229 firstRun = 0;
1230 if (i3 && equate_columns)
1231 free(value1);
1232 if (rows2 && equate_columns)
1233 free(value2);
1234 if (useHashLookup) {
1235 SDDS_FreeNumHash(numHash);
1236 } else {
1237 for (i = 0; i < keyGroups; i++) {
1238 free(keyGroup[i]->equivalent);
1239 free(keyGroup[i]);
1240 }
1241 free(keyGroup);
1242 }
1243 } else {
1244 for (i1 = 0; i1 < rows1; i1++) {
1245 i2 = i1;
1246 if (i2 >= rows2) {
1247 if (!reuse) {
1248 if (fillIn) {
1249 if (!SDDS_CopyRowDirect(&SDDS_output, i1, &SDDS_1, i1)) {
1250 sprintf(s, "Problem copying row %" PRId64 " of first data set", i1);
1251 SDDS_SetError(s);
1252 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1253 }
1254 }
1255 if (warnings)
1256 fprintf(stderr, "warning: no row in file 2 for row %" PRId64 " in file 1\n", i1);
1257 continue;
1258 } else
1259 i2 = rows2 - 1;
1260 }
1261 if (firstRun) {
1262 if (!SDDS_CopyRowDirect(&SDDS_output, i1, &SDDS_1, i1)) {
1263 sprintf(s, "Problem copying row %" PRId64 " of first data set", i1);
1264 SDDS_SetError(s);
1265 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1266 }
1267 }
1268 if (take_RefData[z].columns &&
1269 !CopyRowToNewColumn(&SDDS_output, i1, &SDDS_ref[z], i2, take_RefData[z], take_RefData[z].columns, input2)) {
1270 fprintf(stderr, "error in copying data to output!\n");
1271 exit(EXIT_FAILURE);
1272 }
1273 }
1274 firstRun = 0;
1275 }
1276 }
1277 } else {
1278 if (rows2) {
1279 if (rows1) {
1280 if (match_columns) {
1281 if (firstRun) {
1282 if (!(string1 = (char **)SDDS_GetColumn(&SDDS_1, match_column[0]))) {
1283 fprintf(stderr, "Error: problem getting column %s from file %s\n", match_column[0], input1 ? input1 : "stdin");
1284 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1285 }
1286 } else {
1287 if (!(string1 = (char **)SDDS_GetColumn(&SDDS_output, match_column[0]))) {
1288 fprintf(stderr, "Error: problem getting column %s from file %s\n", match_column[0], input1 ? input1 : "stdin");
1289 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1290 }
1291 }
1292 if (!(string2 = (char **)SDDS_GetColumn(&SDDS_ref[z], match_column[1]))) {
1293 fprintf(stderr, "Error: problem getting column %s from file %s\n", match_column[1], input2);
1294 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1295 }
1296 StrHash *strHash2 = NULL;
1297 if (useHashLookup)
1298 strHash2 = SDDS_BuildStrHash(string2, rows2);
1299 else
1300 keyGroup = MakeSortedKeyGroups(&keyGroups, SDDS_STRING, string2, rows2);
1301 i3 = 0;
1302 for (i1 = 0; i1 < rows1; i1++) {
1303 if (firstRun) {
1304 if (!SDDS_CopyRowDirect(&SDDS_output, i1, &SDDS_1, i1)) {
1305 sprintf(s, "Problem copying row %" PRId64 " of first data set", i1);
1306 SDDS_SetError(s);
1307 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1308 }
1309 }
1310 if ((&SDDS_output)->row_flag[i1]) {
1311 int present = 0;
1312 if (useHashLookup) {
1313 present = SDDS_LookupStr(strHash2, string1[i3], 1) >= 0;
1314 } else {
1315 present = (FindMatchingKeyGroup(keyGroup, keyGroups, SDDS_STRING, string1 + i3, reuse)) >= 0;
1316 }
1317 if (!present) {
1318 if (!fillIn && !SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, i1, i1, (int32_t)0))
1319 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1320 if (warnings)
1321 fprintf(stderr, "warning: no match for row %" PRId64 " (%s = \"%s\")\n", i3, match_column[0], string1[i3]);
1322 }
1323 i3++;
1324 }
1325 }
1326 firstRun = 0;
1327 if (string1) {
1328 for (i = 0; i < i3; i++)
1329 free(string1[i]);
1330 free(string1);
1331 }
1332 if (string2) {
1333 for (i = 0; i < rows2; i++)
1334 free(string2[i]);
1335 free(string2);
1336 }
1337
1338 if (useHashLookup) {
1339 SDDS_FreeStrHash(strHash2);
1340 } else {
1341 for (i = 0; i < keyGroups; i++) {
1342 free(keyGroup[i]->equivalent);
1343 free(keyGroup[i]);
1344 }
1345 free(keyGroup);
1346 }
1347 } else if (equate_columns) {
1348 if (firstRun) {
1349 if (!(value1 = SDDS_GetColumnInDoubles(&SDDS_1, equate_column[0]))) {
1350 fprintf(stderr, "Error: problem getting column %s from file %s\n", equate_column[0], input1 ? input1 : "stdin");
1351 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1352 }
1353 } else {
1354 if (!(value1 = SDDS_GetColumnInDoubles(&SDDS_output, equate_column[0]))) {
1355 fprintf(stderr, "Error: problem getting column %s from file %s\n", equate_column[0], input1 ? input1 : "stdin");
1356 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1357 }
1358 }
1359 if (!(value2 = SDDS_GetColumnInDoubles(&SDDS_ref[z], equate_column[1]))) {
1360 fprintf(stderr, "Error: problem getting column %s from file %s\n", equate_column[1], input2);
1361 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1362 }
1363 NumHash *numHash2 = NULL;
1364 if (useHashLookup)
1365 numHash2 = SDDS_BuildNumHash(value2, rows2);
1366 else
1367 keyGroup = MakeSortedKeyGroups(&keyGroups, SDDS_DOUBLE, value2, rows2);
1368 i3 = 0;
1369 for (i1 = 0; i1 < rows1; i1++) {
1370 if (firstRun) {
1371 if (!SDDS_CopyRowDirect(&SDDS_output, i1, &SDDS_1, i1)) {
1372 sprintf(s, "Problem copying row %" PRId64 " of first data set", i1);
1373 SDDS_SetError(s);
1374 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1375 }
1376 }
1377 if ((&SDDS_output)->row_flag[i1]) {
1378 int presentEq = 0;
1379 if (useHashLookup) {
1380 presentEq = SDDS_LookupNum(numHash2, value1[i3], 1) >= 0;
1381 } else {
1382 presentEq = (FindMatchingKeyGroup(keyGroup, keyGroups, SDDS_DOUBLE, value1 + i3, reuse)) >= 0;
1383 }
1384 if (!presentEq) {
1385 if (!fillIn && !SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, i1, i1, (int32_t)0))
1386 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1387 if (warnings)
1388 fprintf(stderr, "warning: no equal for row %" PRId64 " (%s = %g)\n", i3, equate_column[0], value1[i3]);
1389 }
1390 i3++;
1391 }
1392 }
1393 firstRun = 0;
1394 if (i3 && equate_columns)
1395 free(value1);
1396 if (rows2 && equate_columns)
1397 free(value2);
1398 if (useHashLookup) {
1399 SDDS_FreeNumHash(numHash2);
1400 } else {
1401 for (i = 0; i < keyGroups; i++) {
1402 free(keyGroup[i]->equivalent);
1403 free(keyGroup[i]);
1404 }
1405 free(keyGroup);
1406 }
1407 }
1408 }
1409 }
1410 copyInput1Only++;
1411 }
1412 }
1413 if ((rows2Max == 0 && fillIn) || (copyInput1Only == referfiles && !match_columns && !equate_columns)) {
1414 if (!SDDS_CopyColumns(&SDDS_output, &SDDS_1)) {
1415 SDDS_SetError("Problem copying tabular data for output file.");
1416 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1417 }
1418 }
1419
1420 if (!SDDS_WritePage(&SDDS_output)) {
1421 SDDS_SetError("Problem writing data to output file");
1422 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
1423 }
1424 }
1425
1426 for (z = 0; z < referfiles; z++) {
1427 free(referfile[z]);
1428
1429 if (take_RefData[z].columns) {
1430 for (i = 0; i < take_RefData[z].columns; i++) {
1431 free(take_RefData[z].new_column[i]);
1432 free(take_RefData[z].orig_column[i]);
1433 }
1434 free(take_RefData[z].new_column);
1435 free(take_RefData[z].orig_column);
1436 }
1437
1438 if (take_RefData[z].parameters) {
1439 for (i = 0; i < take_RefData[z].parameters; i++) {
1440 free(take_RefData[z].new_parameter[i]);
1441 free(take_RefData[z].orig_parameter[i]);
1442 }
1443 free(take_RefData[z].new_parameter);
1444 free(take_RefData[z].orig_parameter);
1445 }
1446
1447 if (take_RefData[z].arrays) {
1448 for (i = 0; i < take_RefData[z].arrays; i++) {
1449 free(take_RefData[z].new_array[i]);
1450 free(take_RefData[z].orig_array[i]);
1451 }
1452 free(take_RefData[z].new_array);
1453 free(take_RefData[z].orig_array);
1454 }
1455
1456 if (new_data[z].columns) {
1457 for (i = 0; i < new_data[z].columns; i++) {
1458 free(new_data[z].new_column[i]);
1459 free(new_data[z].orig_column[i]);
1460 }
1461 free(new_data[z].new_column);
1462 free(new_data[z].orig_column);
1463 }
1464
1465 if (new_data[z].parameters) {
1466 for (i = 0; i < new_data[z].parameters; i++) {
1467 free(new_data[z].new_parameter[i]);
1468 free(new_data[z].orig_parameter[i]);
1469 }
1470 free(new_data[z].new_parameter);
1471 free(new_data[z].orig_parameter);
1472 }
1473 if (new_data[z].arrays) {
1474 for (i = 0; i < new_data[z].arrays; i++) {
1475 free(new_data[z].new_array[i]);
1476 free(new_data[z].orig_array[i]);
1477 }
1478 free(new_data[z].new_array);
1479 free(new_data[z].orig_array);
1480 }
1481 }
1482 if (new_data)
1483 free(new_data);
1484
1485 if (edit_column_requests) {
1486 for (i = 0; i < edit_column_requests; i++) {
1487 free(edit_column_request[i].match_string);
1488 free(edit_column_request[i].edit_string);
1489 }
1490 free(edit_column_request);
1491 }
1492 if (edit_parameter_requests) {
1493 for (i = 0; i < edit_parameter_requests; i++) {
1494 free(edit_parameter_request[i].match_string);
1495 free(edit_parameter_request[i].edit_string);
1496 }
1497 free(edit_parameter_request);
1498 }
1499
1500 if (edit_array_requests) {
1501 for (i = 0; i < edit_array_requests; i++) {
1502 free(edit_array_request[i].match_string);
1503 free(edit_array_request[i].edit_string);
1504 }
1505 free(edit_array_request);
1506 }
1507
1508 free(take_RefData);
1509 if (replace_RefData)
1510 free(replace_RefData);
1511 free(refReadCode);
1512 free(referfile);
1513 free(inputfile);
1514
1515 if (match_columns)
1516 free(match_column);
1517 if (equate_columns)
1518 free(equate_column);
1519
1520 /*#ifdef SOLARIS */
1521 if (!SDDS_Terminate(&SDDS_output) || !SDDS_Terminate(&SDDS_1)) {
1522 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1523 exit(EXIT_FAILURE);
1524 }
1525 for (z = 0; z < referfiles; z++) {
1526 if (!SDDS_Terminate(&SDDS_ref[z])) {
1527 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1528 exit(EXIT_FAILURE);
1529 }
1530 }
1531 free(SDDS_ref);
1532 /*#endif */
1533 if (tmpfile_used && !replaceFileAndBackUp(input1, output))
1534 exit(EXIT_FAILURE);
1535 free(input1);
1536 free(output);
1537 return EXIT_SUCCESS;
1538}
SDDS_CopyColumns
int32_t SDDS_CopyColumns(SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source)
Definition SDDS_copy.c:387
SDDS_CopyParameters
int32_t SDDS_CopyParameters(SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source)
Definition SDDS_copy.c:286
SDDS_InitializeCopy
int32_t SDDS_InitializeCopy(SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source, char *filename, char *filemode)
Definition SDDS_copy.c:40
SDDS_CopyRowDirect
int32_t SDDS_CopyRowDirect(SDDS_DATASET *SDDS_target, int64_t target_row, SDDS_DATASET *SDDS_source, int64_t source_row)
Definition SDDS_copy.c:834
SDDS_CopyArrays
int32_t SDDS_CopyArrays(SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source)
Definition SDDS_copy.c:334
SDDS_type_name
char * SDDS_type_name[SDDS_NUM_TYPES]
Array of supported data type names.
Definition SDDS_data.c:43
SDDS_StartPage
int32_t SDDS_StartPage(SDDS_DATASET *SDDS_dataset, int64_t expected_n_rows)
Definition SDDS_dataprep.c:70
SDDS_ClearPage
int32_t SDDS_ClearPage(SDDS_DATASET *SDDS_dataset)
Definition SDDS_dataprep.c:194
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_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_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_SetColumnsOfInterest
int32_t SDDS_SetColumnsOfInterest(SDDS_DATASET *SDDS_dataset, int32_t mode,...)
Sets the acceptance flags for columns based on specified naming criteria.
Definition SDDS_extract.c:432
SDDS_SetColumnFlags
int32_t SDDS_SetColumnFlags(SDDS_DATASET *SDDS_dataset, int32_t column_flag_value)
Sets the acceptance flags for all columns in the current data table of a data set.
Definition SDDS_extract.c:218
SDDS_GetColumnInDoubles
double * SDDS_GetColumnInDoubles(SDDS_DATASET *SDDS_dataset, char *column_name)
Retrieves the data of a specified numerical column as an array of doubles, considering only rows mark...
Definition SDDS_extract.c:872
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_ChangeArrayInformation
int32_t SDDS_ChangeArrayInformation(SDDS_DATASET *SDDS_dataset, char *field_name, void *memory, int32_t mode,...)
Modifies a specific field in an array definition within the SDDS dataset.
Definition SDDS_info.c:597
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_WritePage
int32_t SDDS_WritePage(SDDS_DATASET *SDDS_dataset)
Writes the current data table to the output file.
Definition SDDS_output.c:1229
SDDS_WriteLayout
int32_t SDDS_WriteLayout(SDDS_DATASET *SDDS_dataset)
Writes the SDDS layout header to the output file.
Definition SDDS_output.c:900
SDDS_TransferColumnDefinition
int32_t SDDS_TransferColumnDefinition(SDDS_DATASET *target, SDDS_DATASET *source, char *name, char *newName)
Transfers a column definition from a source dataset to a target dataset.
Definition SDDS_transfer.c:35
SDDS_TransferArrayDefinition
int32_t SDDS_TransferArrayDefinition(SDDS_DATASET *target, SDDS_DATASET *source, char *name, char *newName)
Transfers an array definition from a source dataset to a target dataset.
Definition SDDS_transfer.c:111
SDDS_TransferParameterDefinition
int32_t SDDS_TransferParameterDefinition(SDDS_DATASET *target, SDDS_DATASET *source, char *name, char *newName)
Transfers a parameter definition from a source dataset to a target dataset.
Definition SDDS_transfer.c:73
SDDS_FreeStringArray
int32_t SDDS_FreeStringArray(char **string, int64_t strings)
Frees an array of strings by deallocating each individual string.
Definition SDDS_utils.c:2931
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_ColumnCount
int32_t SDDS_ColumnCount(SDDS_DATASET *page)
Retrieves the number of columns in the SDDS dataset.
Definition SDDS_utils.c:5098
SDDS_GetArrayType
int32_t SDDS_GetArrayType(SDDS_DATASET *SDDS_dataset, int32_t index)
Retrieves the data type of an array in the SDDS dataset by its index.
Definition SDDS_utils.c:2268
SDDS_RegisterProgramName
void SDDS_RegisterProgramName(const char *name)
Registers the executable program name for use in error messages.
Definition SDDS_utils.c:318
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_DOUBLE
#define SDDS_DOUBLE
Identifier for the double data type.
Definition SDDStypes.h:37
SDDS_NUMERIC_TYPE
#define SDDS_NUMERIC_TYPE(type)
Checks if the given type identifier corresponds to any numeric type.
Definition SDDStypes.h:138
tmalloc
void * tmalloc(uint64_t size_of_block)
Allocates a memory block of the specified size with zero initialization.
Definition array.c:65
delete_chars
char * delete_chars(char *s, char *t)
Removes all occurrences of characters found in string t from string s.
Definition delete_chars.c:28
match_string
long match_string(char *string, char **option, long n_options, long mode)
Matches a given string against an array of option strings based on specified modes.
Definition match_string.c:34
replaceFileAndBackUp
long replaceFileAndBackUp(char *file, char *replacement)
Replaces a file with a replacement file and creates a backup of the original.
Definition replacefile.c:78
scanargs
int scanargs(SCANNED_ARG **scanned, int argc, char **argv)
Definition scanargs.c:36
processPipeOption
long processPipeOption(char **item, long items, unsigned long *flags)
Definition scanargs.c:357
processFilenames
void processFilenames(char *programName, char **input, char **output, unsigned long pipeFlags, long noWarnings, long *tmpOutputUsed)
Definition scanargs.c:391
scanItemList
long scanItemList(unsigned long *flags, char **item, long *items, unsigned long mode,...)
Scans a list of items and assigns values based on provided keywords and types.
Definition scanitemlist.c:41
MakeSortedKeyGroups
KEYED_EQUIVALENT ** MakeSortedKeyGroups(long *keyGroups, long keyType, void *data, long points)
Create sorted key groups from data.
Definition sortfunctions.c:368
FindMatchingKeyGroup
long FindMatchingKeyGroup(KEYED_EQUIVALENT **keyGroup, long keyGroups, long keyType, void *searchKeyData, long reuse)
Find a matching key group for a search key.
Definition sortfunctions.c:450
EDIT_NAME_REQUEST
Definition sddsconvert.c:166
IFITEM_LIST
Definition SDDSaps.h:49
TRANSFER_DEFINITION
Definition sddsmxref.c:114
has_wildcards
int has_wildcards(char *template)
Check if a template string contains any wildcard characters.
Definition wild_match.c:498

◆ process_editnames()

char ** process_editnames ( char ** orig_name,
long ** orig_flags,
long orig_names,
EDIT_NAME_REQUEST * edit_request,
long edit_requests,
long filenumber )

Definition at line 1707 of file sddsxref.c.

1708 {
1709 long i, j, i1, i2 = 0, k;
1710 char **new_name, s[1024], tmpstr[1024];
1711 char *ptr, **editstr, *pch;
1712 char edit_buffer[1024];
1713
1714 *orig_flags = NULL;
1715
1716 *orig_flags = tmalloc(sizeof(**orig_flags) * orig_names);
1717 new_name = tmalloc(sizeof(*new_name) * orig_names);
1718
1719 editstr = (char **)malloc(sizeof(*editstr) * edit_requests);
1720 ptr = malloc(sizeof(char) * 256);
1721 sprintf(s, "%ld", filenumber);
1722
1723 for (i = 0; i < edit_requests; i++) {
1724 SDDS_CopyString(&editstr[i], edit_request[i].edit_string);
1725 if (strstr(editstr[i], "%%ld"))
1726 replace_string(ptr, editstr[i], "%%ld", "%ld");
1727 else if (strstr(editstr[i], "%ld")) {
1728 sprintf(s, "%ld", filenumber);
1729 replace_string(ptr, editstr[i], "%ld", s);
1730 } else if (wild_match(editstr[i], "*%*ld*")) {
1731 /* Find the format of %*ld */
1732 /* Find position of '%' */
1733 pch = strchr(editstr[i], '%');
1734 i1 = pch - editstr[i];
1735 /* Find the position of 'd' after '%' */
1736 for (k = 0; k < strlen(editstr[i]); k++) {
1737 if (editstr[i][k] == 'd') {
1738 i2 = k;
1739 if (i2 > i1)
1740 break;
1741 }
1742 }
1743 strncpy(tmpstr, pch, i2 - i1 + 1);
1744 tmpstr[i2 - i1 + 1] = '\0';
1745 sprintf(s, tmpstr, filenumber);
1746 replace_string(ptr, editstr[i], tmpstr, s);
1747 } else
1748 continue;
1749 free(editstr[i]);
1750 SDDS_CopyString(&editstr[i], ptr);
1751 }
1752 free(ptr);
1753 ptr = NULL;
1754 for (j = 0; j < orig_names; j++) {
1755 (*orig_flags)[j] = 0;
1756 SDDS_CopyString(new_name + j, orig_name[j]);
1757 for (i = 0; i < edit_requests; i++) {
1758 ptr = expand_ranges(edit_request[i].match_string);
1759 free(edit_request[i].match_string);
1760 edit_request[i].match_string = ptr;
1761 if (wild_match(new_name[j], edit_request[i].match_string)) {
1762 strcpy(edit_buffer, new_name[j]);
1763 if (!edit_string(edit_buffer, editstr[i]))
1764 SDDS_Bomb("error editing name");
1765 free(new_name[j]);
1766 SDDS_CopyString(&new_name[j], edit_buffer);
1767 (*orig_flags)[j] = 1;
1768 }
1769 }
1770 }
1771
1772 for (i = 0; i < edit_requests; i++)
1773 free(editstr[i]);
1774 free(editstr);
1775 return new_name;
1776}
replace_string
int replace_string(char *t, char *s, char *orig, char *repl)
Replace all occurrences of one string with another string.
Definition replace_string.c:29
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