static void printClasses(int *x, int *y, SmiModule *smiModule)
{
SmiNode *smiNode;
for(smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (isGroup(smiNode)) {
printClass(x, y, smiNode);
}
if (smiNode->nodekind == SMI_NODEKIND_ROW) {
printClass(x, y, smiNode);
}
}
}
//
// printAttribute
//
void wb_print_wbl::printAttribute(wb_volume& v,
wb_attribute& attr,
wb_attribute& tattr, ///< template
wb_adef& adef,
int force)
{
if ( !force &&
(adef.flags() & PWR_MASK_POINTER ||
adef.flags() & PWR_MASK_NOWBL))
return;
if (attr.isClass() && adef.cid() == pwr_eClass_Buffer)
printBuffer(v, attr, tattr, adef);
else if (attr.isClass())
printClass(v, attr, tattr, adef);
else {
switch (adef.cid()) {
case pwr_eClass_Param:
case pwr_eClass_Input:
case pwr_eClass_Intern:
case pwr_eClass_Output:
case pwr_eClass_ObjXRef:
printParameter(v, attr, tattr, adef);
break;
default:
m_os << "! %%WBDUMP-E-Error Unknown attribute class: "
<< adef.name() << ", cid: " << adef.cid() << endl;
m_errCnt++;
break;
}
}
}
/*
void mainInit(char* className, Interpretador* interpretador, int paramsNumber, char** cmdLineParams) {
char* methodName = "main", methodDescriptor = "([Ljava/lang/String;)V";
ClassFile* cFile = loadClass(interpretador, className);
pushFrame(&(interpretador->topStackFrame));
frameInit(interpretador->initClass, *cFile, interpretador->topStackFrame, methodName, methodDescriptor);
}
*/
void methodInit(char* className, char* methodName, char* methodDescriptor, Interpretador* interpretador, int paramsNumber, int print) {
int i;
ClassFile* cFile = loadClass(interpretador, className);
printf("FEZ LOAD\n");
if (print)
printClass(cFile, className);
pushFrame(&(interpretador->topStackFrame));
printf("\n\nPUSHOUFRAME\n");
frameInit(interpretador->initClass, *cFile, interpretador->topStackFrame, methodName, methodDescriptor);
printf("\n\nINITIOUFRAME\n");
if (interpretador->topStackFrame->nextFrame != NULL) {
/*if (interpretador->topStackFrame->nextFrame != NULL) {*/
for (i = countSlots(interpretador->topStackFrame->nextFrame->frame->topOperand, paramsNumber) - 1; i >= 0; i--) {
if (interpretador->topStackFrame->nextFrame->frame->topOperand->operand.type32_64 == CAT2)
i--;
interpretador->topStackFrame->frame->localVarArray[i] = (int)&(interpretador->topStackFrame->nextFrame->frame->topOperand);
}
}
printf("\n\nSAIU DA METHOD INIT\n");
/*}*/
}
void _pf_prin(FILE *f, _pf_Stack *stack, boolean formal)
/* Print out single variable where type is determined at run time. */
{
struct _pf_type *type = _pf_type_table[stack->Var.typeId];
struct _pf_base *base = type->base;
union _pf_varless val = stack->Var.val;
struct hash *idHash = NULL;
switch (base->singleType)
{
case pf_stBit:
fprintf(f, "%d", val.Bit);
break;
case pf_stByte:
fprintf(f, "%d", val.Byte);
break;
case pf_stChar:
fprintf(f, "%c", val.Char);
break;
case pf_stShort:
fprintf(f, "%d", val.Short);
break;
case pf_stInt:
fprintf(f, "%d", val.Int);
break;
case pf_stLong:
fprintf(f, "%lld", val.Long);
break;
case pf_stFloat:
if (formal)
fprintf(f, "%f", val.Float);
else
fprintf(f, "%0.2f", val.Float);
break;
case pf_stDouble:
if (formal)
fprintf(f, "%f", val.Double);
else
fprintf(f, "%0.2f", val.Double);
break;
case pf_stString:
if (formal || val.String == NULL)
printString(f, val.String);
else
fprintf(f, "%s", val.String->s);
break;
case pf_stClass:
idHash = newHash(18);
printClass(f, val.Obj, base, idHash);
break;
case pf_stArray:
idHash = newHash(18);
printArray(f, val.Array, base, idHash);
break;
case pf_stDir:
idHash = newHash(18);
printDir(f, val.Dir, base, idHash);
break;
case pf_stToPt:
fprintf(f, "<toPt %p>\n", val.FunctionPt);
break;
case pf_stFlowPt:
fprintf(f, "<flowPt %p>\n", val.FunctionPt);
break;
default:
fprintf(f, "<type %d>\n", base->singleType);
internalErr();
break;
}
if (base->needsCleanup)
{
if (val.Obj != NULL && val.Obj->_pf_cleanup != NULL &&
--val.Obj->_pf_refCount <= 0)
val.Obj->_pf_cleanup(val.Obj, stack->Var.typeId);
}
freeHash(&idHash);
}
void _pf_printField(FILE *f, void *data, struct _pf_base *base,
struct hash *idHash)
/* Print out a data from a single field of given type. */
{
switch (base->singleType)
{
case pf_stBit:
{
_pf_Bit *p = data;
fprintf(f, "%d", *p);
break;
}
case pf_stChar:
{
_pf_Char *p = data;
_pf_Char b = *p;
fprintf(f, "%c", b);
break;
}
case pf_stByte:
{
_pf_Byte *p = data;
_pf_Byte b = *p;
fprintf(f, "%d", b);
break;
}
case pf_stShort:
{
_pf_Short *p = data;
fprintf(f, "%d", *p);
break;
}
case pf_stInt:
{
_pf_Int *p = data;
fprintf(f, "%d", *p);
break;
}
case pf_stLong:
{
_pf_Long *p = data;
fprintf(f, "%lld", *p);
break;
}
case pf_stFloat:
{
_pf_Float *p = data;
fprintf(f, "%f", *p);
break;
}
case pf_stDouble:
{
_pf_Double *p = data;
fprintf(f, "%f", *p);
break;
}
case pf_stString:
{
_pf_String *p = data;
printString(f, *p);
break;
}
case pf_stClass:
{
struct _pf_object **p = data;
printClass(f, *p, base, idHash);
break;
}
case pf_stArray:
{
struct _pf_array **p = data;
printArray(f, *p, base, idHash);
break;
}
case pf_stDir:
{
struct _pf_dir **p = data;
printDir(f, *p, base, idHash);
break;
}
case pf_stToPt:
{
_pf_FunctionPt **p = data;
fprintf(f, "<toPt %p>", *p);
break;
}
case pf_stFlowPt:
{
_pf_FunctionPt **p = data;
fprintf(f, "<flowPt %p>", *p);
break;
}
case pf_stVar:
{
struct _pf_var *var = data;
struct _pf_type *type = _pf_type_table[var->typeId];
_pf_printField(f, &var->val, type->base, idHash);
break;
}
default:
internalErr();
break;
}
}
/*
* oprintf()
*
* Opcode printf
*/
static void oprintf(disasm_t *d, const char *format)
{
uint32_t i = 0;
const char *fstart, *fend;
if (format == NULL)
return;
fstart = fend = format;
while (*fend) {
if (*fend != '%') {
i++;
fend++;
} else {
if (i)
fprintf(d->fp, "%.*s", i, fstart);
/* Skip past % */
fend++;
switch (*fend) {
case 'b':
fprintf(d->fp, "%d", d->code->buf[d->offset++]);
break;
case 'B': /* Bigpic image */
printBigpic(d->fp, d->code->buf[d->offset++]);
break;
case 'c': /* Class */
printClass(d);
break;
case 'C': /* Spell */
printSpell(d->fp, d->code->buf[d->offset++]);
break;
case 'D': /* Direction */
{
uint8_t dir;
dir = d->code->buf[d->offset++];
if (dir == 0) {
fprintf(d->fp, "north");
} else if (dir == 1) {
fprintf(d->fp, "east");
} else if (dir == 2) {
fprintf(d->fp, "south");
} else if (dir == 3) {
fprintf(d->fp, "west");
} else {
fprintf(d->fp, "unknown");
}
break;
}
case 'f': /* Flag */
{
uint8_t flag;
uint8_t mask;
flag = d->code->buf[d->offset] >> 3;
mask = d->code->buf[d->offset] & 7;
fprintf(d->fp, "%d", (flag * 8) + mask);
d->offset++;
break;
}
case 'I': /* Item */
printItem(d->fp, d->code->buf[d->offset++]);
break;
case 'L':
printLiquid(d->fp, d->code->buf[d->offset++]);
break;
case 'M': /* Monster */
printMonster(d->fp, d->code->buf[d->offset++]);
break;
case 'O': /* String at offset */
{
uint16_t savedOffset;
range_t *r;
r = (range_t *)xzalloc(sizeof(range_t));
savedOffset = d->offset + 2;
d->offset = str_read16le(&d->code->buf[d->offset]) - currentLevel.dataStartOffset;
r->start = d->offset;
printPackedString(d);
r->end = d->offset;
gl_list_add_last(rangeSkipList, r);
d->offset = savedOffset;
break;
}
case 'o': /* offset */
fprintf(d->fp, "%04x",
str_read16le(&d->code->buf[d->offset])
);
d->offset += 2;
break;
case 'S': /* Masked String */
fprintf(d->fp, "\"");
fflush(d->fp);
printMaskedString(d);
fprintf(d->fp, "\"");
break;
case 's': /* Packed String */
fprintf(d->fp, "\"");
printPackedString(d);
fprintf(d->fp, "\"");
break;
case 'w': /* Word */
fprintf(d->fp, "%d",
str_read16le(&d->code->buf[d->offset])
);
d->offset += 2;
break;
case 'x': /* Hex byte */
fprintf(d->fp, "0x%02x", d->code->buf[d->offset++]);
break;
}
fend++;
fstart = fend;
i = 0;
}
}
if (i)
fprintf(d->fp, "%.*s", i, fstart);
}
void ASTPrint( int lev, ASTNode node )
{
if (! node)
{
indent( lev ); ec_stderr_printf( "NULL" );
return;
}
/* Simplify our lives ... */
if (currentScope)
{
if (currentScope->type == PackageScope)
{
currentPackage = currentScope->target;
currentBytecode = EC_PACKAGECODE(currentScope->target);
} else
{
currentBytecode = currentScope->target;
}
currentLiteral = EC_COMPILEDLFRAME(currentBytecode);
}
switch ( node->type )
{
case nullType:
indent( lev ); ec_stderr_printf( "<nullType>" );
break;
case symbolType:
printSymbol( lev, node );
break;
case qualifiedSymbolType:
printQualifiedSymbol( lev, node );
break;
case constExprType:
printConstant( lev, node );
break;
case variableExprType:
printVariable( lev, node );
break;
case arrayConstructionExprType:
printArrayCons( lev, node );
break;
case hashConstructionExprType:
printHashCons( lev, node );
break;
case unaryExprType:
printUnary( lev, node );
break;
case binaryExprType:
printBinary( lev, node );
break;
case conditionalExprType:
printConditional( lev, node );
break;
case orExprType:
printOr( lev, node );
break;
case andExprType:
printAnd( lev, node );
break;
case assignExprType:
printAssign( lev, node );
break;
case simAssignExprType:
printSimAssign( lev, node );
break;
case arrayRefExprType:
printArrayRef( lev, node );
break;
case declNodeType:
printDecl( lev, node );
break;
case declAtomNodeType:
printDeclAtom( lev, node );
break;
case statementType:
printStatement( lev, node );
break;
case labeledStmtType:
printLabeledStmt( lev, node );
break;
case exprStmtType:
printExprStmt( lev, node );
break;
case ifStmtType:
printIf( lev, node );
break;
case whileStmtType:
printWhile( lev, node );
break;
case doStmtType:
printDo( lev, node );
break;
case forStmtType:
printFor( lev, node );
break;
case forInStmtType:
printForIn( lev, node );
break;
case breakStmtType:
printBreak( lev, node );
break;
case continueStmtType:
printContinue( lev, node );
break;
case gotoStmtType:
printGoto( lev, node );
break;
case tryStmtType:
printTry( lev, node );
break;
case catchStmtType:
printCatch( lev, node );
break;
case throwStmtType:
printThrow( lev, node );
break;
case importStmtType:
printImport( lev, node );
break;
case paramNodeType:
printParam( lev, node );
break;
case paramListType:
printParamList( lev, node );
break;
case callNodeType:
printCall( lev, node );
break;
case methodCallNodeType:
printMethodCall( lev, node );
break;
case stmtListType:
printStmtList( lev, node );
break;
case funcNodeType:
printFunction( lev, node );
break;
case returnNodeType:
printReturn( lev, node );
break;
case classNodeType:
printClass( lev, node );
break;
case methodNodeType:
printMethod( lev, node );
break;
case packageNodeType:
printPackage( lev, node );
break;
}
}
