AOO410/main/basic/source/classes/disas.cxx

/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_basic.hxx"

#include <stdio.h>
#include <string.h>
#include <tools/stream.hxx>
#include <basic/sbx.hxx>
#include "sb.hxx"
#include "iosys.hxx"
#include "disas.hxx"
#include "sbtrace.hxx"


static const char* pOp1[] = {
	"NOP",

	// Operators
	// the following operators have the same order as in
	// enum SbxVarOp
	"EXP", "MUL", "DIV", "MOD", "PLUS", "MINUS", "NEG",
	"EQ", "NE", "LT", "GT", "LE", "GE",
	"IDIV", "AND", "OR", "XOR", "EQV", "IMP", "NOT",
	"CAT",
	// End enum SbxVarOp
	"LIKE", "IS",
	// Load/Store
	"ARGC",             // Create new Argv
	"ARGV",             // TOS ==> current Argv
	"INPUT",            // Input ==> TOS
	"LINPUT",           // Line Input ==> TOS
	"GET",              // get TOS
	"SET",              // Save Object TOS ==> TOS-1
	"PUT",              // TOS ==> TOS-1
	"CONST",            // TOS ==> TOS-1, then ReadOnly
	"DIM",              // DIM
	"REDIM",            // REDIM
	"REDIMP",           // REDIM PRESERVE
	"ERASE",            // delete TOS
	// Branch
	"STOP",             // End of program
	"INITFOR",          // FOR-Variable init
	"NEXT",             // FOR-Variable increment
	"CASE",             // Begin CASE
	"ENDCASE",          // End CASE
	"STDERR",           // Default error handling
	"NOERROR",          // No error handling
	"LEAVE",            // leave UP
	// I/O
	"CHANNEL",          // TOS = Channelnumber
	"PRINT",            // print TOS
	"PRINTF",           // print TOS in field
	"WRITE",            // write TOS
	"RENAME",           // Rename Tos+1 to Tos
	"PROMPT",           // TOS = Prompt for Input
	"RESTART",          // Define restart point
	"STDIO",            // Switch to I/O channel 0
	// Misc
	"EMPTY",            // Empty statement to stack
	"ERROR",            // TOS = error code
	"LSET",             // Save object TOS ==> TOS-1
	"RSET",             // Save object TOS ==> TOS-1 (TODO: Same as above?)
    "REDIMP_ERASE",
    "INITFOREACH",
	"VBASET",
	"ERASE_CLEAR",
	"ARRAYACCESS",
	"BYVAL"
};

static const char* pOp2[] = {
	"NUMBER",            // Load a numeric constant (+ID)
	"STRING",            // Load a string constant (+ID)
	"CONSTANT",          // Immediate Load (+value)
	"ARGN",              // Save named args in argv (+StringID)
	"PAD",               // Pad String to defined length (+length)
	// Branches
	"JUMP",              // Jump to target (+Target)
	"JUMP.T",            // evaluate TOS, conditional jump (+Target)
	"JUMP.F",            // evaluate TOS, conditional jump (+Target)
	"ONJUMP",            // evaluate TOS, jump into JUMP-table (+MaxVal)
	"GOSUB",             // UP-Call (+Target)
	"RETURN",            // UP-Return (+0 or Target)
	"TESTFOR",           // Test FOR-Variable, increment (+Endlabel)
	"CASETO",            // Tos+1 <= Case <= Tos, 2xremove (+Target)
	"ERRHDL",            // Error-Handler (+Offset)
	"RESUME",            // Resume after errors (+0 or 1 or Label)
	// I/O
	"CLOSE",             // (+channel/0)
	"PRCHAR",            // (+char)
	// Objects
	"SETCLASS",          // Test Set + Classname (+StringId)
	"TESTCLASS",         // Check TOS class (+StringId)
	"LIB",               // Set Libname for Declare-Procs (+StringId)
	// New since Beta 3 (TODO: Which Beta3?)
	"BASED",             // TOS is incremted about BASE, push BASE before
	"ARGTYP",            // Convert last parameter in argv (+Type)
	"VBASETCLASS",
};

