void uclear() {
/*
*+
* Name:
* uclear
*
* Purpose:
* Clear the list of unoutput strings.
*
* Description:
* This routine reclaims the memory used by the list of unoutput
* strings and initialises the values of the start and end pointers.
*
* Authors:
* MBT: Mark Taylor (STARLINK)
*
* History:
* 10-DEC-1999 (MBT):
* Initial revision.
*-
*/
ELEMENT *i, *j;
/* Reclaim memory. */
i = ufirst->next;
while ( i != NULL ) {
j = i->next;
if ( i->text != NULL )
free( i->text );
free( i );
i = j;
}
/* Reset pointers. */
unew();
}
int main( int argc, char **argv ) {
/*
*+
* Name:
* main
*
* Purpose:
* Harness routine for calling the yacc-generated parser.
*
* Flags:
* -s
* If present, this enforces strict parsing; any parse errors lead
* to program termination. By default, parse errors are silently
* tolerated.
* -d
* Debugging. It may be followed immediately by the letters 'l',
* 'y' or both. This turns on the debugging messages in the lex
* part and/or the yacc part of the processor respectively.
* This will only work if lex and yacc have been compiled to
* enable debugging reports.
*
* Authors:
* MBT: Mark Taylor (STARLINK)
*
* History:
* 25-NOV-1999 (MBT):
* Original version.
*-
*/
/* Declare external function. */
int yyparse();
/* Declare local variables. */
int retval;
char *name, *usagef, *text;
char c;
/* Get name of program etc. */
name = *(argv++);
argc--;
usagef = "Usage: %s [-d[l][y]] [-s] [ in [ out ] ]\n";
/* Work through any command line flags. */
yy_flex_debug = 0;
yydebug = 0;
strict = 0;
while ( argc > 0 && **argv == '-' ) {
switch( *(++(*argv)) ) {
/* Debugging output flag. */
case 'd':
while ( c = *(++(*argv)) )
switch( c ) {
case 'l':
yy_flex_debug = 1;
break;
case 'y':
yydebug = 1;
break;
};
break;
/* Strict error handling flag. */
case 's':
strict = 1;
break;
/* Reply to any other flag (including -h) with a usage message. */
default:
printf( usagef, name );
exit( 1 );
}
argv++;
argc--;
}
/* Open standard input and output appropriately according to command line
arguments, in the normal filter-type way. */
switch( argc ) {
case 2:
if ( freopen( argv[ 1 ], "w", stdout ) == NULL ) {
perror( argv[ 1 ] );
exit( 1 );
}
case 1:
if ( freopen( argv[ 0 ], "r", stdin ) == NULL ) {
perror( argv[ 0 ] );
exit( 1 );
}
case 0:
break;
default:
printf( usagef, name );
exit( 1 );
}
/* Some initialisation. */
unew();
preleng = 0;
prealloc = 0;
preval = "";
/* Call the parser. */
retval = yyparse();
/* Some tidying. */
text = ucontent();
printf( "%s", text );
free( text );
uclear();
tagwrap();
/* Return. */
return( retval );
}
static int riva_load(module_t *Module, const char *FileName) {
riva_t *Riva = unew(riva_t); // This really should be new...
module_setup(Module, Riva, (module_importer)riva_import);
gzFile File = gzopen(FileName, "rb");
char *LoadPath;
for (int I = strlen(FileName) - 1; I >= 0; --I) {
if (FileName[I] == PATHCHR) {
strncpy(LoadPath = (char *)GC_malloc_atomic(I + 2), FileName, I + 1);
break;
};
};
module_set_path(Module, LoadPath);
uint32_t Magic; gzread(File, &Magic, 4);
if (Magic != 0x41564952) {
log_errorf("Error: %s is not a valid riva module\n", FileName);
return 0;
};
uint32_t NoOfSections; gzread(File, &NoOfSections, 4);
uint32_t NoOfExports; gzread(File, &NoOfExports, 4);
uint32_t NoOfRequires; gzread(File, &NoOfRequires, 4);
jmp_buf OnError[1];
if (setjmp(OnError)) return 0;
section_t **Sections = (Riva->Sections = (section_t **)GC_malloc(NoOfSections * sizeof(section_t *)));
for (int I = 0; I < NoOfSections; ++I) Sections[I] = new(section_t);
for (int I = 0; I < NoOfSections; ++I) {
section_t *Section = Sections[I];
uint8_t Type; gzread(File, &Type, 1);
switch (Type) {
case SECT_CODE: {
Section->Fixup = fixup_code_section;
gzread(File, &Section->Flags, 1);
uint32_t Length; gzread(File, &Length, 4);
uint32_t NoOfRelocs; gzread(File, &NoOfRelocs, 4);
Section->NoOfRelocs = NoOfRelocs;
reloc_t *Relocs = (Section->Relocs = (reloc_t *)GC_malloc_uncollectable(NoOfRelocs * sizeof(reloc_t)));
if (Section->Flags & FLAG_GC) {
Section->Data = GC_malloc_uncollectable(Length);
} else {
Section->Data = GC_malloc_atomic_uncollectable(Length);
};
gzread(File, Section->Data, Length);
for (int J = 0; J < NoOfRelocs; ++J) {
reloc_t *Reloc = &Relocs[J];
gzread(File, &Reloc->Size, 1);
gzread(File, &Reloc->Flags, 1);
gzread(File, &Reloc->Position, 4);
uint32_t Index; gzread(File, &Index, 4);
Reloc->Section = Sections[Index];
};
break;};
case SECT_LIBRARY: {
Section->Fixup = fixup_library_section;
gzread(File, &Section->Flags, 1);
uint32_t Length; gzread(File, &Length, 4);
gzread(File, Section->Name = (char *)GC_malloc_atomic(Length + 1), Length);
Section->Name[Length] = 0;
if (Section->Flags == LIBRARY_ABS) {
Section->Path = 0;
} else if (Section->Flags == LIBRARY_REL) {
Section->Path = LoadPath;
};
for (char *P = Section->Name; *P; ++P) if (*P == '/') *P = PATHCHR;
break;};
case SECT_IMPORT: {
Section->Fixup = fixup_import_section;
gzread(File, &Section->Flags, 1);
uint32_t Index; gzread(File, &Index, 4);
Section->Library = Sections[Index];
uint32_t Length; gzread(File, &Length, 4);
gzread(File, Section->Name = (char *)GC_malloc_atomic(Length + 1), Length);
Section->Name[Length] = 0;
break;};
case SECT_BSS: {
Section->Fixup = fixup_bss_section;
gzread(File, &Section->Flags, 1);
uint32_t Size; gzread(File, &Size, 4);
Section->Data = (uint8_t *)GC_malloc(Size);
break;};
case SECT_SYMBOL: {
Section->Fixup = fixup_symbol_section;
gzread(File, &Section->Flags, 1);
uint32_t Length; gzread(File, &Length, 4);
gzread(File, Section->Name = (char *)GC_malloc_atomic(Length + 1), Length);
Section->Name[Length] = 0;
break;};
};
};
for (int I = 0; I < NoOfExports; ++I) {
export_t *Export = new(export_t);
gzread(File, &Export->Flags, 1);
uint32_t Index; gzread(File, &Index, 4);
Export->Section = Sections[Index];
gzread(File, &Export->Offset, 4);
uint32_t Length; gzread(File, &Length, 4);
char *Name = (char *)GC_malloc_atomic(Length + 1);
gzread(File, Name, Length);
Name[Length] = 0;
stringtable_put(Riva->Exports, Name, Export);
};
for (int I = 0; I < NoOfRequires; ++I) {
uint8_t Flags; gzread(File, &Flags, 1);
uint32_t Length; gzread(File, &Length, 4);
char *Name = (char *)GC_malloc_atomic(Length + 1);
char *Path = 0;
gzread(File, Name, Length);
Name[Length] = 0;
if (Flags == LIBRARY_REL) Path = LoadPath;
for (char *P = Name; *P; ++P) if (*P == '/') *P = PATHCHR;
module_load(Path, Name);
};
gzclose(File);
void (*__init)(module_t *) = check_import(Riva, "__init", OnError);
if (__init) __init(Module);
void *Methods = check_import(Riva, "__methods", OnError);
if (Methods) add_methods(Methods);
return 1;
};
