static void parse_success(const char *url,
const char *user,
const char *password,
const char *host,
int port,
const char *vhost)
{
char *s = strdup(url);
struct amqp_uri *uri = alloc_amqp_uri();
int res;
res = amqp_uri_parse(uri,s);
if (!res) {
fprintf(stderr,
"Expected to successfully parse URL, but didn't: %s (%s)\n",
url, amqp_error_string2(res));
abort();
}
match_string("user", user, uri->user);
match_string("password", password, uri->password);
host_port_t *hp = (host_port_t *)uri->host_port_array.elts;
match_string("host", host, hp->host);
match_int("port", port, hp->port);
match_string("vhost", vhost, uri->vhost);
free(s);
free_amqp_uri(uri);
}
bool
ChatQueryHandler::matchedProjection (const Json::Value &root,
const std::string &projection)
{
ChatProjectionParser parser;
parser.parse (projection);
return
match_string (parser.originator_, root["originator"].asString ())
&& match_string (parser.group_id_, root["group_id"].asString ())
&& match_string (parser.text_, root["text"].asString ())
&& match_real (parser.latitude_min_, root["latitude"].asDouble (), true)
&& match_real (parser.latitude_max_, root["latitude"].asDouble (), false)
&& match_real (parser.longitude_min_, root["longitude"].asDouble (), true)
&& match_real (parser.longitude_max_, root["longitude"].asDouble (), false)
&& match_string (parser.uuid_, root["uuid"].asString ())
&& match_int (parser.pending_receipts_min_, root["pending_receipts"].asInt (), true)
&& match_int (parser.pending_receipts_max_, root["pending_receipts"].asInt (), false)
&& match_int (parser.media_count_min_, root["media_count"].asInt (), true)
&& match_int (parser.media_count_max_, root["media_count"].asInt (), false)
&& match_int (parser.status_min_, root["status"].asInt (), true)
&& match_int (parser.status_max_, root["status"].asInt (), false)
&& match_int (parser.created_date_min_, root["created_date"].asInt (), true)
&& match_int (parser.created_date_max_, root["created_date"].asInt (), false)
&& match_int (parser.modified_date_min_, root["modified_date"].asInt (), true)
&& match_int (parser.modified_date_max_, root["modified_date"].asInt (), false);
}
static void parse_success(const char *url,
const char *user,
const char *password,
const char *host,
int port,
const char *vhost)
{
char *s = strdup(url);
struct amqp_connection_info ci;
int res;
amqp_default_connection_info(&ci);
res = amqp_parse_url(s, &ci);
if (res) {
fprintf(stderr,
"Expected to successfully parse URL, but didn't: %s (%s)\n",
url, amqp_error_string2(res));
abort();
}
match_string("user", user, ci.user);
match_string("password", password, ci.password);
match_string("host", host, ci.host);
match_int("port", port, ci.port);
match_string("vhost", vhost, ci.vhost);
free(s);
}
static int match_entry(ENTRY *ep, int flag,
int argc, char * const argv[])
{
int arg;
void *priv = NULL;
for (arg = 0; arg < argc; ++arg) {
#ifdef CONFIG_REGEX
struct slre slre;
if (slre_compile(&slre, argv[arg]) == 0) {
printf("Error compiling regex: %s\n", slre.err_str);
return 0;
}
priv = (void *)&slre;
#endif
if (flag & H_MATCH_KEY) {
if (match_string(flag, ep->key, argv[arg], priv))
return 1;
}
if (flag & H_MATCH_DATA) {
if (match_string(flag, ep->data, argv[arg], priv))
return 1;
}
}
return 0;
}
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;
}
// Work out which data format to use for given filename
DataFormat *data_format(const char *filename)
{
if(filename == NULL) {
// Return default file format
#ifdef PDBF
//output.write("\tUsing default format (PDB)\n");
return new PdbFormat;
#else
#ifdef NCDF
//output.write("\tUsing default format (NetCDF)\n");
return new NcFormat;
#else
#error No file format available; aborting.
#endif // NCDF
#endif // PDBF
}
// Extract the file extension
int len = strlen(filename);
int ind = len-1;
while((ind != -1) && (filename[ind] != '.')) {
ind--;
}
const char *s = filename + ind+1;
// Match strings
#ifdef PDBF
const char *pdb_match[] = {"pdb"};
if(match_string(s, 1, pdb_match) != -1) {
output.write("\tUsing PDB format for file '%s'\n", filename);
return new PdbFormat;
}
#endif
#ifdef NCDF
const char *ncdf_match[] = {"cdl", "nc", "ncdf"};
if(match_string(s, 3, ncdf_match) != -1) {
output.write("\tUsing NetCDF format for file '%s'\n", filename);
return new NcFormat;
}
#endif
output.write("\tFile extension not recognised for '%s'\n", filename);
// Set to the default
return data_format(NULL);
}
/*
* Parse month, weekday, or timezone name
*/
static int match_alpha(const char *date, struct tm *tm, int *offset)
{
unsigned int i;
for (i = 0; i < 12; i++) {
int match = match_string(date, month_names[i]);
if (match >= 3) {
tm->tm_mon = i;
return match;
}
}
for (i = 0; i < 7; i++) {
int match = match_string(date, weekday_names[i]);
if (match >= 3) {
tm->tm_wday = i;
return match;
}
}
for (i = 0; i < ARRAY_SIZE(timezone_names); i++) {
int match = match_string(date, timezone_names[i].name);
if (match >= 0) {
if (match >= 3 || (unsigned int)match == strlen(timezone_names[i].name)) {
int off = timezone_names[i].offset;
/* This is bogus, but we like summer */
off += timezone_names[i].dst;
/* Only use the tz name offset if we don't have anything better */
if (*offset == -1)
*offset = 60*off;
return match;
}
}
}
if (match_string(date, "PM") == 2) {
tm->tm_hour = (tm->tm_hour % 12) + 12;
return 2;
}
if (match_string(date, "AM") == 2) {
tm->tm_hour = (tm->tm_hour % 12) + 0;
return 2;
}
/* BAD CRAP */
return skip_alpha(date);
}
static int __init hash_setup(char *str)
{
struct ima_template_desc *template_desc = ima_template_desc_current();
int i;
if (hash_setup_done)
return 1;
if (strcmp(template_desc->name, IMA_TEMPLATE_IMA_NAME) == 0) {
if (strncmp(str, "sha1", 4) == 0)
ima_hash_algo = HASH_ALGO_SHA1;
else if (strncmp(str, "md5", 3) == 0)
ima_hash_algo = HASH_ALGO_MD5;
else
return 1;
goto out;
}
i = match_string(hash_algo_name, HASH_ALGO__LAST, str);
if (i < 0)
return 1;
ima_hash_algo = i;
out:
hash_setup_done = 1;
return 1;
}
/**
* fwnode_property_match_string - find a string in an array and return index
* @fwnode: Firmware node to get the property of
* @propname: Name of the property holding the array
* @string: String to look for
*
* Find a given string in a string array and if it is found return the
* index back.
*
* Return: %0 if the property was found (success),
* %-EINVAL if given arguments are not valid,
* %-ENODATA if the property does not have a value,
* %-EPROTO if the property is not an array of strings,
* %-ENXIO if no suitable firmware interface is present.
*/
int fwnode_property_match_string(const struct fwnode_handle *fwnode,
const char *propname, const char *string)
{
const char **values;
int nval, ret;
nval = fwnode_property_read_string_array(fwnode, propname, NULL, 0);
if (nval < 0)
return nval;
if (nval == 0)
return -ENODATA;
values = kcalloc(nval, sizeof(*values), GFP_KERNEL);
if (!values)
return -ENOMEM;
ret = fwnode_property_read_string_array(fwnode, propname, values, nval);
if (ret < 0)
goto out;
ret = match_string(values, nval, string);
if (ret < 0)
ret = -ENODATA;
out:
kfree(values);
return ret;
}
static enum usb_dr_mode usb_get_dr_mode_from_string(const char *str)
{
int ret;
ret = match_string(usb_dr_modes, ARRAY_SIZE(usb_dr_modes), str);
return (ret < 0) ? USB_DR_MODE_UNKNOWN : ret;
}
int main (int argc, char* argv[])
{
//printf("%d\n", match_string("Hello world", "*"));
printf("%d\n", match_string("", "*"));
return 0;
}
static int get_pref(const char *prefs, int prefs_len, const char *title, const char *key, int *len)
{
int i = 0;
int title_len = strlen(title);
int key_len = strlen(key);
while (prefs[i] != '\0' && i < prefs_len)
i++;
prefs_len = i;
i = 0;
while (i < prefs_len) {
while (i < prefs_len && prefs[i] != '[')
i++;
if (i + title_len >= prefs_len)
return -1;
if (!match_string(title, prefs + i)) {
i++;
continue;
}
i += title_len;
while (i < prefs_len) {
while (i < prefs_len && (prefs[i] == '\r' || prefs[i] == '\n'))
i++;
if (i < prefs_len && prefs[i] == '[')
break;
if (i + key_len + 1 >= prefs_len)
return -2;
if (!match_string(key, prefs + i)) {
i++;
continue;
}
i += key_len;
if (prefs[i] != '=')
return -3;
*len = ++i;
while (*len < prefs_len && prefs[*len] != '\r' && prefs[*len] != '\n')
(*len)++;
*len -= i;
return i;
}
}
return -1;
}
void reg_question(char* regex, char* word, int* result)
{
// 검색어글자가 현재 글자와 같지 않으면 다음 글자와 비교
// 현재 글자가 마지막 글자면 그대로 유지
if(*regex != *word && *word != '\0')
word = word + 1;
match_string(regex, word, result);
return;
}
static void
pxe_find (grub_uitree_t node)
{
const char *mac, *ip;
mac = grub_env_get ("net_pxe_mac");
ip = grub_env_get ("net_pxe_ip");
node = node->child;
while (node)
{
if ((! grub_strcmp (node->name, "mac")) && (mac))
match_string (node, mac);
else if ((! grub_strcmp (node->name, "ip")) && (ip))
match_string (node, ip);
node = node->next;
}
}
static const char *find_string(const char *s, const char *needle, const char **endp)
{
const char *end;
while (*s)
{
end = match_string(s, needle);
if (end)
return *endp = end, s;
++s;
}
return *endp = NULL, NULL;
}
enum usb_device_speed usb_get_maximum_speed(struct device *dev)
{
const char *maximum_speed;
int ret;
ret = device_property_read_string(dev, "maximum-speed", &maximum_speed);
if (ret < 0)
return USB_SPEED_UNKNOWN;
ret = match_string(speed_names, ARRAY_SIZE(speed_names), maximum_speed);
return (ret < 0) ? USB_SPEED_UNKNOWN : ret;
}
int main (int argc, char ** argv)
{
CompilerKitFSM* fsm;
// Initialize GObject type system.
// Allow us to query the types of an object.
// Only needs to be called once, Test suite already calls it and is not necessary there.
g_type_init();
fsm = state_machine();
/*print_states(fsm);*/
match_string(fsm);
g_object_unref (fsm); // Decreases the reference count by 1, if count becomes 0, then free memeory.
}
match_result attempt_match(const char* begin, const char* end, token_kind& kind, std::size_t& length)
{
auto result = [&] (match_result r, token_kind kind_, std::size_t length_)
{
kind = kind_;
length = length_;
return r;
};
if (begin == end)
{
return result(match_result::unmatched, token_kind::unknown, 0);
}
switch (*begin)
{
case '[': return result(match_result::complete, token_kind::array_begin, 1);
case ']': return result(match_result::complete, token_kind::array_end, 1);
case '{': return result(match_result::complete, token_kind::object_begin, 1);
case '}': return result(match_result::complete, token_kind::object_end, 1);
case ':': return result(match_result::complete, token_kind::object_key_delimiter, 1);
case ',': return result(match_result::complete, token_kind::separator, 1);
case 't': return match_true( begin, end, kind, length);
case 'f': return match_false(begin, end, kind, length);
case 'n': return match_null( begin, end, kind, length);
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
return match_number(begin, end, kind, length);
case '\"':
return match_string(begin, end, kind, length);
case ' ':
case '\t':
case '\n':
case '\r':
return match_whitespace(begin, end, kind, length);
case '/':
return match_comment(begin, end, kind, length);
default:
return result(match_result::unmatched, token_kind::unknown, 1);
}
}
static vector_size_t editor_end(const editor_t *editor)
{
char buf[80];
snprintf(buf, sizeof(buf), ":·%s %s·", BBSNAME_UTF8, BBSHOST);
size_t size = strlen(buf);
vector_size_t end = vector_size(&editor->lines);
for (vector_size_t i = end ? end - 1 : 0; i; --i) {
text_line_t *tl = editor_line(editor, i);
if (tl && match_string(tl, buf, size)) {
return i;
}
}
return end;
}
int main(int argc, char *argv[]) {
int argi;
bool verbose = false;
while ((c = getopt (argc, argv, "v")) != -1) {
switch (c) {
case 'v':
verbose = true;
break;
}
}
if (argc - optind < 2) {
printf("Usage: ./relative_search (-v) string file [...]\n");
return 1;
}
string = argv[optind];
string_len = strlen(string);
for (argi=optind+1; argi < argc; argi++) {
filename = argv[argi];
if (verbose) printf("Looking for string %s in %s\n", string, filename);
fp = fopen(filename, "rb");
if (fp == NULL) {
fprintf(stderr, "ERROR: Cannot open file\n");
return 1;
}
while((c = fgetc(fp)) != EOF) {
match_string(false);
match_string(true);
}
}
return 0;
}
static inline int
match_pair(ErlNifEnv* env, ERL_NIF_TERM term, State *st){
const ERL_NIF_TERM *tuple;
int arity;
if(enif_get_tuple(env, term, &arity, &tuple)){
if(arity == 2){
if(match_string(env, tuple[0], st)){
b_putc(':', st);
if(match_term(env, tuple[1], st)){
return 1;
}
}
}
}
return 0;
}
static void
gimp_pdb_query_entry (gpointer key,
gpointer value,
gpointer user_data)
{
PDBQuery *pdb_query = user_data;
GList *list;
GimpProcedure *procedure;
const gchar *proc_name;
PDBStrings strings;
GEnumClass *enum_class;
GimpEnumDesc *type_desc;
proc_name = key;
if (pdb_query->querying_compat)
list = g_hash_table_lookup (pdb_query->pdb->procedures, value);
else
list = value;
if (! list)
return;
procedure = list->data;
gimp_pdb_get_strings (&strings, procedure, pdb_query->querying_compat);
enum_class = g_type_class_ref (GIMP_TYPE_PDB_PROC_TYPE);
type_desc = gimp_enum_get_desc (enum_class, procedure->proc_type);
g_type_class_unref (enum_class);
if (match_string (pdb_query->name_regex, proc_name) &&
match_string (pdb_query->blurb_regex, strings.blurb) &&
match_string (pdb_query->help_regex, strings.help) &&
match_string (pdb_query->author_regex, strings.author) &&
match_string (pdb_query->copyright_regex, strings.copyright) &&
match_string (pdb_query->date_regex, strings.date) &&
match_string (pdb_query->proc_type_regex, type_desc->value_desc))
{
pdb_query->num_procs++;
pdb_query->list_of_procs = g_renew (gchar *, pdb_query->list_of_procs,
pdb_query->num_procs);
pdb_query->list_of_procs[pdb_query->num_procs - 1] = g_strdup (proc_name);
}
void match_string(char* regex, char* word, int* result)
{
if(*regex == '*')
// 검색어글자가 '*' 인 경우
{
do{
// 다음 검색어와 현재 글자를 비교
// '*' 검색어는 '?' 검색어를 여러번 반복한 것과 같다고 해석된다.
reg_question(regex+1, word, result);
// 전의 검색에서 끝이 나지 않았을 경우 루프를 반복
if(*result != 1 && *word != '\0')
word = word + 1;
}
while(*(regex+1) != *word && *word != '\0'&& *result != 1);
return;
}else if(*regex == '?')
// 검색어 글자가 '?' 인 경우
{
reg_question(regex+1, word, result);
return;
}else if(*regex == '\0' && *word == '\0')
// 검색어 글자가 끝났고 현재 글자도 마지막 글자인 경우
// 성공
{
*result = 1;
return;
}else if(*word != *regex)
// 검색어 글자가 '*'/'?' 가 아니면서 현재 글자와 다른 경우
// 실패
{
*result = 0;
return;
}else{
// 검색어 글자가 현재 글자와 일치하는 경우
// 다음 단어를 검색한다.
match_string(regex+1, word+1, result);
return;
}
}
static int match_string (char * match, char * str)
{
int i;
again:
if (*str == '\0' && *match == '\0')
return 1;
switch (*match) {
case '?':
if (*str == '\0')
return 0;
str++;
match++;
goto again;
case '*':
match++;
if (*match == '\0')
return 1;
for (i = 0; str[i] != '\0'; i++)
if (match_string(match, str + i))
return 1;
return 0;
case '\0':
return 0;
case '\\':
match++;
if (*match == '\0')
return 0;
/* Fall through ! */
default:
if (*match == *str) {
match++;
str++;
goto again;
}
return 0;
}
}
static void
finch_debug_print(PurpleDebugLevel level, const char *category,
const char *args)
{
if (debug.window && !debug.paused && match_string(category, args))
{
int pos = gnt_text_view_get_lines_below(GNT_TEXT_VIEW(debug.tview));
GntTextFormatFlags flag = GNT_TEXT_FLAG_NORMAL;
const char *mdate;
time_t mtime = time(NULL);
mdate = purple_utf8_strftime("%H:%M:%S ", localtime(&mtime));
gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(debug.tview),
mdate, flag);
gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(debug.tview),
category, GNT_TEXT_FLAG_BOLD);
gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(debug.tview),
": ", GNT_TEXT_FLAG_BOLD);
switch (level)
{
case PURPLE_DEBUG_WARNING:
flag |= GNT_TEXT_FLAG_UNDERLINE;
case PURPLE_DEBUG_ERROR:
case PURPLE_DEBUG_FATAL:
flag |= GNT_TEXT_FLAG_BOLD;
break;
default:
break;
}
gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(debug.tview), args, flag);
if (pos <= 1)
gnt_text_view_scroll(GNT_TEXT_VIEW(debug.tview), 0);
}
}
static int
match_string (grub_uitree_t node, const char *str)
{
grub_uitree_t child;
char *cmd;
child = node->child;
while (child)
{
int len;
len = grub_strlen (child->name);
if (! grub_memcmp (child->name, str, len))
{
const char *p;
p = str + len;
if ((*p == '.') || (*p == '-'))
p++;
if (match_string (child, p))
return 1;
}
child = child->next;
}
cmd = grub_uitree_get_prop (node, "command");
if (cmd)
{
grub_parser_execute (cmd);
return 1;
}
return 0;
}
ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
strptime (const char *buf, const char *format, struct tm *timeptr)
{
char c;
for (; (c = *format) != '\0'; ++format) {
char *s;
int ret;
if (isspace ((unsigned char)c)) {
while (isspace ((unsigned char)*buf))
++buf;
} else if (c == '%' && format[1] != '\0') {
c = *++format;
if (c == 'E' || c == 'O')
c = *++format;
switch (c) {
case 'A' :
ret = match_string (&buf, full_weekdays);
if (ret < 0)
return NULL;
timeptr->tm_wday = ret;
break;
case 'a' :
ret = match_string (&buf, abb_weekdays);
if (ret < 0)
return NULL;
timeptr->tm_wday = ret;
break;
case 'B' :
ret = match_string (&buf, full_month);
if (ret < 0)
return NULL;
timeptr->tm_mon = ret;
break;
case 'b' :
case 'h' :
ret = match_string (&buf, abb_month);
if (ret < 0)
return NULL;
timeptr->tm_mon = ret;
break;
case 'C' :
if (parse_number(&buf, 2, &ret))
return NULL;
timeptr->tm_year = (ret * 100) - tm_year_base;
break;
case 'c' :
abort ();
case 'D' : /* %m/%d/%y */
s = strptime (buf, "%m/%d/%y", timeptr);
if (s == NULL)
return NULL;
buf = s;
break;
case 'd' :
case 'e' :
if (parse_number(&buf, 2, &ret))
return NULL;
timeptr->tm_mday = ret;
break;
case 'H' :
case 'k' :
if (parse_number(&buf, 2, &ret))
return NULL;
timeptr->tm_hour = ret;
break;
case 'I' :
case 'l' :
if (parse_number(&buf, 2, &ret))
return NULL;
if (ret == 12)
timeptr->tm_hour = 0;
else
timeptr->tm_hour = ret;
break;
case 'j' :
if (parse_number(&buf, 3, &ret))
return NULL;
if (ret == 0)
return NULL;
timeptr->tm_yday = ret - 1;
break;
case 'm' :
if (parse_number(&buf, 2, &ret))
return NULL;
if (ret == 0)
return NULL;
timeptr->tm_mon = ret - 1;
break;
case 'M' :
if (parse_number(&buf, 2, &ret))
return NULL;
timeptr->tm_min = ret;
break;
case 'n' :
while (isspace ((unsigned char)*buf))
buf++;
break;
case 'p' :
ret = match_string (&buf, ampm);
if (ret < 0)
return NULL;
if (timeptr->tm_hour == 0) {
if (ret == 1)
timeptr->tm_hour = 12;
} else
timeptr->tm_hour += 12;
break;
case 'r' : /* %I:%M:%S %p */
s = strptime (buf, "%I:%M:%S %p", timeptr);
if (s == NULL)
return NULL;
buf = s;
break;
case 'R' : /* %H:%M */
s = strptime (buf, "%H:%M", timeptr);
if (s == NULL)
return NULL;
buf = s;
break;
case 'S' :
if (parse_number(&buf, 2, &ret))
return NULL;
timeptr->tm_sec = ret;
break;
case 't' :
while (isspace ((unsigned char)*buf))
buf++;
break;
case 'T' : /* %H:%M:%S */
case 'X' :
s = strptime (buf, "%H:%M:%S", timeptr);
if (s == NULL)
return NULL;
buf = s;
break;
case 'u' :
if (parse_number(&buf, 1, &ret))
return NULL;
if (ret <= 0)
return NULL;
timeptr->tm_wday = ret - 1;
break;
case 'w' :
if (parse_number(&buf, 1, &ret))
return NULL;
timeptr->tm_wday = ret;
break;
case 'U' :
if (parse_number(&buf, 2, &ret))
return NULL;
set_week_number_sun (timeptr, ret);
break;
case 'V' :
if (parse_number(&buf, 2, &ret))
return NULL;
set_week_number_mon4 (timeptr, ret);
break;
case 'W' :
if (parse_number(&buf, 2, &ret))
return NULL;
set_week_number_mon (timeptr, ret);
break;
case 'x' :
s = strptime (buf, "%Y:%m:%d", timeptr);
if (s == NULL)
return NULL;
buf = s;
break;
case 'y' :
if (parse_number(&buf, 2, &ret))
return NULL;
if (ret < 70)
timeptr->tm_year = 100 + ret;
else
timeptr->tm_year = ret;
break;
case 'Y' :
if (parse_number(&buf, 4, &ret))
return NULL;
timeptr->tm_year = ret - tm_year_base;
break;
case 'Z' :
abort ();
case '\0' :
--format;
/* FALLTHROUGH */
case '%' :
if (*buf == '%')
++buf;
else
return NULL;
break;
default :
if (*buf == '%' || *++buf == c)
++buf;
else
return NULL;
break;
}
} else {
if (*buf == c)
++buf;
else
return NULL;
}
}
return rk_UNCONST(buf);
}
int main(int argc, char **argv)
{
SDDS_DATASET inSet, outSet;
SCANNED_ARG *s_arg;
char *input, *output, *zeroName, **columnName;
long i_arg, i, pageReturned, rows, row, zrow;
int32_t columnNames;
double **indepData, *depenData, **slopeData, slope, offset;
unsigned long pipeFlags, flags, majorOrderFlag;
char s[SDDS_MAXLINE];
short columnMajorOrder=-1;
SDDS_RegisterProgramName(argv[0]);
argc = scanargs(&s_arg, argc, argv);
if (argc<2 || argc>(2+N_OPTIONS))
bomb(NULL, USAGE);
flags = pipeFlags = 0;
input = output = NULL;
zeroName = NULL;
columnName = NULL;
columnNames = 0;
offset = 0;
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], option, N_OPTIONS, 0)) {
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_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_ZEROESOF:
if (s_arg[i_arg].n_items!=2)
SDDS_Bomb("invalid -zeroesOf syntax");
zeroName = s_arg[i_arg].list[1];
break;
case CLO_COLUMNS:
if (s_arg[i_arg].n_items<2)
SDDS_Bomb("invalid -columns syntax");
columnName = tmalloc(sizeof(*columnName)*(columnNames = s_arg[i_arg].n_items-1));
for (i=0; i<columnNames; i++)
columnName[i] = s_arg[i_arg].list[i+1];
break;
case CLO_SLOPEOUTPUT:
flags |= FL_SLOPEOUTPUT;
break;
case CLO_OFFSET:
if (s_arg[i_arg].n_items!=2 || sscanf(s_arg[i_arg].list[1], "%le", &offset)!=1)
SDDS_Bomb("invalid -offset syntax");
break;
default:
fprintf(stderr, "Error (%s): unknown/ambiguous option: %s\n", argv[0], s_arg[i_arg].list[0]);
exit(1);
break;
}
}
else {
if (input==NULL)
input = s_arg[i_arg].list[0];
else if (output==NULL)
output = s_arg[i_arg].list[0];
else
SDDS_Bomb("too many filenames");
}
}
processFilenames("sddszerofind", &input, &output, pipeFlags, 0, NULL);
if (!zeroName)
SDDS_Bomb("-zeroesOf option must be given");
if (!SDDS_InitializeInput(&inSet, input))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!resolveColumnNames(&inSet, zeroName, &columnName, &columnNames) ||
!SDDS_InitializeOutput(&outSet, SDDS_BINARY, 0, NULL, "sddszerofind output", output) ||
!SDDS_TransferColumnDefinition(&outSet, &inSet, zeroName, NULL))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (columnMajorOrder!=-1)
outSet.layout.data_mode.column_major = columnMajorOrder;
else
outSet.layout.data_mode.column_major = inSet.layout.data_mode.column_major;
for (i=0; i<columnNames; i++) {
sprintf(s, "%sSlope", columnName[i]);
if (!SDDS_TransferColumnDefinition(&outSet, &inSet, columnName[i], NULL) ||
(flags&FL_SLOPEOUTPUT &&
!SDDS_TransferColumnDefinition(&outSet, &inSet, columnName[i], s)))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_WriteLayout(&outSet))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
indepData = tmalloc(sizeof(*indepData)*columnNames);
slopeData = tmalloc(sizeof(*slopeData)*columnNames);
while ((pageReturned=SDDS_ReadPage(&inSet))>0) {
if (!SDDS_StartPage(&outSet, 0))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if ((rows=SDDS_CountRowsOfInterest(&inSet))>1) {
if (!(depenData = SDDS_GetColumnInDoubles(&inSet, zeroName)))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
for (i=0; i<columnNames; i++) {
if (!(indepData[i] = SDDS_GetColumnInDoubles(&inSet, columnName[i])))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (flags&FL_SLOPEOUTPUT)
slopeData[i] = tmalloc(sizeof(**slopeData)*rows);
}
if (offset)
for (row=0; row<rows; row++)
depenData[row] += offset;
for (zrow=row=0; row<rows-1; row++) {
if ((depenData[row]<=0 && depenData[row+1]>=0) ||
(depenData[row]>=0 && depenData[row+1]<=0)) {
for (i=0; i<columnNames; i++) {
if (indepData[i][row]==indepData[i][row+1]) {
if (flags&FL_SLOPEOUTPUT)
slopeData[i][zrow] = DBL_MAX;
indepData[i][zrow] = indepData[i][row];
}
else {
slope = (depenData[row+1]-depenData[row])/(indepData[i][row+1]-indepData[i][row]);
if (flags&FL_SLOPEOUTPUT)
slopeData[i][zrow] = slope;
if (slope)
indepData[i][zrow] = indepData[i][row] - depenData[row]/slope;
else
indepData[i][zrow] = (indepData[i][row] + indepData[i][row+1])/2;
}
}
depenData[zrow] = -offset;
zrow++;
}
}
if (zrow) {
if (!SDDS_LengthenTable(&outSet, zrow) ||
!SDDS_SetColumnFromDoubles(&outSet, SDDS_SET_BY_NAME, depenData, zrow, zeroName))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
for (i=0; i<columnNames; i++) {
sprintf(s, "%sSlope", columnName[i]);
if (!SDDS_SetColumnFromDoubles(&outSet, SDDS_SET_BY_NAME, indepData[i], zrow, columnName[i]) ||
(flags&FL_SLOPEOUTPUT &&
!SDDS_SetColumnFromDoubles(&outSet, SDDS_SET_BY_NAME, slopeData[i], zrow, s)))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
free(depenData);
for (i=0; i<columnNames; i++)
free(indepData[i]);
if (flags&FL_SLOPEOUTPUT)
for (i=0; i<columnNames; i++)
free(slopeData[i]);
}
if (!SDDS_WritePage(&outSet))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_Terminate(&inSet) || !SDDS_Terminate(&outSet)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
return(0);
}
char *makeNameUnitsLabel(PLOT_SPEC *plspec, long panel, long plane, long group)
{
long set, datasets;
PLOT_DATA **dataset;
char **symbolUsed, buffer[LABEL_BUFLEN], *ptr;
long symbolsUsed, first, maxLabel, unitsIndex, request, unitsDataSet, addUnits;
static long warned[2] = { 0,0 } ;
long labelLimit = LABEL_BUFLEN-10;
dataset = plspec->panel[panel].dataset;
datasets = plspec->panel[panel].datasets;
symbolsUsed = maxLabel = 0;
symbolUsed = NULL;
first = addUnits = 1;
buffer[0] = 0;
unitsDataSet = -1;
for (set=0; set<datasets; set++) {
if (dataset[set]->scalesGroupIndex[plane]!=group)
continue;
if (unitsDataSet<0)
unitsDataSet = set;
request = dataset[set]->request_index;
if (plspec->plot_request[request].overlay.flags)
continue;
if (!first &&
((!dataset[set]->info[plane].units && dataset[set-1]->info[plane].units) ||
(dataset[set]->info[plane].units && !dataset[set-1]->info[plane].units) ||
(dataset[set]->info[plane].units && dataset[set-1]->info[plane].units &&
strcmp(dataset[set]->info[plane].units, dataset[set-1]->info[plane].units)!=0))) {
if (!warned[plane]) {
fprintf(stderr, "Warning: not all %lc quantities have the same units\n",
'x'+plane);
warned[plane] = 1;
}
addUnits = 0;
}
if (!dataset[set]->info[plane].symbol) {
fprintf(stderr, "internal error: info[%ld] symbol is NULL for dataset %ld (panel %ld)\n",
plane, set, panel);
exit(1);
}
unitsIndex = set;
if (!maxLabel &&
(first || !symbolsUsed ||
match_string(dataset[set]->info[plane].symbol, symbolUsed, symbolsUsed, EXACT_MATCH)<0)) {
if (!(symbolUsed=
SDDS_Realloc(symbolUsed, sizeof(*symbolUsed)*(symbolsUsed+1))))
SDDS_Bomb("Memory allocation failure (makeNameUnitsLabel)");
symbolUsed[symbolsUsed] = dataset[set]->info[plane].symbol;
if ((long)(strlen(buffer)+strlen(symbolUsed[symbolsUsed]))<labelLimit) {
if (!first)
strcat(buffer, ", ");
strcat(buffer, symbolUsed[symbolsUsed]);
}
else {
if (first)
strncpy(buffer, symbolUsed[symbolsUsed], labelLimit);
buffer[labelLimit] = 0;
maxLabel = 1;
}
symbolsUsed++;
}
first = 0;
}
if (symbolUsed)
free(symbolUsed);
if (maxLabel)
strcat(buffer, "...");
if (addUnits && unitsDataSet>=0 &&
dataset[unitsDataSet]->info[plane].units &&
strlen(dataset[unitsDataSet]->info[plane].units)) {
strcat(buffer, " (");
strcat(buffer, dataset[unitsDataSet]->info[plane].units);
strcat(buffer, ")");
}
if (strlen(buffer)) {
if (!SDDS_CopyString(&ptr, buffer))
SDDS_Bomb("String copying problem (makeNameUnitsLabel)");
return ptr;
}
return NULL;
}
int main(int argc, char **argv)
{
FILE *fileID;
COLUMN_DATA_STRUCTURES *columnValues;
PARAMETER_DATA_STRUCTURES *parameterValues;
SDDS_DATASET SDDS_dataset;
SCANNED_ARG *s_arg;
long i, j, k, n, i_arg;
int32_t rows;
int32_t maxRows=10000, initRows=10000, row;
long par, col, page, size, readline=1, fillin=0;
int32_t ptrSize=0;
char *input, *output, s[1024], *ptr, *ptr2, data[10240],temp[10240];
unsigned long pipeFlags=0,majorOrderFlag;
long noWarnings=0, tmpfile_used=0, columnOrder=0, whitespace=1;
short shortValue;
int32_t longValue;
float floatValue;
double doubleValue;
char stringValue[SDDS_MAXLINE];
char characterValue;
char buffer[124], buffer2[124];
long *parameterIndex, *columnIndex;
long binary=0, noRowCount=0, inputBinary=0, count=0;
char separator;
char commentCharacters[20];
short checkComment=0;
short commentFound;
long parameters=0, columns=0;
long skiplines=0;
short abort=0, recover=1, columnMajorOrder=0;
input = output = NULL;
separator = ' ';
columnValues = NULL;
parameterValues = NULL;
parameterIndex = columnIndex = NULL;
SDDS_RegisterProgramName(argv[0]);
argc = scanargs(&s_arg, argc, argv);
if (argc<3)
bomb(NULL, USAGE);
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], option, N_OPTIONS, 0)) {
case SET_MAJOR_ORDER:
majorOrderFlag=0;
s_arg[i_arg].n_items -=1;
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 SET_OUTPUTMODE:
if (s_arg[i_arg].n_items!=2)
SDDS_Bomb("invalid -outputMode syntax");
switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) {
case ASCII_MODE:
binary = 0;
break;
case BINARY_MODE:
binary = 1;
break;
default:
SDDS_Bomb("invalid -outputMode syntax");
break;
}
break;
case SET_INPUTMODE:
if (s_arg[i_arg].n_items!=2)
SDDS_Bomb("invalid -inputMode syntax");
switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) {
case ASCII_MODE:
inputBinary = 0;
break;
case BINARY_MODE:
inputBinary = 1;
break;
default:
SDDS_Bomb("invalid -inputMode syntax");
break;
}
break;
case SET_SEPARATOR:
if (s_arg[i_arg].n_items!=2)
SDDS_Bomb("invalid -separator syntax");
separator = s_arg[i_arg].list[1][0];
whitespace = 0;
break;
case SET_COMMENT:
if (s_arg[i_arg].n_items!=2)
SDDS_Bomb("invalid -commentCharacters syntax");
sprintf(commentCharacters, "%s", s_arg[i_arg].list[1]);
checkComment=1;
break;
case SET_FILLIN:
fillin=1;
break;
case SET_NOROWCOUNT:
if (s_arg[i_arg].n_items!=1)
SDDS_Bomb("invalid -noRowCount syntax");
noRowCount = 1;
break;
case SET_ORDER:
if (s_arg[i_arg].n_items!=2)
SDDS_Bomb("invalid -order syntax");
switch (match_string(s_arg[i_arg].list[1], order_names, ORDERS, 0)) {
case ROW_ORDER:
columnOrder = 0;
break;
case COLUMN_ORDER:
columnOrder = 1;
break;
default:
SDDS_Bomb("invalid -order syntax");
break;
}
break;
case SET_PARAMETER:
if (s_arg[i_arg].n_items<3)
SDDS_Bomb("invalid -parameter syntax");
count=1;
parameters++;
parameterValues = trealloc(parameterValues, sizeof(*parameterValues)*(parameters));
SDDS_CopyString(¶meterValues[parameters-1].name, s_arg[i_arg].list[1]);
parameterValues[parameters-1].units = NULL;
parameterValues[parameters-1].description = NULL;
parameterValues[parameters-1].symbol = NULL;
switch (match_string(s_arg[i_arg].list[2], type_name, DATATYPES, 0)) {
case TYPE_SHORT:
parameterValues[parameters-1].type = SDDS_SHORT;
break;
case TYPE_LONG:
parameterValues[parameters-1].type = SDDS_LONG;
break;
case TYPE_FLOAT:
parameterValues[parameters-1].type = SDDS_FLOAT;
break;
case TYPE_DOUBLE:
parameterValues[parameters-1].type = SDDS_DOUBLE;
break;
case TYPE_STRING:
parameterValues[parameters-1].type = SDDS_STRING;
break;
case TYPE_CHARACTER:
parameterValues[parameters-1].type = SDDS_CHARACTER;
break;
default:
SDDS_Bomb("invalid -parameter type");
break;
}
for (i=3;i<s_arg[i_arg].n_items;i++) {
if (!(ptr=strchr(s_arg[i_arg].list[i], '=')))
SDDS_Bomb("invalid -parameter syntax");
*ptr++ = 0;
switch (match_string(s_arg[i_arg].list[i], header_elements, HEADERELEMENTS, 0)) {
case HEADER_UNITS:
SDDS_CopyString(¶meterValues[parameters-1].units, ptr);
break;
case HEADER_DESCRIPTION:
SDDS_CopyString(¶meterValues[parameters-1].description, ptr);
break;
case HEADER_SYMBOL:
SDDS_CopyString(¶meterValues[parameters-1].symbol, ptr);
break;
case HEADER_COUNT:
if (sscanf(ptr, "%ld", &count)!=1 ||
count<=0)
SDDS_Bomb("invalid parameter count value");
sprintf(buffer, "%s", parameterValues[parameters-1].name);
sprintf(buffer2, "%s1", buffer);
free(parameterValues[parameters-1].name);
SDDS_CopyString(¶meterValues[parameters-1].name, buffer2);
break;
default:
SDDS_Bomb("invalid -parameter syntax");
break;
}
}
for (i=2;i<=count;i++) {
parameters++;
parameterValues = trealloc(parameterValues, sizeof(*parameterValues)*(parameters));
sprintf(buffer2, "%s%ld", buffer, i);
SDDS_CopyString(¶meterValues[parameters-1].name, buffer2);
parameterValues[parameters-1].units = NULL;
parameterValues[parameters-1].description = NULL;
parameterValues[parameters-1].symbol = NULL;
parameterValues[parameters-1].type = parameterValues[parameters-2].type;
if (parameterValues[parameters-2].units)
SDDS_CopyString(¶meterValues[parameters-1].units, parameterValues[parameters-2].units);
if (parameterValues[parameters-2].description)
SDDS_CopyString(¶meterValues[parameters-1].description, parameterValues[parameters-2].description);
if (parameterValues[parameters-2].symbol)
SDDS_CopyString(¶meterValues[parameters-1].symbol, parameterValues[parameters-2].symbol);
}
break;
case SET_COLUMN:
if (s_arg[i_arg].n_items<3)
SDDS_Bomb("invalid -column syntax");
count=1;
columns++;
columnValues = trealloc(columnValues, sizeof(*columnValues)*(columns));
SDDS_CopyString(&columnValues[columns-1].name, s_arg[i_arg].list[1]);
columnValues[columns-1].elements = 0;
columnValues[columns-1].values = NULL;
columnValues[columns-1].stringValues = NULL;
columnValues[columns-1].units = NULL;
columnValues[columns-1].description = NULL;
columnValues[columns-1].symbol = NULL;
columnValues[columns-1].skip = 0;
switch (match_string(s_arg[i_arg].list[2], type_name, DATATYPES, 0)) {
case TYPE_SHORT:
columnValues[columns-1].type = SDDS_SHORT;
break;
case TYPE_LONG:
columnValues[columns-1].type = SDDS_LONG;
break;
case TYPE_FLOAT:
columnValues[columns-1].type = SDDS_FLOAT;
break;
case TYPE_DOUBLE:
columnValues[columns-1].type = SDDS_DOUBLE;
break;
case TYPE_STRING:
columnValues[columns-1].type = SDDS_STRING;
break;
case TYPE_CHARACTER:
columnValues[columns-1].type = SDDS_CHARACTER;
break;
default:
SDDS_Bomb("invalid -column type");
break;
}
for (i=3;i<s_arg[i_arg].n_items;i++) {
if (!(ptr=strchr(s_arg[i_arg].list[i], '=')))
SDDS_Bomb("invalid -column syntax");
*ptr++ = 0;
switch (match_string(s_arg[i_arg].list[i], header_elements, HEADERELEMENTS, 0)) {
case HEADER_UNITS:
SDDS_CopyString(&columnValues[columns-1].units, ptr);
break;
case HEADER_DESCRIPTION:
SDDS_CopyString(&columnValues[columns-1].description, ptr);
break;
case HEADER_SYMBOL:
SDDS_CopyString(&columnValues[columns-1].symbol, ptr);
break;
case HEADER_COUNT:
if (sscanf(ptr, "%ld", &count)!=1 ||
count<=0)
SDDS_Bomb("invalid column count value");
sprintf(buffer, "%s", columnValues[columns-1].name);
sprintf(buffer2, "%s1", buffer);
free(columnValues[columns-1].name);
SDDS_CopyString(&columnValues[columns-1].name, buffer2);
break;
default:
SDDS_Bomb("invalid -column syntax");
break;
}
}
for (i=2;i<=count;i++) {
columns++;
columnValues = trealloc(columnValues, sizeof(*columnValues)*(columns));
sprintf(buffer2, "%s%ld", buffer, i);
SDDS_CopyString(&columnValues[columns-1].name, buffer2);
columnValues[columns-1].elements = 0;
columnValues[columns-1].values = NULL;
columnValues[columns-1].stringValues = NULL;
columnValues[columns-1].units = NULL;
columnValues[columns-1].description = NULL;
columnValues[columns-1].symbol = NULL;
columnValues[columns-1].type = columnValues[columns-2].type;
if (columnValues[columns-2].units)
SDDS_CopyString(&columnValues[columns-1].units, columnValues[columns-2].units);
if (columnValues[columns-2].description)
SDDS_CopyString(&columnValues[columns-1].description, columnValues[columns-2].description);
if (columnValues[columns-2].symbol)
SDDS_CopyString(&columnValues[columns-1].symbol, columnValues[columns-2].symbol);
}
break;
case SET_SKIPCOLUMN:
if (s_arg[i_arg].n_items!=2)
SDDS_Bomb("invalid -skipcolumn syntax");
count=1;
columns++;
columnValues = trealloc(columnValues, sizeof(*columnValues)*(columns));
columnValues[columns-1].name = NULL;
columnValues[columns-1].elements = 0;
columnValues[columns-1].values = NULL;
columnValues[columns-1].stringValues = NULL;
columnValues[columns-1].units = NULL;
columnValues[columns-1].description = NULL;
columnValues[columns-1].symbol = NULL;
columnValues[columns-1].skip = 1;
switch (match_string(s_arg[i_arg].list[1], type_name, DATATYPES, 0)) {
case TYPE_SHORT:
columnValues[columns-1].type = SDDS_SHORT;
break;
case TYPE_LONG:
columnValues[columns-1].type = SDDS_LONG;
break;
case TYPE_FLOAT:
columnValues[columns-1].type = SDDS_FLOAT;
break;
case TYPE_DOUBLE:
columnValues[columns-1].type = SDDS_DOUBLE;
break;
case TYPE_STRING:
columnValues[columns-1].type = SDDS_STRING;
break;
case TYPE_CHARACTER:
columnValues[columns-1].type = SDDS_CHARACTER;
break;
default:
SDDS_Bomb("invalid -skipcolumn type");
break;
}
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;
case SET_NOWARNINGS:
if (s_arg[i_arg].n_items!=1)
SDDS_Bomb("invalid -nowarnings syntax");
noWarnings = 1;
break;
case SET_SKIPLINES:
if (s_arg[i_arg].n_items!=2 ||
sscanf(s_arg[i_arg].list[1], "%ld", &skiplines)!=1 ||
skiplines<=0)
SDDS_Bomb("invalid -skiplines syntax");
break;
default:
fprintf(stderr, "error: unknown switch: %s\n", s_arg[i_arg].list[0]);
exit(1);
break;
}
} else {
if (input == NULL) {
input = s_arg[i_arg].list[0];
} else if (output == NULL) {
output = s_arg[i_arg].list[0];
} else {
fprintf(stderr, "too many filenames");
exit(1);
}
}
}
processFilenames("plaindata2sdds", &input, &output, pipeFlags, noWarnings, &tmpfile_used);
if (!columns && !parameters)
SDDS_Bomb("you must specify one of the -column or the -parameter options");
if (skiplines && inputBinary)
SDDS_Bomb("-skiplines does not work with binary input files");
if (!input) {
if (inputBinary) {
#if defined(_WIN32)
if (_setmode(_fileno(stdin), _O_BINARY) == -1) {
fprintf(stderr, "error: unable to set stdin to binary mode\n");
exit(1);
}
#endif
}
fileID = stdin;
} else {
if (!fexists(input)) {
fprintf(stderr, "input file not found\n");
exit(1);
}
if (inputBinary) {
fileID = fopen(input, "rb");
} else {
fileID = fopen(input, "r");
}
}
if (fileID == NULL) {
fprintf(stderr, "unable to open input file for reading\n");
exit(1);
}
if (!SDDS_InitializeOutput(&SDDS_dataset, binary?SDDS_BINARY:SDDS_ASCII,
1, NULL, NULL, output))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
SDDS_dataset.layout.data_mode.column_major = columnMajorOrder;
if (parameters) {
parameterIndex = tmalloc(sizeof(*parameterIndex)*parameters);
}
if (columns) {
columnIndex = tmalloc(sizeof(*columnIndex)*columns);
}
for (i=0; i<parameters; i++) {
if ((parameterIndex[i] =
SDDS_DefineParameter(&SDDS_dataset, parameterValues[i].name, parameterValues[i].symbol,
parameterValues[i].units, parameterValues[i].description, NULL,
parameterValues[i].type, 0))<0) {
sprintf(s, "Problem defining parameter %s.", parameterValues[i].name);
SDDS_SetError(s);
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
for (i=0; i<columns; i++) {
if (columnValues[i].skip)
continue;
if ((columnIndex[i] =
SDDS_DefineColumn(&SDDS_dataset, columnValues[i].name, columnValues[i].symbol, \
columnValues[i].units, columnValues[i].description, NULL,
columnValues[i].type, 0))<0) {
sprintf(s, "Problem defining column %s.", columnValues[i].name);
SDDS_SetError(s);
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
if (!SDDS_WriteLayout(&SDDS_dataset))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!SDDS_StartPage(&SDDS_dataset, initRows))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
row = par = col = page = 0;
while (inputBinary) {
row = par = col = 0;
if (fread(&rows,sizeof(rows),1,fileID) != 1) {
if (page == 0) {
SDDS_SetError("Unable to read number of rows");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
} else {
if (!SDDS_Terminate(&SDDS_dataset))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
for (k=0;k<columns;k++) {
if (columnValues[k].type == SDDS_STRING) {
SDDS_FreeStringArray(columnValues[k].stringValues,columnValues[k].elements);
} else {
free(columnValues[k].values);
}
}
return 0;
}
}
page++;
for (par=0;par<parameters;par++) {
switch (parameterValues[par].type) {
case SDDS_SHORT:
if (fread(&shortValue,2,1,fileID) != 1) {
SDDS_SetError("Unable to read short parameter");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,shortValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
case SDDS_LONG:
if (fread(&longValue,4,1,fileID) != 1) {
SDDS_SetError("Unable to read long parameter");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,longValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
case SDDS_FLOAT:
if (fread(&floatValue,4,1,fileID) != 1) {
SDDS_SetError("Unable to read float parameter");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,floatValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
case SDDS_DOUBLE:
if (fread(&doubleValue,8,1,fileID) != 1) {
SDDS_SetError("Unable to read double parameter");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,doubleValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
case SDDS_STRING:
if (fread(&size,4,1,fileID) != 1) {
SDDS_SetError("Unable to read string parameter");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (size>SDDS_MAXLINE-1)
SDDS_Bomb("String is too long");
if (size > 0) {
if (fread(&stringValue,size,1,fileID) != 1) {
SDDS_SetError("Unable to read string parameter");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
stringValue[size] = 0;
} else {
strcpy(stringValue,"");
}
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,stringValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
case SDDS_CHARACTER:
if (fread(&characterValue,1,1,fileID) != 1) {
SDDS_SetError("Unable to read character parameter");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,characterValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
}
}
for (i=0;i<columns;i++) {
if (rows > columnValues[i].elements) {
if (columnValues[i].type == SDDS_STRING) {
columnValues[i].stringValues = AllocateColumnStringData(columnValues[i].stringValues, rows, columnValues[i].elements);
} else {
columnValues[i].values = AllocateColumnData(columnValues[i].type, columnValues[i].values, rows);
}
columnValues[i].elements = rows;
}
}
if (columnOrder) {
for (col=0;col<columns;col++) {
switch (columnValues[col].type) {
case SDDS_SHORT:
for (i=0;i<rows;i++) {
if (fread((short*)(columnValues[col].values)+i,2,1,fileID) != 1) {
SDDS_SetError("Unable to read short column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_LONG:
for (i=0;i<rows;i++) {
if (fread((int32_t*)(columnValues[col].values)+i,4,1,fileID) != 1) {
SDDS_SetError("Unable to read long column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_FLOAT:
for (i=0;i<rows;i++) {
if (fread((float*)(columnValues[col].values)+i,4,1,fileID) != 1) {
SDDS_SetError("Unable to read float column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_DOUBLE:
for (i=0;i<rows;i++) {
if (fread((double*)(columnValues[col].values)+i,8,1,fileID) != 1) {
SDDS_SetError("Unable to read double double");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_STRING:
for (i=0;i<rows;i++) {
if (fread(&size,4,1,fileID) != 1) {
SDDS_SetError("Unable to read string column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (size>SDDS_MAXLINE-1)
SDDS_Bomb("String is too long");
columnValues[col].stringValues[i] = malloc(size + 1);
if (size > 0) {
if (fread(columnValues[col].stringValues[i],size,1,fileID) != 1) {
SDDS_SetError("Unable to read string column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
columnValues[col].stringValues[i][size] = 0;
} else {
strcpy(columnValues[col].stringValues[i],"");
}
}
break;
case SDDS_CHARACTER:
for (i=0;i<rows;i++) {
if (fread((char*)(columnValues[col].values)+i,1,1,fileID) != 1) {
SDDS_SetError("Unable to read character column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
}
}
} else {
for (i=0;i<rows;i++) {
for (col=0;col<columns;col++) {
switch (columnValues[col].type) {
case SDDS_SHORT:
if (fread((short*)(columnValues[col].values)+i,2,1,fileID) != 1) {
SDDS_SetError("Unable to read short column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
break;
case SDDS_LONG:
if (fread((int32_t*)(columnValues[col].values)+i,4,1,fileID) != 1) {
SDDS_SetError("Unable to read long column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
break;
case SDDS_FLOAT:
if (fread((float*)(columnValues[col].values)+i,4,1,fileID) != 1) {
SDDS_SetError("Unable to read float column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
break;
case SDDS_DOUBLE:
if (fread(((double*)(columnValues[col].values)+i),8,1,fileID) != 1) {
SDDS_SetError("Unable to read double column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
break;
case SDDS_STRING:
if (fread(&size,4,1,fileID) != 1) {
SDDS_SetError("Unable to read string column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (size>SDDS_MAXLINE-1)
SDDS_Bomb("String is too long");
columnValues[col].stringValues[i] = malloc(size + 1);
if (size > 0) {
if (fread(columnValues[col].stringValues[i],size,1,fileID) != 1) {
SDDS_SetError("Unable to read string column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
columnValues[col].stringValues[i][size] = 0;
} else {
strcpy(columnValues[col].stringValues[i],"");
}
break;
case SDDS_CHARACTER:
if (fread(((char*)(columnValues[col].values)+i),1,1,fileID) != 1) {
SDDS_SetError("Unable to read character column");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
break;
}
}
}
}
if (rows > maxRows) {
if (!SDDS_LengthenTable(&SDDS_dataset, rows - maxRows)) {
SDDS_SetError("Unable to lengthen table");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
maxRows = rows;
}
j=n;
for (i=0;i<columns;i++) {
if (columnValues[i].skip)
continue;
if (columnValues[i].type == SDDS_STRING) {
SetColumnData(columnValues[i].type, &SDDS_dataset, columnValues[i].stringValues, rows, n);
} else {
SetColumnData(columnValues[i].type, &SDDS_dataset, columnValues[i].values, rows, n);
}
n++;
}
if (!SDDS_WritePage(&SDDS_dataset)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
maxRows = 10000;
if (!SDDS_StartPage(&SDDS_dataset, initRows))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
row = par = col = n = 0;
rows = -1;
ptr = NULL;
ptr = SDDS_Malloc(sizeof(*ptr)*(ptrSize=2048));
/* ptr2 = NULL;
ptr2 = SDDS_Malloc(sizeof(*ptr)*(ptrSize=2048));*/
ptr[0] = 0;
while (1) {
if (readline) {
while (skiplines > 0) {
fgets(ptr, ptrSize, fileID);
skiplines--;
}
if (!fgetsSkipCommentsResize(&ptr,&ptrSize,fileID, '!'))
break;
commentFound=0;
if (checkComment) {
for (i=0; i<strlen(commentCharacters); i++) {
if (ptr[0] == commentCharacters[i]) {
commentFound=1;
}
}
}
if (commentFound == 1) {
continue;
}
if (ptr[strlen(ptr)-1] == '\n')
ptr[strlen(ptr)-1] = 0;
strcpy(temp,ptr);
/*skip empty lines*/
if (getToken(temp,data,10240,separator,whitespace)<0)
continue;
} else {
readline = 1;
}
if (par < parameters) {
switch (parameterValues[par].type) {
case SDDS_SHORT:
if (sscanf(ptr,"%hd",&shortValue) != 1) {
SDDS_SetError("Invalid short parameter");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,shortValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
case SDDS_LONG:
if (sscanf(ptr,"%" SCNd32 ,&longValue) != 1) {
SDDS_SetError("Invalid long parameter");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,longValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
case SDDS_FLOAT:
ConvertDNotationToENotation(ptr);
if (sscanf(ptr,"%f",&floatValue) != 1) {
SDDS_SetError("Invalid float parameter");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,floatValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
case SDDS_DOUBLE:
ConvertDNotationToENotation(ptr);
if (sscanf(ptr,"%lf",&doubleValue) != 1) {
SDDS_SetError("Invalid double parameter");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,doubleValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
case SDDS_STRING:
SDDS_GetToken(ptr,stringValue,SDDS_MAXLINE);
SDDS_InterpretEscapes(stringValue);
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,stringValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
case SDDS_CHARACTER:
SDDS_InterpretEscapes(ptr);
characterValue = ptr[0];
if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,characterValue,-1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
}
par++;
} else if ((rows == -1) && (!noRowCount)) {
if (sscanf(ptr,"%ld",&rows) != 1) {
SDDS_SetError("Invalid row count");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
} else if ((columns > 0) && ((row < rows) || (noRowCount))) {
if (columnOrder) {
if (noRowCount) {
cp_str(&ptr2,ptr);
rows = 0;
while (getToken(ptr2,data,10240,separator,whitespace) >= 0) {
rows++;
}
free(ptr2);
}
if (rows > columnValues[col].elements) {
if (columnValues[col].type == SDDS_STRING) {
columnValues[col].stringValues = AllocateColumnStringData(columnValues[col].stringValues, rows, columnValues[col].elements);
} else {
columnValues[col].values = AllocateColumnData(columnValues[col].type, columnValues[col].values, rows);
}
columnValues[col].elements = rows;
}
switch (columnValues[col].type) {
case SDDS_SHORT:
for (row=0;row<rows;row++) {
if (getToken(ptr,data,10240,separator,whitespace) < 0) {
SDDS_SetError("Invalid short column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (sscanf(data,"%hd",((short*)(columnValues[col].values)+row)) != 1) {
SDDS_SetError("Invalid short column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_LONG:
for (row=0;row<rows;row++) {
if (getToken(ptr,data,10240,separator,whitespace) < 0) {
SDDS_SetError("Invalid long column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (sscanf(data,"%" SCNd32,((int32_t*)(columnValues[col].values)+row)) != 1) {
SDDS_SetError("Invalid long column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_FLOAT:
for (row=0;row<rows;row++) {
if (getToken(ptr,data,10240,separator,whitespace) < 0) {
SDDS_SetError("Invalid float column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
ConvertDNotationToENotation(data);
if (sscanf(data,"%f",((float*)(columnValues[col].values)+row)) != 1) {
SDDS_SetError("Invalid float column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_DOUBLE:
for (row=0;row<rows;row++) {
if (getToken(ptr,data,10240,separator,whitespace) < 0) {
SDDS_SetError("Invalid double column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
ConvertDNotationToENotation(data);
if (sscanf(data,"%lf",((double*)(columnValues[col].values)+row)) != 1) {
SDDS_SetError("Invalid double column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_STRING:
for (row=0;row<rows;row++) {
if (getToken(ptr,data,10240,separator,whitespace) < 0) {
SDDS_SetError("Invalid string column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
SDDS_InterpretEscapes(data);
columnValues[col].stringValues[row] = malloc(strlen(data) + 1);
strcpy(columnValues[col].stringValues[row],data);
}
break;
case SDDS_CHARACTER:
for (row=0;row<rows;row++) {
if (getToken(ptr,data,10240,separator,whitespace) < 0) {
SDDS_SetError("Invalid character column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
SDDS_InterpretEscapes(data);
*((char*)(columnValues[col].values)+row) = data[0];
}
break;
}
if (rows > maxRows) {
if (!SDDS_LengthenTable(&SDDS_dataset, rows - maxRows)) {
SDDS_SetError("Unable to lengthen table");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
maxRows = rows;
}
if (columnValues[col].skip == 0) {
if (columnValues[col].type == SDDS_STRING) {
SetColumnData(columnValues[col].type, &SDDS_dataset, columnValues[col].stringValues, rows, col);
} else {
SetColumnData(columnValues[col].type, &SDDS_dataset, columnValues[col].values, rows, col);
}
n++;
}
col++;
row = 0;
} else {
if (noRowCount) {
if (row == 0) {
rows = 3;
} else if (row == rows - 1) {
rows = rows + 3;
for (i=0;i<columns;i++) {
if (rows > columnValues[i].elements) {
if (columnValues[i].type == SDDS_STRING) {
columnValues[i].stringValues = AllocateColumnStringData(columnValues[i].stringValues, rows, columnValues[i].elements);
} else {
columnValues[i].values = AllocateColumnData(columnValues[i].type, columnValues[i].values, rows);
}
}
columnValues[i].elements = rows;
}
}
}
if (row == 0)
for (i=0;i<columns;i++) {
if (rows > columnValues[i].elements) {
if (columnValues[i].type == SDDS_STRING) {
columnValues[i].stringValues = AllocateColumnStringData(columnValues[i].stringValues, rows, columnValues[i].elements);
} else {
columnValues[i].values = AllocateColumnData(columnValues[i].type, columnValues[i].values, rows);
}
}
columnValues[i].elements = rows;
}
if (noRowCount) {
cp_str(&ptr2,ptr);
i = 0;
while (getToken(ptr2,data,10240,separator,whitespace) >= 0)
i++;
free(ptr2);
if ((i != columns) && (parameters>0 && i==1)) {
if (row > 0) {
if (row > maxRows) {
if (!SDDS_LengthenTable(&SDDS_dataset, row - maxRows)) {
SDDS_SetError("Unable to lengthen table");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
maxRows = row;
}
n=0;
for (j=0;j<columns;j++) {
if (columnValues[j].skip)
continue;
if (columnValues[j].type == SDDS_STRING) {
SetColumnData(columnValues[j].type, &SDDS_dataset, columnValues[j].stringValues, row, n);
} else {
SetColumnData(columnValues[j].type, &SDDS_dataset, columnValues[j].values, row, n);
}
n++;
}
if (!SDDS_WritePage(&SDDS_dataset))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
maxRows = 10000;
if (!SDDS_StartPage(&SDDS_dataset, initRows))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
row = par = col = 0;
rows = -1;
}
readline = 0;
continue;
}
}
for (i=0;i<columns;i++) {
if (getToken(ptr,data,10240,separator,whitespace) < 0) {
if (!fillin) {
SDDS_SetError("Invalid column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
} else {
switch (columnValues[i].type) {
case SDDS_SHORT:
case SDDS_LONG:
case SDDS_FLOAT:
case SDDS_DOUBLE:
data[0]='0';
data[1]='\0';
break;
case SDDS_STRING:
case SDDS_CHARACTER:
data[0]='\0';
break;
}
}
}
switch (columnValues[i].type) {
case SDDS_SHORT:
if (sscanf(data,"%hd",((short*)(columnValues[i].values)+row)) != 1) {
if (recover) {
abort=1;
row--;
} else {
SDDS_SetError("Invalid short column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_LONG:
if (sscanf(data,"%" SCNd32,((int32_t*)(columnValues[i].values)+row)) != 1) {
if (recover) {
abort=1;
row--;
} else {
SDDS_SetError("Invalid long column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_FLOAT:
ConvertDNotationToENotation(data);
if (sscanf(data,"%f",((float*)(columnValues[i].values)+row)) != 1) {
if (recover) {
abort=1;
row--;
} else {
SDDS_SetError("Invalid float column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_DOUBLE:
ConvertDNotationToENotation(data);
if (sscanf(data,"%lf",((double*)(columnValues[i].values)+row)) != 1) {
if (recover) {
abort=1;
row--;
} else {
SDDS_SetError("Invalid double column element");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
break;
case SDDS_STRING:
SDDS_InterpretEscapes(data);
columnValues[i].stringValues[row] = malloc(strlen(data) + 1);
strcpy(columnValues[i].stringValues[row],data);
break;
case SDDS_CHARACTER:
SDDS_InterpretEscapes(data);
*((char*)(columnValues[i].values)+row) = data[0];
break;
}
if (recover && abort) {
break;
}
}
row++;
if ((row == rows) && (!noRowCount)) {
if (rows > maxRows) {
if (!SDDS_LengthenTable(&SDDS_dataset, rows - maxRows)) {
SDDS_SetError("Unable to lengthen table");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
maxRows = rows;
}
n=0;
for (i=0;i<columns;i++) {
if (columnValues[i].skip)
continue;
if (columnValues[i].type == SDDS_STRING) {
SetColumnData(columnValues[i].type, &SDDS_dataset, columnValues[i].stringValues, rows, n);
} else {
SetColumnData(columnValues[i].type, &SDDS_dataset, columnValues[i].values, rows, n);
}
n++;
}
}
}
}
if ((par == parameters) &&
(((!noRowCount) && (rows != -1)) || (noRowCount)) &&
(((columnOrder) && (col == columns)) || ((columns > 0) && (row == rows)) || (columns == 0))) {
if (!SDDS_WritePage(&SDDS_dataset)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
maxRows = 10000;
if (!SDDS_StartPage(&SDDS_dataset, initRows))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
row = par = col = 0;
rows = -1;
}
ptr[0] = 0;
}
if (noRowCount) {
if (row > 0) {
if (row > maxRows) {
if (!SDDS_LengthenTable(&SDDS_dataset, row - maxRows)) {
SDDS_SetError("Unable to lengthen table");
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
maxRows = row;
}
n=0;
for (j=0;j<columns;j++) {
if (columnValues[j].skip)
continue;
if (columnValues[j].type == SDDS_STRING) {
SetColumnData(columnValues[j].type, &SDDS_dataset, columnValues[j].stringValues, row, n);
} else {
SetColumnData(columnValues[j].type, &SDDS_dataset, columnValues[j].values, row, n);
}
n++;
}
if (!SDDS_WritePage(&SDDS_dataset)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
maxRows = 10000;
}
}
for (i=0;i<columns;i++) {
if (columnValues[i].type == SDDS_STRING) {
for (j=0;j<columnValues[i].elements;j++) {
free(columnValues[i].stringValues[j]);
}
free(columnValues[i].stringValues);
} else {
free(columnValues[i].values);
}
if (columnValues[i].name) free(columnValues[i].name);
if (columnValues[i].units) free(columnValues[i].units);
if (columnValues[i].description) free(columnValues[i].description);
if (columnValues[i].symbol) free(columnValues[i].symbol);
}
for (i=0;i<parameters;i++) {
free(parameterValues[i].name);
if (parameterValues[i].units) free(parameterValues[i].units);
if (parameterValues[i].description) free(parameterValues[i].description);
if (parameterValues[i].symbol) free(parameterValues[i].symbol);
}
if (columnValues) free(columnValues);
if (parameterValues) free(parameterValues);
if (columnIndex) free(columnIndex);
if (parameterIndex) free(parameterIndex);
if (ptr) free(ptr);
if (!SDDS_Terminate(&SDDS_dataset))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
free_scanargs(&s_arg,argc);
return 0;
}