static void printfields(classinfo *c)
{
u4 i;
fieldinfo *f;
int ident_count;
if (!c) {
addoutputsize(sizeof(java_objectheader));
fprintf(file, " java_objectheader header;\n");
return;
}
printfields(c->super.cls);
for (i = 0; i < c->fieldscount; i++) {
f = &(c->fields[i]);
if (!(f->flags & ACC_STATIC)) {
fprintf(file, " ");
printtype(f->descriptor->text);
fprintf(file, " ");
utf_fprint_printable_ascii(file, f->name);
/* rename multiple fieldnames */
if ((ident_count = searchidentchain_utf(f->name)))
fprintf(file, "%d", ident_count - 1);
chain_addlast(ident_chain, f->name);
fprintf(file, ";\n");
}
}
}
/*
* print [inode] [size] name
* return # of characters printed, no trailing characters.
*/
static int
printaname(FTSENT *p, int inodefield, int sizefield)
{
struct stat *sp;
int chcnt;
char szbuf[5];
sp = p->fts_statp;
chcnt = 0;
if (f_inode)
chcnt += printf("%*"PRIu64" ", inodefield, sp->st_ino);
if (f_size) {
if (f_humanize) {
if ((humanize_number(szbuf, sizeof(szbuf), sp->st_size,
"", HN_AUTOSCALE,
(HN_DECIMAL | HN_B | HN_NOSPACE))) == -1)
err(1, "humanize_number");
chcnt += printf("%*s ", sizefield, szbuf);
} else {
chcnt += printf(f_commas ? "%'*llu " : "%*llu ",
sizefield, (unsigned long long)
howmany(sp->st_blocks, blocksize));
}
}
if (f_octal || f_octal_escape)
chcnt += safe_printpath(p);
else if (f_nonprint)
chcnt += printescapedpath(p);
else
chcnt += printpath(p);
if (f_type || (f_typedir && S_ISDIR(sp->st_mode)))
chcnt += printtype(sp->st_mode);
return (chcnt);
}
int printhead(PICTURE *pic, int magic)
{
switch (magic) {
case PGM_ASCI_MAGIC: (void)fprintf(stderr,"PGM ascii format"); break;
case PPM_ASCI_MAGIC: (void)fprintf(stderr,"PPM ascii format"); break;
case PGM_MAGIC: (void)fprintf(stderr,"PGM rawbits format"); break;
case PPM_MAGIC: (void)fprintf(stderr,"PPM rawbits format"); break;
case PAM_MAGIC: (void)fprintf(stderr,"PAM portable any map format"); break;
case VIS_MAGIC: (void)fprintf(stderr,"LVL binary format"); break;
case VIS_SWMAGIC:(void)fprintf(stderr,"LVL binary format (bytes swapped)");break;
case VISA_MAGIC: (void)fprintf(stderr,"LVL ascii format"); break;
case VISA_SWMAGIC:(void)fprintf(stderr,"LVL ascii format (header bytes swapped)");break;
default: (void)fprintf(stderr,
"Unsupported magic %x given to printhead\n",magic); return(-1); }
(void)fprintf(stderr,", %d bytes of data\n", sizeofdata(pic));
(void)fprintf(stderr,
"%d across %d down, origin (%.2f,%.2f)\n%d items, each has ",
pic->x,pic->y,pic->xorigin,pic->yorigin,pic->items);
if (pic->samples == 1) (void)fprintf(stderr,"one sample ");
else (void)fprintf(stderr,"%d samples ",pic->samples);
(void)fprintf(stderr,"of type: ");
printtype(pic->fileid);
(void)fprintf(stderr,"History: %s\n",pic->history);
return(0);
}
/*
* print [inode] [size] name
* return # of characters printed, no trailing characters.
*/
static int
printaname(const FTSENT *p, u_long inodefield, u_long sizefield)
{
struct stat *sp;
int chcnt;
#ifdef COLORLS
int color_printed = 0;
#endif
sp = p->fts_statp;
chcnt = 0;
if (f_inode)
chcnt += xo_emit("{t:inode/%*ju} ",
(int)inodefield, (uintmax_t)sp->st_ino);
if (f_size)
chcnt += xo_emit("{t:size/%*jd} ",
(int)sizefield, howmany(sp->st_blocks, blocksize));
#ifdef COLORLS
if (f_color)
color_printed = colortype(sp->st_mode);
#endif
chcnt += printname("name", p->fts_name);
#ifdef COLORLS
if (f_color && color_printed)
endcolor(0);
#endif
if (f_type)
chcnt += printtype(sp->st_mode);
return (chcnt);
}
int printtype(collection_type *collection_ptr,struct genhashtable *ght)
{
int j=0;
int offset=0;
int value=0;
struct valuepair *vp=NULL;
if (gencontains(ght,collection_ptr->name))
vp=(struct valuepair *)gengettable(ght,collection_ptr->name);
if (vp!=NULL)
collection_ptr=(collection_type*) dwarf_entry_array[vp->index].entry_ptr;
for(j=0;j<collection_ptr->num_members;j++) {
dwarf_entry *entry=collection_ptr->members[j];
if (entry->tag_name==DW_TAG_inheritance) {
inherit * inherit_ptr=(inherit *)entry->entry_ptr;
if (inherit_ptr->data_member_location>offset) {
printf(" reserved byte[%ld];\n",inherit_ptr->data_member_location-offset);
offset=inherit_ptr->data_member_location;
}
{
dwarf_entry *type=inherit_ptr->target_ptr;
collection_type *c_ptr=(collection_type*)type->entry_ptr;
offset+=printtype(c_ptr,ght);
}
} else {
member * member_ptr=(member *)entry->entry_ptr;
char *name=member_ptr->name;
char *newname=NULL;
dwarf_entry *type=member_ptr->type_ptr;
char *typestr=printname(type,GETTYPE);
char *poststr=printname(type,POSTNAME);
if (member_ptr->data_member_location>offset) {
printf(" reserved byte[%ld];\n",member_ptr->data_member_location-offset);
offset=member_ptr->data_member_location;
}
offset+=getsize(type);
newname=escapestr(name);
{
char buf[512];
char *dtype;
sprintf(buf, "%s.%s\0", collection_ptr->name,newname);
if (arrayt!=NULL&&gencontains(arrayt, &buf)) {
genputtable(arraytype, buf, typestr);
dtype=deref(typestr);
printf(" %s_array * %s%s;\n",dtype,newname,poststr);
free(dtype);
} else
printf(" %s %s%s;\n",typestr,newname,poststr);
}
free(newname);
}
}
return offset;
}
void
printlong(DISPLAY *dp)
{
struct stat *sp;
FTSENT *p;
NAMES *np;
char buf[20];
if (dp->list->fts_level != FTS_ROOTLEVEL && (f_longform || f_size))
(void)printf("total %llu\n", howmany(dp->btotal, blocksize));
for (p = dp->list; p; p = p->fts_link) {
if (IS_NOPRINT(p))
continue;
sp = p->fts_statp;
if (f_inode)
(void)printf("%*llu ", dp->s_inode,
(unsigned long long)sp->st_ino);
if (f_size)
(void)printf("%*lld ", dp->s_block,
howmany((long long)sp->st_blocks, blocksize));
(void)strmode(sp->st_mode, buf);
np = p->fts_pointer;
(void)printf("%s %*u ", buf, dp->s_nlink, sp->st_nlink);
if (!f_grouponly)
(void)printf("%-*s ", dp->s_user, np->user);
(void)printf("%-*s ", dp->s_group, np->group);
if (f_flags)
(void)printf("%-*s ", dp->s_flags, np->flags);
if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode))
(void)printf("%3d, %3d ",
major(sp->st_rdev), minor(sp->st_rdev));
else if (dp->bcfile)
(void)printf("%*s%*lld ",
8 - dp->s_size, "", dp->s_size,
(long long)sp->st_size);
else
printsize(dp->s_size, sp->st_size);
if (f_accesstime)
printtime(sp->st_atime);
else if (f_statustime)
printtime(sp->st_ctime);
else
printtime(sp->st_mtime);
(void)mbsprint(p->fts_name, 1);
if (f_type || (f_typedir && S_ISDIR(sp->st_mode)))
(void)printtype(sp->st_mode);
if (S_ISLNK(sp->st_mode))
printlink(p);
(void)putchar('\n');
}
}
void printtree (Node *n, int level) {
if (!n) return;
initTreeTypes();
char* myname = nodenames[n->node_type];
switch (n->node_type) {
case NT_NUMBERLIT:
printf("%*c %s %f\n", level, ' ', myname, n->node_data.number);
break;
case NT_IMPORTPATH:
case NT_IMPORTTARGET:
case NT_CLASSNAME:
case NT_INTERFACE:
case NT_SUBCLASS:
case NT_STRINGLIT:
case NT_METHOD_NAME_SEGMENT:
case NT_ALIAS:
case NT_COMPILER_HINT:
printf("%*c %s %s\n", level, ' ', myname, n->node_data.string);
break;
case NT_TYPEDATA:
printtype(n->node_data.pure_type, level);
break;
case NT_TYPE_ARRAY:
printf("%*c %s\n", level, ' ', myname);
{
int i;
for(i = 0; i < n->node_data.pure_type_array->typecount; i++)
printtype(n->node_data.pure_type_array->types[i], level + 1);
}
break;
default:
printSubNodes(n, level, myname); break;
}
}
void printmethod(methodinfo *m)
{
char *utf_ptr;
u2 paramnum = 1;
/* search for return-type in descriptor */
utf_ptr = m->descriptor->text;
while (utf_nextu2(&utf_ptr) != ')');
/* create remarks */
fprintf(file, "\n/*\n * Class: ");
utf_fprint_printable_ascii(file, m->class->name);
fprintf(file, "\n * Method: ");
utf_fprint_printable_ascii(file, m->name);
fprintf(file, "\n * Signature: ");
utf_fprint_printable_ascii(file, m->descriptor);
fprintf(file, "\n */\n");
/* create prototype */
fprintf(file, "JNIEXPORT ");
printtype(utf_ptr);
fprintf(file, " JNICALL Java_");
printID(m->class->name);
chain_addlast(ident_chain, m->name);
fprintf(file, "_");
printID(m->name);
/* ATTENTION: We use a dummy flag here. */
if (m->flags & ACC_NATIVELY_OVERLOADED)
printOverloadPart(m->descriptor);
fprintf(file, "(JNIEnv *env");
utf_ptr = m->descriptor->text + 1;
if (!(m->flags & ACC_STATIC)) {
fprintf(file, ", struct ");
printID(m->class->name);
fprintf(file, "* this");
} else {
/*
* print [inode] [size] name
* return # of characters printed, no trailing characters.
*/
static int
printaname(FTSENT *p, int inodefield, int sizefield)
{
struct stat *sp;
int chcnt;
sp = p->fts_statp;
chcnt = 0;
if (f_inode)
chcnt += printf("%*llu ", inodefield,
(unsigned long long)sp->st_ino);
if (f_size)
chcnt += printf("%*lld ", sizefield,
howmany((long long)sp->st_blocks, blocksize));
chcnt += mbsprint(p->fts_name, 1);
if (f_type || (f_typedir && S_ISDIR(sp->st_mode)))
chcnt += printtype(sp->st_mode);
return (chcnt);
}
/*
* print [inode] [size] name
* return # of characters printed, no trailing characters.
*/
static int
printaname(FTSENT *p, u_long inodefield, u_long sizefield)
{
struct stat *sp;
int chcnt;
sp = p->fts_statp;
chcnt = 0;
if (f_inode)
chcnt += printf("%*llu ", (int)inodefield,
(unsigned long long)sp->st_ino);
if (f_size)
chcnt += printf("%*qd ",
(int)sizefield, howmany(sp->st_blocks, blocksize));
chcnt += putname(p->fts_name);
if (f_type || (f_typedir && S_ISDIR(sp->st_mode)))
chcnt += printtype(sp->st_mode);
return (chcnt);
}
void
showallglobals(void)
{
GLOBAL **hp; /* hash table head address */
register GLOBAL *sp; /* current global symbol pointer */
long count; /* number of global variables shown */
count = 0;
for (hp = &globalhash[HASHSIZE-1]; hp >= globalhash; hp--) {
for (sp = *hp; sp; sp = sp->g_next) {
if (count++ == 0) {
printf("\nName Level Type\n");
printf( "---- ----- -----\n");
}
printf("%-8s%4d ", sp->g_name, sp->g_filescope);
printtype(&sp->g_value);
printf("\n");
}
}
if (count > 0)
printf("\nNumber: %ld\n", count);
else
printf("No global variables\n");
}
/*
* To display all static variables whose scope has been ended
*/
void
showstatics(void)
{
long count;
GLOBAL **stp;
GLOBAL *sp;
for (count = 0, stp = statictable; count < staticcount; count++) {
sp = *stp++;
if (count == 0) {
printf("\nName Scopes Type\n");
printf( "---- ------ -----\n");
}
printf("%-8s", sp->g_name);
printf("%3d", sp->g_filescope);
printf("%3d ", sp->g_funcscope);
printtype(&sp->g_value);
printf("\n");
}
if (count > 0)
printf("\nNumber: %ld\n", count);
else
printf("No unscoped static variables\n");
}
void
printlong(const DISPLAY *dp)
{
struct stat *sp;
FTSENT *p;
NAMES *np;
char buf[20];
#ifdef COLORLS
int color_printed = 0;
#endif
if ((dp->list == NULL || dp->list->fts_level != FTS_ROOTLEVEL) &&
(f_longform || f_size)) {
xo_emit("{L:total} {:total-blocks/%lu}\n",
howmany(dp->btotal, blocksize));
}
xo_open_list("entry");
for (p = dp->list; p; p = p->fts_link) {
char *name, *type;
if (IS_NOPRINT(p))
continue;
xo_open_instance("entry");
sp = p->fts_statp;
name = getname(p->fts_name);
if (name)
xo_emit("{ke:name/%hs}", name);
if (f_inode)
xo_emit("{t:inode/%*ju} ",
dp->s_inode, (uintmax_t)sp->st_ino);
if (f_size)
xo_emit("{t:blocks/%*jd} ",
dp->s_block, howmany(sp->st_blocks, blocksize));
strmode(sp->st_mode, buf);
aclmode(buf, p);
np = p->fts_pointer;
xo_attr("value", "%03o", (int) sp->st_mode & ALLPERMS);
if (f_numericonly) {
xo_emit("{t:mode/%s}{e:mode_octal/%03o} {t:links/%*u} {td:user/%-*s}{e:user/%ju} {td:group/%-*s}{e:group/%ju} ",
buf, (int) sp->st_mode & ALLPERMS, dp->s_nlink, sp->st_nlink,
dp->s_user, np->user, sp->st_uid, dp->s_group, np->group, sp->st_gid);
} else {
xo_emit("{t:mode/%s}{e:mode_octal/%03o} {t:links/%*u} {t:user/%-*s} {t:group/%-*s} ",
buf, (int) sp->st_mode & ALLPERMS, dp->s_nlink, sp->st_nlink,
dp->s_user, np->user, dp->s_group, np->group);
}
if (S_ISBLK(sp->st_mode))
asprintf(&type, "block");
if (S_ISCHR(sp->st_mode))
asprintf(&type, "character");
if (S_ISDIR(sp->st_mode))
asprintf(&type, "directory");
if (S_ISFIFO(sp->st_mode))
asprintf(&type, "fifo");
if (S_ISLNK(sp->st_mode))
asprintf(&type, "symlink");
if (S_ISREG(sp->st_mode))
asprintf(&type, "regular");
if (S_ISSOCK(sp->st_mode))
asprintf(&type, "socket");
if (S_ISWHT(sp->st_mode))
asprintf(&type, "whiteout");
xo_emit("{e:type/%s}", type);
free(type);
if (f_flags)
xo_emit("{:flags/%-*s} ", dp->s_flags, np->flags);
if (f_label)
xo_emit("{t:label/%-*s} ", dp->s_label, np->label);
if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode))
printdev(dp->s_size, sp->st_rdev);
else
printsize("size", dp->s_size, sp->st_size);
if (f_accesstime)
printtime("access-time", sp->st_atime);
else if (f_birthtime)
printtime("birth-time", sp->st_birthtime);
else if (f_statustime)
printtime("change-time", sp->st_ctime);
else
printtime("modify-time", sp->st_mtime);
#ifdef COLORLS
if (f_color)
color_printed = colortype(sp->st_mode);
#endif
if (name) {
xo_emit("{dk:name/%hs}", name);
free(name);
}
#ifdef COLORLS
if (f_color && color_printed)
endcolor(0);
#endif
if (f_type)
(void)printtype(sp->st_mode);
if (S_ISLNK(sp->st_mode))
printlink(p);
xo_close_instance("entry");
xo_emit("\n");
}
xo_close_list("entry");
}
void
printlong(DISPLAY *dp)
{
struct stat *sp;
FTSENT *p;
NAMES *np;
char buf[20], szbuf[5];
now = time(NULL);
if (!f_leafonly)
printtotal(dp); /* "total: %u\n" */
for (p = dp->list; p; p = p->fts_link) {
if (IS_NOPRINT(p))
continue;
sp = p->fts_statp;
if (f_inode)
(void)printf("%*"PRIu64" ", dp->s_inode, sp->st_ino);
if (f_size) {
if (f_humanize) {
if ((humanize_number(szbuf, sizeof(szbuf),
sp->st_blocks * S_BLKSIZE,
"", HN_AUTOSCALE,
(HN_DECIMAL | HN_B | HN_NOSPACE))) == -1)
err(1, "humanize_number");
(void)printf("%*s ", dp->s_block, szbuf);
} else {
(void)printf(f_commas ? "%'*llu " : "%*llu ",
dp->s_block,
(unsigned long long)howmany(sp->st_blocks,
blocksize));
}
}
(void)strmode(sp->st_mode, buf);
np = p->fts_pointer;
(void)printf("%s %*lu ", buf, dp->s_nlink,
(unsigned long)sp->st_nlink);
if (!f_grouponly)
(void)printf("%-*s ", dp->s_user, np->user);
(void)printf("%-*s ", dp->s_group, np->group);
if (f_flags)
(void)printf("%-*s ", dp->s_flags, np->flags);
if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode))
(void)printf("%*lld, %*lld ",
dp->s_major, (long long)major(sp->st_rdev),
dp->s_minor, (long long)minor(sp->st_rdev));
else
if (f_humanize) {
if ((humanize_number(szbuf, sizeof(szbuf),
sp->st_size, "", HN_AUTOSCALE,
(HN_DECIMAL | HN_B | HN_NOSPACE))) == -1)
err(1, "humanize_number");
(void)printf("%*s ", dp->s_size, szbuf);
} else {
(void)printf(f_commas ? "%'*llu " : "%*llu ",
dp->s_size, (unsigned long long)
sp->st_size);
}
if (f_accesstime)
printtime(sp->st_atime);
else if (f_statustime)
printtime(sp->st_ctime);
else
printtime(sp->st_mtime);
if (f_octal || f_octal_escape)
(void)safe_printpath(p);
else if (f_nonprint)
(void)printescapedpath(p);
else
(void)printpath(p);
if (f_type || (f_typedir && S_ISDIR(sp->st_mode)))
(void)printtype(sp->st_mode);
if (S_ISLNK(sp->st_mode))
printlink(p);
(void)putchar('\n');
}
}
void
printlong(const DISPLAY *dp)
{
struct stat *sp;
FTSENT *p;
NAMES *np;
char buf[20];
#ifdef COLORLS
int color_printed = 0;
#endif
if ((dp->list == NULL || dp->list->fts_level != FTS_ROOTLEVEL) &&
(f_longform || f_size)) {
(void)printf("total %lu\n", howmany(dp->btotal, blocksize));
}
for (p = dp->list; p; p = p->fts_link) {
if (IS_NOPRINT(p))
continue;
sp = p->fts_statp;
if (f_inode)
(void)printf("%*lu ", dp->s_inode, (u_long)sp->st_ino);
if (f_size)
(void)printf("%*jd ",
dp->s_block, howmany(sp->st_blocks, blocksize));
strmode(sp->st_mode, buf);
aclmode(buf, p);
np = p->fts_pointer;
(void)printf("%s %*u %-*s %-*s ", buf, dp->s_nlink,
sp->st_nlink, dp->s_user, np->user, dp->s_group,
np->group);
if (f_flags)
(void)printf("%-*s ", dp->s_flags, np->flags);
if (f_label)
(void)printf("%-*s ", dp->s_label, np->label);
if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode))
printdev(dp->s_size, sp->st_rdev);
else
printsize(dp->s_size, sp->st_size);
if (f_accesstime)
printtime(sp->st_atime);
else if (f_birthtime)
printtime(sp->st_birthtime);
else if (f_statustime)
printtime(sp->st_ctime);
else
printtime(sp->st_mtime);
#ifdef COLORLS
if (f_color)
color_printed = colortype(sp->st_mode);
#endif
(void)printname(p->fts_name);
#ifdef COLORLS
if (f_color && color_printed)
endcolor(0);
#endif
if (f_type)
(void)printtype(sp->st_mode);
if (S_ISLNK(sp->st_mode))
printlink(p);
(void)putchar('\n');
}
}
void initializeTypeArray()
{
int i;
dwarf_entry * cur_entry;
struct genhashtable * ght=genallocatehashtable((unsigned int (*)(void *)) & hashstring,(int (*)(void *,void *)) &equivalentstrings);
struct genhashtable * sht=NULL;
if (rootfile!=NULL) {
char buf[512];
char a;
int fd=open(rootfile,O_RDONLY);
int offset=0;
sht=genallocatehashtable((unsigned int (*)(void *)) & hashstring,(int (*)(void *,void *)) &equivalentstrings);
while(1) {
if (read(fd,&a,1)>0) {
if (a!=13&&a!=10)
buf[offset++]=a;
} else
break;
if (offset>0&&(a==13||a==10)) {
buf[offset++]=0;
{
char *str=copystr(buf);
genputtable(sht,str,str);
}
offset=0;
}
}
}
if (arrayfile!=NULL) {
char buf[512];
char sizebuf[512];
char a;
int fd=open(arrayfile,O_RDONLY);
int offset=0;
int readmore=1;
int state=0;
arrayt=genallocatehashtable((unsigned int (*)(void *)) & hashstring,(int (*)(void *,void *)) &equivalentstrings);
arraytype=genallocatehashtable((unsigned int (*)(void *)) & hashstring,(int (*)(void *,void *)) &equivalentstrings);
while(readmore) {
if (read(fd,&a,1)<=0)
readmore=0;
if (readmore) {
if (a==' ') {
state=1;
buf[offset]=0;
offset=0;
} else if (a!=13&&a!=10) {
if (state==0)
buf[offset++]=a;
else
sizebuf[offset++]=a;
}
}
if ((state==1)&&offset>0&&(a==13||a==10||!readmore)) {
state=0;
sizebuf[offset]=0;
{
char *str=copystr(buf);
char *sizestr=copystr(sizebuf);
genputtable(arrayt,str,sizestr);
}
offset=0;
}
}
}
/* Assign names */
for (i = 0; i < dwarf_entry_array_size; i++)
{
cur_entry = &dwarf_entry_array[i];
if (entry_is_type(cur_entry))
{
collection_type* collection_ptr = (collection_type*)(cur_entry->entry_ptr);
int j=0;
int offset=0;
int value=0;
for(j=0;j<collection_ptr->num_members;j++) {
dwarf_entry *entry=collection_ptr->members[j];
if (entry->tag_name==DW_TAG_inheritance) {
value++;
} else {
member * member_ptr=(member *)entry->entry_ptr;
char *name=member_ptr->name;
dwarf_entry *type=member_ptr->type_ptr;
char *typestr=printname(type,GETTYPE);
char *poststr=printname(type,POSTNAME);
if (typestr!=NULL)
value++;
}
}
}
}
for (i = 0; i < dwarf_entry_array_size; i++)
{
cur_entry = &dwarf_entry_array[i];
if (entry_is_type(cur_entry))
{
collection_type* collection_ptr = (collection_type*)(cur_entry->entry_ptr);
int j=0;
int offset=0;
int value=0;
for(j=0;j<collection_ptr->num_members;j++) {
dwarf_entry *entry=collection_ptr->members[j];
if (entry->tag_name==DW_TAG_inheritance) {
value++;
} else {
member * member_ptr=(member *)entry->entry_ptr;
char *name=member_ptr->name;
dwarf_entry *type=member_ptr->type_ptr;
char *typestr=printname(type,GETTYPE);
char *poststr=printname(type,POSTNAME);
if (typestr!=NULL)
value++;
}
}
if (collection_ptr->name!=NULL) {
struct valuepair *vp=NULL;
if (gencontains(ght,collection_ptr->name))
vp=(struct valuepair *)gengettable(ght,collection_ptr->name);
if (vp==NULL||vp->value<value) {
if (vp==NULL) {
vp=(struct valuepair*)calloc(1,sizeof(struct valuepair));
genputtable(ght,collection_ptr->name,vp);
}
vp->value=value;
vp->index=i;
}
}
}
}
assigntype=1;
if (sht!=NULL) {
int repeat=1;
while(repeat) {
repeat=0;
for (i = 0; i < dwarf_entry_array_size; i++) {
cur_entry = &dwarf_entry_array[i];
if (entry_is_type(cur_entry)) {
collection_type* collection_ptr = (collection_type*)(cur_entry->entry_ptr);
int j=0;
int offset=0;
int value=0;
if (!gencontains(sht,collection_ptr->name))
continue;
if (gencontains(ght,collection_ptr->name)) {
struct valuepair *vp=(struct valuepair*)gengettable(ght,collection_ptr->name);
if (vp->index!=i)
continue;
}
for(j=0;j<collection_ptr->num_members;j++) {
dwarf_entry *entry=collection_ptr->members[j];
if (entry->tag_name==DW_TAG_inheritance) {
inherit *in_ptr=(inherit*)collection_ptr->members[j]->entry_ptr;
dwarf_entry *typeptr=in_ptr->target_ptr;
collection_type* sub_ptr = (collection_type*)(typeptr->entry_ptr);
if (!gencontains(sht,sub_ptr->name)) {
repeat=1;
genputtable(sht,sub_ptr->name,sub_ptr->name);
}
} else {
member * member_ptr=(member *)entry->entry_ptr;
char *name=member_ptr->name;
dwarf_entry *type=member_ptr->type_ptr;
char *typestr=printname(type,GETJUSTTYPE);
if (typestr!=NULL&&!gencontains(sht,typestr)) {
repeat=1;
genputtable(sht,typestr,typestr);
}
}
}
}
}
}
}
for (i = 0; i < dwarf_entry_array_size; i++)
{
cur_entry = &dwarf_entry_array[i];
if (entry_is_type(cur_entry))
{
collection_type* collection_ptr = (collection_type*)(cur_entry->entry_ptr);
int j=0;
int offset=0;
if (collection_ptr->name==NULL)
continue;
if (sht!=NULL&&!gencontains(sht,collection_ptr->name))
continue;
if (gencontains(ght,collection_ptr->name)) {
struct valuepair *vp=(struct valuepair*)gengettable(ght,collection_ptr->name);
if (vp->index!=i)
continue;
}
j=0;
printf("structure %s ",collection_ptr->name);
while(j<collection_ptr->num_members&&
collection_ptr->members[j]->tag_name==DW_TAG_inheritance) {
inherit *in_ptr=(inherit*)collection_ptr->members[j]->entry_ptr;
dwarf_entry *typeptr=in_ptr->target_ptr;
collection_type* sub_ptr = (collection_type*)(typeptr->entry_ptr);
if (j==0)
printf("subclass of ");
else
printf(", ");
printf("%s ",sub_ptr->name);
j++;
}
printf("{ \n");
for(j=0;j<collection_ptr->num_members;j++) {
dwarf_entry *entry=collection_ptr->members[j];
if (entry->tag_name==DW_TAG_inheritance) {
inherit * inherit_ptr=(inherit *)entry->entry_ptr;
if (inherit_ptr->data_member_location>offset) {
printf(" reserved byte[%ld];\n",inherit_ptr->data_member_location-offset);
offset=inherit_ptr->data_member_location;
}
{
dwarf_entry *type=inherit_ptr->target_ptr;
collection_type *c_ptr=(collection_type*)type->entry_ptr;
offset+=printtype(c_ptr,ght);
}
} else {
member * member_ptr=(member *)entry->entry_ptr;
char *name=member_ptr->name;
dwarf_entry *type=member_ptr->type_ptr;
char *typestr=printname(type,GETTYPE);
char *poststr=printname(type,POSTNAME);
char *newname=NULL;
if (member_ptr->data_member_location>offset) {
printf(" reserved byte[%ld];\n",member_ptr->data_member_location-offset);
offset=member_ptr->data_member_location;
}
offset+=getsize(type);
newname=escapestr(name);
{
char buf[512];
char *dtype;
sprintf(buf, "%s.%s\0", collection_ptr->name,newname);
if (arrayt!=NULL&&gencontains(arrayt, &buf)) {
genputtable(arraytype, copystr(buf), typestr);
dtype=deref(typestr);
printf(" %s_array * %s%s;\n",dtype,newname,poststr);
free(dtype);
} else
printf(" %s %s%s;\n",typestr,newname,poststr);
}
free(newname);
}
}
if (offset<collection_ptr->byte_size)
printf(" reserved byte[%ld];\n",collection_ptr->byte_size-offset);
printf("}\n\n");
}
}
if (arrayt!=NULL) {
struct geniterator * gi=gengetiterator(arrayt);
while(1) {
char * str=(char *)gennext(gi);
char *size=NULL;
char *typestr=NULL;
if (str==NULL)
break;
size=(char *)gengettable(arrayt,str);
typestr=deref((char *)gengettable(arraytype,str));
printf("structure %s_array {\n",typestr);
printf(" %s elem[%s];\n",typestr,size);
printf("}\n");
free(typestr);
}
genfreeiterator(gi);
}
}
/*
* fd references a file which has been authorized & checked for relocations.
* send back the headers & its contents.
* includes checks for conditional requests & ranges.
*/
int
sendfd(HConnect *c, int fd, Dir *dir, HContent *type, HContent *enc)
{
Qid qid;
HRange *r;
HContents conts;
Hio *hout;
char *boundary, etag[32];
long mtime;
ulong tr;
int n, nw, multir, ok;
vlong wrote, length;
hout = &c->hout;
length = dir->length;
mtime = dir->mtime;
qid = dir->qid;
free(dir);
/*
* figure out the type of file and send headers
*/
n = -1;
r = nil;
multir = 0;
boundary = nil;
if(c->req.vermaj){
if(type == nil && enc == nil){
conts = uriclass(c, c->req.uri);
type = conts.type;
enc = conts.encoding;
if(type == nil && enc == nil){
n = read(fd, c->xferbuf, HBufSize-1);
if(n > 0){
c->xferbuf[n] = '\0';
conts = dataclass(c, c->xferbuf, n);
type = conts.type;
enc = conts.encoding;
}
}
}
if(type == nil)
type = hmkcontent(c, "application", "octet-stream", nil);
snprint(etag, sizeof(etag), "\"%lluxv%lux\"", qid.path, qid.vers);
ok = checkreq(c, type, enc, mtime, etag);
if(ok <= 0){
close(fd);
return ok;
}
/*
* check for if-range requests
*/
if(c->head.range == nil
|| c->head.ifrangeetag != nil && !etagmatch(1, c->head.ifrangeetag, etag)
|| c->head.ifrangedate != 0 && c->head.ifrangedate != mtime){
c->head.range = nil;
c->head.ifrangeetag = nil;
c->head.ifrangedate = 0;
}
if(c->head.range != nil){
c->head.range = fixrange(c->head.range, length);
if(c->head.range == nil){
if(c->head.ifrangeetag == nil && c->head.ifrangedate == 0){
hprint(hout, "%s 416 Request range not satisfiable\r\n", hversion);
hprint(hout, "Date: %D\r\n", time(nil));
hprint(hout, "Server: Plan9\r\n");
hprint(hout, "Content-Range: bytes */%lld\r\n", length);
hprint(hout, "Content-Length: %d\r\n", STRLEN(BADRANGE));
hprint(hout, "Content-Type: text/html\r\n");
if(c->head.closeit)
hprint(hout, "Connection: close\r\n");
else if(!http11(c))
hprint(hout, "Connection: Keep-Alive\r\n");
hprint(hout, "\r\n");
if(strcmp(c->req.meth, "HEAD") != 0)
hprint(hout, "%s", BADRANGE);
hflush(hout);
writelog(c, "Reply: 416 Request range not satisfiable\n");
close(fd);
return 1;
}
c->head.ifrangeetag = nil;
c->head.ifrangedate = 0;
}
}
if(c->head.range == nil)
hprint(hout, "%s 200 OK\r\n", hversion);
else
hprint(hout, "%s 206 Partial Content\r\n", hversion);
hprint(hout, "Server: Plan9\r\n");
hprint(hout, "Date: %D\r\n", time(nil));
hprint(hout, "ETag: %s\r\n", etag);
/*
* can't send some entity headers if partially responding
* to an if-range: etag request
*/
r = c->head.range;
if(r == nil)
hprint(hout, "Content-Length: %lld\r\n", length);
else if(r->next == nil){
hprint(hout, "Content-Range: bytes %ld-%ld/%lld\r\n", r->start, r->stop, length);
hprint(hout, "Content-Length: %ld\r\n", r->stop - r->start);
}else{
multir = 1;
boundary = hmkmimeboundary(c);
hprint(hout, "Content-Type: multipart/byteranges; boundary=%s\r\n", boundary);
}
if(c->head.ifrangeetag == nil){
hprint(hout, "Last-Modified: %D\r\n", mtime);
if(!multir)
printtype(hout, type, enc);
if(c->head.fresh_thresh)
hintprint(c, hout, c->req.uri, c->head.fresh_thresh, c->head.fresh_have);
}
if(c->head.closeit)
hprint(hout, "Connection: close\r\n");
else if(!http11(c))
hprint(hout, "Connection: Keep-Alive\r\n");
hprint(hout, "\r\n");
}
if(strcmp(c->req.meth, "HEAD") == 0){
if(c->head.range == nil)
writelog(c, "Reply: 200 file 0\n");
else
writelog(c, "Reply: 206 file 0\n");
hflush(hout);
close(fd);
return 1;
}
/*
* send the file if it's a normal file
*/
if(r == nil){
hflush(hout);
wrote = 0;
if(n > 0)
wrote = write(hout->fd, c->xferbuf, n);
if(n <= 0 || wrote == n){
while((n = read(fd, c->xferbuf, HBufSize)) > 0){
nw = write(hout->fd, c->xferbuf, n);
if(nw != n){
if(nw > 0)
wrote += nw;
break;
}
wrote += nw;
}
}
writelog(c, "Reply: 200 file %lld %lld\n", length, wrote);
close(fd);
if(length == wrote)
return 1;
return -1;
}
/*
* for multipart/byterange messages,
* it is not ok for the boundary string to appear within a message part.
* however, it probably doesn't matter, since there are lengths for every part.
*/
wrote = 0;
ok = 1;
for(; r != nil; r = r->next){
if(multir){
hprint(hout, "\r\n--%s\r\n", boundary);
printtype(hout, type, enc);
hprint(hout, "Content-Range: bytes %ld-%ld/%lld\r\n", r->start, r->stop, length);
hprint(hout, "Content-Length: %ld\r\n", r->stop - r->start);
hprint(hout, "\r\n");
}
hflush(hout);
if(seek(fd, r->start, 0) != r->start){
ok = -1;
break;
}
for(tr = r->stop - r->start + 1; tr; tr -= n){
n = tr;
if(n > HBufSize)
n = HBufSize;
if(read(fd, c->xferbuf, n) != n){
ok = -1;
goto breakout;
}
nw = write(hout->fd, c->xferbuf, n);
if(nw != n){
if(nw > 0)
wrote += nw;
ok = -1;
goto breakout;
}
wrote += nw;
}
}
breakout:;
if(r == nil){
if(multir){
hprint(hout, "--%s--\r\n", boundary);
hflush(hout);
}
writelog(c, "Reply: 206 partial content %lld %lld\n", length, wrote);
}else
writelog(c, "Reply: 206 partial content, early termination %lld %lld\n", length, wrote);
close(fd);
return ok;
}
