DebugInfos* getDebInfo(const char* package)
{
SymbolID_t pkgid = gSymbolTable.symbolID(package);
DebugInfos** pdsi = m_debInfos.find(pkgid);
if (pdsi != NULL)
return *pdsi;
hyu32 len = HMD_STRLEN(package);
TArray<char>* fname = new TArray<char>(len + HMD_STRLEN(DEBUGINFO_EXT) + 1);
memcpy(fname->addSpaces(len), package, len);
len = HMD_STRLEN(DEBUGINFO_EXT);
memcpy(fname->addSpaces(len), DEBUGINFO_EXT, len);
fname->add('\0');
return new DebugInfos(fname->top());
}
// ロードパスを追加する
void addLoadPath(const char* path)
{
//printf("addLoadPath(%s)\n", path);
hyu32 n = loadPathArr.size();
if (n == 0) {
loadPathArr.add(NULL);
n = 1;
}
hyu32 len = HMD_STRLEN(path);
char* apath = gMemPool->allocT<char>(len+1);
HMD_STRNCPY(apath, path, len+1);
loadPathArr[n-1] = apath; // end mark に上書き
loadPathArr.add(NULL); // 新しい end mark
HMD_LOADPATH = loadPathArr.top();
// n=0;for(const char** p = HMD_LOADPATH; *p != NULL; ++p)HMD_PRINTF("path %d:'%s'\n",n++,*p);
}
int main(int argc, const char* argv[])
{
hyu32 memSize = DEFAULT_MEMSIZE;
const char* param;
const char* symbolFile = NULL;
const char* incPath[32];
int numIncPath = 0;
void* hayatMemory = NULL;
numLoadPath = 0;
HMD_LOADPATH = NULL;
bPrintSource = false;
for (int i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
switch (argv[i][1]) {
case 'I':
// includeパス
if (numIncPath >= 32) {
usage();
HMD_PRINTF("too many include path (must <=32)\n");
return 1;
}
param = getParam(i, argc, argv, "-I");
if (param == NULL) {
usage();
HMD_PRINTF("parameter for -I is not specified\n");
return 1;
}
incPath[numIncPath++] = param;
break;
case 'M':
param = getParam(i, argc, argv, "-M");
if (param == NULL) {
usage();
HMD_PRINTF("parameter for -M is not specified\n");
return 1;
} else {
memSize = 0;
while('0' <= *param && *param <= '9') {
memSize *= 10;
memSize += (*param++ - '0');
}
if (*param == 'k' || *param == 'K') {
memSize *= 1024;
} else if (*param == 'm' || *param == 'M') {
memSize *= 1024 * 1024;
} else if (*param != '\0') {
printf("bad parameter for -M\n");
memSize = DEFAULT_MEMSIZE;
}
}
break;
case 'f':
param = getParam(i, argc, argv, "-f");
if (param == NULL) {
HMD_PRINTF("symbol file is not specified\n");
return 1;
}
symbolFile = param;
break;
case 's':
bPrintSource = true;
break;
case 'h':
usage(true);
return 1;
default:
usage(true);
HMD_PRINTF("unknown option %s\n", argv[i]);
return 1;
}
} else {
usage(true);
HMD_PRINTF("unknown option %s\n", argv[i]);
return 1;
}
}
hayatMemory = HMD_ALLOC(memSize);
MemPool::initGMemPool(hayatMemory, memSize);
for (int i = 0; i < numIncPath; ++i) {
addLoadPath(incPath[i], "out");
}
addLoadPath(".", "out");
if (symbolFile != NULL) {
if (! gSymbolTable.readFile(symbolFile)) {
HMD_PRINTF("symbol file '%s' load failed\n", symbolFile);
HMD_FREE(hayatMemory);
return 1;
}
} else {
hyu8* fileBuf;
hyu32 len = hmd_loadFile_inPath("symbols.sym", &fileBuf);
if (len != 0)
gSymbolTable.readTable(fileBuf);
else
HMD_PRINTF("could not load symbols.sym\n");
}
// main loop
static const size_t BUF_SIZE = 1024;
char buf[BUF_SIZE];
while (fgets(buf, BUF_SIZE, stdin) != NULL) {
TArray<char>* s = replaceSymbol(buf);
printResolvedLine(s->top());
s->finalize();
}
// normal exit
gSymbolTable.finalize();
HMD_FREE(hayatMemory);
return 0;
}
void DClass::dump(TArray<SymbolID_t>& parents)
{
hyu8 sbuf[256];
if (bPrimitive)
HMD_PRINTF("flag: primitive\n");
if (numDefaultVal > 0)
HMD_PRINTF("number of default values: %d\n", numDefaultVal);
if (numSuper > 0) {
HMD_PRINTF("%d super classes: ", numSuper);
for (int i = 0; i < numSuper; ++i) {
SymbolID_t supsym = (SymbolID_t)Endian::unpack<hyu32>((const hyu8*)&superTable[i]);
gSymbolTable.id2str_n(sbuf, 256, supsym);
HMD_PRINTF((char*)sbuf);
if (i < numSuper - 1)
HMD_PRINTF(", ");
}
HMD_PRINTF("\n");
}
bool bPrintUsingPath = false;
hyu16 usingInfoSize = Endian::unpack<hyu16>((const hyu8*)usingPaths);
const hyu8* ptr = ((const hyu8*)usingPaths) + 4;
for (;;) {
SymbolID_t sym = Endian::unpackP<SymbolID_t>(&ptr);
if (sym == SYMBOL_ID_ERROR)
break;
if (!bPrintUsingPath) {
bPrintUsingPath = true;
HMD_PRINTF("using paths:\n");
}
if (sym != (SymbolID_t)0) { // 0 == HSym_nil
gSymbolTable.id2str_n(sbuf, 256, sym);
HMD_PRINTF((char*)sbuf);
}
for (;;) {
sym = Endian::unpackP<SymbolID_t>(&ptr);
if (sym == SYMBOL_ID_ERROR)
break;
gSymbolTable.id2str_n(sbuf, 256, sym);
HMD_PRINTF("::%s", sbuf);
}
}
HMD_DEBUG_ASSERT(ptr <= ((const hyu8*)usingPaths) + usingInfoSize);
if (numClassVar > 0) {
HMD_PRINTF("class variables: ");
printSymbols(classVarSymArr.top(), numClassVar, "@@");
}
if (numMembVar > 0) {
HMD_PRINTF("member variables: ");
printSymbols(membVarSymArr.top(), numMembVar, "@");
}
if (numConstVar > 0) {
HMD_PRINTF("constants: ");
printSymbols(constVarSymArr.top(), numConstVar, "");
}
int numBlk = numMethods + numClosures;
TArray<const hyu8*> adrs(numBlk + 2);
adrs.add(codes);
for (int i = 0; i < numBlk; ++i)
adrs.add(codes + methodTable[i]);
if (numInnerClasses > 0)
adrs.add(codes + innerClassTable[0]);
else
adrs.add(bottomAddr);
for (int i = 0; i <= numBlk; ++i) {
if (i == 0)
HMD_PRINTF("***** classInitializer *MAIN *****\n");
else if (i <= numMethods) {
gSymbolTable.id2str_n(sbuf, 256, methodSymTable[i-1]);
HMD_PRINTF("***** method %s *****\n", sbuf);
}
else
HMD_PRINTF("***** closure #%d *****\n", i - numMethods - 1);
dumpMethod(adrs[i], adrs[i+1]);
}
for (int i = 0; i < numInnerClasses; ++i) {
TArray<SymbolID_t> abs(parents.size() + 1);
abs.add(parents);
abs.add(innerClasses[i]->classSymbol);
SymbolID_t sym;
HMD_PRINTF("======== class ");
for (hyu32 j = 0; j < abs.size(); ++j) {
sym = abs[j];
gSymbolTable.id2str_n(sbuf, 256, sym);
HMD_PRINTF("::%s", sbuf);
}
HMD_PRINTF(" ========\n");
innerClasses[i]->dump(abs);
}
}
