/* process arguments */
void
process_args(int argc, char *argv[])
{
int c = 0;
boolean usage_error = FALSE;
program_name = argv[0];
while ((c = dwgetopt(argc, argv, "i:o:se")) != EOF) {
switch (c) {
case 'i':
input_name = optarg;
break;
case 'o':
output_name = optarg;
break;
case 'e':
extended_flag = TRUE;
break;
case 's':
standard_flag = TRUE;
break;
default:
usage_error = TRUE;
break;
}
}
if (usage_error || 1 == optind || optind != argc) {
print_usage_message(argv[0],usage);
exit(FAILED);
}
}
/* process arguments */
static void
process_args(int argc, char *argv[])
{
int c = 0;
boolean usage_error = FALSE;
program_name = argv[0];
while ((c = dwgetopt(argc, argv, "i:o:st")) != EOF) {
switch (c) {
case 'i':
input_name = dwoptarg;
break;
case 'o':
output_name = dwoptarg;
break;
case 's':
use_switch = TRUE;
use_tables = FALSE;
break;
case 't':
use_switch = FALSE;
use_tables = TRUE;
break;
default:
usage_error = TRUE;
break;
}
}
if (usage_error || 1 == dwoptind || dwoptind != argc) {
print_usage_message(usage);
exit(FAILED);
}
}
int
main(int argc, char **argv)
{
unsigned u = 0;
unsigned int num = 0;
int input_eof = 0;
unsigned table_rows = 0;
unsigned table_columns = 0;
unsigned current_row = 0;
FILE * fileInp = 0;
FILE * fileOut = 0;
const char *aname = 0;
unsigned int index = 0;
print_version_details(argv[0],FALSE);
process_args(argc,argv);
print_args(argc,argv);
if (!input_name ) {
fprintf(stderr,"Input name required, not supplied.\n");
print_usage_message(argv[0],usage);
exit(FAILED);
}
fileInp = fopen(input_name,"r");
if (!fileInp) {
fprintf(stderr,"Invalid input filename, could not open '%s'\n",
input_name);
print_usage_message(argv[0],usage);
exit(FAILED);
}
if (!output_name ) {
fprintf(stderr,"Output name required, not supplied.\n");
print_usage_message(argv[0],usage);
exit(FAILED);
}
fileOut = fopen(output_name,"w");
if (!fileOut) {
fprintf(stderr,"Invalid output filename, could not open: '%s'\n",
output_name);
print_usage_message(argv[0],usage);
exit(FAILED);
}
if ((standard_flag && extended_flag) ||
(!standard_flag && !extended_flag)) {
fprintf(stderr,"Invalid table type\n");
fprintf(stderr,"Choose -e or -s .\n");
print_usage_message(argv[0],usage);
exit(FAILED);
}
if (standard_flag) {
table_rows = STD_ATTR_TABLE_ROWS;
table_columns = STD_ATTR_TABLE_COLUMNS;
} else {
table_rows = EXT_ATTR_TABLE_ROWS;
table_columns = EXT_ATTR_TABLE_COLS;
}
input_eof = read_value(&num,fileInp); /* 0xffffffff */
if (IS_EOF == input_eof) {
bad_line_input("Empty input file");
}
if (num != MAGIC_TOKEN_VALUE) {
bad_line_input("Expected 0xffffffff");
}
/* Generate main header, regardless of contents */
fprintf(fileOut,"/* Generated code, do not edit. */\n");
fprintf(fileOut,"/* Generated on %s %s */\n",__DATE__,__TIME__);
fprintf(fileOut,"\n/* BEGIN FILE */\n\n");
#ifdef HAVE_USAGE_TAG_ATTR
/* Generate the data type to record the usage of the pairs tag-attr */
if (standard_flag) {
fprintf(fileOut,"#ifndef HAVE_USAGE_TAG_ATTR\n");
fprintf(fileOut,"#define HAVE_USAGE_TAG_ATTR 1\n");
fprintf(fileOut,"#endif /* HAVE_USAGE_TAG_ATTR */\n\n");
fprintf(fileOut,"#ifdef HAVE_USAGE_TAG_ATTR\n");
fprintf(fileOut,"#include \"dwarf.h\"\n");
fprintf(fileOut,"#include \"libdwarf.h\"\n\n");
fprintf(fileOut,"typedef struct {\n");
fprintf(fileOut," unsigned int count; /* Attribute count */\n");
fprintf(fileOut," Dwarf_Half attr; /* Attribute value */\n");
fprintf(fileOut,"} Usage_Tag_Attr;\n\n");
}
#endif /* HAVE_USAGE_TAG_ATTR */
while (!feof(stdin)) {
unsigned int tag;
unsigned int curcol = 0;
unsigned int cur_attr = 0;
unsigned int attr;
input_eof = read_value(&tag,fileInp);
if (IS_EOF == input_eof) {
/* Reached normal eof */
break;
}
if (standard_flag) {
if (tag >= table_rows ) {
bad_line_input("tag %d exceeds standard table size",tag);
}
} else {
if (current_row >= table_rows) {
bad_line_input("too many extended table rows.");
}
tag_attr_combination_table[current_row][0] = tag;
}
input_eof = read_value(&num,fileInp);
if (IS_EOF == input_eof) {
bad_line_input("Not terminated correctly..");
}
curcol = 1;
cur_attr = 1;
#ifdef HAVE_USAGE_TAG_ATTR
/* Check if we have duplicated tags */
if (standard_flag) {
if (tag_parents[tag]) {
bad_line_input("tag 0x%02x value already defined",tag);
}
tag_parents[tag] = tag;
/* Clear out the working attribute vector */
memset(tag_attr_vector,0,DW_AT_last * sizeof(Dwarf_Half));
}
#endif /* HAVE_USAGE_TAG_ATTR */
while (num != MAGIC_TOKEN_VALUE) {
if (standard_flag) {
unsigned idx = num / BITS_PER_WORD;
unsigned bit = num % BITS_PER_WORD;
if (idx >= table_columns) {
char msg[200];
snprintf(msg, sizeof(msg),
"too many attributes a: table incomplete "
"index %d cols %d.",idx,table_columns);
bad_line_input(msg);
}
tag_attr_combination_table[tag][idx] |= (1 << bit);
} else {
if (curcol >= table_columns) {
char msg[200];
snprintf(msg, sizeof(msg),
"too many attributes b: table incomplete "
"index %d cols %d.",curcol,table_columns);
bad_line_input(msg);
}
tag_attr_combination_table[current_row][curcol] = num;
curcol++;
}
#ifdef HAVE_USAGE_TAG_ATTR
/* Record the usage only for standard tables */
if (standard_flag) {
/* Add attribute to current tag */
if (cur_attr >= DW_AT_last) {
char msg[200];
snprintf(msg, sizeof(msg),
"too many attributes c: table incomplete "
"index %d cols %d.",cur_attr,DW_AT_last);
bad_line_input(msg);
}
/* Check for duplicated entries */
if (tag_attr_vector[cur_attr]) {
bad_line_input("duplicated attributes: table incomplete.");
}
tag_attr_vector[cur_attr] = num;
cur_attr++;
}
#endif /* HAVE_USAGE_TAG_ATTR */
input_eof = read_value(&num,fileInp);
if (IS_EOF == input_eof) {
bad_line_input("Not terminated correctly.");
}
}
#ifdef HAVE_USAGE_TAG_ATTR
/* Generate the tag-attributes vector for current tag */
if (standard_flag) {
if (tag >= DW_TAG_last) {
bad_line_input("tag 0x%02x exceeds standard table size",tag);
}
if (tag_children[tag]) {
bad_line_input("tag 0x%02x already defined",tag);
}
tag_children[tag] = tag;
/* Generate reference vector */
aname = 0;
dwarf_get_TAG_name(tag,&aname);
fprintf(fileOut,"/* 0x%02x - %s */\n",tag,aname);
fprintf(fileOut,
"static Usage_Tag_Attr tag_attr_%02x[] = {\n",tag);
for (index = 1; index < cur_attr; ++index) {
attr = tag_attr_vector[index];
dwarf_get_AT_name(attr,&aname);
fprintf(fileOut," {/* 0x%02x */ 0, %s},\n",attr,aname);
}
fprintf(fileOut," {/* %4s */ 0, 0}\n};\n\n"," ");
/* Record allowed number of attributes */
tag_attr_legal[tag] = cur_attr - 1;
}
#endif /* HAVE_USAGE_TAG_ATTR */
++current_row;
}
#ifdef HAVE_USAGE_TAG_ATTR
/* Generate the parent of the individual vectors */
if (standard_flag) {
unsigned int tag;
unsigned int legal;
fprintf(fileOut,
"static Usage_Tag_Attr *usage_tag_attr[] = {\n");
for (index = 0; index < DW_TAG_last; ++index) {
tag = tag_children[index];
if (tag) {
aname = 0;
dwarf_get_TAG_name(tag,&aname);
fprintf(fileOut,
" tag_attr_%02x, /* 0x%02x - %s */\n",tag,tag,aname);
} else {
fprintf(fileOut," 0,\n");
}
}
fprintf(fileOut," 0\n};\n\n");
/* Generate table with allowed number of attributes */
fprintf(fileOut,"typedef struct {\n");
fprintf(fileOut," Dwarf_Small legal; /* Legal attributes */\n");
fprintf(fileOut," Dwarf_Small found; /* Found attributes */\n");
fprintf(fileOut,"} Rate_Tag_Attr;\n\n");
fprintf(fileOut,
"static Rate_Tag_Attr rate_tag_attr[] = {\n");
for (tag = 0; tag < DW_TAG_last; ++tag) {
if (tag_children[tag]) {
legal = tag_attr_legal[tag];
aname = 0;
dwarf_get_TAG_name(tag,&aname);
fprintf(fileOut,
" {%2d, 0, /* 0x%02x - %s */},\n",legal,tag,aname);
} else {
fprintf(fileOut," {0, 0},\n");
}
}
fprintf(fileOut," {0, 0}\n};\n\n");
fprintf(fileOut,"#endif /* HAVE_USAGE_TAG_ATTR */\n\n");
}
#endif /* HAVE_USAGE_TAG_ATTR */
if (standard_flag) {
fprintf(fileOut,"#define ATTR_TREE_ROW_COUNT %d\n\n",table_rows);
fprintf(fileOut,"#define ATTR_TREE_COLUMN_COUNT %d\n\n",table_columns);
fprintf(fileOut,
"static unsigned int tag_attr_combination_table"
"[ATTR_TREE_ROW_COUNT][ATTR_TREE_COLUMN_COUNT] = {\n");
}
else {
fprintf(fileOut,"/* Common extensions */\n");
fprintf(fileOut,"#define ATTR_TREE_EXT_ROW_COUNT %d\n\n",table_rows);
fprintf(fileOut,"#define ATTR_TREE_EXT_COLUMN_COUNT %d\n\n",
table_columns);
fprintf(fileOut,
"static unsigned int tag_attr_combination_ext_table"
"[ATTR_TREE_EXT_ROW_COUNT][ATTR_TREE_EXT_COLUMN_COUNT] = {\n");
}
for (u = 0; u < table_rows; u++) {
unsigned j = 0;
const char *name = 0;
if (standard_flag) {
dwarf_get_TAG_name(u,&name);
fprintf(fileOut,"/* 0x%02x - %-37s*/\n",u,name);
} else {
unsigned k = tag_attr_combination_table[u][0];
dwarf_get_TAG_name(k,&name);
fprintf(fileOut,"/* 0x%02x - %-37s*/\n",k,name);
}
fprintf(fileOut," { ");
for (j = 0; j < table_columns; ++j ) {
fprintf(fileOut,"0x%08x,",tag_attr_combination_table[u][j]);
}
fprintf(fileOut,"},\n");
}
fprintf(fileOut,"};\n");
fprintf(fileOut,"\n/* END FILE */\n");
fclose(fileInp);
fclose(fileOut);
return (0);
}
int
main(int argc, char **argv)
{
unsigned u = 0;
unsigned int num = 0;
int input_eof = 0;
unsigned table_rows = 0;
unsigned table_columns = 0;
unsigned current_row = 0;
FILE * fileInp = 0;
FILE * fileOut = 0;
print_version_details(argv[0],FALSE);
process_args(argc,argv);
print_args(argc,argv);
if (!input_name ) {
fprintf(stderr,"Input name required, not supplied.\n");
print_usage_message(argv[0],usage);
exit(FAILED);
}
fileInp = fopen(input_name,"r");
if (!fileInp) {
fprintf(stderr,"Invalid input filename, could not open '%s'\n",
input_name);
print_usage_message(argv[0],usage);
exit(FAILED);
}
if (!output_name ) {
fprintf(stderr,"Output name required, not supplied.\n");
print_usage_message(argv[0],usage);
exit(FAILED);
}
fileOut = fopen(output_name,"w");
if (!fileOut) {
fprintf(stderr,"Invalid output filename, could not open: '%s'\n",
output_name);
print_usage_message(argv[0],usage);
exit(FAILED);
}
if ((standard_flag && extended_flag) ||
(!standard_flag && !extended_flag)) {
fprintf(stderr,"Invalid table type\n");
fprintf(stderr,"Choose -e or -s .\n");
print_usage_message(argv[0],usage);
exit(FAILED);
}
if (standard_flag) {
table_rows = STD_ATTR_TABLE_ROWS;
table_columns = STD_ATTR_TABLE_COLUMNS;
} else {
table_rows = EXT_ATTR_TABLE_ROWS;
table_columns = EXT_ATTR_TABLE_COLS;
}
input_eof = read_value(&num,fileInp); /* 0xffffffff */
if (IS_EOF == input_eof) {
bad_line_input("Empty input file");
}
if (num != MAGIC_TOKEN_VALUE) {
bad_line_input("Expected 0xffffffff");
}
while (!feof(stdin)) {
unsigned int tag;
unsigned int curcol = 0;
input_eof = read_value(&tag,fileInp);
if (IS_EOF == input_eof) {
/* Reached normal eof */
break;
}
if (standard_flag) {
if (tag >= table_rows ) {
bad_line_input("tag value exceeds standard table size");
}
} else {
if (current_row >= table_rows) {
bad_line_input("too many extended table rows.");
}
tag_attr_combination_table[current_row][0] = tag;
}
input_eof = read_value(&num,fileInp);
if (IS_EOF == input_eof) {
bad_line_input("Not terminated correctly..");
}
curcol = 1;
while (num != MAGIC_TOKEN_VALUE) {
if (standard_flag) {
unsigned idx = num / BITS_PER_WORD;
unsigned bit = num % BITS_PER_WORD;
if (idx >= table_columns) {
bad_line_input
("too many attributes: table incomplete.");
}
tag_attr_combination_table[tag][idx] |= (1 << bit);
} else {
if (curcol >= table_columns) {
bad_line_input("too many attributes: table incomplete.");
}
tag_attr_combination_table[current_row][curcol] = num;
curcol++;
}
input_eof = read_value(&num,fileInp);
if (IS_EOF == input_eof) {
bad_line_input("Not terminated correctly.");
}
}
++current_row;
}
fprintf(fileOut,"/* Generated code, do not edit. */\n");
fprintf(fileOut,"/* Generated on %s %s */\n",__DATE__,__TIME__);
fprintf(fileOut,"\n/* BEGIN FILE */\n\n");
if (standard_flag) {
fprintf(fileOut,"#define ATTR_TREE_ROW_COUNT %d\n\n",table_rows);
fprintf(fileOut,"#define ATTR_TREE_COLUMN_COUNT %d\n\n",table_columns);
fprintf(fileOut,
"static unsigned int tag_attr_combination_table"
"[ATTR_TREE_ROW_COUNT][ATTR_TREE_COLUMN_COUNT] = {\n");
}
else {
fprintf(fileOut,"/* Common extensions */\n");
fprintf(fileOut,"#define ATTR_TREE_EXT_ROW_COUNT %d\n\n",table_rows);
fprintf(fileOut,"#define ATTR_TREE_EXT_COLUMN_COUNT %d\n\n",
table_columns);
fprintf(fileOut,
"static unsigned int tag_attr_combination_ext_table"
"[ATTR_TREE_EXT_ROW_COUNT][ATTR_TREE_EXT_COLUMN_COUNT] = {\n");
}
for (u = 0; u < table_rows; u++) {
unsigned j = 0;
const char *name = 0;
if (standard_flag) {
dwarf_get_TAG_name(u,&name);
fprintf(fileOut,"/* %u %-37s*/\n",u,name);
} else {
unsigned k = tag_attr_combination_table[u][0];
dwarf_get_TAG_name(k,&name);
fprintf(fileOut,"/* %u %-37s*/\n",k,name);
}
fprintf(fileOut," { ");
for (j = 0; j < table_columns; ++j ) {
fprintf(fileOut,"0x%08x,",tag_attr_combination_table[u][j]);
}
fprintf(fileOut,"},\n");
}
fprintf(fileOut,"};\n");
fprintf(fileOut,"\n/* END FILE */\n");
fclose(fileInp);
fclose(fileOut);
return (0);
}
