AString CMethodInfo::GetName() const
{
AString s;
if (IsLzx())
{
s = "LZX:";
s.Add_UInt32(LzxInfo.GetNumDictBits());
}
else
{
if (IsDes())
s = "DES";
else
{
s = GetGuidString();
if (ControlData.Size() > 0)
{
s += ':';
for (size_t i = 0; i < ControlData.Size(); i++)
PrintByte(ControlData[i], s);
}
}
}
return s;
}
int main(void)
{
static struct {int a[8], b[8], sum ; } testcase[] =
{
{{0,0,0,0,0,0,0,1},{0,0,0,0,0,0,0,1},0},
{{1,1,1,1,1,1,1,1},{1,0,0,0,0,0,0,0},0},
{{1,0,1,0,1,0,1,0},{1,0,1,0,1,0,1,0},-86},
{{1,1,0,1,0,0,0,0},{0,1,1,0,1,1,1,1},1},
{{1,0,1,0,1,0,1,0},{0,1,0,1,0,1,0,1},-1}
} ;
int k ;
InitializeHardware(HEADER, PROJECT_NAME) ;
for (;;)
{
for (k = 0; k < ENTRIES(testcase); k++)
{
int *a = testcase[k].a ;
int *b = testcase[k].b ;
int sum[8] ;
uint32_t before, after, cycles ;
printf(" Test Case %d: ", k+1) ;
PrintBits(a) ;
printf("+") ;
PrintBits(b) ;
printf("\n") ;
printf(" Correct Sum: ") ;
PrintByte(testcase[k].sum) ;
printf("\n") ;
before = GetClockCycleCount() ;
AddBinary(a, b, sum) ;
after = GetClockCycleCount() ;
cycles = after - before ;
printf(" Your Sum: ") ;
if (PrintBits(sum) != (uint8_t) testcase[k].sum) printf(" %s", ERROR_FLAG) ;
printf("\n") ;
printf(" Clock Cycles: %lu\n", cycles) ;
printf("\n") ;
WaitForPushButton() ;
}
printf("Press button to start over.\n") ;
WaitForPushButton() ;
ClearDisplay() ;
}
}
int main(void)
{
static struct {int a[8], b[8], sum ; } testcase[] =
{
{{0,0,0,0,0,0,0,1},{0,0,0,0,0,0,0,1},0},
{{1,1,1,1,1,1,1,1},{1,0,0,0,0,0,0,0},0},
{{1,0,1,0,1,0,1,0},{1,0,1,0,1,0,1,0},-86},
{{1,1,0,1,0,0,0,0},{0,1,1,0,1,1,1,1},1},
{{1,0,1,0,1,0,1,0},{0,1,0,1,0,1,0,1},-1}
} ;
int k ;
for (k = 0; k < ENTRIES(testcase); k++)
{
int *a = testcase[k].a ;
int *b = testcase[k].b ;
int sum[8] ;
uint32_t before, after, cycles ;
printf(" Test Case %d: \n", k+1) ;
PrintBits(a) ;
printf("\n") ;
PrintBits(b) ;
printf("\n") ;
printf(" Correct Sum: \n") ;
PrintByte(testcase[k].sum);
printf("\n") ;
AddBinary(a, b, sum) ;
printf(" Your Sum: \n") ;
PrintBits(sum);
printf("\n") ;
printf("\n") ;
}
printf("Press button to start over.\n") ;
}
/**
* Main menu (level selection)
*/
void menu() {
uint8_t scroll = 0;
uint8_t delay = false;
uint8_t e_traj_offset1 = 0;
uint8_t e_traj_offset2 = ELECTRON_TRAJECTORY_LAST_STEP / 2;
unsigned int joypad;
ClearVram();
hide_sprites();
for (uint8_t sprite_id = 0; sprite_id < 6; sprite_id++) {
sprites[sprite_id].tileIndex = TILE_FIRST_ELECTRON + sprite_id;
}
DrawMap2(2, 2, logo_logo_map);
// credits
Print(2, 23, PSTR("2011 UZEBOX ATOMIX"));
Print(2, 24, PSTR("PROGRAM: MARTIN SUSTEK"));
Print(2, 25, PSTR("LEVEL DESIGN: ANDREAS WUEST"));
// initial scroll position
scroll = (level - 1);
if ((level - 1) < SCREEN_MENU_LEVEL_LINES) {
scroll = 0;
}
if ((level - 1) > LEVEL_COUNT - SCREEN_MENU_LEVEL_LINES) {
scroll = LEVEL_COUNT - SCREEN_MENU_LEVEL_LINES;
}
while (true) {
WaitVsync(1);
// electrons animation
e_traj_offset1++;
if (e_traj_offset1 > ELECTRON_TRAJECTORY_LAST_STEP) {
e_traj_offset1 = 0;
}
e_traj_offset2++;
if (e_traj_offset2 > ELECTRON_TRAJECTORY_LAST_STEP) {
e_traj_offset2 = 0;
}
sprites[0].x = (SCREEN_ELECTRON_X + pgm_read_byte(e_traj_1x + e_traj_offset1));
sprites[0].y = (SCREEN_ELECTRON_Y + pgm_read_byte(e_traj_1y + e_traj_offset1));
sprites[1].x = (SCREEN_ELECTRON_X + pgm_read_byte(e_traj_2x + e_traj_offset2));
sprites[1].y = (SCREEN_ELECTRON_Y + pgm_read_byte(e_traj_2y + e_traj_offset2));
sprites[2].x = (SCREEN_ELECTRON_X + pgm_read_byte(e_traj_3x + e_traj_offset1));
sprites[2].y = (SCREEN_ELECTRON_Y + pgm_read_byte(e_traj_3y + e_traj_offset1));
sprites[3].x = (SCREEN_ELECTRON_X + pgm_read_byte(e_traj_1x + e_traj_offset2));
sprites[3].y = (SCREEN_ELECTRON_Y + pgm_read_byte(e_traj_1y + e_traj_offset2));
sprites[4].x = (SCREEN_ELECTRON_X + pgm_read_byte(e_traj_2x + e_traj_offset1));
sprites[4].y = (SCREEN_ELECTRON_Y + pgm_read_byte(e_traj_2y + e_traj_offset1));
sprites[5].x = (SCREEN_ELECTRON_X + pgm_read_byte(e_traj_3x + e_traj_offset2));
sprites[5].y = (SCREEN_ELECTRON_Y + pgm_read_byte(e_traj_3y + e_traj_offset2));
for (uint8_t i = 0; i < SCREEN_MENU_LEVEL_LINES; i++) {
uint8_t current_level = (i + 1 + scroll);
if ((current_level > 0) && (current_level <= 50)) {
uint8_t y = 11 + i;
// level number
PrintByte(3, y, current_level, false);
// level name (shorten and pad with spaces)
for (uint8_t j = 0; j < 24; j++) {
char ch = pgm_read_byte(levels + (current_level - 1) * LEVEL_BYTE_SIZE + j);
if (ch == '\0') {
ch = ' ';
}
PrintChar(6 + j, y, ch);
}
// level done yet symbol
if (eeprom_data.data[current_level / 8] & 1 << (current_level % 8)) {
PrintChar(4, y, FONT_TICK);
} else {
PrintChar(4, y, ' ');
}
// cursor symbol
if (current_level == level) {
PrintChar(5, y, FONT_CURSOR);
} else {
PrintChar(5, y, ' ');
}
}
}
// molecule thumbnail
draw_molecule(21, 2);
// controls
if (delay) {
WaitVsync(4);
delay = false;
}
joypad = ReadJoypad(0);
if (joypad & BTN_UP) {
if (level > 1) {
play_sound(SOUND_MENU_MOVE);
level--;
if (scroll + 1 > level) {
scroll--;
}
delay = true;
} else {
play_sound(SOUND_MENU_CANT_MOVE);
}
}
if (joypad & BTN_DOWN) {
if (level < LEVEL_COUNT) {
play_sound(SOUND_MENU_MOVE);
level++;
if (scroll + SCREEN_MENU_LEVEL_LINES < level) {
scroll++;
}
delay = true;
} else {
play_sound(SOUND_MENU_CANT_MOVE);
}
}
if (joypad & BTN_START) {
hide_sprites();
play_sound(SOUND_MENU_SELECT);
return;
}
}
}
HRESULT CInArchive::OpenHelp2(IInStream *inStream, CDatabase &database)
{
if (ReadUInt32() != 1) // version
return S_FALSE;
if (ReadUInt32() != 0x28) // Location of header section table
return S_FALSE;
UInt32 numHeaderSections = ReadUInt32();
const unsigned kNumHeaderSectionsMax = 5;
if (numHeaderSections != kNumHeaderSectionsMax)
return S_FALSE;
IsArc = true;
ReadUInt32(); // Len of post-header table
Byte g[16];
ReadGUID(g); // {0A9007C1-4076-11D3-8789-0000F8105754}
// header section table
UInt64 sectionOffsets[kNumHeaderSectionsMax];
UInt64 sectionSizes[kNumHeaderSectionsMax];
UInt32 i;
for (i = 0; i < numHeaderSections; i++)
{
sectionOffsets[i] = ReadUInt64();
sectionSizes[i] = ReadUInt64();
UInt64 end = sectionOffsets[i] + sectionSizes[i];
database.UpdatePhySize(end);
}
// Post-Header
ReadUInt32(); // 2
ReadUInt32(); // 0x98: offset to CAOL from beginning of post-header)
// ----- Directory information
ReadUInt64(); // Chunk number of top-level AOLI chunk in directory, or -1
ReadUInt64(); // Chunk number of first AOLL chunk in directory
ReadUInt64(); // Chunk number of last AOLL chunk in directory
ReadUInt64(); // 0 (unknown)
ReadUInt32(); // $2000 (Directory chunk size of directory)
ReadUInt32(); // Quickref density for main directory, usually 2
ReadUInt32(); // 0 (unknown)
ReadUInt32(); // Depth of main directory index tree
// 1 there is no index, 2 if there is one level of AOLI chunks.
ReadUInt64(); // 0 (unknown)
UInt64 numDirEntries = ReadUInt64(); // Number of directory entries
// ----- Directory Index Information
ReadUInt64(); // -1 (unknown, probably chunk number of top-level AOLI in directory index)
ReadUInt64(); // Chunk number of first AOLL chunk in directory index
ReadUInt64(); // Chunk number of last AOLL chunk in directory index
ReadUInt64(); // 0 (unknown)
ReadUInt32(); // $200 (Directory chunk size of directory index)
ReadUInt32(); // Quickref density for directory index, usually 2
ReadUInt32(); // 0 (unknown)
ReadUInt32(); // Depth of directory index index tree.
ReadUInt64(); // Possibly flags -- sometimes 1, sometimes 0.
ReadUInt64(); // Number of directory index entries (same as number of AOLL
// chunks in main directory)
// (The obvious guess for the following two fields, which recur in a number
// of places, is they are maximum sizes for the directory and directory index.
// However, I have seen no direct evidence that this is the case.)
ReadUInt32(); // $100000 (Same as field following chunk size in directory)
ReadUInt32(); // $20000 (Same as field following chunk size in directory index)
ReadUInt64(); // 0 (unknown)
if (ReadUInt32() != kSignature_CAOL)
return S_FALSE;
if (ReadUInt32() != 2) // (Most likely a version number)
return S_FALSE;
UInt32 caolLength = ReadUInt32(); // $50 (Len of the CAOL section, which includes the ITSF section)
if (caolLength >= 0x2C)
{
/* UInt32 c7 = */ ReadUInt16(); // Unknown. Remains the same when identical files are built.
// Does not appear to be a checksum. Many files have
// 'HH' (HTML Help?) here, indicating this may be a compiler ID
// field. But at least one ITOL/ITLS compiler does not set this
// field to a constant value.
ReadUInt16(); // 0 (Unknown. Possibly part of 00A4 field)
ReadUInt32(); // Unknown. Two values have been seen -- $43ED, and 0.
ReadUInt32(); // $2000 (Directory chunk size of directory)
ReadUInt32(); // $200 (Directory chunk size of directory index)
ReadUInt32(); // $100000 (Same as field following chunk size in directory)
ReadUInt32(); // $20000 (Same as field following chunk size in directory index)
ReadUInt32(); // 0 (unknown)
ReadUInt32(); // 0 (Unknown)
if (caolLength == 0x2C)
{
// fprintf(stdout, "\n !!!NewFormat\n");
// fflush(stdout);
database.ContentOffset = 0; // maybe we must add database.StartPosition here?
database.NewFormat = true;
}
else if (caolLength == 0x50)
{
ReadUInt32(); // 0 (Unknown)
if (ReadUInt32() != kSignature_ITSF)
return S_FALSE;
if (ReadUInt32() != 4) // $4 (Version number -- CHM uses 3)
return S_FALSE;
if (ReadUInt32() != 0x20) // $20 (length of ITSF)
return S_FALSE;
UInt32 unknown = ReadUInt32();
if (unknown != 0 && unknown != 1) // = 0 for some HxW files, 1 in other cases;
return S_FALSE;
database.ContentOffset = database.StartPosition + ReadUInt64();
/* UInt32 timeStamp = */ ReadUInt32();
// A timestamp of some sort.
// Considered as a big-endian DWORD, it appears to contain
// seconds (MSB) and fractional seconds (second byte).
// The third and fourth bytes may contain even more fractional
// bits. The 4 least significant bits in the last byte are constant.
/* UInt32 lang = */ ReadUInt32(); // BE?
}
else
return S_FALSE;
}
// Section 0
ReadChunk(inStream, database.StartPosition + sectionOffsets[0], sectionSizes[0]);
if (sectionSizes[0] < 0x18)
return S_FALSE;
if (ReadUInt32() != 0x01FE)
return S_FALSE;
ReadUInt32(); // unknown: 0
UInt64 fileSize = ReadUInt64();
database.UpdatePhySize(fileSize);
ReadUInt32(); // unknown: 0
ReadUInt32(); // unknown: 0
// Section 1: The Directory Listing
ReadChunk(inStream, database.StartPosition + sectionOffsets[1], sectionSizes[1]);
if (ReadUInt32() != kSignature_IFCM)
return S_FALSE;
if (ReadUInt32() != 1) // (probably a version number)
return S_FALSE;
UInt32 dirChunkSize = ReadUInt32(); // $2000
if (dirChunkSize < 64)
return S_FALSE;
ReadUInt32(); // $100000 (unknown)
ReadUInt32(); // -1 (unknown)
ReadUInt32(); // -1 (unknown)
UInt32 numDirChunks = ReadUInt32();
ReadUInt32(); // 0 (unknown, probably high word of above)
for (UInt32 ci = 0; ci < numDirChunks; ci++)
{
UInt64 chunkPos = _inBuffer.GetProcessedSize();
if (ReadUInt32() == kSignature_AOLL)
{
UInt32 quickrefLength = ReadUInt32(); // Len of quickref area at end of directory chunk
if (quickrefLength > dirChunkSize || quickrefLength < 2)
return S_FALSE;
ReadUInt64(); // Directory chunk number
// This must match physical position in file, that is
// the chunk size times the chunk number must be the
// offset from the end of the directory header.
ReadUInt64(); // Chunk number of previous listing chunk when reading
// directory in sequence (-1 if first listing chunk)
ReadUInt64(); // Chunk number of next listing chunk when reading
// directory in sequence (-1 if last listing chunk)
ReadUInt64(); // Number of first listing entry in this chunk
ReadUInt32(); // 1 (unknown -- other values have also been seen here)
ReadUInt32(); // 0 (unknown)
unsigned numItems = 0;
for (;;)
{
UInt64 offset = _inBuffer.GetProcessedSize() - chunkPos;
UInt32 offsetLimit = dirChunkSize - quickrefLength;
if (offset > offsetLimit)
return S_FALSE;
if (offset == offsetLimit)
break;
if (database.NewFormat)
{
UInt16 nameLen = ReadUInt16();
if (nameLen == 0)
return S_FALSE;
UString name;
ReadUString((unsigned)nameLen, name);
AString s;
ConvertUnicodeToUTF8(name, s);
Byte b = ReadByte();
s.Add_Space();
PrintByte(b, s);
s.Add_Space();
UInt64 len = ReadEncInt();
// then number of items ?
// then length ?
// then some data (binary encoding?)
while (len-- != 0)
{
b = ReadByte();
PrintByte(b, s);
}
database.NewFormatString += s;
database.NewFormatString += "\r\n";
}
else
{
RINOK(ReadDirEntry(database));
}
numItems++;
}
Skip(quickrefLength - 2);
if (ReadUInt16() != numItems)
return S_FALSE;
if (numItems > numDirEntries)
return S_FALSE;
numDirEntries -= numItems;
}
else
Skip(dirChunkSize - 4);
}
return numDirEntries == 0 ? S_OK : S_FALSE;
}
/*
* Read the next TIFF directory from a file
* and convert it to the internal format.
* We read directories sequentially.
*/
static uint32
ReadDirectory(int fd, unsigned ix, uint32 off)
{
register TIFFDirEntry *dp;
register int n;
TIFFDirEntry *dir = 0;
uint16 dircount;
int space;
uint32 nextdiroff = 0;
if (off == 0) /* no more directories */
goto done;
if (lseek(fd, (off_t) off, 0) != off) {
Fatal("Seek error accessing TIFF directory");
goto done;
}
if (read(fd, (char*) &dircount, sizeof (uint16)) != sizeof (uint16)) {
ReadError("directory count");
goto done;
}
if (swabflag)
TIFFSwabShort(&dircount);
dir = (TIFFDirEntry *)_TIFFmalloc(dircount * sizeof (TIFFDirEntry));
if (dir == NULL) {
Fatal("No space for TIFF directory");
goto done;
}
n = read(fd, (char*) dir, dircount*sizeof (*dp));
if (n != dircount*sizeof (*dp)) {
n /= sizeof (*dp);
Error(
"Could only read %u of %u entries in directory at offset %#lx",
n, dircount, (unsigned long) off);
dircount = n;
}
if (read(fd, (char*) &nextdiroff, sizeof (uint32)) != sizeof (uint32))
nextdiroff = 0;
if (swabflag)
TIFFSwabLong(&nextdiroff);
printf("Directory %u: offset %lu (%#lx) next %lu (%#lx)\n", ix,
(unsigned long) off, (unsigned long) off,
(unsigned long) nextdiroff, (unsigned long) nextdiroff);
for (dp = dir, n = dircount; n > 0; n--, dp++) {
if (swabflag) {
TIFFSwabArrayOfShort(&dp->tdir_tag, 2);
TIFFSwabArrayOfLong(&dp->tdir_count, 2);
}
PrintTag(stdout, dp->tdir_tag);
putchar(' ');
PrintType(stdout, dp->tdir_type);
putchar(' ');
printf("%lu<", (unsigned long) dp->tdir_count);
if (dp->tdir_type >= NWIDTHS) {
printf(">\n");
continue;
}
space = dp->tdir_count * datawidth[dp->tdir_type];
if (space <= 4) {
switch (dp->tdir_type) {
case TIFF_FLOAT:
case TIFF_UNDEFINED:
case TIFF_ASCII: {
unsigned char data[4];
_TIFFmemcpy(data, &dp->tdir_offset, 4);
if (swabflag)
TIFFSwabLong((uint32*) data);
PrintData(stdout,
dp->tdir_type, dp->tdir_count, data);
break;
}
case TIFF_BYTE:
PrintByte(stdout, bytefmt, dp);
break;
case TIFF_SBYTE:
PrintByte(stdout, sbytefmt, dp);
break;
case TIFF_SHORT:
PrintShort(stdout, shortfmt, dp);
break;
case TIFF_SSHORT:
PrintShort(stdout, sshortfmt, dp);
break;
case TIFF_LONG:
PrintLong(stdout, longfmt, dp);
break;
case TIFF_SLONG:
PrintLong(stdout, slongfmt, dp);
break;
}
} else {
unsigned char *data = (unsigned char *)_TIFFmalloc(space);
if (data) {
if (TIFFFetchData(fd, dp, data))
if (dp->tdir_count > maxitems) {
PrintData(stdout, dp->tdir_type,
maxitems, data);
printf(" ...");
} else
PrintData(stdout, dp->tdir_type,
dp->tdir_count, data);
_TIFFfree(data);
} else
Error("No space for data for tag %u",
dp->tdir_tag);
}
printf(">\n");
}
done:
if (dir)
_TIFFfree((char *)dir);
return (nextdiroff);
}
