int main(int argc,char *argv[])
{
int i,opsize=sizeof(opcode_table)/sizeof(opcode_desc),
pushsize=sizeof(push_table)/sizeof(opcode_desc),
compsize=sizeof(compiler_table)/sizeof(char*);
const char **func_table = bg_intrinsic_table;
int funsize = bg_intrinsic_size;
int findex = 1; // Index in argv of 1st filename.
indata=codesize=datasize=0;
printf("Wody's Usecode Compiler v0.009\nCopyright (c) 1999 Wody "
"Dragon (a.k.a. Wouter Dijkslag)\n");
if (argc<3)
{
printf("syntax: %s [-s] infile outfile\n", argv[0]);
exit(0);
}
// Serpent Isle?
if (strcmp(argv[1], "-s") == 0)
{
findex++;
func_table = si_intrinsic_table;
funsize = si_intrinsic_size;
}
lindex=0;
for (pass=0;pass<2;pass++)
{
printf("Pass %d\n",pass+1);
if ((fi=fopen(argv[findex],"r"))==NULL)
{
printf("Can't open infile for reading\n");
exit(0);
}
if ((fo=fopen(argv[findex + 1],"wb"))==NULL)
{
printf("Can't open outfile for writing\n");
exit(0);
}
while (!feof(fi))
{
read_token(fi);
if (pass==0 && token[strlen(token)-1]==':') add_label();
else
if (!strcmp(token,".code"))
{
indata=0;
offset=0;
}
else
if (!strcmp(token,".data"))
{
indata=1;
offset=0;
}
else
if (!strcmp(token,".funcnumber"))
{
read_token(fi);
sscanf(token,"%x",&word);
emit_word(word);
emit_word(0);
emit_word(0);
codesize=2;
}
else
if (token[0]=='.')
{
indata=0;
for (i=0;i<compsize;i++)
if (!strcasecmp(compiler_table[i],token))
{
read_token(fi);
sscanf(token,"%x",&word);
emit_word(word);
}
}
else
if (!strcmp(token,"db"))
{
read_token(fi);
if (token[0]==39)
for (i=1;i<strlen(token);i++)
emit_byte(token[i]);
else
{
sscanf(token,"%x",&byte);
emit_byte(byte);
}
}
else
if (!strcasecmp(token,"dw"))
{
read_token(fi);
sscanf(token,"%x",&word);
emit_word(word);
}
else
for (i=0;i<opsize;i++)
{
if (!strcasecmp(opcode_table[i].mnemonic,token))
{
if (opcode_table[i].nbytes==0 && opcode_table[i].type==0)
emit_byte(i);
else
switch (opcode_table[i].type)
{
case BYTE:
emit_byte(i);
read_token(fi);
sscanf(token,"%x",&word);
emit_byte(word);
break;
case CALL:
emit_byte(i);
read_token(fi);
if ((token2=strchr(token,'@'))!=NULL)
{
token2++;
token[strchr(token,'@')-token]=0;
strcpy(token,token+1);
for (i=0;i<funsize;i++)
if (!strcasecmp(token,func_table[i]))
{
emit_word(i);
break;
}
if (i==funsize)
{
printf("Do not know function '%s'\n",token);
exit(0);
}
sscanf(token2,"%d",&word);
}
else
{
sscanf(token,"%x",&word);
emit_word(word);
read_token(fi);
sscanf(token,"%d",&word);
}
emit_byte(word);
break;
case DATA_STRING:
emit_byte(i);
read_token(fi);
emit_word(get_label());
break;
case EXTCALL:
case VARREF:
emit_byte(i);
read_token(fi);
sscanf(token,"[%x]",&word);
emit_word(word);
break;
case FLGREF:
emit_byte(i);
read_token(fi);
sscanf(token,"flag:[%x]",&word);
emit_word(word);
break;
case PUSH:
read_token(fi);
for (i=0;i<pushsize;i++)
{
if (!strcasecmp(push_table[i].mnemonic,token))
{
emit_byte(push_table[i].type);
break;
}
}
if (i==pushsize)
{
emit_byte(0x21);
sscanf(token,"[%x]",&word);
emit_word(word);
}
break;
case IMMED:
emit_byte(i);
read_token(fi);
sscanf(token,"%x",&word);
emit_word(word);
break;
case RELATIVE_JUMP:
emit_byte(i);
read_token(fi);
if (pass==1)
emit_word(get_label()-offset-2);
else
emit_word(-1);
break;
case IMMED_AND_RELATIVE_JUMP:
emit_byte(i);
read_token(fi);
sscanf(token,"%x",&word);
emit_word(word);
read_token(fi);
if (pass==1)
emit_word(get_label()-offset-2);
else
emit_word(-1);
break;
default:
break;
}
}
}
}
fseek(fo,2,SEEK_SET);
indata=0;
i=codesize;
emit_word(i);
emit_word(datasize);
fclose(fo);
fclose(fi);
}
return 0;
}
/**
* Read in global options.
*
* @param fp [in] file pointer
* @param op [out] pointer to store the global options
*/
static void
read_global_opt(FILE *fp, HTK_HMM_Options *op)
{
int i;
short tmptype;
int num;
for (;;) {
if (rdhmmdef_token == NULL) break;
if (currentis("HMMSETID")) { /* <HMMSETID> */
read_token(fp);
NoTokErr("missing HMMSETID argument");
} else if (currentis("STREAMINFO")) { /* <STREAMINFO> */
read_token(fp);
NoTokErr("missing STREAMINFO num");
op->stream_info.num = atoi(rdhmmdef_token);
/*DM("%d STREAMs:", op->stream_info.num);*/
if (op->stream_info.num > MAXSTREAMNUM) {
jlog("Error: rdhmmdef_options: stream num exceeded %d\n", MAXSTREAMNUM);
rderr(NULL);
}
for (i=0;i<op->stream_info.num;i++) {
read_token(fp);
NoTokErr("missing STREAMINFO vector size");
op->stream_info.vsize[i] = atoi(rdhmmdef_token);
/*DM(" %d",op->stream_info.vsize[i]);*/
}
/*DM("\n");*/
} else if (currentis("VECSIZE")) { /* <VECSIZE> */
read_token(fp);
NoTokErr("missing VECSIZE value");
op->vec_size = atoi(rdhmmdef_token);
/*DM("vector size: %d\n", op->vec_size);*/
} else if (currentis("MSDINFO")) { /* <MSDINFO> by HTS */
/* Julius can auto-detect MSD-HMM, so just skip this */
read_token(fp);
NoTokErr("missing MSDINFO num");
num = atoi(rdhmmdef_token);
for (i=0;i<num;i++) {
read_token(fp);
}
} else {
/* covariance matrix type */
for (i=0;optcov[i].name!=NULL;i++) {
if (currentis(optcov[i].name)) {
op->cov_type = optcov[i].type;
/*DM("covariance matrix type: %s\n", optcov[i].desc);*/
goto optloop;
}
}
/* duration type */
for (i=0;optdur[i].name!=NULL;i++) {
if (currentis(optdur[i].name)) {
op->dur_type = optdur[i].type;
/*DM("duration type: %s\n", optdur[i].desc);*/
goto optloop;
}
}
/* parameter type */
tmptype = param_str2code(rdhmmdef_token);
if (tmptype != F_ERR_INVALID) { /* conv success */
op->param_type = tmptype;
/*DM("param type: %s", param_code2str(buf, op->param_type, FALSE));*/
goto optloop;
} else {
/* nothing of above --- not option */
if(rdhmmdef_token[0] != '~') {
jlog("Error: rdhmmdef_options: unknown option in header: %s\n", rdhmmdef_token);
rderr("unknown option in header");
}
return;
}
}
optloop:
read_token(fp);
}
}
static Reference create(SourceStream *in)
{
Reference tok(new SourceTokenC);
read_token(in, tok);
return tok;
}
/* Read in a block. When called, the current token must be an LBrace.
On return, the current token is whatever was after the RBrace.
*/
static node *read_block(mincss_context *context)
{
tokentype toktyp = context->nexttok.typ;
if (toktyp == tok_EOF || toktyp != tok_LBrace) {
mincss_note_error(context, "(Internal) Unexpected token at read_block");
return NULL;
}
read_token(context);
read_token_skipspace(context);
node *nod = new_node(context, nod_Block);
while (1) {
toktyp = context->nexttok.typ;
if (toktyp == tok_EOF) {
mincss_note_error(context, "Unexpected end of block");
return nod;
}
switch (toktyp) {
case tok_RBrace:
/* Done */
read_token(context);
read_token_skipspace(context);
return nod;
case tok_LBrace: {
/* Sub-block */
node *blocknod = read_block(context);
if (!blocknod) {
/* error, already reported */
continue;
}
node_add_node(nod, blocknod);
continue;
}
case tok_Semicolon: {
node *subnod = new_node_token(context, &context->nexttok);
node_add_node(nod, subnod);
read_token(context);
continue;
}
case tok_AtKeyword: {
node *atnod = new_node_token(context, &context->nexttok);
node_add_node(nod, atnod);
read_token(context);
continue;
}
case tok_Function: {
node *subnod = new_node(context, nod_Function);
node_copy_text(subnod, &context->nexttok);
node_add_node(nod, subnod);
read_token(context);
read_any_until_close(context, subnod, tok_RParen);
continue;
}
case tok_LParen: {
node *subnod = new_node(context, nod_Parens);
node_add_node(nod, subnod);
read_token(context);
read_any_until_close(context, subnod, tok_RParen);
continue;
}
case tok_LBracket: {
node *subnod = new_node(context, nod_Brackets);
node_add_node(nod, subnod);
read_token(context);
read_any_until_close(context, subnod, tok_RBracket);
continue;
}
case tok_CDO:
case tok_CDC:
mincss_note_error(context, "HTML comment delimiters not allowed inside block");
read_token(context);
read_token_skipspace(context);
continue;
case tok_RParen:
mincss_note_error(context, "Unexpected close-paren inside block");
read_token(context);
continue;
case tok_RBracket:
mincss_note_error(context, "Unexpected close-bracket inside block");
read_token(context);
continue;
default: {
/* Anything else is a single "any". */
node *subnod = new_node_token(context, &context->nexttok);
node_add_node(nod, subnod);
read_token(context);
}
}
}
}
static int
createFrameFile(struct frameset *f, FILE * f1, Buffer *current, int level,
int force_reload)
{
int r, c, t_stack;
URLFile f2;
#ifdef USE_M17N
wc_ces charset, doc_charset;
#endif
char *d_target, *p_target, *s_target, *t_target;
ParsedURL *currentURL, base;
MySignalHandler(*volatile prevtrap) (SIGNAL_ARG) = NULL;
int flag;
if (f == NULL)
return -1;
if (level == 0) {
if (SETJMP(AbortLoading) != 0) {
TRAP_OFF;
return -1;
}
TRAP_ON;
f->name = "_top";
}
if (level > 7) {
fputs("Too many frameset tasked.\n", f1);
return -1;
}
if (level == 0) {
fprintf(f1, "<html><head><title>%s</title></head><body>\n",
html_quote(current->buffername));
fputs("<table hborder width=\"100%\">\n", f1);
}
else
fputs("<table hborder>\n", f1);
currentURL = f->currentURL ? f->currentURL : ¤t->currentURL;
for (r = 0; r < f->row; r++) {
fputs("<tr valign=top>\n", f1);
for (c = 0; c < f->col; c++) {
union frameset_element frame;
struct frameset *f_frameset;
int i = c + r * f->col;
char *p = "";
int status = R_ST_NORMAL;
Str tok = Strnew();
int pre_mode = 0;
int end_tag = 0;
frame = f->frame[i];
if (frame.element == NULL) {
fputs("<td>\n</td>\n", f1);
continue;
}
fputs("<td", f1);
if (frame.element->name)
fprintf(f1, " id=\"_%s\"", html_quote(frame.element->name));
if (!r)
fprintf(f1, " width=\"%s\"", f->width[c]);
fputs(">\n", f1);
flag = 0;
if (force_reload) {
flag |= RG_NOCACHE;
if (frame.element->attr == F_BODY)
unloadFrame(frame.body);
}
switch (frame.element->attr) {
default:
/* FIXME: gettextize? */
fprintf(f1, "Frameset \"%s\" frame %d: type unrecognized",
html_quote(f->name), i + 1);
break;
case F_UNLOADED:
if (!frame.body->name && f->name) {
frame.body->name = Sprintf("%s_%d", f->name, i)->ptr;
}
fflush(f1);
f_frameset = frame_download_source(frame.body,
currentURL,
current->baseURL, flag);
if (f_frameset) {
deleteFrame(frame.body);
f->frame[i].set = frame.set = f_frameset;
goto render_frameset;
}
/* fall through */
case F_BODY:
init_stream(&f2, SCM_LOCAL, NULL);
if (frame.body->source) {
fflush(f1);
examineFile(frame.body->source, &f2);
}
if (f2.stream == NULL) {
frame.body->attr = F_UNLOADED;
if (frame.body->flags & FB_NO_BUFFER)
/* FIXME: gettextize? */
fprintf(f1, "Open %s with other method",
html_quote(frame.body->url));
else if (frame.body->url)
/* FIXME: gettextize? */
fprintf(f1, "Can't open %s",
html_quote(frame.body->url));
else
/* FIXME: gettextize? */
fprintf(f1,
"This frame (%s) contains no src attribute",
frame.body->name ? html_quote(frame.body->name)
: "(no name)");
break;
}
parseURL2(frame.body->url, &base, currentURL);
p_target = f->name;
s_target = frame.body->name;
t_target = "_blank";
d_target = TargetSelf ? s_target : t_target;
#ifdef USE_M17N
charset = WC_CES_US_ASCII;
if (current->document_charset != WC_CES_US_ASCII)
doc_charset = current->document_charset;
else
doc_charset = DocumentCharset;
#endif
t_stack = 0;
if (frame.body->type &&
!strcasecmp(frame.body->type, "text/plain")) {
Str tmp;
fprintf(f1, "<pre>\n");
while ((tmp = StrmyUFgets(&f2))->length) {
tmp = convertLine(NULL, tmp, HTML_MODE, &charset,
doc_charset);
fprintf(f1, "%s", html_quote(tmp->ptr));
}
fprintf(f1, "</pre>\n");
UFclose(&f2);
break;
}
do {
int is_tag = FALSE;
char *q;
struct parsed_tag *tag;
do {
if (*p == '\0') {
Str tmp = StrmyUFgets(&f2);
if (tmp->length == 0)
break;
tmp = convertLine(NULL, tmp, HTML_MODE, &charset,
doc_charset);
p = tmp->ptr;
}
read_token(tok, &p, &status, 1, status != R_ST_NORMAL);
} while (status != R_ST_NORMAL);
if (tok->length == 0)
continue;
if (tok->ptr[0] == '<') {
if (tok->ptr[1] &&
REALLY_THE_BEGINNING_OF_A_TAG(tok->ptr))
is_tag = TRUE;
else if (!(pre_mode & (RB_PLAIN | RB_INTXTA |
RB_SCRIPT | RB_STYLE))) {
p = Strnew_m_charp(tok->ptr + 1, p, NULL)->ptr;
tok = Strnew_charp("<");
}
}
if (is_tag) {
if (pre_mode & (RB_PLAIN | RB_INTXTA | RB_SCRIPT |
RB_STYLE)) {
q = tok->ptr;
if ((tag = parse_tag(&q, FALSE)) &&
tag->tagid == end_tag) {
if (pre_mode & RB_PLAIN) {
fputs("</PRE_PLAIN>", f1);
pre_mode = 0;
end_tag = 0;
goto token_end;
}
pre_mode = 0;
end_tag = 0;
goto proc_normal;
}
if (strncmp(tok->ptr, "<!--", 4) &&
(q = strchr(tok->ptr + 1, '<'))) {
tok = Strnew_charp_n(tok->ptr, q - tok->ptr);
p = Strnew_m_charp(q, p, NULL)->ptr;
status = R_ST_NORMAL;
}
is_tag = FALSE;
}
else if (pre_mode & RB_INSELECT) {
q = tok->ptr;
if ((tag = parse_tag(&q, FALSE))) {
if ((tag->tagid == end_tag) ||
(tag->tagid == HTML_N_FORM)) {
if (tag->tagid == HTML_N_FORM)
fputs("</SELECT>", f1);
pre_mode = 0;
end_tag = 0;
goto proc_normal;
}
if (t_stack) {
switch (tag->tagid) {
case HTML_TABLE:
case HTML_N_TABLE:
CASE_TABLE_TAG:
fputs("</SELECT>", f1);
pre_mode = 0;
end_tag = 0;
goto proc_normal;
}
}
}
}
}
proc_normal:
if (is_tag) {
char *q = tok->ptr;
int j, a_target = 0;
ParsedURL url;
if (!(tag = parse_tag(&q, FALSE)))
goto token_end;
switch (tag->tagid) {
case HTML_TITLE:
fputs("<!-- title:", f1);
goto token_end;
case HTML_N_TITLE:
fputs("-->", f1);
goto token_end;
case HTML_BASE:
/* "BASE" is prohibit tag */
if (parsedtag_get_value(tag, ATTR_HREF, &q)) {
q = url_encode(remove_space(q), NULL, charset);
parseURL(q, &base, NULL);
}
if (parsedtag_get_value(tag, ATTR_TARGET, &q)) {
if (!strcasecmp(q, "_self"))
d_target = s_target;
else if (!strcasecmp(q, "_parent"))
d_target = p_target;
else
d_target = url_quote_conv(q, charset);
}
Strshrinkfirst(tok, 1);
Strshrink(tok, 1);
fprintf(f1, "<!-- %s -->", html_quote(tok->ptr));
goto token_end;
case HTML_META:
if (parsedtag_get_value(tag, ATTR_HTTP_EQUIV, &q)
&& !strcasecmp(q, "refresh")) {
if (parsedtag_get_value(tag, ATTR_CONTENT, &q)
) {
Str s_tmp = NULL;
int refresh_interval =
getMetaRefreshParam(q, &s_tmp);
if (s_tmp) {
q = html_quote(s_tmp->ptr);
fprintf(f1,
"Refresh (%d sec) <a href=\"%s\">%s</a>\n",
refresh_interval, q, q);
}
}
}
#ifdef USE_M17N
if (UseContentCharset &&
parsedtag_get_value(tag, ATTR_HTTP_EQUIV, &q)
&& !strcasecmp(q, "Content-Type")
&& parsedtag_get_value(tag, ATTR_CONTENT, &q)
&& (q = strcasestr(q, "charset")) != NULL) {
q += 7;
SKIP_BLANKS(q);
if (*q == '=') {
wc_ces c;
q++;
SKIP_BLANKS(q);
if ((c = wc_guess_charset(q, 0)) != 0) {
doc_charset = c;
charset = WC_CES_US_ASCII;
}
}
}
#endif
/* fall thru, "META" is prohibit tag */
case HTML_HEAD:
case HTML_N_HEAD:
case HTML_BODY:
case HTML_N_BODY:
case HTML_DOCTYPE:
/* prohibit_tags */
Strshrinkfirst(tok, 1);
Strshrink(tok, 1);
fprintf(f1, "<!-- %s -->", html_quote(tok->ptr));
goto token_end;
case HTML_TABLE:
t_stack++;
break;
case HTML_N_TABLE:
t_stack--;
if (t_stack < 0) {
t_stack = 0;
Strshrinkfirst(tok, 1);
Strshrink(tok, 1);
fprintf(f1,
"<!-- table stack underflow: %s -->",
html_quote(tok->ptr));
goto token_end;
}
break;
CASE_TABLE_TAG:
/* table_tags MUST be in table stack */
if (!t_stack) {
Strshrinkfirst(tok, 1);
Strshrink(tok, 1);
fprintf(f1, "<!-- %s -->",
html_quote(tok->ptr));
goto token_end;
}
break;
case HTML_SELECT:
pre_mode = RB_INSELECT;
end_tag = HTML_N_SELECT;
break;
case HTML_TEXTAREA:
pre_mode = RB_INTXTA;
end_tag = HTML_N_TEXTAREA;
break;
case HTML_SCRIPT:
pre_mode = RB_SCRIPT;
end_tag = HTML_N_SCRIPT;
break;
case HTML_STYLE:
pre_mode = RB_STYLE;
end_tag = HTML_N_STYLE;
break;
case HTML_LISTING:
pre_mode = RB_PLAIN;
end_tag = HTML_N_LISTING;
fputs("<PRE_PLAIN>", f1);
goto token_end;
case HTML_XMP:
pre_mode = RB_PLAIN;
end_tag = HTML_N_XMP;
fputs("<PRE_PLAIN>", f1);
goto token_end;
case HTML_PLAINTEXT:
pre_mode = RB_PLAIN;
end_tag = MAX_HTMLTAG;
fputs("<PRE_PLAIN>", f1);
goto token_end;
default:
break;
}
for (j = 0; j < TagMAP[tag->tagid].max_attribute; j++) {
switch (tag->attrid[j]) {
case ATTR_SRC:
case ATTR_HREF:
case ATTR_ACTION:
if (!tag->value[j])
break;
tag->value[j] =
url_encode(remove_space(tag->value[j]),
&base, charset);
tag->need_reconstruct = TRUE;
parseURL2(tag->value[j], &url, &base);
if (url.scheme == SCM_UNKNOWN ||
#ifndef USE_W3MMAILER
url.scheme == SCM_MAILTO ||
#endif
url.scheme == SCM_MISSING)
break;
a_target |= 1;
tag->value[j] = parsedURL2Str(&url)->ptr;
parsedtag_set_value(tag,
ATTR_REFERER,
parsedURL2Str(&base)->ptr);
#ifdef USE_M17N
if (tag->attrid[j] == ATTR_ACTION &&
charset != WC_CES_US_ASCII)
parsedtag_set_value(tag,
ATTR_CHARSET,
wc_ces_to_charset
(charset));
#endif
break;
case ATTR_TARGET:
if (!tag->value[j])
break;
a_target |= 2;
if (!strcasecmp(tag->value[j], "_self")) {
parsedtag_set_value(tag,
ATTR_TARGET, s_target);
}
else if (!strcasecmp(tag->value[j], "_parent")) {
parsedtag_set_value(tag,
ATTR_TARGET, p_target);
}
break;
case ATTR_NAME:
case ATTR_ID:
if (!tag->value[j])
break;
parsedtag_set_value(tag,
ATTR_FRAMENAME, s_target);
break;
}
}
if (a_target == 1) {
/* there is HREF attribute and no TARGET
* attribute */
parsedtag_set_value(tag, ATTR_TARGET, d_target);
}
if (parsedtag_need_reconstruct(tag))
tok = parsedtag2str(tag);
Strfputs(tok, f1);
}
else {
if (pre_mode & RB_PLAIN)
fprintf(f1, "%s", html_quote(tok->ptr));
else if (pre_mode & RB_INTXTA)
fprintf(f1, "%s",
html_quote(html_unquote(tok->ptr)));
else
Strfputs(tok, f1);
}
token_end:
Strclear(tok);
} while (*p != '\0' || !iseos(f2.stream));
if (pre_mode & RB_PLAIN)
fputs("</PRE_PLAIN>\n", f1);
else if (pre_mode & RB_INTXTA)
fputs("</TEXTAREA></FORM>\n", f1);
else if (pre_mode & RB_INSELECT)
fputs("</SELECT></FORM>\n", f1);
else if (pre_mode & (RB_SCRIPT | RB_STYLE)) {
if (status != R_ST_NORMAL)
fputs(correct_irrtag(status)->ptr, f1);
if (pre_mode & RB_SCRIPT)
fputs("</SCRIPT>\n", f1);
else if (pre_mode & RB_STYLE)
fputs("</STYLE>\n", f1);
}
while (t_stack--)
fputs("</TABLE>\n", f1);
UFclose(&f2);
break;
case F_FRAMESET:
render_frameset:
if (!frame.set->name && f->name) {
frame.set->name = Sprintf("%s_%d", f->name, i)->ptr;
}
createFrameFile(frame.set, f1, current, level + 1,
force_reload);
break;
}
fputs("</td>\n", f1);
}
fputs("</tr>\n", f1);
}
fputs("</table>\n", f1);
if (level == 0) {
fputs("</body></html>\n", f1);
TRAP_OFF;
}
return 0;
}
/* If the current token is whitespace, read more tokens until it's not. */
static void read_token_skipspace(mincss_context *context)
{
while (context->nexttok.typ == tok_Space)
read_token(context);
}
/* Read an "any*" sequence, up until end-of-file or an AtKeyword
token. Appends nodes to the node passed in (which will be a
TopLevel).
On return, the current token is EOF, LBrace (meaning start of
a block), or AtKeyword.
*/
static void read_any_top_level(mincss_context *context, node *nod)
{
while (1) {
tokentype toktyp = context->nexttok.typ;
if (toktyp == tok_EOF) {
return; /* end of file */
}
switch (toktyp) {
case tok_LBrace:
return;
case tok_Function: {
node *subnod = new_node(context, nod_Function);
node_copy_text(subnod, &context->nexttok);
node_add_node(nod, subnod);
read_token(context);
read_any_until_close(context, subnod, tok_RParen);
continue;
}
case tok_LParen: {
node *subnod = new_node(context, nod_Parens);
node_add_node(nod, subnod);
read_token(context);
read_any_until_close(context, subnod, tok_RParen);
continue;
}
case tok_LBracket: {
node *subnod = new_node(context, nod_Brackets);
node_add_node(nod, subnod);
read_token(context);
read_any_until_close(context, subnod, tok_RBracket);
continue;
}
case tok_CDO:
case tok_CDC:
/* Swallow, ignore */
read_token(context);
read_token_skipspace(context);
continue;
case tok_RParen:
mincss_note_error(context, "Unexpected close-paren");
read_token(context);
continue;
case tok_RBracket:
mincss_note_error(context, "Unexpected close-bracket");
read_token(context);
continue;
case tok_AtKeyword:
return;
case tok_Semicolon: {
node *toknod = new_node_token(context, &context->nexttok);
node_add_node(nod, toknod);
read_token(context);
read_token_skipspace(context);
continue;
}
default: {
node *toknod = new_node_token(context, &context->nexttok);
node_add_node(nod, toknod);
read_token(context);
}
}
}
}
int read_sign(const char *sign)
{
return is_sign(read_token(), sign);
}
void getNextToken()
{
tokenLen = read_token(&ch,str);
}
void
main_loop(void)
{
int c;
int in_defun=0;
char *p;
lineno = 1;
reset();
put_lineno();
LOOP:
c = jump_to_at();
if (c == ')') {
if (!in_defun)
error("unmatched @) found");
in_defun = 0;
putc('}',out);
reset();
goto LOOP;
} else if (c == '\'') {
char *p;
poolp = pool;
p = read_symbol(0);
pushc('\0');
fprintf(out,"%s",p);
goto LOOP;
} else if (c == '[') {
char *p;
poolp = pool;
p = read_symbol(1);
pushc('\0');
fprintf(out,"%s",p);
goto LOOP;
} else if (c != '(') {
char *p;
unreadc(c);
poolp = pool;
poolp = p = read_function();
fprintf(out,"%s",translate_function(poolp));
goto LOOP;
}
p = read_token();
if (strcmp(p, "defun") == 0) {
if (in_defun)
error("@) expected before new function definition");
in_defun = 1;
get_function();
get_lambda_list();
put_fhead();
put_lineno();
c = jump_to_at();
put_declaration();
put_lineno();
} else if (strcmp(p, "return") == 0) {
tab_save = tab;
get_return();
put_return();
} else
error_symbol(p);
goto LOOP;
}
int read_reg(enum Regs *reg, const char *msg)
{
return get_reg(reg, read_token(), msg);
}
void
get_lambda_list(void)
{
int c;
char *p;
if ((c = nextc()) != '(')
error("( expected");
for (;;) {
if ((c = nextc()) == ')')
return;
if (c == '&') {
p = read_token();
goto _OPT;
}
unreadc(c);
p = read_token();
if (nreq >= MAXREQ)
error("too many required variables");
required[nreq++] = p;
}
_OPT:
if (strcmp(p, "optional") != 0 && strcmp(p, "o") != 0)
goto _REST;
for (;; nopt++) {
if ((c = nextc()) == ')')
return;
if (c == '&') {
p = read_token();
goto _REST;
}
if (nopt >= MAXOPT)
error("too many optional argument");
if (c == '(') {
optional[nopt].o_var = read_token();
if ((c = nextc()) == ')')
continue;
unreadc(c);
optional[nopt].o_init = read_token();
if ((c = nextc()) == ')')
continue;
unreadc(c);
optional[nopt].o_svar = read_token();
if (nextc() != ')')
error(") expected");
} else {
unreadc(c);
optional[nopt].o_var = read_token();
}
}
_REST:
if (strcmp(p, "rest") != 0 && strcmp(p, "r") != 0)
goto _KEY;
rest_flag = TRUE;
if ((c = nextc()) == ')' || c == '&')
error("&rest var missing");
unreadc(c);
rest_var = read_token();
if ((c = nextc()) == ')')
return;
if (c != '&')
error("& expected");
p = read_token();
_KEY:
if (strcmp(p, "key") != 0 && strcmp(p, "k") != 0)
goto _AUX;
key_flag = TRUE;
for (;; nkey++) {
if ((c = nextc()) == ')')
return;
if (c == '&') {
p = read_token();
if (strcmp(p, "allow_other_keys") == 0 ||
strcmp(p, "aok") == 0) {
allow_other_keys_flag = TRUE;
if ((c = nextc()) == ')')
return;
if (c != '&')
error("& expected");
p = read_token();
}
goto _AUX;
}
if (nkey >= MAXKEY)
error("too many optional argument");
if (c == '(') {
if ((c = nextc()) == '(') {
p = read_token();
if (p[0] != ':' || p[1] == '\0')
error("keyword expected");
keyword[nkey].k_key = p + 1;
keyword[nkey].k_var = read_token();
if (nextc() != ')')
error(") expected");
} else {
unreadc(c);
keyword[nkey].k_key
= keyword[nkey].k_var
= read_token();
}
if ((c = nextc()) == ')')
continue;
unreadc(c);
keyword[nkey].k_init = read_token();
if ((c = nextc()) == ')')
continue;
unreadc(c);
keyword[nkey].k_svar = read_token();
if (nextc() != ')')
error(") expected");
} else {
unreadc(c);
keyword[nkey].k_key
= keyword[nkey].k_var
= read_token();
}
}
_AUX:
if (strcmp(p, "aux") != 0 && strcmp(p, "a") != 0)
error("illegal lambda-list keyword");
for (;;) {
if ((c = nextc()) == ')')
return;
if (c == '&')
error("illegal lambda-list keyword");
if (naux >= MAXAUX)
error("too many auxiliary variable");
if (c == '(') {
aux[naux].a_var = read_token();
if ((c = nextc()) == ')')
continue;
unreadc(c);
aux[naux].a_init = read_token();
if (nextc() != ')')
error(") expected");
} else {
unreadc(c);
aux[naux].a_var = read_token();
}
naux++;
}
}
void read_op(sm4_op* pop)
{
sm4_op& op = *pop;
sm4_token_operand optok;
read_token(&optok);
assert(optok.file < SM4_FILE_COUNT);
op.swizzle[0] = 0;
op.swizzle[1] = 1;
op.swizzle[2] = 2;
op.swizzle[3] = 3;
op.mask = 0xf;
switch(optok.comps_enum)
{
case SM4_OPERAND_COMPNUM_0:
op.comps = 0;
break;
case SM4_OPERAND_COMPNUM_1:
op.comps = 1;
break;
case SM4_OPERAND_COMPNUM_4:
op.comps = 4;
op.mode = optok.mode;
switch(optok.mode)
{
case SM4_OPERAND_MODE_MASK:
op.mask = SM4_OPERAND_SEL_MASK(optok.sel);
break;
case SM4_OPERAND_MODE_SWIZZLE:
op.swizzle[0] = SM4_OPERAND_SEL_SWZ(optok.sel, 0);
op.swizzle[1] = SM4_OPERAND_SEL_SWZ(optok.sel, 1);
op.swizzle[2] = SM4_OPERAND_SEL_SWZ(optok.sel, 2);
op.swizzle[3] = SM4_OPERAND_SEL_SWZ(optok.sel, 3);
break;
case SM4_OPERAND_MODE_SCALAR:
op.swizzle[0] = op.swizzle[1] = op.swizzle[2] = op.swizzle[3] = SM4_OPERAND_SEL_SCALAR(optok.sel);
break;
}
break;
case SM4_OPERAND_COMPNUM_N:
fail("Unhandled operand component type");
}
op.file = (sm4_file)optok.file;
op.num_indices = optok.num_indices;
if(optok.extended)
{
sm4_token_operand_extended optokext;
read_token(&optokext);
if(optokext.type == 0)
{}
else if(optokext.type == 1)
{
op.neg = optokext.neg;
op.abs= optokext.abs;
}
else
fail("Unhandled extended operand token type");
}
for(unsigned i = 0; i < op.num_indices; ++i)
{
unsigned repr;
if(i == 0)
repr = optok.index0_repr;
else if(i == 1)
repr = optok.index1_repr;
else if(i == 2)
repr = optok.index2_repr;
else
fail("Unhandled operand index representation");
op.indices[0].disp = 0;
// TODO: is disp supposed to be signed here??
switch(repr)
{
case SM4_OPERAND_INDEX_REPR_IMM32:
op.indices[i].disp = (int32_t)read32();
break;
case SM4_OPERAND_INDEX_REPR_IMM64:
op.indices[i].disp = read64();
break;
case SM4_OPERAND_INDEX_REPR_REG:
relative:
op.indices[i].reg.reset(new sm4_op());
read_op(&*op.indices[0].reg);
break;
case SM4_OPERAND_INDEX_REPR_REG_IMM32:
op.indices[i].disp = (int32_t)read32();
goto relative;
case SM4_OPERAND_INDEX_REPR_REG_IMM64:
op.indices[i].disp = read64();
goto relative;
}
}
if(op.file == SM4_FILE_IMMEDIATE32)
{
for(unsigned i = 0; i < op.comps; ++i)
op.imm_values[i].i32 = read32();
}
else if(op.file == SM4_FILE_IMMEDIATE64)
{
for(unsigned i = 0; i < op.comps; ++i)
op.imm_values[i].i64 = read64();
}
}
void do_parse()
{
read_token(&program.version);
unsigned lentok = read32();
tokens_end = tokens - 2 + lentok;
while(tokens != tokens_end)
{
sm4_token_instruction insntok;
read_token(&insntok);
unsigned* insn_end = tokens - 1 + insntok.length;
sm4_opcode opcode = (sm4_opcode)insntok.opcode;
check(opcode < SM4_OPCODE_COUNT);
if(opcode == SM4_OPCODE_CUSTOMDATA)
{
unsigned customlen = read32() - 2;
skip(customlen);
continue;
}
if((opcode >= SM4_OPCODE_DCL_RESOURCE && opcode <= SM4_OPCODE_DCL_GLOBAL_FLAGS)
|| (opcode >= SM4_OPCODE_DCL_STREAM && opcode <= SM4_OPCODE_DCL_RESOURCE_STRUCTURED))
{
sm4_dcl& dcl = *new sm4_dcl;
program.dcls.push_back(&dcl);
(sm4_token_instruction&)dcl = insntok;
sm4_token_instruction_extended exttok;
memcpy(&exttok, &insntok, sizeof(exttok));
while(exttok.extended)
{
read_token(&exttok);
}
#define READ_OP_ANY dcl.op.reset(new sm4_op()); read_op(&*dcl.op);
#define READ_OP(FILE) READ_OP_ANY
//check(dcl.op->file == SM4_FILE_##FILE);
switch(opcode)
{
case SM4_OPCODE_DCL_GLOBAL_FLAGS:
break;
case SM4_OPCODE_DCL_RESOURCE:
READ_OP(RESOURCE);
read_token(&dcl.rrt);
break;
case SM4_OPCODE_DCL_SAMPLER:
READ_OP(SAMPLER);
break;
case SM4_OPCODE_DCL_INPUT:
case SM4_OPCODE_DCL_INPUT_PS:
READ_OP(INPUT);
break;
case SM4_OPCODE_DCL_INPUT_SIV:
case SM4_OPCODE_DCL_INPUT_SGV:
case SM4_OPCODE_DCL_INPUT_PS_SIV:
case SM4_OPCODE_DCL_INPUT_PS_SGV:
READ_OP(INPUT);
dcl.sv = (sm4_sv)(uint16_t)read32();
break;
case SM4_OPCODE_DCL_OUTPUT:
READ_OP(OUTPUT);
break;
case SM4_OPCODE_DCL_OUTPUT_SIV:
case SM4_OPCODE_DCL_OUTPUT_SGV:
READ_OP(OUTPUT);
dcl.sv = (sm4_sv)(uint16_t)read32();
break;
case SM4_OPCODE_DCL_INDEX_RANGE:
READ_OP_ANY;
check(dcl.op->file == SM4_FILE_INPUT || dcl.op->file == SM4_FILE_OUTPUT);
dcl.num = read32();
break;
case SM4_OPCODE_DCL_TEMPS:
dcl.num = read32();
break;
case SM4_OPCODE_DCL_INDEXABLE_TEMP:
READ_OP(INDEXABLE_TEMP);
dcl.indexable_temp.num = read32();
dcl.indexable_temp.comps = read32();
break;
case SM4_OPCODE_DCL_CONSTANT_BUFFER:
READ_OP(CONSTANT_BUFFER);
break;
case SM4_OPCODE_DCL_GS_INPUT_PRIMITIVE:
case SM4_OPCODE_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY:
break;
case SM4_OPCODE_DCL_MAX_OUTPUT_VERTEX_COUNT:
dcl.num = read32();
break;
case SM4_OPCODE_DCL_GS_INSTANCE_COUNT:
dcl.num = read32();
break;
case SM4_OPCODE_DCL_INPUT_CONTROL_POINT_COUNT:
case SM4_OPCODE_DCL_OUTPUT_CONTROL_POINT_COUNT:
case SM4_OPCODE_DCL_TESS_DOMAIN:
case SM4_OPCODE_DCL_TESS_PARTITIONING:
case SM4_OPCODE_DCL_TESS_OUTPUT_PRIMITIVE:
break;
case SM4_OPCODE_DCL_HS_MAX_TESSFACTOR:
dcl.f32 = read32();
break;
case SM4_OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT:
dcl.num = read32();
break;
case SM4_OPCODE_DCL_FUNCTION_BODY:
dcl.num = read32();
break;
case SM4_OPCODE_DCL_FUNCTION_TABLE:
dcl.num = read32();
dcl.data = malloc(dcl.num * sizeof(uint32_t));
for(unsigned i = 0; i < dcl.num; ++i)
((uint32_t*)dcl.data)[i] = read32();
break;
case SM4_OPCODE_DCL_INTERFACE:
dcl.intf.id = read32();
dcl.intf.expected_function_table_length = read32();
{
uint32_t v = read32();
dcl.intf.table_length = v & 0xffff;
dcl.intf.array_length = v >> 16;
}
dcl.data = malloc(dcl.intf.table_length * sizeof(uint32_t));
for(unsigned i = 0; i < dcl.intf.table_length; ++i)
((uint32_t*)dcl.data)[i] = read32();
break;
case SM4_OPCODE_DCL_THREAD_GROUP:
dcl.thread_group_size[0] = read32();
dcl.thread_group_size[1] = read32();
dcl.thread_group_size[2] = read32();
break;
case SM4_OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED:
READ_OP(UNORDERED_ACCESS_VIEW);
read_token(&dcl.rrt);
break;
case SM4_OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW:
READ_OP(UNORDERED_ACCESS_VIEW);
break;
case SM4_OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED:
READ_OP(UNORDERED_ACCESS_VIEW);
dcl.structured.stride = read32();
break;
case SM4_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_RAW:
READ_OP(THREAD_GROUP_SHARED_MEMORY);
dcl.num = read32();
break;
case SM4_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED:
READ_OP(THREAD_GROUP_SHARED_MEMORY);
dcl.structured.stride = read32();
dcl.structured.count = read32();
break;
case SM4_OPCODE_DCL_RESOURCE_RAW:
READ_OP(RESOURCE);
break;
case SM4_OPCODE_DCL_RESOURCE_STRUCTURED:
READ_OP(RESOURCE);
dcl.structured.stride = read32();
break;
case SM4_OPCODE_DCL_STREAM:
/* TODO: dcl_stream is undocumented: what is it? */
fail("Unhandled dcl_stream since it's undocumented");
default:
fail("Unhandled declaration");
}
check(tokens == insn_end);
}
else
{
int
main(int argc, char **argv)
{
OM_uint32 min;
gss_name_t service = NULL;
extern char *optarg;
extern int optind;
size_t count = 1;
int ch;
int Dflag = 0;
int Nflag = 0;
int lflag = 0;
int rflag = 0;
int ret = 0;
char *ccname = NULL;
while ((ch = getopt(argc, argv, "C:DNc:nlr")) != -1) {
switch (ch) {
case 'C':
ccname = optarg;
break;
case 'D':
Dflag = 1;
break;
case 'N':
Nflag = 1;
break;
case 'c':
count = atoi(optarg);
break;
case 'n':
nflag = 1;
break;
case 'l':
lflag = 1;
break;
case 'r':
rflag = 1;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc > 0)
service = import_service(*argv);
if (!rflag) {
if (!argc) {
fprintf(stderr, "Without -r, hostbased_service must "
"be provided.\n");
usage();
}
if (ccname) {
fprintf(stderr, "Specifying a target ccache doesn't "
"make sense without -r.\n");
usage();
}
ret = write_token(service, Dflag, Nflag, count);
goto done;
}
if (Dflag) {
fprintf(stderr, "Delegating credentials (-D) doesn't make "
"sense when reading tokens (-r).\n");
usage();
}
do {
ret = read_token(service, ccname, Nflag, count);
} while (lflag && !ret && !feof(stdin));
done:
if (service)
gss_release_name(&min, &service);
return ret;
}
static u_int32_t peek(void)
{
char c, *end;
fixnum_t x;
int ch, base;
if (toktype != TOK_NONE)
return toktype;
c = nextchar();
if (ios_eof(F)) return TOK_NONE;
if (c == '(') {
toktype = TOK_OPEN;
}
else if (c == ')') {
toktype = TOK_CLOSE;
}
else if (c == '[') {
toktype = TOK_OPENB;
}
else if (c == ']') {
toktype = TOK_CLOSEB;
}
else if (c == '\'') {
toktype = TOK_QUOTE;
}
else if (c == '`') {
toktype = TOK_BQ;
}
else if (c == '"') {
toktype = TOK_DOUBLEQUOTE;
}
else if (c == '#') {
ch = ios_getc(F); c = (char)ch;
if (ch == IOS_EOF)
lerror(ParseError, "read: invalid read macro");
if (c == '.') {
toktype = TOK_SHARPDOT;
}
else if (c == '\'') {
toktype = TOK_SHARPQUOTE;
}
else if (c == '\\') {
uint32_t cval;
if (ios_getutf8(F, &cval) == IOS_EOF)
lerror(ParseError, "read: end of input in character constant");
if (cval == (uint32_t)'u' || cval == (uint32_t)'U' ||
cval == (uint32_t)'x') {
read_token('u', 0);
if (buf[1] != '\0') { // not a solitary 'u','U','x'
if (!read_numtok(&buf[1], &tokval, 16))
lerror(ParseError,
"read: invalid hex character constant");
cval = numval(tokval);
}
}
else if (cval >= 'a' && cval <= 'z') {
read_token((char)cval, 0);
tokval = symbol(buf);
if (buf[1] == '\0') /* one character */;
else if (tokval == nulsym) cval = 0x00;
else if (tokval == alarmsym) cval = 0x07;
else if (tokval == backspacesym) cval = 0x08;
else if (tokval == tabsym) cval = 0x09;
else if (tokval == linefeedsym) cval = 0x0A;
else if (tokval == newlinesym) cval = 0x0A;
else if (tokval == vtabsym) cval = 0x0B;
else if (tokval == pagesym) cval = 0x0C;
else if (tokval == returnsym) cval = 0x0D;
else if (tokval == escsym) cval = 0x1B;
else if (tokval == spacesym) cval = 0x20;
else if (tokval == deletesym) cval = 0x7F;
else
lerrorf(ParseError, "read: unknown character #\\%s", buf);
}
toktype = TOK_NUM;
tokval = mk_wchar(cval);
}
else if (c == '(') {
toktype = TOK_SHARPOPEN;
}
else if (c == '<') {
lerror(ParseError, "read: unreadable object");
}
else if (isdigit(c)) {
read_token(c, 1);
c = (char)ios_getc(F);
if (c == '#')
toktype = TOK_BACKREF;
else if (c == '=')
toktype = TOK_LABEL;
else
lerror(ParseError, "read: invalid label");
errno = 0;
x = strtol(buf, &end, 10);
if (*end != '\0' || errno)
lerror(ParseError, "read: invalid label");
tokval = fixnum(x);
}
else if (c == '!') {
// #! single line comment for shbang script support
do {
ch = ios_getc(F);
} while (ch != IOS_EOF && (char)ch != '\n');
return peek();
}
else if (c == '|') {
// multiline comment
int commentlevel=1;
while (1) {
ch = ios_getc(F);
hashpipe_gotc:
if (ch == IOS_EOF)
lerror(ParseError, "read: eof within comment");
if ((char)ch == '|') {
ch = ios_getc(F);
if ((char)ch == '#') {
commentlevel--;
if (commentlevel == 0)
break;
else
continue;
}
goto hashpipe_gotc;
}
else if ((char)ch == '#') {
ch = ios_getc(F);
if ((char)ch == '|')
commentlevel++;
else
goto hashpipe_gotc;
}
}
// this was whitespace, so keep peeking
return peek();
}
else if (c == ';') {
// datum comment
(void)do_read_sexpr(UNBOUND); // skip
return peek();
}
else if (c == ':') {
// gensym
ch = ios_getc(F);
if ((char)ch == 'g')
ch = ios_getc(F);
read_token((char)ch, 0);
errno = 0;
x = strtol(buf, &end, 10);
if (*end != '\0' || buf[0] == '\0' || errno)
lerror(ParseError, "read: invalid gensym label");
toktype = TOK_GENSYM;
tokval = fixnum(x);
}
else if (symchar(c)) {
read_token(ch, 0);
if (((c == 'b' && (base= 2)) ||
(c == 'o' && (base= 8)) ||
(c == 'd' && (base=10)) ||
(c == 'x' && (base=16))) &&
(isdigit_base(buf[1],base) ||
buf[1]=='-')) {
if (!read_numtok(&buf[1], &tokval, base))
lerrorf(ParseError, "read: invalid base %d constant", base);
return (toktype=TOK_NUM);
}
toktype = TOK_SHARPSYM;
tokval = symbol(buf);
}
else {
lerror(ParseError, "read: unknown read macro");
}
}
else if (c == ',') {
toktype = TOK_COMMA;
ch = ios_getc(F);
if (ch == IOS_EOF)
return toktype;
if ((char)ch == '@')
toktype = TOK_COMMAAT;
else if ((char)ch == '.')
toktype = TOK_COMMADOT;
else
ios_ungetc((char)ch, F);
}
else {
if (!read_token(c, 0)) {
if (buf[0]=='.' && buf[1]=='\0') {
return (toktype=TOK_DOT);
}
else {
if (read_numtok(buf, &tokval, 0))
return (toktype=TOK_NUM);
}
}
toktype = TOK_SYM;
tokval = symbol(buf);
}
return toktype;
}
static int
process_filter(struct event_format *event, struct filter_arg **parg,
char **error_str, int not)
{
enum event_type type;
char *token = NULL;
struct filter_arg *current_op = NULL;
struct filter_arg *current_exp = NULL;
struct filter_arg *left_item = NULL;
struct filter_arg *arg = NULL;
enum op_type op_type;
enum filter_op_type btype;
enum filter_exp_type etype;
enum filter_cmp_type ctype;
int ret;
*parg = NULL;
do {
free(token);
type = read_token(&token);
switch (type) {
case EVENT_SQUOTE:
case EVENT_DQUOTE:
case EVENT_ITEM:
arg = create_arg_item(event, token, type, error_str);
if (!arg)
goto fail;
if (!left_item)
left_item = arg;
else if (current_exp) {
ret = add_right(current_exp, arg, error_str);
if (ret < 0)
goto fail;
left_item = NULL;
/* Not's only one one expression */
if (not) {
arg = NULL;
if (current_op)
goto fail_print;
free(token);
*parg = current_exp;
return 0;
}
} else
goto fail_print;
arg = NULL;
break;
case EVENT_DELIM:
if (*token == ',') {
show_error(error_str,
"Illegal token ','");
goto fail;
}
if (*token == '(') {
if (left_item) {
show_error(error_str,
"Open paren can not come after item");
goto fail;
}
if (current_exp) {
show_error(error_str,
"Open paren can not come after expression");
goto fail;
}
ret = process_filter(event, &arg, error_str, 0);
if (ret != 1) {
if (ret == 0)
show_error(error_str,
"Unbalanced number of '('");
goto fail;
}
ret = 0;
/* A not wants just one expression */
if (not) {
if (current_op)
goto fail_print;
*parg = arg;
return 0;
}
if (current_op)
ret = add_right(current_op, arg, error_str);
else
current_exp = arg;
if (ret < 0)
goto fail;
} else { /* ')' */
if (!current_op && !current_exp)
goto fail_print;
/* Make sure everything is finished at this level */
if (current_exp && !check_op_done(current_exp))
goto fail_print;
if (current_op && !check_op_done(current_op))
goto fail_print;
if (current_op)
*parg = current_op;
else
*parg = current_exp;
return 1;
}
break;
case EVENT_OP:
op_type = process_op(token, &btype, &ctype, &etype);
/* All expect a left arg except for NOT */
switch (op_type) {
case OP_BOOL:
/* Logic ops need a left expression */
if (!current_exp && !current_op)
goto fail_print;
/* fall through */
case OP_NOT:
/* logic only processes ops and exp */
if (left_item)
goto fail_print;
break;
case OP_EXP:
case OP_CMP:
if (!left_item)
goto fail_print;
break;
case OP_NONE:
show_error(error_str,
"Unknown op token %s", token);
goto fail;
}
ret = 0;
switch (op_type) {
case OP_BOOL:
arg = create_arg_op(btype);
if (current_op)
ret = add_left(arg, current_op);
else
ret = add_left(arg, current_exp);
current_op = arg;
current_exp = NULL;
break;
case OP_NOT:
arg = create_arg_op(btype);
if (current_op)
ret = add_right(current_op, arg, error_str);
if (ret < 0)
goto fail;
current_exp = arg;
ret = process_filter(event, &arg, error_str, 1);
if (ret < 0)
goto fail;
ret = add_right(current_exp, arg, error_str);
if (ret < 0)
goto fail;
break;
case OP_EXP:
case OP_CMP:
if (op_type == OP_EXP)
arg = create_arg_exp(etype);
else
arg = create_arg_cmp(ctype);
if (current_op)
ret = add_right(current_op, arg, error_str);
if (ret < 0)
goto fail;
ret = add_left(arg, left_item);
if (ret < 0) {
arg = NULL;
goto fail_print;
}
current_exp = arg;
break;
default:
break;
}
arg = NULL;
if (ret < 0)
goto fail_print;
break;
case EVENT_NONE:
break;
default:
goto fail_print;
}
} while (type != EVENT_NONE);
if (!current_op && !current_exp)
goto fail_print;
if (!current_op)
current_op = current_exp;
current_op = collapse_tree(current_op);
*parg = current_op;
return 0;
fail_print:
show_error(error_str, "Syntax error");
fail:
free_arg(current_op);
free_arg(current_exp);
free_arg(arg);
free(token);
return -1;
}
int main(void)
{
uwrite_int8s("\r\n");
for ( ; ; ) {
uwrite_int8s("Hell> ");
int8_t buffer[BUFFER_LEN];
int8_t* input = read_token(buffer, BUFFER_LEN, " \x0d");
if (strcmp(input, "file") == 0) {
uint32_t address = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t file_length = ascii_dec_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
store(address, file_length);
} else if (strcmp(input, "jal") == 0) {
uint32_t address = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
entry_t start = (entry_t)(address);
start();
} else if (strcmp(input, "lw") == 0) {
uint32_t address = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
volatile uint32_t* p = (volatile uint32_t*)(address);
uwrite_int8s(uint32_to_ascii_hex(address, buffer, BUFFER_LEN));
uwrite_int8s(":");
uwrite_int8s(uint32_to_ascii_hex(*p, buffer, BUFFER_LEN));
uwrite_int8s("\r\n");
} else if (strcmp(input, "lhu") == 0) {
uint32_t address = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
volatile uint16_t* p = (volatile uint16_t*)(address);
uwrite_int8s(uint32_to_ascii_hex(address, buffer, BUFFER_LEN));
uwrite_int8s(":");
uwrite_int8s(uint16_to_ascii_hex(*p, buffer, BUFFER_LEN));
uwrite_int8s("\r\n");
} else if (strcmp(input, "lbu") == 0) {
uint32_t address = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
volatile uint8_t* p = (volatile uint8_t*)(address);
uwrite_int8s(uint32_to_ascii_hex(address, buffer, BUFFER_LEN));
uwrite_int8s(":");
uwrite_int8s(uint8_to_ascii_hex(*p, buffer, BUFFER_LEN));
uwrite_int8s("\r\n");
} else if (strcmp(input, "sw") == 0) {
uint32_t word = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t address = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
volatile uint32_t* p = (volatile uint32_t*)(address);
*p = word;
} else if (strcmp(input, "sh") == 0) {
uint16_t half = ascii_hex_to_uint16(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t address = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
volatile uint16_t* p = (volatile uint16_t*)(address);
*p = half;
} else if (strcmp(input, "sb") == 0) {
uint8_t byte = ascii_hex_to_uint8(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t address = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
volatile uint8_t* p = (volatile uint8_t*)(address);
*p = byte;
} else if (strcmp(input, "fill") == 0) {
uint32_t color = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
fill(color);
} else if (strcmp(input, "hwline") == 0) {
int8_t buffer[64];
uint32_t color = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t x0 = ascii_dec_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t y0 = ascii_dec_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t x1 = ascii_dec_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t y1 = ascii_dec_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
uwrite_int8s("\r\n");
uwrite_int8s(uint32_to_ascii_hex(color, buffer, 64));
uwrite_int8s("\r\n");
uwrite_int8s(uint32_to_ascii_hex(x0, buffer, 64));
uwrite_int8s("\r\n");
uwrite_int8s(uint32_to_ascii_hex(y0, buffer, 64));
uwrite_int8s("\r\n");
uwrite_int8s(uint32_to_ascii_hex(x1, buffer, 64));
uwrite_int8s("\r\n");
uwrite_int8s(uint32_to_ascii_hex(y1, buffer, 64));
uwrite_int8s("\r\n");
uwrite_int8s("\r\n");
hwline(color, x0, y0, x1, y1);
} else if (strcmp(input, "swline") == 0) {
uint32_t color = ascii_hex_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t x0 = ascii_dec_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t y0 = ascii_dec_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t x1 = ascii_dec_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
uint32_t y1 = ascii_dec_to_uint32(read_token(buffer, BUFFER_LEN, " \x0d"));
swline(color, x0, y0, x1, y1);
} else {
uwrite_int8s("\n\rGo f**k yourself: ");
uwrite_int8s(input);
uwrite_int8s("\n\r");
}
}
return 0;
}
/* Read one AtRule or TopLevel. A TopLevel is basically a sequence of anything
that isn't an AtRule.
*/
static node *read_statement(mincss_context *context)
{
tokentype toktyp = context->nexttok.typ;
if (toktyp == tok_EOF)
return NULL;
if (toktyp == tok_AtKeyword) {
node *nod = new_node(context, nod_AtRule);
node_copy_text(nod, &context->nexttok);
read_token(context);
read_token_skipspace(context);
read_any_until_semiblock(context, nod);
toktyp = context->nexttok.typ;
if (toktyp == tok_EOF) {
return nod; /* end of file */
}
if (toktyp == tok_Semicolon) {
/* drop the semicolon, end the AtRule */
read_token(context);
read_token_skipspace(context);
return nod;
}
if (toktyp == tok_LBrace) {
/* beginning of block */
node *blocknod = read_block(context);
if (!blocknod) {
/* error */
free_node(nod);
return NULL;
}
node_add_node(nod, blocknod);
return nod; /* the block ends the AtRule */
}
/* error */
mincss_note_error(context, "(Internal) Unexpected token after read_any_until_semiblock");
free_node(nod);
return NULL;
}
else {
/* The syntax spec lets us parse a ruleset here. But we don't
bother; we just parse any/blocks until the next AtKeyword.
They all get stuffed into a single TopLevel node. (Unless
there's no content at all, in which case we don't create a
node.) */
node *nod = new_node(context, nod_TopLevel);
while (1) {
read_any_top_level(context, nod);
tokentype toktyp = context->nexttok.typ;
if (toktyp == tok_EOF) {
break; /* end of file */
}
if (toktyp == tok_AtKeyword) {
break; /* an @-rule is next */
}
if (toktyp == tok_LBrace) {
node *blocknod = read_block(context);
if (!blocknod) {
/* error, already reported */
continue;
}
node_add_node(nod, blocknod);
continue;
}
mincss_note_error(context, "(Internal) Unexpected token after read_any_top_level");
free_node(nod);
return NULL;
}
if (nod->numnodes == 0) {
/* empty group, don't bother returning it. */
free_node(nod);
return NULL;
}
return nod;
}
}
static const char *http_read_challenge(const char *s, struct http_challenge *challenge)
{
const char *p;
char *scheme;
http_challenge_init(challenge);
scheme = NULL;
s = read_token(s, &scheme);
if (s == NULL)
goto bail;
if (str_equal_i(scheme, "Basic")) {
challenge->scheme = AUTH_BASIC;
} else if (str_equal_i(scheme, "Digest")) {
challenge->scheme = AUTH_DIGEST;
} else {
challenge->scheme = AUTH_UNKNOWN;
}
free(scheme);
scheme = NULL;
/* RFC 2617, section 1.2, requires at least one auth-param:
challenge = auth-scheme 1*SP 1#auth-param
But there are some schemes (NTLM and Negotiate) that can be without
auth-params, so we allow that here. A comma indicates the end of this
challenge and the beginning of the next (see the comment in the loop
below). */
while (is_space_char(*s))
s++;
if (*s == ',') {
s++;
while (is_space_char(*s))
s++;
if (*s == '\0')
goto bail;
return s;
}
while (*s != '\0') {
char *name, *value;
p = read_token(s, &name);
if (p == NULL)
goto bail;
while (is_space_char(*p))
p++;
/* It's possible that we've hit the end of one challenge and the
beginning of another. Section 14.33 says that the header value can be
1#challenge, in other words several challenges separated by commas.
Because the auth-params are also separated by commas, the only way we
can tell is if we find a token not followed by an equals sign. */
if (*p != '=')
break;
p++;
while (is_space_char(*p))
p++;
p = read_token_or_quoted_string(p, &value);
if (p == NULL) {
free(name);
goto bail;
}
if (str_equal_i(name, "realm"))
challenge->realm = Strdup(value);
else if (challenge->scheme == AUTH_DIGEST) {
if (str_equal_i(name, "nonce")) {
if (challenge->digest.nonce != NULL)
goto bail;
challenge->digest.nonce = Strdup(value);
} else if (str_equal_i(name, "opaque")) {
if (challenge->digest.opaque != NULL)
goto bail;
challenge->digest.opaque = Strdup(value);
} else if (str_equal_i(name, "algorithm")) {
if (str_equal_i(value, "MD5"))
challenge->digest.algorithm = ALGORITHM_MD5;
else
challenge->digest.algorithm = ALGORITHM_UNKNOWN;
} else if (str_equal_i(name, "qop")) {
char **tokens;
size_t n;
int i;
const char *tmp;
tmp = read_token_list(value, &tokens, &n);
if (tmp == NULL) {
free(name);
free(value);
goto bail;
}
for (i = 0; i < n; i++) {
if (str_equal_i(tokens[i], "auth"))
challenge->digest.qop |= QOP_AUTH;
else if (str_equal_i(tokens[i], "auth-int"))
challenge->digest.qop |= QOP_AUTH_INT;
}
for (i = 0; i < n; i++)
free(tokens[i]);
free(tokens);
if (*tmp != '\0') {
free(name);
free(value);
goto bail;
}
}
}
free(name);
free(value);
while (is_space_char(*p))
p++;
if (*p == ',') {
p++;
while (is_space_char(*p))
p++;
if (*p == '\0')
goto bail;
}
s = p;
}
return s;
bail:
if (scheme != NULL)
free(scheme);
http_challenge_free(challenge);
return NULL;
}
/* Read an "any* sequence up until a particular close token (RBracket or
RParen). Blocks cannot occur in this context.
On return, the current token is whatever's next.
*/
static void read_any_until_close(mincss_context *context, node *nod, tokentype closetok)
{
while (1) {
tokentype toktyp = context->nexttok.typ;
if (toktyp == tok_EOF) {
mincss_note_error(context, "Missing close-delimiter");
return;
}
if (toktyp == closetok) {
/* The expected close-token. */
read_token(context);
return;
}
switch (toktyp) {
case tok_Semicolon:
mincss_note_error(context, "Unexpected semicolon inside brackets");
read_token(context);
continue;
case tok_LBrace:
mincss_note_error(context, "Unexpected block inside brackets");
read_block(context);
continue;
case tok_Function: {
node *subnod = new_node(context, nod_Function);
node_copy_text(subnod, &context->nexttok);
node_add_node(nod, subnod);
read_token(context);
read_any_until_close(context, subnod, tok_RParen);
continue;
}
case tok_LParen: {
node *subnod = new_node(context, nod_Parens);
node_add_node(nod, subnod);
read_token(context);
read_any_until_close(context, subnod, tok_RParen);
continue;
}
case tok_LBracket: {
node *subnod = new_node(context, nod_Brackets);
node_add_node(nod, subnod);
read_token(context);
read_any_until_close(context, subnod, tok_RBracket);
continue;
}
case tok_CDO:
case tok_CDC:
mincss_note_error(context, "HTML comment delimiters not allowed inside brackets");
read_token(context);
read_token_skipspace(context);
continue;
case tok_RParen:
mincss_note_error(context, "Unexpected close-paren inside brackets");
read_token(context);
continue;
case tok_RBracket:
mincss_note_error(context, "Unexpected close-bracket inside brackets");
read_token(context);
continue;
case tok_AtKeyword:
mincss_note_error(context, "Unexpected @-keyword inside brackets");
read_token(context);
continue;
default: {
node *toknod = new_node_token(context, &context->nexttok);
node_add_node(nod, toknod);
read_token(context);
}
}
}
}
static const char *http_read_credentials(const char *s,
struct http_credentials *credentials)
{
const char *p;
char *scheme;
credentials->scheme = AUTH_UNKNOWN;
s = read_token(s, &scheme);
if (s == NULL)
return NULL;
if (str_equal_i(scheme, "Basic")) {
http_credentials_init_basic(credentials);
} else if (str_equal_i(scheme, "Digest")) {
http_credentials_init_digest(credentials);
} else {
free(scheme);
return NULL;
}
free(scheme);
while (is_space_char(*s))
s++;
if (credentials->scheme == AUTH_BASIC) {
p = s;
/* Read base64. */
while (is_alpha_char(*p) || is_digit_char(*p) || *p == '+' || *p == '/' || *p == '=')
p++;
credentials->u.basic = mkstr(s, p);
while (is_space_char(*p))
p++;
s = p;
} else if (credentials->scheme == AUTH_DIGEST) {
char *name, *value;
while (*s != '\0') {
p = read_token(s, &name);
if (p == NULL)
goto bail;
while (is_space_char(*p))
p++;
/* It's not legal to combine multiple Authorization or
Proxy-Authorization values. The productions are
"Authorization" ":" credentials (section 14.8)
"Proxy-Authorization" ":" credentials (section 14.34)
Contrast this with WWW-Authenticate and Proxy-Authenticate and
their handling in http_read_challenge. */
if (*p != '=')
goto bail;
p++;
while (is_space_char(*p))
p++;
p = read_token_or_quoted_string(p, &value);
if (p == NULL) {
free(name);
goto bail;
}
if (str_equal_i(name, "username")) {
if (credentials->u.digest.username != NULL)
goto bail;
credentials->u.digest.username = Strdup(value);
} else if (str_equal_i(name, "realm")) {
if (credentials->u.digest.realm != NULL)
goto bail;
credentials->u.digest.realm = Strdup(value);
} else if (str_equal_i(name, "nonce")) {
if (credentials->u.digest.nonce != NULL)
goto bail;
credentials->u.digest.nonce = Strdup(value);
} else if (str_equal_i(name, "uri")) {
if (credentials->u.digest.uri != NULL)
goto bail;
credentials->u.digest.uri = Strdup(value);
} else if (str_equal_i(name, "response")) {
if (credentials->u.digest.response != NULL)
goto bail;
credentials->u.digest.response = Strdup(value);
} else if (str_equal_i(name, "algorithm")) {
if (str_equal_i(value, "MD5"))
credentials->u.digest.algorithm = ALGORITHM_MD5;
else
credentials->u.digest.algorithm = ALGORITHM_MD5;
} else if (str_equal_i(name, "qop")) {
if (str_equal_i(value, "auth"))
credentials->u.digest.qop = QOP_AUTH;
else if (str_equal_i(value, "auth-int"))
credentials->u.digest.qop = QOP_AUTH_INT;
else
credentials->u.digest.qop = QOP_NONE;
} else if (str_equal_i(name, "cnonce")) {
if (credentials->u.digest.cnonce != NULL)
goto bail;
credentials->u.digest.cnonce = Strdup(value);
} else if (str_equal_i(name, "nc")) {
if (credentials->u.digest.nc != NULL)
goto bail;
credentials->u.digest.nc = Strdup(value);
}
free(name);
free(value);
while (is_space_char(*p))
p++;
if (*p == ',') {
p++;
while (is_space_char(*p))
p++;
if (*p == '\0')
goto bail;
}
s = p;
}
}
return s;
bail:
http_credentials_free(credentials);
return NULL;
}
int lex (char *buf, arff_info_t * info)
{
char *tok;
char c;
int i, r;
token_t delimiter;
for (;;) {
if ((c = *buf++) == '\0')
break;
switch (c) {
case ' ':
case '\t':
case '\r':
// ignore
break;
case '%':
/* a comment */
do {
c = *buf++;
} while ((c != '\n') && (c != '\0'));
buf--;
break;
case '\n':
/* a new line */
TRY (r, parse (TOKEN_NEWLINE, NULL, info));
break;
case ',':
/* a comma */
TRY (r, parse (TOKEN_COMMA, NULL, info));
break;
case '{':
/* a left brace */
TRY (r, parse (TOKEN_LEFTBRACE, NULL, info));
break;
case '}':
/* a right brace */
TRY (r, parse (TOKEN_RIGHTBRACE, NULL, info));
break;
default:
/* something else */
buf--;
tok = read_token (&buf, &delimiter);
/* check if it is a special token */
for (i = 0; special[i].string != NULL; i++) {
if (!stricmp (tok, special[i].string)) {
TRY (r,
parse (special[i].type, tok,
info));
break;
}
}
if (special[i].string == NULL)
TRY (r, parse (TOKEN_TOKEN, tok, info));
if (delimiter < TOKEN_NUM_TYPES)
TRY (r, parse (delimiter, NULL, info));
break;
}
}
parse_end (info);
return 0;
}
void init_param(int argc, char** argv,double *dtnext,int flag)
{
int ver;
FILE *iop;
double d;
if(argc<2 || (iop=fopen(argv[1],"r"))==NULL) //no ini file
nrerror("Start from no ini file!",-1,-1);
if(fscanf(iop,"%d",&ver)<1 || ver!=2) nrerror("parameters' file has wrong version",0,0);
read_token(iop,&rc);
read_token(iop,&R);
read_token(iop,&Re);
read_token(iop,¶bole);
read_token(iop,&Noise);
read_token(iop,&NoiseNorm);
read_token(iop,&UpLimit);
read_token(iop,&chimax);
read_token(iop,&d); N1 = (int)d;
read_token(iop,&d); N3 = (int)d;
read_token(iop,&d); nvar = (int)d;
read_token(iop,&d); approx = (int)d;
read_token(iop,dtnext);
read_token(iop,&d); max_okr = (int)d;
read_token(iop,&d); OutStep = (int)d;
read_token(iop,&d); SnapStep = (int)d;
read_token(iop,&SnapDelta);
if(ver>=2) read_token(iop,&DumpInterval);
if(ver>=2) read_token(iop,&d); DumpKeep = (int)d;
read_token(iop,&d); CheckStep = (int)d;
read_token(iop,&d); VarStep = (int)d;
read_token(iop,&Ttot);
read_token(iop,&ChangeParamTime);
read_token(iop,&DeltaParam);
read_token(iop,&d);
if(flag)
{
if(d==0) {
goon = 0;
strcpy(NameInitFile,"END");
}
else if(d>0) {
goon = 1;
sprintf(NameInitFile,"%s_%d_%05d.snp",NameSnapFile,size,(int)d);
}
else {// without reading (d<0)
goon=0;
strcpy(NameInitFile,"-1");
}
}
Master if(!goon && !count) nmessage("Parameters were extracted from file",0,0);
fileclose(iop);
Gamma=1e-4;
ghost=(approx-1)/2+3; //radius of approx sample
dx[0]=2*R/N1;
dx[2]=2*R/N3;
p1 = 4/Re;
}
double expression_eval(const char * expr)
{
vector<token> rpn;
stack<token> op_stk;
token start_token;
start_token.type = R;
start_token.value.op = '#';
op_stk.push(start_token);
token tk;
int i = 0;
read_token(expr, i, tk);
while (!op_stk.empty()) {
if (tk.type == D) {
rpn.push_back(tk);
read_token(expr, i, tk);
} else if (tk.type == R) {
int top = op_stk.top().value.op;
int c = op_compare(top, tk.value.op);
if (c == -1) {
token t;
t.type = R;
t.value.op = tk.value.op;
op_stk.push(t);
read_token(expr, i, tk);
} else if (c == 1) {
rpn.push_back(op_stk.top());
op_stk.pop();
} else if (c == 0) {
op_stk.pop();
read_token(expr, i, tk);
} else {
cerr << "ERROR format of expression " << expr << endl;
return -1;
}
}
}
stack<double> e_stk;
for (vector<token>::iterator i = rpn.begin(); i != rpn.end(); ++i) {
if (i->type == D) {
e_stk.push(i->value.num);
} else {
if (e_stk.size() < 2) {
cerr << "ERROR format of expression " << expr << endl;
return -1;
}
double a2 = e_stk.top();
e_stk.pop();
double a1 = e_stk.top();
e_stk.pop();
double b = 0;
switch (i->value.op) {
case '+': b = a1 + a2; break;
case '-': b = a1 - a2; break;
case '*': b = a1 * a2; break;
case '/': b = a1 / a2; break;
}
e_stk.push(b);
}
}
return e_stk.top();
}
int
yylex(void)
{
int ch, value;
char *path;
struct replpath rp;
/* Switch to new file. See comment in read_token below. */
if (lex_include) {
while ((ch = lex_getc()) != EOF && isspace((u_char) ch))
;
if (ch != '"' && ch != '\'')
yyerror("syntax error");
if (ch == '"')
rp.str = read_string('"', 1);
else
rp.str = read_string('\'', 0);
path = replacepath(&rp, parse_tags, NULL, NULL, conf.user_home);
xfree(rp.str);
include_start(path);
lex_include = 0;
}
restart:
while ((ch = lex_getc()) != EOF) {
switch (ch) {
case '#':
/* Comment: discard until EOL. */
while ((ch = lex_getc()) != '\n' && ch != EOF)
;
parse_file->line++;
break;
case '\'':
yylval.string = read_string('\'', 0);
value = STRING;
goto out;
case '"':
yylval.string = read_string('"', 1);
value = STRING;
goto out;
case '$':
ch = lex_getc();
if (ch == '(') {
yylval.string = read_command();
value = STRCOMMAND;
goto out;
}
if (ch == '{' || isalnum((u_char) ch)) {
yylval.string = read_macro('$', ch);
value = STRMACRO;
goto out;
}
yyerror("invalid macro name");
case '%':
ch = lex_getc();
if (ch == '(') {
yylval.string = read_command();
value = NUMCOMMAND;
goto out;
}
if (ch == '{' || isalnum((u_char) ch)) {
yylval.string = read_macro('%', ch);
value = NUMMACRO;
goto out;
}
yyerror("invalid macro name");
case '=':
ch = lex_getc();
if (ch == '=') {
value = TOKEQ;
goto out;
}
lex_ungetc(ch);
value = '=';
goto out;
case '!':
ch = lex_getc();
if (ch == '=') {
value = TOKNE;
goto out;
}
lex_ungetc(ch);
value = '!';
goto out;
case '~':
case '+':
case '(':
case ')':
case ',':
case '<':
case '>':
case '{':
case '}':
case '*':
value = ch;
goto out;
case '\n':
parse_file->line++;
break;
case ' ':
case '\t':
break;
default:
if (ch != '_' && ch != '-' && !isalnum((u_char) ch))
yyerror("unexpected character: %c", ch);
if (isdigit((u_char) ch)) {
yylval.number = read_number(ch);
value = NUMBER;
goto out;
}
value = read_token(ch);
goto out;
}
}
if (!include_finish())
goto restart;
if (lex_ifdef != 0)
yyerror("missing endif");
return (EOF);
out:
if (lex_skip)
goto restart;
return (value);
}
void readToken(SourceStream *in) {
read_token(in, this);
}
/**
* @brief Main top routine to read in HTK %HMM definition file.
*
* A HTK %HMM definition file will be read from @a fp. After reading,
* the parameter type is checked and calculate some statistics.
*
* @param fp [in] file pointer
* @param hmm [out] pointer to a %HMM definition structure to store data.
*
* @return TRUE on success, FALSE on failure.
*/
boolean
rdhmmdef(FILE *fp, HTK_HMM_INFO *hmm)
{
char macrosw;
char *name;
/* variances in htkdefs are not inversed yet */
hmm->variance_inversed = FALSE;
/* read the first token */
/* read new 1 line */
line = 1;
if (getl(buf, MAXBUFLEN, fp) == NULL) {
rdhmmdef_token = NULL;
} else {
rdhmmdef_token = mystrtok_quote(buf, HMMDEF_DELM);
}
/* the toplevel loop */
while (rdhmmdef_token != NULL) {/* break on EOF */
if (rdhmmdef_token[0] != '~') { /* toplevel commands are always macro */
return FALSE;
}
macrosw = rdhmmdef_token[1];
read_token(fp); /* read next token after the "~.." */
switch(macrosw) {
case 'o': /* global option */
if (set_global_opt(fp,hmm) == FALSE) {
return FALSE;
}
break;
case 't': /* transition macro */
name = mybstrdup2(rdhmmdef_token, &(hmm->mroot));
if (strlen(name) >= MAX_HMMNAME_LEN) rderr("Macro name too long");
read_token(fp);
def_trans_macro(name, fp, hmm);
break;
case 's': /* state macro */
name = mybstrdup2(rdhmmdef_token, &(hmm->mroot));
if (strlen(name) >= MAX_HMMNAME_LEN) rderr("Macro name too long");
read_token(fp);
def_state_macro(name, fp, hmm);
break;
case 'm': /* density (mixture) macro */
name = mybstrdup2(rdhmmdef_token, &(hmm->mroot));
if (strlen(name) >= MAX_HMMNAME_LEN) rderr("Macro name too long");
read_token(fp);
def_dens_macro(name, fp, hmm);
break;
case 'h': /* HMM define */
name = mybstrdup2(rdhmmdef_token, &(hmm->mroot));
if (strlen(name) >= MAX_HMMNAME_LEN) rderr("Macro name too long");
read_token(fp);
def_HMM(name, fp, hmm);
break;
case 'v': /* Variance macro */
name = mybstrdup2(rdhmmdef_token, &(hmm->mroot));
if (strlen(name) >= MAX_HMMNAME_LEN) rderr("Macro name too long");
read_token(fp);
def_var_macro(name, fp, hmm);
break;
case 'w': /* Stream weight macro */
name = mybstrdup2(rdhmmdef_token, &(hmm->mroot));
if (strlen(name) >= MAX_HMMNAME_LEN) rderr("Macro name too long");
read_token(fp);
def_streamweight_macro(name, fp, hmm);
break;
case 'r': /* Regression class macro (ignore) */
name = mybstrdup2(rdhmmdef_token, &(hmm->mroot));
if (strlen(name) >= MAX_HMMNAME_LEN) rderr("Macro name too long");
read_token(fp);
def_regtree_macro(name, fp, hmm);
break;
case 'p': /* Mixture pdf macro (extension of HTS) */
name = mybstrdup2(rdhmmdef_token, &(hmm->mroot));
if (strlen(name) >= MAX_HMMNAME_LEN) rderr("Macro name too long");
read_token(fp);
def_mpdf_macro(name, fp, hmm);
break;
}
}
/* convert transition prob to log scale */
conv_log_arc(hmm);
jlog("Stat: rdhmmdef: ascii format HMM definition\n");
/* check limitation */
if (check_all_hmm_limit(hmm)) {
jlog("Stat: rdhmmdef: limit check passed\n");
} else {
jlog("Error: rdhmmdef: cannot handle this HMM due to system limitation\n");
return FALSE;
}
/* determine whether this model needs multi-path handling */
hmm->need_multipath = htk_hmm_has_several_arc_on_edge(hmm);
if (hmm->need_multipath) {
jlog("Stat: rdhmmdef: this HMM requires multipath handling at decoding\n");
} else {
jlog("Stat: rdhmmdef: this HMM does not need multipath handling\n");
}
/* inverse all variance values for faster computation */
if (! hmm->variance_inversed) {
htk_hmm_inverse_variances(hmm);
hmm->variance_inversed = TRUE;
}
/* check HMM parameter option type */
if (!check_hmm_options(hmm)) {
jlog("Error: rdhmmdef: hmm options check failed\n");
return FALSE;
}
/* add ID number for all HTK_HMM_State if not assigned */
{
HTK_HMM_State *stmp;
int n;
boolean has_sid;
/* caclculate total num and check if has sid */
has_sid = FALSE;
n = 0;
for (stmp = hmm->ststart; stmp; stmp = stmp->next) {
n++;
if (n >= MAX_STATE_NUM) {
jlog("Error: rdhmmdef: too much states in a model > %d\n", MAX_STATE_NUM);
return FALSE;
}
if (stmp->id != -1) {
has_sid = TRUE;
}
}
hmm->totalstatenum = n;
if (has_sid) {
jlog("Stat: rdhmmdef: <SID> found in the definition\n");
/* check if each state is assigned a valid sid */
if (htk_hmm_check_sid(hmm) == FALSE) {
jlog("Error: rdhmmdef: error in SID\n");
return FALSE;
}
} else {
/* assign internal sid (will not be saved) */
jlog("Stat: rdhmmdef: no <SID> embedded\n");
jlog("Stat: rdhmmdef: assign SID by the order of appearance\n");
n = hmm->totalstatenum;
for (stmp = hmm->ststart; stmp; stmp = stmp->next) {
stmp->id = --n;
}
}
}
/* calculate the maximum number of mixture */
{
HTK_HMM_State *stmp;
int max, s, mix;
max = 0;
for (stmp = hmm->ststart; stmp; stmp = stmp->next) {
for(s=0;s<stmp->nstream;s++) {
mix = stmp->pdf[s]->mix_num;
if (max < mix) max = mix;
}
}
hmm->maxmixturenum = max;
}
/* compute total number of HMM models and maximum length */
{
HTK_HMM_Data *dtmp;
int n, maxlen;
n = 0;
maxlen = 0;
for (dtmp = hmm->start; dtmp; dtmp = dtmp->next) {
if (maxlen < dtmp->state_num) maxlen = dtmp->state_num;
n++;
}
hmm->maxstatenum = maxlen;
hmm->totalhmmnum = n;
}
/* compute total number of Gaussians */
{
HTK_HMM_Dens *dtmp;
int n = 0;
for (dtmp = hmm->dnstart; dtmp; dtmp = dtmp->next) {
n++;
}
hmm->totalmixnum = n;
}
/* check of HMM name length exceed the maximum */
{
HTK_HMM_Dens *dtmp;
int n = 0;
for (dtmp = hmm->dnstart; dtmp; dtmp = dtmp->next) {
n++;
}
hmm->totalmixnum = n;
}
/* compute total number of mixture PDFs */
{
HTK_HMM_PDF *p;
int n = 0;
for (p = hmm->pdfstart; p; p = p->next) {
n++;
}
hmm->totalpdfnum = n;
}
/* assign ID number for all HTK_HMM_Trans */
{
HTK_HMM_Trans *ttmp;
int n = 0;
for (ttmp = hmm->trstart; ttmp; ttmp = ttmp->next) {
ttmp->id = n++;
}
hmm->totaltransnum = n;
}
#ifdef ENABLE_MSD
/* check if MSD-HMM */
htk_hmm_check_msd(hmm);
#endif
return(TRUE); /* success */
}
Token *peek_token(void) {
Token *tok = read_token();
unget_token(tok);
return tok;
}
/******************************************************
interpreter関数
ソケット通信でclientからコマンドがきたら、コマンドに応じて返信する
*****************************************************/
int interpreter(char *line){
char com[128];
char *ptr;
int command_flag=FALSE;
int fd = get_socket_fd();
char result[8024]; //結果の文字列領域
int size;
int i;
//コマンドを切り出す
while (*line && whitespace (*line)) line++;
ptr = read_token(line, "%s", com);
//fprintf(stderr, "recv command: %s\n", com);
/******** コマンドに応じて返すデータを変更(ここから) *********/
//生画像データが欲しい
if(strcmp(com, "write-rawdata") == 0){
//rawdataを送っている間に画像データが書き変わらないようにロックをかける
sema_lock(raw_semaphore);
write(fd, rawdata, (process_width*process_height*3));
sema_unlock(raw_semaphore);
command_flag = TRUE;
}
//処理語画像データが欲しい
else if(strcmp(com, "write-processdata") == 0){
sema_lock(process_semaphore);
write(fd, processdata, (process_width*process_height*3));
sema_unlock(process_semaphore);
command_flag = TRUE;
}
//処理結果(座標等)が欲しい
// euslispで解釈しやすいように、()のリスト情報で情報付しておいてやるのがよい
// 仕様は自分で決めて、後でclientのeuslisp側のソフトが動くものを作ればいい
// ここでは重心位置を返すようにしている
else if(strcmp(com, "result") == 0){
size = sprintf(result, "((:centroid");
for(i=0; i<label_num; i++){
size += sprintf(result+size, " #f(%d %d)", (int)linfo[i].xpos,(int)linfo[i].ypos);
}
size += sprintf(result+size, ")");
size += sprintf(result+size, " (:area");
for(i=0; i<label_num; i++){
size += sprintf(result+size, " %d", linfo[i].area);
}
size += sprintf(result+size, "))\n");
write(fd, result, size);
command_flag = TRUE;
}
//縦横を返す for vision-viewer
else if(strcmp(com, "vision-size")==0){
size = sprintf(result, "(%d %d)\n", process_height, process_width);
write(fd, result, size);
command_flag = TRUE;
}
//閾値を変更したい
else if(strcmp(com, "color-threshold") == 0){
for(i=0; i<6; i++){
ptr = read_token(ptr, "%d", &rgb_thre[i]);
}
fprintf(stderr, "change rgb_threshold ");
for(i=0; i<6; i++){
fprintf(stderr, "%d ", rgb_thre[i]);
}
fprintf(stderr, "\n");
command_flag = TRUE;
}
//閾値を取得したい
else if(strcmp(com, "get-color-threshold") == 0){
size = sprintf(result, "#f(");
for(i=0; i<6; i++){
size += sprintf(result+size, "%d ", rgb_thre[i]);
}
size += sprintf(result+size, ")\n");
write(fd, result, size);
command_flag = TRUE;
}
//Labeling個数をセット 引数一つ
else if(strcmp(com, "set-displaylabel-num") == 0){
ptr = read_token(ptr, "%d", &display_label_num);
fprintf(stderr, "change displaylabelnum %d\n", display_label_num);
command_flag = TRUE;
}
//Labeling個数を取得
else if(strcmp(com, "get-displaylabel-num") == 0){
size = sprintf(result, "%d\n", display_label_num);
write(fd, result, size);
command_flag = TRUE;
}
//表示最小面積をセット 引数ひとつ
else if(strcmp(com, "set-minarea") == 0){
ptr = read_token(ptr, "%d", &minimum_area);
fprintf(stderr, "change minimu area size %d\n", minimum_area);
command_flag = TRUE;
}
//表示最小面積を取得
else if(strcmp(com, "get-minarea") == 0){
size = sprintf(result, "%d\n", minimum_area);
write(fd, result, size);
command_flag = TRUE;
}
/******** コマンドに応じて返すデータを変更(ここまで) *********/
//該当しないコマンドがきた場合はその旨を表示
if(command_flag == FALSE){
fprintf(stderr, "No such command %s\n", com);
}
return 0;
}
