int startVM() {
fillCode( "mcode.txt" );
FILE* file = fopen("stacktrace.txt","w");
if ( file == NULL) {
printf("Could not open file\n");
exit(1);
}
printCode( file );
fprintf(file, "Line OP L M pc bp sp stack \n");
fprintf(file, "----------------------------------------\n");
fprintf(file, "Init Values: 0 1 0 \n");
/*instruction cycle*/
//while instruction is not halt
while ( halt == 0) {
fetch();
execute();
printInstructionTrace(file);
}
fclose( file );
return 0;
}
/***************************************************************************
print ASCII code to matrix display
***************************************************************************/
void _putchar(int8_t c)
{
uint8_t k;
if((c>='0')&&(c<='9'))k=c-'0'; // 0..9
if((c>='A')&&(c<='Z'))k=c-'A'+13;
if((c>='a')&&(c<='z'))k=c-'a'+13;
printCode(k);
}
void SpTraceVcd::fullFloat (uint32_t code, const float newval) {
(*((float*)&m_sigs_oldvalp[code])) = newval;
// Buffer can't overflow before sprintf; we sized during declaration
sprintf(m_writep, "r%.16g", (double)newval);
m_writep += strlen(m_writep);
*m_writep++=' '; printCode(code); *m_writep++='\n';
bufferCheck();
}
void VerilatedVcd::fullFloat (vluint32_t code, const float newval) {
(*((float*)&m_sigs_oldvalp[code])) = newval;
// Buffer can't overflow; we have at least bufferInsertSize() bytes (>>>16 bytes)
sprintf(m_writep, "r%.16g", (double)newval);
m_writep += strlen(m_writep);
*m_writep++=' '; printCode(code); *m_writep++='\n';
bufferCheck();
}
static void
DECLARE4(emitcode, TIFF*, tif, int, dx, int, x, int, count)
{
CodeEntry* thisCode;
switch (fax.pass) {
case 1: /* count potential code & pair use */
thisCode = enterCode(x-dx, count);
thisCode->c.count++;
if (dopairs) {
if (fax.lastCode)
enterPair(fax.lastCode, thisCode)->c.count++;
fax.lastCode = thisCode;
}
break;
case 2: /* rescan w/ potential codes */
thisCode = enterCode(x-dx, count);
if (fax.lastCode) {
CodePairEntry* pair = findPair(fax.lastCode, thisCode);
if (pair) {
pair->c.count++;
fax.lastCode = 0;
} else {
fax.lastCode->c.count++;
fax.lastCode = thisCode;
}
} else
fax.lastCode = thisCode;
break;
case 3: /* generate encoded output */
thisCode = enterCode(x-dx, count);
if (dopairs) {
if (fax.lastCode) {
if (!printPair(tif, fax.lastCode, thisCode)) {
printCode(tif, fax.lastCode);
fax.lastCode = thisCode;
} else
fax.lastCode = 0;
} else
fax.lastCode = thisCode;
} else
printCode(tif, thisCode);
break;
}
}
void print(iter const & R) const
{
for ( int64_t i = minsym; i <= maxsym; ++i )
if ( codeused[i-minsym] )
::std::cerr << static_cast<char>(R[i]) << "\t"
<< printCode( i )
<< "\t"
<< (*this)[i].second << ::std::endl;
}
void print() const
{
for ( int64_t i = minsym; i <= maxsym; ++i )
if ( codeused[i-minsym] )
::std::cerr << i << "\t"
<< printCode( i )
<< "\t"
<< (*this)[i].second << ::std::endl;
}
/* 全命令列の表示 */
void printCodeList(void)
{
int i;
printf("Code List: \n");
for (i = 0; i <= current_code_size; i++) {
printf("%4d: ", i);
printCode(i);
}
}
void MastermindGame::startGuessing()
{
while (numberOfGuesses < MAX_GUESSES)
{
printf("Code Breaker, you have %i guesses left!\n", MAX_GUESSES - numberOfGuesses++);
Code guess;
cin >> guess;
if (checkCorrect(guess))
{
printCode(true);
return;
}
else
respondToGuess(guess);
}
printCode(false);
}
bool ExtAudioFileAudioSource::init(const RString& path, bool loadIntoMemory)
{
if(mLoadedInMemory && loadIntoMemory)
return true;
// FIXME: query the file to find out how many channels instead of hardcoding.
CFURLRef path_url = CFURLCreateFromFileSystemRepresentation (kCFAllocatorDefault,
(const UInt8*)path.data(),
path.length(),
false
);
OSStatus err = ExtAudioFileOpenURL(path_url, &mAudioFile);
if(err)
{
printCode("ExtAudioFileOpenURL: ", err);
return false;
}
UInt32 propSize = sizeof(mClientFormat);
err = ExtAudioFileGetProperty(mAudioFile, kExtAudioFileProperty_FileDataFormat, &propSize, &mClientFormat);
propSize = sizeof(mTotalFrames);
err = ExtAudioFileGetProperty(mAudioFile, kExtAudioFileProperty_FileLengthFrames, &propSize, &mTotalFrames);
// Setup output format
FillOutASBDForLPCM(mFormat, getSampleRate(), getNumChannels(), 32, 32, true, false,true);
err = ExtAudioFileSetProperty(mAudioFile, kExtAudioFileProperty_ClientDataFormat, sizeof(mFormat), &mFormat);
if(err)
{
printCode("ExtAudioFileSetProperty: ", err);
return false;
}
// Allocate our buffer list with NUM_CHANNELS buffers in it.
mpBufferList = (AudioBufferList *)malloc(sizeof(AudioBufferList) + (getNumChannels() - 1) * sizeof(AudioBuffer));
mpBufferList->mNumberBuffers = getNumChannels();
return BufferedAudioSource::init(path, loadIntoMemory);
}
int main(int argc, char* argv[]){
int i;
//Checking command-line arguments
if(argc > 3){
printf("%s\n", USAGE);
return 1;
}else if(argc < 2){
fin = stdin;
}else if(argc == 2){
if(strcmp(argv[1], "-q") == 0){
verbose = 0;
fin = stdin;
}else{
fin = fopen(argv[1], "r");
if(!fin){
printf("%s\n", USAGE);
return 1;
}
}
}else if(argc == 2){
if(strcmp("-q", argv[1]) != 0){
printf("%s\n", USAGE);
return 1;
}
verbose = 0;
fin = fopen(argv[2], "r");
}
//Initializing the symbol table
symTable = newTable();
//Initializing the disjoint set for scopes
for(i = 0; i < MAX_CODE_LENGTH; i++)
scopeParent[i] = 0;
//Fetching the first token
readToken();
//Parsing the program
program();
//Generating code
printCode();
//END:
deleteTable(symTable);
return 0;
}
::std::map<int64_t,uint64_t> symsOrderedByCodeMap() const
{
::std::map < ::std::string , uint64_t > M;
for ( int64_t i = minsym; i <= maxsym; ++i )
if ( codeused[i-minsym] )
M [ printCode(i) ] = i;
::std::map<int64_t,uint64_t> R;
for ( ::std::map < ::std::string , uint64_t > :: const_iterator ita = M.begin(); ita != M.end(); ++ita )
{
uint64_t const rank = R.size();
R[ita->second] = rank;
}
return R;
}
::std::pair < ::std::vector < uint64_t >, ::std::vector < uint64_t > > symsOrderedByCode() const
{
::std::map < ::std::string , uint64_t > M;
for ( int64_t i = minsym; i <= maxsym; ++i )
if ( codeused[i-minsym] )
M [ printCode(i) ] = i;
::std::vector <uint64_t > V;
::std::vector <uint64_t > R ( maxsym-minsym+1 );
for ( ::std::map < ::std::string , uint64_t > :: const_iterator ita = M.begin(); ita != M.end(); ++ita )
{
R.at(ita->second - minsym) = V.size();
V.push_back ( ita->second );
}
return ::std::pair < ::std::vector < uint64_t >, ::std::vector < uint64_t > >(V,R);
}
void printSorted() const
{
::std::pair < ::std::vector < uint64_t >, ::std::vector < uint64_t > > const VR = symsOrderedByCode();
::std::vector < uint64_t > const & V = VR.first;
::std::vector < uint64_t > const & R = VR.second;
for ( uint64_t j = 0; j < V.size(); ++j )
{
uint64_t const i = V[j];
if ( codeused[i-minsym] )
::std::cerr << static_cast<char>(i) << "\t"
<< printCode( i )
<< "\t"
<< (*this)[i].second
<< "\t"
<< R[i-minsym]
<< ::std::endl;
}
}
int main(int argc, const char * argv[]) {
FILE *file = fopen("mcode.txt", "r" );
// stack_str = malloc((MAX_STACK_HEIGHT + 100) * sizeof(char));
/* fopen returns 0, the NULL pointer, on failure */
if ( file == 0 )
{
printf( "Could not open file\n" );
exit(1);
}
fillCode( file );
fclose( file );
file = fopen("stacktrace.txt","w");
if ( file == NULL) {
printf("Could not open file\n");
exit(1);
}
printCode( file );
fprintf(file, "Line OP L M pc bp sp stack \n");
fprintf(file, "----------------------------------------\n");
fprintf(file, "Init Values: 0 1 0 \n");
/*instruction cycle*/
//while instruction is not halt
while ( halt == 0) {
fetch();
execute();
printInstructionTrace(file);
}
fclose( file );
}
int main(int argc, char *argv[])
{
load();
output = fopen("stacktrace.txt", "w");
fprintf(output, "Line OP L M\n");
printCode(code);
fprintf(output, " pc bp sp stack\n");
fprintf(output, "Initial values %d %d %d\n", pc, bp, sp);
while(halt == 0)
{
fetchInstruction();
executeInstruction();
printInfo();
}
fclose(output);
return 0;
}
bool compileGLSLShader(bx::CommandLine& _cmdLine, uint32_t _gles, const std::string& _code, bx::WriterI* _writer)
{
char ch = tolower(_cmdLine.findOption('\0', "type")[0]);
const glslopt_shader_type type = ch == 'f'
? kGlslOptShaderFragment
: (ch == 'c' ? kGlslOptShaderCompute : kGlslOptShaderVertex);
glslopt_target target = kGlslTargetOpenGL;
switch (_gles)
{
case BX_MAKEFOURCC('M', 'T', 'L', 0):
target = kGlslTargetMetal;
break;
case 2:
target = kGlslTargetOpenGLES20;
break;
case 3:
target = kGlslTargetOpenGLES30;
break;
default:
target = kGlslTargetOpenGL;
break;
}
glslopt_ctx* ctx = glslopt_initialize(target);
glslopt_shader* shader = glslopt_optimize(ctx, type, _code.c_str(), 0);
if (!glslopt_get_status(shader) )
{
const char* log = glslopt_get_log(shader);
int32_t source = 0;
int32_t line = 0;
int32_t column = 0;
int32_t start = 0;
int32_t end = INT32_MAX;
if (3 == sscanf(log, "%u:%u(%u):", &source, &line, &column)
&& 0 != line)
{
start = bx::uint32_imax(1, line-10);
end = start + 20;
}
printCode(_code.c_str(), line, start, end);
fprintf(stderr, "Error: %s\n", log);
glslopt_cleanup(ctx);
return false;
}
const char* optimizedShader = glslopt_get_output(shader);
// Trim all directives.
while ('#' == *optimizedShader)
{
optimizedShader = bx::strnl(optimizedShader);
}
if (0 != _gles)
{
char* code = const_cast<char*>(optimizedShader);
strreplace(code, "gl_FragDepthEXT", "gl_FragDepth");
strreplace(code, "texture2DLodEXT", "texture2DLod");
strreplace(code, "texture2DProjLodEXT", "texture2DProjLod");
strreplace(code, "textureCubeLodEXT", "textureCubeLod");
strreplace(code, "texture2DGradEXT", "texture2DGrad");
strreplace(code, "texture2DProjGradEXT", "texture2DProjGrad");
strreplace(code, "textureCubeGradEXT", "textureCubeGrad");
strreplace(code, "shadow2DEXT", "shadow2D");
strreplace(code, "shadow2DProjEXT", "shadow2DProj");
}
UniformArray uniforms;
{
const char* parse = optimizedShader;
while (NULL != parse
&& *parse != '\0')
{
parse = bx::strws(parse);
const char* eol = strchr(parse, ';');
if (NULL != eol)
{
const char* qualifier = parse;
parse = bx::strws(bx::strword(parse) );
if (0 == strncmp(qualifier, "attribute", 9)
|| 0 == strncmp(qualifier, "varying", 7) )
{
// skip attributes and varyings.
parse = eol + 1;
continue;
}
if (0 != strncmp(qualifier, "uniform", 7) )
{
// end if there is no uniform keyword.
parse = NULL;
continue;
}
const char* precision = NULL;
const char* typen = parse;
if (0 == strncmp(typen, "lowp", 4)
|| 0 == strncmp(typen, "mediump", 7)
|| 0 == strncmp(typen, "highp", 5) )
{
precision = typen;
typen = parse = bx::strws(bx::strword(parse) );
}
BX_UNUSED(precision);
char uniformType[256];
parse = bx::strword(parse);
if (0 == strncmp(typen, "sampler", 7) )
{
strcpy(uniformType, "int");
}
else
{
bx::strlcpy(uniformType, typen, parse-typen+1);
}
const char* name = parse = bx::strws(parse);
char uniformName[256];
uint8_t num = 1;
const char* array = bx::strnstr(name, "[", eol-parse);
if (NULL != array)
{
bx::strlcpy(uniformName, name, array-name+1);
char arraySize[32];
const char* end = bx::strnstr(array, "]", eol-array);
bx::strlcpy(arraySize, array+1, end-array);
num = atoi(arraySize);
}
else
{
bx::strlcpy(uniformName, name, eol-name+1);
}
Uniform un;
un.type = nameToUniformTypeEnum(uniformType);
if (UniformType::Count != un.type)
{
BX_TRACE("name: %s (type %d, num %d)", uniformName, un.type, num);
un.name = uniformName;
un.num = num;
un.regIndex = 0;
un.regCount = num;
uniforms.push_back(un);
}
parse = eol + 1;
}
}
}
uint16_t count = (uint16_t)uniforms.size();
bx::write(_writer, count);
for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
{
const Uniform& un = *it;
uint8_t nameSize = (uint8_t)un.name.size();
bx::write(_writer, nameSize);
bx::write(_writer, un.name.c_str(), nameSize);
uint8_t uniformType = un.type;
bx::write(_writer, uniformType);
bx::write(_writer, un.num);
bx::write(_writer, un.regIndex);
bx::write(_writer, un.regCount);
BX_TRACE("%s, %s, %d, %d, %d"
, un.name.c_str()
, getUniformTypeName(un.type)
, un.num
, un.regIndex
, un.regCount
);
}
uint32_t shaderSize = (uint32_t)strlen(optimizedShader);
bx::write(_writer, shaderSize);
bx::write(_writer, optimizedShader, shaderSize);
uint8_t nul = 0;
bx::write(_writer, nul);
glslopt_cleanup(ctx);
return true;
}
static bool compile(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer)
{
char ch = _options.shaderType;
const glslopt_shader_type type = ch == 'f'
? kGlslOptShaderFragment
: (ch == 'c' ? kGlslOptShaderCompute : kGlslOptShaderVertex);
glslopt_target target = kGlslTargetOpenGL;
switch (_version)
{
case BX_MAKEFOURCC('M', 'T', 'L', 0):
target = kGlslTargetMetal;
break;
case 2:
target = kGlslTargetOpenGLES20;
break;
case 3:
target = kGlslTargetOpenGLES30;
break;
default:
target = kGlslTargetOpenGL;
break;
}
glslopt_ctx* ctx = glslopt_initialize(target);
glslopt_shader* shader = glslopt_optimize(ctx, type, _code.c_str(), 0);
if (!glslopt_get_status(shader) )
{
const char* log = glslopt_get_log(shader);
int32_t source = 0;
int32_t line = 0;
int32_t column = 0;
int32_t start = 0;
int32_t end = INT32_MAX;
bool found = false
|| 3 == sscanf(log, "%u:%u(%u):", &source, &line, &column)
|| 2 == sscanf(log, "(%u,%u):", &line, &column)
;
if (found
&& 0 != line)
{
start = bx::uint32_imax(1, line-10);
end = start + 20;
}
printCode(_code.c_str(), line, start, end, column);
fprintf(stderr, "Error: %s\n", log);
glslopt_shader_delete(shader);
glslopt_cleanup(ctx);
return false;
}
const char* optimizedShader = glslopt_get_output(shader);
// Trim all directives.
while ('#' == *optimizedShader)
{
optimizedShader = bx::strnl(optimizedShader);
}
{
char* code = const_cast<char*>(optimizedShader);
strReplace(code, "gl_FragDepthEXT", "gl_FragDepth");
strReplace(code, "texture2DLodARB", "texture2DLod");
strReplace(code, "texture2DLodEXT", "texture2DLod");
strReplace(code, "texture2DGradARB", "texture2DGrad");
strReplace(code, "texture2DGradEXT", "texture2DGrad");
strReplace(code, "textureCubeLodARB", "textureCubeLod");
strReplace(code, "textureCubeLodEXT", "textureCubeLod");
strReplace(code, "textureCubeGradARB", "textureCubeGrad");
strReplace(code, "textureCubeGradEXT", "textureCubeGrad");
strReplace(code, "texture2DProjLodARB", "texture2DProjLod");
strReplace(code, "texture2DProjLodEXT", "texture2DProjLod");
strReplace(code, "texture2DProjGradARB", "texture2DProjGrad");
strReplace(code, "texture2DProjGradEXT", "texture2DProjGrad");
strReplace(code, "shadow2DARB", "shadow2D");
strReplace(code, "shadow2DEXT", "shadow2D");
strReplace(code, "shadow2DProjARB", "shadow2DProj");
strReplace(code, "shadow2DProjEXT", "shadow2DProj");
}
UniformArray uniforms;
if (target != kGlslTargetMetal)
{
const char* parse = optimizedShader;
while (NULL != parse
&& *parse != '\0')
{
parse = bx::strws(parse);
const char* eol = bx::strFind(parse, ';');
if (NULL != eol)
{
const char* qualifier = parse;
parse = bx::strws(bx::strSkipWord(parse) );
if (0 == bx::strCmp(qualifier, "attribute", 9)
|| 0 == bx::strCmp(qualifier, "varying", 7)
|| 0 == bx::strCmp(qualifier, "in", 2)
|| 0 == bx::strCmp(qualifier, "out", 3)
)
{
// skip attributes and varyings.
parse = eol + 1;
continue;
}
if (0 == bx::strCmp(parse, "tmpvar", 6) )
{
// skip temporaries
parse = eol + 1;
continue;
}
if (0 != bx::strCmp(qualifier, "uniform", 7) )
{
// end if there is no uniform keyword.
parse = NULL;
continue;
}
const char* precision = NULL;
const char* typen = parse;
if (0 == bx::strCmp(typen, "lowp", 4)
|| 0 == bx::strCmp(typen, "mediump", 7)
|| 0 == bx::strCmp(typen, "highp", 5) )
{
precision = typen;
typen = parse = bx::strws(bx::strSkipWord(parse) );
}
BX_UNUSED(precision);
char uniformType[256];
parse = bx::strSkipWord(parse);
if (0 == bx::strCmp(typen, "sampler", 7) )
{
bx::strCopy(uniformType, BX_COUNTOF(uniformType), "int");
}
else
{
bx::strCopy(uniformType, int32_t(parse-typen+1), typen);
}
const char* name = parse = bx::strws(parse);
char uniformName[256];
uint8_t num = 1;
const char* array = bx::strFind(bx::StringView(name, int32_t(eol-parse) ), "[");
if (NULL != array)
{
bx::strCopy(uniformName, int32_t(array-name+1), name);
char arraySize[32];
const char* end = bx::strFind(bx::StringView(array, int32_t(eol-array) ), "]");
bx::strCopy(arraySize, int32_t(end-array), array+1);
num = uint8_t(atoi(arraySize) );
}
else
{
bx::strCopy(uniformName, int32_t(eol-name+1), name);
}
Uniform un;
un.type = nameToUniformTypeEnum(uniformType);
if (UniformType::Count != un.type)
{
BX_TRACE("name: %s (type %d, num %d)", uniformName, un.type, num);
un.name = uniformName;
un.num = num;
un.regIndex = 0;
un.regCount = num;
uniforms.push_back(un);
}
parse = eol + 1;
}
}
}
else
{
const char* parse = bx::strFind(optimizedShader, "struct xlatMtlShaderUniform {");
const char* end = parse;
if (NULL != parse)
{
parse += bx::strLen("struct xlatMtlShaderUniform {");
end = bx::strFind(parse, "};");
}
while ( parse < end
&& *parse != '\0')
{
parse = bx::strws(parse);
const char* eol = bx::strFind(parse, ';');
if (NULL != eol)
{
const char* typen = parse;
char uniformType[256];
parse = bx::strSkipWord(parse);
bx::strCopy(uniformType, int32_t(parse-typen+1), typen);
const char* name = parse = bx::strws(parse);
char uniformName[256];
uint8_t num = 1;
const char* array = bx::strFind(bx::StringView(name, int32_t(eol-parse) ), "[");
if (NULL != array)
{
bx::strCopy(uniformName, int32_t(array-name+1), name);
char arraySize[32];
const char* arrayEnd = bx::strFind(bx::StringView(array, int32_t(eol-array) ), "]");
bx::strCopy(arraySize, int32_t(arrayEnd-array), array+1);
num = uint8_t(atoi(arraySize) );
}
else
{
bx::strCopy(uniformName, int32_t(eol-name+1), name);
}
Uniform un;
un.type = nameToUniformTypeEnum(uniformType);
if (UniformType::Count != un.type)
{
BX_TRACE("name: %s (type %d, num %d)", uniformName, un.type, num);
un.name = uniformName;
un.num = num;
un.regIndex = 0;
un.regCount = num;
uniforms.push_back(un);
}
parse = eol + 1;
}
}
}
uint16_t count = (uint16_t)uniforms.size();
bx::write(_writer, count);
for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
{
const Uniform& un = *it;
uint8_t nameSize = (uint8_t)un.name.size();
bx::write(_writer, nameSize);
bx::write(_writer, un.name.c_str(), nameSize);
uint8_t uniformType = uint8_t(un.type);
bx::write(_writer, uniformType);
bx::write(_writer, un.num);
bx::write(_writer, un.regIndex);
bx::write(_writer, un.regCount);
BX_TRACE("%s, %s, %d, %d, %d"
, un.name.c_str()
, getUniformTypeName(un.type)
, un.num
, un.regIndex
, un.regCount
);
}
uint32_t shaderSize = (uint32_t)bx::strLen(optimizedShader);
bx::write(_writer, shaderSize);
bx::write(_writer, optimizedShader, shaderSize);
uint8_t nul = 0;
bx::write(_writer, nul);
if (_options.disasm )
{
std::string disasmfp = _options.outputFilePath + ".disasm";
writeFile(disasmfp.c_str(), optimizedShader, shaderSize);
}
glslopt_shader_delete(shader);
glslopt_cleanup(ctx);
return true;
}
/***************************************************************************
print one hex digit
input: uint8_t 0..F
***************************************************************************/
void hex1(uint8_t x)
{
if(x<10)printCode(x);
else printCode(x+3);
}
int main(int argc, char *argv[])
{
//int ret;
int c;
unsigned short i=0, ac;
unsigned short rom_adr, startAdr=i8086_BEGINADR; /* Mem-Viewer Startadresse */
char str[6];
char cfgStr[i8086_CFG_MAX_VALUE_LEN];
unsigned short adr;
codeView cv; /* Code-Viewer Data */
if (argc<2)
{
printf("i8086emu "VERSION_NUMBER);
printf("\nUsage: %s [OPTIONS] FILENAME\n", argv[0]);
printf("\nOptions:");
printf("\n -c\t\t\tCodeViewer deaktivieren");
printf("\n -o XXXXh\t\tStartadresse");
printf("\n -r XXXXh\t\tStartadresse ROM-File");
printf("\n -d file\t\tDUMP-File");
printf("\n --version\t\tshow version information");
printf("\n --help\t\t\tthis help information");
printf("\n");
exit(1);
}
signal(SIGTERM, resetAll);
signal(SIGINT, resetAll);
signal(SIGQUIT, resetAll);
signal(SIGSEGV, resetAll);
i8086clearLog(); /* Log-File leeren. */
i8086init(); /* Prozessor initialisieren. */
oldPortHandler = i8086SetMsgFunc(i8086_SIG_PORT_OUT, portSignalHandler);
/* Config-File laden */
if (i8086ReadStrConfig(cfgStr, CONFIG_FILE, "ROMFILE")!=0)
{
rom_adr = i8086ReadHexConfig(CONFIG_FILE, "ROMSTARTADR", 0xc000);
LoadRomFile(cfgStr, rom_adr);
}
else /* Wenn ROM -> kein Core-Dump */
if (i8086ReadStrConfig(cfgStr, CONFIG_FILE, "COREDUMP")!=0)
LoadCoreDumpFile(cfgStr);
startAdr = i8086ReadHexConfig(CONFIG_FILE, "PROGSTARTADR", 0x0100);
for (ac=1; ac<argc; ac++) /* Programmargumente auswerten und speichern */
{
char *str;
if(strcmp(argv[ac],"--version")==0)
{
printf("i8086emu "VERSION_NUMBER"\n"
"Copyright (C) 2004 JMH, RD, FB, CST\n"
"i8086emu comes with NO WARRANTY,\n"
"to the extent permitted by law.\n"
"You may redistribute copies of i8086emu\n"
"under the terms of the GNU General Public License.\n");
exit(1);
}
if(strcmp(argv[ac],"--help")==0)
{
printf("i8086emu "VERSION_NUMBER);
printf("\nUsage: %s [OPTIONS] FILENAME\n", argv[0]);
printf("\nOptions:");
printf("\n -c\t\t\tCodeViewer deaktivieren");
printf("\n -o XXXXh\t\tStartadresse");
printf("\n -r XXXXh\t\tStartadresse ROM-File");
printf("\n -d file\t\tDUMP-File");
printf("\n --version\t\tshow version information");
printf("\n --help\t\t\tthis help information");
printf("\n");
exit(1);
}
if (strcmp(argv[ac], "-c")==0) /* CodeViewer deaktivieren */
args |= HIDE_CODE_VIEWER;
if ((str=strstr(argv[ac], "-o"))!=NULL) /* Startadresse des Programmes setzen */
{
str = strtok(str, "-o");
if (str!=NULL)
startAdr = strtoul(str, NULL, 16);
}
if ((str=strstr(argv[ac], "-r"))!=NULL) /* ROM laden */
{
//int adr;
if (argc<ac+2)
{
printf("\n -r XXXXh file -> Startadresse ROM-File");
exit(1);
}
rom_adr = strtoul(argv[ac+1], NULL, 16);
LoadRomFile(argv[ac+2], rom_adr);
}
if ((str=strstr(argv[ac], "-d"))!=NULL) /* Core-Dump laden */
{
if (argc<ac+1)
{
printf("\n -d file -> DUMP-File");
exit(1);
}
LoadCoreDumpFile(argv[ac+1]);
}
}
if (i8086loadBinFile(core, argv[argc-1], startAdr)!=i8086_SUC_FILELOAD)
{
i8086error(argv[argc-1], i8086_ERR_STR_FILENF);
}
if (args & LOAD_ROM) /* ROM verarbeiten */
startAdr = rom_adr;
core->pc = startAdr;
initscr();
clear();
refresh();
createWin();
printReg();
printFlags();
printLeds(0);
printSwitches();
printDisplay();
printMem(startAdr);
cv.startAdr = 0;//i8086_BEGINADR;
cv.endAdr = 0;
printCode(core, commands, &cv);
//i8086PushMsg(1, 1);
noecho(); /* getch echo aus */
curs_set(0); /* Cursor ausschalten */
keypad(stdscr,1);
//while (/*c=='g' ||*/ (c=getch/*ar*/())!='q')
//sendepuffer ist leer
//core->ports.x[0xD2]=3;
while ((c==ERR && i%50000!=0) || (c=getch/*ar*/())!='q') //automode nur aller 50000 takte abbrechbar, reicht aber aus, sonst wars zu langsam
{
i++;
if (c==KEY_F(9))
nodelay(stdscr,TRUE);
else if (c=='n')
nodelay(stdscr,FALSE);
else if (c==KEY_F(8))
{
adr=i8086GetSegRegister_fast(core,i8086_REG_CS, 1)+core->pc;
stepover=adr+commands[core->mem[adr]]->size;
if (commands[core->mem[adr]]->hasMod!=0)
stepover+=getAdditionalCmdLength(core, core->mem[adr], core->mem[adr+1]);
nodelay(stdscr,TRUE);
}
if (c==ERR||c=='n') /* next Opcode */
if (i8086execCommand(core, commands)==i8086_ERR_ILGOPCODE)
{
sprintf(str, "%hd", core->mem[core->pc + i8086GetSegRegister_fast(core, i8086_REG_CS, 1)]);
i8086error(i8086_ERR_STR_ILGOPCODE, str);
//resetAll(0);
}
if (i8086GetSegRegister_fast(core,i8086_REG_CS, 1)+core->pc==breakpoint || i8086GetSegRegister_fast(core,i8086_REG_CS, 1)+core->pc==stepover)
{
i=0;
nodelay(stdscr,FALSE);
c=0;
}
if (c=='r') /* set Registervalue */
setReg();
else if (c==KEY_F(1)) /* Print Help */
printHelp();
else if (c==KEY_F(2)) //Breakpoint setzen
{
setBreakpoint();
c=0;
}
else if (c=='m') /* Anfangsadresse von Speicherviewer setzen */
startAdr=readMem();
else if (c=='w') /* Wert von Speicherzelle setzen */
setMem();
else if (c==KEY_F(3)) /* CoreDump */
coreDump();
else if ((c>='0')&&(c<='7')) /* Schalter An/Aus */
{
unsigned char dual[] = {1,2,4,8,16,32,64,128};
core->ports.x[0] = core->ports.x[0] ^ dual[atoi((char*)&c)];
}
else if (c==KEY_F(12)) //Reset Taste
{
i=0;
core->pc=0x0c000;
i8086SetSegRegister(core,i8086_REG_CS,0xc00);
i8086SetRegister(core,i8086_REG_AX,1,0);
//i8086SetRegister(core,i8086_REG_BX,1,0);
//i8086SetRegister(core,i8086_REG_CX,1,0);
//i8086SetRegister(core,i8086_REG_DX,1,0);
//nodelay(stdscr,TRUE);
}
handleKeyboard(core,c);
if (c!=ERR)
{
printReg();
printFlags();
printSwitches();
printDisplay();
printMem(startAdr);
printCode(core, commands, &cv);
//printLeds();
}
}
resetAll(0);
return EXIT_SUCCESS;
}
bool compileHLSLShaderDx9(bx::CommandLine& _cmdLine, const std::string& _code, bx::WriterI* _writer)
{
BX_TRACE("DX9");
const char* profile = _cmdLine.findOption('p', "profile");
if (NULL == profile)
{
fprintf(stderr, "Shader profile must be specified.\n");
return false;
}
bool debug = _cmdLine.hasArg('\0', "debug");
uint32_t flags = 0;
flags |= debug ? D3DXSHADER_DEBUG : 0;
flags |= _cmdLine.hasArg('\0', "avoid-flow-control") ? D3DXSHADER_AVOID_FLOW_CONTROL : 0;
flags |= _cmdLine.hasArg('\0', "no-preshader") ? D3DXSHADER_NO_PRESHADER : 0;
flags |= _cmdLine.hasArg('\0', "partial-precision") ? D3DXSHADER_PARTIALPRECISION : 0;
flags |= _cmdLine.hasArg('\0', "prefer-flow-control") ? D3DXSHADER_PREFER_FLOW_CONTROL : 0;
flags |= _cmdLine.hasArg('\0', "backwards-compatibility") ? D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY : 0;
bool werror = _cmdLine.hasArg('\0', "Werror");
uint32_t optimization = 3;
if (_cmdLine.hasArg(optimization, 'O') )
{
optimization = bx::uint32_min(optimization, BX_COUNTOF(s_optimizationLevelDx9)-1);
flags |= s_optimizationLevelDx9[optimization];
}
else
{
flags |= D3DXSHADER_SKIPOPTIMIZATION;
}
BX_TRACE("Profile: %s", profile);
BX_TRACE("Flags: 0x%08x", flags);
LPD3DXBUFFER code;
LPD3DXBUFFER errorMsg;
LPD3DXCONSTANTTABLE constantTable;
HRESULT hr;
// Output preprocessed shader so that HLSL can be debugged via GPA
// or PIX. Compiling through memory won't embed preprocessed shader
// file path.
if (debug)
{
std::string hlslfp = _cmdLine.findOption('o');
hlslfp += ".hlsl";
writeFile(hlslfp.c_str(), _code.c_str(), (int32_t)_code.size() );
hr = D3DXCompileShaderFromFileA(hlslfp.c_str()
, NULL
, NULL
, "main"
, profile
, flags
, &code
, &errorMsg
, &constantTable
);
}
else
{
hr = D3DXCompileShader(_code.c_str()
, (uint32_t)_code.size()
, NULL
, NULL
, "main"
, profile
, flags
, &code
, &errorMsg
, &constantTable
);
}
if (FAILED(hr)
|| (werror && NULL != errorMsg) )
{
const char* log = (const char*)errorMsg->GetBufferPointer();
char source[1024];
int32_t line = 0;
int32_t column = 0;
int32_t start = 0;
int32_t end = INT32_MAX;
if (3 == sscanf(log, "%[^(](%u,%u):", source, &line, &column)
&& 0 != line)
{
start = bx::uint32_imax(1, line-10);
end = start + 20;
}
printCode(_code.c_str(), line, start, end);
fprintf(stderr, "Error: 0x%08x %s\n", (uint32_t)hr, log);
errorMsg->Release();
return false;
}
UniformArray uniforms;
if (NULL != constantTable)
{
D3DXCONSTANTTABLE_DESC desc;
hr = constantTable->GetDesc(&desc);
if (FAILED(hr) )
{
fprintf(stderr, "Error 0x%08x\n", (uint32_t)hr);
return false;
}
BX_TRACE("Creator: %s 0x%08x", desc.Creator, (uint32_t /*mingw warning*/)desc.Version);
BX_TRACE("Num constants: %d", desc.Constants);
BX_TRACE("# cl ty RxC S By Name");
for (uint32_t ii = 0; ii < desc.Constants; ++ii)
{
D3DXHANDLE handle = constantTable->GetConstant(NULL, ii);
D3DXCONSTANT_DESC constDesc;
uint32_t count;
constantTable->GetConstantDesc(handle, &constDesc, &count);
BX_TRACE("%3d %2d %2d [%dx%d] %d %3d %s[%d] c%d (%d)"
, ii
, constDesc.Class
, constDesc.Type
, constDesc.Rows
, constDesc.Columns
, constDesc.StructMembers
, constDesc.Bytes
, constDesc.Name
, constDesc.Elements
, constDesc.RegisterIndex
, constDesc.RegisterCount
);
UniformType::Enum type = findUniformTypeDx9(constDesc);
if (UniformType::Count != type)
{
Uniform un;
un.name = '$' == constDesc.Name[0] ? constDesc.Name+1 : constDesc.Name;
un.type = type;
un.num = constDesc.Elements;
un.regIndex = constDesc.RegisterIndex;
un.regCount = constDesc.RegisterCount;
uniforms.push_back(un);
}
}
}
uint16_t count = (uint16_t)uniforms.size();
bx::write(_writer, count);
uint32_t fragmentBit = profile[0] == 'p' ? BGFX_UNIFORM_FRAGMENTBIT : 0;
for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
{
const Uniform& un = *it;
uint8_t nameSize = (uint8_t)un.name.size();
bx::write(_writer, nameSize);
bx::write(_writer, un.name.c_str(), nameSize);
uint8_t type = un.type|fragmentBit;
bx::write(_writer, type);
bx::write(_writer, un.num);
bx::write(_writer, un.regIndex);
bx::write(_writer, un.regCount);
BX_TRACE("%s, %s, %d, %d, %d"
, un.name.c_str()
, getUniformTypeName(un.type)
, un.num
, un.regIndex
, un.regCount
);
}
uint16_t shaderSize = (uint16_t)code->GetBufferSize();
bx::write(_writer, shaderSize);
bx::write(_writer, code->GetBufferPointer(), shaderSize);
uint8_t nul = 0;
bx::write(_writer, nul);
if (_cmdLine.hasArg('\0', "disasm") )
{
LPD3DXBUFFER disasm;
D3DXDisassembleShader( (const DWORD*)code->GetBufferPointer()
, false
, NULL
, &disasm
);
if (NULL != disasm)
{
std::string disasmfp = _cmdLine.findOption('o');
disasmfp += ".disasm";
writeFile(disasmfp.c_str(), disasm->GetBufferPointer(), disasm->GetBufferSize() );
disasm->Release();
}
}
if (NULL != code)
{
code->Release();
}
if (NULL != errorMsg)
{
errorMsg->Release();
}
if (NULL != constantTable)
{
constantTable->Release();
}
return true;
}
bool compileHLSLShaderDx11(bx::CommandLine& _cmdLine, const std::string& _code, bx::WriterI* _writer)
{
BX_TRACE("DX11");
const char* profile = _cmdLine.findOption('p', "profile");
if (NULL == profile)
{
fprintf(stderr, "Shader profile must be specified.\n");
return false;
}
bool debug = _cmdLine.hasArg('\0', "debug");
uint32_t flags = D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY;
flags |= debug ? D3DCOMPILE_DEBUG : 0;
flags |= _cmdLine.hasArg('\0', "avoid-flow-control") ? D3DCOMPILE_AVOID_FLOW_CONTROL : 0;
flags |= _cmdLine.hasArg('\0', "no-preshader") ? D3DCOMPILE_NO_PRESHADER : 0;
flags |= _cmdLine.hasArg('\0', "partial-precision") ? D3DCOMPILE_PARTIAL_PRECISION : 0;
flags |= _cmdLine.hasArg('\0', "prefer-flow-control") ? D3DCOMPILE_PREFER_FLOW_CONTROL : 0;
flags |= _cmdLine.hasArg('\0', "backwards-compatibility") ? D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY : 0;
bool werror = _cmdLine.hasArg('\0', "Werror");
if (werror)
{
flags |= D3DCOMPILE_WARNINGS_ARE_ERRORS;
}
uint32_t optimization = 3;
if (_cmdLine.hasArg(optimization, 'O') )
{
optimization = bx::uint32_min(optimization, BX_COUNTOF(s_optimizationLevelDx11)-1);
flags |= s_optimizationLevelDx11[optimization];
}
else
{
flags |= D3DCOMPILE_SKIP_OPTIMIZATION;
}
BX_TRACE("Profile: %s", profile);
BX_TRACE("Flags: 0x%08x", flags);
ID3DBlob* code;
ID3DBlob* errorMsg;
// Output preprocessed shader so that HLSL can be debugged via GPA
// or PIX. Compiling through memory won't embed preprocessed shader
// file path.
std::string hlslfp;
if (debug)
{
hlslfp = _cmdLine.findOption('o');
hlslfp += ".hlsl";
writeFile(hlslfp.c_str(), _code.c_str(), (int32_t)_code.size() );
}
HRESULT hr = D3DCompile(_code.c_str()
, _code.size()
, hlslfp.c_str()
, NULL
, NULL
, "main"
, profile
, flags
, 0
, &code
, &errorMsg
);
if (FAILED(hr)
|| (werror && NULL != errorMsg) )
{
const char* log = (char*)errorMsg->GetBufferPointer();
int32_t line = 0;
int32_t column = 0;
int32_t start = 0;
int32_t end = INT32_MAX;
if (2 == sscanf(log, "(%u,%u):", &line, &column)
&& 0 != line)
{
start = bx::uint32_imax(1, line-10);
end = start + 20;
}
printCode(_code.c_str(), line, start, end);
fprintf(stderr, "Error: 0x%08x %s\n", (uint32_t)hr, log);
errorMsg->Release();
return false;
}
UniformArray uniforms;
ID3D11ShaderReflection* reflect = NULL;
hr = D3DReflect(code->GetBufferPointer()
, code->GetBufferSize()
, IID_ID3D11ShaderReflection
, (void**)&reflect
);
if (FAILED(hr) )
{
fprintf(stderr, "Error: 0x%08x\n", (uint32_t)hr);
return false;
}
D3D11_SHADER_DESC desc;
hr = reflect->GetDesc(&desc);
if (FAILED(hr) )
{
fprintf(stderr, BX_FILE_LINE_LITERAL "Error: 0x%08x\n", (uint32_t)hr);
return false;
}
BX_TRACE("Creator: %s 0x%08x", desc.Creator, desc.Version);
BX_TRACE("Num constant buffers: %d", desc.ConstantBuffers);
BX_TRACE("Input:");
uint8_t numAttrs = 0;
uint16_t attrs[bgfx::Attrib::Count];
if (profile[0] == 'v') // Only care about input semantic on vertex shaders
{
for (uint32_t ii = 0; ii < desc.InputParameters; ++ii)
{
D3D11_SIGNATURE_PARAMETER_DESC spd;
reflect->GetInputParameterDesc(ii, &spd);
BX_TRACE("\t%2d: %s%d, vt %d, ct %d, mask %x, reg %d"
, ii
, spd.SemanticName
, spd.SemanticIndex
, spd.SystemValueType
, spd.ComponentType
, spd.Mask
, spd.Register
);
const RemapInputSemantic& ris = findInputSemantic(spd.SemanticName, spd.SemanticIndex);
if (ris.m_attr != bgfx::Attrib::Count)
{
attrs[numAttrs] = bgfx::attribToId(ris.m_attr);
++numAttrs;
}
}
}
BX_TRACE("Output:");
for (uint32_t ii = 0; ii < desc.OutputParameters; ++ii)
{
D3D11_SIGNATURE_PARAMETER_DESC spd;
reflect->GetOutputParameterDesc(ii, &spd);
BX_TRACE("\t%2d: %s%d, %d, %d", ii, spd.SemanticName, spd.SemanticIndex, spd.SystemValueType, spd.ComponentType);
}
uint16_t size = 0;
for (uint32_t ii = 0; ii < bx::uint32_min(1, desc.ConstantBuffers); ++ii)
{
ID3D11ShaderReflectionConstantBuffer* cbuffer = reflect->GetConstantBufferByIndex(ii);
D3D11_SHADER_BUFFER_DESC bufferDesc;
hr = cbuffer->GetDesc(&bufferDesc);
size = (uint16_t)bufferDesc.Size;
if (SUCCEEDED(hr) )
{
BX_TRACE("%s, %d, vars %d, size %d"
, bufferDesc.Name
, bufferDesc.Type
, bufferDesc.Variables
, bufferDesc.Size
);
for (uint32_t jj = 0; jj < bufferDesc.Variables; ++jj)
{
ID3D11ShaderReflectionVariable* var = cbuffer->GetVariableByIndex(jj);
ID3D11ShaderReflectionType* type = var->GetType();
D3D11_SHADER_VARIABLE_DESC varDesc;
hr = var->GetDesc(&varDesc);
if (SUCCEEDED(hr) )
{
D3D11_SHADER_TYPE_DESC constDesc;
hr = type->GetDesc(&constDesc);
if (SUCCEEDED(hr) )
{
UniformType::Enum uniformType = findUniformTypeDx11(constDesc);
if (UniformType::Count != uniformType
&& 0 != (varDesc.uFlags & D3D_SVF_USED) )
{
Uniform un;
un.name = varDesc.Name;
un.type = uniformType;
un.num = constDesc.Elements;
un.regIndex = varDesc.StartOffset;
un.regCount = BX_ALIGN_16(varDesc.Size)/16;
uniforms.push_back(un);
BX_TRACE("\t%s, %d, size %d, flags 0x%08x, %d"
, varDesc.Name
, varDesc.StartOffset
, varDesc.Size
, varDesc.uFlags
, uniformType
);
}
else
{
BX_TRACE("\t%s, unknown type", varDesc.Name);
}
}
}
}
}
}
BX_TRACE("Bound:");
for (uint32_t ii = 0; ii < desc.BoundResources; ++ii)
{
D3D11_SHADER_INPUT_BIND_DESC bindDesc;
hr = reflect->GetResourceBindingDesc(ii, &bindDesc);
if (SUCCEEDED(hr) )
{
// if (bindDesc.Type == D3D_SIT_SAMPLER)
{
BX_TRACE("\t%s, %d, %d, %d"
, bindDesc.Name
, bindDesc.Type
, bindDesc.BindPoint
, bindDesc.BindCount
);
}
}
}
uint16_t count = (uint16_t)uniforms.size();
bx::write(_writer, count);
uint32_t fragmentBit = profile[0] == 'p' ? BGFX_UNIFORM_FRAGMENTBIT : 0;
for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
{
const Uniform& un = *it;
uint8_t nameSize = (uint8_t)un.name.size();
bx::write(_writer, nameSize);
bx::write(_writer, un.name.c_str(), nameSize);
uint8_t type = un.type|fragmentBit;
bx::write(_writer, type);
bx::write(_writer, un.num);
bx::write(_writer, un.regIndex);
bx::write(_writer, un.regCount);
BX_TRACE("%s, %s, %d, %d, %d"
, un.name.c_str()
, getUniformTypeName(un.type)
, un.num
, un.regIndex
, un.regCount
);
}
{
ID3DBlob* stripped;
hr = D3DStripShader(code->GetBufferPointer()
, code->GetBufferSize()
, D3DCOMPILER_STRIP_REFLECTION_DATA
| D3DCOMPILER_STRIP_TEST_BLOBS
, &stripped
);
if (SUCCEEDED(hr) )
{
code->Release();
code = stripped;
}
}
uint16_t shaderSize = (uint16_t)code->GetBufferSize();
bx::write(_writer, shaderSize);
bx::write(_writer, code->GetBufferPointer(), shaderSize);
uint8_t nul = 0;
bx::write(_writer, nul);
bx::write(_writer, numAttrs);
bx::write(_writer, attrs, numAttrs*sizeof(uint16_t) );
bx::write(_writer, size);
if (_cmdLine.hasArg('\0', "disasm") )
{
ID3DBlob* disasm;
D3DDisassemble(code->GetBufferPointer()
, code->GetBufferSize()
, 0
, NULL
, &disasm
);
if (NULL != disasm)
{
std::string disasmfp = _cmdLine.findOption('o');
disasmfp += ".disasm";
writeFile(disasmfp.c_str(), disasm->GetBufferPointer(), (uint32_t)disasm->GetBufferSize() );
disasm->Release();
}
}
if (NULL != reflect)
{
reflect->Release();
}
if (NULL != errorMsg)
{
errorMsg->Release();
}
code->Release();
return true;
}
::std::string printCode(uint64_t const sym) const
{
return printCode (
(*this)[sym].first,
(*this)[sym].second );
}
static bool compile(bx::CommandLine& _cmdLine, uint32_t _version, const std::string& _code, bx::WriterI* _writer, bool _firstPass)
{
const char* profile = _cmdLine.findOption('p', "profile");
if (NULL == profile)
{
fprintf(stderr, "Error: Shader profile must be specified.\n");
return false;
}
s_compiler = load();
bool result = false;
bool debug = _cmdLine.hasArg('\0', "debug");
uint32_t flags = D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY;
flags |= debug ? D3DCOMPILE_DEBUG : 0;
flags |= _cmdLine.hasArg('\0', "avoid-flow-control") ? D3DCOMPILE_AVOID_FLOW_CONTROL : 0;
flags |= _cmdLine.hasArg('\0', "no-preshader") ? D3DCOMPILE_NO_PRESHADER : 0;
flags |= _cmdLine.hasArg('\0', "partial-precision") ? D3DCOMPILE_PARTIAL_PRECISION : 0;
flags |= _cmdLine.hasArg('\0', "prefer-flow-control") ? D3DCOMPILE_PREFER_FLOW_CONTROL : 0;
flags |= _cmdLine.hasArg('\0', "backwards-compatibility") ? D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY : 0;
bool werror = _cmdLine.hasArg('\0', "Werror");
if (werror)
{
flags |= D3DCOMPILE_WARNINGS_ARE_ERRORS;
}
uint32_t optimization = 3;
if (_cmdLine.hasArg(optimization, 'O') )
{
optimization = bx::uint32_min(optimization, BX_COUNTOF(s_optimizationLevelD3D11) - 1);
flags |= s_optimizationLevelD3D11[optimization];
}
else
{
flags |= D3DCOMPILE_SKIP_OPTIMIZATION;
}
BX_TRACE("Profile: %s", profile);
BX_TRACE("Flags: 0x%08x", flags);
ID3DBlob* code;
ID3DBlob* errorMsg;
// Output preprocessed shader so that HLSL can be debugged via GPA
// or PIX. Compiling through memory won't embed preprocessed shader
// file path.
std::string hlslfp;
if (debug)
{
hlslfp = _cmdLine.findOption('o');
hlslfp += ".hlsl";
writeFile(hlslfp.c_str(), _code.c_str(), (int32_t)_code.size() );
}
HRESULT hr = D3DCompile(_code.c_str()
, _code.size()
, hlslfp.c_str()
, NULL
, NULL
, "main"
, profile
, flags
, 0
, &code
, &errorMsg
);
if (FAILED(hr)
|| (werror && NULL != errorMsg) )
{
const char* log = (char*)errorMsg->GetBufferPointer();
int32_t line = 0;
int32_t column = 0;
int32_t start = 0;
int32_t end = INT32_MAX;
bool found = false
|| 2 == sscanf(log, "(%u,%u):", &line, &column)
|| 2 == sscanf(log, " :%u:%u: ", &line, &column)
;
if (found
&& 0 != line)
{
start = bx::uint32_imax(1, line - 10);
end = start + 20;
}
printCode(_code.c_str(), line, start, end, column);
fprintf(stderr, "Error: D3DCompile failed 0x%08x %s\n", (uint32_t)hr, log);
errorMsg->Release();
return false;
}
UniformArray uniforms;
uint8_t numAttrs = 0;
uint16_t attrs[bgfx::Attrib::Count];
uint16_t size = 0;
if (_version == 9)
{
if (!getReflectionDataD3D9(code, uniforms) )
{
fprintf(stderr, "Error: Unable to get D3D9 reflection data.\n");
goto error;
}
}
else
{
UniformNameList unusedUniforms;
if (!getReflectionDataD3D11(code, profile[0] == 'v', uniforms, numAttrs, attrs, size, unusedUniforms) )
{
fprintf(stderr, "Error: Unable to get D3D11 reflection data.\n");
goto error;
}
if (_firstPass
&& unusedUniforms.size() > 0)
{
const size_t strLength = strlen("uniform");
// first time through, we just find unused uniforms and get rid of them
std::string output;
LineReader reader(_code.c_str() );
while (!reader.isEof() )
{
std::string line = reader.getLine();
for (UniformNameList::iterator it = unusedUniforms.begin(), itEnd = unusedUniforms.end(); it != itEnd; ++it)
{
size_t index = line.find("uniform ");
if (index == std::string::npos)
{
continue;
}
// matching lines like: uniform u_name;
// we want to replace "uniform" with "static" so that it's no longer
// included in the uniform blob that the application must upload
// we can't just remove them, because unused functions might still reference
// them and cause a compile error when they're gone
if (!!bx::findIdentifierMatch(line.c_str(), it->c_str() ) )
{
line = line.replace(index, strLength, "static");
unusedUniforms.erase(it);
break;
}
}
output += line;
}
// recompile with the unused uniforms converted to statics
return compile(_cmdLine, _version, output.c_str(), _writer, false);
}
}
{
uint16_t count = (uint16_t)uniforms.size();
bx::write(_writer, count);
uint32_t fragmentBit = profile[0] == 'p' ? BGFX_UNIFORM_FRAGMENTBIT : 0;
for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
{
const Uniform& un = *it;
uint8_t nameSize = (uint8_t)un.name.size();
bx::write(_writer, nameSize);
bx::write(_writer, un.name.c_str(), nameSize);
uint8_t type = uint8_t(un.type | fragmentBit);
bx::write(_writer, type);
bx::write(_writer, un.num);
bx::write(_writer, un.regIndex);
bx::write(_writer, un.regCount);
BX_TRACE("%s, %s, %d, %d, %d"
, un.name.c_str()
, getUniformTypeName(un.type)
, un.num
, un.regIndex
, un.regCount
);
}
}
{
ID3DBlob* stripped;
hr = D3DStripShader(code->GetBufferPointer()
, code->GetBufferSize()
, D3DCOMPILER_STRIP_REFLECTION_DATA
| D3DCOMPILER_STRIP_TEST_BLOBS
, &stripped
);
if (SUCCEEDED(hr) )
{
code->Release();
code = stripped;
}
}
{
uint16_t shaderSize = (uint16_t)code->GetBufferSize();
bx::write(_writer, shaderSize);
bx::write(_writer, code->GetBufferPointer(), shaderSize);
uint8_t nul = 0;
bx::write(_writer, nul);
}
if (_version > 9)
{
bx::write(_writer, numAttrs);
bx::write(_writer, attrs, numAttrs*sizeof(uint16_t) );
bx::write(_writer, size);
}
if (_cmdLine.hasArg('\0', "disasm") )
{
ID3DBlob* disasm;
D3DDisassemble(code->GetBufferPointer()
, code->GetBufferSize()
, 0
, NULL
, &disasm
);
if (NULL != disasm)
{
std::string disasmfp = _cmdLine.findOption('o');
disasmfp += ".disasm";
writeFile(disasmfp.c_str(), disasm->GetBufferPointer(), (uint32_t)disasm->GetBufferSize() );
disasm->Release();
}
}
if (NULL != errorMsg)
{
errorMsg->Release();
}
result = true;
error:
code->Release();
unload();
return result;
}
void indent(int scope, int secondParse){
int i;
for(i = 0; i < scope; i++){
printCode("\t", secondParse);
}
}