void LexStream::Dump()
{
FILE* tokfile;
// +1 for '\0' +4 for length(".tok")
char* tokfile_name = new char[FileNameLength() + 5];
strcpy(tokfile_name, FileName());
strcat(tokfile_name, StringConstant::U8S_DO_tok);
if ((tokfile = SystemFopen(tokfile_name, "w")) == NULL)
{
Coutput << "*** Cannot open LexStream dump output file "
<< tokfile_name << endl;
return;
}
RereadInput();
SetUpComments();
TokenIndex tok = 0;
for (CommentIndex com = FirstComment(tok);
com > 0 && com < NumComments() && PrecedingToken(com) == tok; com++)
{
fprintf(tokfile, "*%5d ", com);
fprintf(tokfile, "%s", FileName());
fprintf(tokfile, ", line %d.%d: ",
FindLine(comments[com].location),
FindColumn(comments[com].location - 1) + 1);
for (const wchar_t* s = CommentString(com); *s; s++)
fprintf(tokfile, "%c", *s);
fprintf(tokfile, "\n");
}
do
{
tok = Gettoken();
fprintf(tokfile, "%6d ", tok);
fprintf(tokfile, " %s", FileName());
fprintf(tokfile, ", %cline %d.%d: %s %s ",
(AfterEol(tok) ? '*' : ' '),
Line(tok), (Kind(tok) == TK_EOF ? 0 : Column(tok)),
token_type(Kind(tok)),
(tokens[tok].Deprecated() ? "(d)" : " "));
for (const wchar_t* s = NameString(tok); *s; s++)
fprintf(tokfile, "%c", *s);
fprintf(tokfile, "\n");
for (CommentIndex com = FirstComment(tok);
com > 0 && com < NumComments() && PrecedingToken(com) == tok; com++)
{
fprintf(tokfile, "*%5d ", com);
fprintf(tokfile, " %s", FileName());
fprintf(tokfile, ", line %d.%d: ",
FindLine(comments[com].location),
FindColumn(comments[com].location - 1) + 1);
for (const wchar_t* s = CommentString(com); *s; s++)
fprintf(tokfile, "%c", *s);
fprintf(tokfile, "\n");
}
} while (Kind(tok) != TK_EOF);
DestroyInput();
fprintf(tokfile, "\n");
#ifdef UNIQUE_NAMES
fprintf(tokfile, "\nThe unique names are:\n\n");
for (int i = 0; i < control.name_table.symbol_pool.length(); i++)
{
fprintf(tokfile, "%4d ", i);
for (const wchar_t* s = control.name_table.symbol_pool[i].name();
*s; s++)
{
fprintf(tokfile, "%c", *s);
}
fprintf(tokfile, "\n");
}
#endif // UNIQUE_NAMES
if (tokfile)
fclose(tokfile);
delete [] tokfile_name;
}
void TypeDependenceChecker::OutputMake(FileSymbol* file_symbol)
{
//
//
//
const char* name;
char* buf = NULL;
int length;
if (control -> option.directory == NULL)
{
name = file_symbol -> FileName();
length = file_symbol -> FileNameLength() -
(file_symbol -> IsJava() ? FileSymbol::java_suffix_length
: FileSymbol::class_suffix_length);
}
else
{
name = file_symbol -> Utf8Name();
length = strlen(name);
DirectorySymbol* dir_symbol = file_symbol -> OutputDirectory();
char* dir_name = dir_symbol -> DirectoryName();
int dir_length = strlen(dir_name);
buf = new char[length + FileSymbol::class_suffix_length + dir_length +
2];
strcpy(buf, dir_name);
#ifdef UNIX_FILE_SYSTEM
buf[dir_length] = (char)U_SLASH;
#elif defined(WIN32_FILE_SYSTEM)
buf[dir_length] = (char)U_BACKSLASH;
#endif
strcpy(&buf[dir_length+1], name);
name = buf;
length = dir_length + 1 + length;
}
char* output_name = new char[length + FileSymbol::class_suffix_length + 1];
char* u_name = new char[length + strlen(StringConstant::U8S_DO_u) + 1];
strncpy(output_name, name, length);
strncpy(u_name, name, length);
strcpy(&output_name[length], FileSymbol::class_suffix);
strcpy(&u_name[length], StringConstant::U8S_DO_u);
//
//
//
SymbolSet file_set;
for (unsigned i = 0; i < file_symbol -> types.Length(); i++)
{
TypeSymbol* type = file_symbol -> types[i];
TypeSymbol* parent;
for (parent = (TypeSymbol*) type -> parents_closure -> FirstElement();
parent;
parent = (TypeSymbol*) type -> parents_closure -> NextElement())
{
FileSymbol* symbol = parent -> file_symbol;
if (symbol && (! symbol -> IsZip()))
file_set.AddElement(symbol);
}
}
file_set.RemoveElement(file_symbol);
//
//
//
Tuple<FileSymbol*> file_list(file_set.Size());
file_list.Next() = file_symbol;
for (FileSymbol* symbol = (FileSymbol*) file_set.FirstElement();
symbol; symbol = (FileSymbol*) file_set.NextElement())
file_list.Next() = symbol;
FILE* outfile = SystemFopen(u_name, "w");
if (outfile == NULL)
Coutput << "*** Cannot open output Makefile " << u_name << endl;
else
{
OutputMake(outfile, output_name, file_list);
fclose(outfile);
}
delete [] output_name;
delete [] u_name;
if (control -> option.directory)
delete [] buf;
}
Zip::Zip(Control &control_, char *zipfile_name) : control(control_),
magic(0),
zipbuffer(NULL)
{
#ifdef UNIX_FILE_SYSTEM
zipfile = SystemFopen(zipfile_name, "rb");
if (zipfile)
{
int rc = fseek(zipfile, -END_SIZE, SEEK_END);
if (rc == 0)
{
zipbuffer = new char[END_SIZE];
buffer_ptr = zipbuffer;
SystemFread(buffer_ptr, sizeof(char), END_SIZE, zipfile);
magic = GetU4();
}
}
#elif defined(WIN32_FILE_SYSTEM)
zipfile = CreateFile(zipfile_name,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_READONLY,
NULL);
if (zipfile != INVALID_HANDLE_VALUE)
{
mapfile = CreateFileMapping(zipfile, NULL, PAGE_READONLY, 0, 0, NULL);
zipbuffer = (mapfile == INVALID_HANDLE_VALUE ?
NULL :
(char *) MapViewOfFile(mapfile,
FILE_MAP_READ,
0, 0, 0)
);
if (zipbuffer)
{
buffer_ptr = &zipbuffer[GetFileSize(zipfile, NULL) - END_SIZE];
magic = GetU4();
}
}
#endif
// The following was posted to the dev list, but was just
// too good to not put in here, the next person to have to
// deal with this crap will appreciate it. -=Chris
//
// From: Mo DeJong <*****@*****.**>
//
// Ode to a zip file:
//
// I can't read it forwards
// I can't read it backwards
// I must know where to begin
// so I need to look in the middle
// to find the middle, I must know the end
// but I don't know where that is, so I guess
//
// -------------------------------------------------
// This may or may not be a valid zip file. The zip file might have
// a file comment so we can't be sure where the END header is located.
// We check for the LOC header at byte 0 to make sure this is a valid
// zip file and then scan over the file backwards in search of the
// END header.
if (zipbuffer != NULL && ! IsValid()) {
u4 sig = 0;
#ifdef UNIX_FILE_SYSTEM
int res = fseek(zipfile, 0, SEEK_SET);
assert(res == 0);
char *tmpbuffer = new char[LOC_SIZE];
buffer_ptr = tmpbuffer;
SystemFread(buffer_ptr, sizeof(char), LOC_SIZE, zipfile);
sig = GetU4();
delete [] tmpbuffer;
buffer_ptr = NULL;
if (sig == LOC_SIG)
{
int block_size = 8192;
tmpbuffer = new char[block_size];
char *holdbuffer = new char[8];
char *index_ptr;
res = fseek(zipfile, 0, SEEK_END);
assert(res == 0);
long zip_file_size = ftell(zipfile);
int num_loops = zip_file_size / block_size;
magic = 0;
for (; magic == 0 && num_loops >= 0 ; num_loops--) {
if ((ftell(zipfile) - block_size) < 0)
{
block_size = ftell(zipfile);
res = fseek(zipfile, 0L, SEEK_SET);
}
else
{
res = fseek(zipfile, -block_size, SEEK_CUR);
}
assert(res == 0);
SystemFread(tmpbuffer, sizeof(char), block_size, zipfile);
res = fseek(zipfile, -block_size, SEEK_CUR); // undo fread
assert(res == 0);
for (index_ptr = tmpbuffer + block_size - 1;
index_ptr >= tmpbuffer;
index_ptr--)
{
if (*index_ptr == 'P')
{
// Check for header signature that spans buffer
int span = (tmpbuffer + block_size) - index_ptr;
if (span < 4)
{
memmove(holdbuffer+span, holdbuffer, 3);
memmove(holdbuffer, index_ptr, span);
buffer_ptr = holdbuffer;
}
else
{
buffer_ptr = index_ptr;
}
sig = GetU4();
if (sig == END_SIG)
{
// Found the END header, put it in zipbuffer.
buffer_ptr = zipbuffer;
fseek(zipfile, block_size-span, SEEK_CUR);
SystemFread(buffer_ptr, sizeof(char),
END_SIZE, zipfile);
magic = GetU4();
break;
}
}
}
// Copy first 3 bytes into holdbuffer in case sig spans
holdbuffer[0] = tmpbuffer[0];
holdbuffer[1] = tmpbuffer[1];
holdbuffer[2] = tmpbuffer[2];
}
delete [] tmpbuffer;
delete [] holdbuffer;
}
#elif defined(WIN32_FILE_SYSTEM)
buffer_ptr = &zipbuffer[0];
sig = GetU4();
if (sig == LOC_SIG)
{
buffer_ptr = &zipbuffer[GetFileSize(zipfile, NULL) - END_SIZE];
for ( ; buffer_ptr >= zipbuffer; buffer_ptr--)
{
if (*buffer_ptr == 'P')
{
sig = GetU4();
if (sig == END_SIG)
{
magic = sig;
break;
}
else
buffer_ptr -= 4;
}
}
}
#endif
}
ReadDirectory();
}
