void migrate_implicit(
void)
{
SYMBOL_ITER iter;
SYMBOL *isym,
*sym;
for (isym = first_sym(&implicit_st, &iter); isym != NULL; isym = next_sym(&implicit_st, &iter)) {
sym = lookup_sym(isym->label, &symbol_st);
if (sym) {
continue; // It's already in there. Great.
}
isym->flags |= SYMBOLFLAG_IMPLICIT_GLOBAL;
sym = add_sym(isym->label, isym->value, isym->flags, isym->section, &symbol_st);
// Just one other thing - migrate the stmtno
sym->stmtno = isym->stmtno;
}
}
static void Decl_Type(sym_pt parent, member_type parent_type){
sym_pt new_type;
member_type child_type = mt_priv;
match_token(T_TYPE);
add_sym(new_type);
// new_type->parent = parent;
// new_type->mtype = parent_type;
new_type->storage = sc_def;
if(Scanner::token() == T_TYPENAME) Type_specifier(new_type);
else{
Context_Stack::push(new_type);
if(Scanner::token() == T_ENUM){
Scanner::next_token();
}
else if(Scanner::token() == T_UNION){
Scanner::next_token();
}
else{
// a new_type definition
}
if(Scanner::token() == T_OBRC) Generic_parameters(new_type);
match_token(T_NL);
match_token(T_IND);
do{
if(Scanner::token() == T_PRIV) child_type = mt_priv;
else if(Scanner::token() == T_PUB) child_type = mt_pub;
else Field_declaration(new_type, child_type);
} while(Scanner::token() != T_OUTD);
match_token(T_OUTD);
// Their shouldn't be any instructions
//Optomize(Context_Stack::pop());
}
match_token(T_NL);
}
void implicit_gbl(
EX_TREE *value)
{
if (pass)
return; /* Only do this in first pass */
if (!enabl_gbl)
return; /* Option not enabled, don't do it. */
switch (value->type) {
case EX_UNDEFINED_SYM:
{
if (!(value->data.symbol->flags & SYMBOLFLAG_LOCAL)) { /* Unless it's a
local symbol, */
add_sym(value->data.symbol->label, 0, SYMBOLFLAG_GLOBAL, &absolute_section, &implicit_st);
}
}
break;
case EX_LIT:
case EX_SYM:
case EX_TEMP_SYM: // Impossible on this pass
return;
case EX_ADD:
case EX_SUB:
case EX_MUL:
case EX_DIV:
case EX_AND:
case EX_OR:
implicit_gbl(value->data.child.right);
/* falls into... */
case EX_COM:
case EX_NEG:
implicit_gbl(value->data.child.left);
break;
case EX_ERR:
if (value->data.child.left)
implicit_gbl(value->data.child.left);
break;
}
}
static void Initializer(sym_pt templt){
sym_pt initializer, instance;
add_sym(instance);
instance->type = templt->type;
instance->storage = templt->storage;
instance->qual = templt->qual;
//instance->parent = templt->parent;
//instance->mtype = templt->mtype;
Instantiate_auto_members(instance, templt);
if (Scanner::token() == T_ASS){ // Initialized value
Scanner::next_token();
if(instance->type == &Syms::none)
parse_error("Cannot initialize an undefined type");
initializer=Expression();
if (!initializer->set)
parse_error("Using an uninitialized value");
if (initializer->storage == sc_constant){
instance->value = initializer->value;
instance->init = true;
//Syms::remove(initializer->full_name());
}
else Context_Stack::emit_op(I_ASS, instance, initializer, NULL);
instance->set = true;
}
else if (instance->qual == q_ro)
parse_error("No initialization for a read only object");
}
void VM::bootstrap_symbol() {
#define add_sym(name) GO(sym_ ## name).set(symbol(#name))
add_sym(object_id);
add_sym(method_missing);
add_sym(inherited);
add_sym(from_literal);
add_sym(method_added);
add_sym(send);
add_sym(public);
add_sym(private);
add_sym(protected);
add_sym(undef);
add_sym(const_missing);
add_sym(object_id);
add_sym(call);
add_sym(coerce_into_array);
#undef add_sym
GO(sym_s_method_added).set(symbol("singleton_method_added"));
GO(sym_init_copy).set(symbol("initialize_copy"));
GO(sym_plus).set(symbol("+"));
GO(sym_minus).set(symbol("-"));
GO(sym_equal).set(symbol("=="));
GO(sym_nequal).set(symbol("!="));
GO(sym_tequal).set(symbol("==="));
GO(sym_lt).set(symbol("<"));
GO(sym_gt).set(symbol(">"));
}
int main()
{
int fname;
add_sym(fname); // Guarantee a symbol exists
}
int main(int argc, char *argv[])
{
int secva[16];
char *sec_name[16];
int sec_rlco[16];
int sec_rlcn[16];
char nbuf[16];
void *p, *q;
byte *buf;
FILE *fd;
char *s;
int sz, peoffs, coff_hdr, symoffs, nsyms;
int secoffs, nsecs, stroffs;
int i, j, k, l;
if(argc>1)
{
printf("open %s\n", argv[1]);
fd=fopen(argv[1], "rb");
}else
{
printf("open %s\n", argv[0]);
fd=fopen(argv[0], "rb");
}
if(!fd)
{
printf("fail open\n");
return(-1);
}
fseek(fd, 0, 2);
sz=ftell(fd);
fseek(fd, 0, 0);
buf=malloc(sz);
fread(buf, 1, sz, fd);
fclose(fd);
printf("EXE %d (0x%X) bytes\n", sz, sz);
coff_hdr=0;
if((buf[0]=='M') || (buf[1]=='Z'))
{
printf("EXE Sig\n");
peoffs=buf[0x3C]|(buf[0x3D]<<8)|(buf[0x3E]<<16)|(buf[0x3F]<<24);
if((buf[peoffs+0]!='P') || (buf[peoffs+1]!='E'))
{
printf("PE Sig Fail\n");
return(-1);
}
printf("PE Sig At 0x%X\n", peoffs);
coff_hdr=peoffs+4;
}
if((buf[coff_hdr+0]!=0x4C) || (buf[coff_hdr+1]!=0x01))
{
printf("COFF-i386 Sig Fail\n");
return(-1);
}
i=buf[coff_hdr+0]|(buf[coff_hdr+1]<<8);
printf("\tMachine 0x%04X\n", i);
symoffs=buf[coff_hdr+8]|(buf[coff_hdr+9]<<8)|
(buf[coff_hdr+10]<<16)|(buf[coff_hdr+11]<<24);
nsyms=buf[coff_hdr+12]|(buf[coff_hdr+13]<<8)|
(buf[coff_hdr+14]<<16)|(buf[coff_hdr+15]<<24);
printf("\tSyms 0x%X %d\n", symoffs, nsyms);
stroffs=symoffs+(nsyms*18);
i=buf[coff_hdr+16]|(buf[coff_hdr+17]<<8);
printf("Optional Header Size %d\n", i);
secoffs=coff_hdr+20+i;
nsecs=buf[coff_hdr+2]|(buf[coff_hdr+3]<<8);
printf("\tSecs 0x%X %d\n", secoffs, nsecs);
printf("\nSections:\n");
for(i=0; i<nsecs; i++)
{
j=secoffs+(i*40);
s=buf+j;
// k=buf[j+12]|(buf[j+13]<<8)|(buf[j+14]<<16)|(buf[j+15]<<24);
sec_name[i]=s;
secva[i]=k;
// printf("\t%d %s 0x%08X\n", i+1, s, k);
printf("\t%d %s\n", i+1, s);
l=buf[j+8]|(buf[j+9]<<8)|(buf[j+10]<<16)|(buf[j+11]<<24);
k=buf[j+12]|(buf[j+13]<<8)|(buf[j+14]<<16)|(buf[j+15]<<24);
printf("\t VA Addr 0x%08X %d\n", k, l);
l=buf[j+16]|(buf[j+17]<<8)|(buf[j+18]<<16)|(buf[j+19]<<24);
k=buf[j+20]|(buf[j+21]<<8)|(buf[j+22]<<16)|(buf[j+23]<<24);
printf("\t Img Offs 0x%08X %d\n", k, l);
k=buf[j+24]|(buf[j+25]<<8)|(buf[j+26]<<16)|(buf[j+27]<<24);
l=buf[j+32]|(buf[j+33]<<8);
printf("\t Reloc 0x%08X %d\n", k, l);
sec_rlco[i]=k;
sec_rlcn[i]=l;
k=buf[j+28]|(buf[j+29]<<8)|(buf[j+30]<<16)|(buf[j+31]<<24);
l=buf[j+34]|(buf[j+35]<<8);
printf("\t Line 0x%08X %d\n", k, l);
k=buf[j+36]|(buf[j+37]<<8)|(buf[j+38]<<16)|(buf[j+39]<<24);
printf("\t Flags 0x%08X\n", k);
}
i=4096;
while(i<nsyms)i=i+(i>>1);
basm_sym_name=malloc(i*sizeof(char *));
basm_sym_addr=malloc(i*sizeof(void *));
basm_sym_nsym=0;
basm_sym_msym=i;
printf("\nSymbols:\n");
for(i=0; i<nsyms; i++)
{
j=symoffs+(i*18);
if(buf[j])
{
memset(nbuf, 0, 16);
memcpy(nbuf, buf+j, 8);
s=nbuf;
}else
{
k=buf[j+4]|(buf[j+5]<<8)|(buf[j+6]<<16)|(buf[j+7]<<24);
s=buf+stroffs+k;
}
k=buf[j+8]|(buf[j+9]<<8)|(buf[j+10]<<16)|(buf[j+11]<<24);
l=buf[j+12]|(buf[j+13]<<8);
// if((l>0) && (l<=nsecs))k+=secva[l-1];
// if((*s=='.') || ((s[0]=='_') && (s[1]=='_')))
// {
// i+=buf[j+17];
// continue;
// }
printf("\t%s 0x%08X %d %d T: %d %d\n", s, k, l, buf[j+16],
buf[j+14], buf[j+15]);
add_sym(s, (void *)k);
// i+=buf[j+17];
}
p=fetch_sym("_main");
q=&main;
k=(int)(q-p);
printf("Displacement %X\n", k);
for(i=0; i<basm_sym_nsym; i++)
basm_sym_addr[i]+=k;
for(i=0; i<basm_sym_nsym; i++)
{
// printf("\t%s 0x%08X\n", basm_sym_name[i],
// basm_sym_addr[i]);
}
printf("\nSections:\n");
for(i=0; i<nsecs; i++)
{
printf("\t%d %s\n", i+1, sec_name[i]);
dump_relocs(buf, sec_rlco[i], sec_rlcn[i]);
}
return(0);
}
