summaryrefslogtreecommitdiff
path: root/basic/source/classes
diff options
context:
space:
mode:
authorJens-Heiner Rechtien <hr@openoffice.org>2000-09-18 15:18:56 +0000
committerJens-Heiner Rechtien <hr@openoffice.org>2000-09-18 15:18:56 +0000
commitc25ec0608a167bcf1d891043f02273761c351701 (patch)
tree32c3e19f0b663e37ad1910e8fddeac200ad3856d /basic/source/classes
initial import
Diffstat (limited to 'basic/source/classes')
-rw-r--r--basic/source/classes/disas.cxx701
-rw-r--r--basic/source/classes/image.cxx431
-rw-r--r--basic/source/classes/makefile.mk93
-rw-r--r--basic/source/classes/propacc.cxx435
-rw-r--r--basic/source/classes/sb.cxx1028
-rw-r--r--basic/source/classes/sb.src3747
-rw-r--r--basic/source/classes/sbintern.cxx109
-rw-r--r--basic/source/classes/sbunoobj.cxx2500
-rw-r--r--basic/source/classes/sbxmod.cxx1984
9 files changed, 11028 insertions, 0 deletions
diff --git a/basic/source/classes/disas.cxx b/basic/source/classes/disas.cxx
new file mode 100644
index 000000000000..74c3922f0ab0
--- /dev/null
+++ b/basic/source/classes/disas.cxx
@@ -0,0 +1,701 @@
+/*************************************************************************
+ *
+ * $RCSfile: disas.cxx,v $
+ *
+ * $Revision: 1.1.1.1 $
+ *
+ * last change: $Author: hr $ $Date: 2000-09-18 16:12:09 $
+ *
+ * The Contents of this file are made available subject to the terms of
+ * either of the following licenses
+ *
+ * - GNU Lesser General Public License Version 2.1
+ * - Sun Industry Standards Source License Version 1.1
+ *
+ * Sun Microsystems Inc., October, 2000
+ *
+ * GNU Lesser General Public License Version 2.1
+ * =============================================
+ * Copyright 2000 by Sun Microsystems, Inc.
+ * 901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ *
+ * Sun Industry Standards Source License Version 1.1
+ * =================================================
+ * The contents of this file are subject to the Sun Industry Standards
+ * Source License Version 1.1 (the "License"); You may not use this file
+ * except in compliance with the License. You may obtain a copy of the
+ * License at http://www.openoffice.org/license.html.
+ *
+ * Software provided under this License is provided on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ * See the License for the specific provisions governing your rights and
+ * obligations concerning the Software.
+ *
+ * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ * Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ * All Rights Reserved.
+ *
+ * Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+
+#ifndef _STREAM_HXX //autogen
+#include <tools/stream.hxx>
+#endif
+#pragma hdrstop
+#include <svtools/sbx.hxx>
+#include "sb.hxx"
+#include "iosys.hxx"
+#include "disas.hxx"
+// Makro MEMBER()
+#include "macfix.hxx"
+
+#include "segmentc.hxx"
+#pragma SW_SEGMENT_CLASS( SBDISAS, SBDISAS_CODE )
+
+static const char* pOp1[] = {
+ "NOP",
+
+ // Operatoren
+ // die folgenden Operatoren sind genauso angeordnet
+ // wie der 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
+ "LIKE", "IS",
+ // Laden/speichern
+ "ARGC", // neuen Argv einrichten
+ "ARGV", // TOS ==> aktueller Argv
+ "INPUT", // Input ==> TOS
+ "LINPUT", // Line Input ==> TOS
+ "GET", // TOS anfassen
+ "SET", // Speichern Objekt TOS ==> TOS-1
+ "PUT", // TOS ==> TOS-1
+ "CONST", // TOS ==> TOS-1, dann 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
+ "STDERR", // Standard-Fehlerbehandlung
+ "NOERROR", // keine Fehlerbehandlung
+ "LEAVE", // UP verlassen
+ // E/A
+ "CHANNEL", // TOS = Kanalnummer
+ "PRINT", // print TOS
+ "PRINTF", // print TOS in field
+ "WRITE", // write TOS
+ "RENAME", // Rename Tos+1 to Tos
+ "PROMPT", // TOS = Prompt for Input
+ "RESTART", // Restartpunkt definieren
+ "STDIO", // E/A-Kanal 0 einstellen
+ // Sonstiges
+ "EMPTY", // Leeren Ausdruck auf Stack
+ "ERROR", // TOS = Fehlercode
+ "LSET", // Speichern Objekt TOS ==> TOS-1
+ "RSET" // Speichern Objekt TOS ==> TOS-1
+};
+
+static const char* pOp2[] = {
+ "NUMBER", // Laden einer numerischen Konstanten (+ID)
+ "STRING", // Laden einer Stringkonstanten (+ID)
+ "CONST", // Immediate Load (+Wert)
+ "ARGN", // Speichern eines named Args in Argv (+StringID)
+ "PAD", // String auf feste Laenge bringen (+Laenge)
+ // Verzweigungen
+ "JUMP", // Sprung (+Target)
+ "JUMP.T", // TOS auswerten, bedingter Sprung (+Target)
+ "JUMP.F", // 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)
+ "CASETO", // Tos+1 <= Case <= Tos, 2xremove (+Target)
+ "ERRHDL", // Fehler-Handler (+Offset)
+ "RESUME", // Resume nach Fehlern (+0 or 1 or Label)
+ // E/A
+ "CLOSE", // (+Kanal/0)
+ "PRCHAR", // (+char)
+ // Objekte
+ "CLASS", // Klassennamen testen (+StringId)
+ "LIB", // Libnamen fuer Declare-Procs setzen (+StringId)
+ // Neues ab Beta 3
+ "BASED", // TOS wird um BASE erhoeht, BASE davor gepusht
+ "ARGTYP", // Letzten Parameter in Argv konvertieren (+Typ)
+};
+
+static const char* pOp3[] = {
+ // Alle Opcodes mit zwei Operanden
+ "RTL", // Laden aus RTL (+StringID+Typ)
+ "FIND", // Laden (+StringID+Typ)
+ "ELEM", // Laden Element (+StringID+Typ)
+ "PARAM", // Parameter (+Offset+Typ)
+ // Verzweigen
+ "CALL", // DECLARE-Methode rufen (+StringID+Typ)
+ "CALL.C", // Cdecl-DECLARE-Methode rufen (+StringID+Typ)
+ "CASEIS", // Case-Test (+Test-Opcode+False-Target)
+ "STMNT", // Beginn eines Statements (+Line+Col)
+ // E/A
+ "OPEN", // (+SvStreamFlags+Flags)
+ // Objekte und Variable
+ "LOCAL", // Lokale Variable (+StringID+Typ)
+ "PUBLIC", // Modulglobale Variable (+StringID+Typ)
+ "GLOBAL", // Globale Variable (+StringID+Typ)
+ "CREATE", // Objekt kreieren (+StringId+StringId)
+ "STATIC", // Objekt kreieren (+StringId+StringId)
+ "TCREATE", // User defined Objekt kreieren (+StringId+StringId)
+ "DCREATE", // User defined Objekt-Array kreieren (+StringId+StringId)
+};
+
+static const char** pOps[3] = { pOp1, pOp2, pOp3 };
+
+typedef void( SbiDisas::*Func )( String& ); // Verarbeitungsroutine
+
+static const Func pOperand2[] = {
+ MEMBER(SbiDisas::StrOp), // Laden einer numerischen Konstanten (+ID)
+ MEMBER(SbiDisas::StrOp), // Laden einer Stringkonstanten (+ID)
+ MEMBER(SbiDisas::ImmOp), // Immediate Load (+Wert)
+ MEMBER(SbiDisas::StrOp), // Speichern eines benannten Arguments(+ID)
+ MEMBER(SbiDisas::ImmOp), // String auf feste Laenge bringen (+Laenge)
+ // Verzweigungen
+ MEMBER(SbiDisas::LblOp), // Sprung (+Target)
+ MEMBER(SbiDisas::LblOp), // TOS auswerten), bedingter Sprung (+Target)
+ MEMBER(SbiDisas::LblOp), // TOS auswerten), bedingter Sprung (+Target)
+ MEMBER(SbiDisas::OnOp), // TOS auswerten), Sprung in JUMP-Tabelle (+MaxVal)
+ MEMBER(SbiDisas::LblOp), // UP-Aufruf (+Target)
+ MEMBER(SbiDisas::ReturnOp), // UP-Return (+0 oder Target)
+ MEMBER(SbiDisas::LblOp), // FOR-Variable testen), inkrementieren (+Endlabel)
+ MEMBER(SbiDisas::LblOp), // Tos+1 <= Case <= Tos), 2xremove (+Target)
+ MEMBER(SbiDisas::LblOp), // Fehler-Handler (+Offset)
+ MEMBER(SbiDisas::ResumeOp), // Resume nach Fehlern (+0 or 1 or Label)
+ // E/A
+ MEMBER(SbiDisas::CloseOp), // (+Kanal/0)
+ MEMBER(SbiDisas::CharOp), // (+char)
+ // Objekte
+ MEMBER(SbiDisas::StrOp), // Klassennamen testen (+StringId)
+ MEMBER(SbiDisas::StrOp), // Libnamen fuer Declare-Procs setzen (+StringId)
+ MEMBER(SbiDisas::ImmOp), // TOS wird um BASE erhoeht, BASE davor gepusht
+ MEMBER(SbiDisas::TypeOp), // Letzten Parameter in Argv konvertieren (+Typ)
+};
+
+static const Func pOperand3[] = {
+ // Alle Opcodes mit zwei Operanden
+ MEMBER(SbiDisas::VarOp), // Laden aus RTL (+StringID+Typ)
+ MEMBER(SbiDisas::VarOp), // Laden (+StringID+Typ)
+ MEMBER(SbiDisas::VarOp), // Laden Element (+StringID+Typ)
+ MEMBER(SbiDisas::OffOp), // Parameter (+Offset+Typ)
+ // Verzweigen
+ MEMBER(SbiDisas::VarOp), // DECLARE-Methode rufen (+StringID+Typ)
+ MEMBER(SbiDisas::VarOp), // CDecl-DECLARE-Methode rufen (+StringID+Typ)
+ MEMBER(SbiDisas::CaseOp), // Case-Test (+Test-Opcode+False-Target)
+ MEMBER(SbiDisas::StmntOp), // Statement (+Zeilen+Spalte)
+ // E/A
+ MEMBER(SbiDisas::StrmOp), // (+SvStreamFlags+Flags)
+ // Objekte
+ MEMBER(SbiDisas::VarDefOp), // Lokale Variable definieren (+StringID+Typ)
+ MEMBER(SbiDisas::VarDefOp), // Modulglobale Variable definieren (+StringID+Typ)
+ MEMBER(SbiDisas::VarDefOp), // Globale Variable definieren (+StringID+Typ)
+ MEMBER(SbiDisas::Str2Op), // Objekt kreieren (+StringId+StringId)
+ MEMBER(SbiDisas::VarDefOp), // Statische Variable definieren (+StringID+Typ)
+ MEMBER(SbiDisas::Str2Op), // User defined Objekt kreieren (+StringId+StringId)
+ MEMBER(SbiDisas::Str2Op), // User defined Objekt-Array kreieren (+StringId+StringId)
+};
+
+static const char* _crlf()
+{
+#if defined (MAC)
+ return "\n";
+#elif defined (UNX) || defined( PM2 )
+ return "\n";
+#else
+ return "\r\n";
+#endif
+}
+
+// Diese Methode ist hier, damit die Datei als eigenes Segment geladen werden
+// kann.
+
+BOOL SbModule::Disassemble( String& rText )
+{
+ rText.Erase();
+ if( pImage )
+ {
+ SbiDisas aDisas( this, pImage );
+ aDisas.Disas( rText );
+ }
+ return BOOL( rText.Len() != 0 );
+}
+
+SbiDisas::SbiDisas( SbModule* p, const SbiImage* q ) : rImg( *q ), pMod( p )
+{
+ memset( cLabels, 0, 8192 );
+ nLine = nOff = nPC = nOp1 = nOp2 = nParts = 0;
+ eOp = _NOP;
+ // Label-Bits setzen
+ USHORT nPos;
+ nOff = 0;
+ while( Fetch() )
+ {
+ BOOL bLbl = FALSE;
+ switch( eOp )
+ {
+ case _RESUME: if( nOp1 <= 1 ) break;
+ case _RETURN: if( !nOp1 ) break;
+ case _JUMP:
+ case _JUMPT:
+ case _JUMPF:
+ case _GOSUB:
+ case _TESTFOR:
+ case _CASEIS:
+ case _CASETO:
+ case _ERRHDL: nPos = nOp1; bLbl = TRUE; break;
+ }
+ if( bLbl )
+ cLabels[ nPos >> 3 ] |= ( 1 << ( nPos & 7 ) );
+ }
+ nOff = 0;
+ // Die Publics noch dazu
+ for( USHORT i = 0; i < pMod->GetMethods()->Count(); i++ )
+ {
+ SbMethod* pMeth = PTR_CAST(SbMethod,pMod->GetMethods()->Get( i ));
+ if( pMeth )
+ {
+ nPos = pMeth->GetId();
+ cLabels[ nPos >> 3 ] |= ( 1 << ( nPos & 7 ) );
+ }
+ }
+}
+
+// Aktuellen Opcode auslesen
+
+BOOL SbiDisas::Fetch()
+{
+ nPC = nOff;
+ if( nOff >= rImg.GetCodeSize() )
+ return FALSE;
+ const char* p = rImg.GetCode() + nOff;
+ eOp = (SbiOpcode) ( *p++ & 0xFF );
+ if( eOp <= SbOP0_END )
+ {
+ nOp1 = nOp2 = 0;
+ nParts = 1;
+ nOff++;
+ return TRUE;
+ }
+ else if( eOp <= SbOP1_END )
+ {
+ nOff += 3;
+ if( nOff > rImg.GetCodeSize() )
+ return FALSE;
+ nOp1 = *p++ & 0xFF; nOp1 |= *p << 8;
+ nParts = 2;
+ return TRUE;
+ }
+ else if( eOp <= SbOP2_END )
+ {
+ nOff += 5;
+ if( nOff > rImg.GetCodeSize() )
+ return FALSE;
+ nOp1 = *p++ & 0xFF; nOp1 |= *p++ << 8;
+ nOp2 = *p++ & 0xFF; nOp2 |= *p << 8;
+ nParts = 3;
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
+void SbiDisas::Disas( SvStream& r )
+{
+ String aText;
+ nOff = 0;
+ while( DisasLine( aText ) )
+ {
+ ByteString aByteText( aText, gsl_getSystemTextEncoding() );
+ r.WriteLine( aByteText );
+ }
+}
+
+void SbiDisas::Disas( String& r )
+{
+ r.Erase();
+ String aText;
+ nOff = 0;
+ while( DisasLine( aText ) )
+ {
+ r += aText;
+ r.AppendAscii( _crlf() );
+ }
+ aText.ConvertLineEnd();
+}
+
+#ifdef HP9000
+const char* SbiDisas_DisasLine_pMask[] = {
+ "%04X ",
+ "%04X %02X ",
+ "%04X %02X %04X ",
+ "%04X %02X %04X %04X " };
+#define pMask SbiDisas_DisasLine_pMask
+#endif
+BOOL SbiDisas::DisasLine( String& rText )
+{
+ char cBuf[ 30 ];
+#ifndef HP9000
+ const char* pMask[] = {
+ "%04X ",
+ "%04X %02X ",
+ "%04X %02X %04X ",
+ "%04X %02X %04X %04X " };
+#endif
+ rText.Erase();
+ if( !Fetch() )
+ return FALSE;
+ // Neue Zeile?
+ if( eOp == _STMNT && (short) nOp1 != nLine )
+ {
+ // Zeile raussuchen
+ USHORT n = 0, l = nLine = nOp1;
+ while( --l ) {
+ n = rImg.aSource.SearchAscii( "\n", n );
+ if( n == STRING_NOTFOUND ) break;
+ else n++;
+ }
+ // Stelle anzeigen
+ if( n != STRING_NOTFOUND )
+ {
+ USHORT n2 = rImg.aSource.SearchAscii( "\n", n );
+ if( n2 == STRING_NOTFOUND ) n2 = rImg.aSource.Len() - n;
+ String s( rImg.aSource.Copy( n, n2 - n + 1 ) );
+ BOOL bDone;
+ do {
+ bDone = TRUE;
+ n = s.Search( '\r' );
+ if( n != STRING_NOTFOUND ) bDone = FALSE, s.Erase( n, 1 );
+ n = s.Search( '\n' );
+ if( n != STRING_NOTFOUND ) bDone = FALSE, s.Erase( n, 1 );
+ } while( !bDone );
+// sprintf( cBuf, pMask[ 0 ], nPC );
+// rText += cBuf;
+ rText.AppendAscii( "; " );
+ rText += s;
+ rText.AppendAscii( _crlf() );
+ }
+ }
+ // Label?
+ const char* p = "";
+ if( cLabels[ nPC >> 3 ] & ( 1 << ( nPC & 7 ) ) )
+ {
+ // Public?
+ ByteString aByteMethName;
+ for( USHORT i = 0; i < pMod->GetMethods()->Count(); i++ )
+ {
+ SbMethod* pMeth = PTR_CAST(SbMethod,pMod->GetMethods()->Get( i ));
+ if( pMeth )
+ {
+ aByteMethName = ByteString( pMeth->GetName(), gsl_getSystemTextEncoding() );
+ if( pMeth->GetId() == nPC )
+ {
+ p = aByteMethName.GetBuffer();
+ break;
+ }
+ if( pMeth->GetId() >= nPC )
+ break;
+ }
+ }
+ sprintf( cBuf, pMask[ 0 ], nPC );
+ rText.AppendAscii( cBuf );
+ if( p && *p )
+ {
+ rText.AppendAscii( p );
+ }
+ else
+ {
+ sprintf( cBuf, "Lbl%04X", nPC );
+ rText.AppendAscii( cBuf );
+ }
+ rText += ':';
+ rText.AppendAscii( _crlf() );
+ }
+ sprintf( cBuf, pMask[ nParts ], nPC, (USHORT) eOp, nOp1, nOp2 );
+ rText.AppendAscii( cBuf );
+ short n = eOp;
+ if( eOp >= SbOP2_START )
+ n -= SbOP2_START;
+ else if( eOp >= SbOP1_START )
+ n -= SbOP1_START;
+ rText += '\t';
+ rText.AppendAscii( pOps[ nParts-1 ][ n ] );
+ rText += '\t';
+ switch( nParts )
+ {
+ case 2: (this->*( pOperand2[ n ] ) )( rText ); break;
+ case 3: (this->*( pOperand3[ n ] ) )( rText ); break;
+ }
+ return TRUE;
+}
+#ifdef HP9000
+#undef pMask
+#endif
+
+
+// Auslesen aus StringPool
+
+void SbiDisas::StrOp( String& rText )
+{
+ String aStr = rImg.GetString( nOp1 );
+ const char* p = ByteString( aStr, gsl_getSystemTextEncoding() ).GetBuffer();
+ if( p )
+ {
+ rText += '"';
+ rText.AppendAscii( p );
+ rText += '"';
+ }
+ else
+ {
+ rText.AppendAscii( "?String? " );
+ rText += nOp1;
+ }
+}
+
+void SbiDisas::Str2Op( String& rText )
+{
+ StrOp( rText );
+ rText += ',';
+ String s;
+ nOp1 = nOp2;
+ StrOp( s );
+ rText += s;
+}
+
+// Immediate Operand
+
+void SbiDisas::ImmOp( String& rText )
+{
+ rText += nOp1;
+}
+
+// OnGoto Operand
+
+void SbiDisas::OnOp( String& rText )
+{
+ rText += nOp1 & 0x7FFF;
+ if( nOp1 & 0x800 )
+ rText.AppendAscii( "\t; Gosub" );
+}
+
+// Label
+
+void SbiDisas::LblOp( String& rText )
+{
+ char cBuf[ 10 ];
+ sprintf( cBuf, "Lbl%04X", nOp1 );
+ rText.AppendAscii( cBuf );
+}
+
+// 0 oder Label
+
+void SbiDisas::ReturnOp( String& rText )
+{
+ if( nOp1 )
+ LblOp( rText );
+}
+
+// 0, 1 oder Label
+
+void SbiDisas::ResumeOp( String& rText )
+{
+ switch( nOp1 )
+ {
+ case 1: rText.AppendAscii( "NEXT" ); break;
+ case 2: LblOp( rText );
+ }
+}
+
+// Prompt ausgeben
+// FALSE/TRUE
+
+void SbiDisas::PromptOp( String& rText )
+{
+ if( nOp1 )
+ rText.AppendAscii( "\"? \"" );
+}
+
+// 0 oder 1
+
+void SbiDisas::CloseOp( String& rText )
+{
+ rText.AppendAscii( nOp1 ? "Channel" : "All" );
+}
+
+// Zeichen ausgeben
+
+void SbiDisas::CharOp( String& rText )
+{
+ const char* p = NULL;
+ switch( nOp1 )
+ {
+ case 7: p = "'\\a'"; break;
+ case 9: p = "'\\t'"; break;
+ case 10: p = "'\\n'"; break;
+ case 12: p = "'\\f'"; break;
+ case 13: p = "'\\r'"; break;
+ }
+ if( p ) rText.AppendAscii( p );
+ else if( nOp1 >= ' ' )
+ rText += '\'',
+ rText += (char) nOp1,
+ rText += '\'';
+ else
+ rText.AppendAscii( "char " ),
+ rText += nOp1;
+}
+
+// Variable ausgeben: String-ID und Typ
+
+void SbiDisas::VarOp( String& rText )
+{
+ rText += rImg.GetString( nOp1 & 0x7FFF );
+ rText.AppendAscii( "\t; " );
+ // Der Typ
+ USHORT n = nOp1;
+ nOp1 = nOp2;
+ TypeOp( rText );
+ if( n & 0x8000 )
+ rText.AppendAscii( ", Args" );
+}
+
+// Variable definieren: String-ID und Typ
+
+void SbiDisas::VarDefOp( String& rText )
+{
+ rText += rImg.GetString( nOp1 );
+ rText.AppendAscii( "\t; " );
+ // Der Typ
+ USHORT n = nOp1;
+ nOp1 = nOp2;
+ TypeOp( rText );
+}
+
+// Variable ausgeben: Offset und Typ
+
+void SbiDisas::OffOp( String& rText )
+{
+ rText += ( nOp1 & 0x7FFF );
+ rText.AppendAscii( "\t; " );
+ // Der Typ
+ USHORT n = nOp1;
+ nOp1 = nOp2;
+ TypeOp( rText );
+ if( n & 0x8000 )
+ rText.AppendAscii( ", Args" );
+}
+
+// Datentyp
+#ifdef HP9000
+static char* SbiDisas_TypeOp_pTypes[13] = {
+ "Empty","Null","Integer","Long","Single","Double",
+ "Currency","Date","String","Object","Error","Boolean",
+ "Variant" };
+#define pTypes SbiDisas_TypeOp_pTypes
+#endif
+void SbiDisas::TypeOp( String& rText )
+{
+ // AB 19.1.96: Typ kann Flag fr BYVAL enthalten (StepARGTYP)
+ if( nOp1 & 0x8000 )
+ {
+ nOp1 &= 0x7FFF; // Flag wegfiltern
+ rText.AppendAscii( "BYVAL " );
+ }
+ if( nOp1 < 13 )
+ {
+#ifndef HP9000
+ static char* pTypes[13] = {
+ "Empty","Null","Integer","Long","Single","Double",
+ "Currency","Date","String","Object","Error","Boolean",
+ "Variant" };
+#endif
+ rText.AppendAscii( pTypes[ nOp1 ] );
+ }
+ else
+ {
+ rText.AppendAscii( "type " );
+ rText += nOp1;
+ }
+}
+#ifdef HP9000
+#undef pTypes
+#endif
+
+// TRUE-Label, Bedingungs-Opcode
+
+void SbiDisas::CaseOp( String& rText )
+{
+ LblOp( rText );
+ rText += ',';
+ rText.AppendAscii( pOp1[ nOp2 - SbxEQ + _EQ ] );
+}
+
+// Zeile, Spalte
+
+void SbiDisas::StmntOp( String& rText )
+{
+ rText += nOp1;
+ rText += ',';
+ USHORT nCol = nOp2 & 0xFF;
+ USHORT nFor = nOp2 / 0x100;
+ rText += nCol;
+ rText.AppendAscii( " (For-Level: " );
+ rText += nFor;
+ rText += ')';
+}
+
+// open mode, flags
+
+void SbiDisas::StrmOp( String& rText )
+{
+ char cBuf[ 10 ];
+ sprintf( cBuf, "%04X", nOp1 );
+ rText.AppendAscii( cBuf );
+ if( nOp2 & SBSTRM_INPUT )
+ rText.AppendAscii( ", Input" );
+ if( nOp2 & SBSTRM_OUTPUT )
+ rText.AppendAscii( ", Output" );
+ if( nOp2 & SBSTRM_APPEND )
+ rText.AppendAscii( ", Append" );
+ if( nOp2 & SBSTRM_RANDOM )
+ rText.AppendAscii( ", Random" );
+ if( nOp2 & SBSTRM_BINARY )
+ rText.AppendAscii( ", Binary" );
+}
+
+
diff --git a/basic/source/classes/image.cxx b/basic/source/classes/image.cxx
new file mode 100644
index 000000000000..b857afd4fe09
--- /dev/null
+++ b/basic/source/classes/image.cxx
@@ -0,0 +1,431 @@
+/*************************************************************************
+ *
+ * $RCSfile: image.cxx,v $
+ *
+ * $Revision: 1.1.1.1 $
+ *
+ * last change: $Author: hr $ $Date: 2000-09-18 16:12:09 $
+ *
+ * The Contents of this file are made available subject to the terms of
+ * either of the following licenses
+ *
+ * - GNU Lesser General Public License Version 2.1
+ * - Sun Industry Standards Source License Version 1.1
+ *
+ * Sun Microsystems Inc., October, 2000
+ *
+ * GNU Lesser General Public License Version 2.1
+ * =============================================
+ * Copyright 2000 by Sun Microsystems, Inc.
+ * 901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ *
+ * Sun Industry Standards Source License Version 1.1
+ * =================================================
+ * The contents of this file are subject to the Sun Industry Standards
+ * Source License Version 1.1 (the "License"); You may not use this file
+ * except in compliance with the License. You may obtain a copy of the
+ * License at http://www.openoffice.org/license.html.
+ *
+ * Software provided under this License is provided on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ * See the License for the specific provisions governing your rights and
+ * obligations concerning the Software.
+ *
+ * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ * Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ * All Rights Reserved.
+ *
+ * Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#ifndef _STREAM_HXX //autogen
+#include <tools/stream.hxx>
+#endif
+#pragma hdrstop
+#include <svtools/sbx.hxx>
+#include "sb.hxx"
+#include <string.h> // memset() etc
+#include "image.hxx"
+#include "filefmt.hxx"
+
+#include "segmentc.hxx"
+#pragma SW_SEGMENT_CLASS( SBASIC, SBASIC_CODE )
+
+SbiImage::SbiImage()
+{
+ rTypes = new SbxArray;
+ pStringOff = NULL;
+ pStrings = NULL;
+ pCode = NULL;
+ nFlags =
+ nStrings =
+ nStringSize=
+ nCodeSize =
+ nDimBase = 0;
+ bInit =
+ bError = FALSE;
+ eCharSet = gsl_getSystemTextEncoding();
+}
+
+SbiImage::~SbiImage()
+{
+ Clear();
+}
+
+void SbiImage::Clear()
+{
+ delete pStringOff;
+ delete pStrings;
+ delete pCode;
+ pStringOff = NULL;
+ pStrings = NULL;
+ pCode = NULL;
+ nFlags =
+ nStrings =
+ nStringSize=
+ nCodeSize = 0;
+ eCharSet = gsl_getSystemTextEncoding();
+ nDimBase = 0;
+ bError = FALSE;
+}
+
+/**************************************************************************
+*
+* Service-Routinen fuer das Laden und Speichern
+*
+**************************************************************************/
+
+BOOL SbiGood( SvStream& r )
+{
+ return BOOL( !r.IsEof() && r.GetError() == SVSTREAM_OK );
+}
+
+// Oeffnen eines Records
+
+ULONG SbiOpenRecord( SvStream& r, UINT16 nSignature, UINT16 nElem )
+{
+ ULONG nPos = r.Tell();
+ r << nSignature << (INT32) 0 << nElem;
+ return nPos;
+}
+
+// Schliessen eines Records
+
+void SbiCloseRecord( SvStream& r, ULONG nOff )
+{
+ ULONG nPos = r.Tell();
+ r.Seek( nOff + 2 );
+ r << (INT32) ( nPos - nOff - 8 );
+ r.Seek( nPos );
+}
+
+/**************************************************************************
+*
+* Laden und Speichern
+*
+**************************************************************************/
+
+// Falls die Versionsnummer nicht passt, werden die binaeren Teile
+// nicht geladen, wohl aber Source, Kommentar und Name.
+
+BOOL SbiImage::Load( SvStream& r )
+{
+ UINT16 nSign, nCount;
+ UINT32 nLen, nOff;
+
+ Clear();
+ ULONG nStart = r.Tell();
+ // Master-Record einlesen
+ r >> nSign >> nLen >> nCount;
+ ULONG nLast = r.Tell() + nLen;
+ UINT32 nVersion = 0; // Versionsnummer
+ UINT32 nCharSet; // System-Zeichensatz
+ UINT32 lDimBase;
+ UINT16 nReserved1;
+ UINT32 nReserved2;
+ UINT32 nReserved3;
+ BOOL bBadVer = FALSE;
+ if( nSign == B_MODULE )
+ {
+ r >> nVersion >> nCharSet >> lDimBase
+ >> nFlags >> nReserved1 >> nReserved2 >> nReserved3;
+ eCharSet = (CharSet) nCharSet;
+ bBadVer = BOOL( nVersion != B_CURVERSION );
+ nDimBase = (USHORT) lDimBase;
+ }
+
+ ULONG nNext;
+ while( ( nNext = r.Tell() ) < nLast )
+ {
+ short i;
+
+ r >> nSign >> nLen >> nCount;
+ nNext += nLen + 8;
+ if( r.GetError() == SVSTREAM_OK )
+ switch( nSign )
+ {
+ case B_NAME:
+ r.ReadByteString( aName, eCharSet );
+ //r >> aName;
+ break;
+ case B_COMMENT:
+ r.ReadByteString( aComment, eCharSet );
+ //r >> aComment;
+ break;
+ case B_SOURCE:
+ r.ReadByteString( aSource, eCharSet );
+ //r >> aSource;
+ break;
+ case B_PCODE:
+ if( bBadVer ) break;
+ pCode = new char[ nLen ];
+ nCodeSize = (USHORT) nLen;
+ r.Read( pCode, nCodeSize );
+ break;
+ case B_PUBLICS:
+ case B_POOLDIR:
+ case B_SYMPOOL:
+ case B_LINERANGES:
+ break;
+ case B_STRINGPOOL:
+ if( bBadVer ) break;
+ MakeStrings( nCount );
+ for( i = 0; i < nStrings && SbiGood( r ); i++ )
+ {
+ r >> nOff;
+ pStringOff[ i ] = (USHORT) nOff;
+ }
+ r >> nLen;
+ if( SbiGood( r ) )
+ {
+ delete pStrings;
+ pStrings = new sal_Unicode[ nLen ];
+ nStringSize = (USHORT) nLen;
+
+ char* pByteStrings = new char[ nLen ];
+ r.Read( pByteStrings, nStringSize );
+ for( short i = 0; i < nStrings; i++ )
+ {
+ USHORT nOff = pStringOff[ i ];
+ String aStr( pByteStrings + nOff, eCharSet );
+ memcpy( pStrings + nOff, aStr.GetBuffer(), (aStr.Len() + 1) * sizeof( sal_Unicode ) );
+ }
+ delete pByteStrings;
+ } break;
+ case B_MODEND:
+ goto done;
+ default:
+ break;
+ }
+ else
+ break;
+ r.Seek( nNext );
+ }
+done:
+ r.Seek( nLast );
+ //if( eCharSet != ::GetSystemCharSet() )
+ //ConvertStrings();
+ if( !SbiGood( r ) )
+ bError = TRUE;
+ return BOOL( !bError );
+}
+
+BOOL SbiImage::Save( SvStream& r )
+{
+ // Erst mal der Header:
+ ULONG nStart = SbiOpenRecord( r, B_MODULE, 1 );
+ ULONG nPos;
+ r << (INT32) B_CURVERSION
+ << (INT32) eCharSet
+ << (INT32) nDimBase
+ << (INT16) nFlags
+ << (INT16) 0
+ << (INT32) 0
+ << (INT32) 0;
+
+ // Name?
+ if( aName.Len() && SbiGood( r ) )
+ {
+ nPos = SbiOpenRecord( r, B_NAME, 1 );
+ r.WriteByteString( aName, eCharSet );
+ //r << aName;
+ SbiCloseRecord( r, nPos );
+ }
+ // Kommentar?
+ if( aComment.Len() && SbiGood( r ) )
+ {
+ nPos = SbiOpenRecord( r, B_COMMENT, 1 );
+ r.WriteByteString( aComment, eCharSet );
+ //r << aComment;
+ SbiCloseRecord( r, nPos );
+ }
+ // Source?
+ if( aSource.Len() && SbiGood( r ) )
+ {
+ nPos = SbiOpenRecord( r, B_SOURCE, 1 );
+ r.WriteByteString( aSource, eCharSet );
+ //r << aSource;
+ SbiCloseRecord( r, nPos );
+ }
+ // Binaere Daten?
+ if( pCode && SbiGood( r ) )
+ {
+ nPos = SbiOpenRecord( r, B_PCODE, 1 );
+ r.Write( pCode, nCodeSize );
+ SbiCloseRecord( r, nPos );
+ }
+ // String-Pool?
+ if( nStrings )
+ {
+ nPos = SbiOpenRecord( r, B_STRINGPOOL, nStrings );
+ // Fuer jeden String:
+ // UINT32 Offset des Strings im Stringblock
+ for( short i = 0; i < nStrings && SbiGood( r ); i++ )
+ r << (UINT32) pStringOff[ i ];
+
+ // Danach der String-Block
+ char* pByteStrings = new char[ nStringSize ];
+ for( i = 0; i < nStrings; i++ )
+ {
+ USHORT nOff = pStringOff[ i ];
+ ByteString aStr( pStrings + nOff, eCharSet );
+ memcpy( pByteStrings + nOff, aStr.GetBuffer(), (aStr.Len() + 1) * sizeof( char ) );
+ }
+ r << (UINT32) nStringSize;
+ r.Write( pByteStrings, nStringSize );
+ delete pByteStrings;
+ SbiCloseRecord( r, nPos );
+ }
+ // Und die Gesamtlaenge setzen
+ SbiCloseRecord( r, nStart );
+ if( !SbiGood( r ) )
+ bError = TRUE;
+ return BOOL( !bError );
+}
+
+/**************************************************************************
+*
+* Routinen, die auch vom Compiler gerufen werden
+*
+**************************************************************************/
+
+void SbiImage::MakeStrings( short nSize )
+{
+ nStrings = nStringIdx = nStringOff = 0;
+ nStringSize = 1024;
+ pStrings = new sal_Unicode[ nStringSize ];
+ pStringOff = new UINT16[ nSize ];
+ if( pStrings && pStringOff )
+ {
+ nStrings = nSize;
+ memset( pStringOff, 0, nSize * sizeof( UINT16 ) );
+ memset( pStrings, 0, nStringSize * sizeof( sal_Unicode ) );
+ }
+ else
+ bError = TRUE;
+}
+
+// Hinzufuegen eines Strings an den StringPool. Der String-Puffer
+// waechst dynamisch in 1K-Schritten
+
+// AB 12.5.2000 Aus Zeitgruenden vorerst weiter auf char-Basis
+// TODO: Auch hier auf Unicode umstellen, d.h. sal_Unicode-Array
+void SbiImage::AddString( const String& r )
+{
+ if( nStringIdx >= nStrings )
+ bError = TRUE;
+ if( !bError )
+ {
+ UINT16 len = r.Len() + 1;
+ long needed = (long) nStringOff + len;
+ if( needed > 0xFF00L )
+ bError = TRUE; // out of mem!
+ else if( (USHORT) needed > nStringSize )
+ {
+ sal_Unicode* p = new sal_Unicode[ nStringSize + 1024 ];
+ if( p )
+ {
+ memcpy( p, pStrings, nStringSize * sizeof( sal_Unicode ) );
+ delete pStrings;
+ pStrings = p;
+ nStringSize += 1024;
+ }
+ else
+ bError = TRUE;
+ }
+ if( !bError )
+ {
+ pStringOff[ nStringIdx++ ] = nStringOff;
+ //ByteString aByteStr( r, eCharSet );
+ memcpy( pStrings + nStringOff, r.GetBuffer(), len * sizeof( sal_Unicode ) );
+ nStringOff += len;
+ // war das der letzte String? Dann die Groesse
+ // des Puffers aktualisieren
+ if( nStringIdx >= nStrings )
+ nStringSize = nStringOff;
+ }
+ }
+}
+
+// Codeblock hinzufuegen
+// Der Block wurde vom Compiler aus der Klasse SbBuffer herausgeholt
+// und ist bereits per new angelegt. Ausserdem enthaelt er alle Integers
+// im Big Endian-Format, kann also direkt gelesen/geschrieben werden.
+
+void SbiImage::AddCode( char* p, USHORT s )
+{
+ pCode = p;
+ nCodeSize = s;
+}
+
+void SbiImage::AddType(SbxObject* pObject) // User-Type mit aufnehmen
+{
+ SbxObject *pCopyObject = new SbxObject(*pObject);
+ rTypes->Insert (pCopyObject,rTypes->Count());
+}
+
+/**************************************************************************
+*
+* Zugriffe auf das Image
+*
+**************************************************************************/
+
+// IDs zaehlen ab 1!!
+
+String SbiImage::GetString( short nId ) const
+{
+ if( nId && nId <= nStrings )
+ {
+ USHORT nOff = pStringOff[ --nId ];
+ String aStr( pStrings + nOff );
+ return aStr;
+ }
+ return String();
+}
+
+const SbxObject* SbiImage::FindType (String aTypeName) const
+{
+ return (SbxObject *)rTypes->Find(aTypeName,SbxCLASS_OBJECT);
+}
+
diff --git a/basic/source/classes/makefile.mk b/basic/source/classes/makefile.mk
new file mode 100644
index 000000000000..da2218d70b77
--- /dev/null
+++ b/basic/source/classes/makefile.mk
@@ -0,0 +1,93 @@
+#*************************************************************************
+#
+# $RCSfile: makefile.mk,v $
+#
+# $Revision: 1.1.1.1 $
+#
+# last change: $Author: hr $ $Date: 2000-09-18 16:12:09 $
+#
+# The Contents of this file are made available subject to the terms of
+# either of the following licenses
+#
+# - GNU Lesser General Public License Version 2.1
+# - Sun Industry Standards Source License Version 1.1
+#
+# Sun Microsystems Inc., October, 2000
+#
+# GNU Lesser General Public License Version 2.1
+# =============================================
+# Copyright 2000 by Sun Microsystems, Inc.
+# 901 San Antonio Road, Palo Alto, CA 94303, USA
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1, as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+# MA 02111-1307 USA
+#
+#
+# Sun Industry Standards Source License Version 1.1
+# =================================================
+# The contents of this file are subject to the Sun Industry Standards
+# Source License Version 1.1 (the "License"); You may not use this file
+# except in compliance with the License. You may obtain a copy of the
+# License at http://www.openoffice.org/license.html.
+#
+# Software provided under this License is provided on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+# See the License for the specific provisions governing your rights and
+# obligations concerning the Software.
+#
+# The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+#
+# Copyright: 2000 by Sun Microsystems, Inc.
+#
+# All Rights Reserved.
+#
+# Contributor(s): _______________________________________
+#
+#
+#
+#*************************************************************************
+
+PRJ=..$/..
+
+PRJNAME=BASIC
+TARGET=classes
+
+# --- Settings -----------------------------------------------------------
+
+ENABLE_EXCEPTIONS=TRUE
+
+.INCLUDE : svpre.mk
+.INCLUDE : settings.mk
+.INCLUDE : sv.mk
+
+
+
+# --- Allgemein -----------------------------------------------------------
+
+SLOFILES= \
+ $(SLO)$/sb.obj \
+ $(SLO)$/sbxmod.obj \
+ $(SLO)$/image.obj \
+ $(SLO)$/sbintern.obj \
+ $(SLO)$/sbunoobj.obj \
+ $(SLO)$/propacc.obj \
+ $(SLO)$/disas.obj
+
+SRCFILES= sb.src
+
+# --- Targets -------------------------------------------------------------
+
+.INCLUDE : target.mk
diff --git a/basic/source/classes/propacc.cxx b/basic/source/classes/propacc.cxx
new file mode 100644
index 000000000000..d28282379bd6
--- /dev/null
+++ b/basic/source/classes/propacc.cxx
@@ -0,0 +1,435 @@
+/*************************************************************************
+ *
+ * $RCSfile: propacc.cxx,v $
+ *
+ * $Revision: 1.1.1.1 $
+ *
+ * last change: $Author: hr $ $Date: 2000-09-18 16:12:09 $
+ *
+ * The Contents of this file are made available subject to the terms of
+ * either of the following licenses
+ *
+ * - GNU Lesser General Public License Version 2.1
+ * - Sun Industry Standards Source License Version 1.1
+ *
+ * Sun Microsystems Inc., October, 2000
+ *
+ * GNU Lesser General Public License Version 2.1
+ * =============================================
+ * Copyright 2000 by Sun Microsystems, Inc.
+ * 901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ *
+ * Sun Industry Standards Source License Version 1.1
+ * =================================================
+ * The contents of this file are subject to the Sun Industry Standards
+ * Source License Version 1.1 (the "License"); You may not use this file
+ * except in compliance with the License. You may obtain a copy of the
+ * License at http://www.openoffice.org/license.html.
+ *
+ * Software provided under this License is provided on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ * See the License for the specific provisions governing your rights and
+ * obligations concerning the Software.
+ *
+ * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ * Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ * All Rights Reserved.
+ *
+ * Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#include "propacc.hxx"
+
+#include <tools/urlobj.hxx>
+#include <tools/errcode.hxx>
+#include <svtools/svarray.hxx>
+#include <svtools/sbx.hxx>
+#include <sbstar.hxx>
+#include <sbunoobj.hxx>
+
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::beans;
+using namespace cppu;
+using namespace rtl;
+
+
+//========================================================================
+
+// Deklaration Konvertierung von Sbx nach Uno mit bekannter Zielklasse
+Any sbxToUnoValue( SbxVariable* pVar, const Reference< XIdlClass >& xIdlTargetClass );
+Reference<XIdlClass> TypeToIdlClass( const Type& rType );
+
+//========================================================================
+
+#ifdef WNT
+#define CDECL _cdecl
+#endif
+#ifdef OS2
+#define CDECL _Optlink
+#endif
+#if defined(UNX) || defined(MAC)
+#define CDECL
+#endif
+
+int CDECL SbCompare_PropertyValues_Impl( const void *arg1, const void *arg2 )
+{
+ return ((PropertyValue*)arg1)->Name.compareTo( ((PropertyValue*)arg2)->Name );
+}
+
+int CDECL SbCompare_UString_PropertyValue_Impl( const void *arg1, const void *arg2 )
+{
+ const OUString *pArg1 = (OUString*) arg1;
+ const PropertyValue **pArg2 = (const PropertyValue**) arg2;
+ return pArg1->compareTo( (*pArg2)->Name );
+}
+
+int CDECL SbCompare_Properties_Impl( const void *arg1, const void *arg2 )
+{
+ return ((Property*)arg1)->Name.compareTo( ((Property*)arg2)->Name );
+}
+
+int CDECL SbCompare_UString_Property_Impl( const void *arg1, const void *arg2 )
+{
+ const OUString *pArg1 = (OUString*) arg1;
+ const Property *pArg2 = (Property*) arg2;
+ return pArg1->compareTo( pArg2->Name );
+}
+
+//----------------------------------------------------------------------------
+
+SbPropertyValues::SbPropertyValues()
+{
+}
+
+//----------------------------------------------------------------------------
+
+SbPropertyValues::~SbPropertyValues()
+{
+ _xInfo = Reference< XPropertySetInfo >();
+
+ for ( USHORT n = 0; n < _aPropVals.Count(); ++n )
+ delete _aPropVals.GetObject( n );
+}
+
+//----------------------------------------------------------------------------
+
+Reference< XPropertySetInfo > SbPropertyValues::getPropertySetInfo(void) throw( RuntimeException )
+{
+ // create on demand?
+ if ( !_xInfo.is() )
+ {
+ SbPropertySetInfo *pInfo = new SbPropertySetInfo( _aPropVals );
+ ((SbPropertyValues*)this)->_xInfo = (XPropertySetInfo*)pInfo;
+ }
+ return _xInfo;
+}
+
+//-------------------------------------------------------------------------
+
+INT32 SbPropertyValues::GetIndex_Impl( const OUString &rPropName ) const
+{
+ PropertyValue **ppPV;
+ ppPV = (PropertyValue **)
+ bsearch( &rPropName, _aPropVals.GetData(), _aPropVals.Count(),
+ sizeof( PropertyValue* ),
+ SbCompare_UString_PropertyValue_Impl );
+ return ppPV ? ( (ppPV-_aPropVals.GetData()) / sizeof(ppPV) ) : USHRT_MAX;
+}
+
+//----------------------------------------------------------------------------
+
+void SbPropertyValues::setPropertyValue(
+ const OUString& aPropertyName,
+ const Any& aValue)
+{
+ USHORT nIndex = GetIndex_Impl( aPropertyName );
+ PropertyValue *pPropVal = _aPropVals.GetObject(nIndex);
+ pPropVal->Value = aValue;
+}
+
+//----------------------------------------------------------------------------
+
+Any SbPropertyValues::getPropertyValue(
+ const OUString& aPropertyName) throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
+{
+ USHORT nIndex = GetIndex_Impl( aPropertyName );
+ if ( nIndex != USHRT_MAX )
+ return _aPropVals.GetObject(nIndex)->Value;
+ return Any();
+}
+
+//----------------------------------------------------------------------------
+
+void SbPropertyValues::addPropertyChangeListener(
+ const OUString& aPropertyName,
+ const Reference< XPropertyChangeListener >& )
+{
+}
+
+//----------------------------------------------------------------------------
+
+void SbPropertyValues::removePropertyChangeListener(
+ const OUString& aPropertyName,
+ const Reference< XPropertyChangeListener >& )
+{
+}
+
+//----------------------------------------------------------------------------
+
+void SbPropertyValues::addVetoableChangeListener(
+ const OUString& aPropertyName,
+ const Reference< XVetoableChangeListener >& )
+{
+}
+
+//----------------------------------------------------------------------------
+
+void SbPropertyValues::removeVetoableChangeListener(
+ const OUString& aPropertyName,
+ const Reference< XVetoableChangeListener >& )
+{
+}
+
+//----------------------------------------------------------------------------
+
+Sequence< PropertyValue > SbPropertyValues::getPropertyValues(void)
+{
+ Sequence<PropertyValue> aRet( _aPropVals.Count());
+ for ( USHORT n = 0; n < _aPropVals.Count(); ++n )
+ aRet.getArray()[n] = *_aPropVals.GetObject(n);
+ return aRet;
+}
+
+//----------------------------------------------------------------------------
+
+void SbPropertyValues::setPropertyValues(const Sequence< PropertyValue >& rPropertyValues )
+{
+ if ( _aPropVals.Count() )
+ throw PropertyExistException();
+
+ const PropertyValue *pPropVals = rPropertyValues.getConstArray();
+ for ( sal_Int16 n = 0; n < rPropertyValues.getLength(); ++n )
+ {
+ PropertyValue *pPropVal = new PropertyValue(pPropVals[n]);
+ _aPropVals.Insert( pPropVal, n );
+ }
+}
+
+//============================================================================
+//PropertySetInfoImpl
+
+PropertySetInfoImpl::PropertySetInfoImpl()
+{
+}
+
+INT32 PropertySetInfoImpl::GetIndex_Impl( const OUString &rPropName ) const
+{
+ Property *pP;
+ pP = (Property*)
+ bsearch( &rPropName, _aProps.getConstArray(), _aProps.getLength(),
+ sizeof( Property ),
+ SbCompare_UString_Property_Impl );
+ return pP ? ( (pP-_aProps.getConstArray()) / sizeof(pP) ) : -1;
+}
+
+Sequence< Property > PropertySetInfoImpl::getProperties(void)
+{
+ return _aProps;
+}
+
+Property PropertySetInfoImpl::getPropertyByName(const OUString& Name) throw( RuntimeException )
+{
+ USHORT nIndex = GetIndex_Impl( Name );
+ if( USHRT_MAX != nIndex )
+ return _aProps.getConstArray()[ nIndex ];
+ return Property();
+}
+
+sal_Bool PropertySetInfoImpl::hasPropertyByName(const OUString& Name) throw( RuntimeException )
+{
+ USHORT nIndex = GetIndex_Impl( Name );
+ return USHRT_MAX != nIndex;
+}
+
+
+//============================================================================
+
+SbPropertySetInfo::SbPropertySetInfo()
+{
+}
+
+//----------------------------------------------------------------------------
+
+SbPropertySetInfo::SbPropertySetInfo( const SbPropertyValueArr_Impl &rPropVals )
+{
+ aImpl._aProps.realloc( rPropVals.Count() );
+ for ( USHORT n = 0; n < rPropVals.Count(); ++n )
+ {
+ Property &rProp = aImpl._aProps.getArray()[n];
+ const PropertyValue &rPropVal = *rPropVals.GetObject(n);
+ rProp.Name = rPropVal.Name;
+ rProp.Handle = rPropVal.Handle;
+ rProp.Type = getCppuVoidType();
+ rProp.Attributes = 0;
+ }
+}
+
+//----------------------------------------------------------------------------
+
+SbPropertySetInfo::~SbPropertySetInfo()
+{
+}
+
+//-------------------------------------------------------------------------
+
+Sequence< Property > SbPropertySetInfo::getProperties(void) throw( RuntimeException )
+{
+ return aImpl.getProperties();
+}
+
+Property SbPropertySetInfo::getPropertyByName(const OUString& Name)
+ throw( RuntimeException )
+{
+ return aImpl.getPropertyByName( Name );
+}
+
+BOOL SbPropertySetInfo::hasPropertyByName(const OUString& Name)
+ throw( RuntimeException )
+{
+ return aImpl.hasPropertyByName( Name );
+}
+
+
+//----------------------------------------------------------------------------
+
+SbPropertyContainer::SbPropertyContainer()
+{
+}
+
+//----------------------------------------------------------------------------
+
+SbPropertyContainer::~SbPropertyContainer()
+{
+}
+
+//----------------------------------------------------------------------------
+void SbPropertyContainer::addProperty(const OUString& Name,
+ INT16 Attributes,
+ const Any& DefaultValue)
+ throw( PropertyExistException, IllegalTypeException,
+ IllegalArgumentException, RuntimeException )
+{
+}
+
+//----------------------------------------------------------------------------
+void SbPropertyContainer::removeProperty(const OUString& Name)
+ throw( UnknownPropertyException, RuntimeException )
+{
+}
+
+//----------------------------------------------------------------------------
+// XPropertySetInfo
+Sequence< Property > SbPropertyContainer::getProperties(void)
+{
+ return aImpl.getProperties();
+}
+
+Property SbPropertyContainer::getPropertyByName(const OUString& Name)
+ throw( RuntimeException )
+{
+ return aImpl.getPropertyByName( Name );
+}
+
+BOOL SbPropertyContainer::hasPropertyByName(const OUString& Name)
+ throw( RuntimeException )
+{
+ return aImpl.hasPropertyByName( Name );
+}
+
+//----------------------------------------------------------------------------
+
+Sequence< PropertyValue > SbPropertyContainer::getPropertyValues(void)
+{
+ return Sequence<PropertyValue>();
+}
+
+//----------------------------------------------------------------------------
+
+void SbPropertyContainer::setPropertyValues(const Sequence< PropertyValue >& PropertyValues_)
+{
+}
+
+//----------------------------------------------------------------------------
+
+void RTL_Impl_CreatePropertySet( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite )
+{
+ // Wir brauchen mindestens 1 Parameter
+ if ( rPar.Count() < 2 )
+ {
+ StarBASIC::Error( SbERR_BAD_ARGUMENT );
+ return;
+ }
+
+ // Klassen-Name der struct holen
+ String aServiceName( RTL_CONSTASCII_USTRINGPARAM("stardiv.uno.beans.PropertySet") );
+
+#if 0
+ // Service suchen und instanzieren
+ Reference< XMultiServiceFactory > xServiceManager = getProcessServiceFactory();
+ Reference< XInterface > xInterface;
+ if( xProv.is() )
+ xInterface = xProv->newInstance();
+#else
+ Reference< XInterface > xInterface = (OWeakObject*) new SbPropertyValues();
+#endif
+
+ SbxVariableRef refVar = rPar.Get(0);
+ if( xInterface.is() )
+ {
+ // PropertyValues setzen
+ Any aArgAsAny = sbxToUnoValue( rPar.Get(1),
+ TypeToIdlClass( getCppuType( (Sequence<PropertyValue>*)0 ) ) );
+ Sequence<PropertyValue> *pArg =
+ (Sequence<PropertyValue>*) aArgAsAny.getValue();
+ Reference< XPropertyAccess > xPropAcc = Reference< XPropertyAccess >::query( xInterface );
+ xPropAcc->setPropertyValues( *pArg );
+
+ // SbUnoObject daraus basteln und zurueckliefern
+ Any aAny;
+ aAny <<= xInterface;
+ SbUnoObjectRef xUnoObj = new SbUnoObject( aServiceName, aAny );
+ if( xUnoObj->getUnoAny().getValueType().getTypeClass() != TypeClass_VOID )
+ {
+ // Objekt zurueckliefern
+ refVar->PutObject( (SbUnoObject*)xUnoObj );
+ return;
+ }
+ }
+
+ // Objekt konnte nicht erzeugt werden
+ refVar->PutObject( NULL );
+}
+
+
diff --git a/basic/source/classes/sb.cxx b/basic/source/classes/sb.cxx
new file mode 100644
index 000000000000..6b3cd5c011ba
--- /dev/null
+++ b/basic/source/classes/sb.cxx
@@ -0,0 +1,1028 @@
+/*************************************************************************
+ *
+ * $RCSfile: sb.cxx,v $
+ *
+ * $Revision: 1.1.1.1 $
+ *
+ * last change: $Author: hr $ $Date: 2000-09-18 16:12:10 $
+ *
+ * The Contents of this file are made available subject to the terms of
+ * either of the following licenses
+ *
+ * - GNU Lesser General Public License Version 2.1
+ * - Sun Industry Standards Source License Version 1.1
+ *
+ * Sun Microsystems Inc., October, 2000
+ *
+ * GNU Lesser General Public License Version 2.1
+ * =============================================
+ * Copyright 2000 by Sun Microsystems, Inc.
+ * 901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ *
+ * Sun Industry Standards Source License Version 1.1
+ * =================================================
+ * The contents of this file are subject to the Sun Industry Standards
+ * Source License Version 1.1 (the "License"); You may not use this file
+ * except in compliance with the License. You may obtain a copy of the
+ * License at http://www.openoffice.org/license.html.
+ *
+ * Software provided under this License is provided on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ * See the License for the specific provisions governing your rights and
+ * obligations concerning the Software.
+ *
+ * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ * Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ * All Rights Reserved.
+ *
+ * Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#include <stdio.h> // sprintf()
+
+#pragma hdrstop
+#include "sb.hxx"
+#ifdef VCL
+#include <vcl/rcid.h>
+#include <vcl/config.hxx>
+#endif
+
+#ifndef _STREAM_HXX //autogen
+#include <tools/stream.hxx>
+#endif
+#ifndef __RSC //autogen
+#include <tools/errinf.hxx>
+#endif
+#ifndef _SBXCLASS_HXX //autogen
+#include <svtools/sbx.hxx>
+#endif
+#ifndef _LIST_HXX //autogen
+#include <tools/list.hxx>
+#endif
+#ifndef _SHL_HXX //autogen
+#include <tools/shl.hxx>
+#endif
+#ifndef _TOOLS_RC_HXX //autogen
+#include <tools/rc.hxx>
+#endif
+#ifndef _SV_SVAPP_HXX //autogen
+#include <vcl/svapp.hxx>
+#endif
+#include "sbunoobj.hxx"
+#include "sbjsmeth.hxx"
+#include "sbjsmod.hxx"
+#include "sbintern.hxx"
+#include "disas.hxx"
+#include "runtime.hxx"
+#include "sbuno.hxx"
+#include "stdobj.hxx"
+#include "filefmt.hxx"
+#include "sb.hrc"
+#include <basrid.hxx>
+
+#pragma SW_SEGMENT_CLASS( SBASIC, SBASIC_CODE )
+
+SV_IMPL_VARARR(SbTextPortions,SbTextPortion)
+
+TYPEINIT1(StarBASIC,SbxObject)
+
+#define RTLNAME "@SBRTL"
+
+
+//========================================================================
+// Array zur Umrechnung SFX <-> VB-Fehlercodes anlegen
+
+struct SFX_VB_ErrorItem
+{
+ USHORT nErrorVB;
+ SbError nErrorSFX;
+};
+
+const SFX_VB_ErrorItem __FAR_DATA SFX_VB_ErrorTab[] =
+{
+ { 2, SbERR_SYNTAX },
+ { 3, SbERR_NO_GOSUB },
+ { 4, SbERR_REDO_FROM_START },
+ { 5, SbERR_BAD_ARGUMENT },
+ { 6, SbERR_MATH_OVERFLOW },
+ { 7, SbERR_NO_MEMORY },
+ { 8, SbERR_ALREADY_DIM },
+ { 9, SbERR_OUT_OF_RANGE },
+ { 10, SbERR_DUPLICATE_DEF },
+ { 11, SbERR_ZERODIV },
+ { 12, SbERR_VAR_UNDEFINED },
+ { 13, SbERR_CONVERSION },
+ { 14, SbERR_BAD_PARAMETER },
+ { 18, SbERR_USER_ABORT },
+ { 20, SbERR_BAD_RESUME },
+ { 28, SbERR_STACK_OVERFLOW },
+ { 35, SbERR_PROC_UNDEFINED },
+ { 48, SbERR_BAD_DLL_LOAD },
+ { 49, SbERR_BAD_DLL_CALL },
+ { 51, SbERR_INTERNAL_ERROR },
+ { 52, SbERR_BAD_CHANNEL },
+ { 53, SbERR_FILE_NOT_FOUND },
+ { 54, SbERR_BAD_FILE_MODE },
+ { 55, SbERR_FILE_ALREADY_OPEN },
+ { 57, SbERR_IO_ERROR },
+ { 58, SbERR_FILE_EXISTS },
+ { 59, SbERR_BAD_RECORD_LENGTH },
+ { 61, SbERR_DISK_FULL },
+ { 62, SbERR_READ_PAST_EOF },
+ { 63, SbERR_BAD_RECORD_NUMBER },
+ { 67, SbERR_TOO_MANY_FILES },
+ { 68, SbERR_NO_DEVICE },
+ { 70, SbERR_ACCESS_DENIED },
+ { 71, SbERR_NOT_READY },
+ { 73, SbERR_NOT_IMPLEMENTED },
+ { 74, SbERR_DIFFERENT_DRIVE },
+ { 75, SbERR_ACCESS_ERROR },
+ { 76, SbERR_PATH_NOT_FOUND },
+ { 91, SbERR_NO_OBJECT },
+ { 93, SbERR_BAD_PATTERN },
+ { 94, SBERR_IS_NULL },
+ { 250, SbERR_DDE_ERROR },
+ { 280, SbERR_DDE_WAITINGACK },
+ { 281, SbERR_DDE_OUTOFCHANNELS },
+ { 282, SbERR_DDE_NO_RESPONSE },
+ { 283, SbERR_DDE_MULT_RESPONSES },
+ { 284, SbERR_DDE_CHANNEL_LOCKED },
+ { 285, SbERR_DDE_NOTPROCESSED },
+ { 286, SbERR_DDE_TIMEOUT },
+ { 287, SbERR_DDE_USER_INTERRUPT },
+ { 288, SbERR_DDE_BUSY },
+ { 289, SbERR_DDE_NO_DATA },
+ { 290, SbERR_DDE_WRONG_DATA_FORMAT },
+ { 291, SbERR_DDE_PARTNER_QUIT },
+ { 292, SbERR_DDE_CONV_CLOSED },
+ { 293, SbERR_DDE_NO_CHANNEL },
+ { 294, SbERR_DDE_INVALID_LINK },
+ { 295, SbERR_DDE_QUEUE_OVERFLOW },
+ { 296, SbERR_DDE_LINK_ALREADY_EST },
+ { 297, SbERR_DDE_LINK_INV_TOPIC },
+ { 298, SbERR_DDE_DLL_NOT_FOUND },
+ { 323, SbERR_CANNOT_LOAD },
+ { 341, SbERR_BAD_INDEX },
+ { 366, SbERR_NO_ACTIVE_OBJECT },
+ { 380, SbERR_BAD_PROP_VALUE },
+ { 382, SbERR_PROP_READONLY },
+ { 394, SbERR_PROP_WRITEONLY },
+ { 420, SbERR_INVALID_OBJECT },
+ { 423, SbERR_NO_METHOD },
+ { 424, SbERR_NEEDS_OBJECT },
+ { 425, SbERR_INVALID_USAGE_OBJECT },
+ { 430, SbERR_NO_OLE },
+ { 438, SbERR_BAD_METHOD },
+ { 440, SbERR_OLE_ERROR },
+ { 445, SbERR_BAD_ACTION },
+ { 446, SbERR_NO_NAMED_ARGS },
+ { 447, SbERR_BAD_LOCALE },
+ { 448, SbERR_NAMED_NOT_FOUND },
+ { 449, SbERR_NOT_OPTIONAL },
+ { 450, SbERR_WRONG_ARGS },
+ { 451, SbERR_NOT_A_COLL },
+ { 452, SbERR_BAD_ORDINAL },
+ { 453, SbERR_DLLPROC_NOT_FOUND },
+ { 460, SbERR_BAD_CLIPBD_FORMAT },
+ { 951, SbERR_UNEXPECTED },
+ { 952, SbERR_EXPECTED },
+ { 953, SbERR_SYMBOL_EXPECTED },
+ { 954, SbERR_VAR_EXPECTED },
+ { 955, SbERR_LABEL_EXPECTED },
+ { 956, SbERR_LVALUE_EXPECTED },
+ { 957, SbERR_VAR_DEFINED },
+ { 958, SbERR_PROC_DEFINED },
+ { 959, SbERR_LABEL_DEFINED },
+ { 960, SbERR_UNDEF_VAR },
+ { 961, SbERR_UNDEF_ARRAY },
+ { 962, SbERR_UNDEF_PROC },
+ { 963, SbERR_UNDEF_LABEL },
+ { 964, SbERR_UNDEF_TYPE },
+ { 965, SbERR_BAD_EXIT },
+ { 966, SbERR_BAD_BLOCK },
+ { 967, SbERR_BAD_BRACKETS },
+ { 968, SbERR_BAD_DECLARATION },
+ { 969, SbERR_BAD_PARAMETERS },
+ { 970, SbERR_BAD_CHAR_IN_NUMBER },
+ { 971, SbERR_MUST_HAVE_DIMS },
+ { 972, SbERR_NO_IF },
+ { 973, SbERR_NOT_IN_SUBR },
+ { 974, SbERR_NOT_IN_MAIN },
+ { 975, SbERR_WRONG_DIMS },
+ { 976, SbERR_BAD_OPTION },
+ { 977, SbERR_CONSTANT_REDECLARED },
+ { 978, SbERR_PROG_TOO_LARGE },
+ { 979, SbERR_NO_STRINGS_ARRAYS },
+ { 1000, SbERR_PROPERTY_NOT_FOUND },
+ { 1001, SbERR_METHOD_NOT_FOUND },
+ { 1002, SbERR_ARG_MISSING },
+ { 1003, SbERR_BAD_NUMBER_OF_ARGS },
+ { 1004, SbERR_METHOD_FAILED },
+ { 1005, SbERR_SETPROP_FAILED },
+ { 1006, SbERR_GETPROP_FAILED },
+ { 0xFFFF, 0xFFFFFFFFL } // End-Marke
+};
+
+////////////////////////////////////////////////////////////////////////////
+
+// Die StarBASIC-Factory hat einen Hack. Wenn ein SbModule eingerichtet wird,
+// wird der Pointer gespeichert und an nachfolgende SbProperties/SbMethods
+// uebergeben. Dadurch wird die Modul-Relationship wiederhergestellt. Das
+// klappt aber nur, wenn ein Modul geladen wird. Fuer getrennt geladene
+// Properties kann es Probleme geben!
+
+SbxBase* SbiFactory::Create( UINT16 nSbxId, UINT32 nCreator )
+{
+ if( nCreator == SBXCR_SBX )
+ {
+ String aEmpty;
+ switch( nSbxId )
+ {
+ case SBXID_BASIC:
+ return new StarBASIC( NULL );
+ case SBXID_BASICMOD:
+ return new SbModule( aEmpty );
+ case SBXID_BASICPROP:
+ return new SbProperty( aEmpty, SbxVARIANT, NULL );
+ case SBXID_BASICMETHOD:
+ return new SbMethod( aEmpty, SbxVARIANT, NULL );
+ case SBXID_JSCRIPTMOD:
+ return new SbJScriptModule( aEmpty );
+ case SBXID_JSCRIPTMETH:
+ return new SbJScriptMethod( aEmpty, SbxVARIANT, NULL );
+ }
+ }
+ return NULL;
+}
+
+SbxObject* SbiFactory::CreateObject( const String& rClass )
+{
+ if( rClass.EqualsIgnoreCaseAscii( "StarBASIC" ) )
+ return new StarBASIC( NULL );
+ else
+ if( rClass.EqualsIgnoreCaseAscii( "StarBASICModule" ) )
+ {
+ String aEmpty;
+ return new SbModule( aEmpty );
+ }
+ else
+ return NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+StarBASIC::StarBASIC( StarBASIC* p )
+ : SbxObject( String( RTL_CONSTASCII_USTRINGPARAM("StarBASIC") ) )
+{
+ SetParent( p );
+ pLibInfo = NULL;
+ bNoRtl = bBreak = FALSE;
+ pModules = new SbxArray;
+
+#ifdef DBG_UTIL
+ Config LangConfig( String( RTL_CONSTASCII_USTRINGPARAM("d:\\LANGUAGE.INI") ) );
+ LangConfig.SetGroup( "main" );
+ ByteString aStr = LangConfig.ReadKey( "language","basic" );
+ if( aStr == "vbscript" )
+ SetGlobalLanguageMode( SB_LANG_VBSCRIPT );
+ else
+ if( aStr == "javascript" )
+ SetGlobalLanguageMode( SB_LANG_JAVASCRIPT );
+#endif
+
+ if( !GetSbData()->nInst++ )
+ {
+ pSBFAC = new SbiFactory;
+ AddFactory( pSBFAC );
+ pUNOFAC = new SbUnoFactory;
+ AddFactory( pUNOFAC );
+ }
+ pRtl = new SbiStdObject( String( RTL_CONSTASCII_USTRINGPARAM(RTLNAME) ), this );
+ // Suche ueber StarBASIC ist immer global
+ SetFlag( SBX_GBLSEARCH );
+}
+
+// #51727 SetModified ueberladen, damit der Modified-
+// Zustand nicht an den Parent weitergegeben wird.
+void StarBASIC::SetModified( BOOL b )
+{
+ SbxBase::SetModified( b );
+}
+
+//***
+
+StarBASIC::~StarBASIC()
+{
+ if( !--GetSbData()->nInst )
+ {
+ RemoveFactory( pSBFAC );
+ pSBFAC = NULL;
+ RemoveFactory( pUNOFAC );
+ pUNOFAC = NULL;
+
+#ifdef DBG_UTIL
+ // SbiData braucht am Programm-Ende nicht abgeraeumt werden,
+ // aber wir wollen keine MLK's beim Purify
+ // Wo sollte es sonst geschehen???
+ SbiGlobals** pp = (SbiGlobals**) ::GetAppData( SHL_SBC );
+ SbiGlobals* p = *pp;
+ if( p )
+ {
+ delete p;
+ *pp = 0;
+ }
+#endif
+ }
+}
+
+// operator new() wird hier versenkt, damit jeder eine Instanz
+// anlegen kann, ohne neu zu bilden.
+
+void* StarBASIC::operator new( size_t n )
+{
+ if( n < sizeof( StarBASIC ) )
+ {
+// DBG_ASSERT( FALSE, "Warnung: inkompatibler BASIC-Stand!" );
+ n = sizeof( StarBASIC );
+ }
+ return ::operator new( n );
+}
+
+void StarBASIC::operator delete( void* p )
+{
+ ::operator delete( p );
+}
+
+/**************************************************************************
+*
+* Erzeugen/Verwalten von Modulen
+*
+**************************************************************************/
+
+SbModule* StarBASIC::MakeModule( const String& rName, const String& rSrc )
+{
+ SbModule* p = new SbModule( rName );
+ p->SetSource( rSrc );
+ p->SetParent( this );
+ pModules->Insert( p, pModules->Count() );
+ SetModified( TRUE );
+ return p;
+}
+
+void StarBASIC::Insert( SbxVariable* pVar )
+{
+ if( pVar->IsA( TYPE(SbModule) ) )
+ {
+ pModules->Insert( pVar, pModules->Count() );
+ pVar->SetParent( this );
+ StartListening( pVar->GetBroadcaster(), TRUE );
+ }
+ else
+ {
+ BOOL bWasModified = IsModified();
+ SbxObject::Insert( pVar );
+ if( !bWasModified && pVar->IsSet( SBX_DONTSTORE ) )
+ SetModified( FALSE );
+ }
+}
+
+void StarBASIC::Remove( SbxVariable* pVar )
+{
+ if( pVar->IsA( TYPE(SbModule) ) )
+ {
+ pModules->Remove( pVar );
+ pVar->SetParent( 0 );
+ EndListening( pVar->GetBroadcaster() );
+ }
+ else
+ SbxObject::Remove( pVar );
+}
+
+BOOL StarBASIC::Compile( SbModule* pMod )
+{
+ return pMod ? pMod->Compile() : FALSE;
+}
+
+BOOL StarBASIC::Disassemble( SbModule* pMod, String& rText )
+{
+ rText.Erase();
+ if( pMod )
+ pMod->Disassemble( rText );
+ return BOOL( rText.Len() != 0 );
+}
+
+void StarBASIC::Clear()
+{
+ while( pModules->Count() )
+ pModules->Remove( pModules->Count() - 1 );
+}
+
+SbModule* StarBASIC::FindModule( const String& rName )
+{
+ for( USHORT i = 0; i < pModules->Count(); i++ )
+ {
+ SbModule* p = (SbModule*) pModules->Get( i );
+ if( p->GetName().EqualsIgnoreCaseAscii( rName ) )
+ return p;
+ }
+ return NULL;
+}
+
+// Init-Code aller Module ausfuehren (auch in inserteten Bibliotheken)
+void StarBASIC::InitAllModules( void )
+{
+ // Eigene Module initialisieren
+ for ( USHORT nMod = 0; nMod < pModules->Count(); nMod++ )
+ {
+ SbModule* pModule = (SbModule*)pModules->Get( nMod );
+ if( !pModule->IsCompiled() )
+ pModule->Compile();
+ pModule->RunInit();
+ }
+ // Alle Objekte ueberpruefen, ob es sich um ein Basic handelt
+ // Wenn ja, auch dort initialisieren
+ for ( USHORT nObj = 0; nObj < pObjs->Count(); nObj++ )
+ {
+ SbxVariable* pVar = pObjs->Get( nObj );
+ StarBASIC* pBasic = PTR_CAST(StarBASIC,pVar);
+ if( pBasic )
+ pBasic->InitAllModules();
+ }
+}
+
+// #43011 Fuer das TestTool, um globale Variablen loeschen zu koennen
+void StarBASIC::ClearGlobalVars( void )
+{
+ SbxArrayRef xProps( GetProperties() );
+ USHORT nPropCount = xProps->Count();
+ for ( USHORT nProp = 0 ; nProp < nPropCount ; ++nProp )
+ {
+ SbxBase* pVar = xProps->Get( nProp );
+ pVar->Clear();
+ }
+ SetModified( TRUE );
+}
+
+
+// Diese Implementation sucht erst innerhalb der Runtime-Library, dann
+// nach einem Element innerhalb eines Moduls. Dieses Element kann eine
+// Public-Variable oder ein Entrypoint sein. Wenn nicht gefunden, wird,
+// falls nach einer Methode gesucht wird und ein Modul mit dem angege-
+// benen Namen gefunden wurde, der Entrypoint "Main" gesucht. Wenn das
+// auch nicht klappt, laeuft die traditionelle Suche ueber Objekte an.
+
+SbxVariable* StarBASIC::Find( const String& rName, SbxClassType t )
+{
+ SbxVariable* pRes = NULL;
+ SbModule* pNamed = NULL;
+ // "Extended" search in Runtime Lib
+ // aber nur, wenn SbiRuntime nicht das Flag gesetzt hat
+ if( !bNoRtl )
+ {
+ if( t == SbxCLASS_DONTCARE || t == SbxCLASS_OBJECT )
+ {
+ if( rName.EqualsIgnoreCaseAscii( RTLNAME ) )
+ pRes = pRtl;
+ }
+ if( !pRes )
+ pRes = ((SbiStdObject*) (SbxObject*) pRtl)->Find( rName, t );
+ if( pRes )
+ pRes->SetFlag( SBX_EXTFOUND );
+ }
+ // Module durchsuchen
+ if( !pRes )
+ for( USHORT i = 0; i < pModules->Count(); i++ )
+ {
+ SbModule* p = (SbModule*) pModules->Get( i );
+ if( p->IsVisible() )
+ {
+ // Modul merken fuer Main()-Aufruf
+ // oder stimmt etwa der Name ueberein?!?
+ if( p->GetName().EqualsIgnoreCaseAscii( rName ) )
+ {
+ if( t == SbxCLASS_OBJECT || t == SbxCLASS_DONTCARE )
+ {
+ pRes = p; break;
+ }
+ pNamed = p;
+ }
+ // Sonst testen, ob das Element vorhanden ist
+ // GBLSEARCH-Flag rausnehmen (wg. Rekursion)
+ USHORT nGblFlag = p->GetFlags() & SBX_GBLSEARCH;
+ p->ResetFlag( SBX_GBLSEARCH );
+ pRes = p->Find( rName, t );
+ p->SetFlag( nGblFlag );
+ if( pRes )
+ break;
+ }
+ }
+ if( !pRes && pNamed && ( t == SbxCLASS_METHOD || t == SbxCLASS_DONTCARE ) )
+ pRes = pNamed->Find( String( RTL_CONSTASCII_USTRINGPARAM("Main") ), SbxCLASS_METHOD );
+ if( !pRes )
+ pRes = SbxObject::Find( rName, t );
+ return pRes;
+}
+
+BOOL StarBASIC::Call( const String& rName, SbxArray* pParam )
+{
+ BOOL bRes = SbxObject::Call( rName, pParam );
+ if( !bRes )
+ {
+ SbxError eErr = SbxBase::GetError();
+ SbxBase::ResetError();
+ if( eErr != SbxERR_OK )
+ RTError( (SbError)eErr, 0, 0, 0 );
+ }
+ return bRes;
+}
+
+// Find-Funktion ueber Name (z.B. Abfrage aus BASIC-IDE)
+SbxBase* StarBASIC::FindSBXInCurrentScope( const String& rName )
+{
+ if( !pINST )
+ return NULL;
+ if( !pINST->pRun )
+ return NULL;
+ return pINST->pRun->FindElementExtern( rName );
+}
+
+// Alte Schnittstelle vorerst erhalten
+SbxVariable* StarBASIC::FindVarInCurrentScopy
+( const String& rName, USHORT& rStatus )
+{
+ rStatus = 1; // Annahme: Nichts gefunden
+ SbxVariable* pVar = NULL;
+ SbxBase* pSbx = FindSBXInCurrentScope( rName );
+ if( pSbx )
+ {
+ if( !pSbx->ISA(SbxMethod) && !pSbx->ISA(SbxObject) )
+ pVar = PTR_CAST(SbxVariable,pSbx);
+ }
+ if( pVar )
+ rStatus = 0; // doch gefunden
+ return pVar;
+}
+
+void StarBASIC::Stop()
+{
+ SbiInstance* p = pINST;
+ while( p )
+ {
+ p->Stop();
+ p = p->pNext;
+ }
+}
+
+BOOL StarBASIC::IsRunning()
+{
+ return BOOL( pINST != NULL );
+}
+
+/**************************************************************************
+*
+* Objekt-Factories etc.
+*
+**************************************************************************/
+
+// Aktivierung eines Objekts. Aktive Objekte muessen nicht mehr
+// von BASIC aus ueber den Namen angesprochen werden. Ist
+// NULL angegeben, wird alles aktiviert.
+
+void StarBASIC::ActivateObject( const String* pName, BOOL bActivate )
+{
+ if( pName )
+ {
+ SbxObject* p = (SbxObject*) SbxObject::Find( *pName, SbxCLASS_OBJECT );
+ if( p )
+ if( bActivate )
+ p->SetFlag( SBX_EXTSEARCH );
+ else
+ p->ResetFlag( SBX_EXTSEARCH );
+ }
+ else
+ {
+ for( USHORT i = 0; i < GetObjects()->Count(); i++ )
+ {
+ SbxObject* p = (SbxObject*) GetObjects()->Get( i );
+ if( bActivate )
+ p->SetFlag( SBX_EXTSEARCH );
+ else
+ p->ResetFlag( SBX_EXTSEARCH );
+ }
+ }
+}
+
+/**************************************************************************
+*
+* Debugging und Fehlerbehandlung
+*
+**************************************************************************/
+
+SbMethod* StarBASIC::GetActiveMethod( USHORT nLevel )
+{
+ if( pINST )
+ return pINST->GetCaller( nLevel );
+ else
+ return NULL;
+}
+
+SbModule* StarBASIC::GetActiveModule()
+{
+ if( pINST && !IsCompilerError() )
+ return pINST->GetActiveModule();
+ else
+ return pCMOD;
+}
+
+USHORT StarBASIC::BreakPoint( USHORT l, USHORT c1, USHORT c2 )
+{
+ SetErrorData( 0, l, c1, c2 );
+ bBreak = TRUE;
+ if( GetSbData()->aBreakHdl.IsSet() )
+ return (USHORT) GetSbData()->aBreakHdl.Call( this );
+ else
+ return BreakHdl();
+}
+
+USHORT StarBASIC::StepPoint( USHORT l, USHORT c1, USHORT c2 )
+{
+ SetErrorData( 0, l, c1, c2 );
+ bBreak = FALSE;
+ if( GetSbData()->aBreakHdl.IsSet() )
+ return (USHORT) GetSbData()->aBreakHdl.Call( this );
+ else
+ return BreakHdl();
+}
+
+USHORT __EXPORT StarBASIC::BreakHdl()
+{
+ return (USHORT) ( aBreakHdl.IsSet()
+ ? aBreakHdl.Call( this ) : SbDEBUG_CONTINUE );
+}
+
+// Abfragen fuer den Error-Handler und den Break-Handler:
+USHORT StarBASIC::GetLine() { return GetSbData()->nLine; }
+USHORT StarBASIC::GetCol1() { return GetSbData()->nCol1; }
+USHORT StarBASIC::GetCol2() { return GetSbData()->nCol2; }
+
+// Spezifisch fuer den Error-Handler:
+SbError StarBASIC::GetErrorCode() { return GetSbData()->nCode; }
+const String& StarBASIC::GetErrorText() { return GetSbData()->aErrMsg; }
+BOOL StarBASIC::IsCompilerError() { return GetSbData()->bCompiler; }
+void StarBASIC::SetGlobalLanguageMode( SbLanguageMode eLanguageMode )
+{
+ GetSbData()->eLanguageMode = eLanguageMode;
+}
+SbLanguageMode StarBASIC::GetGlobalLanguageMode()
+{
+ return GetSbData()->eLanguageMode;
+}
+// Lokale Einstellung
+SbLanguageMode StarBASIC::GetLanguageMode()
+{
+ // Globale Einstellung nehmen?
+ if( eLanguageMode == SB_LANG_GLOBAL )
+ return GetSbData()->eLanguageMode;
+ else
+ return eLanguageMode;
+}
+
+// AB: 29.3.96
+// Das Mapping zwischen alten und neuen Fehlercodes erfolgt, indem die Tabelle
+// SFX_VB_ErrorTab[] durchsucht wird. Dies ist zwar nicht besonders performant,
+// verbraucht aber viel weniger Speicher als entsprechende switch-Bloecke.
+// Die Umrechnung von Fehlercodes muss nicht schnell sein, daher auch keine
+// binaere Suche bei VB-Error -> SFX-Error.
+
+// Neue Fehler-Codes auf alte, Sbx-Kompatible zurueckmappen
+USHORT StarBASIC::GetVBErrorCode( SbError nError )
+{
+ USHORT nRet = 0;
+
+ // Suchschleife
+ const SFX_VB_ErrorItem* pErrItem;
+ USHORT nIndex = 0;
+ do
+ {
+ pErrItem = SFX_VB_ErrorTab + nIndex;
+ if( pErrItem->nErrorSFX == nError )
+ {
+ nRet = pErrItem->nErrorVB;
+ break;
+ }
+ nIndex++;
+ }
+ while( pErrItem->nErrorVB != 0xFFFF ); // bis End-Marke
+ return nRet;
+}
+
+SbError StarBASIC::GetSfxFromVBError( USHORT nError )
+{
+ SbError nRet = 0L;
+
+ // Suchschleife
+ const SFX_VB_ErrorItem* pErrItem;
+ USHORT nIndex = 0;
+ do
+ {
+ pErrItem = SFX_VB_ErrorTab + nIndex;
+ if( pErrItem->nErrorVB == nError )
+ {
+ nRet = pErrItem->nErrorSFX;
+ break;
+ }
+ else if( pErrItem->nErrorVB > nError )
+ break; // kann nicht mehr gefunden werden
+
+ nIndex++;
+ }
+ while( pErrItem->nErrorVB != 0xFFFF ); // bis End-Marke
+ return nRet;
+}
+
+// Error- / Break-Daten setzen
+void StarBASIC::SetErrorData
+( SbError nCode, USHORT nLine, USHORT nCol1, USHORT nCol2 )
+{
+ SbiGlobals& aGlobals = *GetSbData();
+ aGlobals.nCode = nCode;
+ aGlobals.nLine = nLine;
+ aGlobals.nCol1 = nCol1;
+ aGlobals.nCol2 = nCol2;
+}
+
+//----------------------------------------------------------------
+// Hilfsklasse zum Zugriff auf String SubResourcen einer Resource.
+// Quelle: sfx2\source\doc\docfile.cxx (TLX)
+struct BasicStringList_Impl : private Resource
+{
+ ResId aResId;
+
+ BasicStringList_Impl( ResId& rErrIdP, USHORT nId)
+ : Resource( rErrIdP ),aResId(nId){}
+ ~BasicStringList_Impl() { FreeResource(); }
+
+ String GetString(){ return String( aResId ); }
+ BOOL IsErrorTextAvailable( void )
+ { return IsAvailableRes(aResId.SetRT(RSC_STRING)); }
+};
+//----------------------------------------------------------------
+
+// #60175 Flag, das bei Basic-Fehlern das Anziehen der SFX-Resourcen verhindert
+static BOOL bStaticSuppressSfxResource = FALSE;
+
+void StarBASIC::StaticSuppressSfxResource( BOOL bSuppress )
+{
+ bStaticSuppressSfxResource = bSuppress;
+}
+
+void StarBASIC::MakeErrorText( SbError nId, const String& aMsg )
+{
+ if( bStaticSuppressSfxResource )
+ {
+ GetSbData()->aErrMsg = String( RTL_CONSTASCII_USTRINGPARAM("No resource: Error message not available") );
+ return;
+ }
+
+ USHORT nOldID = GetVBErrorCode( nId );
+
+ // Hilfsklasse instanzieren
+ BasicResId aId( RID_BASIC_START );
+ BasicStringList_Impl aMyStringList( aId, USHORT(nId & ERRCODE_RES_MASK) );
+
+ if( aMyStringList.IsErrorTextAvailable() )
+ {
+ // Merge Message mit Zusatztext
+ String aMsg1 = aMyStringList.GetString();
+ // Argument-Platzhalter durch %s ersetzen
+ String aSrgStr( RTL_CONSTASCII_USTRINGPARAM("$(ARG1)") );
+ USHORT nResult = aMsg1.Search( aSrgStr );
+
+ if( nResult != STRING_NOTFOUND )
+ {
+ aMsg1.Erase( nResult, aSrgStr.Len() );
+ aMsg1.Insert( aMsg, nResult );
+ }
+ GetSbData()->aErrMsg = aMsg1;
+ }
+ else
+ {
+ String aStdMsg( RTL_CONSTASCII_USTRINGPARAM("Fehler ") );
+ aStdMsg += String::CreateFromInt32( nOldID);
+ aStdMsg += String( RTL_CONSTASCII_USTRINGPARAM(": Kein Fehlertext verfuegbar!") );
+ GetSbData()->aErrMsg = aStdMsg;
+ }
+}
+
+BOOL StarBASIC::CError
+ ( SbError code, const String& rMsg, USHORT l, USHORT c1, USHORT c2 )
+{
+ // Compiler-Fehler waehrend der Laufzeit -> Programm anhalten
+ if( IsRunning() )
+ Stop();
+
+ // #45741# Falls der Wait-Cursor gesetzt ist, jetzt zuruecksetzen
+ if( GetSbData()->bCompWait )
+ {
+ Application::LeaveWait();
+ GetSbData()->bCompWait = FALSE;
+ }
+
+ // Flag setzen, damit GlobalRunInit den Fehler mitbekommt
+ GetSbData()->bGlobalInitErr = TRUE;
+
+ // Fehlertext basteln
+ MakeErrorText( code, rMsg );
+
+ // Umsetzung des Codes fuer String-Transport in SFX-Error
+ if( rMsg.Len() )
+ code = (ULONG)*new StringErrorInfo( code, String(rMsg) );
+
+ SetErrorData( code, l, c1, c2 );
+ GetSbData()->bCompiler = TRUE;
+ BOOL bRet;
+ if( GetSbData()->aErrHdl.IsSet() )
+ bRet = (BOOL) GetSbData()->aErrHdl.Call( this );
+ else
+ bRet = ErrorHdl();
+ GetSbData()->bCompiler = FALSE; // nur TRUE fuer Error-Handler
+ return bRet;
+}
+
+BOOL StarBASIC::RTError
+ ( SbError code, USHORT l, USHORT c1, USHORT c2 )
+{
+ return RTError( code, String(), l, c1, c2 );
+}
+
+BOOL StarBASIC::RTError( SbError code, const String& rMsg, USHORT l, USHORT c1, USHORT c2 )
+{
+ SbError c = code;
+ if( (c & ERRCODE_CLASS_MASK) == ERRCODE_CLASS_COMPILER )
+ c = 0;
+ MakeErrorText( c, rMsg );
+
+ // Umsetzung des Codes fuer String-Transport in SFX-Error
+ if( rMsg.Len() )
+ code = (ULONG)*new StringErrorInfo( code, String(rMsg) );
+
+ SetErrorData( code, l, c1, c2 );
+ if( GetSbData()->aErrHdl.IsSet() )
+ return (BOOL) GetSbData()->aErrHdl.Call( this );
+ else
+ return ErrorHdl();
+}
+
+void StarBASIC::Error( SbError n )
+{
+ Error( n, String() );
+}
+
+void StarBASIC::Error( SbError n, const String& rMsg )
+{
+ if( pINST )
+ pINST->Error( n, rMsg );
+}
+
+void StarBASIC::FatalError( SbError n )
+{
+ if( pINST )
+ pINST->FatalError( n );
+}
+
+SbError StarBASIC::GetErr()
+{
+ if( pINST )
+ return pINST->GetErr();
+ else
+ return 0;
+}
+
+// #66536 Zusatz-Message fuer RTL-Funktion Error zugreifbar machen
+String StarBASIC::GetErrorMsg()
+{
+ if( pINST )
+ return pINST->GetErrorMsg();
+ else
+ return String();
+}
+
+USHORT StarBASIC::GetErl()
+{
+ if( pINST )
+ return pINST->GetErl();
+ else
+ return 0;
+}
+
+BOOL __EXPORT StarBASIC::ErrorHdl()
+{
+ return (BOOL) ( aErrorHdl.IsSet()
+ ? aErrorHdl.Call( this ) : FALSE );
+}
+
+Link StarBASIC::GetGlobalErrorHdl()
+{
+ return GetSbData()->aErrHdl;
+}
+
+void StarBASIC::SetGlobalErrorHdl( const Link& rLink )
+{
+ GetSbData()->aErrHdl = rLink;
+}
+
+
+Link StarBASIC::GetGlobalBreakHdl()
+{
+ return GetSbData()->aBreakHdl;
+}
+
+void StarBASIC::SetGlobalBreakHdl( const Link& rLink )
+{
+ GetSbData()->aBreakHdl = rLink;
+}
+
+/**************************************************************************
+*
+* Laden und Speichern
+*
+**************************************************************************/
+
+BOOL StarBASIC::LoadData( SvStream& r, USHORT nVer )
+{
+ if( !SbxObject::LoadData( r, nVer ) )
+ return FALSE;
+ UINT16 nMod;
+ pModules->Clear();
+ r >> nMod;
+ for( USHORT i = 0; i < nMod; i++ )
+ {
+ SbModule* pMod = (SbModule*) SbxBase::Load( r );
+ if( !pMod )
+ return FALSE;
+ else if( pMod->ISA(SbJScriptModule) )
+ {
+ // Ref zuweisen, damit pMod deleted wird
+ SbModuleRef xRef = pMod;
+ }
+ else
+ {
+ pMod->SetParent( this );
+ pModules->Put( pMod, i );
+ }
+ }
+ // HACK fuer SFX-Mist!
+ SbxVariable* p = Find( String( RTL_CONSTASCII_USTRINGPARAM("FALSE") ), SbxCLASS_PROPERTY );
+ if( p )
+ Remove( p );
+ p = Find( String( RTL_CONSTASCII_USTRINGPARAM("TRUE") ), SbxCLASS_PROPERTY );
+ if( p )
+ Remove( p );
+ // Ende des Hacks!
+ // Suche ueber StarBASIC ist immer global
+ DBG_ASSERT( IsSet( SBX_GBLSEARCH ), "Basic ohne GBLSEARCH geladen" );
+ SetFlag( SBX_GBLSEARCH );
+ return TRUE;
+}
+
+BOOL StarBASIC::StoreData( SvStream& r ) const
+{
+ if( !SbxObject::StoreData( r ) )
+ return FALSE;
+ r << (UINT16) pModules->Count();
+ for( USHORT i = 0; i < pModules->Count(); i++ )
+ {
+ SbModule* p = (SbModule*) pModules->Get( i );
+ if( !p->Store( r ) )
+ return FALSE;
+ }
+ return TRUE;
+}
+
+BOOL StarBASIC::LoadOldModules( SvStream& r )
+{
+ return FALSE;
+}
+
+
diff --git a/basic/source/classes/sb.src b/basic/source/classes/sb.src
new file mode 100644
index 000000000000..ba78c4a83d89
--- /dev/null
+++ b/basic/source/classes/sb.src
@@ -0,0 +1,3747 @@
+/*************************************************************************
+ *
+ * $RCSfile: sb.src,v $
+ *
+ * $Revision: 1.1.1.1 $
+ *
+ * last change: $Author: hr $ $Date: 2000-09-18 16:12:10 $
+ *
+ * The Contents of this file are made available subject to the terms of
+ * either of the following licenses
+ *
+ * - GNU Lesser General Public License Version 2.1
+ * - Sun Industry Standards Source License Version 1.1
+ *
+ * Sun Microsystems Inc., October, 2000
+ *
+ * GNU Lesser General Public License Version 2.1
+ * =============================================
+ * Copyright 2000 by Sun Microsystems, Inc.
+ * 901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ *
+ * Sun Industry Standards Source License Version 1.1
+ * =================================================
+ * The contents of this file are subject to the Sun Industry Standards
+ * Source License Version 1.1 (the "License"); You may not use this file
+ * except in compliance with the License. You may obtain a copy of the
+ * License at http://www.openoffice.org/license.html.
+ *
+ * Software provided under this License is provided on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ * See the License for the specific provisions governing your rights and
+ * obligations concerning the Software.
+ *
+ * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ * Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ * All Rights Reserved.
+ *
+ * Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#define __RSC
+#ifndef _ERRCODE_HXX //autogen
+#include <tools/errcode.hxx>
+#endif
+#include "sb.hrc"
+#include "sberrors.hxx"
+
+Resource RID_BASIC_START
+{
+ String SbERR_SYNTAX & ERRCODE_RES_MASK
+ {
+ Text = "Syntaxfehler" ;
+ Text [ ENGLISH ] = "Syntax error" ;
+ Text [ norwegian ] = "Syntax error" ;
+ Text [ italian ] = "Errore di sintassi" ;
+ Text [ portuguese_brazilian ] = "Syntax error" ;
+ Text [ portuguese ] = "Erro de sintaxe" ;
+ Text [ french ] = "Erreur de syntaxe" ;
+ Text [ dutch ] = "Fout in syntaxis" ;
+ Text [ spanish ] = "Error de sintaxis" ;
+ Text [ danish ] = "Syntaksfejl" ;
+ Text [ swedish ] = "Syntaxfel" ;
+ Text [ finnish ] = "Syntax error" ;
+ Text [ english_us ] = "Syntax error" ;
+ Text[ chinese_simplified ] = "﷨";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Bd skadni";
+ Text[ japanese ] = " װ";
+ Text[ chinese_traditional ] = "yk~";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Fout in syntaxis";
+ Text[ chinese_simplified ] = "﷨";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ؽ ";
+ Text[ turkish ] = "Szdizim hatas";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_GOSUB & ERRCODE_RES_MASK
+ {
+ Text = "Return ohne Gosub" ;
+ Text [ ENGLISH ] = "Return without Gosub" ;
+ Text [ norwegian ] = "Return without Gosub" ;
+ Text [ italian ] = "Return senza Gosub" ;
+ Text [ portuguese_brazilian ] = "Return without Gosub" ;
+ Text [ portuguese ] = "Retorno sem Gosub" ;
+ Text [ french ] = "Return sans Gosub" ;
+ Text [ dutch ] = "Return zonder Gosub" ;
+ Text [ spanish ] = "Retorno sin Gosub" ;
+ Text [ danish ] = "Return uden Gosub" ;
+ Text [ swedish ] = "Return utan Gosub" ;
+ Text [ finnish ] = "Return without Gosub" ;
+ Text [ english_us ] = "Return without Gosub" ;
+ Text[ chinese_simplified ] = "Return Gosub";
+ Text[ russian ] = " Gosub";
+ Text[ polish ] = "Powrt bez Gosub";
+ Text[ japanese ] = "Return without Gosub";
+ Text[ chinese_traditional ] = "Return a Gosub";
+ Text[ arabic ] = "Gosub Return";
+ Text[ dutch ] = "Return zonder Gosub";
+ Text[ chinese_simplified ] = "Return Gosub";
+ Text[ greek ] = "Return Gosub";
+ Text[ korean ] = "Gosub ";
+ Text[ turkish ] = "Gosub olmadan return";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_REDO_FROM_START & ERRCODE_RES_MASK
+ {
+ Text = "Inkorrekte Eingabe, bitte wiederholen" ;
+ Text [ ENGLISH ] = "Incorrect data, please retry" ;
+ Text [ norwegian ] = "Incorrect data, please retry" ;
+ Text [ italian ] = "Digitazione errata, riprovare" ;
+ Text [ portuguese_brazilian ] = "Incorrect data, please retry" ;
+ Text [ portuguese ] = "Entrada incorrecta, tente novamente" ;
+ Text [ french ] = "Saisie incorrecte, veuillez recommencer" ;
+ Text [ dutch ] = "Incorrecte gegevens, herhalen a.u.b." ;
+ Text [ spanish ] = "Entrada incorrecta. Intntelo otra vez" ;
+ Text [ danish ] = "Forkert input, gentag venligst" ;
+ Text [ swedish ] = "Felaktig inmatning, var vnlig upprepa" ;
+ Text [ finnish ] = "Incorrect data, please retry" ;
+ Text [ english_us ] = "Incorrect entry; please retry" ;
+ Text[ chinese_simplified ] = "Чظ";
+ Text[ russian ] = " , , ";
+ Text[ polish ] = "Niepoprawny wpis, prosz ponowi";
+ Text[ japanese ] = "Ȃ͂łA蒼ĉ";
+ Text[ chinese_traditional ] = "JLġMЭơC";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Incorrecte gegevens, herhalen a.u.b.";
+ Text[ chinese_simplified ] = "Чظ";
+ Text[ greek ] = " , ";
+ Text[ korean ] = " ߸Ǿϴ. ٽ ֽʽÿ.";
+ Text[ turkish ] = "Giri yanl, ltfen yeniden girin";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_ARGUMENT & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ungltiger Prozeduraufruf : Ungltiger Prozeduraufruf */
+ Text = "Ungltiger Prozeduraufruf" ;
+ Text [ ENGLISH ] = "Invalid procedure call" ;
+ Text [ norwegian ] = "Invalid procedure call" ;
+ Text [ italian ] = "Richiamo di procedura non valido" ;
+ Text [ portuguese_brazilian ] = "Invalid procedure call" ;
+ Text [ portuguese ] = "Chamada de procedimento no vlida" ;
+ Text [ french ] = "Appel de procdure incorrect" ;
+ Text [ dutch ] = "Ongeldige oproep van procedure" ;
+ Text [ spanish ] = "Inicio del proceso no vlido" ;
+ Text [ danish ] = "Ugyldigt procedurekald" ;
+ Text [ swedish ] = "Ogiltigt proceduranrop" ;
+ Text [ finnish ] = "Invalid procedure call" ;
+ Text [ english_us ] = "Invalid procedure call" ;
+ Text[ chinese_simplified ] = "Чĵù";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nieprawidowa procedura wywoania";
+ Text[ japanese ] = "ۼެ̌Ăяo";
+ Text[ chinese_traditional ] = "եιL{L";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Ongeldige oproep van procedure";
+ Text[ chinese_simplified ] = "Чĵù";
+ Text[ greek ] = " ";
+ Text[ korean ] = "߸ ν ȣ";
+ Text[ turkish ] = "Geersiz yordam ars";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_MATH_OVERFLOW & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? berlauf : berlauf */
+ Text = "berlauf" ;
+ Text [ ENGLISH ] = "Overflow" ;
+ Text [ norwegian ] = "Overflow" ;
+ Text [ italian ] = "Overflow" ;
+ Text [ portuguese_brazilian ] = "Overflow" ;
+ Text [ portuguese ] = "Transbordo" ;
+ Text [ french ] = "Dbordement" ;
+ Text [ dutch ] = "Overflow" ;
+ Text [ spanish ] = "Desbordamiento" ;
+ Text [ danish ] = "Overlb" ;
+ Text [ swedish ] = "Spill" ;
+ Text [ finnish ] = "Overflow" ;
+ Text [ english_us ] = "Overflow" ;
+ Text[ chinese_simplified ] = "ֵ";
+ Text[ russian ] = "";
+ Text[ polish ] = "Przepenienie";
+ Text[ japanese ] = "ް۰";
+ Text[ chinese_traditional ] = "";
+ Text[ arabic ] = "";
+ Text[ dutch ] = "Overflow";
+ Text[ chinese_simplified ] = "ֵ";
+ Text[ greek ] = "";
+ Text[ korean ] = "ħ";
+ Text[ turkish ] = "Tama";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_MEMORY & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Nicht gengend Speicher : Nicht gengend Speicher */
+ Text = "Nicht gengend Speicher" ;
+ Text [ ENGLISH ] = "Out of memory" ;
+ Text [ norwegian ] = "Out of memory" ;
+ Text [ italian ] = "Memoria insufficiente" ;
+ Text [ portuguese_brazilian ] = "Out of memory" ;
+ Text [ portuguese ] = "Memria insuficiente" ;
+ Text [ french ] = "Mmoire insuffisante" ;
+ Text [ dutch ] = "Niet voldoende geheugen" ;
+ Text [ spanish ] = "No hay memoria suficiente" ;
+ Text [ danish ] = "Ikke tilstrkkelig hukommelse" ;
+ Text [ swedish ] = "Inte tillrckligt med minne" ;
+ Text [ finnish ] = "Out of memory" ;
+ Text [ english_us ] = "Not enough memory" ;
+ Text[ chinese_simplified ] = "ڴ治";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Za mao pamici";
+ Text[ japanese ] = "\\ȋ󂫗eʂ܂";
+ Text[ chinese_traditional ] = "O餣";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Niet voldoende geheugen";
+ Text[ chinese_simplified ] = "ڴ治";
+ Text[ greek ] = " ";
+ Text[ korean ] = "޸ ";
+ Text[ turkish ] = "Bellek yeterli deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_ALREADY_DIM & ERRCODE_RES_MASK
+ {
+ Text = "Array bereits dimensioniert" ;
+ Text [ ENGLISH ] = "Array already dimensioned" ;
+ Text [ norwegian ] = "Array already dimensioned" ;
+ Text [ italian ] = "Array gi dimensionato" ;
+ Text [ portuguese_brazilian ] = "Array already dimensioned" ;
+ Text [ portuguese ] = "A matriz j foi dimensionada" ;
+ Text [ french ] = "Array dj dimensionn" ;
+ Text [ dutch ] = "Array reeds gedimensioneerd" ;
+ Text [ spanish ] = "Array ya dimensionado" ;
+ Text [ danish ] = "Array er allerede dimensioneret" ;
+ Text [ swedish ] = "Array redan dimensionerad" ;
+ Text [ finnish ] = "Array already dimensioned" ;
+ Text [ english_us ] = "Array already dimensioned" ;
+ Text[ chinese_simplified ] = "Ѿ߶";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Macierz ju zostaa zwymiarowana";
+ Text[ japanese ] = "z͂łɎĂ܂";
+ Text[ chinese_traditional ] = "CwgQwث";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Array reeds gedimensioneerd";
+ Text[ chinese_simplified ] = "Ѿ߶";
+ Text[ greek ] = " ";
+ Text[ korean ] = "迭 ũⰡ ̹ ";
+ Text[ turkish ] = "Dizi boyutlandrlm durumda";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_OUT_OF_RANGE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Index auerhalb des definierten Bereichs : Index auerhalb des definierten Bereichs */
+ Text = "Index auerhalb des definierten Bereichs" ;
+ Text [ ENGLISH ] = "Subscript out of range" ;
+ Text [ norwegian ] = "Subscript out of range" ;
+ Text [ italian ] = "Indice al di fuori dell'area definita" ;
+ Text [ portuguese_brazilian ] = "Subscript out of range" ;
+ Text [ portuguese ] = "ndice fora da rea definida" ;
+ Text [ french ] = "Index en dehors de la plage dfinie" ;
+ Text [ dutch ] = "Index buiten gedefinieerd bereik" ;
+ Text [ spanish ] = "El ndice se encuentra fuera del rea definida" ;
+ Text [ danish ] = "Indeks udenfor det definerede omrde" ;
+ Text [ swedish ] = "Index utanfr definierat omrde" ;
+ Text [ finnish ] = "Subscript out of range" ;
+ Text [ english_us ] = "Index out of defined range" ;
+ Text[ chinese_simplified ] = "巶Χ֮";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Indeks poza zdefiniowanym obszarem";
+ Text[ japanese ] = "`ꂽ͈͊O̲ޯ";
+ Text[ chinese_traditional ] = "wqd򤧥~";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Index buiten gedefinieerd bereik";
+ Text[ chinese_simplified ] = "巶Χ֮";
+ Text[ greek ] = " .";
+ Text[ korean ] = "ǵ ε";
+ Text[ turkish ] = "Dizin tanmlanan araln dnda";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DUPLICATE_DEF & ERRCODE_RES_MASK
+ {
+ Text = "Doppelt vorhandene Definition" ;
+ Text [ ENGLISH ] = "Duplicate definition" ;
+ Text [ norwegian ] = "Duplicate definition" ;
+ Text [ italian ] = "Definizione doppia" ;
+ Text [ portuguese_brazilian ] = "Duplicate definition" ;
+ Text [ portuguese ] = "Definio dupla" ;
+ Text [ french ] = "Dfinition faisant double emploi" ;
+ Text [ dutch ] = "Definitie dubbel voorhanden" ;
+ Text [ spanish ] = "La definicin existe dos veces" ;
+ Text [ danish ] = "Dobbelt foreliggende definition" ;
+ Text [ swedish ] = "Dubbelt frekommande definition" ;
+ Text [ finnish ] = "Duplicate definition" ;
+ Text [ english_us ] = "Duplicate definition" ;
+ Text[ chinese_simplified ] = "˫ض";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Zduplikowana definicja";
+ Text[ japanese ] = "d`";
+ Text[ chinese_traditional ] = "sbwq";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Definitie dubbel voorhanden";
+ Text[ chinese_simplified ] = "˫ض";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ߺ ";
+ Text[ turkish ] = "ift tanmlama";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_ZERODIV & ERRCODE_RES_MASK
+ {
+ Text = "Division durch Null" ;
+ Text [ ENGLISH ] = "Division by zero" ;
+ Text [ norwegian ] = "Division by zero" ;
+ Text [ italian ] = "Diviso zero" ;
+ Text [ portuguese_brazilian ] = "Division by zero" ;
+ Text [ portuguese ] = "Dividir por zero" ;
+ Text [ french ] = "Division par zro" ;
+ Text [ dutch ] = "Deling door nul" ;
+ Text [ spanish ] = "Divisin por cero" ;
+ Text [ danish ] = "Divider med nul" ;
+ Text [ swedish ] = "Division med noll" ;
+ Text [ finnish ] = "Division by zero" ;
+ Text [ english_us ] = "Division by zero" ;
+ Text[ chinese_simplified ] = "";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Dzielenie przez zero";
+ Text[ japanese ] = "ۂɂ鏜Z";
+ Text[ chinese_traditional ] = "_s";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Deling door nul";
+ Text[ chinese_simplified ] = "";
+ Text[ greek ] = " ";
+ Text[ korean ] = "0 ";
+ Text[ turkish ] = "Sfra blme";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_VAR_UNDEFINED & ERRCODE_RES_MASK
+ {
+ Text = "Variable nicht definiert" ;
+ Text [ ENGLISH ] = "Variable not defined" ;
+ Text [ norwegian ] = "Variable not defined" ;
+ Text [ italian ] = "Variabile non definita" ;
+ Text [ portuguese_brazilian ] = "Variable not defined" ;
+ Text [ portuguese ] = "Varivel no definida" ;
+ Text [ french ] = "Variable indfinie" ;
+ Text [ dutch ] = "Variabele niet gedefinieerd" ;
+ Text [ spanish ] = "Variable no definida" ;
+ Text [ danish ] = "Variablen er ikke defineret" ;
+ Text [ swedish ] = "Variabel inte definierad" ;
+ Text [ finnish ] = "Variable not defined" ;
+ Text [ english_us ] = "Variable not defined" ;
+ Text[ chinese_simplified ] = "ûж";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Zmienna nie zdefiniowana";
+ Text[ japanese ] = "ϐ͒`Ă܂";
+ Text[ chinese_traditional ] = "Swqܼ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Variabele niet gedefinieerd";
+ Text[ chinese_simplified ] = "ûж";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ";
+ Text[ turkish ] = "Deiken tanmlanmad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_CONVERSION & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Datentypen unvertrglich : Datentypen unvertrglich */
+ Text = "Datentypen unvertrglich" ;
+ Text [ ENGLISH ] = "Data type mismatch" ;
+ Text [ norwegian ] = "Data type mismatch" ;
+ Text [ italian ] = "Tipi di dati non compatibili" ;
+ Text [ portuguese_brazilian ] = "Data type mismatch" ;
+ Text [ portuguese ] = "Tipos de dados incompatveis" ;
+ Text [ french ] = "Types de donnes incompatibles" ;
+ Text [ dutch ] = "Gegevenstypen passen niet bij elkaar" ;
+ Text [ spanish ] = "Los tipos de datos no coinciden" ;
+ Text [ danish ] = "Datatyper er uforenelige" ;
+ Text [ swedish ] = "Datatyper passar inte ihop" ;
+ Text [ finnish ] = "Data type mismatch" ;
+ Text [ english_us ] = "Data type mismatch" ;
+ Text[ chinese_simplified ] = "Ͳƥ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Niezgodne typy danych";
+ Text[ japanese ] = "ް̎ނ͋܂";
+ Text[ chinese_traditional ] = "ǰt";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Gegevenstypen passen niet bij elkaar";
+ Text[ chinese_simplified ] = "Ͳƥ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " Ÿ ʽϴ.";
+ Text[ turkish ] = "Veri tipleri arasnda uyumazlk";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_PARAMETER & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ungltiger Parameter : Ungltiger Parameter */
+ Text = "Ungltiger Parameter" ;
+ Text [ ENGLISH ] = "Bad parameter" ;
+ Text [ norwegian ] = "Bad parameter" ;
+ Text [ italian ] = "Parametro non valido" ;
+ Text [ portuguese_brazilian ] = "Bad parameter" ;
+ Text [ portuguese ] = "Parmetro no vlido" ;
+ Text [ french ] = "Paramtre incorrect" ;
+ Text [ dutch ] = "Ongeldige parameter" ;
+ Text [ spanish ] = "Parmetro no vlido" ;
+ Text [ danish ] = "Ugyldig parameter" ;
+ Text [ swedish ] = "Ogiltig parameter" ;
+ Text [ finnish ] = "Bad parameter" ;
+ Text [ english_us ] = "Invalid parameter" ;
+ Text[ chinese_simplified ] = "Ч";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nieprawidowy parametr";
+ Text[ japanese ] = "Ұ";
+ Text[ chinese_traditional ] = "UܼƵL";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Ongeldige parameter";
+ Text[ chinese_simplified ] = "Ч";
+ Text[ greek ] = " ";
+ Text[ korean ] = "߸ ۶";
+ Text[ turkish ] = "Geersiz parametre";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_USER_ABORT & ERRCODE_RES_MASK
+ {
+ Text = "Der Ablauf wurde durch den Benutzer unterbrochen" ;
+ Text [ ENGLISH ] = "User interrupt occurred" ;
+ Text [ norwegian ] = "User interrupt occurred" ;
+ Text [ italian ] = "Processo interrotto dall'utente" ;
+ Text [ portuguese_brazilian ] = "User interrupt occurred" ;
+ Text [ portuguese ] = "O processo foi interrompido pelo utilizador" ;
+ Text [ french ] = "Processus interrompu par l'utilisateur" ;
+ Text [ dutch ] = "Onderbreking door gebruiker" ;
+ Text [ spanish ] = "El proceso ha sido interrumpido por el usuario" ;
+ Text [ danish ] = "Processen blev afbrudt af brugeren" ;
+ Text [ swedish ] = "Anvndaren avslutade frloppet" ;
+ Text [ finnish ] = "User interrupt occurred" ;
+ Text [ english_us ] = "Process interrupted by user" ;
+ Text[ chinese_simplified ] = "ʹж̡";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Proces zosta przerwany przez uytkownika";
+ Text[ japanese ] = "հްɂĒf܂";
+ Text[ chinese_traditional ] = "ϥΪ̤_BL{C";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Onderbreking door gebruiker";
+ Text[ chinese_simplified ] = "ʹж̡";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ڿ μ ͷƮ";
+ Text[ turkish ] = "Sre kullanc tarafndan kesildi";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_RESUME & ERRCODE_RES_MASK
+ {
+ Text = "Resume ohne Fehler" ;
+ Text [ ENGLISH ] = "Resume without error" ;
+ Text [ norwegian ] = "Resume without error" ;
+ Text [ italian ] = "Resume senza errori" ;
+ Text [ portuguese_brazilian ] = "Resume without error" ;
+ Text [ portuguese ] = "Resumo sem erros" ;
+ Text [ french ] = "Rsum sans erreur" ;
+ Text [ dutch ] = "Resume zonder fouten" ;
+ Text [ spanish ] = "Resumen sin error" ;
+ Text [ danish ] = "Resume uden fejl" ;
+ Text [ swedish ] = "Resume utan fel" ;
+ Text [ finnish ] = "Resume without error" ;
+ Text [ english_us ] = "Resume without error" ;
+ Text[ chinese_simplified ] = "Resume error";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Resume bez bdu";
+ Text[ japanese ] = "Resume without error";
+ Text[ chinese_traditional ] = "Resume a error";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Resume zonder fouten";
+ Text[ chinese_simplified ] = "Resume error";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ٽ ";
+ Text[ turkish ] = "Resume ohne Fehler";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_STACK_OVERFLOW & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Nicht gengend Stapelspeicher : Nicht gengend Stapelspeicher */
+ Text = "Nicht gengend Stapelspeicher" ;
+ Text [ ENGLISH ] = "Out of stack space" ;
+ Text [ norwegian ] = "Out of stack space" ;
+ Text [ italian ] = "Memoria stack non sufficiente" ;
+ Text [ portuguese_brazilian ] = "Out of stack space" ;
+ Text [ portuguese ] = "Memria tampo insuficiente" ;
+ Text [ french ] = "Mmoire tampon insuffisante" ;
+ Text [ dutch ] = "Niet genoeg stack" ;
+ Text [ spanish ] = "Desbordamiento de pila" ;
+ Text [ danish ] = "Ikke nok stakhukommelse" ;
+ Text [ swedish ] = "Inte tillrckligt med stapelminne" ;
+ Text [ finnish ] = "Out of stack space" ;
+ Text [ english_us ] = "Not enough stack memory" ;
+ Text[ chinese_simplified ] = "ջʽڴ治";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Za mao pamici stosowej";
+ Text[ japanese ] = "s\\Ƚ";
+ Text[ chinese_traditional ] = "|O餣";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Niet genoeg stack";
+ Text[ chinese_simplified ] = "ջʽڴ治";
+ Text[ greek ] = " ";
+ Text[ korean ] = "stack ޸ ";
+ Text[ turkish ] = "Yn bellek yeterli deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_PROC_UNDEFINED & ERRCODE_RES_MASK
+ {
+ Text = "Sub- oder Function-Prozedur nicht definiert" ;
+ Text [ ENGLISH ] = "Sub or Function not defined" ;
+ Text [ norwegian ] = "Sub or Function not defined" ;
+ Text [ italian ] = "Procedura sub o di funzione non definita" ;
+ Text [ portuguese_brazilian ] = "Sub or Function not defined" ;
+ Text [ portuguese ] = "Procedimento de funo ou subordinado no definidos" ;
+ Text [ french ] = "La sous-procdure ou procdure fonctionnelle n'est pas dfinie" ;
+ Text [ dutch ] = "Sub- of functieprocedure niet gedefinieerd" ;
+ Text [ spanish ] = "Procedimiento de funcin o subordinado no definido" ;
+ Text [ danish ] = "Under- eller funktionsproceduren er ikke defineret" ;
+ Text [ swedish ] = "Sub- eller funktionsproceduren inte definierad" ;
+ Text [ finnish ] = "Sub or Function not defined" ;
+ Text [ english_us ] = "Sub-procedure or function procedure not defined" ;
+ Text[ chinese_simplified ] = "ûжֹ̻";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nie zdefiniowano procedury podrzdnej lub funkcyjnej";
+ Text[ japanese ] = "Sub܂Functionۼެ͒`Ă܂";
+ Text[ chinese_traditional ] = "SwqL{ΨƹL{";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Sub- of functieprocedure niet gedefinieerd";
+ Text[ chinese_simplified ] = "ûжֹ̻";
+ Text[ greek ] = " (Sub) (Function)";
+ Text[ korean ] = " ν Ǵ ν";
+ Text[ turkish ] = "Alt yordam ya da ilev yordam tanmlanmad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_DLL_LOAD & ERRCODE_RES_MASK
+ {
+ Text = "Fehler beim Laden einer DLL-Datei" ;
+ Text [ ENGLISH ] = "Error in loading DLL" ;
+ Text [ norwegian ] = "Error in loading DLL" ;
+ Text [ italian ] = "Errore nel caricamento del file DLL" ;
+ Text [ portuguese_brazilian ] = "Error in loading DLL" ;
+ Text [ portuguese ] = "Erro ao carregar um ficheiro DLL" ;
+ Text [ french ] = "Erreur lors du chargement d'un fichier DLL" ;
+ Text [ dutch ] = "Fout bei laden van DLL-bestand" ;
+ Text [ spanish ] = "Error al cargar un archivo DDL" ;
+ Text [ danish ] = "Fejl ved indlsning af DLL-fil" ;
+ Text [ swedish ] = "Fel vid laddning av DLL-fil" ;
+ Text [ finnish ] = "Error in loading DLL" ;
+ Text [ english_us ] = "Error loading DLL file" ;
+ Text[ chinese_simplified ] = "װ DLL ļʱ";
+ Text[ russian ] = " DLL";
+ Text[ polish ] = "Bd przy adowaniu pliku DLL";
+ Text[ japanese ] = "DLĻق̓ǂݍ݂̍ۂ̴װ";
+ Text[ chinese_traditional ] = "˸DLLɮ׮ɵoͿ~";
+ Text[ arabic ] = "DLL ";
+ Text[ dutch ] = "Fout bei laden van DLL-bestand";
+ Text[ chinese_simplified ] = "װ DLL ļʱ";
+ Text[ greek ] = " DLL";
+ Text[ korean ] = "DLL ε ";
+ Text[ turkish ] = "DLL dosyasn ykleme srasnda hata";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_DLL_CALL & ERRCODE_RES_MASK
+ {
+ Text = "Falsche DLL-Aufrufkonvention" ;
+ Text [ ENGLISH ] = "Bad DLL calling convention" ;
+ Text [ norwegian ] = "Bad DLL calling convention" ;
+ Text [ italian ] = "Convenzione di richiamo DLL errata" ;
+ Text [ portuguese_brazilian ] = "Bad DLL calling convention" ;
+ Text [ portuguese ] = "Conveno da chamada DLL incorrecta" ;
+ Text [ french ] = "Convention d'appel DLL incorrecte" ;
+ Text [ dutch ] = "Foutieve DLL-oproepconventie" ;
+ Text [ spanish ] = "Convencin de la llamada DLL incorrecta" ;
+ Text [ danish ] = "Forkert DLL-kaldkonvention" ;
+ Text [ swedish ] = "Fel DLL-anropningskonvention" ;
+ Text [ finnish ] = "Bad DLL calling convention" ;
+ Text [ english_us ] = "Wrong DLL call convention" ;
+ Text[ chinese_simplified ] = " DLLԼ";
+ Text[ russian ] = " DLL";
+ Text[ polish ] = "Nieprawidowa konwencja wywoania DLL";
+ Text[ japanese ] = "ȂDLLĂяo";
+ Text[ chinese_traditional ] = "~DLLեάw";
+ Text[ arabic ] = " DLL ";
+ Text[ dutch ] = "Foutieve DLL-oproepconventie";
+ Text[ chinese_simplified ] = " DLLԼ";
+ Text[ greek ] = " DLL";
+ Text[ korean ] = "Ʋ DLL ȣ ";
+ Text[ turkish ] = "Yanl DLL ar kural";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_INTERNAL_ERROR & ERRCODE_RES_MASK
+ {
+ Text = "Interner Fehler $(ARG1)" ;
+ Text [ ENGLISH ] = "Internal error $(ARG1)" ;
+ Text [ norwegian ] = "Internal error $(ARG1)" ;
+ Text [ italian ] = "Errore interno $(ARG1)" ;
+ Text [ portuguese_brazilian ] = "Internal error $(ARG1)" ;
+ Text [ portuguese ] = "Erro interno $(ARG1)" ;
+ Text [ french ] = "Erreur interne $(ARG1)" ;
+ Text [ dutch ] = "Interne fout $(ARG1)" ;
+ Text [ spanish ] = "Error interno $(ARG1)" ;
+ Text [ danish ] = "Intern fejl $(ARG1)" ;
+ Text [ swedish ] = "Internt fel $(ARG1)" ;
+ Text [ finnish ] = "Internal error $(ARG1)" ;
+ Text [ english_us ] = "Internal error $(ARG1)" ;
+ Text[ chinese_simplified ] = "ڲ $(ARG1)";
+ Text[ russian ] = " $(ARG1)";
+ Text[ polish ] = "Bd wewntrzny $(ARG1)";
+ Text[ japanese ] = "װ$(ARG1)";
+ Text[ chinese_traditional ] = "~$(ARG1)";
+ Text[ arabic ] = "$(ARG1) ";
+ Text[ dutch ] = "Interne fout $(ARG1)";
+ Text[ chinese_simplified ] = "ڲ $(ARG1)";
+ Text[ greek ] = " $(ARG1)";
+ Text[ korean ] = " $(ARG1)";
+ Text[ turkish ] = "Dahili hata $(ARG1)";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_CHANNEL & ERRCODE_RES_MASK
+ {
+ Text = "Dateiname oder -nummer falsch" ;
+ Text [ ENGLISH ] = "Bad file name or number" ;
+ Text [ norwegian ] = "Bad file name or number" ;
+ Text [ italian ] = "Nome file o numero file errato" ;
+ Text [ portuguese_brazilian ] = "Bad file name or number" ;
+ Text [ portuguese ] = "Nome ou nmero do ficheiro incorrecto" ;
+ Text [ french ] = "Nom ou numro de fichier incorrect" ;
+ Text [ dutch ] = "Foutieve bestandsnaam of -nummer" ;
+ Text [ spanish ] = "Nombre o nmero incorrecto de archivo" ;
+ Text [ danish ] = "Forkert filnavn eller -nummer" ;
+ Text [ swedish ] = "Ogiltigt filnamn eller filnummer" ;
+ Text [ finnish ] = "Bad file name or number" ;
+ Text [ english_us ] = "Invalid file name or file number" ;
+ Text[ chinese_simplified ] = "Чļ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nazwa pliku lub numer nieprawidowe";
+ Text[ japanese ] = "̧ٖ܂̧ٔԍ܂";
+ Text[ chinese_traditional ] = "LĪɮשθX";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Foutieve bestandsnaam of -nummer";
+ Text[ chinese_simplified ] = "Чļ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "߸ ̸ Ǵ ȣ";
+ Text[ turkish ] = "Dosya ad ya da numaras yanl";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_FILE_NOT_FOUND & ERRCODE_RES_MASK
+ {
+ Text = "Datei nicht gefunden" ;
+ Text [ ENGLISH ] = "File not found" ;
+ Text [ norwegian ] = "File not found" ;
+ Text [ italian ] = "File non trovato" ;
+ Text [ portuguese_brazilian ] = "File not found" ;
+ Text [ portuguese ] = "O ficheiro no foi encontrado" ;
+ Text [ french ] = "Fichier introuvable" ;
+ Text [ dutch ] = "Bestand niet gevonden" ;
+ Text [ spanish ] = "No se encuentra el archivo" ;
+ Text [ danish ] = "Filen blev ikke fundet" ;
+ Text [ swedish ] = "Filen hittades inte" ;
+ Text [ finnish ] = "File not found" ;
+ Text [ english_us ] = "File not found" ;
+ Text[ chinese_simplified ] = "ûҵļ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "pliku nie znaleziono";
+ Text[ japanese ] = "̧ق͌‚܂";
+ Text[ chinese_traditional ] = "Sɮ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Bestand niet gevonden";
+ Text[ chinese_simplified ] = "ûҵļ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ϴ.";
+ Text[ turkish ] = "Dosya bulunamad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_FILE_MODE & ERRCODE_RES_MASK
+ {
+ Text = "Dateimodus falsch" ;
+ Text [ ENGLISH ] = "Bad file mode" ;
+ Text [ norwegian ] = "Bad file mode" ;
+ Text [ italian ] = "Modo file errato" ;
+ Text [ portuguese_brazilian ] = "Bad file mode" ;
+ Text [ portuguese ] = "Modo do ficheiro incorrecto" ;
+ Text [ french ] = "Mode de fichier incorrect" ;
+ Text [ dutch ] = "Foutieve bestandsmodus" ;
+ Text [ spanish ] = "Modo de archivo incorrecto" ;
+ Text [ danish ] = "Forkert filtilstand" ;
+ Text [ swedish ] = "Fel fillge" ;
+ Text [ finnish ] = "Bad file mode" ;
+ Text [ english_us ] = "Incorrect file mode" ;
+ Text[ chinese_simplified ] = "ļģʽ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Niepoprawny tryb pliku";
+ Text[ japanese ] = "̧ Ӱނ܂@@@@@@@@@@@@@";
+ Text[ chinese_traditional ] = "~ɮ׼Ҧ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Foutieve bestandsmodus";
+ Text[ chinese_simplified ] = "ļģʽ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "߸ ";
+ Text[ turkish ] = "Dosya kipi yanl";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_FILE_ALREADY_OPEN & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Datei bereits geffnet : Datei bereits geffnet */
+ Text = "Datei bereits geffnet" ;
+ Text [ ENGLISH ] = "File already open" ;
+ Text [ norwegian ] = "File already open" ;
+ Text [ italian ] = "File gi aperto" ;
+ Text [ portuguese_brazilian ] = "File already open" ;
+ Text [ portuguese ] = "O ficheiro j est aberto" ;
+ Text [ french ] = "Fichier dj ouvert" ;
+ Text [ dutch ] = "Bestand reeds geopend" ;
+ Text [ spanish ] = "El archivo ya est abierto" ;
+ Text [ danish ] = "Filen er allerede ben" ;
+ Text [ swedish ] = "Filen r redan ppen" ;
+ Text [ finnish ] = "File already open" ;
+ Text [ english_us ] = "File already open" ;
+ Text[ chinese_simplified ] = "Ѿļ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Plik ju otworzony";
+ Text[ japanese ] = "̧ق͂łɊJĂ܂";
+ Text[ chinese_traditional ] = "wg}ɮ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Bestand reeds geopend";
+ Text[ chinese_simplified ] = "Ѿļ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ̹ ֽϴ.";
+ Text[ turkish ] = "Dosya ak durumda";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_IO_ERROR & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Gerte-E/A-Fehler : Gerte-E/A-Fehler */
+ Text = "Gerte-E/A-Fehler" ;
+ Text [ ENGLISH ] = "Device I/O error" ;
+ Text [ norwegian ] = "Device I/O error" ;
+ Text [ italian ] = "Errore di I/O" ;
+ Text [ portuguese_brazilian ] = "Device I/O error" ;
+ Text [ portuguese ] = "Erro perifrico I/O" ;
+ Text [ french ] = "Erreur de priphrique E/S" ;
+ Text [ dutch ] = "Fout in-/uitvoerapparatuur" ;
+ Text [ spanish ] = "Error de dispositivo E/S" ;
+ Text [ danish ] = "I/O-fejl i enhed" ;
+ Text [ swedish ] = "Apparat I/O-fel" ;
+ Text [ finnish ] = "Device I/O error" ;
+ Text [ english_us ] = "Device I/O error" ;
+ Text[ chinese_simplified ] = "豸I/O";
+ Text[ russian ] = " /";
+ Text[ polish ] = "Bd We/Wy urzdzenia";
+ Text[ japanese ] = "ި޲ I/O װ";
+ Text[ chinese_traditional ] = "]ƵoI/O~";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Fout in-/uitvoerapparatuur";
+ Text[ chinese_simplified ] = "豸I/O";
+ Text[ greek ] = " /";
+ Text[ korean ] = "̽ I/O ";
+ Text[ turkish ] = "Cihaz I/O hatas";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_FILE_EXISTS & ERRCODE_RES_MASK
+ {
+ Text = "Datei bereits vorhanden" ;
+ Text [ ENGLISH ] = "File already exists" ;
+ Text [ norwegian ] = "File already exists" ;
+ Text [ italian ] = "File gi esistente" ;
+ Text [ portuguese_brazilian ] = "File already exists" ;
+ Text [ portuguese ] = "O ficheiro j existe" ;
+ Text [ french ] = "Fichier existant dj" ;
+ Text [ dutch ] = "Bestand bestaat reeds" ;
+ Text [ spanish ] = "El archivo ya existe" ;
+ Text [ danish ] = "Filen eksisterer allerede" ;
+ Text [ swedish ] = "Filen existerar redan" ;
+ Text [ finnish ] = "File already exists" ;
+ Text [ english_us ] = "File already exists" ;
+ Text[ chinese_simplified ] = "ļѾ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Plik ju istnieje";
+ Text[ japanese ] = "̧ق͂łɂ܂";
+ Text[ chinese_traditional ] = "ɮפwgsb";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Bestand bestaat reeds";
+ Text[ chinese_simplified ] = "ļѾ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ̹ մϴ.";
+ Text[ turkish ] = "Dosya mevcut durumda";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_RECORD_LENGTH & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Falsche Datensatzlnge : Falsche Datensatzlnge */
+ Text = "Falsche Datensatzlnge" ;
+ Text [ ENGLISH ] = "Bad record length" ;
+ Text [ norwegian ] = "Bad record length" ;
+ Text [ italian ] = "Lunghezza record di dati errata" ;
+ Text [ portuguese_brazilian ] = "Bad record length" ;
+ Text [ portuguese ] = "Comprimento do registo de dados incorrecto" ;
+ Text [ french ] = "Longueur d'enregistrement incorrecte" ;
+ Text [ dutch ] = "Foutieve record-lengte" ;
+ Text [ spanish ] = "Longitud errnea del registro de datos" ;
+ Text [ danish ] = "Forkert datapostlngde" ;
+ Text [ swedish ] = "Felaktig datapostlngd" ;
+ Text [ finnish ] = "Bad record length" ;
+ Text [ english_us ] = "Incorrect record length" ;
+ Text[ chinese_simplified ] = "Ŀȴ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Niepoprawna dugo rekordw";
+ Text[ japanese ] = "Ȃںނ̒";
+ Text[ chinese_traditional ] = "~ƶت";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Foutieve record-lengte";
+ Text[ chinese_simplified ] = "Ŀȴ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "߸ ڵ ";
+ Text[ turkish ] = "Yanl veri kmesi uzunluu";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DISK_FULL & ERRCODE_RES_MASK
+ {
+ Text = "Diskette/Festplatte voll" ;
+ Text [ ENGLISH ] = "Disk full" ;
+ Text [ norwegian ] = "Disk full" ;
+ Text [ italian ] = "Dischetto o disco rigido pieno" ;
+ Text [ portuguese_brazilian ] = "Disk full" ;
+ Text [ portuguese ] = "Disquete ou disco rgido cheios" ;
+ Text [ french ] = "Disquette/disque dur plein(e)" ;
+ Text [ dutch ] = "Diskette/harde schijf vol" ;
+ Text [ spanish ] = "Disquete o disco duro lleno" ;
+ Text [ danish ] = "Disketten/harddisken er fuld" ;
+ Text [ swedish ] = "Diskett eller hrddisk full" ;
+ Text [ finnish ] = "Disk full" ;
+ Text [ english_us ] = "Disk or hard drive full" ;
+ Text[ chinese_simplified ] = "̻Ӳ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Dyskietka/Dysk twardy s pene";
+ Text[ japanese ] = "ۯ߰ި܂ʰިς";
+ Text[ chinese_traditional ] = "nϽLκϽLw";
+ Text[ arabic ] = " / ";
+ Text[ dutch ] = "Diskette/harde schijf vol";
+ Text[ chinese_simplified ] = "̻Ӳ";
+ Text[ greek ] = "/ ";
+ Text[ korean ] = "/ ϵ ũ á";
+ Text[ turkish ] = "Disket/disk dolu";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_READ_PAST_EOF & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Lesen ber das Ende der Datei hinaus : Lesen ber das Ende der Datei hinaus */
+ Text = "Lesen ber das Ende der Datei hinaus" ;
+ Text [ ENGLISH ] = "Input past end of file" ;
+ Text [ norwegian ] = "Input past end of file" ;
+ Text [ italian ] = "Lettura oltre la fine del file" ;
+ Text [ portuguese_brazilian ] = "Input past end of file" ;
+ Text [ portuguese ] = "Ler para alm do fim de ficheiro" ;
+ Text [ french ] = "Lecture au-del de la fin du fichier" ;
+ Text [ dutch ] = "Lezen overschrijdt bestandseinde" ;
+ Text [ spanish ] = "Seguir leyendo tras el final del archivo" ;
+ Text [ danish ] = "Ls ud over filens slutning" ;
+ Text [ swedish ] = "Lsning utver filens slut" ;
+ Text [ finnish ] = "Input past end of file" ;
+ Text [ english_us ] = "Reading exceeds EOF" ;
+ Text[ chinese_simplified ] = "ȡļΧ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Odczyt przekracza koniec pliku";
+ Text[ japanese ] = "EOF ނzǂݎ";
+ Text[ chinese_traditional ] = "ŪWXɮ׽d";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Lezen overschrijdt bestandseinde";
+ Text[ chinese_simplified ] = "ȡļΧ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ʰϿ ";
+ Text[ turkish ] = "Okuma dosya sonunu ayor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_RECORD_NUMBER & ERRCODE_RES_MASK
+ {
+ Text = "Datensatznummer falsch" ;
+ Text [ ENGLISH ] = "Bad record number" ;
+ Text [ norwegian ] = "Bad record number" ;
+ Text [ italian ] = "Numero record errato" ;
+ Text [ portuguese_brazilian ] = "Bad record number" ;
+ Text [ portuguese ] = "Nmero do registo de dados incorrecto" ;
+ Text [ french ] = "Numro d'enregistrement incorrect" ;
+ Text [ dutch ] = "Foutief record-nummer" ;
+ Text [ spanish ] = "Nmero errneo de registro de datos" ;
+ Text [ danish ] = "Forkert datapostnummer" ;
+ Text [ swedish ] = "Felaktigt datapostnummer" ;
+ Text [ finnish ] = "Bad record number" ;
+ Text [ english_us ] = "Incorrect record number" ;
+ Text[ chinese_simplified ] = "Ŀ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Niepoprawna dugo rekordw";
+ Text[ japanese ] = "ںނ̔ԍ܂";
+ Text[ chinese_traditional ] = "ƶظX~";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Foutief record-nummer";
+ Text[ chinese_simplified ] = "Ŀ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "߸ ڵ ȣ";
+ Text[ turkish ] = "Veri kmesi numaras yanl";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_TOO_MANY_FILES & ERRCODE_RES_MASK
+ {
+ Text = "Zu viele Dateien" ;
+ Text [ ENGLISH ] = "Too many files" ;
+ Text [ norwegian ] = "Too many files" ;
+ Text [ italian ] = "Troppi file" ;
+ Text [ portuguese_brazilian ] = "Too many files" ;
+ Text [ portuguese ] = "Demasiados ficheiros" ;
+ Text [ french ] = "Trop de fichiers" ;
+ Text [ dutch ] = "Teveel bestanden" ;
+ Text [ spanish ] = "Demasiados archivos" ;
+ Text [ danish ] = "Der er for mange filer" ;
+ Text [ swedish ] = "Fr mnga filer" ;
+ Text [ finnish ] = "Too many files" ;
+ Text [ english_us ] = "Too many files" ;
+ Text[ chinese_simplified ] = "̫ļ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Za duo plikw";
+ Text[ japanese ] = "̧ق܂";
+ Text[ chinese_traditional ] = "Ӧhɮ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Teveel bestanden";
+ Text[ chinese_simplified ] = "̫ļ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ϵ ʹ ";
+ Text[ turkish ] = "Dosya says fazla";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_DEVICE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Gert nicht verfgbar : Gert nicht verfgbar */
+ Text = "Gert nicht verfgbar" ;
+ Text [ ENGLISH ] = "Device not available" ;
+ Text [ norwegian ] = "Device not available" ;
+ Text [ italian ] = "Apparecchio non disponibile" ;
+ Text [ portuguese_brazilian ] = "Device not available" ;
+ Text [ portuguese ] = "Aparelho no disponvel" ;
+ Text [ french ] = "Priphrique indisponible" ;
+ Text [ dutch ] = "Apparatuur niet beschikbaar" ;
+ Text [ spanish ] = "El dispositivo no est disponible" ;
+ Text [ danish ] = "Enheden er ikke tilgngelig" ;
+ Text [ swedish ] = "Enhet ej tillgnglig" ;
+ Text [ finnish ] = "Device not available" ;
+ Text [ english_us ] = "Device not available" ;
+ Text[ chinese_simplified ] = "豸";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Urzdzenie niedostpne";
+ Text[ japanese ] = "ި޲͂܂";
+ Text[ chinese_traditional ] = "]Ƥsb";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Apparatuur niet beschikbaar";
+ Text[ chinese_simplified ] = "豸";
+ Text[ greek ] = " ";
+ Text[ korean ] = "̽ Ұ";
+ Text[ turkish ] = "Cihaz kullanlabilir durumda deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_ACCESS_DENIED & ERRCODE_RES_MASK
+ {
+ Text = "Zugriff verweigert" ;
+ Text [ ENGLISH ] = "Permission denied" ;
+ Text [ norwegian ] = "Permission denied" ;
+ Text [ italian ] = "Accesso negato" ;
+ Text [ portuguese_brazilian ] = "Permission denied" ;
+ Text [ portuguese ] = "Acesso recusado" ;
+ Text [ french ] = "Accs refus" ;
+ Text [ dutch ] = "Toegang geweigerd" ;
+ Text [ spanish ] = "Acceso denegado" ;
+ Text [ danish ] = "Adgang ngtet" ;
+ Text [ swedish ] = "tkomst nekad" ;
+ Text [ finnish ] = "Permission denied" ;
+ Text [ english_us ] = "Access denied" ;
+ Text[ chinese_simplified ] = "ܾȡ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Dostp zabroniony";
+ Text[ japanese ] = "ł܂";
+ Text[ chinese_traditional ] = "ڵŪ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Toegang geweigerd";
+ Text[ chinese_simplified ] = "ܾȡ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ź";
+ Text[ turkish ] = "Eriim engellendi";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NOT_READY & ERRCODE_RES_MASK
+ {
+ Text = "Diskette nicht bereit" ;
+ Text [ ENGLISH ] = "Disk not ready" ;
+ Text [ norwegian ] = "Disk not ready" ;
+ Text [ italian ] = "Dischetto non pronto" ;
+ Text [ portuguese_brazilian ] = "Disk not ready" ;
+ Text [ portuguese ] = "A disquete no est pronta" ;
+ Text [ french ] = "La disquette n'est pas prte" ;
+ Text [ dutch ] = "Diskette niet bereid" ;
+ Text [ spanish ] = "El disquete no est preparado" ;
+ Text [ danish ] = "Disketten er ikke klar" ;
+ Text [ swedish ] = "Disketten r inte beredd" ;
+ Text [ finnish ] = "Disk not ready" ;
+ Text [ english_us ] = "Disk not ready" ;
+ Text[ chinese_simplified ] = "̻û׼";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Dyskietka nie gotowa";
+ Text[ japanese ] = "ި͗pӂłĂ܂";
+ Text[ chinese_traditional ] = "nϽL٨SdzƦn";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Diskette niet bereid";
+ Text[ chinese_simplified ] = "̻û׼";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ũ غ ʾҽϴ.";
+ Text[ turkish ] = "Disket hazr deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NOT_IMPLEMENTED & ERRCODE_RES_MASK
+ {
+ Text = "Nicht implementiert" ;
+ Text [ ENGLISH ] = "Feature not implemented" ;
+ Text [ norwegian ] = "Feature not implemented" ;
+ Text [ italian ] = "Non implementato" ;
+ Text [ portuguese_brazilian ] = "Feature not implemented" ;
+ Text [ portuguese ] = "No implementado" ;
+ Text [ french ] = "Non implant" ;
+ Text [ dutch ] = "Niet gemplementeerd" ;
+ Text [ spanish ] = "No implementado" ;
+ Text [ danish ] = "Ikke implementeret" ;
+ Text [ swedish ] = "Ej implementerad" ;
+ Text [ finnish ] = "Feature not implemented" ;
+ Text [ english_us ] = "Not implemented" ;
+ Text[ chinese_simplified ] = "δʵʩ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nie zaimplementowane";
+ Text[ japanese ] = "Ă܂";
+ Text[ chinese_traditional ] = "|I";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Niet gemplementeerd";
+ Text[ chinese_simplified ] = "δʵʩ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ʾ";
+ Text[ turkish ] = "Uygulanmad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DIFFERENT_DRIVE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Umbenennen auf verschiedenen Laufwerken nicht mglich : Umbenennen auf verschiedenen Laufwerken nicht mglich */
+ Text = "Umbenennen auf verschiedenen Laufwerken nicht mglich" ;
+ Text [ ENGLISH ] = "No rename with different drive" ;
+ Text [ norwegian ] = "No rename with different drive" ;
+ Text [ italian ] = "Impossibile rinominare su drive diversi" ;
+ Text [ portuguese_brazilian ] = "No rename with different drive" ;
+ Text [ portuguese ] = "Impossvel mudar nome em vrias unidades" ;
+ Text [ french ] = "Impossible de renommer sur des lecteurs diffrents" ;
+ Text [ dutch ] = "Namen wijzigen op verschillende stations niet mogelijk" ;
+ Text [ spanish ] = "No se puede cambiar nombre en distintas unidades" ;
+ Text [ danish ] = "Omdbning p forskellige drev er ikke mulig" ;
+ Text [ swedish ] = "Omjligt att byta namn p olika enheter" ;
+ Text [ finnish ] = "No rename with different drive" ;
+ Text [ english_us ] = "Renaming on different drives impossible" ;
+ Text[ chinese_simplified ] = "޷ɲͬ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Zmiana nazwy na rnych dyskach jest niemoliwa";
+ Text[ japanese ] = "ײނ̖O̕ύX͂ł܂";
+ Text[ chinese_traditional ] = "LksRWPϽL";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Namen wijzigen op verschillende stations niet mogelijk";
+ Text[ chinese_simplified ] = "޷ɲͬ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ٸ ̹ ο ̸ Ұմϴ.";
+ Text[ turkish ] = "Farkl srclerde yeniden adlandrma yaplamaz";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_ACCESS_ERROR & ERRCODE_RES_MASK
+ {
+ Text = "Pfad/Datei-Zugriffsfehler" ;
+ Text [ ENGLISH ] = "Path/File access error" ;
+ Text [ norwegian ] = "Path/File access error" ;
+ Text [ italian ] = "Errore di accesso al percorso/file" ;
+ Text [ portuguese_brazilian ] = "Path/File access error" ;
+ Text [ portuguese ] = "Atalho/Erro de acesso ao ficheiro" ;
+ Text [ french ] = "Erreur d'accs au chemin/fichier" ;
+ Text [ dutch ] = "Fout bij toegang op pad/bestand" ;
+ Text [ spanish ] = "Error de acceso a la ruta o al archivo" ;
+ Text [ danish ] = "Sti/fil adgangsfejl" ;
+ Text [ swedish ] = "Skvg/fil tkomstfel" ;
+ Text [ finnish ] = "Path/File access error" ;
+ Text [ english_us ] = "Path/File access error" ;
+ Text[ chinese_simplified ] = "ȡ·/ļʱ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Bd dostpu do cieki/pliku";
+ Text[ japanese ] = "߽܂̧قւ̱װ";
+ Text[ chinese_traditional ] = "Ū|/ɮ׮ɵoͿ~";
+ Text[ arabic ] = " /";
+ Text[ dutch ] = "Fout bij toegang op pad/bestand";
+ Text[ chinese_simplified ] = "ȡ·/ļʱ";
+ Text[ greek ] = " /";
+ Text[ korean ] = "н/ ";
+ Text[ turkish ] = "Veri yolu/eriim hatas";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_PATH_NOT_FOUND & ERRCODE_RES_MASK
+ {
+ Text = "Pfad nicht gefunden" ;
+ Text [ ENGLISH ] = "Path not found" ;
+ Text [ norwegian ] = "Path not found" ;
+ Text [ italian ] = "Percorso non trovato" ;
+ Text [ portuguese_brazilian ] = "Path not found" ;
+ Text [ portuguese ] = "Atalho no encontrado" ;
+ Text [ french ] = "Chemin introuvable" ;
+ Text [ dutch ] = "Pad niet gevonden" ;
+ Text [ spanish ] = "No se encontr la ruta" ;
+ Text [ danish ] = "Stien blev ikke fundet" ;
+ Text [ swedish ] = "Skvgen hittades inte" ;
+ Text [ finnish ] = "Path not found" ;
+ Text [ english_us ] = "Path not found" ;
+ Text[ chinese_simplified ] = "ûҵ·";
+ Text[ russian ] = " ";
+ Text[ polish ] = "cieka nie zostaa znaleziona";
+ Text[ japanese ] = "߽‚܂";
+ Text[ chinese_traditional ] = "S|";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Pad niet gevonden";
+ Text[ chinese_simplified ] = "ûҵ·";
+ Text[ greek ] = " ";
+ Text[ korean ] = "н ߰ߵ ʾҽϴ.";
+ Text[ turkish ] = "Veri yolu bulunamad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_OBJECT & ERRCODE_RES_MASK
+ {
+ Text = "Objektvariable nicht belegt" ;
+ Text [ ENGLISH ] = "Object variable not set" ;
+ Text [ norwegian ] = "Object variable not set" ;
+ Text [ italian ] = "Variabile dell'oggetto non impostata" ;
+ Text [ portuguese_brazilian ] = "Object variable not set" ;
+ Text [ portuguese ] = "Varivel do objecto no configurada" ;
+ Text [ french ] = "Variable d'objet non configure" ;
+ Text [ dutch ] = "Objectvariabele niet gereserveerd" ;
+ Text [ spanish ] = "La variable del objeto no se ha establecido" ;
+ Text [ danish ] = "Objektvariablen er ikke optaget" ;
+ Text [ swedish ] = "Objektvariablerna inte bestmda" ;
+ Text [ finnish ] = "Object variable not set" ;
+ Text [ english_us ] = "Object variable not set" ;
+ Text[ chinese_simplified ] = "û趨";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nie osadzono zmiennej obiektu";
+ Text[ japanese ] = "޼ުĕϐ͐ݒłĂ܂";
+ Text[ chinese_traditional ] = "٨S]wܶq";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Objectvariabele niet gereserveerd";
+ Text[ chinese_simplified ] = "û趨";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ü ʾҽϴ.";
+ Text[ turkish ] = "Nesne deikeni belirlenmedi";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_PATTERN & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Zeichenfolgenmuster unzulssig : Zeichenfolgenmuster unzulssig */
+ Text = "Zeichenfolgenmuster unzulssig" ;
+ Text [ ENGLISH ] = "Invalid pattern string" ;
+ Text [ norwegian ] = "Invalid pattern string" ;
+ Text [ italian ] = "Sequenza di caratteri non valida" ;
+ Text [ portuguese_brazilian ] = "Invalid pattern string" ;
+ Text [ portuguese ] = "Sequncia de caracteres no vlida" ;
+ Text [ french ] = "chantillon de chane de caractres incorrect" ;
+ Text [ dutch ] = "Ontoelaatbare tekenreeks" ;
+ Text [ spanish ] = "Secuencia de caracteres no vlida" ;
+ Text [ danish ] = "Ugyldigt strengmnster" ;
+ Text [ swedish ] = "Ogiltig mnsterstring" ;
+ Text [ finnish ] = "Invalid pattern string" ;
+ Text [ english_us ] = "Invalid string pattern" ;
+ Text[ chinese_simplified ] = "Чִģʽ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nieprawidowy cig wzoru";
+ Text[ japanese ] = "݂͋‚܂";
+ Text[ chinese_traditional ] = "LĪrҦ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Ontoelaatbare tekenreeks";
+ Text[ chinese_simplified ] = "Чִģʽ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ȿ ڿ ";
+ Text[ turkish ] = "Dizilim rnei geerli deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SBERR_IS_NULL & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Verwendung von Null unzulssig : Verwendung von Null unzulssig */
+ Text = "Verwendung von Null unzulssig" ;
+ Text [ ENGLISH ] = "Invalid use of Null" ;
+ Text [ norwegian ] = "Invalid use of Null" ;
+ Text [ italian ] = "Uso dello zero non ammesso" ;
+ Text [ portuguese_brazilian ] = "Invalid use of Null" ;
+ Text [ portuguese ] = "Interdito o uso do zero" ;
+ Text [ french ] = "Utilisation du zro interdite" ;
+ Text [ dutch ] = "Ongeldig gebruik van nul" ;
+ Text [ spanish ] = "No se admite el uso del cero" ;
+ Text [ danish ] = "Brug af nul er ikke tilladt" ;
+ Text [ swedish ] = "Anvndning av noll r ej tilltet" ;
+ Text [ finnish ] = "Invalid use of Null" ;
+ Text [ english_us ] = "Use of zero not permitted" ;
+ Text[ chinese_simplified ] = "ʹֵ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Uywanie zera niedopuszczalne";
+ Text[ japanese ] = "ۂ̎gp͋‚܂";
+ Text[ chinese_traditional ] = "\\եιs";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Ongeldig gebruik van nul";
+ Text[ chinese_simplified ] = "ʹֵ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "0 ʾҽϴ.";
+ Text[ turkish ] = "Sfr kullanm geerli deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_ERROR & ERRCODE_RES_MASK
+ {
+ Text = "DDE-Fehler" ;
+ Text [ ENGLISH ] = "DDE Error" ;
+ Text [ norwegian ] = "DDE Error" ;
+ Text [ italian ] = "Errore DDE" ;
+ Text [ portuguese_brazilian ] = "DDE Error" ;
+ Text [ portuguese ] = "Erro DDE" ;
+ Text [ french ] = "Erreur DDE" ;
+ Text [ dutch ] = "DDE-fout" ;
+ Text [ spanish ] = "Error de DDE" ;
+ Text [ danish ] = "DDE-fejl" ;
+ Text [ swedish ] = "DDE-fel" ;
+ Text [ finnish ] = "DDE Error" ;
+ Text [ english_us ] = "DDE Error" ;
+ Text[ chinese_simplified ] = "DDE ";
+ Text[ russian ] = " DDE";
+ Text[ polish ] = "Bd DDE";
+ Text[ japanese ] = "DDE̴װ";
+ Text[ chinese_traditional ] = "DDE ~";
+ Text[ arabic ] = "DDE ";
+ Text[ dutch ] = "DDE-fout";
+ Text[ chinese_simplified ] = "DDE ";
+ Text[ greek ] = " DDE";
+ Text[ korean ] = "DDE ";
+ Text[ turkish ] = "DDE hatas";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_WAITINGACK & ERRCODE_RES_MASK
+ {
+ Text = "Warten auf Antwort in DDE-Verbindung" ;
+ Text [ ENGLISH ] = "Awaiting response in DDE-Conversation" ;
+ Text [ norwegian ] = "Awaiting response in DDE-Conversation" ;
+ Text [ italian ] = "In attesa di risposta nel collegamento DDE" ;
+ Text [ portuguese_brazilian ] = "Awaiting response in DDE-Conversation" ;
+ Text [ portuguese ] = "Esperando resposta ligao DDE" ;
+ Text [ french ] = "Attente de rponse dans une connexion DDE" ;
+ Text [ dutch ] = "Wachten op antwoord in DDE-verbinding" ;
+ Text [ spanish ] = "Esperando respuesta en la conexin DDE" ;
+ Text [ danish ] = "Venter p svar til DDE-forbindelsen" ;
+ Text [ swedish ] = "Vntar p svar till DDE-frbindelsen" ;
+ Text [ finnish ] = "Awaiting response in DDE-Conversation" ;
+ Text [ english_us ] = "Awaiting response to DDE connection" ;
+ Text[ chinese_simplified ] = " DDE ʱȺ";
+ Text[ russian ] = " DDE";
+ Text[ polish ] = "Czekanie na odpowied w poczeniu DDE";
+ Text[ japanese ] = "DDEڑɂ鉞҂";
+ Text[ chinese_traditional ] = "b DDE sɵԵ_";
+ Text[ arabic ] = "DDE ";
+ Text[ dutch ] = "Wachten op antwoord in DDE-verbinding";
+ Text[ chinese_simplified ] = " DDE ʱȺ";
+ Text[ greek ] = " DDE";
+ Text[ korean ] = "DDE ";
+ Text[ turkish ] = "DDE balantsnda yant bekleniyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_OUTOFCHANNELS & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Keine freien DDE-Kanle : Keine freien DDE-Kanle */
+ Text = "Keine freien DDE-Kanle" ;
+ Text [ ENGLISH ] = "No more DDE channels" ;
+ Text [ norwegian ] = "No more DDE channels" ;
+ Text [ italian ] = "Nessun canale DDE libero" ;
+ Text [ portuguese_brazilian ] = "No more DDE channels" ;
+ Text [ portuguese ] = "Nenhum canal DDE livre" ;
+ Text [ french ] = "Aucun canal DDE libre" ;
+ Text [ dutch ] = "Geen vrije DDE-kanalen" ;
+ Text [ spanish ] = "No hay canales DDE libres" ;
+ Text [ danish ] = "Ingen bne DDE-kanaler" ;
+ Text [ swedish ] = "Inga fria DDE-kanaler" ;
+ Text [ finnish ] = "No more DDE channels" ;
+ Text [ english_us ] = "No DDE channels available" ;
+ Text[ chinese_simplified ] = "ûпõ DDE-ŵ";
+ Text[ russian ] = " DDE ";
+ Text[ polish ] = "Nie ma wolnych kanaw DDE";
+ Text[ japanese ] = "gDDEق܂";
+ Text[ chinese_traditional ] = "S} DDE-HD";
+ Text[ arabic ] = "DDE ";
+ Text[ dutch ] = "Geen vrije DDE-kanalen";
+ Text[ chinese_simplified ] = "ûпõ DDE-ŵ";
+ Text[ greek ] = " DDE";
+ Text[ korean ] = "DDE ä Ұ";
+ Text[ turkish ] = "Bo DDE kanallar yok";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_NO_RESPONSE & ERRCODE_RES_MASK
+ {
+ Text = "Keine Applikation anwortet auf DDE-Verbindungswunsch" ;
+ Text [ ENGLISH ] = "No application responded to DDE initiate" ;
+ Text [ norwegian ] = "No application responded to DDE initiate" ;
+ Text [ italian ] = "Nessuna applicazione risponde al tentativo di collegamento DDE" ;
+ Text [ portuguese_brazilian ] = "No application responded to DDE initiate" ;
+ Text [ portuguese ] = "O estabelecimento da ligao DDE no obteve resposta de nenhuma aplicao" ;
+ Text [ french ] = "Aucune application ne ragit la tentative de connexion DDE" ;
+ Text [ dutch ] = "Geen enkele applicatie antwoordt op DDE-verbindingsoproep" ;
+ Text [ spanish ] = "No responde ninguna aplicacin a la conexin DDE deseada" ;
+ Text [ danish ] = "Ingen applikation svarer p DDE-forbindelsesinitialiseringen" ;
+ Text [ swedish ] = "Ingen applikation svarar p DDE-frbindelsinitieringen" ;
+ Text [ finnish ] = "No application responded to DDE initiate" ;
+ Text [ english_us ] = "No application responded to DDE connect initiation" ;
+ Text[ chinese_simplified ] = "ûκӦóӦ DDE ";
+ Text[ russian ] = " DDE";
+ Text[ polish ] = "Za duo aplikacji odpowiada na inicjacj poczenia DDE";
+ Text[ japanese ] = "DDEڑ]ɉع݂܂";
+ Text[ chinese_traditional ] = "Sε{^ DDE sШD";
+ Text[ arabic ] = " DDE";
+ Text[ dutch ] = "Geen enkele applicatie antwoordt op DDE-verbindingsoproep";
+ Text[ chinese_simplified ] = "ûκӦóӦ DDE ";
+ Text[ greek ] = " DDE";
+ Text[ korean ] = "DDE ʱȭ ϴ α׷ ";
+ Text[ turkish ] = "Hibir uygulama DDE balant talebine yant vermiyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_MULT_RESPONSES & ERRCODE_RES_MASK
+ {
+ Text = "Zu viele Applikationen antworten auf DDE-Verbindungswunsch" ;
+ Text [ ENGLISH ] = "Multiple applications responded to DDE initiate" ;
+ Text [ norwegian ] = "Multiple applications responded to DDE initiate" ;
+ Text [ italian ] = "Troppe applicazioni rispondono al collegamento DDE desiderato" ;
+ Text [ portuguese_brazilian ] = "Multiple applications responded to DDE initiate" ;
+ Text [ portuguese ] = "Demasiadas aplicaes respondem tentativa de ligao DDE" ;
+ Text [ french ] = "Trop d'applications rpondent la tentative de connexion DDE" ;
+ Text [ dutch ] = "Teveel applicatiex antwoorden op de DDE-verbindingsoproep" ;
+ Text [ spanish ] = "Demasiadas aplicaciones responden a la conexin deseada DDE" ;
+ Text [ danish ] = "For mange applikationer svarer p DDE-forbindelsesinitialiseringen" ;
+ Text [ swedish ] = "Alltfr mnga applikationer svarar p DDE-frbindelseinitieringen" ;
+ Text [ finnish ] = "Multiple applications responded to DDE initiate" ;
+ Text [ english_us ] = "Too many applications responded to DDE connect initiation" ;
+ Text[ chinese_simplified ] = "̫ӦóӦ DDE ";
+ Text[ russian ] = " DDE";
+ Text[ polish ] = "Za duo aplikacji odpowiada na inicjacj poczenia DDE";
+ Text[ japanese ] = "DDEڑ]ɉع݂܂";
+ Text[ chinese_traditional ] = "Ӧhε{^ DDE sШD";
+ Text[ arabic ] = " DDE";
+ Text[ dutch ] = "Teveel applicatiex antwoorden op de DDE-verbindingsoproep";
+ Text[ chinese_simplified ] = "̫ӦóӦ DDE ";
+ Text[ greek ] = " DDE";
+ Text[ korean ] = "DDE ʱȭ ϴ α׷ ʹ ";
+ Text[ turkish ] = "DDE balant talebine ok fazla uygulama yant veriyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_CHANNEL_LOCKED & ERRCODE_RES_MASK
+ {
+ Text = "DDE-Kanal gesperrt" ;
+ Text [ ENGLISH ] = "DDE channel locked" ;
+ Text [ norwegian ] = "DDE channel locked" ;
+ Text [ italian ] = "Canale DDE bloccato" ;
+ Text [ portuguese_brazilian ] = "DDE channel locked" ;
+ Text [ portuguese ] = "Canal DDE bloqueado" ;
+ Text [ french ] = "Canal DDE verrouill" ;
+ Text [ dutch ] = "DDE-kanaal geblokkeerd" ;
+ Text [ spanish ] = "Canal DDE bloqueado" ;
+ Text [ danish ] = "DDE-kanalen er lst" ;
+ Text [ swedish ] = "DDE-kanalen r sprrad" ;
+ Text [ finnish ] = "DDE channel locked" ;
+ Text [ english_us ] = "DDE channel locked" ;
+ Text[ chinese_simplified ] = "DDE ŵѾ";
+ Text[ russian ] = " DDE ";
+ Text[ polish ] = "Kana DDE jest zablokowany";
+ Text[ japanese ] = "DDEقۯĂ܂";
+ Text[ chinese_traditional ] = "DDE HDwgQw";
+ Text[ arabic ] = ".DDE ";
+ Text[ dutch ] = "DDE-kanaal geblokkeerd";
+ Text[ chinese_simplified ] = "DDE ŵѾ";
+ Text[ greek ] = " DDE ";
+ Text[ korean ] = "DDE ä ";
+ Text[ turkish ] = "DDE kanal kilitli";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_NOTPROCESSED & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Fremdapplikation kann DDE-Operation nicht ausfhren : Fremdapplikation kann DDE-Operation nicht ausfhren */
+ Text = "Fremdapplikation kann DDE-Operation nicht ausfhren" ;
+ Text [ ENGLISH ] = "Foreign application won't perform DDE operation" ;
+ Text [ norwegian ] = "Foreign application won't perform DDE operation" ;
+ Text [ italian ] = "L'applicazione esterna non pu eseguire l'operazione DDE" ;
+ Text [ portuguese_brazilian ] = "Foreign application won't perform DDE operation" ;
+ Text [ portuguese ] = "A aplicao externa no pode executar a operao DDE" ;
+ Text [ french ] = "L'application externe ne peut pas excuter l'opration DDE" ;
+ Text [ dutch ] = "Externe applicatie kan DDE niet uitvoeren" ;
+ Text [ spanish ] = "Una aplicacin externa no puede realizar la operacin DDE" ;
+ Text [ danish ] = "Den eksterne applikation kan ikke udfre DDE-operationen" ;
+ Text [ swedish ] = "Den externa applikationen kan inte utfra DDE-operationen" ;
+ Text [ finnish ] = "Foreign application won't perform DDE operation" ;
+ Text [ english_us ] = "External application cannot execute DDE operation" ;
+ Text[ chinese_simplified ] = "ⲿӦó޷ִ DDE ";
+ Text[ russian ] = " DDE";
+ Text[ polish ] = "Obca aplikacja nie moe wykona operacjiDDE";
+ Text[ japanese ] = "Oع݂DDE̵ڰ݂sł܂";
+ Text[ chinese_traditional ] = "~ε{ǵLk DDE B";
+ Text[ arabic ] = "DDE ";
+ Text[ dutch ] = "Externe applicatie kan DDE niet uitvoeren";
+ Text[ chinese_simplified ] = "ⲿӦó޷ִ DDE ";
+ Text[ greek ] = " DDE";
+ Text[ korean ] = "ܺ α׷ DDE ۵ ų ϴ.";
+ Text[ turkish ] = "Harici uygulama DDE ilemini yrtemiyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_TIMEOUT & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Zeitberschreitung whrend des Wartens auf DDE-Antwort : Zeitberschreitung whrend des Wartens auf DDE-Antwort */
+ Text = "Zeitberschreitung whrend des Wartens auf DDE-Antwort" ;
+ Text [ ENGLISH ] = "Timeout while waiting for DDE response" ;
+ Text [ norwegian ] = "Timeout while waiting for DDE response" ;
+ Text [ italian ] = "Tempo d'attesa per la rispota DDE oltrepassato" ;
+ Text [ portuguese_brazilian ] = "Timeout while waiting for DDE response" ;
+ Text [ portuguese ] = "Ultrapassado tempo de espera pela resposta DDE" ;
+ Text [ french ] = "Timeout pendant l'attente de la rponse DDE" ;
+ Text [ dutch ] = "Tijdoverschrijding tijdens wachten op DDE-antwoord" ;
+ Text [ spanish ] = "Se ha excedido el tiempo de espera por una respuesta DDE" ;
+ Text [ danish ] = "Timeout mens der blev ventet p DDE-svar" ;
+ Text [ swedish ] = "Tiden har gtt ut vid vntandet p DDE-svar" ;
+ Text [ finnish ] = "Timeout while waiting for DDE response" ;
+ Text [ english_us ] = "Timeout while waiting for DDE response" ;
+ Text[ chinese_simplified ] = "Ⱥ DDE Ӧʱ";
+ Text[ russian ] = " DDE";
+ Text[ polish ] = "Przekroczenie limitu czasu podczas czekania na odpowied DDE";
+ Text[ japanese ] = "DDẺ҂̊ԂɎԒ";
+ Text[ chinese_traditional ] = " DDE ^WLɭ";
+ Text[ arabic ] = "DDE ";
+ Text[ dutch ] = "Tijdoverschrijding tijdens wachten op DDE-antwoord";
+ Text[ chinese_simplified ] = "Ⱥ DDE Ӧʱ";
+ Text[ greek ] = " DDE";
+ Text[ korean ] = "DDE ٸ ŸӾƿ";
+ Text[ turkish ] = "DDE yantn beklemede zaman am";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_USER_INTERRUPT & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Benutzer drckte ESCAPE whrend der DDE-Operation : Benutzer drckte ESCAPE whrend der DDE-Operation */
+ Text = "Benutzer drckte ESCAPE whrend der DDE-Operation" ;
+ Text [ ENGLISH ] = "User pressed Escape during DDE operation" ;
+ Text [ norwegian ] = "User pressed Escape during DDE operation" ;
+ Text [ italian ] = "L'utente ha premuto ESC durante l'operazione DDE" ;
+ Text [ portuguese_brazilian ] = "User pressed Escape during DDE operation" ;
+ Text [ portuguese ] = "O utilizador premiu ESCAPE durante a operao DDE" ;
+ Text [ french ] = "L'utilisateur a appuy sur CHAP pendant l'opration DDE" ;
+ Text [ dutch ] = "Gebruiker drukte Escape tijdens uitvoering DDE" ;
+ Text [ spanish ] = "El usuario presion la tecla ESC durante la operacin DDE" ;
+ Text [ danish ] = "Brugeren trykkede p ESCAPE under DDE-operationen" ;
+ Text [ swedish ] = "Anvndaren tryckte p ESCAPE under DDE-operationen" ;
+ Text [ finnish ] = "User pressed Escape during DDE operation" ;
+ Text [ english_us ] = "User pressed ESCAPE during DDE operation." ;
+ Text[ chinese_simplified ] = "ִ DDE ʹ߰ ESCAPE ";
+ Text[ russian ] = " ESCAPE DDE";
+ Text[ polish ] = "Uytkownik uy przycisku ESCAPE podczas operacji DDE";
+ Text[ japanese ] = "DDE̵ڰ݂̍Œ հްESCAPE݂܂";
+ Text[ language_user1 ] = " ";
+ Text[ chinese_traditional ] = "b DDE BL{ϥΪ̫F ESCAPE ";
+ Text[ arabic ] = " DDE";
+ Text[ dutch ] = "Gebruiker drukte Escape tijdens uitvoering DDE";
+ Text[ chinese_simplified ] = "ִ DDE ʹ߰ ESCAPE ";
+ Text[ greek ] = " ESCAPE DDE.";
+ Text[ korean ] = "DDE ۵̿ Escape .";
+ Text[ turkish ] = "DDE ilemi srasnda ESCAPE tuuna basld";
+ };
+ String SbERR_DDE_BUSY & ERRCODE_RES_MASK
+ {
+ Text = "Fremdapplikation ist nicht bereit" ;
+ Text [ ENGLISH ] = "Destination application is busy" ;
+ Text [ norwegian ] = "Destination application is busy" ;
+ Text [ italian ] = "L'applicazione esterna non pronta" ;
+ Text [ portuguese_brazilian ] = "Destination application is busy" ;
+ Text [ portuguese ] = "A aplicao externa est ocupada" ;
+ Text [ french ] = "L'application externe est occupe" ;
+ Text [ dutch ] = "Doelapplicatie is niet bereid" ;
+ Text [ spanish ] = "La aplicacin externa no est lista" ;
+ Text [ danish ] = "Den eksterne applikation er ikke klar" ;
+ Text [ swedish ] = "Extern applikation upptagen" ;
+ Text [ finnish ] = "Destination application is busy" ;
+ Text [ english_us ] = "External application busy" ;
+ Text[ chinese_simplified ] = "ⲿӦóæµ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Obca aplikacja nie jest gotowa";
+ Text[ japanese ] = "Oع݂޼ިԂł";
+ Text[ chinese_traditional ] = "~ε{L";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Doelapplicatie is niet bereid";
+ Text[ chinese_simplified ] = "ⲿӦóæµ";
+ Text[ greek ] = " .";
+ Text[ korean ] = " α׷ غ ȵǾϴ.";
+ Text[ turkish ] = "Harici uygulama hazr deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_NO_DATA & ERRCODE_RES_MASK
+ {
+ Text = "DDE-Operation ohne Daten" ;
+ Text [ ENGLISH ] = "Data not provided in DDE operation" ;
+ Text [ norwegian ] = "Data not provided in DDE operation" ;
+ Text [ italian ] = "Operazione DDE senza dati" ;
+ Text [ portuguese_brazilian ] = "Data not provided in DDE operation" ;
+ Text [ portuguese ] = "A operao DDE no tem dados" ;
+ Text [ french ] = "Donnes non fournies dans l'opration DDE" ;
+ Text [ dutch ] = "DDE-operatie zonder gegevens" ;
+ Text [ spanish ] = "Operacin DDE sin datos" ;
+ Text [ danish ] = "DDE-operation uden data" ;
+ Text [ swedish ] = "DDE-operation utan data" ;
+ Text [ finnish ] = "Data not provided in DDE operation" ;
+ Text [ english_us ] = "DDE operation without data" ;
+ Text[ chinese_simplified ] = "ûݵ DDE ";
+ Text[ russian ] = " DDE ";
+ Text[ polish ] = "Operacja DDE bez danych";
+ Text[ japanese ] = "ްȂDDEڰ";
+ Text[ chinese_traditional ] = "Sƪ DDE B";
+ Text[ arabic ] = " DDE ";
+ Text[ dutch ] = "DDE-operatie zonder gegevens";
+ Text[ chinese_simplified ] = "ûݵ DDE ";
+ Text[ greek ] = " DDE ";
+ Text[ korean ] = " DDE ۵";
+ Text[ turkish ] = "Verisiz DDE ilemi";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_WRONG_DATA_FORMAT & ERRCODE_RES_MASK
+ {
+ Text = "Daten sind im falschen Format" ;
+ Text [ ENGLISH ] = "Data in wrong format" ;
+ Text [ norwegian ] = "Data in wrong format" ;
+ Text [ italian ] = "I dati hanno un formato errato" ;
+ Text [ portuguese_brazilian ] = "Data in wrong format" ;
+ Text [ portuguese ] = "Formato dos dados incorrecto" ;
+ Text [ french ] = "Le format des donnes est incorrect" ;
+ Text [ dutch ] = "Gegevens hebben foutief formaat" ;
+ Text [ spanish ] = "Los datos estn en un formato falso" ;
+ Text [ danish ] = "Data er i forkert format" ;
+ Text [ swedish ] = "Data har fel format" ;
+ Text [ finnish ] = "Data in wrong format" ;
+ Text [ english_us ] = "Data are in wrong format" ;
+ Text[ chinese_simplified ] = "ݸʽ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Pliki s le sformatowane";
+ Text[ japanese ] = "ް͏܂";
+ Text[ chinese_traditional ] = "Ʈ榡~";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Gegevens hebben foutief formaat";
+ Text[ chinese_simplified ] = "ݸʽ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "߸ ";
+ Text[ turkish ] = "Verilerin format yanl";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_PARTNER_QUIT & ERRCODE_RES_MASK
+ {
+ Text = "Fremdapplikation ist beendet worden" ;
+ Text [ ENGLISH ] = "Foreign application quit" ;
+ Text [ norwegian ] = "Foreign application quit" ;
+ Text [ italian ] = "L'applicazione esterna terminata" ;
+ Text [ portuguese_brazilian ] = "Foreign application quit" ;
+ Text [ portuguese ] = "Cancelada a aplicao externa" ;
+ Text [ french ] = "L'application externe a t quitte" ;
+ Text [ dutch ] = "Externe applicatie werd beindigd" ;
+ Text [ spanish ] = "La aplicacin externa se ha cancelado" ;
+ Text [ danish ] = "Den eksterne applikation er blevet afsluttet" ;
+ Text [ swedish ] = "Den externa applikationen r avslutad" ;
+ Text [ finnish ] = "Foreign application quit" ;
+ Text [ english_us ] = "External application has been terminated" ;
+ Text[ chinese_simplified ] = "ⲿӦóѾ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Obca aplikacja zostaa zakoczona";
+ Text[ japanese ] = "Oع݂͏IĂ܂";
+ Text[ chinese_traditional ] = "~ε{wg";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Externe applicatie werd beindigd";
+ Text[ chinese_simplified ] = "ⲿӦóѾ";
+ Text[ greek ] = " .";
+ Text[ korean ] = "ܺ α׷ ŵǾϴ.";
+ Text[ turkish ] = "Harici uygulamadan kld";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_CONV_CLOSED & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? DDE-Verbindung ist unterbrochen oder gendert worden : DDE-Verbindung ist unterbrochen oder gendert worden */
+ Text = "DDE-Verbindung ist unterbrochen oder gendert worden" ;
+ Text [ ENGLISH ] = "DDE conversation closed or changed" ;
+ Text [ norwegian ] = "DDE conversation closed or changed" ;
+ Text [ italian ] = "Collegamento DEE interrotto o modificato" ;
+ Text [ portuguese_brazilian ] = "DDE conversation closed or changed" ;
+ Text [ portuguese ] = "A ligao DDE foi interrompida ou modificada" ;
+ Text [ french ] = "La connexion DDE a t interrompue ou modifie" ;
+ Text [ dutch ] = "DDE-verbinding verbroken of veranderd" ;
+ Text [ spanish ] = "La conexin DDE se ha interrumpido o modificado" ;
+ Text [ danish ] = "DDE-forbindelsen er blevet afbrudt eller modificeret" ;
+ Text [ swedish ] = "DDE-frbindelsen r avbruten eller frndrad" ;
+ Text [ finnish ] = "DDE conversation closed or changed" ;
+ Text [ english_us ] = "DDE connection interrupted or modified" ;
+ Text[ chinese_simplified ] = "DDEѾжϻѾ";
+ Text[ russian ] = " DDE ";
+ Text[ polish ] = "Poczenie DDE zostao przerwane lub zmodyfikowane.";
+ Text[ japanese ] = "DDEڑf܂͕ύXĂ܂";
+ Text[ chinese_traditional ] = "DDEswg_Ϊ̤wgܧ";
+ Text[ arabic ] = "DDE ";
+ Text[ dutch ] = "DDE-verbinding verbroken of veranderd";
+ Text[ chinese_simplified ] = "DDEѾжϻѾ";
+ Text[ greek ] = " DDE ";
+ Text[ korean ] = "DDE ͷƮǰų Ǿϴ.";
+ Text[ turkish ] = "DDE balants kesildi ya da deitirildi";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_NO_CHANNEL & ERRCODE_RES_MASK
+ {
+ Text = "DDE-Methode ohne offenen DDE-Kanal gerufen" ;
+ Text [ ENGLISH ] = "DDE method invoked with no channel open" ;
+ Text [ norwegian ] = "DDE method invoked with no channel open" ;
+ Text [ italian ] = "Metodo DDE richiamato senza canale DDE aperto" ;
+ Text [ portuguese_brazilian ] = "DDE method invoked with no channel open" ;
+ Text [ portuguese ] = "Mtodo DDE foi chamado sem canal aberto" ;
+ Text [ french ] = "Mthode DDE appele sans avoir ouvert un canal DDE" ;
+ Text [ dutch ] = "DDE-methode zonder open kanaal opgeroepen" ;
+ Text [ spanish ] = "Se llam al mtodo DDE sin un canal DDE abierto" ;
+ Text [ danish ] = "DDE-metode blev kaldt uden ben DDE-kanal" ;
+ Text [ swedish ] = "DDE-metod anropad utan ppen DDE-kanal" ;
+ Text [ finnish ] = "DDE method invoked with no channel open" ;
+ Text [ english_us ] = "DDE method invoked with no channel open" ;
+ Text[ chinese_simplified ] = "ûдDDEŵʱDDE";
+ Text[ russian ] = " DDE DDE";
+ Text[ polish ] = "Metoda DDE wywoana bez otwartego kanau DDE";
+ Text[ japanese ] = "DDEقJĂȂԂDDEҿނĂяoĂ܂";
+ Text[ chinese_traditional ] = "bS}DDEHDɽեDDE k";
+ Text[ arabic ] = "DDE DDE ";
+ Text[ dutch ] = "DDE-methode zonder open kanaal opgeroepen";
+ Text[ chinese_simplified ] = "ûдDDEŵʱDDE";
+ Text[ greek ] = " DDE DDE";
+ Text[ korean ] = "DDE ä ʰ DDE ޼ҵ带 ȣ";
+ Text[ turkish ] = "Ak DDE kanal olmadan DDE yntemi ars";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_INVALID_LINK & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ungltiges DDE-Linkformat : Ungltiges DDE-Linkformat */
+ Text = "Ungltiges DDE-Linkformat" ;
+ Text [ ENGLISH ] = "Invalid DDE Link format" ;
+ Text [ norwegian ] = "Invalid DDE Link format" ;
+ Text [ italian ] = "Formato link DDE non valido" ;
+ Text [ portuguese_brazilian ] = "Invalid DDE Link format" ;
+ Text [ portuguese ] = "Formato de ligao DDE no vlido" ;
+ Text [ french ] = "Format de lien DDE incorrect" ;
+ Text [ dutch ] = "Foutief DDE-link-formaat" ;
+ Text [ spanish ] = "Formato del vnculo DDE incorrecto" ;
+ Text [ danish ] = "Ugyldigt DDE-linkformat" ;
+ Text [ swedish ] = "Ogiltigt DDE- linkformat" ;
+ Text [ finnish ] = "Invalid DDE Link format" ;
+ Text [ english_us ] = "Invalid DDE link format" ;
+ Text[ chinese_simplified ] = "Ч DDE Ӹʽ";
+ Text[ russian ] = " DDE";
+ Text[ polish ] = "Nieprawidowy format cza DDE";
+ Text[ japanese ] = " DDE ݸ";
+ Text[ chinese_traditional ] = "LĪDDEs榡";
+ Text[ arabic ] = " DDE ";
+ Text[ dutch ] = "Foutief DDE-link-formaat";
+ Text[ chinese_simplified ] = "Ч DDE Ӹʽ";
+ Text[ greek ] = " DDE";
+ Text[ korean ] = "ȿ DDE ";
+ Text[ turkish ] = "Geersiz DDE balant format";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_QUEUE_OVERFLOW & ERRCODE_RES_MASK
+ {
+ Text = "DDE-Message ist verlorengegangen" ;
+ Text [ ENGLISH ] = "Message queue filled; DDE Message lost" ;
+ Text [ norwegian ] = "Message queue filled; DDE Message lost" ;
+ Text [ italian ] = "Il messaggio DDE andato perduto" ;
+ Text [ portuguese_brazilian ] = "Message queue filled; DDE Message lost" ;
+ Text [ portuguese ] = "A mensagem DDE perdeu-se" ;
+ Text [ french ] = "Le message DDE a t perdu" ;
+ Text [ dutch ] = "DDE-message verloren gegaan" ;
+ Text [ spanish ] = "El mensaje DDE se ha perdido" ;
+ Text [ danish ] = "DDE-meddelelse er get tabt" ;
+ Text [ swedish ] = "DDE-meddelandet r borttappat" ;
+ Text [ finnish ] = "Message queue filled; DDE Message lost" ;
+ Text [ english_us ] = "DDE message has been lost" ;
+ Text[ chinese_simplified ] = "DDE Ϣʧ";
+ Text[ russian ] = " DDE ";
+ Text[ polish ] = "Wiadomo DDE zagina";
+ Text[ japanese ] = "DDEүނ͎܂";
+ Text[ chinese_traditional ] = "DDET";
+ Text[ arabic ] = "DDE ";
+ Text[ dutch ] = "DDE-message verloren gegaan";
+ Text[ chinese_simplified ] = "DDE Ϣʧ";
+ Text[ greek ] = " DDE ";
+ Text[ korean ] = "DDE ޼ ";
+ Text[ turkish ] = "DDE iletisi kayboldu";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_LINK_ALREADY_EST & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Paste Link bereits durchgefhrt : Paste Link bereits durchgefhrt */
+ Text = "Paste Link bereits durchgefhrt" ;
+ Text [ ENGLISH ] = "Paste link already performed" ;
+ Text [ norwegian ] = "Paste link already performed" ;
+ Text [ italian ] = "Paste link gi eseguito" ;
+ Text [ portuguese_brazilian ] = "Paste link already performed" ;
+ Text [ portuguese ] = "\"Paste link\" j executado" ;
+ Text [ french ] = "Le paste link a dj t excut" ;
+ Text [ dutch ] = "Paste link reeds uitgevoerd" ;
+ Text [ spanish ] = "Pegar vnculo ya ejecutado" ;
+ Text [ danish ] = "Paste link er allerede udfrt" ;
+ Text [ swedish ] = "Paste link r redan genomfrt" ;
+ Text [ finnish ] = "Paste link already performed" ;
+ Text [ english_us ] = "Paste link already performed" ;
+ Text[ chinese_simplified ] = "ճѾ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Polecenie Wklej cze zostao ju wykonane";
+ Text[ japanese ] = "ݸ̓\\t͂łɎsĂ܂";
+ Text[ language_user1 ] = " ";
+ Text[ chinese_traditional ] = "߶Kswg";
+ Text[ arabic ] = " Paste link ";
+ Text[ dutch ] = "Paste link reeds uitgevoerd";
+ Text[ chinese_simplified ] = "ճѾ";
+ Text[ greek ] = " 'Paste link' ";
+ Text[ korean ] = " ٿֱ ̹ Ǿϴ.";
+ Text[ turkish ] = "Paste Link ilemi yrtld";
+ };
+ String SbERR_DDE_LINK_INV_TOPIC & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? LinkMode kann wegen ungltigen Link-Topics nicht gesetzt werden : LinkMode kann wegen ungltigen Link-Topics nicht gesetzt werden */
+ Text = "LinkMode kann wegen ungltigen Link-Topics nicht gesetzt werden" ;
+ Text [ ENGLISH ] = "Cant set LinkMode; invalid Link Topic" ;
+ Text [ norwegian ] = "Cant set LinkMode; invalid Link Topic" ;
+ Text [ italian ] = "Link topic non valido; impossibile impostare il modo link" ;
+ Text [ portuguese_brazilian ] = "Cant set LinkMode; invalid Link Topic" ;
+ Text [ portuguese ] = "Impossvel configurar o LinkMode devido a LinkTopic no vlido" ;
+ Text [ french ] = "Impossible de dfinir le LinkMode cause d'un Link-Topic incorrect" ;
+ Text [ dutch ] = "Ongeldig Link Topic; LinkMode kan niet worden gezet" ;
+ Text [ spanish ] = "No se puede establecer el LinkMode debido a un Link Topic incorrecto" ;
+ Text [ danish ] = "Linktilstand kan ikke indstilles p grund af ugyldige linktopics." ;
+ Text [ swedish ] = "LinkMode kan inte stllas in p grund av ogiltiga Link-Topics" ;
+ Text [ finnish ] = "Cant set LinkMode; invalid Link Topic" ;
+ Text [ english_us ] = "Link mode cannot be set due to invalid link topic" ;
+ Text[ chinese_simplified ] = "Чӱ޷趨ӱ";
+ Text[ russian ] = "- Link-Topic LinkMode ";
+ Text[ polish ] = "Nie mona skonfigurowa LinkMode z powodu niewanych Link-Topics";
+ Text[ japanese ] = "ݸ Ӱނݸ ߯ł邽߁Aݒł܂";
+ Text[ chinese_traditional ] = "]LĪ|DӵLk]w|D";
+ Text[ arabic ] = " Link-Topics LinkMode ";
+ Text[ dutch ] = "Ongeldig Link Topic; LinkMode kan niet worden gezet";
+ Text[ chinese_simplified ] = "Чӱ޷趨ӱ";
+ Text[ greek ] = " LinkMode Link-Topics.";
+ Text[ korean ] = "ȿ Ͽ ɼ ϴ.";
+ Text[ turkish ] = "LinkMode, geersiz Link-Topics nedeniyle belirlenemez";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_DLL_NOT_FOUND & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Fr DDE wird DDEML.DLL bentigt : Fr DDE wird DDEML.DLL bentigt */
+ Text = "Fr DDE wird DDEML.DLL bentigt" ;
+ Text [ ENGLISH ] = "DDE requires DDEML.DLL" ;
+ Text [ norwegian ] = "DDE requires DDEML.DLL" ;
+ Text [ italian ] = "DDE necessita del DDEML.DLL" ;
+ Text [ portuguese_brazilian ] = "DDE requires DDEML.DLL" ;
+ Text [ portuguese ] = "DDE requere DDEML.DLL" ;
+ Text [ french ] = "Le DDE requiert DDEML.DLL" ;
+ Text [ dutch ] = "DDE benodigt DDEML.DLL" ;
+ Text [ spanish ] = "Para el DDE se requiere DDEML.DLL" ;
+ Text [ danish ] = "DDE krver DDEML.DLL" ;
+ Text [ swedish ] = "DDE krver DDEML.DLL" ;
+ Text [ finnish ] = "DDE requires DDEML.DLL" ;
+ Text [ english_us ] = "DDE requires the DDEML.DLL file" ;
+ Text[ chinese_simplified ] = "DDE Ҫ DDEML.DLL";
+ Text[ russian ] = " DDE DDEML.DLL";
+ Text[ polish ] = "Dla DDE jest wymagane DDEML.DLL";
+ Text[ japanese ] = "DDÊ߂DDEML.DLLKvł";
+ Text[ chinese_traditional ] = "DDEnDDDEML.DLL";
+ Text[ arabic ] = "DDEML.DLL DDE";
+ Text[ dutch ] = "DDE benodigt DDEML.DLL";
+ Text[ chinese_simplified ] = "DDE Ҫ DDEML.DLL";
+ Text[ greek ] = " DDE DDEML.DLL";
+ Text[ korean ] = "DDE DDEML.DLL ʿմϴ.";
+ Text[ turkish ] = "DDE iin DDEML.DLL gerekli";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_CANNOT_LOAD & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Das Modul kann nicht geladen werden, ungltiges Format : Das Modul kann nicht geladen werden, ungltiges Format */
+ Text = "Das Modul kann nicht geladen werden, ungltiges Format" ;
+ Text [ ENGLISH ] = "Can't load module, invalid format" ;
+ Text [ norwegian ] = "Can't load module, invalid format" ;
+ Text [ italian ] = "Formato non valido; impossibile caricare il modulo" ;
+ Text [ portuguese_brazilian ] = "Can't load module, invalid format" ;
+ Text [ portuguese ] = "Impossvel carregar mdulo; formato no vlido" ;
+ Text [ french ] = "Impossible de charger le module cause d'une erreur de format" ;
+ Text [ dutch ] = "De module kan niet worden geladen, ongeldig formaat" ;
+ Text [ spanish ] = "No se puede cargar el mdulo ya que el formato es incorrecto" ;
+ Text [ danish ] = "Det er ikke muligt at indlse modulet; ugyldigt format" ;
+ Text [ swedish ] = "Modulen kan inte laddas, ogiltigt format" ;
+ Text [ finnish ] = "Can't load module, invalid format" ;
+ Text [ english_us ] = "Module cannot be loaded; invalid format" ;
+ Text[ chinese_simplified ] = "ʽЧ޷װģ";
+ Text[ russian ] = " , ";
+ Text[ polish ] = "Moduu nie mona zaadowa, nieprawidowy format";
+ Text[ japanese ] = "Ӽޭقǂݍ߂܂BȏłB";
+ Text[ chinese_traditional ] = "榡LġM]ӵLk˸Ҷ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "De module kan niet worden geladen, ongeldig formaat";
+ Text[ chinese_simplified ] = "ʽЧ޷װģ";
+ Text[ greek ] = " , ";
+ Text[ korean ] = " ε ʾҽϴ. ; ߸ ";
+ Text[ turkish ] = "Modl yklenemiyor; geersiz format";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_INDEX & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ungltiger Objektindex : Ungltiger Objektindex */
+ Text = "Ungltiger Objektindex" ;
+ Text [ ENGLISH ] = "Invalid object index" ;
+ Text [ norwegian ] = "Invalid object index" ;
+ Text [ italian ] = "Indice di oggetto non valido" ;
+ Text [ portuguese_brazilian ] = "Invalid object index" ;
+ Text [ portuguese ] = "ndice de objectos no vlido" ;
+ Text [ french ] = "Index d'objets incorrect" ;
+ Text [ dutch ] = "Ongeldige objectindex" ;
+ Text [ spanish ] = "ndice incorrecto del objeto" ;
+ Text [ danish ] = "Ugyldigt objektindeks" ;
+ Text [ swedish ] = "Ogiltigt objektindex" ;
+ Text [ finnish ] = "Invalid object index" ;
+ Text [ english_us ] = "Invalid object index" ;
+ Text[ chinese_simplified ] = "ЧĶ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nieprawidowy indeks obiektw";
+ Text[ japanese ] = "ȵ޼ު ޯ";
+ Text[ chinese_traditional ] = "LĪ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Ongeldige objectindex";
+ Text[ chinese_simplified ] = "ЧĶ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ȿ ü ε";
+ Text[ turkish ] = "Geersiz nesne dizini";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_ACTIVE_OBJECT & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Objekt ist nicht verfgbar : Objekt ist nicht verfgbar */
+ Text = "Objekt ist nicht verfgbar" ;
+ Text [ ENGLISH ] = "Object is not available" ;
+ Text [ norwegian ] = "Object is not available" ;
+ Text [ italian ] = "Oggetto non disponibile" ;
+ Text [ portuguese_brazilian ] = "Object is not available" ;
+ Text [ portuguese ] = "Objecto no disponvel" ;
+ Text [ french ] = "L'objet n'est pas disponible" ;
+ Text [ dutch ] = "Object niet beschikbaar" ;
+ Text [ spanish ] = "El objeto no est disponible" ;
+ Text [ danish ] = "Objektet er ikke tilgngeligt" ;
+ Text [ swedish ] = "Objektet r inte tillgngligt" ;
+ Text [ finnish ] = "Object is not available" ;
+ Text [ english_us ] = "Object is not available" ;
+ Text[ chinese_simplified ] = "󲻴";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Obiekt jest niedostpny";
+ Text[ japanese ] = "޼ުĂ܂";
+ Text[ chinese_traditional ] = "󤣦sb";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Object niet beschikbaar";
+ Text[ chinese_simplified ] = "󲻴";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ü ȿ Ƚϴ.";
+ Text[ turkish ] = "Nesne mevcut deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_PROP_VALUE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Falscher Wert fr Eigenschaft : Falscher Wert fr Eigenschaft */
+ Text = "Falscher Wert fr Eigenschaft" ;
+ Text [ ENGLISH ] = "Bad property value" ;
+ Text [ norwegian ] = "Bad property value" ;
+ Text [ italian ] = "Valore per la propriet errato" ;
+ Text [ portuguese_brazilian ] = "Bad property value" ;
+ Text [ portuguese ] = "Valor de propriedade incorrecto" ;
+ Text [ french ] = "Valeur de proprit incorrecte" ;
+ Text [ dutch ] = "Foutieve waarde voor eigenschap" ;
+ Text [ spanish ] = "Valor no vlido para la propiedad" ;
+ Text [ danish ] = "Forkert egenskabsvrdi" ;
+ Text [ swedish ] = "Felaktigt vrde fr egenskap" ;
+ Text [ finnish ] = "Bad property value" ;
+ Text [ english_us ] = "Incorrect property value" ;
+ Text[ chinese_simplified ] = "ֵ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Niepoprawna warto waciwoci";
+ Text[ japanese ] = "èl܂";
+ Text[ chinese_traditional ] = "~ݩʼƭ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Foutieve waarde voor eigenschap";
+ Text[ chinese_simplified ] = "ֵ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "߸ Ƽ ";
+ Text[ turkish ] = "Yanl zellik deeri";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_PROP_READONLY & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Eigenschaft ist schreibgeschtzt : Eigenschaft ist schreibgeschtzt */
+ Text = "Eigenschaft ist schreibgeschtzt" ;
+ Text [ ENGLISH ] = "Property is read only" ;
+ Text [ norwegian ] = "Property is read only" ;
+ Text [ italian ] = "La propriet a sola lettura" ;
+ Text [ portuguese_brazilian ] = "Property is read only" ;
+ Text [ portuguese ] = "A propriedade s leitura" ;
+ Text [ french ] = "La proprit est en lecture seule" ;
+ Text [ dutch ] = "Eigenschap is schrijfbeveiligd" ;
+ Text [ spanish ] = "Propiedad es solo lectura" ;
+ Text [ danish ] = "Egenskaben er skrivebeskyttet" ;
+ Text [ swedish ] = "Egenskapen r skrivskyddad" ;
+ Text [ finnish ] = "Property is read only" ;
+ Text [ english_us ] = "This property is read only" ;
+ Text[ chinese_simplified ] = "д";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Waciwo tylko do odczytu";
+ Text[ japanese ] = "è͏ݕی삳Ă܂";
+ Text[ chinese_traditional ] = "Ūݩ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Eigenschap is schrijfbeveiligd";
+ Text[ chinese_simplified ] = "д";
+ Text[ greek ] = " ";
+ Text[ korean ] = " Ƽ б Դϴ.";
+ Text[ turkish ] = "zellik yazma korumal";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_PROP_WRITEONLY & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Eigenschaft ist lesegeschtzt : Eigenschaft ist lesegeschtzt */
+ Text = "Eigenschaft ist lesegeschtzt" ;
+ Text [ ENGLISH ] = "Property is write only" ;
+ Text [ norwegian ] = "Property is write only" ;
+ Text [ italian ] = "La propriet a sola scrittura" ;
+ Text [ portuguese_brazilian ] = "Property is write only" ;
+ Text [ portuguese ] = "A propriedade s escrita" ;
+ Text [ french ] = "La proprit est en criture seule" ;
+ Text [ dutch ] = "Eigenschap is leesbeveiligd" ;
+ Text [ spanish ] = "Propiedad es solo escritura" ;
+ Text [ danish ] = "Egenskaben er lsebeskyttet" ;
+ Text [ swedish ] = "Egenskapen r lsskyddad" ;
+ Text [ finnish ] = "Property is write only" ;
+ Text [ english_us ] = "This property is write only" ;
+ Text[ chinese_simplified ] = "ȡ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Waciwo tylko do zapisu";
+ Text[ japanese ] = "è͓ǂݎی삳Ă܂";
+ Text[ chinese_traditional ] = "Ūݩ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Eigenschap is leesbeveiligd";
+ Text[ chinese_simplified ] = "ȡ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " Ƽ Դϴ.";
+ Text[ turkish ] = "zellik okuma korumal";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_INVALID_OBJECT & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ungltige Objektreferenz : Ungltige Objektreferenz */
+ Text = "Ungltige Objektreferenz" ;
+ Text [ ENGLISH ] = "Invalid object reference" ;
+ Text [ norwegian ] = "Invalid object reference" ;
+ Text [ italian ] = "Riferimento ad oggetto non valido" ;
+ Text [ portuguese_brazilian ] = "Invalid object reference" ;
+ Text [ portuguese ] = "Referncia do objecto no-vlida" ;
+ Text [ french ] = "Rfrence d'objet incorrecte" ;
+ Text [ dutch ] = "Ongeldige objectverwijzing" ;
+ Text [ spanish ] = "Referencia al objeto no vlida" ;
+ Text [ danish ] = "Ugyldig objektreference" ;
+ Text [ swedish ] = "Ogiltig objektreferens" ;
+ Text [ finnish ] = "Invalid object reference" ;
+ Text [ english_us ] = "Invalid object reference" ;
+ Text[ chinese_simplified ] = "ЧĶ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Niewane odwoanie obiektu";
+ Text[ japanese ] = "ȵ޼ުĎQ";
+ Text[ chinese_traditional ] = "LĪѷ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Ongeldige objectverwijzing";
+ Text[ chinese_simplified ] = "ЧĶ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "߸ ü ";
+ Text[ turkish ] = "Geersiz nesne referans";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_METHOD & ERRCODE_RES_MASK
+ {
+ Text = "Eigenschaft oder Methode nicht gefunden" ;
+ Text [ ENGLISH ] = "Property or method not found" ;
+ Text [ norwegian ] = "Property or method not found" ;
+ Text [ italian ] = "Propriet o metodo non trovati" ;
+ Text [ portuguese_brazilian ] = "Property or method not found" ;
+ Text [ portuguese ] = "Propriedade ou mtodo no encontrados" ;
+ Text [ french ] = "Proprit ou mthode introuvable" ;
+ Text [ dutch ] = "Eigenschap of methode niet gevonden" ;
+ Text [ spanish ] = "No se encontr la propiedad o el mtodo" ;
+ Text [ danish ] = "Egenskab eller metode blev ikke fundet" ;
+ Text [ swedish ] = "Egenskap eller metod hittades inte" ;
+ Text [ finnish ] = "Property or method not found" ;
+ Text [ english_us ] = "Property or method not found" ;
+ Text[ chinese_simplified ] = "ûҵԻ򷽷";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nie znaleziono waciwoci lub metody";
+ Text[ japanese ] = "è܂ҿނ‚܂";
+ Text[ chinese_traditional ] = "SݩʩΤk";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Eigenschap of methode niet gevonden";
+ Text[ chinese_simplified ] = "ûҵԻ򷽷";
+ Text[ greek ] = " ";
+ Text[ korean ] = "Ƽ Ǵ ޼ҵ尡 ߰ߵ ʽϴ.";
+ Text[ turkish ] = "zellik ya da yntem bulunamad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NEEDS_OBJECT & ERRCODE_RES_MASK
+ {
+ Text = "Objekt erforderlich" ;
+ Text [ ENGLISH ] = "Object required" ;
+ Text [ norwegian ] = "Object required" ;
+ Text [ italian ] = " necessario un oggetto" ;
+ Text [ portuguese_brazilian ] = "Object required" ;
+ Text [ portuguese ] = "Necessrio objecto" ;
+ Text [ french ] = "Objet requis" ;
+ Text [ dutch ] = "Object vereist" ;
+ Text [ spanish ] = "Se requiere un objeto" ;
+ Text [ danish ] = "Objekt krves" ;
+ Text [ swedish ] = "Objekt krvs" ;
+ Text [ finnish ] = "Object required" ;
+ Text [ english_us ] = "Object required" ;
+ Text[ chinese_simplified ] = "Ҫ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Wymagany obiekt";
+ Text[ japanese ] = "޼ުĂKvł";
+ Text[ chinese_traditional ] = "nD";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Object vereist";
+ Text[ chinese_simplified ] = "Ҫ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ü ʿմϴ.";
+ Text[ turkish ] = "Nesne gerekli";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_INVALID_USAGE_OBJECT & ERRCODE_RES_MASK
+ {
+ Text = "Falsche Verwendung eines Objekts" ;
+ Text [ ENGLISH ] = "Invalid use of object" ;
+ Text [ norwegian ] = "Invalid use of object" ;
+ Text [ italian ] = "Utilizzo non valido di un oggetto" ;
+ Text [ portuguese_brazilian ] = "Invalid use of object" ;
+ Text [ portuguese ] = "Uso incorrecto de um objecto" ;
+ Text [ french ] = "Utilisation incorrecte d'un objet" ;
+ Text [ dutch ] = "Ongeldig gebruik van object" ;
+ Text [ spanish ] = "Uso errneo de un objeto" ;
+ Text [ danish ] = "Ugyldig brug af et objekt" ;
+ Text [ swedish ] = "Felaktig anvndning av ett objekt" ;
+ Text [ finnish ] = "Invalid use of object" ;
+ Text [ english_us ] = "Invalid use of an object" ;
+ Text[ chinese_simplified ] = "ʹö";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nieprawidowe uycie obiektu";
+ Text[ japanese ] = "޼ުĂ̌gp";
+ Text[ chinese_traditional ] = "~ϥΪ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Ongeldig gebruik van object";
+ Text[ chinese_simplified ] = "ʹö";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ü ߸ ";
+ Text[ turkish ] = "Nesne kullanm yanl";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_OLE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? OLE-Automatisierung wird von diesem Objekt nicht untersttzt : OLE-Automatisierung wird von diesem Objekt nicht untersttzt */
+ Text = "OLE-Automatisierung wird von diesem Objekt nicht untersttzt" ;
+ Text [ ENGLISH ] = "Object does not support OLE Automation" ;
+ Text [ norwegian ] = "Object does not support OLE Automation" ;
+ Text [ italian ] = "L'automatizzazione OLE non supportata dall'oggetto" ;
+ Text [ portuguese_brazilian ] = "Object does not support OLE Automation" ;
+ Text [ portuguese ] = "Este objecto no suporta a automatao OLE" ;
+ Text [ french ] = "Cet objet ne supporte pas l'automatisation OLE" ;
+ Text [ dutch ] = "OLE-automatisering wordt niet ondersteund door het aangegeven object" ;
+ Text [ spanish ] = "Este objeto no apoya la automatizacin OLE" ;
+ Text [ danish ] = "OLE-automatiseringen understttes ikke af dette objekt" ;
+ Text [ swedish ] = "OLE-automatiseringen stds ej av detta objekt" ;
+ Text [ finnish ] = "Object does not support OLE Automation" ;
+ Text [ english_us ] = "OLE Automation is not supported by this object" ;
+ Text[ chinese_simplified ] = "֧OLEԶ";
+ Text[ russian ] = " OLE ";
+ Text[ polish ] = "Automatyzacja OLE nie jest obsugiwana przez ten obiekt";
+ Text[ japanese ] = "OLE̵̎͂޼ުĂx܂";
+ Text[ chinese_traditional ] = "oӪ󤣤䴩OLE۰ʤ";
+ Text[ arabic ] = " OLE ";
+ Text[ dutch ] = "OLE-automatisering wordt niet ondersteund door het aangegeven object";
+ Text[ chinese_simplified ] = "֧OLEԶ";
+ Text[ greek ] = " OLE ";
+ Text[ korean ] = "OLE ڵȭ ü ʽϴ.";
+ Text[ turkish ] = "OLE otomasyonu bu nesne tarafndan desteklenmiyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_METHOD & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Objekt untersttzt diese Eigenschaft oder Methode nicht : Objekt untersttzt diese Eigenschaft oder Methode nicht */
+ Text = "Objekt untersttzt diese Eigenschaft oder Methode nicht" ;
+ Text [ ENGLISH ] = "Object doesn't support property or method" ;
+ Text [ norwegian ] = "Object doesn't support property or method" ;
+ Text [ italian ] = "L'oggetto non supporta la propriet o il metodo" ;
+ Text [ portuguese_brazilian ] = "Object doesn't support property or method" ;
+ Text [ portuguese ] = "Objecto no suporta nem a caracterstica nem o mtodo" ;
+ Text [ french ] = "L'objet ne supporte pas cette proprit ou mthode" ;
+ Text [ dutch ] = "Deze eigenschap of methode wordt niet ondersteund door het aangegeven object" ;
+ Text [ spanish ] = "El objeto no apoya esta propiedad o mtodo" ;
+ Text [ danish ] = "Objektet understtter ikke denne egenskab eller metode" ;
+ Text [ swedish ] = "Objektet understdjer inte denna egenskap eller metod" ;
+ Text [ finnish ] = "Object doesn't support property or method" ;
+ Text [ english_us ] = "This property or method is not supported by the object" ;
+ Text[ chinese_simplified ] = "֧Ի򷽷";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Obiekt nie obsuguje tej waciwoci lub metody";
+ Text[ japanese ] = "޼ުĂ͂è܂͕@xł܂";
+ Text[ chinese_traditional ] = "󤣤oݩʩΤk";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Deze eigenschap of methode wordt niet ondersteund door het aangegeven object";
+ Text[ chinese_simplified ] = "֧Ի򷽷";
+ Text[ greek ] = " ";
+ Text[ korean ] = " Ƽ Ǵ ޼ҵ ü ʽϴ.";
+ Text[ turkish ] = "Nesne bu zellii ya da yntemi desteklemiyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_OLE_ERROR & ERRCODE_RES_MASK
+ {
+ Text = "Fehler bei OLE-Automatisierung" ;
+ Text [ ENGLISH ] = "OLE Automation error" ;
+ Text [ norwegian ] = "OLE Automation error" ;
+ Text [ italian ] = "Errore nell'automatizzazione OLE" ;
+ Text [ portuguese_brazilian ] = "OLE Automation error" ;
+ Text [ portuguese ] = "Erro na automatao OLE" ;
+ Text [ french ] = "Erreur lors de l'automatisation OLE" ;
+ Text [ dutch ] = "Fout bij OLE-automatisering" ;
+ Text [ spanish ] = "Error en la automatizacin OLE" ;
+ Text [ danish ] = "Fejl ved OLE-automatisering" ;
+ Text [ swedish ] = "Fel vid OLE-automatisering" ;
+ Text [ finnish ] = "OLE Automation error" ;
+ Text [ english_us ] = "OLE Automation Error" ;
+ Text[ chinese_simplified ] = "OLE Զ";
+ Text[ russian ] = " OLE";
+ Text[ polish ] = "Bd przy automatyzacji OLE";
+ Text[ japanese ] = "OLE̍ۂ̴װ";
+ Text[ chinese_traditional ] = "OLE۰ʤƿ~";
+ Text[ arabic ] = " OLE ";
+ Text[ dutch ] = "Fout bij OLE-automatisering";
+ Text[ chinese_simplified ] = "OLE Զ";
+ Text[ greek ] = " OLE";
+ Text[ korean ] = "OLE ڵȭ ";
+ Text[ turkish ] = "OLE otomasyonunda hata";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_ACTION & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Diese Aktion wird vom angegebenen Objekt nicht untersttzt : Diese Aktion wird vom angegebenen Objekt nicht untersttzt */
+ Text = "Diese Aktion wird vom angegebenen Objekt nicht untersttzt" ;
+ Text [ ENGLISH ] = "Object doesn't support this action" ;
+ Text [ norwegian ] = "Object doesn't support this action" ;
+ Text [ italian ] = "Azione non supportata dall'oggetto specificato" ;
+ Text [ portuguese_brazilian ] = "Object doesn't support this action" ;
+ Text [ portuguese ] = "O objecto indicado no suporta esta aco" ;
+ Text [ french ] = "L'objet indiqu ne supporte pas cette action" ;
+ Text [ dutch ] = "Deze activiteit wordt niet ondersteund door het aangegeven object" ;
+ Text [ spanish ] = "Esta accin no es apoyada por el objeto dado" ;
+ Text [ danish ] = "Denne handling understttes ikke at det angivne objekt." ;
+ Text [ swedish ] = "Denna tgrd understds inte av angivet objekt" ;
+ Text [ finnish ] = "Object doesn't support this action" ;
+ Text [ english_us ] = "This action is not supported by given object" ;
+ Text[ chinese_simplified ] = "Ķ֧";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Ta akcja nie jest obsugiwana przez podany obiekt";
+ Text[ japanese ] = "̱݂͎w肳ꂽ޼ުĂx܂";
+ Text[ chinese_traditional ] = "w󤣤䴩oӾާ@";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Deze activiteit wordt niet ondersteund door het aangegeven object";
+ Text[ chinese_simplified ] = "Ķ֧";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ־ üؼ ʽϴ.";
+ Text[ turkish ] = "Bu ilem belirtilen nesne tarafndan desteklenmiyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_NAMED_ARGS & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Benannte Argumente werden vom angegebenen Objekt nicht untersttzt : Benannte Argumente werden vom angegebenen Objekt nicht untersttzt */
+ Text = "Benannte Argumente werden vom angegebenen Objekt nicht untersttzt" ;
+ Text [ ENGLISH ] = "Object doesn't support named args" ;
+ Text [ norwegian ] = "Object doesn't support named args" ;
+ Text [ italian ] = "Gli argomenti indicati non vengono supportati dall'oggetto specificato" ;
+ Text [ portuguese_brazilian ] = "Object doesn't support named args" ;
+ Text [ portuguese ] = "O objecto indicado no suporta os argumentos mencionados" ;
+ Text [ french ] = "L'objet indiqu ne supporte pas les arguments cits" ;
+ Text [ dutch ] = "Genoemde argumenten wordt niet ondersteund door het aangegeven object" ;
+ Text [ spanish ] = "El objeto indicado no apoya los argumentos nombrados" ;
+ Text [ danish ] = "Nvnte argumenter understttes ikke af det angivne objekt" ;
+ Text [ swedish ] = "Angivna argument understds ej av angivet objekt" ;
+ Text [ finnish ] = "Object doesn't support named args" ;
+ Text [ english_us ] = "Named arguments are not supported by given object" ;
+ Text[ chinese_simplified ] = "ָ֧Ա";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nazwane argumenty nie s obsugiwane przez podany obiekt";
+ Text[ japanese ] = "wꂽ͎w肳ꂽ޼ުĂx܂";
+ Text[ chinese_traditional ] = "wܶqw󪺤䴩";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Genoemde argumenten wordt niet ondersteund door het aangegeven object";
+ Text[ chinese_simplified ] = "ָ֧Ա";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ־ ü ʽϴ.";
+ Text[ turkish ] = "Adlandrlm argmanlar, belirtilen nesne tarafndan desteklenmiyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_LOCALE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Das aktuelle Gebietsschema wird vom angegebenen Objekt nicht untersttzt : Das aktuelle Gebietsschema wird vom angegebenen Objekt nicht untersttzt */
+ Text = "Das aktuelle Gebietsschema wird vom angegebenen Objekt nicht untersttzt" ;
+ Text [ ENGLISH ] = "Object doesn't support current locale setting" ;
+ Text [ norwegian ] = "Object doesn't support current locale setting" ;
+ Text [ italian ] = "L'oggetto indicato non supporta l'attuale schema regionale" ;
+ Text [ portuguese_brazilian ] = "Object doesn't support current locale setting" ;
+ Text [ portuguese ] = "O objecto indicado no suporta a configurao local actual" ;
+ Text [ french ] = "L'objet indiqu ne supporte pas les paramtres rgionaux slectionns" ;
+ Text [ dutch ] = "Dit actuele gebiedschema wordt niet ondersteund door het aangegeven object" ;
+ Text [ spanish ] = "La configuracin local actual no es apoyada por el objeto dado" ;
+ Text [ danish ] = "Det aktuelle omrdeskema understttes ikke af det angivne objekt" ;
+ Text [ swedish ] = "De aktuella lokala instllningarna understds inte av angivet objekt" ;
+ Text [ finnish ] = "Object doesn't support current locale setting" ;
+ Text [ english_us ] = "The current locale setting is not supported by the given object" ;
+ Text[ chinese_simplified ] = "ǰľֲ趨ܸ֧";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Biece ustawienie lokalne nie jest obsugiwane przez podany obiekt";
+ Text[ japanese ] = "݂۰ِݒ͎w肵޼ުĂx܂";
+ Text[ chinese_traditional ] = "e]ww󪺤䴩";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Dit actuele gebiedschema wordt niet ondersteund door het aangegeven object";
+ Text[ chinese_simplified ] = "ǰľֲ趨ܸ֧";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ־ üؼ ʽϴ.";
+ Text[ turkish ] = "Yrlkteki yerel ayarlar, belirtilen nesne tarafndan desteklenmiyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NAMED_NOT_FOUND & ERRCODE_RES_MASK
+ {
+ Text = "Benanntes Argument nicht gefunden" ;
+ Text [ ENGLISH ] = "Named argument not found" ;
+ Text [ norwegian ] = "Named argument not found" ;
+ Text [ italian ] = "L'argomento indicato non stato trovato" ;
+ Text [ portuguese_brazilian ] = "Named argument not found" ;
+ Text [ portuguese ] = "Impossvel encontrar o argumento mencionado" ;
+ Text [ french ] = "L'argument cit est introuvable" ;
+ Text [ dutch ] = "Genoemd argument niet gevonden" ;
+ Text [ spanish ] = "No se encontr el argumento nombrado" ;
+ Text [ danish ] = "Det nvnte argument blev ikke fundet" ;
+ Text [ swedish ] = "Angivet argument hittades inte" ;
+ Text [ finnish ] = "Named argument not found" ;
+ Text [ english_us ] = "Named argument not found" ;
+ Text[ chinese_simplified ] = "ûҵָԱ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nazwanego argumentu nie znaleziono";
+ Text[ japanese ] = "w͌‚܂";
+ Text[ chinese_traditional ] = "Swܶq";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Genoemd argument niet gevonden";
+ Text[ chinese_simplified ] = "ûҵָԱ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ߰ߵ ʽϴ.";
+ Text[ turkish ] = "Adlandrlan argman bulunamad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NOT_OPTIONAL & ERRCODE_RES_MASK
+ {
+ Text = "Argument ist nicht optional" ;
+ Text [ ENGLISH ] = "Argument not optional" ;
+ Text [ norwegian ] = "Argument not optional" ;
+ Text [ italian ] = "L'argomento non opzionale" ;
+ Text [ portuguese_brazilian ] = "Argument not optional" ;
+ Text [ portuguese ] = "Argumento no opcional" ;
+ Text [ french ] = "L'argument n'est pas facultatif" ;
+ Text [ dutch ] = "Argument niet optioneel" ;
+ Text [ spanish ] = "El argumento no es opcional" ;
+ Text [ danish ] = "Argumentet er ikke valgfrit" ;
+ Text [ swedish ] = "Argumentet r inte valfritt" ;
+ Text [ finnish ] = "Argument not optional" ;
+ Text [ english_us ] = "Argument is not optional" ;
+ Text[ chinese_simplified ] = "ǿѡԱ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Argument nie jest opcjonalny";
+ Text[ japanese ] = "͵߼݂ł͂܂";
+ Text[ chinese_traditional ] = "Di諸ܶq";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Argument niet optioneel";
+ Text[ chinese_simplified ] = "ǿѡԱ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ɼ ƴմϴ.";
+ Text[ turkish ] = "Argman istee bal deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_WRONG_ARGS & ERRCODE_RES_MASK
+ {
+ Text = "Falsche Anzahl an Argumenten" ;
+ Text [ ENGLISH ] = "Wrong number of arguments" ;
+ Text [ norwegian ] = "Wrong number of arguments" ;
+ Text [ italian ] = "Numero di argomenti errato" ;
+ Text [ portuguese_brazilian ] = "Wrong number of arguments" ;
+ Text [ portuguese ] = "Nmero de argumentos incorrecto" ;
+ Text [ french ] = "Nombre d'arguments incorrect" ;
+ Text [ dutch ] = "Foutief aantal argumenten" ;
+ Text [ spanish ] = "Nmero errneo de argumentos" ;
+ Text [ danish ] = "Forkert antal argumenter" ;
+ Text [ swedish ] = "Felaktigt antal argument" ;
+ Text [ finnish ] = "Wrong number of arguments" ;
+ Text [ english_us ] = "Invalid number of arguments" ;
+ Text[ chinese_simplified ] = "ЧԱĿ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nieprawidowa ilo argumentw";
+ Text[ japanese ] = "̐܂";
+ Text[ chinese_traditional ] = "LĪܶqƥ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Foutief aantal argumenten";
+ Text[ chinese_simplified ] = "ЧԱĿ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " Ʋ";
+ Text[ turkish ] = "Argman says yanl";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NOT_A_COLL & ERRCODE_RES_MASK
+ {
+ Text = "Objekt ist keine Auflistung" ;
+ Text [ ENGLISH ] = "Object not a collection" ;
+ Text [ norwegian ] = "Object not a collection" ;
+ Text [ italian ] = "L'oggetto non un elenco" ;
+ Text [ portuguese_brazilian ] = "Object not a collection" ;
+ Text [ portuguese ] = "O objecto no uma lista" ;
+ Text [ french ] = "L'objet n'est pas une liste" ;
+ Text [ dutch ] = "Object is geen lijst" ;
+ Text [ spanish ] = "El objeto no es una lista" ;
+ Text [ danish ] = "Objektet er ingen liste" ;
+ Text [ swedish ] = "Objektet r ingen lista" ;
+ Text [ finnish ] = "Object not a collection" ;
+ Text [ english_us ] = "Object is not a list" ;
+ Text[ chinese_simplified ] = "һе";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Obiekt nie jest list";
+ Text[ japanese ] = "޼ުĂؽĂł͂܂";
+ Text[ chinese_traditional ] = "󤣬O@ӲM";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Object is geen lijst";
+ Text[ chinese_simplified ] = "һе";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ü ϵ ʾҽϴ.";
+ Text[ turkish ] = "Nesne bir liste deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_ORDINAL & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ordnungszahl ungltig : Ordnungszahl ungltig */
+ Text = "Ordnungszahl ungltig" ;
+ Text [ ENGLISH ] = "Invalid ordinal" ;
+ Text [ norwegian ] = "Invalid ordinal" ;
+ Text [ italian ] = "Numero ordinale non valido" ;
+ Text [ portuguese_brazilian ] = "Invalid ordinal" ;
+ Text [ portuguese ] = "Ordinal incorrecto" ;
+ Text [ french ] = "Nombre ordinal non valable" ;
+ Text [ dutch ] = "Ongeldig ranggetal" ;
+ Text [ spanish ] = "Nmero ordinal no vlido" ;
+ Text [ danish ] = "Ugyldigt ordenstal" ;
+ Text [ swedish ] = "Ogiltigt ordningstal" ;
+ Text [ finnish ] = "Invalid ordinal" ;
+ Text [ english_us ] = "Invalid ordinal number" ;
+ Text[ chinese_simplified ] = "Ч";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nieprawidowa liczba porzdkowa";
+ Text[ japanese ] = "͖ł";
+ Text[ chinese_traditional ] = "ǸL";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Ongeldig ranggetal";
+ Text[ chinese_simplified ] = "Ч";
+ Text[ greek ] = " ";
+ Text[ korean ] = "߸ ";
+ Text[ turkish ] = "Sra says geersiz";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DLLPROC_NOT_FOUND & ERRCODE_RES_MASK
+ {
+ Text = "Angegebene DLL-Funktion nicht gefunden" ;
+ Text [ ENGLISH ] = "Specified DLL function not found" ;
+ Text [ norwegian ] = "Specified DLL function not found" ;
+ Text [ italian ] = "Impossibile trovare la funzione DLL specificata" ;
+ Text [ portuguese_brazilian ] = "Specified DLL function not found" ;
+ Text [ portuguese ] = "Funo DLL especificada no foi encontrada" ;
+ Text [ french ] = "La fonction DLL indique est introuvable" ;
+ Text [ dutch ] = "Aangegeven DLL- functie niet gevonden" ;
+ Text [ spanish ] = "No se encontr la funcin DLL especificada" ;
+ Text [ danish ] = "Den angivne DDL-funktion blev ikke fundet" ;
+ Text [ swedish ] = "Angiven DLL-funktion hittades inte" ;
+ Text [ finnish ] = "Specified DLL function not found" ;
+ Text [ english_us ] = "Specified DLL function not found" ;
+ Text[ chinese_simplified ] = "ûҵָ DLL ";
+ Text[ russian ] = " DLL ";
+ Text[ polish ] = "Podanej funkcji DLL nie znaleziono";
+ Text[ japanese ] = "w肳ꂽDLL@\\͌‚܂";
+ Text[ chinese_traditional ] = "SwDLL\\";
+ Text[ arabic ] = " DLL ";
+ Text[ dutch ] = "Aangegeven DLL- functie niet gevonden";
+ Text[ chinese_simplified ] = "ûҵָ DLL ";
+ Text[ greek ] = " DLL";
+ Text[ korean ] = " DLL Լ ߰ߵ ʾҽϴ.";
+ Text[ turkish ] = "Belirtilen DLL ilevi bulunamad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_CLIPBD_FORMAT & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ungltiges Clipboard-Format : Ungltiges Clipboard-Format */
+ Text = "Ungltiges Clipboard-Format" ;
+ Text [ ENGLISH ] = "Invalid clipboard format" ;
+ Text [ norwegian ] = "Invalid clipboard format" ;
+ Text [ italian ] = "Formato clipboard non valido" ;
+ Text [ portuguese_brazilian ] = "Invalid clipboard format" ;
+ Text [ portuguese ] = "Formato da rea de transferncia no vlido" ;
+ Text [ french ] = "Le format de presse-papiers souhait est incorrect." ;
+ Text [ dutch ] = "Ongeldig Clipboard- formaat" ;
+ Text [ spanish ] = "Formato de portapapeles no vlido" ;
+ Text [ danish ] = "Ugyldigt udklipsholderformat" ;
+ Text [ swedish ] = "Ogiltigt urklippsformat" ;
+ Text [ finnish ] = "Invalid clipboard format" ;
+ Text [ english_us ] = "Invalid clipboard format" ;
+ Text[ chinese_simplified ] = "Чļʽ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nieprawidowy format schowka";
+ Text[ japanese ] = "دްޏł";
+ Text[ chinese_traditional ] = "LĪŶKï榡";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Ongeldig Clipboard- formaat";
+ Text[ chinese_simplified ] = "Чļʽ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ȿ Ŭ ";
+ Text[ turkish ] = "Geersiz pano format";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_PROPERTY_NOT_FOUND & ERRCODE_RES_MASK
+ {
+ Text = "Objekt hat diese Eigenschaft nicht" ;
+ Text [ ENGLISH ] = "Object does not have property" ;
+ Text [ norwegian ] = "Object does not have property" ;
+ Text [ italian ] = "L'oggetto non dispone di questa propriet" ;
+ Text [ portuguese_brazilian ] = "Object does not have property" ;
+ Text [ portuguese ] = "O objecto no tem esta propriedade" ;
+ Text [ french ] = "L'objet ne possde pas cette proprit" ;
+ Text [ dutch ] = "Object heeft deze eigenschap niet" ;
+ Text [ spanish ] = "El objeto no tiene esta propiedad" ;
+ Text [ danish ] = "Objektet har ikke denne egenskab" ;
+ Text [ swedish ] = "Objektet har inte denna egenskap" ;
+ Text [ finnish ] = "Object does not have property" ;
+ Text [ english_us ] = "Object does not have this property" ;
+ Text[ chinese_simplified ] = "󲻾߱";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Obiekt nie ma tej waciwoci";
+ Text[ japanese ] = "޼ުĂɂ̑͂܂";
+ Text[ chinese_traditional ] = "󤣨Ƴoݩ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Object heeft deze eigenschap niet";
+ Text[ chinese_simplified ] = "󲻾߱";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ü Ƽ ʽϴ.";
+ Text[ turkish ] = "Nesne bu zellie sahip deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_METHOD_NOT_FOUND & ERRCODE_RES_MASK
+ {
+ Text = "Objekt hat diese Methode nicht" ;
+ Text [ ENGLISH ] = "Object does not have method" ;
+ Text [ norwegian ] = "Object does not have method" ;
+ Text [ italian ] = "L'oggetto non dispone di questo metodo" ;
+ Text [ portuguese_brazilian ] = "Object does not have method" ;
+ Text [ portuguese ] = "O objecto no dispe deste mtodo" ;
+ Text [ french ] = "L'objet ne possde pas cette mthode" ;
+ Text [ dutch ] = "Object kent deze methode niet" ;
+ Text [ spanish ] = "El objeto no tiene este mtodo" ;
+ Text [ danish ] = "Objekt har ikke denne metode" ;
+ Text [ swedish ] = "Objektet har inte denna metod" ;
+ Text [ finnish ] = "Object does not have method" ;
+ Text [ english_us ] = "Object does not have this method" ;
+ Text[ chinese_simplified ] = "󲻾߱";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Obiekt nie ma tej metody";
+ Text[ japanese ] = "޼ުĂɂҿނ͂܂";
+ Text[ chinese_traditional ] = "󤣨ƳoӤk";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Object kent deze methode niet";
+ Text[ chinese_simplified ] = "󲻾߱";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ü ޼ҵ带 ʽϴ.";
+ Text[ turkish ] = "Nesne bu ynteme sahip deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_ARG_MISSING & ERRCODE_RES_MASK
+ {
+ Text = "Erforderliches Argument fehlt" ;
+ Text [ ENGLISH ] = "Missing required argument" ;
+ Text [ norwegian ] = "Missing required argument" ;
+ Text [ italian ] = "L'argomento richiesto manca" ;
+ Text [ portuguese_brazilian ] = "Missing required argument" ;
+ Text [ portuguese ] = "Falta o argumento necessrio" ;
+ Text [ french ] = "L'argument requis fait dfaut" ;
+ Text [ dutch ] = "Noordzakelijk argument ontbreekt" ;
+ Text [ spanish ] = "Falta el argumento requerido" ;
+ Text [ danish ] = "Pkrvet argument mangler" ;
+ Text [ swedish ] = "Ndvndigt argument saknas" ;
+ Text [ finnish ] = "Missing required argument" ;
+ Text [ english_us ] = "Required argument lacking" ;
+ Text[ chinese_simplified ] = "ȱٱҪԱ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Brakuje wymaganego argumentu";
+ Text[ japanese ] = "KvȈ܂";
+ Text[ chinese_traditional ] = "ʤ֥nܶq";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Noordzakelijk argument ontbreekt";
+ Text[ chinese_simplified ] = "ȱٱҪԱ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "û ϴ";
+ Text[ turkish ] = "Gerekli argman eksik";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_NUMBER_OF_ARGS & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ungltige Anzahl von Argumenten : Ungltige Anzahl von Argumenten */
+ Text = "Ungltige Anzahl von Argumenten" ;
+ Text [ ENGLISH ] = "Invalid number of arguments" ;
+ Text [ norwegian ] = "Invalid number of arguments" ;
+ Text [ italian ] = "Numero di argomenti non valido" ;
+ Text [ portuguese_brazilian ] = "Invalid number of arguments" ;
+ Text [ portuguese ] = "Nmero de argumentos incorrecto" ;
+ Text [ french ] = "Nombre d'arguments incorrect" ;
+ Text [ dutch ] = "Ongeldig aantal argumenten" ;
+ Text [ spanish ] = "Nmero de argumentos no vlido" ;
+ Text [ danish ] = "Ugyldigt antal argumenter" ;
+ Text [ swedish ] = "Ogiltigt antal argument" ;
+ Text [ finnish ] = "Invalid number of arguments" ;
+ Text [ english_us ] = "Invalid number of arguments" ;
+ Text[ chinese_simplified ] = "ЧԱĿ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nieprawidowa ilo argumentw";
+ Text[ japanese ] = "̐ɖ肪܂";
+ Text[ chinese_traditional ] = "ܶqƥصL";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Ongeldig aantal argumenten";
+ Text[ chinese_simplified ] = "ЧԱĿ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ȿ ";
+ Text[ turkish ] = "Argman says geersiz";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_METHOD_FAILED & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Fehler in Ausfhrung einer Methode : Fehler in Ausfhrung einer Methode */
+ Text = "Fehler in Ausfhrung einer Methode" ;
+ Text [ ENGLISH ] = "Method failed" ;
+ Text [ norwegian ] = "Method failed" ;
+ Text [ italian ] = "Errore nell'esecuzione di un metodo" ;
+ Text [ portuguese_brazilian ] = "Method failed" ;
+ Text [ portuguese ] = "Erro ao executar mtodo" ;
+ Text [ french ] = "Erreur dans l'excution d'une mthode" ;
+ Text [ dutch ] = "Fout in uitvoering van een methode" ;
+ Text [ spanish ] = "Error al ejecutar un mtodo" ;
+ Text [ danish ] = "Fejl ved udfrelsen af en metode" ;
+ Text [ swedish ] = "Fel vid utfrandet av en metod" ;
+ Text [ finnish ] = "Method failed" ;
+ Text [ english_us ] = "Error executing a method" ;
+ Text[ chinese_simplified ] = "зʱ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Bd w wykonywaniu metody";
+ Text[ japanese ] = "ҿގs̴װ";
+ Text[ chinese_traditional ] = "BkɵoͿ~";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Fout in uitvoering van een methode";
+ Text[ chinese_simplified ] = "зʱ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "޼ҵ ";
+ Text[ turkish ] = "Yntemin yrtlmesinde hata";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_SETPROP_FAILED & ERRCODE_RES_MASK
+ {
+ Text = "Eigenschaft konnte nicht festgelegt werden" ;
+ Text [ ENGLISH ] = "Unable to set property" ;
+ Text [ norwegian ] = "Unable to set property" ;
+ Text [ italian ] = "Impossibile impostare la propriet" ;
+ Text [ portuguese_brazilian ] = "Unable to set property" ;
+ Text [ portuguese ] = "Foi impossvel definir propriedade" ;
+ Text [ french ] = "Impossible de dfinir la proprit" ;
+ Text [ dutch ] = "Eigenschap kon niet worden gedefinieerd" ;
+ Text [ spanish ] = "No se pudo determinar la propiedad" ;
+ Text [ danish ] = "Det var ikke muligt at definere egenskaben" ;
+ Text [ swedish ] = "Egenskap kunde inte definieras" ;
+ Text [ finnish ] = "Unable to set property" ;
+ Text [ english_us ] = "Unable to set property" ;
+ Text[ chinese_simplified ] = "޷ȷ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Waciwo nie moga zosta zdefiniowana";
+ Text[ japanese ] = "͎wł܂ł";
+ Text[ chinese_traditional ] = "LkTwݩ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Eigenschap kon niet worden gedefinieerd";
+ Text[ chinese_simplified ] = "޷ȷ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "Ƽ Ҽ ϴ.";
+ Text[ turkish ] = "zellik tanmlanamad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_GETPROP_FAILED & ERRCODE_RES_MASK
+ {
+ Text = "Eigenschaft konnte nicht ermittelt werden" ;
+ Text [ ENGLISH ] = "Unable to get property" ;
+ Text [ norwegian ] = "Unable to get property" ;
+ Text [ italian ] = "Impossibile individuare la propriet" ;
+ Text [ portuguese_brazilian ] = "Unable to get property" ;
+ Text [ portuguese ] = "Foi impossvel determinar a propriedade" ;
+ Text [ french ] = "Impossible de dterminer la proprit" ;
+ Text [ dutch ] = "Eigenschap kon niet worden vastgesteld" ;
+ Text [ spanish ] = "No se pudo determinar la propiedad" ;
+ Text [ danish ] = "Det var ikke muligt at bestemme egenskaben" ;
+ Text [ swedish ] = "Egenskaperna kunde inte bestmmas" ;
+ Text [ finnish ] = "Unable to get property" ;
+ Text [ english_us ] = "Unable to determine property" ;
+ Text[ chinese_simplified ] = "޷";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Waciwo nie moga zosta zdefiniowana";
+ Text[ japanese ] = "͊m߂邱Ƃł܂ł";
+ Text[ chinese_traditional ] = "LkŪXݩ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Eigenschap kon niet worden vastgesteld";
+ Text[ chinese_simplified ] = "޷";
+ Text[ greek ] = " ";
+ Text[ korean ] = "Ƽ Ҽ ϴ.";
+ Text[ turkish ] = "zellik belirlenemedi";
+ Text[ language_user1 ] = " ";
+ };
+ // Compiler errors. These are not runtime errors.
+ String SbERR_UNEXPECTED & ERRCODE_RES_MASK
+ {
+ Text = "Unerwartetes Symbol: $(ARG1)" ;
+ Text [ ENGLISH ] = "Unexpected symbol: $(ARG1)" ;
+ Text [ norwegian ] = "Unexpected symbol: $(ARG1)" ;
+ Text [ italian ] = "Simbolo inatteso: $(ARG1)" ;
+ Text [ portuguese_brazilian ] = "Unexpected symbol: $(ARG1)" ;
+ Text [ portuguese ] = "Smbolo inesperado: $(ARG1)" ;
+ Text [ french ] = "Symbole imprvu : $(ARG1)" ;
+ Text [ dutch ] = "Onverwacht symbool: $(ARG1)" ;
+ Text [ spanish ] = "Smbolo inesperado: $(ARG1)" ;
+ Text [ danish ] = "Uventet symbol: $(ARG1)" ;
+ Text [ swedish ] = "Ovntad symbol: $(ARG1)" ;
+ Text [ finnish ] = "Unexpected symbol: $(ARG1)" ;
+ Text [ english_us ] = "Unexpected symbol: $(ARG1)" ;
+ Text[ chinese_simplified ] = "ͼ꣺$(ARG1)";
+ Text[ russian ] = " : $(ARG1)";
+ Text[ polish ] = "Nieoczekiwany symbol: $(ARG1)";
+ Text[ japanese ] = "sKȼ: $(ARG1)";
+ Text[ chinese_traditional ] = "N~ϥܡG$(ARG1)";
+ Text[ arabic ] = "$(ARG1) : ";
+ Text[ dutch ] = "Onverwacht symbool: $(ARG1)";
+ Text[ chinese_simplified ] = "ͼ꣺$(ARG1)";
+ Text[ greek ] = " : $(ARG1)";
+ Text[ korean ] = " ȣ : $(ARG1)";
+ Text[ turkish ] = "Beklenmeyen simge: $(ARG1)";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_EXPECTED & ERRCODE_RES_MASK
+ {
+ Text = "Erwartet: $(ARG1)" ;
+ Text [ ENGLISH ] = "Expected: $(ARG1)" ;
+ Text [ norwegian ] = "Expected: $(ARG1)" ;
+ Text [ italian ] = "Atteso: $(ARG1)" ;
+ Text [ portuguese_brazilian ] = "Expected: $(ARG1)" ;
+ Text [ portuguese ] = "Esperado: $(ARG1)" ;
+ Text [ french ] = "Requis : $(ARG1)" ;
+ Text [ dutch ] = "Verwacht: $(ARG1)" ;
+ Text [ spanish ] = "Se espera: $(ARG1)" ;
+ Text [ danish ] = "Forventet: $(ARG1)" ;
+ Text [ swedish ] = "Frvntad: $(ARG1)" ;
+ Text [ finnish ] = "Expected: $(ARG1)" ;
+ Text [ english_us ] = "Expected: $(ARG1)" ;
+ Text[ chinese_simplified ] = "ȴ$(ARG1)";
+ Text[ russian ] = ": $(ARG1)";
+ Text[ polish ] = "Oczekiwany: $(ARG1)";
+ Text[ japanese ] = "Kv: $(ARG1)";
+ Text[ chinese_traditional ] = "ݡG$(ARG1)";
+ Text[ arabic ] = "$(ARG1) :";
+ Text[ dutch ] = "Verwacht: $(ARG1)";
+ Text[ chinese_simplified ] = "ȴ$(ARG1)";
+ Text[ greek ] = ": $(ARG1)";
+ Text[ korean ] = ": $(ARG1)";
+ Text[ turkish ] = "Beklenen: $(ARG1)";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_SYMBOL_EXPECTED & ERRCODE_RES_MASK
+ {
+ Text = "Symbol erwartet" ;
+ Text [ ENGLISH ] = "Symbol expected" ;
+ Text [ norwegian ] = "Symbol expected" ;
+ Text [ italian ] = "Simbolo atteso" ;
+ Text [ portuguese_brazilian ] = "Symbol expected" ;
+ Text [ portuguese ] = "Smbolo esperado" ;
+ Text [ french ] = "Symbole requis" ;
+ Text [ dutch ] = "Symbool verwacht" ;
+ Text [ spanish ] = "Smbolo esperado" ;
+ Text [ danish ] = "Symbol forventes" ;
+ Text [ swedish ] = "Symbol frvntad" ;
+ Text [ finnish ] = "Symbol expected" ;
+ Text [ english_us ] = "Symbol expected" ;
+ Text[ chinese_simplified ] = "ȴͼ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Oczekiwany symbol";
+ Text[ japanese ] = "قKvł";
+ Text[ chinese_traditional ] = "ݹϥ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Symbool verwacht";
+ Text[ chinese_simplified ] = "ȴͼ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ȣ";
+ Text[ turkish ] = "Simge bekleniyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_VAR_EXPECTED & ERRCODE_RES_MASK
+ {
+ Text = "Variable erwartet" ;
+ Text [ ENGLISH ] = "Variable expected" ;
+ Text [ norwegian ] = "Variable expected" ;
+ Text [ italian ] = "Variabile attesa" ;
+ Text [ portuguese_brazilian ] = "Variable expected" ;
+ Text [ portuguese ] = "Varivel esperada" ;
+ Text [ french ] = "Variable requise" ;
+ Text [ dutch ] = "Variabele verwacht" ;
+ Text [ spanish ] = "Se requiere una variable" ;
+ Text [ danish ] = "Variabel forventes" ;
+ Text [ swedish ] = "Variabel frvntad" ;
+ Text [ finnish ] = "Variable expected" ;
+ Text [ english_us ] = "Variable expected" ;
+ Text[ chinese_simplified ] = "ȴ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Zmienna oczekiwana";
+ Text[ japanese ] = "ϐKvł";
+ Text[ chinese_traditional ] = "ܶq";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Variabele verwacht";
+ Text[ chinese_simplified ] = "ȴ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ";
+ Text[ turkish ] = "Deiken bekleniyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_LABEL_EXPECTED & ERRCODE_RES_MASK
+ {
+ Text = "Label erwartet" ;
+ Text [ ENGLISH ] = "Label expected" ;
+ Text [ norwegian ] = "Label expected" ;
+ Text [ italian ] = "Label attesa" ;
+ Text [ portuguese_brazilian ] = "Label expected" ;
+ Text [ portuguese ] = "Etiqueta esperada" ;
+ Text [ french ] = "tiquette requise" ;
+ Text [ dutch ] = "Label verwacht" ;
+ Text [ spanish ] = "Se requiere una etiqueta" ;
+ Text [ danish ] = "Etiket forventes" ;
+ Text [ swedish ] = "Etikett frvntad" ;
+ Text [ finnish ] = "Label expected" ;
+ Text [ english_us ] = "Label expected" ;
+ Text[ chinese_simplified ] = "ȴ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Oczekiwana etykieta";
+ Text[ japanese ] = "قKvł";
+ Text[ chinese_traditional ] = "ݼи";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Label verwacht";
+ Text[ chinese_simplified ] = "ȴ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ";
+ Text[ turkish ] = "Etiket bekleniyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_LVALUE_EXPECTED & ERRCODE_RES_MASK
+ {
+ Text = "Wert kann nicht zugewiesen werden" ;
+ Text [ ENGLISH ] = "Cannot set value" ;
+ Text [ norwegian ] = "Cannot set value" ;
+ Text [ italian ] = "Impossibile attribuitre il valore" ;
+ Text [ portuguese_brazilian ] = "Cannot set value" ;
+ Text [ portuguese ] = "Impossvel atribuir o valor" ;
+ Text [ french ] = "Impossible d'attribuer la valeur" ;
+ Text [ dutch ] = "Waarde kan niet worden toegewezen" ;
+ Text [ spanish ] = "No se puede asignar el valor" ;
+ Text [ danish ] = "Vrdien kan ikke tildeles" ;
+ Text [ swedish ] = "Vrdet kan inte tilldelas" ;
+ Text [ finnish ] = "Cannot set value" ;
+ Text [ english_us ] = "Value cannot be applied" ;
+ Text[ chinese_simplified ] = "޷ֵָ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nie mona zastosowa wartoci";
+ Text[ japanese ] = "l͊蓖Ă܂";
+ Text[ chinese_traditional ] = "Lkwƭ";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Waarde kan niet worden toegewezen";
+ Text[ chinese_simplified ] = "޷ֵָ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " ϴ.";
+ Text[ turkish ] = "Deer atanamyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_VAR_DEFINED & ERRCODE_RES_MASK
+ {
+ Text = "Variable $(ARG1) bereits definiert" ;
+ Text [ ENGLISH ] = "Variable $(ARG1) already defined" ;
+ Text [ norwegian ] = "Variable $(ARG1) already defined" ;
+ Text [ italian ] = "Variabile $(ARG1) gi definita" ;
+ Text [ portuguese_brazilian ] = "Variable $(ARG1) already defined" ;
+ Text [ portuguese ] = "Varivel $(ARG1) j definida" ;
+ Text [ french ] = "La variable $(ARG1) est dj dfinie" ;
+ Text [ dutch ] = "Variabele $(ARG1) reeds gedefinieerd" ;
+ Text [ spanish ] = "La variable $(ARG1) ya se ha definido" ;
+ Text [ danish ] = "Variabel $(ARG1) er allerede defineret" ;
+ Text [ swedish ] = "Variabeln $(ARG1) r redan definierad" ;
+ Text [ finnish ] = "Variable $(ARG1) already defined" ;
+ Text [ english_us ] = "Variable $(ARG1) already defined" ;
+ Text[ chinese_simplified ] = "Ѿ˱ $(ARG1)";
+ Text[ russian ] = " $(ARG1) ";
+ Text[ polish ] = "Zmienna $(ARG1) ju zdefiniowana";
+ Text[ japanese ] = "ϐ$(ARG1)͂łɒ`Ă܂";
+ Text[ chinese_traditional ] = "wgwqFܶq $(ARG1)";
+ Text[ arabic ] = " $(ARG1) ";
+ Text[ dutch ] = "Variabele $(ARG1) reeds gedefinieerd";
+ Text[ chinese_simplified ] = "Ѿ˱ $(ARG1)";
+ Text[ greek ] = " $(ARG1) ";
+ Text[ korean ] = "$(ARG1) ̹ ǵǾֽϴ.";
+ Text[ turkish ] = "Deiken $(ARG1) tanmlanm durumda";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_PROC_DEFINED & ERRCODE_RES_MASK
+ {
+ Text = "Sub- oder Function-Prozedur $(ARG1) bereits definiert" ;
+ Text [ ENGLISH ] = "Procedure $(ARG1) already defined" ;
+ Text [ norwegian ] = "Procedure $(ARG1) already defined" ;
+ Text [ italian ] = "Procedura subordinata o di funzione $(ARG1) gi definita" ;
+ Text [ portuguese_brazilian ] = "Procedure $(ARG1) already defined" ;
+ Text [ portuguese ] = "Procedimento subordinado ou de funo $(ARG1) j definidos" ;
+ Text [ french ] = "La sous-procdure ou procdure fonctionnelle $(ARG1) est dj dfinie" ;
+ Text [ dutch ] = "Sub- of functieprocedure $(ARG1) reeds gedefinieerd" ;
+ Text [ spanish ] = "El procedimiento de funcin o subordinado $(ARG1) ya est definido" ;
+ Text [ danish ] = "Under- eller funktionsprocedure $(ARG1) er allerede defineret" ;
+ Text [ swedish ] = "Sub- eller funktionsproceduren $(ARG1) r redan definierad" ;
+ Text [ finnish ] = "Procedure $(ARG1) already defined" ;
+ Text [ english_us ] = "Sub procedure or function procedure $(ARG1) already defined" ;
+ Text[ chinese_simplified ] = "Ѿ˷ֹ̻ $(ARG1)";
+ Text[ russian ] = " $(ARG1) ";
+ Text[ polish ] = "Procedura podrzdna lub funkcyjna ju zostaa zdefiniowana $(ARG1)";
+ Text[ japanese ] = "Sub܂Functionۼެ$(ARG1)͂łɒ`Ă܂";
+ Text[ chinese_traditional ] = "wgwqFL{ΨƹL{$(ARG1)";
+ Text[ arabic ] = " $(ARG1) ";
+ Text[ dutch ] = "Sub- of functieprocedure $(ARG1) reeds gedefinieerd";
+ Text[ chinese_simplified ] = "Ѿ˷ֹ̻ $(ARG1)";
+ Text[ greek ] = " (Sub) (Function) $(ARG1) ";
+ Text[ korean ] = " Ǵ Լ ν $(ARG1) ̹ Ǿֽϴ";
+ Text[ turkish ] = "Alt yordam ya da ilev yordam $(ARG1) tanmlanm durumda";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_LABEL_DEFINED & ERRCODE_RES_MASK
+ {
+ Text = "Label $(ARG1) bereits definiert" ;
+ Text [ ENGLISH ] = "Label $(ARG1) already defined" ;
+ Text [ norwegian ] = "Label $(ARG1) already defined" ;
+ Text [ italian ] = "Label $(ARG1) gi definita" ;
+ Text [ portuguese_brazilian ] = "Label $(ARG1) already defined" ;
+ Text [ portuguese ] = "Etiqueta $(ARG1) j foi definida" ;
+ Text [ french ] = "L'tiquette $(ARG1) est dj dfinie" ;
+ Text [ dutch ] = "Label $(ARG1) reeds gedefinieerd" ;
+ Text [ spanish ] = "La etiqueta $(ARG1) ya est definida" ;
+ Text [ danish ] = "Etiket $(ARG1) er allerede defineret" ;
+ Text [ swedish ] = "Etiketten $(ARG1) r redan definierad" ;
+ Text [ finnish ] = "Label $(ARG1) already defined" ;
+ Text [ english_us ] = "Label $(ARG1) already defined" ;
+ Text[ chinese_simplified ] = "Ѿ˱ $(ARG1)";
+ Text[ russian ] = " $(ARG1) ";
+ Text[ polish ] = "Etykieta $(ARG1) zostaa ju zdefiniowana";
+ Text[ japanese ] = "$(ARG1)͂łɒ`Ă܂";
+ Text[ chinese_traditional ] = "wgwqFаO$(ARG1)";
+ Text[ arabic ] = " $(ARG1) ";
+ Text[ dutch ] = "Label $(ARG1) reeds gedefinieerd";
+ Text[ chinese_simplified ] = "Ѿ˱ $(ARG1)";
+ Text[ greek ] = " $(ARG1) ";
+ Text[ korean ] = " $(ARG1) ̹ Ǿֽϴ.";
+ Text[ turkish ] = "Etiket $(ARG1) tanmlanm durumda";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_UNDEF_VAR & ERRCODE_RES_MASK
+ {
+ Text = "Variable $(ARG1) nicht gefunden" ;
+ Text [ ENGLISH ] = "Variable $(ARG1) not found" ;
+ Text [ norwegian ] = "Variable $(ARG1) not found" ;
+ Text [ italian ] = "Variabile $(ARG1) non trovata" ;
+ Text [ portuguese_brazilian ] = "Variable $(ARG1) not found" ;
+ Text [ portuguese ] = "Varivel $(ARG1) no encontrada" ;
+ Text [ french ] = "Variable $(ARG1) introuvable" ;
+ Text [ dutch ] = "Variabele $(ARG1) niet gevonden" ;
+ Text [ spanish ] = "No se encontr la variable $(ARG1)" ;
+ Text [ danish ] = "Variabel $(ARG1) blev ikke fundet" ;
+ Text [ swedish ] = "Variabeln $(ARG1) hittades inte" ;
+ Text [ finnish ] = "Variable $(ARG1) not found" ;
+ Text [ english_us ] = "Variable $(ARG1) not found" ;
+ Text[ chinese_simplified ] = "ûҵ $(ARG1)";
+ Text[ russian ] = " $(ARG1) ";
+ Text[ polish ] = "Zmiennej $(ARG1) nie znaleziono";
+ Text[ japanese ] = "ϐ$(ARG1)͌‚܂";
+ Text[ chinese_traditional ] = "Sܶq$(ARG1)";
+ Text[ arabic ] = " $(ARG1) ";
+ Text[ dutch ] = "Variabele $(ARG1) niet gevonden";
+ Text[ chinese_simplified ] = "ûҵ $(ARG1)";
+ Text[ greek ] = " $(ARG1) ";
+ Text[ korean ] = " $(ARG1) ߰ߵ ʾҽϴ.";
+ Text[ turkish ] = "Deiken $(ARG1) bulunamad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_UNDEF_ARRAY & ERRCODE_RES_MASK
+ {
+ Text = "Array oder Prozedur $(ARG1) nicht gefunden" ;
+ Text [ ENGLISH ] = "Array or function $(ARG1) not found" ;
+ Text [ norwegian ] = "Array or function $(ARG1) not found" ;
+ Text [ italian ] = "Array o procedura $(ARG1) non trovata" ;
+ Text [ portuguese_brazilian ] = "Array or function $(ARG1) not found" ;
+ Text [ portuguese ] = "Matriz ou funo $(ARG1) no encontrados" ;
+ Text [ french ] = "Array ou procdure $(ARG1) introuvable" ;
+ Text [ dutch ] = "Array of procedure $(ARG1) niet gevonden" ;
+ Text [ spanish ] = "No se encontr la matriz o procedimiento $(ARG1)" ;
+ Text [ danish ] = "Array eller procedure $(ARG1) blev ikke fundet" ;
+ Text [ swedish ] = "Array eller procedur $(ARG1) hittades inte" ;
+ Text [ finnish ] = "Array or function $(ARG1) not found" ;
+ Text [ english_us ] = "Array or procedure $(ARG1) not found" ;
+ Text[ chinese_simplified ] = "ûҵ $(ARG1)";
+ Text[ russian ] = " $(ARG1) ";
+ Text[ polish ] = "Tablicy lub procedury $(ARG1) nie znaleziono";
+ Text[ japanese ] = "z܂ۼެ$(ARG1)͌‚܂";
+ Text[ chinese_traditional ] = "SCιL{$(ARG1)";
+ Text[ arabic ] = "$(ARG1) ";
+ Text[ dutch ] = "Array of procedure $(ARG1) niet gevonden";
+ Text[ chinese_simplified ] = "ûҵ $(ARG1)";
+ Text[ greek ] = " $(ARG1)";
+ Text[ korean ] = "迭 Ǵ Լ $(ARG1) ߰ߵ ʾҽϴ. ";
+ Text[ turkish ] = "Dizi ya da yordam $(ARG1) bulunamad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_UNDEF_PROC & ERRCODE_RES_MASK
+ {
+ Text = "Procedure $(ARG1) nicht gefunden" ;
+ Text [ ENGLISH ] = "Procedure $(ARG1) not found" ;
+ Text [ norwegian ] = "Procedure $(ARG1) not found" ;
+ Text [ italian ] = "Procedura $(ARG1) non trovata" ;
+ Text [ portuguese_brazilian ] = "Procedure $(ARG1) not found" ;
+ Text [ portuguese ] = "Procedimento $(ARG1) no encontrado" ;
+ Text [ french ] = "Procdure $(ARG1) introuvable" ;
+ Text [ dutch ] = "Procedure $(ARG1) niet gevonden" ;
+ Text [ spanish ] = "No se encontr el procedimiento $(ARG1)" ;
+ Text [ danish ] = "Procedure $(ARG1) blev ikke fundet" ;
+ Text [ swedish ] = "Proceduren $(ARG1) hittades inte" ;
+ Text [ finnish ] = "Procedure $(ARG1) not found" ;
+ Text [ english_us ] = "Procedure $(ARG1) not found" ;
+ Text[ chinese_simplified ] = "ûҵ $(ARG1)";
+ Text[ russian ] = " $(ARG1) ";
+ Text[ polish ] = "Procedury $(ARG1) nie znaleziono";
+ Text[ japanese ] = "ۼެ$(ARG1)͌‚܂";
+ Text[ chinese_traditional ] = "SL{$(ARG1)";
+ Text[ arabic ] = "$(ARG1) ";
+ Text[ dutch ] = "Procedure $(ARG1) niet gevonden";
+ Text[ chinese_simplified ] = "ûҵ $(ARG1)";
+ Text[ greek ] = " $(ARG1) ";
+ Text[ korean ] = "ν $(ARG1) ߰ߵ ʾҽϴ.";
+ Text[ turkish ] = "Yordam $(ARG1) bulunamad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_UNDEF_LABEL & ERRCODE_RES_MASK
+ {
+ Text = "Label $(ARG1) undefiniert" ;
+ Text [ ENGLISH ] = "Label $(ARG1) undefined" ;
+ Text [ norwegian ] = "Label $(ARG1) undefined" ;
+ Text [ italian ] = "Label $(ARG1) non definita" ;
+ Text [ portuguese_brazilian ] = "Label $(ARG1) undefined" ;
+ Text [ portuguese ] = "Rtulo $(ARG1) indefinido" ;
+ Text [ french ] = "L'tiquette $(ARG1) n'est pas dfinie" ;
+ Text [ dutch ] = "Label $(ARG1) ongedefinieerd" ;
+ Text [ spanish ] = "La etiqueta $(ARG1) no est definida" ;
+ Text [ danish ] = "Etket $(ARG1) er udefineret" ;
+ Text [ swedish ] = "Etiketten $(ARG1) r odefinierad" ;
+ Text [ finnish ] = "Label $(ARG1) undefined" ;
+ Text [ english_us ] = "Label $(ARG1) undefined" ;
+ Text[ chinese_simplified ] = "δ $(ARG1)";
+ Text[ russian ] = " $(ARG1) ";
+ Text[ polish ] = "Etykieta $(ARG1) nie jest zdefionowana";
+ Text[ japanese ] = "$(ARG1)͒`Ă܂";
+ Text[ chinese_traditional ] = "|wqаO$(ARG1)";
+ Text[ arabic ] = " $(ARG1) ";
+ Text[ dutch ] = "Label $(ARG1) ongedefinieerd";
+ Text[ chinese_simplified ] = "δ $(ARG1)";
+ Text[ greek ] = " $(ARG1)";
+ Text[ korean ] = " $(ARG1) ǵ ʾҽϴ.";
+ Text[ turkish ] = "Etiket $(ARG1) tanmlanmad";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_UNDEF_TYPE & ERRCODE_RES_MASK
+ {
+ Text = "Unbekannter Datentyp $(ARG1)" ;
+ Text [ ENGLISH ] = "Unknown data type $(ARG1)" ;
+ Text [ norwegian ] = "Unknown data type $(ARG1)" ;
+ Text [ italian ] = "Tipo di dati $(ARG1) sconosciuto" ;
+ Text [ portuguese_brazilian ] = "Unknown data type $(ARG1)" ;
+ Text [ portuguese ] = "Tipo de dados $(ARG1) desconhecido" ;
+ Text [ french ] = "Type de donnes $(ARG1) inconnu" ;
+ Text [ dutch ] = "Onbekend gegevenstype $(ARG1)" ;
+ Text [ spanish ] = "Tipo de datos $(ARG1) desconocido" ;
+ Text [ danish ] = "Ukendt datatype $(ARG1)" ;
+ Text [ swedish ] = "Oknd datatyp $(ARG1)" ;
+ Text [ finnish ] = "Unknown data type $(ARG1)" ;
+ Text [ english_us ] = "Unknown data type $(ARG1)" ;
+ Text[ chinese_simplified ] = " $(ARG1)";
+ Text[ russian ] = " $(ARG1)";
+ Text[ polish ] = "Nieznany typ danych $(ARG1)";
+ Text[ japanese ] = "sް̎$(ARG1)";
+ Text[ chinese_traditional ] = " $(ARG1)";
+ Text[ arabic ] = "$(ARG1) ";
+ Text[ dutch ] = "Onbekend gegevenstype $(ARG1)";
+ Text[ chinese_simplified ] = " $(ARG1)";
+ Text[ greek ] = " $(ARG1)";
+ Text[ korean ] = "˷ Ÿ $(ARG1)";
+ Text[ turkish ] = "Bilinmeyen veri tipi $(ARG1)";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_EXIT & ERRCODE_RES_MASK
+ {
+ Text = "Exit $(ARG1) erwartet" ;
+ Text [ ENGLISH ] = "Exit $(ARG1) erwartet" ;
+ Text [ norwegian ] = "Exit $(ARG1) erwartet" ;
+ Text [ italian ] = "Exit $(ARG1) atteso" ;
+ Text [ portuguese_brazilian ] = "Exit $(ARG1) erwartet" ;
+ Text [ portuguese ] = "Sada de $(ARG1) esperada" ;
+ Text [ french ] = "Exit $(ARG1) requis" ;
+ Text [ dutch ] = "Exit $(ARG1) verwacht" ;
+ Text [ spanish ] = "Se requiere salida $(ARG1)" ;
+ Text [ danish ] = "Exit $(ARG1) forventes" ;
+ Text [ swedish ] = "Exit $(ARG1) frvntat" ;
+ Text [ finnish ] = "Exit $(ARG1) erwartet" ;
+ Text [ english_us ] = "Exit $(ARG1) expected" ;
+ Text[ chinese_simplified ] = "Ⱥ˳ $(ARG1)";
+ Text[ russian ] = " $(ARG1)";
+ Text[ polish ] = "Oczekiwany koniec $(ARG1)";
+ Text[ japanese ] = "$(ARG1)̏IKvł";
+ Text[ chinese_traditional ] = "԰hX$(ARG1)";
+ Text[ arabic ] = " $(ARG1)";
+ Text[ dutch ] = "Exit $(ARG1) verwacht";
+ Text[ chinese_simplified ] = "Ⱥ˳ $(ARG1)";
+ Text[ greek ] = " Exit $(ARG1)";
+ Text[ korean ] = " $(ARG1)";
+ Text[ turkish ] = "k $(ARG1) bekleniyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_BLOCK & ERRCODE_RES_MASK
+ {
+ Text = "Noch offener Anweisungsblock: $(ARG1) fehlt" ;
+ Text [ ENGLISH ] = "Unterminated statement block: missing $(ARG1)" ;
+ Text [ norwegian ] = "Unterminated statement block: missing $(ARG1)" ;
+ Text [ italian ] = "Blocco di comandi ancora aperto: manca $(ARG1)" ;
+ Text [ portuguese_brazilian ] = "Unterminated statement block: missing $(ARG1)" ;
+ Text [ portuguese ] = "Bloco de instrues ainda incompleto: falta $(ARG1)" ;
+ Text [ french ] = "Bloc d'instructions encore ouvert : $(ARG1) fait dfaut" ;
+ Text [ dutch ] = "Nog open aanwijzingenblok $(ARG1) ontbreekt" ;
+ Text [ spanish ] = "Bloque de instrucciones incompleto: falta $(ARG1) " ;
+ Text [ danish ] = "Endnu ben instruktionsblok: $(ARG1) mangler" ;
+ Text [ swedish ] = "Icke avslutat statementblock: $(ARG1) saknas" ;
+ Text [ finnish ] = "Unterminated statement block: missing $(ARG1)" ;
+ Text [ english_us ] = "Statement block still open: $(ARG1) missing" ;
+ Text[ chinese_simplified ] = "ȱδķֳ飺$(ARG1)";
+ Text[ russian ] = " : $(ARG1)";
+ Text[ polish ] = "Jeszcze otwarty blok instrukcji: brak $(ARG1)";
+ Text[ japanese ] = "܂J܂܂̎wۯ: $(ARG1)܂";
+ Text[ chinese_traditional ] = "ٯʤ֥{ǶG$(ARG1)";
+ Text[ arabic ] = " : $(ARG1) ";
+ Text[ dutch ] = "Nog open aanwijzingenblok $(ARG1) ontbreekt";
+ Text[ chinese_simplified ] = "ȱδķֳ飺$(ARG1)";
+ Text[ greek ] = " : $(ARG1) .";
+ Text[ korean ] = " ֽϴ. :$(ARG1) ϴ.";
+ Text[ turkish ] = "Ak deyim bloku: $(ARG1) eksik";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_BRACKETS & ERRCODE_RES_MASK
+ {
+ Text = "Fehler in Klammerschachtelung" ;
+ Text [ ENGLISH ] = "Parentheses do not match" ;
+ Text [ norwegian ] = "Parentheses do not match" ;
+ Text [ italian ] = "Errore nelle parentesi impostate" ;
+ Text [ portuguese_brazilian ] = "Parentheses do not match" ;
+ Text [ portuguese ] = "Erro nos parnteses" ;
+ Text [ french ] = "Erreur de parenthses" ;
+ Text [ dutch ] = "Fout in het plaatsen van haakjes" ;
+ Text [ spanish ] = "Los parntesis no coinciden" ;
+ Text [ danish ] = "Fejl i parentesstrukturen" ;
+ Text [ swedish ] = "Parentesfel" ;
+ Text [ finnish ] = "Parentheses do not match" ;
+ Text [ english_us ] = "Parentheses do not match" ;
+ Text[ chinese_simplified ] = "";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Bd w ustawianiu nawiasw";
+ Text[ japanese ] = "ʕt̴װ";
+ Text[ chinese_traditional ] = "Aտ~";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Fout in het plaatsen van haakjes";
+ Text[ chinese_simplified ] = "";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ȣ ʽϴ.";
+ Text[ turkish ] = "Ayralar uyumsuz";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_DECLARATION & ERRCODE_RES_MASK
+ {
+ Text = "Symbol $(ARG1) bereits anders definiert" ;
+ Text [ ENGLISH ] = "Symbol $(ARG1) defined differently" ;
+ Text [ norwegian ] = "Symbol $(ARG1) defined differently" ;
+ Text [ italian ] = "Simbolo $(ARG1) gi definito diversamente" ;
+ Text [ portuguese_brazilian ] = "Symbol $(ARG1) defined differently" ;
+ Text [ portuguese ] = "O smbolo $(ARG1) j tem outra definio" ;
+ Text [ french ] = "Le symbole $(ARG1) a dj reu une autre dfinition" ;
+ Text [ dutch ] = "Symbool $(ARG1) reeds anders gedefinieerd" ;
+ Text [ spanish ] = "El smbolo $(ARG1) ya se defini de otra manera" ;
+ Text [ danish ] = "Symbolet $(ARG1) er allerede defineret anderledes" ;
+ Text [ swedish ] = "Symbolen $(ARG1) r redan annorlunda definierad" ;
+ Text [ finnish ] = "Symbol $(ARG1) defined differently" ;
+ Text [ english_us ] = "Symbol $(ARG1) already defined differently" ;
+ Text[ chinese_simplified ] = "Ѿжͼ $(ARG1)";
+ Text[ russian ] = " $(ARG1) -";
+ Text[ polish ] = "Symbol $(ARG1) zosta ju inaczej zdefiniowany";
+ Text[ japanese ] = "$(ARG1)͂łɕʂɒ`Ă܂";
+ Text[ chinese_traditional ] = "wgtwqFϥ$(ARG1)";
+ Text[ arabic ] = " $(ARG1) ";
+ Text[ dutch ] = "Symbool $(ARG1) reeds anders gedefinieerd";
+ Text[ chinese_simplified ] = "Ѿжͼ $(ARG1)";
+ Text[ greek ] = " $(ARG1) ";
+ Text[ korean ] = "ȣ$(ARG1) ̹ ٸ ǵǾ ֽϴ.";
+ Text[ turkish ] = "Simge $(ARG1) farkl bir biimde tanmlanm durumda";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_PARAMETERS & ERRCODE_RES_MASK
+ {
+ Text = "Parameter passen nicht zu Prozedur" ;
+ Text [ ENGLISH ] = "Parameters do not match" ;
+ Text [ norwegian ] = "Parameters do not match" ;
+ Text [ italian ] = "Le parentesi non corrispondono alla procedura" ;
+ Text [ portuguese_brazilian ] = "Parameters do not match" ;
+ Text [ portuguese ] = "Os parmetros no correspondem ao procedimento" ;
+ Text [ french ] = "Les paramtres ne correspondent pas la procdure" ;
+ Text [ dutch ] = "Parameters passen niet bij procedure" ;
+ Text [ spanish ] = "Los parmetros no coinciden con el procedimiento" ;
+ Text [ danish ] = "Parametrene svarer ikke til proceduren" ;
+ Text [ swedish ] = "Parametern passar inte till proceduren" ;
+ Text [ finnish ] = "Parameters do not match" ;
+ Text [ english_us ] = "Parameters do not correspond to procedure" ;
+ Text[ chinese_simplified ] = "͹̲ƥ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Parametry nie odpowiadaj procedurze";
+ Text[ japanese ] = "Ұۼެɍ܂";
+ Text[ chinese_traditional ] = "UܶqML{ǰt";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Parameters passen niet bij procedure";
+ Text[ chinese_simplified ] = "͹̲ƥ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ĶͰ ν ʽϴ.";
+ Text[ turkish ] = "Parametreler yordama uymuyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_CHAR_IN_NUMBER & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ungltiges Zeichen in Zahl : Ungltiges Zeichen in Zahl */
+ Text = "Ungltiges Zeichen in Zahl" ;
+ Text [ ENGLISH ] = "Bad character in number" ;
+ Text [ norwegian ] = "Bad character in number" ;
+ Text [ italian ] = "Carattere non valido nel numero" ;
+ Text [ portuguese_brazilian ] = "Bad character in number" ;
+ Text [ portuguese ] = "Caracter incorrecto no nmero" ;
+ Text [ french ] = "Le nombre contient un caractre incorrect" ;
+ Text [ dutch ] = "Ongeldig teken in getal" ;
+ Text [ spanish ] = "Carcter incorrecto en el nmero" ;
+ Text [ danish ] = "Ugyldigt tegn i tallet" ;
+ Text [ swedish ] = "Ogiltigt tecken i talet" ;
+ Text [ finnish ] = "Bad character in number" ;
+ Text [ english_us ] = "Invalid character in number" ;
+ Text[ chinese_simplified ] = "ںЧַ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Nieprawidowy znak w liczbie";
+ Text[ japanese ] = "ɖȕ";
+ Text[ chinese_traditional ] = "bƦrtLĪr";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Ongeldig teken in getal";
+ Text[ chinese_simplified ] = "ںЧַ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ڿ ȿ ";
+ Text[ turkish ] = "Numara geersiz bir karakter ieriyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_MUST_HAVE_DIMS & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Array mu dimensioniert werden : Array mu dimensioniert werden */
+ Text = "Array muss dimensioniert werden" ;
+ Text [ ENGLISH ] = "Array needs dimensioning" ;
+ Text [ norwegian ] = "Array needs dimensioning" ;
+ Text [ italian ] = "L'array deve essere dimensionato" ;
+ Text [ portuguese_brazilian ] = "Array needs dimensioning" ;
+ Text [ portuguese ] = "Necessrio dimensionar matriz" ;
+ Text [ french ] = "Vous devez dimensionner l'Array" ;
+ Text [ dutch ] = "Array moet worden gedimensioneerd" ;
+ Text [ spanish ] = "Hay que dimensionar el array" ;
+ Text [ danish ] = "Array skal dimensioneres" ;
+ Text [ swedish ] = "Array mste dimensioneras" ;
+ Text [ finnish ] = "Array needs dimensioning" ;
+ Text [ english_us ] = "Array must be dimensioned" ;
+ Text[ chinese_simplified ] = "Ϊ鶨߶";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Macierz naley zwymiarowa";
+ Text[ japanese ] = "z͎Ȃ΂Ȃ܂";
+ Text[ chinese_traditional ] = "Cwث";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Array moet worden gedimensioneerd";
+ Text[ chinese_simplified ] = "Ϊ鶨߶";
+ Text[ greek ] = " ";
+ Text[ korean ] = "迭 ݵ ġ ־Ѵ.";
+ Text[ turkish ] = "Dizinin boyutlandrlmas gerekir";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_IF & ERRCODE_RES_MASK
+ {
+ Text = "Else/Endif ohne If" ;
+ Text [ ENGLISH ] = "Else/Endif without If" ;
+ Text [ norwegian ] = "Else/Endif without If" ;
+ Text [ italian ] = "Else/Endif senza If" ;
+ Text [ portuguese_brazilian ] = "Else/Endif without If" ;
+ Text [ portuguese ] = "Else/Endif sem If" ;
+ Text [ french ] = "Else/Endif sans If" ;
+ Text [ dutch ] = "Else/Endif zonder If" ;
+ Text [ spanish ] = "Else/Endif sin If" ;
+ Text [ danish ] = "Else/Endif uden If" ;
+ Text [ swedish ] = "Else/Endif utan If" ;
+ Text [ finnish ] = "Else/Endif without If" ;
+ Text [ english_us ] = "Else/Endif without If" ;
+ Text[ chinese_simplified ] = "Else/Endif If";
+ Text[ russian ] = "Else/Endif If";
+ Text[ polish ] = "Else/Endif bez If";
+ Text[ japanese ] = "Else/Endif without If";
+ Text[ chinese_traditional ] = "Else/Endif a If";
+ Text[ arabic ] = "If Else/Endif";
+ Text[ dutch ] = "Else/Endif zonder If";
+ Text[ chinese_simplified ] = "Else/Endif If";
+ Text[ greek ] = "Else/Endif If";
+ Text[ korean ] = "IF ELSE/ELSEIF";
+ Text[ turkish ] = "If olmadan Else/Endif";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NOT_IN_SUBR & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? $(ARG1) innerhalb einer Prozedur unzulssig : $(ARG1) innerhalb einer Prozedur unzulssig */
+ Text = "$(ARG1) innerhalb einer Prozedur unzulssig" ;
+ Text [ ENGLISH ] = "$(ARG1) not allowed within a procedure" ;
+ Text [ norwegian ] = "$(ARG1) not allowed within a procedure" ;
+ Text [ italian ] = "$(ARG1) non ammesso all'interno di una procedura" ;
+ Text [ portuguese_brazilian ] = "$(ARG1) not allowed within a procedure" ;
+ Text [ portuguese ] = "$(ARG1) no permitido dentro de um procedimento" ;
+ Text [ french ] = "$(ARG1) interdit dans une procdure" ;
+ Text [ dutch ] = "$(ARG1) binnen een procedure niet toegestaan" ;
+ Text [ spanish ] = "$(ARG1) no est permitido dentro de un proceso" ;
+ Text [ danish ] = "$(ARG1) er ikke tilladt indenfor en procedure" ;
+ Text [ swedish ] = "$(ARG1) inte tilltet inuti en procedur" ;
+ Text [ finnish ] = "$(ARG1) not allowed within a procedure" ;
+ Text [ english_us ] = "$(ARG1) not allowed within a procedure" ;
+ Text[ chinese_simplified ] = "һڲ $(ARG1)";
+ Text[ russian ] = "$(ARG1) ";
+ Text[ polish ] = "$(ARG1) niedopuszczalny w procedurze";
+ Text[ japanese ] = "$(ARG1)ۼެł͋‚܂";
+ Text[ chinese_traditional ] = "b@ӹL{\\$(ARG1)";
+ Text[ arabic ] = " $(ARG1)";
+ Text[ dutch ] = "$(ARG1) binnen een procedure niet toegestaan";
+ Text[ chinese_simplified ] = "һڲ $(ARG1)";
+ Text[ greek ] = "$(ARG1) ";
+ Text[ korean ] = "$(ARG1) ν ̿ ʽϴ.";
+ Text[ turkish ] = "Yordamda $(ARG1) geerli deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NOT_IN_MAIN & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? $(ARG1) auerhalb einer Prozedur unzulssig : $(ARG1) auerhalb einer Prozedur unzulssig */
+ Text = "$(ARG1) auerhalb einer Prozedur unzulssig" ;
+ Text [ ENGLISH ] = "$(ARG1) not allowed outside a procedure" ;
+ Text [ norwegian ] = "$(ARG1) not allowed outside a procedure" ;
+ Text [ italian ] = "$(ARG1) non permesso al di fuori di una procedura" ;
+ Text [ portuguese_brazilian ] = "$(ARG1) not allowed outside a procedure" ;
+ Text [ portuguese ] = "$(ARG1) no permitido fora de um procedimento" ;
+ Text [ french ] = "$(ARG1) interdit en dehors d'une procdure" ;
+ Text [ dutch ] = "$(ARG1) buiten een procedure niet toegestaan" ;
+ Text [ spanish ] = "$(ARG1) no est permitido fuera de un proceso" ;
+ Text [ danish ] = "$(ARG1) er ikke tilladt udenfor en procedure" ;
+ Text [ swedish ] = "$(ARG1) inte tilltet utanfr en procedur" ;
+ Text [ finnish ] = "$(ARG1) not allowed outside a procedure" ;
+ Text [ english_us ] = "$(ARG1) not allowed outside a procedure" ;
+ Text[ chinese_simplified ] = "һⲻ $(ARG1)";
+ Text[ russian ] = "$(ARG1) ";
+ Text[ polish ] = "$(ARG1) niedopuszczalny poza procedur";
+ Text[ japanese ] = "$(ARG1)ۼެOł͋‚܂";
+ Text[ chinese_traditional ] = "b@ӹL{~\\$(ARG1)";
+ Text[ arabic ] = " $(ARG1)";
+ Text[ dutch ] = "$(ARG1) buiten een procedure niet toegestaan";
+ Text[ chinese_simplified ] = "һⲻ $(ARG1)";
+ Text[ greek ] = "$(ARG1) ";
+ Text[ korean ] = "$(ARG1) νۿ ʽϴ.";
+ Text[ turkish ] = "Yordam dnda $(ARG1) geerli deil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_WRONG_DIMS & ERRCODE_RES_MASK
+ {
+ Text = "Dimensionsangaben passen nicht zueinander" ;
+ Text [ ENGLISH ] = "Dimensions do not match" ;
+ Text [ norwegian ] = "Dimensions do not match" ;
+ Text [ italian ] = "I dati sulle dimensioni non sono compatibili tra loro" ;
+ Text [ portuguese_brazilian ] = "Dimensions do not match" ;
+ Text [ portuguese ] = "As dimenses indicadas no combinam" ;
+ Text [ french ] = "Les dimensions indiques ne concordent pas" ;
+ Text [ dutch ] = "Aangegeven afmetingen passen niet bij elkaar" ;
+ Text [ spanish ] = "Las dimensiones no coinciden" ;
+ Text [ danish ] = "Dimensionsangivelserne svarer ikke til hinanden" ;
+ Text [ swedish ] = "Dimensionsspecificeringarna stmmer inte verens" ;
+ Text [ finnish ] = "Dimensions do not match" ;
+ Text [ english_us ] = "Dimension specifications do not match" ;
+ Text[ chinese_simplified ] = "߶ȵ趨ƥ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Dane wymiarowe nie s zgodne";
+ Text[ japanese ] = "̎w͍Ă܂";
+ Text[ chinese_traditional ] = "wثת]wǰt";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Aangegeven afmetingen passen niet bij elkaar";
+ Text[ chinese_simplified ] = "߶ȵ趨ƥ";
+ Text[ greek ] = " .";
+ Text[ korean ] = " ǰ ʽϴ.";
+ Text[ turkish ] = "Boyut verileri arasnda uyumazlk";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_OPTION & ERRCODE_RES_MASK
+ {
+ Text = "Unbekannte Option: $(ARG1)" ;
+ Text [ ENGLISH ] = "Unknown option: $(ARG1)" ;
+ Text [ norwegian ] = "Unknown option: $(ARG1)" ;
+ Text [ italian ] = "Opzione sconosciuta: $(ARG1)" ;
+ Text [ portuguese_brazilian ] = "Unknown option: $(ARG1)" ;
+ Text [ portuguese ] = "Opo desconhecida: $(ARG1)" ;
+ Text [ french ] = "Option inconnue : $(ARG1)" ;
+ Text [ dutch ] = "Onbekende optie: $(ARG1)" ;
+ Text [ spanish ] = "Opcin desconocida: $(ARG1)" ;
+ Text [ danish ] = "Ukendt alternativ: $(ARG1)" ;
+ Text [ swedish ] = "Obekant alternativ: $(ARG1)" ;
+ Text [ finnish ] = "Unknown option: $(ARG1)" ;
+ Text [ english_us ] = "Unknown option: $(ARG1)" ;
+ Text[ chinese_simplified ] = "ѡ$(ARG1)";
+ Text[ russian ] = " : $(ARG1)";
+ Text[ polish ] = "Nieznana opcja: $(ARG1)";
+ Text[ japanese ] = "sȵ߼: $(ARG1)";
+ Text[ chinese_traditional ] = "ﶵG$(ARG1)";
+ Text[ arabic ] = "$(ARG1) : ";
+ Text[ dutch ] = "Onbekende optie: $(ARG1)";
+ Text[ chinese_simplified ] = "ѡ$(ARG1)";
+ Text[ greek ] = " : $(ARG1)";
+ Text[ korean ] = "˷ ɼ:$(ARG1)";
+ Text[ turkish ] = "Bilinmeyen seenek: $(ARG1)";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_CONSTANT_REDECLARED & ERRCODE_RES_MASK
+ {
+ Text = "Konstante $(ARG1) neu definiert" ;
+ Text [ ENGLISH ] = "Constant $(ARG1) redeclared" ;
+ Text [ norwegian ] = "Constant $(ARG1) redeclared" ;
+ Text [ italian ] = "Costante $(ARG1) ridefinita" ;
+ Text [ portuguese_brazilian ] = "Constant $(ARG1) redeclared" ;
+ Text [ portuguese ] = "Constante $(ARG1) redefinida" ;
+ Text [ french ] = "La constante $(ARG1) a t redfinie" ;
+ Text [ dutch ] = "Constante $(ARG1) opnieuw gedefinieerd" ;
+ Text [ spanish ] = "Constante $(ARG1) redefinida" ;
+ Text [ danish ] = "Konstanten $(ARG1) er nydefineret" ;
+ Text [ swedish ] = "Konstanten $(ARG1) r nydefinierad" ;
+ Text [ finnish ] = "Constant $(ARG1) redeclared" ;
+ Text [ english_us ] = "Constant $(ARG1) redefined" ;
+ Text[ chinese_simplified ] = "¶峣 $(ARG1)";
+ Text[ russian ] = " $(ARG1) ";
+ Text[ polish ] = "Staa $(ARG1) ponownie zdefiniowana";
+ Text[ japanese ] = "萔$(ARG1)͍Ē`܂";
+ Text[ chinese_traditional ] = "swq`$(ARG1)";
+ Text[ arabic ] = "$(ARG1) ";
+ Text[ dutch ] = "Constante $(ARG1) opnieuw gedefinieerd";
+ Text[ chinese_simplified ] = "¶峣 $(ARG1)";
+ Text[ greek ] = " $(ARG1)";
+ Text[ korean ] = " ǵ $(ARG1)";
+ Text[ turkish ] = "Sabit $(ARG1) yeniden tanmland";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_PROG_TOO_LARGE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Programm ist zu gro : Programm ist zu gro */
+ Text = "Programm ist zu gro" ;
+ Text [ ENGLISH ] = "Program is too large" ;
+ Text [ norwegian ] = "Program is too large" ;
+ Text [ italian ] = "Il programma troppo esteso" ;
+ Text [ portuguese_brazilian ] = "Program is too large" ;
+ Text [ portuguese ] = "O programa demasiado extenso" ;
+ Text [ french ] = "Le programme est trop volumineux" ;
+ Text [ dutch ] = "Programma is te groot" ;
+ Text [ spanish ] = "El programa es demasiado grande" ;
+ Text [ danish ] = "Programmet er for stort" ;
+ Text [ swedish ] = "Programmet r fr stort" ;
+ Text [ finnish ] = "Program is too large" ;
+ Text [ english_us ] = "Program too large" ;
+ Text[ chinese_simplified ] = "̫";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Program jest za duy";
+ Text[ japanese ] = "۸т͑傫܂";
+ Text[ chinese_traditional ] = "{Ӥj";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Programma is te groot";
+ Text[ chinese_simplified ] = "̫";
+ Text[ greek ] = " ";
+ Text[ korean ] = "α׷̳ʹ Ůϴ.";
+ Text[ turkish ] = "Program ok byk";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_STRINGS_ARRAYS & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Strings oder Arrays unzulssig : Strings oder Arrays unzulssig */
+ Text = "Strings oder Arrays unzulssig" ;
+ Text [ ENGLISH ] = "Sorry, no strings or arrays allowed" ;
+ Text [ norwegian ] = "Sorry, no strings or arrays allowed" ;
+ Text [ italian ] = "String o array non validi" ;
+ Text [ portuguese_brazilian ] = "Sorry, no strings or arrays allowed" ;
+ Text [ portuguese ] = "Sries de caracteres ou matrizes no permitidas" ;
+ Text [ french ] = "Strings ou Arrays inadmissibles" ;
+ Text [ dutch ] = "Strings of arrays niet toegestaan" ;
+ Text [ spanish ] = "No estn permitidos strings o arrays" ;
+ Text [ danish ] = "Strenge eller arrays er ikke tilladte" ;
+ Text [ swedish ] = "Strings eller arrays ej tilltna" ;
+ Text [ finnish ] = "Sorry, no strings or arrays allowed" ;
+ Text [ english_us ] = "Strings or arrays not permitted" ;
+ Text[ chinese_simplified ] = "ִ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Ciagi znakw lub macierze niedopuszczalne";
+ Text[ japanese ] = "܂͔z͋‚܂";
+ Text[ chinese_traditional ] = "\\rΦC";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Strings of arrays niet toegestaan";
+ Text[ chinese_simplified ] = "ִ";
+ Text[ greek ] = " ";
+ Text[ korean ] = " Ǵ 迭 ʾҽϴ.";
+ Text[ turkish ] = "Dizilimler ya da diziler geerli deil";
+ Text[ language_user1 ] = " ";
+ };
+#ifdef VBSCRIPT_TEST
+ String ERRCODE_BASIC_NOT_IN_VBSCRIPT & ERRCODE_RES_MASK
+ {
+ Text = "In VBScript nicht enthalten" ;
+ Text [ ENGLISH ] = "Not implemented in VBScript" ;
+ Text [ norwegian ] = "Not implemented in VBScript" ;
+ Text [ italian ] = "Non contenuto nello script VB" ;
+ Text [ portuguese_brazilian ] = "Not implemented in VBScript" ;
+ Text [ portuguese ] = "No contido no Script VB" ;
+ Text [ french ] = "Pas contenu dans le VBScript" ;
+ Text [ dutch ] = "Bevindt zich niet in VBScript" ;
+ Text [ spanish ] = "No est contenido en el script VB" ;
+ Text [ danish ] = "Ikke indeholdt i VB-script" ;
+ Text [ swedish ] = "Innefattas inte i VBScript" ;
+ Text [ finnish ] = "Not implemented in VBScript" ;
+ Text [ english_us ] = "Not contained in VB script" ;
+ Text[ chinese_simplified ] = "ûа VB script ";
+ Text[ russian ] = " VBScript ";
+ Text[ polish ] = "Nie zawarte w VBScript";
+ Text[ japanese ] = "VBScriptɊ܂܂Ă܂";
+ Text[ chinese_traditional ] = "S]tbVB script";
+ Text[ arabic ] = "VB script ";
+ Text[ dutch ] = "Bevindt zich niet in VBScript";
+ Text[ chinese_simplified ] = "ûа VB script ";
+ Text[ greek ] = " VB script";
+ Text[ korean ] = "VB ũƮ ʽϴ.";
+ Text[ turkish ] = "VBScript'te mevcut deil";
+ Text[ language_user1 ] = " ";
+ };
+#endif
+};
+ // Hinweis: IDS_SBERR_TERMINATED = IDS_SBERR_START+2000.
+String IDS_SBERR_TERMINATED
+{
+ Text = "Das laufende Makro wurde unterbrochen" ;
+ Text [ ENGLISH ] = "Stopped currently running macro" ;
+ Text [ norwegian ] = "Stopped currently running macro" ;
+ Text [ italian ] = "La macro in corso stata interrotta" ;
+ Text [ portuguese_brazilian ] = "Stopped currently running macro" ;
+ Text [ portuguese ] = "A macro em execuo foi cancelada" ;
+ Text [ french ] = "La macro en cours a t interrompue" ;
+ Text [ dutch ] = "Actuele macro werd onderbroken" ;
+ Text [ spanish ] = "Se ha interrumpido la macro activa" ;
+ Text [ danish ] = "Den aktuelle makro blev afbrudt" ;
+ Text [ swedish ] = "Det aktuella makrot avbrts" ;
+ Text [ finnish ] = "Stopped currently running macro" ;
+ Text [ english_us ] = "The macro running has been interrupted" ;
+ Text[ chinese_simplified ] = "жкꡣ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Wykonywane makro zostao przerwane";
+ Text[ japanese ] = "ϸۍƂf܂";
+ Text[ chinese_traditional ] = "_B楨C";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Actuele macro werd onderbroken";
+ Text[ chinese_simplified ] = "жкꡣ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "ũ ߴܵǾϴ.";
+ Text[ turkish ] = "Yrtlen makro kesildi";
+ Text[ language_user1 ] = " ";
+};
+String IDS_SBERR_STOREREF
+{
+ Text = "Referenz wird nicht gespeichert: ";
+ Text [ italian ] = "Il riferimento non viene salvato: ";
+ Text [ portuguese_brazilian ] = "reference will not be saved: ";
+ Text [ portuguese ] = "A referncia no ser guardada: ";
+ Text [ danish ] = "Referencen bliver ikke gemt: ";
+ Text [ french ] = "Impossible d'enregistrer la rfrence : ";
+ Text [ swedish ] = "Referens sparas inte: ";
+ Text [ dutch ] = "Verwijzing wordt niet opgeslagen: ";
+ Text [ spanish ] = "No se guardar la referencia: ";
+ Text [ english_us ] = "Reference will not be saved: ";
+ Text[ chinese_simplified ] = ": ";
+ Text[ language_user1 ] = " ";
+ Text[ russian ] = " : ";
+ Text[ polish ] = "Odwoanie nie zostao zapisane: ";
+ Text[ japanese ] = "QƂ͕ۑ܂: ";
+ Text[ chinese_traditional ] = "xsѷӡG ";
+ Text[ arabic ] = ": ";
+ Text[ dutch ] = "Verwijzing wordt niet opgeslagen: ";
+ Text[ chinese_simplified ] = ": ";
+ Text[ greek ] = " : ";
+ Text[ korean ] = " ʾҽϴ. ";
+ Text[ turkish ] = "Referans kaydedilmeyecek: ";
+#if defined( MAC ) || defined( OS2 )
+ Text = "Referenz wird nicht gesichert: " ;
+#else
+ Text = "Referenz wird nicht gespeichert: " ;
+#endif
+ Text [ ENGLISH ] = "reference will not be saved: " ;
+ Text [ norwegian ] = "reference will not be saved: " ;
+ Text [ italian ] = "Il riferimento non viene salvato: " ;
+ Text [ portuguese_brazilian ] = "reference will not be saved: " ;
+ Text [ portuguese ] = "A referncia no ser guardada: " ;
+ Text [ french ] = "Rfrence non enregistre : " ;
+ Text [ dutch ] = "Verwijzing wordt niet opgeslagen: " ;
+ Text [ spanish ] = "No se guardar la referencia: " ;
+ Text [ danish ] = "Referencen bliver ikke gemt: " ;
+ Text [ swedish ] = "Referens sparas inte: " ;
+ Text [ finnish ] = "reference will not be saved: " ;
+ Text [ english_us ] = "Reference will not be saved: " ;
+ Text = "Referenz wird nicht gespeichert: " ;
+};
+String ERRCODE_BASMGR_LIBLOAD & ERRCODE_RES_MASK
+{
+ /* ### ACHTUNG: Neuer Text in Resource? Fehler beim Laden der Bibliothek '$(ARG1)' : Fehler beim Laden der Bibliothek ''$(ARG1)'' */
+ /* ### ACHTUNG: Neuer Text in Resource? Fehler beim Laden der Bibliothek '$(ARG1)' : Fehler beim Laden der Bibliothek ''$(ARG1) */
+ /* ### ACHTUNG: Neuer Text in Resource? Fehler beim Laden der Bibliothek '$(ARG1)' : Fehler beim Laden der Bibliothek ''$(ARG1) */
+ /* ### ACHTUNG: Neuer Text in Resource? Fehler beim Laden der Bibliothek '$(ARG1)' : Fehler beim Laden der Bibliothek ''$(ARG1)'' */
+ Text = "Fehler beim Laden der Bibliothek '$(ARG1)'" ;
+ Text [ ENGLISH ] = "Fehler beim Laden der Bibliothek '$(ARG1)'" ;
+ Text [ english_us ] = "Error loading library '$(ARG1)'" ;
+ Text [ italian ] = "Errore nel caricare la library '$(ARG1)'" ;
+ Text [ spanish ] = "Error al cargar la biblioteca '$(ARG1)'" ;
+ Text [ french ] = "Erreur lors du chargement de la bibliothque '$(ARG1)'" ;
+ Text [ dutch ] = "Fout bij laden van bibliotheek '$(ARG1)'" ;
+ Text [ swedish ] = "Fel vid laddning av bibliotek '$(ARG1)'" ;
+ Text [ danish ] = "Fejl ved indlsning af biblioteket '$(ARG1)'" ;
+ Text [ portuguese_brazilian ] = "Fehler beim Laden der Bibliothek '$(ARG1)" ;
+ Text [ portuguese ] = "Erro ao carregar a biblioteca '$(ARG1)" ;
+ Text[ chinese_simplified ] = "װؿʱ'$(ARG1)'";
+ Text[ russian ] = " '$(ARG1)'";
+ Text[ polish ] = "Bd przy adowaniu biblioteki '$(ARG1)'";
+ Text[ japanese ] = "ײ'$(ARG1)'̓ǂݍ݂̍ۂ̴װ";
+ Text[ chinese_traditional ] = "˸{wɵoͿ~'$(ARG1)'";
+ Text[ arabic ] = "'$(ARG1)' ";
+ Text[ dutch ] = "Fout bij laden van bibliotheek '$(ARG1)'";
+ Text[ chinese_simplified ] = "װؿʱ'$(ARG1)'";
+ Text[ greek ] = " '$(ARG1)'";
+ Text[ korean ] = "̺귯 $(ARG1) ε ";
+ Text[ turkish ] = "Kitapl ykleme srasnda hata '$(ARG1)'";
+ Text[ language_user1 ] = " ";
+};
+String ERRCODE_BASMGR_LIBSAVE & ERRCODE_RES_MASK
+{
+ /* ### ACHTUNG: Neuer Text in Resource? Fehler beim Speichern der Bibliothek: '$(ARG1)' : Fehler beim Speichern der Bibliothek: ''$(ARG1)'' */
+ /* ### ACHTUNG: Neuer Text in Resource? Fehler beim Speichern der Bibliothek: '$(ARG1)' : Fehler beim Speichern der Bibliothek: ''$(ARG1) */
+ /* ### ACHTUNG: Neuer Text in Resource? Fehler beim Speichern der Bibliothek: '$(ARG1)' : Fehler beim Speichern der Bibliothek: ''$(ARG1) */
+ /* ### ACHTUNG: Neuer Text in Resource? Fehler beim Speichern der Bibliothek: '$(ARG1)' : Fehler beim Speichern der Bibliothek: ''$(ARG1)'' */
+ Text = "Fehler beim Speichern der Bibliothek: '$(ARG1)'" ;
+ Text [ ENGLISH ] = "Fehler beim Speichern der Bibliothek: '$(ARG1)'" ;
+ Text [ dutch ] = "Fout bij het opslaan van bibliotheek: '$(ARG1)'" ;
+ Text [ english_us ] = "Error saving library: '$(ARG1)'" ;
+ Text [ italian ] = "Errore nel salvare la library: '$(ARG1)'" ;
+ Text [ spanish ] = "Error al guardar la biblioteca: '$(ARG1)'" ;
+ Text [ french ] = "Erreur lors de l'enregistrement de la bibliothque : '$(ARG1)'" ;
+ Text [ swedish ] = "Fel vid sparandet av bibliotek: '$(ARG1)'" ;
+ Text [ danish ] = "Fejl under forsg p at gemme biblioteket: '$(ARG1)'" ;
+ Text [ portuguese ] = "Erro ao guardar a biblioteca: '$(ARG1)" ;
+ Text [ portuguese_brazilian ] = "Fehler beim Speichern der Bibliothek: '$(ARG1)" ;
+ Text[ chinese_simplified ] = "̿ʱ '$(ARG1)'";
+ Text[ russian ] = " : '$(ARG1)'";
+ Text[ polish ] = "Bd przy zapisie biblioteki '$(ARG1)'";
+ Text[ japanese ] = "ײ؂̕ۑ̍ۂ̴װ: '$(ARG1)'";
+ Text[ chinese_traditional ] = "xs{wɵoͿ~'$(ARG1)'";
+ Text[ arabic ] = "'$(ARG1)' : ";
+ Text[ dutch ] = "Fout bij het opslaan van bibliotheek: '$(ARG1)'";
+ Text[ chinese_simplified ] = "̿ʱ '$(ARG1)'";
+ Text[ greek ] = " : '$(ARG1)'";
+ Text[ korean ] = "̺귯 $(ARG1) ";
+ Text[ turkish ] = "Kitapl kaydetme srasnda hata: '$(ARG1)'";
+ Text[ language_user1 ] = " ";
+};
+String ERRCODE_BASMGR_MGROPEN & ERRCODE_RES_MASK
+{
+ /* ### ACHTUNG: Neuer Text in Resource? Das BASIC aus der Datei '$(ARG1)' konnte nicht initialisiert werden : Das BASIC aus der Datei ''$(ARG1)'' konnte nicht initialisiert werden */
+ /* ### ACHTUNG: Neuer Text in Resource? Das BASIC aus der Datei '$(ARG1)' konnte nicht initialisiert werden : Das BASIC aus der Datei ''$(ARG1)'' konnte nicht initialisiert werden */
+ /* ### ACHTUNG: Neuer Text in Resource? Das BASIC aus der Datei '$(ARG1)' konnte nicht initialisiert werden : Das BASIC aus der Datei ''$(ARG1)'' konnte nicht initialisiert werden */
+ /* ### ACHTUNG: Neuer Text in Resource? Das BASIC aus der Datei '$(ARG1)' konnte nicht initialisiert werden : Das BASIC aus der Datei ''$(ARG1)'' konnte nicht initialisiert werden */
+ Text = "Das BASIC aus der Datei '$(ARG1)' konnte nicht initialisiert werden" ;
+ Text [ english ] = "The BASIC from the file '$(ARG1)' could not be initialized" ;
+ Text [ dutch ] = "BASIC in bestand '$(ARG1)' kon niet worden genitialiseerd" ;
+ Text [ english_us ] = "The BASIC from the file '$(ARG1)' could not be initialized" ;
+ Text [ italian ] = "Impossibile inizializzare il BASIC dal file '$(ARG1)'" ;
+ Text [ spanish ] = "No se pudo inicializar el Basic del archivo '$(ARG1)'" ;
+ Text [ french ] = "Impossible d'initialiser BASIC partir du fichier '$(ARG1)'" ;
+ Text [ swedish ] = "BASIC frn filen '$(ARG1)' kunde inte initialiseras" ;
+ Text [ danish ] = "Det var ikke muligt at initialisere BASIC fra filen '$(ARG1)'" ;
+ Text [ portuguese ] = "Impossvel inicializar BASIC do ficheiro '$(ARG1)'" ;
+ Text [ portuguese_brazilian ] = "Das BASIC aus der Datei '$(ARG1)' konnte nicht initialisiert werden" ;
+ Text[ chinese_simplified ] = "޷ļ'$(ARG1)' ʼ BASIC";
+ Text[ russian ] = " BASIC '$(ARG1)' ";
+ Text[ polish ] = "BASIC z pliku '$(ARG1)' nie mg zosta zainicjowany";
+ Text[ japanese ] = "̧ '$(ARG1)'BASIC͏ł܂ł";
+ Text[ chinese_traditional ] = "Lkqɮ'$(ARG1)'lBASIC";
+ Text[ arabic ] = "'$(ARG1)' BASIC ";
+ Text[ dutch ] = "BASIC in bestand '$(ARG1)' kon niet worden genitialiseerd";
+ Text[ chinese_simplified ] = "޷ļ'$(ARG1)' ʼ BASIC";
+ Text[ greek ] = " BASIC '$(ARG1)'.";
+ Text[ korean ] = " $(ARG1) BASIC ʱȭ ʾҽϴ.";
+ Text[ turkish ] = "'$(ARG1)' dosyasndan BASIC kurulamad";
+ Text[ language_user1 ] = " ";
+};
+String ERRCODE_BASMGR_MGRSAVE & ERRCODE_RES_MASK
+{
+ Text = "Fehler beim Speichern des BASIC's: '$(ARG1)'" ;
+ Text [ english ] = "Error saving BASIC: '$(ARG1)'" ;
+ Text [ dutch ] = "Fout bij het opslaan van BASIC: '$(ARG1)'" ;
+ Text [ english_us ] = "Error saving BASIC: '$(ARG1)'" ;
+ Text [ italian ] = "Errore nel salvare il BASIC: '$(ARG1)'" ;
+ Text [ spanish ] = "Error al guardar BASIC: '$(ARG1)'" ;
+ Text [ french ] = "Erreur lors de l'enregistrement de la macro BASIC : '$(ARG1)'" ;
+ Text [ swedish ] = "Fel vid sparandet av BASIC: '$(ARG1)'" ;
+ Text [ danish ] = "Fejl under forsg p at gemme BASIC: '$(ARG1)'" ;
+ Text [ portuguese ] = "Erro ao guardar BASIC: '$(ARG1)'" ;
+ Text [ portuguese_brazilian ] = "Fehler beim Speichern des Basics: '$(ARG1)" ;
+ Text[ chinese_simplified ] = "BASICʱ'$(ARG1)'";
+ Text[ russian ] = " BASIC: '$(ARG1)'";
+ Text[ polish ] = "Bd przy zapisie biblioteki BASIC: '$(ARG1)'";
+ Text[ japanese ] = "BASIC̕ۑ̍ۂ̴װ: '$(ARG1)'";
+ Text[ chinese_traditional ] = "xsBASICɵoͿ~G'$(ARG1)'";
+ Text[ arabic ] = "'$(ARG1)' :BASIC ";
+ Text[ dutch ] = "Fout bij het opslaan van BASIC: '$(ARG1)'";
+ Text[ chinese_simplified ] = "BASICʱ'$(ARG1)'";
+ Text[ greek ] = " BASIC: '$(ARG1)'";
+ Text[ korean ] = "BASIC :$(ARG1)";
+ Text[ turkish ] = "BASIC'i kaydetme srasnda hata: '$(ARG1)'";
+ Text[ language_user1 ] = " ";
+};
+String ERRCODE_BASMGR_REMOVELIB & ERRCODE_RES_MASK
+{
+ Text = "Fehler beim entfernen der Bibliothek" ;
+ Text [ ENGLISH ] = "Fehler beim entfernen der Bibliothek" ;
+ Text [ dutch ] = "Fout bij verwijderen van bibliotheek" ;
+ Text [ english_us ] = "Error removing library" ;
+ Text [ italian ] = "Errore nell'eliminare la library" ;
+ Text [ spanish ] = "Error al eliminar la biblioteca" ;
+ Text [ french ] = "Erreur lors de la suppression de la bibliothque" ;
+ Text [ swedish ] = "Fel vid borttagande av bibliotek" ;
+ Text [ danish ] = "Fejl under sletning af biblioteket" ;
+ Text [ portuguese ] = "Erro ao eliminar a biblioteca" ;
+ Text [ portuguese_brazilian ] = "Fehler beim entfernen der Bibliothek" ;
+ Text[ chinese_simplified ] = "ɾʱ";
+ Text[ russian ] = " ";
+ Text[ polish ] = "Bd przy usuwaniu biblioteki";
+ Text[ japanese ] = "ײ؂̍폜̍ۂ̴װ";
+ Text[ chinese_traditional ] = "R{wɵoͿ~";
+ Text[ arabic ] = " ";
+ Text[ dutch ] = "Fout bij verwijderen van bibliotheek";
+ Text[ chinese_simplified ] = "ɾʱ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "̺귯 ";
+ Text[ turkish ] = "Kitapl kaldrma srasnda hata";
+ Text[ language_user1 ] = " ";
+};
+String ERRCODE_BASMGR_UNLOADLIB & ERRCODE_RES_MASK
+{
+ Text = "Die Bibliothek konnte nicht aus dem Speicher entfernt werden." ;
+ Text [ ENGLISH ] = "Die Bibliothek konnte nicht aus dem Speicher entfernt werden." ;
+ Text [ dutch ] = "De bibliotheek kon niet uit het geheugen worden verwijderd." ;
+ Text [ english_us ] = "The library could not be removed from memory." ;
+ Text [ italian ] = "Impossibile eliminare la library dalla memoria." ;
+ Text [ spanish ] = "No se pudo eliminar la biblioteca de la memoria." ;
+ Text [ french ] = "Impossible de supprimer la bibliothque de la mmoire." ;
+ Text [ swedish ] = "Biblioteket kunde inte tas bort frn minnet." ;
+ Text [ danish ] = "Det var ikke muligt at slette biblioteket fra hukommelsen." ;
+ Text [ portuguese ] = "Foi impossvel remover a biblioteca da memria." ;
+ Text [ portuguese_brazilian ] = "Die Bibliothek konnte nicht aus dem Speicher entfernt werden." ;
+ Text[ chinese_simplified ] = "޷ڴ";
+ Text[ russian ] = " .";
+ Text[ polish ] = "Biblioteki nie mona byo usun z pamici.";
+ Text[ japanese ] = "ײ؂؂폜ł܂łB";
+ Text[ chinese_traditional ] = "{wLkqO餺MC";
+ Text[ arabic ] = ". ";
+ Text[ dutch ] = "De bibliotheek kon niet uit het geheugen worden verwijderd.";
+ Text[ chinese_simplified ] = "޷ڴ";
+ Text[ greek ] = " ";
+ Text[ korean ] = "̺귯 ޸𸮷 ϴ.";
+ Text[ turkish ] = "Kitaplk bellekten silinemedi.";
+ Text[ language_user1 ] = " ";
+};
diff --git a/basic/source/classes/sbintern.cxx b/basic/source/classes/sbintern.cxx
new file mode 100644
index 000000000000..2a94af758ece
--- /dev/null
+++ b/basic/source/classes/sbintern.cxx
@@ -0,0 +1,109 @@
+/*************************************************************************
+ *
+ * $RCSfile: sbintern.cxx,v $
+ *
+ * $Revision: 1.1.1.1 $
+ *
+ * last change: $Author: hr $ $Date: 2000-09-18 16:12:10 $
+ *
+ * The Contents of this file are made available subject to the terms of
+ * either of the following licenses
+ *
+ * - GNU Lesser General Public License Version 2.1
+ * - Sun Industry Standards Source License Version 1.1
+ *
+ * Sun Microsystems Inc., October, 2000
+ *
+ * GNU Lesser General Public License Version 2.1
+ * =============================================
+ * Copyright 2000 by Sun Microsystems, Inc.
+ * 901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ *
+ * Sun Industry Standards Source License Version 1.1
+ * =================================================
+ * The contents of this file are subject to the Sun Industry Standards
+ * Source License Version 1.1 (the "License"); You may not use this file
+ * except in compliance with the License. You may obtain a copy of the
+ * License at http://www.openoffice.org/license.html.
+ *
+ * Software provided under this License is provided on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ * See the License for the specific provisions governing your rights and
+ * obligations concerning the Software.
+ *
+ * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ * Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ * All Rights Reserved.
+ *
+ * Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#ifndef _SHL_HXX //autogen
+#include <tools/shl.hxx>
+#endif
+#include "sbintern.hxx"
+#include "sbunoobj.hxx"
+#include "token.hxx" // Tokenizer
+#include "symtbl.hxx" // Symbolverwaltung
+#include "parser.hxx" // Parser
+#include "codegen.hxx" // Code-Generator
+#pragma hdrstop
+
+SV_IMPL_PTRARR(SbErrorStack, SbErrorStackEntry*)
+
+SbiGlobals* GetSbData()
+{
+ SbiGlobals** pp = (SbiGlobals**) ::GetAppData( SHL_SBC );
+ SbiGlobals* p = *pp;
+ if( !p )
+ p = *pp = new SbiGlobals;
+ return p;
+}
+
+SbiGlobals::SbiGlobals()
+{
+ pInst = NULL;
+ pMod = NULL;
+ pSbFac= NULL;
+ pUnoFac = NULL;
+ pCompMod = NULL; // JSM
+ nInst = 0;
+ nCode = 0;
+ nLine = 0;
+ nCol1 = nCol2 = 0;
+ bCompiler = FALSE;
+ bCompWait = FALSE;
+ bGlobalInitErr = FALSE;
+ bRunInit = FALSE;
+ eLanguageMode = SB_LANG_BASIC;
+ pErrStack = NULL;
+}
+
+SbiGlobals::~SbiGlobals()
+{
+ delete pErrStack;
+ delete pSbFac;
+ delete pUnoFac;
+}
+
diff --git a/basic/source/classes/sbunoobj.cxx b/basic/source/classes/sbunoobj.cxx
new file mode 100644
index 000000000000..799ffc0054a5
--- /dev/null
+++ b/basic/source/classes/sbunoobj.cxx
@@ -0,0 +1,2500 @@
+/*************************************************************************
+ *
+ * $RCSfile: sbunoobj.cxx,v $
+ *
+ * $Revision: 1.1.1.1 $
+ *
+ * last change: $Author: hr $ $Date: 2000-09-18 16:12:10 $
+ *
+ * The Contents of this file are made available subject to the terms of
+ * either of the following licenses
+ *
+ * - GNU Lesser General Public License Version 2.1
+ * - Sun Industry Standards Source License Version 1.1
+ *
+ * Sun Microsystems Inc., October, 2000
+ *
+ * GNU Lesser General Public License Version 2.1
+ * =============================================
+ * Copyright 2000 by Sun Microsystems, Inc.
+ * 901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ *
+ * Sun Industry Standards Source License Version 1.1
+ * =================================================
+ * The contents of this file are subject to the Sun Industry Standards
+ * Source License Version 1.1 (the "License"); You may not use this file
+ * except in compliance with the License. You may obtain a copy of the
+ * License at http://www.openoffice.org/license.html.
+ *
+ * Software provided under this License is provided on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ * See the License for the specific provisions governing your rights and
+ * obligations concerning the Software.
+ *
+ * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ * Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ * All Rights Reserved.
+ *
+ * Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+//#include <stl_queue.h>
+
+#ifndef _VOS_MUTEX_HXX_ //autogen
+#include <vos/mutex.hxx>
+#endif
+#ifndef _SV_SVAPP_HXX //autogen
+#include <vcl/svapp.hxx>
+#endif
+#ifndef _TOOLERR_HXX //autogen
+#include <tools/errcode.hxx>
+#endif
+#ifndef _SFXHINT_HXX //autogen
+#include <svtools/hint.hxx>
+#endif
+#ifndef _SBXCLASS_HXX //autogen
+#include <svtools/sbx.hxx>
+#endif
+
+#include <cppuhelper/implbase1.hxx>
+#include <cppuhelper/typeprovider.hxx>
+#include <cppuhelper/extract.hxx>
+
+#ifndef _UNOTOOLS_PROCESSFACTORY_HXX_
+#include <unotools/processfactory.hxx>
+#endif
+
+#include <rtl/ustrbuf.hxx>
+#include <rtl/strbuf.hxx>
+
+
+#include <com/sun/star/lang/XTypeProvider.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/beans/PropertyConcept.hpp>
+#include <com/sun/star/beans/MethodConcept.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/script/XAllListener.hpp>
+#include <com/sun/star/script/XInvocationAdapterFactory.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
+#include <com/sun/star/reflection/XIdlArray.hpp>
+#include <com/sun/star/reflection/XIdlReflection.hpp>
+#include <com/sun/star/reflection/XIdlClassProvider.hpp>
+
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::reflection;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::script;
+using namespace com::sun::star::container;
+using namespace cppu;
+using namespace rtl;
+
+
+#include<sbstar.hxx>
+#include<sbuno.hxx>
+#include<sberrors.hxx>
+#include<sbunoobj.hxx>
+#include"sbjsmod.hxx"
+#include<basmgr.hxx>
+#include<sbintern.hxx>
+#include<runtime.hxx>
+
+TYPEINIT1(SbUnoMethod,SbxMethod)
+TYPEINIT1(SbUnoProperty,SbxProperty)
+TYPEINIT1(SbUnoObject,SbxObject)
+TYPEINIT1(SbUnoClass,SbxObject)
+
+//#define U2S(Str) String( OUStringToOString( Str, RTL_TEXTENCODING_ASCII_US ) )
+//#define S2U(Str) OStringToOUString( OString( (Str).GetStr() ), RTL_TEXTENCODING_ASCII_US )
+
+typedef WeakImplHelper1< XAllListener > BasicAllListenerHelper;
+
+// Flag, um immer ueber Invocation zu gehen
+//#define INVOCATION_ONLY
+
+
+// Identifier fuer die dbg_-Properies als Strings anlegen
+static String ID_DBG_SUPPORTEDINTERFACES( RTL_CONSTASCII_USTRINGPARAM("Dbg_SupportedInterfaces") );
+static String ID_DBG_PROPERTIES( RTL_CONSTASCII_USTRINGPARAM("Dbg_Properties") );
+static String ID_DBG_METHODS( RTL_CONSTASCII_USTRINGPARAM("Dbg_Methods") );
+
+
+// CoreReflection statisch speichern
+Reference< XIdlReflection > getCoreReflection_Impl( void )
+{
+ static Reference< XIdlReflection > xCoreReflection;
+
+ // Haben wir schon CoreReflection, sonst besorgen
+ if( !xCoreReflection.is() )
+ {
+ Reference< XMultiServiceFactory > xFactory = utl::getProcessServiceFactory();
+ if ( xFactory.is() )
+ {
+ Reference< XInterface > xI = xFactory->createInstance( rtl::OUString::createFromAscii("com.sun.star.reflection.CoreReflection") );
+ //if (xI.is())
+ //{
+ xCoreReflection = Reference<XIdlReflection>::query( xI );
+ //xI->queryInterface( XIdlReflection::getSmartUik(), xCoreReflection );
+ //}
+ }
+ }
+ return xCoreReflection;
+}
+
+// TODO: Spaeter auslagern
+Reference<XIdlClass> TypeToIdlClass( const Type& rType )
+{
+ // void als Default-Klasse eintragen
+ Reference<XIdlClass> xRetClass;
+ typelib_TypeDescription * pTD = 0;
+ rType.getDescription( &pTD );
+ if( pTD )
+ {
+ OUString sOWName( pTD->pTypeName );
+ Reference< XIdlReflection > xRefl = getCoreReflection_Impl();
+ xRetClass = xRefl->forName( sOWName );
+ }
+ return xRetClass;
+}
+
+// Fehlermeldungs-Message bei Exception zusammenbauen
+String implGetExceptionMsg( Exception& e1 )
+{
+ // TODO: NAME???
+ static String aBaseMsg( RTL_CONSTASCII_USTRINGPARAM("\nException " ) );
+ String aMsg = aBaseMsg;
+ aMsg.AppendAscii( ": " );
+ aMsg += String( e1.Message );
+ //aMsg += ": " + U2S( ((Exception&)e1).Message );
+ return aMsg;
+}
+
+// Error-Message fuer WrappedTargetExceptions
+String implGetWrappedMsg( WrappedTargetException& e1 )
+{
+ Any aWrappedAny = e1.TargetException;
+
+ // Haben wir wirklich eine gewrappte Exception?
+ if( aWrappedAny.getValueType().getTypeClass() == TypeClass_EXCEPTION )
+ {
+ RuntimeException& e = *( (RuntimeException*)aWrappedAny.getValue() );
+ return implGetExceptionMsg( e );
+ }
+ // Sonst WrappedTargetException selbst liefern
+ else
+ {
+ return implGetExceptionMsg( e1 );
+ }
+}
+
+// Von Uno nach Sbx wandeln
+SbxDataType unoToSbxType( const Reference< XIdlClass >& xIdlClass )
+{
+ SbxDataType eRetType = SbxVOID;
+
+ if( xIdlClass.is() )
+ {
+ TypeClass eType = xIdlClass->getTypeClass();
+ switch( eType )
+ {
+ case TypeClass_INTERFACE:
+ case TypeClass_TYPE:
+ case TypeClass_STRUCT: eRetType = SbxOBJECT; break;
+
+ /* folgende Typen lassen wir erstmal weg
+ case TypeClass_SERVICE: break;
+ case TypeClass_CLASS: break;
+ case TypeClass_TYPEDEF: break;
+ case TypeClass_UNION: break;
+ case TypeClass_EXCEPTION: break;
+ case TypeClass_ARRAY: break;
+ */
+ case TypeClass_ENUM: eRetType = SbxLONG; break;
+ case TypeClass_SEQUENCE:
+ eRetType = (SbxDataType) ( SbxOBJECT | SbxARRAY );
+ break;
+
+ /*
+ case TypeClass_VOID: break;
+ case TypeClass_UNKNOWN: break;
+ */
+
+ case TypeClass_ANY: eRetType = SbxVARIANT; break;
+ case TypeClass_BOOLEAN: eRetType = SbxBOOL; break;
+ case TypeClass_CHAR: eRetType = SbxCHAR; break;
+ case TypeClass_STRING: eRetType = SbxSTRING; break;
+ case TypeClass_FLOAT: eRetType = SbxSINGLE; break;
+ case TypeClass_DOUBLE: eRetType = SbxDOUBLE; break;
+ //case TypeClass_OCTET: break;
+ case TypeClass_BYTE: eRetType = SbxBYTE; break;
+ //case TypeClass_INT: eRetType = SbxINT; break;
+ case TypeClass_SHORT: eRetType = SbxINTEGER; break;
+ case TypeClass_LONG: eRetType = SbxLONG; break;
+ //case TypeClass_HYPER: break;
+ //case TypeClass_UNSIGNED_OCTET: break;
+ case TypeClass_UNSIGNED_SHORT: eRetType = SbxUSHORT; break;
+ case TypeClass_UNSIGNED_LONG: eRetType = SbxULONG; break;
+ //case TypeClass_UNSIGNED_HYPER: break;
+ //case TypeClass_UNSIGNED_INT: eRetType = SbxUINT; break;
+ //case TypeClass_UNSIGNED_BYTE: eRetType = SbxUSHORT; break;
+ }
+ }
+ return eRetType;
+}
+
+void unoToSbxValue( SbxVariable* pVar, const Any& aValue )
+{
+ Type aType = aValue.getValueType();
+ TypeClass eTypeClass = aType.getTypeClass();
+ switch( eTypeClass )
+ {
+ case TypeClass_TYPE:
+ {
+ // Map Type to IdlClass
+ Type aType;
+ aValue >>= aType;
+ Reference<XIdlClass> xClass = TypeToIdlClass( aType );
+ Any aClassAny;
+ aClassAny <<= xClass;
+
+ // SbUnoObject instanzieren
+ String aName;
+ SbUnoObject* pSbUnoObject = new SbUnoObject( aName, aClassAny );
+ SbxObjectRef xWrapper = (SbxObject*)pSbUnoObject;
+
+ // #51475 Wenn das Objekt ungueltig ist null liefern
+ if( pSbUnoObject->getUnoAny().getValueType().getTypeClass() == TypeClass_VOID )
+ {
+ pVar->PutObject( NULL );
+ }
+ else
+ {
+ pVar->PutObject( xWrapper );
+ }
+ }
+ break;
+
+ // Interfaces und Structs muessen in ein SbUnoObject gewrappt werden
+ case TypeClass_INTERFACE:
+ case TypeClass_STRUCT:
+ {
+ // SbUnoObject instanzieren
+ String aName;
+ SbUnoObject* pSbUnoObject = new SbUnoObject( aName, aValue );
+ SbxObjectRef xWrapper = (SbxObject*)pSbUnoObject;
+
+ // #51475 Wenn das Objekt ungueltig ist null liefern
+ if( pSbUnoObject->getUnoAny().getValueType().getTypeClass() == TypeClass_VOID )
+ {
+ pVar->PutObject( NULL );
+ }
+ else
+ {
+ pVar->PutObject( xWrapper );
+ }
+ }
+ break;
+
+ /* folgende Typen lassen wir erstmal weg
+ case TypeClass_SERVICE: break;
+ case TypeClass_CLASS: break;
+ case TypeClass_TYPEDEF: break;
+ case TypeClass_UNION: break;
+ case TypeClass_ENUM: break;
+ case TypeClass_EXCEPTION: break;
+ case TypeClass_ARRAY: break;
+ */
+
+ case TypeClass_ENUM:
+ {
+ sal_Int32 nEnum = 0;
+ enum2int( nEnum, aValue );
+ pVar->PutLong( nEnum );
+ }
+ break;
+
+ case TypeClass_SEQUENCE:
+ {
+ Reference< XIdlClass > xIdlTargetClass = TypeToIdlClass( aType );
+ Reference< XIdlArray > xIdlArray = xIdlTargetClass->getArray();
+ sal_Int32 i, nLen = xIdlArray->getLen( aValue );
+ // In Basic Array anlegen
+ SbxDimArrayRef xArray = new SbxDimArray( SbxVARIANT );
+ if( nLen >= 0 )
+ xArray->unoAddDim( 0, nLen - 1 );
+
+ // Elemente als Variablen eintragen
+ for( i = 0 ; i < nLen ; i++ )
+ {
+ // Elemente wandeln
+ Any aElementAny = xIdlArray->get( aValue, (UINT32)i );
+ //Any aElementAny = pSeqReflection->get( aValue, (UINT32)i );
+ SbxVariableRef xVar = new SbxVariable( SbxVARIANT );
+ unoToSbxValue( (SbxVariable*)xVar, aElementAny );
+
+ // Ins Array braten
+ short nIndex = (short)i;
+ xArray->Put( (SbxVariable*)xVar, &nIndex );
+ }
+
+ // Array zurueckliefern
+ USHORT nFlags = pVar->GetFlags();
+ pVar->ResetFlag( SBX_FIXED );
+ pVar->PutObject( (SbxDimArray*)xArray );
+ pVar->SetFlags( nFlags );
+
+ // #54548, Die Parameter duerfen hier nicht weggehauen werden
+ //pVar->SetParameters( NULL );
+ }
+ break;
+
+ /*
+ case TypeClass_SEQUENCE: break;
+ case TypeClass_VOID: break;
+ case TypeClass_UNKNOWN: break;
+
+ case TypeClass_ANY:
+ {
+ // Any rausholen und konvertieren
+ //Any* pAny = (Any*)aValue.get();
+ //if( pAny )
+ //unoToSbxValue( pVar, *pAny );
+ }
+ break;
+ */
+
+ case TypeClass_BOOLEAN: pVar->PutBool( *(sal_Bool*)aValue.getValue() ); break;
+ case TypeClass_CHAR: { sal_Unicode val; aValue >>= val; pVar->PutChar( val ); } break;
+ case TypeClass_STRING: { OUString val; aValue >>= val; pVar->PutString( String( val ) ); } break;
+ case TypeClass_FLOAT: { float val; aValue >>= val; pVar->PutSingle( val ); } break;
+ case TypeClass_DOUBLE: { double val; aValue >>= val; pVar->PutDouble( val ); } break;
+ //case TypeClass_OCTET: break;
+ case TypeClass_BYTE: { sal_Int8 val; aValue >>= val; pVar->PutByte( val ); } break;
+ //case TypeClass_INT: break;
+ case TypeClass_SHORT: { sal_Int16 val; aValue >>= val; pVar->PutInteger( val ); } break;
+ case TypeClass_LONG: { sal_Int32 val; aValue >>= val; pVar->PutLong( val ); } break;
+ //case TypeClass_HYPER: break;
+ //case TypeClass_UNSIGNED_OCTET:break;
+ case TypeClass_UNSIGNED_SHORT: { sal_uInt16 val; aValue >>= val; pVar->PutUShort( val ); } break;
+ case TypeClass_UNSIGNED_LONG: { sal_uInt32 val; aValue >>= val; pVar->PutULong( val ); } break;
+ //case TypeClass_UNSIGNED_HYPER:break;
+ //case TypeClass_UNSIGNED_INT: break;
+ //case TypeClass_UNSIGNED_BYTE: break;
+ default: pVar->PutEmpty(); break;
+ }
+}
+
+// Reflection fuer Sbx-Typen liefern
+Type getUnoTypeForSbxBaseType( SbxDataType eType )
+{
+ Type aRetType = getCppuVoidType();
+ switch( eType )
+ {
+ //case SbxEMPTY: eRet = TypeClass_VOID; break;
+ case SbxNULL: aRetType = ::getCppuType( (const Reference< XInterface > *)0 ); break;
+ case SbxINTEGER: aRetType = ::getCppuType( (sal_Int16*)0 ); break;
+ case SbxLONG: aRetType = ::getCppuType( (sal_Int32*)0 ); break;
+ case SbxSINGLE: aRetType = ::getCppuType( (float*)0 ); break;
+ case SbxDOUBLE: aRetType = ::getCppuType( (double*)0 ); break;
+ //case SbxCURRENCY: break;
+ case SbxDATE: aRetType = ::getCppuType( (double*)0 ); break;
+ case SbxSTRING: aRetType = ::getCppuType( (OUString*)0 ); break;
+ //case SbxOBJECT: break;
+ //case SbxERROR: break;
+ case SbxBOOL: aRetType = ::getCppuType( (sal_Bool*)0 ); break;
+ case SbxVARIANT: aRetType = ::getCppuType( (Any*)0 ); break;
+ //case SbxDATAOBJECT: break;
+ case SbxCHAR: aRetType = ::getCppuType( (sal_Unicode*)0 ); break;
+ case SbxBYTE: aRetType = ::getCppuType( (sal_Int8*)0 ); break;
+ case SbxUSHORT: aRetType = ::getCppuType( (sal_uInt16*)0 ); break;
+ case SbxULONG: aRetType = ::getCppuType( (sal_uInt32*)0 ); break;
+ //case SbxLONG64: break;
+ //case SbxULONG64: break;
+ // Maschinenabhaengige zur Sicherheit auf Hyper abbilden
+ case SbxINT: aRetType = ::getCppuType( (sal_Int32*)0 ); break;
+ case SbxUINT: aRetType = ::getCppuType( (sal_uInt32*)0 ); break;
+ //case SbxVOID: break;
+ //case SbxHRESULT: break;
+ //case SbxPOINTER: break;
+ //case SbxDIMARRAY: break;
+ //case SbxCARRAY: break;
+ //case SbxUSERDEF: break;
+ //case SbxLPSTR: break;
+ //case SbxLPWSTR: break;
+ //case SbxCoreSTRING: break;
+ }
+ return aRetType;
+}
+
+// Konvertierung von Sbx nach Uno ohne bekannte Zielklasse fuer TypeClass_ANY
+Type getUnoTypeForSbxValue( SbxValue* pVal )
+{
+ Type aRetType = getCppuVoidType();
+ if( !pVal )
+ return aRetType;
+
+ // SbxType nach Uno wandeln
+ SbxDataType eBaseType = pVal->SbxValue::GetType();
+ if( eBaseType == SbxOBJECT )
+ {
+ SbxBaseRef xObj = (SbxBase*)pVal->GetObject();
+ if( !xObj )
+ {
+ StarBASIC::Error( SbERR_INVALID_OBJECT );
+ return aRetType;
+ }
+
+ if( xObj->ISA(SbxDimArray) )
+ {
+ SbxBase* pObj = (SbxBase*)xObj;
+ SbxDimArray* pArray = (SbxDimArray*)pObj;
+
+ // es muss ein eindimensionales Array sein
+ short nLower, nUpper;
+ if( pArray->GetDims() == 1 && pArray->GetDim( 1, nLower, nUpper ) )
+ {
+ INT32 nSize = nUpper - nLower + 1;
+ Type aElementType;
+ if( nSize == 0 )
+ {
+ aElementType = getUnoTypeForSbxBaseType( (SbxDataType)(pArray->GetType() & 0xfff) );
+ }
+ else
+ {
+ // Wenn alle Elemente des Arrays vom gleichen Typ sind, wird
+ // der genommen, sonst wird das ganze als Any-Sequence betrachtet
+ sal_Bool bInit = sal_False;
+
+ short nIdx = nLower;
+ for( UINT32 i = 0 ; i < nSize ; i++,nIdx++ )
+ {
+ SbxVariableRef xVar = pArray->Get( &nIdx );
+ Type aType = getUnoTypeForSbxValue( (SbxVariable*)xVar );
+ if( !bInit )
+ {
+ aElementType = aType;
+ bInit = sal_True;
+ }
+ else if( aElementType != aType )
+ {
+ // Verschiedene Typen -> AnySequence
+ aElementType = getCppuType( (Any*)0 );
+ break;
+ }
+ }
+ }
+
+ OUString aSeqTypeName( RTL_CONSTASCII_USTRINGPARAM("[]") );
+ aSeqTypeName += aElementType.getTypeName();
+ aRetType = Type( TypeClass_SEQUENCE, aSeqTypeName );
+ }
+ // Ein Array mit Dim > 1 wird nicht konvertiert -> default==void liefern
+ }
+ // Kein Array, sondern...
+ else if( xObj->ISA(SbUnoObject) )
+ {
+ aRetType = ((SbUnoObject*)(SbxBase*)xObj)->getUnoAny().getValueType();
+ }
+ // Sonst ist es ein Nicht-Uno-Basic-Objekt -> default==void liefern
+ }
+ // Kein Objekt, Basistyp konvertieren
+ else
+ {
+ aRetType = getUnoTypeForSbxBaseType( eBaseType );
+ }
+ return aRetType;
+}
+
+// Deklaration Konvertierung von Sbx nach Uno mit bekannter Zielklasse
+Any sbxToUnoValue( SbxVariable* pVar, const Reference< XIdlClass >& xIdlTargetClass );
+
+// Konvertierung von Sbx nach Uno ohne bekannte Zielklasse fuer TypeClass_ANY
+Any sbxToUnoValue( SbxVariable* pVar )
+{
+ Type aType = getUnoTypeForSbxValue( pVar );
+ return sbxToUnoValue( pVar, TypeToIdlClass( aType ) );
+}
+
+// Konvertierung von Sbx nach Uno mit bekannter Zielklasse
+Any sbxToUnoValue( SbxVariable* pVar, const Reference< XIdlClass >& xIdlTargetClass )
+{
+ Any aRetVal;
+ //aRetVal.setVoid();
+
+ TypeClass eType = xIdlTargetClass->getTypeClass();
+ switch( eType )
+ {
+ case TypeClass_INTERFACE:
+ case TypeClass_STRUCT:
+ {
+ // Null-Referenz?
+ if( pVar->IsNull() && eType == TypeClass_INTERFACE )
+ {
+ Reference< XInterface > xRef;
+ OUString aClassName = xIdlTargetClass->getName();
+ Type aClassType( xIdlTargetClass->getTypeClass(), aClassName.getStr() );
+ aRetVal <<= aClassType;
+ }
+ else
+ {
+ SbxBaseRef pObj = (SbxBase*)pVar->GetObject();
+ if( pObj && pObj->ISA(SbUnoObject) )
+ aRetVal = ((SbUnoObject*)(SbxBase*)pObj)->getUnoAny();
+ }
+ }
+ break;
+
+ /* folgende Typen lassen wir erstmal weg
+ case TypeClass_SERVICE: break;
+ case TypeClass_CLASS: break;
+ case TypeClass_TYPEDEF: break;
+ case TypeClass_UNION: break;
+ case TypeClass_ENUM: break;
+ case TypeClass_EXCEPTION: break;
+ case TypeClass_ARRAY: break;
+ */
+
+ // Array -> Sequence
+ case TypeClass_ENUM:
+ {
+ OUString aClassName = xIdlTargetClass->getName();
+ Type aEnumType( xIdlTargetClass->getTypeClass(), aClassName.getStr() );
+ aRetVal = int2enum( pVar->GetLong(), aEnumType );
+ }
+ break;
+
+ case TypeClass_SEQUENCE:
+ {
+ SbxBaseRef xObj = (SbxBase*)pVar->GetObject();
+ if( xObj && xObj->ISA(SbxDimArray) )
+ {
+ SbxBase* pObj = (SbxBase*)xObj;
+ SbxDimArray* pArray = (SbxDimArray*)pObj;
+
+ // Instanz der geforderten Sequence erzeugen
+ xIdlTargetClass->createObject( aRetVal );
+
+ // es muss ein eindimensionales Array sein
+ short nLower, nUpper;
+ if( pArray->GetDims() == 1 && pArray->GetDim( 1, nLower, nUpper ) )
+ {
+ INT32 nSeqSize = nUpper - nLower + 1;
+
+ Reference< XIdlArray > xArray = xIdlTargetClass->getArray();
+ xArray->realloc( aRetVal, nSeqSize );
+
+ // Element-Type
+ OUString aClassName = xIdlTargetClass->getName();
+ typelib_TypeDescription * pSeqTD = 0;
+ typelib_typedescription_getByName( &pSeqTD, aClassName.pData );
+ OSL_ASSERT( pSeqTD );
+#if SUPD > 600
+ Type aElemType( ((typelib_IndirectTypeDescription *)pSeqTD)->pType );
+#else
+ typelib_TypeDescription * pElementTD =
+ ((typelib_IndirectTypeDescription *)pSeqTD)->pType;
+ Type aElemType( pElementTD->pWeakRef );
+#endif
+ Reference< XIdlClass > xElementClass = TypeToIdlClass( aElemType );
+
+ // Alle Array-Member umwandeln und eintragen
+ short nIdx = nLower;
+ for( sal_Int32 i = 0 ; i < nSeqSize ; i++,nIdx++ )
+ {
+ SbxVariableRef xVar = pArray->Get( &nIdx );
+
+ // Wert von Sbx nach Uno wandeln
+ Any aAnyValue = sbxToUnoValue( (SbxVariable*)xVar, xElementClass );
+
+ try
+ {
+ // In die Sequence uebernehmen
+ xArray->set( aRetVal, i, aAnyValue );
+ }
+ catch( IllegalArgumentException& e1 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e1 ) );
+ }
+ catch (IndexOutOfBoundsException& e2)
+ {
+ StarBASIC::Error( SbERR_OUT_OF_RANGE );
+ }
+ }
+ }
+ }
+ }
+ break;
+
+ /*
+ case TypeClass_VOID: break;
+ case TypeClass_UNKNOWN: break;
+ */
+
+ // Bei Any die Klassen-unabhaengige Konvertierungs-Routine nutzen
+ case TypeClass_ANY:
+ {
+ aRetVal = sbxToUnoValue( pVar );
+ }
+ break;
+
+ case TypeClass_BOOLEAN: aRetVal <<= (sal_Bool)( pVar->GetBool() ); break;
+ case TypeClass_CHAR: aRetVal <<= (sal_Unicode)( pVar->GetChar() ); break;
+ case TypeClass_STRING: aRetVal <<= OUString( pVar->GetString() ); break;
+ case TypeClass_FLOAT: aRetVal <<= pVar->GetSingle(); break;
+ case TypeClass_DOUBLE: aRetVal <<= pVar->GetDouble(); break;
+ //case TypeClass_OCTET: break;
+ case TypeClass_BYTE: aRetVal <<= (sal_Int8)( pVar->GetByte() ); break;
+ //case TypeClass_INT: break;
+ case TypeClass_SHORT: aRetVal <<= (sal_Int16)( pVar->GetInteger() ); break;
+ case TypeClass_LONG: aRetVal <<= (sal_Int32)( pVar->GetLong() ); break;
+ //case TypeClass_HYPER: break;
+ //case TypeClass_UNSIGNED_OCTET:break;
+ case TypeClass_UNSIGNED_SHORT: aRetVal <<= (sal_uInt16)( pVar->GetUShort() ); break;
+ case TypeClass_UNSIGNED_LONG: aRetVal <<= (sal_uInt32)( pVar->GetULong() ); break;
+ //case TypeClass_UNSIGNED_HYPER:break;
+ //case TypeClass_UNSIGNED_INT: break;
+ //case TypeClass_UNSIGNED_BYTE: break;
+ }
+
+ return aRetVal;
+}
+
+// Dbg-Hilfsmethode zum Auslesen der in einem Object implementierten Interfaces
+String Impl_GetInterfaceInfo( const Reference< XInterface >& x, const Reference< XIdlClass >& xClass, USHORT nRekLevel )
+{
+ Type aIfaceType = ::getCppuType( (const Reference< XInterface > *)0 );
+ static Reference< XIdlClass > xIfaceClass = TypeToIdlClass( aIfaceType );
+
+ String aRetStr;
+ for( USHORT i = 0 ; i < nRekLevel ; i++ )
+ aRetStr.AppendAscii( " " );
+ aRetStr += String( xClass->getName() );
+ OUString aClassName = xClass->getName();
+ Type aClassType( xClass->getTypeClass(), aClassName.getStr() );
+
+ // Pruefen, ob das Interface wirklich unterstuetzt wird
+ if( !x->queryInterface( aClassType ).hasValue() )
+ {
+ aRetStr.AppendAscii( " (ERROR: Not really supported!)\n" );
+ }
+ // Gibt es Super-Interfaces
+ else
+ {
+ aRetStr.AppendAscii( "\n" );
+
+ // Super-Interfaces holen
+ Sequence< Reference< XIdlClass > > aSuperClassSeq = xClass->getSuperclasses();
+ const Reference< XIdlClass >* pClasses = aSuperClassSeq.getConstArray();
+ UINT32 nSuperIfaceCount = aSuperClassSeq.getLength();
+ for( UINT32 j = 0 ; j < nSuperIfaceCount ; j++ )
+ {
+ const Reference< XIdlClass >& rxIfaceClass = pClasses[j];
+ if( !rxIfaceClass->equals( xIfaceClass ) )
+ aRetStr += Impl_GetInterfaceInfo( x, rxIfaceClass, nRekLevel + 1 );
+ }
+ }
+ return aRetStr;
+}
+
+// Dbg-Hilfsmethode zum Auslesen der in einem Object implementierten Interfaces
+String Impl_GetSupportedInterfaces( const String& rName, const Any& aToInspectObj )
+{
+ //static Reference< XIdlClass > xUsrObjectClass = UsrObject::getUsrObjectIdlClass();
+
+ // #54898: Nur TypeClass Interface zulasssen
+ TypeClass eType = aToInspectObj.getValueType().getTypeClass();
+ String aRet;
+ if( eType != TypeClass_INTERFACE )
+ {
+ aRet += ID_DBG_SUPPORTEDINTERFACES;
+ aRet.AppendAscii( " not available for \"" );
+ aRet += rName;
+ aRet.AppendAscii( "\"\n(TypeClass is not TypeClass_INTERFACE)" );
+ }
+ else
+ {
+ // Interface aus dem Any besorgen
+ const Reference< XInterface > x = *(Reference< XInterface >*)aToInspectObj.getValue();
+
+ // XIdlClassProvider-Interface ansprechen
+ Reference< XIdlClassProvider > xClassProvider( x, UNO_QUERY );
+ Reference< XTypeProvider > xTypeProvider( x, UNO_QUERY );
+
+ aRet.AssignAscii( "Supported interfaces by object " );
+ if( xTypeProvider.is() )
+ aRet.AppendAscii( "(using XTypeProvider) " );
+ if( rName.Len() > 20 )
+ aRet.AppendAscii( "\n" );
+ aRet.AppendAscii( "(Type \"" );
+ aRet += rName;
+ aRet.AppendAscii( "\"):\n" );
+ if( xTypeProvider.is() )
+ {
+ // Interfaces der Implementation holen
+ Sequence< Type > aTypeSeq = xTypeProvider->getTypes();
+ //Sequence< Reference< XIdlClass > > aClassSeq = xTypeProvider->getTypes();
+ const Type* pTypeArray = aTypeSeq.getConstArray();
+ UINT32 nIfaceCount = aTypeSeq.getLength();
+ for( UINT32 j = 0 ; j < nIfaceCount ; j++ )
+ {
+ const Type& rType = pTypeArray[j];
+ aRet += Impl_GetInterfaceInfo( x, TypeToIdlClass( rType ), 1 );
+ }
+ }
+ else if( xClassProvider.is() )
+ {
+
+ DBG_ERROR( "XClassProvider not supported in UNO3" );
+ }
+ }
+ return aRet;
+}
+
+
+
+// Dbg-Hilfsmethode SbxDataType -> String
+String Dbg_SbxDataType2String( SbxDataType eType )
+{
+ String aRet( RTL_CONSTASCII_USTRINGPARAM("Unknown Sbx-Type!") );
+ switch( eType )
+ {
+ case SbxEMPTY: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxEMPTY") ); break;
+ case SbxNULL: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxNULL") ); break;
+ case SbxINTEGER: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxINTEGER") ); break;
+ case SbxLONG: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxLONG") ); break;
+ case SbxSINGLE: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxSINGLE") ); break;
+ case SbxDOUBLE: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxDOUBLE") ); break;
+ case SbxCURRENCY: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxCURRENCY") ); break;
+ case SbxDATE: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxDATE") ); break;
+ case SbxSTRING: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxSTRING") ); break;
+ case SbxOBJECT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxOBJECT") ); break;
+ case SbxERROR: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxERROR") ); break;
+ case SbxBOOL: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxBOOL") ); break;
+ case SbxVARIANT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxVARIANT") ); break;
+ case SbxDATAOBJECT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxDATAOBJECT") ); break;
+ case SbxCHAR: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxCHAR") ); break;
+ case SbxBYTE: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxBYTE") ); break;
+ case SbxUSHORT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxUSHORT") ); break;
+ case SbxULONG: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxULONG") ); break;
+ case SbxLONG64: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxLONG64") ); break;
+ case SbxULONG64: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxULONG64") ); break;
+ case SbxINT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxINT") ); break;
+ case SbxUINT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxUINT") ); break;
+ case SbxVOID: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxVOID") ); break;
+ case SbxHRESULT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxHRESULT") ); break;
+ case SbxPOINTER: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxPOINTER") ); break;
+ case SbxDIMARRAY: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxDIMARRAY") ); break;
+ case SbxCARRAY: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxCARRAY") ); break;
+ case SbxUSERDEF: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxUSERDEF") ); break;
+ case SbxLPSTR: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxLPSTR") ); break;
+ case SbxLPWSTR: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxLPWSTR") ); break;
+ case SbxCoreSTRING: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxCoreSTRING" ) ); break;
+ case SbxOBJECT | SbxARRAY: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxARRAY") ); break;
+ }
+ return aRet;
+}
+
+// Dbg-Hilfsmethode zum Anzeigen der Properties eines SbUnoObjects
+String Impl_DumpProperties( const String& rName, SbUnoObject* pUnoObj )
+{
+ String aRet( RTL_CONSTASCII_USTRINGPARAM("Properties of object ") );
+ if( rName.Len() > 20 )
+ aRet.AppendAscii( "\n" );
+ aRet.AppendAscii( "(Type \"" );
+ aRet += rName;
+ aRet.AppendAscii( "\"):" );
+
+ // Uno-Infos auswerten, um Arrays zu erkennen
+ Reference< XIntrospectionAccess > xAccess = pUnoObj->getIntrospectionAccess();
+ if( !xAccess.is() )
+ {
+ Reference< XInvocation > xInvok = pUnoObj->getInvocation();
+ if( xInvok.is() )
+ xAccess = xInvok->getIntrospection();
+ }
+ if( !xAccess.is() )
+ {
+ aRet.AppendAscii( "\nUnknown, no introspection available" );
+ return aRet;
+ }
+
+ Sequence<Property> props = xAccess->getProperties( PropertyConcept::ALL - PropertyConcept::DANGEROUS );
+ UINT32 nUnoPropCount = props.getLength();
+ const Property* pUnoProps = props.getConstArray();
+
+ SbxArray* pProps = pUnoObj->GetProperties();
+ USHORT nPropCount = pProps->Count();
+ USHORT nPropsPerLine = 1 + nPropCount / 30;
+ for( USHORT i = 0; i < nPropCount; i++ )
+ {
+ SbxVariable* pVar = pProps->Get( i );
+ if( pVar )
+ {
+ String aPropStr;
+ if( (i % nPropsPerLine) == 0 )
+ aPropStr.AppendAscii( "\n" );
+
+ // Typ und Namen ausgeben
+ // Ist es in Uno eine Sequence?
+ SbxDataType eType = pVar->GetFullType();
+
+ BOOL bMaybeVoid = FALSE;
+ if( i < nUnoPropCount )
+ {
+ const Property& rProp = pUnoProps[ i ];
+
+ // #63133: Bei MAYBEVOID Typ aus Uno neu konvertieren,
+ // damit nicht immer nur SbxEMPTY ausgegben wird.
+ if( rProp.Attributes & PropertyAttribute::MAYBEVOID )
+ {
+ eType = unoToSbxType( TypeToIdlClass( rProp.Type ) );
+ bMaybeVoid = TRUE;
+ }
+ if( eType == SbxOBJECT )
+ {
+ Type aType = rProp.Type;
+ if( aType.getTypeClass() == TypeClass_SEQUENCE )
+ eType = (SbxDataType) ( SbxOBJECT | SbxARRAY );
+ }
+ }
+ aPropStr += Dbg_SbxDataType2String( eType );
+ if( bMaybeVoid )
+ aPropStr.AppendAscii( "/void" );
+ aPropStr.AppendAscii( " " );
+ aPropStr += pVar->GetName();
+
+ if( i == nPropCount - 1 )
+ aPropStr.AppendAscii( "\n" );
+ else
+ aPropStr.AppendAscii( "; " );
+
+ aRet += aPropStr;
+ }
+ }
+ return aRet;
+}
+
+// Dbg-Hilfsmethode zum Anzeigen der Methoden eines SbUnoObjects
+String Impl_DumpMethods( const String& rName, SbUnoObject* pUnoObj )
+{
+ String aRet( RTL_CONSTASCII_USTRINGPARAM("Methods of object ") );
+ if( rName.Len() > 20 )
+ aRet.AppendAscii( "\n" );
+ aRet.AppendAscii( "(Type \"" );
+ aRet += rName;
+ aRet.AppendAscii( "\"):" );
+
+ // XIntrospectionAccess, um die Typen der Parameter auch ausgeben zu koennen
+ Reference< XIntrospectionAccess > xAccess = pUnoObj->getIntrospectionAccess();
+ if( !xAccess.is() )
+ {
+ Reference< XInvocation > xInvok = pUnoObj->getInvocation();
+ if( xInvok.is() )
+ xAccess = xInvok->getIntrospection();
+ }
+ if( !xAccess.is() )
+ {
+ aRet.AppendAscii( "\nUnknown, no introspection available" );
+ return aRet;
+ }
+ Sequence< Reference< XIdlMethod > > methods = xAccess->getMethods
+ ( MethodConcept::ALL - MethodConcept::DANGEROUS );
+ const Reference< XIdlMethod >* pUnoMethods = methods.getConstArray();
+
+ SbxArray* pMethods = pUnoObj->GetMethods();
+ USHORT nMethodCount = pMethods->Count();
+ USHORT nPropsPerLine = 1 + nMethodCount / 30;
+ for( USHORT i = 0; i < nMethodCount; i++ )
+ {
+ SbxVariable* pVar = pMethods->Get( i );
+ if( pVar )
+ {
+ String aPropStr;
+ if( (i % nPropsPerLine) == 0 )
+ aPropStr.AppendAscii( "\n" );
+
+ // Methode ansprechen
+ const Reference< XIdlMethod >& rxMethod = pUnoMethods[i];
+
+ // Ist es in Uno eine Sequence?
+ SbxDataType eType = pVar->GetFullType();
+ if( eType == SbxOBJECT )
+ {
+ Reference< XIdlClass > xClass = rxMethod->getReturnType();
+ if( xClass.is() && xClass->getTypeClass() == TypeClass_SEQUENCE )
+ eType = (SbxDataType) ( SbxOBJECT | SbxARRAY );
+ }
+ // Name und Typ ausgeben
+ aPropStr += Dbg_SbxDataType2String( eType );
+ aPropStr.AppendAscii( " " );
+ aPropStr += pVar->GetName();
+ aPropStr.AppendAscii( " ( " );
+
+ // get-Methode darf keinen Parameter haben
+ Sequence< Reference< XIdlClass > > aParamsSeq = rxMethod->getParameterTypes();
+ UINT32 nParamCount = aParamsSeq.getLength();
+ const Reference< XIdlClass >* pParams = aParamsSeq.getConstArray();
+
+ if( nParamCount > 0 )
+ {
+ for( USHORT j = 0; j < nParamCount; j++ )
+ {
+ String aTypeStr = Dbg_SbxDataType2String( unoToSbxType( pParams[ j ] ) );
+ aPropStr += aTypeStr;
+
+ if( j < nParamCount - 1 )
+ aPropStr.AppendAscii( ", " );
+ }
+ }
+ else
+ aPropStr.AppendAscii( "void" );
+
+ aPropStr.AppendAscii( " ) " );
+
+ if( i == nMethodCount - 1 )
+ aPropStr.AppendAscii( "\n" );
+ else
+ aPropStr.AppendAscii( "; " );
+
+ aRet += aPropStr;
+ }
+ }
+ return aRet;
+}
+
+// Implementation SbUnoObject
+void SbUnoObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
+ const SfxHint& rHint, const TypeId& rHintType )
+{
+ if( bNeedIntrospection ) doIntrospection();
+
+ const SbxHint* pHint = PTR_CAST(SbxHint,&rHint);
+ if( pHint )
+ {
+ SbxVariable* pVar = pHint->GetVar();
+ SbxArray* pParams = pVar->GetParameters();
+ SbUnoProperty* pProp = PTR_CAST(SbUnoProperty,pVar);
+ SbUnoMethod* pMeth = PTR_CAST(SbUnoMethod,pVar);
+ if( pProp )
+ {
+ if( pHint->GetId() == SBX_HINT_DATAWANTED )
+ {
+ // Test-Properties
+ INT32 nId = (INT32)pProp->nId;
+ if( nId < 0 )
+ {
+ // Id == -1: Implementierte Interfaces gemaess ClassProvider anzeigen
+ if( nId == -1 ) // Property ID_DBG_SUPPORTEDINTERFACES"
+ {
+ String aRetStr = Impl_GetSupportedInterfaces( GetClassName(), getUnoAny() );
+ pVar->PutString( aRetStr );
+ }
+ // Id == -2: Properties ausgeben
+ else if( nId == -2 ) // Property ID_DBG_PROPERTIES
+ {
+ // Jetzt muessen alle Properties angelegt werden
+ implCreateAll();
+ String aRetStr = Impl_DumpProperties( GetClassName(), this );
+ pVar->PutString( aRetStr );
+ }
+ // Id == -3: Methoden ausgeben
+ else if( nId == -3 ) // Property ID_DBG_METHODS
+ {
+ // Jetzt muessen alle Properties angelegt werden
+ implCreateAll();
+ String aRetStr = Impl_DumpMethods( GetClassName(), this );
+ pVar->PutString( aRetStr );
+ }
+ return;
+ }
+
+ if( mxUnoAccess.is() )
+ {
+ try
+ {
+ // Wert holen
+ Reference< XPropertySet > xPropSet( mxUnoAccess->queryAdapter( ::getCppuType( (const Reference< XPropertySet > *)0 ) ), UNO_QUERY );
+ Any aRetAny = xPropSet->getPropertyValue( pProp->GetName() );
+ // Die Nutzung von getPropertyValue (statt ueber den Index zu gehen) ist
+ // nicht optimal, aber die Umstellung auf XInvocation steht ja ohnehin an
+ // Ansonsten kann auch FastPropertySet genutzt werden
+
+ // Wert von Uno nach Sbx uebernehmen
+ unoToSbxValue( pVar, aRetAny );
+ }
+ catch( WrappedTargetException& e1 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetWrappedMsg( e1 ) );
+ }
+ catch( RuntimeException& e2 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e2 ) );
+ }
+ catch( Exception& e3 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e3 ) );
+ }
+ }
+ else if( mxInvocation.is() )
+ {
+ try
+ {
+ // Wert holen
+ Any aRetAny = mxInvocation->getValue( pProp->GetName() );
+
+ // Wert von Uno nach Sbx uebernehmen
+ unoToSbxValue( pVar, aRetAny );
+ }
+ catch( WrappedTargetException& e1 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetWrappedMsg( e1 ) );
+ }
+ catch( RuntimeException& e2 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e2 ) );
+ }
+ catch( Exception& e3 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e3 ) );
+ }
+ }
+ }
+ else if( pHint->GetId() == SBX_HINT_DATACHANGED )
+ {
+ if( mxUnoAccess.is() )
+ {
+ if( pProp->aUnoProp.Attributes & PropertyAttribute::READONLY )
+ {
+ StarBASIC::Error( SbERR_PROP_READONLY );
+ return;
+ }
+
+ // Wert von Uno nach Sbx uebernehmen
+ Any aAnyValue = sbxToUnoValue( pVar, TypeToIdlClass( pProp->aUnoProp.Type ) );
+ try
+ {
+ // Wert setzen
+ Reference< XPropertySet > xPropSet( mxUnoAccess->queryAdapter( ::getCppuType( (const Reference< XPropertySet > *)0 ) ), UNO_QUERY );
+ xPropSet->setPropertyValue( pProp->GetName(), aAnyValue );
+ // Die Nutzung von getPropertyValue (statt ueber den Index zu gehen) ist
+ // nicht optimal, aber die Umstellung auf XInvocation steht ja ohnehin an
+ // Ansonsten kann auch FastPropertySet genutzt werden
+ }
+ catch( WrappedTargetException& e1 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetWrappedMsg( e1 ) );
+ }
+ catch( IllegalArgumentException& e2 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e2 ) );
+ }
+ catch( RuntimeException& e3 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e3 ) );
+ }
+ catch( Exception& e4 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e4 ) );
+ }
+ }
+ else if( mxInvocation.is() )
+ {
+ // Wert von Uno nach Sbx uebernehmen
+ Any aAnyValue = sbxToUnoValue( pVar );
+ try
+ {
+ // Wert setzen
+ mxInvocation->setValue( pProp->GetName(), aAnyValue );
+ }
+ catch( WrappedTargetException& e1 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetWrappedMsg( e1 ) );
+ }
+ catch( RuntimeException& e2 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e2 ) );
+ }
+ catch( Exception& e3 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e3 ) );
+ }
+ }
+ }
+ }
+ else if( pMeth )
+ {
+ if( pHint->GetId() == SBX_HINT_DATAWANTED )
+ {
+ UINT32 nParamCount = 0;
+ Sequence<Any> args;
+ BOOL bOutParams = FALSE;
+ UINT32 i;
+ if( pParams )
+ {
+ // Anzahl Parameter -1 wegen Param0 == this
+ nParamCount = (UINT32)pParams->Count() - 1;
+ args.realloc( nParamCount );
+ Any* pAnyArgs = args.getArray();
+
+ if( mxUnoAccess.is() )
+ {
+ // Infos holen
+ const Sequence<ParamInfo>& rInfoSeq = pMeth->getParamInfos();
+ const ParamInfo* pParamInfos = rInfoSeq.getConstArray();
+ UINT32 nUnoParamCount = rInfoSeq.getLength();
+
+ // Ueberschuessige Parameter ignorieren, Alternative: Error schmeissen
+ if( nParamCount > nUnoParamCount )
+ nParamCount = nUnoParamCount;
+
+ for( i = 0 ; i < nParamCount ; i++ )
+ {
+ const ParamInfo& rInfo = pParamInfos[i];
+ const Reference< XIdlClass >& rxClass = rInfo.aType;
+ //const XIdlClassRef& rxClass = pUnoParams[i];
+
+ // ACHTUNG: Bei den Sbx-Parametern den Offset nicht vergessen!
+ pAnyArgs[i] = sbxToUnoValue( pParams->Get( (USHORT)(i+1) ), rxClass );
+
+ // Wenn es nicht schon feststeht pruefen, ob Out-Parameter vorliegen
+ if( !bOutParams )
+ {
+ ParamMode aParamMode = rInfo.aMode;
+ if( aParamMode != ParamMode_IN )
+ bOutParams = TRUE;
+ }
+ }
+ }
+ else if( mxInvocation.is() )
+ {
+ for( i = 0 ; i < nParamCount ; i++ )
+ {
+ // ACHTUNG: Bei den Sbx-Parametern den Offset nicht vergessen!
+ pAnyArgs[i] = sbxToUnoValue( pParams->Get( (USHORT)(i+1) ) );
+ }
+ }
+ }
+
+ // Methode callen
+ try
+ {
+ if( mxUnoAccess.is() )
+ {
+ Any aRetAny = pMeth->m_xUnoMethod->invoke( getUnoAny(), args );
+
+ // Wert von Uno nach Sbx uebernehmen
+ unoToSbxValue( pVar, aRetAny );
+
+ // Muessen wir Out-Parameter zurueckkopieren?
+ if( bOutParams )
+ {
+ const Any* pAnyArgs = args.getConstArray();
+
+ // Infos holen
+ const Sequence<ParamInfo>& rInfoSeq = pMeth->getParamInfos();
+ const ParamInfo* pParamInfos = rInfoSeq.getConstArray();
+
+ UINT32 i;
+ for( i = 0 ; i < nParamCount ; i++ )
+ {
+ const ParamInfo& rInfo = pParamInfos[i];
+ ParamMode aParamMode = rInfo.aMode;
+ if( aParamMode != ParamMode_IN )
+ unoToSbxValue( (SbxVariable*)pParams->Get( (USHORT)(i+1) ), pAnyArgs[ i ] );
+ }
+ }
+ }
+ else if( mxInvocation.is() )
+ {
+ Sequence< INT16 > OutParamIndex;
+ Sequence< Any > OutParam;
+ Any aRetAny = mxInvocation->invoke( pMeth->GetName(), args, OutParamIndex, OutParam );
+
+ // Wert von Uno nach Sbx uebernehmen
+ unoToSbxValue( pVar, aRetAny );
+
+ const INT16* pIndices = OutParamIndex.getConstArray();
+ UINT32 nLen = OutParamIndex.getLength();
+ if( nLen )
+ {
+ const Any* pNewValues = OutParam.getConstArray();
+ for( UINT32 i = 0 ; i < nLen ; i++ )
+ {
+ INT16 iTarget = pIndices[ i ];
+ if( iTarget >= nParamCount )
+ break;
+ unoToSbxValue( (SbxVariable*)pParams->Get( (USHORT)(i+1) ), pNewValues[ i ] );
+ }
+ }
+ }
+
+ // #55460, Parameter hier weghauen, da das in unoToSbxValue()
+ // bei Arrays wegen #54548 nicht mehr gemacht wird
+ if( pParams )
+ pVar->SetParameters( NULL );
+ }
+ catch( WrappedTargetException& e1 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetWrappedMsg( e1 ) );
+ }
+ catch( RuntimeException& e2 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e2 ) );
+ }
+ catch( Exception& e3 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e3 ) );
+ }
+ /*
+ catch( NullPointerException& e1 )
+ {
+ }
+ catch( InvocationTargetException& e2 )
+ {
+ }
+ catch( IllegalArgumentException& e3)
+ {
+ }
+ */
+ }
+ }
+ else
+ SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
+ }
+}
+
+
+#ifdef INVOCATION_ONLY
+// Aus USR
+Reference< XInvocation > createDynamicInvocationFor( const Any& aAny );
+#endif
+
+SbUnoObject::SbUnoObject( const String& aName, const Any& aUnoObj_ )
+ : SbxObject( aName )
+{
+ static Reference< XIntrospection > xIntrospection;
+
+ // Default-Properties von Sbx wieder rauspruegeln
+ Remove( XubString( RTL_CONSTASCII_USTRINGPARAM("Name") ), SbxCLASS_DONTCARE );
+ Remove( XubString( RTL_CONSTASCII_USTRINGPARAM("Parent") ), SbxCLASS_DONTCARE );
+
+ // Typ des Objekts pruefen
+ TypeClass eType = aUnoObj_.getValueType().getTypeClass();
+ Reference< XInterface > x;
+ if( eType == TypeClass_INTERFACE )
+ {
+ // Interface aus dem Any besorgen
+ x = *(Reference< XInterface >*)aUnoObj_.getValue();
+ if( !x.is() )
+ return;
+ }
+
+#ifdef INVOCATION_ONLY
+ // Invocation besorgen
+ mxInvocation = createDynamicInvocationFor( aUnoObj_ );
+#else
+ // Hat das Object selbst eine Invocation?
+ mxInvocation = Reference< XInvocation >( x, UNO_QUERY );
+#endif
+
+ if( mxInvocation.is() )
+ {
+ // MaterialHolder holen
+ mxMaterialHolder = Reference< XMaterialHolder >::query( mxInvocation );
+
+ // ExactName holen
+ mxExactName = Reference< XExactName >::query( mxInvocation );
+
+ // Rest bezieht sich nur auf Introspection
+ bNeedIntrospection = FALSE;
+ return;
+ }
+
+ // Introspection-Flag
+ bNeedIntrospection = TRUE;
+ maTmpUnoObj = aUnoObj_;
+
+
+ //*** Namen bestimmen ***
+ BOOL bFatalError = TRUE;
+
+ // Ist es ein Interface oder eine struct?
+ BOOL bSetClassName = FALSE;
+ String aClassName;
+ if( eType == TypeClass_STRUCT )
+ {
+ // Struct ist Ok
+ bFatalError = FALSE;
+
+ // #67173 Echten Klassen-Namen eintragen
+ if( aName.Len() == 0 )
+ {
+ aClassName = String( aUnoObj_.getValueType().getTypeName() );
+ bSetClassName = TRUE;
+ }
+ }
+ else if( eType == TypeClass_INTERFACE )
+ {
+ // #70197 Interface geht immer durch Typ im Any
+ bFatalError = FALSE;
+
+ // Nach XIdlClassProvider-Interface fragen
+ Reference< XIdlClassProvider > xClassProvider( x, UNO_QUERY );
+ if( xClassProvider.is() )
+ {
+ // #67173 Echten Klassen-Namen eintragen
+ if( aName.Len() == 0 )
+ {
+ Sequence< Reference< XIdlClass > > szClasses = xClassProvider->getIdlClasses();
+ UINT32 nLen = szClasses.getLength();
+ if( nLen )
+ {
+ const Reference< XIdlClass > xImplClass = szClasses.getConstArray()[ 0 ];
+ if( xImplClass.is() )
+ {
+ aClassName = String( xImplClass->getName() );
+ bSetClassName = TRUE;
+ }
+ }
+ }
+ }
+ }
+ if( bSetClassName )
+ SetClassName( aClassName );
+
+ // Weder Interface noch Struct -> FatalError
+ if( bFatalError )
+ {
+ StarBASIC::FatalError( SbERR_INTERNAL_ERROR );
+ return;
+ }
+
+ // #67781 Introspection erst on demand durchfuehren
+}
+
+SbUnoObject::~SbUnoObject()
+{}
+
+
+// #76470 Introspection on Demand durchfuehren
+void SbUnoObject::doIntrospection( void )
+{
+ static Reference< XIntrospection > xIntrospection;
+
+ if( !bNeedIntrospection )
+ return;
+ bNeedIntrospection = FALSE;
+
+ if( !xIntrospection.is() )
+ {
+ // Introspection-Service holen
+ Reference< XMultiServiceFactory > xFactory( utl::getProcessServiceFactory() );
+ if ( xFactory.is() )
+ {
+ Reference< XInterface > xI = xFactory->createInstance( rtl::OUString::createFromAscii("com.sun.star.beans.Introspection") );
+ if (xI.is())
+ xIntrospection = Reference< XIntrospection >::query( xI );
+ //xI->queryInterface( ::getCppuType( (const Reference< XIntrospection > *)0 ), xIntrospection );
+ }
+ }
+ if( !xIntrospection.is() )
+ {
+ StarBASIC::FatalError( SbERR_INTERNAL_ERROR );
+ return;
+ }
+
+ // Introspection durchfuehren
+ try
+ {
+ mxUnoAccess = xIntrospection->inspect( maTmpUnoObj );
+ }
+ catch( RuntimeException& e )
+ {
+ String aMsg = implGetExceptionMsg( e );
+ }
+
+ if( !mxUnoAccess.is() )
+ {
+ // #51475 Ungueltiges Objekt kennzeichnen (kein mxMaterialHolder)
+ return;
+ }
+
+ // MaterialHolder vom Access holen
+ mxMaterialHolder = Reference< XMaterialHolder >::query( mxUnoAccess );
+
+ // ExactName vom Access holen
+ mxExactName = Reference< XExactName >::query( mxUnoAccess );
+}
+
+
+
+
+// #67781 Start einer Liste aller SbUnoMethod-Instanzen
+static SbUnoMethod* pFirst = NULL;
+
+void clearUnoMethods( void )
+{
+ SbUnoMethod* pMeth = pFirst;
+ while( pMeth )
+ {
+ pMeth->SbxValue::Clear();
+ pMeth = pMeth->pNext;
+ }
+}
+
+
+SbUnoMethod::SbUnoMethod
+(
+ const String& aName,
+ SbxDataType eSbxType,
+ Reference< XIdlMethod > xUnoMethod_
+)
+ : SbxMethod( aName, eSbxType )
+{
+ m_xUnoMethod = xUnoMethod_;
+ pParamInfoSeq = NULL;
+
+ // #67781 Methode in Liste eintragen
+ pNext = pFirst;
+ pPrev = NULL;
+ pFirst = this;
+ if( pNext )
+ pNext->pPrev = this;
+}
+
+SbUnoMethod::~SbUnoMethod()
+{
+ delete pParamInfoSeq;
+
+ if( this == pFirst )
+ pFirst = pNext;
+ else if( pPrev )
+ pPrev->pNext = pNext;
+ if( pNext )
+ pNext->pPrev = pPrev;
+}
+
+const Sequence<ParamInfo>& SbUnoMethod::getParamInfos( void )
+{
+ if( !pParamInfoSeq )
+ {
+ Sequence<ParamInfo> aTmp = m_xUnoMethod->getParameterInfos() ;
+ pParamInfoSeq = new Sequence<ParamInfo>( aTmp );
+ //pParamInfoSeq = new Sequence<ParamInfo>( m_xUnoMethod->getParameterInfos() );
+ }
+ return *pParamInfoSeq;
+}
+
+SbUnoProperty::SbUnoProperty
+(
+ const String& aName,
+ SbxDataType eSbxType,
+ const Property& aUnoProp_,
+ UINT32 nId_
+)
+ : SbxProperty( aName, eSbxType )
+{
+ aUnoProp = aUnoProp_;
+ nId = nId_;
+
+ // #54548, bei bedarf Dummy-Array einsetzen, damit SbiRuntime::CheckArray() geht
+ static SbxArrayRef xDummyArray = new SbxArray( SbxVARIANT );
+ if( eSbxType & SbxARRAY )
+ PutObject( xDummyArray );
+}
+
+SbUnoProperty::~SbUnoProperty()
+{}
+
+
+// #72732 Spezielle SbxVariable, die beim put/get prueft,
+// ob der Kontext fuer eine UnoClass sinnvoll ist. Sonst
+// liegt eventuell ein Schreibfehler im Basic-Source vor.
+BOOL UnoClassMemberVariable::Get( SbxValues& rRes ) const
+{
+ // Zugriff auf den Member einer UnoClass mit Parametern ist unsinnig
+ if( GetParameters() )
+ {
+ if( mpRuntime )
+ mpRuntime->Error( SbERR_NO_METHOD );
+ }
+ return SbxVariable::Get( rRes );
+}
+
+BOOL UnoClassMemberVariable::Put( const SbxValues& rRes )
+{
+ if( bInternalUse )
+ {
+ return SbxVariable::Put( rRes );
+ }
+ // Schreibzugriff auf den Member einer UnoClass ist immer falsch
+ mpRuntime->Error( SbERR_NO_METHOD );
+ return FALSE;
+}
+
+TYPEINIT1(UnoClassMemberVariable,SbxVariable)
+
+
+SbxVariable* SbUnoObject::Find( const XubString& rName, SbxClassType t )
+{
+ static Reference< XIdlMethod > xDummyMethod;
+ static Property aDummyProp;
+
+ SbxVariable* pRes = SbxObject::Find( rName, t );
+
+ if( bNeedIntrospection ) doIntrospection();
+
+ // Neu 4.3.1999: Properties on Demand anlegen, daher jetzt perIntrospectionAccess
+ // suchen, ob doch eine Property oder Methode des geforderten Namens existiert
+ if( !pRes && mxExactName.is() )
+ {
+ OUString aUNonCaseName( rName );
+ OUString aUName = mxExactName->getExactName( aUNonCaseName );
+ if( mxUnoAccess.is() )
+ {
+ if( aUName.len() )
+ {
+ if( mxUnoAccess->hasProperty( aUName, PropertyConcept::ALL - PropertyConcept::DANGEROUS ) )
+ {
+ const Property& rProp = mxUnoAccess->
+ getProperty( aUName, PropertyConcept::ALL - PropertyConcept::DANGEROUS );
+
+ // #58455 Wenn die Property void sein kann, muss als Typ Variant gesetzt werden
+ SbxDataType eSbxType;
+ if( rProp.Attributes & PropertyAttribute::MAYBEVOID )
+ eSbxType = SbxVARIANT;
+ else
+ eSbxType = unoToSbxType( TypeToIdlClass( rProp.Type ) );
+
+ // Property anlegen und reinbraten
+ SbxVariableRef xVarRef = new SbUnoProperty( rProp.Name, eSbxType, rProp, 0 );
+ QuickInsert( (SbxVariable*)xVarRef );
+ pRes = xVarRef;
+ }
+ else if( mxUnoAccess->hasMethod( aUName,
+ MethodConcept::ALL - MethodConcept::DANGEROUS ) )
+ {
+ // Methode ansprechen
+ const Reference< XIdlMethod >& rxMethod = mxUnoAccess->
+ getMethod( aUName, MethodConcept::ALL - MethodConcept::DANGEROUS );
+
+ // SbUnoMethode anlegen und reinbraten
+ SbxVariableRef xMethRef = new SbUnoMethod
+ ( rxMethod->getName(), unoToSbxType( rxMethod->getReturnType() ), rxMethod );
+ QuickInsert( (SbxVariable*)xMethRef );
+ pRes = xMethRef;
+ }
+ }
+
+ // Wenn immer noch nichts gefunden wurde, muss geprueft werden, ob NameAccess vorliegt
+ if( !pRes )
+ {
+ try
+ {
+ Reference< XNameAccess > xNameAccess( mxUnoAccess->queryAdapter( ::getCppuType( (const Reference< XPropertySet > *)0 ) ), UNO_QUERY );
+ OUString aUName( rName );
+
+ if( xNameAccess.is() && xNameAccess->hasByName( aUName ) )
+ {
+ Any aAny = xNameAccess->getByName( aUName );
+
+ // ACHTUNG: Die hier erzeugte Variable darf wegen bei XNameAccess
+ // nicht als feste Property in das Object aufgenommen werden und
+ // wird daher nirgendwo gehalten.
+ // Wenn das Probleme gibt, muss das kuenstlich gemacht werden oder
+ // es muss eine Klasse SbUnoNameAccessProperty geschaffen werden,
+ // bei der die Existenz staendig neu ueberprueft und die ggf. weg-
+ // geworfen wird, wenn der Name nicht mehr gefunden wird.
+ pRes = new SbxVariable( SbxVARIANT );
+ unoToSbxValue( pRes, aAny );
+ }
+ }
+ catch( WrappedTargetException& e1 )
+ {
+ // Anlegen, damit der Exception-Fehler nicht ueberschrieben wird
+ if( !pRes )
+ pRes = new SbxVariable( SbxVARIANT );
+
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetWrappedMsg( e1 ) );
+ }
+ catch( RuntimeException& e2 )
+ {
+ // Anlegen, damit der Exception-Fehler nicht ueberschrieben wird
+ if( !pRes )
+ pRes = new SbxVariable( SbxVARIANT );
+
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e2 ) );
+ }
+ }
+ }
+ else if( mxInvocation.is() )
+ {
+ if( aUName.len() )
+ {
+ if( mxInvocation->hasProperty( aUName ) )
+ {
+ // Property anlegen und reinbraten
+ SbxVariableRef xVarRef = new SbUnoProperty( aUName, SbxVARIANT, aDummyProp, 0 );
+ QuickInsert( (SbxVariable*)xVarRef );
+ pRes = xVarRef;
+ }
+ else if( mxInvocation->hasMethod( aUName ) )
+ {
+ // SbUnoMethode anlegen und reinbraten
+ SbxVariableRef xMethRef = new SbUnoMethod( aUName, SbxVARIANT, xDummyMethod );
+ QuickInsert( (SbxVariable*)xMethRef );
+ pRes = xMethRef;
+ }
+ }
+ }
+ }
+
+ // Ganz am Schluss noch pruefen, ob die Dbg_-Properties gemeint sind
+
+ if( !pRes )
+ {
+ if( rName.EqualsIgnoreCaseAscii( ID_DBG_SUPPORTEDINTERFACES ) ||
+ rName.EqualsIgnoreCaseAscii( ID_DBG_PROPERTIES ) ||
+ rName.EqualsIgnoreCaseAscii( ID_DBG_METHODS ) )
+ {
+ // Anlegen
+ implCreateDbgProperties();
+
+ // Jetzt muessen sie regulaer gefunden werden
+ pRes = SbxObject::Find( rName, SbxCLASS_DONTCARE );
+ }
+ }
+ return pRes;
+}
+
+// Hilfs-Methode zum Anlegen der dbg_-Properties
+void SbUnoObject::implCreateDbgProperties( void )
+{
+ Property aProp;
+
+ // Id == -1: Implementierte Interfaces gemaess ClassProvider anzeigen
+ SbxVariableRef xVarRef = new SbUnoProperty( ID_DBG_SUPPORTEDINTERFACES, SbxSTRING, aProp, -1 );
+ QuickInsert( (SbxVariable*)xVarRef );
+
+ // Id == -2: Properties ausgeben
+ xVarRef = new SbUnoProperty( ID_DBG_PROPERTIES, SbxSTRING, aProp, -2 );
+ QuickInsert( (SbxVariable*)xVarRef );
+
+ // Id == -3: Methoden ausgeben
+ xVarRef = new SbUnoProperty( ID_DBG_METHODS, SbxSTRING, aProp, -3 );
+ QuickInsert( (SbxVariable*)xVarRef );
+}
+
+void SbUnoObject::implCreateAll( void )
+{
+ // Bestehende Methoden und Properties alle wieder wegwerfen
+ pMethods = new SbxArray;
+ pProps = new SbxArray;
+
+ if( bNeedIntrospection ) doIntrospection();
+
+ // Instrospection besorgen
+ Reference< XIntrospectionAccess > xAccess = mxUnoAccess;
+ if( !xAccess.is() )
+ {
+ if( mxInvocation.is() )
+ xAccess = mxInvocation->getIntrospection();
+ }
+ if( !xAccess.is() )
+ return;
+
+ // Properties anlegen
+ Sequence<Property> props = xAccess->getProperties( PropertyConcept::ALL - PropertyConcept::DANGEROUS );
+ UINT32 nPropCount = props.getLength();
+ const Property* pProps = props.getConstArray();
+
+ UINT32 i;
+ for( i = 0 ; i < nPropCount ; i++ )
+ {
+ const Property& rProp = pProps[ i ];
+
+ // #58455 Wenn die Property void sein kann, muss als Typ Variant gesetzt werden
+ SbxDataType eSbxType;
+ if( rProp.Attributes & PropertyAttribute::MAYBEVOID )
+ eSbxType = SbxVARIANT;
+ else
+ eSbxType = unoToSbxType( TypeToIdlClass( rProp.Type ) );
+
+ // Property anlegen und reinbraten
+ SbxVariableRef xVarRef = new SbUnoProperty( rProp.Name, eSbxType, rProp, i );
+ QuickInsert( (SbxVariable*)xVarRef );
+ }
+
+ // Dbg_-Properties anlegen
+ implCreateDbgProperties();
+
+ // Methoden anlegen
+ Sequence< Reference< XIdlMethod > > aMethodSeq = xAccess->getMethods
+ ( MethodConcept::ALL - MethodConcept::DANGEROUS );
+ UINT32 nMethCount = aMethodSeq.getLength();
+ const Reference< XIdlMethod >* pMethods = aMethodSeq.getConstArray();
+ for( i = 0 ; i < nMethCount ; i++ )
+ {
+ // Methode ansprechen
+ const Reference< XIdlMethod >& rxMethod = pMethods[i];
+
+ // SbUnoMethode anlegen und reinbraten
+ SbxVariableRef xMethRef = new SbUnoMethod
+ ( rxMethod->getName(), unoToSbxType( rxMethod->getReturnType() ), rxMethod );
+ QuickInsert( (SbxVariable*)xMethRef );
+ }
+}
+
+
+// Wert rausgeben
+Any SbUnoObject::getUnoAny( void )
+{
+ Any aRetAny;
+ if( bNeedIntrospection ) doIntrospection();
+ if( mxMaterialHolder.is() )
+ aRetAny = mxMaterialHolder->getMaterial();
+ else if( mxInvocation.is() )
+ aRetAny <<= mxInvocation;
+ return aRetAny;
+}
+
+// Hilfsmethode zum Anlegen einer Uno-Struct per CoreReflection
+SbUnoObject* Impl_CreateUnoStruct( const String& aClassName )
+{
+ // CoreReflection holen
+ Reference< XIdlReflection > xCoreReflection = getCoreReflection_Impl();
+ if( !xCoreReflection.is() )
+ return NULL;
+
+ // Klasse suchen
+ Reference< XIdlClass > xClass = xCoreReflection->forName( aClassName );
+ if( !xClass.is() )
+ return NULL;
+
+ // Ist es ueberhaupt ein struct?
+ TypeClass eType = xClass->getTypeClass();
+ if( eType != TypeClass_STRUCT )
+ return NULL;
+
+ // Instanz erzeugen
+ Any aNewAny;
+ xClass->createObject( aNewAny );
+
+ // SbUnoObject daraus basteln
+ SbUnoObject* pUnoObj = new SbUnoObject( aClassName, aNewAny );
+ return pUnoObj;
+}
+
+
+// Factory-Klasse fuer das Anlegen von Uno-Structs per DIM AS NEW
+SbxBase* SbUnoFactory::Create( UINT16 nSbxId, UINT32 )
+{
+ // Ueber SbxId laeuft in Uno nix
+ return NULL;
+}
+
+SbxObject* SbUnoFactory::CreateObject( const String& rClassName )
+{
+ return Impl_CreateUnoStruct( rClassName );
+}
+
+
+// Provisorische Schnittstelle fuer UNO-Anbindung
+// Liefert ein SbxObject, das ein Uno-Interface wrappt
+SbxObjectRef GetSbUnoObject( const String& aName, const Any& aUnoObj_ )
+{
+ return new SbUnoObject( aName, aUnoObj_ );
+}
+
+void RTL_Impl_CreateUnoStruct( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite )
+{
+ // Wir brauchen mindestens 1 Parameter
+ if ( rPar.Count() < 2 )
+ {
+ StarBASIC::Error( SbERR_BAD_ARGUMENT );
+ return;
+ }
+
+ // Klassen-Name der struct holen
+ String aClassName = rPar.Get(1)->GetString();
+
+ // Versuchen, gleichnamige Struct zu erzeugen
+ SbUnoObjectRef xUnoObj = Impl_CreateUnoStruct( aClassName );
+ if( !xUnoObj )
+ return;
+
+ // Objekt zurueckliefern
+ SbxVariableRef refVar = rPar.Get(0);
+ refVar->PutObject( (SbUnoObject*)xUnoObj );
+}
+
+void RTL_Impl_CreateUnoService( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite )
+{
+ // Wir brauchen mindestens 1 Parameter
+ if ( rPar.Count() < 2 )
+ {
+ StarBASIC::Error( SbERR_BAD_ARGUMENT );
+ return;
+ }
+
+ // Klassen-Name der struct holen
+ String aServiceName = rPar.Get(1)->GetString();
+
+ // Service suchen und instanzieren
+ Reference< XMultiServiceFactory > xFactory( utl::getProcessServiceFactory() );
+ Reference< XInterface > xInterface;
+ if ( xFactory.is() )
+ {
+ try
+ {
+ xInterface = xFactory->createInstance( aServiceName );
+ }
+ catch( WrappedTargetException& e1 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetWrappedMsg( e1 ) );
+ }
+ catch( RuntimeException& e2 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e2 ) );
+ }
+ }
+
+ SbxVariableRef refVar = rPar.Get(0);
+ if( xInterface.is() )
+ {
+ Any aAny;
+ aAny <<= xInterface;
+
+ // SbUnoObject daraus basteln und zurueckliefern
+ SbUnoObjectRef xUnoObj = new SbUnoObject( aServiceName, aAny );
+ if( xUnoObj->getUnoAny().getValueType().getTypeClass() != TypeClass_VOID )
+ {
+ // Objekt zurueckliefern
+ refVar->PutObject( (SbUnoObject*)xUnoObj );
+ }
+ else
+ {
+ refVar->PutObject( NULL );
+ }
+ }
+ else
+ {
+ refVar->PutObject( NULL );
+ }
+}
+
+void RTL_Impl_GetProcessServiceManager( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite )
+{
+ SbxVariableRef refVar = rPar.Get(0);
+
+ // Globalen Service-Manager holen
+ Reference< XMultiServiceFactory > xFactory( utl::getProcessServiceFactory() );
+ if( xFactory.is() )
+ {
+ Any aAny;
+ aAny <<= xFactory;
+
+ // SbUnoObject daraus basteln und zurueckliefern
+ SbUnoObjectRef xUnoObj = new SbUnoObject( String( RTL_CONSTASCII_USTRINGPARAM("ProcessServiceManager") ), aAny );
+ refVar->PutObject( (SbUnoObject*)xUnoObj );
+ }
+ else
+ {
+ refVar->PutObject( NULL );
+ }
+}
+
+void RTL_Impl_HasInterfaces( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite )
+{
+ // Wir brauchen mindestens 2 Parameter
+ USHORT nParCount = rPar.Count();
+ if( nParCount < 3 )
+ {
+ StarBASIC::Error( SbERR_BAD_ARGUMENT );
+ return;
+ }
+
+ // Variable fuer Rueckgabewert
+ SbxVariableRef refVar = rPar.Get(0);
+ refVar->PutBool( FALSE );
+
+ // Uno-Objekt holen
+ SbxBaseRef pObj = (SbxBase*)rPar.Get( 1 )->GetObject();
+ if( !(pObj && pObj->ISA(SbUnoObject)) )
+ return;
+ Any aAny = ((SbUnoObject*)(SbxBase*)pObj)->getUnoAny();
+ TypeClass eType = aAny.getValueType().getTypeClass();
+ if( eType != TypeClass_INTERFACE )
+ return;
+
+ // Interface aus dem Any besorgen
+ Reference< XInterface > x = *(Reference< XInterface >*)aAny.getValue();
+
+ // CoreReflection holen
+ Reference< XIdlReflection > xCoreReflection = getCoreReflection_Impl();
+ if( !xCoreReflection.is() )
+ return;
+
+ for( USHORT i = 2 ; i < nParCount ; i++ )
+ {
+ // Interface-Name der struct holen
+ String aIfaceName = rPar.Get( i )->GetString();
+
+ // Klasse suchen
+ Reference< XIdlClass > xClass = xCoreReflection->forName( aIfaceName );
+ if( !xClass.is() )
+ return;
+
+ // Pruefen, ob das Interface unterstuetzt wird
+ OUString aClassName = xClass->getName();
+ Type aClassType( xClass->getTypeClass(), aClassName.getStr() );
+ if( !x->queryInterface( aClassType ).hasValue() )
+ return;
+ }
+
+ // Alles hat geklappt, dann TRUE liefern
+ refVar->PutBool( TRUE );
+}
+
+void RTL_Impl_IsUnoStruct( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite )
+{
+ // Wir brauchen mindestens 1 Parameter
+ if ( rPar.Count() < 2 )
+ {
+ StarBASIC::Error( SbERR_BAD_ARGUMENT );
+ return;
+ }
+
+ // Variable fuer Rueckgabewert
+ SbxVariableRef refVar = rPar.Get(0);
+ refVar->PutBool( FALSE );
+
+ // Uno-Objekt holen
+ SbxVariableRef xParam = rPar.Get( 1 );
+ if( !xParam->IsObject() )
+ return;
+ SbxBaseRef pObj = (SbxBase*)rPar.Get( 1 )->GetObject();
+ if( !(pObj && pObj->ISA(SbUnoObject)) )
+ return;
+ Any aAny = ((SbUnoObject*)(SbxBase*)pObj)->getUnoAny();
+ TypeClass eType = aAny.getValueType().getTypeClass();
+ if( eType == TypeClass_STRUCT )
+ refVar->PutBool( TRUE );
+}
+
+
+void RTL_Impl_EqualUnoObjects( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite )
+{
+ if ( rPar.Count() < 3 )
+ {
+ StarBASIC::Error( SbERR_BAD_ARGUMENT );
+ return;
+ }
+
+ // Variable fuer Rueckgabewert
+ SbxVariableRef refVar = rPar.Get(0);
+ refVar->PutBool( FALSE );
+
+ // Uno-Objekte holen
+ SbxVariableRef xParam1 = rPar.Get( 1 );
+ if( !xParam1->IsObject() )
+ return;
+ SbxBaseRef pObj1 = (SbxBase*)xParam1->GetObject();
+ if( !(pObj1 && pObj1->ISA(SbUnoObject)) )
+ return;
+ Any aAny1 = ((SbUnoObject*)(SbxBase*)pObj1)->getUnoAny();
+ TypeClass eType1 = aAny1.getValueType().getTypeClass();
+ if( eType1 != TypeClass_INTERFACE )
+ return;
+ Reference< XInterface > x1;
+ aAny1 >>= x1;
+ //XInterfaceRef x1 = *(XInterfaceRef*)aAny1.get();
+
+ SbxVariableRef xParam2 = rPar.Get( 2 );
+ if( !xParam2->IsObject() )
+ return;
+ SbxBaseRef pObj2 = (SbxBase*)xParam2->GetObject();
+ if( !(pObj2 && pObj2->ISA(SbUnoObject)) )
+ return;
+ Any aAny2 = ((SbUnoObject*)(SbxBase*)pObj2)->getUnoAny();
+ TypeClass eType2 = aAny2.getValueType().getTypeClass();
+ if( eType2 != TypeClass_INTERFACE )
+ return;
+ Reference< XInterface > x2;
+ aAny2 >>= x2;
+ //XInterfaceRef x2 = *(XInterfaceRef*)aAny2.get();
+
+ if( x1 == x2 )
+ refVar->PutBool( TRUE );
+}
+
+// Funktion, um einen globalen Bezeichner im
+// UnoScope zu suchen und fuer Sbx zu wrappen
+SbxVariable* findUnoClass( const String& rName )
+{
+ // CoreReflection holen
+ Reference< XIdlReflection > xCoreReflection = getCoreReflection_Impl();
+ if( !xCoreReflection.is() )
+ return NULL;
+
+ // Klasse suchen
+ Reference< XIdlClass > xClass = xCoreReflection->forName( rName );
+
+ // #72382 Klasse wird jetzt immer angelegt, da Module unbekannt sind
+ SbUnoClass* pUnoClass = new SbUnoClass( rName, xClass );
+ return pUnoClass;
+}
+
+SbxVariable* SbUnoClass::Find( const XubString& rName, SbxClassType t )
+{
+ SbxVariable* pRes = SbxObject::Find( rName, t );
+
+ // Wenn nichts gefunden wird, ist das Sub-Modul noch nicht bekannt
+ if( !pRes )
+ {
+ // Wenn es schon eine Klasse ist, nach einen Feld fragen
+ if( m_xClass.is() )
+ {
+ // Ist es ein Field
+ OUString aUStr( rName );
+ Reference< XIdlField > xField = m_xClass->getField( aUStr );
+ Reference< XIdlClass > xClass;
+ if( xField.is() )
+ {
+ try
+ {
+ Any aAny;
+ aAny = xField->get( aAny );
+
+ // Nach Sbx wandeln
+ pRes = new SbxVariable( SbxVARIANT );
+ pRes->SetName( rName );
+ unoToSbxValue( pRes, aAny );
+ }
+ catch( WrappedTargetException& e1 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetWrappedMsg( e1 ) );
+ }
+ catch( RuntimeException& e2 )
+ {
+ StarBASIC::Error( SbERR_INTERNAL_ERROR, implGetExceptionMsg( e2 ) );
+ }
+ }
+ }
+ else
+ {
+ // Vollqualifizierten Namen erweitern
+ String aNewName = GetName();
+ aNewName.AppendAscii( "." );
+ aNewName += rName;
+
+ // CoreReflection holen
+ Reference< XIdlReflection > xCoreReflection = getCoreReflection_Impl();
+ if( xCoreReflection.is() )
+ {
+ // Ist es eine Konstante?
+ Reference< XHierarchicalNameAccess > xHarryName( xCoreReflection, UNO_QUERY );
+ if( xHarryName.is() )
+ {
+ try
+ {
+ Any aValue = xHarryName->getByHierarchicalName( aNewName );
+ TypeClass eType = aValue.getValueType().getTypeClass();
+
+ // Interface gefunden? Dann ist es eine Klasse
+ if( eType == TypeClass_INTERFACE )
+ {
+ Reference< XInterface > xIface = *(Reference< XInterface >*)aValue.getValue();
+ Reference< XIdlClass > xClass( xIface, UNO_QUERY );
+ if( xClass.is() )
+ {
+ pRes = new SbxVariable( SbxVARIANT );
+ SbxObjectRef xWrapper = (SbxObject*)new SbUnoClass( aNewName, xClass );
+ pRes->PutObject( xWrapper );
+
+ }
+ }
+ else
+ {
+ pRes = new SbxVariable( SbxVARIANT );
+ unoToSbxValue( pRes, aValue );
+ }
+ }
+ catch( NoSuchElementException& e1 )
+ {
+ String aMsg = implGetExceptionMsg( e1 );
+ }
+ }
+
+ // Sonst wieder als Klasse annehmen
+ if( !pRes )
+ {
+ // neue Klasse erzeugen
+ Reference< XIdlClass > xClass;
+ pRes = new SbxVariable( SbxVARIANT );
+ SbxObjectRef xWrapper = (SbxObject*)new SbUnoClass( aNewName, xClass );
+ pRes->PutObject( xWrapper );
+ }
+ }
+ }
+
+ if( pRes )
+ {
+ pRes->SetName( rName );
+
+ // Variable einfuegen, damit sie spaeter im Find gefunden wird
+ QuickInsert( pRes );
+
+ // Uns selbst gleich wieder als Listener rausnehmen,
+ // die Werte sind alle konstant
+ if( pRes->IsBroadcaster() )
+ EndListening( pRes->GetBroadcaster(), TRUE );
+ }
+ }
+ return pRes;
+}
+
+
+//========================================================================
+//========================================================================
+//========================================================================
+
+// Implementation eines EventAttacher-bezogenen AllListeners, der
+// nur einzelne Events an einen allgemeinen AllListener weiterleitet
+class BasicAllListener_Impl : public BasicAllListenerHelper
+{
+ virtual void firing_impl(const AllEventObject& Event, Any* pRet);
+
+public:
+ SbxObjectRef xSbxObj;
+ OUString aPrefixName;
+
+ BasicAllListener_Impl( const OUString& aPrefixName );
+ ~BasicAllListener_Impl();
+
+ // Methoden von XInterface
+ //virtual BOOL queryInterface( Uik aUik, Reference< XInterface > & rOut );
+
+ // Methoden von XAllListener
+ virtual void SAL_CALL firing(const AllEventObject& Event) throw ( RuntimeException );
+ virtual Any SAL_CALL approveFiring(const AllEventObject& Event) throw ( RuntimeException );
+
+ // Methoden von XEventListener
+ virtual void SAL_CALL disposing(const EventObject& Source) throw ( RuntimeException );
+};
+
+
+//========================================================================
+BasicAllListener_Impl::BasicAllListener_Impl
+(
+ const OUString & aPrefixName_
+)
+ : aPrefixName( aPrefixName_ )
+{
+}
+
+//========================================================================
+BasicAllListener_Impl::~BasicAllListener_Impl()
+{
+}
+
+//========================================================================
+
+void BasicAllListener_Impl::firing_impl( const AllEventObject& Event, Any* pRet )
+{
+ NAMESPACE_VOS(OGuard) guard( Application::GetSolarMutex() );
+
+ if( xSbxObj.Is() )
+ {
+ OUString aMethodName = aPrefixName;
+ aMethodName = aMethodName + Event.MethodName;
+
+ SbxVariable * pP = xSbxObj;
+ while( pP->GetParent() )
+ {
+ pP = pP->GetParent();
+ StarBASIC * pLib = PTR_CAST(StarBASIC,pP);
+ if( pLib )
+ {
+ // In Basic Array anlegen
+ SbxArrayRef xSbxArray = new SbxArray( SbxVARIANT );
+ const Any * pArgs = Event.Arguments.getConstArray();
+ INT32 nCount = Event.Arguments.getLength();
+ for( INT32 i = 0; i < nCount; i++ )
+ {
+ // Elemente wandeln
+ SbxVariableRef xVar = new SbxVariable( SbxVARIANT );
+ unoToSbxValue( (SbxVariable*)xVar, pArgs[i] );
+ xSbxArray->Put( xVar, i +1 );
+ }
+
+ pLib->Call( aMethodName, xSbxArray );
+
+ // Return-Wert aus dem Param-Array holen, wenn verlangt
+ if( pRet )
+ {
+ SbxVariable* pVar = xSbxArray->Get( 0 );
+ if( pVar )
+ *pRet = sbxToUnoValue( pVar );
+ }
+ break;
+ }
+ }
+ }
+}
+
+
+// Methoden von XAllListener
+void BasicAllListener_Impl::firing( const AllEventObject& Event ) throw ( RuntimeException )
+{
+ firing_impl( Event, NULL );
+}
+
+Any BasicAllListener_Impl::approveFiring( const AllEventObject& Event ) throw ( RuntimeException )
+{
+ Any aRetAny;
+ firing_impl( Event, &aRetAny );
+ return aRetAny;
+}
+
+//========================================================================
+// Methoden von XEventListener
+void BasicAllListener_Impl ::disposing(const EventObject& ) throw ( RuntimeException )
+{
+ NAMESPACE_VOS(OGuard) guard( Application::GetSolarMutex() );
+
+ xSbxObj.Clear();
+}
+
+
+
+//*************************************************************************
+// class InvocationToAllListenerMapper
+// helper class to map XInvocation to XAllListener (also in project eventattacher!)
+//*************************************************************************
+class InvocationToAllListenerMapper : public WeakImplHelper1< XInvocation >
+{
+public:
+ InvocationToAllListenerMapper( const Reference< XIdlClass >& ListenerType,
+ const Reference< XAllListener >& AllListener, const Any& Helper );
+
+ // XInvocation
+ virtual Reference< XIntrospectionAccess > SAL_CALL getIntrospection(void) throw( RuntimeException );
+ virtual Any SAL_CALL invoke(const OUString& FunctionName, const Sequence< Any >& Params, Sequence< sal_Int16 >& OutParamIndex, Sequence< Any >& OutParam)
+ throw( IllegalArgumentException, CannotConvertException, InvocationTargetException, RuntimeException );
+ virtual void SAL_CALL setValue(const OUString& PropertyName, const Any& Value)
+ throw( UnknownPropertyException, CannotConvertException, InvocationTargetException, RuntimeException );
+ virtual Any SAL_CALL getValue(const OUString& PropertyName) throw( UnknownPropertyException, RuntimeException );
+ virtual sal_Bool SAL_CALL hasMethod(const OUString& Name) throw( RuntimeException );
+ virtual sal_Bool SAL_CALL hasProperty(const OUString& Name) throw( RuntimeException );
+
+private:
+ Reference< XIdlReflection > m_xCoreReflection;
+ Reference< XAllListener > m_xAllListener;
+ Reference< XIdlClass > m_xListenerType;
+ Any m_Helper;
+};
+
+
+// Function to replace AllListenerAdapterService::createAllListerAdapter
+Reference< XInterface > createAllListenerAdapter
+(
+ const Reference< XInvocationAdapterFactory >& xInvocationAdapterFactory,
+ const Reference< XIdlClass >& xListenerType,
+ const Reference< XAllListener >& xListener,
+ const Any& Helper
+)
+{
+ Reference< XInterface > xAdapter;
+ if( xInvocationAdapterFactory.is() && xListenerType.is() && xListener.is() )
+ {
+ Reference< XInvocation > xInvocationToAllListenerMapper =
+ (XInvocation*)new InvocationToAllListenerMapper( xListenerType, xListener, Helper );
+ Type aListenerType( xListenerType->getTypeClass(), xListenerType->getName() );
+ xAdapter = xInvocationAdapterFactory->createAdapter( xInvocationToAllListenerMapper, aListenerType );
+ }
+ return xAdapter;
+}
+
+
+//--------------------------------------------------------------------------------------------------
+// InvocationToAllListenerMapper
+InvocationToAllListenerMapper::InvocationToAllListenerMapper
+ ( const Reference< XIdlClass >& ListenerType, const Reference< XAllListener >& AllListener, const Any& Helper )
+ : m_xAllListener( AllListener )
+ , m_Helper( Helper )
+ , m_xListenerType( ListenerType )
+{
+}
+
+//*************************************************************************
+Reference< XIntrospectionAccess > SAL_CALL InvocationToAllListenerMapper::getIntrospection(void)
+ throw( RuntimeException )
+{
+ return Reference< XIntrospectionAccess >();
+}
+
+//*************************************************************************
+Any SAL_CALL InvocationToAllListenerMapper::invoke(const OUString& FunctionName, const Sequence< Any >& Params,
+ Sequence< sal_Int16 >& OutParamIndex, Sequence< Any >& OutParam)
+ throw( IllegalArgumentException, CannotConvertException,
+ InvocationTargetException, RuntimeException )
+{
+ Any aRet;
+
+ // Check if to firing or approveFiring has to be called
+ Reference< XIdlMethod > xMethod = m_xListenerType->getMethod( FunctionName );
+ sal_Bool bApproveFiring = sal_False;
+ if( !xMethod.is() )
+ return aRet;
+ Reference< XIdlClass > xReturnType = xMethod->getReturnType();
+ Sequence< Reference< XIdlClass > > aExceptionSeq = xMethod->getExceptionTypes();
+ if( ( xReturnType.is() && xReturnType->getTypeClass() != TypeClass_VOID ) ||
+ aExceptionSeq.getLength() > 0 )
+ {
+ bApproveFiring = sal_True;
+ }
+ else
+ {
+ Sequence< ParamInfo > aParamSeq = xMethod->getParameterInfos();
+ sal_uInt32 nParamCount = aParamSeq.getLength();
+ if( nParamCount > 1 )
+ {
+ const ParamInfo* pInfos = aParamSeq.getConstArray();
+ for( sal_uInt32 i = 0 ; i < nParamCount ; i++ )
+ {
+ if( pInfos[ i ].aMode != ParamMode_IN )
+ {
+ bApproveFiring = sal_True;
+ break;
+ }
+ }
+ }
+ }
+
+ AllEventObject aAllEvent;
+ aAllEvent.Source = (OWeakObject*) this;
+ aAllEvent.Helper = m_Helper;
+ aAllEvent.ListenerType = Type(m_xListenerType->getTypeClass(), m_xListenerType->getName() );
+ aAllEvent.MethodName = FunctionName;
+ aAllEvent.Arguments = Params;
+ if( bApproveFiring )
+ aRet = m_xAllListener->approveFiring( aAllEvent );
+ else
+ m_xAllListener->firing( aAllEvent );
+ return aRet;
+}
+
+//*************************************************************************
+void SAL_CALL InvocationToAllListenerMapper::setValue(const OUString& PropertyName, const Any& Value)
+ throw( UnknownPropertyException, CannotConvertException,
+ InvocationTargetException, RuntimeException )
+{
+}
+
+//*************************************************************************
+Any SAL_CALL InvocationToAllListenerMapper::getValue(const OUString& PropertyName)
+ throw( UnknownPropertyException, RuntimeException )
+{
+ return Any();
+}
+
+//*************************************************************************
+sal_Bool SAL_CALL InvocationToAllListenerMapper::hasMethod(const OUString& Name)
+ throw( RuntimeException )
+{
+ Reference< XIdlMethod > xMethod = m_xListenerType->getMethod( Name );
+ return xMethod.is();
+}
+
+//*************************************************************************
+sal_Bool SAL_CALL InvocationToAllListenerMapper::hasProperty(const OUString& Name)
+ throw( RuntimeException )
+{
+ Reference< XIdlField > xField = m_xListenerType->getField( Name );
+ return xField.is();
+}
+
+//========================================================================
+// Uno-Service erzeugen
+// 1. Parameter == Prefix-Name der Makros
+// 2. Parameter == voll qualifizierter Name des Listeners
+void SbRtl_CreateUnoListener( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite )
+//RTLFUNC(CreateUnoListener)
+{
+ // Wir brauchen mindestens 1 Parameter
+ if ( rPar.Count() != 3 )
+ {
+ StarBASIC::Error( SbERR_BAD_ARGUMENT );
+ return;
+ }
+
+ // Klassen-Name der struct holen
+ String aPrefixName = rPar.Get(1)->GetString();
+ String aListenerClassName = rPar.Get(2)->GetString();
+
+ // CoreReflection holen
+ Reference< XIdlReflection > xCoreReflection = getCoreReflection_Impl();
+ if( !xCoreReflection.is() )
+ return;
+
+ // AllListenerAdapterService holen
+ Reference< XMultiServiceFactory > xFactory( utl::getProcessServiceFactory() );
+ if( !xFactory.is() )
+ return;
+
+ // Klasse suchen
+ Reference< XIdlClass > xClass = xCoreReflection->forName( aListenerClassName );
+ if( !xClass.is() )
+ return;
+
+ // AB, 30.11.1999 InvocationAdapterFactory holen
+ Reference< XInvocationAdapterFactory > xInvocationAdapterFactory = Reference< XInvocationAdapterFactory >(
+ xFactory->createInstance( rtl::OUString::createFromAscii("com.sun.star.script.InvocationAdapterFactory") ), UNO_QUERY );
+
+ BasicAllListener_Impl * p;
+ Reference< XAllListener > xAllLst = p = new BasicAllListener_Impl( aPrefixName );
+ Any aTmp;
+ Reference< XInterface > xLst = createAllListenerAdapter( xInvocationAdapterFactory, xClass, xAllLst, aTmp );
+ if( !xLst.is() )
+ return;
+
+ OUString aClassName = xClass->getName();
+ Type aClassType( xClass->getTypeClass(), aClassName.getStr() );
+ aTmp = xLst->queryInterface( aClassType );
+ if( !aTmp.hasValue() )
+ return;
+
+ p->xSbxObj = new SbUnoObject( aListenerClassName, aTmp );
+ p->xSbxObj->SetParent( pBasic );
+
+ // Objekt zurueckliefern
+ SbxVariableRef refVar = rPar.Get(0);
+ refVar->PutObject( p->xSbxObj );
+}
+
+
+
diff --git a/basic/source/classes/sbxmod.cxx b/basic/source/classes/sbxmod.cxx
new file mode 100644
index 000000000000..187a5b45280c
--- /dev/null
+++ b/basic/source/classes/sbxmod.cxx
@@ -0,0 +1,1984 @@
+/*************************************************************************
+ *
+ * $RCSfile: sbxmod.cxx,v $
+ *
+ * $Revision: 1.1.1.1 $
+ *
+ * last change: $Author: hr $ $Date: 2000-09-18 16:12:10 $
+ *
+ * The Contents of this file are made available subject to the terms of
+ * either of the following licenses
+ *
+ * - GNU Lesser General Public License Version 2.1
+ * - Sun Industry Standards Source License Version 1.1
+ *
+ * Sun Microsystems Inc., October, 2000
+ *
+ * GNU Lesser General Public License Version 2.1
+ * =============================================
+ * Copyright 2000 by Sun Microsystems, Inc.
+ * 901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ *
+ * Sun Industry Standards Source License Version 1.1
+ * =================================================
+ * The contents of this file are subject to the Sun Industry Standards
+ * Source License Version 1.1 (the "License"); You may not use this file
+ * except in compliance with the License. You may obtain a copy of the
+ * License at http://www.openoffice.org/license.html.
+ *
+ * Software provided under this License is provided on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ * See the License for the specific provisions governing your rights and
+ * obligations concerning the Software.
+ *
+ * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ * Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ * All Rights Reserved.
+ *
+ * Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#if STLPORT_VERSION < 321
+#include <tools/presys.h>
+#include <list>
+#include <tools/postsys.h>
+#else
+#include <list>
+#endif
+
+#include <vos/macros.hxx>
+#include <vcl/svapp.hxx>
+
+#ifndef _STREAM_HXX //autogen
+#include <tools/stream.hxx>
+#endif
+#ifndef _SFXBRDCST_HXX //autogen
+#include <svtools/brdcst.hxx>
+#endif
+#ifndef _SHL_HXX //autogen
+#include <tools/shl.hxx>
+#endif
+#pragma hdrstop
+#include <svtools/sbx.hxx>
+#include "sb.hxx"
+#include <sbjsmeth.hxx>
+#include "sbjsmod.hxx"
+#include "sbintern.hxx"
+#include "image.hxx"
+#include "opcodes.hxx"
+#include "runtime.hxx"
+#include "token.hxx"
+#include "sbunoobj.hxx"
+#include <hilight.hxx>
+#include <basrdll.hxx>
+
+
+// for the bsearch
+#ifdef WNT
+#define CDECL _cdecl
+#endif
+#ifdef OS2
+#define CDECL _Optlink
+#endif
+#if defined(UNX) || defined(MAC)
+#define CDECL
+#endif
+
+
+// TEST
+#include <stdio.h>
+
+#include "segmentc.hxx"
+#pragma SW_SEGMENT_CLASS( SBASIC, SBASIC_CODE )
+
+TYPEINIT1(SbModule,SbxObject)
+TYPEINIT1(SbMethod,SbxMethod)
+TYPEINIT1(SbProperty,SbxProperty)
+TYPEINIT1(SbJScriptModule,SbModule)
+TYPEINIT1(SbJScriptMethod,SbMethod)
+
+SV_DECL_VARARR(SbiBreakpoints,USHORT,4,4)
+SV_IMPL_VARARR(SbiBreakpoints,USHORT)
+
+
+SV_IMPL_VARARR(HighlightPortions, HighlightPortion)
+
+// ##########################################################################
+// ACHTUNG!!! Alle Woerter dieser Tabelle mssen KLEIN geschrieben werden!!!
+// ##########################################################################
+static char* strListBasicKeyWords[] = {
+ "access",
+ "alias",
+ "and",
+ "any",
+ "append",
+ "as",
+ "base",
+ "binary",
+ "boolean",
+ "byval",
+ "call",
+ "case",
+ "cdecl",
+ "close",
+ "compare",
+ "const",
+ "currency",
+ "date",
+ "declare",
+ "defbool",
+ "defcur",
+ "defdate",
+ "defdbl",
+ "deferr",
+ "defint",
+ "deflng",
+ "defobj",
+ "defsng",
+ "defstr",
+ "defvar",
+ "dim",
+ "do",
+ "double",
+ "each",
+ "else",
+ "elseif",
+ "end",
+ "end function",
+ "end if",
+ "end select",
+ "end sub",
+ "end type",
+ "endif",
+ "eqv",
+ "erase",
+ "error",
+ "exit",
+ "explicit",
+ "for",
+ "function",
+ "global",
+ "gosub",
+ "goto",
+ "if",
+ "imp",
+ "in",
+ "input",
+ "integer",
+ "is",
+ "let",
+ "lib"
+ "line",
+ "line input",
+ "local",
+ "lock",
+ "long",
+ "loop",
+ "lprint",
+ "lset",
+ "mod",
+ "name",
+ "new",
+ "next",
+ "not",
+ "object",
+ "on",
+ "open",
+ "option",
+ "optional",
+ "or",
+ "output",
+ "preserve",
+ "print",
+ "private",
+ "public",
+ "random",
+ "read",
+ "redim",
+ "rem",
+ "resume",
+ "return",
+ "rset",
+ "select",
+ "set",
+ "shared",
+ "single",
+ "static",
+ "step",
+ "stop",
+ "string",
+ "sub",
+ "system",
+ "text",
+ "then",
+ "to",
+ "type",
+ "until",
+ "variant",
+ "wend",
+ "while",
+ "with",
+ "write",
+ "xor"
+};
+
+int CDECL compare_strings( const void *arg1, const void *arg2 )
+{
+ char* pCh = *(char**)arg2;
+ return strcmp( (char *)arg1, *(char **)arg2 );
+}
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+// Ein BASIC-Modul hat EXTSEARCH gesetzt, damit die im Modul enthaltenen
+// Elemente von anderen Modulen aus gefunden werden koennen.
+
+SbModule::SbModule( const String& rName )
+ : SbxObject( String( RTL_CONSTASCII_USTRINGPARAM("StarBASICModule") ) ),
+ pImage( NULL ), pBreaks( NULL )
+{
+ SetName( rName );
+ SetFlag( SBX_EXTSEARCH | SBX_GBLSEARCH );
+}
+
+SbModule::~SbModule()
+{
+ if( pImage )
+ delete pImage;
+ if( pBreaks )
+ delete pBreaks;
+}
+
+BOOL SbModule::IsCompiled() const
+{
+ return BOOL( pImage != 0 );
+}
+
+// Aus dem Codegenerator: Loeschen des Images und Invalidieren der Entries
+
+void SbModule::StartDefinitions()
+{
+ delete pImage; pImage = NULL;
+ // Methoden und Properties bleiben erhalten, sind jedoch ungueltig
+ // schliesslich sind ja u.U. die Infos belegt
+ USHORT i;
+ for( i = 0; i < pMethods->Count(); i++ )
+ {
+ SbMethod* p = PTR_CAST(SbMethod,pMethods->Get( i ) );
+ if( p )
+ p->bInvalid = TRUE;
+ }
+ for( i = 0; i < pProps->Count(); )
+ {
+ SbProperty* p = PTR_CAST(SbProperty,pProps->Get( i ) );
+ if( p )
+ pProps->Remove( i );
+ else
+ i++;
+ }
+}
+
+// Methode anfordern/anlegen
+
+SbMethod* SbModule::GetMethod( const String& rName, SbxDataType t )
+{
+ SbxVariable* p = pMethods->Find( rName, SbxCLASS_METHOD );
+ SbMethod* pMeth = p ? PTR_CAST(SbMethod,p) : NULL;
+ if( p && !pMeth )
+ pMethods->Remove( p );
+ if( !pMeth )
+ {
+ pMeth = new SbMethod( rName, t, this );
+ pMeth->SetParent( this );
+ pMeth->SetFlags( SBX_READ );
+ pMethods->Put( pMeth, pMethods->Count() );
+ StartListening( pMeth->GetBroadcaster(), TRUE );
+ }
+ // Per Default ist die Methode GUELTIG, da sie auch vom Compiler
+ // (Codegenerator) erzeugt werden kann
+ pMeth->bInvalid = FALSE;
+ pMeth->ResetFlag( SBX_FIXED );
+ pMeth->SetFlag( SBX_WRITE );
+ pMeth->SetType( t );
+ pMeth->ResetFlag( SBX_WRITE );
+ if( t != SbxVARIANT )
+ pMeth->SetFlag( SBX_FIXED );
+ return pMeth;
+}
+
+// Property anfordern/anlegen
+
+SbProperty* SbModule::GetProperty( const String& rName, SbxDataType t )
+{
+ SbxVariable* p = pProps->Find( rName, SbxCLASS_PROPERTY );
+ SbProperty* pProp = p ? PTR_CAST(SbProperty,p) : NULL;
+ if( p && !pProp )
+ pProps->Remove( p );
+ if( !pProp )
+ {
+ pProp = new SbProperty( rName, t, this );
+ pProp->SetFlag( SBX_READWRITE );
+ pProp->SetParent( this );
+ pProps->Put( pProp, pProps->Count() );
+ StartListening( pProp->GetBroadcaster(), TRUE );
+ }
+ return pProp;
+}
+
+// Aus dem Codegenerator: Ungueltige Eintraege entfernen
+
+void SbModule::EndDefinitions( BOOL bNewState )
+{
+ for( USHORT i = 0; i < pMethods->Count(); )
+ {
+ SbMethod* p = PTR_CAST(SbMethod,pMethods->Get( i ) );
+ if( p )
+ {
+ if( p->bInvalid )
+ pMethods->Remove( p );
+ else
+ {
+ p->bInvalid = bNewState;
+ i++;
+ }
+ }
+ }
+ SetModified( TRUE );
+}
+
+void SbModule::Clear()
+{
+ delete pImage; pImage = NULL;
+ SbxObject::Clear();
+}
+
+const String& SbModule::GetSource() const
+{
+ return aSource;
+}
+
+// Parent und BASIC sind eins!
+
+void SbModule::SetParent( SbxObject* p )
+{
+ DBG_ASSERT( !p || p->IsA( TYPE(StarBASIC) ), "SbModules nur in BASIC eintragen" );
+ pParent = p;
+}
+
+void SbModule::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
+ const SfxHint& rHint, const TypeId& rHintType )
+{
+ const SbxHint* pHint = PTR_CAST(SbxHint,&rHint);
+ if( pHint )
+ {
+ SbxVariable* pVar = pHint->GetVar();
+ SbProperty* pProp = PTR_CAST(SbProperty,pVar);
+ SbMethod* pMeth = PTR_CAST(SbMethod,pVar);
+ if( pProp )
+ {
+ if( pProp->GetModule() != this )
+ SetError( SbxERR_BAD_ACTION );
+ }
+ else if( pMeth )
+ {
+ if( pHint->GetId() == SBX_HINT_DATAWANTED )
+ {
+ if( pMeth->bInvalid && !Compile() )
+ // Auto-Compile hat nicht geklappt!
+ StarBASIC::Error( SbERR_BAD_PROP_VALUE );
+ else
+ {
+ // Aufruf eines Unterprogramms
+ SbModule* pOld = pMOD;
+ pMOD = this;
+ Run( (SbMethod*) pVar );
+ pMOD = pOld;
+ }
+ }
+ }
+ else
+ SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
+ }
+}
+
+// Das Setzen der Source macht das Image ungueltig
+// und scant die Methoden-Definitionen neu ein
+
+void SbModule::SetSource( const String& r )
+{
+ aSource = r;
+ StartDefinitions();
+ SbiTokenizer aTok( r );
+ while( !aTok.IsEof() )
+ {
+ SbiToken eEndTok = NIL;
+
+ // Suchen nach SUB oder FUNCTION
+ SbiToken eLastTok = NIL;
+ while( !aTok.IsEof() )
+ {
+ // #32385: Nicht bei declare
+ SbiToken eCurTok = aTok.Next();
+ if( eLastTok != DECLARE )
+ {
+ if( eCurTok == SUB )
+ {
+ eEndTok = ENDSUB; break;
+ }
+ if( eCurTok == FUNCTION )
+ {
+ eEndTok = ENDFUNC; break;
+ }
+ }
+ eLastTok = eCurTok;
+ }
+ // Definition der Methode
+ SbMethod* pMeth;
+ if( eEndTok != NIL )
+ {
+ USHORT nLine1 = aTok.GetLine();
+ if( aTok.Next() == SYMBOL )
+ {
+ String aName( aTok.GetSym() );
+ SbxDataType t = aTok.GetType();
+ if( t == SbxVARIANT && eEndTok == ENDSUB )
+ t = SbxVOID;
+ pMeth = GetMethod( aName, t );
+ pMeth->nLine1 = pMeth->nLine2 = nLine1;
+ // Die Methode ist erst mal GUELTIG
+ pMeth->bInvalid = FALSE;
+ }
+ else
+ eEndTok = NIL;
+ }
+ // Skip bis END SUB/END FUNCTION
+ if( eEndTok != NIL )
+ {
+ while( !aTok.IsEof() )
+ {
+ if( aTok.Next() == eEndTok )
+ {
+ pMeth->nLine2 = aTok.GetLine();
+ break;
+ }
+ }
+ if( aTok.IsEof() )
+ pMeth->nLine2 = aTok.GetLine();
+ }
+ }
+ EndDefinitions( TRUE );
+}
+
+void SbModule::SetComment( const String& r )
+{
+ aComment = r;
+ SetModified( TRUE );
+}
+
+SbMethod* SbModule::GetFunctionForLine( USHORT nLine )
+{
+ for( USHORT i = 0; i < pMethods->Count(); i++ )
+ {
+ SbMethod* p = (SbMethod*) pMethods->Get( i );
+ if( p->GetSbxId() == SBXID_BASICMETHOD )
+ {
+ if( nLine >= p->nLine1 && nLine <= p->nLine2 )
+ return p;
+ }
+ }
+ return NULL;
+}
+
+// Ausstrahlen eines Hints an alle Basics
+
+static void _SendHint( SbxObject* pObj, ULONG nId, SbMethod* p )
+{
+ // Selbst ein BASIC?
+ if( pObj->IsA( TYPE(StarBASIC) ) && pObj->IsBroadcaster() )
+ pObj->GetBroadcaster().Broadcast( SbxHint( nId, p ) );
+ // Dann die Unterobjekte fragen
+ SbxArray* pObjs = pObj->GetObjects();
+ for( USHORT i = 0; i < pObjs->Count(); i++ )
+ {
+ SbxVariable* pVar = pObjs->Get( i );
+ if( pVar->IsA( TYPE(SbxObject) ) )
+ _SendHint( PTR_CAST(SbxObject,pVar), nId, p );
+ }
+}
+
+static void SendHint( SbxObject* pObj, ULONG nId, SbMethod* p )
+{
+ while( pObj->GetParent() )
+ pObj = pObj->GetParent();
+ _SendHint( pObj, nId, p );
+}
+
+// #57841 Uno-Objekte, die in RTL-Funktionen gehalten werden,
+// beim Programm-Ende freigeben, damit nichts gehalten wird.
+void ClearUnoObjectsInRTL_Impl_Rek( StarBASIC* pBasic )
+{
+ // return-Wert von CreateUnoService loeschen
+ static String aName( RTL_CONSTASCII_USTRINGPARAM("CreateUnoService") );
+ SbxVariable* pVar = pBasic->GetRtl()->Find( aName, SbxCLASS_METHOD );
+ if( pVar )
+ pVar->SbxValue::Clear();
+
+ // Ueber alle Sub-Basics gehen
+ SbxArray* pObjs = pBasic->GetObjects();
+ USHORT nCount = pObjs->Count();
+ for( USHORT i = 0 ; i < nCount ; i++ )
+ {
+ SbxVariable* pObjVar = pObjs->Get( i );
+ StarBASIC* pSubBasic = PTR_CAST( StarBASIC, pObjVar );
+ if( pSubBasic )
+ ClearUnoObjectsInRTL_Impl_Rek( pSubBasic );
+ }
+}
+
+void ClearUnoObjectsInRTL_Impl( StarBASIC* pBasic )
+{
+ // #67781 Rueckgabewerte der Uno-Methoden loeschen
+ clearUnoMethods();
+
+ // Oberstes Basic suchen
+ SbxObject* p = pBasic;
+ while( p->GetParent() )
+ p = p->GetParent();
+
+ // Rekursiven Loeschvorgang ausloesen
+ ClearUnoObjectsInRTL_Impl_Rek( (StarBASIC*)p );
+}
+
+// Ausfuehren eines BASIC-Unterprogramms
+USHORT SbModule::Run( SbMethod* pMeth )
+{
+ USHORT nRes = 0;
+ BOOL bDelInst = BOOL( pINST == NULL );
+ StarBASICRef xBasic;
+ if( bDelInst )
+ {
+ // #32779: Basic waehrend der Ausfuehrung festhalten
+ xBasic = (StarBASIC*) GetParent();
+
+ pINST = new SbiInstance( (StarBASIC*) GetParent() );
+
+ // Error-Stack loeschen
+ SbErrorStack*& rErrStack = GetSbData()->pErrStack;
+ delete rErrStack;
+ rErrStack = NULL;
+ }
+ // Rekursion zu tief?
+ if( ++pINST->nCallLvl <= MAXRECURSION )
+ {
+ // Globale Variable in allen Mods definieren
+ GlobalRunInit( /* bBasicStart = */ bDelInst );
+
+ // Trat ein Compiler-Fehler auf? Dann starten wir nicht
+ if( GetSbData()->bGlobalInitErr == FALSE )
+ {
+ if( bDelInst )
+ {
+ SendHint( GetParent(), SBX_HINT_BASICSTART, pMeth );
+
+ // 16.10.96: #31460 Neues Konzept fuer StepInto/Over/Out
+ // Erklaerung siehe runtime.cxx bei SbiInstance::CalcBreakCallLevel()
+ // BreakCallLevel ermitteln
+ pINST->CalcBreakCallLevel( pMeth->GetDebugFlags() );
+ }
+
+ SbModule* pOldMod = pMOD;
+ pMOD = this;
+ SbiRuntime* pRt = new SbiRuntime( this, pMeth, pMeth->nStart );
+ pRt->pNext = pINST->pRun;
+ pINST->pRun = pRt;
+ while( pRt->Step() ) {}
+
+ // #63710 Durch ein anderes Thread-Handling bei Events kann es passieren,
+ // dass show-Aufruf an einem Dialog zurueckkehrt (durch schliessen des
+ // Dialogs per UI), BEVOR ein per Event ausgeloester weitergehender Call,
+ // der in Basic weiter oben im Stack steht und auf einen Basic-Breakpoint
+ // gelaufen ist, zurueckkehrt. Dann wird unten die Instanz zerstoert und
+ // wenn das noch im Call stehende Basic weiterlaeuft, gibt es einen GPF.
+ // Daher muss hier gewartet werden, bis andere Call zurueckkehrt.
+ if( bDelInst )
+ {
+ // Hier mit 1 statt 0 vergleichen, da vor nCallLvl--
+ while( pINST->nCallLvl != 1 )
+ GetpApp()->Yield();
+ }
+
+ nRes = TRUE;
+ pINST->pRun = pRt->pNext;
+ pINST->nCallLvl--; // Call-Level wieder runter
+
+ // Gibt es eine uebergeordnete Runtime-Instanz?
+ // Dann SbDEBUG_BREAK uebernehmen, wenn gesetzt
+ SbiRuntime* pRtNext = pRt->pNext;
+ if( pRtNext && (pRt->GetDebugFlags() & SbDEBUG_BREAK) )
+ pRtNext->SetDebugFlags( SbDEBUG_BREAK );
+
+ delete pRt;
+ pMOD = pOldMod;
+ if( bDelInst )
+ {
+ // #57841 Uno-Objekte, die in RTL-Funktionen gehalten werden,
+ // beim Programm-Ende freigeben, damit nichts gehalten wird.
+ ClearUnoObjectsInRTL_Impl( xBasic );
+
+ DBG_ASSERT(pINST->nCallLvl==0,"BASIC-Call-Level > 0")
+ delete pINST, pINST = NULL, bDelInst = FALSE;
+ SendHint( GetParent(), SBX_HINT_BASICSTOP, pMeth );
+ }
+ }
+ }
+ else
+ StarBASIC::FatalError( SbERR_STACK_OVERFLOW );
+ if( bDelInst )
+ {
+ // #57841 Uno-Objekte, die in RTL-Funktionen gehalten werden,
+ // beim Programm-Ende freigeben, damit nichts gehalten wird.
+ ClearUnoObjectsInRTL_Impl( xBasic );
+
+ delete pINST;
+ pINST = NULL;
+ }
+ return nRes;
+}
+
+// Ausfuehren der Init-Methode eines Moduls nach dem Laden
+// oder der Compilation
+
+void SbModule::RunInit()
+{
+ if( pImage
+ && !pImage->bInit
+ && pImage->GetFlag( SBIMG_INITCODE ) )
+ {
+ // Flag setzen, dass RunInit aktiv ist (Testtool)
+ GetSbData()->bRunInit = TRUE;
+
+ // BOOL bDelInst = BOOL( pINST == NULL );
+ // if( bDelInst )
+ // pINST = new SbiInstance( (StarBASIC*) GetParent() );
+ SbModule* pOldMod = pMOD;
+ pMOD = this;
+ // Der Init-Code beginnt immer hier
+ SbiRuntime* pRt = new SbiRuntime( this, NULL, 0 );
+ pRt->pNext = pINST->pRun;
+ pINST->pRun = pRt;
+ while( pRt->Step() ) {}
+ pINST->pRun = pRt->pNext;
+ delete pRt;
+ pMOD = pOldMod;
+ // if( bDelInst )
+ // delete pINST, pINST = NULL;
+ pImage->bInit = TRUE;
+
+ // RunInit ist nicht mehr aktiv
+ GetSbData()->bRunInit = FALSE;
+ }
+}
+
+// Mit private/dim deklarierte Variablen loeschen
+void SbModule::ClearPrivateVars()
+{
+ for( int i = 0 ; i < pProps->Count() ; i++ )
+ {
+ SbProperty* p = PTR_CAST(SbProperty,pProps->Get( i ) );
+ if( p )
+ {
+ // Arrays nicht loeschen, sondern nur deren Inhalt
+ if( p->GetType() & SbxARRAY )
+ {
+ SbxArray* pArray = PTR_CAST(SbxArray,p->GetObject());
+ if( pArray )
+ {
+ for( int j = 0 ; j < pArray->Count() ; j++ )
+ {
+ SbxVariable* pj = PTR_CAST(SbxVariable,pArray->Get( j ));
+ pj->SbxValue::Clear();
+ /*
+ USHORT nFlags = pj->GetFlags();
+ pj->SetFlags( (nFlags | SBX_WRITE) & (~SBX_FIXED) );
+ pj->PutEmpty();
+ pj->SetFlags( nFlags );
+ */
+ }
+ }
+ }
+ else
+ {
+ p->SbxValue::Clear();
+ /*
+ USHORT nFlags = p->GetFlags();
+ p->SetFlags( (nFlags | SBX_WRITE) & (~SBX_FIXED) );
+ p->PutEmpty();
+ p->SetFlags( nFlags );
+ */
+ }
+ }
+ }
+}
+
+// Zunaechst in dieses Modul, um 358-faehig zu bleiben
+// (Branch in sb.cxx vermeiden)
+void StarBASIC::ClearAllModuleVars( void )
+{
+ // Eigene Module initialisieren
+ for ( USHORT nMod = 0; nMod < pModules->Count(); nMod++ )
+ {
+ SbModule* pModule = (SbModule*)pModules->Get( nMod );
+ // Nur initialisieren, wenn der Startcode schon ausgefuehrt wurde
+ if( pModule->pImage && pModule->pImage->bInit )
+ pModule->ClearPrivateVars();
+ }
+ // Alle Objekte ueberpruefen, ob es sich um ein Basic handelt
+ // Wenn ja, auch dort initialisieren
+ for ( USHORT nObj = 0; nObj < pObjs->Count(); nObj++ )
+ {
+ SbxVariable* pVar = pObjs->Get( nObj );
+ StarBASIC* pBasic = PTR_CAST(StarBASIC,pVar);
+ if( pBasic )
+ pBasic->ClearAllModuleVars();
+ }
+
+}
+
+// Ausfuehren des Init-Codes aller Module
+void SbModule::GlobalRunInit( BOOL bBasicStart )
+{
+ // Wenn kein Basic-Start, nur initialisieren, wenn Modul uninitialisiert
+ if( !bBasicStart )
+ if( !(pImage && !pImage->bInit) )
+ return;
+
+ // GlobalInitErr-Flag fuer Compiler-Error initialisieren
+ // Anhand dieses Flags kann in SbModule::Run() nach dem Aufruf
+ // von GlobalRunInit festgestellt werden, ob beim initialisieren
+ // der Module ein Fehler auftrat. Dann wird nicht gestartet.
+ GetSbData()->bGlobalInitErr = FALSE;
+
+ // Parent vom Modul ist ein Basic
+ StarBASIC *pBasic = PTR_CAST(StarBASIC,GetParent());
+ if( pBasic )
+ {
+ pBasic->InitAllModules();
+
+ SbxObject* pParent = pBasic->GetParent();
+ if( pParent )
+ pBasic = PTR_CAST(StarBASIC,pParent);
+ if( pBasic )
+ pBasic->InitAllModules();
+ }
+}
+
+// Suche nach dem naechsten STMNT-Befehl im Code. Wird vom STMNT-
+// Opcode verwendet, um die Endspalte zu setzen.
+
+const BYTE* SbModule::FindNextStmnt( const BYTE* p, USHORT& nLine, USHORT& nCol ) const
+{
+ USHORT nPC = (USHORT) ( p - (const BYTE*) pImage->GetCode() );
+ while( nPC < pImage->GetCodeSize() )
+ {
+ SbiOpcode eOp = (SbiOpcode ) ( *p++ );
+ nPC++;
+ if( eOp >= SbOP1_START && eOp <= SbOP1_END )
+ p += 2, nPC += 2;
+ else if( eOp == _STMNT )
+ {
+ USHORT nl, nc;
+ nl = *p++; nl |= *p++ << 8;
+ nc = *p++; nc |= *p++ << 8;
+ nLine = nl; nCol = nc;
+ return p;
+ }
+ else if( eOp >= SbOP2_START && eOp <= SbOP2_END )
+ p += 4, nPC += 4;
+ else if( !( eOp >= SbOP0_START && eOp <= SbOP0_END ) )
+ {
+ StarBASIC::FatalError( SbERR_INTERNAL_ERROR );
+ break;
+ }
+ }
+ return NULL;
+}
+
+// Testen, ob eine Zeile STMNT-Opcodes enthaelt
+
+BOOL SbModule::IsBreakable( USHORT nLine ) const
+{
+ if( !pImage )
+ return FALSE;
+ const BYTE* p = (const BYTE* ) pImage->GetCode();
+ USHORT nl, nc;
+ while( ( p = FindNextStmnt( p, nl, nc ) ) != NULL )
+ if( nl == nLine )
+ return TRUE;
+ return FALSE;
+}
+
+USHORT SbModule::GetBPCount() const
+{
+ return pBreaks ? pBreaks->Count() : 0;
+}
+
+USHORT SbModule::GetBP( USHORT n ) const
+{
+ if( pBreaks && n < pBreaks->Count() )
+ return pBreaks->GetObject( n );
+ else
+ return 0;
+}
+
+BOOL SbModule::IsBP( USHORT nLine ) const
+{
+ if( pBreaks )
+ {
+ const USHORT* p = pBreaks->GetData();
+ USHORT n = pBreaks->Count();
+ for( USHORT i = 0; i < n; i++, p++ )
+ {
+ USHORT b = *p;
+ if( b == nLine )
+ return TRUE;
+ if( b < nLine )
+ break;
+ }
+ }
+ return FALSE;
+}
+
+BOOL SbModule::SetBP( USHORT nLine )
+{
+ if( !IsBreakable( nLine ) )
+ return FALSE;
+ if( !pBreaks )
+ pBreaks = new SbiBreakpoints;
+ const USHORT* p = pBreaks->GetData();
+ USHORT n = pBreaks->Count();
+ USHORT i;
+ for( i = 0; i < n; i++, p++ )
+ {
+ USHORT b = *p;
+ if( b == nLine )
+ return TRUE;
+ if( b < nLine )
+ break;
+ }
+ pBreaks->Insert( &nLine, 1, i );
+
+ // #38568: Zur Laufzeit auch hier SbDEBUG_BREAK setzen
+ if( pINST && pINST->pRun )
+ pINST->pRun->SetDebugFlags( SbDEBUG_BREAK );
+
+ return IsBreakable( nLine );
+}
+
+BOOL SbModule::ClearBP( USHORT nLine )
+{
+ BOOL bRes = FALSE;
+ if( pBreaks )
+ {
+ const USHORT* p = pBreaks->GetData();
+ USHORT n = pBreaks->Count();
+ for( USHORT i = 0; i < n; i++, p++ )
+ {
+ USHORT b = *p;
+ if( b == nLine )
+ {
+ pBreaks->Remove( i, 1 ); bRes = TRUE; break;
+ }
+ if( b < nLine )
+ break;
+ }
+ if( !pBreaks->Count() )
+ delete pBreaks, pBreaks = NULL;
+ }
+ return bRes;
+}
+
+void SbModule::ClearAllBP()
+{
+ delete pBreaks; pBreaks = NULL;
+}
+
+BOOL SbModule::LoadData( SvStream& rStrm, USHORT nVer )
+{
+ Clear();
+ if( !SbxObject::LoadData( rStrm, 1 ) )
+ return FALSE;
+ // Sicherheitshalber...
+ SetFlag( SBX_EXTSEARCH | SBX_GBLSEARCH );
+ BYTE bImage;
+ rStrm >> bImage;
+ if( bImage )
+ {
+ SbiImage* p = new SbiImage;
+ if( !p->Load( rStrm ) )
+ {
+ delete p;
+ return FALSE;
+ }
+ aComment = p->aComment;
+ SetName( p->aName );
+ // Ist Code vorhanden?
+ if( p->GetCodeSize() )
+ {
+ aSource = p->aSource;
+ // Alte Version: Image weg
+ if( nVer == 1 )
+ {
+ SetSource( p->aSource );
+ delete p;
+ }
+ else
+ pImage = p;
+ }
+ else
+ {
+ SetSource( p->aSource );
+ delete p;
+ }
+ }
+ return TRUE;
+}
+
+BOOL SbModule::StoreData( SvStream& rStrm ) const
+{
+ if( !SbxObject::StoreData( rStrm ) )
+ return FALSE;
+ if( pImage )
+ {
+ pImage->aSource = aSource;
+ pImage->aComment = aComment;
+ pImage->aName = GetName();
+ rStrm << (BYTE) 1;
+ return pImage->Save( rStrm );
+ }
+ else
+ {
+ SbiImage aImg;
+ aImg.aSource = aSource;
+ aImg.aComment = aComment;
+ aImg.aName = GetName();
+ rStrm << (BYTE) 1;
+ return aImg.Save( rStrm );
+ }
+}
+
+BOOL SbModule::LoadCompleted()
+{
+ SbxArray* p = GetMethods();
+ USHORT i;
+ for( i = 0; i < p->Count(); i++ )
+ {
+ SbMethod* q = PTR_CAST(SbMethod,p->Get( i ) );
+ if( q )
+ q->pMod = this;
+ }
+ p = GetProperties();
+ for( i = 0; i < p->Count(); i++ )
+ {
+ SbProperty* q = PTR_CAST(SbProperty,p->Get( i ) );
+ if( q )
+ q->pMod = this;
+ }
+ return TRUE;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// Hilfsklasse zur Untersuchung von JavaScript-Modulen, zunaechst zum
+// Heraussuchen der Funktionen, spaeter auch zum Syntax-Highlighting verwenden
+
+// Flags fuer Zeichen-Eigenschaften
+#define CHAR_START_IDENTIFIER 0x0001
+#define CHAR_IN_IDENTIFIER 0x0002
+#define CHAR_START_NUMBER 0x0004
+#define CHAR_IN_NUMBER 0x0008
+#define CHAR_IN_HEX_NUMBER 0x0010
+#define CHAR_IN_OCT_NUMBER 0x0020
+#define CHAR_START_STRING 0x0040
+#define CHAR_OPERATOR 0x0080
+#define CHAR_SPACE 0x0100
+#define CHAR_EOL 0x0200
+
+#define CHAR_EOF 0x00
+
+
+// Token-Typen TT_...
+
+//enum TokenType
+//{
+// TT_UNKNOWN,
+// TT_IDENTIFIER,
+// TT_WHITESPACE,
+// TT_NUMBER,
+// TT_STRING,
+//// TT_HTMLSTRING,
+//// TT_LONG,
+//// TT_DOUBLE,
+//// TT_BOOLEAN,
+//// TT_NULLOBJECT,
+//// TT_CHAR,
+// TT_EOL,
+//// TT_LONG2DOUBLE,
+// TT_COMMENT,
+//// TT_SKIP,
+// TT_ERROR,
+// TT_OPERATOR,
+// TT_KEYWORD
+//};
+
+
+class SimpleTokenizer_Impl
+{
+ // Zeichen-Info-Tabelle
+ USHORT aCharTypeTab[256];
+
+ const char* mpStringBegin;
+ const char* mpActualPos;
+
+ // Zeile und Spalte
+ UINT32 nLine;
+ UINT32 nCol;
+
+ char peekChar( void ) { return *mpActualPos; }
+ char getChar( void ) { nCol++; return *mpActualPos++; }
+
+ // Hilfsfunktion: Zeichen-Flag Testen
+ BOOL testCharFlags( unsigned char c, USHORT nTestFlags );
+
+ // Neues Token holen, Leerstring == nix mehr da
+ BOOL getNextToken( /*out*/TokenTypes& reType,
+ /*out*/const char*& rpStartPos, /*out*/const char*& rpEndPos );
+
+ String getTokStr( /*out*/const char* pStartPos, /*out*/const char* pEndPos );
+
+ // TEST: Token ausgeben
+ String getFullTokenStr( /*out*/TokenTypes eType,
+ /*out*/const char* pStartPos, /*out*/const char* pEndPos );
+
+ BOOL isBeginComment( UINT32 nLine );
+ void setCommentState(UINT32 nLine, BOOL bCommentBegin, BOOL bCommentEnd);
+
+ NAMESPACE_STD(list)<BOOL>* pCommentsBegin;
+ NAMESPACE_STD(list)<BOOL>* pCommentsEnd;
+
+ char** ppListKeyWords;
+ UINT16 nKeyWordCount;
+ BOOL bStarScriptMode;
+
+ BOOL bLineHasCommentBegin;
+ BOOL bLineHasCommentEnd;
+
+public:
+ SimpleTokenizer_Impl( void );
+ ~SimpleTokenizer_Impl( void );
+
+ UINT16 parseLine( UINT32 nLine, const String* aSource );
+ void getHighlightPortions( UINT32 nParseLine, const String& rLine,
+ /*out*/HighlightPortions& portions );
+ void addLines(UINT32 nLine, INT32 nCount);
+ void outCommentList();
+ void setKeyWords( char** ppKeyWords, UINT16 nCount );
+};
+
+// Hilfsfunktion: Zeichen-Flag Testen
+BOOL SimpleTokenizer_Impl::testCharFlags( unsigned char c, USHORT nTestFlags )
+{
+ if( c != 0 )
+ return ( (aCharTypeTab[c] & nTestFlags) != 0 );
+ return FALSE;
+}
+
+void SimpleTokenizer_Impl::setKeyWords( char** ppKeyWords, UINT16 nCount )
+{
+ ppListKeyWords = ppKeyWords;
+ nKeyWordCount = nCount;
+}
+
+// Neues Token holen
+BOOL SimpleTokenizer_Impl::getNextToken( /*out*/TokenTypes& reType,
+ /*out*/const char*& rpStartPos, /*out*/const char*& rpEndPos )
+{
+ reType = TT_UNKNOWN;
+
+ // Position merken
+ rpStartPos = mpActualPos;
+
+ // Zeichen untersuchen
+ char c = peekChar();
+ if( c == CHAR_EOF )
+ return FALSE;
+
+ // Zeichen lesen
+ getChar();
+
+ //*** Alle Moeglichkeiten durchgehen ***
+ // Spce?
+ if ( (testCharFlags( c, CHAR_SPACE ) == TRUE) && (!bLineHasCommentBegin) )
+ {
+ while( testCharFlags( peekChar(), CHAR_SPACE ) == TRUE )
+ getChar();
+
+ reType = TT_WHITESPACE;
+ }
+
+ // Identifier?
+ else if ( (testCharFlags( c, CHAR_START_IDENTIFIER ) == TRUE) && (!bLineHasCommentBegin) )
+ {
+ BOOL bIdentifierChar;
+ int nPos = 0;
+ do
+ {
+ // Naechstes Zeichen holen
+ c = peekChar();
+ bIdentifierChar = testCharFlags( c, CHAR_IN_IDENTIFIER );
+ if( bIdentifierChar )
+ getChar();
+ }
+ while( bIdentifierChar );
+
+ reType = TT_IDENTIFIER;
+
+ // Schluesselwort-Tabelle
+ if (ppListKeyWords != NULL)
+ {
+ ByteString aByteStr(rpStartPos, mpActualPos-rpStartPos);
+ if ( !bStarScriptMode )
+ aByteStr.ToLowerAscii();
+
+ if ( bsearch( aByteStr.GetBuffer(), ppListKeyWords, nKeyWordCount, sizeof( char* ),
+ compare_strings ) )
+ {
+ reType = TT_KEYWORD;
+
+ if ( (!bStarScriptMode) && (aByteStr.Equals( "rem" )) )
+ {
+ // Alle Zeichen bis Zeilen-Ende oder EOF entfernen
+ char cPeek = peekChar();
+ while( cPeek != CHAR_EOF && testCharFlags( cPeek, CHAR_EOL ) == FALSE )
+ {
+ c = getChar();
+ cPeek = peekChar();
+ }
+
+ reType = TT_COMMENT;
+ }
+ }
+ }
+ }
+
+ // Operator?
+ else if ( (testCharFlags( c, CHAR_OPERATOR ) == TRUE) || bLineHasCommentBegin
+ || ((!bStarScriptMode) && (c == '\'')) )
+ {
+ // Kommentar ?
+ if ( (( c == '/' ) || bLineHasCommentBegin) || ((!bStarScriptMode) && (c == '\'')) )
+ {
+ char cNext = peekChar();
+ if ( cNext == '/' || ( bStarScriptMode && (cNext == '*' || bLineHasCommentBegin))
+ || ((!bStarScriptMode) && (c == '\'')) ) // Kommentar
+ {
+ if ((c == '*') && (cNext == '/')) // Kommentarende am Zeilenanfang
+ {
+ getChar(); // Zeichen entfernen
+
+ bLineHasCommentEnd = TRUE;
+ bLineHasCommentBegin = FALSE;
+
+ reType = TT_COMMENT;
+ }
+ else if ( (cNext == '/' && (!bStarScriptMode || !bLineHasCommentBegin))
+ || ((!bStarScriptMode) && (c == '\'')) )// C++ - Kommentar
+ {
+ c = getChar(); // '/' entfernen
+
+ // Alle Zeichen bis Zeilen-Ende oder EOF entfernen
+ char cPeek = peekChar();
+ while( cPeek != CHAR_EOF && testCharFlags( cPeek, CHAR_EOL ) == FALSE )
+ {
+ c = getChar();
+ cPeek = peekChar();
+
+ if (c == '*' && cPeek == '/')
+ {
+ bLineHasCommentEnd = TRUE;
+ }
+ }
+
+ reType = TT_COMMENT;
+ }
+ else if (( cNext == '*' ) || bLineHasCommentBegin) // C -Kommentar
+ {
+ bLineHasCommentBegin = !bLineHasCommentBegin;
+
+ // Alle Zeichen bis */ entfernen
+ do
+ {
+ c = getChar();
+ cNext = peekChar();
+
+ // Zeilennummer auch im Kommentar pflegen
+ if( testCharFlags( c, CHAR_EOL ) == TRUE )
+ {
+ // Doppelt-EOL rausschmeissen (CR/LF)
+ if( cNext != c && testCharFlags( cNext, CHAR_EOL ) == TRUE )
+ {
+ c = getChar();
+ cNext = peekChar();
+ }
+
+ setCommentState(nLine, bLineHasCommentBegin, bLineHasCommentEnd);
+ bLineHasCommentBegin = FALSE;
+ bLineHasCommentEnd = FALSE;
+
+ // Positions-Daten auf Zeilen-Beginn setzen
+ nCol = 0;
+ nLine++;
+ }
+ else if (c == '*' && cNext == '/') // am Kommentarende
+ {
+ if (bLineHasCommentBegin) // das Ende ist in der gleichen Zeile
+ { // wie der Anfang des Kommentars
+ bLineHasCommentBegin = FALSE; // also zurcksetzen
+ }
+ else
+ {
+ bLineHasCommentEnd = TRUE;
+ }
+ }
+ }
+ while( cNext != CHAR_EOF && ( c != '*' || cNext != '/' ) );
+
+ // Alles ausser EOF lesen
+ if( cNext != CHAR_EOF )
+ getChar();
+
+ reType = TT_COMMENT;
+ }
+ }
+ }
+ // HTML-Kommentar
+ else if( c == '<' )
+ {
+ char cNext = peekChar();
+ if( cNext == '!' )
+ {
+ getChar(); // '!' ist verloren, wenn nicht wirklich Tag
+
+ cNext = peekChar();
+ if( cNext == '-' )
+ {
+ getChar(); // '-' ist verloren, wenn nicht wirklich Tag
+
+ cNext = peekChar();
+ if( cNext == '-' )
+ {
+ getChar();
+
+ // HTML-Kommentar: Alle Zeichen bis Zeilen-Ende oder EOF entfernen
+ char cPeek = peekChar();
+ while( cPeek != CHAR_EOF && testCharFlags( cPeek, CHAR_EOL ) == FALSE )
+ {
+ c = getChar();
+ cPeek = peekChar();
+ }
+
+ reType = TT_COMMENT;
+ }
+ else
+ {
+ // Verlorene Zeichen nachliefern
+ mpActualPos -= 2;
+ }
+ }
+ else
+ {
+ // Verlorenes Zeichen nachliefern
+ mpActualPos--;
+ }
+ }
+ }
+
+ // Echter Operator, kann hier einfach behandelt werden,
+ // da nicht der wirkliche Operator, wie z.B. += interessiert,
+ // sondern nur die Tatsache, dass es sich um einen handelt.
+ if( reType != TT_COMMENT )
+ {
+ reType = TT_OPERATOR;
+ }
+ }
+
+ // Objekt-Trenner? Muss vor Number abgehandelt werden
+ else if( c == '.' && ( peekChar() < '0' || peekChar() > '9' ) )
+ {
+ reType = TT_OPERATOR;
+ }
+
+ // Zahl?
+ else if( testCharFlags( c, CHAR_START_NUMBER ) == TRUE )
+ {
+ // Buffer-Position initialisieren
+ int nPos = 0;
+
+ // Zahlensystem, 10 = normal, wird bei Oct/Hex geaendert
+ int nRadix = 10;
+
+ // Ist es eine Hex- oder Oct-Zahl?
+ if( c == '0' )
+ {
+ // Octal?
+ // Java-Script geht von einem Octal-Wert aus, wenn nach 0 eine
+ // Ziffer im oktalen Ziffernbereich folgt
+ if( testCharFlags( peekChar(), CHAR_IN_OCT_NUMBER ) )
+ {
+ nRadix = 8; // Octal-Basis
+
+ // Alle Ziffern einlesen
+ while( testCharFlags( peekChar(), CHAR_IN_OCT_NUMBER ) )
+ c = getChar();
+ }
+
+ // Dementsprechend wird bei 0x Hex geparsed
+ else if( peekChar() == 'x' || peekChar() == 'X' )
+ {
+ // x entfernen
+ getChar();
+ nRadix = 16; // Hex-Basis
+
+ // Alle Ziffern einlesen und puffern
+ while( testCharFlags( peekChar(), CHAR_IN_HEX_NUMBER ) )
+ c = getChar();
+ }
+ }
+
+ // Wenn nicht Oct oder Hex als double ansehen
+ if( nRadix == 10 )
+ {
+ // Flag, ob das letzte Zeichen ein Exponent war
+ BOOL bAfterExpChar = FALSE;
+
+ // Alle Ziffern einlesen
+ while( testCharFlags( peekChar(), CHAR_IN_NUMBER ) ||
+ (bAfterExpChar && peekChar() == '+' ) ||
+ (bAfterExpChar && peekChar() == '-' ) )
+ // Nach Exponent auch +/- OK
+ {
+ c = getChar(); // Zeichen lesen
+ bAfterExpChar = ( c == 'e' || c == 'E' );
+ }
+ }
+
+ reType = TT_NUMBER;
+ }
+
+ // String?
+ else if( testCharFlags( c, CHAR_START_STRING ) == TRUE )
+ {
+ // Merken, welches Zeichen den String eroeffnet hat
+ char cEndString = c;
+
+ // Alle Ziffern einlesen und puffern
+ while( peekChar() != cEndString )
+ {
+ // #58846 EOF vor getChar() abfangen, damit EOF micht verloren geht
+ if( peekChar() == CHAR_EOF )
+ {
+ // ERROR: unterminated string literal
+ reType = TT_ERROR;
+ break;
+ }
+ c = getChar();
+ if( testCharFlags( c, CHAR_EOL ) == TRUE )
+ {
+ // ERROR: unterminated string literal
+ reType = TT_ERROR;
+ break;
+ }
+ // Escape-Character untersuchen
+ else if ( (c == '\\') && (bStarScriptMode) )
+ {
+ // Kann hier ganz einfach gehandelt werden:
+ // Einfach ein weiteres Zeichen lesen
+ char cNext = getChar();
+ }
+ }
+
+ // Zeichen lesen
+ if( reType != TT_ERROR )
+ {
+ getChar();
+ reType = TT_STRING;
+ }
+ }
+
+ // Zeilenende?
+ else if( testCharFlags( c, CHAR_EOL ) == TRUE )
+ {
+ // Falls ein weiteres anderes EOL-Char folgt, weg damit
+ char cNext = peekChar();
+ if( cNext != c && testCharFlags( cNext, CHAR_EOL ) == TRUE )
+ getChar();
+
+ setCommentState(nLine, bLineHasCommentBegin, bLineHasCommentEnd);
+ bLineHasCommentBegin = FALSE;
+ bLineHasCommentEnd = FALSE;
+
+ // Positions-Daten auf Zeilen-Beginn setzen
+ nCol = 0;
+ nLine++;
+
+ reType = TT_EOL;
+ }
+
+ // Alles andere bleibt TT_UNKNOWN
+
+
+ // End-Position eintragen
+ rpEndPos = mpActualPos;
+ return TRUE;
+}
+
+void SimpleTokenizer_Impl::setCommentState(UINT32 nLine, BOOL bCommentBegin, BOOL bCommentEnd)
+{
+ while (pCommentsBegin->size() <= nLine)
+ pCommentsBegin->push_back(FALSE);
+
+ while (pCommentsEnd->size() <= nLine)
+ pCommentsEnd->push_back(FALSE);
+
+ NAMESPACE_STD(list)<BOOL>::iterator posBegins, posEnds;
+ UINT32 nCounter = 0;
+
+ posBegins = pCommentsBegin->begin();
+ posEnds = pCommentsEnd->begin();
+
+ while (nCounter < nLine)
+ {
+ posBegins++;
+ posEnds++;
+ nCounter++;
+ }
+
+ *posBegins = bCommentBegin;
+ *posEnds = bCommentEnd;
+}
+
+void SimpleTokenizer_Impl::addLines(UINT32 nLine, INT32 nCount)
+{
+ NAMESPACE_STD(list)<BOOL>::iterator posBegins, posEnds;
+ UINT32 nCounter = 0;
+
+ if (!pCommentsBegin->empty())
+ {
+ posBegins = pCommentsBegin->begin();
+ posEnds = pCommentsEnd->begin();
+
+ while (nCounter < nLine)
+ {
+ posBegins++;
+ posEnds++;
+ nCounter++;
+ }
+
+ INT32 nDiff = nCount;
+ while (nDiff != 0)
+ {
+ if (nDiff > 0)
+ {
+ pCommentsBegin->insert(posBegins, FALSE);
+ pCommentsEnd->insert(posEnds, FALSE);
+ nDiff--;
+ }
+ else
+ {
+ pCommentsBegin->erase(posBegins++);
+ pCommentsEnd->erase(posEnds++);
+ UINT16 dummy = pCommentsBegin->size();
+
+ nDiff++;
+ }
+ }
+ }
+ else if (nCount > 0)
+ {
+ INT32 nDiff = nCount;
+ while (nDiff != 0)
+ {
+ pCommentsBegin->push_back(FALSE);
+ pCommentsEnd->push_back(FALSE);
+ nDiff--;
+ }
+ }
+}
+
+String SimpleTokenizer_Impl::getTokStr
+ ( /*out*/const char* pStartPos, /*out*/const char* pEndPos )
+{
+ return String( pStartPos, (USHORT)( pEndPos - pStartPos ) );
+}
+
+// TEST: Token ausgeben
+String SimpleTokenizer_Impl::getFullTokenStr( /*out*/TokenTypes eType,
+ /*out*/const char* pStartPos, /*out*/const char* pEndPos )
+{
+ String aOut;
+ switch( eType )
+ {
+ case TT_UNKNOWN: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_UNKNOWN:") ); break;
+ case TT_IDENTIFIER: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_IDENTIFIER:") ); break;
+ case TT_WHITESPACE: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_WHITESPACE:") ); break;
+ case TT_NUMBER: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_NUMBER:") ); break;
+ case TT_STRING: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_STRING:") ); break;
+ case TT_EOL: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_EOL:") ); break;
+ case TT_COMMENT: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_COMMENT:") ); break;
+ case TT_ERROR: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_ERROR:") ); break;
+ case TT_OPERATOR: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_OPERATOR:") ); break;
+ case TT_KEYWORD: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_KEYWORD:") ); break;
+ }
+ if( eType != TT_EOL )
+ {
+ aOut += String( pStartPos, (USHORT)( pEndPos - pStartPos ) );
+ }
+ aOut += String( RTL_CONSTASCII_USTRINGPARAM("\n") );
+ return aOut;
+}
+
+SimpleTokenizer_Impl::SimpleTokenizer_Impl( void )
+{
+ memset( aCharTypeTab, 0, sizeof( aCharTypeTab ) );
+
+ // Zeichen-Tabelle fuellen
+ USHORT i;
+
+ // Zulaessige Zeichen fuer Identifier
+ USHORT nHelpMask = (USHORT)( CHAR_START_IDENTIFIER | CHAR_IN_IDENTIFIER );
+ for( i = 'a' ; i <= 'z' ; i++ )
+ aCharTypeTab[i] |= nHelpMask;
+ for( i = 'A' ; i <= 'Z' ; i++ )
+ aCharTypeTab[i] |= nHelpMask;
+ // '_' extra eintragen
+ aCharTypeTab['_'] |= nHelpMask;
+ // AB 23.6.97: '$' ist auch erlaubt
+ aCharTypeTab['$'] |= nHelpMask;
+
+ // Ziffern (Identifier und Number ist moeglich)
+ nHelpMask = (USHORT)( CHAR_IN_IDENTIFIER | CHAR_START_NUMBER |
+ CHAR_IN_NUMBER | CHAR_IN_HEX_NUMBER );
+ for( i = '0' ; i <= '9' ; i++ )
+ aCharTypeTab[i] |= nHelpMask;
+
+ // e und E sowie . von Hand ergaenzen
+ aCharTypeTab['e'] |= CHAR_IN_NUMBER;
+ aCharTypeTab['E'] |= CHAR_IN_NUMBER;
+ aCharTypeTab['.'] |= (USHORT)( CHAR_IN_NUMBER | CHAR_START_NUMBER );
+
+ // Hex-Ziffern
+ for( i = 'a' ; i <= 'f' ; i++ )
+ aCharTypeTab[i] |= CHAR_IN_HEX_NUMBER;
+ for( i = 'A' ; i <= 'F' ; i++ )
+ aCharTypeTab[i] |= CHAR_IN_HEX_NUMBER;
+
+ // Oct-Ziffern
+ for( i = '0' ; i <= '7' ; i++ )
+ aCharTypeTab[i] |= CHAR_IN_OCT_NUMBER;
+
+ // String-Beginn/End-Zeichen
+ aCharTypeTab['\''] |= CHAR_START_STRING;
+ aCharTypeTab['\"'] |= CHAR_START_STRING;
+
+ // Operator-Zeichen
+ aCharTypeTab['!'] |= CHAR_OPERATOR;
+ aCharTypeTab['%'] |= CHAR_OPERATOR;
+ aCharTypeTab['&'] |= CHAR_OPERATOR;
+ aCharTypeTab['('] |= CHAR_OPERATOR;
+ aCharTypeTab[')'] |= CHAR_OPERATOR;
+ aCharTypeTab['*'] |= CHAR_OPERATOR;
+ aCharTypeTab['+'] |= CHAR_OPERATOR;
+ aCharTypeTab[','] |= CHAR_OPERATOR;
+ aCharTypeTab['-'] |= CHAR_OPERATOR;
+ aCharTypeTab['/'] |= CHAR_OPERATOR;
+ aCharTypeTab[':'] |= CHAR_OPERATOR;
+ aCharTypeTab['<'] |= CHAR_OPERATOR;
+ aCharTypeTab['='] |= CHAR_OPERATOR;
+ aCharTypeTab['>'] |= CHAR_OPERATOR;
+ aCharTypeTab['?'] |= CHAR_OPERATOR;
+ aCharTypeTab['^'] |= CHAR_OPERATOR;
+ aCharTypeTab['|'] |= CHAR_OPERATOR;
+ aCharTypeTab['~'] |= CHAR_OPERATOR;
+ aCharTypeTab['{'] |= CHAR_OPERATOR;
+ aCharTypeTab['}'] |= CHAR_OPERATOR;
+ aCharTypeTab['['] |= CHAR_OPERATOR;
+ aCharTypeTab[']'] |= CHAR_OPERATOR;
+ aCharTypeTab[';'] |= CHAR_OPERATOR;
+
+ // Space
+ aCharTypeTab[' ' ] |= CHAR_SPACE;
+ aCharTypeTab['\t'] |= CHAR_SPACE;
+
+ // Zeilen-Ende-Zeichen
+ aCharTypeTab['\r'] |= CHAR_EOL;
+ aCharTypeTab['\n'] |= CHAR_EOL;
+
+ // fuer Syntax Highlighting
+ pCommentsBegin = new NAMESPACE_STD(list)<BOOL>();
+ pCommentsEnd = new NAMESPACE_STD(list)<BOOL>();
+
+ bStarScriptMode = FALSE;
+ ppListKeyWords = NULL;
+}
+
+SimpleTokenizer_Impl::~SimpleTokenizer_Impl( void )
+{
+ delete(pCommentsBegin);
+ delete(pCommentsEnd);
+}
+
+SimpleTokenizer_Impl* getSimpleTokenizer( void )
+{
+ static SimpleTokenizer_Impl* pSimpleTokenizer = NULL;
+ if( !pSimpleTokenizer )
+ pSimpleTokenizer = new SimpleTokenizer_Impl();
+ return pSimpleTokenizer;
+}
+
+// Heraussuchen der jeweils naechsten Funktion aus einem JavaScript-Modul
+UINT16 SimpleTokenizer_Impl::parseLine( UINT32 nParseLine, const String* aSource )
+{
+ ByteString aByteSource( *aSource, gsl_getSystemTextEncoding() );
+
+ // Position auf den Anfang des Source-Strings setzen
+ mpStringBegin = mpActualPos = aByteSource.GetBuffer();
+ bLineHasCommentBegin = isBeginComment( nParseLine );
+ bLineHasCommentEnd = FALSE;
+
+ // Zeile und Spalte initialisieren
+ nLine = nParseLine;
+ nCol = 0L;
+
+ // Variablen fuer die Out-Parameter
+ TokenTypes eType;
+ const char* pStartPos;
+ const char* pEndPos;
+
+ // Schleife ueber alle Tokens
+ UINT16 nTokenCount = 0;
+ while( getNextToken( eType, pStartPos, pEndPos ) )
+ nTokenCount++;
+
+ // die Endzustaende der Zeilen in die Listen eintragen
+ setCommentState(nParseLine, bLineHasCommentBegin, bLineHasCommentEnd);
+
+ return nTokenCount;
+}
+
+void SimpleTokenizer_Impl::getHighlightPortions( UINT32 nParseLine, const String& rLine,
+ /*out*/HighlightPortions& portions )
+{
+ ByteString aByteLine( rLine, gsl_getSystemTextEncoding() );
+
+ // Position auf den Anfang des Source-Strings setzen
+ mpStringBegin = mpActualPos = aByteLine.GetBuffer();
+ bLineHasCommentBegin = isBeginComment( nParseLine );
+ bLineHasCommentEnd = FALSE;
+
+ // Zeile und Spalte initialisieren
+ nLine = nParseLine;
+ nCol = 0L;
+
+ // Variablen fuer die Out-Parameter
+ TokenTypes eType;
+ const char* pStartPos;
+ const char* pEndPos;
+
+ // Schleife ueber alle Tokens
+ while( getNextToken( eType, pStartPos, pEndPos ) )
+ {
+ HighlightPortion portion;
+
+ portion.nBegin = (UINT16)(pStartPos - mpStringBegin);
+ portion.nEnd = (UINT16)(pEndPos - mpStringBegin);
+ portion.tokenType = eType;
+
+ portions.Insert(portion, portions.Count());
+ }
+}
+
+BOOL SimpleTokenizer_Impl::isBeginComment( UINT32 nLine )
+{
+ NAMESPACE_STD(list)<BOOL>::const_iterator posBegin, posEnd;
+ BOOL bCommentStart = FALSE;
+
+ UINT32 i = 0;
+ posBegin=pCommentsBegin->begin();
+ posEnd=pCommentsEnd->begin();
+
+ while ((i < nLine) && (posBegin != pCommentsBegin->end()) && (posEnd != pCommentsEnd->end()))
+ {
+ if (bCommentStart && *posEnd)
+ bCommentStart = FALSE;
+ if ((!bCommentStart) && *posBegin)
+ bCommentStart = TRUE;
+
+ posBegin++;
+ posEnd++;
+ i++;
+ }
+
+ return bCommentStart;
+}
+
+void SimpleTokenizer_Impl::outCommentList()
+{
+ NAMESPACE_STD(list)<BOOL>::const_iterator posBegin, posEnd;
+ BOOL bCommentStart = FALSE;
+
+ UINT32 i = 0;
+ posBegin=pCommentsBegin->begin();
+ posEnd=pCommentsEnd->begin();
+
+ printf("\nComments:\n");
+ while (posBegin != pCommentsBegin->end())
+ {
+ printf("line: %2d beginComment: %d endComment: %d\n", i, *posBegin, *posEnd);
+
+ posBegin++;
+ posEnd++;
+ i++;
+ }
+
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Implementierung des SyntaxHighlighter
+
+SyntaxHighlighter::SyntaxHighlighter()
+{
+ m_pSimpleTokenizer = new SimpleTokenizer_Impl();
+ m_pKeyWords = NULL;
+ m_nKeyWordCount = 0;
+}
+
+SyntaxHighlighter::~SyntaxHighlighter()
+{
+ delete(m_pSimpleTokenizer);
+ delete(m_pKeyWords);
+}
+
+void SyntaxHighlighter::initialize( HighlighterLanguage eLanguage_ )
+{
+ eLanguage = eLanguage_;
+ delete(m_pSimpleTokenizer);
+ m_pSimpleTokenizer = new SimpleTokenizer_Impl();
+
+ if (eLanguage == HIGHLIGHT_BASIC)
+ {
+ m_pSimpleTokenizer->setKeyWords( strListBasicKeyWords,
+ sizeof( strListBasicKeyWords ) / sizeof( char* ));
+ }
+ else
+ {
+ m_pSimpleTokenizer->setKeyWords( NULL, 0 );
+ }
+}
+
+const Range SyntaxHighlighter::notifyChange( UINT32 nLine, INT32 nLineCountDifference,
+ const String* pChangedLines, UINT32 nArrayLength)
+{
+ if (nLineCountDifference != 0)
+ m_pSimpleTokenizer->addLines(nLine, nLineCountDifference);
+
+ for (INT32 i=0; i<nArrayLength; i++)
+ m_pSimpleTokenizer->parseLine(nLine+i, &pChangedLines[i]);
+
+ return Range(nLine, nLine+nArrayLength-1);
+}
+
+void SyntaxHighlighter::getHighlightPortions( UINT32 nLine, const String& rLine,
+ /*out*/HighlightPortions& portions )
+{
+ m_pSimpleTokenizer->getHighlightPortions( nLine, rLine, portions );
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// Implementation SbJScriptModule (Basic-Modul fuer JavaScript-Sourcen)
+SbJScriptModule::SbJScriptModule( const String& rName )
+ :SbModule( rName )
+{
+}
+
+BOOL SbJScriptModule::LoadData( SvStream& rStrm, USHORT nVer )
+{
+ Clear();
+ if( !SbxObject::LoadData( rStrm, 1 ) )
+ return FALSE;
+
+ // Source-String holen
+ rStrm.ReadByteString( aSource, gsl_getSystemTextEncoding() );
+ //rStrm >> aSource;
+ return TRUE;
+}
+
+BOOL SbJScriptModule::StoreData( SvStream& rStrm ) const
+{
+ if( !SbxObject::StoreData( rStrm ) )
+ return FALSE;
+
+ // Source-String schreiben
+ rStrm.WriteByteString( aSource, gsl_getSystemTextEncoding() );
+ //rStrm << aSource;
+ return TRUE;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+
+SbMethod::SbMethod( const String& r, SbxDataType t, SbModule* p )
+ : SbxMethod( r, t ), pMod( p )
+{
+ bInvalid = TRUE;
+ nStart =
+ nDebugFlags =
+ nLine1 =
+ nLine2 = 0;
+ // AB: 2.7.1996: HACK wegen 'Referenz kann nicht gesichert werden'
+ SetFlag( SBX_NO_MODIFY );
+}
+
+SbMethod::~SbMethod()
+{}
+
+SbxArray* SbMethod::GetLocals()
+{
+ if( pINST )
+ return pINST->GetLocals( this );
+ else
+ return NULL;
+}
+
+SbxArray* SbMethod::GetStatics()
+{
+ DBG_ERROR( "SbMethod::GetStatics() invalid, AB fragen" )
+ return NULL;
+}
+
+BOOL SbMethod::LoadData( SvStream& rStrm, USHORT nVer )
+{
+ if( !SbxMethod::LoadData( rStrm, 1 ) )
+ return FALSE;
+ INT16 n;
+ rStrm >> n;
+ // nDebugFlags = n; // AB 16.1.96: Nicht mehr uebernehmen
+ if( nVer == 2 )
+ rStrm >> nLine1 >> nLine2 >> nStart >> bInvalid;
+ // AB: 2.7.1996: HACK wegen 'Referenz kann nicht gesichert werden'
+ SetFlag( SBX_NO_MODIFY );
+ return TRUE;
+}
+
+BOOL SbMethod::StoreData( SvStream& rStrm ) const
+{
+ if( !SbxMethod::StoreData( rStrm ) )
+ return FALSE;
+ rStrm << (INT16) nDebugFlags
+ << (INT16) nLine1
+ << (INT16) nLine2
+ << (INT16) nStart
+ << (BYTE) bInvalid;
+ return TRUE;
+}
+
+void SbMethod::GetLineRange( USHORT& l1, USHORT& l2 )
+{
+ l1 = nLine1; l2 = nLine2;
+}
+
+// Kann spaeter mal weg
+
+SbxInfo* SbMethod::GetInfo()
+{
+ return pInfo;
+}
+
+// Schnittstelle zum Ausfuehren einer Methode aus den Applikationen
+// #34191# Mit speziellem RefCounting, damit das Basic nicht durch CloseDocument()
+// abgeschossen werden kann. Rueckgabewert wird als String geliefert.
+ErrCode SbMethod::Call( SbxValue* pRet )
+{
+ // RefCount vom Modul hochzaehlen
+ SbModule* pMod = (SbModule*)GetParent();
+ pMod->AddRef();
+
+ // RefCount vom Basic hochzaehlen
+ StarBASIC* pBasic = (StarBASIC*)pMod->GetParent();
+ pBasic->AddRef();
+
+ // Values anlegen, um Return-Wert zu erhalten
+ SbxValues aVals;
+ aVals.eType = SbxVARIANT;
+ Get( aVals );
+ if ( pRet )
+ pRet->Put( aVals );
+
+ // Gab es einen Error
+ ErrCode nErr = SbxBase::GetError();
+ SbxBase::ResetError();
+
+ // Objekte freigeben
+ pMod->ReleaseRef();
+ pBasic->ReleaseRef();
+
+ return nErr;
+}
+
+/////////////////////////////////////////////////////////////////////////
+
+// Implementation SbJScriptMethod (Method-Klasse als Wrapper fuer JavaScript-Funktionen)
+
+SbJScriptMethod::SbJScriptMethod( const String& r, SbxDataType t, SbModule* p )
+ : SbMethod( r, t, p )
+{
+}
+
+SbJScriptMethod::~SbJScriptMethod()
+{}
+
+
+/////////////////////////////////////////////////////////////////////////
+
+SbProperty::SbProperty( const String& r, SbxDataType t, SbModule* p )
+ : SbxProperty( r, t ), pMod( p )
+{
+ bInvalid = FALSE;
+}
+
+SbProperty::~SbProperty()
+{}
+
+
generated by cgit (git 2.34.1) at 2025-02-06 16:46:51 +0000