struct Block * normalize(struct Block * block, struct Block * opt) { const char * column_name = get_attribute_value_as_string(opt, "column_name"); double multiple = 1; struct Attribute * multiple_attr = get_attribute_by_name(opt, "multiple"); if (multiple_attr != NULL && multiple_attr->type == TYPE_FLOAT) { if (multiple_attr->value_length == 4) multiple = *(float*)attribute_get_value(multiple_attr); if (multiple_attr->value_length == 8) multiple = *(double*)attribute_get_value(multiple_attr); } int column_id = get_column_id_by_name_or_exit(block, (char*)column_name); if (column_id == -1) { fprintf(stderr, "normalize called on '%s' field, wasn't found\n", column_name); return block; } struct Column * column = get_column(block, column_id); if (column->type != TYPE_FLOAT) { fprintf(stderr, "normalize called on '%s' field, which is of type '%s' (only supports floating point)\n", column_name, get_type_name(column->type, column->bsize)); return block; } char temp[100]; snprintf(temp, sizeof(temp), "normalize(column:\"%s\")", column_name); block = add_string_attribute(block, "command", temp); double min = DBL_MAX; double max = -DBL_MAX; int32_t i; for (i = 0 ; i < block->num_rows ; i++) { double value = get_cell_as_double(block, i, column_id); if (value < min) min = value; if (value > max) max = value; } for (i = 0 ; i < block->num_rows ; i++) { double value = get_cell_as_double(block, i, column_id); value = (value-min) / (max-min) * multiple; set_cell_from_double(block, i, column_id, value); } return block; }
/** * Write to the console details of the dropped node * @param d the dom in question * @param r the node we are dropping * @param n the parent node */ static void dom_drop_notify( dom *d, node *r, node *n ) { warning("dom: dropping %s at %d:%d - %s and %s incompatible\n", node_name(r),node_offset(r), node_end(r),node_html_name(r),node_html_name(n)); attribute *id = node_get_attribute( r, "id" ); if ( id != NULL ) { char *value = attribute_get_value( id ); if ( value[strlen(value)-1]=='b' ) printf( "aha! dropping id %s\n",value ); } node_dispose( r ); }
/** * Does the given attribute exist in the given list of attributes? * @param a the attribute to test * @param attrs the expat list of attributes (name, value pairs) * @return 1 if present, else 0 */ int attribute_present( attr1bute *a, char **attrs ) { int i = 0; int res = 0; while ( attrs[i] != NULL ) { if ( strcmp(attrs[i],attribute_get_name(a))==0 &&strcmp(attrs[i+1],attribute_get_value(a))==0 ) { res = 1; break; } i += 2; } return res; }
/** * Remove an attribute from a copy of the expat attribute list * @param a the attribute to apply to he list * @param attrs the copy of the expat attribute list (updated) */ void attribute_remove( attr1bute *a, char **attrs ) { int i = 0; while ( attrs[i] != NULL ) { if ( strcmp(attribute_get_name(a),attrs[i])==0 && strcmp(attribute_get_value(a),attrs[i+1])==0 ) { free( attrs[i] ); free( attrs[i+1] ); int j = i; while ( attrs[j] != NULL ) { attrs[j] = attrs[j+2]; attrs[j+1] = attrs[j+3]; j+=2; } break; } i += 2; } }
int main(int argc, char ** argv) { if (stdout_is_piped()) // other wise you don't see the seg fault setup_segfault_handling(argv); assert_stdin_is_piped(); assert_stdout_is_piped(); //assert_stdin_or_out_is_piped(); static char remove_attributes_all[1000] = ""; static char int_attributes_all[1000] = ""; static int debug = 0; struct Params * params = NULL; params = add_string_param(params, "remove", 'r', remove_attributes_all, 0); params = add_string_param(params, "makeint", 'i', int_attributes_all, 0); params = add_flag_param(params, "debug", 'd', &debug, 0); char remove_attributes_copy[1000] = ""; strncpy(remove_attributes_copy, remove_attributes_all, 1000); char int_attributes_copy[1000] = ""; strncpy(int_attributes_copy, int_attributes_all, 1000); int num_remove_attributes = 0; char ** remove_attributes = NULL; char * pch = strtok(remove_attributes_all, ","); while (pch != NULL) { num_remove_attributes++; remove_attributes = realloc(remove_attributes, sizeof(char*)*num_remove_attributes); remove_attributes[num_remove_attributes-1] = pch; pch = strtok(NULL, ","); } int num_int_attributes = 0; char ** int_attributes = NULL; pch = strtok(int_attributes_all, ","); while (pch != NULL) { num_int_attributes++; int_attributes = realloc(int_attributes, sizeof(char*)*num_int_attributes); int_attributes[num_int_attributes-1] = pch; pch = strtok(NULL, ","); } int i,j; struct Block * block = NULL; while ((block = read_block(stdin))) { struct Block * newblock = new_block(); newblock = copy_all_attributes(newblock, block); if (remove_attributes_copy[0] != 0) newblock = add_string_attribute(newblock, "remove attributes", remove_attributes_copy); if (int_attributes_copy[0] != 0) newblock = add_string_attribute(newblock, "convert attributes to int", int_attributes_copy); int num_remove_attribute_ids = 0; int * remove_attribute_ids = NULL; for (i = 0 ; i < block->num_attributes ; i++) { struct Attribute * attr = get_attribute(block, i); for (j = 0 ; j < num_remove_attributes ; j++) { // fprintf(stderr, "%s(%d(%d)) vs %s(%d) = %d\n", // attribute_get_name(attr), attr->name_length, strlen(attribute_get_name(attr)), // remove_attributes[j], strlen(remove_attributes[j]), // strcmp(attribute_get_name(attr), remove_attributes[j])); if (strcmp(attribute_get_name(attr), remove_attributes[j])==0) break; } if (j == num_remove_attributes) // not a attribute to be removed { //fprintf(stderr, "%d: %s (%d) - do not remove\n", i, attribute_get_name(attr), strlen(attribute_get_name(attr))); for (j = 0 ; j < num_int_attributes ; j++) if (strcmp(attribute_get_name(attr), int_attributes[j])==0) break; if (j == num_int_attributes) { num_remove_attribute_ids++; remove_attribute_ids = realloc(remove_attribute_ids, sizeof(int)*num_remove_attribute_ids); remove_attribute_ids[num_remove_attribute_ids-1] = i; newblock = _add_attribute(newblock, attr->type, attr->value_length, attribute_get_name(attr), attribute_get_value(attr)); } } } int num_int_attribute_ids = 0; int * int_attribute_ids = NULL; for (i = 0 ; i < block->num_attributes ; i++) { struct Attribute * attr = get_attribute(block, i); for (j = 0 ; j < num_int_attributes ; j++) if (strcmp(attribute_get_name(attr), int_attributes[j])==0) break; if (j != num_int_attributes) { num_int_attribute_ids++; int_attribute_ids = realloc(int_attribute_ids, sizeof(int)*num_int_attribute_ids); int_attribute_ids[num_int_attribute_ids-1] = i; newblock = add_int32_attribute(newblock, attribute_get_name(attr), *(int32_t*)attribute_get_value(attr)); } } newblock = set_num_rows(newblock, block->num_rows); for (i = 0 ; i < newblock->num_rows ; i++) { for (j = 0 ; j < num_remove_attribute_ids ; j++) { void * dst = get_cell(newblock, i, j); void * src = get_cell(block, i, remove_attribute_ids[j]); struct Attribute * attr = get_attribute(block, remove_attribute_ids[j]); memcpy(dst, src, attr->value_length); } for (j = 0 ; j < num_int_attribute_ids ; j++) { set_cell_from_int32(newblock, i, j + num_remove_attribute_ids, get_cell_as_int32(block, i, int_attribute_ids[j])); } } free(remove_attribute_ids); free(int_attribute_ids); write_block(stdout, newblock); free_block(newblock); free_block(block); } }