static const char* pOp3[] = {
	// All opcodes with two operands
	"RTL",              // Load from RTL (+StringID+Typ)
	"FIND",             // Load (+StringID+Typ)
	"ELEM",             // Load element (+StringID+Typ)
	"PARAM",            // Parameter (+Offset+Typ)
	
    // Branching
	"CALL",             // Call DECLARE method (+StringID+Typ)
	"CALL.C",           // Call Cdecl-DECLARE method (+StringID+Typ)
	"CASEIS",           // Case-Test (+Test-Opcode+False-Target)
	"STMNT",            // Start of a statement (+Line+Col)

    // I/O
	"OPEN",             // (+SvStreamFlags+Flags)

    // Objects and variables
	"LOCAL",            // Local variables (+StringID+Typ)
	"PUBLIC",           // Modul global var (+StringID+Typ)
	"GLOBAL",           // Global var (+StringID+Typ)
	"CREATE",           // Create object (+StringId+StringId)
	"STATIC",           // Create static object (+StringId+StringId)
	"TCREATE",          // Create User defined Object (+StringId+StringId)
	"DCREATE",          // Create User defined Object-Array kreieren (+StringId+StringId)
    "GLOBAL_P",         // Define persistent global var (existing after basic restart)
                        // P=PERSIST (+StringID+Typ)
    "FIND_G",           // Searches for global var with special handling due to _GLOBAL_P
    "DCREATE_REDIMP",   // Change dimensions of a user defined Object-Array (+StringId+StringId)
    "FIND_CM",          // Search inside a class module (CM) to enable global search in time
    "PUBLIC_P",        	// Module global Variable (persisted between calls)(+StringID+Typ)
    "FIND_STATIC",     	// local static var lookup (+StringID+Typ) 
};

static const char** pOps[3] = { pOp1, pOp2, pOp3 };

typedef void( SbiDisas::*Func )( String& );  // Processing routines

static const Func pOperand2[] = {
	&SbiDisas::StrOp,	// Load a numeric constant (+ID)
	&SbiDisas::StrOp,	// Load a string constant (+ID)
	&SbiDisas::ImmOp,	// Immediate Load (+Wert)
	&SbiDisas::StrOp,	// Save a named argument (+ID)
	&SbiDisas::ImmOp,	// Strip String to fixed size (+length)

    // Branches
	&SbiDisas::LblOp,	// Jump (+Target)
	&SbiDisas::LblOp,	// eval TOS, conditional jump (+Target)
	&SbiDisas::LblOp, 	// eval TOS, conditional jump (+Target)
	&SbiDisas::OnOp,	// eval TOS, jump in JUMP table (+MaxVal)
	&SbiDisas::LblOp,	// UP call (+Target)
	&SbiDisas::ReturnOp,	// UP Return (+0 or Target)
	&SbiDisas::LblOp,	// test FOR-Variable, increment (+Endlabel)
	&SbiDisas::LblOp,	// Tos+1 <= Case <= Tos), 2xremove (+Target)
	&SbiDisas::LblOp,	// Error handler (+Offset)
	&SbiDisas::ResumeOp,	// Resume after errors (+0 or 1 or Label)

    // I/O
	&SbiDisas::CloseOp,	// (+channel/0)
	&SbiDisas::CharOp,	// (+char)

    // Objects
	&SbiDisas::StrOp,   // Test classname (+StringId)
	&SbiDisas::StrOp,   // TESTCLASS, Check TOS class (+StringId)
	&SbiDisas::StrOp,   // Set libname for declare procs (+StringId)
	&SbiDisas::ImmOp,   // TOS is incremented about BASE erhoeht, BASE pushed before
	&SbiDisas::TypeOp,  // Convert last parameter to/in(?) argv (+Typ)
	&SbiDisas::StrOp,   // VBASETCLASS (+StringId)
};

