555 lines
11 KiB
C
555 lines
11 KiB
C
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include "c.h"
|
|
#include "rcc.h"
|
|
#if WIN32
|
|
#include <fcntl.h>
|
|
#include <io.h>
|
|
#endif
|
|
|
|
|
|
static void do_int(int x) {
|
|
printf("%d", x);
|
|
}
|
|
|
|
static void do_scope(int x) {
|
|
#define xx(c) if (x == c) { printf(#c); return; }
|
|
xx(CONSTANTS)
|
|
xx(LABELS)
|
|
xx(GLOBAL)
|
|
xx(PARAM)
|
|
xx(LOCAL)
|
|
#undef xx
|
|
if (x > LOCAL)
|
|
printf("LOCAL+%d", x-LOCAL);
|
|
else
|
|
do_int(x);
|
|
}
|
|
|
|
static void do_sclass(int x) {
|
|
#define xx(c) if (x == c) { printf(#c); return; }
|
|
xx(REGISTER)
|
|
xx(AUTO)
|
|
xx(EXTERN)
|
|
xx(STATIC)
|
|
xx(TYPEDEF)
|
|
#undef xx
|
|
do_int(x);
|
|
}
|
|
|
|
static void do_flags(int x) {
|
|
char *bar = "";
|
|
#define xx(f,n) if ((x>>n)&1) { printf("%s" #f, bar); bar = "|"; }
|
|
xx(structarg,0)
|
|
xx(addressed,1)
|
|
xx(computed,2)
|
|
xx(temporary,3)
|
|
xx(generated,4)
|
|
#undef xx
|
|
if (*bar == '\0')
|
|
do_int(x);
|
|
}
|
|
|
|
static void do_seg(int x) {
|
|
#define xx(s) if (x == s) { printf(#s); return; }
|
|
xx(CODE)
|
|
xx(BSS)
|
|
xx(DATA)
|
|
xx(LIT)
|
|
#undef xx
|
|
do_int(x);
|
|
}
|
|
|
|
#define xx(ptr,field,type) do { printf("<li>" #field " = "); do_##type(ptr->field); printf("</li>\n"); } while (0)
|
|
|
|
static void do_op(int x) {
|
|
static char *opnames[] = {
|
|
"",
|
|
"CNST",
|
|
"ARG",
|
|
"ASGN",
|
|
"INDIR",
|
|
"CVC",
|
|
"CVD",
|
|
"CVF",
|
|
"CVI",
|
|
"CVP",
|
|
"CVS",
|
|
"CVU",
|
|
"NEG",
|
|
"CALL",
|
|
"*LOAD*",
|
|
"RET",
|
|
"ADDRG",
|
|
"ADDRF",
|
|
"ADDRL",
|
|
"ADD",
|
|
"SUB",
|
|
"LSH",
|
|
"MOD",
|
|
"RSH",
|
|
"BAND",
|
|
"BCOM",
|
|
"BOR",
|
|
"BXOR",
|
|
"DIV",
|
|
"MUL",
|
|
"EQ",
|
|
"GE",
|
|
"GT",
|
|
"LE",
|
|
"LT",
|
|
"NE",
|
|
"JUMP",
|
|
"LABEL",
|
|
"AND",
|
|
"NOT",
|
|
"OR",
|
|
"COND",
|
|
"RIGHT",
|
|
"FIELD"
|
|
};
|
|
int op = opindex(x);
|
|
if (op < 1 || op >= sizeof opnames/sizeof opnames[0])
|
|
printf("%d", x);
|
|
else
|
|
printf("%s", opnames[op]);
|
|
}
|
|
|
|
static void do_define_uid(int x) {
|
|
printf("<strong id=uid%d>%d</strong>", x, x);
|
|
}
|
|
|
|
static void do_define_label(int x) {
|
|
printf("<strong id=ll%d>%d</strong>", x, x);
|
|
}
|
|
|
|
static void do_uid(int x) {
|
|
printf("<a href='#%d'>%d</a>", x, x, x);
|
|
}
|
|
|
|
static void do_label(int x) {
|
|
printf("<a href='#L%d'>%d</a>", x, x, x);
|
|
}
|
|
|
|
static int nextid;
|
|
|
|
static void do_list(list_ty x, void do_one(void *), char *type, char *listhtml, char *separator) {
|
|
int count = Seq_length(x);
|
|
|
|
if (count == 0)
|
|
printf("<em>empty %s list</em>\n", type);
|
|
else {
|
|
int i;
|
|
printf("<em>%s list</em>", type);
|
|
if (listhtml != NULL)
|
|
printf("<%s>\n", listhtml);
|
|
for (i = 0; i < count; i++) {
|
|
if (listhtml != NULL)
|
|
printf("<li>");
|
|
printf(separator);
|
|
do_one(Seq_get(x, i));
|
|
if (listhtml != NULL)
|
|
printf("</li>\n");
|
|
}
|
|
if (listhtml != NULL)
|
|
printf("</%s>\n", listhtml);
|
|
}
|
|
}
|
|
|
|
static void do_uid_list(list_ty x) {
|
|
int i, count = Seq_length(x);
|
|
|
|
if (count == 0)
|
|
printf("<em>empty int list</em>\n");
|
|
else {
|
|
int i;
|
|
printf("<em>int list</em>");
|
|
for (i= 0; i < count; i++) {
|
|
printf(" ");
|
|
do_uid(*(int *)Seq_get(x, i));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void do_identifier(const char *x) {
|
|
printf("%s", x);
|
|
}
|
|
|
|
static void do_real(rcc_real_ty x) {
|
|
double d;
|
|
unsigned *p = (unsigned *)&d;
|
|
static union { int x; char endian; } little = { 1 };
|
|
|
|
p[1-little.endian] = x->msb;
|
|
p[little.endian] = x->lsb;
|
|
printf("(%#X,%#X) = %g", x->msb, x->lsb, d);
|
|
}
|
|
|
|
static void do_suffix(int x) {
|
|
static char suffixes[] = "0F234IUPVB";
|
|
|
|
if (x < 0 || x >= (sizeof suffixes/sizeof suffixes[0]) - 1)
|
|
printf("%d", x);
|
|
else
|
|
printf("%c", suffixes[x]);
|
|
}
|
|
|
|
static void do_enum(void *x) {
|
|
rcc_enum__ty e = x;
|
|
|
|
do_identifier(e->id);
|
|
printf("=");
|
|
do_int(e->value);
|
|
}
|
|
|
|
static void do_enum_list(list_ty x) {
|
|
do_list(x, do_enum, "enum", NULL, " ");
|
|
}
|
|
|
|
static void do_field(void *x) {
|
|
rcc_field_ty f = x;
|
|
|
|
printf("<em>field</em><ul>\n");
|
|
xx(f,id,identifier);
|
|
xx(f,type,uid);
|
|
xx(f,offset,int);
|
|
xx(f,bitsize,int);
|
|
xx(f,lsb,int);
|
|
printf("</ul>\n");
|
|
}
|
|
|
|
static void do_field_list(list_ty x) {
|
|
do_list(x, do_field, "field", "ol", "");
|
|
}
|
|
|
|
static void do_symbol(rcc_symbol_ty x) {
|
|
printf("<em>symbol</em><ul>\n");
|
|
xx(x,id,identifier);
|
|
xx(x,type,uid);
|
|
xx(x,scope,scope);
|
|
xx(x,sclass,sclass);
|
|
xx(x,ref,int);
|
|
xx(x,flags,flags);
|
|
printf("</ul>\n");
|
|
}
|
|
|
|
#define caselabel(kind) case rcc_##kind##_enum: \
|
|
printf("<strong>" #kind "</strong> : <em>%s</em>", typename); \
|
|
printf("<ul>\n"); attributes
|
|
#define yy(kind,field,type) xx((&x->v.rcc_##kind),field,type)
|
|
|
|
static void do_type(rcc_type_ty x) {
|
|
#define attributes xx(x,size,int); xx(x,align,int)
|
|
switch (x->kind) {
|
|
static char *typename = "type";
|
|
caselabel(INT); break;
|
|
caselabel(UNSIGNED); break;
|
|
caselabel(FLOAT); break;
|
|
caselabel(VOID); break;
|
|
caselabel(POINTER);
|
|
yy(POINTER,type,uid);
|
|
break;
|
|
caselabel(ENUM);
|
|
yy(ENUM,tag,identifier);
|
|
yy(ENUM,ids,enum_list);
|
|
break;
|
|
caselabel(STRUCT);
|
|
yy(STRUCT,tag,identifier);
|
|
yy(STRUCT,fields,field_list);
|
|
break;
|
|
caselabel(UNION);
|
|
yy(UNION,tag,identifier);
|
|
yy(UNION,fields,field_list);
|
|
break;
|
|
caselabel(ARRAY);
|
|
yy(ARRAY,type,uid);
|
|
break;
|
|
caselabel(FUNCTION);
|
|
yy(FUNCTION,type,uid);
|
|
yy(FUNCTION,formals,uid_list);
|
|
break;
|
|
caselabel(CONST);
|
|
yy(CONST,type,uid);
|
|
break;
|
|
caselabel(VOLATILE);
|
|
yy(VOLATILE,type,uid);
|
|
break;
|
|
default: assert(0);
|
|
}
|
|
#undef attributes
|
|
printf("</ul>\n");
|
|
}
|
|
|
|
static void do_item(rcc_item_ty x) {
|
|
printf("<a name='%d'>", x->uid);
|
|
#define attributes xx(x,uid,define_uid)
|
|
printf("</a>");
|
|
switch (x->kind) {
|
|
static char *typename = "item";
|
|
caselabel(Symbol);
|
|
yy(Symbol,symbol,symbol);
|
|
break;
|
|
caselabel(Type);
|
|
yy(Type,type,type);
|
|
break;
|
|
default: assert(0);
|
|
}
|
|
#undef attributes
|
|
printf("</ul>\n");
|
|
}
|
|
|
|
static void do_item_list(list_ty x) {
|
|
int count = Seq_length(x);
|
|
|
|
if (count == 0)
|
|
printf("<em>empty item list</em>\n");
|
|
else {
|
|
int i;
|
|
printf("<em>item list</em>");
|
|
printf("<ol>\n");
|
|
for (i = 0; i < count; i++) {
|
|
rcc_item_ty item = Seq_get(x, i);
|
|
printf("<li value=%d>", item->uid);
|
|
do_item(item);
|
|
printf("</li>\n");
|
|
}
|
|
printf("</ol>\n");
|
|
}
|
|
}
|
|
|
|
static void do_string(string_ty x) {
|
|
printf("%d,<code>'%s'</code>", x.len, x.str);
|
|
}
|
|
|
|
static void do_generic_string(void *x) {
|
|
do_string(*(string_ty *)x);
|
|
}
|
|
|
|
static void do_string_list(list_ty x) {
|
|
do_list(x, do_generic_string, "string", "ol", "");
|
|
}
|
|
|
|
static void do_node(void *y) {
|
|
rcc_node_ty x = y;
|
|
|
|
if (x->kind == rcc_LABEL_enum)
|
|
printf("<a name='L%d'></a>", x->v.rcc_LABEL.label);
|
|
#define attributes xx(x,suffix,suffix); xx(x,size,int)
|
|
switch (x->kind) {
|
|
static char *typename = "node";
|
|
caselabel(CNST);
|
|
yy(CNST,value,int);
|
|
break;
|
|
caselabel(CNSTF);
|
|
yy(CNSTF,value,real);
|
|
break;
|
|
caselabel(ARG);
|
|
yy(ARG,left,node);
|
|
yy(ARG,len,int);
|
|
yy(ARG,align,int);
|
|
break;
|
|
caselabel(ASGN);
|
|
yy(ASGN,left,node);
|
|
yy(ASGN,right,node);
|
|
yy(ASGN,len,int);
|
|
yy(ASGN,align,int);
|
|
break;
|
|
caselabel(CVT);
|
|
yy(CVT,op,op);
|
|
yy(CVT,left,node);
|
|
yy(CVT,fromsize,int);
|
|
break;
|
|
caselabel(CALL);
|
|
yy(CALL,left,node);
|
|
yy(CALL,type,uid);
|
|
break;
|
|
caselabel(CALLB);
|
|
yy(CALLB,left,node);
|
|
yy(CALLB,right,node);
|
|
yy(CALLB,type,uid);
|
|
break;
|
|
caselabel(RET); break;
|
|
caselabel(ADDRG);
|
|
yy(ADDRG,uid,uid);
|
|
break;
|
|
caselabel(ADDRL);
|
|
yy(ADDRL,uid,uid);
|
|
break;
|
|
caselabel(ADDRF);
|
|
yy(ADDRF,uid,uid);
|
|
break;
|
|
caselabel(Unary);
|
|
yy(Unary,op,op);
|
|
yy(Unary,left,node);
|
|
break;
|
|
caselabel(Binary);
|
|
yy(Binary,op,op);
|
|
yy(Binary,left,node);
|
|
yy(Binary,right,node);
|
|
break;
|
|
caselabel(Compare);
|
|
yy(Compare,op,op);
|
|
yy(Compare,left,node);
|
|
yy(Compare,right,node);
|
|
yy(Compare,label,label);
|
|
break;
|
|
caselabel(LABEL);
|
|
yy(LABEL,label,define_label);
|
|
break;
|
|
caselabel(BRANCH);
|
|
yy(BRANCH,label,label);
|
|
break;
|
|
caselabel(CSE);
|
|
yy(CSE,uid,uid);
|
|
yy(CSE,node,node);
|
|
break;
|
|
default: assert(0);
|
|
}
|
|
#undef attributes
|
|
printf("</ul>");
|
|
}
|
|
|
|
static void do_node_list(list_ty x) {
|
|
do_list(x, do_node, "node", "ol", "");
|
|
}
|
|
|
|
static void do_interface(void *);
|
|
|
|
static void do_interface_list(list_ty x) {
|
|
do_list(x, do_interface, "interface", "ol", "");
|
|
}
|
|
|
|
static void do_interface(void *y) {
|
|
rcc_interface_ty x = y;
|
|
|
|
if (x->kind == rcc_Address_enum)
|
|
printf("<a name='%d'></a>", x->v.rcc_Address.uid);
|
|
else if (x->kind == rcc_Local_enum)
|
|
printf("<a name='%d'></a>", x->v.rcc_Local.uid);
|
|
#define attributes
|
|
switch (x->kind) {
|
|
static char *typename = "interface";
|
|
caselabel(Export);
|
|
yy(Export,p,uid);
|
|
break;
|
|
caselabel(Import);
|
|
yy(Import,p,uid);
|
|
break;
|
|
caselabel(Global);
|
|
yy(Global,p,uid);
|
|
yy(Global,seg,seg);
|
|
break;
|
|
caselabel(Local);
|
|
yy(Local,uid,define_uid);
|
|
yy(Local,p,symbol);
|
|
break;
|
|
caselabel(Address);
|
|
yy(Address,uid,define_uid);
|
|
yy(Address,q,symbol);
|
|
yy(Address,p,uid);
|
|
yy(Address,n,int);
|
|
break;
|
|
caselabel(Segment);
|
|
yy(Segment,seg,seg);
|
|
break;
|
|
caselabel(Defaddress);
|
|
yy(Defaddress,p,uid);
|
|
break;
|
|
caselabel(Deflabel);
|
|
yy(Deflabel,label,label);
|
|
break;
|
|
caselabel(Defconst);
|
|
yy(Defconst,suffix,suffix);
|
|
yy(Defconst,size,int);
|
|
yy(Defconst,value,int);
|
|
break;
|
|
caselabel(Defconstf);
|
|
yy(Defconstf,size,int);
|
|
yy(Defconstf,value,real);
|
|
break;
|
|
caselabel(Defstring);
|
|
yy(Defstring,s,string);
|
|
break;
|
|
caselabel(Space);
|
|
yy(Space,n,int);
|
|
break;
|
|
caselabel(Function);
|
|
yy(Function,f,uid);
|
|
yy(Function,caller,uid_list);
|
|
yy(Function,callee,uid_list);
|
|
yy(Function,ncalls,int);
|
|
yy(Function,codelist,interface_list);
|
|
break;
|
|
caselabel(Forest);
|
|
yy(Forest,nodes,node_list);
|
|
break;
|
|
case rcc_Blockbeg_enum: printf("<strong>Blockbeg</strong> : <em>%s</em>", typename); return;
|
|
case rcc_Blockend_enum: printf("<strong>Blockend</strong> : <em>%s</em>", typename); return;
|
|
default: assert(0);
|
|
}
|
|
#undef attributes
|
|
printf("</ul>\n");
|
|
}
|
|
|
|
static void do_program(rcc_program_ty x) {
|
|
printf("<ul>\n");
|
|
xx(x,nuids,int);
|
|
xx(x,nlabels,int);
|
|
xx(x,items,item_list);
|
|
xx(x,interfaces,interface_list);
|
|
xx(x,argc,int);
|
|
xx(x,argv,string_list);
|
|
printf("</ul>\n");
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
int i, version;
|
|
float stamp = (assert(strstr(rcsid, ",v")), strtod(strstr(rcsid, ",v")+2, NULL))
|
|
;
|
|
char *infile = NULL, *outfile = NULL;
|
|
rcc_program_ty pickle;
|
|
|
|
for (i = 1; i < argc; i++)
|
|
if (*argv[i] != '-' || strcmp(argv[i], "-") == 0) {
|
|
if (infile == NULL)
|
|
infile = argv[i];
|
|
else if (outfile == NULL)
|
|
outfile = argv[i];
|
|
}
|
|
if (infile != NULL && strcmp(infile, "-") != 0
|
|
&& freopen(infile, "rb", stdin) == NULL) {
|
|
fprintf(stderr, "%s: can't read `%s'\n", argv[0], infile);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
if (infile == NULL || strcmp(infile, "-") == 0)
|
|
infile = "Standard Input";
|
|
#if WIN32
|
|
else
|
|
_setmode(_fileno(stdin), _O_BINARY);
|
|
#endif
|
|
if (outfile != NULL && strcmp(outfile, "-") != 0
|
|
&& freopen(outfile, "w", stdout) == NULL) {
|
|
fprintf(stderr, "%s: can't write `%s'\n", argv[0], outfile);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
version = read_int(stdin);
|
|
assert(version/100 == (int)stamp);
|
|
pickle = rcc_read_program(stdin);
|
|
printf("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\"\n");
|
|
printf("<html><head><title>%s</title>\n"
|
|
"<link rev=made href=\"mailto:drh@microsoft.com\">\n"
|
|
"</head><body>\n<h1>%s</h1>\n", infile, infile);
|
|
printf("<p>version = %d.%d</p>", version/100, version%100);
|
|
do_program(pickle);
|
|
{
|
|
time_t t;
|
|
time(&t);
|
|
printf("<hr><address>%s</address>\n", ctime(&t));
|
|
}
|
|
printf("</body></html>\n");
|
|
return EXIT_SUCCESS;
|
|
}
|