Translated German comments, removed redundant ones till cairo (incl.)
Allmann-Rahn
allmann-rahn at ubuntu.ubuntu-domain
Sat Aug 27 12:37:14 PDT 2011
---
basegfx/inc/basegfx/matrix/b2dhommatrix.hxx | 21 +--
basic/inc/basic/process.hxx | 2 +-
basic/inc/basic/sbxbase.hxx | 2 +-
basic/source/app/app.hxx | 6 +-
basic/source/app/appwin.cxx | 2 +-
basic/source/basmgr/basmgr.cxx | 2 +-
basic/source/classes/sb.cxx | 2 +-
basic/source/classes/sbintern.cxx | 8 +-
basic/source/classes/sbunoobj.cxx | 6 +-
basic/source/comp/exprtree.cxx | 186 +++++++++----------
basic/source/comp/io.cxx | 30 ++--
basic/source/comp/loops.cxx | 57 +++---
basic/source/comp/parser.cxx | 103 +++++------
basic/source/comp/sbcomp.cxx | 12 +-
basic/source/comp/scanner.cxx | 71 ++++----
basic/source/comp/symtbl.cxx | 92 ++++------
basic/source/comp/token.cxx | 69 +++----
basic/source/inc/buffer.hxx | 42 ++--
basic/source/inc/codegen.hxx | 18 +-
basic/source/inc/collelem.hxx | 8 +-
basic/source/inc/disas.hxx | 18 +-
basic/source/inc/expr.hxx | 134 +++++++-------
basic/source/inc/filefmt.hxx | 192 ++++++++++----------
basic/source/inc/image.hxx | 62 +++---
basic/source/inc/iosys.hxx | 41 ++--
basic/source/inc/object.hxx | 50 +++---
basic/source/inc/opcodes.hxx | 150 ++++++++--------
basic/source/inc/parser.hxx | 80 ++++----
basic/source/inc/runtime.hxx | 179 +++++++++---------
basic/source/inc/sbcomp.hxx | 10 +-
basic/source/inc/sbintern.hxx | 36 ++--
basic/source/inc/sbjsmeth.hxx | 6 +-
basic/source/inc/sbjsmod.hxx | 8 +-
basic/source/inc/sbunoobj.hxx | 31 ++--
basic/source/inc/scanner.hxx | 63 +++----
basic/source/inc/symtbl.hxx | 123 ++++++------
basic/source/inc/token.hxx | 56 +++---
basic/source/runtime/basrdll.cxx | 4 +-
basic/source/runtime/inputbox.cxx | 2 +-
basic/source/runtime/iosys.cxx | 19 +--
basic/source/runtime/methods.cxx | 121 +++++-------
basic/source/runtime/methods1.cxx | 105 +++++------
basic/source/runtime/props.cxx | 8 +-
basic/source/runtime/runtime.cxx | 267 +++++++++++++--------------
basic/source/runtime/stdobj.cxx | 87 +++++-----
basic/source/runtime/stdobj1.cxx | 9 +-
basic/source/runtime/step0.cxx | 128 ++++++-------
basic/source/runtime/step1.cxx | 85 +++++-----
basic/source/runtime/step2.cxx | 242 +++++++++++--------------
basic/source/sample/collelem.cxx | 12 +-
basic/source/sample/object.cxx | 139 ++++++------
basic/source/sbx/sbxbool.cxx | 2 +-
basic/source/sbx/sbxform.cxx | 480 +++++++++++++++-----------------------
basic/source/sbx/sbxscan.cxx | 189 +++++++--------
basic/workben/mgrtest.cxx | 6 +-
55 files changed, 1803 insertions(+), 2080 deletions(-)
diff --git a/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx b/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
index 0855582..7159635 100644
--- a/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
+++ b/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
@@ -71,53 +71,43 @@ namespace basegfx
// involved in calculations
bool isLastLineDefault() const;
- // Auf Einheitsmatrix zuruecksetzen
+ // reset to a standard matrix
bool isIdentity() const;
void identity();
- // Invertierung
bool isInvertible() const;
bool invert();
- // Normalisierung
bool isNormalized() const;
void normalize();
- // Determinante
double determinant() const;
- // Trace
double trace() const;
- // Transpose
void transpose();
- // Rotation
void rotate(double fRadiant);
- // Translation
void translate(double fX, double fY);
- // Skalierung
void scale(double fX, double fY);
// Shearing-Matrices
void shearX(double fSx);
void shearY(double fSy);
- // Addition, Subtraktion
+
B2DHomMatrix& operator+=(const B2DHomMatrix& rMat);
B2DHomMatrix& operator-=(const B2DHomMatrix& rMat);
- // Vergleichsoperatoren
bool operator==(const B2DHomMatrix& rMat) const;
bool operator!=(const B2DHomMatrix& rMat) const;
- // Multiplikation, Division mit Konstante
B2DHomMatrix& operator*=(double fValue);
B2DHomMatrix& operator/=(double fValue);
- // Matritzenmultiplikation von links auf die lokale
+ // matrix multiplication from the left to the local
B2DHomMatrix& operator*=(const B2DHomMatrix& rMat);
// assignment operator
@@ -125,11 +115,10 @@ namespace basegfx
// Help routine to decompose given homogen 3x3 matrix to components. A correction of
// the components is done to avoid inaccuracies.
- // Zerlegung
bool decompose(B2DTuple& rScale, B2DTuple& rTranslate, double& rRotate, double& rShearX) const;
};
- // Addition, Subtraktion
+ // addition, subtraction
inline B2DHomMatrix operator+(const B2DHomMatrix& rMatA, const B2DHomMatrix& rMatB)
{
B2DHomMatrix aSum(rMatA);
@@ -144,7 +133,7 @@ namespace basegfx
return aDiv;
}
- // Multiplikation, Division mit Konstante
+ // multiplication, division by a constant
inline B2DHomMatrix operator*(const B2DHomMatrix& rMat, double fValue)
{
B2DHomMatrix aNew(rMat);
diff --git a/basic/inc/basic/process.hxx b/basic/inc/basic/process.hxx
index 8c63f53..e795407 100644
--- a/basic/inc/basic/process.hxx
+++ b/basic/inc/basic/process.hxx
@@ -55,7 +55,7 @@ class Process
public:
Process();
~Process();
- // Methoden
+ // methods
void SetImage( const String &aAppPath, const String &aAppParams, const Environment *pEnv = NULL );
sal_Bool Start();
sal_uIntPtr GetExitCode();
diff --git a/basic/inc/basic/sbxbase.hxx b/basic/inc/basic/sbxbase.hxx
index e38c2ec..b136f1f 100644
--- a/basic/inc/basic/sbxbase.hxx
+++ b/basic/inc/basic/sbxbase.hxx
@@ -40,7 +40,7 @@ class SbxBasicFormater;
SV_DECL_PTRARR_DEL(SbxFacs,SbxFactory*,5,5)
-// AppData-Struktur for SBX:
+// AppData structure for SBX:
struct SbxAppData
{
SbxError eSbxError; // Error code
diff --git a/basic/source/app/app.hxx b/basic/source/app/app.hxx
index 3ef46ed..cdc7765 100644
--- a/basic/source/app/app.hxx
+++ b/basic/source/app/app.hxx
@@ -53,10 +53,10 @@ struct TTLogMsg;
typedef ::std::vector< AppWin* > EditList;
class BasicApp : public Application {
- short nWait; // Wait-Zaehler
+ short nWait; // wait counter
public:
- BasicFrame* pFrame; // Frame Window
- Accelerator* pMainAccel; // Acceleratoren
+ BasicFrame* pFrame; // frame window
+ Accelerator* pMainAccel; // accelerators
int Main( );
diff --git a/basic/source/app/appwin.cxx b/basic/source/app/appwin.cxx
index fc6d5ec..8d7375a 100644
--- a/basic/source/app/appwin.cxx
+++ b/basic/source/app/appwin.cxx
@@ -219,7 +219,7 @@ long AppWin::PreNotify( NotifyEvent& rNEvt )
if ( rNEvt.GetType() == EVENT_GETFOCUS )
if ( pFrame->pList->back() != this )
Activate();
- return sal_False; // Der event soll weiter verarbeitet werden
+ return sal_False; // the event shall continue to be handled
}
void AppWin::Activate()
diff --git a/basic/source/basmgr/basmgr.cxx b/basic/source/basmgr/basmgr.cxx
index c3187f5..174aa1d 100644
--- a/basic/source/basmgr/basmgr.cxx
+++ b/basic/source/basmgr/basmgr.cxx
@@ -1341,7 +1341,7 @@ StarBASIC* BasicManager::AddLib( SotStorage& rStorage, const String& rLibName, s
BasicLibInfo* pLibInfo = CreateLibInfo();
// Use original name otherwise ImpLoadLibary failes...
pLibInfo->SetLibName( rLibName );
- // Funktioniert so aber nicht, wenn Name doppelt
+ // but doesn't work this way if name exists twice
sal_uInt16 nLibId = (sal_uInt16) pLibs->GetPos( pLibInfo );
// Set StorageName before load because it is compared with pCurStorage
diff --git a/basic/source/classes/sb.cxx b/basic/source/classes/sb.cxx
index d2a5341..98f71ae 100644
--- a/basic/source/classes/sb.cxx
+++ b/basic/source/classes/sb.cxx
@@ -1794,7 +1794,7 @@ SbxArrayRef StarBASIC::getUnoListeners( void )
/**************************************************************************
*
-* Laden und Speichern
+* load and save
*
**************************************************************************/
diff --git a/basic/source/classes/sbintern.cxx b/basic/source/classes/sbintern.cxx
index 2f0a9fe..d9243dd 100644
--- a/basic/source/classes/sbintern.cxx
+++ b/basic/source/classes/sbintern.cxx
@@ -32,10 +32,10 @@
#include "sbintern.hxx"
#include "sbunoobj.hxx"
-#include "token.hxx" // Tokenizer
-#include "symtbl.hxx" // Symbolverwaltung
-#include "parser.hxx" // Parser
-#include "codegen.hxx" // Code-Generator
+#include "token.hxx"
+#include "symtbl.hxx"
+#include "parser.hxx"
+#include "codegen.hxx"
#include <basic/basmgr.hxx>
SV_IMPL_PTRARR(SbErrorStack, SbErrorStackEntry*)
diff --git a/basic/source/classes/sbunoobj.cxx b/basic/source/classes/sbunoobj.cxx
index c8ccefa..360e78a 100644
--- a/basic/source/classes/sbunoobj.cxx
+++ b/basic/source/classes/sbunoobj.cxx
@@ -1244,8 +1244,8 @@ Any sbxToUnoValue( SbxVariable* pVar )
return sbxToUnoValueImpl( pVar );
}
-// Funktion, um einen globalen Bezeichner im
-// UnoScope zu suchen und fuer Sbx zu wrappen
+// function to find a global identifier in
+// the UnoScope and to wrap it for Sbx
static bool implGetTypeByName( const String& rName, Type& rRetType )
{
bool bSuccess = false;
@@ -4183,7 +4183,7 @@ sal_Bool SAL_CALL InvocationToAllListenerMapper::hasProperty(const ::rtl::OUStri
}
//========================================================================
-// Uno-Service erzeugen
+// create Uno-Service
// 1. Parameter == Prefix-Name of the macro
// 2. Parameter == fully qualified name of the listener
void SbRtl_CreateUnoListener( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite )
diff --git a/basic/source/comp/exprtree.cxx b/basic/source/comp/exprtree.cxx
index 31d285f..1c7ec1b 100644
--- a/basic/source/comp/exprtree.cxx
+++ b/basic/source/comp/exprtree.cxx
@@ -30,7 +30,7 @@
#include "precompiled_basic.hxx"
#include "sbcomp.hxx"
-#include <basic/sbx.hxx> // w.g. ...IMPL_REF(...sbxvariable)
+#include <basic/sbx.hxx> // because of ...IMPL_REF(...sbxvariable)
#include "expr.hxx"
/***************************************************************************
@@ -99,20 +99,20 @@ SbiExpression::~SbiExpression()
delete pExpr;
}
-// Einlesen eines kompletten Bezeichners
-// Ein Bezeichner hat folgende Form:
+// reading in a complete identifier
+// an identifier has the following form:
// name[(Parameter)][.Name[(parameter)]]...
-// Strukturelemente werden ueber das Element pNext verkoppelt,
-// damit sie nicht im Baum stehen.
+// structure elements are coupled via the element pNext,
+// so that they're not in the tree.
-// Folgen Parameter ohne Klammer? Dies kann eine Zahl, ein String,
-// ein Symbol oder auch ein Komma sein (wenn der 1. Parameter fehlt)
+// Are there parameters without brackets following? This may be a number,
+// a string, a symbol or also a comma (if the 1st parameter is missing)
static sal_Bool DoParametersFollow( SbiParser* p, SbiExprType eCurExpr, SbiToken eTok )
{
if( eTok == LPAREN )
return sal_True;
- // Aber nur, wenn CALL-aehnlich!
+ // but only if similar to CALL!
if( !p->WhiteSpace() || eCurExpr != SbSYMBOL )
return sal_False;
if ( eTok == NUMBER || eTok == MINUS || eTok == FIXSTRING
@@ -131,26 +131,26 @@ static sal_Bool DoParametersFollow( SbiParser* p, SbiExprType eCurExpr, SbiToken
return sal_False;
}
-// Definition eines neuen Symbols
+// definition of a new symbol
static SbiSymDef* AddSym
( SbiToken eTok, SbiSymPool& rPool, SbiExprType eCurExpr,
const String& rName, SbxDataType eType, SbiParameters* pPar )
{
SbiSymDef* pDef;
- // A= ist keine Prozedur
+ // A= is not a procedure
sal_Bool bHasType = sal_Bool( eTok == EQ || eTok == DOT );
if( ( !bHasType && eCurExpr == SbSYMBOL ) || pPar )
{
- // Dies ist also eine Prozedur
- // da suche man doch den richtigen Pool raus, da Procs
- // immer in einem Public-Pool landen muessen
+ // so this is a procedure
+ // the correct pool should be found out, as
+ // procs must always get into a public pool
SbiSymPool* pPool = &rPool;
if( pPool->GetScope() != SbPUBLIC )
pPool = &rPool.GetParser()->aPublics;
SbiProcDef* pProc = pPool->AddProc( rName );
- // Sonderbehandlung fuer Colls wie Documents(1)
+ // special treatment for Colls like Documents(1)
if( eCurExpr == SbSTDEXPR )
bHasType = sal_True;
@@ -158,7 +158,7 @@ static SbiSymDef* AddSym
pDef->SetType( bHasType ? eType : SbxEMPTY );
if( pPar )
{
- // Dummy-Parameter generieren
+ // generate dummy parameters
sal_uInt16 n = 1;
for( short i = 0; i < pPar->GetSize(); i++ )
{
@@ -170,22 +170,21 @@ static SbiSymDef* AddSym
}
else
{
- // oder ein normales Symbol
+ // or a normal symbol
pDef = rPool.AddSym( rName );
pDef->SetType( eType );
}
return pDef;
}
-// Zur Zeit sind sogar Keywords zugelassen (wg. gleichnamiger Dflt-Properties)
+// currently even keywords are allowed (because of Dflt properties of the same name)
SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
{
if( pParser->Peek() == DOT )
{
- // eine WITH-Variable
SbiExprNode* pWithVar = pParser->GetWithVar();
- // #26608: Ans Ende der Node-Kette gehen, um richtiges Objekt zu uebergeben
+ // #26608: get to the node-chain's end to pass the correct object
SbiSymDef* pDef = pWithVar ? pWithVar->GetRealVar() : NULL;
SbiExprNode* pNd = NULL;
if( !pDef )
@@ -207,23 +206,23 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
}
SbiToken eTok = (pKeywordSymbolInfo == NULL) ? pParser->Next() : pKeywordSymbolInfo->m_eTok;
- // Anfang des Parsings merken
+ // memorize the parsing's begin
pParser->LockColumn();
String aSym( (pKeywordSymbolInfo == NULL) ? pParser->GetSym() : pKeywordSymbolInfo->m_aKeywordSymbol );
SbxDataType eType = (pKeywordSymbolInfo == NULL) ? pParser->GetType() : pKeywordSymbolInfo->m_eSbxDataType;
SbiParameters* pPar = NULL;
SbiExprListVector* pvMoreParLcl = NULL;
- // Folgen Parameter?
+ // are there parameters following?
SbiToken eNextTok = pParser->Peek();
- // Ist es ein benannter Parameter?
- // Dann einfach eine Stringkonstante erzeugen. Diese wird
- // im SbiParameters-ctor erkannt und weiterverarbeitet
+ // is it a known parameter?
+ // create a string constant then, which will be recognized
+ // in the SbiParameters-ctor and is continued to be handled
if( eNextTok == ASSIGN )
{
pParser->UnlockColumn();
return new SbiExprNode( pParser, aSym );
}
- // ab hier sind keine Keywords zugelassen!
+ // no keywords allowed from here on!
if( pParser->IsKwd( eTok ) )
{
if( pParser->IsCompatible() && eTok == INPUT )
@@ -257,9 +256,9 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
eTok = pParser->Peek();
}
}
- // Es koennte ein Objektteil sein, wenn . oder ! folgt
- // Bei . muss aber die Variable bereits definiert sein; wenn pDef
- // nach der Suche NULL ist, isses ein Objekt!
+ // It might be an object part, if . or ! is following.
+ // In case of . the variable must already be defined;
+ // it's an object, if pDef is NULL after the search.
sal_Bool bObj = sal_Bool( ( eTok == DOT || eTok == EXCLAM )
&& !pParser->WhiteSpace() );
if( bObj )
@@ -269,18 +268,18 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
eType = SbxOBJECT;
else
{
- // Name%. geht wirklich nicht!
+ // Name%. really does not work!
pParser->Error( SbERR_BAD_DECLARATION, aSym );
bError = sal_True;
}
}
- // Suche:
+ // Search:
SbiSymDef* pDef = pParser->pPool->Find( aSym );
if( !pDef )
{
- // Teil der Runtime-Library?
- // AB 31.3.1996: In Parser-Methode ausgelagert
- // (wird auch in SbiParser::DefVar() in DIM.CXX benoetigt)
+ // Part of the Runtime-Library?
+ // from 31.3.1996: swapped out to parser-method
+ // (is also needed in SbiParser::DefVar() in DIM.CXX)
pDef = pParser->CheckRTLForSym( aSym, eType );
// #i109184: Check if symbol is or later will be defined inside module
@@ -291,8 +290,6 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
}
if( !pDef )
{
- // Falls ein Punkt angegeben war, isses Teil eines Objekts,
- // also muss der Returnwert ein Objekt sein
if( bObj )
eType = SbxOBJECT;
pDef = AddSym( eTok, *pParser->pPool, eCurExpr, aSym, eType, pPar );
@@ -305,8 +302,6 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
else
{
- // Symbol ist bereits definiert.
- // Ist es eine Konstante?
SbiConstDef* pConst = pDef->GetConstDef();
if( pConst )
{
@@ -315,9 +310,8 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
else
return new SbiExprNode( pParser, pConst->GetValue(), pConst->GetType() );
}
- // Hat es Dimensionen,
- // und sind auch Parameter angegeben?
- // (Wobei 0 Parameter () entsprechen)
+
+ // 0 parameters come up to ()
if( pDef->GetDims() )
{
if( pPar && pPar->GetSize() && pPar->GetSize() != pDef->GetDims() )
@@ -329,26 +323,26 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
// #119187 Only error if types conflict
if( eType >= SbxINTEGER && eType <= SbxSTRING && eType != eDefType )
{
- // Wie? Erst mit AS definieren und dann einen Suffix nehmen?
+ // How? Define with AS first and take a Suffix then?
pParser->Error( SbERR_BAD_DECLARATION, aSym );
bError = sal_True;
}
else if ( eType == SbxVARIANT )
- // Falls nix angegeben, den Typ des Eintrags nehmen
- // aber nur, wenn die Var nicht mit AS XXX definiert ist
- // damit erwischen wir n% = 5 : print n
+ // if there's nothing named, take the type of the entry,
+ // but only if the var hasn't been defined with AS XXX
+ // so that we catch n% = 5 : print n
eType = eDefType;
}
- // Typcheck bei Variablen:
- // ist explizit im Scanner etwas anderes angegeben?
- // Bei Methoden ist dies OK!
- if( eType != SbxVARIANT && // Variant nimmt alles
+ // checking type of variables:
+ // is there named anything different in the scanner?
+ // That's OK for methods!
+ if( eType != SbxVARIANT && // Variant takes everything
eType != pDef->GetType() &&
!pDef->GetProcDef() )
{
- // Es kann sein, dass pDef ein Objekt beschreibt, das bisher
- // nur als SbxVARIANT erkannt wurde, dann Typ von pDef aendern
- // AB, 16.12.95 (Vielleicht noch aehnliche Faelle moeglich ?!?)
+ // maybe pDef describes an object that so far has only been
+ // recognized as SbxVARIANT - then change type of pDef
+ // from 16.12.95 (similar cases possible perhaps?!?)
if( eType == SbxOBJECT && pDef->GetType() == SbxVARIANT )
{
pDef->SetType( SbxOBJECT );
@@ -367,11 +361,11 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
pNd->aVar.pvMorePar = pvMoreParLcl;
if( bObj )
{
- // AB, 8.1.95: Objekt kann auch vom Typ SbxVARIANT sein
+ // from 8.1.95: Object may also be of the type SbxVARIANT
if( pDef->GetType() == SbxVARIANT )
pDef->SetType( SbxOBJECT );
- // Falls wir etwas mit Punkt einscannen, muss der
- // Typ SbxOBJECT sein
+ // if we scan something with point,
+ // the type must be SbxOBJECT
if( pDef->GetType() != SbxOBJECT && pDef->GetType() != SbxVARIANT )
{
// defer error until runtime if in vba mode
@@ -384,13 +378,13 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
if( !bError )
pNd->aVar.pNext = ObjTerm( *pDef );
}
- // Merken der Spalte 1 wieder freigeben
+
pParser->UnlockColumn();
return pNd;
}
-// Aufbau eines Objekt-Terms. Ein derartiger Term ist Teil
-// eines Ausdrucks, der mit einer Objektvariablen beginnt.
+// construction of an object term. A term of this kind is part
+// of an expression that begins with an object variable.
SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
{
@@ -398,8 +392,8 @@ SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
SbiToken eTok = pParser->Next();
if( eTok != SYMBOL && !pParser->IsKwd( eTok ) && !pParser->IsExtra( eTok ) )
{
- // #66745 Einige Operatoren koennen in diesem Kontext auch
- // als Identifier zugelassen werden, wichtig fuer StarOne
+ // #66745 Some operators can also be allowed
+ // as identifiers, important for StarOne
if( eTok != MOD && eTok != NOT && eTok != AND && eTok != OR &&
eTok != XOR && eTok != EQV && eTok != IMP && eTok != IS )
{
@@ -416,7 +410,7 @@ SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
SbiParameters* pPar = NULL;
SbiExprListVector* pvMoreParLcl = NULL;
eTok = pParser->Peek();
- // Parameter?
+
if( DoParametersFollow( pParser, eCurExpr, eTok ) )
{
bool bStandaloneExpression = false;
@@ -443,13 +437,13 @@ SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
eType = SbxOBJECT;
else
{
- // Name%. geht wirklich nicht!
+ // Name%. does really not work!
pParser->Error( SbERR_BAD_DECLARATION, aSym );
bError = sal_True;
}
}
- // Der Symbol-Pool eines Objekts ist immer PUBLIC
+ // an object's symbol pool is always PUBLIC
SbiSymPool& rPool = rObj.GetPool();
rPool.SetScope( SbPUBLIC );
SbiSymDef* pDef = rPool.Find( aSym );
@@ -464,11 +458,6 @@ SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
pNd->aVar.pvMorePar = pvMoreParLcl;
if( bObj )
{
- // Falls wir etwas mit Punkt einscannen, muss der
- // Typ SbxOBJECT sein
-
- // Es kann sein, dass pDef ein Objekt beschreibt, das bisher
- // nur als SbxVARIANT erkannt wurde, dann Typ von pDef aendern
if( pDef->GetType() == SbxVARIANT )
pDef->SetType( SbxOBJECT );
@@ -486,20 +475,20 @@ SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
return pNd;
}
-// Als Operanden kommen in Betracht:
-// Konstante
-// skalare Variable
-// Strukturelemente
-// Array-Elemente
-// Funktionen
-// geklammerte Ausdruecke
+// an operand can be:
+// constant
+// scalar variable
+// structure elements
+// array elements
+// functions
+// bracketed expressions
SbiExprNode* SbiExpression::Operand( bool bUsedForTypeOf )
{
SbiExprNode *pRes;
SbiToken eTok;
- // Operand testen:
+ // test operand:
switch( eTok = pParser->Peek() )
{
case SYMBOL:
@@ -555,13 +544,13 @@ SbiExprNode* SbiExpression::Operand( bool bUsedForTypeOf )
pRes->bComposite = sal_True;
break;
default:
- // Zur Zeit sind Keywords hier OK!
+ // keywords here are OK at the moment!
if( pParser->IsKwd( eTok ) )
pRes = Term();
else
{
pParser->Next();
- pRes = new SbiExprNode( pParser, 1.0, SbxDOUBLE ); // bei Fehlern
+ pRes = new SbiExprNode( pParser, 1.0, SbxDOUBLE );
pParser->Error( SbERR_UNEXPECTED, eTok );
}
}
@@ -848,7 +837,7 @@ SbiExprNode* SbiExpression::Like()
SbiToken eTok = pParser->Next();
pNd = new SbiExprNode( pParser, pNd, eTok, Comp() ), nCount++;
}
- // Mehrere Operatoren hintereinander gehen nicht
+ // multiple operands in a row does not work
if( nCount > 1 && !pParser->IsVBASupportOn() )
{
pParser->Error( SbERR_SYNTAX );
@@ -882,9 +871,6 @@ SbiExprNode* SbiExpression::Boolean()
|*
***************************************************************************/
-// Parsing einer Expression, die sich zu einer numerischen
-// Konstanten verarbeiten laesst.
-
SbiConstExpression::SbiConstExpression( SbiParser* p ) : SbiExpression( p )
{
if( pExpr->IsConstant() )
@@ -902,13 +888,12 @@ SbiConstExpression::SbiConstExpression( SbiParser* p ) : SbiExpression( p )
}
else
{
- // #40204 Spezialbehandlung fuer sal_Bool-Konstanten
+ // #40204 special treatment for sal_Bool-constants
sal_Bool bIsBool = sal_False;
if( pExpr->eNodeType == SbxVARVAL )
{
SbiSymDef* pVarDef = pExpr->GetVar();
- // Ist es eine sal_Bool-Konstante?
sal_Bool bBoolVal = sal_False;
if( pVarDef->GetName().EqualsIgnoreCaseAscii( "true" ) )
{
@@ -922,7 +907,6 @@ SbiConstExpression::SbiConstExpression( SbiParser* p ) : SbiExpression( p )
bBoolVal = sal_False;
}
- // Wenn es ein sal_Bool ist, Node austauschen
if( bIsBool )
{
delete pExpr;
@@ -988,7 +972,6 @@ SbiExprList::~SbiExprList()
}
}
-// Parameter anfordern (ab 0)
SbiExpression* SbiExprList::Get( short n )
{
@@ -1014,11 +997,11 @@ void SbiExprList::addExpression( SbiExpression* pExpr )
|*
***************************************************************************/
-// Parsender Konstruktor:
-// Die Parameterliste wird komplett geparst.
-// "Prozedurname()" ist OK.
-// Dann handelt es sich um eine Funktion ohne Parameter
-// respektive um die Angabe eines Arrays als Prozedurparameter.
+// parsing constructor:
+// the parameter list is completely parsed
+// "procedurename()" is OK
+// it's a function without parameters then
+// i. e. you give an array as procedure parameter
// #i79918/#i80532: bConst has never been set to true
// -> reused as bStandaloneExpression
@@ -1032,7 +1015,6 @@ SbiParameters::SbiParameters( SbiParser* p, sal_Bool bStandaloneExpression, sal_
SbiExpression *pExpr;
SbiToken eTok = pParser->Peek();
- // evtl. Klammer auf weg:
bool bAssumeExprLParenMode = false;
bool bAssumeArrayMode = false;
if( eTok == LPAREN )
@@ -1049,25 +1031,25 @@ SbiParameters::SbiParameters( SbiParser* p, sal_Bool bStandaloneExpression, sal_
}
}
- // Ende-Test
+
if( ( bBracket && eTok == RPAREN ) || pParser->IsEoln( eTok ) )
{
if( eTok == RPAREN )
pParser->Next();
return;
}
- // Parametertabelle einlesen und in richtiger Folge ablegen!
+ // read in parameter table and lay down in correct order!
SbiExpression* pLast = NULL;
String aName;
while( !bError )
{
aName.Erase();
- // Fehlendes Argument
+ // missing argument
if( eTok == COMMA )
{
pExpr = new SbiExpression( pParser, 0, SbxEMPTY );
}
- // Benannte Argumente: entweder .name= oder name:=
+ // named arguments: either .name= or name:=
else
{
bool bByVal = false;
@@ -1117,7 +1099,7 @@ SbiParameters::SbiParameters( SbiParser* p, sal_Bool bStandaloneExpression, sal_
if( pParser->Peek() == ASSIGN )
{
// VBA mode: name:=
- // SbiExpression::Term() hat einen String daraus gemacht
+ // SbiExpression::Term() has made as string out of it
aName = pExpr->GetString();
delete pExpr;
pParser->Next();
@@ -1137,7 +1119,7 @@ SbiParameters::SbiParameters( SbiParser* p, sal_Bool bStandaloneExpression, sal_
if( bAssumeArrayMode )
break;
- // Naechstes Element?
+ // next element?
eTok = pParser->Peek();
if( eTok != COMMA )
{
@@ -1156,7 +1138,7 @@ SbiParameters::SbiParameters( SbiParser* p, sal_Bool bStandaloneExpression, sal_
break;
}
}
- // Schliessende Klammer
+ // closing bracket
if( eTok == RPAREN )
{
pParser->Next();
@@ -1176,10 +1158,9 @@ SbiParameters::SbiParameters( SbiParser* p, sal_Bool bStandaloneExpression, sal_
|*
***************************************************************************/
-// Parsender Konstruktor:
-// Eine Liste von Array-Dimensionen wird geparst. Die Ausdruecke werden
-// auf numerisch getestet. Das bCONST-Bit wird gesetzt, wenn alle Ausdruecke
-// Integer-Konstanten sind.
+// parsing constructor:
+// A list of array dimensions is parsed. The expressions are tested for being
+// numeric. The bCONST-Bit is reset when all expressions are Integer constants.
SbiDimList::SbiDimList( SbiParser* p ) : SbiExprList( p )
{
@@ -1216,7 +1197,6 @@ SbiDimList::SbiDimList( SbiParser* p ) : SbiExprList( p )
}
else
{
- // Nur eine Dim-Angabe
pExpr1->SetBased();
pExpr1->pNext = NULL;
bConst &= pExpr1->IsIntConstant();
diff --git a/basic/source/comp/io.cxx b/basic/source/comp/io.cxx
index bc458e5..cff657a 100644
--- a/basic/source/comp/io.cxx
+++ b/basic/source/comp/io.cxx
@@ -34,7 +34,7 @@
#include "sbcomp.hxx"
#include "iosys.hxx"
-// Test, ob ein I/O-Channel angegeben wurde
+// test if there's an I/O channel
sal_Bool SbiParser::Channel( sal_Bool bAlways )
{
@@ -54,15 +54,13 @@ sal_Bool SbiParser::Channel( sal_Bool bAlways )
return bRes;
}
-// Fuer PRINT und WRITE wird bei Objektvariablen versucht,
-// die Default-Property anzusprechen.
-
-// PRINT
+// it's tried that at object variables the Default-
+// Property is addressed for PRINT and WRITE
void SbiParser::Print()
{
sal_Bool bChan = Channel();
- // Die Ausdruecke zum Drucken:
+
while( !bAbort )
{
if( !IsEoln( Peek() ) )
@@ -93,7 +91,7 @@ void SbiParser::Print()
void SbiParser::Write()
{
sal_Bool bChan = Channel();
- // Die Ausdruecke zum Drucken:
+
while( !bAbort )
{
SbiExpression* pExpr = new SbiExpression( this );
@@ -153,7 +151,7 @@ void SbiParser::LineInput()
pExpr->Gen();
aGen.Gen( _LINPUT );
delete pExpr;
- aGen.Gen( _CHAN0 ); // ResetChannel() nicht mehr in StepLINPUT()
+ aGen.Gen( _CHAN0 ); // ResetChannel() not in StepLINPUT() anymore
}
// INPUT
@@ -178,7 +176,7 @@ void SbiParser::Input()
else break;
}
delete pExpr;
- aGen.Gen( _CHAN0 ); // ResetChannel() nicht mehr in StepINPUT()
+ aGen.Gen( _CHAN0 );
}
// OPEN stringexpr FOR mode ACCCESS access mode AS Channel [Len=n]
@@ -209,8 +207,8 @@ void SbiParser::Open()
{
Next();
eTok = Next();
- // Nur STREAM_READ,STREAM_WRITE-Flags in nMode beeinflussen
- nMode &= ~(STREAM_READ | STREAM_WRITE); // loeschen
+ // influence only STREAM_READ,STREAM_WRITE-Flags in nMode
+ nMode &= ~(STREAM_READ | STREAM_WRITE); // delete
if( eTok == READ )
{
if( Peek() == WRITE )
@@ -254,7 +252,7 @@ void SbiParser::Open()
default: break;
}
TestToken( AS );
- // Die Kanalnummer
+ // channel number
SbiExpression* pChan = new SbiExpression( this );
if( !pChan )
Error( SbERR_SYNTAX );
@@ -270,10 +268,10 @@ void SbiParser::Open()
}
}
if( !pLen ) pLen = new SbiExpression( this, 128, SbxINTEGER );
- // Der Stack fuer den OPEN-Befehl sieht wie folgt aus:
- // Blocklaenge
- // Kanalnummer
- // Dateiname
+ // the stack for the OPEN command looks as follows:
+ // block length
+ // channel number
+ // file name
pLen->Gen();
if( pChan )
pChan->Gen();
diff --git a/basic/source/comp/loops.cxx b/basic/source/comp/loops.cxx
index c3e9159..392e3e9 100644
--- a/basic/source/comp/loops.cxx
+++ b/basic/source/comp/loops.cxx
@@ -37,18 +37,18 @@ void SbiParser::If()
{
sal_uInt32 nEndLbl;
SbiToken eTok = NIL;
- // Ende-Tokens ignorieren:
+ // ignore end-tokens
SbiExpression aCond( this );
aCond.Gen();
TestToken( THEN );
if( IsEoln( Next() ) )
{
- // Am Ende jeden Blocks muss ein Jump zu ENDIF
- // eingefuegt werden, damit bei ELSEIF nicht erneut die Bedingung
- // ausgewertet wird. Die Tabelle nimmt alle Absprungstellen auf.
+ // At the end of each block a jump to ENDIF must be inserted,
+ // so that the condition is not evaluated again at ELSEIF.
+ // The table collects all jump points.
#define JMP_TABLE_SIZE 100
- sal_uInt32 pnJmpToEndLbl[JMP_TABLE_SIZE]; // 100 ELSEIFs zulaessig
- sal_uInt16 iJmp = 0; // aktueller Tabellen-Index
+ sal_uInt32 pnJmpToEndLbl[JMP_TABLE_SIZE]; // 100 ELSEIFs allowed
+ sal_uInt16 iJmp = 0; // current table index
// multiline IF
nEndLbl = aGen.Gen( _JUMPF, 0 );
@@ -64,7 +64,7 @@ void SbiParser::If()
}
while( eTok == ELSEIF )
{
- // Bei erfolgreichem IF/ELSEIF auf ENDIF springen
+ // jump to ENDIF in case of a successful IF/ELSEIF
if( iJmp >= JMP_TABLE_SIZE )
{
Error( SbERR_PROG_TOO_LARGE ); bAbort = sal_True; return;
@@ -104,7 +104,7 @@ void SbiParser::If()
else if( eTok == ENDIF )
Next();
- // Jmp-Tabelle abarbeiten
+
while( iJmp > 0 )
{
iJmp--;
@@ -143,7 +143,7 @@ void SbiParser::If()
aGen.BackChain( nEndLbl );
}
-// ELSE/ELSEIF/ENDIF ohne IF
+// ELSE/ELSEIF/ENDIF without IF
void SbiParser::NoIf()
{
@@ -213,7 +213,7 @@ void SbiParser::For()
if( bForEach )
Next();
SbiExpression aLvalue( this, SbOPERAND );
- aLvalue.Gen(); // Variable auf dem Stack
+ aLvalue.Gen(); // variable on the Stack
if( bForEach )
{
@@ -227,10 +227,10 @@ void SbiParser::For()
{
TestToken( EQ );
SbiExpression aStartExpr( this );
- aStartExpr.Gen(); // Startausdruck auf dem Stack
+ aStartExpr.Gen();
TestToken( TO );
SbiExpression aStopExpr( this );
- aStopExpr.Gen(); // Endausdruck auf dem Stack
+ aStopExpr.Gen();
if( Peek() == STEP )
{
Next();
@@ -243,19 +243,19 @@ void SbiParser::For()
aOne.Gen();
}
TestEoln();
- // Der Stack hat jetzt 4 Elemente: Variable, Start, Ende, Inkrement
- // Startwert binden
+ // The stack has all 4 elements now: variable, start, end, increment
+ // bind start value
aGen.Gen( _INITFOR );
}
sal_uInt32 nLoop = aGen.GetPC();
- // Test durchfuehren, evtl. Stack freigeben
+ // do tests, maybe free the stack
sal_uInt32 nEndTarget = aGen.Gen( _TESTFOR, 0 );
OpenBlock( FOR );
StmntBlock( NEXT );
aGen.Gen( _NEXT );
aGen.Gen( _JUMP, nLoop );
- // Kommen Variable nach NEXT?
+ // are there variables after NEXT?
if( Peek() == SYMBOL )
{
SbiExpression aVar( this, SbOPERAND );
@@ -272,16 +272,15 @@ void SbiParser::With()
{
SbiExpression aVar( this, SbOPERAND );
- // Letzten Knoten in der Objekt-Kette ueberpruefen
SbiExprNode *pNode = aVar.GetExprNode()->GetRealNode();
SbiSymDef* pDef = pNode->GetVar();
- // Variant, AB 27.6.1997, #41090: bzw. empty -> muß Object sein
+ // Variant, from 27.6.1997, #41090: empty -> must be Object
if( pDef->GetType() == SbxVARIANT || pDef->GetType() == SbxEMPTY )
pDef->SetType( SbxOBJECT );
else if( pDef->GetType() != SbxOBJECT )
Error( SbERR_NEEDS_OBJECT );
- // Knoten auch auf SbxOBJECT setzen, damit spaeter Gen() klappt
+
pNode->SetType( SbxOBJECT );
OpenBlock( NIL, aVar.GetExprNode() );
@@ -289,7 +288,7 @@ void SbiParser::With()
CloseBlock();
}
-// LOOP/NEXT/WEND ohne Konstrukt
+// LOOP/NEXT/WEND without construct
void SbiParser::BadBlock()
{
@@ -312,11 +311,11 @@ void SbiParser::OnGoto()
Error( SbERR_EXPECTED, "GoTo/GoSub" );
eTok = GOTO;
}
- // Label-Tabelle einlesen:
+
sal_uInt32 nLbl = 0;
do
{
- Next(); // Label holen
+ Next(); // get label
if( MayBeLabel() )
{
sal_uInt32 nOff = pProc->GetLabels().Reference( aSym );
@@ -371,7 +370,7 @@ void SbiParser::Select()
sal_uInt32 nNextTarget = 0;
sal_uInt32 nDoneTarget = 0;
sal_Bool bElse = sal_False;
- // Die Cases einlesen:
+
while( !bAbort )
{
eTok = Next();
@@ -380,7 +379,7 @@ void SbiParser::Select()
if( nNextTarget )
aGen.BackChain( nNextTarget ), nNextTarget = 0;
aGen.Statement();
- // Jeden Case einlesen
+
sal_Bool bDone = sal_False;
sal_uInt32 nTrueTarget = 0;
if( Peek() == ELSE )
@@ -429,13 +428,13 @@ void SbiParser::Select()
if( Peek() == COMMA ) Next();
else TestEoln(), bDone = sal_True;
}
- // Alle Cases abgearbeitet
+
if( !bElse )
{
nNextTarget = aGen.Gen( _JUMP, nNextTarget );
aGen.BackChain( nTrueTarget );
}
- // den Statement-Rumpf bauen
+ // build the statement body
while( !bAbort )
{
eTok = Peek();
@@ -472,14 +471,14 @@ void SbiParser::On()
SbiToken eTok = Peek();
String aString = SbiTokenizer::Symbol(eTok);
if (aString.EqualsIgnoreCaseAscii("ERROR"))
- eTok = _ERROR_; // Error kommt als SYMBOL
+ eTok = _ERROR_; // Error comes as SYMBOL
if( eTok != _ERROR_ && eTok != LOCAL ) OnGoto();
else
{
if( eTok == LOCAL ) Next();
- Next (); // Kein TestToken mehr, da es sonst einen Fehler gibt
+ Next (); // no more TestToken, as there'd be an error otherwise
- Next(); // Token nach Error holen
+ Next(); // get token after error
if( eCurTok == GOTO )
{
// ON ERROR GOTO label|0
diff --git a/basic/source/comp/parser.cxx b/basic/source/comp/parser.cxx
index 2ea7835..6758425 100644
--- a/basic/source/comp/parser.cxx
+++ b/basic/source/comp/parser.cxx
@@ -32,18 +32,18 @@
#include "sbcomp.hxx"
#include <com/sun/star/script/ModuleType.hpp>
-struct SbiParseStack { // "Stack" fuer Statement-Blocks
+struct SbiParseStack { // "Stack" for statement-blocks
SbiParseStack* pNext; // Chain
- SbiExprNode* pWithVar; // Variable fuer WITH
- SbiToken eExitTok; // Exit-Token
+ SbiExprNode* pWithVar;
+ SbiToken eExitTok;
sal_uInt32 nChain; // JUMP-Chain
};
struct SbiStatement {
SbiToken eTok;
- void( SbiParser::*Func )(); // Verarbeitungsroutine
- sal_Bool bMain; // sal_True: ausserhalb SUBs OK
- sal_Bool bSubr; // sal_True: in SUBs OK
+ void( SbiParser::*Func )();
+ sal_Bool bMain; // sal_True: OK outside the SUB
+ sal_Bool bSubr; // sal_True: OK inside the SUB
};
#define Y sal_True
@@ -148,16 +148,16 @@ SbiParser::SbiParser( StarBASIC* pb, SbModule* pm )
OSL_TRACE("Parser - %s, bClassModule %d", rtl::OUStringToOString( pm->GetName(), RTL_TEXTENCODING_UTF8 ).getStr(), bClassModule );
pPool = &aPublics;
for( short i = 0; i < 26; i++ )
- eDefTypes[ i ] = SbxVARIANT; // Kein expliziter Defaulttyp
+ eDefTypes[ i ] = SbxVARIANT; // no explicit default type
aPublics.SetParent( &aGlobals );
aGlobals.SetParent( &aRtlSyms );
- // Die globale Chainkette faengt bei Adresse 0 an:
+
nGblChain = aGen.Gen( _JUMP, 0 );
- rTypeArray = new SbxArray; // Array fuer Benutzerdefinierte Typen
- rEnumArray = new SbxArray; // Array for Enum types
+ rTypeArray = new SbxArray; // array for user defined types
+ rEnumArray = new SbxArray; // array for Enum types
bVBASupportOn = pm->IsVBACompat();
if ( bVBASupportOn )
EnableCompatibility();
@@ -165,7 +165,7 @@ SbiParser::SbiParser( StarBASIC* pb, SbModule* pm )
}
-// Ist Teil der Runtime-Library?
+// part of the runtime-library?
SbiSymDef* SbiParser::CheckRTLForSym( const String& rSym, SbxDataType eType )
{
SbxVariable* pVar = GetBasic()->GetRtl()->Find( rSym, SbxCLASS_DONTCARE );
@@ -187,7 +187,7 @@ SbiSymDef* SbiParser::CheckRTLForSym( const String& rSym, SbxDataType eType )
return pDef;
}
-// Globale Chainkette schliessen
+// close global chain
sal_Bool SbiParser::HasGlobalCode()
{
@@ -210,7 +210,7 @@ void SbiParser::OpenBlock( SbiToken eTok, SbiExprNode* pVar )
pStack = p;
pWithVar = pVar;
- // #29955 for-Schleifen-Ebene pflegen
+ // #29955 service the for-loop level
if( eTok == FOR )
aGen.IncForLevel();
}
@@ -221,7 +221,7 @@ void SbiParser::CloseBlock()
{
SbiParseStack* p = pStack;
- // #29955 for-Schleifen-Ebene pflegen
+ // #29955 service the for-loop level
if( p->eExitTok == FOR )
aGen.DecForLevel();
@@ -264,7 +264,7 @@ sal_Bool SbiParser::TestSymbol( sal_Bool bKwdOk )
return sal_False;
}
-// Testen auf ein bestimmtes Token
+
sal_Bool SbiParser::TestToken( SbiToken t )
{
@@ -279,7 +279,7 @@ sal_Bool SbiParser::TestToken( SbiToken t )
}
}
-// Testen auf Komma oder EOLN
+
sal_Bool SbiParser::TestComma()
{
@@ -298,7 +298,7 @@ sal_Bool SbiParser::TestComma()
return sal_True;
}
-// Testen, ob EOLN vorliegt
+
void SbiParser::TestEoln()
{
@@ -309,8 +309,7 @@ void SbiParser::TestEoln()
}
}
-// Parsing eines Statement-Blocks
-// Das Parsing laeuft bis zum Ende-Token.
+
void SbiParser::StmntBlock( SbiToken eEnd )
{
@@ -325,8 +324,7 @@ void SbiParser::StmntBlock( SbiToken eEnd )
}
}
-// Die Hauptroutine. Durch wiederholten Aufrufs dieser Routine wird
-// die Quelle geparst. Returnwert sal_False bei Ende/Fehlern.
+
sal_Bool SbiParser::Parse()
{
@@ -337,19 +335,19 @@ sal_Bool SbiParser::Parse()
bErrorIsSymbol = false;
Peek();
bErrorIsSymbol = true;
- // Dateiende?
+
if( IsEof() )
{
- // AB #33133: Falls keine Sub angelegt wurde, muss hier
- // der globale Chain abgeschlossen werden!
- // AB #40689: Durch die neue static-Behandlung kann noch
- // ein nGblChain vorhanden sein, daher vorher abfragen
+ // AB #33133: If no sub has been created before,
+ // the global chain must be closed here!
+ // AB #40689: Due to the new static-handling there
+ // can be another nGblChain, so ask for it before.
if( bNewGblDefs && nGblChain == 0 )
nGblChain = aGen.Gen( _JUMP, 0 );
return sal_False;
}
- // Leerstatement?
+
if( IsEoln( eCurTok ) )
{
Next(); return sal_True;
@@ -357,20 +355,20 @@ sal_Bool SbiParser::Parse()
if( !bSingleLineIf && MayBeLabel( sal_True ) )
{
- // Ist ein Label
+ // is a label
if( !pProc )
Error( SbERR_NOT_IN_MAIN, aSym );
else
pProc->GetLabels().Define( aSym );
Next(); Peek();
- // Leerstatement?
+
if( IsEoln( eCurTok ) )
{
Next(); return sal_True;
}
}
- // Ende des Parsings?
+ // end of parsing?
if( eCurTok == eEndTok ||
( bVBASupportOn && // #i109075
(eCurTok == ENDFUNC || eCurTok == ENDPROPERTY || eCurTok == ENDSUB) &&
@@ -382,7 +380,7 @@ sal_Bool SbiParser::Parse()
return sal_False;
}
- // Kommentar?
+ // comment?
if( eCurTok == REM )
{
Next(); return sal_True;
@@ -400,16 +398,16 @@ sal_Bool SbiParser::Parse()
ePush = eCurTok;
}
}
- // Kommt ein Symbol, ist es entweder eine Variable( LET )
- // oder eine SUB-Prozedur( CALL ohne Klammern )
- // DOT fuer Zuweisungen im WITH-Block: .A=5
+ // if there's a symbol, it's either a variable (LET)
+ // or a SUB-procedure (CALL without brackets)
+ // DOT for assignments in the WITH-block: .A=5
if( eCurTok == SYMBOL || eCurTok == DOT )
{
if( !pProc )
Error( SbERR_EXPECTED, SUB );
else
{
- // Damit Zeile & Spalte stimmen...
+ // for correct line and column...
Next();
Push( eCurTok );
aGen.Statement();
@@ -420,7 +418,7 @@ sal_Bool SbiParser::Parse()
{
Next();
- // Hier folgen nun die Statement-Parser.
+ // statement parsers
SbiStatement* p;
for( p = StmntTable; p->eTok != NIL; p++ )
@@ -434,16 +432,15 @@ sal_Bool SbiParser::Parse()
Error( SbERR_NOT_IN_SUBR, eCurTok );
else
{
- // globalen Chain pflegen
- // AB #41606/#40689: Durch die neue static-Behandlung kann noch
- // ein nGblChain vorhanden sein, daher vorher abfragen
+ // AB #41606/#40689: Due to the new static-handling there
+ // can be another nGblChain, so ask for it before.
if( bNewGblDefs && nGblChain == 0 &&
( eCurTok == SUB || eCurTok == FUNCTION || eCurTok == PROPERTY ) )
{
nGblChain = aGen.Gen( _JUMP, 0 );
bNewGblDefs = sal_False;
}
- // Statement-Opcode bitte auch am Anfang einer Sub
+ // statement-opcode at the beginning of a sub, too, please
if( ( p->bSubr && (eCurTok != STATIC || Peek() == SUB || Peek() == FUNCTION ) ) ||
eCurTok == SUB || eCurTok == FUNCTION )
aGen.Statement();
@@ -457,35 +454,34 @@ sal_Bool SbiParser::Parse()
Error( SbERR_UNEXPECTED, eCurTok );
}
- // Test auf Ende des Statements:
- // Kann auch ein ELSE sein, da vor dem ELSE kein : stehen muss!
+ // test for the statement's end -
+ // might also be an ELSE, as there must not neccessary be a : before the ELSE!
if( !IsEos() )
{
Peek();
if( !IsEos() && eCurTok != ELSE )
{
- // falls das Parsing abgebrochen wurde, bis zum ":" vorgehen:
+ // if the parsing has been aborted, jump over to the ":"
Error( SbERR_UNEXPECTED, eCurTok );
while( !IsEos() ) Next();
}
}
- // Der Parser bricht am Ende ab, das naechste Token ist noch nicht
- // geholt!
+ // The parser aborts at the end, the
+ // next token has not been fetched yet!
return sal_True;
}
-// Innerste With-Variable liefern
+
SbiExprNode* SbiParser::GetWithVar()
{
if( pWithVar )
return pWithVar;
- // Sonst im Stack suchen
SbiParseStack* p = pStack;
while( p )
{
- // LoopVar kann zur Zeit nur fuer with sein
+ // LoopVar can at the moment only be for with
if( p->pWithVar )
return p->pWithVar;
p = p->pNext;
@@ -494,7 +490,7 @@ SbiExprNode* SbiParser::GetWithVar()
}
-// Zuweisung oder Subroutine Call
+// assignment or subroutine call
void SbiParser::Symbol( const KeywordSymbolInfo* pKeywordSymbolInfo )
{
@@ -540,7 +536,7 @@ void SbiParser::Symbol( const KeywordSymbolInfo* pKeywordSymbolInfo )
}
else
{
- // Dann muss es eine Zuweisung sein. Was anderes gibts nicht!
+ // so it must be an assignment!
if( !aVar.IsLvalue() )
Error( SbERR_LVALUE_EXPECTED );
TestToken( EQ );
@@ -566,7 +562,6 @@ void SbiParser::Symbol( const KeywordSymbolInfo* pKeywordSymbolInfo )
}
}
-// Zuweisungen
void SbiParser::Assign()
{
@@ -587,7 +582,7 @@ void SbiParser::Assign()
aGen.Gen( _PUT );
}
-// Zuweisungen einer Objektvariablen
+// assignments of an object-variable
void SbiParser::Set()
{
@@ -671,7 +666,7 @@ void SbiParser::RSet()
aGen.Gen( _RSET );
}
-// DEFINT, DEFLNG, DEFSNG, DEFDBL, DEFSTR und so weiter
+// DEFINT, DEFLNG, DEFSNG, DEFDBL, DEFSTR and so on
void SbiParser::DefXXX()
{
@@ -705,7 +700,7 @@ void SbiParser::DefXXX()
void SbiParser::Stop()
{
aGen.Gen( _STOP );
- Peek(); // #35694: Nur Peek(), damit EOL in Single-Line-If erkannt wird
+ Peek(); // #35694: only Peek(), so that EOL is recognized in Single-Line-If
}
// IMPLEMENTS
diff --git a/basic/source/comp/sbcomp.cxx b/basic/source/comp/sbcomp.cxx
index 86557db..b2cba95 100644
--- a/basic/source/comp/sbcomp.cxx
+++ b/basic/source/comp/sbcomp.cxx
@@ -903,8 +903,8 @@ void RTL_Impl_TraceCommand( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite )
#endif
-// Diese Routine ist hier definiert, damit der Compiler als eigenes Segment
-// geladen werden kann.
+// This routine is defined here, so that the
+// compiler can be loaded as a discrete segment.
sal_Bool SbModule::Compile()
{
@@ -914,7 +914,7 @@ sal_Bool SbModule::Compile()
if( !pBasic )
return sal_False;
SbxBase::ResetError();
- // Aktuelles Modul!
+
SbModule* pOld = pCMOD;
pCMOD = this;
@@ -923,14 +923,14 @@ sal_Bool SbModule::Compile()
if( !pParser->GetErrors() )
pParser->aGen.Save();
delete pParser;
- // fuer den Disassembler
+ // for the disassembler
if( pImage )
pImage->aOUSource = aOUSource;
pCMOD = pOld;
- // Beim Compilieren eines Moduls werden die Modul-globalen
- // Variablen aller Module ungueltig
+ // compiling a module, the module-global
+ // variables of all modules become invalid
sal_Bool bRet = IsCompiled();
if( bRet )
{
diff --git a/basic/source/comp/scanner.cxx b/basic/source/comp/scanner.cxx
index 11c081d..1dec4db 100644
--- a/basic/source/comp/scanner.cxx
+++ b/basic/source/comp/scanner.cxx
@@ -97,12 +97,12 @@ void SbiScanner::GenError( SbError code )
if( !bError && bErrors )
{
sal_Bool bRes = sal_True;
- // Nur einen Fehler pro Statement reporten
+ // report only one error per statement
bError = sal_True;
if( pBasic )
{
- // Falls EXPECTED oder UNEXPECTED kommen sollte, bezieht es sich
- // immer auf das letzte Token, also die Col1 uebernehmen
+ // in case of EXPECTED or UNEXPECTED it always refers
+ // to the last token, so take the Col1 over
sal_uInt16 nc = nColLock ? nSavedCol1 : nCol1;
switch( code )
{
@@ -123,8 +123,8 @@ void SbiScanner::GenError( SbError code )
nErrors++;
}
-// Falls sofort ein Doppelpunkt folgt, wird sal_True zurueckgeliefert.
-// Wird von SbiTokenizer::MayBeLabel() verwendet, um einen Label zu erkennen
+
+// used by SbiTokenizer::MayBeLabel() to detect a label
sal_Bool SbiScanner::DoesColonFollow()
{
@@ -135,7 +135,7 @@ sal_Bool SbiScanner::DoesColonFollow()
else return sal_False;
}
-// Testen auf ein legales Suffix
+// test for legal suffix
static SbxDataType GetSuffixType( sal_Unicode c )
{
@@ -149,8 +149,8 @@ static SbxDataType GetSuffixType( sal_Unicode c )
return SbxVARIANT;
}
-// Einlesen des naechsten Symbols in die Variablen aSym, nVal und eType
-// Returnwert ist sal_False bei EOF oder Fehlern
+// reading the next symbol into the variables aSym, nVal and eType
+// return value is sal_False at EOF or errors
#define BUF_SIZE 80
namespace {
@@ -165,7 +165,7 @@ inline bool lclIsWhitespace( sal_Unicode cChar )
sal_Bool SbiScanner::NextSym()
{
- // Fuer den EOLN-Fall merken
+ // memorize for the EOLN-case
sal_uInt16 nOldLine = nLine;
sal_uInt16 nOldCol1 = nCol1;
sal_uInt16 nOldCol2 = nCol2;
@@ -177,7 +177,7 @@ sal_Bool SbiScanner::NextSym()
bSymbol =
bNumber = bSpaces = sal_False;
- // Zeile einlesen?
+ // read in line?
if( !pLine )
{
sal_Int32 n = nBufPos;
@@ -207,13 +207,13 @@ sal_Bool SbiScanner::NextSym()
nColLock = 0;
}
- // Leerstellen weg:
+
while( lclIsWhitespace( *pLine ) )
pLine++, nCol++, bSpaces = sal_True;
nCol1 = nCol;
- // nur Leerzeile?
+ // only blank line?
if( !*pLine )
goto eoln;
@@ -227,10 +227,10 @@ sal_Bool SbiScanner::NextSym()
bHash = sal_True;
}
- // Symbol? Dann Zeichen kopieren.
+ // copy character if symbol
if( BasicSimpleCharClass::isAlpha( *pLine, bCompatible ) || *pLine == '_' )
{
- // Wenn nach '_' nichts kommt, ist es ein Zeilenabschluss!
+ // if there's nothing behind '_' , it's the end of a line!
if( *pLine == '_' && !*(pLine+1) )
{ pLine++;
goto eoln; }
@@ -263,16 +263,16 @@ sal_Bool SbiScanner::NextSym()
}
}
- // Abschliessendes '_' durch Space ersetzen, wenn Zeilenende folgt
- // (sonst falsche Zeilenfortsetzung)
+ // replace closing '_' by space when end of line is following
+ // (wrong line continuation otherwise)
if( !bUsedForHilite && !*pLine && *(pLine-1) == '_' )
{
aSym.GetBufferAccess(); // #109693 force copy if necessary
- *((sal_Unicode*)(pLine-1)) = ' '; // cast wegen const
+ *((sal_Unicode*)(pLine-1)) = ' '; // cast because of const
}
- // Typkennung?
- // Das Ausrufezeichen bitte nicht testen, wenn
- // danach noch ein Symbol anschliesst
+ // type recognition?
+ // don't test the exclamation mark
+ // if there's a symbol behind it
else if( *pLine != '!' || !BasicSimpleCharClass::isAlpha( pLine[ 1 ], bCompatible ) )
{
SbxDataType t = GetSuffixType( *pLine );
@@ -285,7 +285,7 @@ sal_Bool SbiScanner::NextSym()
}
}
- // Zahl? Dann einlesen und konvertieren.
+ // read in and convert if number
else if( BasicSimpleCharClass::isDigit( *pLine & 0xFF )
|| ( *pLine == '.' && BasicSimpleCharClass::isDigit( *(pLine+1) & 0xFF ) ) )
{
@@ -297,14 +297,14 @@ sal_Bool SbiScanner::NextSym()
sal_Bool bBufOverflow = sal_False;
while( strchr( "0123456789.DEde", *pLine ) && *pLine )
{
- // AB 4.1.1996: Buffer voll? -> leer weiter scannen
+ // from 4.1.1996: buffer full? -> go on scanning empty
if( (p-buf) == (BUF_SIZE-1) )
{
bBufOverflow = sal_True;
pLine++, nCol++;
continue;
}
- // Komma oder Exponent?
+ // point or exponent?
if( *pLine == '.' )
{
if( ++comma > 1 )
@@ -320,7 +320,7 @@ sal_Bool SbiScanner::NextSym()
pLine++; nCol++; continue;
}
*p++ = 'E'; pLine++; nCol++;
- // Vorzeichen hinter Exponent?
+
if( *pLine == '+' )
pLine++, nCol++;
else
@@ -336,12 +336,12 @@ sal_Bool SbiScanner::NextSym()
}
*p = 0;
aSym = p; bNumber = sal_True;
- // Komma, Exponent mehrfach vorhanden?
+
if( comma > 1 || exp > 1 )
{ aError = '.';
GenError( SbERR_BAD_CHAR_IN_NUMBER ); }
- // #57844 Lokalisierte Funktion benutzen
+ // #57844 use localized function
nVal = rtl_math_uStringToDouble( buf, buf+(p-buf), '.', ',', NULL, NULL );
ndig = ndig - comma;
@@ -356,7 +356,7 @@ sal_Bool SbiScanner::NextSym()
if( bBufOverflow )
GenError( SbERR_MATH_OVERFLOW );
- // Typkennung?
+ // type recognition?
SbxDataType t = GetSuffixType( *pLine );
if( t != SbxVARIANT )
{
@@ -366,7 +366,7 @@ sal_Bool SbiScanner::NextSym()
}
}
- // Hex/Oktalzahl? Einlesen und konvertieren:
+ // Hex/octal number? Read in and convert:
else if( *pLine == '&' )
{
pLine++; nCol++;
@@ -383,7 +383,7 @@ sal_Bool SbiScanner::NextSym()
case 'H':
break;
default :
- // Wird als Operator angesehen
+ // treated as an operator
pLine--; nCol--; nCol1 = nCol-1; aSym = '&'; return SYMBOL;
}
bNumber = sal_True;
@@ -395,7 +395,7 @@ sal_Bool SbiScanner::NextSym()
sal_Unicode ch = sal::static_int_cast< sal_Unicode >(
toupper( *pLine & 0xFF ) );
pLine++; nCol++;
- // AB 4.1.1996: Buffer voll, leer weiter scannen
+ // from 4.1.1996: buffer full, go on scanning empty
if( (p-buf) == (BUF_SIZE-1) )
bBufOverflow = sal_True;
else if( String( cmp ).Search( ch ) != STRING_NOTFOUND )
@@ -447,7 +447,7 @@ sal_Bool SbiScanner::NextSym()
aSym = aLine.copy( n - 1, nCol - n + 1);
else
aSym = aLine.copy( n, nCol - n - 1 );
- // Doppelte Stringbegrenzer raus
+ // get out duplicate string delimiters
String s( cSep );
s += cSep;
sal_uInt16 nIdx = 0;
@@ -463,12 +463,12 @@ sal_Bool SbiScanner::NextSym()
if( cSep != ']' )
eScanType = ( cSep == '#' ) ? SbxDATE : SbxSTRING;
}
- // ungueltige Zeichen:
+ // invalid characters:
else if( ( *pLine & 0xFF ) >= 0x7F )
{
GenError( SbERR_SYNTAX ); pLine++; nCol++;
}
- // andere Gruppen:
+ // other groups:
else
{
short n = 1;
@@ -485,7 +485,7 @@ sal_Bool SbiScanner::NextSym()
nCol2 = nCol-1;
PrevLineCommentLbl:
- // Kommentar?
+
if( bPrevLineExtentsComment || (eScanType != SbxSTRING &&
( aSym.GetBuffer()[0] == '\'' || aSym.EqualsIgnoreCaseAscii( "REM" ) ) ) )
{
@@ -499,8 +499,7 @@ PrevLineCommentLbl:
}
return sal_True;
- // Sonst Zeilen-Ende: aber bitte auf '_' testen, ob die
- // Zeile nicht weitergeht!
+
eoln:
if( nCol && *--pLine == '_' )
{
diff --git a/basic/source/comp/symtbl.cxx b/basic/source/comp/symtbl.cxx
index 128c4ac..4e6e932 100644
--- a/basic/source/comp/symtbl.cxx
+++ b/basic/source/comp/symtbl.cxx
@@ -37,11 +37,11 @@
SV_IMPL_PTRARR(SbiStrings,String*)
SV_IMPL_PTRARR(SbiSymbols,SbiSymDef*)
-// Alle Symbolnamen werden im Stringpool des Symbol-Pools abgelegt, damit
-// alle Symbole im gleichen Case verarbeitet werden. Beim Speichern des
-// Code-Images wird der globale Stringpool mit den entsprechenden Sympools
-// gespeichert. Der lokale Stringpool nimmt alle Symbole auf, die nicht
-// ins Image wandern (Labels, Konstantennamen etc).
+// All symbol names are laid down int the symbol-pool's stringpool, so that
+// all symbols are handled in the same case. On saving the code-image, the
+// global stringpool with the respective symbols is also saved.
+// The local stringpool holds all the symbols that don't move to the image
+// (labels, constant names etc.).
/***************************************************************************
|*
@@ -57,7 +57,6 @@ SbiStringPool::SbiStringPool( SbiParser* p )
SbiStringPool::~SbiStringPool()
{}
-// Suchen
const String& SbiStringPool::Find( sal_uInt16 n ) const
{
@@ -67,8 +66,7 @@ const String& SbiStringPool::Find( sal_uInt16 n ) const
return *aData.GetObject( n-1 );
}
-// Hinzufuegen eines Strings. Der String wird Case-Insensitiv
-// verglichen.
+
short SbiStringPool::Add( const String& rVal, sal_Bool bNoCase )
{
@@ -117,7 +115,6 @@ SbiSymPool::SbiSymPool( SbiStringPool& r, SbiSymScope s ) : rStrings( r )
SbiSymPool::~SbiSymPool()
{}
-// Inhalt loeschen
void SbiSymPool::Clear()
{
@@ -138,7 +135,6 @@ SbiSymDef* SbiSymPool::Next()
return aData.GetObject( nCur );
}
-// Hinzufuegen eines Symbols
SbiSymDef* SbiSymPool::AddSym( const String& rName )
{
@@ -157,7 +153,7 @@ SbiProcDef* SbiSymPool::AddProc( const String& rName )
SbiProcDef* p = new SbiProcDef( pParser, rName );
p->nPos = aData.Count();
p->nId = rStrings.Add( rName );
- // Procs sind immer global
+ // procs are always local
p->nProcId = 0;
p->pIn = this;
const SbiSymDef* q = p;
@@ -165,7 +161,7 @@ SbiProcDef* SbiSymPool::AddProc( const String& rName )
return p;
}
-// Hinzufuegen einer extern aufgebauten Symboldefinition
+// adding an externally constructed symbol definition
void SbiSymPool::Add( SbiSymDef* pDef )
{
@@ -174,7 +170,7 @@ void SbiSymPool::Add( SbiSymDef* pDef )
if( pDef->pIn )
{
#ifdef DBG_UTIL
- // schon in einem anderen Pool drin!
+
pParser->Error( SbERR_INTERNAL_ERROR, "Dbl Pool" );
#endif
return;
@@ -183,8 +179,8 @@ void SbiSymPool::Add( SbiSymDef* pDef )
pDef->nPos = aData.Count();
if( !pDef->nId )
{
- // Bei statischen Variablen muss ein eindeutiger Name
- // im Stringpool erzeugt werden (Form ProcName:VarName)
+ // A unique name must be created in the string pool
+ // for static variables (Form ProcName:VarName)
String aName( pDef->aName );
if( pDef->IsStatic() )
{
@@ -194,7 +190,7 @@ void SbiSymPool::Add( SbiSymDef* pDef )
}
pDef->nId = rStrings.Add( aName );
}
- // Procs sind immer global
+
if( !pDef->GetProcDef() )
pDef->nProcId = nProcId;
pDef->pIn = this;
@@ -203,7 +199,6 @@ void SbiSymPool::Add( SbiSymDef* pDef )
}
}
-// Suchen eines Eintrags ueber den Namen. Es wird auch im Parent gesucht.
SbiSymDef* SbiSymPool::Find( const String& rName ) const
{
@@ -221,7 +216,6 @@ SbiSymDef* SbiSymPool::Find( const String& rName ) const
return NULL;
}
-// Suchen ueber ID-Nummer
SbiSymDef* SbiSymPool::FindId( sal_uInt16 n ) const
{
@@ -237,7 +231,7 @@ SbiSymDef* SbiSymPool::FindId( sal_uInt16 n ) const
return NULL;
}
-// Suchen ueber Position (ab 0)
+// find via position (from 0)
SbiSymDef* SbiSymPool::Get( sal_uInt16 n ) const
{
@@ -264,12 +258,11 @@ sal_uInt32 SbiSymPool::Reference( const String& rName )
SbiSymDef* p = Find( rName );
if( !p )
p = AddSym( rName );
- //Sicherheitshalber
+ // to be sure
pParser->aGen.GenStmnt();
return p->Reference();
}
-// Alle offenen Referenzen anmaulen
void SbiSymPool::CheckRefs()
{
@@ -283,7 +276,7 @@ void SbiSymPool::CheckRefs()
/***************************************************************************
|*
-|* Symbol-Definitionen
+|* symbol definitions
|*
***************************************************************************/
@@ -328,8 +321,6 @@ SbiConstDef* SbiSymDef::GetConstDef()
return NULL;
}
-// Wenn der Name benoetigt wird, den aktuellen Namen
-// aus dem Stringpool nehmen
const String& SbiSymDef::GetName()
{
@@ -338,7 +329,6 @@ const String& SbiSymDef::GetName()
return aName;
}
-// Eintragen eines Datentyps
void SbiSymDef::SetType( SbxDataType t )
{
@@ -358,9 +348,8 @@ void SbiSymDef::SetType( SbxDataType t )
eType = t;
}
-// Aufbau einer Backchain, falls noch nicht definiert
-// Es wird der Wert zurueckgeliefert, der als Operand gespeichert
-// werden soll.
+// construct a backchain, if not yet defined
+// the value that shall be stored as an operand is returned
sal_uInt32 SbiSymDef::Reference()
{
@@ -373,8 +362,6 @@ sal_uInt32 SbiSymDef::Reference()
else return nChain;
}
-// Definition eines Symbols.
-// Hier wird der Backchain aufgeloest, falls vorhanden
sal_uInt32 SbiSymDef::Define()
{
@@ -386,13 +373,13 @@ sal_uInt32 SbiSymDef::Define()
return nChain;
}
-// Eine Symboldefinition kann einen eigenen Pool haben. Dies ist
-// der Fall bei Objekten und Prozeduren (lokale Variable)
+// A symbol definition may have its own pool. This is the caseDies ist
+// for objects and procedures (local variable)
SbiSymPool& SbiSymDef::GetPool()
{
if( !pPool )
- pPool = new SbiSymPool( pIn->pParser->aGblStrings, SbLOCAL ); // wird gedumpt
+ pPool = new SbiSymPool( pIn->pParser->aGblStrings, SbLOCAL ); // is dumped
return *pPool;
}
@@ -402,22 +389,22 @@ SbiSymScope SbiSymDef::GetScope() const
}
-// Die Prozedur-Definition hat drei Pools:
-// 1) aParams: wird durch die Definition gefuellt. Enthaelt die Namen
-// der Parameter, wie sie innerhalb des Rumpfes verwendet werden.
-// Das erste Element ist der Returnwert.
-// 2) pPool: saemtliche lokale Variable
-// 3) aLabels: Labels
+// The procedure definition has three pools:
+// 1) aParams: is filled by the definition. Contains the
+// parameters' names, like they're used inside the body.
+// The first element is the return value.
+// 2) pPool: all local variables
+// 3) aLabels: labels
SbiProcDef::SbiProcDef( SbiParser* pParser, const String& rName,
sal_Bool bProcDecl )
: SbiSymDef( rName )
- , aParams( pParser->aGblStrings, SbPARAM ) // wird gedumpt
- , aLabels( pParser->aLclStrings, SbLOCAL ) // wird nicht gedumpt
+ , aParams( pParser->aGblStrings, SbPARAM ) // is dumped
+ , aLabels( pParser->aLclStrings, SbLOCAL ) // is not dumped
, mbProcDecl( bProcDecl )
{
aParams.SetParent( &pParser->aPublics );
- pPool = new SbiSymPool( pParser->aGblStrings, SbLOCAL ); // Locals
+ pPool = new SbiSymPool( pParser->aGblStrings, SbLOCAL );
pPool->SetParent( &aParams );
nLine1 =
nLine2 = 0;
@@ -425,8 +412,8 @@ SbiProcDef::SbiProcDef( SbiParser* pParser, const String& rName,
bPublic = sal_True;
bCdecl = sal_False;
bStatic = sal_False;
- // Fuer Returnwerte ist das erste Element der Parameterliste
- // immer mit dem Namen und dem Typ der Proc definiert
+ // For return values the first element of the parameter
+ // list is always defined with name and type of the proc
aParams.AddSym( aName );
}
@@ -444,30 +431,29 @@ void SbiProcDef::SetType( SbxDataType t )
aParams.Get( 0 )->SetType( eType );
}
-// Match mit einer Forward-Deklaration
-// Falls der Match OK ist, wird pOld durch this im Pool ersetzt
-// pOld wird immer geloescht!
+// match with a forward-declaration
+// if the match is OK, pOld is replaced by this in the pool
+// pOld is deleted in any case!
void SbiProcDef::Match( SbiProcDef* pOld )
{
SbiSymDef* po, *pn=NULL;
- // Parameter 0 ist der Funktionsname
+ // parameter 0 is the function name
sal_uInt16 i;
for( i = 1; i < aParams.GetSize(); i++ )
{
po = pOld->aParams.Get( i );
pn = aParams.Get( i );
- // Kein Typabgleich; das wird beim Laufen erledigt
- // aber ist sie evtl. mit zu wenigen Parametern aufgerufen
- // worden?
+ // no type matching - that is done during running
+ // but is it maybe called with too little parameters?
if( !po && !pn->IsOptional() && !pn->IsParamArray() )
break;
po = pOld->aParams.Next();
}
- // Wurden zu viele Parameter angegeben?
+
if( pn && i < aParams.GetSize() && pOld->pIn )
{
- // Die ganze Zeile markieren
+ // mark the whole line
pOld->pIn->GetParser()->SetCol1( 0 );
pOld->pIn->GetParser()->Error( SbERR_BAD_DECLARATION, aName );
}
diff --git a/basic/source/comp/token.cxx b/basic/source/comp/token.cxx
index df387ea..1027d5b 100644
--- a/basic/source/comp/token.cxx
+++ b/basic/source/comp/token.cxx
@@ -34,11 +34,11 @@
struct TokenTable { SbiToken t; const char *s; };
-static short nToken; // Anzahl der Tokens
+static short nToken; // number of tokens
static TokenTable* pTokTable;
-static TokenTable aTokTable_Basic [] = { // Token-Tabelle:
+static TokenTable aTokTable_Basic [] = {
{ CAT, "&" },
{ MUL, "*" },
@@ -119,7 +119,7 @@ static TokenTable aTokTable_Basic [] = { // Token-Tabelle:
{ IMP, "Imp" },
{ IMPLEMENTS, "Implements" },
{ _IN_, "In" },
- { INPUT, "Input" }, // auch INPUT #
+ { INPUT, "Input" }, // also INPUT #
{ TINTEGER, "Integer" },
{ IS, "Is" },
{ LET, "Let" },
@@ -188,7 +188,7 @@ static TokenTable aTokTable_Basic [] = { // Token-Tabelle:
{ WHILE, "While" },
{ WITH, "With" },
{ WITHEVENTS, "WithEvents" },
- { WRITE, "Write" }, // auch WRITE #
+ { WRITE, "Write" }, // also WRITE #
{ XOR, "Xor" },
{ NIL, "" }
};
@@ -217,7 +217,7 @@ TokenLabelInfo::~TokenLabelInfo()
}
-// Der Konstruktor ermittelt die Laenge der Token-Tabelle.
+// the constructor detects the length of the token table
SbiTokenizer::SbiTokenizer( const ::rtl::OUString& rSrc, StarBASIC* pb )
: SbiScanner( rSrc, pb )
@@ -236,7 +236,6 @@ SbiTokenizer::~SbiTokenizer()
{
}
-// Wiederablage (Pushback) eines Tokens. (Bis zu 2 Tokens)
void SbiTokenizer::Push( SbiToken t )
{
@@ -263,7 +262,7 @@ void SbiTokenizer::Error( SbError code, SbiToken tok )
Error( code );
}
-// Einlesen des naechsten Tokens, ohne dass das Token geschluckt wird
+// reading in the next token without absorbing it
SbiToken SbiTokenizer::Peek()
{
@@ -280,12 +279,11 @@ SbiToken SbiTokenizer::Peek()
return eCurTok = ePush;
}
-// Dies ist fuer die Decompilation.
-// Zahlen und Symbole liefern einen Leerstring zurueck.
+// For decompilation. Numbers and symbols return an empty string.
const String& SbiTokenizer::Symbol( SbiToken t )
{
- // Zeichen-Token?
+ // character token?
if( t < FIRSTKWD )
{
aSym = (char) t;
@@ -312,15 +310,15 @@ const String& SbiTokenizer::Symbol( SbiToken t )
return aSym;
}
-// Einlesen des naechsten Tokens und Ablage desselben
-// Tokens, die nicht in der Token-Tabelle vorkommen, werden
-// direkt als Zeichen zurueckgeliefert.
-// Einige Worte werden gesondert behandelt.
+// Reading in the next token and put it down.
+// Tokens that don't appear in the token table
+// are directly returned as a character.
+// Some words are treated in a special way.
SbiToken SbiTokenizer::Next()
{
if (bEof) return EOLN;
- // Schon eines eingelesen?
+ // have read in one already?
if( ePush != NIL )
{
eCurTok = ePush;
@@ -333,40 +331,35 @@ SbiToken SbiTokenizer::Next()
}
TokenTable *tp;
- // Sonst einlesen:
if( !NextSym() )
{
bEof = bEos = sal_True;
return eCurTok = EOLN;
}
- // Zeilenende?
+
if( aSym.GetBuffer()[0] == '\n' )
{
bEos = sal_True; return eCurTok = EOLN;
}
bEos = sal_False;
- // Zahl?
if( bNumber )
return eCurTok = NUMBER;
- // String?
else if( ( eScanType == SbxDATE || eScanType == SbxSTRING ) && !bSymbol )
return eCurTok = FIXSTRING;
- // Sonderfaelle von Zeichen, die zwischen "Z" und "a" liegen. ICompare()
- // wertet die Position dieser Zeichen unterschiedlich aus.
+ // Special cases of characters that are between "Z" and "a". ICompare()
+ // evaluates the position of these characters in different ways.
else if( aSym.GetBuffer()[0] == '^' )
return eCurTok = EXPON;
else if( aSym.GetBuffer()[0] == '\\' )
return eCurTok = IDIV;
else
{
- // Mit Typkennung oder ein Symbol und keine Keyword-Erkennung?
- // Dann kein Token-Test
if( eScanType != SbxVARIANT
|| ( !bKeywords && bSymbol ) )
return eCurTok = SYMBOL;
- // Gueltiges Token?
+ // valid token?
short lb = 0;
short ub = nToken-1;
short delta;
@@ -375,23 +368,23 @@ SbiToken SbiTokenizer::Next()
delta = (ub - lb) >> 1;
tp = &pTokTable[ lb + delta ];
StringCompare res = aSym.CompareIgnoreCaseToAscii( tp->s );
- // Gefunden?
+
if( res == COMPARE_EQUAL )
goto special;
- // Groesser? Dann untere Haelfte
+
if( res == COMPARE_LESS )
{
if ((ub - lb) == 2) ub = lb;
else ub = ub - delta;
}
- // Kleiner? Dann obere Haelfte
+
else
{
if ((ub -lb) == 2) lb = ub;
else lb = lb + delta;
}
} while( delta );
- // Symbol? Wenn nicht >= Token
+ // Symbol? if not >= token
sal_Unicode ch = aSym.GetBuffer()[0];
if( !BasicSimpleCharClass::isAlpha( ch, bCompatible ) && !bSymbol )
return eCurTok = (SbiToken) (ch & 0x00FF);
@@ -410,14 +403,14 @@ special:
// END IF, CASE, SUB, DEF, FUNCTION, TYPE, CLASS, WITH
if( tp->t == END )
{
- // AB, 15.3.96, Spezialbehandlung fuer END, beim Peek() geht die
- // aktuelle Zeile verloren, daher alles merken und danach restaurieren
+ // from 15.3.96, special treatment for END, at Peek() the current
+ // time is lost, so memorize everything and restore after
sal_uInt16 nOldLine = nLine;
sal_uInt16 nOldCol = nCol;
sal_uInt16 nOldCol1 = nCol1;
sal_uInt16 nOldCol2 = nCol2;
String aOldSym = aSym;
- SaveLine(); // pLine im Scanner sichern
+ SaveLine(); // save pLine in the scanner
eCurTok = Peek();
switch( eCurTok )
@@ -435,21 +428,20 @@ special:
nCol1 = nOldCol1;
if( eCurTok == END )
{
- // Alles zuruecksetzen, damit Token nach END ganz neu gelesen wird
+ // reset everything so that token is read completely newly after END
ePush = NIL;
nLine = nOldLine;
nCol = nOldCol;
nCol2 = nOldCol2;
aSym = aOldSym;
- RestoreLine(); // pLine im Scanner restaurieren
+ RestoreLine();
}
return eCurTok;
}
- // Sind Datentypen Keywords?
- // Nur nach AS, sonst sind es Symbole!
- // Es gibt ja ERROR(), DATA(), STRING() etc.
+ // are data types keywords?
+ // there is ERROR(), DATA(), STRING() etc.
eCurTok = tp->t;
- // AS: Datentypen sind Keywords
+ // AS: data types are keywords
if( tp->t == AS )
bAs = sal_True;
else
@@ -493,7 +485,6 @@ special:
#pragma optimize("",off)
#endif
-// Kann das aktuell eingelesene Token ein Label sein?
sal_Bool SbiTokenizer::MayBeLabel( sal_Bool bNeedsColon )
{
@@ -541,7 +532,7 @@ void SbiTokenizer::Hilite( SbTextPortions& rList )
else
aRes.eType = SB_PUNCTUATION;
}
- // Die Folge xxx.Keyword sollte nicht als Kwd geflagt werden
+ // the sequence xxx.Keyword should not be flagged as Kwd
if( aRes.eType == SB_KEYWORD
&& ( eLastTok == DOT|| eLastTok == EXCLAM ) )
aRes.eType = SB_SYMBOL;
diff --git a/basic/source/inc/buffer.hxx b/basic/source/inc/buffer.hxx
index 24c4bc0..e354dfa 100644
--- a/basic/source/inc/buffer.hxx
+++ b/basic/source/inc/buffer.hxx
@@ -34,29 +34,29 @@
class SbiParser;
-class SbiBuffer { // Code/Konstanten-Puffer:
- SbiParser* pParser; // fuer Fehlermeldungen
- char* pBuf; // Puffer-Pointer
- char* pCur; // aktueller Puffer-Pointer
- sal_uInt32 nOff; // aktuelles Offset
- sal_uInt32 nSize; // aktuelle Groesse
- short nInc; // Inkrement
- sal_Bool Check( sal_uInt16 ); // Buffergroesse testen
+class SbiBuffer {
+ SbiParser* pParser; // for error messages
+ char* pBuf;
+ char* pCur;
+ sal_uInt32 nOff;
+ sal_uInt32 nSize;
+ short nInc;
+ sal_Bool Check( sal_uInt16 );
public:
- SbiBuffer( SbiParser*, short ); // Inkrement
+ SbiBuffer( SbiParser*, short ); // increment
~SbiBuffer();
- void Patch( sal_uInt32, sal_uInt32 ); // Patchen
- void Chain( sal_uInt32 ); // Back-Chain
- void Align( sal_Int32 ); // Alignment
- sal_Bool Add( const void*, sal_uInt16 );// Element anfuegen
- sal_Bool operator += (const String&);// Basic-String speichern
- sal_Bool operator += (sal_Int8); // Zeichen speichern
- sal_Bool operator += (sal_Int16); // Integer speichern
- sal_Bool operator += (sal_uInt8); // Zeichen speichern
- sal_Bool operator += (sal_uInt16); // Integer speichern
- sal_Bool operator += (sal_uInt32); // Integer speichern
- sal_Bool operator += (sal_Int32); // Integer speichern
- char* GetBuffer(); // Puffer rausgeben (selbst loeschen!)
+ void Patch( sal_uInt32, sal_uInt32 );
+ void Chain( sal_uInt32 );
+ void Align( sal_Int32 );
+ sal_Bool Add( const void*, sal_uInt16 );
+ sal_Bool operator += (const String&); // save basic-string
+ sal_Bool operator += (sal_Int8); // save character
+ sal_Bool operator += (sal_Int16); // save integer
+ sal_Bool operator += (sal_uInt8); // save character
+ sal_Bool operator += (sal_uInt16); // save integer
+ sal_Bool operator += (sal_uInt32); // save integer
+ sal_Bool operator += (sal_Int32); // save integer
+ char* GetBuffer(); // give out buffer (delete yourself!)
char* GetBufferPtr(){ return pBuf; }
sal_uInt32 GetSize() { return nOff; }
};
diff --git a/basic/source/inc/codegen.hxx b/basic/source/inc/codegen.hxx
index 0f56998..973bcc0 100644
--- a/basic/source/inc/codegen.hxx
+++ b/basic/source/inc/codegen.hxx
@@ -35,13 +35,13 @@ class SbModule;
#include "opcodes.hxx"
#include "buffer.hxx"
-class SbiCodeGen { // Code-Erzeugung:
- SbiParser* pParser; // fuer Fehlermeldungen, Line, Column etc.
- SbModule& rMod; // aktuelles Modul
- SbiBuffer aCode; // Code-Puffer
- short nLine, nCol; // Zeile, Spalte fuer Stmnt-Befehl
- short nForLevel; // #29955 for-Schleifen-Ebene
- sal_Bool bStmnt; // sal_True: Statement-Opcode liegt an
+class SbiCodeGen {
+ SbiParser* pParser; // for error messages, line, column etc.
+ SbModule& rMod;
+ SbiBuffer aCode;
+ short nLine, nCol; // for stmnt command
+ short nForLevel; // #29955
+ sal_Bool bStmnt; // sal_True: statement-opcode is pending
public:
SbiCodeGen( SbModule&, SbiParser*, short );
SbiParser* GetParser() { return pParser; }
@@ -52,12 +52,12 @@ public:
void Patch( sal_uInt32 o, sal_uInt32 v ){ aCode.Patch( o, v ); }
void BackChain( sal_uInt32 off ) { aCode.Chain( off ); }
void Statement();
- void GenStmnt(); // evtl. Statement-Opcode erzeugen
+ void GenStmnt(); // create statement-opcode maybe
sal_uInt32 GetPC();
sal_uInt32 GetOffset() { return GetPC() + 1; }
void Save();
- // #29955 for-Schleifen-Ebene pflegen
+ // #29955 service for-loop-level
void IncForLevel( void ) { nForLevel++; }
void DecForLevel( void ) { nForLevel--; }
diff --git a/basic/source/inc/collelem.hxx b/basic/source/inc/collelem.hxx
index 2c39e71..8465fd4 100644
--- a/basic/source/inc/collelem.hxx
+++ b/basic/source/inc/collelem.hxx
@@ -31,10 +31,10 @@
#include <basic/sbxobj.hxx>
-// Das Sample-Element ist ein kleines Objekt, das die Properties
-// Name und Value enth„lt sowie die Methode Say, die den bergebenen
-// Text mit dem eigenen Namen verkoppelt. Der Name ist von aussen setzbar.
-// Die Implementation arbeitet ausschliesslich mit dynamischen Elementen.
+// The sample-element is a small object that contains the
+// properties name and value and the method Say which couples
+// the passed text with its own name. The name can be set from
+// outside. Implementation works with dynamic elements only.
class SampleElement : public SbxObject
{
diff --git a/basic/source/inc/disas.hxx b/basic/source/inc/disas.hxx
index dbb951a..c1f42e9 100644
--- a/basic/source/inc/disas.hxx
+++ b/basic/source/inc/disas.hxx
@@ -37,19 +37,19 @@ class SvStream;
class SbiDisas {
const SbiImage& rImg;
SbModule* pMod;
- char cLabels[ MAX_LABELS ]; // Bitvektor fuer Labels
- sal_uInt32 nOff; // aktuelle Position
- sal_uInt32 nPC; // Position des Opcodes
- SbiOpcode eOp; // Opcode
- sal_uInt32 nOp1, nOp2; // Operanden
- sal_uInt32 nParts; // 1, 2 oder 3
- sal_uInt32 nLine; // aktuelle Zeile
+ char cLabels[ MAX_LABELS ]; // bit vector for labels
+ sal_uInt32 nOff; // current position
+ sal_uInt32 nPC; // position of the opcode
+ SbiOpcode eOp; // opcode
+ sal_uInt32 nOp1, nOp2; // operands
+ sal_uInt32 nParts; // 1, 2 or 3
+ sal_uInt32 nLine; // current line
sal_Bool DisasLine( String& );
- sal_Bool Fetch(); // naechster Opcode
+ sal_Bool Fetch(); // next opcode
public:
SbiDisas( SbModule*, const SbiImage* );
void Disas( String& );
- // NICHT AUFRUFEN
+ // DO NOT CALL
void StrOp( String& );
void Str2Op( String& );
void ImmOp( String& );
diff --git a/basic/source/inc/expr.hxx b/basic/source/inc/expr.hxx
index 0ae218d..fbf80a0 100644
--- a/basic/source/inc/expr.hxx
+++ b/basic/source/inc/expr.hxx
@@ -46,10 +46,10 @@ class SbiProcDef;
#include <vector>
typedef ::std::vector<SbiExprList*> SbiExprListVector;
-struct SbVar { // Variablen-Element:
- SbiExprNode* pNext; // Weiteres Element (bei Strukturen)
- SbiSymDef* pDef; // Symboldefinition
- SbiExprList* pPar; // optionale Parameter (wird geloescht)
+struct SbVar {
+ SbiExprNode* pNext; // next element (for structures)
+ SbiSymDef* pDef; // symbol definition
+ SbiExprList* pPar; // optional parameters (is deleted)
SbiExprListVector* pvMorePar; // Array of arrays foo(pPar)(avMorePar[0])(avMorePar[1])...
};
@@ -60,11 +60,11 @@ struct KeywordSymbolInfo
SbiToken m_eTok;
};
-enum SbiExprType { // Expression-Typen:
- SbSTDEXPR, // normaler Ausdruck
- SbLVALUE, // beliebiger lValue
- SbSYMBOL, // beliebiges zusammengesetztes Symbol
- SbOPERAND // Variable/Funktion
+enum SbiExprType { // expression types:
+ SbSTDEXPR, // normal expression
+ SbLVALUE, // any lValue
+ SbSYMBOL, // any composite symbol
+ SbOPERAND // variable/function
};
enum SbiExprMode { // Expression context:
@@ -79,9 +79,9 @@ enum SbiExprMode { // Expression context:
};
enum SbiNodeType {
- SbxNUMVAL, // nVal = Wert
- SbxSTRVAL, // aStrVal = Wert, before #i59791/#i45570: nStringId = Wert
- SbxVARVAL, // aVar = Wert
+ SbxNUMVAL, // nVal = value
+ SbxSTRVAL, // aStrVal = value, before #i59791/#i45570: nStringId = value
+ SbxVARVAL, // aVar = value
SbxTYPEOF, // TypeOf ObjExpr Is Type
SbxNODE, // Node
SbxNEW, // new <type> expression
@@ -95,37 +95,37 @@ enum RecursiveMode
PREVENT_CALL
};
-class SbiExprNode { // Operatoren (und Operanden)
+class SbiExprNode { // operators (and operands)
friend class SbiExpression;
friend class SbiConstExpression;
union {
- sal_uInt16 nTypeStrId; // gepoolter String-ID, #i59791/#i45570 Now only for TypeOf
- double nVal; // numerischer Wert
- SbVar aVar; // oder Variable
+ sal_uInt16 nTypeStrId; // pooled String-ID, #i59791/#i45570 Now only for TypeOf
+ double nVal; // numeric value
+ SbVar aVar; // or variable
};
String aStrVal; // #i59791/#i45570 Store string directly
- SbiExprNode* pLeft; // linker Zweig
- SbiExprNode* pRight; // rechter Zweig (NULL bei unaeren Ops)
- SbiExprNode* pWithParent; // Knoten, dessen Member this per with ist
- SbiCodeGen* pGen; // Code-Generator
- SbiNodeType eNodeType; // Art des Nodes
- SbxDataType eType; // aktueller Datentyp
- SbiToken eTok; // Token des Operators
- sal_Bool bComposite; // sal_True: Zusammengesetzter Ausdruck
- sal_Bool bError; // sal_True: Fehlerhaft
- void FoldConstants(); // Constant Folding durchfuehren
- void CollectBits(); // Umwandeln von Zahlen in Strings
- sal_Bool IsOperand() // sal_True, wenn Operand
+ SbiExprNode* pLeft; // right branch
+ SbiExprNode* pRight; // right branch (NULL for unary ops)
+ SbiExprNode* pWithParent; // node, whose member is "this per with"
+ SbiCodeGen* pGen; // code-generator
+ SbiNodeType eNodeType;
+ SbxDataType eType;
+ SbiToken eTok;
+ sal_Bool bComposite; // sal_True: composite expression
+ sal_Bool bError; // sal_True: error
+ void FoldConstants();
+ void CollectBits(); // converting numbers to strings
+ sal_Bool IsOperand()
{ return sal_Bool( eNodeType != SbxNODE && eNodeType != SbxTYPEOF && eNodeType != SbxNEW ); }
sal_Bool IsTypeOf()
{ return sal_Bool( eNodeType == SbxTYPEOF ); }
sal_Bool IsNew()
{ return sal_Bool( eNodeType == SbxNEW ); }
- sal_Bool IsNumber(); // sal_True bei Zahlen
- sal_Bool IsString(); // sal_True bei Strings
- sal_Bool IsLvalue(); // sal_True, falls als Lvalue verwendbar
- void GenElement( SbiOpcode ); // Element
- void BaseInit( SbiParser* p ); // Hilfsfunktion fuer Ctor, AB 17.12.95
+ sal_Bool IsNumber();
+ sal_Bool IsString();
+ sal_Bool IsLvalue(); // sal_True, if usable as Lvalue
+ void GenElement( SbiOpcode );
+ void BaseInit( SbiParser* p ); // help function for Ctor, from 17.12.95
public:
SbiExprNode( void );
SbiExprNode( SbiParser*, double, SbxDataType );
@@ -137,10 +137,10 @@ public:
virtual ~SbiExprNode();
sal_Bool IsValid() { return sal_Bool( !bError ); }
- sal_Bool IsConstant() // sal_True bei konstantem Operanden
+ sal_Bool IsConstant() // sal_True constant operand
{ return sal_Bool( eNodeType == SbxSTRVAL || eNodeType == SbxNUMVAL ); }
- sal_Bool IsIntConst(); // sal_True bei Integer-Konstanten
- sal_Bool IsVariable(); // sal_True, wenn Variable
+ sal_Bool IsIntConst();
+ sal_Bool IsVariable();
SbiExprNode* GetWithParent() { return pWithParent; }
void SetWithParent( SbiExprNode* p ) { pWithParent = p; }
@@ -148,33 +148,33 @@ public:
SbxDataType GetType() { return eType; }
void SetType( SbxDataType eTp ) { eType = eTp; }
SbiNodeType GetNodeType() { return eNodeType; }
- SbiSymDef* GetVar(); // Variable (falls vorhanden)
- SbiSymDef* GetRealVar(); // letzte Variable in x.y.z
- SbiExprNode* GetRealNode(); // letzter Knoten in x.y.z
- short GetDepth(); // Tiefe eines Baumes berechnen
+ SbiSymDef* GetVar();
+ SbiSymDef* GetRealVar(); // last variable in x.y.z
+ SbiExprNode* GetRealNode(); // last node in x.y.z
+ short GetDepth(); // compute a tree's depth
const String& GetString() { return aStrVal; }
short GetNumber() { return (short)nVal; }
SbiExprList* GetParameters() { return aVar.pPar; }
SbiExprListVector* GetMoreParameters() { return aVar.pvMorePar; }
- void Optimize(); // Baumabgleich
+ void Optimize(); // tree matching
- void Gen( RecursiveMode eRecMode = UNDEFINED ); // Ausgabe eines Nodes
+ void Gen( RecursiveMode eRecMode = UNDEFINED ); // giving out a node
};
-class SbiExpression { // der Ausdruck:
+class SbiExpression {
friend class SbiExprList;
friend class SbiParameters;
friend class SbiDimList;
protected:
- String aArgName; // Name fuer bananntes Argument
- SbiParser* pParser; // fuer Fehlermeldungen, Parsing
- SbiExpression* pNext; // Link bei Parameterlisten
- SbiExprNode* pExpr; // Der Expression-Baum
- SbiExprType eCurExpr; // Art des Ausdrucks
- SbiExprMode m_eMode; // Expression context
- sal_Bool bBased; // sal_True: einfacher DIM-Teil (+BASE)
- sal_Bool bError; // sal_True: Fehler
+ String aArgName;
+ SbiParser* pParser;
+ SbiExpression* pNext; // link at parameter lists
+ SbiExprNode* pExpr; // expression tree
+ SbiExprType eCurExpr; // type of expression
+ SbiExprMode m_eMode; // expression context
+ sal_Bool bBased; // sal_True: easy DIM-part (+BASE)
+ sal_Bool bError;
sal_Bool bByVal; // sal_True: ByVal-Parameter
sal_Bool bBracket; // sal_True: Parameter list with brackets
sal_uInt16 nParenLevel;
@@ -199,11 +199,11 @@ protected:
SbiExprNode* Boolean();
public:
SbiExpression( SbiParser*, SbiExprType = SbSTDEXPR,
- SbiExprMode eMode = EXPRMODE_STANDARD, const KeywordSymbolInfo* pKeywordSymbolInfo = NULL ); // Parsender Ctor
+ SbiExprMode eMode = EXPRMODE_STANDARD, const KeywordSymbolInfo* pKeywordSymbolInfo = NULL ); // parsing Ctor
SbiExpression( SbiParser*, const String& );
SbiExpression( SbiParser*, double, SbxDataType = SbxDOUBLE );
SbiExpression( SbiParser*, const SbiSymDef&, SbiExprList* = NULL );
- SbiExpression( SbiParser*, SbiToken ); // Spezial-Expr mit Spezial-Tokens
+ SbiExpression( SbiParser*, SbiToken ); // special expr with special tokens
~SbiExpression();
String& GetName() { return aArgName; }
void SetBased() { bBased = sal_True; }
@@ -222,14 +222,14 @@ public:
SbiExprNode* GetExprNode() { return pExpr; }
SbxDataType GetType() { return pExpr->GetType(); }
void SetType( SbxDataType eType){ pExpr->eType = eType; }
- void Gen( RecursiveMode eRecMode = UNDEFINED ); // Ausgabe eines Nodes
+ void Gen( RecursiveMode eRecMode = UNDEFINED );
};
class SbiConstExpression : public SbiExpression {
double nVal;
String aVal;
SbxDataType eType;
-public: // numerische Konstante
+public: // numeric constant
SbiConstExpression( SbiParser* );
SbxDataType GetType() { return eType; }
const String& GetString() { return aVal; }
@@ -237,14 +237,14 @@ public: // numerische Konstante
short GetShortValue();
};
-class SbiExprList { // Basisklasse fuer Parameter und Dims
+class SbiExprList { // base class for parameters and dims
protected:
- SbiParser* pParser; // Parser
- SbiExpression* pFirst; // Expressions
- short nExpr; // Anzahl Expressions
- short nDim; // Anzahl Dimensionen
- sal_Bool bError; // sal_True: Fehler
- sal_Bool bBracket; // sal_True: Klammern
+ SbiParser* pParser;
+ SbiExpression* pFirst;
+ short nExpr;
+ short nDim;
+ sal_Bool bError;
+ sal_Bool bBracket;
public:
SbiExprList( SbiParser* );
virtual ~SbiExprList();
@@ -253,20 +253,20 @@ public:
short GetSize() { return nExpr; }
short GetDims() { return nDim; }
SbiExpression* Get( short );
- sal_Bool Test( const SbiProcDef& ); // Parameter-Checks
- void Gen(); // Code-Erzeugung
+ sal_Bool Test( const SbiProcDef& ); // parameter checks
+ void Gen(); // code generation
void addExpression( SbiExpression* pExpr );
};
class SbiParameters : public SbiExprList {
public:
- SbiParameters( SbiParser*, sal_Bool bConst = sal_False, sal_Bool bPar = sal_True);// parsender Ctor
+ SbiParameters( SbiParser*, sal_Bool bConst = sal_False, sal_Bool bPar = sal_True);// parsing Ctor
};
class SbiDimList : public SbiExprList {
- sal_Bool bConst; // sal_True: Alles sind Integer-Konstanten
+ sal_Bool bConst; // sal_True: everything integer constants
public:
- SbiDimList( SbiParser* ); // Parsender Ctor
+ SbiDimList( SbiParser* ); // parsing Ctor
sal_Bool IsConstant() { return bConst; }
};
diff --git a/basic/source/inc/filefmt.hxx b/basic/source/inc/filefmt.hxx
index caf6131..2206106 100644
--- a/basic/source/inc/filefmt.hxx
+++ b/basic/source/inc/filefmt.hxx
@@ -33,36 +33,36 @@
class SvStream;
-// Version 2: Datentyp des Returnwerts fuer Publics
-// Version 3: neue Opcodes
-// Version 4: neue Opcodes
-// Version 5: Bug (Ansprung von STATIC-Variablen im Init-Code)
-// Version 6: Neue Opcodes und Bug (Globals anlegen, ohne BASIC zu beenden)
-// Version 7: Korrektur im WITH-Parsing
-// Version 8: Korrektur im IF-Parsing
-// Version 9: Init-Code auch mit LEAVE beenden, wenn keine SUB/FUNCTION folgt
-// Version A: #36374 Bei DIM AS NEW... auch Variablen anlegen
-// Version B: #40689 Static umgestellt
-// Version C: #41606 Bug bei Static
-// Version D: #42678 Bug bei RTL-Function spc
-// Version E: #56204 DCREATE, um auch bei DIM AS NEW Arrays anzulegen
-// Version F: #57844 Einfuehrung von SvNumberformat::StringToDouble
-// Version 10: #29955 For-Schleifen-Level in Statement-PCodes generieren
-// Version 11: #29955 Wegen Build-Inkonsistenzen Neu-Compilieren erzwingen
+// Version 2: data type of the return value for publics
+// Version 3: new opcodes
+// Version 4: new opcodes
+// Version 5: bug (entry of STATIC-variables in the init code)
+// Version 6: new opcodes and bug (construct globals, without ending the BASIC)
+// Version 7: correction concerning the WITH-Parsing
+// Version 8: correction concerning the IF-Parsing
+// Version 9: end init code with LEAVE, too, if no SUB/FUNCTION follows
+// Version A: #36374 at DIM AS NEW... construct variable too
+// Version B: #40689 reorganized static
+// Version C: #41606 bug at static
+// Version D: #42678 bug at RTL-function spc
+// Version E: #56204 DCREATE, to also construct arrays at DIM AS NEW
+// Version F: #57844 introduction of SvNumberformat::StringToDouble
+// Version 10: #29955 generate for-loop-level in Statement-PCodes
+// Version 11: #29955 force anew compilation because of build-inconsistences
#define B_LEGACYVERSION 0x00000011L
#define B_CURVERSION 0x00000012L
#define B_EXT_IMG_VERSION 0x00000012L
-// Eine Datei enthaelt entweder einen Modul- oder einen Library-Record.
-// Diese Records enthalten wiederum weitere Records. Jeder Record hat
-// den folgenden Header:
+// The file contains either a module- or a library-record.
+// Those records contain further records. Every record's got
+// the following header:
-// sal_uInt16 Kennung
-// sal_uInt32 Laenge des Records ohne Header
-// sal_uInt16 Anzahl Unterelemente
+// sal_uInt16 identifier
+// sal_uInt32 the record's length without the header
+// sal_uInt16 number of sub-elements
-// Alle Datei-Offsets in Records sind relativ zum Start des Moduls!
+// all the file-offsets in records are relative to the module's start!
#define B_LIBRARY 0x4C42 // BL Library Record
#define B_MODULE 0x4D42 // BM Module Record
@@ -84,92 +84,92 @@ class SvStream;
#define B_EXTSOURCE 0x5345 // ES extended source
#endif
-// Ein Library Record enthaelt nur Module Records
-// sal_uInt16 Kennung BL
-// sal_uInt32 Laenge des Records
-// sal_uInt16 Anzahl Module
+// A library record contains only module records
+// sal_uInt16 identifier BL
+// sal_uInt32 the record's length
+// sal_uInt16 number of modules
-// Ein Modul-Record enthaelt alle anderen Recordtypen
-// sal_uInt16 Kennung BM
-// sal_uInt32 Laenge des Records
+// A module-record contains all the other record types
+// sal_uInt16 identifier BM
+// sal_uInt32 the record's length
// sal_uInt16 1
-// Daten:
-// sal_uInt32 Versionsnummer
-// sal_uInt32 Zeichensatz
-// sal_uInt32 Startadresse Initialisierungscode
-// sal_uInt32 Startadresse Sub Main
-// sal_uInt32 Reserviert
-// sal_uInt32 Reserviert
-
-// Modulname, Kommentar und Quellcode:
-// sal_uInt16 Kennung MN, MC oder SC
-// sal_uInt32 Laenge des Records
+// Data:
+// sal_uInt32 version number
+// sal_uInt32 character set
+// sal_uInt32 starting address initialisation code
+// sal_uInt32 starting address sub main
+// sal_uInt32 reserved
+// sal_uInt32 reserved
+
+// module name, comment and source code:
+// sal_uInt16 identifier MN, MC or SC
+// sal_uInt32 the record's length
// sal_uInt16 1
-// Daten:
-// String-Instanz
+// Data:
+// string instance
// P-Code:
-// sal_uInt16 Kennung PC
-// sal_uInt32 Laenge des Records
+// sal_uInt16 identifier PC
+// sal_uInt32 the record's length
// sal_uInt16 1
-// Daten:
-// Der P-Code als Bytesack
-
-// Alle Symbole und Strings werden in einem String-Pool gehalten.
-// Verweise auf diese Strings sind in Form eines Indexes in diesen Pool.
-
-// Liste aller Publics:
-// sal_uInt16 Kennung PU oder Pu
-// sal_uInt32 Laenge des Records
-// sal_uInt16 Anzahl der Publics
-// Daten fuer jeden Public-Eintrag:
-// sal_uInt16 String-Index
-// sal_uInt32 Startadresse im P-Code-Image (sal_uInt16 fuer alte Publics)
-// sal_uInt16 Datentyp des Returnwertes (ab Version 2)
-
-// Verzeichnis der Symbol-Tabellen:
-// sal_uInt16 Kennung SP
-// sal_uInt32 Laenge des Records
-// sal_uInt16 Anzahl der Symboltabellen
-// Daten fuer jede Symboltabelle:
-// sal_uInt16 Stringindex des Namens
-// sal_uInt16 Anzahl Symbole
-// sal_uInt16 Scope-Kennung
-
-// Symboltabelle:
-// sal_uInt16 Kennung SY
-// sal_uInt32 Laenge des Records
-// sal_uInt16 Anzahl der Symbole
-// Daten:
-// sal_uInt16 Stringindex des Namens
-// sal_uInt16 Anzahl Symbole
-// Daten fuer jedes Symbol:
-// sal_uInt16 Stringindex des Namens
-// sal_uInt16 Datentyp
-// sal_uInt16 Laenge bei STRING*n-Symbolen (0x8000: STATIC-Variable)
+// Data:
+// the P-Code as bytesack
+
+// All symbols and strings are kept in a string-pool.
+// References to these strings are in this pool in the form of an index.
+
+// List of all publics:
+// sal_uInt16 identifier PU or Pu
+// sal_uInt32 the record's length
+// sal_uInt16 number of publics
+// Data for every public-entry:
+// sal_uInt16 string index
+// sal_uInt32 starting address in the p-code-image (sal_uInt16 for old publics)
+// sal_uInt16 data type of the return value (from version 2)
+
+// Register of the symbol tables:
+// sal_uInt16 identifier SP
+// sal_uInt32 the record's length
+// sal_uInt16 number of symbol tables
+// Data for every symbol table:
+// sal_uInt16 stringindex of the name
+// sal_uInt16 number of symbols
+// sal_uInt16 scope identifier
+
+// symbol table:
+// sal_uInt16 identifier SY
+// sal_uInt32 the record's length
+// sal_uInt16 number of symbols
+// Data:
+// sal_uInt16 stringindex of the name
+// sal_uInt16 number of symbols
+// Data for every symbol:
+// sal_uInt16 stringindex of the name
+// sal_uInt16 data type
+// sal_uInt16 length for STRING*n-symbols (0x8000: STATIC variable)
// Stringpool:
-// sal_uInt16 Kennung ST
-// sal_uInt32 Laenge des Records
-// sal_uInt16 Anzahl der Strings
-// Daten fuer jeden String:
-// sal_uInt32 Offset in den Block aller Strings
-// Danach folgt der Block aller Strings, die dort als ASCIIZ-Strings liegen.
-
-// Line Ranges:
-// sal_uInt16 Kennung LR
-// sal_uInt32 Laenge des Records
-// sal_uInt16 Anzahl der Strings
-// Daten fuer jedes Public:
+// sal_uInt16 identifier ST
+// sal_uInt32 the record's length
+// sal_uInt16 number of strings
+// Data for every string:
+// sal_uInt32 Offset in the block of all strings
+// the block of all strings (ASCIIZ) follows then
+
+// line ranges:
+// sal_uInt16 identifier LR
+// sal_uInt32 the record's length
+// sal_uInt16 number of strings
+// Data for every public:
// sal_uInt16 1. Zeile (Sub XXX)
// sal_uInt16 2. Zeile (End Sub)
-// SBX-Objekte:
-// sal_uInt16 Anzahl Objekte
-// .... Objektdaten
+// SBX-objects:
+// sal_uInt16 number of objects
+// .... object data
-// Service-Routinen (in IMAGE.CXX)
+// service routines (in IMAGE.CXX)
sal_Bool SbGood( SvStream& r );
sal_uIntPtr SbOpenRecord( SvStream&, sal_uInt16 nSignature, sal_uInt16 nElem );
diff --git a/basic/source/inc/image.hxx b/basic/source/inc/image.hxx
index 0f0ffdf..6fe01f8 100644
--- a/basic/source/inc/image.hxx
+++ b/basic/source/inc/image.hxx
@@ -33,13 +33,13 @@
#include <rtl/ustring.hxx>
#include <filefmt.hxx>
-// Diese Klasse liest das vom Compiler erzeugte Image ein und verwaltet
-// den Zugriff auf die einzelnen Elemente.
+// This class reads in the image that's been produced by the compiler
+// and manages the access to the single elements.
struct SbPublicEntry;
class SbiImage {
- friend class SbiCodeGen; // Compiler-Klassen, die die private-
+ friend class SbiCodeGen; // compiler classes, that the private-
SbxArrayRef rTypes; // User defined types
SbxArrayRef rEnums; // Enum types
@@ -47,35 +47,35 @@ class SbiImage {
sal_Unicode* pStrings; // StringPool
char* pCode; // Code-Image
char* pLegacyPCode; // Code-Image
- sal_Bool bError; // sal_True: Fehler
- sal_uInt16 nFlags; // Flags (s.u.)
- short nStrings; // Anzahl Strings
- sal_uInt32 nStringSize; // Groesse des String-Puffers
- sal_uInt32 nCodeSize; // Groesse des Code-Blocks
- sal_uInt16 nLegacyCodeSize; // Groesse des Code-Blocks
- sal_uInt16 nDimBase; // OPTION BASE-Wert
- rtl_TextEncoding eCharSet; // Zeichensatz fuer Strings
- // temporaere Verwaltungs-Variable:
- short nStringIdx; // aktueller String-Index
- sal_uInt32 nStringOff; // aktuelle Pos im Stringpuffer
- // Routinen fuer Compiler:
- void MakeStrings( short ); // StringPool einrichten
- void AddString( const String& );// String zufuegen
- void AddCode( char*, sal_uInt32 ); // Codeblock dazu
- void AddType(SbxObject *); // User-Type mit aufnehmen
- void AddEnum(SbxObject *); // Register enum type
+ sal_Bool bError;
+ sal_uInt16 nFlags;
+ short nStrings;
+ sal_uInt32 nStringSize;
+ sal_uInt32 nCodeSize;
+ sal_uInt16 nLegacyCodeSize;
+ sal_uInt16 nDimBase; // OPTION BASE value
+ rtl_TextEncoding eCharSet;
+ // temporary management-variable:
+ short nStringIdx;
+ sal_uInt32 nStringOff; // current Pos in the stringbuffer
+ // routines for the compiler:
+ void MakeStrings( short ); // establish StringPool
+ void AddString( const String& );
+ void AddCode( char*, sal_uInt32 );
+ void AddType(SbxObject *);
+ void AddEnum(SbxObject *);
public:
- String aName; // Makroname
- ::rtl::OUString aOUSource; // Quellcode
- String aComment; // Kommentar
- sal_Bool bInit; // sal_True: Init-Code ist gelaufen
- sal_Bool bFirstInit; // sal_True, wenn das Image das erste mal nach
- // dem Compilieren initialisiert wird.
+ String aName; // macro name
+ ::rtl::OUString aOUSource; // source code
+ String aComment;
+ sal_Bool bInit;
+ sal_Bool bFirstInit;
+
SbiImage();
~SbiImage();
- void Clear(); // Inhalt loeschen
- sal_Bool Load( SvStream&, sal_uInt32& nVer ); // Loads image from stream
+ void Clear();
+ sal_Bool Load( SvStream&, sal_uInt32& nVer );
// nVer is set to version
// of image
sal_Bool Load( SvStream& );
@@ -100,9 +100,9 @@ public:
};
-#define SBIMG_EXPLICIT 0x0001 // OPTION EXPLICIT ist aktiv
-#define SBIMG_COMPARETEXT 0x0002 // OPTION COMPARE TEXT ist aktiv
-#define SBIMG_INITCODE 0x0004 // Init-Code vorhanden
+#define SBIMG_EXPLICIT 0x0001 // OPTION EXPLICIT is active
+#define SBIMG_COMPARETEXT 0x0002 // OPTION COMPARE TEXT is active
+#define SBIMG_INITCODE 0x0004 // Init-Code does exist
#define SBIMG_CLASSMODULE 0x0008 // OPTION ClassModule is active
#endif
diff --git a/basic/source/inc/iosys.hxx b/basic/source/inc/iosys.hxx
index 48d6ce3..fe431c2 100644
--- a/basic/source/inc/iosys.hxx
+++ b/basic/source/inc/iosys.hxx
@@ -34,29 +34,28 @@
class SvStream;
-// Zur Zeit sind globale Dateien (Kanalnummern 256 bis 511)
-// nicht implementiert.
+// Global files (channel numbers 256 to 511) are not
+// implemented at the moment.
#define CHANNELS 256
#define CONSOLE 0
-#define SBSTRM_INPUT 0x0001 // Input
-#define SBSTRM_OUTPUT 0x0002 // Output
-#define SBSTRM_RANDOM 0x0004 // Random
-#define SBSTRM_APPEND 0x0008 // Append
-#define SBSTRM_BINARY 0x0010 // Binary
+#define SBSTRM_INPUT 0x0001
+#define SBSTRM_OUTPUT 0x0002
+#define SBSTRM_RANDOM 0x0004
+#define SBSTRM_APPEND 0x0008
+#define SBSTRM_BINARY 0x0010
class SbiStream {
- SvStream* pStrm; // der Stream
- sal_uIntPtr nExpandOnWriteTo; // bei Schreibzugriff, den Stream
- // bis zu dieser Groesse aufblasen
- ByteString aLine; // aktuelle Zeile
- sal_uIntPtr nLine; // aktuelle Zeilennummer
- short nLen; // Pufferlaenge
- short nMode; // Bits:
- short nChan; // aktueller Kanal
- SbError nError; // letzter Fehlercode
- void MapError(); // Fehlercode mappen
+ SvStream* pStrm;
+ sal_uIntPtr nExpandOnWriteTo; // during writing access expand the stream to this size
+ ByteString aLine;
+ sal_uIntPtr nLine;
+ short nLen; // buffer length
+ short nMode;
+ short nChan;
+ SbError nError;
+ void MapError();
public:
SbiStream();
@@ -82,10 +81,10 @@ public:
class SbiIoSystem {
SbiStream* pChan[ CHANNELS ];
- ByteString aPrompt; // Input-Prompt
- ByteString aIn, aOut; // Console-Buffer
- short nChan; // aktueller Kanal
- SbError nError; // letzter Fehlercode
+ ByteString aPrompt;
+ ByteString aIn, aOut;
+ short nChan;
+ SbError nError;
void ReadCon( ByteString& );
void WriteCon( const ByteString& );
public:
diff --git a/basic/source/inc/object.hxx b/basic/source/inc/object.hxx
index 52af24b..577ee37 100644
--- a/basic/source/inc/object.hxx
+++ b/basic/source/inc/object.hxx
@@ -34,27 +34,26 @@
#include <basic/sbxobj.hxx>
// 1) Properties:
-// Name der Name, R/O
-// Value ein double-Wert, R/W
-// 2) Methoden:
-// Display Ausgabe eines Textes
-// Square Argument * Argument
-// Event Aufruf eines Basic-Programms
-// 3) Unterobjekte:
-// eine Collection names "Elements". Der Zugriff ist sowohl als
-// Property (fuer das gesamte Objekt) als auch als Methode (fuer
-// einzelne Elemente, wird durchgereicht) implementiert.
-// Diese Implementation ist ein Beispiel fuer eine tabellengesteuerte
-// Version, die sehr viele Elemente enthalten kann.
-// Die Collection findet sich in COLLECTN.*, die in der Collection
-// enthaltenen Objekte in COLLELEM.*
+// Name R/O
+// Value a double-value, R/W
+// 2) Methods:
+// Display display a text
+// Square argument * argument
+// Event call of a Basic-program
+// 3) Sub-objects:
+// a collection named "elements". The access is implemented as
+// property (for the whole object) and as method (for single
+// elements, is passed through).
+// This implementation is an example for a table controlled
+// version that can contain many elements.
+// The collection is located in COLLECTN.*, the collection's
+// objects in COLLELEM.*
class SampleObject : public SbxObject
{
using SbxVariable::GetInfo;
- // Definition eines Tabelleneintrags. Dies wird hier gemacht,
- // da dadurch die Methoden und Properties als private deklariert
- // werden koennen.
+ // Definition of a table entry. This is done here because
+ // methods and properties can be declared private that way.
#if defined ( ICC ) || defined ( C50 )
public:
#endif
@@ -65,30 +64,29 @@ private:
#endif
struct Methods {
- const char* pName; // Name des Eintrags
- SbxDataType eType; // Datentyp
- pMeth pFunc; // Function Pointer
- short nArgs; // Argumente und Flags
+ const char* pName; // name of an entry
+ SbxDataType eType; // data type
+ pMeth pFunc;
+ short nArgs; // arguments and flags
};
- static Methods aMethods[]; // Methodentabelle
+ static Methods aMethods[]; // method table
- // Methoden
+ // methods
void Display( SbxVariable*, SbxArray*, sal_Bool );
void Event( SbxVariable*, SbxArray*, sal_Bool );
void Square( SbxVariable*, SbxArray*, sal_Bool );
void Create( SbxVariable*, SbxArray*, sal_Bool );
- // Infoblock auffuellen
+ // fill infoblock
SbxInfo* GetInfo( short nIdx );
// Broadcaster Notification
virtual void SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
const SfxHint& rHint, const TypeId& rHintType );
public:
SampleObject( const String& );
- // Suchen eines Elements
+
virtual SbxVariable* Find( const String&, SbxClassType );
};
-// Die dazugehoerige Factory:
class SampleObjectFac : public SbxFactory
{
diff --git a/basic/source/inc/opcodes.hxx b/basic/source/inc/opcodes.hxx
index 156ef8b..bf8b20f 100644
--- a/basic/source/inc/opcodes.hxx
+++ b/basic/source/inc/opcodes.hxx
@@ -31,60 +31,60 @@
#include "sbintern.hxx"
-// Ein Opcode ist entweder 1, 3 oder 5 Bytes lang, je nach numerischen
-// Wert des Opcodes (s.u.).
+// An opcode can have a length of 1, 3 or 5 bytes,
+// depending on its numeric value (see below).
enum SbiOpcode {
- // Alle Opcodes ohne Operanden
+ // all opcodes without operands
_NOP = 0,
SbOP0_START = _NOP,
- // Operatoren
- // die folgenden Operatoren sind genauso angeordnet
- // wie der enum SbxVarOp
+ // operators
+ // the following operators are ordered
+ // the same way as the enum SbxVarOp
_EXP, _MUL, _DIV, _MOD, _PLUS, _MINUS, _NEG,
_EQ, _NE, _LT, _GT, _LE, _GE,
_IDIV, _AND, _OR, _XOR, _EQV, _IMP, _NOT,
_CAT,
- // Ende enum SbxVarOp
+ // end of enum SbxVarOp
_LIKE, _IS,
- // Laden/speichern
- _ARGC, // neuen Argv einrichten
- _ARGV, // TOS ==> aktueller Argv
+ // load/save
+ _ARGC, // establish new Argv
+ _ARGV, // TOS ==> current Argv
_INPUT, // Input ==> TOS
_LINPUT, // Line Input ==> TOS
- _GET, // TOS anfassen
- _SET, // Speichern Objekt TOS ==> TOS-1
+ _GET, // touch TOS
+ _SET, // save object TOS ==> TOS-1
_PUT, // TOS ==> TOS-1
- _PUTC, // TOS ==> TOS-1, dann ReadOnly
+ _PUTC, // TOS ==> TOS-1, then ReadOnly
_DIM, // DIM
_REDIM, // REDIM
_REDIMP, // REDIM PRESERVE
- _ERASE, // TOS loeschen
- // Verzweigen
- _STOP, // Programmende
- _INITFOR, // FOR-Variable initialisieren
- _NEXT, // FOR-Variable inkrementieren
- _CASE, // Anfang CASE
- _ENDCASE, // Ende CASE
- _STDERROR, // Standard-Fehlerbehandlung
- _NOERROR, // keine Fehlerbehandlung
- _LEAVE, // UP verlassen
+ _ERASE, // delete TOS
+ // branch
+ _STOP, // end of program
+ _INITFOR, // initialize FOR-variable
+ _NEXT, // increment FOR-variable
+ _CASE, // beginning CASE
+ _ENDCASE, // end CASE
+ _STDERROR, // standard error handling
+ _NOERROR, // no error handling
+ _LEAVE, // leave UP
// E/A
- _CHANNEL, // TOS = Kanalnummer
+ _CHANNEL, // TOS = channel number
_BPRINT, // print TOS
_PRINTF, // print TOS in field
_BWRITE, // write TOS
_RENAME, // Rename Tos+1 to Tos
_PROMPT, // TOS = Prompt for Input
- _RESTART, // Restartpunkt definieren
- _CHAN0, // I/O-Kanal 0
- // Sonstiges
- _EMPTY, // Leeren Ausdruck auf Stack
- _ERROR, // TOS = Fehlercode
- _LSET, // Speichern Objekt TOS ==> TOS-1
- _RSET, // Speichern Objekt TOS ==> TOS-1
+ _RESTART, // define restart point
+ _CHAN0, // I/O-channel 0
+ // miscellaneous
+ _EMPTY, // empty expression on stack
+ _ERROR, // TOS = error code
+ _LSET, // saving object TOS ==> TOS-1
+ _RSET, // saving object TOS ==> TOS-1
_REDIMP_ERASE, // Copies array to be later used by REDIM PRESERVE before erasing it
_INITFOREACH,
_VBASET, // VBA-like Set
@@ -94,70 +94,70 @@ enum SbiOpcode {
SbOP0_END = _BYVAL,
- // Alle Opcodes mit einem Operanden
+ // all opcodes with one operand
- _NUMBER = 0x40, // Laden einer numerischen Konstanten (+ID)
+ _NUMBER = 0x40, // loading a numeric constant (+ID)
SbOP1_START = _NUMBER,
- _SCONST, // Laden einer Stringkonstanten (+ID)
- _CONST, // Immediate Load (+Wert)
- _ARGN, // Speichern eines named Args in Argv (+StringID)
- _PAD, // String auf feste Laenge bringen (+Laenge)
+ _SCONST, // loading a stringconstant (+ID)
+ _CONST, // Immediate Load (+ value)
+ _ARGN, // saving a named Arg in Argv (+StringID)
+ _PAD, // bring string to a firm length (+length)
// Verzweigungen
- _JUMP, // Sprung (+Target)
- _JUMPT, // TOS auswerten, bedingter Sprung (+Target)
- _JUMPF, // TOS auswerten, bedingter Sprung (+Target)
- _ONJUMP, // TOS auswerten, Sprung in JUMP-Tabelle (+MaxVal)
- _GOSUB, // UP-Aufruf (+Target)
- _RETURN, // UP-Return (+0 oder Target)
- _TESTFOR, // FOR-Variable testen, inkrementieren (+Endlabel)
+ _JUMP, // jump (+target)
+ _JUMPT, // evaluate TOS, conditional jump (+target)
+ _JUMPF, // 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, // Fehler-Handler (+Offset)
- _RESUME, // Resume nach Fehlern (+0 or 1 or Label)
+ _ERRHDL, // error handler (+Offset)
+ _RESUME, // Resume after errors (+0 or 1 or Label)
// E/A
- _CLOSE, // (+Kanal/0)
+ _CLOSE, // (+channel/0)
_PRCHAR, // (+char)
// Verwaltung
- _SETCLASS, // Set + Klassennamen testen (+StringId)
+ _SETCLASS, // test set + class names (+StringId)
_TESTCLASS, // Check TOS class (+StringId)
- _LIB, // Libnamen fuer Declare-Procs setzen (+StringId)
- _BASED, // TOS wird um BASE erhoeht, BASE davor gepusht (+base)
- // Typanpassung im Argv
- _ARGTYP, // Letzten Parameter in Argv konvertieren (+Typ)
+ _LIB, // set lib name for declar-procs (+StringId)
+ _BASED, // TOS is incremented by BASE, BASE is pushed before (+base)
+ // type adjustment in the Argv
+ _ARGTYP, // convert last parameter in Argv (+type)
_VBASETCLASS, // VBA-like Set
SbOP1_END = _VBASETCLASS,
- // Alle Opcodes mit zwei Operanden
+ // all opcodes with two operands
- _RTL = 0x80, // Laden aus RTL (+StringID+Typ)
+ _RTL = 0x80, // load from the RTL (+StringID+Typ)
SbOP2_START = _RTL,
- _FIND, // Laden (+StringID+Typ)
- _ELEM, // Laden Element (+StringID+Typ)
- _PARAM, // Parameter (+Offset+Typ)
- // Verzweigen
- _CALL, // DECLARE-Methode rufen (+StringID+Typ)
- _CALLC, // Cdecl-DECLARE-Methode rufen (+StringID+Typ)
- _CASEIS, // Case-Test (+Test-Opcode+True-Target)
- // Verwaltung
- _STMNT, // Beginn eines Statements (+Line+Col)
+ _FIND, // load (+StringID+Typ)
+ _ELEM, // load element (+StringID+Typ)
+ _PARAM, // parameters (+Offset+Typ)
+ // branch
+ _CALL, // call DECLARE-method (+StringID+Typ)
+ _CALLC, // call Cdecl-DECLARE-Method (+StringID+Typ)
+ _CASEIS, // case-test (+Test-Opcode+True-Target)
+ // management
+ _STMNT, // begin of a statement (+Line+Col)
// E/A
_OPEN, // (+SvStreamFlags+Flags)
- // Objekte
- _LOCAL, // Lokale Variable definieren (+StringID+Typ)
- _PUBLIC, // Modulglobale Variable (+StringID+Typ)
- _GLOBAL, // Globale Variable definieren, public-Anweisung (+StringID+Typ)
- _CREATE, // Objekt kreieren (+StringId+StringID)
- _STATIC, // Statische Variabl (+StringID+Typ) JSM
- _TCREATE, // User Defined Objekt kreieren
- _DCREATE, // Objekt-Array kreieren (+StringId+StringID)
- _GLOBAL_P, // Globale Variable definieren, die beim Neustart von Basic
- // nicht ueberschrieben wird, P=PERSIST (+StringID+Typ)
- _FIND_G, // Sucht globale Variable mit Spezialbehandlung wegen _GLOBAL_P
- _DCREATE_REDIMP, // Objekt-Array redimensionieren (+StringId+StringID)
+ // objects
+ _LOCAL, // define locals variables (+StringID+Typ)
+ _PUBLIC, // module global variables (+StringID+Typ)
+ _GLOBAL, // define global variables, public command (+StringID+Typ)
+ _CREATE, // create object (+StringId+StringID)
+ _STATIC, // static variable (+StringID+Typ) JSM
+ _TCREATE, // create user-defined object
+ _DCREATE, // create object-array (+StringId+StringID)
+ _GLOBAL_P, // define global variable that's not overwritten on restarting
+ // the Basic, P=PERSIST (+StringID+Typ)
+ _FIND_G, // finds global variable with special treatment due to _GLOBAL_P
+ _DCREATE_REDIMP, // redimension 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)
diff --git a/basic/source/inc/parser.hxx b/basic/source/inc/parser.hxx
index 1b58e5d..4fe80e3 100644
--- a/basic/source/inc/parser.hxx
+++ b/basic/source/inc/parser.hxx
@@ -43,42 +43,42 @@ class SbiParser : public SbiTokenizer
{
friend class SbiExpression;
- SbiParseStack* pStack; // Block-Stack
- SbiProcDef* pProc; // aktuelle Prozedur
- SbiExprNode* pWithVar; // aktuelle With-Variable
- SbiToken eEndTok; // das Ende-Token
- sal_uInt32 nGblChain; // Chainkette fuer globale DIMs
- sal_Bool bGblDefs; // sal_True globale Definitionen allgemein
- sal_Bool bNewGblDefs; // sal_True globale Definitionen vor Sub
- sal_Bool bSingleLineIf; // sal_True einzeiliges if-Statement
-
- SbiSymDef* VarDecl( SbiDimList**,sal_Bool,sal_Bool );// Variablen-Deklaration
- SbiProcDef* ProcDecl(sal_Bool bDecl);// Prozedur-Deklaration
+ SbiParseStack* pStack;
+ SbiProcDef* pProc;
+ SbiExprNode* pWithVar;
+ SbiToken eEndTok;
+ sal_uInt32 nGblChain; // for global DIMs
+ sal_Bool bGblDefs; // sal_True global definitions general
+ sal_Bool bNewGblDefs; // sal_True globale definitions before sub
+ sal_Bool bSingleLineIf;
+
+ SbiSymDef* VarDecl( SbiDimList**,sal_Bool,sal_Bool );
+ SbiProcDef* ProcDecl(sal_Bool bDecl);
void DefStatic( sal_Bool bPrivate );
- void DefProc( sal_Bool bStatic, sal_Bool bPrivate ); // Prozedur einlesen
- void DefVar( SbiOpcode eOp, sal_Bool bStatic ); // DIM/REDIM einlesen
- void TypeDecl( SbiSymDef&, sal_Bool bAsNewAlreadyParsed=sal_False ); // AS-Deklaration
- void OpenBlock( SbiToken, SbiExprNode* = NULL ); // Block oeffnen
- void CloseBlock(); // Block aufloesen
- sal_Bool Channel( sal_Bool=sal_False ); // Kanalnummer parsen
- void StmntBlock( SbiToken ); // Statement-Block abarbeiten
+ void DefProc( sal_Bool bStatic, sal_Bool bPrivate ); // read in procedure
+ void DefVar( SbiOpcode eOp, sal_Bool bStatic ); // read in DIM/REDIM
+ void TypeDecl( SbiSymDef&, sal_Bool bAsNewAlreadyParsed=sal_False ); // AS-declaration
+ void OpenBlock( SbiToken, SbiExprNode* = NULL );
+ void CloseBlock();
+ sal_Bool Channel( sal_Bool=sal_False ); // parse channel number
+ void StmntBlock( SbiToken );
void DefType( sal_Bool bPrivate ); // Parse type declaration
void DefEnum( sal_Bool bPrivate ); // Parse enum declaration
void DefDeclare( sal_Bool bPrivate );
void EnableCompatibility();
public:
- SbxArrayRef rTypeArray; // das Type-Array
- SbxArrayRef rEnumArray; // Enum types
- SbiStringPool aGblStrings; // der String-Pool
- SbiStringPool aLclStrings; // der String-Pool
- SbiSymPool aGlobals; // globale Variable
- SbiSymPool aPublics; // modulglobale Variable
+ SbxArrayRef rTypeArray;
+ SbxArrayRef rEnumArray;
+ SbiStringPool aGblStrings; // string-pool
+ SbiStringPool aLclStrings; // string-pool
+ SbiSymPool aGlobals;
+ SbiSymPool aPublics; // module global
SbiSymPool aRtlSyms; // Runtime-Library
SbiCodeGen aGen; // Code-Generator
- StarBASIC* pBasic; // StarBASIC-Instanz
- SbiSymPool* pPool; // aktueller Pool
- SbiExprType eCurExpr; // aktueller Expr-Typ
- short nBase; // OPTION BASE-Wert
+ StarBASIC* pBasic; // StarBASIC instance
+ SbiSymPool* pPool;
+ SbiExprType eCurExpr;
+ short nBase; // OPTION BASE-value
sal_Bool bText; // OPTION COMPARE TEXT
sal_Bool bExplicit; // sal_True: OPTION EXPLICIT
sal_Bool bClassModule; // sal_True: OPTION ClassModule
@@ -87,28 +87,28 @@ public:
SbxDataType eDefTypes[26]; // DEFxxx-Datentypen
SbiParser( StarBASIC*, SbModule* );
- sal_Bool Parse(); // die Aktion
- SbiExprNode* GetWithVar(); // Innerste With-Variable liefern
+ sal_Bool Parse();
+ SbiExprNode* GetWithVar();
- // AB 31.3.1996, Symbol in Runtime-Library suchen
+ // from 31.3.1996, search symbol in the runtime-library
SbiSymDef* CheckRTLForSym( const String& rSym, SbxDataType eType );
void AddConstants( void );
- sal_Bool HasGlobalCode(); // Globaler Code definiert?
+ sal_Bool HasGlobalCode();
- sal_Bool TestToken( SbiToken ); // bestimmtes TOken?
- sal_Bool TestSymbol( sal_Bool=sal_False ); // Symbol?
- sal_Bool TestComma(); // Komma oder EOLN?
- void TestEoln(); // EOLN?
+ sal_Bool TestToken( SbiToken );
+ sal_Bool TestSymbol( sal_Bool=sal_False );
+ sal_Bool TestComma();
+ void TestEoln();
- void Symbol( const KeywordSymbolInfo* pKeywordSymbolInfo = NULL ); // Let oder Call
+ void Symbol( const KeywordSymbolInfo* pKeywordSymbolInfo = NULL ); // let or call
void ErrorStmnt(); // ERROR n
- void NotImp(); // nicht implementiert
+ void NotImp(); // not implemented
void BadBlock(); // LOOP/WEND/NEXT
- void BadSyntax(); // Falsches SbiToken
- void NoIf(); // ELSE/ELSE IF ohne IF
+ void BadSyntax(); // wrong SbiToken
+ void NoIf(); // ELSE/ELSE IF without IF
void Assign(); // LET
- void Attribute(); // Attribute
+ void Attribute();
void Call(); // CALL
void Close(); // CLOSE
void Declare(); // DECLARE
diff --git a/basic/source/inc/runtime.hxx b/basic/source/inc/runtime.hxx
index d8e8b25..6ee9df8 100644
--- a/basic/source/inc/runtime.hxx
+++ b/basic/source/inc/runtime.hxx
@@ -61,16 +61,16 @@ public:
}
-class SbiInstance; // aktiver StarBASIC-Prozess
-class SbiRuntime; // aktive StarBASIC-Prozedur-Instanz
+class SbiInstance; // active StarBASIC process
+class SbiRuntime; // active StarBASIC procedure instance
struct SbiArgvStack; // Argv stack element
struct SbiGosubStack; // GOSUB stack element
class SbiImage; // Code-Image
-class SbiIoSystem; // Dateisystem
-class SbiDdeControl; // DDE-Steuerung
-class SbiDllMgr; // Aufrufe in DLLs
-class SvNumberFormatter; // Zeit/Datumsfunktionen
+class SbiIoSystem;
+class SbiDdeControl;
+class SbiDllMgr;
+class SvNumberFormatter; // time/date functions
enum ForType
{
@@ -113,7 +113,7 @@ struct SbiGosubStack { // GOSUB-Stack:
sal_uInt16 nStartForLvl; // #118235: For Level in moment of gosub
};
-#define MAXRECURSION 500 // max. 500 Rekursionen
+#define MAXRECURSION 500
#define Sb_ATTR_NORMAL 0x0000
#define Sb_ATTR_HIDDEN 0x0002
@@ -143,9 +143,9 @@ public:
~SbiRTLData();
};
-// Die Instanz entspricht einem laufenden StarBASIC. Mehrere gleichzeitig
-// laufende BASICs werden ueber verkettete Instanzen verwaltet. Hier liegen
-// alle Daten, die nur leben, wenn BASIC auch lebt, wie z.B. das I/O-System.
+// The instance matches a running StarBASIC. Many basics running at the same
+// time are managed by chained instances. There is all the data that only lives
+// when the BASIC is living too, like the I/O-system.
typedef ::std::vector
<
@@ -160,7 +160,7 @@ class SbiInstance
SbiRTLData aRTLData;
- SbiIoSystem* pIosys; // Dateisystem
+ SbiIoSystem* pIosys; // file system
SbiDdeControl* pDdeCtrl; // DDE
SbiDllMgr* pDllMgr; // DLL-Calls (DECLARE)
StarBASIC* pBasic;
@@ -169,33 +169,33 @@ class SbiInstance
DateFormat meFormatterDateFormat;
sal_uInt32 nStdDateIdx, nStdTimeIdx, nStdDateTimeIdx;
- SbError nErr; // aktueller Fehlercode
- String aErrorMsg; // letzte Error-Message fuer $ARG
- sal_uInt16 nErl; // aktuelle Fehlerzeile
- sal_Bool bReschedule; // Flag: sal_True = Reschedule in Hauptschleife
+ SbError nErr;
+ String aErrorMsg; // last error message for $ARG
+ sal_uInt16 nErl; // current error line
+ sal_Bool bReschedule; // Flag: sal_True = Reschedule in main loop
sal_Bool bCompatibility; // Flag: sal_True = VBA runtime compatibility mode
ComponentVector_t ComponentVector;
public:
SbiRuntime* pRun; // Call-Stack
- SbiInstance* pNext; // Instanzen-Chain
+ SbiInstance* pNext; // instances chain
- // #31460 Neues Konzept fuer StepInto/Over/Out,
- // Erklaerung siehe runtime.cxx bei SbiInstance::CalcBreakCallLevel()
- sal_uInt16 nCallLvl; // Call-Level (wg. Rekursion)
- sal_uInt16 nBreakCallLvl; // Call-Level zum Anhalten
- void CalcBreakCallLevel( sal_uInt16 nFlags ); // Gemaess Flags setzen
+ // #31460 new concept for StepInto/Over/Out,
+ // Explaination see runtime.cxx at SbiInstance::CalcBreakCallLevel()
+ sal_uInt16 nCallLvl;
+ sal_uInt16 nBreakCallLvl;
+ void CalcBreakCallLevel( sal_uInt16 nFlags );
SbiInstance( StarBASIC* );
~SbiInstance();
void Error( SbError ); // trappable Error
- void Error( SbError, const String& rMsg ); // trappable Error mit Message
+ void Error( SbError, const String& rMsg ); // trappable Error with message
void ErrorVB( sal_Int32 nVBNumber, const String& rMsg );
void setErrorVB( sal_Int32 nVBNumber, const String& rMsg );
void FatalError( SbError ); // non-trappable Error
void FatalError( SbError, const String& ); // non-trappable Error
- void Abort(); // Abbruch mit aktuellem Fehlercode
+ void Abort(); // with current error code
void Stop();
SbError GetErr() { return nErr; }
@@ -223,16 +223,16 @@ public:
sal_uInt32 GetStdTimeIdx() const { return nStdTimeIdx; }
sal_uInt32 GetStdDateTimeIdx() const { return nStdDateTimeIdx; }
- // NumberFormatter auch statisch anbieten
+ // offer NumberFormatter also static
static void PrepareNumberFormatter( SvNumberFormatter*& rpNumberFormatter,
sal_uInt32 &rnStdDateIdx, sal_uInt32 &rnStdTimeIdx, sal_uInt32 &rnStdDateTimeIdx,
LanguageType* peFormatterLangType=NULL, DateFormat* peFormatterDateFormat=NULL );
};
-SbiIoSystem* SbGetIoSystem(); // das aktuelle I/O-System
+SbiIoSystem* SbGetIoSystem();
-// Verkettbare Items, um Referenzen temporaer zu halten
+// chainable items to keep references temporary
struct RefSaveItem
{
SbxVariableRef xRef;
@@ -242,9 +242,8 @@ struct RefSaveItem
};
-// Eine Instanz dieser Klasse wird fuer jedes ausgefuehrte Unterprogramm
-// aufgesetzt. Diese Instanz ist das Herz der BASIC-Maschine und enthaelt
-// nur lokale Daten.
+// There's one instance of this class for every executed sub-program.
+// This instance is the heart of the BASIC-machine and contains only local data.
class SbiRuntime
{
@@ -253,52 +252,52 @@ class SbiRuntime
typedef void( SbiRuntime::*pStep0 )();
typedef void( SbiRuntime::*pStep1 )( sal_uInt32 nOp1 );
typedef void( SbiRuntime::*pStep2 )( sal_uInt32 nOp1, sal_uInt32 nOp2 );
- static pStep0 aStep0[]; // Opcode-Tabelle Gruppe 0
- static pStep1 aStep1[]; // Opcode-Tabelle Gruppe 1
- static pStep2 aStep2[]; // Opcode-Tabelle Gruppe 2
-
- StarBASIC& rBasic; // StarBASIC-Instanz
- SbiInstance* pInst; // aktiver Thread
- SbModule* pMod; // aktuelles Modul
- SbMethod* pMeth; // Methoden-Instanz
+ static pStep0 aStep0[]; // opcode-table group 0
+ static pStep1 aStep1[];
+ static pStep2 aStep2[];
+
+ StarBASIC& rBasic; // StarBASIC instance
+ SbiInstance* pInst; // current thread
+ SbModule* pMod; // current module
+ SbMethod* pMeth; // method instance
SbiIoSystem* pIosys; // I/O-System
const SbiImage* pImg; // Code-Image
SbxArrayRef refExprStk; // expression stack
SbxArrayRef refCaseStk; // CASE expression stack
SbxArrayRef refRedimpArray; // Array saved to use for REDIM PRESERVE
SbxVariableRef refRedim; // Array saved to use for REDIM
- SbxVariableRef xDummyVar; // Ersatz fuer nicht gefundene Variablen
+ SbxVariableRef xDummyVar; // substitute for variables that weren't found
SbxVariable* mpExtCaller; // Caller ( external - e.g. button name, shape, range object etc. - only in vba mode )
SbiArgvStack* pArgvStk; // ARGV-Stack
SbiGosubStack* pGosubStk; // GOSUB stack
SbiForStack* pForStk; // FOR/NEXT-Stack
- sal_uInt16 nExprLvl; // Tiefe des Expr-Stacks
- sal_uInt16 nGosubLvl; // Zum Vermeiden von Tot-Rekursionen
+ sal_uInt16 nExprLvl; // depth of the expr-stack
+ sal_uInt16 nGosubLvl; // to prevent dead-recursions
sal_uInt16 nForLvl; // #118235: Maintain for level
- const sal_uInt8* pCode; // aktueller Code-Pointer
- const sal_uInt8* pStmnt; // Beginn des lezten Statements
- const sal_uInt8* pError; // Adresse des aktuellen Error-Handlers
- const sal_uInt8* pRestart; // Restart-Adresse
- const sal_uInt8* pErrCode; // Restart-Adresse RESUME NEXT
+ const sal_uInt8* pCode; // current Code-Pointer
+ const sal_uInt8* pStmnt; // beginning of the last statement
+ const sal_uInt8* pError; // address of the current error handler
+ const sal_uInt8* pRestart; // restart-address
+ const sal_uInt8* pErrCode; // restart-adresse RESUME NEXT
const sal_uInt8* pErrStmnt; // Restart-Adresse RESUMT 0
- String aLibName; // Lib-Name fuer Declare-Call
- SbxArrayRef refParams; // aktuelle Prozedur-Parameter
- SbxArrayRef refLocals; // lokale Variable
- SbxArrayRef refArgv; // aktueller Argv
- // #74254, Ein refSaveObj reicht nicht! Neu: pRefSaveList (s.u.)
- short nArgc; // aktueller Argc
- sal_Bool bRun; // sal_True: Programm ist aktiv
- sal_Bool bError; // sal_True: Fehler behandeln
- sal_Bool bInError; // sal_True: in einem Fehler-Handler
+ String aLibName; // Lib-name for declare-call
+ SbxArrayRef refParams; // current procedure parameters
+ SbxArrayRef refLocals; // local variable
+ SbxArrayRef refArgv;
+ // #74254, one refSaveObj is not enough! new: pRefSaveList (see above)
+ short nArgc;
+ sal_Bool bRun;
+ sal_Bool bError; // sal_True: handle errors
+ sal_Bool bInError; // sal_True: in an error handler
sal_Bool bBlocked; // sal_True: blocked by next call level, #i48868
sal_Bool bVBAEnabled;
sal_uInt16 nFlags; // Debugging-Flags
- SbError nError; // letzter Fehler
- sal_uInt16 nOps; // Opcode-Zaehler
+ SbError nError;
+ sal_uInt16 nOps; // opcode counter
sal_uInt32 m_nLastTime;
- RefSaveItem* pRefSaveList; // #74254 Temporaere Referenzen sichern
- RefSaveItem* pItemStoreList; // Unbenutzte Items aufbewahren
+ RefSaveItem* pRefSaveList; // #74254 save temporary references
+ RefSaveItem* pItemStoreList; // keep unused items
void SaveRef( SbxVariable* pVar )
{
RefSaveItem* pItem = pItemStoreList;
@@ -327,43 +326,43 @@ class SbiRuntime
void SetupArgs( SbxVariable*, sal_uInt32 );
SbxVariable* CheckArray( SbxVariable* );
- void PushVar( SbxVariable* ); // Variable push
- SbxVariableRef PopVar(); // Variable pop
- SbxVariable* GetTOS( short=0 ); // Variable vom TOS holen
- void TOSMakeTemp(); // TOS in temp. Variable wandeln
- sal_Bool ClearExprStack(); // Expr-Stack freigeben
+ void PushVar( SbxVariable* );
+ SbxVariableRef PopVar();
+ SbxVariable* GetTOS( short=0 );
+ void TOSMakeTemp();
+ sal_Bool ClearExprStack();
- void PushGosub( const sal_uInt8* ); // GOSUB-Element push
- void PopGosub(); // GOSUB-Element pop
- void ClearGosubStack(); // GOSUB-Stack freigeben
+ void PushGosub( const sal_uInt8* );
+ void PopGosub();
+ void ClearGosubStack();
- void PushArgv(); // Argv-Element push
- void PopArgv(); // Argv-Element pop
- void ClearArgvStack(); // Argv-Stack freigeben
+ void PushArgv();
+ void PopArgv();
+ void ClearArgvStack();
- void PushFor(); // For-Element push
- void PushForEach(); // For-Each-Element push
- void PopFor(); // For-Element pop
- void ClearForStack(); // For-Stack freigeben
+ void PushFor();
+ void PushForEach();
+ void PopFor();
+ void ClearForStack();
- void StepArith( SbxOperator ); // arithmetische Verknuepfungen
- void StepUnary( SbxOperator ); // unaere Verknuepfungen
- void StepCompare( SbxOperator );// Vergleiche
+ void StepArith( SbxOperator );
+ void StepUnary( SbxOperator );
+ void StepCompare( SbxOperator );
- void SetParameters( SbxArray* );// Parameter uebernehmen
+ void SetParameters( SbxArray* );
- // MUSS NOCH IMPLEMENTIERT WERDEN
+ // HAS TO BE IMPLEMENTED SOME TIME
void DllCall( const String&, const String&, SbxArray*, SbxDataType, sal_Bool );
- // #56204 DIM-Funktionalitaet in Hilfsmethode auslagern (step0.cxx)
+ // #56204 swap out DIM-functionality into help method (step0.cxx)
void DimImpl( SbxVariableRef refVar );
bool implIsClass( SbxObject* pObj, const ::rtl::OUString& aClass );
void StepSETCLASS_impl( sal_uInt32 nOp1, bool bHandleDflt = false );
- // Die nachfolgenden Routinen werden vom Single Stepper
- // gerufen und implementieren die einzelnen Opcodes
+ // the following routines are called by the single
+ // stepper and implement the single opcodes
void StepNOP(), StepEXP(), StepMUL(), StepDIV();
void StepMOD(), StepPLUS(), StepMINUS(), StepNEG();
void StepEQ(), StepNE(), StepLT(), StepGT();
@@ -382,7 +381,7 @@ class SbiRuntime
void StepRESTART(), StepEMPTY(), StepLEAVE();
void StepLSET(), StepRSET(), StepREDIMP_ERASE(), StepERASE_CLEAR();
void StepARRAYACCESS(), StepBYVAL();
- // Alle Opcodes mit einem Operanden
+ // all opcodes with one operand
void StepLOADNC( sal_uInt32 ), StepLOADSC( sal_uInt32 ), StepLOADI( sal_uInt32 );
void StepARGN( sal_uInt32 ), StepBASED( sal_uInt32 ), StepPAD( sal_uInt32 );
void StepJUMP( sal_uInt32 ), StepJUMPT( sal_uInt32 );
@@ -392,7 +391,7 @@ class SbiRuntime
void StepRESUME( sal_uInt32 ), StepSETCLASS( sal_uInt32 ), StepVBASETCLASS( sal_uInt32 ), StepTESTCLASS( sal_uInt32 ), StepLIB( sal_uInt32 );
bool checkClass_Impl( const SbxVariableRef& refVal, const ::rtl::OUString& aClass, bool bRaiseErrors, bool bDefault = true );
void StepCLOSE( sal_uInt32 ), StepPRCHAR( sal_uInt32 ), StepARGTYP( sal_uInt32 );
- // Alle Opcodes mit zwei Operanden
+ // all opcodes with two operands
void StepRTL( sal_uInt32, sal_uInt32 ), StepPUBLIC( sal_uInt32, sal_uInt32 ), StepPUBLIC_P( sal_uInt32, sal_uInt32 );
void StepPUBLIC_Impl( sal_uInt32, sal_uInt32, bool bUsedForClassModule );
void StepFIND_Impl( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, SbError, sal_Bool bLocal, sal_Bool bStatic = sal_False );
@@ -413,18 +412,18 @@ public:
void SetVBAEnabled( bool bEnabled );
sal_uInt16 GetImageFlag( sal_uInt16 n ) const;
sal_uInt16 GetBase();
- xub_StrLen nLine,nCol1,nCol2; // aktuelle Zeile, Spaltenbereich
+ xub_StrLen nLine,nCol1,nCol2;
SbiRuntime* pNext; // Stack-Chain
SbiRuntime( SbModule*, SbMethod*, sal_uInt32 );
~SbiRuntime();
- void Error( SbError, bool bVBATranslationAlreadyDone = false ); // Fehler setzen, falls != 0
- void Error( SbError, const String& ); // Fehler setzen, falls != 0
- void FatalError( SbError ); // Fehlerbehandlung=Standard, Fehler setzen
- void FatalError( SbError, const String& ); // Fehlerbehandlung=Standard, Fehler setzen
+ void Error( SbError, bool bVBATranslationAlreadyDone = false ); // set error if != 0
+ void Error( SbError, const String& ); // set error if != 0
+ void FatalError( SbError ); // error handling = standard, set error
+ void FatalError( SbError, const String& ); // error handling = standard, set error
static sal_Int32 translateErrorToVba( SbError nError, String& rMsg );
void DumpPCode();
- sal_Bool Step(); // Einzelschritt (ein Opcode)
+ sal_Bool Step(); // single step (one opcode)
void Stop() { bRun = sal_False; }
sal_Bool IsRun() { return bRun; }
void block( void ) { bBlocked = sal_True; }
@@ -460,7 +459,7 @@ inline void checkArithmeticOverflow( SbxVariable* pVar )
}
}
-// Hilfsfunktion, um aktives Basic zu finden
+
StarBASIC* GetCurrentBasic( StarBASIC* pRTBasic );
// Get information if security restrictions should be
diff --git a/basic/source/inc/sbcomp.hxx b/basic/source/inc/sbcomp.hxx
index 2918e67..737ce5b 100644
--- a/basic/source/inc/sbcomp.hxx
+++ b/basic/source/inc/sbcomp.hxx
@@ -29,12 +29,12 @@
#ifndef _SBCOMP_HXX
#define _SBCOMP_HXX
-// das folgende habe ich der neuen Datei von MD entnommen! (MT)
+// I've taken the following from the new file by MD! (MT)
#include "sbintern.hxx"
-#include "token.hxx" // Tokenizer
-#include "symtbl.hxx" // Symbolverwaltung
-#include "parser.hxx" // Parser
-#include "codegen.hxx" // Code-Generator
+#include "token.hxx"
+#include "symtbl.hxx"
+#include "parser.hxx"
+#include "codegen.hxx"
#endif
diff --git a/basic/source/inc/sbintern.hxx b/basic/source/inc/sbintern.hxx
index 501b278..2c469c6 100644
--- a/basic/source/inc/sbintern.hxx
+++ b/basic/source/inc/sbintern.hxx
@@ -87,7 +87,7 @@ public:
SbModule* FindClass( const String& rClassName );
};
-// Stack fuer die im Fehlerfall abgebaute SbiRuntime Kette
+// stack for the SbiRuntime chain which is removed in the case of an error
class BASIC_DLLPUBLIC SbErrorStackEntry
{
public:
@@ -153,27 +153,27 @@ private:
struct SbiGlobals
{
- SbiInstance* pInst; // alle aktiven Runtime-Instanzen
+ SbiInstance* pInst; // all active runtime instances
SbiFactory* pSbFac; // StarBASIC-Factory
- SbUnoFactory* pUnoFac; // Factory fuer Uno-Structs bei DIM AS NEW
+ SbUnoFactory* pUnoFac; // Factory for Uno-Structs at DIM AS NEW
SbTypeFactory* pTypeFac; // Factory for user defined types
SbClassFactory* pClassFac; // Factory for user defined classes (based on class modules)
SbOLEFactory* pOLEFac; // Factory for OLE types
SbFormFactory* pFormFac; // Factory for user forms
- SbModule* pMod; // aktuell aktives Modul
- SbModule* pCompMod; // aktuell compiliertes Modul
- short nInst; // Anzahl BASICs
- Link aErrHdl; // globaler Error-Handler
- Link aBreakHdl; // globaler Break-Handler
- SbError nCode; // aktueller Fehlercode
- xub_StrLen nLine; // aktuelle Zeile
- xub_StrLen nCol1,nCol2; // aktuelle Spalten (von,bis)
- sal_Bool bCompiler; // Flag fuer Compiler-Error
- sal_Bool bGlobalInitErr; // Beim GlobalInit trat ein Compiler-Fehler auf
- sal_Bool bRunInit; // sal_True, wenn RunInit vom Basic aktiv ist
- String aErrMsg; // Puffer fuer GetErrorText()
- SbLanguageMode eLanguageMode; // Flag fuer Visual-Basic-Script-Modus
- SbErrorStack* pErrStack; // Stack fuer die im Fehlerfall abgebaute SbiRuntime Kette
+ SbModule* pMod; // currently active module
+ SbModule* pCompMod; // currently compiled module
+ short nInst; // number of BASICs
+ Link aErrHdl; // global error handler
+ Link aBreakHdl; // global break handler
+ SbError nCode;
+ xub_StrLen nLine;
+ xub_StrLen nCol1,nCol2; // from... to...
+ sal_Bool bCompiler; // flag for compiler error
+ sal_Bool bGlobalInitErr;
+ sal_Bool bRunInit; // sal_True, if RunInit active from the Basic
+ String aErrMsg; // buffer for GetErrorText()
+ SbLanguageMode eLanguageMode; // flag for Visual-Basic-Script-Modus
+ SbErrorStack* pErrStack; // for the SbiRuntime chain
::utl::TransliterationWrapper* pTransliterationWrapper; // For StrComp
sal_Bool bBlockCompilerError;
BasicManager* pAppBasMgr;
@@ -183,7 +183,7 @@ struct SbiGlobals
~SbiGlobals();
};
-// Utility-Makros und -Routinen
+// utility macros and routines
BASIC_DLLPUBLIC SbiGlobals* GetSbData();
diff --git a/basic/source/inc/sbjsmeth.hxx b/basic/source/inc/sbjsmeth.hxx
index f2cc8a3..d37ba22 100644
--- a/basic/source/inc/sbjsmeth.hxx
+++ b/basic/source/inc/sbjsmeth.hxx
@@ -32,9 +32,9 @@
#include <basic/sbmeth.hxx>
-// Basic-Modul fuer JavaScript-Sourcen.
-// Alle Basic-spezifischen Methoden muessen virtuell ueberladen und deaktiviert
-// werden. Die Unterscheidung von normalen Modulen erfolgt uebr RTTI.
+// basic module for JavaScript sources
+// All the basic-specific methods must be overloaded virtually and must
+// be deactivated. The differentiation of normal modules is done by RTTI.
class SbJScriptMethod : public SbMethod
{
diff --git a/basic/source/inc/sbjsmod.hxx b/basic/source/inc/sbjsmod.hxx
index 55091dc..7c00874 100644
--- a/basic/source/inc/sbjsmod.hxx
+++ b/basic/source/inc/sbjsmod.hxx
@@ -31,9 +31,9 @@
#include <basic/sbmod.hxx>
-// Basic-Modul fuer JavaScript-Sourcen.
-// Alle Basic-spezifischen Methoden muessen virtuell ueberladen und deaktiviert
-// werden. Die Unterscheidung von normalen Modulen erfolgt uebr RTTI.
+// basic module for JavaScript sources
+// All the basic-specific methods must be overloaded virtually and must
+// be deactivated. The differentiation of normal modules is done by RTTI.
class SbJScriptModule : public SbModule
{
@@ -42,7 +42,7 @@ class SbJScriptModule : public SbModule
public:
SBX_DECL_PERSIST_NODATA(SBXCR_SBX,SBXID_JSCRIPTMOD,1);
TYPEINFO();
- SbJScriptModule( const String& ); // DURCHREICHEN
+ SbJScriptModule( const String& ); // hand through
};
#endif
diff --git a/basic/source/inc/sbunoobj.hxx b/basic/source/inc/sbunoobj.hxx
index cc0f039..5e833c2 100644
--- a/basic/source/inc/sbunoobj.hxx
+++ b/basic/source/inc/sbunoobj.hxx
@@ -56,11 +56,11 @@ class SbUnoObject: public SbxObject
sal_Bool bNativeCOMObject;
::com::sun::star::uno::Any maTmpUnoObj; // Only to save obj for doIntrospection!
- // Hilfs-Methode zum Anlegen der dbg_-Properties
+ // help method to establish the dbg_-properties
void implCreateDbgProperties( void );
- // Hilfs-Methode zum Anlegen aller Properties und Methoden
- // (Beim on-demand-Mechanismus erforderlich fuer die dbg_-Properties)
+ // help method to establish all properties and methods
+ // (on the on-demand-mechanism required for the dbg_-properties)
void implCreateAll( void );
public:
@@ -69,17 +69,17 @@ public:
SbUnoObject( const ::rtl::OUString& aName_, const ::com::sun::star::uno::Any& aUnoObj_ );
~SbUnoObject();
- // #76470 Introspection on Demand durchfuehren
+ // #76470 do introspection on demand
void doIntrospection( void );
- // Find ueberladen, um z.B. NameAccess zu unterstuetzen
+ // Find overloaded to support e. g. NameAccess
virtual SbxVariable* Find( const String&, SbxClassType );
// Force creation of all properties for debugging
void createAllProperties( void )
{ implCreateAll(); }
- // Wert rausgeben
+ // give out value
::com::sun::star::uno::Any getUnoAny( void );
::com::sun::star::uno::Reference< ::com::sun::star::beans::XIntrospectionAccess > getIntrospectionAccess( void ) { return mxUnoAccess; }
::com::sun::star::uno::Reference< ::com::sun::star::script::XInvocation > getInvocation( void ) { return mxInvocation; }
@@ -92,7 +92,7 @@ public:
SV_DECL_IMPL_REF(SbUnoObject);
-// #67781 Rueckgabewerte der Uno-Methoden loeschen
+// #67781 delete return values of the uno-methods
void clearUnoMethods( void );
void clearUnoMethodsForBasic( StarBASIC* pBasic );
@@ -105,7 +105,7 @@ class SbUnoMethod : public SbxMethod
::com::sun::star::uno::Reference< ::com::sun::star::reflection::XIdlMethod > m_xUnoMethod;
::com::sun::star::uno::Sequence< ::com::sun::star::reflection::ParamInfo >* pParamInfoSeq;
- // #67781 Verweis auf vorige und naechste Methode in der Methoden-Liste
+ // #67781 reference to the previous and the next method in the method list
SbUnoMethod* pPrev;
SbUnoMethod* pNext;
@@ -134,7 +134,6 @@ class SbUnoProperty : public SbxProperty
{
friend class SbUnoObject;
- // Daten der Uno-Property
::com::sun::star::beans::Property aUnoProp;
sal_Int32 nId;
@@ -150,7 +149,7 @@ public:
{ return mbInvocation; }
};
-// Factory-Klasse fuer das Anlegen von Uno-Structs per DIM AS NEW
+// factory class to create uno-structs per DIM AS NEW
class SbUnoFactory : public SbxFactory
{
public:
@@ -158,7 +157,7 @@ public:
virtual SbxObject* CreateObject( const String& );
};
-// Wrapper fuer eine Uno-Klasse
+// wrapper for an uno-class
class SbUnoClass : public SbxObject
{
const ::com::sun::star::uno::Reference< ::com::sun::star::reflection::XIdlClass > m_xClass;
@@ -173,18 +172,18 @@ public:
, m_xClass( xClass_ )
{}
- // Find ueberladen, um Elemente on Demand anzulegen
+
virtual SbxVariable* Find( const String&, SbxClassType );
- // Wert rausgeben
+
const ::com::sun::star::uno::Reference< ::com::sun::star::reflection::XIdlClass >& getUnoClass( void ) { return m_xClass; }
};
SV_DECL_IMPL_REF(SbUnoClass);
-// Funktion, um einen globalen Bezeichner im
-// UnoScope zu suchen und fuer Sbx zu wrappen
+// function to find a global identifier in
+// the UnoScope and to wrap it for Sbx
SbUnoClass* findUnoClass( const ::rtl::OUString& rName );
@@ -290,7 +289,7 @@ public:
class StarBASIC;
-// Impl-Methoden fuer RTL
+// Impl-methods for RTL
void RTL_Impl_CreateUnoStruct( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite );
void RTL_Impl_CreateUnoService( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite );
void RTL_Impl_CreateUnoServiceWithArguments( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite );
diff --git a/basic/source/inc/scanner.hxx b/basic/source/inc/scanner.hxx
index 5abfc1e..7790d8b 100644
--- a/basic/source/inc/scanner.hxx
+++ b/basic/source/inc/scanner.hxx
@@ -32,43 +32,42 @@
#include <tools/string.hxx>
#include <basic/sberrors.hxx>
-// Der Scanner ist stand-alone, d.h. er kann von ueberallher verwendet
-// werden. Eine BASIC-Instanz ist fuer Fehlermeldungen notwendig. Ohne
-// BASIC werden die Fehler nur gezaehlt. Auch ist Basic notwendig, wenn
-// eine erweiterte SBX-Variable zur Erkennung von Datentypen etc. verwendet
-// werden soll.
+// The scanner is stand-alone, i. e. it can be used from everywhere.
+// A BASIC-instance is necessary for error messages. Without BASIC
+// the errors are only counted. Also the BASICC is necessary when an
+// advanced SBX-variable shall be used for data type recognition etc.
class StarBASIC;
class SbiScanner
{
- ::rtl::OUString aBuf; // Input-Puffer
- ::rtl::OUString aLine; // aktuelle Zeile
- const sal_Unicode* pLine; // Pointer
- const sal_Unicode* pSaveLine; // Merker fuer Line
+ ::rtl::OUString aBuf; // input buffer
+ ::rtl::OUString aLine;
+ const sal_Unicode* pLine;
+ const sal_Unicode* pSaveLine;
protected:
- String aSym; // Symbolpuffer
- String aError; // Fehler-String
- SbxDataType eScanType; // evtl. Datentyp
- StarBASIC* pBasic; // Instanz fuer Fehler-Callbacks
- double nVal; // numerischer Wert
- short nCurCol1; // aktuelle Spalte 1
- short nSavedCol1; // gerettete Spalte 1
- short nCol; // aktuelle Spaltennummer
- short nErrors; // Anzahl Fehler
- short nColLock; // Lock-Zaehler fuer Col1
- sal_Int32 nBufPos; // aktuelle Buffer-Pos
- sal_uInt16 nLine; // aktuelle Zeile
- sal_uInt16 nCol1, nCol2; // aktuelle 1. und 2. Spalte
- sal_Bool bSymbol; // sal_True: Symbol gescannt
- sal_Bool bNumber; // sal_True: Zahl gescannt
- sal_Bool bSpaces; // sal_True: Whitespace vor Token
- sal_Bool bErrors; // sal_True: Fehler generieren
- sal_Bool bAbort; // sal_True: abbrechen
- sal_Bool bHash; // sal_True: # eingelesen
- sal_Bool bError; // sal_True: Fehler generieren
- sal_Bool bUsedForHilite; // sal_True: Nutzung fuer Highlighting
- sal_Bool bCompatible; // sal_True: OPTION Compatibl
+ String aSym;
+ String aError;
+ SbxDataType eScanType;
+ StarBASIC* pBasic; // instance for error callbacks
+ double nVal; // numeric value
+ short nCurCol1;
+ short nSavedCol1;
+ short nCol;
+ short nErrors;
+ short nColLock; // lock counter for Col1
+ sal_Int32 nBufPos;
+ sal_uInt16 nLine;
+ sal_uInt16 nCol1, nCol2;
+ sal_Bool bSymbol; // sal_True: symbol scanned
+ sal_Bool bNumber; // sal_True: number scanned
+ sal_Bool bSpaces; // sal_True: whitespace before token
+ sal_Bool bErrors; // sal_True: generate errors
+ sal_Bool bAbort;
+ sal_Bool bHash; // sal_True: # has been read in
+ sal_Bool bError; // sal_True: generate error
+ sal_Bool bUsedForHilite;
+ sal_Bool bCompatible; // sal_True: OPTION compatible
sal_Bool bVBASupportOn; // sal_True: OPTION VBASupport 1 otherwise default False
sal_Bool bPrevLineExtentsComment; // sal_True: Previous line is comment and ends on "... _"
@@ -96,7 +95,7 @@ public:
void UnlockColumn();
sal_Bool DoesColonFollow();
- sal_Bool NextSym(); // naechstes Symbol lesen
+ sal_Bool NextSym();
const String& GetSym() { return aSym; }
SbxDataType GetType() { return eScanType; }
double GetDbl() { return nVal; }
diff --git a/basic/source/inc/symtbl.hxx b/basic/source/inc/symtbl.hxx
index a52d8c4..3d83441 100644
--- a/basic/source/inc/symtbl.hxx
+++ b/basic/source/inc/symtbl.hxx
@@ -34,11 +34,11 @@
#include <basic/sbxdef.hxx>
#include <basic/sbdef.hxx>
-class SbiSymDef; // Basisklasse
-class SbiProcDef; // Prozedur
-class SbiConstDef; // Konstante
-class SbiSymPool; // Symbol-Pool
-class SbiStringPool; // gepoolte Strings
+class SbiSymDef; // base class
+class SbiProcDef;
+class SbiConstDef;
+class SbiSymPool;
+class SbiStringPool;
class SvStream;
class SbiParser;
@@ -46,21 +46,21 @@ class SbiParser;
enum SbiSymScope { SbLOCAL, SbPARAM, SbPUBLIC, SbGLOBAL, SbRTL };
-// Der String-Pool nimmt String-Eintraege auf und sorgt dafuer,
-// dass sie nicht doppelt vorkommen.
+// The string-pool collects string entries and
+// makes sure that they don't exist twice.
SV_DECL_PTRARR_DEL(SbiStrings,String*,5,5)
-class SbiStringPool { // String-Pool
- SbiStrings aData; // Daten
+class SbiStringPool {
+ SbiStrings aData;
String aEmpty; // for convenience
- SbiParser* pParser; // der Parser
+ SbiParser* pParser;
public:
SbiStringPool( SbiParser* );
~SbiStringPool();
sal_uInt16 GetSize() const { return aData.Count(); }
- // AB 8.4.1999, Default wegen #64236 auf sal_True geaendert
- // Wenn der Bug sauber behoben ist, wieder auf sal_False aendern.
+ // From 8.4.1999: default changed to sal_True because of #64236 -
+ // change it back to sal_False when the bug is cleanly removed.
short Add( const String&, sal_Bool=sal_True );
short Add( double, SbxDataType );
const String& Find( sal_uInt16 ) const;
@@ -70,17 +70,17 @@ public:
SV_DECL_PTRARR_DEL(SbiSymbols,SbiSymDef*,5,5)
-class SbiSymPool { // Symbol-Pool
+class SbiSymPool {
friend class SbiSymDef;
friend class SbiProcDef;
protected:
- SbiStringPool& rStrings; // verwendeter Stringpool
- SbiSymbols aData; // Daten
- SbiSymPool* pParent; // uebergeordneter Symbol-Pool
- SbiParser* pParser; // der Parser
- SbiSymScope eScope; // Scope des Pools
- sal_uInt16 nProcId; // aktuelles ProcId fuer STATIC-Variable
- sal_uInt16 nCur; // Iterator
+ SbiStringPool& rStrings;
+ SbiSymbols aData;
+ SbiSymPool* pParent;
+ SbiParser* pParser;
+ SbiSymScope eScope;
+ sal_uInt16 nProcId; // for STATIC-variable
+ sal_uInt16 nCur; // iterator
public:
SbiSymPool( SbiStringPool&, SbiSymScope );
~SbiSymPool();
@@ -94,41 +94,41 @@ public:
void SetScope( SbiSymScope s ) { eScope = s; }
SbiParser* GetParser() { return pParser; }
- SbiSymDef* AddSym( const String& ); // Symbol hinzufuegen
- SbiProcDef* AddProc( const String& );// Prozedur hinzufuegen
- void Add( SbiSymDef* ); // Symbol uebernehmen
- SbiSymDef* Find( const String& ) const;// Variablenname
- SbiSymDef* FindId( sal_uInt16 ) const; // Variable per ID suchen
- SbiSymDef* Get( sal_uInt16 ) const; // Variable per Position suchen
- SbiSymDef* First(), *Next(); // Iteratoren
-
- sal_uInt32 Define( const String& ); // Label definieren
- sal_uInt32 Reference( const String& ); // Label referenzieren
- void CheckRefs(); // offene Referenzen suchen
+ SbiSymDef* AddSym( const String& );
+ SbiProcDef* AddProc( const String& );
+ void Add( SbiSymDef* );
+ SbiSymDef* Find( const String& ) const; // variable name
+ SbiSymDef* FindId( sal_uInt16 ) const;
+ SbiSymDef* Get( sal_uInt16 ) const; // find variable per position
+ SbiSymDef* First(), *Next(); // iterators
+
+ sal_uInt32 Define( const String& );
+ sal_uInt32 Reference( const String& );
+ void CheckRefs();
};
-class SbiSymDef { // Allgemeiner Symboleintrag
+class SbiSymDef { // general symbol entry
friend class SbiSymPool;
protected:
- String aName; // Name des Eintrags
- SbxDataType eType; // Typ des Eintrags
- SbiSymPool* pIn; // Parent-Pool
- SbiSymPool* pPool; // Pool fuer Unterelemente
- short nLen; // Stringlaenge bei STRING*n
- short nDims; // Array-Dimensionen
- sal_uInt16 nId; // Symbol-Nummer
- sal_uInt16 nTypeId; // String-ID des Datentyps (Dim X AS Dytentyp)
- sal_uInt16 nProcId; // aktuelles ProcId fuer STATIC-Variable
- sal_uInt16 nPos; // Positions-Nummer
- sal_uInt32 nChain; // Backchain-Kette
+ String aName;
+ SbxDataType eType;
+ SbiSymPool* pIn; // parent pool
+ SbiSymPool* pPool; // pool for sub-elements
+ short nLen; // string length for STRING*n
+ short nDims;
+ sal_uInt16 nId;
+ sal_uInt16 nTypeId; // Dim X AS data type
+ sal_uInt16 nProcId;
+ sal_uInt16 nPos;
+ sal_uInt32 nChain;
sal_Bool bNew : 1; // sal_True: Dim As New...
- sal_Bool bChained : 1; // sal_True: Symbol ist in Code definiert
- sal_Bool bByVal : 1; // sal_True: ByVal-Parameter
- sal_Bool bOpt : 1; // sal_True: optionaler Parameter
- sal_Bool bStatic : 1; // sal_True: STATIC-Variable
- sal_Bool bAs : 1; // sal_True: Datentyp per AS XXX definiert
- sal_Bool bGlobal : 1; // sal_True: Global-Variable
+ sal_Bool bChained : 1; // sal_True: symbol is defined in code
+ sal_Bool bByVal : 1; // sal_True: ByVal-parameter
+ sal_Bool bOpt : 1; // sal_True: optional parameter
+ sal_Bool bStatic : 1; // sal_True: STATIC variable
+ sal_Bool bAs : 1; // sal_True: data type defined per AS XXX
+ sal_Bool bGlobal : 1; // sal_True: global variable
sal_Bool bParamArray : 1; // sal_True: ParamArray parameter
sal_Bool bWithEvents : 1; // sal_True: Declared WithEvents
sal_Bool bWithBrackets : 1; // sal_True: Followed by ()
@@ -180,24 +180,24 @@ public:
void SetFixedStringLength( short n ) { nFixedStringLength = n; }
SbiSymPool& GetPool();
- sal_uInt32 Define(); // Symbol in Code definieren
- sal_uInt32 Reference(); // Symbol in Code referenzieren
+ sal_uInt32 Define(); // define symbol in code
+ sal_uInt32 Reference(); // reference symbol in code
private:
SbiSymDef( const SbiSymDef& );
};
-class SbiProcDef : public SbiSymDef { // Prozedur-Definition (aus Basic):
- SbiSymPool aParams; // Parameter
- SbiSymPool aLabels; // lokale Sprungziele
- String aLibName; // LIB "name"
- String aAlias; // ALIAS "name"
- sal_uInt16 nLine1, nLine2; // Zeilenbereich
+class SbiProcDef : public SbiSymDef { // procedure definition (from basic):
+ SbiSymPool aParams;
+ SbiSymPool aLabels; // local jump targets
+ String aLibName;
+ String aAlias;
+ sal_uInt16 nLine1, nLine2; // line area
PropertyMode mePropMode; // Marks if this is a property procedure and which
String maPropName; // Property name if property procedure (!= proc name)
- sal_Bool bCdecl : 1; // sal_True: CDECL angegeben
- sal_Bool bPublic : 1; // sal_True: proc ist PUBLIC
+ sal_Bool bCdecl : 1; // sal_True: CDECL given
+ sal_Bool bPublic : 1; // sal_True: proc is PUBLIC
sal_Bool mbProcDecl : 1; // sal_True: instanciated by SbiParser::ProcDecl
public:
SbiProcDef( SbiParser*, const String&, sal_Bool bProcDecl=false );
@@ -222,9 +222,8 @@ public:
void setPropertyMode( PropertyMode ePropMode );
const String& GetPropName() { return maPropName; }
- // Match mit einer Forward-Deklaration. Die Parameternamen
- // werden abgeglichen und die Forward-Deklaration wird
- // durch this ersetzt
+ // Match with a forward-declaration. The parameter names are
+ // compared and the forward declaration is replaced by this
void Match( SbiProcDef* pForward );
private:
diff --git a/basic/source/inc/token.hxx b/basic/source/inc/token.hxx
index deb6764..23e09e1 100644
--- a/basic/source/inc/token.hxx
+++ b/basic/source/inc/token.hxx
@@ -37,28 +37,28 @@
#undef SHARED
#endif
-// Der Tokenizer ist stand-alone, d.h. er kann von ueberallher verwendet
-// werden. Eine BASIC-Instanz ist fuer Fehlermeldungen notwendig. Ohne
-// BASIC werden die Fehler nur gezaehlt. Auch ist Basic notwendig, wenn
-// eine erweiterte SBX-Variable zur Erkennung von Datentypen etc. verwendet
-// werden soll.
+// The tokenizer is stand-alone, i. e. he can be used from everywhere.
+// A BASIC-instance is necessary for error messages. Without BASIC the
+// errors are only counted. The BASIC is also necessary when an advanced
+// SBX-variable shall be used for recognition of data types etc.
+
enum SbiToken {
NIL = 0,
- // Token zwischen 0x20 und 0x3F sind Literale:
+ // tokens between 0x20 and 0x3F are literals:
LPAREN = '(', RPAREN = ')', COMMA = ',', DOT = '.', EXCLAM = '!',
HASH = '#', SEMICOLON = ';',
- // Anweisungen:
+ // commands:
FIRSTKWD = 0x40,
AS = FIRSTKWD, ALIAS, ASSIGN,
CALL, CASE, CLOSE, COMPARE, _CONST_,
DECLARE, DIM, DO,
- // in der Reihenfolge der Datentyp-Enums!
+ // in the order of the data type enums!
DEFINT, DEFLNG, DEFSNG, DEFDBL, DEFCUR, DEFDATE, DEFSTR, DEFOBJ,
DEFERR, DEFBOOL, DEFVAR,
- // in der Reihenfolge der Datentyp-Enums!
+ // in the order of the data type enums!
DATATYPE1,
TINTEGER = DATATYPE1,
TLONG, TSINGLE, TDOUBLE, TCURRENCY, TDATE, TSTRING, TOBJECT,
@@ -79,29 +79,29 @@ enum SbiToken {
UNTIL,
WEND, WHILE, WITH, WRITE,
ENDENUM, ENDIF, ENDFUNC, ENDPROPERTY, ENDSUB, ENDTYPE, ENDSELECT, ENDWITH,
- // Ende aller Keywords
+ // end of all keywords
LASTKWD = ENDWITH,
- // Statement-Ende
+ // statement end
EOS, EOLN,
- // Operatoren:
+ // operators:
EXPON, NEG, MUL,
DIV, IDIV, MOD, PLUS, MINUS,
EQ, NE, LT, GT, LE, GE,
NOT, AND, OR, XOR, EQV,
IMP, CAT, LIKE, IS, TYPEOF,
- // Sonstiges:
+ // miscellaneous:
FIRSTEXTRA,
NUMBER=FIRSTEXTRA, FIXSTRING, SYMBOL, _CDECL_, BYVAL, BYREF,
OUTPUT, RANDOM, APPEND, BINARY, ACCESS,
LOCK, READ, PRESERVE, BASE, ANY, LIB, _OPTIONAL_,
EXPLICIT, COMPATIBLE, CLASSMODULE, PARAMARRAY, WITHEVENTS,
- // Ab hier kommen JavaScript-Tokens (gleiches enum, damit gleicher Typ)
+ // from here there are JavaScript-tokens (same enum so that same type)
FIRSTJAVA,
JS_BREAK=FIRSTJAVA, JS_CONTINUE, JS_FOR, JS_FUNCTION, JS_IF, JS_NEW,
JS_RETURN, JS_THIS, JS_VAR, JS_WHILE, JS_WITH,
- // JavaScript-Operatoren
+ // JavaScript-operators
// _ASS_ = Assignment
JS_COMMA, JS_ASSIGNMENT, JS_ASS_PLUS, JS_ASS_MINUS, JS_ASS_MUL,
JS_ASS_DIV, JS_ASS_MOD, JS_ASS_LSHIFT, JS_ASS_RSHIFT, JS_ASS_RSHIFT_Z,
@@ -139,13 +139,13 @@ class SbiTokenizer : public SbiScanner {
TokenLabelInfo m_aTokenLabelInfo;
protected:
- SbiToken eCurTok; // aktuelles Token
- SbiToken ePush; // Pushback-Token
- sal_uInt16 nPLine, nPCol1, nPCol2; // Pushback-Location
- sal_Bool bEof; // sal_True bei Dateiende
- sal_Bool bEos; // sal_True bei Statement-Ende
- sal_Bool bKeywords; // sal_True, falls Keywords geparst werden
- sal_Bool bAs; // letztes Keyword war AS
+ SbiToken eCurTok;
+ SbiToken ePush;
+ sal_uInt16 nPLine, nPCol1, nPCol2; // pushback location
+ sal_Bool bEof;
+ sal_Bool bEos;
+ sal_Bool bKeywords; // sal_True, if keywords are parsed
+ sal_Bool bAs; // last keyword was AS
sal_Bool bErrorIsSymbol; // Handle Error token as Symbol, not keyword
public:
SbiTokenizer( const ::rtl::OUString&, StarBASIC* = NULL );
@@ -154,14 +154,14 @@ public:
inline sal_Bool IsEof() { return bEof; }
inline sal_Bool IsEos() { return bEos; }
- void Push( SbiToken ); // Pushback eines Tokens
- const String& Symbol( SbiToken );// Rueckumwandlung
+ void Push( SbiToken );
+ const String& Symbol( SbiToken ); // reconversion
- SbiToken Peek(); // das naechste Token lesen
- SbiToken Next(); // Ein Token lesen
- sal_Bool MayBeLabel( sal_Bool= sal_False ); // Kann es ein Label sein?
+ SbiToken Peek(); // read the next token
+ SbiToken Next(); // read a token
+ sal_Bool MayBeLabel( sal_Bool= sal_False );
- void Hilite( SbTextPortions& ); // Syntax-Highlighting
+ void Hilite( SbTextPortions& );
void Error( SbError c ) { GenError( c ); }
void Error( SbError, SbiToken );
diff --git a/basic/source/runtime/basrdll.cxx b/basic/source/runtime/basrdll.cxx
index 1f05688..cd3c24f 100644
--- a/basic/source/runtime/basrdll.cxx
+++ b/basic/source/runtime/basrdll.cxx
@@ -79,8 +79,8 @@ void BasicDLL::SetDebugMode( sal_Bool bDebugMode )
void BasicDLL::BasicBreak()
{
- //bJustStopping: Wenn jemand wie wild x-mal STOP drueckt, aber das Basic
- // nicht schnell genug anhaelt, kommt die Box ggf. oefters...
+ // bJustStopping: if there's someone pressing STOP like crazy umpteen times,
+ // but the Basic doesn't stop early enough, the box might appear more often...
static sal_Bool bJustStopping = sal_False;
BasicDLL* pThis = *(BasicDLL**)GetAppData(SHL_BASIC);
diff --git a/basic/source/runtime/inputbox.cxx b/basic/source/runtime/inputbox.cxx
index c14afa0..86a7578 100644
--- a/basic/source/runtime/inputbox.cxx
+++ b/basic/source/runtime/inputbox.cxx
@@ -167,7 +167,7 @@ RTLFUNC(InputBox)
{
String aTitle;
String aDefault;
- sal_Int32 nX = -1, nY = -1; // zentrieren
+ sal_Int32 nX = -1, nY = -1; // center
const String& rPrompt = rPar.Get(1)->GetString();
if ( nArgCount > 2 && !rPar.Get(2)->IsErr() )
aTitle = rPar.Get(2)->GetString();
diff --git a/basic/source/runtime/iosys.cxx b/basic/source/runtime/iosys.cxx
index 7765490..7f4274c 100644
--- a/basic/source/runtime/iosys.cxx
+++ b/basic/source/runtime/iosys.cxx
@@ -73,7 +73,7 @@ using namespace com::sun::star::bridge;
#include "iosys.hxx"
#include "sbintern.hxx"
-// Der Input-Dialog:
+
class SbiInputDialog : public ModalDialog {
Edit aInput;
@@ -145,7 +145,7 @@ SbiStream::~SbiStream()
delete pStrm;
}
-// Ummappen eines SvStream-Fehlers auf einen StarBASIC-Code
+// map an SvStream-error to StarBASIC-code
void SbiStream::MapError()
{
@@ -560,7 +560,7 @@ void UCBStream::SetSize( sal_uIntPtr nSize )
SetError( ERRCODE_IO_GENERAL );
}
-// Oeffnen eines Streams
+
SbError SbiStream::Open
( short nCh, const ByteString& rName, short nStrmMode, short nFlags, short nL )
{
@@ -706,8 +706,8 @@ SbError SbiStream::Write( const ByteString& rBuf, sal_uInt16 n )
if( IsText() )
{
aLine += rBuf;
- // Raus damit, wenn das Ende ein LF ist, aber CRLF vorher
- // strippen, da der SvStrm ein CRLF anfuegt!
+ // Get it out, if the end is an LF, but strip CRLF before,
+ // because the SvStrm adds a CRLF!
sal_uInt16 nLineLen = aLine.Len();
if( nLineLen && aLine.GetBuffer()[ --nLineLen ] == 0x0A )
{
@@ -730,7 +730,6 @@ SbError SbiStream::Write( const ByteString& rBuf, sal_uInt16 n )
}
-// Zugriff auf das aktuelle I/O-System:
SbiIoSystem* SbGetIoSystem()
{
@@ -776,7 +775,6 @@ void SbiIoSystem::Open
nChan = 0;
}
-// Aktuellen Kanal schliessen
void SbiIoSystem::Close()
{
@@ -793,7 +791,6 @@ void SbiIoSystem::Close()
nChan = 0;
}
-// Shutdown nach Programmlauf
void SbiIoSystem::Shutdown()
{
@@ -809,7 +806,7 @@ void SbiIoSystem::Shutdown()
}
}
nChan = 0;
- // Noch was zu PRINTen?
+ // anything left to PRINT?
if( aOut.Len() )
{
String aOutStr( aOut, gsl_getSystemTextEncoding() );
@@ -823,7 +820,6 @@ void SbiIoSystem::Shutdown()
aOut.Erase();
}
-// Aus aktuellem Kanal lesen
void SbiIoSystem::Read( ByteString& rBuf, short n )
{
@@ -907,7 +903,6 @@ void SbiIoSystem::CloseAll(void)
*
***************************************************************************/
-// Einlesen einer Zeile von der Console
void SbiIoSystem::ReadCon( ByteString& rIn )
{
@@ -920,7 +915,7 @@ void SbiIoSystem::ReadCon( ByteString& rIn )
aPrompt.Erase();
}
-// Ausgabe einer MessageBox, wenn im Console-Puffer ein CR ist
+// output of a MessageBox, if theres a CR in the console-buffer
void SbiIoSystem::WriteCon( const ByteString& rText )
{
diff --git a/basic/source/runtime/methods.cxx b/basic/source/runtime/methods.cxx
index 562b289..ad795d0 100644
--- a/basic/source/runtime/methods.cxx
+++ b/basic/source/runtime/methods.cxx
@@ -141,7 +141,7 @@ static long GetDayDiff( const Date& rDate )
}
else
nDiffDays = (long)(rDate - aRefDate);
- nDiffDays += 2; // Anpassung VisualBasic: 1.Jan.1900 == 2
+ nDiffDays += 2; // adjustment VisualBasic: 1.Jan.1900 == 2
return nDiffDays;
}
@@ -202,9 +202,8 @@ static com::sun::star::uno::Reference< XSimpleFileAccess3 > getFileAccess( void
-// Properties und Methoden legen beim Get (bPut = sal_False) den Returnwert
-// im Element 0 des Argv ab; beim Put (bPut = sal_True) wird der Wert aus
-// Element 0 gespeichert.
+// Properties and methods lie down the return value at the Get (bPut = sal_False) in the
+// element 0 of the Argv; the value of element 0 is saved at Put (bPut = sal_True)
// CreateObject( class )
@@ -218,7 +217,7 @@ RTLFUNC(CreateObject)
StarBASIC::Error( SbERR_CANNOT_LOAD );
else
{
- // Convenience: BASIC als Parent eintragen
+ // Convenience: enter BASIC as parent
p->SetParent( pBasic );
rPar.Get( 0 )->PutObject( p );
}
@@ -291,7 +290,6 @@ RTLFUNC(Sin)
}
}
-// Cosinus
RTLFUNC(Cos)
{
@@ -307,7 +305,6 @@ RTLFUNC(Cos)
}
}
-// Atn
RTLFUNC(Atn)
{
@@ -417,10 +414,10 @@ RTLFUNC(CurDir)
(void)pBasic;
(void)bWrite;
- // #57064 Obwohl diese Funktion nicht mit DirEntry arbeitet, ist sie von
- // der Anpassung an virtuelle URLs nich betroffen, da bei Nutzung der
- // DirEntry-Funktionalitaet keine Moeglichkeit besteht, das aktuelle so
- // zu ermitteln, dass eine virtuelle URL geliefert werden koennte.
+ // #57064 Although this function doesn't work with DirEntry, it isn't touched
+ // by the adjustment to virtual URLs, as, using the DirEntry-functionality,
+ // there's no possibility to detect the current one in a way that a virtual URL
+ // could be delivered.
#if defined (WNT)
int nCurDir = 0; // Current dir // JSM
@@ -1208,10 +1205,10 @@ RTLFUNC(Mid)
StarBASIC::Error( SbERR_BAD_ARGUMENT );
else
{
- // #23178: Funktionalitaet von Mid$ als Anweisung nachbilden, indem
- // als weiterer (4.) Parameter ein Ersetzungsstring aufgenommen wird.
- // Anders als im Original kann in dieser Variante der 3. Parameter
- // nLength nicht weggelassen werden. Ist ueber bWrite schon vorgesehen.
+ // #23178: replicate the functionality of Mid$ as a command
+ // by adding a replacement-string as a fourth parameter.
+ // In contrast to the original the third parameter (nLength)
+ // can't be left out here. That's considered in bWrite already.
if( nArgCount == 4 )
bWrite = sal_True;
@@ -1527,7 +1524,7 @@ RTLFUNC(Str)
// Numbers start with a space
if( pArg->IsNumericRTL() )
{
- // Kommas durch Punkte ersetzen, damit es symmetrisch zu Val ist!
+ // replace commas by points so that it's symmetric to Val!
aStr.SearchAndReplace( ',', '.' );
SbiInstance* pInst = pINST;
@@ -1712,7 +1709,7 @@ RTLFUNC(Val)
}
else
{
- // #57844 Lokalisierte Funktion benutzen
+ // #57844 use localized function
nResult = ::rtl::math::stringToDouble( aStr, '.', ',', NULL, NULL );
checkArithmeticOverflow( nResult );
}
@@ -1725,7 +1722,7 @@ RTLFUNC(Val)
// Helper functions for date conversion
sal_Int16 implGetDateDay( double aDate )
{
- aDate -= 2.0; // normieren: 1.1.1900 => 0.0
+ aDate -= 2.0; // standardize: 1.1.1900 => 0.0
Date aRefDate( 1, 1, 1900 );
if ( aDate >= 0.0 )
{
@@ -1746,7 +1743,7 @@ sal_Int16 implGetDateMonth( double aDate )
{
Date aRefDate( 1,1,1900 );
long nDays = (long)aDate;
- nDays -= 2; // normieren: 1.1.1900 => 0.0
+ nDays -= 2; // standardize: 1.1.1900 => 0.0
aRefDate += nDays;
sal_Int16 nRet = (sal_Int16)( aRefDate.GetMonth() );
return nRet;
@@ -1756,7 +1753,7 @@ sal_Int16 implGetDateYear( double aDate )
{
Date aRefDate( 1,1,1900 );
long nDays = (long) aDate;
- nDays -= 2; // normieren: 1.1.1900 => 0.0
+ nDays -= 2; // standardize: 1.1.1900 => 0.0
aRefDate += nDays;
sal_Int16 nRet = (sal_Int16)( aRefDate.GetYear() );
return nRet;
@@ -1893,7 +1890,7 @@ RTLFUNC(TimeSerial)
}
sal_Int16 nHour = rPar.Get(1)->GetInteger();
if ( nHour == 24 )
- nHour = 0; // Wegen UNO DateTimes, die bis 24 Uhr gehen
+ nHour = 0; // because of UNO DateTimes, which go till 24 o'clock
sal_Int16 nMinute = rPar.Get(2)->GetInteger();
sal_Int16 nSecond = rPar.Get(3)->GetInteger();
if ((nHour < 0 || nHour > 23) ||
@@ -1921,7 +1918,7 @@ RTLFUNC(DateValue)
StarBASIC::Error( SbERR_BAD_ARGUMENT );
else
{
- // #39629 pINST pruefen, kann aus URL-Zeile gerufen werden
+ // #39629 check pINST, can be called from the URL line
SvNumberFormatter* pFormatter = NULL;
if( pINST )
pFormatter = pINST->GetNumberFormatter();
@@ -1956,7 +1953,7 @@ RTLFUNC(DateValue)
{
if ( nType == NUMBERFORMAT_DATETIME )
{
- // Zeit abschneiden
+ // cut time
if ( fResult > 0.0 )
fResult = floor( fResult );
else
@@ -1967,7 +1964,7 @@ RTLFUNC(DateValue)
else
StarBASIC::Error( SbERR_CONVERSION );
- // #39629 pFormatter kann selbst angefordert sein
+ // #39629 pFormatter can be requested itself
if( !pINST )
delete pFormatter;
}
@@ -1982,13 +1979,12 @@ RTLFUNC(TimeValue)
StarBASIC::Error( SbERR_BAD_ARGUMENT );
else
{
- // #39629 pINST pruefen, kann aus URL-Zeile gerufen werden
SvNumberFormatter* pFormatter = NULL;
if( pINST )
pFormatter = pINST->GetNumberFormatter();
else
{
- sal_uInt32 n; // Dummy
+ sal_uInt32 n;
SbiInstance::PrepareNumberFormatter( pFormatter, n, n, n );
}
@@ -2000,14 +1996,13 @@ RTLFUNC(TimeValue)
if(bSuccess && (nType==NUMBERFORMAT_TIME||nType==NUMBERFORMAT_DATETIME))
{
if ( nType == NUMBERFORMAT_DATETIME )
- // Tage abschneiden
+ // cut days
fResult = fmod( fResult, 1 );
rPar.Get(0)->PutDate( fResult );
}
else
StarBASIC::Error( SbERR_CONVERSION );
- // #39629 pFormatter kann selbst angefordert sein
if( !pINST )
delete pFormatter;
}
@@ -2194,7 +2189,6 @@ RTLFUNC(Time)
double nDays = (double)nSeconds * ( 1.0 / (24.0*3600.0) );
Color* pCol;
- // #39629 pINST pruefen, kann aus URL-Zeile gerufen werden
SvNumberFormatter* pFormatter = NULL;
sal_uInt32 nIndex;
if( pINST )
@@ -2210,7 +2204,6 @@ RTLFUNC(Time)
pFormatter->GetOutputString( nDays, nIndex, aRes, &pCol );
- // #39629 pFormatter kann selbst angefordert sein
if( !pINST )
delete pFormatter;
}
@@ -2251,7 +2244,6 @@ RTLFUNC(Date)
String aRes;
Color* pCol;
- // #39629 pINST pruefen, kann aus URL-Zeile gerufen werden
SvNumberFormatter* pFormatter = NULL;
sal_uInt32 nIndex;
if( pINST )
@@ -2261,14 +2253,13 @@ RTLFUNC(Date)
}
else
{
- sal_uInt32 n; // Dummy
+ sal_uInt32 n;
SbiInstance::PrepareNumberFormatter( pFormatter, nIndex, n, n );
}
pFormatter->GetOutputString( nDays, nIndex, aRes, &pCol );
pMeth->PutString( aRes );
- // #39629 pFormatter kann selbst angefordert sein
if( !pINST )
delete pFormatter;
}
@@ -2330,7 +2321,7 @@ RTLFUNC(IsDate)
StarBASIC::Error( SbERR_BAD_ARGUMENT );
else
{
- // #46134 Nur String wird konvertiert, andere Typen ergeben sal_False
+ // #46134 only string is converted, all other types result in sal_False
SbxVariableRef xArg = rPar.Get( 1 );
SbxDataType eType = xArg->GetType();
sal_Bool bDate = sal_False;
@@ -2341,17 +2332,14 @@ RTLFUNC(IsDate)
}
else if( eType == SbxSTRING )
{
- // Error loeschen
SbxError nPrevError = SbxBase::GetError();
SbxBase::ResetError();
- // Konvertierung des Parameters nach SbxDATE erzwingen
+ // force conversion of the parameter to SbxDATE
xArg->SbxValue::GetDate();
- // Bei Fehler ist es kein Date
bDate = !SbxBase::IsError();
- // Error-Situation wiederherstellen
SbxBase::ResetError();
SbxBase::SetError( nPrevError );
}
@@ -2416,8 +2404,8 @@ RTLFUNC(IsNull)
StarBASIC::Error( SbERR_BAD_ARGUMENT );
else
{
- // #51475 Wegen Uno-Objekten auch true liefern,
- // wenn der pObj-Wert NULL ist
+ // #51475 because of Uno-objects return true
+ // even if the pObj value is NULL
SbxVariableRef pArg = rPar.Get( 1 );
sal_Bool bNull = rPar.Get(1)->IsNull();
if( !bNull && pArg->GetType() == SbxOBJECT )
@@ -2441,7 +2429,7 @@ RTLFUNC(IsNumeric)
rPar.Get( 0 )->PutBool( rPar.Get( 1 )->IsNumericRTL() );
}
-// Das machen wir auf die billige Tour
+
RTLFUNC(IsMissing)
{
@@ -2451,7 +2439,7 @@ RTLFUNC(IsMissing)
if ( rPar.Count() < 2 )
StarBASIC::Error( SbERR_BAD_ARGUMENT );
else
- // #57915 Missing wird durch Error angezeigt
+ // #57915 Missing is reported by an error
rPar.Get( 0 )->PutBool( rPar.Get(1)->IsErr() );
}
@@ -2573,8 +2561,8 @@ RTLFUNC(Dir)
{
SbiRTLData* pRTLData = pINST->GetRTLData();
- // #34645: Kann auch von der URL-Zeile ueber 'macro: Dir' aufgerufen werden
- // dann existiert kein pRTLData und die Methode muss verlassen werden
+ // #34645: can also be called from the URL line via 'macro: Dir'
+ // there's no pRTLDate existing in that case and the method must be left
if( !pRTLData )
return;
@@ -2837,7 +2825,7 @@ RTLFUNC(GetAttr)
DirEntry aEntry( rPar.Get(1)->GetString() );
aEntry.ToAbs();
- // #57064 Bei virtuellen URLs den Real-Path extrahieren
+ // #57064 extract the real-path for virtual URLs
ByteString aByteStrFullPath( aEntry.GetFull(), gsl_getSystemTextEncoding() );
DWORD nRealFlags = GetFileAttributes (aByteStrFullPath.GetBuffer());
if (nRealFlags != 0xffffffff)
@@ -2964,7 +2952,6 @@ RTLFUNC(FileDateTime)
Color* pCol;
- // #39629 pINST pruefen, kann aus URL-Zeile gerufen werden
SvNumberFormatter* pFormatter = NULL;
sal_uInt32 nIndex;
if( pINST )
@@ -2974,7 +2961,7 @@ RTLFUNC(FileDateTime)
}
else
{
- sal_uInt32 n; // Dummy
+ sal_uInt32 n;
SbiInstance::PrepareNumberFormatter( pFormatter, n, n, nIndex );
}
@@ -2982,7 +2969,6 @@ RTLFUNC(FileDateTime)
pFormatter->GetOutputString( fSerial, nIndex, aRes, &pCol );
rPar.Get(0)->PutString( aRes );
- // #39629 pFormatter kann selbst angefordert sein
if( !pINST )
delete pFormatter;
}
@@ -3012,13 +2998,13 @@ RTLFUNC(EOF)
if ( pSbStrm->IsText() )
{
char cBla;
- (*pSvStrm) >> cBla; // koennen wir noch ein Zeichen lesen
+ (*pSvStrm) >> cBla; // can we read another character?
bIsEof = pSvStrm->IsEof();
if ( !bIsEof )
pSvStrm->SeekRel( -1 );
}
else
- bIsEof = pSvStrm->IsEof(); // fuer binaerdateien!
+ bIsEof = pSvStrm->IsEof(); // for binary data!
rPar.Get(0)->PutBool( bIsEof );
}
}
@@ -3029,9 +3015,9 @@ RTLFUNC(FileAttr)
(void)bWrite;
// No changes for UCB
- // #57064 Obwohl diese Funktion nicht mit DirEntry arbeitet, ist sie von
- // der Anpassung an virtuelle URLs nich betroffen, da sie nur auf bereits
- // geoeffneten Dateien arbeitet und der Name hier keine Rolle spielt.
+ // #57064 Although this function doesn't operate with DirEntry, it is
+ // not touched by the adjustment to virtual URLs, as it only works on
+ // already opened files and the name doesn't matter there.
if ( rPar.Count() != 3 )
StarBASIC::Error( SbERR_BAD_ARGUMENT );
@@ -3078,7 +3064,7 @@ RTLFUNC(Loc)
{
short nBlockLen = pSbStrm->GetBlockLen();
nPos = nBlockLen ? (pSvStrm->Tell() / nBlockLen) : 0;
- nPos++; // Blockpositionen beginnen bei 1
+ nPos++; // block positions starting at 1
}
else if ( pSbStrm->IsText() )
nPos = pSbStrm->GetLine();
@@ -3146,7 +3132,7 @@ RTLFUNC(Seek)
sal_uIntPtr nPos = pStrm->Tell();
if( pSbStrm->IsRandom() )
nPos = nPos / pSbStrm->GetBlockLen();
- nPos++; // Basic zaehlt ab 1
+ nPos++; // Basic counts from 1
rPar.Get(0)->PutLong( (sal_Int32)nPos );
}
else // Seek-Statement
@@ -3157,7 +3143,7 @@ RTLFUNC(Seek)
StarBASIC::Error( SbERR_BAD_ARGUMENT );
return;
}
- nPos--; // Basic zaehlt ab 1, SvStreams zaehlen ab 0
+ nPos--; // Basic counts from 1, SvStreams count from 0
pSbStrm->SetExpandOnWriteTo( 0 );
if ( pSbStrm->IsRandom() )
nPos *= pSbStrm->GetBlockLen();
@@ -3251,7 +3237,7 @@ RTLFUNC(Shell)
oslProcessOption nOptions = osl_Process_SEARCHPATH | osl_Process_DETACHED;
String aCmdLine = rPar.Get(1)->GetString();
- // Zusaetzliche Parameter anhaengen, es muss eh alles geparsed werden
+ // attach additional parameters - everything must be parsed anyway
if( nArgCount >= 4 )
{
aCmdLine.AppendAscii( " " );
@@ -3259,20 +3245,19 @@ RTLFUNC(Shell)
}
else if( !aCmdLine.Len() )
{
- // Spezial-Behandlung (leere Liste) vermeiden
+ // avaoid special treatment (empty list)
aCmdLine.AppendAscii( " " );
}
sal_uInt16 nLen = aCmdLine.Len();
- // #55735 Wenn Parameter dabei sind, muessen die abgetrennt werden
- // #72471 Auch die einzelnen Parameter trennen
+ // #55735 if there are parameters, they have to be seperated
+ // #72471 also seperate the single parameters
std::list<String> aTokenList;
String aToken;
sal_uInt16 i = 0;
sal_Unicode c;
while( i < nLen )
{
- // Spaces weg
for ( ;; ++i )
{
c = aCmdLine.GetBuffer()[ i ];
@@ -3284,7 +3269,6 @@ RTLFUNC(Shell)
{
sal_uInt16 iFoundPos = aCmdLine.Search( c, i + 1 );
- // Wenn nichts gefunden wurde, Rest kopieren
if( iFoundPos == STRING_NOTFOUND )
{
aToken = aCmdLine.Copy( i, STRING_LEN );
@@ -3302,7 +3286,6 @@ RTLFUNC(Shell)
sal_uInt16 iFoundTabPos = aCmdLine.Search( '\t', i );
sal_uInt16 iFoundPos = Min( iFoundSpacePos, iFoundTabPos );
- // Wenn nichts gefunden wurde, Rest kopieren
if( iFoundPos == STRING_NOTFOUND )
{
aToken = aCmdLine.Copy( i, STRING_LEN );
@@ -3315,10 +3298,10 @@ RTLFUNC(Shell)
}
}
- // In die Liste uebernehmen
+ // insert into the list
aTokenList.push_back( aToken );
}
- // #55735 / #72471 Ende
+ // #55735 / #72471 end
sal_Int16 nWinStyle = 0;
if( nArgCount >= 3 )
@@ -3344,7 +3327,7 @@ RTLFUNC(Shell)
nOptions |= osl_Process_WAIT;
}
- // #72471 Parameter aufbereiten
+ // #72471 work parameter(s) up
std::list<String>::const_iterator iter = aTokenList.begin();
const String& rStr = *iter;
::rtl::OUString aOUStrProg( rStr.GetBuffer(), rStr.Len() );
@@ -4031,7 +4014,7 @@ RTLFUNC(Load)
return;
}
- // Diesen Call einfach an das Object weiterreichen
+
SbxBase* pObj = (SbxObject*)rPar.Get(1)->GetObject();
if ( pObj )
{
@@ -4061,7 +4044,7 @@ RTLFUNC(Unload)
return;
}
- // Diesen Call einfach an das Object weitereichen
+
SbxBase* pObj = (SbxObject*)rPar.Get(1)->GetObject();
if ( pObj )
{
@@ -4172,7 +4155,7 @@ RTLFUNC(MsgBox)
if( nArgCount >= 3 )
nType = (WinBits)rPar.Get(2)->GetInteger();
WinBits nStyle = nType;
- nStyle &= 15; // Bits 4-16 loeschen
+ nStyle &= 15; // delete bits 4-16
if( nStyle > 5 )
nStyle = 0;
diff --git a/basic/source/runtime/methods1.cxx b/basic/source/runtime/methods1.cxx
index 20191cb..f54ff7b 100644
--- a/basic/source/runtime/methods1.cxx
+++ b/basic/source/runtime/methods1.cxx
@@ -331,7 +331,7 @@ RTLFUNC(CDbl) // JSM
SbxVariable *pSbxVariable = rPar.Get(1);
if( pSbxVariable->GetType() == SbxSTRING )
{
- // AB #41690 , String holen
+ // #41690
String aScanStr = pSbxVariable->GetString();
SbError Error = SbxValue::ScanNumIntnl( aScanStr, nVal );
if( Error != SbxERR_OK )
@@ -393,7 +393,7 @@ RTLFUNC(CSng) // JSM
SbxVariable *pSbxVariable = rPar.Get(1);
if( pSbxVariable->GetType() == SbxSTRING )
{
- // AB #41690 , String holen
+ // #41690
double dVal = 0.0;
String aScanStr = pSbxVariable->GetString();
SbError Error = SbxValue::ScanNumIntnl( aScanStr, dVal, /*bSingle=*/sal_True );
@@ -566,7 +566,7 @@ RTLFUNC(Switch)
sal_uInt16 nCount = rPar.Count();
if( !(nCount & 0x0001 ))
- // Anzahl der Argumente muss ungerade sein
+ // number of arguments must be odd
StarBASIC::Error( SbERR_BAD_ARGUMENT );
sal_uInt16 nCurExpr = 1;
while( nCurExpr < (nCount-1) )
@@ -764,7 +764,7 @@ RTLFUNC(Array)
SbxDimArray* pArray = new SbxDimArray( SbxVARIANT );
sal_uInt16 nArraySize = rPar.Count() - 1;
- // Option Base zunaechst ignorieren (kennt leider nur der Compiler)
+ // ignore Option Base so far (unfortunately only known by the compiler)
bool bIncIndex = (IsBaseIndexOne() && SbiRuntime::isVBAEnabled() );
if( nArraySize )
{
@@ -778,7 +778,7 @@ RTLFUNC(Array)
pArray->unoAddDim( 0, -1 );
}
- // Parameter ins Array uebernehmen
+ // insert parameters into the array
// ATTENTION: Using type sal_uInt16 for loop variable is
// mandatory to workaround a problem with the
// Solaris Intel compiler optimizer! See i104354
@@ -793,7 +793,7 @@ RTLFUNC(Array)
pArray->Put( pNew, &index );
}
- // Array zurueckliefern
+ // return array
SbxVariableRef refVar = rPar.Get(0);
sal_uInt16 nFlags = refVar->GetFlags();
refVar->ResetFlag( SBX_FIXED );
@@ -803,13 +803,13 @@ RTLFUNC(Array)
}
-// Featurewunsch #57868
-// Die Funktion liefert ein Variant-Array, wenn keine Parameter angegeben
-// werden, wird ein leeres Array erzeugt (entsprechend dim a(), entspricht
-// einer Sequence der Laenge 0 in Uno).
-// Wenn Parameter angegeben sind, wird fuer jeden eine Dimension erzeugt
-// DimArray( 2, 2, 4 ) entspricht DIM a( 2, 2, 4 )
-// Das Array ist immer vom Typ Variant
+// Featurewish #57868
+// The function returns a variant-array; if there are no parameters passed,
+// an empty array is created (according to dim a(); equal to a sequence of
+// the length 0 in Uno).
+// If there are parameters passed, there's a dimension created for each of
+// them; DimArray( 2, 2, 4 ) is equal to DIM a( 2, 2, 4 )
+// the array is always of the type variant
RTLFUNC(DimArray)
{
(void)pBasic;
@@ -833,7 +833,6 @@ RTLFUNC(DimArray)
else
pArray->unoAddDim( 0, -1 );
- // Array zurueckliefern
SbxVariableRef refVar = rPar.Get(0);
sal_uInt16 nFlags = refVar->GetFlags();
refVar->ResetFlag( SBX_FIXED );
@@ -843,14 +842,14 @@ RTLFUNC(DimArray)
}
/*
- * FindObject und FindPropertyObject ermoeglichen es,
- * Objekte und Properties vom Typ Objekt zur Laufzeit
- * ueber ihren Namen als String-Parameter anzusprechen.
+ * FindObject and FindPropertyObject make it possible to
+ * address objects and properties of the type Object with
+ * their name as string-pararmeters at the runtime.
*
- * Bsp.:
+ * Example:
* MyObj.Prop1.Bla = 5
*
- * entspricht:
+ * is equal to:
* dim ObjVar as Object
* dim ObjProp as Object
* ObjName$ = "MyObj"
@@ -859,56 +858,49 @@ RTLFUNC(DimArray)
* ObjProp = FindPropertyObject( ObjVar, PropName$ )
* ObjProp.Bla = 5
*
- * Dabei koennen die Namen zur Laufzeit dynamisch
- * erzeugt werden und, so dass z.B. ueber Controls
- * "TextEdit1" bis "TextEdit5" in einem Dialog in
- * einer Schleife iteriert werden kann.
+ * The names can be created dynamically at the runtime
+ * so that e. g. via controls "TextEdit1" to "TextEdit5"
+ * can be iterated in a dialog in a loop.
*/
-// Objekt ueber den Namen ansprechen
-// 1. Parameter = Name des Objekts als String
+
+// 1st parameter = the object's name as string
RTLFUNC(FindObject)
{
(void)pBasic;
(void)bWrite;
- // Wir brauchen einen Parameter
if ( rPar.Count() < 2 )
{
StarBASIC::Error( SbERR_BAD_ARGUMENT );
return;
}
- // 1. Parameter ist der Name
String aNameStr = rPar.Get(1)->GetString();
- // Basic-Suchfunktion benutzen
SbxBase* pFind = StarBASIC::FindSBXInCurrentScope( aNameStr );
SbxObject* pFindObj = NULL;
if( pFind )
pFindObj = PTR_CAST(SbxObject,pFind);
- // Objekt zurueckliefern
SbxVariableRef refVar = rPar.Get(0);
refVar->PutObject( pFindObj );
}
-// Objekt-Property in einem Objekt ansprechen
-// 1. Parameter = Objekt
-// 2. Parameter = Name der Property als String
+// address object-property in an object
+// 1st parameter = object
+// 2nd parameter = the property's name as string
RTLFUNC(FindPropertyObject)
{
(void)pBasic;
(void)bWrite;
- // Wir brauchen 2 Parameter
if ( rPar.Count() < 3 )
{
StarBASIC::Error( SbERR_BAD_ARGUMENT );
return;
}
- // 1. Parameter holen, muss Objekt sein
SbxBase* pObjVar = (SbxObject*)rPar.Get(1)->GetObject();
SbxObject* pObj = NULL;
if( pObjVar )
@@ -919,21 +911,18 @@ RTLFUNC(FindPropertyObject)
pObj = PTR_CAST(SbxObject,pObjVarObj);
}
- // 2. Parameter ist der Name
String aNameStr = rPar.Get(2)->GetString();
- // Jetzt muss ein Objekt da sein, sonst Error
SbxObject* pFindObj = NULL;
if( pObj )
{
- // Im Objekt nach Objekt suchen
SbxVariable* pFindVar = pObj->Find( aNameStr, SbxCLASS_OBJECT );
pFindObj = PTR_CAST(SbxObject,pFindVar);
}
else
StarBASIC::Error( SbERR_BAD_PARAMETER );
- // Objekt zurueckliefern
+
SbxVariableRef refVar = rPar.Get(0);
refVar->PutObject( pFindObj );
}
@@ -1008,7 +997,7 @@ sal_Bool lcl_WriteSbxVariable( const SbxVariable& rVar, SvStream* pStrm,
}
else
{
- // ohne Laengenangabe! ohne Endekennung!
+ // without any length information! without end-identifier!
// What does that mean for Unicode?! Choosing conversion to ByteString...
ByteString aByteStr( rStr, gsl_getSystemTextEncoding() );
*pStrm << (const char*)aByteStr.GetBuffer();
@@ -1166,7 +1155,6 @@ sal_Bool lcl_WriteReadSbxArray( SbxDimArray& rArr, SvStream* pStrm,
void PutGet( SbxArray& rPar, sal_Bool bPut )
{
- // Wir brauchen 3 Parameter
if ( rPar.Count() != 4 )
{
StarBASIC::Error( SbERR_BAD_ARGUMENT );
@@ -1182,10 +1170,10 @@ void PutGet( SbxArray& rPar, sal_Bool bPut )
StarBASIC::Error( SbERR_BAD_ARGUMENT );
return;
}
- nRecordNo--; // wir moegen's ab 0!
+ nRecordNo--;
SbiIoSystem* pIO = pINST->GetIoSystem();
SbiStream* pSbStrm = pIO->GetStream( nFileNo );
- // das File muss Random (feste Record-Laenge) oder Binary sein
+
if ( !pSbStrm || !(pSbStrm->GetMode() & (SBSTRM_BINARY | SBSTRM_RANDOM)) )
{
StarBASIC::Error( SbERR_BAD_CHANNEL );
@@ -1198,11 +1186,9 @@ void PutGet( SbxArray& rPar, sal_Bool bPut )
if( bPut )
{
- // Datei aufplustern, falls jemand uebers Dateiende hinaus geseekt hat
pSbStrm->ExpandFile();
}
- // auf die Startposition seeken
if( bHasRecordNo )
{
sal_uIntPtr nFilePos = bRandom ? (sal_uIntPtr)(nBlockLen*nRecordNo) : (sal_uIntPtr)nRecordNo;
@@ -1267,7 +1253,7 @@ RTLFUNC(Environ)
return;
}
String aResult;
- // sollte ANSI sein, aber unter Win16 in DLL nicht moeglich
+ // should be ANSI but that's not possible under Win16 in the DLL
ByteString aByteStr( rPar.Get(1)->GetString(), gsl_getSystemTextEncoding() );
const char* pEnvStr = getenv( aByteStr.GetBuffer() );
if ( pEnvStr )
@@ -1461,8 +1447,7 @@ RTLFUNC(TypeLen)
}
-// Uno-Struct eines beliebigen Typs erzeugen
-// 1. Parameter == Klassename, weitere Parameter zur Initialisierung
+// 1st parameter == class name, other parameters for initialisation
RTLFUNC(CreateUnoStruct)
{
(void)pBasic;
@@ -1471,8 +1456,8 @@ RTLFUNC(CreateUnoStruct)
RTL_Impl_CreateUnoStruct( pBasic, rPar, bWrite );
}
-// Uno-Service erzeugen
-// 1. Parameter == Service-Name
+
+// 1st parameter == service-name
RTLFUNC(CreateUnoService)
{
(void)pBasic;
@@ -1499,7 +1484,7 @@ RTLFUNC(CreateUnoValue)
}
-// ServiceManager liefern (keine Parameter)
+// no parameters
RTLFUNC(GetProcessServiceManager)
{
(void)pBasic;
@@ -1508,8 +1493,8 @@ RTLFUNC(GetProcessServiceManager)
RTL_Impl_GetProcessServiceManager( pBasic, rPar, bWrite );
}
-// PropertySet erzeugen
-// 1. Parameter == Sequence<PropertyValue>
+
+// 1st parameter == Sequence<PropertyValue>
RTLFUNC(CreatePropertySet)
{
(void)pBasic;
@@ -1518,8 +1503,8 @@ RTLFUNC(CreatePropertySet)
RTL_Impl_CreatePropertySet( pBasic, rPar, bWrite );
}
-// Abfragen, ob ein Interface unterstuetzt wird
-// Mehrere Interface-Namen als Parameter
+
+// multiple interface-names as parameters
RTLFUNC(HasUnoInterfaces)
{
(void)pBasic;
@@ -1528,7 +1513,7 @@ RTLFUNC(HasUnoInterfaces)
RTL_Impl_HasInterfaces( pBasic, rPar, bWrite );
}
-// Abfragen, ob ein Basic-Objekt ein Uno-Struct repraesentiert
+
RTLFUNC(IsUnoStruct)
{
(void)pBasic;
@@ -1537,7 +1522,7 @@ RTLFUNC(IsUnoStruct)
RTL_Impl_IsUnoStruct( pBasic, rPar, bWrite );
}
-// Abfragen, ob zwei Uno-Objekte identisch sind
+
RTLFUNC(EqualUnoObjects)
{
(void)pBasic;
@@ -1737,7 +1722,7 @@ RTLFUNC(Split)
SbxDimArray* pArray = new SbxDimArray( SbxVARIANT );
pArray->unoAddDim( 0, nArraySize-1 );
- // Parameter ins Array uebernehmen
+ // insert parameter(s) into the array
for( short i = 0 ; i < nArraySize ; i++ )
{
SbxVariableRef xVar = new SbxVariable( SbxVARIANT );
@@ -1745,7 +1730,7 @@ RTLFUNC(Split)
pArray->Put( (SbxVariable*)xVar, &i );
}
- // Array zurueckliefern
+ // return array
SbxVariableRef refVar = rPar.Get(0);
sal_uInt16 nFlags = refVar->GetFlags();
refVar->ResetFlag( SBX_FIXED );
@@ -1863,9 +1848,9 @@ sal_Int16 implGetWeekDay( double aDate, bool bFirstDayParam = false, sal_Int16 n
if ( aDay != SUNDAY )
nDay = (sal_Int16)aDay + 2;
else
- nDay = 1; // 1==Sonntag
+ nDay = 1; // 1 == Sunday
- // #117253 Optional 2. parameter "firstdayofweek"
+ // #117253 optional 2nd parameter "firstdayofweek"
if( bFirstDayParam )
{
if( nFirstDay < 0 || nFirstDay > 7 )
diff --git a/basic/source/runtime/props.cxx b/basic/source/runtime/props.cxx
index 1c67239..5610e20 100644
--- a/basic/source/runtime/props.cxx
+++ b/basic/source/runtime/props.cxx
@@ -36,9 +36,9 @@
#include "basegfx/numeric/ftools.hxx"
-// Properties und Methoden legen beim Get (bWrite = sal_False) den Returnwert
-// im Element 0 des Argv ab; beim Put (bWrite = sal_True) wird der Wert aus
-// Element 0 gespeichert.
+// Properties and methods lay the return value down at Get (bWrite = sal_False)
+// at the element 0 of the Argv; at Put (bWrite = sal_True) the value from
+// element 0 is stored.
RTLFUNC(Erl)
{
@@ -99,7 +99,7 @@ RTLFUNC(Null)
(void)pBasic;
(void)bWrite;
- // liefert eine leere Objekt-Variable.
+ // returns an empty object-variable
rPar.Get( 0 )->PutNull();
}
diff --git a/basic/source/runtime/runtime.cxx b/basic/source/runtime/runtime.cxx
index b7bcfe3..170e1ed 100644
--- a/basic/source/runtime/runtime.cxx
+++ b/basic/source/runtime/runtime.cxx
@@ -87,7 +87,7 @@ struct SbiArgvStack { // Argv stack:
short nArgc; // Argc
};
-SbiRuntime::pStep0 SbiRuntime::aStep0[] = { // Alle Opcodes ohne Operanden
+SbiRuntime::pStep0 SbiRuntime::aStep0[] = { // all opcodes without operands
&SbiRuntime::StepNOP,
&SbiRuntime::StepEXP,
&SbiRuntime::StepMUL,
@@ -113,41 +113,41 @@ SbiRuntime::pStep0 SbiRuntime::aStep0[] = { // Alle Opcodes ohne Operanden
&SbiRuntime::StepLIKE,
&SbiRuntime::StepIS,
- // Laden/speichern
- &SbiRuntime::StepARGC, // neuen Argv einrichten
- &SbiRuntime::StepARGV, // TOS ==> aktueller Argv
+ // load/save
+ &SbiRuntime::StepARGC, // establish new Argv
+ &SbiRuntime::StepARGV, // TOS ==> current Argv
&SbiRuntime::StepINPUT, // Input ==> TOS
&SbiRuntime::StepLINPUT, // Line Input ==> TOS
- &SbiRuntime::StepGET, // TOS anfassen
- &SbiRuntime::StepSET, // Speichern Objekt TOS ==> TOS-1
+ &SbiRuntime::StepGET, // touch TOS
+ &SbiRuntime::StepSET, // save object TOS ==> TOS-1
&SbiRuntime::StepPUT, // TOS ==> TOS-1
- &SbiRuntime::StepPUTC, // TOS ==> TOS-1, dann ReadOnly
+ &SbiRuntime::StepPUTC, // TOS ==> TOS-1, then ReadOnly
&SbiRuntime::StepDIM, // DIM
&SbiRuntime::StepREDIM, // REDIM
&SbiRuntime::StepREDIMP, // REDIM PRESERVE
- &SbiRuntime::StepERASE, // TOS loeschen
- // Verzweigen
- &SbiRuntime::StepSTOP, // Programmende
- &SbiRuntime::StepINITFOR, // FOR-Variable initialisieren
- &SbiRuntime::StepNEXT, // FOR-Variable inkrementieren
- &SbiRuntime::StepCASE, // Anfang CASE
- &SbiRuntime::StepENDCASE, // Ende CASE
- &SbiRuntime::StepSTDERROR, // Standard-Fehlerbehandlung
- &SbiRuntime::StepNOERROR, // keine Fehlerbehandlung
- &SbiRuntime::StepLEAVE, // UP verlassen
+ &SbiRuntime::StepERASE, // delete TOS
+ // branch
+ &SbiRuntime::StepSTOP, // program end
+ &SbiRuntime::StepINITFOR, // intitialize FOR-Variable
+ &SbiRuntime::StepNEXT, // increment FOR-Variable
+ &SbiRuntime::StepCASE, // beginning CASE
+ &SbiRuntime::StepENDCASE, // end CASE
+ &SbiRuntime::StepSTDERROR, // standard error handling
+ &SbiRuntime::StepNOERROR, // no error handling
+ &SbiRuntime::StepLEAVE, // leave UP
// E/A
- &SbiRuntime::StepCHANNEL, // TOS = Kanalnummer
+ &SbiRuntime::StepCHANNEL, // TOS = channel number
&SbiRuntime::StepPRINT, // print TOS
&SbiRuntime::StepPRINTF, // print TOS in field
&SbiRuntime::StepWRITE, // write TOS
&SbiRuntime::StepRENAME, // Rename Tos+1 to Tos
- &SbiRuntime::StepPROMPT, // Input Prompt aus TOS definieren
+ &SbiRuntime::StepPROMPT, // define Input Prompt from TOS
&SbiRuntime::StepRESTART, // Set restart point
- &SbiRuntime::StepCHANNEL0, // E/A-Kanal 0 einstellen
- &SbiRuntime::StepEMPTY, // Leeren Ausdruck auf Stack
- &SbiRuntime::StepERROR, // TOS = Fehlercode
- &SbiRuntime::StepLSET, // Speichern Objekt TOS ==> TOS-1
- &SbiRuntime::StepRSET, // Speichern Objekt TOS ==> TOS-1
+ &SbiRuntime::StepCHANNEL0, // set E/A-channel 0
+ &SbiRuntime::StepEMPTY, // empty expression on stack
+ &SbiRuntime::StepERROR, // TOS = error code
+ &SbiRuntime::StepLSET, // save object TOS ==> TOS-1
+ &SbiRuntime::StepRSET, // save object TOS ==> TOS-1
&SbiRuntime::StepREDIMP_ERASE,// Copy array object for REDIMP
&SbiRuntime::StepINITFOREACH,// Init for each loop
&SbiRuntime::StepVBASET,// vba-like set statement
@@ -156,60 +156,60 @@ SbiRuntime::pStep0 SbiRuntime::aStep0[] = { // Alle Opcodes ohne Operanden
&SbiRuntime::StepBYVAL, // access TOS as array
};
-SbiRuntime::pStep1 SbiRuntime::aStep1[] = { // Alle Opcodes mit einem Operanden
- &SbiRuntime::StepLOADNC, // Laden einer numerischen Konstanten (+ID)
- &SbiRuntime::StepLOADSC, // Laden einer Stringkonstanten (+ID)
+SbiRuntime::pStep1 SbiRuntime::aStep1[] = { // all opcodes with one operand
+ &SbiRuntime::StepLOADNC, // loading a numeric constant (+ID)
+ &SbiRuntime::StepLOADSC, // loading a string constant (+ID)
&SbiRuntime::StepLOADI, // Immediate Load (+Wert)
- &SbiRuntime::StepARGN, // Speichern eines named Args in Argv (+StringID)
- &SbiRuntime::StepPAD, // String auf feste Laenge bringen (+Laenge)
- // Verzweigungen
- &SbiRuntime::StepJUMP, // Sprung (+Target)
- &SbiRuntime::StepJUMPT, // TOS auswerten), bedingter Sprung (+Target)
- &SbiRuntime::StepJUMPF, // TOS auswerten), bedingter Sprung (+Target)
- &SbiRuntime::StepONJUMP, // TOS auswerten), Sprung in JUMP-Tabelle (+MaxVal)
- &SbiRuntime::StepGOSUB, // UP-Aufruf (+Target)
- &SbiRuntime::StepRETURN, // UP-Return (+0 oder Target)
- &SbiRuntime::StepTESTFOR, // FOR-Variable testen), inkrementieren (+Endlabel)
+ &SbiRuntime::StepARGN, // save a named Args in Argv (+StringID)
+ &SbiRuntime::StepPAD, // bring string to a definite length (+length)
+ // branches
+ &SbiRuntime::StepJUMP, // jump (+Target)
+ &SbiRuntime::StepJUMPT, // evaluate TOS, conditional jump (+Target)
+ &SbiRuntime::StepJUMPF, // evaluate TOS, conditional jump (+Target)
+ &SbiRuntime::StepONJUMP, // evaluate TOS, jump into JUMP-table (+MaxVal)
+ &SbiRuntime::StepGOSUB, // UP-call (+Target)
+ &SbiRuntime::StepRETURN, // UP-return (+0 or Target)
+ &SbiRuntime::StepTESTFOR, // check FOR-variable, increment (+Endlabel)
&SbiRuntime::StepCASETO, // Tos+1 <= Case <= Tos), 2xremove (+Target)
- &SbiRuntime::StepERRHDL, // Fehler-Handler (+Offset)
- &SbiRuntime::StepRESUME, // Resume nach Fehlern (+0 or 1 or Label)
+ &SbiRuntime::StepERRHDL, // error handler (+Offset)
+ &SbiRuntime::StepRESUME, // resume after errors (+0 or 1 or Label)
// E/A
- &SbiRuntime::StepCLOSE, // (+Kanal/0)
+ &SbiRuntime::StepCLOSE, // (+channel/0)
&SbiRuntime::StepPRCHAR, // (+char)
- // Verwaltung
- &SbiRuntime::StepSETCLASS, // Set + Klassennamen testen (+StringId)
+ // management
+ &SbiRuntime::StepSETCLASS, // check set + class names (+StringId)
&SbiRuntime::StepTESTCLASS, // Check TOS class (+StringId)
- &SbiRuntime::StepLIB, // Lib fuer Declare-Call (+StringId)
- &SbiRuntime::StepBASED, // TOS wird um BASE erhoeht, BASE davor gepusht
- &SbiRuntime::StepARGTYP, // Letzten Parameter in Argv konvertieren (+Typ)
+ &SbiRuntime::StepLIB, // lib for declare-call (+StringId)
+ &SbiRuntime::StepBASED, // TOS is incremented by BASE, BASE is pushed before
+ &SbiRuntime::StepARGTYP, // convert last parameter in Argv (+Type)
&SbiRuntime::StepVBASETCLASS,// vba-like set statement
};
-SbiRuntime::pStep2 SbiRuntime::aStep2[] = {// Alle Opcodes mit zwei Operanden
- &SbiRuntime::StepRTL, // Laden aus RTL (+StringID+Typ)
- &SbiRuntime::StepFIND, // Laden (+StringID+Typ)
- &SbiRuntime::StepELEM, // Laden Element (+StringID+Typ)
+SbiRuntime::pStep2 SbiRuntime::aStep2[] = {// all opcodes with two operands
+ &SbiRuntime::StepRTL, // load from RTL (+StringID+Typ)
+ &SbiRuntime::StepFIND, // load (+StringID+Typ)
+ &SbiRuntime::StepELEM, // load element (+StringID+Typ)
&SbiRuntime::StepPARAM, // Parameter (+Offset+Typ)
// Verzweigen
&SbiRuntime::StepCALL, // Declare-Call (+StringID+Typ)
&SbiRuntime::StepCALLC, // CDecl-Declare-Call (+StringID+Typ)
&SbiRuntime::StepCASEIS, // Case-Test (+Test-Opcode+False-Target)
// Verwaltung
- &SbiRuntime::StepSTMNT, // Beginn eines Statements (+Line+Col)
+ &SbiRuntime::StepSTMNT, // beginning of a statement (+Line+Col)
// E/A
&SbiRuntime::StepOPEN, // (+SvStreamFlags+Flags)
// Objekte
- &SbiRuntime::StepLOCAL, // Lokale Variable definieren (+StringId+Typ)
- &SbiRuntime::StepPUBLIC, // Modulglobale Variable (+StringID+Typ)
- &SbiRuntime::StepGLOBAL, // Globale Variable definieren (+StringID+Typ)
- &SbiRuntime::StepCREATE, // Objekt kreieren (+StringId+StringId)
- &SbiRuntime::StepSTATIC, // Statische Variable (+StringId+StringId)
- &SbiRuntime::StepTCREATE, // User Defined Objekte (+StringId+StringId)
- &SbiRuntime::StepDCREATE, // Objekt-Array kreieren (+StringID+StringID)
- &SbiRuntime::StepGLOBAL_P, // Globale Variable definieren, die beim Neustart
- // von Basic nicht ueberschrieben wird (+StringID+Typ)
- &SbiRuntime::StepFIND_G, // Sucht globale Variable mit Spezialbehandlung wegen _GLOBAL_P
- &SbiRuntime::StepDCREATE_REDIMP, // Objekt-Array redimensionieren (+StringID+StringID)
+ &SbiRuntime::StepLOCAL, // define local variable (+StringId+Typ)
+ &SbiRuntime::StepPUBLIC, // module global variable (+StringID+Typ)
+ &SbiRuntime::StepGLOBAL, // define global variable (+StringID+Typ)
+ &SbiRuntime::StepCREATE, // create object (+StringId+StringId)
+ &SbiRuntime::StepSTATIC, // static variable (+StringId+StringId)
+ &SbiRuntime::StepTCREATE, // user-defined objects (+StringId+StringId)
+ &SbiRuntime::StepDCREATE, // create object-array (+StringID+StringID)
+ &SbiRuntime::StepGLOBAL_P, // define global variable which is not overwritten
+ // by the Basic on a restart (+StringID+Typ)
+ &SbiRuntime::StepFIND_G, // finds global variable with special treatment because of _GLOBAL_P
+ &SbiRuntime::StepDCREATE_REDIMP, // redimension object array (+StringID+StringID)
&SbiRuntime::StepFIND_CM, // Search inside a class module (CM) to enable global search in time
&SbiRuntime::StepPUBLIC_P, // Search inside a class module (CM) to enable global search in time
&SbiRuntime::StepFIND_STATIC, // Search inside a class module (CM) to enable global search in time
@@ -235,39 +235,38 @@ SbiRTLData::~SbiRTLData()
// SbiInstance //
-// 16.10.96: #31460 Neues Konzept fuer StepInto/Over/Out
-// Die Entscheidung, ob StepPoint aufgerufen werden soll, wird anhand des
-// CallLevels getroffen. Angehalten wird, wenn der aktuelle CallLevel <=
-// nBreakCallLvl ist. Der aktuelle CallLevel kann niemals kleiner als 1
-// sein, da er beim Aufruf einer Methode (auch main) inkrementiert wird.
-// Daher bedeutet ein BreakCallLvl von 0, dass das Programm gar nicht
-// angehalten wird.
-// (siehe auch step2.cxx, SbiRuntime::StepSTMNT() )
+// 16.10.96: #31460 new concept for StepInto/Over/Out
+// The decision whether StepPoint shall be called is done with the help of
+// the CallLevel. It's stopped when the current CallLevel is <= nBreakCallLvl.
+// The current CallLevel can never be smaller than 1, as it's also incremented
+// during the call of a method (also main). Therefore a BreakCallLvl from 0
+// means that the program isn't stopped at all.
+// (also have a look at: step2.cxx, SbiRuntime::StepSTMNT() )
+
-// Hilfsfunktion, um den BreakCallLevel gemaess der der Debug-Flags zu ermitteln
void SbiInstance::CalcBreakCallLevel( sal_uInt16 nFlags )
{
- // Break-Flag wegfiltern
+
nFlags &= ~((sal_uInt16)SbDEBUG_BREAK);
sal_uInt16 nRet;
switch( nFlags )
{
case SbDEBUG_STEPINTO:
- nRet = nCallLvl + 1; // CallLevel+1 wird auch angehalten
+ nRet = nCallLvl + 1; // CallLevel+1 is also stopped
break;
case SbDEBUG_STEPOVER | SbDEBUG_STEPINTO:
- nRet = nCallLvl; // Aktueller CallLevel wird angehalten
+ nRet = nCallLvl; // current CallLevel is stopped
break;
case SbDEBUG_STEPOUT:
- nRet = nCallLvl - 1; // Kleinerer CallLevel wird angehalten
+ nRet = nCallLvl - 1; // smaller CallLevel is stopped
break;
case SbDEBUG_CONTINUE:
- // Basic-IDE liefert 0 statt SbDEBUG_CONTINUE, also auch default=continue
+ // Basic-IDE returns 0 instead of SbDEBUG_CONTINUE, so also default=continue
default:
- nRet = 0; // CallLevel ist immer >0 -> kein StepPoint
+ nRet = 0; // CallLevel is always > 0 -> no StepPoint
}
- nBreakCallLvl = nRet; // Ergebnis uebernehmen
+ nBreakCallLvl = nRet; // take result
}
SbiInstance::SbiInstance( StarBASIC* p )
@@ -328,7 +327,7 @@ SbiDllMgr* SbiInstance::GetDllMgr()
return pDllMgr;
}
-// #39629 NumberFormatter jetzt ueber statische Methode anlegen
+// #39629 create NumberFormatter with the help of a static method now
SvNumberFormatter* SbiInstance::GetNumberFormatter()
{
LanguageType eLangType = GetpApp()->GetSettings().GetLanguage();
@@ -351,7 +350,7 @@ SvNumberFormatter* SbiInstance::GetNumberFormatter()
return pNumberFormatter;
}
-// #39629 NumberFormatter auch statisch anbieten
+// #39629 offer NumberFormatter static too
void SbiInstance::PrepareNumberFormatter( SvNumberFormatter*& rpNumberFormatter,
sal_uInt32 &rnStdDateIdx, sal_uInt32 &rnStdTimeIdx, sal_uInt32 &rnStdDateTimeIdx,
LanguageType* peFormatterLangType, DateFormat* peFormatterDateFormat )
@@ -379,13 +378,13 @@ void SbiInstance::PrepareNumberFormatter( SvNumberFormatter*& rpNumberFormatter,
xub_StrLen nCheckPos = 0; short nType;
rnStdTimeIdx = rpNumberFormatter->GetStandardFormat( NUMBERFORMAT_TIME, eLangType );
- // Standard-Vorlagen des Formatters haben nur zweistellige
- // Jahreszahl. Deshalb eigenes Format registrieren
+ // the formatter's standard templates have only got a two-digit date
+ // -> registering an own format
- // HACK, da der Numberformatter in PutandConvertEntry die Platzhalter
- // fuer Monat, Tag, Jahr nicht entsprechend der Systemeinstellung
- // austauscht. Problem: Print Year(Date) unter engl. BS
- // siehe auch svtools\source\sbx\sbxdate.cxx
+ // HACK, beause the numberformatter doesn't swap the place holders
+ // for month, day and year according to the system setting.
+ // Problem: Print Year(Date) under engl. BS
+ // also have a look at: svtools\source\sbx\sbxdate.cxx
String aDateStr;
switch( eDate )
@@ -408,7 +407,7 @@ void SbiInstance::PrepareNumberFormatter( SvNumberFormatter*& rpNumberFormatter,
-// Engine laufenlassen. Falls Flags == SbDEBUG_CONTINUE, Flags uebernehmen
+// Let engine run. If Flags == SbDEBUG_CONTINUE, take Flags over
void SbiInstance::Stop()
{
@@ -479,13 +478,12 @@ void SbiInstance::FatalError( SbError _errCode, const String& _details )
void SbiInstance::Abort()
{
- // Basic suchen, in dem der Fehler auftrat
StarBASIC* pErrBasic = GetCurrentBasic( pBasic );
pErrBasic->RTError( nErr, aErrorMsg, pRun->nLine, pRun->nCol1, pRun->nCol2 );
pBasic->Stop();
}
-// Hilfsfunktion, um aktives Basic zu finden, kann ungleich pRTBasic sein
+// can be unequal to pRTBasic
StarBASIC* GetCurrentBasic( StarBASIC* pRTBasic )
{
StarBASIC* pCurBasic = pRTBasic;
@@ -531,7 +529,7 @@ SbxArray* SbiInstance::GetLocals( SbMethod* pMeth )
// SbiInstance //
-// Achtung: pMeth kann auch NULL sein (beim Aufruf des Init-Codes)
+// Attention: pMeth can also be NULL (on a call of the init-code)
SbiRuntime::SbiRuntime( SbModule* pm, SbMethod* pe, sal_uInt32 nStart )
: rBasic( *(StarBASIC*)pm->pParent ), pInst( pINST ),
@@ -579,7 +577,7 @@ SbiRuntime::~SbiRuntime()
ClearArgvStack();
ClearForStack();
- // #74254 Items zum Sichern temporaere Referenzen freigeben
+ // #74254 free items for saving temporary references
ClearRefs();
while( pItemStoreList )
{
@@ -601,14 +599,14 @@ void SbiRuntime::SetVBAEnabled(bool bEnabled )
mpExtCaller = 0;
}
-// Aufbau der Parameterliste. Alle ByRef-Parameter werden direkt
-// uebernommen; von ByVal-Parametern werden Kopien angelegt. Falls
-// ein bestimmter Datentyp verlangt wird, wird konvertiert.
+// Construction of the parameter list. All ByRef-parameters are directly
+// taken over; copies of ByVal-parameters are created. If a particular
+// data type is requested, it is converted.
void SbiRuntime::SetParameters( SbxArray* pParams )
{
refParams = new SbxArray;
- // fuer den Returnwert
+ // for the return value
refParams->Put( pMeth, 0 );
SbxInfo* pInfo = pMeth ? pMeth->GetInfo() : NULL;
@@ -642,7 +640,7 @@ void SbiRuntime::SetParameters( SbxArray* pParams )
}
SbxVariable* v = pParams->Get( i );
- // Methoden sind immer byval!
+ // methods are always byval!
sal_Bool bByVal = v->IsA( TYPE(SbxMethod) );
SbxDataType t = v->GetType();
bool bTargetTypeIsArray = false;
@@ -670,7 +668,6 @@ void SbiRuntime::SetParameters( SbxArray* pParams )
{
if( t != SbxVARIANT && t != ( v->GetType() & 0x0FFF ) )
{
- // Array konvertieren??
if( p && (p->eType & SbxARRAY) )
Error( SbERR_CONVERSION );
else
@@ -701,13 +698,13 @@ void SbiRuntime::SetParameters( SbxArray* pParams )
}
-// Einen P-Code ausfuehren
+// execute a P-Code
sal_Bool SbiRuntime::Step()
{
if( bRun )
{
- // Unbedingt gelegentlich die Kontrolle abgeben!
+ // in any case check casually!
if( !( ++nOps & 0xF ) && pInst->IsReschedule() )
{
sal_uInt32 nTime = osl_getGlobalTimer();
@@ -746,19 +743,19 @@ sal_Bool SbiRuntime::Step()
else
StarBASIC::FatalError( SbERR_INTERNAL_ERROR );
- // SBX-Fehler aufgetreten?
+
SbError nSbError = SbxBase::GetError();
- Error( ERRCODE_TOERROR(nSbError) ); // Warnings rausfiltern
+ Error( ERRCODE_TOERROR(nSbError) );
- // AB 13.2.1997, neues Error-Handling:
- // ACHTUNG: Hier kann nError auch dann gesetzt sein, wenn !nSbError,
- // da nError jetzt auch von anderen RT-Instanzen gesetzt werden kann
+ // from 13.2.1997, new error handling:
+ // ATTENTION: nError can be set already even if !nSbError
+ // since nError can now also be set from other RT-instances
if( nError )
SbxBase::ResetError();
- // AB,15.3.96: Fehler nur anzeigen, wenn BASIC noch aktiv
- // (insbesondere nicht nach Compiler-Fehlern zur Laufzeit)
+ // from 15.3.96: display errors only if BASIC is still active
+ // (especially not after compiler errors at the runtime)
if( nError && bRun )
{
SbError err = nError;
@@ -773,7 +770,7 @@ sal_Bool SbiRuntime::Step()
// to handle the error
bool bLetParentHandleThis = false;
- // Im Error Handler? Dann Std-Error
+ // in the error handler? so std-error
if ( !bInError )
{
bInError = sal_True;
@@ -792,15 +789,14 @@ sal_Bool SbiRuntime::Step()
}
if ( bLetParentHandleThis )
{
- // AB 13.2.1997, neues Error-Handling:
- // Uebergeordnete Error-Handler beruecksichtigen
+ // from 13.2.1997, new error handling:
+ // consider superior error handlers
- // Wir haben keinen Error-Handler -> weiter oben suchen
+ // there's no error handler -> find one farther above
SbiRuntime* pRtErrHdl = NULL;
SbiRuntime* pRt = this;
while( NULL != (pRt = pRt->pNext) )
{
- // Gibt es einen Error-Handler?
if( pRt->bError == sal_False || pRt->pError != NULL )
{
pRtErrHdl = pRt;
@@ -808,37 +804,33 @@ sal_Bool SbiRuntime::Step()
}
}
- // Error-Hdl gefunden?
+
if( pRtErrHdl )
{
- // (Neuen) Error-Stack anlegen
SbErrorStack*& rErrStack = GetSbData()->pErrStack;
if( rErrStack )
delete rErrStack;
rErrStack = new SbErrorStack();
- // Alle im Call-Stack darunter stehenden RTs manipulieren
+ // manipulate all the RTs that are below in the call-stack
pRt = this;
do
{
- // Fehler setzen
pRt->nError = err;
if( pRt != pRtErrHdl )
pRt->bRun = sal_False;
- // In Error-Stack eintragen
SbErrorStackEntry *pEntry = new SbErrorStackEntry
( pRt->pMeth, pRt->nLine, pRt->nCol1, pRt->nCol2 );
rErrStack->C40_INSERT(SbErrorStackEntry, pEntry, rErrStack->Count() );
- // Nach RT mit Error-Handler aufhoeren
if( pRt == pRtErrHdl )
break;
pRt = pRt->pNext;
}
while( pRt );
}
- // Kein Error-Hdl gefunden -> altes Vorgehen
+ // no error-hdl found -> old behaviour
else
{
pInst->Abort();
@@ -945,8 +937,8 @@ SbxArray* SbiRuntime::GetParams()
// Stacks
-// Der Expression-Stack steht fuer die laufende Auswertung von Expressions
-// zur Verfuegung.
+// The expression-stack is available for the continous evaluation
+// of expressions.
void SbiRuntime::PushVar( SbxVariable* pVar )
{
@@ -968,7 +960,7 @@ SbxVariableRef SbiRuntime::PopVar()
if ( xVar->GetName().EqualsAscii( "Cells" ) )
OSL_TRACE( "" );
#endif
- // Methods halten im 0.Parameter sich selbst, also weghauen
+ // methods hold themselves in parameter 0
if( xVar->IsA( TYPE(SbxMethod) ) )
xVar->SetParameters(0);
return xVar;
@@ -976,7 +968,7 @@ SbxVariableRef SbiRuntime::PopVar()
sal_Bool SbiRuntime::ClearExprStack()
{
- // Achtung: Clear() reicht nicht, da Methods geloescht werden muessen
+ // Attention: Clear() doesn't suffice as methods must be deleted
while ( nExprLvl )
{
PopVar();
@@ -985,8 +977,8 @@ sal_Bool SbiRuntime::ClearExprStack()
return sal_False;
}
-// Variable auf dem Expression-Stack holen, ohne sie zu entfernen
-// n zaehlt ab 0.
+// Take variable from the expression-stack without removing it
+// n counts from 0
SbxVariable* SbiRuntime::GetTOS( short n )
{
@@ -1001,7 +993,6 @@ SbxVariable* SbiRuntime::GetTOS( short n )
return refExprStk->Get( (sal_uInt16) n );
}
-// Sicherstellen, dass TOS eine temporaere Variable ist
void SbiRuntime::TOSMakeTemp()
{
@@ -1031,7 +1022,7 @@ void SbiRuntime::TOSMakeTemp()
}
}
-// Der GOSUB-Stack nimmt Returnadressen fuer GOSUBs auf
+// the GOSUB-stack collects return-addresses for GOSUBs
void SbiRuntime::PushGosub( const sal_uInt8* pc )
{
if( ++nGosubLvl > MAXRECURSION )
@@ -1057,7 +1048,6 @@ void SbiRuntime::PopGosub()
}
}
-// Entleeren des GOSUB-Stacks
void SbiRuntime::ClearGosubStack()
{
@@ -1067,7 +1057,7 @@ void SbiRuntime::ClearGosubStack()
nGosubLvl = 0;
}
-// Der Argv-Stack nimmt aktuelle Argument-Vektoren auf
+// the Argv-stack collects current argument-vectors
void SbiRuntime::PushArgv()
{
@@ -1092,7 +1082,6 @@ void SbiRuntime::PopArgv()
}
}
-// Entleeren des Argv-Stacks
void SbiRuntime::ClearArgvStack()
{
@@ -1100,8 +1089,8 @@ void SbiRuntime::ClearArgvStack()
PopArgv();
}
-// Push des For-Stacks. Der Stack hat Inkrement, Ende, Beginn und Variable.
-// Nach Aufbau des Stack-Elements ist der Stack leer.
+// Push of the for-stack. The stack has increment, end, begin and variable.
+// After the creation of the stack-element the stack's empty.
void SbiRuntime::PushFor()
{
@@ -1109,7 +1098,7 @@ void SbiRuntime::PushFor()
p->eForType = FOR_TO;
p->pNext = pForStk;
pForStk = p;
- // Der Stack ist wie folgt aufgebaut:
+
p->refInc = PopVar();
p->refEnd = PopVar();
SbxVariableRef xBgn = PopVar();
@@ -1207,7 +1196,6 @@ void SbiRuntime::PushForEach()
nForLvl++;
}
-// Poppen des FOR-Stacks
void SbiRuntime::PopFor()
{
@@ -1220,7 +1208,6 @@ void SbiRuntime::PopFor()
}
}
-// Entleeren des FOR-Stacks
void SbiRuntime::ClearForStack()
{
@@ -1246,14 +1233,14 @@ SbiForStack* SbiRuntime::FindForStackItemForCollection( class BasicCollection* p
//////////////////////////////////////////////////////////////////////////
//
-// DLL-Aufrufe
+// DLL-calls
void SbiRuntime::DllCall
- ( const String& aFuncName, // Funktionsname
- const String& aDLLName, // Name der DLL
- SbxArray* pArgs, // Parameter (ab Index 1, kann NULL sein)
- SbxDataType eResType, // Returnwert
- sal_Bool bCDecl ) // sal_True: nach C-Konventionen
+ ( const String& aFuncName,
+ const String& aDLLName,
+ SbxArray* pArgs, // parameter (from index 1, can be NULL)
+ SbxDataType eResType, // return value
+ sal_Bool bCDecl ) // sal_True: according to C-conventions
{
// No DllCall for "virtual" portal users
if( needSecurityRestrictions() )
@@ -1262,7 +1249,7 @@ void SbiRuntime::DllCall
return;
}
- // MUSS NOCH IMPLEMENTIERT WERDEN
+ // NOT YET IMPLEMENTED
SbxVariable* pRes = new SbxVariable( eResType );
SbiDllMgr* pDllMgr = pInst->GetDllMgr();
diff --git a/basic/source/runtime/stdobj.cxx b/basic/source/runtime/stdobj.cxx
index 53b2ae1..a451b4f 100644
--- a/basic/source/runtime/stdobj.cxx
+++ b/basic/source/runtime/stdobj.cxx
@@ -36,9 +36,9 @@
#include "rtlproto.hxx"
#include "sbintern.hxx"
#include <boost/unordered_map.hpp>
-// Das nArgs-Feld eines Tabelleneintrags ist wie folgt verschluesselt:
-// Zur Zeit wird davon ausgegangen, dass Properties keine Parameter
-// benoetigen!
+// The nArgs-field of a table entry is encrypted as follows:
+// At the moment it is assumed that properties don't need any
+// parameters!
// previously _ARGSMASK was 0x007F ( e.g. up to 127 args ) however 63 should be
// enough, if not we need to increase the size of nArgs member in the Methods
@@ -52,33 +52,33 @@
#define _COMPATONLY 0x0080 // procedure is visible in vba mode only
#define _NORMONLY 0x0040 // procedure is visible in normal mode only
-#define _RWMASK 0x0F00 // Maske fuer R/W-Bits
-#define _TYPEMASK 0xF000 // Maske fuer den Typ des Eintrags
-
-#define _READ 0x0100 // kann gelesen werden
-#define _BWRITE 0x0200 // kann as Lvalue verwendet werden
-#define _LVALUE _BWRITE // kann as Lvalue verwendet werden
-#define _READWRITE 0x0300 // beides
-#define _OPT 0x0400 // Parameter ist optional
-#define _CONST 0x0800 // Property ist const
-#define _METHOD 0x3000 // Masken-Bits fuer eine Methode
-#define _PROPERTY 0x4000 // Masken-Bit fuer eine Property
-#define _OBJECT 0x8000 // Masken-Bit fuer ein Objekt
- // Kombination von oberen Bits:
-#define _FUNCTION 0x1100 // Maske fuer Function
-#define _LFUNCTION 0x1300 // Maske fuer Function, die auch als Lvalue geht
-#define _SUB 0x2100 // Maske fuer Sub
-#define _ROPROP 0x4100 // Maske Read Only-Property
-#define _WOPROP 0x4200 // Maske Write Only-Property
-#define _RWPROP 0x4300 // Maske Read/Write-Property
-#define _CPROP 0x4900 // Maske fuer Konstante
+#define _RWMASK 0x0F00 // mask for R/W-bits
+#define _TYPEMASK 0xF000 // mask for the entry's type
+
+#define _READ 0x0100 // can be read
+#define _BWRITE 0x0200 // can be used as Lvalue
+#define _LVALUE _BWRITE // can be used as Lvalue
+#define _READWRITE 0x0300 // both
+#define _OPT 0x0400 // parameter is optional
+#define _CONST 0x0800 // property is const
+#define _METHOD 0x3000
+#define _PROPERTY 0x4000
+#define _OBJECT 0x8000
+ // combination of bits above:
+#define _FUNCTION 0x1100
+#define _LFUNCTION 0x1300 // mask for function which also works as Lvalue
+#define _SUB 0x2100
+#define _ROPROP 0x4100 // mask Read Only-Property
+#define _WOPROP 0x4200 // mask Write Only-Property
+#define _RWPROP 0x4300 // mask Read/Write-Property
+#define _CPROP 0x4900 // mask for constant
struct Methods {
- const char* pName; // Name des Eintrags
- SbxDataType eType; // Datentyp
- short nArgs; // Argumente und Flags
- RtlCall pFunc; // Function Pointer
- sal_uInt16 nHash; // Hashcode
+ const char* pName;
+ SbxDataType eType;
+ short nArgs;
+ RtlCall pFunc;
+ sal_uInt16 nHash;
};
struct StringHashCode
@@ -722,11 +722,11 @@ static Methods aMethods[] = {
{ "Year", SbxINTEGER, 1 | _FUNCTION, RTLNAME(Year),0 },
{ "Date", SbxDATE, 0,NULL,0 },
-{ NULL, SbxNULL, -1,NULL,0 }}; // Tabellenende
+{ NULL, SbxNULL, -1,NULL,0 }}; // end of the table
SbiStdObject::SbiStdObject( const String& r, StarBASIC* pb ) : SbxObject( r )
{
- // Muessen wir die Hashcodes initialisieren?
+ // do we have to initialize the hashcodes?
Methods* p = aMethods;
if( !p->nHash )
while( p->nArgs != -1 )
@@ -754,21 +754,21 @@ SbiStdObject::~SbiStdObject()
delete pStdFactory;
}
-// Suche nach einem Element:
-// Hier wird linear durch die Methodentabelle gegangen, bis eine
-// passende Methode gefunden wurde. Auf Grund der Bits im nArgs-Feld
-// wird dann die passende Instanz eines SbxObjElement generiert.
-// Wenn die Methode/Property nicht gefunden wurde, nur NULL ohne
-// Fehlercode zurueckliefern, da so auch eine ganze Chain von
-// Objekten nach der Methode/Property befragt werden kann.
+// Finding an element:
+// It runs linearly through the method table here until an
+// adequate method is has been found. Because of the bits in
+// the nArgs-field the adequate instance of an SbxObjElement
+// is created then. If the method/property hasn't been found,
+// return NULL without error code, so that a whole chain of
+// objects can be asked for the method/property.
SbxVariable* SbiStdObject::Find( const String& rName, SbxClassType t )
{
- // Bereits eingetragen?
+ // entered already?
SbxVariable* pVar = SbxObject::Find( rName, t );
if( !pVar )
{
- // sonst suchen
+ // else search one
sal_uInt16 nHash_ = SbxVariable::MakeHashCode( rName );
Methods* p = aMethods;
sal_Bool bFound = sal_False;
@@ -802,7 +802,7 @@ SbxVariable* SbiStdObject::Find( const String& rName, SbxClassType t )
if( bFound )
{
- // Args-Felder isolieren:
+ // isolate Args-fields:
short nAccess = ( p->nArgs & _RWMASK ) >> 8;
short nType = ( p->nArgs & _TYPEMASK );
if( p->nArgs & _CONST )
@@ -821,12 +821,11 @@ SbxVariable* SbiStdObject::Find( const String& rName, SbxClassType t )
return pVar;
}
-// SetModified mu� bei der RTL abgklemmt werden
+// SetModified must be pinched off at the RTL
void SbiStdObject::SetModified( sal_Bool )
{
}
-// Aufruf einer Property oder Methode.
void SbiStdObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
const SfxHint& rHint, const TypeId& rHintType )
@@ -866,8 +865,8 @@ void SbiStdObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
}
}
-// Zusammenbau der Infostruktur fuer einzelne Elemente
-// Falls nIdx = 0, nix erzeugen (sind Std-Props!)
+// building the info-structure for single elements
+// if nIdx = 0, don't create anything (Std-Props!)
SbxInfo* SbiStdObject::GetInfo( short nIdx )
{
diff --git a/basic/source/runtime/stdobj1.cxx b/basic/source/runtime/stdobj1.cxx
index b8759d7..831b663 100644
--- a/basic/source/runtime/stdobj1.cxx
+++ b/basic/source/runtime/stdobj1.cxx
@@ -148,7 +148,7 @@ SbStdPicture::~SbStdPicture()
SbxVariable* SbStdPicture::Find( const String& rName, SbxClassType t )
{
- // Bereits eingetragen?
+ // entered already?
return SbxObject::Find( rName, t );
}
@@ -258,7 +258,7 @@ SbStdFont::SbStdFont() :
p->SetFlags( SBX_READWRITE | SBX_DONTSTORE );
p->SetUserData( ATTR_IMP_SIZE );
- // Name Property selbst verarbeiten
+ // handle name property yourself
p = Find( String( RTL_CONSTASCII_USTRINGPARAM("Name") ), SbxCLASS_PROPERTY );
DBG_ASSERT( p, "Keine Name Property" );
p->SetUserData( ATTR_IMP_NAME );
@@ -271,7 +271,6 @@ SbStdFont::~SbStdFont()
SbxVariable* SbStdFont::Find( const String& rName, SbxClassType t )
{
- // Bereits eingetragen?
return SbxObject::Find( rName, t );
}
@@ -409,12 +408,11 @@ TYPEINIT1( SbStdClipboard, SbxObject );
SbStdClipboard::SbStdClipboard() :
SbxObject( String( RTL_CONSTASCII_USTRINGPARAM("Clipboard") ) )
{
- // Name Property selbst verarbeiten
SbxVariable* p = Find( String( RTL_CONSTASCII_USTRINGPARAM("Name") ), SbxCLASS_PROPERTY );
DBG_ASSERT( p, "Keine Name Property" );
p->SetUserData( ATTR_IMP_NAME );
- //Methoden registrieren
+ // register methods
p = Make( String( RTL_CONSTASCII_USTRINGPARAM("Clear") ), SbxCLASS_METHOD, SbxEMPTY );
p->SetFlag( SBX_DONTSTORE );
p->SetUserData( METH_CLEAR );
@@ -442,7 +440,6 @@ SbStdClipboard::~SbStdClipboard()
SbxVariable* SbStdClipboard::Find( const String& rName, SbxClassType t )
{
- // Bereits eingetragen?
return SbxObject::Find( rName, t );
}
diff --git a/basic/source/runtime/step0.cxx b/basic/source/runtime/step0.cxx
index bc3aeab..714c2c4 100644
--- a/basic/source/runtime/step0.cxx
+++ b/basic/source/runtime/step0.cxx
@@ -296,7 +296,7 @@ void SbiRuntime::StepLIKE()
PushVar( pRes );
}
-// TOS und TOS-1 sind beides Objektvariable und enthalten den selben Pointer
+// TOS and TOS-1 are both object variables and contain the same pointer
void SbiRuntime::StepIS()
{
@@ -325,7 +325,7 @@ void SbiRuntime::StepIS()
PushVar( pRes );
}
-// Aktualisieren des Wertes von TOS
+// update the value of TOS
void SbiRuntime::StepGET()
{
@@ -333,7 +333,7 @@ void SbiRuntime::StepGET()
p->Broadcast( SBX_HINT_DATAWANTED );
}
-// #67607 Uno-Structs kopieren
+// #67607 copy Uno-Structs
inline void checkUnoStructCopy( SbxVariableRef& refVal, SbxVariableRef& refVar )
{
SbxDataType eVarType = refVar->GetType();
@@ -359,7 +359,7 @@ inline void checkUnoStructCopy( SbxVariableRef& refVal, SbxVariableRef& refVar )
if( aAny.getValueType().getTypeClass() == TypeClass_STRUCT )
{
SbUnoObject* pNewUnoObj = new SbUnoObject( pUnoObj->GetName(), aAny );
- // #70324: ClassName uebernehmen
+ // #70324: adopt ClassName
pNewUnoObj->SetClassName( pUnoObj->GetClassName() );
refVar->PutObject( pNewUnoObj );
}
@@ -368,13 +368,13 @@ inline void checkUnoStructCopy( SbxVariableRef& refVal, SbxVariableRef& refVar )
}
-// Ablage von TOS in TOS-1
+// laying down TOS in TOS-1
void SbiRuntime::StepPUT()
{
SbxVariableRef refVal = PopVar();
SbxVariableRef refVar = PopVar();
- // Store auf die eigene Methode (innerhalb einer Function)?
+ // store on its own method (inside a function)?
sal_Bool bFlagsChanged = sal_False;
sal_uInt16 n = 0;
if( (SbxVariable*) refVar == (SbxVariable*) pMeth )
@@ -458,14 +458,14 @@ void removeDimAsNewRecoverItem( SbxVariable* pVar )
}
-// Speichern Objektvariable
-// Nicht-Objekt-Variable fuehren zu Fehlern
+// saving object variable
+// not-object variables will cause errors
static const char pCollectionStr[] = "Collection";
void SbiRuntime::StepSET_Impl( SbxVariableRef& refVal, SbxVariableRef& refVar, bool bHandleDefaultProp )
{
- // #67733 Typen mit Array-Flag sind auch ok
+ // #67733 types with array-flag are OK too
// Check var, !object is no error for sure if, only if type is fixed
SbxDataType eVarType = refVar->GetType();
@@ -487,13 +487,12 @@ void SbiRuntime::StepSET_Impl( SbxVariableRef& refVal, SbxVariableRef& refVar, b
// if they are SbxEMPTY I guess
if ( !bHandleDefaultProp || ( bHandleDefaultProp && eValType == SbxOBJECT ) )
{
- // Auf refVal GetObject fuer Collections ausloesen
+ // activate GetOject for collections on refVal
SbxBase* pObjVarObj = refVal->GetObject();
if( pObjVarObj )
{
SbxVariableRef refObjVal = PTR_CAST(SbxObject,pObjVarObj);
- // #67733 Typen mit Array-Flag sind auch ok
if( refObjVal )
refVal = refObjVal;
else if( !(eValType & SbxARRAY) )
@@ -501,16 +500,15 @@ void SbiRuntime::StepSET_Impl( SbxVariableRef& refVal, SbxVariableRef& refVar, b
}
}
- // #52896 Wenn Uno-Sequences bzw. allgemein Arrays einer als
- // Object deklarierten Variable zugewiesen werden, kann hier
- // refVal ungueltig sein!
+ // #52896 refVal can be invalid here, if uno-sequences - or more
+ // general arrays - are assigned to variables that are declared
+ // as an object!
if( !refVal )
{
Error( SbERR_INVALID_USAGE_OBJECT );
}
else
{
- // Store auf die eigene Methode (innerhalb einer Function)?
sal_Bool bFlagsChanged = sal_False;
sal_uInt16 n = 0;
if( (SbxVariable*) refVar == (SbxVariable*) pMeth )
@@ -666,7 +664,7 @@ void SbiRuntime::StepSET_Impl( SbxVariableRef& refVal, SbxVariableRef& refVar, b
// in this case we do not want to call checkUnoStructCopy 'cause that will
// cause an error also
if ( !bHandleDefaultProp || ( bHandleDefaultProp && ( refVar->GetType() != SbxEMPTY ) ) )
- // #67607 Uno-Structs kopieren
+ // #67607 copy Uno-Structs
checkUnoStructCopy( refVal, refVar );
if( bFlagsChanged )
refVar->SetFlags( n );
@@ -698,7 +696,6 @@ void SbiRuntime::StepLSET()
Error( SbERR_INVALID_USAGE_OBJECT );
else
{
- // Store auf die eigene Methode (innerhalb einer Function)?
sal_uInt16 n = refVar->GetFlags();
if( (SbxVariable*) refVar == (SbxVariable*) pMeth )
refVar->SetFlag( SBX_WRITE );
@@ -733,7 +730,6 @@ void SbiRuntime::StepRSET()
Error( SbERR_INVALID_USAGE_OBJECT );
else
{
- // Store auf die eigene Methode (innerhalb einer Function)?
sal_uInt16 n = refVar->GetFlags();
if( (SbxVariable*) refVar == (SbxVariable*) pMeth )
refVar->SetFlag( SBX_WRITE );
@@ -755,7 +751,7 @@ void SbiRuntime::StepRSET()
}
}
-// Ablage von TOS in TOS-1, dann ReadOnly-Bit setzen
+// laying down TOS in TOS-1, then set ReadOnly-Bit
void SbiRuntime::StepPUTC()
{
@@ -768,7 +764,7 @@ void SbiRuntime::StepPUTC()
}
// DIM
-// TOS = Variable fuer das Array mit Dimensionsangaben als Parameter
+// TOS = variable for the array with dimension information as parameter
void SbiRuntime::StepDIM()
{
@@ -776,7 +772,7 @@ void SbiRuntime::StepDIM()
DimImpl( refVar );
}
-// #56204 DIM-Funktionalitaet in Hilfsmethode auslagern (step0.cxx)
+// #56204 swap out DIM-functionality into a help method (step0.cxx)
void SbiRuntime::DimImpl( SbxVariableRef refVar )
{
// If refDim then this DIM statement is terminating a ReDIM and
@@ -791,15 +787,15 @@ void SbiRuntime::DimImpl( SbxVariableRef refVar )
refRedim = NULL;
}
SbxArray* pDims = refVar->GetParameters();
- // Muss eine gerade Anzahl Argumente haben
- // Man denke daran, dass Arg[0] nicht zaehlt!
+ // must have an even number of arguments
+ // have in mind that Arg[0] does not count!
if( pDims && !( pDims->Count() & 1 ) )
StarBASIC::FatalError( SbERR_INTERNAL_ERROR );
else
{
SbxDataType eType = refVar->IsFixed() ? refVar->GetType() : SbxVARIANT;
SbxDimArray* pArray = new SbxDimArray( eType );
- // auch Arrays ohne Dimensionsangaben zulassen (VB-komp.)
+ // allow arrays without dimension information, too (VB-compatible)
if( pDims )
{
refVar->ResetFlag( SBX_VAR_TO_DIM );
@@ -817,8 +813,8 @@ void SbiRuntime::DimImpl( SbxVariableRef refVar )
}
else
{
- // #62867 Beim Anlegen eines Arrays der Laenge 0 wie bei
- // Uno-Sequences der Laenge 0 eine Dimension anlegen
+ // #62867 On creating an array of the length 0, create
+ // a dimension (like for Uno-Sequences of the length 0)
pArray->unoAddDim( 0, -1 );
}
sal_uInt16 nSavFlags = refVar->GetFlags();
@@ -830,13 +826,13 @@ void SbiRuntime::DimImpl( SbxVariableRef refVar )
}
// REDIM
-// TOS = Variable fuer das Array
-// argv = Dimensionsangaben
+// TOS = variable for the array
+// argv = dimension information
void SbiRuntime::StepREDIM()
{
- // Im Moment ist es nichts anderes als Dim, da doppeltes Dim
- // bereits vom Compiler erkannt wird.
+ // Nothing different than dim at the moment because
+ // a double dim is already recognized by the compiler.
StepDIM();
}
@@ -864,8 +860,8 @@ void implCopyDimArray( SbxDimArray* pNewArray, SbxDimArray* pOldArray, short nMa
}
// REDIM PRESERVE
-// TOS = Variable fuer das Array
-// argv = Dimensionsangaben
+// TOS = variable for the array
+// argv = dimension information
void SbiRuntime::StepREDIMP()
{
@@ -997,11 +993,11 @@ void lcl_eraseImpl( SbxVariableRef& refVar, bool bVBAEnabled )
}
}
else
- // Arrays haben bei Erase nach VB ein recht komplexes Verhalten. Hier
- // werden zunaechst nur die Typ-Probleme bei REDIM (#26295) beseitigt:
- // Typ hart auf den Array-Typ setzen, da eine Variable mit Array
- // SbxOBJECT ist. Bei REDIM entsteht dann ein SbxOBJECT-Array und
- // der ursruengliche Typ geht verloren -> Laufzeitfehler
+ // Arrays have on an erase to VB quite a complex behaviour. Here are
+ // only the type problems at REDIM (#26295) removed at first:
+ // Set type hard onto the array-type, because a variable with array is
+ // SbxOBJECT. At REDIM there's an SbxOBJECT-array generated then and
+ // the original type is lost -> runtime error
lcl_clearImpl( refVar, eType );
}
else
@@ -1011,8 +1007,8 @@ void lcl_eraseImpl( SbxVariableRef& refVar, bool bVBAEnabled )
refVar->SetType( SbxEMPTY );
}
-// Variable loeschen
-// TOS = Variable
+// delete variable
+// TOS = variable
void SbiRuntime::StepERASE()
{
@@ -1048,8 +1044,8 @@ void SbiRuntime::StepBYVAL()
PushVar( pCopyVar );
}
-// Einrichten eines Argvs
-// nOp1 bleibt so -> 1. Element ist Returnwert
+// establishing an argv
+// nOp1 stays as it is -> 1st element is the return value
void SbiRuntime::StepARGC()
{
@@ -1058,7 +1054,7 @@ void SbiRuntime::StepARGC()
nArgc = 1;
}
-// Speichern eines Arguments in Argv
+// storing an argument in Argv
void SbiRuntime::StepARGV()
{
@@ -1071,7 +1067,7 @@ void SbiRuntime::StepARGV()
// Before fix of #94916:
if( pVal->ISA(SbxMethod) || pVal->ISA(SbUnoProperty) || pVal->ISA(SbProcedureProperty) )
{
- // Methoden und Properties evaluieren!
+ // evaluate methods and properties!
SbxVariable* pRes = new SbxVariable( *pVal );
pVal = pRes;
}
@@ -1079,8 +1075,8 @@ void SbiRuntime::StepARGV()
}
}
-// Input to Variable. Die Variable ist auf TOS und wird
-// anschliessend entfernt.
+// Input to Variable. The variable is on TOS and is
+// is removed afterwards.
void SbiRuntime::StepINPUT()
{
@@ -1124,8 +1120,8 @@ void SbiRuntime::StepINPUT()
if( !err )
{
SbxVariableRef pVar = GetTOS();
- // Zuerst versuchen, die Variable mit einem numerischen Wert
- // zu fuellen, dann mit einem Stringwert
+ // try to fill the variable with a numeric value first,
+ // then with a string value
if( !pVar->IsFixed() || pVar->IsNumeric() )
{
sal_uInt16 nLen = 0;
@@ -1134,7 +1130,7 @@ void SbiRuntime::StepINPUT()
err = SbxBase::GetError();
SbxBase::ResetError();
}
- // Der Wert muss komplett eingescant werden
+ // the value has to be scanned in completely
else if( nLen != s.Len() && !pVar->PutString( s ) )
{
err = SbxBase::GetError();
@@ -1176,8 +1172,8 @@ void SbiRuntime::StepINPUT()
}
}
-// Line Input to Variable. Die Variable ist auf TOS und wird
-// anschliessend entfernt.
+// Line Input to Variable. The variable is on TOS and is
+// deleted afterwards.
void SbiRuntime::StepLINPUT()
{
@@ -1188,14 +1184,13 @@ void SbiRuntime::StepLINPUT()
p->PutString( String( aInput, gsl_getSystemTextEncoding() ) );
}
-// Programmende
+// end of program
void SbiRuntime::StepSTOP()
{
pInst->Stop();
}
-// FOR-Variable initialisieren
void SbiRuntime::StepINITFOR()
{
@@ -1207,7 +1202,7 @@ void SbiRuntime::StepINITFOREACH()
PushForEach();
}
-// FOR-Variable inkrementieren
+// increment FOR-variable
void SbiRuntime::StepNEXT()
{
@@ -1220,7 +1215,7 @@ void SbiRuntime::StepNEXT()
pForStk->refVar->Compute( SbxPLUS, *pForStk->refInc );
}
-// Anfang CASE: TOS in CASE-Stack
+// beginning CASE: TOS in CASE-stack
void SbiRuntime::StepCASE()
{
@@ -1230,7 +1225,7 @@ void SbiRuntime::StepCASE()
refCaseStk->Put( xVar, refCaseStk->Count() );
}
-// Ende CASE: Variable freigeben
+// end CASE: free variable
void SbiRuntime::StepENDCASE()
{
@@ -1240,7 +1235,6 @@ void SbiRuntime::StepENDCASE()
refCaseStk->Remove( refCaseStk->Count() - 1 );
}
-// Standard-Fehlerbehandlung
void SbiRuntime::StepSTDERROR()
{
@@ -1262,7 +1256,7 @@ void SbiRuntime::StepNOERROR()
bError = sal_False;
}
-// UP verlassen
+// leave UP
void SbiRuntime::StepLEAVE()
{
@@ -1272,7 +1266,7 @@ void SbiRuntime::StepLEAVE()
SbxErrObject::getUnoErrObject()->Clear();
}
-void SbiRuntime::StepCHANNEL() // TOS = Kanalnummer
+void SbiRuntime::StepCHANNEL() // TOS = channel number
{
SbxVariableRef pChan = PopVar();
short nChan = pChan->GetInteger();
@@ -1291,7 +1285,7 @@ void SbiRuntime::StepPRINT() // print TOS
String s1 = p->GetString();
String s;
if( p->GetType() >= SbxINTEGER && p->GetType() <= SbxDOUBLE )
- s = ' '; // ein Blank davor
+ s = ' '; // one blank before
s += s1;
ByteString aByteStr( s, gsl_getSystemTextEncoding() );
pIosys->Write( aByteStr );
@@ -1304,7 +1298,7 @@ void SbiRuntime::StepPRINTF() // print TOS in field
String s1 = p->GetString();
String s;
if( p->GetType() >= SbxINTEGER && p->GetType() <= SbxDOUBLE )
- s = ' '; // ein Blank davor
+ s = ' ';
s += s1;
s.Expand( 14, ' ' );
ByteString aByteStr( s, gsl_getSystemTextEncoding() );
@@ -1315,7 +1309,7 @@ void SbiRuntime::StepPRINTF() // print TOS in field
void SbiRuntime::StepWRITE() // write TOS
{
SbxVariableRef p = PopVar();
- // Muss der String gekapselt werden?
+ // Does the string have to be encapsulated?
char ch = 0;
switch (p->GetType() )
{
@@ -1369,20 +1363,20 @@ void SbiRuntime::StepRESTART()
pRestart = pCode;
}
-// Leerer Ausdruck auf Stack fuer fehlenden Parameter
+// empty expression on stack for missing parameter
void SbiRuntime::StepEMPTY()
{
- // #57915 Die Semantik von StepEMPTY() ist die Repraesentation eines fehlenden
- // Arguments. Dies wird in VB durch ein durch den Wert 448 (SbERR_NAMED_NOT_FOUND)
- // vom Typ Error repraesentiert. StepEmpty jetzt muesste besser StepMISSING()
- // heissen, aber der Name wird der Einfachkeit halber beibehalten.
+ // #57915 The semantics of StepEMPTY() is the representation of a missing argument.
+ // This is represented by the value 448 (SbERR_NAMED_NOT_FOUND) of the type error
+ // in VB. StepEmpty should now rather be named StepMISSING() but the name is kept
+ // to simplify matters.
SbxVariableRef xVar = new SbxVariable( SbxVARIANT );
xVar->PutErr( 448 );
PushVar( xVar );
}
-// TOS = Fehlercode
+// TOS = error code
void SbiRuntime::StepERROR()
{
diff --git a/basic/source/runtime/step1.cxx b/basic/source/runtime/step1.cxx
index 74d6989..7dbf23e 100644
--- a/basic/source/runtime/step1.cxx
+++ b/basic/source/runtime/step1.cxx
@@ -41,15 +41,15 @@
bool checkUnoObjectType( SbUnoObject* refVal, const ::rtl::OUString& aClass );
-// Laden einer numerischen Konstanten (+ID)
+// loading a numeric constant (+ID)
void SbiRuntime::StepLOADNC( sal_uInt32 nOp1 )
{
SbxVariable* p = new SbxVariable( SbxDOUBLE );
- // #57844 Lokalisierte Funktion benutzen
+ // #57844 use localized function
String aStr = pImg->GetString( static_cast<short>( nOp1 ) );
- // Auch , zulassen !!!
+ // also allow , !!!
sal_uInt16 iComma = aStr.Search( ',' );
if( iComma != STRING_NOTFOUND )
{
@@ -65,7 +65,7 @@ void SbiRuntime::StepLOADNC( sal_uInt32 nOp1 )
PushVar( p );
}
-// Laden einer Stringkonstanten (+ID)
+// loading a string constant (+ID)
void SbiRuntime::StepLOADSC( sal_uInt32 nOp1 )
{
@@ -83,7 +83,7 @@ void SbiRuntime::StepLOADI( sal_uInt32 nOp1 )
PushVar( p );
}
-// Speichern eines named Arguments in Argv (+Arg-Nr ab 1!)
+// stora a named argument in Argv (+Arg-no. from 1!)
void SbiRuntime::StepARGN( sal_uInt32 nOp1 )
{
@@ -98,7 +98,7 @@ void SbiRuntime::StepARGN( sal_uInt32 nOp1 )
// named variables ( that are Any especially properties ) can be empty at this point and need a broadcast
if ( pVal->GetType() == SbxEMPTY )
pVal->Broadcast( SBX_HINT_DATAWANTED );
- // Methoden und Properties evaluieren!
+ // evaluate methods and properties!
SbxVariable* pRes = new SbxVariable( *pVal );
pVal = pRes;
}
@@ -107,7 +107,7 @@ void SbiRuntime::StepARGN( sal_uInt32 nOp1 )
}
}
-// Konvertierung des Typs eines Arguments in Argv fuer DECLARE-Fkt. (+Typ)
+// converting the type of an argument in Argv for DECLARE-Fkt. (+type)
void SbiRuntime::StepARGTYP( sal_uInt32 nOp1 )
{
@@ -115,44 +115,44 @@ void SbiRuntime::StepARGTYP( sal_uInt32 nOp1 )
StarBASIC::FatalError( SbERR_INTERNAL_ERROR );
else
{
- sal_Bool bByVal = (nOp1 & 0x8000) != 0; // Ist BYVAL verlangt?
+ sal_Bool bByVal = (nOp1 & 0x8000) != 0; // Ist BYVAL requested?
SbxDataType t = (SbxDataType) (nOp1 & 0x7FFF);
- SbxVariable* pVar = refArgv->Get( refArgv->Count() - 1 ); // letztes Arg
+ SbxVariable* pVar = refArgv->Get( refArgv->Count() - 1 ); // last Arg
- // BYVAL pr�fen
- if( pVar->GetRefCount() > 2 ) // 2 ist normal f�r BYVAL
+ // check BYVAL
+ if( pVar->GetRefCount() > 2 ) // 2 is normal for BYVAL
{
- // Parameter ist eine Referenz
+ // parameter is a reference
if( bByVal )
{
- // Call by Value ist verlangt -> Kopie anlegen
+ // Call by Value is requested -> create a copy
pVar = new SbxVariable( *pVar );
pVar->SetFlag( SBX_READWRITE );
refExprStk->Put( pVar, refArgv->Count() - 1 );
}
else
- pVar->SetFlag( SBX_REFERENCE ); // Ref-Flag f�r DllMgr
+ pVar->SetFlag( SBX_REFERENCE ); // Ref-Flag for DllMgr
}
else
{
- // Parameter ist KEINE Referenz
+ // parameter is NO reference
if( bByVal )
- pVar->ResetFlag( SBX_REFERENCE ); // Keine Referenz -> OK
+ pVar->ResetFlag( SBX_REFERENCE ); // no reference -> OK
else
- Error( SbERR_BAD_PARAMETERS ); // Referenz verlangt
+ Error( SbERR_BAD_PARAMETERS ); // reference needed
}
if( pVar->GetType() != t )
{
- // Variant, damit richtige Konvertierung
- // Ausserdem Fehler, wenn SbxBYREF
+ // variant for correct conversion
+ // besides error, if SbxBYREF
pVar->Convert( SbxVARIANT );
pVar->Convert( t );
}
}
}
-// String auf feste Laenge bringen (+Laenge)
+// bring string to a definite length (+length)
void SbiRuntime::StepPAD( sal_uInt32 nOp1 )
{
@@ -164,7 +164,7 @@ void SbiRuntime::StepPAD( sal_uInt32 nOp1 )
s.Expand( static_cast<xub_StrLen>( nOp1 ), ' ' );
}
-// Sprung (+Target)
+// jump (+target)
void SbiRuntime::StepJUMP( sal_uInt32 nOp1 )
{
@@ -177,7 +177,7 @@ void SbiRuntime::StepJUMP( sal_uInt32 nOp1 )
pCode = (const sal_uInt8*) pImg->GetCode() + nOp1;
}
-// TOS auswerten, bedingter Sprung (+Target)
+// evaluate TOS, conditional jump (+target)
void SbiRuntime::StepJUMPT( sal_uInt32 nOp1 )
{
@@ -186,7 +186,7 @@ void SbiRuntime::StepJUMPT( sal_uInt32 nOp1 )
StepJUMP( nOp1 );
}
-// TOS auswerten, bedingter Sprung (+Target)
+// evaluate TOS, conditional jump (+target)
void SbiRuntime::StepJUMPF( sal_uInt32 nOp1 )
{
@@ -197,13 +197,13 @@ void SbiRuntime::StepJUMPF( sal_uInt32 nOp1 )
StepJUMP( nOp1 );
}
-// TOS auswerten, Sprung in JUMP-Tabelle (+MaxVal)
-// Sieht so aus:
+// evaluate TOS, jump into JUMP-table (+MaxVal)
+// looks like this:
// ONJUMP 2
// JUMP target1
// JUMP target2
// ...
-//Falls im Operanden 0x8000 gesetzt ist, Returnadresse pushen (ON..GOSUB)
+// if 0x8000 is set in the operand, push the return address (ON..GOSUB)
void SbiRuntime::StepONJUMP( sal_uInt32 nOp1 )
{
@@ -220,7 +220,7 @@ void SbiRuntime::StepONJUMP( sal_uInt32 nOp1 )
StepJUMP( nOp1 );
}
-// UP-Aufruf (+Target)
+// UP-call (+target)
void SbiRuntime::StepGOSUB( sal_uInt32 nOp1 )
{
@@ -230,7 +230,7 @@ void SbiRuntime::StepGOSUB( sal_uInt32 nOp1 )
pCode = (const sal_uInt8*) pImg->GetCode() + nOp1;
}
-// UP-Return (+0 oder Target)
+// UP-return (+0 or target)
void SbiRuntime::StepRETURN( sal_uInt32 nOp1 )
{
@@ -239,7 +239,7 @@ void SbiRuntime::StepRETURN( sal_uInt32 nOp1 )
StepJUMP( nOp1 );
}
-// FOR-Variable testen (+Endlabel)
+// check FOR-variable (+Endlabel)
void SbiRuntime::StepTESTFOR( sal_uInt32 nOp1 )
{
@@ -357,7 +357,6 @@ void SbiRuntime::StepCASETO( sal_uInt32 nOp1 )
}
}
-// Fehler-Handler
void SbiRuntime::StepERRHDL( sal_uInt32 nOp1 )
{
@@ -372,11 +371,11 @@ void SbiRuntime::StepERRHDL( sal_uInt32 nOp1 )
SbxErrObject::getUnoErrObject()->Clear();
}
-// Resume nach Fehlern (+0=statement, 1=next or Label)
+// Resume after errors (+0=statement, 1=next or Label)
void SbiRuntime::StepRESUME( sal_uInt32 nOp1 )
{
- // #32714 Resume ohne Error? -> Fehler
+ // #32714 Resume without error? -> error
if( !bInError )
{
Error( SbERR_BAD_RESUME );
@@ -384,7 +383,7 @@ void SbiRuntime::StepRESUME( sal_uInt32 nOp1 )
}
if( nOp1 )
{
- // Code-Zeiger auf naechstes Statement setzen
+ // set Code-pointer to the next statement
sal_uInt16 n1, n2;
pCode = pMod->FindNextStmnt( pErrCode, n1, n2, sal_True, pImg );
}
@@ -401,13 +400,13 @@ void SbiRuntime::StepRESUME( sal_uInt32 nOp1 )
nError = 0;
bInError = sal_False;
- // Error-Stack loeschen
+
SbErrorStack*& rErrStack = GetSbData()->pErrStack;
delete rErrStack;
rErrStack = NULL;
}
-// Kanal schliessen (+Kanal, 0=Alle)
+// close channel (+channel, 0=all)
void SbiRuntime::StepCLOSE( sal_uInt32 nOp1 )
{
SbError err;
@@ -425,7 +424,7 @@ void SbiRuntime::StepCLOSE( sal_uInt32 nOp1 )
Error( err );
}
-// Zeichen ausgeben (+char)
+// output character (+char)
void SbiRuntime::StepPRCHAR( sal_uInt32 nOp1 )
{
@@ -434,7 +433,7 @@ void SbiRuntime::StepPRCHAR( sal_uInt32 nOp1 )
Error( pIosys->GetError() );
}
-// Check, ob TOS eine bestimmte Objektklasse ist (+StringID)
+// check whether TOS is a certain object class (+StringID)
bool SbiRuntime::implIsClass( SbxObject* pObj, const ::rtl::OUString& aClass )
{
@@ -551,16 +550,16 @@ void SbiRuntime::StepTESTCLASS( sal_uInt32 nOp1 )
PushVar( pRet );
}
-// Library fuer anschliessenden Declare-Call definieren
+// define library for following declare-call
void SbiRuntime::StepLIB( sal_uInt32 nOp1 )
{
aLibName = pImg->GetString( static_cast<short>( nOp1 ) );
}
-// TOS wird um BASE erhoeht, BASE davor gepusht (+BASE)
-// Dieser Opcode wird vor DIM/REDIM-Anweisungen gepusht,
-// wenn nur ein Index angegeben wurde.
+// TOS is incremented by BASE, BASE is pushed before (+BASE)
+// This opcode is pushed before DIM/REDIM-commands,
+// if there's been only one index named.
void SbiRuntime::StepBASED( sal_uInt32 nOp1 )
{
@@ -573,8 +572,8 @@ void SbiRuntime::StepBASED( sal_uInt32 nOp1 )
p1->PutInteger( uBase );
if( !bCompatible )
x2->Compute( SbxPLUS, *p1 );
- PushVar( x2 ); // erst die Expr
- PushVar( p1 ); // dann die Base
+ PushVar( x2 ); // first the Expr
+ PushVar( p1 ); // then the Base
}
diff --git a/basic/source/runtime/step2.cxx b/basic/source/runtime/step2.cxx
index 89c369a..3220ae9 100644
--- a/basic/source/runtime/step2.cxx
+++ b/basic/source/runtime/step2.cxx
@@ -52,9 +52,9 @@ using com::sun::star::uno::Reference;
SbxVariable* getVBAConstant( const String& rName );
-// Suchen eines Elements
-// Die Bits im String-ID:
-// 0x8000 - Argv ist belegt
+
+// the bits in the String-ID:
+// 0x8000 - Argv is reserved
SbxVariable* SbiRuntime::FindElement
( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, SbError nNotFound, sal_Bool bLocal, sal_Bool bStatic )
@@ -106,7 +106,6 @@ SbxVariable* SbiRuntime::FindElement
}
if( !pElem )
{
- // Die RTL brauchen wir nicht mehr zu durchsuchen!
sal_Bool bSave = rBasic.bNoRtl;
rBasic.bNoRtl = sal_True;
pElem = pObj->Find( aName, SbxCLASS_DONTCARE );
@@ -125,7 +124,7 @@ SbxVariable* SbiRuntime::FindElement
}
rBasic.bNoRtl = bSave;
- // Ist es ein globaler Uno-Bezeichner?
+ // is it a global uno-identifier?
if( bLocal && !pElem )
{
bool bSetName = true; // preserve normal behaviour
@@ -144,8 +143,8 @@ SbxVariable* SbiRuntime::FindElement
if( !pElem )
{
- // #72382 VORSICHT! Liefert jetzt wegen unbekannten
- // Modulen IMMER ein Ergebnis!
+ // #72382 ATTENTION! ALWAYS returns a result now
+ // because of unknown modules!
SbUnoClass* pUnoClass = findUnoClass( aName );
if( pUnoClass )
{
@@ -156,18 +155,18 @@ SbxVariable* SbiRuntime::FindElement
}
}
- // #62939 Wenn eine Uno-Klasse gefunden wurde, muss
- // das Wrapper-Objekt gehalten werden, da sonst auch
- // die Uno-Klasse, z.B. "stardiv" immer wieder neu
- // aus der Registry gelesen werden muss
+ // #62939 If an uno-class has been found, the wrapper
+ // object has to be held, because the uno-class, e. g.
+ // "stardiv", has to be read out of the registry
+ // every time again otherwise
if( pElem )
{
- // #63774 Darf nicht mit gespeichert werden!!!
+ // #63774 May not be saved too!!!
pElem->SetFlag( SBX_DONTSTORE );
pElem->SetFlag( SBX_NO_MODIFY);
- // #72382 Lokal speichern, sonst werden alle implizit
- // deklarierten Vars automatisch global !
+ // #72382 save locally, all variables that have been declared
+ // implicit would become global automatically otherwise!
if ( bSetName )
pElem->SetName( aName );
refLocals->Put( pElem, refLocals->Count() );
@@ -176,32 +175,30 @@ SbxVariable* SbiRuntime::FindElement
if( !pElem )
{
- // Nicht da und nicht im Objekt?
- // Hat das Ding Parameter, nicht einrichten!
+ // not there and not in the object?
+ // don't establish if that thing has parameters!
if( nOp1 & 0x8000 )
bFatalError = sal_True;
- // Sonst, falls keine Parameter sind, anderen Error Code verwenden
+ // else, if there are parameters, use different error code
if( !bLocal || pImg->GetFlag( SBIMG_EXPLICIT ) )
{
- // #39108 Bei explizit und als ELEM immer ein Fatal Error
+ // #39108 if explicit and as ELEM always a fatal error
bFatalError = sal_True;
- // Falls keine Parameter sind, anderen Error Code verwenden
+
if( !( nOp1 & 0x8000 ) && nNotFound == SbERR_PROC_UNDEFINED )
nNotFound = SbERR_VAR_UNDEFINED;
}
if( bFatalError )
{
- // #39108 Statt FatalError zu setzen, Dummy-Variable liefern
+ // #39108 use dummy variable instead of fatal error
if( !xDummyVar.Is() )
xDummyVar = new SbxVariable( SbxVARIANT );
pElem = xDummyVar;
- // Parameter von Hand loeschen
ClearArgvStack();
- // Normalen Error setzen
Error( nNotFound, aName );
}
else
@@ -210,7 +207,6 @@ SbxVariable* SbiRuntime::FindElement
pElem = StepSTATIC_Impl( aName, t );
if ( !pElem )
{
- // Sonst Variable neu anlegen
pElem = new SbxVariable( t );
if( t != SbxVARIANT )
pElem->SetFlag( SBX_FIXED );
@@ -220,15 +216,14 @@ SbxVariable* SbiRuntime::FindElement
}
}
}
- // #39108 Args koennen schon geloescht sein!
+ // #39108 Args can already be deleted!
if( !bFatalError )
SetupArgs( pElem, nOp1 );
- // Ein bestimmter Call-Type wurde gewuenscht, daher muessen
- // wir hier den Typ setzen und das Ding anfassen, um den
- // korrekten Returnwert zu erhalten!
+
+ // because a particular call-type is requested
if( pElem->IsA( TYPE(SbxMethod) ) )
{
- // Soll der Typ konvertiert werden?
+ // shall the type be converted?
SbxDataType t2 = pElem->GetType();
sal_Bool bSet = sal_False;
if( !( pElem->GetFlags() & SBX_FIXED ) )
@@ -237,75 +232,70 @@ SbxVariable* SbiRuntime::FindElement
t >= SbxINTEGER && t <= SbxSTRING )
pElem->SetType( t ), bSet = sal_True;
}
- // pElem auf eine Ref zuweisen, um ggf. eine Temp-Var zu loeschen
+ // assign pElem to a Ref, to delete a temp-var if applicable
SbxVariableRef refTemp = pElem;
- // Moegliche Reste vom letzten Aufruf der SbxMethod beseitigen
- // Vorher Schreiben freigeben, damit kein Error gesetzt wird.
+ // remove potential rests of the last call of the SbxMethod
+ // free Write before, so that there's no error
sal_uInt16 nSavFlags = pElem->GetFlags();
pElem->SetFlag( SBX_READWRITE | SBX_NO_BROADCAST );
pElem->SbxValue::Clear();
pElem->SetFlags( nSavFlags );
- // Erst nach dem Setzen anfassen, da z.B. LEFT()
- // den Unterschied zwischen Left$() und Left() kennen muss
+ // don't touch before setting, as e. g. LEFT()
+ // has to know the difference between Left$() and Left()
- // Da in PopVar() die Parameter von Methoden weggehauen
- // werden, muessen wir hier explizit eine neue SbxMethod anlegen
- SbxVariable* pNew = new SbxMethod( *((SbxMethod*)pElem) ); // das ist der Call!
- //ALT: SbxVariable* pNew = new SbxVariable( *pElem ); // das ist der Call!
+ // because the methods' parameters are cut away in PopVar()
+ SbxVariable* pNew = new SbxMethod( *((SbxMethod*)pElem) );
+ //OLD: SbxVariable* pNew = new SbxVariable( *pElem );
- pElem->SetParameters(0); // sonst bleibt Ref auf sich selbst
+ pElem->SetParameters(0);
pNew->SetFlag( SBX_READWRITE );
- // den Datentypen zuruecksetzen?
if( bSet )
pElem->SetType( t2 );
pElem = pNew;
}
- // Index-Access bei UnoObjekten beruecksichtigen
+ // consider index-access for UnoObjects
// definitely we want this for VBA where properties are often
// collections ( which need index access ), but lets only do
// this if we actually have params following
else if( bVBAEnabled && pElem->ISA(SbUnoProperty) && pElem->GetParameters() )
{
- // pElem auf eine Ref zuweisen, um ggf. eine Temp-Var zu loeschen
SbxVariableRef refTemp = pElem;
- // Variable kopieren und dabei den Notify aufloesen
- SbxVariable* pNew = new SbxVariable( *((SbxVariable*)pElem) ); // das ist der Call!
- pElem->SetParameters( NULL ); // sonst bleibt Ref auf sich selbst
+ // dissolve the notify while copying variable
+ SbxVariable* pNew = new SbxVariable( *((SbxVariable*)pElem) );
+ pElem->SetParameters( NULL );
pElem = pNew;
}
}
return CheckArray( pElem );
}
-// Find-Funktion ueber Name fuer aktuellen Scope (z.B. Abfrage aus BASIC-IDE)
+// for current scope (e. g. query from BASIC-IDE)
SbxBase* SbiRuntime::FindElementExtern( const String& rName )
{
- // Hinweis zu: Es darf nicht davon ausgegangen werden, dass
- // pMeth != null, da im RunInit noch keine gesetzt ist.
+ // don't expect pMeth to be != 0, as there are none set
+ // in the RunInit yet
SbxVariable* pElem = NULL;
if( !pMod || !rName.Len() )
return NULL;
- // Lokal suchen
if( refLocals )
pElem = refLocals->Find( rName, SbxCLASS_DONTCARE );
- // In Statics suchen
if ( !pElem && pMeth )
{
- // Bei Statics, Name der Methode davor setzen
+ // for statics, set the method's name in front
String aMethName = pMeth->GetName();
aMethName += ':';
aMethName += rName;
pElem = pMod->Find(aMethName, SbxCLASS_DONTCARE);
}
- // In Parameter-Liste suchen
+ // search in parameter list
if( !pElem && pMeth )
{
SbxInfo* pInfo = pMeth->GetInfo();
@@ -335,10 +325,9 @@ SbxBase* SbiRuntime::FindElementExtern( const String& rName )
}
}
- // Im Modul suchen
+ // search in module
if( !pElem )
{
- // RTL nicht durchsuchen!
sal_Bool bSave = rBasic.bNoRtl;
rBasic.bNoRtl = sal_True;
pElem = pMod->Find( rName, SbxCLASS_DONTCARE );
@@ -348,9 +337,6 @@ SbxBase* SbiRuntime::FindElementExtern( const String& rName )
}
-// Argumente eines Elements setzen
-// Dabei auch die Argumente umsetzen, falls benannte Parameter
-// verwendet wurden
void SbiRuntime::SetupArgs( SbxVariable* p, sal_uInt32 nOp1 )
{
@@ -370,9 +356,6 @@ void SbiRuntime::SetupArgs( SbxVariable* p, sal_uInt32 nOp1 )
}
if( bHasNamed )
{
- // Wir haben mindestens einen benannten Parameter!
- // Wir muessen also umsortieren
- // Gibt es Parameter-Infos?
SbxInfo* pInfo = p->GetInfo();
if( !pInfo )
{
@@ -449,7 +432,7 @@ void SbiRuntime::SetupArgs( SbxVariable* p, sal_uInt32 nOp1 )
const String& rName = refArgv->GetAlias( i );
if( rName.Len() )
{
- // nCurPar wird auf den gefundenen Parameter gesetzt
+ // nCurPar is set to the found parameter
sal_uInt16 j = 1;
const SbxParamInfo* pParam = pInfo->GetParam( j );
while( pParam )
@@ -471,7 +454,7 @@ void SbiRuntime::SetupArgs( SbxVariable* p, sal_uInt32 nOp1 )
refArgv = pArg;
}
}
- // Eigene Var als Parameter 0
+ // own var as parameter 0
refArgv->Put( p, 0 );
p->SetParameters( refArgv );
PopArgv();
@@ -480,11 +463,10 @@ void SbiRuntime::SetupArgs( SbxVariable* p, sal_uInt32 nOp1 )
p->SetParameters( NULL );
}
-// Holen eines Array-Elements
+// getting an array element
SbxVariable* SbiRuntime::CheckArray( SbxVariable* pElem )
{
- // Falls wir ein Array haben, wollen wir bitte das Array-Element!
SbxArray* pPar;
if( ( pElem->GetType() & SbxARRAY ) && (SbxVariable*)refRedim != pElem )
{
@@ -493,8 +475,8 @@ SbxVariable* SbiRuntime::CheckArray( SbxVariable* pElem )
pPar = pElem->GetParameters();
if( pDimArray )
{
- // Die Parameter koennen fehlen, wenn ein Array als
- // Argument uebergeben wird.
+ // parameters may be missing, if an array is
+ // passed as an argument
if( pPar )
pElem = pDimArray->Get( pPar );
}
@@ -513,17 +495,17 @@ SbxVariable* SbiRuntime::CheckArray( SbxVariable* pElem )
}
}
- // #42940, 0.Parameter zu NULL setzen, damit sich Var nicht selbst haelt
+ // #42940, set parameter 0 to NULL so that var doesn't contain itself
if( pPar )
pPar->Put( NULL, 0 );
}
- // Index-Access bei UnoObjekten beruecksichtigen
+ // consider index-access for UnoObjects
else if( pElem->GetType() == SbxOBJECT && !pElem->ISA(SbxMethod) && ( !bVBAEnabled || ( bVBAEnabled && !pElem->ISA(SbxProperty) ) ) )
{
pPar = pElem->GetParameters();
if ( pPar )
{
- // Ist es ein Uno-Objekt?
+ // is it an uno-object?
SbxBaseRef pObj = (SbxBase*)pElem->GetObject();
if( pObj )
{
@@ -538,7 +520,6 @@ SbxVariable* SbiRuntime::CheckArray( SbxVariable* pElem )
Reference< XIndexAccess > xIndexAccess( x, UNO_QUERY );
if ( !bVBAEnabled )
{
- // Haben wir Index-Access?
if( xIndexAccess.is() )
{
sal_uInt32 nParamCount = (sal_uInt32)pPar->Count() - 1;
@@ -548,7 +529,7 @@ SbxVariable* SbiRuntime::CheckArray( SbxVariable* pElem )
return pElem;
}
- // Index holen
+ // get index
sal_Int32 nIndex = pPar->Get( 1 )->GetLong();
Reference< XInterface > xRet;
try
@@ -560,18 +541,18 @@ SbxVariable* SbiRuntime::CheckArray( SbxVariable* pElem )
}
catch (const IndexOutOfBoundsException&)
{
- // Bei Exception erstmal immer von Konvertierungs-Problem ausgehen
+ // usually expect converting problem
StarBASIC::Error( SbERR_OUT_OF_RANGE );
}
- // #57847 Immer neue Variable anlegen, sonst Fehler
- // durch PutObject(NULL) bei ReadOnly-Properties.
+ // #57847 always create a new variable, else error
+ // due to PutObject(NULL) at ReadOnly-properties
pElem = new SbxVariable( SbxVARIANT );
if( xRet.is() )
{
aAny <<= xRet;
- // #67173 Kein Namen angeben, damit echter Klassen-Namen eintragen wird
+ // #67173 don't specify a name so that the real class name is entered
String aName;
SbxObjectRef xWrapper = (SbxObject*)new SbUnoObject( aName, aAny );
pElem->PutObject( xWrapper );
@@ -607,7 +588,7 @@ SbxVariable* SbiRuntime::CheckArray( SbxVariable* pElem )
}
}
- // #42940, 0.Parameter zu NULL setzen, damit sich Var nicht selbst haelt
+ // #42940, set parameter 0 to NULL so that var doesn't contain itself
pPar->Put( NULL, 0 );
}
else if( pObj->ISA(BasicCollection) )
@@ -630,7 +611,7 @@ SbxVariable* SbiRuntime::CheckArray( SbxVariable* pElem )
return pElem;
}
-// Laden eines Elements aus der Runtime-Library (+StringID+Typ)
+// loading an element from the runtime-library (+StringID+type)
void SbiRuntime::StepRTL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
@@ -644,7 +625,7 @@ SbiRuntime::StepFIND_Impl( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, Sb
refLocals = new SbxArray;
PushVar( FindElement( pObj, nOp1, nOp2, nNotFound, bLocal, bStatic ) );
}
-// Laden einer lokalen/globalen Variablen (+StringID+Typ)
+// loading a local/global variable (+StringID+type)
void SbiRuntime::StepFIND( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
@@ -670,12 +651,11 @@ void SbiRuntime::StepFIND_STATIC( sal_uInt32 nOp1, sal_uInt32 nOp2 )
StepFIND_Impl( pMod, nOp1, nOp2, SbERR_PROC_UNDEFINED, sal_True, sal_True );
}
-// Laden eines Objekt-Elements (+StringID+Typ)
-// Das Objekt liegt auf TOS
+// loading an object-element (+StringID+type)
+// the object lies on TOS
void SbiRuntime::StepELEM( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
- // Liegt auf dem TOS ein Objekt?
SbxVariableRef pObjVar = PopVar();
SbxObject* pObj = PTR_CAST(SbxObject,(SbxVariable*) pObjVar);
@@ -685,20 +665,20 @@ void SbiRuntime::StepELEM( sal_uInt32 nOp1, sal_uInt32 nOp2 )
pObj = PTR_CAST(SbxObject,pObjVarObj);
}
- // #56368 Bei StepElem Referenz sichern, sonst koennen Objekte
- // in Qualifizierungsketten wie ActiveComponent.Selection(0).Text
- // zu fueh die Referenz verlieren
- // #74254 Jetzt per Liste
+ // #56368 save reference at StepElem, otherwise objects could
+ // lose their reference too early in qualification chains like
+ // ActiveComponent.Selection(0).Text
+ // #74254 now per list
if( pObj )
SaveRef( (SbxVariable*)pObj );
PushVar( FindElement( pObj, nOp1, nOp2, SbERR_NO_METHOD, sal_False ) );
}
-// Laden eines Parameters (+Offset+Typ)
-// Wenn der Datentyp nicht stimmen sollte, eine Kopie anlegen
-// Der Datentyp SbxEMPTY zeigt an, daa kein Parameter angegeben ist.
-// Get( 0 ) darf EMPTY sein
+// loading a parameter (+offset+type)
+// If the data type is wrong, create a copy.
+// The data type SbxEMPTY shows that no parameters are given.
+// Get( 0 ) may be EMPTY
void SbiRuntime::StepPARAM( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
@@ -706,7 +686,7 @@ void SbiRuntime::StepPARAM( sal_uInt32 nOp1, sal_uInt32 nOp2 )
SbxDataType t = (SbxDataType) nOp2;
SbxVariable* p;
- // #57915 Missing sauberer loesen
+ // #57915 solve missing in a cleaner way
sal_uInt16 nParamCount = refParams->Count();
if( i >= nParamCount )
{
@@ -724,7 +704,7 @@ void SbiRuntime::StepPARAM( sal_uInt32 nOp1, sal_uInt32 nOp2 )
p->PutString( String() );
}
else
- p->PutErr( 448 ); // Wie in VB: Error-Code 448 (SbERR_NAMED_NOT_FOUND)
+ p->PutErr( 448 ); // like in VB: Error-Code 448 (SbERR_NAMED_NOT_FOUND)
refParams->Put( p, iLoop );
iLoop--;
@@ -734,7 +714,7 @@ void SbiRuntime::StepPARAM( sal_uInt32 nOp1, sal_uInt32 nOp2 )
if( p->GetType() == SbxERROR && ( i ) )
{
- // Wenn ein Parameter fehlt, kann er OPTIONAL sein
+ // if there's a parameter missing, it can be OPTIONAL
sal_Bool bOpt = sal_False;
if( pMeth )
{
@@ -789,8 +769,8 @@ void SbiRuntime::StepCASEIS( sal_uInt32 nOp1, sal_uInt32 nOp2 )
}
}
-// Aufruf einer DLL-Prozedur (+StringID+Typ)
-// Auch hier zeigt das MSB des StringIDs an, dass Argv belegt ist
+// call of a DLL-procedure (+StringID+type)
+// the StringID's MSB shows that Argv is occupied
void SbiRuntime::StepCALL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
@@ -804,8 +784,7 @@ void SbiRuntime::StepCALL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
PopArgv();
}
-// Aufruf einer DLL-Prozedur nach CDecl (+StringID+Typ)
-// Auch hier zeigt das MSB des StringIDs an, dass Argv belegt ist
+// call of a DLL-procedure after CDecl (+StringID+type)
void SbiRuntime::StepCALLC( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
@@ -820,12 +799,12 @@ void SbiRuntime::StepCALLC( sal_uInt32 nOp1, sal_uInt32 nOp2 )
}
-// Beginn eines Statements (+Line+Col)
+// beginning of a statement (+Line+Col)
void SbiRuntime::StepSTMNT( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
- // Wenn der Expr-Stack am Anfang einen Statements eine Variable enthaelt,
- // hat ein Trottel X als Funktion aufgerufen, obwohl es eine Variable ist!
+ // If the Expr-Stack at the beginning of a statement constains a variable,
+ // some fool has called X as a function, although it's a variable!
sal_Bool bFatalExpr = sal_False;
String sUnknownMethodName;
if( nExprLvl > 1 )
@@ -840,13 +819,13 @@ void SbiRuntime::StepSTMNT( sal_uInt32 nOp1, sal_uInt32 nOp2 )
bFatalExpr = sal_True;
}
}
- // Der Expr-Stack ist nun nicht mehr notwendig
+
ClearExprStack();
ClearRefs();
- // Wir muessen hier hart abbrechen, da sonst Zeile und Spalte nicht mehr
- // stimmen!
+ // We have to cancel hard here because line and column
+ // would be wrong later otherwise!
if( bFatalExpr)
{
StarBASIC::FatalError( SbERR_NO_METHOD, sUnknownMethodName );
@@ -856,13 +835,11 @@ void SbiRuntime::StepSTMNT( sal_uInt32 nOp1, sal_uInt32 nOp2 )
sal_uInt16 nOld = nLine;
nLine = static_cast<short>( nOp1 );
- // #29955 & 0xFF, um for-Schleifen-Ebene wegzufiltern
+ // #29955 & 0xFF, to filter out for-loop-level
nCol1 = static_cast<short>( nOp2 & 0xFF );
- // Suchen des naechsten STMNT-Befehls,
- // um die End-Spalte dieses Statements zu setzen
- // Searches of the next STMNT instruction,
- // around the final column of this statement to set
+ // find the next STMNT-command to set the final column
+ // of this statement
nCol2 = 0xffff;
sal_uInt16 n1, n2;
@@ -871,37 +848,36 @@ void SbiRuntime::StepSTMNT( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
if( n1 == nOp1 )
{
- // #29955 & 0xFF, um for-Schleifen-Ebene wegzufiltern
+ // #29955 & 0xFF, to filter out for-loop-level
nCol2 = (n2 & 0xFF) - 1;
}
}
- // #29955 for-Schleifen-Ebene korrigieren, #67452 NICHT im Error-Handler sonst Chaos
+ // #29955 correct for-loop-level, #67452 NOT in the error-handler
if( !bInError )
{
- // (Bei Spr�ngen aus Schleifen tritt hier eine Differenz auf)
+ // (there's a difference here in case of a jump out of a loop)
sal_uInt16 nExspectedForLevel = static_cast<sal_uInt16>( nOp2 / 0x100 );
if( pGosubStk )
nExspectedForLevel = nExspectedForLevel + pGosubStk->nStartForLvl;
- // Wenn der tatsaechliche For-Level zu klein ist, wurde aus
- // einer Schleife heraus gesprungen -> korrigieren
+ // if the actual for-level is too small it'd jump out
+ // of a loop -> corrected
while( nForLvl > nExspectedForLevel )
PopFor();
}
- // 16.10.96: #31460 Neues Konzept fuer StepInto/Over/Out
- // Erkl�rung siehe bei _ImplGetBreakCallLevel.
+ // 16.10.96: #31460 new concept for StepInto/Over/Out
+ // see explanation at _ImplGetBreakCallLevel
if( pInst->nCallLvl <= pInst->nBreakCallLvl )
{
StarBASIC* pStepBasic = GetCurrentBasic( &rBasic );
sal_uInt16 nNewFlags = pStepBasic->StepPoint( nLine, nCol1, nCol2 );
- // Neuen BreakCallLevel ermitteln
pInst->CalcBreakCallLevel( nNewFlags );
}
- // Breakpoints nur bei STMNT-Befehlen in neuer Zeile!
+ // break points only at STMNT-commands in a new line!
else if( ( nOp1 != nOld )
&& ( nFlags & SbDEBUG_BREAK )
&& pMod->IsBP( static_cast<sal_uInt16>( nOp1 ) ) )
@@ -909,15 +885,14 @@ void SbiRuntime::StepSTMNT( sal_uInt32 nOp1, sal_uInt32 nOp2 )
StarBASIC* pBreakBasic = GetCurrentBasic( &rBasic );
sal_uInt16 nNewFlags = pBreakBasic->BreakPoint( nLine, nCol1, nCol2 );
- // Neuen BreakCallLevel ermitteln
pInst->CalcBreakCallLevel( nNewFlags );
}
}
// (+SvStreamFlags+Flags)
-// Stack: Blocklaenge
-// Kanalnummer
-// Dateiname
+// Stack: block length
+// channel number
+// file name
void SbiRuntime::StepOPEN( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
@@ -932,7 +907,7 @@ void SbiRuntime::StepOPEN( sal_uInt32 nOp1, sal_uInt32 nOp2 )
Error( pIosys->GetError() );
}
-// Objekt kreieren (+StringID+StringID)
+// create object (+StringID+StringID)
void SbiRuntime::StepCREATE( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
@@ -944,7 +919,7 @@ void SbiRuntime::StepCREATE( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
String aName( pImg->GetString( static_cast<short>( nOp1 ) ) );
pObj->SetName( aName );
- // Das Objekt muss BASIC rufen koennen
+ // the object must be able to call the BASIC
pObj->SetParent( &rBasic );
SbxVariable* pNew = new SbxVariable;
pNew->PutObject( pObj );
@@ -983,14 +958,14 @@ void implCopyDimArray_DCREATE( SbxDimArray* pNewArray, SbxDimArray* pOldArray, s
}
}
-// #56204 Objekt-Array kreieren (+StringID+StringID), DCREATE == Dim-Create
+// #56204 create object array (+StringID+StringID), DCREATE == Dim-Create
void SbiRuntime::StepDCREATE_IMPL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
SbxVariableRef refVar = PopVar();
DimImpl( refVar );
- // Das Array mit Instanzen der geforderten Klasse fuellen
+ // fill the array with instances of the requested class
SbxBaseRef xObj = (SbxBase*)refVar->GetObject();
if( !xObj )
{
@@ -1004,11 +979,10 @@ void SbiRuntime::StepDCREATE_IMPL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
SbxBase* pObj = (SbxBase*)xObj;
pArray = (SbxDimArray*)pObj;
- // Dimensionen auswerten
short nDims = pArray->GetDims();
sal_Int32 nTotalSize = 0;
- // es muss ein eindimensionales Array sein
+ // must be a one-dimensional array
sal_Int32 nLower, nUpper, nSize;
sal_Int32 i;
for( i = 0 ; i < nDims ; i++ )
@@ -1021,7 +995,7 @@ void SbiRuntime::StepDCREATE_IMPL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
nTotalSize *= nSize;
}
- // Objekte anlegen und ins Array eintragen
+ // create objects and insert them into the array
String aClass( pImg->GetString( static_cast<short>( nOp2 ) ) );
for( i = 0 ; i < nTotalSize ; i++ )
{
@@ -1035,7 +1009,7 @@ void SbiRuntime::StepDCREATE_IMPL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
String aName( pImg->GetString( static_cast<short>( nOp1 ) ) );
pClassObj->SetName( aName );
- // Das Objekt muss BASIC rufen koennen
+ // the object must be able to call the basic
pClassObj->SetParent( &rBasic );
pArray->SbxArray::Put32( pClassObj, i );
}
@@ -1095,7 +1069,7 @@ void SbiRuntime::StepDCREATE_IMPL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
}
}
-// Objekt aus User-Type kreieren (+StringID+StringID)
+// create object from user-type (+StringID+StringID)
SbxObject* createUserTypeImpl( const String& rClassName ); // sb.cxx
@@ -1137,7 +1111,7 @@ void SbiRuntime::implHandleSbxFlags( SbxVariable* pVar, SbxDataType t, sal_uInt3
pVar->SetFlag( SBX_VAR_TO_DIM );
}
-// Einrichten einer lokalen Variablen (+StringID+Typ)
+// establishing a local variable (+StringID+type)
void SbiRuntime::StepLOCAL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
@@ -1154,7 +1128,7 @@ void SbiRuntime::StepLOCAL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
}
}
-// Einrichten einer modulglobalen Variablen (+StringID+Typ)
+// establishing a module-global variable (+StringID+type)
void SbiRuntime::StepPUBLIC_Impl( sal_uInt32 nOp1, sal_uInt32 nOp2, bool bUsedForClassModule )
{
@@ -1173,7 +1147,7 @@ void SbiRuntime::StepPUBLIC_Impl( sal_uInt32 nOp1, sal_uInt32 nOp2, bool bUsedFo
if( pProp )
{
pProp->SetFlag( SBX_DONTSTORE );
- // AB: 2.7.1996: HACK wegen 'Referenz kann nicht gesichert werden'
+ // from 2.7.1996: HACK because of 'reference can't be saved'
pProp->SetFlag( SBX_NO_MODIFY);
implHandleSbxFlags( pProp, t, nOp2 );
@@ -1196,7 +1170,7 @@ void SbiRuntime::StepPUBLIC_P( sal_uInt32 nOp1, sal_uInt32 nOp2 )
}
}
-// Einrichten einer globalen Variablen (+StringID+Typ)
+// establishing a global variable (+StringID+type)
void SbiRuntime::StepGLOBAL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
@@ -1227,7 +1201,7 @@ void SbiRuntime::StepGLOBAL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
if( p )
{
p->SetFlag( SBX_DONTSTORE );
- // AB: 2.7.1996: HACK wegen 'Referenz kann nicht gesichert werden'
+ // from 2.7.1996: HACK because of 'reference can't be saved'
p->SetFlag( SBX_NO_MODIFY);
}
}
@@ -1285,7 +1259,7 @@ SbxVariable* SbiRuntime::StepSTATIC_Impl( String& aName, SbxDataType& t )
}
return p;
}
-// Einrichten einer statischen Variablen (+StringID+Typ)
+// establishing a static variable (+StringID+type)
void SbiRuntime::StepSTATIC( sal_uInt32 nOp1, sal_uInt32 nOp2 )
{
String aName( pImg->GetString( static_cast<short>( nOp1 ) ) );
diff --git a/basic/source/sample/collelem.cxx b/basic/source/sample/collelem.cxx
index 80ee91d..0646c3e 100644
--- a/basic/source/sample/collelem.cxx
+++ b/basic/source/sample/collelem.cxx
@@ -33,13 +33,13 @@
#include <basic/sbx.hxx>
#include "collelem.hxx"
-// Das Sample-Element ist ein kleines Objekt, das die Properties
-// Name und Value enth„lt sowie die Methode Say, die den bergebenen
-// Text mit dem eigenen Namen verkoppelt und ausgibt.
+// The sample-element is a small object that contains the properties
+// name and value and the method say, which couples the passed text
+// with its own name and outputs it.
SampleElement::SampleElement( const String& r ) : SbxObject( r )
{
- // Methode Say mit einem String-Parameter
+ // method say with a string-parameter
SbxVariable* pMeth = Make( String( RTL_CONSTASCII_USTRINGPARAM("Say") ), SbxCLASS_METHOD, SbxEMPTY );
pMeth->SetUserData( 0x12345678 );
pMeth->ResetFlag( SBX_FIXED );
@@ -59,8 +59,8 @@ void SampleElement::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
sal_uIntPtr t = pHint->GetId();
if( t == SBX_HINT_DATAWANTED && pVar->GetUserData() == 0x12345678 )
{
- // Die Say-Methode:
- // 1 Parameter + Returnwert
+ // the say-method:
+ // 1 parameter + return value
if( !pPar_ || pPar_->Count() != 2 )
SetError( SbxERR_WRONG_ARGS );
else
diff --git a/basic/source/sample/object.cxx b/basic/source/sample/object.cxx
index 4322d5e..de802da 100644
--- a/basic/source/sample/object.cxx
+++ b/basic/source/sample/object.cxx
@@ -37,93 +37,90 @@
#include "object.hxx"
#include "collelem.hxx"
-// Das Sample-Objekt hat folgende Elemente:
+// The sample-object has got the following elements:
// 1) Properties:
-// Name der Name
-// Value ein double-Wert, beide bereits als Default drin
-// 2) Methoden:
-// Create Erzeugen eines neuen Unterelements
-// Display Ausgabe eines Textes
+// Name the name
+// Value a double-value, both already as default
+// 2) Methods:
+// Create creating a new sub-element
+// Display display a text
// Square Argument * Argument
-// Event Aufruf eines Basic-Eventhandlers
-// 3) Unterobjekte:
-// Per Create() kann ein neues Unterelement eingerichtet werden,
-// das indiziert werden kann, falls mehrere Objekte gleichen Namens
-// existieren.
-// Diese Implementation ist ein Beispiel fuer eine tabellengesteuerte
-// Version, die sehr viele Elemente enthalten kann. Die Elemente werden
-// je nach Bedarf aus der Tabelle in das Objekt uebernommen.
-// Die Collection findet sich in COLLECTN.*, die in der Collection
-// enthaltenen Objekte in COLLELEM.*
+// Event calling a basic event handler
+// 3) Subobjects:
+// With Create() a new sub-element can be established, which
+// can be indexed if multiple objects of the same name exist.
+// This implementation is an example for a table-controlled version,
+// which can contain a lot of elements. The elements are taken from
+// the table into the object as required.
+// The collection can be found in COLLECTN.*, the collection's
+// objects in COLLELEM.*
-// Das Sample-Objekt wird in ..\app\mybasic.cxx wie folgt in StarBASIC
-// eingebaut:
+// The sample-object is in ..\app\mybasic.cxx implemented as follows
+// in StarBASIC:
-// Das nArgs-Feld eines Tabelleneintrags ist wie folgt verschluesselt:
+// The nArgs-field of a table entry is encrypted as follows:
-#define _ARGSMASK 0x00FF // Bis zu 255 Argumente
-#define _RWMASK 0x0F00 // Maske fuer R/W-Bits
-#define _TYPEMASK 0xF000 // Maske fuer den Typ des Eintrags
+#define _ARGSMASK 0x00FF // up to 255 arguments
+#define _RWMASK 0x0F00 // mask for R/W-bits
+#define _TYPEMASK 0xF000 // mask for the entry's type
-#define _READ 0x0100 // kann gelesen werden
-#define _BWRITE 0x0200 // kann as Lvalue verwendet werden
-#define _LVALUE _BWRITE // kann as Lvalue verwendet werden
-#define _READWRITE 0x0300 // beides
-#define _OPT 0x0400 // sal_True: optionaler Parameter
-#define _METHOD 0x1000 // Masken-Bit fuer eine Methode
-#define _PROPERTY 0x2000 // Masken-Bit fuer eine Property
-#define _COLL 0x4000 // Masken-Bit fuer eine Collection
- // Kombination von oberen Bits:
-#define _FUNCTION 0x1100 // Maske fuer Function
-#define _LFUNCTION 0x1300 // Maske fuer Function, die auch als Lvalue geht
-#define _ROPROP 0x2100 // Maske Read Only-Property
-#define _WOPROP 0x2200 // Maske Write Only-Property
-#define _RWPROP 0x2300 // Maske Read/Write-Property
-#define _COLLPROP 0x4100 // Maske Read-Collection-Element
+#define _READ 0x0100 // can be read
+#define _BWRITE 0x0200 // can be used as Lvalue
+#define _LVALUE _BWRITE // can be used as Lvalue
+#define _READWRITE 0x0300 // both
+#define _OPT 0x0400 // sal_True: optional parameter
+#define _METHOD 0x1000 // mask-bit for a method
+#define _PROPERTY 0x2000 // mask-bit for a property
+#define _COLL 0x4000 // mask-bit for a collection
+ // combination of the bits above:
+#define _FUNCTION 0x1100 // mask for function
+#define _LFUNCTION 0x1300 // mask for function that also works as Lvalue
+#define _ROPROP 0x2100 // mask Read Only-Property
+#define _WOPROP 0x2200 // mask Write Only-Property
+#define _RWPROP 0x2300 // mask Read/Write-Property
+#define _COLLPROP 0x4100 // mask Read-Collection-Element
-#define COLLNAME "Elements" // Name der Collection, hier mal hart verdrahtet
+#define COLLNAME "Elements" // the collection's name, wired hard here
SampleObject::Methods SampleObject::aMethods[] = {
-// Eine Sample-Methode (der Returnwert ist SbxNULL)
+// a sample-method (the return value is SbxNULL)
{ "Display", SbxEMPTY, &SampleObject::Display, 1 | _FUNCTION },
- // Ein Named Parameter
+ // a named parameter
{ "message", SbxSTRING, NULL, 0 },
-// Eine Sample-Funktion
+// a sample-function
{ "Square", SbxDOUBLE, &SampleObject::Square, 1 | _FUNCTION },
- // Ein Named Parameter
+ // a named parameter
{ "value", SbxDOUBLE, NULL, 0 },
// Basic-Callback
{ "Event", SbxEMPTY, &SampleObject::Event, 1 | _FUNCTION },
- // Ein Named Parameter
+ // a named parameter
{ "event", SbxSTRING, NULL, 0 },
-// Element erzeugen
+// create element
{ "Create", SbxEMPTY, &SampleObject::Create, 1 | _FUNCTION },
- // Ein Named Parameter
+ // a named parameter
{ "name", SbxSTRING, NULL, 0 },
-{ NULL, SbxNULL, NULL, -1 }}; // Tabellenende
+{ NULL, SbxNULL, NULL, -1 }}; // end of the table
SampleObject::SampleObject( const String& rClass ) : SbxObject( rClass )
{
SetName( String( RTL_CONSTASCII_USTRINGPARAM("Sample") ) );
- PutDouble( 1.0 ); // Startwert fuer Value
+ PutDouble( 1.0 );
}
-// Suche nach einem Element:
-// Hier wird linear durch die Methodentabelle gegangen, bis eine
-// passende Methode gefunden wurde.
-// Wenn die Methode/Property nicht gefunden wurde, nur NULL ohne
-// Fehlercode zurueckliefern, da so auch eine ganze Chain von
-// Objekten nach der Methode/Property befragt werden kann.
+// Finding an element:
+// It goes linearly through the method table until an adequate
+// method is found.
+// If the method/property hasn't been found, return only NULL
+// without error code so that a whole chain of objects can be
+// asked for their method/property.
SbxVariable* SampleObject::Find( const String& rName, SbxClassType t )
{
- // Ist das Element bereits vorhanden?
SbxVariable* pRes = SbxObject::Find( rName, t );
if( !pRes && t != SbxCLASS_OBJECT )
{
- // sonst suchen
Methods* p = aMethods;
short nIndex = 0;
sal_Bool bFound = sal_False;
@@ -138,7 +135,7 @@ SbxVariable* SampleObject::Find( const String& rName, SbxClassType t )
}
if( bFound )
{
- // Args-Felder isolieren:
+ // isolate args-fields:
short nAccess = ( p->nArgs & _RWMASK ) >> 8;
short nType = ( p->nArgs & _TYPEMASK );
String aName_ = String::CreateFromAscii( p->pName );
@@ -148,9 +145,8 @@ SbxVariable* SampleObject::Find( const String& rName, SbxClassType t )
else if( nType & _METHOD )
eCT = SbxCLASS_METHOD;
pRes = Make( aName_, eCT, p->eType );
- // Wir setzen den Array-Index + 1, da ja noch andere
- // Standard-Properties existieren, die auch aktiviert
- // werden muessen.
+ // We set the array-index + 1 because there are other standard-
+ // properties existing which have to activated too.
pRes->SetUserData( nIndex + 1 );
pRes->SetFlags( nAccess );
}
@@ -158,7 +154,7 @@ SbxVariable* SampleObject::Find( const String& rName, SbxClassType t )
return pRes;
}
-// Aktivierung eines Elements oder Anfordern eines Infoblocks
+// activation of an element or ask for an info block
void SampleObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCT,
const SfxHint& rHint, const TypeId& rHT )
@@ -169,7 +165,7 @@ void SampleObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCT,
SbxVariable* pVar = pHint->GetVar();
SbxArray* pPar_ = pVar->GetParameters();
sal_uInt16 nIndex = (sal_uInt16) pVar->GetUserData();
- // kein Index: weiterreichen!
+ // no index: hand on!
if( nIndex )
{
sal_uIntPtr t = pHint->GetId();
@@ -182,13 +178,13 @@ void SampleObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCT,
bWrite = sal_True;
if( t == SBX_HINT_DATAWANTED || bWrite )
{
- // Parameter-Test fuer Methoden:
+ // parameter-test for methods:
sal_uInt16 nPar = aMethods[ --nIndex ].nArgs & 0x00FF;
- // Element 0 ist der Returnwert
+ // element 0 is the return value
if( ( !pPar_ && nPar )
|| ( pPar_->Count() != nPar+1 ) )
SetError( SbxERR_WRONG_ARGS );
- // Alles klar, man kann den Call ausfuehren
+ // alright, the call can be done
else
{
(this->*(aMethods[ nIndex ].pFunc))( pVar, pPar_, bWrite );
@@ -200,7 +196,7 @@ void SampleObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCT,
}
}
-// Zusammenbau der Infostruktur fuer einzelne Elemente
+// construction of the info structure for single elements
SbxInfo* SampleObject::GetInfo( short nIdx )
{
@@ -220,15 +216,14 @@ SbxInfo* SampleObject::GetInfo( short nIdx )
}
-// Properties und Methoden legen beim Get (bPut = sal_False) den Returnwert
-// im Element 0 des Argv ab; beim Put (bPut = sal_True) wird der Wert aus
-// Element 0 gespeichert.
+// Properties and methods lay down the return value in element 0 of the
+// Argv at Get (bPut = sal_False); at Put (bPut = sal_True) the value from
+// element 0 is saved.
-// Die Methoden:
void SampleObject::Display( SbxVariable*, SbxArray* pPar_, sal_Bool )
{
- // GetString() loest u.U. auch einen Error aus!
+ // GetString() might perhaps cause an error!
String s( pPar_->Get( 1 )->GetString() );
if( !IsError() )
InfoBox( NULL, s ).Execute();
@@ -240,14 +235,13 @@ void SampleObject::Square( SbxVariable* pVar, SbxArray* pPar_, sal_Bool )
pVar->PutDouble( n * n );
}
-// Callback nach BASIC:
+// Callback to BASIC:
void SampleObject::Event( SbxVariable*, SbxArray* pPar_, sal_Bool )
{
Call( pPar_->Get( 1 )->GetString(), NULL );
}
-// Neues Element anlegen
void SampleObject::Create( SbxVariable* pVar, SbxArray* pPar_, sal_Bool )
{
@@ -255,7 +249,6 @@ void SampleObject::Create( SbxVariable* pVar, SbxArray* pPar_, sal_Bool )
MakeObject( pPar_->Get( 1 )->GetString(), String( RTL_CONSTASCII_USTRINGPARAM("SampleElement") ) ) );
}
-// Die Factory legt unsere beiden Objekte an.
SbxObject* SampleObjectFac::CreateObject( const String& rClass )
{
diff --git a/basic/source/sbx/sbxbool.cxx b/basic/source/sbx/sbxbool.cxx
index 7efb748..d4479a6 100644
--- a/basic/source/sbx/sbxbool.cxx
+++ b/basic/source/sbx/sbxbool.cxx
@@ -85,7 +85,7 @@ enum SbxBOOL ImpGetBool( const SbxValues* p )
nRes = SbxTRUE;
else if( !p->pOUString->equalsIgnoreAsciiCase( SbxRes( STRING_FALSE ) ) )
{
- // Jetzt kann es noch in eine Zahl konvertierbar sein
+ // it can be convertable to a number
sal_Bool bError = sal_True;
double n;
SbxDataType t;
diff --git a/basic/source/sbx/sbxform.cxx b/basic/source/sbx/sbxform.cxx
index 61fbafd..77a155b 100644
--- a/basic/source/sbx/sbxform.cxx
+++ b/basic/source/sbx/sbxform.cxx
@@ -34,21 +34,21 @@
#include <basic/sbxform.hxx>
/*
-TODO: gibt es noch irgend welche Star-Basic Besonderheiten ?
+TODO: are there any Star-Basic characteristics unconsidered?
- was bedeutet: * als Platzhalter
+ what means: * as placeholder
-BEMERKUNG: Visual-Basic behandelt folgende (ung"ultige) Format-Strings
- wie angezeigt:
+COMMENT: Visual-Basic treats the following (invalid) format-strings
+ as shown:
##0##.##0## --> ##000.000##
- (diese Klasse verh"alt sich genau so).
+ (this class behaves the same way)
*/
-#include <stdio.h> // f"ur: sprintf()
-#include <float.h> // f"ur: DBL_DIG, DBL_EPSILON
-#include <math.h> // f"ur: floor(), fabs(), log10(), pow()
+#include <stdio.h> // for: sprintf()
+#include <float.h> // for: DBL_DIG, DBL_EPSILON
+#include <math.h> // for: floor(), fabs(), log10(), pow()
//=================================================================
//=========================== DEFINES =============================
@@ -57,18 +57,18 @@ BEMERKUNG: Visual-Basic behandelt folgende (ung"ultige) Format-Strings
#define _NO_DIGIT -1
#define MAX_NO_OF_EXP_DIGITS 5
- // +4 wegen dem Wertebereich: zwischen -308 und +308
- // +1 f"ur abschliessende 0
+ // +4 because of the value range: between -308 and +308
+ // +1 for closing 0
#define MAX_NO_OF_DIGITS DBL_DIG
#define MAX_DOUBLE_BUFFER_LENGTH MAX_NO_OF_DIGITS + 9
- // +1 f"ur Vorzeichen
- // +1 f"ur Ziffer vor dem Dezimal-Punkt
- // +1 f"ur Dezimal-Punkt
- // +2 f"ur Exponent E und Exp. Vorzeichen
- // +3 f"ur den Wert des Exponenten
- // +1 f"ur abschliessende 0
-
-// Defines f"ur die Ziffern:
+ // +1 for leading sign
+ // +1 for digit before the decimal point
+ // +1 for decimal point
+ // +2 for exponent E and exp. leading sign
+ // +3 for the exponent's value
+ // +1 for closing 0
+
+// Defines for the digits:
#define ASCII_0 '0' // 48
#define ASCII_9 '9' // 57
@@ -76,7 +76,7 @@ BEMERKUNG: Visual-Basic behandelt folgende (ung"ultige) Format-Strings
#define FORMAT_SEPARATOR ';'
-// vordefinierte Formate f"ur den Format$()-Befehl:
+// predefined formats for the Format$()-command:
#define BASICFORMAT_GENERALNUMBER "General Number"
#define BASICFORMAT_CURRENCY "Currency"
#define BASICFORMAT_FIXED "Fixed"
@@ -89,28 +89,26 @@ BEMERKUNG: Visual-Basic behandelt folgende (ung"ultige) Format-Strings
#define EMPTYFORMATSTRING ""
-// Bem.: Visual-Basic hat bei Floating-Point-Zahlen maximal 12 Stellen
-// nach dem Dezimal-Punkt.
-// Alle Format-Strings sind kompatibel zu Visual-Basic:
+// Comment: Visual-Basic has a maximum of 12 positions after the
+// decimal point for floating-point-numbers.
+// all format-strings are compatible to Visual-Basic:
#define GENERALNUMBER_FORMAT "0.############"
- // max. 12 Stellen in Visual-Basic !
#define CURRENCY_FORMAT "@$0.00;@($0.00)"
#define FIXED_FORMAT "0.00"
#define STANDARD_FORMAT "@0.00"
#define PERCENT_FORMAT "0.00%"
#define SCIENTIFIC_FORMAT "#.00E+00"
-// BEMERKUNG: das Zeichen @ bedeutet, das Tausender-Separatoren erzeugt
-// weden sollen. Dies ist eine StarBasic 'Erweiterung'.
+// Comment: the character @ means that thousand-separators shall
+// be generated. That's a StarBasic 'extension'.
//=================================================================
-// zur Bestimmung der Anzahl Stellen in dNumber
+
double get_number_of_digits( double dNumber )
//double floor_log10_fabs( double dNumber )
{
if( dNumber==0.0 )
- // 0 hat zumindest auch eine Stelle !
- return 0.0; //ehemals 1.0, jetzt 0.0 wegen #40025;
+ return 0.0; // used to be 1.0, now 0.0 because of #40025;
else
return floor( log10( fabs( dNumber ) ) );
}
@@ -141,87 +139,74 @@ SbxBasicFormater::SbxBasicFormater( sal_Unicode _cDecPoint, sal_Unicode _cThousa
sCurrencyFormatStrg = _sCurrencyFormatStrg;
}
-// Funktion zur Ausgabe eines Fehler-Textes (zum Debuggen)
-// verschiebt alle Zeichen des Strings, angefangen von der nStartPos,
-// um eine Position zu gr"osseren Indizes, d.h. es wird Platz f"ur
-// ein neues (einzuf"ugendes) Zeichen geschafft.
-// ACHTUNG: der String MUSS gross genug sein !
+// function for ouput of a error-text (for debugging)
+// displaces all characters of the string, starting from nStartPos
+// for one position to larger indexes, i. e. place for a new
+// character (which is to be inserted) is created.
+// ATTENTION: the string MUST be long enough!
inline void SbxBasicFormater::ShiftString( String& sStrg, sal_uInt16 nStartPos )
{
sStrg.Erase( nStartPos,1 );
}
-// Funktion um ein Zeichen an einen String anzuh"angen
inline void SbxBasicFormater::StrAppendChar( String& sStrg, sal_Unicode ch )
{
sStrg.Insert( ch );
}
-// h"angt die "ubergebene Ziffer nDigit an den "ubergebenen String sStrg
-// an, dabei wird "uberpr"uft ob nDigit eine g"ultige Ziffer ist,
-// falls dies nicht der Fall ist, wird nichts gemacht.
void SbxBasicFormater::AppendDigit( String& sStrg, short nDigit )
{
if( nDigit>=0 && nDigit<=9 )
StrAppendChar( sStrg, (sal_Unicode)(nDigit+ASCII_0) );
}
-// verschiebt den Dezimal-Punkt um eine Stelle nach links
void SbxBasicFormater::LeftShiftDecimalPoint( String& sStrg )
{
sal_uInt16 nPos = sStrg.Search( cDecPoint );
if( nPos!=STRING_NOTFOUND )
{
- // vertausche Dezimal-Punkt
+ // swap decimal point
sStrg.SetChar( nPos, sStrg.GetChar( nPos - 1 ) );
sStrg.SetChar( nPos-1, cDecPoint );
}
}
-// rundet in einem String die Ziffer an der angegebenen Stelle,
-// es wird ein Flag zur"uckgeliefert, falls ein Overflow auftrat,
-// d.h. 99.99 --> 100.00, d.h. ein Gr"ossenordung ge"andert wurde
-// (geschieht beim Runden einer 9).
+// returns a flag if rounding a 9
void SbxBasicFormater::StrRoundDigit( String& sStrg, short nPos, sal_Bool& bOverflow )
{
- // wurde ggf ein falscher Index uebergeben --> Aufruf ignorieren
if( nPos<0 )
return;
bOverflow = sal_False;
- // "uberspringe den Dezimalpunkt und Tausender-Trennzeichen
+
sal_Unicode c = sStrg.GetChar( nPos );
if( nPos>0 && (c == cDecPoint || c == cThousandSep) )
{
StrRoundDigit( sStrg,nPos-1,bOverflow );
- // AENDERUNG ab 9.3.1997: nach rekursivem Call die Methode SOFORT beenden !
+ // CHANGE from 9.3.1997: end the method immediately after recursive call!
return;
}
- // "uberspringe alle nicht-Ziffern:
- // BEMERKUNG:
- // in einem g"ultigen Format-String sollte die Ausgabe
- // der Zahl an einem St"uck geschen, d.h. Sonderzeichen sollten
- // NUR vor ODER nach der Zahl stehen und nicht mitten in der
- // Format-Angabe f"ur die Zahl
+ // skip non-digits:
+ // COMMENT:
+ // in a valid format-string the number's output should be done
+ // in one piece, i. e. special characters should ONLY be in
+ // front OR behind the number and not right in the middle of
+ // the format information for the number
while( nPos>=0 && (sStrg.GetChar( nPos )<ASCII_0 || sStrg.GetChar( nPos )>ASCII_9) )
nPos--;
- // muss ggf. noch Platz f"ur eine weitere (f"uhrende) Ziffer
- // geschaffen werden ?
+
if( nPos==-1 )
{
ShiftString( sStrg,0 );
- // f"uhrende 1 einf"ugen: z.B. 99.99 f"ur 0.0
sStrg.SetChar( 0, '1' );
bOverflow = sal_True;
}
else
{
- // ist die zu rundende Position eine Ziffer ?
sal_Unicode c2 = sStrg.GetChar( nPos );
if( c2 >= ASCII_0 && c2 <= ASCII_9 )
{
- // muss eine 9 gerundet werden? Falls: Ja --> rekursiver Aufruf
if( c2 == ASCII_9 )
{
sStrg.SetChar( nPos, '0' );
@@ -232,18 +217,14 @@ void SbxBasicFormater::StrRoundDigit( String& sStrg, short nPos, sal_Bool& bOver
}
else
{
- // --> Nein, d.h. Platz f"ur Ziffer schaffen: z.B. -99.99 f"ur #0.0
- // da gerundet wird MUSS es immer eine g"ultige Position
- // nPos+1 geben !
ShiftString( sStrg,nPos+1 );
- // f"uhrende 1 einf"ugen
sStrg.SetChar( nPos+1, '1' );
bOverflow = sal_True;
}
}
}
-// rundet in einem String die Ziffer an der angegebenen Stelle
+
void SbxBasicFormater::StrRoundDigit( String& sStrg, short nPos )
{
sal_Bool bOverflow;
@@ -251,12 +232,9 @@ void SbxBasicFormater::StrRoundDigit( String& sStrg, short nPos )
StrRoundDigit( sStrg,nPos,bOverflow );
}
-// parse den Formatstring von der "ubergebenen Position zur"uck
-// und l"osche ggf. "uberf"ussige 0en, z.B. 4.50 in 0.0#
void SbxBasicFormater::ParseBack( String& sStrg, const String& sFormatStrg,
short nFormatPos )
{
- // WICHTIG: nFormatPos kann auch negativ sein, in diesem Fall Aufruf ignorieren
for( short i=nFormatPos;
i>0 && sFormatStrg.GetChar( i ) == '#' && sStrg.GetChar( (sStrg.Len()-1) ) == '0';
i-- )
@@ -265,54 +243,45 @@ void SbxBasicFormater::ParseBack( String& sStrg, const String& sFormatStrg,
#ifdef _with_sprintf
-/*
- Bemerkung:
- Zahl wird mit maximaler (sinnvollen) Genauigkeit in einen String
- umgewandelt (mit sprintf()), dieser String wird dann im Schleifen-
- Durchlauf nach der entsprechenden Ziffer durchsucht.
-*/
-// initialisiert die Daten der Klasse um einen Scan-Durchlauf durchzuf"uhren
+
void SbxBasicFormater::InitScan( double _dNum )
{
char sBuffer[ MAX_DOUBLE_BUFFER_LENGTH ];
dNum = _dNum;
InitExp( get_number_of_digits( dNum ) );
- // maximal 15 Nachkomma-Stellen, Format-Beispiel: -1.234000000000000E-001
+ // maximum of 15 positions behind the decimal point, example: -1.234000000000000E-001
/*int nCount =*/ sprintf( sBuffer,"%+22.15lE",dNum );
sSciNumStrg.AssignAscii( sBuffer );
}
+
void SbxBasicFormater::InitExp( double _dNewExp )
{
char sBuffer[ MAX_DOUBLE_BUFFER_LENGTH ];
- // bestimme den Exponenten (kann immer GENAU durch int dargestellt werden)
nNumExp = (short)_dNewExp;
- // und dessen String
/*int nCount =*/ sprintf( sBuffer,"%+i",nNumExp );
sNumExpStrg.AssignAscii( sBuffer );
- // bestimme die Anzahl der Stellen im Exponenten
nExpExp = (short)get_number_of_digits( (double)nNumExp );
}
-// bestimmt die Ziffer an der angegebenen Stelle (gedacht zur Anwendung im
-// Scan-Durchlauf)
+
short SbxBasicFormater::GetDigitAtPosScan( short nPos, sal_Bool& bFoundFirstDigit )
{
- // Versuch eine gr"ossere Ziffer zu lesen,
- // z.B. Stelle 4 in 1.234,
- // oder eine Ziffer ausserhalb der Aufl"osung der
- // Zahl (double) zu lesen (z.B. max. 15 Stellen).
+ // trying to read a higher digit,
+ // e. g. position 4 in 1.234,
+ // or to read a digit outside of the
+ // number's dissolution (double)
if( nPos>nNumExp || abs(nNumExp-nPos)>MAX_NO_OF_DIGITS )
return _NO_DIGIT;
- // bestimme den Index der Stelle in dem Number-String:
- // "uberlese das Vorzeichen
+ // determine the index of the position in the number-string:
+ // skip the leading sign
sal_uInt16 no = 1;
- // falls notwendig den Dezimal-Punkt "uberlesen:
+ // skip the decimal point if necessary
if( nPos<nNumExp )
no++;
no += nNumExp-nPos;
- // Abfrage der ersten (g"ultigen) Ziffer der Zahl --> Flag setzen
+ // query of the number's first valid digit --> set flag
if( nPos==nNumExp )
bFoundFirstDigit = sal_True;
return (short)(sSciNumStrg.GetChar( no ) - ASCII_0);
@@ -320,110 +289,93 @@ short SbxBasicFormater::GetDigitAtPosScan( short nPos, sal_Bool& bFoundFirstDigi
short SbxBasicFormater::GetDigitAtPosExpScan( short nPos, sal_Bool& bFoundFirstDigit )
{
- // ist die abgefragte Stelle zu gross f"ur den Exponenten ?
if( nPos>nExpExp )
return -1;
- // bestimme den Index der Stelle in dem Number-String:
- // "uberlese das Vorzeichen
sal_uInt16 no = 1;
no += nExpExp-nPos;
- // Abfrage der ersten (g"ultigen) Ziffer der Zahl --> Flag setzen
+
if( nPos==nExpExp )
bFoundFirstDigit = sal_True;
return (short)(sNumExpStrg.GetChar( no ) - ASCII_0);
}
-// es kann ein Wert f"ur den Exponent angegeben werden, da ggf. die
-// Zahl ggf. NICHT normiert (z.B. 1.2345e-03) dargestellt werden soll,
-// sondern eventuell 123.345e-3 !
+// a value for the exponent can be given because the number maybe shall
+// not be displayed in a normed way (e. g. 1.2345e-03) but maybe 123.345e-3 !
short SbxBasicFormater::GetDigitAtPosExpScan( double dNewExponent, short nPos,
sal_Bool& bFoundFirstDigit )
{
- // neuer Exponent wurde "ubergeben, aktualisiere
- // die tempor"aren Klassen-Variablen
InitExp( dNewExponent );
- // und jetzt die Stelle bestimmen
+
return GetDigitAtPosExpScan( nPos,bFoundFirstDigit );
}
#else
-/* Probleme mit der folgenden Methode:
+/* Problems with the following method:
-TODO: ggf einen 'intelligenten' Peek-Parser um Rundungsfehler bei
- double-Zahlen herauszufinden ? z.B. f"ur 0.00115 #.#e-000
+TODO: an 'intelligent' peek-parser might be needed to detect rounding
+ mistakes at double-numbers - e. g. for 0.00115 #.#e-000
- Problem mit: format( 0.3345 , "0.000" )
- Problem mit: format( 0.00115 , "0.0000" )
+ problem with: format( 0.3345 , "0.000" )
+ problem with: format( 0.00115 , "0.0000" )
*/
-// liefert die Ziffer an der angegebenen '10er System'-Position,
-// d.h. positive nPos f"ur Stellen vor dem Komma und negative
-// f"ur Stellen nach dem Komma.
-// nPos==0 bedeutet erste Stelle vor dem Komma, also 10^0.
-// liefert 0..9 f"ur g"ultige Ziffern und -1 f"ur nicht vorhanden,
-// d.h. falls die "ubergebene Zahl zu klein ist
-// (z.B. Stelle 5 bei dNumber=123).
-// Weiter wird in dNextNumber die um die f"uhrenden Stellen
-// (bis nPos) gek"urzte Zahl zur"uckgeliefert, z.B.
+// returns the digit at the given '10 system'-position,
+// i. e. positive nPos for positions before the decimal
+// point and negative for positions after.
+// nPos==0 means first position after the decimalpoint, so 10^0.
+// returns 0..9 for valid digits and -1 for not existing,
+// i. e. if the passed number is too small
+// (e. g. position 5 of dNumber=123).
+// Furthermore in dNextNumber the number shorted by leading
+// positions (till nPos) is returned, e. g.
// GetDigitAtPos( 3434.565 , 2 , dNewNumber ) --> dNewNumber = 434.565
-// dies kann f"ur Schleifenabarbeitung g"unstiger sein, d.h.
-// die Zahlen immer von der gr"ossten Stelle abarbeiten/scanen.
-// In bFoundFirstDigit wird ggf. ein Flag gesetzt wenn eine Ziffer
-// gefunden wurde, dies wird dazu verwendet um 'Fehler' beim Parsen 202
-// zu vermeiden, die
-// ACHTUNG: anscheinend gibt es manchmal noch Probleme mit Rundungs-Fehlern!
+// In bFoundFirstDigit a flag is set if a digit has been found,
+// this is used to prevent 'errors' on parsing 202
+// ATTENTION: apparently there are sometimes still problems with rounding mistakes!
short SbxBasicFormater::GetDigitAtPos( double dNumber, short nPos,
double& dNextNumber, sal_Bool& bFoundFirstDigit )
-// ACHTUNG: nPos kann auch negativ werden, f"ur Stellen nach dem Dezimal-Punkt
{
double dDigit;
short nMaxDigit;
- // erst mal aus der Zahl eine positive Zahl machen:
dNumber = fabs( dNumber );
- // "uberpr"ufe ob Zahl zu klein f"ur angegebene Stelle ist
nMaxDigit = (short)get_number_of_digits( dNumber );
- // f"uhrende Ziffern 'l"oschen'
- // Bem.: Fehler nur bei Zahlen gr"osser 0, d.h. bei Ziffern vor dem
- // Dezimal-Punkt
+ // error only at numbers > 0, i. e. for digits before
+ // the decimal point
if( nMaxDigit<nPos && !bFoundFirstDigit && nPos>=0 )
return _NO_DIGIT;
- // Ziffer gefunden, setze Flag:
+
bFoundFirstDigit = sal_True;
for( short i=nMaxDigit; i>=nPos; i-- )
{
double dI = (double)i;
double dTemp1 = pow( 10.0,dI );
- // pr"apariere nun die gesuchte Ziffer:
+
dDigit = floor( pow( 10.0,log10( fabs( dNumber ) )-dI ) );
dNumber -= dTemp1 * dDigit;
}
- // Zuweisung f"ur optimierte Schleifen-Durchl"aufe
+ // for optimized loop run
dNextNumber = dNumber;
- // und zum Schluss noch die float-Rundungsungenauigkeiten heraus filtern
+
return RoundDigit( dDigit );
}
-// rundet eine double-Zahl zwischen 0 und 9 auf die genaue
-// Integer-Zahl, z.B. 2.8 -> 3 und 2.2 -> 2
+
short SbxBasicFormater::RoundDigit( double dNumber )
{
- // ist der Wertebereich g"ultig ?
if( dNumber<0.0 || dNumber>10.0 )
return -1;
- short nTempHigh = (short)(dNumber+0.5); // ggf. floor( )
+ short nTempHigh = (short)(dNumber+0.5); // maybe floor( )
return nTempHigh;
}
#endif
-// kopiert den entsprechenden Teil des Format-Strings, falls vorhanden,
-// und liefert diesen zur"uck.
-// Somit wird ein neuer String erzeugt, der vom Aufrufer wieder freigegeben
-// werden muss
+// Copies the respective part of the format-string, if existing, and returns it.
+// So a new string is created, which has to be freed by the caller later.
String SbxBasicFormater::GetPosFormatString( const String& sFormatStrg, sal_Bool & bFound )
{
bFound = sal_False; // default...
@@ -432,17 +384,17 @@ String SbxBasicFormater::GetPosFormatString( const String& sFormatStrg, sal_Bool
if( nPos!=STRING_NOTFOUND )
{
bFound = sal_True;
- // der Format-String f"ur die positiven Zahlen ist alles
- // vor dem ersten ';'
+ // the format-string for positive numbers is
+ // everything before the first ';'
return sFormatStrg.Copy( 0,nPos );
}
- // kein ; gefunden, liefere Leerstring
+
String aRetStr;
aRetStr.AssignAscii( EMPTYFORMATSTRING );
return aRetStr;
}
-// siehe auch GetPosFormatString()
+// see also GetPosFormatString()
String SbxBasicFormater::GetNegFormatString( const String& sFormatStrg, sal_Bool & bFound )
{
bFound = sal_False; // default...
@@ -450,18 +402,14 @@ String SbxBasicFormater::GetNegFormatString( const String& sFormatStrg, sal_Bool
if( nPos!=STRING_NOTFOUND )
{
- // der Format-String f"ur die negative Zahlen ist alles
- // zwischen dem ersten und dem zweiten ';'.
- // Daher: hole erst mal alles nach dem ersten ';'
+ // the format-string for negative numbers is
+ // everything between the first and the second ';'
String sTempStrg = sFormatStrg.Copy( nPos+1 );
- // und suche darin ggf. ein weiteres ';'
nPos = sTempStrg.Search( FORMAT_SEPARATOR );
bFound = sal_True;
if( nPos==STRING_NOTFOUND )
- // keins gefunden, liefere alles...
return sTempStrg;
else
- // ansonsten den String zwischen den beiden ';' liefern
return sTempStrg.Copy( 0,nPos );
}
String aRetStr;
@@ -469,7 +417,7 @@ String SbxBasicFormater::GetNegFormatString( const String& sFormatStrg, sal_Bool
return aRetStr;
}
-// siehe auch GetPosFormatString()
+// see also GetPosFormatString()
String SbxBasicFormater::Get0FormatString( const String& sFormatStrg, sal_Bool & bFound )
{
bFound = sal_False; // default...
@@ -477,11 +425,9 @@ String SbxBasicFormater::Get0FormatString( const String& sFormatStrg, sal_Bool &
if( nPos!=STRING_NOTFOUND )
{
- // der Format-String f"ur die Null ist alles
- // was nach dem zweiten ';' kommt.
- // Daher: hole erst mal alles nach dem ersten ';'
+ // the format string for the zero is
+ // everything after the second ';'
String sTempStrg = sFormatStrg.Copy( nPos+1 );
- // und suche darin ggf. ein weiteres ';'
nPos = sTempStrg.Search( FORMAT_SEPARATOR );
if( nPos!=STRING_NOTFOUND )
{
@@ -489,19 +435,18 @@ String SbxBasicFormater::Get0FormatString( const String& sFormatStrg, sal_Bool &
sTempStrg = sTempStrg.Copy( nPos+1 );
nPos = sTempStrg.Search( FORMAT_SEPARATOR );
if( nPos==STRING_NOTFOUND )
- // keins gefunden, liefere alles...
return sTempStrg;
else
return sTempStrg.Copy( 0,nPos );
}
}
- // kein ; gefunden, liefere Leerstring
+
String aRetStr;
aRetStr.AssignAscii( EMPTYFORMATSTRING );
return aRetStr;
}
-// siehe auch GetPosFormatString()
+// see also GetPosFormatString()
String SbxBasicFormater::GetNullFormatString( const String& sFormatStrg, sal_Bool & bFound )
{
bFound = sal_False; // default...
@@ -509,15 +454,12 @@ String SbxBasicFormater::GetNullFormatString( const String& sFormatStrg, sal_Boo
if( nPos!=STRING_NOTFOUND )
{
- // der Format-String f"ur die Null ist alles
- // was nach dem dritten ';' kommt.
- // Daher: hole erst mal alles nach dem ersten ';'
+ // the format-string for the Null is
+ // everything after the third ';'
String sTempStrg = sFormatStrg.Copy( nPos+1 );
- // und suche darin ggf. ein weiteres ';'
nPos = sTempStrg.Search( FORMAT_SEPARATOR );
if( nPos!=STRING_NOTFOUND )
{
- // und suche nun nach dem dritten ';'
sTempStrg = sTempStrg.Copy( nPos+1 );
nPos = sTempStrg.Search( FORMAT_SEPARATOR );
if( nPos!=STRING_NOTFOUND )
@@ -527,14 +469,14 @@ String SbxBasicFormater::GetNullFormatString( const String& sFormatStrg, sal_Boo
}
}
}
- // kein ; gefunden, liefere Leerstring
+
String aRetStr;
aRetStr.AssignAscii( EMPTYFORMATSTRING );
return aRetStr;
}
-// analysiert den Format-String, liefert Wert <> 0 falls ein Fehler
-// aufgetreten ist
+
+// returns value <> 0 in case of an error
short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg,
short& nNoOfDigitsLeft, short& nNoOfDigitsRight,
short& nNoOfOptionalDigitsLeft,
@@ -547,7 +489,6 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg,
short nState = 0;
nLen = sFormatStrg.Len();
- // initialisiere alle Z"ahler und Flags
nNoOfDigitsLeft = 0;
nNoOfDigitsRight = 0;
nNoOfOptionalDigitsLeft = 0;
@@ -556,14 +497,11 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg,
bPercent = sal_False;
bCurrency = sal_False;
bScientific = sal_False;
- // ab 11.7.97: sobald ein Komma in dem Format String gefunden wird,
- // werden alle 3 Zehnerpotenzen markiert (d.h. tausender, milionen, ...)
- // bisher wurde nur an den gesetzten Position ein Tausender-Separator
- // ausgegeben oder wenn ein @ im Format-String stand.
- // Dies war ein Missverstaendnis der VB Kompatiblitaet.
+ // from 11.7.97: as soon as a comma (point?) is found in the format string,
+ // all three decimal powers are marked (i. e. thousand, million, ...)
bGenerateThousandSeparator = sFormatStrg.Search( ',' ) != STRING_NOTFOUND;
nMultipleThousandSeparators = 0;
- // und untersuche den Format-String nach den gew"unschten Informationen
+
for( sal_uInt16 i=0; i<nLen; i++ )
{
sal_Unicode c = sFormatStrg.GetChar( i );
@@ -573,29 +511,28 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg,
if( nState==0 )
{
nNoOfDigitsLeft++;
-// TODO hier ggf. bessere Fehler-"Uberpr"ufung der Mantisse auf g"ultige Syntax (siehe Grammatik)
- // ACHTUNG: 'undefiniertes' Verhalten falls # und 0
- // gemischt werden !!!
- // BEMERKUNG: eigentlich sind #-Platzhalter bei Scientific
- // Darstellung vor dem Dezimal-Punkt sinnlos !
+// TODO here maybe better error inspection of the mantissa for valid syntax (see grammar)h
+ // ATTENTION: 'undefined' behaviour if # and 0 are combined!
+ // REMARK: #-placeholders are actually useless for
+ // scientific display before the decimal point!
if( c=='#' )
nNoOfOptionalDigitsLeft++;
}
else if( nState==1 )
nNoOfDigitsRight++;
- else if( nState==-1 ) // suche 0 im Exponent
+ else if( nState==-1 ) // search 0 in the exponent
{
- if( c=='#' ) // # schaltet den Zustand weiter
+ if( c=='#' ) // # switches on the condition
{
nNoOfOptionalExponentDigits++;
nState = -2;
}
nNoOfExponentDigits++;
}
- else if( nState==-2 ) // suche # im Exponent
+ else if( nState==-2 ) // search # in the exponent
{
if( c=='0' )
- // ERROR: 0 nach # im Exponent ist NICHT erlaubt !!
+ // ERROR: 0 after # in the exponent is NOT allowed!!
return -4;
nNoOfOptionalExponentDigits++;
nNoOfExponentDigits++;
@@ -604,7 +541,7 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg,
case '.':
nState++;
if( nState>1 )
- return -1; // ERROR: zu viele Dezimal-Punkte
+ return -1; // ERROR: too many decimal points
break;
case '%':
bPercent = sal_True;
@@ -615,8 +552,7 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg,
case ',':
{
sal_Unicode ch = sFormatStrg.GetChar( i+1 );
- // vorl"aufig wird NUR auf zwei aufeinanderfolgede
- // Zeichen gepr"uft
+
if( ch!=0 && (ch==',' || ch=='.') )
nMultipleThousandSeparators++;
} break;
@@ -625,12 +561,12 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg,
// #i13821 not when no digits before
if( nNoOfDigitsLeft > 0 || nNoOfDigitsRight > 0 )
{
- nState = -1; // breche jetzt das Z"ahlen der Stellen ab
+ nState = -1; // abort counting digits
bScientific = sal_True;
}
break;
- // EIGENES Kommando-Zeichen, das die Erzeugung der
- // Tausender-Trennzeichen einschaltet
+ // OWN command-character which turns on
+ // the creation of thousand-separators
case '\\':
// Ignore next char
i++;
@@ -643,8 +579,8 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg,
return 0;
}
-// das Flag bCreateSign zeigt an, dass bei der Mantisse ein Vorzeichen
-// erzeugt werden soll
+// the flag bCreateSign says that at the mantissa a leading sign
+// shall be created
void SbxBasicFormater::ScanFormatString( double dNumber,
const String& sFormatStrg, String& sReturnStrg,
sal_Bool bCreateSign )
@@ -654,47 +590,44 @@ void SbxBasicFormater::ScanFormatString( double dNumber,
nMultipleThousandSeparators;
sal_Bool bPercent,bCurrency,bScientific,bGenerateThousandSeparator;
- // Initialisiere den Return-String
sReturnStrg = String();
- // analysiere den Format-String, d.h. bestimme folgende Werte:
+ // analyse the format-string, i. e. determine the following values:
/*
- - Anzahl der Ziffern vor dem Komma
- - Anzahl der Ziffern nach dem Komma
- - optionale Ziffern vor dem Komma
- - Anzahl der Ziffern im Exponent
- - optionale Ziffern im Exponent
- - Prozent-Zeichen gefunden ?
- - () f"ur negatives Vorzeichen ?
- - Exponetial-Schreibweise ?
- - sollen Tausender-Separatoren erzeugt werden ?
- - wird ein Prozent-Zeichen gefunden ? --> dNumber *= 100.0;
- - gibt es aufeinanderfolgende Tausender-Trennzeichen ?
- ,, oder ,. --> dNumber /= 1000.0;
- - sonstige Fehler ? mehrfache Dezimalpunkte, E's, etc.
- --> Fehler werden zur Zeit einfach ignoriert
+ - number of digits before decimal point
+ - number of digits after decimal point
+ - optional digits before decimal point
+ - number of digits in the exponent
+ - optional digits in the exponent
+ - percent-character found?
+ - () for negative leading sign?
+ - exponetial-notation?
+ - shall thousand-separators be generated?
+ - is a percent-character being found? --> dNumber *= 100.0;
+ - are there thousand-separators in a row?
+ ,, or ,. --> dNumber /= 1000.0;
+ - other errors? multiple decimal points, E's, etc.
+ --> errors are simply ignored at the moment
*/
AnalyseFormatString( sFormatStrg,nNoOfDigitsLeft,nNoOfDigitsRight,
nNoOfOptionalDigitsLeft,nNoOfExponentDigits,
nNoOfOptionalExponentDigits,
bPercent,bCurrency,bScientific,bGenerateThousandSeparator,
nMultipleThousandSeparators );
- // Spezialbehandlung f"ur Spezialzeichen
+ // special handling for special characters
if( bPercent )
dNumber *= 100.0;
-// TODO: diese Vorgabe (,, oder ,.) ist NICHT Visual-Basic kompatibel !
- // Frage: soll das hier stehen bleiben (Anforderungen) ?
+// TODO: this condition (,, or ,.) is NOT Visual-Basic compatible!
+ // Question: shall this stay here (requirements)?
if( nMultipleThousandSeparators )
dNumber /= 1000.0;
- // einige Arbeits-Variablen
double dExponent;
short i,nLen;
short nState,nDigitPos,nExponentPos,nMaxDigit,nMaxExponentDigit;
sal_Bool bFirstDigit,bFirstExponentDigit,bFoundFirstDigit,
bIsNegative,bZeroSpaceOn, bSignHappend,bDigitPosNegative;
- // Initialisierung der Arbeits-Variablen
bSignHappend = sal_False;
bFoundFirstDigit = sal_False;
bIsNegative = dNumber<0.0;
@@ -706,7 +639,6 @@ void SbxBasicFormater::ScanFormatString( double dNumber,
bDigitPosNegative = false;
if( bScientific )
{
- // beim Exponent ggf. "uberz"ahlige Stellen vor dem Komma abziehen
dExponent = dExponent - (double)(nNoOfDigitsLeft-1);
nDigitPos = nMaxDigit;
nMaxExponentDigit = (short)get_number_of_digits( dExponent );
@@ -714,20 +646,20 @@ void SbxBasicFormater::ScanFormatString( double dNumber,
}
else
{
- nDigitPos = nNoOfDigitsLeft-1; // Z"ahlweise f"angt bei 0 an, 10^0
- // hier ben"otigt man keine Exponent-Daten !
+ nDigitPos = nNoOfDigitsLeft-1; // counting starts at 0, 10^0
+ // no exponent-data is needed here!
bDigitPosNegative = (nDigitPos < 0);
}
bFirstDigit = sal_True;
bFirstExponentDigit = sal_True;
- nState = 0; // 0 --> Mantisse; 1 --> Exponent
+ nState = 0; // 0 --> mantissa; 1 --> exponent
bZeroSpaceOn = 0;
#ifdef _with_sprintf
InitScan( dNumber );
#endif
- // scanne jetzt den Format-String:
+ // scanning the format-string:
sal_Unicode cForce = 0;
for( i=0; i<nLen; i++ )
{
@@ -746,20 +678,18 @@ void SbxBasicFormater::ScanFormatString( double dNumber,
case '#':
if( nState==0 )
{
- // Behandlung der Mantisse
+ // handling of the mantissa
if( bFirstDigit )
{
- // ggf. Vorzeichen erzeugen
- // Bem.: bei bCurrency soll das negative
- // Vorzeichen durch () angezeigt werden
+ // remark: at bCurrency the negative
+ // leading sign shall be shown with ()
if( bIsNegative && !bCreateSign && !bSignHappend )
{
- // nur einmal ein Vorzeichen ausgeben
bSignHappend = sal_True;
StrAppendChar( sReturnStrg,'-' );
}
- // hier jetzt "uberz"ahlige Stellen ausgeben,
- // d.h. vom Format-String nicht erfasste Stellen
+ // output redundant positions, i. e. those which
+ // are undocumented by the format-string
if( nMaxDigit>nDigitPos )
{
for( short j=nMaxDigit; j>nDigitPos; j-- )
@@ -770,27 +700,26 @@ void SbxBasicFormater::ScanFormatString( double dNumber,
#else
AppendDigit( sReturnStrg,nTempDigit = GetDigitAtPos( dNumber,j,dNumber,bFoundFirstDigit ) );
#endif
- // wurde wirklich eine Ziffer eingefuegt ?
+
if( nTempDigit!=_NO_DIGIT )
- // jetzt wurde wirklich eine Ziffer ausgegeben, Flag setzen
bFirstDigit = sal_False;
- // muss ggf. ein Tausender-Trennzeichen erzeugt werden?
+
if( bGenerateThousandSeparator && ( c=='0' || nMaxDigit>=nDigitPos ) && j>0 && (j % 3 == 0) )
StrAppendChar( sReturnStrg,cThousandSep );
}
}
}
- // muss f"ur eine leere Stelle eventuell eine 0 ausgegeben werden ?
+
if( nMaxDigit<nDigitPos && ( c=='0' || bZeroSpaceOn ) )
{
- AppendDigit( sReturnStrg,0 ); // Ja
- // jetzt wurde wirklich eine Ziffer ausgegeben, Flag setzen
+ AppendDigit( sReturnStrg,0 );
+
bFirstDigit = sal_False;
bZeroSpaceOn = 1;
- // BEM.: bei Visual-Basic schaltet die erste 0 f"ur alle
- // nachfolgenden # (bis zum Dezimal-Punkt) die 0 ein,
- // dieses Verhalten wird hier mit dem Flag simmuliert.
- // muss ggf. ein Tausender-Trennzeichen erzeugt werden?
+ // Remark: in Visual-Basic the first 0 turns on the 0 for
+ // all the following # (up to the decimal point),
+ // this behaviour is simulated here with the flag.
+
if( bGenerateThousandSeparator && ( c=='0' || nMaxDigit>=nDigitPos ) && nDigitPos>0 && (nDigitPos % 3 == 0) )
StrAppendChar( sReturnStrg,cThousandSep );
}
@@ -802,27 +731,26 @@ void SbxBasicFormater::ScanFormatString( double dNumber,
#else
AppendDigit( sReturnStrg,nTempDigit = GetDigitAtPos( dNumber,nDigitPos,dNumber,bFoundFirstDigit ) );
#endif
- // wurde wirklich eine Ziffer eingefuegt ?
+
if( nTempDigit!=_NO_DIGIT )
- // jetzt wurde wirklich eine Ziffer ausgegeben, Flag setzen
bFirstDigit = sal_False;
- // muss ggf. ein Tausender-Trennzeichen erzeugt werden?
+
if( bGenerateThousandSeparator && ( c=='0' || nMaxDigit>=nDigitPos ) && nDigitPos>0 && (nDigitPos % 3 == 0) )
StrAppendChar( sReturnStrg,cThousandSep );
}
- // und Position aktualisieren
+
nDigitPos--;
}
else
{
- // Behandlung des Exponenten
+ // handling the exponent
if( bFirstExponentDigit )
{
- // Vorzeichen wurde schon bei e/E ausgegeben
+ // leading sign has been given out at e/E already
bFirstExponentDigit = sal_False;
if( nMaxExponentDigit>nExponentPos )
- // hier jetzt "uberz"ahlige Stellen ausgeben,
- // d.h. vom Format-String nicht erfasste Stellen
+ // output redundant positions, i. e. those which
+ // are undocumented by the format-string
{
for( short j=nMaxExponentDigit; j>nExponentPos; j-- )
{
@@ -834,9 +762,9 @@ void SbxBasicFormater::ScanFormatString( double dNumber,
}
}
}
- // muss f"ur eine leere Stelle eventuell eine 0 ausgegeben werden ?
+
if( nMaxExponentDigit<nExponentPos && c=='0' )
- AppendDigit( sReturnStrg,0 ); // Ja
+ AppendDigit( sReturnStrg,0 );
else
#ifdef _with_sprintf
AppendDigit( sReturnStrg,GetDigitAtPosExpScan( dExponent,nExponentPos,bFoundFirstDigit ) );
@@ -855,25 +783,23 @@ void SbxBasicFormater::ScanFormatString( double dNumber,
i-=2;
break;
}
- // gebe Komma aus
StrAppendChar( sReturnStrg,cDecPoint );
break;
case '%':
- // ggf. "uberf"ussige 0en l"oschen, z.B. 4.500e4 in 0.0##e-00
+ // maybe remove redundant 0s, e. g. 4.500e4 in 0.0##e-00
ParseBack( sReturnStrg,sFormatStrg,i-1 );
- // gebe Prozent-Zeichen aus
sReturnStrg.Insert('%');
break;
case 'e':
case 'E':
- // muss Mantisse noch gerundet werden, bevor der Exponent angezeigt wird ?
+ // does mantissa have to be rounded, before the exponent is displayed?
{
- // gibt es ueberhaupt eine Mantisse ?
+ // is there a mantissa at all?
if( bFirstDigit )
{
- // anscheinend nicht, d.h. ungueltiger Format String, z.B. E000.00
- // d.h. ignoriere diese e bzw. E Zeichen
- // ggf. einen Fehler (wie Visual Basic) ausgeben ?
+ // apparently not, i. e. invalid format string, e. g. E000.00
+ // so ignore these e and E characters
+ // maybe output an error (like in Visual Basic)?
// #i13821: VB 6 behaviour
StrAppendChar( sReturnStrg,c );
@@ -890,37 +816,30 @@ void SbxBasicFormater::ScanFormatString( double dNumber,
StrRoundDigit( sReturnStrg,sReturnStrg.Len()-1,bOverflow );
if( bOverflow )
{
- // es wurde eine f"uhrende 9 gerundet, d.h.
- // verschiebe den Dezimal-Punkt um eine Stelle nach links
+ // a leading 9 has been rounded
LeftShiftDecimalPoint( sReturnStrg );
- // und l"osche die letzte Ziffer, diese wird
- // duch die f"uhrende 1 ersetzt:
sReturnStrg.SetChar( sReturnStrg.Len()-1 , 0 );
- // der Exponent muss um 1 erh"oht werden,
- // da der Dezimalpunkt verschoben wurde
dExponent += 1.0;
}
- // ggf. "uberf"ussige 0en l"oschen, z.B. 4.500e4 in 0.0##e-00
+ // maybe remove redundant 0s, e. g. 4.500e4 in 0.0##e-00
ParseBack( sReturnStrg,sFormatStrg,i-1 );
}
- // "andere Zustand des Scanners
+ // change the scanner's condition
nState++;
- // gebe Exponent-Zeichen aus
+ // output exponent character
StrAppendChar( sReturnStrg,c );
- // i++; // MANIPULATION der Schleifen-Variable !
+ // i++; // MANIPULATION of the loop-variable!
c = sFormatStrg.GetChar( ++i );
- // und gebe Vorzeichen / Exponent aus
+ // output leading sign / exponent
if( c!=0 )
{
if( c=='-' )
{
- // falls Exponent < 0 gebe - aus
if( dExponent<0.0 )
StrAppendChar( sReturnStrg,'-' );
}
else if( c=='+' )
{
- // gebe auf jeden Fall das Vorzeichen des Exponenten aus !
if( dExponent<0.0 )
StrAppendChar( sReturnStrg,'-' );
else
@@ -934,50 +853,43 @@ void SbxBasicFormater::ScanFormatString( double dNumber,
break;
case '(':
case ')':
- // ggf. "uberf"ussige 0en l"oschen, z.B. 4.500e4 in 0.0##e-00
+ // maybe remove redundant 0s, e. g. 4.500e4 in 0.0##e-00
ParseBack( sReturnStrg,sFormatStrg,i-1 );
if( bIsNegative )
StrAppendChar( sReturnStrg,c );
break;
case '$':
- // den String fuer die Waehrung dranhengen:
+ // append the string for the currency:
sReturnStrg += sCurrencyStrg;
break;
case ' ':
case '-':
case '+':
- // ggf. "uberf"ussige 0en l"oschen, z.B. 4.500e4 in 0.0##e-00
ParseBack( sReturnStrg,sFormatStrg,i-1 );
- // gebe das jeweilige Zeichen direkt aus
StrAppendChar( sReturnStrg,c );
break;
case '\\':
- // ggf. "uberf"ussige 0en l"oschen, z.B. 4.500e4 in 0.0##e-00
- // falls Sonderzeichen am Ende oder mitten in
- // Format-String vorkommen
ParseBack( sReturnStrg,sFormatStrg,i-1 );
- // Sonderzeichen gefunden, gebe N"ACHSTES
- // Zeichen direkt aus (falls es existiert)
+ // special character found, output next
+ // character directly (if existing)
c = sFormatStrg.GetChar( ++i );
if( c!=0 )
StrAppendChar( sReturnStrg,c );
break;
case CREATE_1000SEP_CHAR:
- // hier ignorieren, Aktion wurde schon in
- // AnalyseFormatString durchgef"uhrt
+ // ignore here, action has already been
+ // executed in AnalyseFormatString
break;
default:
- // auch die Zeichen und Ziffern ausgeben (wie in Visual-Basic)
+ // output characters and digits, too (like in Visual-Basic)
if( ( c>='a' && c<='z' ) ||
( c>='A' && c<='Z' ) ||
( c>='1' && c<='9' ) )
StrAppendChar( sReturnStrg,c );
}
}
- // Format-String wurde vollst"andig gescanned,
- // muss die letzte Stelle nun gerundet werden ?
- // Dies hier ist jedoch NUR notwendig, falls das
- // Zahlenformat NICHT Scientific-Format ist !
+
+ // scan completed - rounding necessary?
if( !bScientific )
{
#ifdef _with_sprintf
@@ -988,9 +900,7 @@ void SbxBasicFormater::ScanFormatString( double dNumber,
if( nNextDigit>=5 )
StrRoundDigit( sReturnStrg,sReturnStrg.Len()-1 );
}
- // und ganz zum Schluss:
- // ggf. "uberf"ussige 0en l"oschen, z.B. 4.500e4 in 0.0##e-00#,
- // ABER nur Stellen nach dem Dezimal-Punkt k"onnen gel"oscht werden
+
if( nNoOfDigitsRight>0 )
ParseBack( sReturnStrg,sFormatStrg,sFormatStrg.Len()-1 );
}
@@ -1011,7 +921,7 @@ String SbxBasicFormater::BasicFormat( double dNumber, String sFormatStrg )
{
sal_Bool bPosFormatFound,bNegFormatFound,b0FormatFound;
- // analysiere Format-String auf vordefinierte Formate:
+ // analyse format-string concerning predefined formats:
if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_GENERALNUMBER ) )
sFormatStrg.AssignAscii( GENERALNUMBER_FORMAT );
if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_CURRENCY ) )
@@ -1031,8 +941,8 @@ String SbxBasicFormater::BasicFormat( double dNumber, String sFormatStrg )
if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_ONOFF ) )
return ( dNumber==0.0 ) ? sOffStrg : sOnStrg ;
- // analysiere Format-String auf ';', d.h. Format-Strings f"ur
- // positive-, negative- und 0-Werte
+ // analyse format-string concerning ';', i. e. format-strings for
+ // positive-, negative- and 0-values
String sPosFormatStrg = GetPosFormatString( sFormatStrg, bPosFormatFound );
String sNegFormatStrg = GetNegFormatString( sFormatStrg, bNegFormatFound );
String s0FormatStrg = Get0FormatString( sFormatStrg, b0FormatFound );
@@ -1045,16 +955,13 @@ String SbxBasicFormater::BasicFormat( double dNumber, String sFormatStrg )
sTempStrg = sFormatStrg;
if( b0FormatFound )
{
- // wurde ggf. Leer-String uebergeben ?
if( s0FormatStrg.Len() == 0 && bPosFormatFound )
- // --> Ja, dann verwende String fuer positive Werte
sTempStrg = sPosFormatStrg;
else
sTempStrg = s0FormatStrg;
}
else if( bPosFormatFound )
{
- // verwende String fuer positive Werte
sTempStrg = sPosFormatStrg;
}
ScanFormatString( dNumber, sTempStrg, sReturnStrg,/*bCreateSign=*/sal_False );
@@ -1065,11 +972,8 @@ String SbxBasicFormater::BasicFormat( double dNumber, String sFormatStrg )
{
if( bNegFormatFound )
{
- // wurde ggf. Leer-String uebergeben ?
if( sNegFormatStrg.Len() == 0 && bPosFormatFound )
{
- // --> Ja, dann verwende String fuer positive Werte
- // und setzte Minus-Zeichen davor !
sTempStrg = String::CreateFromAscii("-");
sTempStrg += sPosFormatStrg;
}
@@ -1078,8 +982,8 @@ String SbxBasicFormater::BasicFormat( double dNumber, String sFormatStrg )
}
else
sTempStrg = sFormatStrg;
- // falls KEIN Format-String speziell f"ur negative Werte angegeben
- // wurde, so soll das Vorzeichen ausgegeben werden
+ // if NO format-string especially for negative
+ // values is given, output the leading sign
ScanFormatString( dNumber, sTempStrg, sReturnStrg,/*bCreateSign=*/bNegFormatFound/*sNegFormatStrg!=EMPTYFORMATSTRING*/ );
}
else // if( dNumber>0.0 )
diff --git a/basic/source/sbx/sbxscan.cxx b/basic/source/sbx/sbxscan.cxx
index 95d4b8d..229f350 100644
--- a/basic/source/sbx/sbxscan.cxx
+++ b/basic/source/sbx/sbxscan.cxx
@@ -63,19 +63,15 @@ void ImpGetIntntlSep( sal_Unicode& rcDecimalSep, sal_Unicode& rcThousandSep )
rcThousandSep = rData.getNumThousandSep().GetBuffer()[0];
}
-// Scannen eines Strings nach BASIC-Konventionen
-// Dies entspricht den ueblichen Konventionen, nur dass der Exponent
-// auch ein D sein darf, was den Datentyp auf SbxDOUBLE festlegt.
-// Die Routine versucht, den Datentyp so klein wie moeglich zu gestalten.
-// Das ganze gibt auch noch einen Konversionsfehler, wenn der Datentyp
-// Fixed ist und das ganze nicht hineinpasst!
+// scanning a string according to BASIC-conventions
+// but exponent may also be a D, so data type is SbxDOUBLED
+// conversion error if data type is fixed and it doesn't fit
SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType,
sal_uInt16* pLen, sal_Bool bAllowIntntl, sal_Bool bOnlyIntntl )
{
::rtl::OString aBStr( ::rtl::OUStringToOString( rWSrc, RTL_TEXTENCODING_ASCII_US ) );
- // Bei International Komma besorgen
char cIntntlComma, cIntntl1000;
char cNonIntntlComma = '.';
@@ -86,13 +82,13 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType
cIntntlComma = (char)cDecimalSep;
cIntntl1000 = (char)cThousandSep;
}
- // Sonst einfach auch auf . setzen
+
else
{
cIntntlComma = cNonIntntlComma;
- cIntntl1000 = cNonIntntlComma; // Unschaedlich machen
+ cIntntl1000 = cNonIntntlComma;
}
- // Nur International -> IntnlComma uebernehmen
+
if( bOnlyIntntl )
{
cNonIntntlComma = cIntntlComma;
@@ -106,20 +102,17 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType
sal_Bool bMinus = sal_False;
nVal = 0;
SbxDataType eScanType = SbxSINGLE;
- // Whitespace wech
while( *p &&( *p == ' ' || *p == '\t' ) ) p++;
- // Zahl? Dann einlesen und konvertieren.
if( *p == '-' )
p++, bMinus = sal_True;
if( isdigit( *p ) ||( (*p == cNonIntntlComma || *p == cIntntlComma ||
*p == cIntntl1000) && isdigit( *(p+1 ) ) ) )
{
- short exp = 0; // >0: Exponentteil
- short comma = 0; // >0: Nachkomma
- short ndig = 0; // Anzahl Ziffern
- short ncdig = 0; // Anzahl Ziffern nach Komma
+ short exp = 0;
+ short comma = 0;
+ short ndig = 0;
+ short ncdig = 0; // number of digits after decimal point
ByteString aSearchStr( "0123456789DEde" );
- // Kommas ergaenzen
aSearchStr += cNonIntntlComma;
if( cIntntlComma != cNonIntntlComma )
aSearchStr += cIntntlComma;
@@ -128,17 +121,15 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType
const char* pSearchStr = aSearchStr.GetBuffer();
while( strchr( pSearchStr, *p ) && *p )
{
- // 1000er-Trenner ueberlesen
if( bOnlyIntntl && *p == cIntntl1000 )
{
p++;
continue;
}
- // Komma oder Exponent?
if( *p == cNonIntntlComma || *p == cIntntlComma )
{
- // Immer '.' einfuegen, damit atof funktioniert
+ // always insert '.' so that atof works
p++;
if( ++comma > 1 )
continue;
@@ -154,7 +145,7 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType
if( toupper( *p ) == 'D' )
eScanType = SbxDOUBLE;
*q++ = 'E'; p++;
- // Vorzeichen hinter Exponent?
+
if( *p == '+' )
p++;
else
@@ -169,10 +160,10 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType
if( !exp ) ndig++;
}
*q = 0;
- // Komma, Exponent mehrfach vorhanden?
+
if( comma > 1 || exp > 1 )
bRes = sal_False;
- // Kann auf Integer gefaltet werden?
+
if( !comma && !exp )
{
if( nVal >= SbxMININT && nVal <= SbxMAXINT )
@@ -183,14 +174,14 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType
nVal = atof( buf );
ndig = ndig - comma;
- // zu viele Zahlen fuer SINGLE?
+ // too many numbers for SINGLE?
if( ndig > 15 || ncdig > 6 )
eScanType = SbxDOUBLE;
- // Typkennung?
+ // type detection?
if( strchr( "%!&#", *p ) && *p ) p++;
}
- // Hex/Oktalzahl? Einlesen und konvertieren:
+ // hex/octal number? read in and convert:
else if( *p == '&' )
{
p++;
@@ -243,21 +234,21 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType
return SbxERR_OK;
}
-// Schnittstelle fuer CDbl im Basic
+// port for CDbl in the Basic
SbxError SbxValue::ScanNumIntnl( const String& rSrc, double& nVal, sal_Bool bSingle )
{
SbxDataType t;
sal_uInt16 nLen = 0;
SbxError nRetError = ImpScan( rSrc, nVal, t, &nLen,
/*bAllowIntntl*/sal_False, /*bOnlyIntntl*/sal_True );
- // Komplett gelesen?
+ // read completely?
if( nRetError == SbxERR_OK && nLen != rSrc.Len() )
nRetError = SbxERR_CONVERSION;
if( bSingle )
{
SbxValues aValues( nVal );
- nVal = (double)ImpGetSingle( &aValues ); // Hier Error bei Overflow
+ nVal = (double)ImpGetSingle( &aValues ); // here error at overflow
}
return nRetError;
}
@@ -271,13 +262,13 @@ static double roundArray[] = {
|*
|* void myftoa( double, char *, short, short, sal_Bool, sal_Bool )
|*
-|* Beschreibung: Konversion double --> ASCII
-|* Parameter: double die Zahl.
-|* char * der Zielpuffer
-|* short Anzahl Nachkommastellen
-|* short Weite des Exponenten( 0=kein E )
-|* sal_Bool sal_True: mit 1000er Punkten
-|* sal_Bool sal_True: formatfreie Ausgabe
+|* description: conversion double --> ASCII
+|* parameters: double the number
+|* char * target buffer
+|* short number of positions after decimal point
+|* short range of the exponent ( 0=no E )
+|* sal_Bool sal_True: with 1000-separators
+|* sal_Bool sal_True: output without formatting
|*
***************************************************************************/
@@ -285,18 +276,17 @@ static void myftoa( double nNum, char * pBuf, short nPrec, short nExpWidth,
sal_Bool bPt, sal_Bool bFix, sal_Unicode cForceThousandSep = 0 )
{
- short nExp = 0; // Exponent
- short nDig = nPrec + 1; // Anzahl Digits in Zahl
- short nDec; // Anzahl Vorkommastellen
+ short nExp = 0;
+ short nDig = nPrec + 1;
+ short nDec; // number of positions before decimal point
register int i;
- // Komma besorgen
sal_Unicode cDecimalSep, cThousandSep;
ImpGetIntntlSep( cDecimalSep, cThousandSep );
if( cForceThousandSep )
cThousandSep = cForceThousandSep;
- // Exponentberechnung:
+ // compute exponent
nExp = 0;
if( nNum > 0.0 )
{
@@ -308,7 +298,7 @@ static void myftoa( double nNum, char * pBuf, short nPrec, short nExpWidth,
else if( bFix && !nPrec )
nDig = nExp + 1;
- // Zahl runden:
+ // round number
if( (nNum += roundArray [( nDig > 16 ) ? 16 : nDig] ) >= 10.0 )
{
nNum = 1.0;
@@ -316,12 +306,12 @@ static void myftoa( double nNum, char * pBuf, short nPrec, short nExpWidth,
if( !nExpWidth ) ++nDig;
}
- // Bestimmung der Vorkommastellen:
+ // determine positions before decimal point
if( !nExpWidth )
{
if( nExp < 0 )
{
- // #41691: Auch bei bFix eine 0 spendieren
+ // #41691: also a 0 at bFix
*pBuf++ = '0';
if( nPrec ) *pBuf++ = (char)cDecimalSep;
i = -nExp - 1;
@@ -335,7 +325,7 @@ static void myftoa( double nNum, char * pBuf, short nPrec, short nExpWidth,
else
nDec = 1;
- // Zahl ausgeben:
+ // output number
if( nDig > 0 )
{
register int digit;
@@ -360,7 +350,7 @@ static void myftoa( double nNum, char * pBuf, short nPrec, short nExpWidth,
}
}
- // Exponent ausgeben:
+ // output exponent
if( nExpWidth )
{
if( nExpWidth < 3 ) nExpWidth = 3;
@@ -380,10 +370,10 @@ static void myftoa( double nNum, char * pBuf, short nPrec, short nExpWidth,
*pBuf = 0;
}
-// Die Zahl wird unformatiert mit der angegebenen Anzahl NK-Stellen
-// aufbereitet. Evtl. wird ein Minus vorangestellt.
-// Diese Routine ist public, weil sie auch von den Put-Funktionen
-// der Klasse SbxImpSTRING verwendet wird.
+// The number is prepared unformattedly with the given number of
+// NK-positions. A leading minus is added if applicable.
+// This routine is public because it's also used by the Put-functions
+// in the class SbxImpSTRING.
#ifdef _MSC_VER
#pragma optimize( "", off )
@@ -407,7 +397,7 @@ void ImpCvtNum( double nNum, short nPrec, ::rtl::OUString& rRes, sal_Bool bCoreS
double dMaxNumWithoutExp = (nPrec == 6) ? 1E6 : 1E14;
myftoa( nNum, p, nPrec,( nNum &&( nNum < 1E-1 || nNum >= dMaxNumWithoutExp ) ) ? 4:0,
sal_False, sal_True, cDecimalSep );
- // Trailing Zeroes weg:
+ // remove trailing zeros
for( p = cBuf; *p &&( *p != 'E' ); p++ ) {}
q = p; p--;
while( nPrec && *p == '0' ) nPrec--, p--;
@@ -423,26 +413,23 @@ void ImpCvtNum( double nNum, short nPrec, ::rtl::OUString& rRes, sal_Bool bCoreS
sal_Bool ImpConvStringExt( ::rtl::OUString& rSrc, SbxDataType eTargetType )
{
- // Merken, ob ueberhaupt was geaendert wurde
sal_Bool bChanged = sal_False;
::rtl::OUString aNewString;
- // Nur Spezial-F�lle behandeln, als Default tun wir nichts
+ // only special cases are handled, nothing on default
switch( eTargetType )
{
- // Bei Fliesskomma International beruecksichtigen
+ // consider international for floating point
case SbxSINGLE:
case SbxDOUBLE:
case SbxCURRENCY:
{
::rtl::OString aBStr( ::rtl::OUStringToOString( rSrc, RTL_TEXTENCODING_ASCII_US ) );
- // Komma besorgen
sal_Unicode cDecimalSep, cThousandSep;
ImpGetIntntlSep( cDecimalSep, cThousandSep );
aNewString = rSrc;
- // Ersetzen, wenn DecimalSep kein '.' (nur den ersten)
if( cDecimalSep != (sal_Unicode)'.' )
{
sal_Int32 nPos = aNewString.indexOf( cDecimalSep );
@@ -456,7 +443,7 @@ sal_Bool ImpConvStringExt( ::rtl::OUString& rSrc, SbxDataType eTargetType )
break;
}
- // Bei sal_Bool sal_True und sal_False als String pruefen
+ // check as string in case of sal_Bool sal_True and sal_False
case SbxBOOL:
{
if( rSrc.equalsIgnoreAsciiCaseAscii( "true" ) )
@@ -474,39 +461,38 @@ sal_Bool ImpConvStringExt( ::rtl::OUString& rSrc, SbxDataType eTargetType )
}
default: break;
}
- // String bei Aenderung uebernehmen
+
if( bChanged )
rSrc = aNewString;
return bChanged;
}
-// Formatierte Zahlenausgabe
-// Der Returnwert ist die Anzahl Zeichen, die aus dem
-// Format verwendt wurden.
+// formatted number output
+// the return value is the number of characters used
+// from the format
#ifdef _old_format_code_
-// lasse diesen Code vorl"aufig drin, zum 'abgucken'
-// der bisherigen Implementation
+// leave the code provisionally to copy the previous implementation
static sal_uInt16 printfmtnum( double nNum, XubString& rRes, const XubString& rWFmt )
{
const String& rFmt = rWFmt;
- char cFill = ' '; // Fuellzeichen
- char cPre = 0; // Startzeichen( evtl. "$" )
- short nExpDig= 0; // Anzahl Exponentstellen
- short nPrec = 0; // Anzahl Nachkommastellen
- short nWidth = 0; // Zahlenweite gesamnt
- short nLen; // Laenge konvertierte Zahl
- sal_Bool bPoint = sal_False; // sal_True: mit 1000er Kommas
- sal_Bool bTrail = sal_False; // sal_True, wenn folgendes Minus
- sal_Bool bSign = sal_False; // sal_True: immer mit Vorzeichen
- sal_Bool bNeg = sal_False; // sal_True: Zahl ist negativ
- char cBuf [1024]; // Zahlenpuffer
+ char cFill = ' '; // filling characters
+ char cPre = 0; // start character ( maybe "$" )
+ short nExpDig= 0; // number of exponent positions
+ short nPrec = 0; // number of positions after decimal point
+ short nWidth = 0; // number range completely
+ short nLen; // length of converted number
+ sal_Bool bPoint = sal_False; // sal_True: with 1000 seperators
+ sal_Bool bTrail = sal_False; // sal_True, if following minus
+ sal_Bool bSign = sal_False; // sal_True: always with leading sign
+ sal_Bool bNeg = sal_False; // sal_True: number is negative
+ char cBuf [1024]; // number buffer
char * p;
const char* pFmt = rFmt;
rRes.Erase();
- // $$ und ** abfangen. Einfach wird als Zeichen ausgegeben.
+ // catch $$ and **, is simply output as character
if( *pFmt == '$' )
if( *++pFmt != '$' ) rRes += '$';
if( *pFmt == '*' )
@@ -529,30 +515,30 @@ static sal_uInt16 printfmtnum( double nNum, XubString& rRes, const XubString& rW
case ',':
pFmt--; break;
}
- // Vorkomma:
+ // pre point
for( ;; )
{
while( *pFmt == '#' ) pFmt++, nWidth++;
- // 1000er Kommas?
+ // 1000 separators?
if( *pFmt == ',' )
{
nWidth++; pFmt++; bPoint = sal_True;
} else break;
}
- // Nachkomma:
+ // after point
if( *pFmt == '.' )
{
while( *++pFmt == '#' ) nPrec++;
nWidth += nPrec + 1;
}
- // Exponent:
+ // exponent
while( *pFmt == '^' )
pFmt++, nExpDig++, nWidth++;
- // Folgendes Minus:
+ // following minus
if( !bSign && *pFmt == '-' )
pFmt++, bTrail = sal_True;
- // Zahl konvertieren:
+ // convert number
if( nPrec > 15 ) nPrec = 15;
if( nNum < 0.0 ) nNum = -nNum, bNeg = sal_True;
p = cBuf;
@@ -560,7 +546,7 @@ static sal_uInt16 printfmtnum( double nNum, XubString& rRes, const XubString& rW
myftoa( nNum, p, nPrec, nExpDig, bPoint, sal_False );
nLen = strlen( cBuf );
- // Ueberlauf?
+ // overflow?
if( cPre ) nLen++;
if( nLen > nWidth ) rRes += '%';
else {
@@ -849,7 +835,7 @@ void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const
case SbxULONG:
case SbxINT:
case SbxUINT:
- case SbxNULL: // #45929 NULL mit durchschummeln
+ case SbxNULL: // #45929 NULL with a little cheating
nComma = 0; goto cvt;
case SbxSINGLE:
nComma = 6; goto cvt;
@@ -860,11 +846,10 @@ void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const
if( eType != SbxNULL )
d = GetDouble();
- // #45355 weiterer Einsprungpunkt fuer isnumeric-String
+ // #45355 another point to jump in for isnumeric-String
cvt2:
if( pFmt )
{
- // hole die 'statischen' Daten f"ur Sbx
SbxAppData* pData = GetSbxData_Impl();
LanguageType eLangType = GetpApp()->GetSettings().GetLanguage();
@@ -878,8 +863,7 @@ void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const
}
pData->eBasicFormaterLangType = eLangType;
- // falls bisher noch kein BasicFormater-Objekt
- // existiert, so erzeuge dieses
+
if( !pData->pBasicFormater )
{
SvtSysLocale aSysLocale;
@@ -888,9 +872,9 @@ void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const
sal_Unicode c1000 = rData.getNumThousandSep().GetBuffer()[0];
String aCurrencyStrg = rData.getCurrSymbol();
- // Initialisierung des Basic-Formater-Hilfsobjekts:
- // hole die Resourcen f"ur die vordefinierten Ausgaben
- // des Format()-Befehls, z.B. f"ur "On/Off".
+ // initialize the Basic-formater help object:
+ // get resources for predefined output
+ // of the Format()-command, e. g. for "On/Off"
String aOnStrg = String( SbxValueFormatResId(
STR_BASICKEY_FORMAT_ON ) );
String aOffStrg = String( SbxValueFormatResId(
@@ -905,22 +889,22 @@ void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const
STR_BASICKEY_FORMAT_FALSE) );
String aCurrencyFormatStrg = String( SbxValueFormatResId(
STR_BASICKEY_FORMAT_CURRENCY) );
- // erzeuge das Basic-Formater-Objekt
+
pData->pBasicFormater
= new SbxBasicFormater( cComma,c1000,aOnStrg,aOffStrg,
aYesStrg,aNoStrg,aTrueStrg,aFalseStrg,
aCurrencyStrg,aCurrencyFormatStrg );
}
- // Bem.: Aus Performance-Gr"unden wird nur EIN BasicFormater-
- // Objekt erzeugt und 'gespeichert', dadurch erspart man
- // sich das teure Resourcen-Laden (f"ur landesspezifische
- // vordefinierte Ausgaben, z.B. "On/Off") und die st"andige
- // String-Erzeugungs Operationen.
- // ABER: dadurch ist dieser Code NICHT multithreading f"ahig !
-
- // hier gibt es Probleme mit ;;;Null, da diese Methode nur aufgerufen
- // wird, wenn der SbxValue eine Zahl ist !!!
- // dazu koennte: pData->pBasicFormater->BasicFormatNull( *pFmt ); aufgerufen werden !
+ // Remark: For performance reasons there's only ONE BasicFormater-
+ // object created and 'stored', so that the expensive resource-
+ // loading is saved (for country-specific predefined outputs,
+ // e. g. "On/Off") and the continous string-creation
+ // operations, too.
+ // BUT: therefore this code is NOT multithreading capable!
+
+ // here are problems with ;;;Null because this method is only
+ // called, if SbxValue is a number!!!
+ // in addition pData->pBasicFormater->BasicFormatNull( *pFmt ); could be called!
if( eType != SbxNULL )
{
rRes = pData->pBasicFormater->BasicFormat( d ,*pFmt );
@@ -941,7 +925,7 @@ void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const
case SbxSTRING:
if( pFmt )
{
- // #45355 wenn es numerisch ist, muss gewandelt werden
+ // #45355 converting if numeric
if( IsNumericRTL() )
{
ScanNumIntnl( GetString(), d, /*bSingle*/sal_False );
@@ -949,7 +933,6 @@ void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const
}
else
{
- // Sonst String-Formatierung
printfmtstr( GetString(), rRes, *pFmt );
}
}
diff --git a/basic/workben/mgrtest.cxx b/basic/workben/mgrtest.cxx
index a269bcd..49d63ad 100644
--- a/basic/workben/mgrtest.cxx
+++ b/basic/workben/mgrtest.cxx
@@ -327,7 +327,7 @@ IMPL_LINK( TestWindow, TBSelect, ToolBox *, p )
{
if ( pBasMgr )
{
- // liegt in einem anderen Storage !!!
+ // is in another storage!!!
sal_uInt16 nLib = pBasMgr->GetLibId( pBasMgr->CreateLib( pLib3Str ) );
if ( nLib != LIB_NOTFOUND )
{
@@ -366,7 +366,7 @@ IMPL_LINK( TestWindow, TBSelect, ToolBox *, p )
{
if ( pBasMgr )
{
- // liegt in einem anderen Storage !!!
+ // is in another storage!!!
SvStorageRef xStorage = new SvStorage( "d:\\mystore2.svs" );
if ( !pBasMgr->AddLib( *xStorage, pLib3Str, sal_False ) )
Sound::Beep();
@@ -528,7 +528,7 @@ void __EXPORT TestWindow::KeyInput( const KeyEvent& rKEvt )
{
sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
- // Nur bei Alt-Return
+ // only for Alt-Return
if ( ( nCode == KEY_RETURN ) && rKEvt.GetKeyCode().IsMod2() )
;
else
--
1.7.4.1
--========GMX206631314795935933404--
More information about the LibreOffice
mailing list