long get_material_property(char *label, char *property, char **str_value, long *int_value, double *double_value) { long rows=0, index, col_index=-1; SDDS_DATASET table; int32_t *intValue = NULL; char **formula, **name; double *doubleValue = NULL; formula = name = NULL; if ((col_index=match_string(property, table_column, TABLE_COLS, 0))<0) { if (verbose) fprintf(stderr, "Property - %s does not exist in the property table.\n", property); return -1; } if (!SDDS_InitializeInput(&table, matTable)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!SDDS_ReadPage(&table) || !(rows=SDDS_CountRowsOfInterest(&table)) || !(formula=(char**)SDDS_GetColumn(&table, "Formula")) || !(name=(char**)SDDS_GetColumn(&table, "Name"))) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); index = match_string(label, formula, rows, EXACT_MATCH); if (index<0) index = match_string(label, name, rows, 0); if (index<0) { fprintf(stdout, "%s not found.\n", label); return -1; } switch (col_index) { case FORMULA_COL: SDDS_CopyString(str_value, formula[index]); break; case NAME_COL: SDDS_CopyString(str_value, name[index]); break; case Z_COL: case GROUP_COL: case PERIOD_COL: intValue = (int32_t*)SDDS_GetColumn(&table, table_column[col_index]); *int_value = intValue[index]; free(intValue); break; default: doubleValue = (double*)SDDS_GetColumn(&table, table_column[col_index]); *double_value = doubleValue[index]; free(doubleValue); break; } if (!SDDS_Terminate(&table)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); SDDS_FreeStringArray(formula, rows); SDDS_FreeStringArray(name, rows); free(formula); free(name); return index; }
int main(int argc, char **argv) { SDDS_DATASET SDDSnew, SDDSold; long i, j, iArg; SCANNED_ARG *scArg; char *input, *output, *columnName; long mode, matchCode, rows, rowsMinus1, tmpfile_used; double gapAmount, *columnData, gapFactor; char *matchPattern; long matchPatternAfter = 0; double changeAmount, changeBase; long retval, newStart, rowLimit, breakNext; int32_t dataType, overlap=0; unsigned long flags, pipeFlags, changeFlags; char **stringData; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&scArg, argc, argv); if (argc<2) { fprintf(stderr, "%s", USAGE); return(1); } columnData = NULL; stringData = NULL; input = output = columnName = NULL; mode = -1; pipeFlags = flags = 0; gapAmount = changeAmount = rowLimit = gapFactor = 0; matchPattern = NULL; for (iArg=1; iArg<argc; iArg++) { if (scArg[iArg].arg_type==OPTION) { switch (matchCode=match_string(scArg[iArg].list[0], option, N_OPTIONS, 0)) { case SET_GAPIN: if ((scArg[iArg].n_items-=2)<0 || !scanItemList(&flags, scArg[iArg].list+2, &scArg[iArg].n_items, 0, "amount", SDDS_DOUBLE, &gapAmount, 1, GAPIN_AMOUNT, "factor", SDDS_DOUBLE, &gapFactor, 1, GAPIN_FACTOR, NULL) || (flags&GAPIN_AMOUNT && gapAmount<=0) || (flags&GAPIN_FACTOR && gapFactor<=0)) { fprintf(stderr, "Error: invalid -gapin syntax/values\n"); return(1); } columnName = scArg[iArg].list[1]; mode = matchCode; break; case SET_INCREASEOF: case SET_DECREASEOF: if (scArg[iArg].n_items!=2) { fprintf(stderr, "Error: invalid option syntax---specify column-name with -increaseof and -decreaseof\n"); return(1); } columnName = scArg[iArg].list[1]; mode = matchCode; break; case SET_CHANGEOF: if ((scArg[iArg].n_items-=2)<0 || !scanItemList(&changeFlags, scArg[iArg].list+2, &scArg[iArg].n_items, 0, "amount", SDDS_DOUBLE, &changeAmount, 1, CHANGEOF_AMOUNT, "base", SDDS_DOUBLE, &changeBase, 1, CHANGEOF_BASE, NULL) || (changeFlags&CHANGEOF_AMOUNT && changeAmount<=0)) { fprintf(stderr, "Error: invalid -changeof syntax/values\n"); return(1); } columnName = scArg[iArg].list[1]; mode = matchCode; break; case SET_ROWLIMIT: if (scArg[iArg].n_items<2) { fprintf(stderr, "Error: invalid -rowlimit syntax\n"); return(1); } if (sscanf(scArg[iArg].list[1], "%ld", &rowLimit)!=1 || rowLimit<=0) { fprintf(stderr, "Error: invalid -rowlimit syntax\n"); return(1); } if (scArg[iArg].n_items>2) { scArg[iArg].n_items-=2; if (!scanItemList(&flags, scArg[iArg].list+2, &scArg[iArg].n_items, 0, "overlap", SDDS_LONG, &overlap, NULL) || overlap<0) { fprintf(stderr, "Error: invalid overlap given in -rowlimit syntax\n"); return(1); } } mode = matchCode; break; case SET_PIPE: if (!processPipeOption(scArg[iArg].list+1, scArg[iArg].n_items-1, &pipeFlags)) { fprintf(stderr, "Error: invalid -pipe syntax\n"); return(1); } break; case SET_MATCHTO: if ((scArg[iArg].n_items!=3 && scArg[iArg].n_items!=4) || strlen(columnName=scArg[iArg].list[1])==0 || strlen(matchPattern=scArg[iArg].list[2])==0) { fprintf(stderr, "Error: invalid -matchTo syntax\n"); return(1); } if (scArg[iArg].n_items==4) { if (strncmp(scArg[iArg].list[3], "after", strlen(scArg[iArg].list[3]))==0) matchPatternAfter = 1; else { fprintf(stderr, "Error: invalid -matchTo syntax\n"); return(1); } } mode = matchCode; break; default: fprintf(stderr, "Error: unknown switch: %s\n", scArg[iArg].list[0]); fprintf(stderr, "%s", USAGE); return(1); } } else { if (input==NULL) input = scArg[iArg].list[0]; else if (output==NULL) output = scArg[iArg].list[0]; else { fprintf(stderr, "Error: too many filenames given\n"); return(1); } } } processFilenames("sddsbreak", &input, &output, pipeFlags, 0, &tmpfile_used); if (mode==-1) { fprintf(stderr, "Error: no break mode specified\n"); return(1); } if (!SDDS_InitializeInput(&SDDSold, input) || !SDDS_InitializeCopy(&SDDSnew, &SDDSold, output, "w")) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } SDDSnew.layout.data_mode.no_row_counts = 0; if (!SDDS_WriteLayout(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (mode!=SET_ROWLIMIT) { if (SDDS_GetColumnInformation(&SDDSold, "type", &dataType, SDDS_BY_NAME, columnName)!=SDDS_LONG) { SDDS_SetError("problem getting type information on given column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (mode==SET_MATCHTO) { if (!(dataType==SDDS_STRING)) { fprintf(stderr, "Error: given column does not contain string data\n"); return(1); } } else if (!SDDS_NUMERIC_TYPE(dataType)) { if (!(mode==SET_CHANGEOF && !(changeFlags&CHANGEOF_AMOUNT) && !(changeFlags&CHANGEOF_BASE))) { fprintf(stderr, "Error: given column does not contain numeric data\n"); return(1); } } } while ((retval=SDDS_ReadPage(&SDDSold))>0) { if ((rows = SDDS_CountRowsOfInterest(&SDDSold))<0) { SDDS_SetError("Problem getting number of rows of tabular data"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } rowsMinus1 = rows-1; if (!SDDS_StartPage(&SDDSnew, rows) || !SDDS_CopyParameters(&SDDSnew, &SDDSold) || !SDDS_CopyArrays(&SDDSnew, &SDDSold)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (rows==0) { if (!SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } continue; } switch (mode) { case SET_GAPIN: if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (!gapAmount && rows>1) { double *gap; gap = tmalloc(sizeof(*gap)*rows); for (i=1; i<rows; i++) gap[i-1] = fabs(columnData[i]-columnData[i-1]); if (!compute_average(&gapAmount, gap, rows-1)) { fprintf(stderr, "Error: unable to determine default gap amount--couldn't find median gap\n"); return(1); } gapAmount *= (gapFactor?gapFactor:2); free(gap); } newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows && fabs(columnData[i]-columnData[i-1])<gapAmount) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } free(columnData); break; case SET_INCREASEOF: if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows && columnData[i]<=columnData[i-1]) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } free(columnData); break; case SET_DECREASEOF: if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows && columnData[i]>=columnData[i-1]) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } free(columnData); break; case SET_CHANGEOF: if (dataType!=SDDS_STRING) { if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } } else { if (!(stringData=SDDS_GetColumn(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } } newStart = 0; if (dataType==SDDS_STRING || !changeAmount) { for (i=1; i<=rows; i++) { if (i!=rows && ((dataType==SDDS_STRING && strcmp(stringData[i], stringData[i-1])==0) || (dataType!=SDDS_STRING && columnData[i]==columnData[i-1]))) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } } else { long region, lastRegion; region = lastRegion = 0; if (!(changeFlags&CHANGEOF_BASE) && rows>=1) changeBase = columnData[0]; if (rows>1) lastRegion = (columnData[0]-changeBase)/changeAmount; #ifdef DEBUG fprintf(stderr, "change base=%e, lastRegion=%ld\n", changeBase, lastRegion); fprintf(stderr, "start value = %e\n", columnData[0]); #endif newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows) region = (columnData[i]-changeBase)/changeAmount; if (i!=rows && region==lastRegion) continue; #ifdef DEBUG fprintf(stderr, "split after %e, before %e, region = %d\n", columnData[i-1], columnData[i], region); #endif if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; lastRegion = region; #ifdef DEBUG fprintf(stderr, "start value = %e\n", columnData[i]); #endif } } if (dataType!=SDDS_STRING) free(columnData); else SDDS_FreeStringArray(stringData, rows); break; case SET_MATCHTO: if (!(stringData=SDDS_GetColumn(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = 0; breakNext = 0; for (i=1; i<=rows; i++) { if (i!=rows && !breakNext) { if (wild_match(stringData[i], matchPattern)) { if (matchPatternAfter) { breakNext = 1; continue; } } else continue; } if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } breakNext = 0; newStart = i; } SDDS_FreeStringArray(stringData, rows); break; case SET_ROWLIMIT: for (i=0; i<rows; i+=rowLimit-overlap) { if ((j=i+rowLimit-1)>=rows) j = rows-1; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, i, j, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (j==rows-1) break; } break; default: fprintf(stderr, "Error: unknown break mode code seen---this can't happen\n"); return(1); } } if (retval==0) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (!SDDS_Terminate(&SDDSold)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (tmpfile_used && !replaceFileAndBackUp(input, output)) { return(1); } return(0); }
int main(int argc, char **argv) { SCANNED_ARG *s_arg; SDDS_DATASET inputPage, outputPage; char *inputfile, *outputfile; char **inputColumnName, **inputStringColumnName, **inputDoubleColumnName; char **outputStringColumnName, **outputDoubleColumnName, **matchColumn=NULL; long inputRows, inputDoubleColumns, inputStringColumns, indexColumn=0, matchColumns=0, noOldColumnNamesColumn=0; long outputRows, outputDoubleColumns, outputStringColumns; char **inputParameterName; int32_t inputParameters, inputColumns; char *inputDescription, *inputContents; char *outputDescription; long i, i_arg, col; char *buffer; char **columnOfStrings; long buffer_size; #define BUFFER_SIZE_INCREMENT 16384 MATRIX *R, *RInv; long OldStringColumnsDefined; char *inputStringRows, *outputStringRows; char **stringArray, *stringParameter; long token_length; long verbose; char format[32]; long digits; char *Symbol, *Root; void *parameterPointer; long ascii; unsigned long pipeFlags, majorOrderFlag; long tmpfile_used, noWarnings; long ipage=0, columnType; char *oldColumnNames, *newColumnNamesColumn; short columnMajorOrder=-1; inputColumnName = outputStringColumnName = outputDoubleColumnName = inputParameterName = NULL; outputRows = outputDoubleColumns = outputStringColumns = OldStringColumnsDefined = 0; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&s_arg, argc, argv); if (argc==1) bomb(NULL, USAGE); inputfile = outputfile = NULL; verbose = 0; Symbol = Root = NULL; ascii = 0; digits=3; pipeFlags = 0; tmpfile_used = 0; noWarnings = 0; oldColumnNames = NULL; newColumnNamesColumn = NULL; for (i_arg=1; i_arg<argc; i_arg++) { if (s_arg[i_arg].arg_type==OPTION) { switch(match_string(s_arg[i_arg].list[0], commandline_option, COMMANDLINE_OPTIONS, UNIQUE_MATCH)) { case CLO_MAJOR_ORDER: majorOrderFlag=0; s_arg[i_arg].n_items--; if (s_arg[i_arg].n_items>0 && (!scanItemList(&majorOrderFlag, s_arg[i_arg].list+1, &s_arg[i_arg].n_items, 0, "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER, "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL))) SDDS_Bomb("invalid -majorOrder syntax/values"); if (majorOrderFlag&SDDS_COLUMN_MAJOR_ORDER) columnMajorOrder=1; else if (majorOrderFlag&SDDS_ROW_MAJOR_ORDER) columnMajorOrder=0; break; case CLO_MATCH_COLUMN: matchColumns = s_arg[i_arg].n_items-1; matchColumn = s_arg[i_arg].list+1; break; case CLO_INDEX_COLUMN: indexColumn = 1; break; case CLO_NO_OLDCOLUMNNAMES: noOldColumnNamesColumn = 1; break; case CLO_VERBOSE: verbose=1; break; case CLO_ASCII: ascii=1; break; case CLO_DIGITS: if (!(get_long(&digits, s_arg[i_arg].list[1]))) bomb("no string given for option -digits", USAGE); break; case CLO_COLUMNROOT: if (!(Root=s_arg[i_arg].list[1])) SDDS_Bomb("No root string given"); break; case CLO_SYMBOL: if (!(Symbol=s_arg[i_arg].list[1])) SDDS_Bomb("No symbol string given"); break; case CLO_PIPE: if (!processPipeOption(s_arg[i_arg].list+1, s_arg[i_arg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; case CLO_OLDCOLUMNNAMES: if (!(oldColumnNames=s_arg[i_arg].list[1])) SDDS_Bomb("No oldColumnNames string given"); break; case CLO_NEWCOLUMNNAMES: if (s_arg[i_arg].n_items!=2 || SDDS_StringIsBlank(newColumnNamesColumn = s_arg[i_arg].list[1])) SDDS_Bomb("Invalid -newColumnNames syntax/value"); break; default: bomb("unrecognized option given", USAGE); } } else { if (!inputfile) inputfile = s_arg[i_arg].list[0]; else if (!outputfile) outputfile = s_arg[i_arg].list[0]; else bomb("too many filenames given", USAGE); } } processFilenames("sddstranpose", &inputfile, &outputfile, pipeFlags, noWarnings, &tmpfile_used); if (newColumnNamesColumn && Root) SDDS_Bomb("-root and -newColumnNames are incompatible"); if (!SDDS_InitializeInput(&inputPage, inputfile) || !(inputParameterName=(char**)SDDS_GetParameterNames(&inputPage, &inputParameters)) || !SDDS_GetDescription(&inputPage, &inputDescription, &inputContents)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); if (matchColumns) inputColumnName = getMatchingSDDSNames(&inputPage, matchColumn, matchColumns, &inputColumns, SDDS_MATCH_COLUMN); else { if (!(inputColumnName=(char**)SDDS_GetColumnNames(&inputPage, &inputColumns))) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); } inputDoubleColumns=0; inputStringColumns=0; inputDoubleColumnName=(char**)malloc(inputColumns*sizeof(char*)); inputStringColumnName=(char**)malloc(inputColumns*sizeof(char*)); inputRows = 0; /*********** \ * read data * \***********/ while (0<SDDS_ReadTable(&inputPage)) { ipage ++; #if defined(DEBUG) fprintf(stderr, "working on page %ld\n", ipage); #endif if (ipage==1) { SDDS_DeferSavingLayout(1); if( !SDDS_SetColumnFlags(&inputPage, 0)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); /* count the string and numerical columns in the input file */ for (i=0;i<inputColumns;i++) { if ( SDDS_NUMERIC_TYPE( columnType = SDDS_GetColumnType( &inputPage, i))) { inputDoubleColumnName[inputDoubleColumns]=inputColumnName[i]; inputDoubleColumns++; } } for (i=0; i<inputPage.layout.n_columns; i++) { if (inputPage.layout.column_definition[i].type == SDDS_STRING ) { inputStringColumnName[inputStringColumns] = inputPage.layout.column_definition[i].name; inputStringColumns++; } } if( !(inputRows=SDDS_CountRowsOfInterest(&inputPage))) SDDS_Bomb("No rows in dataset."); } else { /* these statements are executed on the subsequent pages */ if (inputRows != SDDS_CountRowsOfInterest(&inputPage)) { SDDS_Bomb("Datasets don't have the same number of rows.\nProcessing stopped before reaching the end of the input file."); } } #if defined(DEBUG) fprintf(stderr, "row flags set\n"); #endif if (inputDoubleColumns == 0) SDDS_Bomb("No numerical columns in file."); if ((ipage==1) && verbose) { fprintf(stderr, "No. of double/float/integer columns: %ld.\n", inputDoubleColumns); fprintf(stderr, "No. of string columns: %ld.\n", inputStringColumns); fprintf(stderr, "No. of rows: %ld.\n", inputRows); } /****************\ * transpose data * \****************/ if (inputDoubleColumns) { if (ipage == 1) { m_alloc(&RInv, inputRows, inputDoubleColumns); m_alloc(&R, inputDoubleColumns, inputRows); } for (col=0;col<inputDoubleColumns;col++){ if (!(R->a[col]=(double*)SDDS_GetColumnInDoubles(&inputPage, inputDoubleColumnName[col]))) { SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (verbose) { m_show(R, "%9.6le ", "Transpose of input matrix:\n", stdout); } m_trans(RInv, R); } /***************************\ * determine existence of * * transposed string columns * \***************************/ if (ipage == 1) { OldStringColumnsDefined=0; switch(SDDS_CheckParameter(&inputPage, OLD_STRING_COLUMN_NAMES, NULL, SDDS_STRING, NULL)){ case SDDS_CHECK_OKAY: OldStringColumnsDefined=1; break; case SDDS_CHECK_NONEXISTENT: break; case SDDS_CHECK_WRONGTYPE: case SDDS_CHECK_WRONGUNITS: fprintf(stderr, "Something wrong with parameter OldStringColumns.\n"); exit(1); break; } if (OldStringColumnsDefined){ /* decompose OldStringColumns into names of string columns for the output file */ if (!SDDS_GetParameter(&inputPage, OLD_STRING_COLUMN_NAMES, &inputStringRows)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (verbose) { fprintf(stderr, "Parameter OldStringColumns: %s.\n", inputStringRows); } outputStringColumnName=(char**)malloc(sizeof(char*)); outputStringColumns=0; buffer_size=BUFFER_SIZE_INCREMENT; buffer=(char*)malloc(sizeof(char)*buffer_size); while ( 0 <= (token_length = SDDS_GetToken(inputStringRows, buffer, BUFFER_SIZE_INCREMENT))){ if (!token_length) SDDS_Bomb("A null string was detected in parameter OldStringColumns.\n"); if (!SDDS_CopyString(&outputStringColumnName[outputStringColumns], buffer)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (verbose) { fprintf(stderr, "Output string column: %s\n", outputStringColumnName[outputStringColumns]); } outputStringColumns++; } } } /*********************\ * define output page * \*********************/ if ( ipage == 1 ) { outputRows = inputDoubleColumns; outputDoubleColumns = inputRows; if (inputDescription){ outputDescription = (char*) malloc( sizeof(char) * (strlen("Transpose of ") + strlen(inputDescription) + 1)); strcat(strcpy(outputDescription, "Transpose of "), inputDescription); if (!SDDS_InitializeOutput(&outputPage, ascii?SDDS_ASCII:SDDS_BINARY, 1, outputDescription, inputContents, outputfile)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { if (!SDDS_InitializeOutput(&outputPage, ascii?SDDS_ASCII:SDDS_BINARY, 1, NULL, NULL, outputfile)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (columnMajorOrder!=-1) outputPage.layout.data_mode.column_major = columnMajorOrder; else outputPage.layout.data_mode.column_major = inputPage.layout.data_mode.column_major; /***********************************\ * define names for double columns * \***********************************/ if (!Root && inputStringColumns ) { /* use specified string column, or first string column encountered */ if (!newColumnNamesColumn) /* first string column encountered */ outputDoubleColumnName = (char**) SDDS_GetColumn(&inputPage, inputStringColumnName[0]); else { /* use specified string column */ if (SDDS_CheckColumn(&inputPage, newColumnNamesColumn, NULL, SDDS_STRING, stderr)!=SDDS_CHECK_OKAY) SDDS_Bomb("column named with -newColumnNames does not exist in input"); outputDoubleColumnName = (char**)SDDS_GetColumn(&inputPage, newColumnNamesColumn); } for (i=1; i<inputRows; i++) { if (match_string(outputDoubleColumnName[i-1], outputDoubleColumnName+i, inputRows-i, EXACT_MATCH)>=0) { fprintf(stderr, "Error, duplicate %s found in input file string column %s, can not be used as output column names\n", outputDoubleColumnName[i-1], newColumnNamesColumn ? newColumnNamesColumn : inputStringColumnName[0]); exit(1); } } } else { /* use command line options to produce column names in the output file */ outputDoubleColumnName = (char**) malloc( outputDoubleColumns * sizeof(char*) ); digits = MAX(digits, log10(inputRows) + 1); if (!Root){ Root = (char*) malloc( sizeof(char) * (strlen("Column")+1) ); strcpy(Root, "Column"); } if (outputDoubleColumns!=1) { for ( i=0; i < outputDoubleColumns; i++){ outputDoubleColumnName[i] = (char*) malloc( sizeof(char) * (strlen(Root)+digits+1)); sprintf(format, "%s%%0%ldld", Root, digits); sprintf(outputDoubleColumnName[i], format, i); } } else {/* only one row to transpose */ outputDoubleColumnName[0] = (char*) malloc( sizeof(char) * (strlen(Root)+1)); strcpy( outputDoubleColumnName[0], Root); } } /*************************\ * define string columns * \*************************/ if (OldStringColumnsDefined) { if (!SDDS_DefineSimpleColumns(&outputPage, outputStringColumns, outputStringColumnName, NULL, SDDS_STRING)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { /* by default there should be at least one string column, that of the old column names. */ if (!noOldColumnNamesColumn) { outputStringColumns = 1; outputStringColumnName = (char**) malloc( sizeof(char*)); if (oldColumnNames) { /* commanline option specification */ outputStringColumnName[0] = oldColumnNames; } else { outputStringColumnName[0] = (char*) malloc( sizeof(char) * (strlen("OldColumnNames") + 1)); strcpy(outputStringColumnName[0], "OldColumnNames"); } if ( 0 > SDDS_DefineColumn(&outputPage, outputStringColumnName[0], NULL, NULL, NULL, NULL, SDDS_STRING, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (indexColumn && !SDDS_DefineSimpleColumn(&outputPage, "Index", NULL, SDDS_LONG)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); /*************************\ * define double columns * \*************************/ for ( i=0; i < outputDoubleColumns; i++) if (Symbol){ if (0>SDDS_DefineColumn(&outputPage, outputDoubleColumnName[i], Symbol, NULL, NULL, NULL, SDDS_DOUBLE, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { if (0>SDDS_DefineColumn(&outputPage, outputDoubleColumnName[i], NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } /********************************\ * define string parameters * * i.e. transposed string columns * \********************************/ if ( inputStringColumns>1 ) { if (0>SDDS_DefineParameter(&outputPage, OLD_STRING_COLUMN_NAMES, NULL, NULL, "Transposed string columns", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); for ( i=0; i < inputStringColumns; i++){ if (0>SDDS_DefineParameter(&outputPage, inputStringColumnName[i], NULL, NULL, "Transposed string column data", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } /*************************\ * transfer parameters not * * associated with old * * string columns * \*************************/ if (inputParameters) { for ( i=0; i < inputParameters; i++) { if ( (0 > match_string(inputParameterName[i], outputStringColumnName, outputStringColumns, 0) && strcasecmp(inputParameterName[i], OLD_STRING_COLUMN_NAMES))) if ( 0 > SDDS_TransferParameterDefinition(&outputPage, &inputPage, inputParameterName[i], NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } /***************\ * write layout * \***************/ SDDS_DeferSavingLayout(0); /* if InputFile is not already transfered ot the output file, then create it. */ switch( SDDS_CheckParameter(&outputPage, "InputFile", NULL, SDDS_STRING, NULL) ) { case SDDS_CHECK_NONEXISTENT: if (0>SDDS_DefineParameter(&outputPage, "InputFile", NULL, NULL, "Original matrix file", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; default: break; } if (!SDDS_WriteLayout(&outputPage) ) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "table layout defined\n"); #endif if (!SDDS_StartTable(&outputPage, outputRows) ) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (ipage == 1) { if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, "InputFile", inputfile?inputfile:"pipe", NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } /***************************************\ * assign string columns from input * * to string parameters in output * \**************************************/ if ( inputStringColumns > 1) { for ( i=0; i < inputStringColumns; i++){ columnOfStrings = (char**) SDDS_GetColumn(&inputPage, inputStringColumnName[i]); stringParameter = JoinStrings(columnOfStrings, inputRows, BUFFER_SIZE_INCREMENT); if ( !SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, inputStringColumnName[i], stringParameter, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); free(columnOfStrings); free(stringParameter); } outputStringRows = JoinStrings(inputStringColumnName, inputStringColumns, BUFFER_SIZE_INCREMENT); if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, OLD_STRING_COLUMN_NAMES, outputStringRows, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "string parameters assigned\n"); #endif if (inputParameters){ for ( i=0; i < inputParameters; i++){ if ( (0 > match_string(inputParameterName[i], outputStringColumnName, outputStringColumns, 0) && strcasecmp(inputParameterName[i], OLD_STRING_COLUMN_NAMES))) { parameterPointer = (void*) SDDS_GetParameter(&inputPage, inputParameterName[i], NULL); if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, inputParameterName[i], parameterPointer, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); free(parameterPointer); } } } #if defined(DEBUG) fprintf(stderr, "input parameters assigned\n"); #endif /**********************************\ * assign data to * * output table part of data set * \**********************************/ if (outputRows) { /***************************\ * assign string column data * \***************************/ if (OldStringColumnsDefined){ for ( i=0 ; i < outputStringColumns; i++){ if (!SDDS_GetParameter(&inputPage, outputStringColumnName[i], &stringParameter)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); stringArray=TokenizeString(stringParameter, outputRows); if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, stringArray, outputRows, outputStringColumnName[i])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } else { if (!noOldColumnNamesColumn && !SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, inputDoubleColumnName, outputRows, outputStringColumnName[0])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "string data columns assigned\n"); #endif /***************************\ * assign double column data * \***************************/ for ( i=0 ; i < outputDoubleColumns; i++) /* i is the row index */ if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, RInv->a[i], outputRows, outputDoubleColumnName[i])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (indexColumn) { for (i=0; i<outputRows; i++) if (!SDDS_SetRowValues(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, i, "Index", i, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "double data columns assigned\n"); #endif } #if defined(DEBUG) fprintf(stderr, "data assigned\n"); #endif if (!SDDS_WriteTable(&outputPage)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); #if defined(DEBUG) fprintf(stderr, "data written out\n"); #endif } if (inputDoubleColumns) { m_free(&RInv); m_free(&R); } if (inputColumnName) { SDDS_FreeStringArray(inputColumnName, inputColumns); free(inputColumnName); } if (inputStringColumns) free(inputStringColumnName); if (inputDescription) free(inputDescription); if (inputParameterName) { SDDS_FreeStringArray(inputParameterName, inputParameters); free(inputParameterName); } if (outputDoubleColumns) { SDDS_FreeStringArray(outputDoubleColumnName, outputDoubleColumns); free(outputDoubleColumnName); } if (!SDDS_Terminate(&inputPage) || !SDDS_Terminate(&outputPage)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (tmpfile_used && !replaceFileAndBackUp(inputfile, outputfile)) exit(1); return(0); }
int main(int argc, char **argv) { SDDS_DATASET SDDS_1, SDDS_2, SDDS_output; long i, j, i_arg, rows1, rows2, reuse, reusePage, i1, i2; SCANNED_ARG *s_arg; char s[200], *ptr; char **match_column, **equate_column; long match_columns, equate_columns; char *input1, *input2, *output; long tmpfile_used, retval1, retval2; long warnings, invert; unsigned long pipeFlags; KEYED_EQUIVALENT **keyGroup=NULL; long keyGroups=0; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&s_arg, argc, argv); if (argc<3) bomb(NULL, USAGE); input1 = input2 = output = NULL; match_column = equate_column = NULL; match_columns = equate_columns = reuse = reusePage = 0; tmpfile_used = invert = 0; warnings = 1; pipeFlags = 0; for (i_arg=1; i_arg<argc; i_arg++) { if (s_arg[i_arg].arg_type==OPTION) { delete_chars(s_arg[i_arg].list[0], "_"); switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) { case SET_MATCH_COLUMN: if (s_arg[i_arg].n_items!=2) SDDS_Bomb("invalid -match syntax"); if (match_columns!=0) SDDS_Bomb("only one -match option may be given"); match_column = tmalloc(sizeof(*match_column)*2); if ((ptr=strchr(s_arg[i_arg].list[1], '='))) *ptr++ = 0; else ptr = s_arg[i_arg].list[1]; match_column[0] = s_arg[i_arg].list[1]; match_column[1] = ptr; match_columns = 1; break; case SET_EQUATE_COLUMN: if (s_arg[i_arg].n_items!=2) SDDS_Bomb("invalid -equate syntax"); if (equate_columns!=0) SDDS_Bomb("only one -equate option may be given"); equate_column = tmalloc(sizeof(*equate_column)*2); if ((ptr=strchr(s_arg[i_arg].list[1], '='))) *ptr++ = 0; else ptr = s_arg[i_arg].list[1]; equate_column[0] = s_arg[i_arg].list[1]; equate_column[1] = ptr; equate_columns = 1; break; case SET_REUSE: if (s_arg[i_arg].n_items==1) reuse = 1; else { char *reuseOptions[2] = {"rows", "page"}; for (i=1; i<s_arg[i_arg].n_items; i++) { switch (match_string(s_arg[i_arg].list[i], reuseOptions, 2, 0)) { case 0: reuse = 1; break; case 1: reusePage = 1; break; default: SDDS_Bomb("unknown reuse keyword"); break; } } } break; case SET_INVERT: invert = 1; break; case SET_NOWARNINGS: warnings = 0; break; case SET_PIPE: if (!processPipeOption(s_arg[i_arg].list+1, s_arg[i_arg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; default: fprintf(stderr, "error: unknown switch: %s\n", s_arg[i_arg].list[0]); SDDS_Bomb(NULL); break; } } else { if (input1==NULL) input1 = s_arg[i_arg].list[0]; else if (input2==NULL) input2 = s_arg[i_arg].list[0]; else if (output==NULL) output = s_arg[i_arg].list[0]; else SDDS_Bomb("too many filenames"); } } if (pipeFlags&USE_STDIN && input1) { if (output) SDDS_Bomb("too many filenames (sddsxref)"); output = input2; input2 = input1; input1 = NULL; } processFilenames("sddsselect", &input1, &output, pipeFlags, !warnings, &tmpfile_used); if (!input2) SDDS_Bomb("second input file not specified (sddsxref)"); if (equate_columns && match_columns) SDDS_Bomb("only one of -equate or -match may be given"); if (!equate_columns && !match_columns) SDDS_Bomb("one of -equate or -match must be given"); if (!SDDS_InitializeInput(&SDDS_1, input1)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (!SDDS_InitializeInput(&SDDS_2, input2)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (match_columns) { if ((j=SDDS_GetColumnIndex(&SDDS_1, match_column[0]))<0 || SDDS_GetColumnType(&SDDS_1, j)!=SDDS_STRING) { sprintf(s, "error: column %s not found or not string type in file %s", match_column[0], input1?input1:"stdin"); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if ((j=SDDS_GetColumnIndex(&SDDS_2, match_column[1]))<0 || SDDS_GetColumnType(&SDDS_2, j)!=SDDS_STRING) { sprintf(s, "error: column %s not found or not string type in file %s", match_column[1], input2); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (equate_columns) { if ((j=SDDS_GetColumnIndex(&SDDS_1, equate_column[0]))<0 || !SDDS_NUMERIC_TYPE(SDDS_GetColumnType(&SDDS_1, j))) { sprintf(s, "error: column %s not found or not numeric type in file %s", equate_column[0], input1?input1:"stdin"); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if ((j=SDDS_GetColumnIndex(&SDDS_2, equate_column[1]))<0 || !SDDS_NUMERIC_TYPE(SDDS_GetColumnType(&SDDS_2, j))) { sprintf(s, "error: column %s not found or not numeric type in file %s", equate_column[1], input2); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (output && pipeFlags&USE_STDOUT) SDDS_Bomb("too many filenames with -pipe option"); if (!output && !(pipeFlags&USE_STDOUT)) { if (warnings) fprintf(stderr, "warning: existing file %s will be replaced (sddsselect)\n", input1?input1:"stdin"); tmpfile_used = 1; cp_str(&output, tmpname(NULL)); } if (!SDDS_InitializeCopy(&SDDS_output, &SDDS_1, output, "w")) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (!SDDS_WriteLayout(&SDDS_output)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); while ((retval1=SDDS_ReadPage(&SDDS_1))>0) { if (!reusePage) { if ((retval2=SDDS_ReadPage(&SDDS_2))<=0) { if (warnings) fprintf(stderr, "warning: <input2> ends before <input1>\n"); if (invert) { /* nothing to match, so everything would normally be thrown out */ if (!SDDS_CopyPage(&SDDS_output, &SDDS_1) || !SDDS_WritePage(&SDDS_output)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); continue; } else /* nothing to match, so everything thrown out */ break; } } else { if (retval1==1 && (retval2=SDDS_ReadPage(&SDDS_2))<=0) SDDS_Bomb("<input2> has no data"); SDDS_SetRowFlags(&SDDS_2, 1); } rows1 = SDDS_CountRowsOfInterest(&SDDS_1); rows2 = SDDS_CountRowsOfInterest(&SDDS_2); if (!SDDS_StartPage(&SDDS_output, rows1)) { SDDS_SetError("Problem starting output page"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_CopyParameters(&SDDS_output, &SDDS_2) || !SDDS_CopyArrays(&SDDS_output, &SDDS_2)) { SDDS_SetError("Problem copying parameter or array data from second input file"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_CopyParameters(&SDDS_output, &SDDS_1) || !SDDS_CopyArrays(&SDDS_output, &SDDS_1)) { SDDS_SetError("Problem copying parameter or array data from first input file"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (match_columns) { char **string1, **string2; long matched; string2 = NULL; if (!(string1 = SDDS_GetColumn(&SDDS_1, match_column[0]))) { fprintf(stderr, "Error: problem getting column %s from file %s\n", match_column[0], input1?input1:"stdin"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (rows2 && !(string2 = SDDS_GetColumn(&SDDS_2, match_column[1]))) { fprintf(stderr, "Error: problem getting column %s from file %s\n", match_column[1], input2); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (rows2) keyGroup = MakeSortedKeyGroups(&keyGroups, SDDS_STRING, string2, rows2); for (i1=0; i1<rows1; i1++) { if (!SDDS_CopyRowDirect(&SDDS_output, i1, &SDDS_1, i1)) { sprintf(s, "Problem copying row %ld of first data set", i1); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } matched = 0; if (rows2 &&(i2 = FindMatchingKeyGroup(keyGroup, keyGroups, SDDS_STRING, string1+i1, reuse))>=0) { matched = 1; } if ((!matched && !invert) || (matched && invert)) { if (!SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, i1, i1, 0)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (string1) { for (i=0;i<rows1;i++) free(string1[i]); free(string1); string1 = NULL; } if (string2) { for (i=0;i<rows2;i++) free(string2[i]); free(string2); string2 = NULL; } for (i=0;i<keyGroups;i++) { if (keyGroup[i]) { if (keyGroup[i]->equivalent) free(keyGroup[i]->equivalent); free(keyGroup[i]); keyGroup[i] = NULL; } } if (keyGroups) { free(keyGroup); keyGroup = NULL; keyGroups = 0; } } else if (equate_columns) { double *value1, *value2; long equated; value2 = NULL; if (!(value1 = SDDS_GetColumnInDoubles(&SDDS_1, equate_column[0]))) { fprintf(stderr, "Error: problem getting column %s from file %s\n", equate_column[0], input1?input1:"stdin"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (rows2 && !(value2 = SDDS_GetColumnInDoubles(&SDDS_2, equate_column[1]))) { fprintf(stderr, "Error: problem getting column %s from file %s\n", equate_column[1], input2); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (rows2) keyGroup = MakeSortedKeyGroups(&keyGroups, SDDS_DOUBLE, value2, rows2); for (i1=0; i1<rows1; i1++) { if (!SDDS_CopyRowDirect(&SDDS_output, i1, &SDDS_1, i1)) { sprintf(s, "Problem copying row %ld of first data set", i1); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } equated = 0; if (rows2 && (i2 = FindMatchingKeyGroup(keyGroup, keyGroups, SDDS_DOUBLE, value1+i1, reuse))>=0) { equated = 1; } if ((!equated && !invert) || (equated && invert)) { if (!SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, i1, i1, 0)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (value1) free(value1); value1 = NULL; if (rows2 && value2) free(value2); value2 = NULL; for (i=0;i<keyGroups;i++) { if (keyGroup[i]) { if (keyGroup[i]->equivalent) free(keyGroup[i]->equivalent); free(keyGroup[i]); keyGroup[i] = NULL; } } if (keyGroups) { free(keyGroup); keyGroup = NULL; keyGroups = 0; } } if (!SDDS_WritePage(&SDDS_output)) { SDDS_SetError("Problem writing data to output file"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (!SDDS_Terminate(&SDDS_1) || !SDDS_Terminate(&SDDS_2) || !SDDS_Terminate(&SDDS_output)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (tmpfile_used && !replaceFileAndBackUp(input1, output)) exit(1); free_scanargs(&s_arg,argc); if (match_columns) free(match_column); return(0); }
void run_rpn_load(NAMELIST_TEXT *nltext, RUN *run) { SDDS_DATASET SDDSin; long code, foundPage, iColumn, matchRow, rows, iParameter; int32_t columns, parameters; char *parameterValue = NULL; double *data, data1; char **columnName, **matchColumnData, *memName = NULL; char **parameterName; /* process the namelist text */ set_namelist_processing_flags(STICKY_NAMELIST_DEFAULTS); set_print_namelist_flags(0); if (processNamelist(&rpn_load, nltext)==NAMELIST_ERROR) bombElegant(NULL, NULL); if (echoNamelists) print_namelist(stdout, &rpn_load); if (match_column && strlen(match_column)) { if (use_row!=-1) { fprintf(stdout, "Error: you asked to match a column and also gave use_row.\n"); exitElegant(1); } if (!match_column_value || !strlen(match_column_value)) { fprintf(stdout, "Error: you must give match_column_value with match_column\n"); exitElegant(1); } } if (match_parameter && strlen(match_parameter)) { if (use_page!=-1) { fprintf(stdout, "Error: you asked to match a parameter and also gave use_page.\n"); exitElegant(1); } if (!match_parameter_value || !strlen(match_parameter_value)) { fprintf(stdout, "Error: you must give match_parameter_value with match_parameter\n"); exitElegant(1); } } if (!filename || !strlen(filename)) { fprintf(stdout, "Error: no filename given for rpn_load.\n"); exitElegant(1); } filename = compose_filename(filename, run->rootname); if (!SDDS_InitializeInputFromSearchPath(&SDDSin, filename)) { fprintf(stdout, "Error: couldn't initialize SDDS input for %s\n", filename); exitElegant(1); } foundPage = 0; while ((code=SDDS_ReadPage(&SDDSin))>0) { if (use_page>0) { if (code==use_page) { foundPage = 1; break; } continue; } if (match_parameter && strlen(match_parameter)) { if (!(parameterValue=SDDS_GetParameterAsString(&SDDSin, match_parameter, NULL))) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!wild_match(parameterValue, match_parameter_value)) continue; foundPage = 1; break; } if (use_page==-1 && SDDS_CheckEndOfFile(&SDDSin)==1) { foundPage = 1; break; } } if (!foundPage) { fprintf(stdout, "Error: no appropriate page found\n"); exitElegant(1); } if (!load_parameters) { if ((columnName = SDDS_GetColumnNames(&SDDSin, &columns))==NULL) { fprintf(stdout, "Warning: No columns in file!\n"); return; } rows = SDDS_RowCount(&SDDSin); matchRow = rows-1; if (use_row!=-1) { if (use_row>=rows) { fprintf(stdout, "Error: number of rows in file (%ld) less than needed for use_row=%ld\n", rows, use_row); exitElegant(1); } matchRow = use_row; } if (match_column) { if (SDDS_GetNamedColumnType(&SDDSin, match_column)!=SDDS_STRING) { fprintf(stdout, "Error: column %s nonexistent or not string type.\n", match_column); exitElegant(1); } if (!(matchColumnData=SDDS_GetColumn(&SDDSin, match_column))) { fprintf(stdout, "Error: unable to get data for column %s\n", match_column); exitElegant(1); } if (matching_row_number<0) { /* use last match */ for (matchRow=rows-1; matchRow>=0; matchRow--) if (wild_match(matchColumnData[matchRow], match_column_value)) break; } else { /* use nth match */ for (matchRow=0; matchRow<rows; matchRow++) if (wild_match(matchColumnData[matchRow], match_column_value) && matching_row_number-- == 0) break; } if (matchRow<0 || matchRow>=rows) { fprintf(stdout, "Error: unable to find match for %s in column %s\n", match_column_value, match_column); exitElegant(1); } SDDS_FreeStringArray(matchColumnData, rows); } for (iColumn=0; iColumn<columns; iColumn++) { switch (SDDS_GetNamedColumnType(&SDDSin, columnName[iColumn])) { case SDDS_CHARACTER: case SDDS_STRING: break; default: if (!(data=SDDS_GetColumnInDoubles(&SDDSin, columnName[iColumn]))) { fprintf(stdout, "Error: unable to get data for column %s as numerical data.\n", columnName[iColumn]); exitElegant(1); } if (!(memName=SDDS_Realloc(memName, sizeof(*memName)*((tag?strlen(tag):0)+strlen(columnName[iColumn])+2)))) { fprintf(stdout, "Memory allocation failure trying to create memory name for loaded data\n"); exitElegant(1); } if (tag && strlen(tag)) sprintf(memName, "%s.%s", tag, columnName[iColumn]); else sprintf(memName, "%s", columnName[iColumn]); rpn_store(data[matchRow], NULL, rpn_create_mem(memName, 0)); fprintf(stdout, "%le --> %s\n", data[matchRow], memName); free(columnName[iColumn]); free(data); } } if (memName) free(memName); if (columnName) free(columnName); } else { /* load data from parameters */ if ((parameterName = SDDS_GetParameterNames(&SDDSin, ¶meters))==NULL) { fprintf(stdout, "Warning: No parameters in file!\n"); return; } for (iParameter=0; iParameter<parameters; iParameter++) { switch (SDDS_GetNamedParameterType(&SDDSin, parameterName[iParameter])) { case SDDS_CHARACTER: case SDDS_STRING: break; default: if (!SDDS_GetParameterAsDouble(&SDDSin, parameterName[iParameter], &data1)) { fprintf(stdout, "Error: unable to get data for parameter %s as numerical data.\n", parameterName[iParameter]); exitElegant(1); } if (!(memName=SDDS_Realloc(memName, sizeof(*memName)*((tag?strlen(tag):0)+strlen(parameterName[iParameter])+2)))) { fprintf(stdout, "Memory allocation failure trying to create memory name for loaded data\n"); exitElegant(1); } if (tag && strlen(tag)) sprintf(memName, "%s.%s", tag, parameterName[iParameter]); else sprintf(memName, "%s", parameterName[iParameter]); rpn_store(data1, NULL, rpn_create_mem(memName, 0)); fprintf(stdout, "%le --> %s\n", data1, memName); free(parameterName[iParameter]); } } if (memName) free(memName); if (parameterName) free(parameterName); } }