static const Func pOperand3[] = {
	// All opcodes with two operands
	&SbiDisas::VarOp,	// Load from RTL (+StringID+Typ)
	&SbiDisas::VarOp,	// Load (+StringID+Typ)
	&SbiDisas::VarOp,	// Load Element (+StringID+Typ)
	&SbiDisas::OffOp,	// Parameter (+Offset+Typ)

	// Branch
	&SbiDisas::VarOp,	// Call DECLARE-Method (+StringID+Typ)
	&SbiDisas::VarOp,	// Call CDecl-DECLARE-Methode (+StringID+Typ)
	&SbiDisas::CaseOp,	// Case-Test (+Test-Opcode+False-Target)
	&SbiDisas::StmntOp,	// Statement (+Row+Column)

	// I/O
	&SbiDisas::StrmOp,	// (+SvStreamFlags+Flags)

	// Objects
	&SbiDisas::VarDefOp,   // Define local var (+StringID+Typ)
	&SbiDisas::VarDefOp,   // Define Module global var (+StringID+Typ)
	&SbiDisas::VarDefOp,   // Define global var (+StringID+Typ)
	&SbiDisas::Str2Op,     // Create object (+StringId+StringId)
	&SbiDisas::VarDefOp,   // Define static object (+StringID+Typ)
	&SbiDisas::Str2Op,     // Create User defined Object (+StringId+StringId)
	&SbiDisas::Str2Op,     // Create User defined Object-Array (+StringId+StringId)
	&SbiDisas::VarDefOp,   // Define persistent global var P=PERSIST (+StringID+Typ)
    &SbiDisas::VarOp,    // Searches for global var with special handling due to  _GLOBAL_P
	&SbiDisas::Str2Op,     // Redimensionate User defined Object-Array (+StringId+StringId)
	&SbiDisas::VarOp,	 // FIND_CM
	&SbiDisas::VarDefOp, // PUBLIC_P
	&SbiDisas::VarOp,	 // FIND_STATIC
};

// TODO: Why as method? Isn't a simple define sufficient?
static const char* _crlf()
{
#if defined (UNX) || defined( PM2 )
	return "\n";
#else
	return "\r\n";
#endif
}

// This method exists because we want to load the file as own segment
sal_Bool SbModule::Disassemble( String& rText )
{
	rText.Erase();
	if( pImage )
	{
		SbiDisas aDisas( this, pImage );
		aDisas.Disas( rText );
	}
	return sal_Bool( rText.Len() != 0 );
}

SbiDisas::SbiDisas( SbModule* p, const SbiImage* q ) : rImg( *q ), pMod( p )
{
	memset( cLabels, 0, 8192 );
	nLine = 0;
	nOff = 0;
	nPC = 0;
	nOp1 = nOp2 = nParts = 0;
	eOp = _NOP;
	// Set Label-Bits
	nOff = 0;
	while( Fetch() )
	{
		switch( eOp )
		{
			case _RESUME: if( nOp1 <= 1 ) break;
			case _RETURN: if( !nOp1 ) break;
			case _JUMP:
			case _JUMPT:
			case _JUMPF:
			case _GOSUB:
			case _TESTFOR:
			case _CASEIS:
			case _CASETO:
			case _ERRHDL:
                cLabels[ (nOp1 & 0xffff) >> 3 ] |= ( 1 << ( nOp1 & 7 ) );
                break;
			default: break;
		}
	}
	nOff = 0;
	// Add the publics
	for( sal_uInt16 i = 0; i < pMod->GetMethods()->Count(); i++ )
	{
		SbMethod* pMeth = PTR_CAST(SbMethod,pMod->GetMethods()->Get( i ));
		if( pMeth )
		{
			sal_uInt16 nPos = (sal_uInt16) (pMeth->GetId());
			cLabels[ nPos >> 3 ] |= ( 1 << ( nPos & 7 ) );
		}
	}
}

