/**
* Sub function to Add a dictionary entry line to the word dictionary.
*
* @param buf [i/o] buffer to hold the input string, will be modified in this function
* @param vnum_p [in] current number of words in @a winfo
* @param linenum [in] current line number of the input
* @param winfo [out] pointer to word dictionary to append the data.
* @param hmminfo [in] HTK %HMM definition data. if NULL, phonemes are ignored.
* @param do_conv [in] TRUE if performing triphone conversion
* @param ok_flag [out] will be set to FALSE if an error occured for this input.
* @param headphone [in] word head silence model name
* @param tailphone [in] word tail silence model name
* @param contextphone [in] silence context name to be used at head and tail
*
* @return FALSE if buf == "DICEND", else TRUE will be returned.
*/
boolean
voca_load_wordlist_line(char *buf, WORD_ID *vnum_p, int linenum, WORD_INFO *winfo, HTK_HMM_INFO *hmminfo, boolean do_conv, boolean *ok_flag, char *headphone, char *tailphone, char *contextphone)
{
char *ptmp, *lp = NULL, *p;
static char cbuf[MAX_HMMNAME_LEN];
static HMM_Logical **tmpwseq = NULL;
static int tmpmaxlen;
int i, len;
HMM_Logical *tmplg;
boolean pok, first;
int vnum;
vnum = *vnum_p;
if (strmatch(buf, "DICEND")) return FALSE;
/* allocate temporal work area for the first call */
if (tmpwseq == NULL) {
tmpmaxlen = PHONEMELEN_STEP;
tmpwseq = (HMM_Logical **)mymalloc(sizeof(HMM_Logical *) * tmpmaxlen);
}
/* backup whole line for debug output */
strcpy(bufbak, buf);
/* Output string */
if ((ptmp = mystrtok_quote(buf, " \t\n")) == NULL) {
jlog("Error: voca_load_wordlist: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
winfo->wname[vnum] = strcpy((char *)mybmalloc2(strlen(ptmp)+1, &(winfo->mroot)), ptmp);
/* reset transparent flag */
winfo->is_transparent[vnum] = FALSE;
/* just move pointer to next token */
if ((ptmp = mystrtok_movetonext(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_wordlist: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
#ifdef CLASS_NGRAM
winfo->cprob[vnum] = 0.0; /* prob = 1.0, logprob = 0.0 */
#endif
if (ptmp[0] == '@') { /* class N-gram prob */
#ifdef CLASS_NGRAM
/* word probability within the class (for class N-gram) */
/* format: classname @classprob wordname [output] phoneseq */
/* classname equals to wname, and wordname will be omitted */
/* format: @%f (log scale) */
/* if "@" not found or "@0", it means class == word */
if ((ptmp = mystrtok(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_wordlist: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
if (ptmp[1] == '\0') { /* space between '@' and figures */
jlog("Error: voca_load_wordlist: line %d: value after '@' missing, maybe wrong space?\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
winfo->cprob[vnum] = atof(&(ptmp[1]));
if (winfo->cprob[vnum] != 0.0) winfo->cwnum++;
/* read next word entry (just skip them) */
if ((ptmp = mystrtok(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_wordlist: line %d: corrupted data:\n> %s\n", linenum,bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
/* move to the next word entry */
if ((ptmp = mystrtok_movetonext(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_wordlist: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
#else /* ~CLASS_NGRAM */
jlog("Error: voca_load_wordlist: line %d: cannot handle in-class word probability\n> %s\n", linenum, ptmp, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
#endif /* CLASS_NGRAM */
}
/* OutputString */
switch(ptmp[0]) {
case '[': /* ignore transparency */
ptmp = mystrtok_quotation(NULL, " \t\n", '[', ']', 0);
break;
case '{': /* ignore transparency */
ptmp = mystrtok_quotation(NULL, " \t\n", '{', '}', 0);
break;
default:
/* ALLOW no entry for output */
/* same as wname is used */
ptmp = winfo->wname[vnum];
}
if (ptmp == NULL) {
jlog("Error: voca_load_wordlist: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
winfo->woutput[vnum] = strcpy((char *)mybmalloc2(strlen(ptmp)+1, &(winfo->mroot)), ptmp);
#ifdef USE_MBR
/* just move pointer to next token */
if ((ptmp = mystrtok_movetonext(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_wordlist: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
if (ptmp[0] == ':') { /* Word weight (use minimization WWER on MBR) */
/* Word weight (use minimization WWER on MBR) */
/* format: (classname @classprob) wordname [output] :weight phoneseq */
/* format: :%f (linear scale) */
/* if ":" not found, it means weight == 1.0 (same minimization WER) */
if ((ptmp = mystrtok(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_wordlist: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
if ((ptmp[1] < '0' || ptmp[1] > '9') && ptmp[1] != '.') { /* not figure after ':' */
jlog("Error: voca_load_wordlist: line %d: value after ':' missing, maybe wrong space?\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
/* allocate if not yet */
if (winfo->weight == NULL) {
winfo->weight = (LOGPROB *)mymalloc(sizeof(LOGPROB) * winfo->maxnum);
for (i = 0; i < vnum; i++) {
winfo->weight[i] = 1.0;
}
}
winfo->weight[vnum] = atof(&(ptmp[1]));
}
else {
if (winfo->weight)
winfo->weight[vnum] = 1.0; /* default, same minimization WER */
}
#endif
/* phoneme sequence */
if (hmminfo == NULL) {
/* don't read */
winfo->wseq[vnum] = NULL;
winfo->wlen[vnum] = 0;
} else {
len = 0;
first = TRUE;
pok = TRUE;
for (;;) {
if (do_conv) {
if (first) {
/* init phone cycler */
cycle_triphone(NULL);
/* insert head phone at beginning of word */
if (contextphone) {
if (strlen(contextphone) >= MAX_HMMNAME_LEN) {
jlog("Error: voca_load_wordlist: line %d: too long phone name: %s\n", linenum, contextphone);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
cycle_triphone(contextphone);
} else {
cycle_triphone("NULL_C");
}
if ((lp = mystrtok(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_wordlist: line %d: word %s has no phoneme:\n> %s\n", linenum, winfo->wname[vnum], bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
if (strlen(lp) >= MAX_HMMNAME_LEN) {
jlog("Error: voca_load_wordlist: line %d: too long phone name: %s\n", linenum, lp);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
p = cycle_triphone(lp);
first = FALSE;
} else { /* do_conv, not first */
if (lp != NULL) { /* some token processed at last loop */
lp = mystrtok(NULL, " \t\n");
if (lp != NULL) {
/* token exist */
if (strlen(lp) >= MAX_HMMNAME_LEN) {
jlog("Error: voca_load_wordlist: line %d: too long phone name: %s\n", linenum, lp);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
p = cycle_triphone(lp);
} else {
/* no more token, insert tail phone at end of word */
if (contextphone) {
if (strlen(contextphone) >= MAX_HMMNAME_LEN) {
jlog("Error: voca_load_wordlist: line %d: too long phone name: %s\n", linenum, contextphone);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
p = cycle_triphone(contextphone);
} else {
p = cycle_triphone("NULL_C");
}
}
} else { /* no more token at last input */
/* flush tone cycler */
p = cycle_triphone_flush();
}
}
} else { /* not do_conv */
if (first) {
p = lp = headphone;
first = FALSE;
} else {
if (lp != NULL) { /* some token processed at last loop */
p = lp = mystrtok(NULL, " \t\n");
/* if no more token, use tailphone */
if (lp == NULL) p = tailphone;
} else {
/* no more token at last input, exit loop */
p = NULL;
}
}
}
if (p == NULL) break;
/* for headphone and tailphone, their context should not be handled */
/* and when they appear as context they should be replaced by contextphone */
if (do_conv) {
center_name(p, cbuf);
if (contextphone) {
if (strmatch(cbuf, contextphone)) {
if (len == 0) {
p = headphone;
} else if (lp == NULL) {
p = tailphone;
}
}
} else {
if (strmatch(cbuf, "NULL_C")) {
if (len == 0) {
p = headphone;
} else if (lp == NULL) {
p = tailphone;
}
} else {
if (strnmatch(p, "NULL_C", 6)) {
if (strnmatch(&(p[strlen(p)-6]), "NULL_C", 6)) {
p = cbuf;
} else {
p = rightcenter_name(p, cbuf);
}
} else if (strnmatch(&(p[strlen(p)-6]), "NULL_C", 6)) {
p = leftcenter_name(p, cbuf);
}
}
}
}
//printf("[[%s]]\n", p);
/* both defined/pseudo phone is allowed */
tmplg = htk_hmmdata_lookup_logical(hmminfo, p);
if (tmplg == NULL) {
/* not found */
if (do_conv) {
/* logical phone was not found */
jlog("Error: voca_load_wordlist: line %d: logical phone \"%s\" not found\n", linenum, p);
snprintf(cbuf,MAX_HMMNAME_LEN,"%s", p);
} else {
jlog("Error: voca_load_wordlist: line %d: phone \"%s\" not found\n", linenum, p);
snprintf(cbuf, MAX_HMMNAME_LEN, "%s", p);
}
add_to_error(winfo, cbuf);
pok = FALSE;
} else {
/* found */
if (len >= tmpmaxlen) {
/* expand wseq area by PHONEMELEN_STEP */
tmpmaxlen += PHONEMELEN_STEP;
tmpwseq = (HMM_Logical **)myrealloc(tmpwseq, sizeof(HMM_Logical *) * tmpmaxlen);
}
/* store to temporal buffer */
tmpwseq[len] = tmplg;
}
len++;
}
if (!pok) { /* error in phoneme */
jlog("Error: voca_load_wordlist: the line content was: %s\n", bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
if (len == 0) {
jlog("Error: voca_load_wordlist: line %d: no phone specified:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
/* store to winfo */
winfo->wseq[vnum] = (HMM_Logical **)mybmalloc2(sizeof(HMM_Logical *) * len, &(winfo->mroot));
memcpy(winfo->wseq[vnum], tmpwseq, sizeof(HMM_Logical *) * len);
winfo->wlen[vnum] = len;
winfo->wton[vnum] = 0;
}
vnum++;
*vnum_p = vnum;
return(TRUE);
}
struct einit_cron_job *einit_cron_parse_attrs_to_cron_job (char **attributes) {
if (!attributes) return NULL;
struct einit_cron_job *cj = emalloc (sizeof (struct einit_cron_job));
uint32_t i = 0;
memset (cj, 0, sizeof (struct einit_cron_job));
for (; attributes[i]; i+=2) {
if (strmatch (attributes[i], "command")) {
cj->command = estrdup(attributes[i+1]);
} else if (strmatch (attributes[i], "id")) {
cj->id = estrdup(attributes[i+1]);
} else if (strmatch (attributes[i], "years") || strmatch (attributes[i], "year")) {
char **x = str2set (':', attributes[i+1]);
uint32_t j = 0;
for (; x[j]; j++) {
uintptr_t num = parse_integer (x[j]);
if (num) {
cj->years = (uintptr_t *)setadd ((void **)cj->years, (void *)num, SET_NOALLOC);
}
}
free (x);
} else if (strmatch (attributes[i], "months") || strmatch (attributes[i], "month")) {
char **x = str2set (':', attributes[i+1]);
uint32_t j = 0;
for (; x[j]; j++) {
uintptr_t num = parse_integer (x[j]);
if (num) {
cj->months = (uintptr_t *)setadd ((void **)cj->months, (void *)num, SET_NOALLOC);
}
}
free (x);
} else if (strmatch (attributes[i], "days") || strmatch (attributes[i], "day")) {
char **x = str2set (':', attributes[i+1]);
uint32_t j = 0;
for (; x[j]; j++) {
uintptr_t num = parse_integer (x[j]);
if (num) {
cj->days = (uintptr_t *)setadd ((void **)cj->days, (void *)num, SET_NOALLOC);
}
}
free (x);
} else if (strmatch (attributes[i], "hours") || strmatch (attributes[i], "hour")) {
char **x = str2set (':', attributes[i+1]);
uint32_t j = 0;
for (; x[j]; j++) {
uintptr_t num = parse_integer (x[j]);
if (num) {
cj->hours = (uintptr_t *)setadd ((void **)cj->hours, (void *)num, SET_NOALLOC);
}
}
free (x);
} else if (strmatch (attributes[i], "minutes") || strmatch (attributes[i], "minute")) {
char **x = str2set (':', attributes[i+1]);
uint32_t j = 0;
for (; x[j]; j++) {
uintptr_t num = parse_integer (x[j]);
if (num) {
cj->minutes = (uintptr_t *)setadd ((void **)cj->minutes, (void *)num, SET_NOALLOC);
}
}
free (x);
} else if (strmatch (attributes[i], "seconds") || strmatch (attributes[i], "second")) {
char **x = str2set (':', attributes[i+1]);
uint32_t j = 0;
for (; x[j]; j++) {
uintptr_t num = parse_integer (x[j]);
if (num) {
cj->seconds = (uintptr_t *)setadd ((void **)cj->seconds, (void *)num, SET_NOALLOC);
}
}
free (x);
} else if (strmatch (attributes[i], "weekdays") || strmatch (attributes[i], "weekday")) {
char **x = str2set (':', attributes[i+1]);
uint32_t j = 0;
for (; x[j]; j++) {
if (strmatch (x[j], "sunday")) {
cj->weekdays = (uintptr_t *)setadd ((void **)cj->weekdays, (void *)0, SET_NOALLOC);
} else if (strmatch (x[j], "monday")) {
cj->weekdays = (uintptr_t *)setadd ((void **)cj->weekdays, (void *)1, SET_NOALLOC);
} else if (strmatch (x[j], "tuesday")) {
cj->weekdays = (uintptr_t *)setadd ((void **)cj->weekdays, (void *)2, SET_NOALLOC);
} else if (strmatch (x[j], "wednesday")) {
cj->weekdays = (uintptr_t *)setadd ((void **)cj->weekdays, (void *)3, SET_NOALLOC);
} else if (strmatch (x[j], "thursday")) {
cj->weekdays = (uintptr_t *)setadd ((void **)cj->weekdays, (void *)4, SET_NOALLOC);
} else if (strmatch (x[j], "friday")) {
cj->weekdays = (uintptr_t *)setadd ((void **)cj->weekdays, (void *)5, SET_NOALLOC);
} else if (strmatch (x[j], "saturday")) {
cj->weekdays = (uintptr_t *)setadd ((void **)cj->weekdays, (void *)6, SET_NOALLOC);
}
}
free (x);
}
}
return cj;
}
int linux_static_dev_run() {
char *dm;
if (!linux_static_dev_enabled && (dm = cfg_getstring("configuration-system-device-manager", NULL)) && strmatch (dm, "static")) {
linux_static_dev_enabled = 1;
mount ("proc", "/proc", "proc", 0, NULL);
mount ("sys", "/sys", "sysfs", 0, NULL);
mount ("devpts", "/dev/pts", "devpts", 0, NULL);
mount ("shm", "/dev/shm", "tmpfs", 0, NULL);
ethread_spawn_detached ((void *(*)(void *))linux_static_dev_hotplug, (void *)NULL);
FILE *he = fopen ("/proc/sys/kernel/hotplug", "w");
if (he) {
char *hotplug_handler = cfg_getstring ("configuration-system-hotplug-handler", NULL);
if (hotplug_handler) {
fputs (hotplug_handler, he);
} else {
fputs ("", he);
}
fputs ("\n", he);
fclose (he);
}
linux_static_dev_load_kernel_extensions();
mount ("usbfs", "/proc/bus/usb", "usbfs", 0, NULL);
return status_ok;
} else
return status_failed;
}
void writefile(FILE *input, FILE *output, unsigned char *buffer, unsigned buffersize, unsigned char pairtable[128][2])
{
char str[256];
int insection, indent, needseparator;
unsigned char *bufptr;
bufptr = buffer;
insection = 0;
rewind(input);
while (!feof(input)) {
while (fgets(str,sizeof str,input)!=NULL) {
fprintf(output,"%s",str);
if (check_tablename(str)) {
write_pairtable(output, pairtable, tablename);
/* strip an existing pair table from the file */
if (fgets(str,sizeof str,input)!=NULL) {
if (strmatch(str,"/*-*SCPACK",NULL)) {
while (fgets(str,sizeof str,input)!=NULL)
if (strmatch(str,"/*-*SCPACK",NULL))
break;
} else {
fprintf(output,"%s",str);
} /* if */
} /* if */
} /* if */
if (strmatch(str,START_TOKEN,NULL))
insection = 1;
if (insection && strmatch(str,"#else",NULL))
break;
} /* while */
if (!strmatch(str,"#else",&indent))
return; /* no (more) section found, quit */
insection=0;
/* dump the buffer as strings, separated with commas */
needseparator = 0;
while (*bufptr != '\0') {
assert((unsigned)(bufptr-buffer) < buffersize);
if (needseparator)
fprintf(output, "%s\n",separator);
fprintf(output, "%*c\"",indent+2,' ');
/* loop over string */
while (*bufptr != '\0') {
if (*bufptr<' ' || *bufptr >= 128 || *bufptr == '"' || *bufptr == '\\')
fprintf(output, "\\%03o", *bufptr);
else
fprintf(output, "%c", *bufptr);
bufptr++;
} /* while */
fprintf(output, "\"");
needseparator = 1;
bufptr++; /* skip '\0' */
} /* while */
fprintf(output, "%s\n",terminator);
bufptr++;
/* skip the input file until the #endif section */
while (fgets(str,sizeof str,input)!=NULL) {
if (strmatch(str,"#endif",NULL)) {
fprintf(output,"%s",str);
break; /* done */
} /* if */
} /* while */
} /* while - !feof(input) */
}
void core_einit_event_handler (struct einit_event *ev) {
if (ev->type == einit_core_configuration_update) {
struct cfgnode *node;
char *str;
ev->chain_type = einit_core_update_modules;
if ((node = cfg_getnode ("core-mortality-bad-malloc", NULL)))
mortality[bitch_emalloc] = node->value;
if ((node = cfg_getnode ("core-mortality-bad-stdio", NULL)))
mortality[bitch_stdio] = node->value;
if ((node = cfg_getnode ("core-mortality-bad-regex", NULL)))
mortality[bitch_regex] = node->value;
if ((node = cfg_getnode ("core-mortality-bad-expat", NULL)))
mortality[bitch_expat] = node->value;
if ((node = cfg_getnode ("core-mortality-bad-dl", NULL)))
mortality[bitch_dl] = node->value;
if ((node = cfg_getnode ("core-mortality-bad-lookup", NULL)))
mortality[bitch_lookup] = node->value;
if ((node = cfg_getnode ("core-mortality-bad-pthreads", NULL)))
mortality[bitch_epthreads] = node->value;
if ((node = cfg_getnode ("core-settings-allow-code-unloading", NULL)))
einit_allow_code_unloading = node->flag;
if ((str = cfg_getstring ("core-scheduler-niceness/core", NULL)))
einit_core_niceness_increment = parse_integer (str);
if ((str = cfg_getstring ("core-scheduler-niceness/tasks", NULL)))
einit_task_niceness_increment = parse_integer (str);
} else if (ev->type == einit_core_update_modules) {
struct lmodule *lm;
repeat:
lm = mlist;
einit_new_node = 0;
while (lm) {
if (lm->source && strmatch(lm->source, "core")) {
lm = mod_update (lm);
// tell module to scan for changes if it's a module-loader
if (lm->module && (lm->module->mode & einit_module_loader) && (lm->scanmodules != NULL)) {
notice (8, "updating modules (%s)", lm->module->rid ? lm->module->rid : "unknown");
lm->scanmodules (mlist);
/* if an actual new node has been added to the configuration,
repeat this step */
if (einit_new_node) goto repeat;
}
}
lm = lm->next;
}
/* give the module-logic code and others a chance at processing the current list */
struct einit_event update_event = evstaticinit(einit_core_module_list_update);
update_event.para = mlist;
event_emit (&update_event, einit_event_flag_broadcast);
evstaticdestroy(update_event);
} else if (ev->type == einit_core_recover) { // call everyone's recover-function (if defined)
struct lmodule *lm = mlist;
while (lm) {
if (lm->recover) {
lm->recover (lm);
}
lm = lm->next;
}
} else if (ev->type == einit_core_suspend_all) { // suspend everyone (if possible)
struct lmodule *lm = mlist;
int ok = 0;
while (lm) {
ok += (mod (einit_module_suspend, lm, NULL) == status_ok) ? 1 : 0;
lm = lm->next;
}
if (ok)
notice (4, "%i modules suspended", ok);
event_snooze_time = event_timer_register_timeout(60);
} else if (ev->type == einit_core_resume_all) { // resume everyone (if necessary)
struct lmodule *lm = mlist;
int ok = 0;
while (lm) {
ok += (mod (einit_module_resume, lm, NULL) == status_ok) ? 1 : 0;
lm = lm->next;
}
if (ok)
notice (4, "%i available", ok);
}
}
int Imatch (int argc, lvar_t *argv) {
if (!T_ISSTRING (argv[0].o) || !T_ISSTRING (argv[1].o))
return L_FAILURE;
rtno = Tinteger (strmatch (Tgetstring (argv[0].o), Tgetstring (argv[1].o)));
return L_SUCCESS;
}
char*
pathshell(void)
{
register char* sh;
int ru;
int eu;
int rg;
int eg;
struct stat st;
static char* val;
if ((sh = getenv("SHELL")) && *sh == '/' && strmatch(sh, "*/(sh|*[!cC]sh)*([[:digit:]])?(-+([.[:alnum:]]))?(.exe)"))
{
if (!(ru = getuid()) || !eaccess("/bin", W_OK))
{
if (stat(sh, &st))
goto defshell;
if (ru != st.st_uid && !strmatch(sh, "?(/usr)?(/local)/?([ls])bin/?([[:lower:]])sh?(.exe)"))
goto defshell;
}
else
{
eu = geteuid();
rg = getgid();
eg = getegid();
if (ru != eu || rg != eg)
{
char* s;
char dir[PATH_MAX];
s = sh;
for (;;)
{
if (stat(s, &st))
goto defshell;
if (ru != eu && st.st_uid == ru)
goto defshell;
if (rg != eg && st.st_gid == rg)
goto defshell;
if (s != sh)
break;
if (strlen(s) >= sizeof(dir))
goto defshell;
strcpy(dir, s);
if (!(s = strrchr(dir, '/')))
break;
*s = 0;
s = dir;
}
}
}
return sh;
}
defshell:
if (!(sh = val))
{
if (!*(sh = astconf("SH", NiL, NiL)) || *sh != '/' || eaccess(sh, X_OK) || !(sh = strdup(sh)))
sh = "/bin/sh";
val = sh;
}
return sh;
}
GImage *GImageRead(char * filename) {
/* Go read an input image file. Return NULL if cannot guess file type */
char *mime, *pt;
if (filename == NULL )
return( NULL );
/* Try finding correct routine to use based on GTK mime type */
if ( GFileExists(filename) ) {
mime=GIOGetMimeType(filename, true);
if ( strcasecmp(mime,"image/bmp")==0 )
return( GImageReadBmp(filename) );
else if ( strcasecmp(mime,"image/x-xbitmap")==0 )
return( GImageReadXbm(filename) );
else if ( strcasecmp(mime,"image/x-xpixmap")==0 )
return( GImageReadXpm(filename) );
else if ( strcasecmp(mime,"image/tiff")==0 )
return( GImageReadTiff(filename) );
else if ( strcasecmp(mime,"image/jpeg")==0 )
return( GImageReadJpeg(filename) );
else if ( strcasecmp(mime,"image/png")==0 )
return( GImageReadPng(filename) );
else if ( strcasecmp(mime,"image/gif")==0 )
return( GImageReadGif(filename) );
else if ( strcasecmp(mime,"image/x-cmu-raster")==0 || \
strcasecmp(mime,"image/x-sun-raster")==0 )
return( GImageReadRas(filename) ); /* Sun raster */
else if ( strcasecmp(mime,"image/x-rgb")==0 || \
strcasecmp(mime,"image/x-sgi")==0 )
return( GImageReadRgb(filename) ); /* SGI format */
}
/* Try finding correct routine to use based on filename suffix */
if ( (pt=strrchr(filename,'.'))!=NULL ) {
if ( strmatch(pt,".bmp")==0 )
return( GImageReadBmp(filename) );
else if ( strmatch(pt,".xbm")==0 )
return( GImageReadXbm(filename) );
else if ( strmatch(pt,".xpm")==0 )
return( GImageReadXpm(filename) );
else if ( strmatch(pt,".tiff")==0 || strmatch(pt,".tif")==0 )
return( GImageReadTiff(filename) );
else if ( strmatch(pt,".jpeg")==0 || strmatch(pt,".jpg")==0 )
return( GImageReadJpeg(filename) );
else if ( strmatch(pt,".png")==0 )
return( GImageReadPng(filename) );
else if ( strmatch(pt,".gif")==0 )
return( GImageReadGif(filename) );
else if ( strmatch(pt,".ras")==0 || strmatch(pt,".im1")==0 || \
strmatch(pt,".im8")==0 || strmatch(pt,".im24")==0 || \
strmatch(pt,".im32")==0 || strmatch(pt,".rs")==0 || \
strmatch(pt,".sun")==0 )
return( GImageReadRas(filename) ); /* Sun raster */
else if ( strmatch(pt,".rgb")==0 || strmatch(pt,".rgba")==0 || \
strmatch(pt,".sgi")==0 || strmatch(pt,".bw")==0 )
return( GImageReadRgb(filename) ); /* SGI format */
}
return( NULL );
}
/* parse DNN config file */
boolean
dnn_config_file_parse(char *filename, JCONF_AM *am, Jconf *jconf)
{
FILE *fp;
char buf[BUFLEN];
char *p, *pp;
char *v;
int i, n;
boolean error_flag;
char *cdir;
if (am->dnn.wfile != NULL) {
jlog("ERROR: dnn_config_file_parse: duplicated loading: %s\n", filename);
return FALSE;
}
if ((fp = fopen(filename, "r")) == NULL) {
jlog("ERROR: dnn_config_file_parse: failed to open %s\n", filename);
return FALSE;
}
cdir = strcpy((char *)mymalloc(strlen(filename)+1), filename);
get_dirname(cdir);
if (cdir[0] == '\0') {
free(cdir);
cdir = NULL;
}
while (fgets_jconf(buf, BUFLEN, fp) != NULL) {
if ((p = strchr(buf, '#')) != NULL) {
*p = '\0';
}
pp = &(buf[0]);
while (*pp == ' ' || *pp == '\t') pp++;
if (*pp == '\0') continue;
p = strchr(pp, ' ');
if (p == NULL) {
jlog("ERROR: dnn_config_file_parse: wrong file format: %s\n", buf);
if (cdir) free(cdir);
fclose(fp);
return FALSE;
}
v = p;
while (*v == ' ') v++;
*p = '\0';
if (strmatch(pp, "feature_type")) {
am->dnn.paramtype = param_str2code(v);
} else if (strmatch(pp, "feature_options")) {
am->dnn.optionstring = strdup(v);
} else if (strmatch(pp, "feature_len")) am->dnn.veclen = atoi(v);
else if (strmatch(pp, "context_len")) am->dnn.contextlen = atoi(v);
else if (strmatch(pp, "input_nodes")) am->dnn.inputnodes = atoi(v);
else if (strmatch(pp, "output_nodes")) am->dnn.outputnodes = atoi(v);
else if (strmatch(pp, "hidden_nodes")) am->dnn.hiddennodes = atoi(v);
else if (strmatch(pp, "hidden_layers")) {
am->dnn.hiddenlayernum = atoi(v);
am->dnn.wfile = (char **)mymalloc(sizeof(char *) * am->dnn.hiddenlayernum);
am->dnn.bfile = (char **)mymalloc(sizeof(char *) * am->dnn.hiddenlayernum);
for (i = 0; i < am->dnn.hiddenlayernum; i++) {
am->dnn.wfile[i] = NULL;
am->dnn.bfile[i] = NULL;
}
} else if (pp[0] == 'W') {
n = atoi(&(pp[1]));
if (n > am->dnn.hiddenlayernum) {
jlog("ERROR: dnn_config_file_parse: W%d > # of hidden_layers (%d)\n", n, am->dnn.hiddenlayernum);
if (cdir) free(cdir);
fclose(fp);
return FALSE;
} else if (n <= 0) {
jlog("ERROR: dnn_config_file_parse: layer id should begin with 1\n");
if (cdir) free(cdir);
fclose(fp);
return FALSE;
}
am->dnn.wfile[n-1] = filepath(v, cdir);
} else if (pp[0] == 'B') {
n = atoi(&(pp[1]));
if (n > am->dnn.hiddenlayernum) {
jlog("ERROR: dnn_config_file_parse: B%d > # of hidden_layers (%d)\n", n, am->dnn.hiddenlayernum);
if (cdir) free(cdir);
fclose(fp);
return FALSE;
} else if (n <= 0) {
jlog("ERROR: dnn_config_file_parse: layer id should begin with 1\n");
if (cdir) free(cdir);
fclose(fp);
return FALSE;
}
am->dnn.bfile[n-1] = filepath(v, cdir);
} else if (strmatch(pp, "output_W")) am->dnn.output_wfile = filepath(v, cdir);
else if (strmatch(pp, "output_B")) am->dnn.output_bfile = filepath(v, cdir);
else if (strmatch(pp, "state_prior")) am->dnn.priorfile = filepath(v, cdir);
else if (strmatch(pp, "state_prior_factor")) am->dnn.prior_factor = atof(v);
else if (strmatch(pp, "batch_size")) am->dnn.batchsize = atoi(v);
else if (strmatch(pp, "num_threads")) am->dnn.num_threads = atoi(v);
else {
jlog("ERROR: dnn_config_file_parse: unknown spec: %s %s\n", pp, v);
if (cdir) free(cdir);
fclose(fp);
return FALSE;
}
}
if (fclose(fp) == -1) {
jlog("ERROR: dnn_config_file_parse: failed to close file\n");
if (cdir) free(cdir);
return FALSE;
}
/* check validity */
error_flag = FALSE;
for (i = 0; i < am->dnn.hiddenlayernum; i++) {
if (am->dnn.wfile[i] == NULL) {
jlog("ERROR: dnn_config_file_parse: no W file specified for hidden layer #%d\n", i + 1);
error_flag = TRUE;
}
if (am->dnn.bfile[i] == NULL) {
jlog("ERROR: dnn_config_file_parse: no B file specified for hidden layer #%d\n", i + 1);
error_flag = TRUE;
}
}
if (error_flag == TRUE) {
if (cdir) free(cdir);
return FALSE;
}
am->dnn.enabled = TRUE;
/* load options */
if (am->dnn.optionstring) {
if (config_string_parse_basedir(jconf->amnow->dnn.optionstring, jconf, cdir) == FALSE) {
if (cdir) free(cdir);
return FALSE;
}
}
if (cdir) free(cdir);
return TRUE;
}
int main(int argc, char **argv)
{
int x, y;
int maskflag=0;
unsigned char *mask;
double k;
double *phase2elevBase,*sinFlat,*cosFlat;
char datafile[256], basefile[256], outfile[256];
char maskfile[256];
int nrows,ncols;
float *f_coh;
float *f_eleverr;
float percent=0.0;
double init_err=DEFAULT_ERROR;
FILE *fdata, *fmask, *fout;
meta_parameters *meta;
baseline base;
/* Parse command line arguments */
logflag=FALSE;
while (currArg < (argc-NUM_ARGS)) {
char *key = argv[currArg++];
if (strmatch(key,"-log")) {
CHECK_ARG(1);
strcpy(logFile,GET_ARG(1));
fLog = FOPEN(logFile, "a");
logflag=TRUE;
}
else if (strmatch(key, "-mask")) {
CHECK_ARG(1);
strcpy(maskfile, GET_ARG(1));
maskflag = TRUE;
}
else if (strmatch(key,"-i")) {
CHECK_ARG(1);
init_err = atof(GET_ARG(1));
init_err *= init_err;
}
else {
printf("\n**Invalid option: %s\n",argv[currArg-1]);
usage(argv[0]);
}
}
if ((argc-currArg) < NUM_ARGS) {
printf("Insufficient arguments.\n");
usage(argv[0]);
}
create_name(datafile, argv[currArg], ".img");
strcpy(basefile, argv[currArg+1]);
strcpy(outfile, argv[currArg+2]);
asfSplashScreen(argc, argv);
/* Get appropriate metadata */
meta = meta_read(datafile);
nrows = meta->general->line_count;
ncols = meta->general->sample_count;
meta->general->data_type = REAL32;
meta_write(meta, outfile);
k = meta_get_k(meta); /* wave number*/
/* Allocate space for vectors, matricies, and stuff*/
mask = (unsigned char *)MALLOC(sizeof(unsigned char)*ncols);
f_coh = (float *)MALLOC(sizeof(float)*ncols);
f_eleverr = (float *)MALLOC(sizeof(float)*ncols);
sinFlat = (double *)MALLOC(sizeof(double)*ncols);
cosFlat = (double *)MALLOC(sizeof(double)*ncols);
phase2elevBase = (double *)MALLOC(sizeof(double)*ncols);
/* Open data file & get seed phase*/
fdata = fopenImage(datafile, "rb");
fout = fopenImage(outfile,"wb");
if (maskflag) fmask = fopenImage(maskfile,"rb");
/* Read in baseline values*/
base = read_baseline(basefile);
/* Obtain information from metadata*/
for (x=0;x<ncols;x++)
{
int img_x = x * meta->sar->sample_increment
+ meta->general->start_sample;
double incid=meta_incid(meta,0,img_x);
double flat=meta_flat(meta,0,img_x);
sinFlat[x]=sin(flat);
cosFlat[x]=cos(flat);
phase2elevBase[x]=meta_get_slant(meta,0,img_x)*sin(incid)/(2.0*k);
}
/* Loop through each row & calculate height*/
for (y=0;y<nrows;y++) {
double Bn_y,Bp_y;
/* Report progress */
if ((y*100/nrows)>percent) {
printf("\r Completed %3.0f percent", percent);
fflush(NULL);
percent+=5.0;
}
/* read in data */
if (maskflag)
ASF_FREAD(mask,sizeof(unsigned char),ncols,fmask);
get_float_line(fdata, meta, y, f_coh);
/* calculate baseline for this row*/
meta_interp_baseline(meta, base,
y*meta->sar->line_increment+meta->general->start_line+1,
&Bn_y, &Bp_y);
/* step through each pixel in row*/
for (x=0;x<ncols;x++) {
if ((mask[x] == 0x10 && maskflag) || (!maskflag)) {
double tmp,tmp1,sigma_height;
tmp = phase2elevBase[x]/(-Bp_y*sinFlat[x]-Bn_y*cosFlat[x]);
tmp1 = (FLOAT_EQUALS_ZERO(f_coh[x]))
? 0.0 : sqrt((1-f_coh[x])/f_coh[x]);
sigma_height = tmp*tmp1;
f_eleverr[x] = (float)sqrt( init_err +
sigma_height*sigma_height );
}
else
f_eleverr[x] = -1.0;
}
put_float_line(fout, meta, y, f_eleverr);
}
printf("\r Completed 100 percent\n\n");
sprintf(logbuf, " Wrote %lld bytes of data\n\n",
(long long)(nrows*ncols*4));
printf("%s", logbuf);
if (logflag) { printLog(logbuf); }
/* free memory & scram*/
meta_free(meta);
FREE(mask);
FREE(f_coh);
FREE(f_eleverr);
FREE(sinFlat);
FREE(cosFlat);
FREE(phase2elevBase);
FCLOSE(fdata);
FCLOSE(fout);
if (maskflag) FCLOSE(fmask);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
FILE *fp;
meta_parameters *metaSrc, *metaTrg;
envi_header *envi;
extern int currArg; // Pre-initialized to 1
radiometry_t radiometry=r_AMP;
filter_type_t filter_type;
char srcImage[255], trgImage[255], *inFile, outFile[255], filter_str[25];
int startX_src, startY_src, startX_trg, startY_trg, lines, samples, size;
int subset=FALSE, filter=FALSE, geotiff=FALSE, line_count, sample_count;
double lat_UL, lon_UL, lat_LR, lon_LR, yLine, xSample;
float mean, scale;
register float *img, *filtered_img=NULL;
register int x, y, l;
/* parse command line */
logflag=quietflag=FALSE;
while (currArg < (argc-2)) {
char *key = argv[currArg++];
if (strmatch(key,"-startX")) {
CHECK_ARG(1);
startX_src = atoi(GET_ARG(1));
subset = TRUE;
}
else if (strmatch(key,"-startY")) {
CHECK_ARG(1);
startY_src = atoi(GET_ARG(1));
subset = TRUE;
}
else if (strmatch(key,"-lines")) {
CHECK_ARG(1);
lines = atoi(GET_ARG(1));
subset = TRUE;
}
else if (strmatch(key,"-samples")) {
CHECK_ARG(1);
samples = atoi(GET_ARG(1));
subset = TRUE;
}
else if (strmatch(key,"-filter")) {
CHECK_ARG(2);
strcpy(filter_str, GET_ARG(2));
size = atoi(GET_ARG(1));
filter = TRUE;
}
else if (strmatch(key,"-geotiff")) {
geotiff = TRUE;
}
else {
printf( "\n**Invalid option: %s\n", argv[currArg-1]);
usage(argv[0]);
}
}
if ((argc-currArg)<2) {printf("Insufficient arguments.\n"); usage(argv[0]);}
strcpy (srcImage, argv[currArg]);
strcpy (trgImage, argv[currArg+1]);
asfSplashScreen(argc, argv);
// Ingesting CEOS files into ASF internal format
asfPrintStatus("Ingesting source image: %s ...\n", srcImage);
asf_import(radiometry, FALSE, FALSE, FALSE, "CEOS", "", "geocoded_image", NULL, NULL,
-99.0, -99.0, NULL, NULL, NULL, TRUE, NULL, srcImage, "", srcImage);
metaSrc = meta_read(srcImage);
asfPrintStatus("Ingesting target image: %s ...\n", trgImage);
asf_import(radiometry, FALSE, FALSE, FALSE, "CEOS", "", "geocoded_image", NULL, NULL,
-99.0, -99.0, NULL, NULL, NULL, TRUE, NULL, trgImage, "", trgImage);
metaTrg = meta_read(trgImage);
// Check subset values for source image
line_count = metaSrc->general->line_count;
sample_count = metaSrc->general->sample_count;
if (subset) {
if (startX_src < 0 || startX_src > sample_count)
startX_src = 0;
if (startY_src < 0 || startY_src > line_count)
startY_src = 0;
if (lines < 0 || (lines-startY_src) > line_count)
lines = line_count - startY_src;
if (samples < 0 || (samples-startX_src) > sample_count)
samples = sample_count - startX_src;
}
else {
startX_src = startY_src = 0;
lines = line_count;
samples = sample_count;
}
// Assign filter
if (filter) {
if (strcmp(uc(filter_str), "AVERAGE") == 0)
filter_type = AVERAGE;
else if (strcmp(uc(filter_str), "SOBEL") == 0)
filter_type = SOBEL;
else if (strcmp(uc(filter_str), "FROST") == 0)
filter_type = FROST;
else if (strcmp(uc(filter_str), "LEE") == 0)
filter_type = LEE;
else if (strcmp(uc(filter_str), "GAMMA_MAP") == 0)
filter_type = GAMMA_MAP;
else {
asfPrintWarning("Unsupported filter type '%s'- ignoring the filter"
" settings\n", filter_str);
filter = FALSE;
}
if (size%2 == 0 && filter_type != AVERAGE) {
size--;
asfPrintWarning("Filter kernel must have an odd number of lines and"
"samples!\n");
}
}
// Allocate some memory for the subsets
line_count = metaTrg->general->line_count;
sample_count = metaTrg->general->sample_count;
img = (float *) MALLOC(sizeof(float)*lines*samples);
if (filter)
filtered_img = (float *) MALLOC(sizeof(float)*lines*samples);
// Determine geographic location of subset
meta_get_latLon(metaSrc, startY_src, startX_src, 0.0, &lat_UL, &lon_UL);
meta_get_latLon(metaSrc, startY_src+lines, startX_src+samples, 0.0,
&lat_LR, &lon_LR);
meta_get_lineSamp(metaTrg, lat_UL, lon_UL, 0.0, &yLine, &xSample);
startX_trg = (int) (xSample + 0.5);
startY_trg = (int) (yLine + 0.5);
// READ IN SUBSETS
// Read target image subset first to determine average brightness
asfPrintStatus("\nGenerating subset for target image ...\n");
asfPrintStatus("start line: %d, start sample: %d, lines: %d, samples: %d\n",
startY_trg, startX_trg, lines, samples);
inFile = appendExt(trgImage, ".img");
sprintf(outFile, "%s_sub.img", trgImage);
fp = FOPEN(inFile, "rb");
read_subset(fp, metaTrg, startX_trg, startY_trg, samples, lines, 0.0,
&mean, img);
FCLOSE(fp);
// Compute scale factor
mean *= -1;
scale = 1.0 / (lines * samples);
// Subtract this average off of target image
for (y=0; y<lines; y++) {
l = samples * y;
for (x=0; x<samples; x++)
img[l+x] = (img[l+x] + mean) * scale;
}
if (filter) {
asfPrintStatus("\nFiltering target image subset with %s (%dx%d) ...\n",
uc(filter_str), size, size);
filter_image(img, filtered_img, filter_type, size, lines, samples);
}
// Update metadata and write target subset to file
metaTrg->general->line_count = lines;
metaTrg->general->sample_count = samples;
metaTrg->general->start_line = startY_trg;
metaTrg->general->start_sample = startX_trg;
meta_write(metaTrg, outFile);
envi = meta2envi(metaTrg);
write_envi_header(outFile, outFile, metaTrg, envi);
fp = FOPEN(outFile, "wb");
if (filter)
put_float_lines(fp, metaTrg, 0, lines, filtered_img);
else
put_float_lines(fp, metaTrg, 0, lines, img);
FCLOSE(fp);
// Read source image subset applying for brightness
asfPrintStatus("\nGenerating subset for source image ...\n");
asfPrintStatus("start line: %d, start sample: %d, lines: %d, samples: %d\n",
startY_src, startX_src, lines, samples);
inFile = appendExt(srcImage, ".img");
sprintf(outFile, "%s_sub.img", srcImage);
fp = FOPEN(inFile, "rb");
read_subset(fp, metaSrc, startX_src, startY_src, samples, lines, mean,
NULL, img);
FCLOSE(fp);
if (filter) {
asfPrintStatus("\nFiltering source image subset with %s (%dx%d) ...\n",
uc(filter_str), size, size);
filter_image(img, filtered_img, filter_type, size, lines, samples);
}
// Update metadata and write source subset to file
metaSrc->general->line_count = lines;
metaSrc->general->sample_count = samples;
metaSrc->general->start_line = startY_src;
metaSrc->general->start_sample = startX_src;
meta_write(metaSrc, outFile);
envi = meta2envi(metaSrc);
write_envi_header(outFile, outFile, metaSrc, envi);
fp = FOPEN(outFile, "wb");
if (filter)
put_float_lines(fp, metaSrc, 0, lines, filtered_img);
else
put_float_lines(fp, metaSrc, 0, lines, img);
FCLOSE(fp);
// Clean up
FREE(img);
meta_free(metaSrc);
meta_free(metaTrg);
// Exporting subsets to GeoTIFF
if (geotiff) {
output_format_t output_format=GEOTIFF;
scale_t sample_mapping=SIGMA;
asfPrintStatus("\nExporting source image subset to GeoTIFF ...\n");
sprintf(outFile, "%s_sub", srcImage);
asf_export(output_format, sample_mapping, outFile, outFile);
asfPrintStatus("\nExporting target image subset to GeoTIFF ...\n");
sprintf(outFile, "%s_sub", trgImage);
asf_export(output_format, sample_mapping, outFile, outFile);
}
return (0);
}
/*
* Process queries - return list of available agent programs
*/
INTERNAL int
agent_query(EVENT_AGENTD_REQ *eagent, DIR *dir, char *dirpath) {
EVENT_AGENTD_MOD emod;
struct dirent *dirent;
struct stat statb;
char path[PATHLEN];
char *bufp;
int ntot, nmod, len, bytes;
int rc;
if (Verbose)
printf("processing agentd query from %d\n", eagent->head.from);
ntot = 0;
bufp = &emod.modules[0];
bytes = AGENTD_LISTBUF-1;
nmod = 0;
while (dirent = readdir(dir)) {
if (*dirpath) sprintf(path, "%s/%s", dirpath, dirent->d_name);
else strcpy(path, dirent->d_name);
if (stat(path, &statb) != SYS_OK) {
if (errno == EACCES) continue;
fprintf(stderr, "error stating %s\n", path);
continue;
}
if (Debug)
printf("agent_query: processing file %s %o\n", path, statb.st_mode);
if (statb.st_mode&S_IFDIR) {
DIR *subdir;
if (dirent->d_name[0] == '.') continue;
subdir = opendir(path);
if (!subdir) {
fprintf(stderr, "error opening subdir %s\n", path);
continue;
}
ntot += agent_query(eagent, subdir, path);
closedir(subdir);
continue;
}
if (!(statb.st_mode&S_IFREG) ||
!strmatch(eagent->module, path) ||
access(path, X_OK)
) continue;
/* Copy module name to query event */
len = strlen(path)+1;
if (len >= AGENTD_LISTBUF-1) { /* This would be very, very bad */
fprintf(stderr,
"path too long for event buffer!!!\"%s\"\n",
path);
continue;
}
if (len > bytes) { /* If no room send and start anew */
*bufp = '\0';
emod.flags = AGENTD_FLAG_MORE;
emod.tag = eagent->tag;
emod.nmodules = nmod;
event_clientname(emod.hostname);
SEND(EventFrom(*eagent), AGENTD_MOD, emod);
bytes = AGENTD_LISTBUF-1;
nmod = 0;
bufp = &emod.modules[0];
}
strcpy(bufp, path);
bufp += len;
bytes -= len;
++nmod;
}
if (nmod) {
*bufp = '\0';
emod.flags = 0;
emod.tag = eagent->tag;
emod.nmodules = nmod;
event_clientname(emod.hostname);
SEND(EventFrom(*eagent), AGENTD_MOD, emod);
}
return(ntot+nmod);
}
main(int argc, char *argv[]) {
char *pgm, *s;
int ok, help;
char *server;
int id, nc;
int i;
char me[256];
char logstr[200];
pgm = argv[0];
/* Get and save our original working directory */
if (!GetWD(SelfWD, sizeof(SelfWD))) {
fprintf(stderr, "%s: couldn't get working directory\n", pgm);
perror(pgm);
exit(4);
}
/* Get our own name and any path prefix */
if (pgm = strrchr(argv[0], '/')) {
*pgm++ = '\0';
if (*argv[0] == '/') strcpy(Logdir, argv[0]);
else make_path(Logdir, SelfWD, argv[0]);
if (Verbose) printf("Logdir search is \"%s\"\n", Logdir);
}
else {
strcpy(Logdir, SelfWD);
pgm = argv[0];
}
++argv; --argc;
/* See if we are running as the LOGGER */
sprintf(logstr, "{%s,%s%s}", LOGGEREXEC, LOGGEREXEC, LOGGEREXT);
if (strmatch(logstr, pgm)) logger(pgm, argc, argv);
/* Default options */
ok = 1;
help = 0;
/* Parse out command line options */
while (argc && *argv[0] == '-') {
char *opt;
opt = argv[0] + 1;
++argv; --argc;
if (substr(opt, "help")) ++help;
else if (substr(opt, "debug")) ++Debug;
else if (substr(opt, "nodebug")) Debug = 0;
else if (substr(opt, "verbose")) Verbose = 1;
else if (substr(opt, "quiet")) Verbose = 0;
else if (streq(opt, "bin") || streq(opt, "dir")) {
if (argc < 1) {
fprintf(stderr, "%s: missing argument to -%s\n",
pgm, opt);
ok = 0;
break;
}
RootPath = argv[0];
++argv; --argc;
}
else if (streq(opt, "wd") || streq(opt, "cd")) {
if (argc < 1) {
fprintf(stderr, "%s: missing argument to -%s\n",
pgm, opt);
ok = 0;
break;
}
WorkDir = argv[0];
++argv; --argc;
}
else if (substr(opt, "logger")) {
if (argc < 1) {
fprintf(stderr, "%s: missing argument to -%s\n",
pgm, opt);
ok = 0;
break;
}
if (argv[0][0] == '/') strcpy(Logger, argv[0]);
else {
int len;
char *name;
/* Copy the current working directory */
strcpy(Logger, SelfWD);
len = strlen(Logger);
if (Logger[len-1] != '/') Logger[len++] = '/';
name = argv[0];
if (substr("./", name)) name += 2;
strcpy(Logger+len, name);
}
++argv; --argc;
}
else {
fprintf(stderr, "%s: ignoring argument -%s\n", pgm, opt);
help = 1;
ok = 0;
}
}
if (!ok || argc == 0) {
usage(pgm, help);
exit(!help);
}
server = argv[0];
++argv; --argc;
/* Allow directory to be specified as last command line arg */
if (argc) {
if (RootPath) {
if (!streq(RootPath, argv[0])) {
fprintf(stderr,
"%s: can't use -dir (%s) and specify path (%s)\n",
pgm, RootPath, argv[0]);
exit(4);
}
}
else {
RootPath = argv[0];
++argv; --argc;
}
}
/* Check for any extraneous args */
if (argc) {
fprintf(stderr, "%s: too many arguments starting with \"%s\"\n",
pgm, argv[0]);
usage(pgm, help);
exit(!help);
}
/* Now change to our root directory */
if (RootPath) {
if (chdir(RootPath) != SYS_OK) {
fprintf(stderr, "%s: couldn't chdir to \"%s\"\n", pgm, RootPath);
exit(4);
}
}
else fprintf(stderr, "%s: WARNING! no root directory specified - using .\n", pgm);
/* Set up path to working directory for lauched agents */
if (WorkDir)
if (*WorkDir == '/') strcpy(WorkPath, WorkDir);
else make_path(WorkPath, SelfWD, WorkDir);
/* Open the executable directory to process queries */
if (!GetWD(ExecPath, sizeof(ExecPath))) {
fprintf(stderr, "%s: couldn't get working directory\n", pgm);
perror(pgm);
exit(4);
}
ExecDir = opendir(ExecPath);
if (!ExecDir) {
fprintf(stderr, "%s: couldn't open working directory \"%s\"\n", pgm, ExecPath);
perror(pgm);
exit(4);
}
#ifdef win32
/*
* On windows we need to run the logger as a separate helper app
* since the cygwin implementation of fork is not quite right.
* Look for it in standard places as well as looking as users $PATH
*/
if (!Logger[0] && !find_logger()) {
fprintf(stderr,
"%s: couldn't find initiator \"%s\"\n",
pgm, LOGGEREXEC);
exit(4);
}
if (Verbose) printf("Logger exec is \"%s\"\n", Logger);
#endif
/* Make sure we found the file and it is executable */
if (Logger[0] && access(Logger, X_OK) != SYS_OK) {
fprintf(stderr,
"%s: initiator \"%s\" not %s\n", pgm, Logger,
access(Logger, F_OK)?"found":"executable");
exit(4);
}
/* Deal with signals */
siginit();
/* local initialization */
event_verbose(Verbose);
event_tunnel_enable(0);
agentd_init();
/* Connect to our event server */
id = event_join(server, &nc);
if (!id) {
fprintf(stderr, "%s: couldn't join server \"%s\"\n", pgm, server);
exit(4);
}
if (Verbose) printf("%s: joined %s as client id %d (%d clients)\n", pgm, server, id, nc);
/* Register */
cuserid(me);
event_register(AGENTDCLASS, AGENTDSPEC, me);
/* Subscribe to only AGENTD type events */
event_select_type(0, ET_MIN, ET_MAX);
event_select_type(1, ET_AGENTD_MIN, ET_AGENTD_MAX);
/* Initialize agent control structures */
for (i = 0; i < MAX_AGENT; ++i) {
Agent[i].pid = 0;
Agent[i].status = AGENTD_AGENT_FREE;
}
mp_init(); /*(not strcitly necessary, since done in event land)*/
/* Allocate our locks and semaphores */
AgentLock = mp_alloclock();
Exitlock = mp_alloclock();
Exitwait = mp_allocsema();
ReadInit = mp_allocsema();
AgentInit = mp_allocsema();
/*
* Loop forever processing agentd requests
*/
FOREVER {
EVENT e;
/* Wait for an event and then dispatch it */
event_wait();
if (!event_receive(&e)) continue;
switch (e.ev_head.type) {
case ET_AGENTD_REQ:
agent_request((EVENT_AGENTD_REQ *)&e);
break;
default:
if (Verbose)
printf("Ignoring event \'%s\'(%d) from %d\n",
event_lookup_name(e.ev_head.type),
e.ev_head.type, e.ev_head.from);
}
}
}
/**
* <EN>
* Fill in system default values to a search parameter structure.
*
* @param j [in] search configuration parameter structure
* </EN>
* <JA>
* 探索(SEARCH)パラメータ構造体に初期値を代入する.
*
* @param j [in] 探索パラメータ構造体
* </JA>
*
* @callgraph
* @callergraph
*
*/
void
jconf_set_default_values_search(JCONF_SEARCH *j)
{
j->name[0] = '\0';
j->amconf = NULL;
j->lmconf = NULL;
j->compute_only_1pass = FALSE;
j->force_ccd_handling = FALSE;
j->ccd_handling = FALSE;
/*
default values below are assigned later using HMM information:
j->lmp.*
*/
j->lmp.lm_penalty_trans = 0.0;
j->lmp.penalty1 = 0.0;
j->lmp.penalty2 = 0.0;
j->lmp.lmp2_specified = FALSE;
j->lmp.lmp_specified = FALSE;
j->pass1.specified_trellis_beam_width = -1;
#ifdef SCORE_PRUNING
j->pass1.score_pruning_width = -1.0;
#endif
#if defined(WPAIR) && defined(WPAIR_KEEP_NLIMIT)
j->pass1.wpair_keep_nlimit = 3;
#endif
#ifdef HASH_CACHE_IW
j->pass1.iw_cache_rate = 10;
#endif
j->pass1.old_tree_function_flag = FALSE;
#ifdef DETERMINE
j->pass1.determine_score_thres = 10.0;
j->pass1.determine_duration_thres = 6;
#endif
if (strmatch(JULIUS_SETUP, "fast")) {
j->pass2.nbest = 1;
j->pass2.enveloped_bestfirst_width = 30;
} else {
j->pass2.nbest = 10;
j->pass2.enveloped_bestfirst_width = 100;
}
#ifdef SCAN_BEAM
j->pass2.scan_beam_thres = 80.0;
#endif
j->pass2.hypo_overflow = 2000;
j->pass2.stack_size = 500;
j->pass2.lookup_range = 5;
j->pass2.looktrellis_flag = FALSE; /* dfa */
j->graph.enabled = FALSE;
j->graph.lattice = FALSE;
j->graph.confnet = FALSE;
j->graph.graph_merge_neighbor_range = 0;
#ifdef GRAPHOUT_DEPTHCUT
j->graph.graphout_cut_depth = 80;
#endif
#ifdef GRAPHOUT_LIMIT_BOUNDARY_LOOP
j->graph.graphout_limit_boundary_loop_num = 20;
#endif
#ifdef GRAPHOUT_SEARCH_DELAY_TERMINATION
j->graph.graphout_search_delay = FALSE;
#endif
j->successive.enabled = FALSE;
j->successive.sp_frame_duration = 10;
j->successive.pausemodelname = NULL;
#ifdef SPSEGMENT_NAIST
j->successive.sp_margin = DEFAULT_SP_MARGIN;
j->successive.sp_delay = DEFAULT_SP_DELAY;
#endif
#ifdef CONFIDENCE_MEASURE
j->annotate.cm_alpha = 0.05;
#ifdef CM_MULTIPLE_ALPHA
j->annotate.cm_alpha_bgn = 0.03;
j->annotate.cm_alpha_end = 0.15;
j->annotate.cm_alpha_num = 5;
j->annotate.cm_alpha_step = 0.03;
#endif
#ifdef CM_SEARCH_LIMIT
j->annotate.cm_cut_thres = 0.03;
#endif
#ifdef CM_SEARCH_LIMIT_POPO
j->annotate.cm_cut_thres_pop = 0.1;
#endif
#endif /* CONFIDENCE_MEASURE */
j->annotate.align_result_word_flag = FALSE;
j->annotate.align_result_phoneme_flag = FALSE;
j->annotate.align_result_state_flag = FALSE;
j->output.output_hypo_maxnum = 1;
j->output.progout_flag = FALSE;
j->output.progout_interval = 300;
j->output.multigramout_flag = FALSE; /* dfa */
j->sw.trellis_check_flag = FALSE;
j->sw.triphone_check_flag = FALSE;
j->sw.wchmm_check_flag = FALSE;
j->sw.start_inactive = FALSE;
j->sw.fallback_pass1_flag = FALSE;
#ifdef USE_MBR
j->mbr.use_mbr = FALSE;
j->mbr.use_word_weight = FALSE;
j->mbr.score_weight = 0.1;
j->mbr.loss_weight = 1.0;
#endif
}
static Extype_t
eval(Expr_t* ex, register Exnode_t* expr, void* env)
{
register Exnode_t* x;
register Exnode_t* a;
register Extype_t** t;
register int n;
Extype_t v;
Extype_t r;
Extype_t i;
char* e;
Exnode_t tmp;
Exassoc_t* assoc;
Extype_t args[FRAME+1];
Extype_t save[FRAME];
if (!expr || ex->loopcount)
{
v.integer = 1;
return v;
}
x = expr->data.operand.left;
switch (expr->op)
{
case BREAK:
case CONTINUE:
v = eval(ex, x, env);
ex->loopcount = v.integer;
ex->loopop = expr->op;
return v;
case CONSTANT:
return expr->data.constant.value;
case DEC:
n = -1;
add:
if (x->op == DYNAMIC)
r = getdyn(ex, x, env, &assoc);
else
{
if (x->data.variable.index)
i = eval(ex, x->data.variable.index, env);
else
i.integer = EX_SCALAR;
r = (*ex->disc->getf)(ex, x, x->data.variable.symbol, x->data.variable.reference, env, (int)i.integer, ex->disc);
}
v = r;
switch (x->type)
{
case FLOATING:
v.floating += n;
break;
case INTEGER:
case UNSIGNED:
v.integer += n;
break;
default:
goto huh;
}
set:
if (x->op == DYNAMIC)
{
if (x->type == STRING)
{
v.string = vmstrdup(ex->vm, v.string);
if (e = assoc ? assoc->value.string : x->data.variable.symbol->value->data.constant.value.string)
vmfree(ex->vm, e);
}
if (assoc)
assoc->value = v;
else
x->data.variable.symbol->value->data.constant.value = v;
}
else
{
if (x->data.variable.index)
i = eval(ex, x->data.variable.index, env);
else
i.integer = EX_SCALAR;
if ((*ex->disc->setf)(ex, x, x->data.variable.symbol, x->data.variable.reference, env, (int)i.integer, v, ex->disc) < 0)
exerror("%s: cannot set value", x->data.variable.symbol->name);
}
if (expr->subop == PRE)
r = v;
return r;
case DYNAMIC:
return getdyn(ex, expr, env, &assoc);
case EXIT:
v = eval(ex, x, env);
exit((int)v.integer);
/*NOTREACHED*/
v.integer = -1;
return v;
case IF:
v = eval(ex, x, env);
if (v.integer)
eval(ex, expr->data.operand.right->data.operand.left, env);
else
eval(ex, expr->data.operand.right->data.operand.right, env);
v.integer = 1;
return v;
case FOR:
case WHILE:
expr = expr->data.operand.right;
for (;;)
{
r = eval(ex, x, env);
if (!r.integer)
{
v.integer = 1;
return v;
}
if (expr->data.operand.right)
{
eval(ex, expr->data.operand.right, env);
if (ex->loopcount > 0 && (--ex->loopcount > 0 || ex->loopop != CONTINUE))
{
v.integer = 0;
return v;
}
}
if (expr->data.operand.left)
eval(ex, expr->data.operand.left, env);
}
/*NOTREACHED*/
case SWITCH:
v = eval(ex, x, env);
i.integer = x->type;
r.integer = 0;
x = expr->data.operand.right;
a = x->data.select.statement;
n = 0;
while (x = x->data.select.next)
{
if (!(t = x->data.select.constant))
n = 1;
else
for (; *t; t++)
{
switch ((int)i.integer)
{
case INTEGER:
case UNSIGNED:
if ((*t)->integer == v.integer)
break;
continue;
case STRING:
if ((ex->disc->version >= 19981111L && ex->disc->matchf) ? (*ex->disc->matchf)(ex, x, (*t)->string, expr->data.operand.left, v.string, env, ex->disc) : strmatch((*t)->string, v.string))
break;
continue;
case FLOATING:
if ((*t)->floating == v.floating)
break;
continue;
}
n = 1;
break;
}
if (n)
{
if (!x->data.select.statement)
{
r.integer = 1;
break;
}
r = eval(ex, x->data.select.statement, env);
if (ex->loopcount > 0)
{
ex->loopcount--;
break;
}
}
}
if (!n && a)
{
r = eval(ex, a, env);
if (ex->loopcount > 0)
ex->loopcount--;
}
return r;
case ITERATE:
v.integer = 0;
if (expr->data.generate.array->op == DYNAMIC)
{
n = expr->data.generate.index->type == STRING;
for (assoc = (Exassoc_t*)dtfirst((Dt_t*)expr->data.generate.array->data.variable.symbol->local.pointer); assoc; assoc = (Exassoc_t*)dtnext((Dt_t*)expr->data.generate.array->data.variable.symbol->local.pointer, assoc))
{
v.integer++;
if (n)
expr->data.generate.index->value->data.constant.value.string = assoc->name;
else
expr->data.generate.index->value->data.constant.value.integer = strtol(assoc->name, NiL, 0);
eval(ex, expr->data.generate.statement, env);
if (ex->loopcount > 0 && (--ex->loopcount > 0 || ex->loopop != CONTINUE))
{
v.integer = 0;
break;
}
}
}
else
{
r = (*ex->disc->getf)(ex, expr, expr->data.generate.array->data.variable.symbol, expr->data.generate.array->data.variable.reference, env, 0, ex->disc);
for (v.integer = 0; v.integer < r.integer; v.integer++)
{
expr->data.generate.index->value->data.constant.value.integer = v.integer;
eval(ex, expr->data.generate.statement, env);
if (ex->loopcount > 0 && (--ex->loopcount > 0 || ex->loopop != CONTINUE))
{
v.integer = 0;
break;
}
}
}
return v;
case CALL:
x = expr->data.call.args;
for (n = 0, a = expr->data.call.procedure->value->data.procedure.args; a && x; a = a->data.operand.right)
{
if (n < elementsof(args))
{
save[n] = a->data.operand.left->data.variable.symbol->value->data.constant.value;
args[n++] = eval(ex, x->data.operand.left, env);
}
else
a->data.operand.left->data.variable.symbol->value->data.constant.value = eval(ex, x->data.operand.left, env);
x = x->data.operand.right;
}
for (n = 0, a = expr->data.call.procedure->value->data.procedure.args; a && n < elementsof(save); a = a->data.operand.right)
a->data.operand.left->data.variable.symbol->value->data.constant.value = args[n++];
if (x)
exerror("too many actual args");
else if (a)
exerror("not enough actual args");
v = exeval(ex, expr->data.call.procedure->value->data.procedure.body, env);
for (n = 0, a = expr->data.call.procedure->value->data.procedure.args; a && n < elementsof(save); a = a->data.operand.right)
a->data.operand.left->data.variable.symbol->value->data.constant.value = save[n++];
return v;
case FUNCTION:
n = 0;
args[n++].string = (char*)env;
for (x = expr->data.operand.right; x && n < elementsof(args); x = x->data.operand.right)
args[n++] = eval(ex, x->data.operand.left, env);
return (*ex->disc->getf)(ex, expr->data.operand.left, expr->data.operand.left->data.variable.symbol, expr->data.operand.left->data.variable.reference, args+1, EX_CALL, ex->disc);
case ID:
if (expr->data.variable.index)
i = eval(ex, expr->data.variable.index, env);
else
i.integer = EX_SCALAR;
return (*ex->disc->getf)(ex, expr, expr->data.variable.symbol, expr->data.variable.reference, env, (int)i.integer, ex->disc);
case INC:
n = 1;
goto add;
case PRINTF:
v.integer = print(ex, expr, env, NiL);
return v;
case QUERY:
print(ex, expr, env, sfstderr);
v.integer = !astquery(2, "");
return v;
case RETURN:
ex->loopret = eval(ex, x, env);
ex->loopcount = 32767;
ex->loopop = expr->op;
return ex->loopret;
case SCANF:
case SSCANF:
v.integer = scan(ex, expr, env, NiL);
return v;
case SPRINTF:
print(ex, expr, env, ex->tmp);
v.string = exstash(ex->tmp, ex->ve);
return v;
case '=':
v = eval(ex, expr->data.operand.right, env);
if (expr->subop != '=')
{
r = v;
if (x->op == DYNAMIC)
v = getdyn(ex, x, env, &assoc);
else
{
if (x->data.variable.index)
v = eval(ex, x->data.variable.index, env);
else
v.integer = EX_SCALAR;
v = (*ex->disc->getf)(ex, x, x->data.variable.symbol, x->data.variable.reference, env, (int)v.integer, ex->disc);
}
switch (x->type)
{
case FLOATING:
switch (expr->subop)
{
case '+':
v.floating += r.floating;
break;
case '-':
v.floating -= r.floating;
break;
case '*':
v.floating *= r.floating;
break;
case '/':
if (r.floating == 0.0)
exerror("floating divide by 0");
else
v.floating /= r.floating;
break;
case '%':
if ((r.integer = r.floating) == 0)
exerror("floating 0 modulus");
else
v.floating = ((Sflong_t)v.floating) % r.integer;
break;
case '&':
v.floating = ((Sflong_t)v.floating) & ((Sflong_t)r.floating);
break;
case '|':
v.floating = ((Sflong_t)v.floating) | ((Sflong_t)r.floating);
break;
case '^':
v.floating = ((Sflong_t)v.floating) ^ ((Sflong_t)r.floating);
break;
case LS:
v.floating = ((Sflong_t)v.floating) << ((Sflong_t)r.floating);
break;
case RS:
#if _WIN32
v.floating = (Sflong_t)(((Sfulong_t)v.floating) >> ((Sflong_t)r.floating));
#else
v.floating = ((Sfulong_t)v.floating) >> ((Sflong_t)r.floating);
#endif
break;
default:
goto huh;
}
break;
case INTEGER:
case UNSIGNED:
switch (expr->subop)
{
case '+':
v.integer += r.integer;
break;
case '-':
v.integer -= r.integer;
break;
case '*':
v.integer *= r.integer;
break;
case '/':
if (r.integer == 0)
exerror("integer divide by 0");
else
v.integer /= r.integer;
break;
case '%':
if (r.integer == 0)
exerror("integer 0 modulus");
else
v.integer %= r.integer;
break;
case '&':
v.integer &= r.integer;
break;
case '|':
v.integer |= r.integer;
break;
case '^':
v.integer ^= r.integer;
break;
case LS:
v.integer <<= r.integer;
break;
case RS:
v.integer = (Sfulong_t)v.integer >> r.integer;
break;
default:
goto huh;
}
break;
case STRING:
switch (expr->subop)
{
case '+':
v.string = str_add(ex, v.string, r.string);
break;
case '|':
v.string = str_ior(ex, v.string, r.string);
break;
case '&':
v.string = str_and(ex, v.string, r.string);
break;
case '^':
v.string = str_xor(ex, v.string, r.string);
break;
case '%':
v.string = str_mod(ex, v.string, r.string);
break;
case '*':
v.string = str_mpy(ex, v.string, r.string);
break;
default:
goto huh;
}
break;
default:
goto huh;
}
}
else if (x->op == DYNAMIC)
Encoding *_FindOrMakeEncoding(const char *name,int make_it) {
Encoding *enc;
char buffer[20];
const char *iconv_name;
Encoding temp;
uint8 good[256];
int i, j, any, all;
char from[8], ucs[20];
size_t fromlen, tolen;
ICONV_CONST char *fpt;
char *upt;
/* iconv is not case sensitive */
if ( strncasecmp(name,"iso8859_",8)==0 || strncasecmp(name,"koi8_",5)==0 ) {
/* Fixup for old naming conventions */
strncpy(buffer,name,sizeof(buffer));
*strchr(buffer,'_') = '-';
name = buffer;
} else if ( strcasecmp(name,"iso-8859")==0 ) {
/* Fixup for old naming conventions */
strncpy(buffer,name,3);
strncpy(buffer+3,name+4,sizeof(buffer)-3);
name = buffer;
} else if ( strcasecmp(name,"isolatin1")==0 ) {
name = "iso8859-1";
} else if ( strcasecmp(name,"isocyrillic")==0 ) {
name = "iso8859-5";
} else if ( strcasecmp(name,"isoarabic")==0 ) {
name = "iso8859-6";
} else if ( strcasecmp(name,"isogreek")==0 ) {
name = "iso8859-7";
} else if ( strcasecmp(name,"isohebrew")==0 ) {
name = "iso8859-8";
} else if ( strcasecmp(name,"isothai")==0 ) {
name = "tis-620"; /* TIS doesn't define non-breaking space in 0xA0 */
} else if ( strcasecmp(name,"latin0")==0 || strcasecmp(name,"latin9")==0 ) {
name = "iso8859-15"; /* "latin-9" is supported (libiconv bug?) */
} else if ( strcasecmp(name,"koi8r")==0 ) {
name = "koi8-r";
} else if ( strncasecmp(name,"jis201",6)==0 || strncasecmp(name,"jisx0201",8)==0 ) {
name = "jis_x0201";
} else if ( strcasecmp(name,"AdobeStandardEncoding")==0 || strcasecmp(name,"Adobe")==0 )
name = "AdobeStandard";
for ( enc=enclist; enc!=NULL; enc=enc->next )
if ( strmatch(name,enc->enc_name)==0 ||
(enc->iconv_name!=NULL && strmatch(name,enc->iconv_name)==0))
return( enc );
if ( strmatch(name,"unicode")==0 || strmatch(name,"iso10646")==0 || strmatch(name,"iso10646-1")==0 )
return( &unicodebmp );
if ( strmatch(name,"unicode4")==0 || strmatch(name,"ucs4")==0 )
return( &unicodefull );
iconv_name = name;
/* Mac seems to work ok */
if ( strcasecmp(name,"win")==0 || strcasecmp(name,"ansi")==0 )
iconv_name = "MS-ANSI"; /* "WINDOWS-1252";*/
else if ( strcasecmp(name,"gb2312pk")==0 || strcasecmp(name,"gb2312packed")==0 )
iconv_name = "EUC-CN";
else if ( strcasecmp(name,"wansung")==0 )
iconv_name = "EUC-KR";
else if ( strcasecmp(name,"EUC-CN")==0 ) {
iconv_name = name;
name = "gb2312pk";
} else if ( strcasecmp(name,"EUC-KR")==0 ) {
iconv_name = name;
name = "wansung";
}
/* Escape sequences: */
/* ISO-2022-CN: \e $ ) A ^N */
/* ISO-2022-KR: \e $ ) C ^N */
/* ISO-2022-JP: \e $ B */
/* ISO-2022-JP-2: \e $ ( D */
/* ISO-2022-JP-3: \e $ ( O */ /* Capital "O", not zero */
/* ISO-2022-CN-EXT: \e $ ) E ^N */ /* Not sure about this, also uses CN escape */
memset(&temp,0,sizeof(temp));
temp.builtin = true;
temp.tounicode = iconv_open(FindUnicharName(),iconv_name);
if ( temp.tounicode==(iconv_t) -1 || temp.tounicode==NULL )
return( NULL ); /* Iconv doesn't recognize this name */
temp.fromunicode = iconv_open(iconv_name,FindUnicharName());
if ( temp.fromunicode==(iconv_t) -1 || temp.fromunicode==NULL ) {
/* This should never happen, but if it does... */
iconv_close(temp.tounicode);
return( NULL );
}
memset(good,0,sizeof(good));
any = false; all = true;
for ( i=1; i<256; ++i ) {
from[0] = i; from[1] = 0;
fromlen = 1;
fpt = from;
upt = ucs;
tolen = sizeof(ucs);
if ( iconv( temp.tounicode , &fpt, &fromlen, &upt, &tolen )!= (size_t) (-1)) {
good[i] = true;
any = true;
} else
all = false;
}
if ( any )
temp.has_1byte = true;
if ( all )
temp.only_1byte = true;
if ( !all ) {
if ( strstr(iconv_name,"2022")==NULL ) {
for ( i=temp.has_1byte; i<256; ++i ) if ( !good[i] ) {
for ( j=0; j<256; ++j ) {
from[0] = i; from[1] = j; from[2] = 0;
fromlen = 2;
fpt = from;
upt = ucs;
tolen = sizeof(ucs);
if ( iconv( temp.tounicode , &fpt, &fromlen, &upt, &tolen )!= (size_t) (-1) &&
upt-ucs==sizeof(unichar_t) /* Exactly one character */ ) {
if ( temp.low_page==-1 )
temp.low_page = i;
temp.high_page = i;
temp.has_2byte = true;
break;
}
}
}
if ( temp.low_page==temp.high_page ) {
temp.has_2byte = false;
temp.low_page = temp.high_page = -1;
}
}
if ( !temp.has_2byte && !good[033]/* escape */ ) {
if ( strstr(iconv_name,"2022")!=NULL &&
strstr(iconv_name,"JP3")!=NULL &&
TryEscape( &temp,"\33$(O" )) {
;
}
else if ( strstr(iconv_name,"2022")!=NULL &&
strstr(iconv_name,"JP2")!=NULL &&
TryEscape( &temp,"\33$(D" )) {
;
}
else if ( strstr(iconv_name,"2022")!=NULL &&
strstr(iconv_name,"JP")!=NULL &&
TryEscape( &temp,"\33$B" )) {
;
}
else if ( strstr(iconv_name,"2022")!=NULL &&
strstr(iconv_name,"KR")!=NULL &&
TryEscape( &temp,"\33$)C\16" )) {
;
}
else if ( strstr(iconv_name,"2022")!=NULL &&
strstr(iconv_name,"CN")!=NULL &&
TryEscape( &temp,"\33$)A\16" )) {
;
}
}
}
if ( !temp.has_1byte && !temp.has_2byte )
return( NULL );
if ( !make_it )
return( NULL );
enc = chunkalloc(sizeof(Encoding));
*enc = temp;
enc->enc_name = copy(name);
if ( iconv_name!=name )
enc->iconv_name = copy(iconv_name);
enc->next = enclist;
enc->builtin = true;
enclist = enc;
if ( enc->has_2byte )
enc->char_cnt = (enc->high_page<<8) + 256;
else {
enc->char_cnt = 256;
enc->only_1byte = true;
}
if ( strstrmatch(iconv_name,"JP")!=NULL ||
strstrmatch(iconv_name,"sjis")!=NULL ||
strstrmatch(iconv_name,"cp932")!=NULL )
enc->is_japanese = true;
else if ( strstrmatch(iconv_name,"KR")!=NULL )
enc->is_korean = true;
else if ( strstrmatch(iconv_name,"CN")!=NULL )
enc->is_simplechinese = true;
else if ( strstrmatch(iconv_name,"BIG")!=NULL && strstrmatch(iconv_name,"5")!=NULL )
enc->is_tradchinese = true;
if ( strstrmatch(name,"ISO8859")!=NULL &&
strtol(name+strlen(name)-2,NULL,10)>=16 )
/* Not in our menu, don't hide */;
else if ( iconv_name!=name || strmatch(name,"mac")==0 || strstrmatch(name,"ISO8859")!=NULL ||
strmatch(name,"koi8-r")==0 || strmatch(name,"sjis")==0 ||
strmatch(name,"big5")==0 || strmatch(name,"big5hkscs")==0 )
enc->hidden = true;
return( enc );
}
/**
* Register a physical %HMM as a member of a pseudo phone set.
*
* @param root [i/o] root node of %HMM search index node.
* @param d [in] a physical defined %HMM to be added.
* @param cdname [in] name of the pseudo phone set.
*
* @return TRUE if newly registered, FALSE if the specified physical %HMM already exists in the pseudo phone.
*/
boolean
regist_cdset(APATNODE **root, HTK_HMM_Data *d, char *cdname, BMALLOC_BASE **mroot)
{
boolean need_new;
CD_State_Set *tmp;
CD_Set *lset = NULL, *lmatch = NULL;
int j,n;
boolean changed = FALSE;
if (strlen(cdname) >= MAX_HMMNAME_LEN) {
jlog("Error: cdset: HMM name exceeds limit (%d): %s!\n", MAX_HMMNAME_LEN, cdname);
jlog("Error: cdset: Please increase the value of MAX_HMMNAME_LEN (current = %d)\n", MAX_HMMNAME_LEN);
exit(1);
}
/* check if the cdset already exist */
need_new = TRUE;
if (*root != NULL) {
lmatch = aptree_search_data(cdname, *root);
if (lmatch != NULL && strmatch(lmatch->name, cdname)) {
/* exist, add to it later */
lset = lmatch;
need_new = FALSE;
/* if the state num is larger than allocated, expand the lset */
if (d->state_num > lset->state_num) {
lset->stateset = (CD_State_Set *)myrealloc(lset->stateset, sizeof(CD_State_Set) * d->state_num);
/* 0 1 ... (lset->state_num-1) */
/* N A ... N */
/* 0 1 ... ... (d->state_num-1) */
/* N A ... A ..................... N */
/* malloc new area to expanded state (N to A above) */
for(j = lset->state_num - 1; j < d->state_num - 1; j++) {
lset->stateset[j].maxnum = CD_STATE_SET_STEP;
lset->stateset[j].s = (HTK_HMM_State **)mymalloc(sizeof(HTK_HMM_State *) * lset->stateset[j].maxnum);
lset->stateset[j].num = 0;
}
lset->stateset[d->state_num-1].s = NULL;
lset->stateset[d->state_num-1].num = 0;
lset->stateset[d->state_num-1].maxnum = 0;
lset->state_num = d->state_num;
/* update transition table */
lset->tr = d->tr;
changed = TRUE;
}
}
}
if (need_new) {
/* allocate as new with blank data */
lset = cdset_new();
lset->name = strdup(cdname);
lset->state_num = d->state_num;
lset->stateset = (CD_State_Set *)mymalloc(sizeof(CD_State_Set) * lset->state_num);
/* assume first and last state has no outprob */
lset->stateset[0].s = lset->stateset[lset->state_num-1].s = NULL;
lset->stateset[0].num = lset->stateset[lset->state_num-1].num = 0;
lset->stateset[0].maxnum = lset->stateset[lset->state_num-1].maxnum = 0;
for(j=1;j<lset->state_num-1; j++) {
/* pre-allocate only the first step */
lset->stateset[j].maxnum = CD_STATE_SET_STEP;
lset->stateset[j].s = (HTK_HMM_State **)mymalloc(sizeof(HTK_HMM_State *) * lset->stateset[j].maxnum);
lset->stateset[j].num = 0;
}
/* assign transition table of first found %HMM (ad-hoc?) */
lset->tr = d->tr;
/* add to search index tree */
if (*root == NULL) {
*root = aptree_make_root_node(lset, mroot);
} else {
aptree_add_entry(lset->name, lset, lmatch->name, root, mroot);
}
changed = TRUE;
}
/* register each HMM states to the lcdset */
for (j=1;j<d->state_num-1;j++) {
tmp = &(lset->stateset[j]);
/* check if the state has already registered */
for(n = 0; n < tmp->num ; n++) {
if (tmp->s[n] == d->s[j]) { /* compare by pointer */
/*jlog("\tstate %d has same\n", n);*/
break;
}
}
if (n < tmp->num ) continue; /* same state found, cancel regist. */
/* expand storage area if necessary */
if (tmp->num >= tmp->maxnum) {
tmp->maxnum += CD_STATE_SET_STEP;
tmp->s = (HTK_HMM_State **)myrealloc(tmp->s, sizeof(HTK_HMM_State *) * tmp->maxnum);
}
tmp->s[tmp->num] = d->s[j];
tmp->num++;
changed = TRUE;
}
return(changed);
}
static void evalPrimary(Parser *p){
double d, d2=NAN;
char *next= p->s;
int i;
/* number */
d= strtod(p->s, &next);
if(next != p->s){
push(p, d);
p->s= next;
return;
}
/* named constants */
for(i=0; p->const_name[i]; i++){
if(strmatch(p->s, p->const_name[i])){
push(p, p->const_value[i]);
p->s+= strlen(p->const_name[i]);
return;
}
}
p->s= strchr(p->s, '(');
if(p->s==NULL){
fprintf(stderr, "Parser: missing ( in \"%s\"\n", next);
return;
}
p->s++; // "("
evalExpression(p);
d= pop(p);
if(p->s[0]== ','){
p->s++; // ","
evalExpression(p);
d2= pop(p);
}
if(p->s[0] != ')'){
fprintf(stderr, "Parser: missing ) in \"%s\"\n", next);
return;
}
p->s++; // ")"
if( strmatch(next, "sinh" ) ) d= sinh(d);
else if( strmatch(next, "cosh" ) ) d= cosh(d);
else if( strmatch(next, "tanh" ) ) d= tanh(d);
else if( strmatch(next, "sin" ) ) d= sin(d);
else if( strmatch(next, "cos" ) ) d= cos(d);
else if( strmatch(next, "tan" ) ) d= tan(d);
else if( strmatch(next, "exp" ) ) d= exp(d);
else if( strmatch(next, "log" ) ) d= log(d);
else if( strmatch(next, "squish") ) d= 1/(1+exp(4*d));
else if( strmatch(next, "gauss" ) ) d= exp(-d*d/2)/sqrt(2*M_PI);
else if( strmatch(next, "abs" ) ) d= fabs(d);
else if( strmatch(next, "max" ) ) d= d > d2 ? d : d2;
else if( strmatch(next, "min" ) ) d= d < d2 ? d : d2;
else if( strmatch(next, "gt" ) ) d= d > d2 ? 1.0 : 0.0;
else if( strmatch(next, "gte" ) ) d= d >= d2 ? 1.0 : 0.0;
else if( strmatch(next, "lt" ) ) d= d > d2 ? 0.0 : 1.0;
else if( strmatch(next, "lte" ) ) d= d >= d2 ? 0.0 : 1.0;
else if( strmatch(next, "eq" ) ) d= d == d2 ? 1.0 : 0.0;
// else if( strmatch(next, "l1" ) ) d= 1 + d2*(d - 1);
// else if( strmatch(next, "sq01" ) ) d= (d >= 0.0 && d <=1.0) ? 1.0 : 0.0;
else{
int error=1;
for(i=0; p->func1_name && p->func1_name[i]; i++){
if(strmatch(next, p->func1_name[i])){
d= p->func1[i](p->opaque, d);
error=0;
break;
}
}
for(i=0; p->func2_name && p->func2_name[i]; i++){
if(strmatch(next, p->func2_name[i])){
d= p->func2[i](p->opaque, d, d2);
error=0;
break;
}
}
if(error){
fprintf(stderr, "Parser: unknown function in \"%s\"\n", next);
return;
}
}
push(p, d);
}
/**
* Parse the input line and set grammar information, one by line.
*
* @param line [in] text buffer that holds a line of DFA file
* @param dinfo [i/o] the read data will be appended to this DFA data
* @param state_max [i/o] maximum number of state id appeared, will be updated
* @param arc_num [i/o] number of read arcs, will be updated
* @param terminal_max [i/o] maximum number of state id appended, will be updated
*
* @return TRUE if the line was successfully parsed, FALSE if failed.
*/
boolean
rddfa_line(char *line, DFA_INFO *dinfo, int *state_max, int *arc_num, int *terminal_max)
{
DFA_ARC *newarc;
int state, terminal, next_state;
unsigned int status;
char *p;
if (strmatch(buf, "DFAEND")) return(FALSE);
/* format: state terminalID nextstate statuscode_of_state */
if ((p = strtok(line, DELM)) == NULL) {
jlog("Error: rddfa: failed to parse, corrupted or invalid data?\n");
return FALSE;
}
state = atoi(p);
if ((p = strtok(NULL, DELM)) == NULL) {
jlog("Error: rddfa: failed to parse, corrupted or invalid data?\n");
return FALSE;
}
terminal = atoi(p);
if ((p = strtok(NULL, DELM)) == NULL) {
jlog("Error: rddfa: failed to parse, corrupted or invalid data?\n");
return FALSE;
}
next_state = atoi(p);
if ((p = strtok(NULL, DELM)) == NULL) {
jlog("Error: rddfa: failed to parse, corrupted or invalid data?\n");
return FALSE;
}
sscanf(p, "%x", &status);
if (state >= dinfo->maxstatenum) { /* expand */
dfa_state_expand(dinfo, state+1);
}
if (next_state >= dinfo->maxstatenum) { /* expand */
dfa_state_expand(dinfo, next_state+1);
}
/* set state status (accept / initial) */
if (status & ACCEPT_S) {
dinfo->st[state].status |= ACCEPT_S;
}
/* the state #0 is an initial state */
if (state == 0) {
dinfo->st[state].status |= INITIAL_S;
}
/* skip line with negative terminalID/nextstate */
if (terminal > 0 || next_state > 0) {
/* add new arc to the state */
newarc = (DFA_ARC *)mymalloc(sizeof(DFA_ARC));
newarc->label = terminal;
newarc->to_state = next_state;
newarc->next = dinfo->st[state].arc;
dinfo->st[state].arc = newarc;
(*arc_num)++;
}
if (*state_max < state) *state_max = state;
if (*terminal_max < terminal) *terminal_max = terminal;
return(TRUE);
}
char *linux_bootchart_update_ps (char *ps, char *uptime) {
DIR *d;
struct dirent *e;
char **data = NULL;
d = opendir ("/proc");
if (d != NULL) {
while ((e = readdir (d))) {
char *t, *u, *da = NULL;
if (strmatch (e->d_name, ".") || strmatch (e->d_name, "..")) {
continue;
}
if ((t = joinpath ("/proc/", e->d_name))) {
if ((u = joinpath (t, "stat"))) {
struct stat st;
if (!stat (u, &st)) {
da = readfile (u);
}
free (u);
}
/* if ((u = joinpath (t, "cmdline"))) {
struct stat st;
if (!stat (u, &st)) {
char *ru = readfile (u);
if (strstr (ru, )) {
linux_bootchart_have_thread = 0;
}
}
free (u);
}*/
free (t);
}
if (da) {
data = (char **)setadd ((void **)data, da, SET_TYPE_STRING);
free (da);
da = NULL;
}
}
closedir(d);
}
if (data) {
char *t = set2str ('\n', (const char **)data);
if (t) {
size_t len = strlen (uptime) + strlen (t) + 4 + (ps ? strlen (ps) : 0);
char *tx = emalloc (len);
if (ps) {
esprintf (tx, len, "%s\n%s\n%s\n", ps, uptime, t);
free (ps);
} else {
esprintf (tx, len, "%s\n%s\n", uptime, t);
}
free (t);
ps = tx;
}
free (data);
}
return ps;
}
/* readbuffer
* Reads in the input file and stores all strings in the
* section between "#ifdef SCPACK" and "#else" in a buffer.
* Only text that is between double quotes is added to the
* buffer; the \" escape code is handled. Multiple strings
* on one line are handled.
*/
unsigned readbuffer(FILE *input, unsigned char *buffer)
{
char str[256];
unsigned buffersize;
int i,linenr;
linenr=0;
buffersize=0;
rewind(input);
while (!feof(input)) {
while (fgets(str,sizeof str,input)!=NULL) {
linenr++;
check_tablename(str);
check_separator(str);
if (strmatch(str,START_TOKEN,NULL))
break;
} /* while */
if (!strmatch(str,START_TOKEN,NULL))
return buffersize; /* no (more) section found, quit */
while (fgets(str,sizeof str,input)!=NULL) {
linenr++;
check_if(str,linenr);
if (check_tablename(str))
printf("Error: table name definition should not be in SCPACK section (line %d)\n", linenr);
check_separator(str);
if (strmatch(str,"#else",NULL))
break; /* done */
/* add to the buffer only what is between double quotes */
i=0;
do {
while (str[i]!='\0' && str[i]!='"')
i++;
if (str[i]=='"') {
/* we are in a string */
i++;
while (str[i]!='\0' && str[i]!='"') {
/* handle escape sequences */
if (str[i]=='\\') {
i++;
switch (str[i]) {
case 'a': /* alarm */
buffer[buffersize++]='\a';
i++;
break;
case 'b': /* backspace */
buffer[buffersize++]='\b';
i++;
break;
case 'f': /* form feed */
buffer[buffersize++]='\f';
i++;
break;
case 'n': /* newline */
buffer[buffersize++]='\n';
i++;
break;
case 'r': /* carriage return */
buffer[buffersize++]='\n';
i++;
break;
case 't': /* tab */
buffer[buffersize++]='\t';
i++;
break;
case '\'':
buffer[buffersize++]='\'';
i++;
break;
case '"':
buffer[buffersize++]='"';
i++;
break;
default:
// ??? octal character code escapes and hexadecimal escapes
// not supported
printf("Unknown escape sequence '\\%c' on line %d\n",
str[i], linenr);
} /* switch */
} else {
buffer[buffersize++]=str[i++];
} /* if */
} /* while */
if (str[i]=='"') {
buffer[buffersize++]='\0'; /* terminate each string */
i++;
} else {
printf("Error: unterminated string on line %d\n",linenr);
} /* if */
} /* if */
} while (str[i]!='\0');
} /* while - in SCPACK section */
/* put in another '\0' to terminate the section */
buffer[buffersize++]='\0';
} /* while - !feof(input) */
return buffersize;
}
static int
str2code(char *codestr, unsigned int *code)
{
if (strmatch(codestr, "euc-jp")
|| strmatch(codestr, "euc")
|| strmatch(codestr, "eucjp")) {
/* input = Shift_jis (codepage 932) */
*code = CODE_JPN_EUC;
} else if (strmatch(codestr, "ansi")) {
/* ANSI codepage (MBCS) ex. shift-jis in Windows XP Japanese edition.*/
*code = CP_ACP;
} else if (strmatch(codestr, "mac")) {
/* Macintosh codepage */
*code = CP_MACCP;
} else if (strmatch(codestr, "oem")) {
/* OEM localized default codepage */
*code = CP_OEMCP;
} else if (strmatch(codestr, "utf-7")) {
/* UTF-7 codepage */
*code = CP_UTF7;
} else if (strmatch(codestr, "utf-8")) {
/* UTF-8 codepage */
*code = CP_UTF8;
} else if (strmatch(codestr, "sjis")
|| strmatch(codestr, "sjis-win")
|| strmatch(codestr, "shift-jis")
|| strmatch(codestr, "shift_jis")) {
/* sjis codepage = 932 */
*code = 932;
} else if (codestr[0] >= '0' && codestr[0] <= '9') {
/* codepage number */
*code = atoi(codestr);
if (! IsValidCodePage(*code)) {
jlog("Error: charconv_win32: codepage \"%d\" not found\n", codestr);
return -1;
}
} else {
fprintf(stderr, "Error: str2code: unknown source codepage \"%s\"\n", codestr);
fprintf(stderr, "Error: str2code: valids are \"euc-jp\", \"ansi\", \"mac\", \"oem\", \"utf-7\", \"utf-8\", \"sjis\" and codepage number\n");
return -1;
}
return 0;
}
mBOOL DLLINTERNAL MConfig::set(option_t *setp, const char *setstr) {
char pathbuf[PATH_MAX];
int *optval = (int *) setp->dest;
char **optstr = (char **) setp->dest;
// cvar_t *optcvar = (cvar_t *) setp->dest;
// SETOPT_FN optcmd = (SETOPT_FN) setp->dest;
if(!setstr)
return(mTRUE);
switch(setp->type) {
case CF_INT:
if(!isdigit(setstr[0])) {
META_WARNING("option '%s' invalid format '%s'", setp->name, setstr);
RETURN_ERRNO(mFALSE, ME_FORMAT);
}
*optval=atoi(setstr);
META_DEBUG(3, ("set config int: %s = %d", setp->name, *optval));
break;
case CF_BOOL:
if(strcasematch(setstr, "true")
|| strcasematch(setstr, "yes")
|| strmatch(setstr, "1"))
{
*optval=1;
}
else if(strcasematch(setstr, "false")
|| strcasematch(setstr, "no")
|| strmatch(setstr, "0"))
{
*optval=0;
}
else {
META_WARNING("option '%s' invalid format '%s'", setp->name, setstr);
RETURN_ERRNO(mFALSE, ME_FORMAT);
}
META_DEBUG(3, ("set config bool: %s = %s", setp->name, *optval ? "true" : "false"));
break;
case CF_STR:
if(*optstr)
free(*optstr);
*optstr=strdup(setstr);
META_DEBUG(3, ("set config string: %s = %s", setp->name, *optstr));
break;
case CF_PATH:
if(*optstr)
free(*optstr);
full_gamedir_path(setstr, pathbuf);
*optstr=strdup(pathbuf);
META_DEBUG(3, ("set config path: %s = %s", setp->name, *optstr));
break;
#if 0
case CF_CVAR:
CVAR_SET_STRING(optcvar->name, setstr);
META_DEBUG(3, ("set config cvar: %s = %s", optcvar->name, setstr));
break;
case CF_CMD:
optcmd(setp->name, setstr);
META_DEBUG(3, ("set config command: %s, %s", optcvar->name, setstr));
break;
#endif
default:
META_WARNING("unrecognized config type '%d'", setp->type);
RETURN_ERRNO(mFALSE, ME_ARGUMENT);
}
return(mTRUE);
}
void linux_hotplug_hotplug_event_handler (struct einit_event *ev) {
if (ev->stringset) {
char *subsystem = NULL;
char *firmware = NULL;
char *devpath = NULL;
int i = 0;
struct cfgnode *node = cfg_getnode ("configuration-system-hotplug-support-legacy-hotplug-scripts", NULL);
for (; ev->stringset[i]; i+=2) {
if (strmatch (ev->stringset[i], "SUBSYSTEM")) {
subsystem = ev->stringset[i+1];
} else if (strmatch (ev->stringset[i], "FIRMWARE")) {
firmware = ev->stringset[i+1];
} else if (strmatch (ev->stringset[i], "DEVPATH")) {
devpath = ev->stringset[i+1];
}
}
if (node && node->flag) {
char **commands = NULL;
if (subsystem) {
char n = 0;
for (; n < 2; n++) {
char buffer[BUFFERSIZE];
char *tbuffer = (n == 1) ? "/etc/einit/hotplug.d/default/" : NULL;
switch (n) {
case 0:
esprintf(buffer, BUFFERSIZE, "/etc/einit/hotplug.d/%s/", subsystem);
tbuffer = buffer;
break;
case 1:
break;
default:
tbuffer = NULL;
break;
}
if (tbuffer) {
struct stat st;
if (!stat (tbuffer, &st) && S_ISDIR(st.st_mode)) {
char **cm = readdirfilter (NULL, tbuffer, "\\.hotplug$", NULL, 0);
if (cm) {
commands = (char **)setcombine_nc ((void **)commands, (const void **)cm, SET_TYPE_STRING);
efree (cm);
}
}
}
}
}
if (commands) {
char **env = NULL;
char *command;
ssize_t blen = strlen (subsystem) + 2;
char **cd = NULL;
for (i = 0; ev->stringset[i]; i+=2) {
env = straddtoenviron (env, ev->stringset[i], ev->stringset[i+1]);
}
for (i = 0; commands[i]; i++) {
int len = blen + strlen (commands[i]);
char *t = emalloc (len);
esprintf (t, len, "%s %s", commands[i], subsystem);
cd = set_str_add (cd, t);
efree (t);
}
if (cd) {
command = set2str (';', (const char **)cd);
pexec(command, NULL, 0, 0, NULL, NULL, env, NULL);
efree (cd);
efree (command);
}
efree (env);
efree (commands);
}
}
if (firmware && (ev->type == einit_hotplug_add)) {
char buffer[BUFFERSIZE];
int tblen = sizeof(SYS_DIR) + strlen (devpath) + 11;
FILE *f;
struct stat st;
char *targetbuffer = emalloc (tblen);
notice (2, "need firmware: %s", firmware);
esprintf (buffer, BUFFERSIZE, FIRMWARE_DIR "/%s", firmware);
if (stat (buffer, &st)) {
esprintf (targetbuffer, tblen, SYS_DIR "/%s/loading", devpath);
if ((f = fopen (targetbuffer, "w"))) {
fputs ("-1\n", f);
fclose (f);
}
notice (3, "can't locate firmware: %s", buffer);
} else {
esprintf (targetbuffer, tblen, SYS_DIR "/%s/loading", devpath);
if ((f = fopen (targetbuffer, "w"))) {
fputs ("1\n", f);
fclose (f);
}
esprintf (targetbuffer, tblen, SYS_DIR "/%s/data", devpath);
ssize_t ll = 0;
char *firmware_data = readfile_l (buffer, &ll);
if (firmware_data && ll) {
if ((f = fopen (targetbuffer, "w"))) {
int rembytes = ll;
while (rembytes > 0) {
size_t bw = fwrite (firmware_data +ll -rembytes, rembytes, 1, f);
if (bw == 1) break;
if (bw < 0) {
notice (3, "error writing firmware: %s", buffer);
}
}
fclose (f);
}
esprintf (targetbuffer, tblen, SYS_DIR "/%s/loading", devpath);
if ((f = fopen (targetbuffer, "w"))) {
fputs ("0\n", f);
fclose (f);
}
notice (3, "firmware loaded okay: %s", buffer);
} else {
esprintf (targetbuffer, tblen, SYS_DIR "/%s/loading", devpath);
if ((f = fopen (targetbuffer, "w"))) {
fputs ("-1\n", f);
fclose (f);
}
notice (3, "can't load firmware: %s", buffer);
}
}
notice (3, "done loading firmware: %s", buffer);
efree (targetbuffer);
}
}
}
int main(int argc, char **argv, char **environ) {
#else
int main(int argc, char **argv) {
#endif
int i, ret = EXIT_SUCCESS;
pid_t pid = getpid(), wpid = 0;
char **ipccommands = NULL;
int pthread_errno;
FILE *commandpipe_in, *commandpipe_out;
int commandpipe[2];
int debugsocket[2];
char need_recovery = 0;
char debug = 0;
int debugme_pipe = 0;
char crash_threshold = 5;
char *einit_crash_data = NULL;
boottime = time(NULL);
uname (&osinfo);
config_configure();
// initialise subsystems
ipc_configure(NULL);
// is this the system's init-process?
isinit = getpid() == 1;
event_listen (einit_event_subsystem_core, core_einit_event_handler);
event_listen (einit_event_subsystem_timer, core_timer_event_handler);
if (argv) einit_argv = (char **)setdup ((const void **)argv, SET_TYPE_STRING);
/* check command line arguments */
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-')
switch (argv[i][1]) {
case 'c':
if ((++i) < argc)
einit_default_startup_configuration_files[0] = argv[i];
else
return print_usage_info ();
break;
case 'h':
return print_usage_info ();
break;
case 'v':
eputs("eINIT " EINIT_VERSION_LITERAL "\n", stdout);
return 0;
case 'L':
eputs("eINIT " EINIT_VERSION_LITERAL
"\nThis Program is Free Software, released under the terms of this (BSD) License:\n"
"--------------------------------------------------------------------------------\n"
"Copyright (c) 2006, 2007, Magnus Deininger\n"
BSDLICENSE "\n", stdout);
return 0;
case '-':
if (strmatch(argv[i], "--check-configuration") || strmatch(argv[i], "--checkup") || strmatch(argv[i], "--wtf")) {
ipccommands = (char **)setadd ((void **)ipccommands, "examine configuration", SET_TYPE_STRING);
} else if (strmatch(argv[i], "--help"))
return print_usage_info ();
else if (strmatch(argv[i], "--ipc-command") && argv[i+1])
ipccommands = (char **)setadd ((void **)ipccommands, (void *)argv[i+1], SET_TYPE_STRING);
else if (strmatch(argv[i], "--override-init-check"))
initoverride = 1;
else if (strmatch(argv[i], "--sandbox")) {
einit_default_startup_configuration_files[0] = "lib/einit/einit.xml";
coremode = einit_mode_sandbox;
need_recovery = 1;
} else if (strmatch(argv[i], "--metadaemon")) {
coremode = einit_mode_metadaemon;
} else if (strmatch(argv[i], "--bootstrap-modules")) {
bootstrapmodulepath = argv[i+1];
} else if (strmatch(argv[i], "--debugme")) {
debugme_pipe = parse_integer (argv[i+1]);
i++;
initoverride = 1;
} else if (strmatch(argv[i], "--debug")) {
debug = 1;
}
break;
}
}
/* check environment */
if (environ) {
uint32_t e = 0;
for (e = 0; environ[e]; e++) {
char *ed = estrdup (environ[e]);
char *lp = strchr (ed, '=');
*lp = 0;
lp++;
if (strmatch (ed, "softlevel")) {
einit_startup_mode_switches = str2set (':', lp);
} if (strmatch (ed, "mode")) {
/* override default mode-switches with the ones in the environment variable mode= */
einit_startup_mode_switches = str2set (':', lp);
} else if (strmatch (ed, "einit")) {
/* override default configuration files and/or mode-switches with the ones in the variable einit= */
char **tmpstrset = str2set (',', lp);
uint32_t rx = 0;
for (rx = 0; tmpstrset[rx]; rx++) {
char **atom = str2set (':', tmpstrset[rx]);
if (strmatch (atom[0], "file")) {
/* specify configuration files */
einit_startup_configuration_files = (char **)setdup ((const void **)atom, SET_TYPE_STRING);
einit_startup_configuration_files = (char **)strsetdel (einit_startup_configuration_files, (void *)"file");
} else if (strmatch (atom[0], "mode")) {
/* specify mode-switches */
einit_startup_mode_switches = (char **)setdup ((const void **)atom, SET_TYPE_STRING);
einit_startup_mode_switches = (char **)strsetdel (einit_startup_mode_switches, (void *)"mode");
} else if (strmatch (atom[0], "stfu")) {
einit_quietness = 3;
} else if (strmatch (atom[0], "silent")) {
einit_quietness = 2;
} else if (strmatch (atom[0], "quiet")) {
einit_quietness = 1;
}
free (atom);
}
free (tmpstrset);
}
free (ed);
}
einit_initial_environment = (char **)setdup ((const void **)environ, SET_TYPE_STRING);
}
if (!einit_startup_mode_switches) einit_startup_mode_switches = einit_default_startup_mode_switches;
if (!einit_startup_configuration_files) einit_startup_configuration_files = einit_default_startup_configuration_files;
respawn:
pipe (commandpipe);
fcntl (commandpipe[1], F_SETFD, FD_CLOEXEC);
socketpair (AF_UNIX, SOCK_STREAM, 0, debugsocket);
fcntl (debugsocket[0], F_SETFD, FD_CLOEXEC);
fcntl (debugsocket[1], F_SETFD, FD_CLOEXEC);
if (!debug) {
fcntl (commandpipe[0], F_SETFD, FD_CLOEXEC);
commandpipe_in = fdopen (commandpipe[0], "r");
}
commandpipe_out = fdopen (commandpipe[1], "w");
if (!initoverride && ((pid == 1) || ((coremode & einit_mode_sandbox) && !ipccommands))) {
// if (pid == 1) {
initoverride = 1;
#if 0
#ifdef LINUX
if ((einit_sub = syscall(__NR_clone, CLONE_PTRACE | SIGCHLD, 0, NULL, NULL, NULL)) < 0) {
bitch (bitch_stdio, errno, "Could not fork()");
eputs (" !! Haven't been able to fork a secondary worker process. This is VERY bad, you will get a lot of zombie processes! (provided that things work at all)\n", stderr);
}
#else
#endif
#endif
if ((einit_sub = fork()) < 0) {
bitch (bitch_stdio, errno, "Could not fork()");
eputs (" !! Haven't been able to fork a secondary worker process. This is VERY bad, you will get a lot of zombie processes! (provided that things work at all)\n", stderr);
}
}
if (einit_sub) {
/* PID==1 part */
int rstatus;
struct sigaction action;
/* signal handlers */
action.sa_sigaction = einit_sigint;
sigemptyset(&(action.sa_mask));
action.sa_flags = SA_SIGINFO | SA_RESTART | SA_NODEFER;
if ( sigaction (SIGINT, &action, NULL) ) bitch (bitch_stdio, 0, "calling sigaction() failed.");
/* ignore sigpipe */
action.sa_sigaction = (void (*)(int, siginfo_t *, void *))SIG_IGN;
if ( sigaction (SIGPIPE, &action, NULL) ) bitch (bitch_stdio, 0, "calling sigaction() failed.");
close (debugsocket[1]);
if (einit_crash_data) {
free (einit_crash_data);
einit_crash_data = NULL;
}
while (1) {
wpid = waitpid(-1, &rstatus, 0); /* this ought to wait for ANY process */
if (wpid == einit_sub) {
// goto respawn; /* try to recover by re-booting */
if (!debug) if (commandpipe_in) fclose (commandpipe_in);
if (commandpipe_out) fclose (commandpipe_out);
if (WIFEXITED(rstatus) && (WEXITSTATUS(rstatus) != einit_exit_status_die_respawn)) {
fprintf (stderr, "eINIT has quit properly.\n");
if (!(coremode & einit_mode_sandbox)) {
if (WEXITSTATUS(rstatus) == einit_exit_status_last_rites_halt) {
execl (EINIT_LIB_BASE "/bin/last-rites", EINIT_LIB_BASE "/bin/last-rites", "h", NULL);
} else if (WEXITSTATUS(rstatus) == einit_exit_status_last_rites_reboot) {
execl (EINIT_LIB_BASE "/bin/last-rites", EINIT_LIB_BASE "/bin/last-rites", "r", NULL);
} else if (WEXITSTATUS(rstatus) == einit_exit_status_last_rites_kexec) {
execl (EINIT_LIB_BASE "/bin/last-rites", EINIT_LIB_BASE "/bin/last-rites", "k", NULL);
}
}
exit (EXIT_SUCCESS);
}
int n = 5;
fprintf (stderr, "The secondary eINIT process has died, waiting a while before respawning.\n");
if ((einit_crash_data = readfd (debugsocket[0]))) {
fprintf (stderr, " > neat, received crash data\n");
}
while ((n = sleep (n)));
fprintf (stderr, "Respawning secondary eINIT process.\n");
if (crash_threshold) crash_threshold--;
else debug = 1;
need_recovery = 1;
initoverride = 0;
close (debugsocket[0]);
goto respawn;
} else {
if (commandpipe_out) {
if (WIFEXITED(rstatus)) {
fprintf (commandpipe_out, "pid %i terminated\n\n", wpid);
} else {
fprintf (commandpipe_out, "pid %i died\n\n", wpid);
}
fflush (commandpipe_out);
}
}
}
} else {
enable_core_dumps ();
close (debugsocket[0]);
sched_trace_target = debugsocket[1];
if (debug) {
char **xargv = (char **)setdup ((const void **)argv, SET_TYPE_STRING);
char tbuffer[BUFFERSIZE];
struct stat st;
char have_valgrind = 0;
char have_gdb = 0;
fputs ("eINIT needs to be debugged, starting in debugger mode\n.", stderr);
xargv = (char **)setadd ((void **)xargv, (void *)"--debugme", SET_TYPE_STRING);
snprintf (tbuffer, BUFFERSIZE, "%i", commandpipe[0]);
xargv = (char **)setadd ((void **)xargv, (void *)tbuffer, SET_TYPE_STRING);
xargv = strsetdel (xargv, "--debug"); // don't keep the --debug flag
if (!stat ("/usr/bin/valgrind", &st)) have_valgrind = 1;
if (!stat ("/usr/bin/gdb", &st)) have_gdb = 1;
if (have_valgrind) {
char **nargv = NULL;
uint32_t i = 1;
#ifdef LINUX
if (!(coremode & einit_mode_sandbox)) {
mount ("proc", "/proc", "proc", 0, NULL);
mount ("sys", "/sys", "sysfs", 0, NULL);
system ("mount / -o remount,rw");
}
#endif
nargv = (char **)setadd ((void **)nargv, "/usr/bin/valgrind", SET_TYPE_STRING);
nargv = (char **)setadd ((void **)nargv, "--log-file=/einit.valgrind", SET_TYPE_STRING);
nargv = (char **)setadd ((void **)nargv, (coremode & einit_mode_sandbox) ? "sbin/einit" : "/sbin/einit", SET_TYPE_STRING);
for (; xargv[i]; i++) {
nargv = (char **)setadd ((void **)nargv, xargv[i], SET_TYPE_STRING);
}
execv ("/usr/bin/valgrind", nargv);
} else {
execv ((coremode & einit_mode_sandbox) ? "sbin/einit" : "/sbin/einit", xargv);
}
}
if (debugme_pipe) { // commandpipe[0]
fcntl (commandpipe[0], F_SETFD, FD_CLOEXEC);
commandpipe_in = fdopen (debugme_pipe, "r");
}
/* actual system initialisation */
struct einit_event cev = evstaticinit(einit_core_update_configuration);
if (ipccommands && (coremode != einit_mode_sandbox)) {
coremode = einit_mode_ipconly;
}
eprintf (stderr, "eINIT " EINIT_VERSION_LITERAL ": Initialising: %s\n", osinfo.sysname);
if ((pthread_errno = pthread_attr_init (&thread_attribute_detached))) {
bitch(bitch_epthreads, pthread_errno, "pthread_attr_init() failed.");
if (einit_initial_environment) free (einit_initial_environment);
return -1;
} else {
if ((pthread_errno = pthread_attr_setdetachstate (&thread_attribute_detached, PTHREAD_CREATE_DETACHED))) {
bitch(bitch_epthreads, pthread_errno, "pthread_attr_setdetachstate() failed.");
}
}
if ((pthread_errno = pthread_key_create(&einit_function_macro_key, NULL))) {
bitch(bitch_epthreads, pthread_errno, "pthread_key_create(einit_function_macro_key) failed.");
if (einit_initial_environment) free (einit_initial_environment);
return -1;
}
/* this should be a good place to initialise internal modules */
if (coremodules) {
uint32_t cp = 0;
eputs (" >> initialising in-core modules:", stderr);
for (; coremodules[cp]; cp++) {
struct lmodule *lmm;
eprintf (stderr, " [%s]", (*coremodules[cp])->rid);
lmm = mod_add(NULL, (*coremodules[cp]));
lmm->source = estrdup("core");
}
eputs (" OK\n", stderr);
}
/* emit events to read configuration files */
if (einit_startup_configuration_files) {
uint32_t rx = 0;
for (; einit_startup_configuration_files[rx]; rx++) {
cev.string = einit_startup_configuration_files[rx];
event_emit (&cev, einit_event_flag_broadcast);
}
if (einit_startup_configuration_files != einit_default_startup_configuration_files) {
free (einit_startup_configuration_files);
}
}
cev.string = NULL;
cev.type = einit_core_configuration_update;
// make sure we keep updating until everything is sorted out
while (cev.type == einit_core_configuration_update) {
// notice (2, "stuff changed, updating configuration.");
cev.type = einit_core_update_configuration;
event_emit (&cev, einit_event_flag_broadcast);
}
evstaticdestroy(cev);
if (ipccommands) {
uint32_t rx = 0;
for (; ipccommands[rx]; rx++) {
ret = ipc_process (ipccommands[rx], stdout);
}
// if (gmode == EINIT_GMODE_SANDBOX)
// cleanup ();
free (ipccommands);
if (einit_initial_environment) free (einit_initial_environment);
return ret;
} else if ((coremode == einit_mode_init) && !isinit && !initoverride) {
eputs ("WARNING: eINIT is configured to run as init, but is not the init-process (pid=1) and the --override-init-check flag was not specified.\nexiting...\n\n", stderr);
exit (EXIT_FAILURE);
} else {
/* actual init code */
uint32_t e = 0;
nice (einit_core_niceness_increment);
if (need_recovery) {
notice (1, "need to recover from something...");
struct einit_event eml = evstaticinit(einit_core_recover);
event_emit (&eml, einit_event_flag_broadcast);
evstaticdestroy(eml);
}
if (einit_crash_data) {
notice (1, "submitting crash data...");
struct einit_event eml = evstaticinit(einit_core_crash_data);
eml.string = einit_crash_data;
event_emit (&eml, einit_event_flag_broadcast);
evstaticdestroy(eml);
free (einit_crash_data);
einit_crash_data = NULL;
}
{
notice (3, "running early bootup code...");
struct einit_event eml = evstaticinit(einit_boot_early);
event_emit (&eml, einit_event_flag_broadcast | einit_event_flag_spawn_thread_multi_wait);
evstaticdestroy(eml);
}
notice (2, "scheduling startup switches.\n");
for (e = 0; einit_startup_mode_switches[e]; e++) {
struct einit_event ee = evstaticinit(einit_core_switch_mode);
ee.string = einit_startup_mode_switches[e];
event_emit (&ee, einit_event_flag_broadcast | einit_event_flag_spawn_thread | einit_event_flag_duplicate);
evstaticdestroy(ee);
}
struct einit_event eml = evstaticinit(einit_core_main_loop_reached);
eml.file = commandpipe_in;
event_emit (&eml, einit_event_flag_broadcast);
evstaticdestroy(eml);
}
if (einit_initial_environment) free (einit_initial_environment);
return ret;
}
/* this should never be reached... */
if (einit_initial_environment) free (einit_initial_environment);
return 0;
}
json_object_free(top);
}
list_delete(&errlist);
}
DEFUN_NOSH(show_error_code,
show_error_code_cmd,
"show error <(1-4294967296)|all> [json]",
SHOW_STR
"Information on errors\n"
"Error code to get info about\n"
"Information on all errors\n"
JSON_STR)
{
bool json = strmatch(argv[argc-1]->text, "json");
uint32_t arg = 0;
if (!strmatch(argv[2]->text, "all"))
arg = strtoul(argv[2]->arg, NULL, 10);
log_ref_display(vty, arg, json);
return CMD_SUCCESS;
}
void log_ref_init(void)
{
pthread_mutex_lock(&refs_mtx);
{
refs = hash_create(ferr_hash_key, ferr_hash_cmp,
"Error Reference Texts");
static enum encoding name_to_enc(const char *encname) {
struct { const char *name; enum encoding enc; } map[] = {
{ "UCS-2-INTERNAL", e_unicode },
{ "UCS2", e_unicode },
{ "UCS-2", e_unicode },
{ "UCS-2LE", e_unicode },
{ "UCS-2BE", e_unicode },
{ "UNICODELITTLE", e_unicode },
{ "UNICODEBIG", e_unicode },
{ "ISO-10646/UCS2", e_unicode },
{ "ISO-10646/USC2", e_unicode }, /* Old typo */
{ "UCS4", e_ucs4 },
{ "UCS-4", e_ucs4 },
{ "UCS-4LE", e_ucs4 },
{ "UCS-4BE", e_ucs4 },
{ "UCS-4-INTERNAL", e_ucs4 },
{ "ISO-10646/UCS4", e_ucs4 },
{ "iso8859-1", e_iso8859_1 },
{ "iso8859-2", e_iso8859_2 },
{ "iso8859-3", e_iso8859_3 },
{ "iso8859-4", e_iso8859_4 },
{ "iso8859-5", e_iso8859_5 },
{ "iso8859-6", e_iso8859_6 },
{ "iso8859-7", e_iso8859_7 },
{ "iso8859-8", e_iso8859_8 },
{ "iso8859-9", e_iso8859_9 },
{ "iso8859-10", e_iso8859_10 },
{ "iso8859-11", e_iso8859_11 },
{ "iso8859-13", e_iso8859_13 },
{ "iso8859-14", e_iso8859_14 },
{ "iso8859-15", e_iso8859_15 },
{ "iso-8859-1", e_iso8859_1 },
{ "iso-8859-2", e_iso8859_2 },
{ "iso-8859-3", e_iso8859_3 },
{ "iso-8859-4", e_iso8859_4 },
{ "iso-8859-5", e_iso8859_5 },
{ "iso-8859-6", e_iso8859_6 },
{ "iso-8859-7", e_iso8859_7 },
{ "iso-8859-8", e_iso8859_8 },
{ "iso-8859-9", e_iso8859_9 },
{ "iso-8859-10", e_iso8859_10 },
{ "iso-8859-11", e_iso8859_11 },
{ "iso-8859-13", e_iso8859_13 },
{ "iso-8859-14", e_iso8859_14 },
{ "iso-8859-15", e_iso8859_15 },
{ "koi8-r", e_koi8_r },
{ "jis201", e_jis201 },
{ "mac", e_mac },
{ "Macintosh", e_mac },
{ "MS-ANSI", e_win },
{ "EUC-KR", e_wansung },
{ "johab", e_johab },
{ "ISO-2022-KR", e_jiskorean },
{ "ISO-2022-CN", e_jisgb },
{ "EUC-CN", e_jisgbpk },
{ "big5", e_big5 },
{ "big5hkscs", e_big5hkscs },
{ "ISO-2022-JP", e_jis },
{ "ISO-2022-JP-2", e_jis2 },
{ "Sjis", e_sjis },
{ "UTF-8", e_utf8 },
{ "UTF8", e_utf8 },
{ NULL }};
int i;
for ( i=0; map[i].name!=NULL; ++i )
if ( strmatch(map[i].name,encname)==0 )
return( map[i].enc );
return( -1 );
}
int search_next_matches(Search_Context *context, Search_Match *matches, int max_matches)
{
unsigned chain_data_size = SEARCH_DATA_COUNT;
int match_count = 0;
// Restore the state from context to the stack, this should help compilers
// optimize the variables better.
const char *data = context->data;
int length = context->length;
Search_Chain *chains = context->chains;
uint16_t *chain_data = context->chain_data;
unsigned chain_data_head = context->chain_data_head;
Search_Chain *last_end_chain = context->last_end_chain;
int last_match_pos = context->last_match_pos;
int last_match_length = context->last_match_length;
bool last_match_was_best = context->last_match_was_best;
// TODO: Free list optimization (less GC)
int pos = context->position;
for (; pos < length; pos++) {
if (match_count >= max_matches)
break;
if (pos + SEARCH_TUPLE_SIZE > length) {
// This algorithm can't find matches that are less than the tuple
// size in length. But in practice that's not a problem because there
// is no need for that short matches anyway.
continue;
}
const char *pos_str = &data[pos];
// Find the chain the beginning tuple of this match belongs to.
unsigned hash = tuplehash(pos_str) % SEARCH_CHAIN_COUNT;
Search_Chain *chain = &chains[hash];
int begin_pos = chain->base;
int pos_diff = pos - begin_pos;
// Set as the new base of the chain.
chain->base = pos;
if (pos_diff >= SEARCH_MAX_DIST) {
// Never seen or too far to reference: Orphan the chain.
chain->capacity = 0;
chain->data_index = 0;
continue;
}
// If there is not enough space in the chain, its storage needs to be reallocated
if (chain->capacity == 0) {
uint16_t *begin = &chain_data[chain->data_index];
uint16_t *iter = begin;
int chain_diff = pos_diff;
do {
chain_diff += *iter++;
} while (chain_diff < SEARCH_MAX_DIST);
unsigned length = (int)(iter - begin);
// Grow the allocation geometrically to reduce the amount of reallocations needed.
unsigned alloc_amount = length * 2;
// If there is no space try to do a garbage collection, if that doesn't help give up.
if (chain_data_head + alloc_amount > chain_data_size) {
chain_data_head = chain_data_gc(chains, SEARCH_CHAIN_COUNT,
chain_data, chain_data_size, pos);
if (chain_data_head + alloc_amount > chain_data_size) {
return false;
}
}
unsigned capacity = alloc_amount - length;
int data_begin = chain_data_head + capacity;
// Copy the old data.
memcpy(chain_data + data_begin, begin, length * sizeof(uint16_t));
chain->data_index = data_begin;
chain->capacity = capacity;
chain_data_head += alloc_amount;
}
// Add the distance to the previous occurrence to the chain.
chain->capacity--;
chain_data[--chain->data_index] = (uint16_t)pos_diff;
uint16_t *begin_iter = chain_data + chain->data_index + 1;
// Info about the current match candidate.
int match_pos = 0;
int match_length = 0;
bool best_match = false;
// The chain and iterator for the tuple that is required for a match
// that is longer than the previous matches.
Search_Chain *end_chain = 0;
int end_pos;
uint16_t *end_iter;
int target_match_length = SEARCH_TUPLE_SIZE;
// Can't match the buffer but don't limit the match lengths since it
// breaks the buffering of the matches. Let the calling code splice
// the too long matches into smaller ones (easy)
int input_left = length - pos;
int max_match_length = input_left;
// If this match is a sub-match of the previous one we have already
// found a match which is one byte shorter than the last one.
int submatch_length = last_match_length - 1;
if (submatch_length > SEARCH_TUPLE_SIZE) {
// Set as new minimum goal
match_pos = last_match_pos + 1;
match_length = submatch_length;
if (last_match_was_best) {
// If the last match was the best possible match just accept it.
last_match_was_best = true;
last_match_pos = match_pos;
last_match_length = match_length;
continue;
}
// Re-use the previous end tuple, since it must be included in any
// longer matches than the current submatch of the previous one.
end_chain = last_end_chain;
end_pos = end_chain->base;
end_iter = chain_data + end_chain->data_index;
target_match_length = last_match_length;
}
do {
// If we have an end chain make sure that we only check places where
// the begin and end iterators are separated by the target distance
int target_dist = target_match_length - SEARCH_TUPLE_SIZE;
if (end_chain && !sync_iterators(&begin_pos, &begin_iter, &end_pos, &end_iter, target_dist, pos)) {
break;
}
// Compare the reference byte-by-byte as far as they match.
int length = strmatch(pos_str, &data[begin_pos], max_match_length);
int mpos = begin_pos;
if (length >= target_match_length) {
// Found a new longest match!
match_length = length;
match_pos = mpos;
if (match_length == max_match_length) {
// Accept as the best match.
best_match = true;
break;
}
// We MUST have additional characters left that could match, create the tuple
// of the source string that contains one character past of the current best
// match.
const int end_offset = match_length - SEARCH_TUPLE_SIZE + 1;
unsigned end_hash = tuplehash(pos_str + end_offset) % SEARCH_CHAIN_COUNT;
Search_Chain *chain = &chains[end_hash];
if (pos - chain->base >= SEARCH_MAX_DIST) {
// There is no instance of a tuple that is required to continue the match
// therefore this is the best match.
best_match = true;
break;
}
end_chain = chain;
end_pos = end_chain->base;
end_iter = chain_data + end_chain->data_index;
target_match_length = match_length + 1;
}
// Advance.
begin_pos -= *begin_iter++;
} while (pos - begin_pos < SEARCH_MAX_DIST);
// If there was a match and it's not _completely_ included in the last one
// write it to the buffer.
if (match_length >= SEARCH_TUPLE_SIZE && match_length >= last_match_length) {
Search_Match *match = &matches[match_count++];
match->position = pos;
match->offset = pos - match_pos;
match->length = match_length;
}
last_end_chain = end_chain;
last_match_length = match_length;
last_match_was_best = best_match;
}
// Store the cached data back to the context.
context->chain_data_head = chain_data_head;
context->last_end_chain = last_end_chain;
context->last_match_pos = last_match_pos;
context->last_match_length = last_match_length;
context->last_match_was_best = last_match_was_best;
context->position = pos;
return match_count;
}
/**
* Read word/class entry names and 1-gram data from LR 2-gram file.
*
* @param fp [in] file pointer
* @param ndata [out] N-gram to set the read data.
*/
static boolean
set_unigram(FILE *fp, NGRAM_INFO *ndata)
{
WORD_ID nid;
int resid;
LOGPROB prob, bo_wt;
char *name, *p;
boolean ok_p = TRUE;
NGRAM_TUPLE_INFO *t;
t = &(ndata->d[0]);
/* malloc name area */
ndata->wname = (char **)mymalloc(sizeof(char *) * ndata->max_word_num);
/* malloc data area */
//t->bgn_upper = t->bgn_lower = t->bgn = t->num = NULL;
t->bgn_upper = NULL;
t->bgn_lower = NULL;
t->bgn = NULL;
t->num = NULL;
t->bgnlistlen = 0;
t->nnid2wid = NULL;
t->prob = (LOGPROB *)mymalloc_big(sizeof(LOGPROB), t->totalnum);
t->bo_wt = (LOGPROB *)mymalloc_big(sizeof(LOGPROB), t->totalnum);
t->context_num = t->totalnum;
t->nnid2ctid_upper = NULL;
t->nnid2ctid_lower = NULL;
nid = 0;
while (getl(buf, sizeof(buf), fp) != NULL && buf[0] != '\\') {
if ((p = strtok(buf, DELM)) == NULL) {
jlog("Error: ngram_read_arpa: 1-gram: failed to parse, corrupted or invalid data?\n");
return FALSE;
}
prob = (LOGPROB)atof(p);
if ((p = strtok(NULL, DELM)) == NULL) {
jlog("Error: ngram_read_arpa: 1-gram: failed to parse, corrupted or invalid data?\n");
return FALSE;
}
name = strcpy((char *)mymalloc(strlen(p)+1), p);
if ((p = strtok(NULL, DELM)) == NULL) {
bo_wt = 0.0;
} else {
bo_wt = (LOGPROB)atof(p);
}
/* register word entry name */
ndata->wname[nid] = name;
/* add entry name to index tree */
if (ndata->root == NULL) {
ndata->root = ptree_make_root_node(nid, &(ndata->mroot));
} else {
resid = ptree_search_data(name, ndata->root);
if (resid != -1 && strmatch(name, ndata->wname[resid])) { /* already exist */
jlog("Error: ngram_read_arpa: duplicate word entry \"%s\" at #%d and #%d in 1-gram\n", name, resid, nid);
ok_p = FALSE;
continue;
} else {
ptree_add_entry(name, nid, ndata->wname[resid], &(ndata->root), &(ndata->mroot));
}
}
if (nid >= ndata->max_word_num) {
jlog("Error: ngram_read_arpa: num of 1-gram is bigger than header value (%d)\n", ndata->max_word_num);
return FALSE;
}
/* register entry info */
t->prob[nid] = prob;
t->bo_wt[nid] = bo_wt;
nid++;
}
if (nid != t->totalnum) {
jlog("Error: ngram_read_arpa: num of 1-gram (%d) not equal to header value (%d)\n", nid, t->totalnum);
return FALSE;
}
if (ok_p == TRUE) {
jlog("Stat: ngram_read_arpa: read %d 1-gram entries\n", nid);
}
return ok_p;
}
/**
* Sub function to Add a dictionary entry line to the word dictionary.
*
* @param buf [i/o] buffer to hold the input string, will be modified in this function
* @param vnum_p [in] current number of words in @a winfo
* @param linenum [in] current line number of the input
* @param winfo [out] pointer to word dictionary to append the data.
* @param hmminfo [in] HTK %HMM definition data. if NULL, phonemes are ignored.
* @param do_conv [in] TRUE if performing triphone conversion
* @param ok_flag [out] will be set to FALSE if an error occured for this input.
*
* @return FALSE if buf == "DICEND", else TRUE will be returned.
*/
boolean
voca_load_htkdict_line(char *buf, WORD_ID *vnum_p, int linenum, WORD_INFO *winfo, HTK_HMM_INFO *hmminfo, boolean do_conv, boolean *ok_flag)
{
char *ptmp, *lp = NULL, *p;
static char cbuf[MAX_HMMNAME_LEN];
HMM_Logical **tmpwseq;
int len;
HMM_Logical *tmplg;
boolean pok;
int vnum;
vnum = *vnum_p;
if (strmatch(buf, "DICEND")) return FALSE;
/* allocate temporal work area for the first call */
if (winfo->work == NULL) {
winfo->work_num = PHONEMELEN_STEP;
winfo->work = (void *)mybmalloc2(sizeof(HMM_Logical *) * winfo->work_num, &(winfo->mroot));
}
tmpwseq = (HMM_Logical **)winfo->work;
/* backup whole line for debug output */
strcpy(bufbak, buf);
/* GrammarEntry */
if ((ptmp = mystrtok_quote(buf, " \t\n")) == NULL) {
jlog("Error: voca_load_htkdict: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
winfo->wname[vnum] = strcpy((char *)mybmalloc2(strlen(ptmp)+1, &(winfo->mroot)), ptmp);
/* just move pointer to next token */
if ((ptmp = mystrtok_movetonext(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_htkdict: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
#ifdef CLASS_NGRAM
winfo->cprob[vnum] = 0.0; /* prob = 1.0, logprob = 0.0 */
#endif
if (ptmp[0] == '@') { /* class N-gram prob */
#ifdef CLASS_NGRAM
/* word probability within the class (for class N-gram) */
/* format: classname @classprob wordname [output] phoneseq */
/* classname equals to wname, and wordname will be omitted */
/* format: @%f (log scale) */
/* if "@" not found or "@0", it means class == word */
if ((ptmp = mystrtok(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_htkdict: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
if (ptmp[1] == '\0') { /* space between '@' and figures */
jlog("Error: voca_load_htkdict: line %d: value after '@' missing, maybe wrong space?\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
winfo->cprob[vnum] = atof(&(ptmp[1]));
if (winfo->cprob[vnum] != 0.0) winfo->cwnum++;
/* read next word entry (just skip them) */
if ((ptmp = mystrtok(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_htkdict: line %d: corrupted data:\n> %s\n", linenum,bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
/* move to the next word entry */
if ((ptmp = mystrtok_movetonext(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_htkdict: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
#else /* ~CLASS_NGRAM */
jlog("Error: voca_load_htkdict: line %d: cannot handle in-class word probability\n> %s\n", linenum, ptmp, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
#endif /* CLASS_NGRAM */
}
/* OutputString */
switch(ptmp[0]) {
case '[': /* not transparent word */
winfo->is_transparent[vnum] = FALSE;
ptmp = mystrtok_quotation(NULL, " \t\n", '[', ']', 0);
break;
case '{': /* transparent word */
winfo->is_transparent[vnum] = TRUE;
ptmp = mystrtok_quotation(NULL, " \t\n", '{', '}', 0);
break;
default:
#if 1
/* ALLOW no entry for output */
/* same as wname is used */
winfo->is_transparent[vnum] = FALSE;
ptmp = winfo->wname[vnum];
#else
/* error */
jlog("Error: voca_load_htkdict: line %d: missing output string??\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
#endif
}
if (ptmp == NULL) {
jlog("Error: voca_load_htkdict: line %d: corrupted data:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
winfo->woutput[vnum] = strcpy((char *)mybmalloc2(strlen(ptmp)+1, &(winfo->mroot)), ptmp);
/* phoneme sequence */
if (hmminfo == NULL) {
/* don't read */
winfo->wseq[vnum] = NULL;
winfo->wlen[vnum] = 0;
} else {
/* store converted phone sequence to temporal bufffer */
len = 0;
if (do_conv) {
/* convert phoneme to triphone expression (word-internal) */
cycle_triphone(NULL);
if ((lp = mystrtok(NULL, " \t\n")) == NULL) {
jlog("Error: voca_load_htkdict: line %d: word %s has no phoneme:\n> %s\n", linenum, winfo->wname[vnum], bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
if (strlen(lp) >= MAX_HMMNAME_LEN) {
jlog("Error: voca_load_htkdict: line %d: too long phone name: %s\n", linenum, lp);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
cycle_triphone(lp);
}
pok = TRUE;
for (;;) {
if (do_conv) {
/* if (lp != NULL) jlog(" %d%s",len,lp);*/
if (lp != NULL) lp = mystrtok(NULL, " \t\n");
if (lp != NULL) {
if (strlen(lp) >= MAX_HMMNAME_LEN) {
jlog("Error: voca_load_htkdict: line %d: too long phone name: %s\n", linenum, lp);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
p = cycle_triphone(lp);
}
else p = cycle_triphone_flush();
} else {
p = mystrtok(NULL, " \t\n");
}
if (p == NULL) break;
/* both defined/pseudo phone is allowed */
tmplg = htk_hmmdata_lookup_logical(hmminfo, p);
if (tmplg == NULL) {
/* not found */
if (do_conv) {
/* both defined or pseudo phone are not found */
if (len == 0 && lp == NULL) {
jlog("Error: voca_load_htkdict: line %d: triphone \"*-%s+*\" or monophone \"%s\" not found\n", linenum, p, p);
snprintf(cbuf,MAX_HMMNAME_LEN,"*-%s+* or monophone %s", p, p);
} else if (len == 0) {
jlog("Error: voca_load_htkdict: line %d: triphone \"*-%s\" or biphone \"%s\" not found\n", linenum, p, p);
snprintf(cbuf,MAX_HMMNAME_LEN,"*-%s or biphone %s", p, p);
} else if (lp == NULL) {
jlog("Error: voca_load_htkdict: line %d: triphone \"%s+*\" or biphone \"%s\" not found\n", linenum, p, p);
snprintf(cbuf,MAX_HMMNAME_LEN,"%s+* or biphone %s", p, p);
} else {
jlog("Error: voca_load_htkdict: line %d: triphone \"%s\" not found\n", linenum, p);
snprintf(cbuf,MAX_HMMNAME_LEN,"%s", p);
}
} else {
jlog("Error: voca_load_htkdict: line %d: phone \"%s\" not found\n", linenum, p);
snprintf(cbuf, MAX_HMMNAME_LEN, "%s", p);
}
add_to_error(winfo, cbuf);
pok = FALSE;
} else {
/* found */
if (len >= winfo->work_num) {
/* expand wseq area by PHONEMELEN_STEP */
winfo->work_num += PHONEMELEN_STEP;
winfo->work = (void *)mybmalloc2(sizeof(HMM_Logical *) * winfo->work_num, &(winfo->mroot));
memcpy(winfo->work, tmpwseq, sizeof(HMM_Logical *) * (winfo->work_num - PHONEMELEN_STEP));
tmpwseq = (HMM_Logical **)winfo->work;
}
/* store to temporal buffer */
tmpwseq[len] = tmplg;
}
len++;
}
if (!pok) { /* error in phoneme */
jlog("Error: voca_load_htkdict: the line content was: %s\n", bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
if (len == 0) {
jlog("Error: voca_load_htkdict: line %d: no phone specified:\n> %s\n", linenum, bufbak);
winfo->errnum++;
*ok_flag = FALSE;
return TRUE;
}
/* store to winfo */
winfo->wseq[vnum] = (HMM_Logical **)mybmalloc2(sizeof(HMM_Logical *) * len, &(winfo->mroot));
memcpy(winfo->wseq[vnum], tmpwseq, sizeof(HMM_Logical *) * len);
winfo->wlen[vnum] = len;
}
vnum++;
*vnum_p = vnum;
return(TRUE);
}
