/*--------------------------------------------------------------------------*/ static line_status iniparser_line( char * input_line, char * section, char * key, char * value) { line_status sta ; char line[ASCIILINESZ+1]; char l[ASCIILINESZ+1]; int len ; strcpy(line, strstrip(l, input_line)); len = (int)strlen(line); sta = LINE_UNPROCESSED ; if (len<1) { /* Empty line */ sta = LINE_EMPTY ; } else if (line[0]=='#') { /* Comment line */ sta = LINE_COMMENT ; } else if (line[0]=='[' && line[len-1]==']') { /* Section name */ sscanf(line, "[%[^]]", section); strcpy(section, strstrip(l, section)); strcpy(section, strlwc(l, section)); sta = LINE_SECTION ; } else if (sscanf (line, "%[^=] = \"%[^\"]\"", key, value) == 2 || sscanf (line, "%[^=] = '%[^\']'", key, value) == 2 || sscanf (line, "%[^=] = %[^;#]", key, value) == 2) { /* Usual key=value, with or without comments */ strcpy(key, strstrip(l, key)); strcpy(key, strlwc(l, key)); strcpy(value, strstrip(l, value)); /* * sscanf cannot handle '' or "" as empty values * this is done here */ if (!strcmp(value, "\"\"") || (!strcmp(value, "''"))) { value[0]=0 ; } sta = LINE_VALUE ; } else if (sscanf(line, "%[^=] = %[;#]", key, value)==2 || sscanf(line, "%[^=] %[=]", key, value) == 2) { /* * Special cases: * key= * key=; * key=# */ strcpy(key, strstrip(l, key)); strcpy(key, strlwc(l, key)); value[0]=0 ; sta = LINE_VALUE ; } else { /* Generate syntax error */ sta = LINE_ERROR ; } return sta ; }
dictionary * iniparser_load(const char * ininame) { dictionary * d ; char lin[ASCIILINESZ+1]; char sec[ASCIILINESZ+1]; char key[ASCIILINESZ+1]; char val[ASCIILINESZ+1]; char * where ; FILE * ini ; int lineno ; if ((ini=fopen(ininame, "r"))==NULL) { return NULL ; } sec[0]=0; /* * Initialize a new dictionary entry */ if (!(d = dictionary_new(0))) { fclose(ini); return NULL; } lineno = 0 ; while (fgets(lin, ASCIILINESZ, ini)!=NULL) { lineno++ ; where = strskp(lin); /* Skip leading spaces */ if (*where==';' || *where=='#' || *where==0) continue ; /* Comment lines */ else { if (sscanf(where, "[%[^]]", sec)==1) { /* Valid section name */ strcpy(sec, strlwc(sec)); iniparser_add_entry(d, sec, NULL, NULL); } else if (sscanf (where, "%[^=] = \"%[^\"]\"", key, val) == 2 || sscanf (where, "%[^=] = '%[^\']'", key, val) == 2 || sscanf (where, "%[^=] = %[^;#]", key, val) == 2) { strcpy(key, strlwc(strcrop(key))); /* * sscanf cannot handle "" or '' as empty value, * this is done here */ if (!strcmp(val, "\"\"") || !strcmp(val, "''")) { val[0] = (char)0; } else { strcpy(val, strcrop(val)); } iniparser_add_entry(d, sec, key, val); } } } fclose(ini); return d ; }
/*--------------------------------------------------------------------------*/ int iniparser_getsecnkeys(const dictionary * d, const char * s) { int seclen, nkeys ; char keym[ASCIILINESZ+1]; int j ; nkeys = 0; if (d==NULL) return nkeys; if (! iniparser_find_entry(d, s)) return nkeys; seclen = (int)strlen(s); strlwc(s, keym, sizeof(keym)); keym[seclen] = ':'; for (j=0 ; j<d->size ; j++) { if (d->key[j]==NULL) continue ; if (!strncmp(d->key[j], keym, seclen+1)) nkeys++; } return nkeys; }
MODULE get_command (THREAD *thread) { char *value; tcb = thread-> tcb; /* Point to thread's context */ strcrop (buffer); strlwc (buffer); value = strskp (buffer); if (value != buffer) strcpy (buffer, value); if (strnull (buffer)) the_next_event = none_event; else if (streq (buffer, "help")) the_next_event = help_event; else if (strchr (buffer, '?')) the_next_event = help_event; else if (strncmp (buffer, "set server", 10) == 0) the_next_event = server_ip_event; else if (streq (buffer, "set debug")) the_next_event = debug_event; else if (streq (buffer, "set recursive")) the_next_event = recursive_event; else if (streq (buffer, "exit")) the_next_event = exit_event; else if (streq (buffer, "quit")) the_next_event = exit_event; else { if (strchr (buffer, ' ') != NULL) the_next_event = invalid_event; else the_next_event = request_event; } }
/*--------------------------------------------------------------------------*/ void iniparser_unset(dictionary * ini, const char * entry) { char* lc_entry = xstrdup(entry); strlwc(lc_entry); dictionary_unset(ini, lc_entry); free(lc_entry); }
/*--------------------------------------------------------------------------*/ char * iniparser_getstring(dictionary * d, char * key, char * def) { char lc_key[ASCIILINESZ+1]; if (d==NULL || key==NULL) return def ; return dictionary_get(d, strlwc(key, lc_key), def); }
/*--------------------------------------------------------------------------*/ int iniparser_set(dictionary * ini, const char * entry, const char * val) { int result = 0; char *lc_entry = xstrdup(entry); strlwc(lc_entry); result = dictionary_set(ini, lc_entry, val) ; free(lc_entry); return result; }
/*--------------------------------------------------------------------------*/ char * iniparser_getstring(dictionary * d, const char * key, char * def) { char * lc_key; char * sval; if (d == NULL || key == NULL) return def; lc_key = strlwc(key); sval = dictionary_get(d, lc_key, def); return sval; }
int main(int argc, char * argv[]) { char * str ; str = "\t\tI'm a lumberkack and I'm OK " ; printf("lowercase: [%s]\n", strlwc(str)); printf("uppercase: [%s]\n", strupc(str)); printf("skipped : [%s]\n", strskp(str)); printf("cropped : [%s]\n", strcrop(str)); printf("stripped : [%s]\n", strstrip(str)); return 0 ; }
/*--------------------------------------------------------------------------*/ const char * iniparser_getstring(const dictionary * d, const char * key, const char * def) { const char * lc_key ; const char * sval ; char tmp_str[ASCIILINESZ+1]; if (d==NULL || key==NULL) return def ; lc_key = strlwc(key, tmp_str, sizeof(tmp_str)); sval = dictionary_get(d, lc_key, def); return sval ; }
const char *rtl_ini_get_string(const rtl_dict_t *d, const char *key, const char *def) { const char *lc_key; const char *sval; char tmp_str[ASCIILINESZ + 1]; if (d == NULL || key == NULL) return def; lc_key = strlwc(key, tmp_str, sizeof(tmp_str)); sval = rtl_dict_get(d, lc_key, def); return sval; }
/*--------------------------------------------------------------------------*/ char* iniparser_getstring (dictionary * d, char * key, char * def) { char * lc_key; char * sval; if (!d || !key) return def; lc_key = strdup (strlwc (key)); sval = dictionary_get (d, lc_key, def); free (lc_key); return sval; }
/*--------------------------------------------------------------------------*/ char * iniparser_getstring(dictionary * d, const char * key, char * def) { char * lc_key ; char * sval ; if (d==NULL || key==NULL) return def ; if (!(lc_key = strdup(strlwc(key)))) { return NULL; } sval = dictionary_get(d, lc_key, def); free(lc_key); return sval ; }
char * ini_dyn_value ( SYMTAB *symtab, const char *section, const char *keyword, const char *default_value) { ASSERT (section); if (keyword && *keyword) snprintf (ini_keyword, sizeof (ini_keyword), "%s:%s", section, keyword); else strncpy (ini_keyword, section, sizeof (ini_keyword)); strlwc (ini_keyword); return (sym_get_value (symtab, ini_keyword, default_value)); }
MODULE get_confirmation_for_stop (THREAD *thread) { printf ("Do you really want to stop all tasks (n)? "); fflush (stdout); if (fgets (input_line, LINE_MAX, stdin) == NULL) strclr (input_line); /* Treat EOF as empty */ strlwc (input_line); if (input_line [0] == 'y') the_next_event = ok_event; else { the_next_event = cancel_event; printf ("syscli> 211 - cancelled\n"); } }
MODULE invoke_active_program (void) { int prognbr, /* Index into program list */ rc; strlwc (session.program_name); /* Compare lwc with lwc */ rc = FEEDBACK_UNKNOWN; /* Assume not found */ for (prognbr = 0; wtp_broker_map [prognbr].name; prognbr++) { if (streq (session.program_name, wtp_broker_map [prognbr].name)) { rc = ((ATP_FCT) wtp_broker_map [prognbr].function) (&session); break; } } switch (rc) { case FEEDBACK_SHOW: the_next_event = show_event; break; case FEEDBACK_CALL: the_next_event = call_event; break; case FEEDBACK_RETURN: the_next_event = return_event; break; case FEEDBACK_UNKNOWN: the_next_event = not_found_event; break; case FEEDBACK_ERROR: the_next_event = error_event; break; default: the_next_event = exit_event; break; } if (dbio_commit () != TRUE) { fprintf (stderr, "Error on commit: %d: %s", dbio_error_code (), dbio_error_message ()); } }
MODULE store_time_slot_specification (THREAD *thread) { struct_smtslot_specification *message; SPEC *spec; /* Spec we create */ tcb = thread-> tcb; /* Point to thread's context */ /* Get fields from event body; just copy, don't parse them yet */ get_smtslot_specification (thread-> event-> body, &message); tcb-> reply_to = thread-> event-> sender; if ((spec = node_create (tcb-> specs.prev, sizeof (SPEC))) == NULL) send_smtslot_error (&tcb-> reply_to, "Out of memory"); else /* Store day and times for slot */ spec-> times = strlwc (mem_strdup (message-> times)); free_smtslot_specification (&message); }
MODULE get_next_argument (THREAD *thread) { char *value; tcb = thread-> tcb; /* Point to thread's context */ if (++tcb-> arg_index <= tcb-> argc) { value = tcb-> argv [tcb-> arg_index - 1]; if (*value == '-') { value++; strcrop (value); strlwc (value); value = strskp (value); if (streq (value, "debug")) strcpy (buffer, "set debug"); else if (streq (value, "rec")) strcpy (buffer, "set recursive"); else if (streq (value, "server")) { if (++tcb-> arg_index <= tcb-> argc) xstrcpy (buffer, "set server ", tcb-> argv [tcb-> arg_index - 1], NULL); else strcpy (buffer, "set server"); } else strcpy (buffer, value); } else strcpy (buffer, value); } else buffer [0] = '\0'; }
int conv_str_day ( const char *string) { static char *day_name [] = { "sun", "mon", "tue", "wed", "thu", "fri", "sat" }; int day; char day_comp [4]; /* Get up to three letters of day name and convert to lower case */ strncpy (day_comp, string, 3); day_comp [3] = '\0'; strlwc (day_comp); /* I don't like magic constants, but "7" is pretty safe for now */ for (day = 0; day < 7; day++) if (streq (day_name [day], day_comp)) break; return (day >= 7? -1: day); }
/*--------------------------------------------------------------------------*/ int iniparser_set(dictionary * ini, char * entry, char * val) { return dictionary_set(ini, strlwc(entry), val) ; }
/*--------------------------------------------------------------------------*/ void iniparser_unset(dictionary * ini, char * entry) { dictionary_unset(ini, strlwc(entry)); }
/*--------------------------------------------------------------------------*/ static line_status iniparser_line( const char * input_line, char * section, char * key, char * value) { line_status sta ; char * line = NULL; size_t len ; line = xstrdup(input_line); len = strstrip(line); sta = LINE_UNPROCESSED ; if (len<1) { /* Empty line */ sta = LINE_EMPTY ; } else if (line[0]=='#' || line[0]==';') { /* Comment line */ sta = LINE_COMMENT ; } else if (line[0]=='[' && line[len-1]==']') { /* Section name */ sscanf(line, "[%[^]]", section); strstrip(section); strlwc(section, section, len); sta = LINE_SECTION ; } else if (sscanf (line, "%[^=] = \"%[^\"]\"", key, value) == 2 || sscanf (line, "%[^=] = '%[^\']'", key, value) == 2) { /* Usual key=value with quotes, with or without comments */ strstrip(key); strlwc(key, key, len); /* Don't strip spaces from values surrounded with quotes */ sta = LINE_VALUE ; } else if (sscanf (line, "%[^=] = %[^;#]", key, value) == 2) { /* Usual key=value without quotes, with or without comments */ strstrip(key); strlwc(key, key, len); strstrip(value); /* * sscanf cannot handle '' or "" as empty values * this is done here */ if (!strcmp(value, "\"\"") || (!strcmp(value, "''"))) { value[0]=0 ; } sta = LINE_VALUE ; } else if (sscanf(line, "%[^=] = %[;#]", key, value)==2 || sscanf(line, "%[^=] %[=]", key, value) == 2) { /* * Special cases: * key= * key=; * key=# */ strstrip(key); strlwc(key, key, len); value[0]=0 ; sta = LINE_VALUE ; } else { /* Generate syntax error */ sta = LINE_ERROR ; } free(line); return sta ; }
void Test_iniparser_strlwc(CuTest *tc) { char out_buffer[128]; /* NULL ptr as input */ CuAssertPtrEquals(tc, NULL, strlwc(NULL, NULL, 0)); CuAssertPtrEquals(tc, NULL, strlwc(NULL, out_buffer, sizeof (out_buffer))); CuAssertPtrEquals(tc, NULL, strlwc("", NULL, sizeof (out_buffer))); CuAssertPtrEquals(tc, NULL, strlwc("", out_buffer, 0)); CuAssertPtrEquals(tc, NULL, strlwc(NULL, NULL, 0)); /* empty string */ CuAssertStrEquals(tc, "", strlwc("", out_buffer, sizeof (out_buffer))); CuAssertStrEquals(tc, " ", strlwc(" ", out_buffer, sizeof (out_buffer))); CuAssertStrEquals(tc, "test", strlwc("test", out_buffer, sizeof (out_buffer))); CuAssertStrEquals(tc, "test", strlwc("TEST", out_buffer, sizeof (out_buffer))); CuAssertStrEquals(tc, "test", strlwc("TeSt", out_buffer, sizeof (out_buffer))); CuAssertStrEquals(tc, "test test", strlwc("TEST TEST", out_buffer, sizeof (out_buffer))); CuAssertStrEquals(tc, "very long string !!!!!!!", strlwc("very long string !!!!!!!", out_buffer, sizeof (out_buffer))); CuAssertStrEquals(tc, "cutted string", strlwc("cutted string<---here", out_buffer, 14)); /* test using same buffer as input and output */ strcpy(out_buffer, "OVERWRITE ME !"); CuAssertPtrNotNull(tc, strlwc(out_buffer, out_buffer, sizeof(out_buffer))); CuAssertStrEquals(tc, "overwrite me !", out_buffer); }
/*--------------------------------------------------------------------------*/ int iniparser_set(dictionary * ini, const char * entry, const char * val) { char tmp_str[ASCIILINESZ+1]; return dictionary_set(ini, strlwc(entry, tmp_str, sizeof(tmp_str)), val) ; }
/*--------------------------------------------------------------------------*/ void iniparser_unset(dictionary * ini, const char * entry) { char tmp_str[ASCIILINESZ+1]; dictionary_unset(ini, strlwc(entry, tmp_str, sizeof(tmp_str))); }
/*--------------------------------------------------------------------------*/ int iniparser_set(dictionary * ini, char * entry, char * val) { char l[ASCIILINESZ+1]; return dictionary_set(ini, strlwc(l, entry), val) ; }
/*--------------------------------------------------------------------------*/ void iniparser_unset(dictionary * ini, char * entry) { char l[ASCIILINESZ+1]; dictionary_unset(ini, strlwc(l, entry)); }
int ciniparser_set(dictionary *d, char *entry, char *val) { return dictionary_set(d, strlwc(entry), val); }
/*--------------------------------------------------------------------------*/ static line_status iniparser_line( int line_size, const char * input_line, char ** section_out, char ** key_out, char ** value_out) { line_status sta ; int len = line_size-1; char * line = malloc(line_size); char * key = NULL; char * value = NULL; char * equals = NULL; if (!line) { fprintf(stderr, "iniparser: memory alloc error\n"); return LINE_ERROR; } *line = 0; strcpy(line, input_line); strstrip(line); len = (int)strlen(line); /* only allocate necessary space for key & val */ equals = strchr(line, '='); if (equals) { value = malloc((len + line) - equals + 1); key = malloc(equals - line + 1); *value = 0; } else { key = malloc(line_size + 1); } if (!key || (equals && !value)) { fprintf(stderr, "iniparser: memory alloc error\n"); sta = LINE_ERROR; goto out; } *key = 0; sta = LINE_UNPROCESSED ; if (len<1) { /* Empty line */ sta = LINE_EMPTY ; } else if (line[0]=='#' || line[0]==';') { /* Comment line */ sta = LINE_COMMENT ; } else if (line[0]=='[' && line[len-1]==']') { /* Section name */ sscanf(line, "[%[^]]", key); strstrip(key); strlwc(key); sta = LINE_SECTION ; *section_out=key; /* don't free key's memory */ key = NULL; } else if (equals && (sscanf (line, "%[^=] = \"%[^\"]\"", key, value) == 2 || sscanf (line, "%[^=] = '%[^\']'", key, value) == 2 || sscanf (line, "%[^=] = %[^;#]", key, value) == 2)) { /* Usual key=value, with or without comments */ strstrip(key); strlwc(key); strstrip(value); /* * sscanf cannot handle '' or "" as empty values * this is done here */ if (!strcmp(value, "\"\"") || (!strcmp(value, "''"))) { value[0]=0 ; } *key_out = key; *value_out = value; key = NULL; value = NULL; sta = LINE_VALUE ; } else if (equals && (sscanf(line, "%[^=] = %[;#]", key, value)==2 || sscanf(line, "%[^=] %[=]", key, value) == 2)) { /* * Special cases: * key= * key=; * key=# */ strstrip(key); strlwc(key); value[0]=0 ; *key_out = key; *value_out = value; /* don't free out params key or val's memory */ key = NULL; value = NULL; sta = LINE_VALUE ; } else { /* Generate syntax error */ sta = LINE_ERROR ; } out: if (line) { free(line); line = NULL; } if (key) { free(key); key = NULL; } if (value) { free(value); value= NULL; } return sta ; }
/*--------------------------------------------------------------------------*/ int iniparser_setstr (dictionary * ini, char * entry, char * val) { dictionary_set (ini, strlwc (entry), val); return 0; }