// Read current opcode
sal_Bool SbiDisas::Fetch()
{
	nPC = nOff;
	if( nOff >= rImg.GetCodeSize() )
		return sal_False;
	const unsigned char* p = (const unsigned char*)( rImg.GetCode() + nOff );
	eOp = (SbiOpcode) ( *p++ & 0xFF );
	if( eOp <= SbOP0_END )
	{
		nOp1 = nOp2 = 0;
		nParts = 1;
		nOff++;
		return sal_True;
	}
	else if( eOp <= SbOP1_END )
	{
		nOff += 5;
		if( nOff > rImg.GetCodeSize() )
			return sal_False;
		nOp1 = *p++; nOp1 |= *p++ << 8; nOp1 |= *p++ << 16; nOp1 |= *p++ << 24;
		nParts = 2;
		return sal_True;
	}
	else if( eOp <= SbOP2_END )
	{
		nOff += 9;
		if( nOff > rImg.GetCodeSize() )
			return sal_False;
		nOp1 = *p++; nOp1 |= *p++ << 8; nOp1 |= *p++ << 16; nOp1 |= *p++ << 24;
		nOp2 = *p++; nOp2 |= *p++ << 8; nOp2 |= *p++ << 16; nOp2 |= *p++ << 24;
		nParts = 3;
		return sal_True;
	}
	else
		return sal_False;
}

void SbiDisas::Disas( SvStream& r )
{
	String aText;
	nOff = 0;
	while( DisasLine( aText ) )
	{
		ByteString aByteText( aText, gsl_getSystemTextEncoding() );
		r.WriteLine( aByteText );
	}
}

void SbiDisas::Disas( String& r )
{
	r.Erase();
	String aText;
	nOff = 0;
	while( DisasLine( aText ) )
	{
		r += aText;
		r.AppendAscii( _crlf() );
	}
	aText.ConvertLineEnd();
}

sal_Bool SbiDisas::DisasLine( String& rText )
{
	char cBuf[ 100 ];
	const char* pMask[] = {
		"%08" SAL_PRIXUINT32 "                            ",
		"%08" SAL_PRIXUINT32 " %02X                   ",
		"%08" SAL_PRIXUINT32 " %02X %08X          ",
		"%08" SAL_PRIXUINT32 " %02X %08X %08X " };
	rText.Erase();
	if( !Fetch() )
		return sal_False;

#ifdef DBG_TRACE_BASIC
	String aTraceStr_STMNT;
#endif

	// New line?
	if( eOp == _STMNT && nOp1 != nLine )
	{
        // Find line
        String aSource = rImg.aOUSource;
		nLine = nOp1;
		sal_uInt16 n = 0;
		sal_uInt16 l = (sal_uInt16)nLine;
		while( --l ) {
			n = aSource.SearchAscii( "\n", n );
			if( n == STRING_NOTFOUND ) break;
			else n++;
		}
		// Show position
		if( n != STRING_NOTFOUND )
		{
			sal_uInt16 n2 = aSource.SearchAscii( "\n", n );
			if( n2 == STRING_NOTFOUND ) n2 = aSource.Len() - n;
			String s( aSource.Copy( n, n2 - n + 1 ) );
			sal_Bool bDone;
			do {
				bDone = sal_True;
				n = s.Search( '\r' );
				if( n != STRING_NOTFOUND ) bDone = sal_False, s.Erase( n, 1 );
				n = s.Search( '\n' );
				if( n != STRING_NOTFOUND ) bDone = sal_False, s.Erase( n, 1 );
			} while( !bDone );
//          snprintf( cBuf, sizeof(cBuf), pMask[ 0 ], nPC );
//			rText += cBuf;
			rText.AppendAscii( "; " );
			rText += s;
			rText.AppendAscii( _crlf() );

#ifdef DBG_TRACE_BASIC
			aTraceStr_STMNT = s;
#endif
		}
	}

	// Label?
	const char* p = "";
	if( cLabels[ nPC >> 3 ] & ( 1 << ( nPC & 7 ) ) )
	{
		// Public?
		ByteString aByteMethName;
		for( sal_uInt16 i = 0; i < pMod->GetMethods()->Count(); i++ )
		{
			SbMethod* pMeth = PTR_CAST(SbMethod,pMod->GetMethods()->Get( i ));
			if( pMeth )
			{
				aByteMethName = ByteString( pMeth->GetName(), gsl_getSystemTextEncoding() );
				if( pMeth->GetId() == nPC )
				{
					p = aByteMethName.GetBuffer();
					break;
				}
				if( pMeth->GetId() >= nPC )
					break;
			}
		}
        snprintf( cBuf, sizeof(cBuf), pMask[ 0 ], nPC );
		rText.AppendAscii( cBuf );
		if( p && *p )
		{
			rText.AppendAscii( p );
		}
		else
		{
            // fix warning (now error) for "Lbl%04lX" format
  			snprintf( cBuf, sizeof(cBuf), "Lbl%08" SAL_PRIXUINT32, nPC );
			rText.AppendAscii( cBuf );
		}
		rText += ':';
		rText.AppendAscii( _crlf() );
	}
    snprintf( cBuf, sizeof(cBuf), pMask[ nParts ], nPC, (sal_uInt16) eOp, nOp1, nOp2 );

	String aPCodeStr;
	aPCodeStr.AppendAscii( cBuf );
	int n = eOp;
	if( eOp >= SbOP2_START )
		n -= SbOP2_START;
	else if( eOp >= SbOP1_START )
		n -= SbOP1_START;
	aPCodeStr += '\t';
	aPCodeStr.AppendAscii( pOps[ nParts-1 ][ n ] );
	aPCodeStr += '\t';
	switch( nParts )
	{
		case 2: (this->*( pOperand2[ n ] ) )( aPCodeStr ); break;
		case 3: (this->*( pOperand3[ n ] ) )( aPCodeStr ); break;
	}

	rText += aPCodeStr;

#ifdef DBG_TRACE_BASIC
	dbg_RegisterTraceTextForPC( pMod, nPC, aTraceStr_STMNT, aPCodeStr );
#endif

	return sal_True;
}

