Public_Skunkworks/rickjr
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: Public_Skunkworks:develop
Branches Tags
Public_Skunkworks:main
Public_Skunkworks:develop
..
compare: Public_Skunkworks:main
Branches Tags
Public_Skunkworks:develop
Public_Skunkworks:main

No commits in common. "develop" and "main" have entirely different histories.
develop ... main

31 changed files with 32 additions and 1868 deletions
Show stats Expand all files Collapse all files

11
.gitignore vendored
View file

@ -2,14 +2,3 @@
*.vpw *.vpw
*.vpwhistxml *.vpwhistxml
*.vtg *.vtg
dep/
lst/
obj/
bin/blockgen/.vs/
*.user
bin/blockgen/vcxproj/.vs/
bin/blockgen/vcxproj/x64/
*.pdb
bin/overlayhelper/.vs/
bin/overlayhelper/vcxproj/.vs/
bin/overlayhelper/vcxproj/x64/

52
Makefile
View file

@ -29,8 +29,7 @@ F256 = $(HOME)/code/f256
#SYSLIBDIR = $(SYSTEM)/lib #SYSLIBDIR = $(SYSTEM)/lib
#SYSINCDIR = $(SYSTEM)/include #SYSINCDIR = $(SYSTEM)/include
#TMPFLAGS = -D F256=1 -include src/mapper.h -include blocks.h -Wno-unknown-pragmas TMPFLAGS = -D F256=1 -Wno-unknown-pragmas
TMPFLAGS = -D F256=1 -include src/mapper.h -Wno-unknown-pragmas
INCCMD = -I$(SYSINCDIR) INCCMD = -I$(SYSINCDIR)
@ -41,6 +40,7 @@ INCCMD += -I$(F256)/f256lib
OBJDIR = $(PROJROOT)/obj OBJDIR = $(PROJROOT)/obj
DEPDIR = $(PROJROOT)/dep DEPDIR = $(PROJROOT)/dep
LSTDIR = $(PROJROOT)/lst
# #
# Special GnuMake Search Path Directive # Special GnuMake Search Path Directive
@ -95,13 +95,7 @@ OBJS += syssnd.o
OBJS += system.o OBJS += system.o
OBJS += sysvid.o OBJS += sysvid.o
OBJS += util.o OBJS += util.o
#OBJS += f256.o OBJS += f256.o
OBJS += dat_spritesJR.o
LIBS := $(OBJDIR)/f256.o
# Data Objects
#OBJS += splash.o
# change list of .o's into a list of .d's # change list of .o's into a list of .d's
@ -111,14 +105,12 @@ DEPS := $(OBJS:%.o=%.d)
AS = merlin32 AS = merlin32
CC = mos-f256k-clang CC = mos-f256k-clang
LD = mos-f256k-clang LD = mos-f256k-clang
OBJCOPY = llvm-objcopy
RM = /bin/rm -rfv RM = /bin/rm -rfv
CFLAGS = -Os -Wall -Werror -Wa,-al -fno-common CFLAGS = -Os -Wall -Werror -Wa,-al -fno-common
CXXFLAGS = -Os -Wall -Werror -Wa,-al -fno-common CXXFLAGS = -Os -Wall -Werror -Wa,-al -fno-common
#ASFLAGS = -c -xassembler-with-cpp -Wa,-al #ASFLAGS = -c -xassembler-with-cpp -Wa,-al
#LDFLAGS = -Wl,-Map,$(TARGET).map $(LIBCMD) #LDFLAGS = -Wl,-Map,$(TARGET).map $(LIBCMD)
LDFLAGS = -Trickjr.ld --verbose
# Clear Default Suffixes # Clear Default Suffixes
.SUFFIXES: .SUFFIXES:
@ -127,23 +119,20 @@ LDFLAGS = -Trickjr.ld --verbose
all: $(TARGET) all: $(TARGET)
#$(TARGET): $(DEPS) $(OBJS) $(LIBS) $(TARGET): $(DEPS) $(OBJS) $(LIBS)
$(TARGET): $(DEPS) $(OBJS) overlay ${CC} $(CFLAGS) $(TMPFLAGS) $(INCCMD) -c ${F256}/f256lib/f256.c -o $(OBJDIR)/f256.o > $(LSTDIR)/$*.lst
${CC} $(CFLAGS) $(TMPFLAGS) $(INCCMD) -c ${F256}/f256lib/f256.c -o $(OBJDIR)/f256.o
$(LD) -o $@ $(addprefix $(OBJDIR)/,$(OBJS)) $(LIBS) $(LDFLAGS) $(LD) -o $@ $(addprefix $(OBJDIR)/,$(OBJS)) $(LIBS) $(LDFLAGS)
llvm-objdump --syms -d --print-imm-hex $(TARGET).elf > $(TARGET).lst
# Object Rules # Object Rules
.s.o: .s.o:
$(AS) $(ASFLAGS) $(TMPFLAGS) $(INCCMD) -o $(OBJDIR)/$@ $< $(AS) $(ASFLAGS) $(TMPFLAGS) $(INCCMD) -o $(OBJDIR)/$@ $< > $(LSTDIR)/$*.lst
.c.o: .c.o:
$(CC) $(CFLAGS) $(TMPFLAGS) $(INCCMD) -c $< -o $(OBJDIR)/$*.o $(CC) $(CFLAGS) $(TMPFLAGS) $(INCCMD) -c $< -o $(OBJDIR)/$*.o > $(LSTDIR)/$*.lst
.cc.o: .cc.o:
$(CC) $(CXXFLAGS) $(TMPFLAGS) $(INCCMD) -c $< -o $(OBJDIR)/$*.o $(CC) $(CXXFLAGS) $(TMPFLAGS) $(INCCMD) -c $< -o $(OBJDIR)/$*.o > $(LSTDIR)/$*.lst
# Dependencie Rules # Dependencie Rules
# #
@ -168,20 +157,7 @@ $(TARGET): $(DEPS) $(OBJS) overlay
.PHONY: clean .PHONY: clean
clean: clean:
$(RM) $(OBJDIR) *.o $(DEPDIR) *.map $(TARGET) $(TARGET).elf $(TARGET).pgz $(TARGET).lst $(RM) $(OBJDIR) *.o $(DEPDIR) *.map $(LSTDIR) $(TARGET) $(TARGET).elf $(TARGET).pgz
# needed for the overlay input
HELPER = $(HOME)/code/rickjr/bin/oh
CFILES = $(patsubst %.o,src/%.c,$(OBJS))
.PHONY: overlay
overlay_reset:
@echo '/* Overlay Helper Generated Linker Script */' > overlay.ld
overlay: overlay_reset $(CFILES)
$(foreach cfile,$(CFILES),$(shell $(HELPER) $(cfile) >> $(HOME)/code/rickjr/overlay.ld))
######################################## ########################################
@ -200,7 +176,7 @@ $(DEPS) : Makefile
# Targets that create the output object directory if it doesn't already exist # Targets that create the output object directory if it doesn't already exist
# #
Makefile : $(OBJDIR) $(DEPDIR) Makefile : $(OBJDIR) $(DEPDIR) $(LSTDIR)
$(OBJDIR) : $(OBJDIR) :
$(MKDIR) $(OBJDIR) $(MKDIR) $(OBJDIR)
@ -212,8 +188,16 @@ $(OBJDIR) :
$(DEPDIR) : $(DEPDIR) :
$(MKDIR) $(DEPDIR) $(MKDIR) $(DEPDIR)
#
# Targets that create the output list directory if it doesn't already exist
#
$(LSTDIR) :
$(MKDIR) $(LSTDIR)
# #
# Generated Dependencie Files # Generated Dependencie Files
# #
-include $(wildcard $(DEPDIR)/*.d) -include $(wildcard $(DEPDIR)/*.d)

BIN
bin/blockgen.exe
View file

Binary file not shown.

48
bin/blockgen/source/bctypes.h
View file

@ -1,48 +0,0 @@
/*
bctypes.h
Because I need Standard Types
*/
#ifndef _bctypes_h
#define _bctypes_h
typedef signed char i8;
typedef unsigned char u8;
typedef signed short i16;
typedef unsigned short u16;
typedef signed long i32;
typedef unsigned long u32;
typedef signed long long i64;
typedef unsigned long long u64;
// If we're using C, I still like having a bool around
#ifndef __cplusplus
typedef i32 bool;
#define false (0)
#define true (!false)
#define nullptr 0
#endif
typedef float f32;
typedef float r32;
typedef double f64;
typedef double r64;
#define null (0)
// Odd Types
typedef union {
// u128 ul128;
u64 ul64[2];
u32 ui32[4];
} QWdata;
#endif // _bctypes_h
// EOF - bctypes.h

68
bin/blockgen/source/blockgen.cpp
View file

@ -1,68 +0,0 @@
// omf2hex.cpp : This file contains the 'main' function. Program execution begins and ends there.
//
#include <stdio.h>
#include <stdlib.h>
#include "symfile.h"
//------------------------------------------------------------------------------
void helpText()
{
printf("blockgen - v1.0\n");
printf("--------------\n");
printf("Convert mos-llvm elf file symboles into a C header file\n");
printf("\nblock [options] <file.elf>\n");
printf(" -v verbose\n\n");
exit(-1);
}
//------------------------------------------------------------------------------
int main(int argc, char* argv[])
{
char* pInfilePath = nullptr;
bool bVerbose = false;
for (int idx = 1; idx < argc; ++idx )
{
char* arg = argv[ idx ];
if ('-' == arg[0])
{
// Parse as an option
if ('v'==arg[1])
{
bVerbose = true;
}
}
else if (nullptr == pInfilePath)
{
// Assume the first non-option is an input file path
pInfilePath = argv[ idx ];
}
else
{
// Oh Crap, we have a non-option, but we don't know what to do with
// it
printf("ERROR: Invalid option, Arg %d = %s\n\n", idx, argv[ idx ]);
helpText();
}
}
if (pInfilePath)
{
// Load the .sym File
SYMFile *pSymFile = new SYMFile(std::string(pInfilePath));
delete pSymFile;
}
else
{
helpText();
}
return 0;
}

164
bin/blockgen/source/memstream.h
View file

@ -1,164 +0,0 @@
//
// Jason's Memory Stream Helper thing
// Serialize a byte stream into real types
//
// Currently only support Little Endian
//
#ifndef MEMSTREAM_H_
#define MEMSTREAM_H_
#include <string>
// Prototypes
void *memcpy(void *dest, const void *src, size_t n);
class MemoryStream
{
public:
MemoryStream(unsigned char* pStreamStart, size_t streamSize)
: m_pStreamStart( pStreamStart )
, m_streamSize(streamSize)
, m_pStreamCurrent( pStreamStart )
{}
~MemoryStream()
{
m_pStreamStart = nullptr;
m_streamSize = 0;
m_pStreamCurrent = nullptr;
}
// Really Dumb Reader Template
template <class T>
T Read()
{
T result;
memcpy(&result, m_pStreamCurrent, sizeof(T));
m_pStreamCurrent += sizeof(T);
return result;
}
template <class T>
void Read(T& result)
{
memcpy(&result, m_pStreamCurrent, sizeof(result));
m_pStreamCurrent += sizeof(result);
}
void ReadBytes(u8* pDest, size_t numBytes)
{
memcpy(pDest, m_pStreamCurrent, numBytes);
m_pStreamCurrent += numBytes;
}
std::string ReadPString()
{
std::string result;
u8 length = *m_pStreamCurrent++;
result.insert(0, (char*)m_pStreamCurrent, (size_t)length);
m_pStreamCurrent += length;
return result;
}
std::string ReadLine()
{
unsigned char* pStreamEnd = m_pStreamStart + m_streamSize;
std::string result;
u8 *pEndOfLine = m_pStreamCurrent;
while (pEndOfLine < pStreamEnd)
{
if ((0x0a != *pEndOfLine) && (0x0d != *pEndOfLine))
{
pEndOfLine++;
}
else
{
break;
}
}
size_t length = pEndOfLine - m_pStreamCurrent;
if (length)
{
// Capture the line
result.insert(0, (char*)m_pStreamCurrent, (size_t)length);
m_pStreamCurrent += length;
}
// Figure out if that loop broke out because we hit the end of the file
while (pEndOfLine < pStreamEnd)
{
if ((0x0a == *pEndOfLine) || (0x0d == *pEndOfLine))
{
pEndOfLine++;
}
else
{
break;
}
}
m_pStreamCurrent = pEndOfLine;
if (m_pStreamCurrent > pStreamEnd)
{
m_pStreamCurrent = pStreamEnd;
}
return result;
}
size_t SeekCurrent(int delta)
{
m_pStreamCurrent += delta;
return m_pStreamCurrent - m_pStreamStart;
}
size_t SeekSet(size_t offset)
{
m_pStreamCurrent = m_pStreamStart + offset;
return m_pStreamCurrent - m_pStreamStart;
}
unsigned char* GetPointer() { return m_pStreamCurrent; }
size_t NumBytesAvailable() {
unsigned char* pStreamEnd = m_pStreamStart + m_streamSize;
if (pStreamEnd - m_pStreamCurrent >= 0)
{
return pStreamEnd - m_pStreamCurrent;
}
else
{
return 0;
}
}
private:
unsigned char* m_pStreamStart;
size_t m_streamSize;
unsigned char* m_pStreamCurrent;
};
#endif // MEMSTREAM_H_

231
bin/blockgen/source/symfile.cpp
View file

@ -1,231 +0,0 @@
//
// symfile.cpp
//
#include "symfile.h"
#include <stdio.h>
//------------------------------------------------------------------------------
// Static Helpers
static bool contains(char x, const char* pSeparators)
{
while (*pSeparators)
{
if (x == *pSeparators)
{
return true;
}
pSeparators++;
}
return false;
}
static std::vector<std::string> split(const std::string& s, const char* separators)
{
std::vector<std::string> output;
std::string::size_type prev_pos = 0, pos = 0;
for (int index = 0; index < s.length(); ++index)
{
pos = index;
// if the index is a separator
if (contains(s[index], separators))
{
// if we've skipped a token, collect it
if (prev_pos != index)
{
output.push_back(s.substr(prev_pos, index-prev_pos));
// skip white space here
while (index < s.length())
{
if (contains(s[index], separators))
{
++index;
}
else
{
prev_pos = index;
pos = index;
break;
}
}
}
else
{
prev_pos++;
}
}
}
output.push_back(s.substr(prev_pos, pos-prev_pos+1)); // Last word
return output;
}
// make this string lowercase
static void tolower(std::string& s)
{
for (int index = 0; index < s.length(); ++index)
{
s[index] = tolower( s[index] );
}
}
//------------------------------------------------------------------------------
SYMFile::SYMFile( std::string filepath )
: m_filepath( filepath )
{
FILE* pFile = nullptr;
errno_t err = fopen_s(&pFile, filepath.c_str(), "rb");
if (0==err)
{
fseek(pFile, 0, SEEK_END);
size_t length = ftell(pFile);
fseek(pFile, 0, SEEK_SET);
printf("\n// SYMFile %s - %lld bytes\n", filepath.c_str(), length);
printf("// Reading %s\n", filepath.c_str());
printf("//\n");
printf("// This file generated by blockgen.exe\n");
printf("//\n");
printf("//\n");
u8* pData = new u8[ length ];
fread(pData, sizeof(u8), length / sizeof(u8), pFile);
// Now we have a buffer, with the whole SYM File
// Read in the Sections
{
MemoryStream memStream(pData, length);
while (memStream.NumBytesAvailable())
{
std::string lineData = memStream.ReadLine();
// symbols are case sensitive
// we care about the first 32 bit value in hex, and the last value on the line, the symbol
std::vector<std::string> tokens = split(lineData, " \t");
if (tokens.size() >= 3)
{
if (IsHexAddress(tokens[0]))
{
// We're only interested in lines that start with a hex address
std::string sym_name = tokens[ tokens.size() - 1 ];
u32 address = strtoul(tokens[0].c_str(), nullptr, 16);
//printf("address = %08x\n", address);
if (0 != (address >> 24))
{
printf("#define %s_BLOCK %d\n", sym_name.c_str(), address>>24);
}
else if (0 != (address & 0xFF0000))
{
printf("#define %s_high %d\n", sym_name.c_str(), (address>>16) & 0xFF);
printf("#define %s_BLOCK %d\n", sym_name.c_str(), ((address&0xFFFFFF) / 0x2000));
}
}
}
}
}
delete[] pData;
fclose(pFile);
printf("\n// Read Completed\n");
}
else
{
printf("// SYMFile could not open %s\n", filepath.c_str());
printf("//\n");
printf("Feed in a symbol dump file, and I will print out a header file\n");
printf("Capture my output with a pipe.\n");
printf("\nGenerate a .sym file like this:\n");
printf("\nllvm-objdump --syms <program>.elf > program.sym\n");
}
}
//------------------------------------------------------------------------------
SYMFile::~SYMFile()
{
}
//------------------------------------------------------------------------------
u32 SYMFile::GetAddress(std::string symbolName)
{
u32 result_address = 0;
// If the address is in there, return it
// First remove trailing spaces from the sectionName
const size_t strEnd = symbolName.find_last_not_of(" ");
if (strEnd != std::string::npos)
{
if ((strEnd+1) != symbolName.length())
{
symbolName.resize(strEnd+1);
}
}
// Make sure not case sensitive
tolower(symbolName);
for (int labelIndex = 0; labelIndex < m_symbols.size(); ++labelIndex)
{
if (symbolName == m_symbols[labelIndex])
{
result_address = m_addresses[labelIndex];
break;
}
}
return result_address;
}
//------------------------------------------------------------------------------
bool SYMFile::IsHexAddress(const std::string& address)
{
if (8 == address.size())
{
for (int idx = 0; idx < 8; ++idx)
{
if ((address[idx] >= '0')&&(address[idx] <= '9'))
{
continue; // this is good
}
else if ((address[idx] >= 'a')&&(address[idx] <= 'f'))
{
continue; // this is good
}
else if ((address[idx] >= 'A')&&(address[idx] <= 'F'))
{
continue; // this is good
}
else
{
return false;
}
}
return true;
}
return false;
}
//------------------------------------------------------------------------------

34
bin/blockgen/source/symfile.h
View file

@ -1,34 +0,0 @@
//
// SYMFile Class
//
#ifndef SYMFILE_H_
#define SYMFILE_H_
#include <string>
#include <vector>
#include "bctypes.h"
#include "memstream.h"
//------------------------------------------------------------------------------
class SYMFile
{
public:
SYMFile( std::string filepath );
~SYMFile();
u32 GetAddress(std::string symbolName);
bool IsHexAddress(const std::string& address);
private:
std::string m_filepath;
std::vector<std::string> m_symbols;
std::vector<u32> m_addresses;
};
#endif // SYMFILE_H_

31
bin/blockgen/vcxproj/blockgen.sln
View file

@ -1,31 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.8.34309.116
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "blockgen", "blockgen.vcxproj", "{3E291D4B-EB9C-439B-8090-A0F1D0BD21EB}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{3E291D4B-EB9C-439B-8090-A0F1D0BD21EB}.Debug|x64.ActiveCfg = Debug|x64
{3E291D4B-EB9C-439B-8090-A0F1D0BD21EB}.Debug|x64.Build.0 = Debug|x64
{3E291D4B-EB9C-439B-8090-A0F1D0BD21EB}.Debug|x86.ActiveCfg = Debug|Win32
{3E291D4B-EB9C-439B-8090-A0F1D0BD21EB}.Debug|x86.Build.0 = Debug|Win32
{3E291D4B-EB9C-439B-8090-A0F1D0BD21EB}.Release|x64.ActiveCfg = Release|x64
{3E291D4B-EB9C-439B-8090-A0F1D0BD21EB}.Release|x64.Build.0 = Release|x64
{3E291D4B-EB9C-439B-8090-A0F1D0BD21EB}.Release|x86.ActiveCfg = Release|Win32
{3E291D4B-EB9C-439B-8090-A0F1D0BD21EB}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {43F6DB44-6241-4F87-B55D-35450E50405E}
EndGlobalSection
EndGlobal

141
bin/blockgen/vcxproj/blockgen.vcxproj
View file

@ -1,141 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>17.0</VCProjectVersion>
<Keyword>Win32Proj</Keyword>
<ProjectGuid>{3e291d4b-eb9c-439b-8090-a0f1d0bd21eb}</ProjectGuid>
<RootNamespace>blockgen</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="..\source\blockgen.cpp" />
<ClCompile Include="..\source\symfile.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\source\bctypes.h" />
<ClInclude Include="..\source\memstream.h" />
<ClInclude Include="..\source\symfile.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

26
bin/blockgen/vcxproj/blockgen.vcxproj.filters
View file

@ -1,26 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\source\blockgen.cpp" />
<ClCompile Include="..\source\symfile.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\source\bctypes.h">
<Filter>Source Files</Filter>
</ClInclude>
<ClInclude Include="..\source\memstream.h">
<Filter>Source Files</Filter>
</ClInclude>
<ClInclude Include="..\source\symfile.h">
<Filter>Source Files</Filter>
</ClInclude>
</ItemGroup>
</Project>

BIN
bin/overlayhelper.exe
View file

Binary file not shown.

49
bin/overlayhelper/Makefile
View file

@ -1,49 +0,0 @@
#
# overlayhelper/Makefile
#
# Make and Build Variables
VPATH = source:obj
SOURCEFILES = $(wildcard source/*.cpp)
OBJFILES = $(patsubst source/%.cpp,obj/%.o,$(SOURCEFILES))
CC = clang++
INCCMD = -Isource
# List of directories to create
DIRS=obj
CFLAGS = -std=c++17 -Os -Wall -Werror
#CFLAGS = -Os -Wall -Werror -S
help:
@echo
@echo overlayhelper Makefile
@echo -------------------------------------------------
@echo build commands:
@echo make install - Compile / Install
@echo make clean - Clean intermediate/target files
@echo -------------------------------------------------
@echo
overlayhelper: $(OBJFILES)
install: overlayhelper
$(CC) -o ../oh $(OBJFILES)
# $(CC) -o ../overlayhelper $(OBJFILES) -Wl,-Map,overlayhelper.map
clean:
@echo Remove overlayhelper
$(shell if exist overlayhelper echo Y | rm overlayhelper)
@echo Remove Intermediate Files
@rm obj\*
# Goofy Object File Rule
obj/%.o : source/%.cpp
@echo Compiling $(<F)
$(CC) $(CFLAGS) $(INCCMD) -c $< -o obj/$*.o
# Create all the directories
$(shell if not exist $(DIRS) mkdir $(DIRS))

48
bin/overlayhelper/source/bctypes.h
View file

@ -1,48 +0,0 @@
/*
bctypes.h
Because I need Standard Types
*/
#ifndef _bctypes_h
#define _bctypes_h
typedef signed char i8;
typedef unsigned char u8;
typedef signed short i16;
typedef unsigned short u16;
typedef signed long i32;
typedef unsigned long u32;
typedef signed long long i64;
typedef unsigned long long u64;
// If we're using C, I still like having a bool around
#ifndef __cplusplus
typedef i32 bool;
#define false (0)
#define true (!false)
#define nullptr 0
#endif
typedef float f32;
typedef float r32;
typedef double f64;
typedef double r64;
#define null (0)
// Odd Types
typedef union {
// u128 ul128;
u64 ul64[2];
u32 ui32[4];
} QWdata;
#endif // _bctypes_h
// EOF - bctypes.h

220
bin/overlayhelper/source/cfile.cpp
View file

@ -1,220 +0,0 @@
//
// cfile.cpp
//
#include "cfile.h"
#ifdef __STDC_LIB_EXT1__
#define __STDC_WANT_LIB_EXT1__ 1
#endif
#include <stdio.h>
//------------------------------------------------------------------------------
// Static Helpers
static bool contains(char x, const char* pSeparators)
{
while (*pSeparators)
{
if (x == *pSeparators)
{
return true;
}
pSeparators++;
}
return false;
}
static std::vector<std::string> split(const std::string& s, const char* separators)
{
std::vector<std::string> output;
std::string::size_type prev_pos = 0, pos = 0;
for (int index = 0; index < s.length(); ++index)
{
pos = index;
// if the index is a separator
if (contains(s[index], separators))
{
// if we've skipped a token, collect it
if (prev_pos != index)
{
output.push_back(s.substr(prev_pos, index-prev_pos));
// skip white space here
while (index < s.length())
{
if (contains(s[index], separators))
{
++index;
}
else
{
prev_pos = index;
pos = index;
break;
}
}
}
else
{
prev_pos++;
}
}
}
output.push_back(s.substr(prev_pos, pos-prev_pos+1)); // Last word
return output;
}
#if 0
// make this string lowercase
static void tolower(std::string& s)
{
for (int index = 0; index < s.length(); ++index)
{
s[index] = tolower( s[index] );
}
}
#endif
static std::string next_token(std::vector<std::string>& tokens, MemoryStream& memStream)
{
std::string result = "";
if (tokens.size() >= 1)
{
result = tokens[0];
tokens.erase(tokens.cbegin());
}
else
{
while (memStream.NumBytesAvailable())
{
std::string lineData = memStream.ReadLine();
tokens = split(lineData, "[](), \t");
if (tokens.size() >= 1)
{
return next_token(tokens, memStream);
}
}
}
return result;
}
//------------------------------------------------------------------------------
CFile::CFile( std::string filepath )
: m_filepath( filepath )
{
FILE* pFile = nullptr;
#ifdef __STDC_LIB_EXT1__
int err = fopen_s(&pFile, filepath.c_str(), "rb");
#else
int err = 0;
pFile = fopen(filepath.c_str(), "rb");
#endif
if ((0==err) && (nullptr!=pFile))
{
fseek(pFile, 0, SEEK_END);
size_t length = ftell(pFile);
fseek(pFile, 0, SEEK_SET);
//printf("\n// CFile %s - %lld bytes\n", filepath.c_str(), length);
//printf("// Reading %s\n", filepath.c_str());
//printf("//\n");
//printf("// This file generated by overlayhelper.exe\n");
//printf("//\n");
//printf("//\n");
u8* pData = new u8[ length ];
fread(pData, sizeof(u8), length / sizeof(u8), pFile);
// Now we have a buffer, with the whole C File
// Looking to parse 2 types of things
// CODE_BLOCK macros
// DATA_BLOCK macros
// INCBIN macros
{
MemoryStream memStream(pData, length);
while (memStream.NumBytesAvailable())
{
std::string lineData = memStream.ReadLine();
// symbols are case sensitive
// we care about the first 32 bit value in hex, and the last value on the line, the symbol
std::vector<std::string> tokens = split(lineData, "[](), \t");
if (tokens.size() >= 2)
{
std::string token = next_token(tokens, memStream);
if (token == "INCBIN")
{
// section
token = next_token(tokens, memStream);
token = next_token(tokens, memStream);
printf("incbin_%s_start_high = incbin_%s_start>>16;\n", token.c_str(),token.c_str());
printf("incbin_%s_start_BLOCK = incbin_%s_start/0x2000;\n", token.c_str(),token.c_str());
printf("incbin_%s_length = incbin_%s_end-incbin_%s_start;\n", token.c_str(),token.c_str(),token.c_str());
printf("incbin_%s_length_high = incbin_%s_length>>16;\n", token.c_str(),token.c_str());
}
else if ( (token == "CODE_BLOCK") ||
(token == "DATA_BLOCK") )
{
// We aren't as good as the C Preprocessor, but we will allow this
// to span 1 line, because RickJr has weird syntax
// First get the block number
token = next_token(tokens, memStream);
u32 block_num = strtoul(token.c_str(), nullptr, 0);
// Next we need the function name
do
{
token = next_token(tokens, memStream);
} while (token=="static" || token =="volatile");
// now token has return type
token = next_token(tokens, memStream);
// now token finally has our function or data name
printf("%s_BLOCK = %lu;\n", token.c_str(), block_num); // just need the block number for mapper
}
}
}
}
delete[] pData;
fclose(pFile);
//printf("\n// Read Completed\n");
}
else
{
printf("// CFile could not open %s\n", filepath.c_str());
printf("//\n");
}
}
//------------------------------------------------------------------------------
CFile::~CFile()
{
}
//------------------------------------------------------------------------------

27
bin/overlayhelper/source/cfile.h
View file

@ -1,27 +0,0 @@
//
// CFile Class
//
#ifndef CFILE_H_
#define CFILE_H_
#include <string>
#include <vector>
#include "bctypes.h"
#include "memstream.h"
//------------------------------------------------------------------------------
class CFile
{
public:
CFile( std::string filepath );
~CFile();
private:
std::string m_filepath;
};
#endif // CFILE_H_

164
bin/overlayhelper/source/memstream.h
View file

@ -1,164 +0,0 @@
//
// Jason's Memory Stream Helper thing
// Serialize a byte stream into real types
//
// Currently only support Little Endian
//
#ifndef MEMSTREAM_H_
#define MEMSTREAM_H_
#include <string>
// Prototypes
void *memcpy(void *dest, const void *src, size_t n);
class MemoryStream
{
public:
MemoryStream(unsigned char* pStreamStart, size_t streamSize)
: m_pStreamStart( pStreamStart )
, m_streamSize(streamSize)
, m_pStreamCurrent( pStreamStart )
{}
~MemoryStream()
{
m_pStreamStart = nullptr;
m_streamSize = 0;
m_pStreamCurrent = nullptr;
}
// Really Dumb Reader Template
template <class T>
T Read()
{
T result;
memcpy(&result, m_pStreamCurrent, sizeof(T));
m_pStreamCurrent += sizeof(T);
return result;
}
template <class T>
void Read(T& result)
{
memcpy(&result, m_pStreamCurrent, sizeof(result));
m_pStreamCurrent += sizeof(result);
}
void ReadBytes(u8* pDest, size_t numBytes)
{
memcpy(pDest, m_pStreamCurrent, numBytes);
m_pStreamCurrent += numBytes;
}
std::string ReadPString()
{
std::string result;
u8 length = *m_pStreamCurrent++;
result.insert(0, (char*)m_pStreamCurrent, (size_t)length);
m_pStreamCurrent += length;
return result;
}
std::string ReadLine()
{
unsigned char* pStreamEnd = m_pStreamStart + m_streamSize;
std::string result;
u8 *pEndOfLine = m_pStreamCurrent;
while (pEndOfLine < pStreamEnd)
{
if ((0x0a != *pEndOfLine) && (0x0d != *pEndOfLine))
{
pEndOfLine++;
}
else
{
break;
}
}
size_t length = pEndOfLine - m_pStreamCurrent;
if (length)
{
// Capture the line
result.insert(0, (char*)m_pStreamCurrent, (size_t)length);
m_pStreamCurrent += length;
}
// Figure out if that loop broke out because we hit the end of the file
while (pEndOfLine < pStreamEnd)
{
if ((0x0a == *pEndOfLine) || (0x0d == *pEndOfLine))
{
pEndOfLine++;
}
else
{
break;
}
}
m_pStreamCurrent = pEndOfLine;
if (m_pStreamCurrent > pStreamEnd)
{
m_pStreamCurrent = pStreamEnd;
}
return result;
}
size_t SeekCurrent(int delta)
{
m_pStreamCurrent += delta;
return m_pStreamCurrent - m_pStreamStart;
}
size_t SeekSet(size_t offset)
{
m_pStreamCurrent = m_pStreamStart + offset;
return m_pStreamCurrent - m_pStreamStart;
}
unsigned char* GetPointer() { return m_pStreamCurrent; }
size_t NumBytesAvailable() {
unsigned char* pStreamEnd = m_pStreamStart + m_streamSize;
if (pStreamEnd - m_pStreamCurrent >= 0)
{
return pStreamEnd - m_pStreamCurrent;
}
else
{
return 0;
}
}
private:
unsigned char* m_pStreamStart;
size_t m_streamSize;
unsigned char* m_pStreamCurrent;
};
#endif // MEMSTREAM_H_

70
bin/overlayhelper/source/overlayhelper.cpp
View file

@ -1,70 +0,0 @@
// overlayhelper
//
// - generate linker script crap, so that we can resolve addresses larger
// than 32-bit with mos llvm (hacky work around for 16 bit address linker)
#include <stdio.h>
#include <stdlib.h>
#include "cfile.h"
//------------------------------------------------------------------------------
void helpText()
{
printf("overlayhelper - v1.0\n");
printf("--------------------\n");
printf("Convert macros found in C code, into mos-llvm .ld linker format\n");
printf("\noverlayhelper [options] <file.c>\n");
printf(" -v verbose\n\n");
exit(-1);
}
//------------------------------------------------------------------------------
int main(int argc, char* argv[])
{
char* pInfilePath = nullptr;
bool bVerbose = false;
for (int idx = 1; idx < argc; ++idx )
{
char* arg = argv[ idx ];
if ('-' == arg[0])
{
// Parse as an option
if ('v'==arg[1])
{
bVerbose = true;
}
}
else if (nullptr == pInfilePath)
{
// Assume the first non-option is an input file path
pInfilePath = argv[ idx ];
}
else
{
// Oh Crap, we have a non-option, but we don't know what to do with
// it
printf("ERROR: Invalid option, Arg %d = %s\n\n", idx, argv[ idx ]);
helpText();
}
}
if (pInfilePath)
{
// Load the .c File
CFile *pCFile = new CFile(std::string(pInfilePath));
delete pCFile;
}
else
{
helpText();
}
return 0;
}

31
bin/overlayhelper/vcxproj/overlayhelper.sln
View file

@ -1,31 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.8.34309.116
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "overlayhelper", "overlayhelper.vcxproj", "{77D5186F-C388-4740-8BA7-23997A659FB8}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{77D5186F-C388-4740-8BA7-23997A659FB8}.Debug|x64.ActiveCfg = Debug|x64
{77D5186F-C388-4740-8BA7-23997A659FB8}.Debug|x64.Build.0 = Debug|x64
{77D5186F-C388-4740-8BA7-23997A659FB8}.Debug|x86.ActiveCfg = Debug|Win32
{77D5186F-C388-4740-8BA7-23997A659FB8}.Debug|x86.Build.0 = Debug|Win32
{77D5186F-C388-4740-8BA7-23997A659FB8}.Release|x64.ActiveCfg = Release|x64
{77D5186F-C388-4740-8BA7-23997A659FB8}.Release|x64.Build.0 = Release|x64
{77D5186F-C388-4740-8BA7-23997A659FB8}.Release|x86.ActiveCfg = Release|Win32
{77D5186F-C388-4740-8BA7-23997A659FB8}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {4AE0A6E5-5981-4BAE-96E2-DDD5656B0B2E}
EndGlobalSection
EndGlobal

147
bin/overlayhelper/vcxproj/overlayhelper.vcxproj
View file

@ -1,147 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>17.0</VCProjectVersion>
<Keyword>Win32Proj</Keyword>
<ProjectGuid>{77d5186f-c388-4740-8ba7-23997a659fb8}</ProjectGuid>
<RootNamespace>overlayhelper</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<OutDir>$(SolutionDir)\..\..</OutDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<OutDir>$(SolutionDir)\..\..</OutDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="..\source\bctypes.h" />
<ClInclude Include="..\source\cfile.h" />
<ClInclude Include="..\source\memstream.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\source\cfile.cpp" />
<ClCompile Include="..\source\overlayhelper.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

26
bin/overlayhelper/vcxproj/overlayhelper.vcxproj.filters
View file

@ -1,26 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\source\bctypes.h">
<Filter>Source Files</Filter>
</ClInclude>
<ClInclude Include="..\source\cfile.h">
<Filter>Source Files</Filter>
</ClInclude>
<ClInclude Include="..\source\memstream.h">
<Filter>Source Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\source\cfile.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\source\overlayhelper.cpp" />
</ItemGroup>
</Project>

BIN
data/credits.256
View file

Binary file not shown.

BIN
data/credits.png
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 4.5 KiB

BIN
lib/i256.flib
View file

Binary file not shown.

183
rickjr.ld
View file

@ -1,183 +0,0 @@
/* RickJr Linker Script
*/
/*
TARGET(binary)
INPUT(./data/congrats.256)
INPUT(./data/haf.256)
INPUT(./data/splash.256)
INPUT(./data/sprites_data.256)
INPUT(./data/tiles_data.256)
*/
/* fake C Stack */
PROVIDE(__stack = 0xA000);
/* entry point to my program */
PROVIDE(__f256_start = 0x300);
/* page size of a block of memory */
PROVIDE(__BLOCK_SIZE = 0x2000);
/* swappable block address */
PROVIDE(__SLOT_ADDR = 0xA000);
/* f256k uses first 16 bytes of ZP for mmu control? */
__rc0 = 0x10;
INCLUDE imag-regs.ld
ASSERT(__rc0 == 0x10, "Inconsistent zero page map.")
ASSERT(__rc31 == 0x2f, "Inconsistent zero page map.")
MEMORY {
/* kernel uses 0xf0-0xff for parameter passing */
zp : ORIGIN = __rc31 + 1, LENGTH = 0xF0 - (__rc31 + 1)
ram (rw) : ORIGIN = __f256_start, LENGTH = 0xA000-__f256_start
}
/* LMAs */
__block8_lma = ( 8<<24)|__SLOT_ADDR;
__block9_lma = ( 9<<24)|__SLOT_ADDR;
__block10_lma = (10<<24)|__SLOT_ADDR;
__block11_lma = (11<<24)|__SLOT_ADDR;
__block12_lma = (12<<24)|__SLOT_ADDR;
__block13_lma = (13<<24)|__SLOT_ADDR;
__block14_lma = (14<<24)|__SLOT_ADDR;
__block15_lma = (15<<24)|__SLOT_ADDR;
__block16_lma = (16<<24)|__SLOT_ADDR;
__block17_lma = (17<<24)|__SLOT_ADDR;
__block18_lma = (18<<24)|__SLOT_ADDR;
__block19_lma = (19<<24)|__SLOT_ADDR;
__block20_lma = (20<<24)|__SLOT_ADDR;
__block21_lma = (21<<24)|__SLOT_ADDR;
__block22_lma = (22<<24)|__SLOT_ADDR;
__block23_lma = (23<<24)|__SLOT_ADDR;
/* Stash preloaded binary data */
__binarydata_lma = 0x70000; /* At least now, its less than 64k */
__BINARYDATA_SIZE = 0x10000;
MEMORY {
binarydata : ORIGIN = __binarydata_lma, LENGTH = __BINARYDATA_SIZE
block8 : ORIGIN = __block8_lma, LENGTH = __BLOCK_SIZE
block9 : ORIGIN = __block9_lma, LENGTH = __BLOCK_SIZE
block10 : ORIGIN = __block10_lma, LENGTH = __BLOCK_SIZE
block11 : ORIGIN = __block11_lma, LENGTH = __BLOCK_SIZE
block12 : ORIGIN = __block12_lma, LENGTH = __BLOCK_SIZE
block13 : ORIGIN = __block13_lma, LENGTH = __BLOCK_SIZE
block14 : ORIGIN = __block14_lma, LENGTH = __BLOCK_SIZE
block15 : ORIGIN = __block15_lma, LENGTH = __BLOCK_SIZE
block16 : ORIGIN = __block16_lma, LENGTH = __BLOCK_SIZE
block17 : ORIGIN = __block17_lma, LENGTH = __BLOCK_SIZE
block18 : ORIGIN = __block18_lma, LENGTH = __BLOCK_SIZE
block19 : ORIGIN = __block19_lma, LENGTH = __BLOCK_SIZE
block20 : ORIGIN = __block20_lma, LENGTH = __BLOCK_SIZE
block21 : ORIGIN = __block21_lma, LENGTH = __BLOCK_SIZE
block22 : ORIGIN = __block22_lma, LENGTH = __BLOCK_SIZE
block23 : ORIGIN = __block23_lma, LENGTH = __BLOCK_SIZE
}
REGION_ALIAS("c_writeable", ram)
/* REGION_ALIAS("c_readonly", fixed) */
/* I want to use the lower 40k */
REGION_ALIAS("c_readonly", ram)
SECTIONS {
INCLUDE c.ld
.binarydata : { *(.binarydata .binarydata.*) } >binarydata end_binarydata = .;
.block8 : { *(.block8 .block8.*) } >block8 end_block8 = .;
.block9 : { *(.block9 .block9.*) } >block9 end_block9 = .;
.block10 : { *(.block10 .block10.*) } >block10 end_block10 = .;
.block11 : { *(.block11 .block11.*) } >block11 end_block11 = .;
.block12 : { *(.block12 .block12.*) } >block12 end_block12 = .;
.block13 : { *(.block13 .block13.*) } >block13 end_block13 = .;
.block14 : { *(.block14 .block14.*) } >block14 end_block14 = .;
.block15 : { *(.block15 .block15.*) } >block15 end_block15 = .;
.block16 : { *(.block16 .block16.*) } >block16 end_block16 = .;
.block17 : { *(.block17 .block17.*) } >block17 end_block17 = .;
.block18 : { *(.block18 .block18.*) } >block18 end_block18 = .;
.block19 : { *(.block19 .block19.*) } >block19 end_block19 = .;
.block20 : { *(.block20 .block20.*) } >block20 end_block20 = .;
.block21 : { *(.block21 .block21.*) } >block21 end_block21 = .;
.block22 : { *(.block22 .block22.*) } >block22 end_block22 = .;
.block23 : { *(.block23 .block23.*) } >block23 end_block23 = .;
}
/* Trick linker into exposing symbols with values larger than 16 bits */
INCLUDE overlay.ld
/* OUTPUT_FORMAT { FULL(cart_rom) } */
OUTPUT_FORMAT {
BYTE(0x5A) /* pgZ */
/* ram segment */
SHORT(ORIGIN(ram)) /* where to load it, 24 bits */
BYTE(0x00)
SHORT(__bss_start-ORIGIN(ram)) /* size to load */
BYTE(0x00)
TRIM(ram)
/* block8 */
SHORT(8*0x2000)
BYTE(8/8) /* block#/8 = the actual system high byte */
SHORT(end_block8 - __block8_lma)
BYTE(0x00)
TRIM(block8)
/* block9 */
SHORT(9*0x2000)
BYTE(9/8) /* block#/8 = the actual system high byte */
SHORT(end_block9 - __block9_lma)
BYTE(0x00)
TRIM(block9)
/* block10 */
SHORT(10*0x2000)
BYTE(10/8) /* block#/8 = the actual system high byte */
SHORT(end_block10 - __block10_lma)
BYTE(0x00)
TRIM(block10)
/* block11 */
SHORT(11*0x2000)
BYTE(11/8) /* block#/8 = the actual system high byte */
SHORT(end_block11 - __block11_lma)
BYTE(0x00)
TRIM(block11)
/*
Empty Blocks are not allowed, bring these in as you use them
TRIM(block12)
TRIM(block13)
TRIM(block14)
TRIM(block15)
TRIM(block16)
TRIM(block17)
TRIM(block18)
TRIM(block19)
TRIM(block20)
TRIM(block21)
TRIM(block22)
TRIM(block23)
*/
/* Compressed Data */
SHORT(ORIGIN(binarydata))
BYTE(ORIGIN(binarydata)>>16)
SHORT(end_binarydata - __binarydata_lma)
BYTE((end_binarydata - __binarydata_lma)>>16)
TRIM(binarydata)
/* Launch the program, at _start */
SHORT(_start)
LONG(0)
}

6
src/dat_ents.c
View file

@ -19,7 +19,7 @@
segment "dat"; segment "dat";
#endif #endif
DATA_BLOCK(10) entdata_t ent_entdata[ENT_NBR_ENTDATA] = { entdata_t ent_entdata[ENT_NBR_ENTDATA] = {
{0000, 0000, 000000, 000000, 0000, 0000, 0x00}, {0000, 0000, 000000, 000000, 0000, 0000, 0x00},
{0x18, 0x15, 000000, 000000, 0000, 0000, 0x00}, {0x18, 0x15, 000000, 000000, 0000, 0000, 0x00},
{0000, 0000, 000000, 000000, 0000, 0000, 0x00}, {0000, 0000, 000000, 000000, 0000, 0000, 0x00},
@ -101,7 +101,7 @@ DATA_BLOCK(10) entdata_t ent_entdata[ENT_NBR_ENTDATA] = {
{0x18, 0x10, 0x000c, 0x0005, 0x04, 0x04, 0x14}, {0x18, 0x10, 0x000c, 0x0005, 0x04, 0x04, 0x14},
}; };
DATA_BLOCK(10) U8 ent_sprseq[ENT_NBR_SPRSEQ] = { U8 ent_sprseq[ENT_NBR_SPRSEQ] = {
0000, 0x01, 0000, 0x02, 0x05, 0x03, 0x04, 0x03, 0000, 0x01, 0000, 0x02, 0x05, 0x03, 0x04, 0x03,
0x65, 0xff, 0x66, 0xff, 0x55, 0xff, 0000, 0x56, 0x65, 0xff, 0x66, 0xff, 0x55, 0xff, 0000, 0x56,
0xff, 0000, 0x57, 0xff, 0000, 0x58, 0x59, 0xff, 0xff, 0000, 0x57, 0xff, 0000, 0x58, 0x59, 0xff,
@ -122,7 +122,7 @@ DATA_BLOCK(10) U8 ent_sprseq[ENT_NBR_SPRSEQ] = {
0xff, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xff, 0x00, 0xff, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xff, 0x00,
}; };
DATA_BLOCK(10) mvstep_t ent_mvstep[ENT_NBR_MVSTEP] = { mvstep_t ent_mvstep[ENT_NBR_MVSTEP] = {
{ 0x10, 0, 0 } , { 0x10, 0, 0 } ,
{ 0x0c, 0, 4 } , { 0x0c, 0, 4 } ,
{ 0xfa, 0, 0 } , { 0xfa, 0, 0 } ,

12
src/dat_maps.c
View file

@ -19,7 +19,7 @@ segment "dat";
#include "system.h" #include "system.h"
#include "maps.h" #include "maps.h"
DATA_BLOCK(9) map_t map_maps[MAP_NBR_MAPS] = { map_t map_maps[MAP_NBR_MAPS] = {
#ifdef IIGS #ifdef IIGS
{0x0008, 0x008b, 0x0008, 000000, &samerica_lz4}, {0x0008, 0x008b, 0x0008, 000000, &samerica_lz4},
{0x0008, 0x008b, 0x0068, 0x0009, &egypt_lz4}, {0x0008, 0x008b, 0x0068, 0x0009, &egypt_lz4},
@ -35,7 +35,7 @@ DATA_BLOCK(9) map_t map_maps[MAP_NBR_MAPS] = {
#endif #endif
}; };
DATA_BLOCK(9) submap_t map_submaps[MAP_NBR_SUBMAPS] = { submap_t map_submaps[MAP_NBR_SUBMAPS] = {
{000000, 000000, 000000, 000000}, {000000, 000000, 000000, 000000},
{000000, 0x0078, 0x0003, 0x0005}, {000000, 0x0078, 0x0003, 0x0005},
{000000, 0x0150, 0x0006, 0x0011}, {000000, 0x0150, 0x0006, 0x0011},
@ -85,7 +85,7 @@ DATA_BLOCK(9) submap_t map_submaps[MAP_NBR_SUBMAPS] = {
{0x0001, 0x1f5a, 0x0096, 0x0202}, {0x0001, 0x1f5a, 0x0096, 0x0202},
}; };
DATA_BLOCK(9) connect_t map_connect[MAP_NBR_CONNECT] = { connect_t map_connect[MAP_NBR_CONNECT] = {
/* map 0 */ /* map 0 */
@ -1322,7 +1322,7 @@ U8 map_bnums[MAP_NBR_BNUMS] = {
0xc0, 0xc0, 0000, 0000, 0000, 0000, 0000, 0000, 0xc0, 0xc0, 0000, 0000, 0000, 0000, 0000, 0000,
}; };
DATA_BLOCK(9) block_t map_blocks[MAP_NBR_BLOCKS] = { block_t map_blocks[MAP_NBR_BLOCKS] = {
{0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, {0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000,
0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000}, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000},
{0x29, 0x2a, 0x2d, 0x2e, 0x2b, 0x2c, 0x2f, 0x30, {0x29, 0x2a, 0x2d, 0x2e, 0x2b, 0x2c, 0x2f, 0x30,
@ -1837,7 +1837,7 @@ DATA_BLOCK(9) block_t map_blocks[MAP_NBR_BLOCKS] = {
0x22, 0x2d, 0x2e, 0xe7, 0x28, 0x2b, 0x2c, 0xea}, 0x22, 0x2d, 0x2e, 0xe7, 0x28, 0x2b, 0x2c, 0xea},
}; };
DATA_BLOCK(9) mark_t map_marks[MAP_NBR_MARKS] = { mark_t map_marks[MAP_NBR_MARKS] = {
{0x18, 0x16, 0000, 0x08, 0x08}, /* 0 */ {0x18, 0x16, 0000, 0x08, 0x08}, /* 0 */
{0x18, 0x2a, 0x88, 0x01, 0x28}, {0x18, 0x2a, 0x88, 0x01, 0x28},
{0x38, 0x04, 0xf0, 0x15, 0x29}, {0x38, 0x04, 0xf0, 0x15, 0x29},
@ -2363,7 +2363,7 @@ DATA_BLOCK(9) mark_t map_marks[MAP_NBR_MARKS] = {
{0xff, 0000, 0000, 0000, 0000}, {0xff, 0000, 0000, 0000, 0000},
}; };
DATA_BLOCK(9) U8 map_eflg_c[MAP_NBR_EFLGC] = { U8 map_eflg_c[MAP_NBR_EFLGC] = {
0x4d, 0000, 0x0e, 0x02, 0x04, 0x04, 0x57, 0x08, 0x4d, 0000, 0x0e, 0x02, 0x04, 0x04, 0x57, 0x08,
0x08, 0x18, 0x03, 0x68, 0x3b, 0x48, 0x04, 0x80, 0x08, 0x18, 0x03, 0x68, 0x3b, 0x48, 0x04, 0x80,
0x37, 0000, 0x04, 0x02, 0x04, 0x04, 0x90, 0x08, 0x37, 0000, 0x04, 0x02, 0x04, 0x04, 0x90, 0x08,

57
src/dat_spritesJR.c
View file

@ -1,57 +0,0 @@
/*
* xrick/data/dat-sprites.c
*
* Copyright (C) 1998-2002 BigOrno (bigorno@bigorno.net). All rights reserved.
*
* The use and distribution terms for this software are contained in the file
* named README, which can be found in the root of this distribution. By
* using this software in any fashion, you are agreeing to be bound by the
* terms of this license.
*
* You must not remove this notice, or any other, from this software.
*/
#include "config.h"
#ifdef GFXF256
// $$TODO - move this macro into it's own header
#define STR2(x) #x
#define STR(x) STR2(x)
// this aligns start address to 16 and terminates byte array with explict 0
// which is not really needed, feel free to change it to whatever you want/need
#define INCBIN(INCBIN_SECTION, name, file) \
__asm__(".section " INCBIN_SECTION ",\"aR\" \n" \
".global incbin_" STR(name) "_start\n" \
".balign 16\n" \
"incbin_" STR(name) "_start:\n" \
".incbin \"" file "\"\n" \
\
".global incbin_" STR(name) "_end\n" \
".balign 1\n" \
"incbin_" STR(name) "_end:\n" \
".byte 0\n" \
); \
extern __attribute__((aligned(16))) const char incbin_ ## name ## _start[]; \
extern const char incbin_ ## name ## _end[]
// Credits/Jr Title
INCBIN(".binarydata.credits", credits_256, "data/credits.256");
// Title Page
INCBIN(".binarydata.splash", splash_256, "data/splash.256");
// Map Tiles
INCBIN(".binarydata.tiles", tiles_256, "data/tiles_data.256");
// Sprite Frames (32x32 sprites)
INCBIN(".binarydata.sprites", sprites_256, "data/sprites_data.256");
// Hall of Fame
INCBIN(".binarydata.haf", haf_256, "data/haf.256");
// Congrats
INCBIN(".binarydata.haf", congrats_256, "data/congrats.256");
INCBIN(".block11.i256", i256lib, "lib/i256.flib");
#endif /* GFXF256 */
/* eof */

29
src/mapper.h
View file

@ -1,29 +0,0 @@
/*
Special mapper macros for the F256 + mos-llvm, so we can put code
anywhere in physical ram
Currently only blocks 8-23 are defined in the linker file
If you need to go beyond the 128k of extra code, just add more definitions
into rickjr.ld
*/
#if defined(F256) && F256
/*
$$JGA TODO, sort out how to mark an entire file
*/
#define CODE_BLOCK(index) __attribute__((noinline, section(".block"#index)))
#define DATA_BLOCK(index) __attribute__((section(".block"#index)))
#define PAGEIN(_function_BLOCK) POKE(SWAP_SLOT, _function_BLOCK)
#else
#define CODE_BLOCK(index)
#define DATA_BLOCK(index)
#define PAGEIN(_function_BLOCK)
#endif

20
src/scr_credit.c
View file

@ -13,27 +13,9 @@ segment "screen";
#endif #endif
extern char credits_lz4; extern char credits_lz4;
extern char incbin_sprites_256_start[];
extern char incbin_sprites_256_start_high[];
extern char incbin_tiles_256_start[];
extern char incbin_splash_256_start[];
extern char __block23_lma_high[];
//extern char scr_credit_BLOCK[];
extern const char scr_credit_BLOCK;
CODE_BLOCK(8) void scr_credit() void scr_credit()
{ {
#ifdef F256
//$$JGA TODO - fix this
*((char*)0x200) = (char)(((long)(&incbin_sprites_256_start)));
*((char*)0x201) = (char)(((long)(&incbin_sprites_256_start))>>8);
*((char*)0x202) = (char)(((long)(&incbin_sprites_256_start_high)));
// *((char*)0x203) = (char)(((long)(&scr_credit_BLOCK)));
*((char*)0x203) = scr_credit_BLOCK;
// *((char*)0x203) = (char)(((long)(__block23_lma_high))>>8);
#endif
#ifdef IIGS #ifdef IIGS
// Keep the Screen on // Keep the Screen on
*VIDEO_REGISTER|=0xC0; *VIDEO_REGISTER|=0xC0;

5
src/system.c
View file

@ -34,6 +34,9 @@
void puts(char* c_str) void puts(char* c_str)
{ {
} }
void __putchar(char c)
{
}
#endif #endif
@ -138,7 +141,7 @@ sys_sleep(int s)
/* /*
* Initialize system * Initialize system
*/ */
CODE_BLOCK(8) void void
sys_init(int argc, char **argv) sys_init(int argc, char **argv)
{ {
sysarg_init(argc, argv); sysarg_init(argc, argv);