// Read from StringPool
void SbiDisas::StrOp( String& rText )
{
	String aStr = rImg.GetString( (sal_uInt16)nOp1 );
	ByteString aByteString( aStr, RTL_TEXTENCODING_ASCII_US );
	const char* p = aByteString.GetBuffer();
	if( p )
	{
		rText += '"';
		rText.AppendAscii( p );
		rText += '"';
	}
	else
	{
		rText.AppendAscii( "?String? " );
		rText += (sal_uInt16)nOp1;
	}
}

void SbiDisas::Str2Op( String& rText )
{
	StrOp( rText );
	rText += ',';
	String s;
	nOp1 = nOp2;
	StrOp( s );
	rText += s;
}

// Immediate Operand
void SbiDisas::ImmOp( String& rText )
{
	rText += String::CreateFromInt32(nOp1);
}

// OnGoto Operand
void SbiDisas::OnOp( String& rText )
{
	rText += String::CreateFromInt32(nOp1 & 0x7FFF);
	if( nOp1 & 0x800 )
		rText.AppendAscii( "\t; Gosub" );
}

// Label
void SbiDisas::LblOp( String& rText )
{
	char cBuf[ 10 ];
    snprintf( cBuf, sizeof(cBuf), "Lbl%04" SAL_PRIXUINT32, nOp1 );
	rText.AppendAscii( cBuf );
}

// 0 or Label
void SbiDisas::ReturnOp( String& rText )
{
	if( nOp1 )
		LblOp( rText );
}

// 0, 1 or Label
void SbiDisas::ResumeOp( String& rText )
{
	switch( nOp1 )
	{
		case 1: rText.AppendAscii( "NEXT" ); break;
		case 2: LblOp( rText );
	}
}

// print Prompt
// sal_False/TRUE
void SbiDisas::PromptOp( String& rText )
{
	if( nOp1 )
		rText.AppendAscii( "\"? \"" );
}

// 0 or 1
void SbiDisas::CloseOp( String& rText )
{
	rText.AppendAscii( nOp1 ? "Channel" : "All" );
}

// Print character
void SbiDisas::CharOp( String& rText )
{
	const char* p = NULL;
	switch( nOp1 )
	{
		case  7: p = "'\\a'"; break;
		case  9: p = "'\\t'"; break;
		case 10: p = "'\\n'"; break;
		case 12: p = "'\\f'"; break;
		case 13: p = "'\\r'"; break;
	}
	if( p ) rText.AppendAscii( p );
	else if( nOp1 >= ' ' )
		rText += '\'',
		rText += (char) nOp1,
		rText += '\'';
	else
		rText.AppendAscii( "char " ),
		rText += (sal_uInt16)nOp1;
}

// Print var: String-ID and type
void SbiDisas::VarOp( String& rText )
{
	rText += rImg.GetString( (sal_uInt16)(nOp1 & 0x7FFF) );
	rText.AppendAscii( "\t; " );
    // The type
	sal_uInt32 n = nOp1;
	nOp1 = nOp2;
	TypeOp( rText );
	if( n & 0x8000 )
		rText.AppendAscii( ", Args" );
}

// Define variable: String-ID and type
void SbiDisas::VarDefOp( String& rText )
{
	rText += rImg.GetString( (sal_uInt16)(nOp1 & 0x7FFF) );
	rText.AppendAscii( "\t; " );
    // The Typ
	nOp1 = nOp2;
	TypeOp( rText );
}

// Print variable: Offset and Typ
void SbiDisas::OffOp( String& rText )
{
	rText += String::CreateFromInt32( nOp1 & 0x7FFF );
	rText.AppendAscii( "\t; " );
	// The type
	sal_uInt32 n = nOp1;
	nOp1 = nOp2;
	TypeOp( rText );
	if( n & 0x8000 )
		rText.AppendAscii( ", Args" );
}

// Data type
#ifdef HP9000 // TODO: remove this!
static char* SbiDisas_TypeOp_pTypes[13] = {
	"Empty","Null","Integer","Long","Single","Double",
	"Currency","Date","String","Object","Error","Boolean",
	"Variant" };
#define pTypes SbiDisas_TypeOp_pTypes
#endif
void SbiDisas::TypeOp( String& rText )
{
	// AB 19.1.96: Typ kann Flag für BYVAL enthalten (StepARGTYP)
	if( nOp1 & 0x8000 )
	{
		nOp1 &= 0x7FFF;		// Flag wegfiltern
		rText.AppendAscii( "BYVAL " );
	}
	if( nOp1 < 13 )
	{
#ifndef HP9000
		static char pTypes[][13] = {
			"Empty","Null","Integer","Long","Single","Double",
			"Currency","Date","String","Object","Error","Boolean",
			"Variant" };
#endif
		rText.AppendAscii( pTypes[ nOp1 ] );
	}
	else
	{
		rText.AppendAscii( "type " );
		rText += (sal_uInt16)nOp1;
	}
}
#ifdef HP9000
#undef pTypes
#endif

// sal_True-Label, condition Opcode
void SbiDisas::CaseOp( String& rText )
{
	LblOp( rText );
	rText += ',';
	rText.AppendAscii( pOp1[ nOp2 - SbxEQ + _EQ ] );
}

// Row, column
void SbiDisas::StmntOp( String& rText )
{
	rText += String::CreateFromInt32( nOp1 );
	rText += ',';
	sal_uInt32 nCol = nOp2 & 0xFF;
	sal_uInt32 nFor = nOp2 / 0x100;
    rText += String::CreateFromInt32( nCol );
	rText.AppendAscii( " (For-Level: " );
	rText += String::CreateFromInt32( nFor );
	rText += ')';
}

// open mode, flags
void SbiDisas::StrmOp( String& rText )
{
	char cBuf[ 10 ];
    snprintf( cBuf, sizeof(cBuf), "%04" SAL_PRIXUINT32, nOp1 );
	rText.AppendAscii( cBuf );
	if( nOp2 & SBSTRM_INPUT )
		rText.AppendAscii( ", Input" );
	if( nOp2 & SBSTRM_OUTPUT )
		rText.AppendAscii( ", Output" );
	if( nOp2 & SBSTRM_APPEND )
		rText.AppendAscii( ", Append" );
	if( nOp2 & SBSTRM_RANDOM )
		rText.AppendAscii( ", Random" );
	if( nOp2 & SBSTRM_BINARY )
		rText.AppendAscii( ", Binary" );
}