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
commitcb1a7c1869062c789c65bc55285e6b18fcf378e0 (patch)
treea084b702d7cce826b3b68cb69be833eeedd6bedb /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 0000000000..ebe3c0dc04
--- /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 für BYVAL enthalten (StepARGTYP)
+ if( nOp1 & 0x8000 )
+ {
+ nOp1 &= 0x7FFF; // Flag wegfiltern
+ rText.AppendAscii( "BYVAL " );
+ }
+ if( nOp1 < 13 )
+ {
+#ifndef HP9000
+ static char* pTypes[13] = {
+ "Empty","Null","Integer","Long","Single","Double",
+ "Currency","Date","String","Object","Error","Boolean",
+ "Variant" };
+#endif
+ rText.AppendAscii( pTypes[ nOp1 ] );
+ }
+ else
+ {
+ rText.AppendAscii( "type " );
+ rText += 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 0000000000..d401d7669e
--- /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 0000000000..da2218d70b
--- /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 0000000000..d00772d542
--- /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 0000000000..dd6d387ec2
--- /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 0000000000..ba78c4a83d
--- /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 ] = "B³¹d sk³adni";
+ Text[ japanese ] = "¼ÝÀ¯¸½ ´×°";
+ Text[ chinese_traditional ] = "»yªk¿ù»~";
+ Text[ arabic ] = "ÎØà Ýí ÈäÇÁ ÇáÌãáÉ";
+ Text[ dutch ] = "Fout in syntaxis";
+ Text[ chinese_simplified ] = "Óï·¨´íÎó";
+ Text[ greek ] = "ÓöÜëìá óýíôáîçò";
+ Text[ korean ] = "½ÅÅؽº ¿¡·¯";
+ Text[ turkish ] = "Sözdizim 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 ] = "Powrót 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. Inténtelo otra vez" ;
+ Text [ danish ] = "Forkert input, gentag venligst" ;
+ Text [ swedish ] = "Felaktig inmatning, var vänlig 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 ] = "¿é¤JµL®Ä¡M½Ð­«½Æ¡C";
+ Text[ arabic ] = "ÅÏÎÇá ÎÇØÆ ºÇáÑÌÇÁ ÅÚÇÏÉ ÇáãÍÇæáÉ";
+ Text[ dutch ] = "Incorrecte gegevens, herhalen a.u.b.";
+ Text[ chinese_simplified ] = "ÊäÈëÎÞЧ£¬ÇëÖظ´¡£";
+ Text[ greek ] = "ËáíèáóìÝíç åéóáãùãÞ, ðáñáêáëþ îáíáðñïóðáèÞóôå";
+ Text[ korean ] = "µî·ÏÀÌ À߸øµÇ¾ú½À´Ï´Ù. ´Ù½Ã µî·ÏÇØ ÁֽʽÿÀ.";
+ Text[ turkish ] = "Giriþ yanlýþ, lütfen yeniden girin";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_ARGUMENT & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ung³ltiger Prozeduraufruf : Ungltiger Prozeduraufruf */
+ Text = "Ungültiger 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 não válida" ;
+ Text [ french ] = "Appel de procédure incorrect" ;
+ Text [ dutch ] = "Ongeldige oproep van procedure" ;
+ Text [ spanish ] = "Inicio del proceso no válido" ;
+ 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 ] = "Nieprawid³owa procedura wywo³ania";
+ 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 ] = "Geçersiz yordam çaðrýsý";
+ 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 ] = "Débordement" ;
+ Text [ dutch ] = "Overflow" ;
+ Text [ spanish ] = "Desbordamiento" ;
+ Text [ danish ] = "Overløb" ;
+ Text [ swedish ] = "Spill" ;
+ Text [ finnish ] = "Overflow" ;
+ Text [ english_us ] = "Overflow" ;
+ Text[ chinese_simplified ] = "ÒçÖµ";
+ Text[ russian ] = "Ïåðåïîëíåíèå";
+ Text[ polish ] = "Przepe³nienie";
+ Text[ japanese ] = "µ°ÊÞ°ÌÛ°";
+ Text[ chinese_traditional ] = "·¸­È";
+ Text[ arabic ] = "ÝÇÆÖ";
+ Text[ dutch ] = "Overflow";
+ Text[ chinese_simplified ] = "ÒçÖµ";
+ Text[ greek ] = "Õðåñ÷åßëéóç";
+ Text[ korean ] = "³Ñħ";
+ Text[ turkish ] = "Taþma";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_MEMORY & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Nicht gen³gend Speicher : Nicht gengend Speicher */
+ Text = "Nicht genügend Speicher" ;
+ Text [ ENGLISH ] = "Out of memory" ;
+ Text [ norwegian ] = "Out of memory" ;
+ Text [ italian ] = "Memoria insufficiente" ;
+ Text [ portuguese_brazilian ] = "Out of memory" ;
+ Text [ portuguese ] = "Memória insuficiente" ;
+ Text [ french ] = "Mémoire insuffisante" ;
+ Text [ dutch ] = "Niet voldoende geheugen" ;
+ Text [ spanish ] = "No hay memoria suficiente" ;
+ Text [ danish ] = "Ikke tilstrækkelig hukommelse" ;
+ Text [ swedish ] = "Inte tillräckligt med minne" ;
+ Text [ finnish ] = "Out of memory" ;
+ Text [ english_us ] = "Not enough memory" ;
+ Text[ chinese_simplified ] = "ÄÚ´æ²»×ã";
+ Text[ russian ] = "Íåäîñòàòî÷íî ïàìÿòè";
+ Text[ polish ] = "Za ma³o pamiêci";
+ 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 deðil";
+ 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 déjà 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¿ zosta³a zwymiarowana";
+ Text[ japanese ] = "”z—ñ‚Í‚·‚Å‚ÉŽŸŒ³‰»‚³‚ê‚Ä‚¢‚Ü‚·";
+ Text[ chinese_traditional ] = "¦æ¦C¤w¸g³Q©w¤Ø«×";
+ Text[ arabic ] = "ÃÈÚÇÏ ÇáÕÝíÝ ãÚíäÉ ãÓÈÞÇð";
+ Text[ dutch ] = "Array reeds gedimensioneerd";
+ Text[ chinese_simplified ] = "Êý×éÒѾ­±»¶¨³ß¶È";
+ Text[ greek ] = "¸÷ïõí Þäç ïñéóôåß ïé äéáóôÜóåéò ôçò ìÞôñáò";
+ Text[ korean ] = "¹è¿­ÀÇ Â÷¿ø Å©±â°¡ ÀÌ¹Ì Á¤ÇØÁ® ÀÖÀ½";
+ Text[ turkish ] = "Dizi boyutlandýrýlmýþ durumda";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_OUT_OF_RANGE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Index au˜erhalb des definierten Bereichs : Index auÿerhalb des definierten Bereichs */
+ Text = "Index außerhalb 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 définie" ;
+ Text [ dutch ] = "Index buiten gedefinieerd bereik" ;
+ Text [ spanish ] = "El índice se encuentra fuera del área definida" ;
+ Text [ danish ] = "Indeks udenfor det definerede område" ;
+ Text [ swedish ] = "Index utanför definierat område" ;
+ 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 ] = "©w¸q½d³ò¤§¥~ªº¯Á¤Þ";
+ Text[ arabic ] = "íÞÚ ÇáÝåÑÓ ÎÇÑÌ ÇáäØÇÞ ÇáãÍÏÏ";
+ Text[ dutch ] = "Index buiten gedefinieerd bereik";
+ Text[ chinese_simplified ] = "¶¨Ò巶Χ֮ÍâµÄË÷Òý";
+ Text[ greek ] = "Äåßêôçò Ýîù áðü ôçí êáèïñéæüìåíç ðåñéï÷Þ.";
+ Text[ korean ] = "Á¤ÀÇµÈ ¹üÀ§·Î ºÎÅÍÀÇ À妽º";
+ Text[ turkish ] = "Dizin tanýmlanan aralýðýn dýþýnda";
+ 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 ] = "Definição dupla" ;
+ Text [ french ] = "Définition faisant double emploi" ;
+ Text [ dutch ] = "Definitie dubbel voorhanden" ;
+ Text [ spanish ] = "La definición existe dos veces" ;
+ Text [ danish ] = "Dobbelt foreliggende definition" ;
+ Text [ swedish ] = "Dubbelt förekommande 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 ] = "¦s¦bÂù­«©w¸q";
+ Text[ arabic ] = "ÊÚÑíÝ ãßÑÑ";
+ Text[ dutch ] = "Definitie dubbel voorhanden";
+ Text[ chinese_simplified ] = "´æÔÚË«Öض¨Òå";
+ Text[ greek ] = "Äéðëüò ïñéóìüò";
+ Text[ korean ] = "Áߺ¹ Á¤ÀÇ";
+ Text[ turkish ] = "Çift tanýmlama";
+ 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 zéro" ;
+ Text [ dutch ] = "Deling door nul" ;
+ Text [ spanish ] = "División 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 ] = "Sýfýra bölme";
+ 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 ] = "Variável não definida" ;
+ Text [ french ] = "Variable indéfinie" ;
+ 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 ] = "¨S¦³©w¸qÅܼÆ";
+ Text[ arabic ] = "ÇáãÊÛíÑÉ ÛíÑ ãÍÏÏÉ";
+ Text[ dutch ] = "Variabele niet gedefinieerd";
+ Text[ chinese_simplified ] = "ûÓж¨Òå±äÊý";
+ Text[ greek ] = "Äåí Ý÷åé ïñéóôåß ìåôáâëçôÞ";
+ Text[ korean ] = "Á¤ÀÇ µÇÁö¾ÊÀº º¯¼ö";
+ Text[ turkish ] = "Deðiþken tanýmlanmadý";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_CONVERSION & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Datentypen unvertrõglich : Datentypen unvertr§glich */
+ Text = "Datentypen unverträglich" ;
+ 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 incompatíveis" ;
+ Text [ french ] = "Types de données 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 arasýnda uyuþmazlýk";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_PARAMETER & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ung³ltiger Parameter : Ungltiger Parameter */
+ Text = "Ungültiger Parameter" ;
+ Text [ ENGLISH ] = "Bad parameter" ;
+ Text [ norwegian ] = "Bad parameter" ;
+ Text [ italian ] = "Parametro non valido" ;
+ Text [ portuguese_brazilian ] = "Bad parameter" ;
+ Text [ portuguese ] = "Parâmetro não válido" ;
+ Text [ french ] = "Paramètre incorrect" ;
+ Text [ dutch ] = "Ongeldige parameter" ;
+ Text [ spanish ] = "Parámetro no válido" ;
+ Text [ danish ] = "Ugyldig parameter" ;
+ Text [ swedish ] = "Ogiltig parameter" ;
+ Text [ finnish ] = "Bad parameter" ;
+ Text [ english_us ] = "Invalid parameter" ;
+ Text[ chinese_simplified ] = "ÎÞЧµÄÖú±äÊý";
+ Text[ russian ] = "Íåäåéñòâèòåëüíûé ïàðàìåòð";
+ Text[ polish ] = "Nieprawid³owy parametr";
+ Text[ japanese ] = "–³Œø‚ÈÊß×Ò°À";
+ Text[ chinese_traditional ] = "§UÅܼƵL®Ä";
+ Text[ arabic ] = "ãÚáãÉ ÛíÑ ÕÇáÍÉ";
+ Text[ dutch ] = "Ongeldige parameter";
+ Text[ chinese_simplified ] = "ÎÞЧµÄÖú±äÊý";
+ Text[ greek ] = "Ìç Ýãêõñç ðáñÜìåôñïò";
+ Text[ korean ] = "À߸øµÈ ÆÛ¶ó¹ÌÅÍ";
+ Text[ turkish ] = "Geçersiz 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 ] = "Användaren avslutade förloppet" ;
+ Text [ finnish ] = "User interrupt occurred" ;
+ Text [ english_us ] = "Process interrupted by user" ;
+ Text[ chinese_simplified ] = "ʹÓÃÕßÖжÏÔËËã¹ý³Ì¡£";
+ Text[ russian ] = "Ïðîöåññ ïðåðâàí ïîëüçîâàòåëåì";
+ Text[ polish ] = "Proces zosta³ przerwany przez u¿ytkownika";
+ Text[ japanese ] = "ˆ—‚ÍÕ°»Þ°‚É‚æ‚Á‚Ä’†’f‚³‚ê‚Ü‚µ‚½";
+ Text[ chinese_traditional ] = "¨Ï¥ÎªÌ¤¤Â_¹Bºâ¹Lµ{¡C";
+ Text[ arabic ] = "ÊãÊ ãÞÇØÚÉ ÇáÚãáíÉ ãä ÞÈá ÇáãÓÊÎÏã";
+ Text[ dutch ] = "Onderbreking door gebruiker";
+ Text[ chinese_simplified ] = "ʹÓÃÕßÖжÏÔËËã¹ý³Ì¡£";
+ Text[ greek ] = "Ç äéáäéêáóßá Ý÷åé äéáêïðåß áðü ôïí ÷ñÞóôç";
+ Text[ korean ] = "»ç¿ëÀÚ¿¡ÀÇÇÑ ÇÁ·Î¼¼½º ÀÎÅÍ·´Æ®";
+ Text[ turkish ] = "Süreç kullanýcý tarafýndan 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 ] = "Résumé 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 b³êdu";
+ 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 gen³gend Stapelspeicher : Nicht gengend Stapelspeicher */
+ Text = "Nicht genügend 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 ] = "Memória tampão insuficiente" ;
+ Text [ french ] = "Mémoire tampon insuffisante" ;
+ Text [ dutch ] = "Niet genoeg stack" ;
+ Text [ spanish ] = "Desbordamiento de pila" ;
+ Text [ danish ] = "Ikke nok stakhukommelse" ;
+ Text [ swedish ] = "Inte tillräckligt med stapelminne" ;
+ Text [ finnish ] = "Out of stack space" ;
+ Text [ english_us ] = "Not enough stack memory" ;
+ Text[ chinese_simplified ] = "ջʽÄÚ´æ²»×ã";
+ Text[ russian ] = "Íåäîñòàòî÷íî ïàìÿòè ìàãàçèííîãî òèïà";
+ Text[ polish ] = "Za ma³o pamiêci 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 ] = "Yýðýn bellek yeterli deðil";
+ 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 função ou subordinado não definidos" ;
+ Text [ french ] = "La sous-procédure ou procédure fonctionnelle n'est pas définie" ;
+ Text [ dutch ] = "Sub- of functieprocedure niet gedefinieerd" ;
+ Text [ spanish ] = "Procedimiento de función 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 podrzêdnej lub funkcyjnej";
+ Text[ japanese ] = "Sub‚Ü‚½‚ÍFunctionÌßÛ¼°¼Þ¬‚Í’è‹`‚³‚ê‚Ä‚¢‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "¨S¦³©w¸q¤À¹Lµ{©Î¨ç¼Æ¹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 iþlev yordamý tanýmlanmadý";
+ 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 indlæsning 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 ] = "B³¹d 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 dosyasýný yükleme sýrasýnda 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 ] = "Convenção da chamada DLL incorrecta" ;
+ Text [ french ] = "Convention d'appel DLL incorrecte" ;
+ Text [ dutch ] = "Foutieve DLL-oproepconventie" ;
+ Text [ spanish ] = "Convención 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 ] = "Nieprawid³owa konwencja wywo³ania 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 çaðrý 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 ] = "B³¹d wewnêtrzny $(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 número do ficheiro incorrecto" ;
+ Text [ french ] = "Nom ou numéro de fichier incorrect" ;
+ Text [ dutch ] = "Foutieve bestandsnaam of -nummer" ;
+ Text [ spanish ] = "Nombre o número 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 nieprawid³owe";
+ 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 não 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 filläge" ;
+ 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 ge÷ffnet : Datei bereits ge”ffnet */
+ Text = "Datei bereits geöffnet" ;
+ 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 déjà 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 ] = "¤w¸g¶}±ÒÀÉ®×";
+ Text[ arabic ] = "ÇáãáÝ ãÝÊæÍ ãÓÈÞÇð";
+ Text[ dutch ] = "Bestand reeds geopend";
+ Text[ chinese_simplified ] = "ÒѾ­´ò¿ªÎļþ";
+ Text[ greek ] = "Ôï áñ÷åßï åßíáé Þäç áíïé÷ôü";
+ Text[ korean ] = "ÆÄÀÏÀÌ ÀÌ¹Ì ¿­·ÁÀÖ½À´Ï´Ù.";
+ Text[ turkish ] = "Dosya açýk durumda";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_IO_ERROR & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Gerõte-E/A-Fehler : Ger§te-E/A-Fehler */
+ Text = "Geräte-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 periférico I/O" ;
+ Text [ french ] = "Erreur de périphérique 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 ] = "B³¹d We/Wy urz¹dzenia";
+ Text[ japanese ] = "ÃÞ¨ÊÞ²½ I/O ´×°";
+ Text[ chinese_traditional ] = "³]³Æµo¥ÍI/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 déjà" ;
+ 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 ] = "Àɮפw¸g¦s¦b";
+ 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 Datensatzlõnge : Falsche Datensatzl§nge */
+ Text = "Falsche Datensatzlänge" ;
+ 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 errónea del registro de datos" ;
+ Text [ danish ] = "Forkert datapostlængde" ;
+ Text [ swedish ] = "Felaktig datapostlängd" ;
+ Text [ finnish ] = "Bad record length" ;
+ Text [ english_us ] = "Incorrect record length" ;
+ Text[ chinese_simplified ] = "Êý¾ÝÌõÄ¿³¤¶È´íÎó";
+ Text[ russian ] = "Íåïðàâèëüíàÿ äëèíà çàïèñè äàííûõ";
+ Text[ polish ] = "Niepoprawna d³ugoœæ rekordów";
+ Text[ japanese ] = "³‚µ‚­‚È‚¢Úº°ÄÞ‚Ì’·‚³";
+ Text[ chinese_traditional ] = "¿ù»~ªº¸ê®Æ¶µ¥Øªø«×";
+ Text[ arabic ] = "Øæá ÓÌáÇÊ ÇáÈíÇäÇÊ ÛíÑ ÕÍíÍ";
+ Text[ dutch ] = "Foutieve record-lengte";
+ Text[ chinese_simplified ] = "Êý¾ÝÌõÄ¿³¤¶È´íÎó";
+ Text[ greek ] = "Ìç áðïäåêôü ìÞêïò åããñáöÞò";
+ Text[ korean ] = "À߸øµÈ µ¥ÀÌÅÍ ·¹ÄÚµå ±æÀÌ";
+ Text[ turkish ] = "Yanlýþ veri kümesi uzunluðu";
+ 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 rígido 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 hårddisk full" ;
+ Text [ finnish ] = "Disk full" ;
+ Text [ english_us ] = "Disk or hard drive full" ;
+ Text[ chinese_simplified ] = "ÈíÅÌ»òÓ²ÅÌÒÑÂú";
+ Text[ russian ] = "Äèñê èëè æåñòêèé äèñê çàïîëíåíû";
+ Text[ polish ] = "Dyskietka/Dysk twardy s¹ pe³ne";
+ Text[ japanese ] = "ÌÛ¯Ëß°ÃÞ¨½¸‚Ü‚½‚ÍÊ°ÄÞÃÞ¨½¸‚ª‚¢‚Á‚Ï‚¢";
+ Text[ chinese_traditional ] = "³nºÏ½L©ÎºÏ½L¤wº¡";
+ 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 além 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 ] = "Læs ud over filens slutning" ;
+ Text [ swedish ] = "Läsning utöver 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 ] = "Ū¨ú¶W¥XÀÉ®×½d³ò";
+ Text[ arabic ] = "ÇáÞÑÇÁÉ ÍÊì äåÇíÉ ÇáãáÝ æãÇ ÈÚÏåÇ";
+ Text[ dutch ] = "Lezen overschrijdt bestandseinde";
+ Text[ chinese_simplified ] = "¶ÁÈ¡³¬³öÎļþ·¶Î§";
+ Text[ greek ] = "ÁíÜãíùóç ðÝñá áðü ôï ôÝëïò ôïõ áñ÷åßïõ";
+ Text[ korean ] = "ÆÄÀÏÀÇ ³¡À» ÃÊ°úÇÏ¿© ÀÐÀ½";
+ Text[ turkish ] = "Okuma dosya sonunu aþýyor";
+ 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 ] = "Número do registo de dados incorrecto" ;
+ Text [ french ] = "Numéro d'enregistrement incorrect" ;
+ Text [ dutch ] = "Foutief record-nummer" ;
+ Text [ spanish ] = "Número erróneo 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 d³ugoœæ rekordów";
+ Text[ japanese ] = "Úº°Äނ̔Ԇ‚ª³‚µ‚­‚ ‚è‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "¸ê®Æ¶µ¥Ø¸¹½X¿ù»~";
+ Text[ arabic ] = "ÑÞã ÓÌáÇÊ ÇáÈíÇäÇÊ ÛíÑ ÕÍíÍ";
+ Text[ dutch ] = "Foutief record-nummer";
+ Text[ chinese_simplified ] = "Êý¾ÝÌõÄ¿ºÅÂë´íÎó";
+ Text[ greek ] = "ËáíèáóìÝíïò áñéèìüò åããñáöÞò";
+ Text[ korean ] = "À߸øµÈ µ¥ÀÌÅÍ ·¹ÄÚµå ¹øÈ£";
+ Text[ turkish ] = "Veri kümesi 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 ] = "För många filer" ;
+ Text [ finnish ] = "Too many files" ;
+ Text [ english_us ] = "Too many files" ;
+ Text[ chinese_simplified ] = "Ì«¶àÎļþ";
+ Text[ russian ] = "Ñëèøêîì ìíîãî ôàéëîâ";
+ Text[ polish ] = "Za du¿o plików";
+ Text[ japanese ] = "̧²Ù‚ª‘½‚·‚¬‚Ü‚·";
+ Text[ chinese_traditional ] = "¤Ó¦hÀÉ®×";
+ Text[ arabic ] = "ãáÝÇÊ ßËíÑÉ ÌÏÇð";
+ Text[ dutch ] = "Teveel bestanden";
+ Text[ chinese_simplified ] = "Ì«¶àÎļþ";
+ Text[ greek ] = "ÐÜñá ðïëëÜ áñ÷åßá";
+ Text[ korean ] = "ÆÄÀϵéÀÌ ³Ê¹« ¸¹À½";
+ Text[ turkish ] = "Dosya sayýsý fazla";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_DEVICE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Gerõt nicht verf³gbar : Ger§t nicht verfgbar */
+ Text = "Gerät nicht verfügbar" ;
+ Text [ ENGLISH ] = "Device not available" ;
+ Text [ norwegian ] = "Device not available" ;
+ Text [ italian ] = "Apparecchio non disponibile" ;
+ Text [ portuguese_brazilian ] = "Device not available" ;
+ Text [ portuguese ] = "Aparelho não disponível" ;
+ Text [ french ] = "Périphérique indisponible" ;
+ Text [ dutch ] = "Apparatuur niet beschikbaar" ;
+ Text [ spanish ] = "El dispositivo no está disponible" ;
+ Text [ danish ] = "Enheden er ikke tilgængelig" ;
+ Text [ swedish ] = "Enhet ej tillgänglig" ;
+ Text [ finnish ] = "Device not available" ;
+ Text [ english_us ] = "Device not available" ;
+ Text[ chinese_simplified ] = "É豸²»´æÔÚ";
+ Text[ russian ] = "Óñòðîéñòâî íåäîñòóïíî";
+ Text[ polish ] = "Urz¹dzenie niedostêpne";
+ Text[ japanese ] = "ÃÞ¨ÊÞ²½‚Í‚ ‚è‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "³]³Æ¤£¦s¦b";
+ Text[ arabic ] = "ÇáÌåÇÒ ÛíÑ ãÊÇÍ";
+ Text[ dutch ] = "Apparatuur niet beschikbaar";
+ Text[ chinese_simplified ] = "É豸²»´æÔÚ";
+ Text[ greek ] = "Ç óõóêåõÞ äåí åßíáé äéáèÝóéìç";
+ Text[ korean ] = "µð¹ÙÀ̽º »ç¿ëÀÌ ºÒ°¡´É";
+ Text[ turkish ] = "Cihaz kullanýlabilir durumda deðil";
+ 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 ] = "Accès refusé" ;
+ Text [ dutch ] = "Toegang geweigerd" ;
+ Text [ spanish ] = "Acceso denegado" ;
+ Text [ danish ] = "Adgang nægtet" ;
+ Text [ swedish ] = "Åtkomst nekad" ;
+ Text [ finnish ] = "Permission denied" ;
+ Text [ english_us ] = "Access denied" ;
+ Text[ chinese_simplified ] = "¾Ü¾ø¶ÁÈ¡";
+ Text[ russian ] = "Äîñòóï çàïðåùåí";
+ Text[ polish ] = "Dostêp zabroniony";
+ Text[ japanese ] = "±¸¾½‚Å‚«‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "©Úµ´Åª¨ú";
+ Text[ arabic ] = "áã íÓãÍ ÈÇáæÕæá";
+ Text[ dutch ] = "Toegang geweigerd";
+ Text[ chinese_simplified ] = "¾Ü¾ø¶ÁÈ¡";
+ Text[ greek ] = "Äåí åðéôñÝðåôáé ç ðñüóâáóç";
+ Text[ korean ] = "Á¢±Ù °ÅºÎ";
+ Text[ turkish ] = "Eriþim 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 não está pronta" ;
+ Text [ french ] = "La disquette n'est pas prête" ;
+ 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ÁÙ¨S¦³·Ç³Æ¦n";
+ Text[ arabic ] = "ÇáÞÑÕ ÛíÑ ÌÇåÒ";
+ Text[ dutch ] = "Diskette niet bereid";
+ Text[ chinese_simplified ] = "ÈíÅÌ»¹Ã»ÓÐ×¼±¸ºÃ";
+ Text[ greek ] = "Ç äéóêÝôá äåí åßíáé Ýôïéìç";
+ Text[ korean ] = "µð½ºÅ©°¡ ÁغñµÇÁö ¾Ê¾Ò½À´Ï´Ù.";
+ Text[ turkish ] = "Disket hazýr deðil";
+ 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 ] = "Não implementado" ;
+ Text [ french ] = "Non implanté" ;
+ Text [ dutch ] = "Niet geïmplementeerd" ;
+ 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 geïmplementeerd";
+ 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 m÷glich : Umbenennen auf verschiedenen Laufwerken nicht m”glich */
+ Text = "Umbenennen auf verschiedenen Laufwerken nicht möglich" ;
+ 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 ] = "Impossível mudar nome em várias unidades" ;
+ Text [ french ] = "Impossible de renommer sur des lecteurs différents" ;
+ Text [ dutch ] = "Namen wijzigen op verschillende stations niet mogelijk" ;
+ Text [ spanish ] = "No se puede cambiar nombre en distintas unidades" ;
+ Text [ danish ] = "Omdøbning på forskellige drev er ikke mulig" ;
+ Text [ swedish ] = "Omöjligt 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 ró¿nych dyskach jest niemo¿liwa";
+ Text[ japanese ] = "•¡”ÄÞײÌÞ‚Ì–¼‘O‚Ì•ÏX‚Í‚Å‚«‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "µLªk­«·s©R¦W¦¨¤£¦PªººÏ½L";
+ Text[ arabic ] = "ÅÚÇÏÉ ÇáÊÓãíÉ Úáì ãÍÑßÇÊ ÃÞÑÇÕ ãÎÊáÝÉ ÛíÑ ããßä";
+ Text[ dutch ] = "Namen wijzigen op verschillende stations niet mogelijk";
+ Text[ chinese_simplified ] = "ÎÞ·¨ÖØÃüÃû³É²»Í¬µÄÇý¶¯ÅÌ";
+ Text[ greek ] = "Äåí åßíáé äõíáôÞ ç ìåôïíïìáóßá óå äéáöïñåôéêïýò äßóêïõò";
+ Text[ korean ] = "´Ù¸¥ µå¶óÀ̹ö»óÀÇ »õ·Î¿î À̸§Àº ºÒ°¡´ÉÇÕ´Ï´Ù.";
+ Text[ turkish ] = "Farklý sürücülerde yeniden adlandýrma yapýlamaz";
+ 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'accès 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 ] = "Sökväg/fil åtkomstfel" ;
+ Text [ finnish ] = "Path/File access error" ;
+ Text [ english_us ] = "Path/File access error" ;
+ Text[ chinese_simplified ] = "¶Áȡ·¾¶/Îļþʱ·¢Éú´íÎó";
+ Text[ russian ] = "Îøèáêà äîñòóïà ïóòè èëè ôàéëà";
+ Text[ polish ] = "B³¹d dostêpu do œcie¿ki/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/eriþim 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 não 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 ] = "Sökvägen hittades inte" ;
+ Text [ finnish ] = "Path not found" ;
+ Text [ english_us ] = "Path not found" ;
+ Text[ chinese_simplified ] = "ûÓÐÕÒµ½Â·¾¶";
+ Text[ russian ] = "Ïóòü íå íàéäåí";
+ Text[ polish ] = "Œcie¿ka nie zosta³a 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 ] = "Variável do objecto não configurada" ;
+ Text [ french ] = "Variable d'objet non configurée" ;
+ 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 bestämda" ;
+ 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 deðiþkeni belirlenmedi";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_PATTERN & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Zeichenfolgenmuster unzulõssig : Zeichenfolgenmuster unzul§ssig */
+ Text = "Zeichenfolgenmuster unzulässig" ;
+ 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 ] = "Sequência de caracteres não válida" ;
+ Text [ french ] = "Échantillon de chaîne de caractères incorrect" ;
+ Text [ dutch ] = "Ontoelaatbare tekenreeks" ;
+ Text [ spanish ] = "Secuencia de caracteres no válida" ;
+ Text [ danish ] = "Ugyldigt strengmønster" ;
+ Text [ swedish ] = "Ogiltig mönsterstring" ;
+ Text [ finnish ] = "Invalid pattern string" ;
+ Text [ english_us ] = "Invalid string pattern" ;
+ Text[ chinese_simplified ] = "ÎÞЧµÄ×Ö´®Ä£Ê½";
+ Text[ russian ] = "Íåäîïóñòèìûé îáðàçåö ïîñëåäîâàòåëüíîñòè çíàêîâ";
+ Text[ polish ] = "Nieprawid³owy ci¹g wzoru";
+ Text[ japanese ] = "•¶Žš—ñÊßÀ°Ý‚Í‹–‰Â‚³‚ê‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "µL®Äªº¦r¦ê¼Ò¦¡";
+ Text[ arabic ] = "äãæÐÌ ÊÊÇÈÚ ÇáÃÍÑÝ ÛíÑ ãÓãæÍ Èå";
+ Text[ dutch ] = "Ontoelaatbare tekenreeks";
+ Text[ chinese_simplified ] = "ÎÞЧµÄ×Ö´®Ä£Ê½";
+ Text[ greek ] = "ÅóöáëìÝíç óõìâïëïóåéñÜ ìïôßâïõ";
+ Text[ korean ] = "À¯È¿ÇÏÁö¾ÊÀº ¹®ÀÚ¿­ À¯Çü";
+ Text[ turkish ] = "Dizilim örneði geçerli deðil";
+ Text[ language_user1 ] = " ";
+ };
+ String SBERR_IS_NULL & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Verwendung von Null unzulõssig : Verwendung von Null unzul§ssig */
+ Text = "Verwendung von Null unzulässig" ;
+ 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 zéro 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 ] = "Användning av noll är ej tillåtet" ;
+ Text [ finnish ] = "Invalid use of Null" ;
+ Text [ english_us ] = "Use of zero not permitted" ;
+ Text[ chinese_simplified ] = "²»ÔÊÐíʹÓÃÓÃÁãÖµ";
+ Text[ russian ] = "Èñïîëüçîâàíèå íóëÿ íåäîïóñòèìî";
+ Text[ polish ] = "U¿ywanie zera niedopuszczalne";
+ Text[ japanese ] = "¾ÞÛ‚ÌŽg—p‚Í‹–‰Â‚³‚ê‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "¤£¤¹³\\½Õ¥Î¹s­È";
+ Text[ arabic ] = "ÛíÑ ãÓãæÍ ÈÇÓÊÎÏÇã ÇáÕÝÑ";
+ Text[ dutch ] = "Ongeldig gebruik van nul";
+ Text[ chinese_simplified ] = "²»ÔÊÐíʹÓÃÓÃÁãÖµ";
+ Text[ greek ] = "Äåí åðéôñÝðåôáé ç ÷ñÞóç ôïõ ìçäåíüò";
+ Text[ korean ] = "0ÀÇ »ç¿ëÀÌ Çã¿ëµÇÁö ¾Ê¾Ò½À´Ï´Ù.";
+ Text[ turkish ] = "Sýfýr kullanýmý geçerli deðil";
+ 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 ] = "B³¹d 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 à ligação DDE" ;
+ Text [ french ] = "Attente de réponse dans une connexion DDE" ;
+ Text [ dutch ] = "Wachten op antwoord in DDE-verbinding" ;
+ Text [ spanish ] = "Esperando respuesta en la conexión DDE" ;
+ Text [ danish ] = "Venter på svar til DDE-forbindelsen" ;
+ Text [ swedish ] = "Väntar på svar till DDE-förbindelsen" ;
+ 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 po³¹czeniu 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 baðlantýsýnda yanýt bekleniyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_OUTOFCHANNELS & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Keine freien DDE-Kanõle : Keine freien DDE-Kan§le */
+ Text = "Keine freien DDE-Kanäle" ;
+ 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 kana³ów DDE";
+ Text[ japanese ] = "Žg‚¦‚éDDEÁ¬ÝÈÙ‚ª‚ ‚è‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "¨S¦³¶}©ñ DDE-«H¹D";
+ 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 ligação DDE não obteve resposta de nenhuma aplicação" ;
+ Text [ french ] = "Aucune application ne réagit à la tentative de connexion DDE" ;
+ Text [ dutch ] = "Geen enkele applicatie antwoordt op DDE-verbindingsoproep" ;
+ Text [ spanish ] = "No responde ninguna aplicación a la conexión DDE deseada" ;
+ Text [ danish ] = "Ingen applikation svarer på DDE-forbindelsesinitialiseringen" ;
+ Text [ swedish ] = "Ingen applikation svarar på DDE-förbindelsinitieringen" ;
+ 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 du¿o aplikacji odpowiada na inicjacjê po³¹czenia 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 ] = "Hiçbir uygulama DDE baðlantý talebine yanýt 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 aplicações respondem à tentativa de ligação DDE" ;
+ Text [ french ] = "Trop d'applications répondent à la tentative de connexion DDE" ;
+ Text [ dutch ] = "Teveel applicatiex antwoorden op de DDE-verbindingsoproep" ;
+ Text [ spanish ] = "Demasiadas aplicaciones responden a la conexión deseada DDE" ;
+ Text [ danish ] = "For mange applikationer svarer på DDE-forbindelsesinitialiseringen" ;
+ Text [ swedish ] = "Alltför många applikationer svarar på DDE-förbindelseinitieringen" ;
+ 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 du¿o aplikacji odpowiada na inicjacjê po³¹czenia 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 baðlantý talebine çok fazla uygulama yanýt 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 låst" ;
+ Text [ swedish ] = "DDE-kanalen är spärrad" ;
+ 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 «H¹D¤w¸g³QÂê©w";
+ 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 ausf³hren : Fremdapplikation kann DDE-Operation nicht ausfhren */
+ Text = "Fremdapplikation kann DDE-Operation nicht ausführen" ;
+ 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 aplicação externa não pode executar a operação DDE" ;
+ Text [ french ] = "L'application externe ne peut pas exécuter l'opération DDE" ;
+ Text [ dutch ] = "Externe applicatie kan DDE niet uitvoeren" ;
+ Text [ spanish ] = "Una aplicación externa no puede realizar la operación DDE" ;
+ Text [ danish ] = "Den eksterne applikation kan ikke udføre DDE-operationen" ;
+ Text [ swedish ] = "Den externa applikationen kan inte utföra 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 mo¿e wykonaæ operacjiDDE";
+ Text[ japanese ] = "ŠO•”±Ìßع°¼®Ý‚ÍDDE‚̵ÍßÚ°¼®Ý‚ðŽÀs‚Å‚«‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "¥~³¡ªºÀ³¥Îµ{§ÇµLªk°õ¦æ 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 iþlemini yürütemiyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_TIMEOUT & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Zeit³berschreitung wõhrend des Wartens auf DDE-Antwort : Zeitberschreitung w§hrend des Wartens auf DDE-Antwort */
+ Text = "Zeitüberschreitung während 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 réponse 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 gått ut vid väntandet 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 ] = "DDE‚̉ž“š‘Ò‚¿‚ÌŠÔ‚ÉŽžŠÔ’´‰ß";
+ Text[ chinese_traditional ] = "µ¥­Ô DDE ¦^À³¶W¹L®É­­";
+ Text[ arabic ] = "DDE Êã ÊÎØí ÇáæÞÊ ÃËäÇÁ ÇäÊÙÇÑ ÇáÑÏ ãä";
+ Text[ dutch ] = "Tijdoverschrijding tijdens wachten op DDE-antwoord";
+ Text[ chinese_simplified ] = "µÈºò DDE »ØÓ¦³¬¹ýʱÏÞ";
+ Text[ greek ] = "ÕðÝñâáóç ÷ñüíïõ êáôÜ ôçí áíáìïíÞ áðÜíôçóçò áðü ôï DDE";
+ Text[ korean ] = "DDE ÀÀ´äÀ» ±â´Ù¸®´Â µ¿¾È ŸÀӾƿô";
+ Text[ turkish ] = "DDE yanýtýný beklemede zaman aþýmý";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_USER_INTERRUPT & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Benutzer dr³ckte ESCAPE wõhrend der DDE-Operation : Benutzer drckte ESCAPE w§hrend der DDE-Operation */
+ Text = "Benutzer drückte ESCAPE während 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 operação DDE" ;
+ Text [ french ] = "L'utilisateur a appuyé sur ÉCHAP pendant l'opération DDE" ;
+ Text [ dutch ] = "Gebruiker drukte Escape tijdens uitvoering DDE" ;
+ Text [ spanish ] = "El usuario presionó la tecla ESC durante la operación DDE" ;
+ Text [ danish ] = "Brugeren trykkede på ESCAPE under DDE-operationen" ;
+ Text [ swedish ] = "Användaren 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 ] = "U¿ytkownik u¿y³ przycisku ESCAPE podczas operacji DDE";
+ Text[ japanese ] = "DDE‚̵ÍßÚ°¼®Ý‚ÌÅ’†‚É Õ°»Þ°‚ªESCAPEÎÞÀÝ‚ð‰Ÿ‚µ‚Ü‚µ‚½";
+ Text[ language_user1 ] = " ";
+ Text[ chinese_traditional ] = "¦b°õ¦æ DDE ¹Bºâ¹Lµ{¤¤¨Ï¥ÎªÌ«öÀ»¤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 iþlemi sýrasýnda ESCAPE tuþuna basýldý";
+ };
+ 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 aplicação externa está ocupada" ;
+ Text [ french ] = "L'application externe est occupée" ;
+ Text [ dutch ] = "Doelapplicatie is niet bereid" ;
+ Text [ spanish ] = "La aplicación 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 hazýr deðil";
+ 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 operação DDE não tem dados" ;
+ Text [ french ] = "Données non fournies dans l'opération DDE" ;
+ Text [ dutch ] = "DDE-operatie zonder gegevens" ;
+ Text [ spanish ] = "Operación 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 iþlemi";
+ 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 données est incorrect" ;
+ Text [ dutch ] = "Gegevens hebben foutief formaat" ;
+ Text [ spanish ] = "Los datos están 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 aplicação externa" ;
+ Text [ french ] = "L'application externe a été quittée" ;
+ Text [ dutch ] = "Externe applicatie werd beëindigd" ;
+ Text [ spanish ] = "La aplicación 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 zosta³a zakoñczona";
+ Text[ japanese ] = "ŠO•”±Ìßع°¼®Ý‚ÍI—¹‚µ‚Ä‚¢‚Ü‚·";
+ Text[ chinese_traditional ] = "¥~³¡À³¥Îµ{¦¡¤w¸gµ²§ô";
+ Text[ arabic ] = "Êã ÅäåÇÁ ÇáÊØÈíÞ ÇáÎÇÑÌí";
+ Text[ dutch ] = "Externe applicatie werd beëindigd";
+ Text[ chinese_simplified ] = "ÍⲿӦÓóÌÐòÒѾ­½áÊø";
+ Text[ greek ] = "Ç åîùôåñéêÞ åöáñìïãÞ ôåñìáôßóôçêå.";
+ Text[ korean ] = "¿ÜºÎ ÀÀ¿ëÇÁ·Î±×·¥ÀÌ Á¦°ÅµÇ¾ú½À´Ï´Ù.";
+ Text[ turkish ] = "Harici uygulamadan çýkýldý";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_CONV_CLOSED & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? DDE-Verbindung ist unterbrochen oder geõndert worden : DDE-Verbindung ist unterbrochen oder ge§ndert worden */
+ Text = "DDE-Verbindung ist unterbrochen oder geändert 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 ligação DDE foi interrompida ou modificada" ;
+ Text [ french ] = "La connexion DDE a été interrompue ou modifiée" ;
+ Text [ dutch ] = "DDE-verbinding verbroken of veranderd" ;
+ Text [ spanish ] = "La conexión DDE se ha interrumpido o modificado" ;
+ Text [ danish ] = "DDE-forbindelsen er blevet afbrudt eller modificeret" ;
+ Text [ swedish ] = "DDE-förbindelsen är avbruten eller förändrad" ;
+ Text [ finnish ] = "DDE conversation closed or changed" ;
+ Text [ english_us ] = "DDE connection interrupted or modified" ;
+ Text[ chinese_simplified ] = "DDEÁ¬½ÓÒѾ­ÖжϻòÕßÒѾ­¸ü¸Ä";
+ Text[ russian ] = "Ñîåäèíåíèå DDE ïðåðâàíî èëè èçìåíåíî";
+ Text[ polish ] = "Po³¹czenie DDE zosta³o przerwane lub zmodyfikowane.";
+ Text[ japanese ] = "DDEÚ‘±‚ª’†’f‚µ‚½‚©‚Ü‚½‚Í•ÏX‚³‚ê‚Ä‚¢‚Ü‚·";
+ Text[ chinese_traditional ] = "DDE³sµ²¤w¸g¤¤Â_©ÎªÌ¤w¸gÅܧó";
+ Text[ arabic ] = "DDE Êã ãÞÇØÚÉ Ãæ ÊÛííÑ ÇÊÕÇá";
+ Text[ dutch ] = "DDE-verbinding verbroken of veranderd";
+ Text[ chinese_simplified ] = "DDEÁ¬½ÓÒѾ­ÖжϻòÕßÒѾ­¸ü¸Ä";
+ Text[ greek ] = "Ç óýíäåóç DDE äéáêüðçêå Þ Üëëáîå";
+ Text[ korean ] = "DDE Á¢¼ÓÀÌ ÀÎÅÍ·´Æ®µÇ°Å³ª ¼öÁ¤µÇ¾ú½À´Ï´Ù.";
+ Text[ turkish ] = "DDE baðlantýsý kesildi ya da deðiþtirildi";
+ 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 ] = "Método DDE foi chamado sem canal aberto" ;
+ Text [ french ] = "Méthode DDE appelée sans avoir ouvert un canal DDE" ;
+ Text [ dutch ] = "DDE-methode zonder open kanaal opgeroepen" ;
+ Text [ spanish ] = "Se llamó al método 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 wywo³ana bez otwartego kana³u DDE";
+ Text[ japanese ] = "DDEÁ¬ÝÈÙ‚ªŠJ‚©‚ê‚Ä‚¢‚È‚¢ó‘Ô‚ÅDDEÒ¿¯ÄÞ‚ªŒÄ‚Ño‚³‚ê‚Ä‚¢‚Ü‚·";
+ Text[ chinese_traditional ] = "¦b¨S¦³¶}±ÒDDE«H¹D®É½Õ¥Î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 ] = "Açýk DDE kanalý olmadan DDE yöntemi çaðrýsý";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_INVALID_LINK & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ung³ltiges DDE-Linkformat : Ungltiges DDE-Linkformat */
+ Text = "Ungültiges 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 ligação DDE não válido" ;
+ Text [ french ] = "Format de lien DDE incorrect" ;
+ Text [ dutch ] = "Foutief DDE-link-formaat" ;
+ Text [ spanish ] = "Formato del vínculo 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 ] = "Nieprawid³owy format ³¹cza DDE";
+ Text[ japanese ] = "–³Œø‚È DDE Øݸ‘Ž®";
+ Text[ chinese_traditional ] = "µL®ÄªºDDE³sµ²®æ¦¡";
+ Text[ arabic ] = "ÛíÑ ÕÇáÍ DDE ÊäÓíÞ ÇÑÊÈÇØ";
+ Text[ dutch ] = "Foutief DDE-link-formaat";
+ Text[ chinese_simplified ] = "ÎÞЧµÄ DDE Á´½Ó¸ñʽ";
+ Text[ greek ] = "Ìç Ýãêõñç ìïñöÞ óýíäåóçò DDE";
+ Text[ korean ] = "À¯È¿ÇÏÁö ¾ÊÀº DDE ¿¬°á ¼­½Ä";
+ Text[ turkish ] = "Geçersiz DDE baðlantý 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 gået 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 zaginê³a";
+ Text[ japanese ] = "DDEÒ¯¾°¼Þ‚ÍŽ¸‚í‚ê‚Ü‚µ‚½";
+ Text[ chinese_traditional ] = "DDE°T®§¿ò¥¢";
+ 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 durchgef³hrt : Paste Link bereits durchgefhrt */
+ Text = "Paste Link bereits durchgeführt" ;
+ 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 déjà été exécuté" ;
+ Text [ dutch ] = "Paste link reeds uitgevoerd" ;
+ Text [ spanish ] = "Pegar vínculo ya ejecutado" ;
+ Text [ danish ] = "Paste link er allerede udført" ;
+ Text [ swedish ] = "Paste link är redan genomfört" ;
+ Text [ finnish ] = "Paste link already performed" ;
+ Text [ english_us ] = "Paste link already performed" ;
+ Text[ chinese_simplified ] = "Õ³ÌùÁ´½ÓÒѾ­Íê³É";
+ Text[ russian ] = "Âñòàâêà ññûëêè óæå âûïîëíåíà";
+ Text[ polish ] = "Polecenie Wklej ³¹cze zosta³o ju¿ wykonane";
+ Text[ japanese ] = "Øݸ‚Ì“\\‚è•t‚¯‚Í‚·‚Å‚ÉŽÀs‚³‚ê‚Ä‚¢‚Ü‚·";
+ Text[ language_user1 ] = " ";
+ Text[ chinese_traditional ] = "Ö߶K³sµ²¤w¸g§¹¦¨";
+ Text[ arabic ] = "ãÓÈÞÇð Paste link Êã ÃÏÇÁ ";
+ Text[ dutch ] = "Paste link reeds uitgevoerd";
+ Text[ chinese_simplified ] = "Õ³ÌùÁ´½ÓÒѾ­Íê³É";
+ Text[ greek ] = "Ôï 'Paste link' åêôåëÝóôçêå Þäç";
+ Text[ korean ] = "¿¬°á ºÙ¿©³Ö±â´Â ÀÌ¹Ì ¼öÇàµÇ¾ú½À´Ï´Ù.";
+ Text[ turkish ] = "Paste Link iþlemi yürütüldü";
+ };
+ String SbERR_DDE_LINK_INV_TOPIC & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? LinkMode kann wegen ung³ltigen Link-Topics nicht gesetzt werden : LinkMode kann wegen ungltigen Link-Topics nicht gesetzt werden */
+ Text = "LinkMode kann wegen ungültigen 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 ] = "Impossível configurar o LinkMode devido a LinkTopic não válido" ;
+ Text [ french ] = "Impossible de définir 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 ställas 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 mo¿na skonfigurowaæ LinkMode z powodu niewa¿nych Link-Topics";
+ Text[ japanese ] = "Øݸ Ó°ÄÞ‚ÍØݸ ÄË߯¸‚ª–³Œø‚Å‚ ‚邽‚ßAÝ’è‚Å‚«‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "¦]¬°µL®Äªº±¶®|¼ÐÃD¦ÓµLªk³]©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, geçersiz Link-Topics nedeniyle belirlenemez";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_DDE_DLL_NOT_FOUND & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? F³r DDE wird DDEML.DLL ben÷tigt : Fr DDE wird DDEML.DLL ben”tigt */
+ Text = "Für DDE wird DDEML.DLL benötigt" ;
+ 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 kræver DDEML.DLL" ;
+ Text [ swedish ] = "DDE kräver 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 ] = "DDE‚Ì‚½‚ß‚ÉDDEML.DLL‚ª•K—v‚Å‚·";
+ Text[ chinese_traditional ] = "DDE­n¨DDDEML.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 için DDEML.DLL gerekli";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_CANNOT_LOAD & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Das Modul kann nicht geladen werden, ung³ltiges Format : Das Modul kann nicht geladen werden, ungltiges Format */
+ Text = "Das Modul kann nicht geladen werden, ungültiges 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 ] = "Impossível carregar módulo; formato não válido" ;
+ 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 módulo ya que el formato es incorrecto" ;
+ Text [ danish ] = "Det er ikke muligt at indlæse 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 ] = "Modu³u nie mo¿na za³adowaæ, nieprawid³owy format";
+ Text[ japanese ] = "Ó¼Þ­°Ù‚ª“Ç‚Ýž‚ß‚Ü‚¹‚ñB–³Œø‚È‘Ž®‚Å‚·B";
+ Text[ chinese_traditional ] = "®æ¦¡µL®Ä¡M¦]¦ÓµLªk¸Ë¸ü¼Ò¶ô";
+ Text[ arabic ] = "áÇ íãßä ÊÍãíá ÇáæÍÏÉ ÇáäãØíÉ º ÊäÓíÞ ÛíÑ ÕÇáÍ";
+ Text[ dutch ] = "De module kan niet worden geladen, ongeldig formaat";
+ Text[ chinese_simplified ] = "¸ñʽÎÞЧ£¬Òò¶øÎÞ·¨×°ÔØÄ£¿é";
+ Text[ greek ] = "Äåí Þôáí äõíáôüí íá öïñôùèåß ç ëåéôïõñãéêÞ ìïíÜäá, ìç Ýãêõñç ìïñöÞ";
+ Text[ korean ] = "¸ðµâÀÌ ·ÎµåµÇÁö ¾Ê¾Ò½À´Ï´Ù. ; À߸øµÈ Æ÷¸Ë";
+ Text[ turkish ] = "Modül yüklenemiyor; geçersiz format";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_INDEX & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ung³ltiger Objektindex : Ungltiger Objektindex */
+ Text = "Ungültiger 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 não válido" ;
+ 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 ] = "Nieprawid³owy indeks obiektów";
+ Text[ japanese ] = "–³Œø‚ȵÌÞ¼Þª¸Ä ²ÝÃÞ¯¸½";
+ Text[ chinese_traditional ] = "µL®Äªºª«¥ó¯Á¤Þ";
+ Text[ arabic ] = "ÝåÑÓ ßÇÆä ÛíÑ ÕÇáÍ";
+ Text[ dutch ] = "Ongeldige objectindex";
+ Text[ chinese_simplified ] = "ÎÞЧµÄ¶ÔÏóË÷Òý";
+ Text[ greek ] = "Ìç Ýãêõñï åõñåôÞñéï áíôéêåéìÝíùí";
+ Text[ korean ] = "À¯È¿ÇÏÁö ¾ÊÀº °³Ã¼ À妽º";
+ Text[ turkish ] = "Geçersiz nesne dizini";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_ACTIVE_OBJECT & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Objekt ist nicht verf³gbar : Objekt ist nicht verfgbar */
+ Text = "Objekt ist nicht verfügbar" ;
+ 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 não disponível" ;
+ 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 tilgængeligt" ;
+ Text [ swedish ] = "Objektet är inte tillgängligt" ;
+ Text [ finnish ] = "Object is not available" ;
+ Text [ english_us ] = "Object is not available" ;
+ Text[ chinese_simplified ] = "¶ÔÏó²»´æÔÚ";
+ Text[ russian ] = "Îáúåêò íåäîñòóïåí";
+ Text[ polish ] = "Obiekt jest niedostêpny";
+ Text[ japanese ] = "µÌÞ¼Þª¸Ä‚ª‚ ‚è‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "ª«¥ó¤£¦s¦b";
+ Text[ arabic ] = "ÇáßÇÆä ÛíÑ ãÊÇÍ";
+ Text[ dutch ] = "Object niet beschikbaar";
+ Text[ chinese_simplified ] = "¶ÔÏó²»´æÔÚ";
+ Text[ greek ] = "Ôï áíôéêåßìåíï äåí åßíáé äéáèÝóéìï";
+ Text[ korean ] = "°³Ã¼°¡ À¯È¿ÇÏÁö ¾È½À´Ï´Ù.";
+ Text[ turkish ] = "Nesne mevcut deðil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_PROP_VALUE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Falscher Wert f³r Eigenschaft : Falscher Wert fr Eigenschaft */
+ Text = "Falscher Wert für 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 propriété incorrecte" ;
+ Text [ dutch ] = "Foutieve waarde voor eigenschap" ;
+ Text [ spanish ] = "Valor no válido para la propiedad" ;
+ Text [ danish ] = "Forkert egenskabsværdi" ;
+ Text [ swedish ] = "Felaktigt värde för egenskap" ;
+ Text [ finnish ] = "Bad property value" ;
+ Text [ english_us ] = "Incorrect property value" ;
+ Text[ chinese_simplified ] = "´íÎóµÄÊôÐÔÊýÖµ";
+ Text[ russian ] = "Íåïðàâèëüíîå çíà÷åíèå ñâîéñòâà";
+ Text[ polish ] = "Niepoprawna wartoœæ w³aœciwoœci";
+ 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 deðeri";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_PROP_READONLY & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Eigenschaft ist schreibgesch³tzt : Eigenschaft ist schreibgeschtzt */
+ Text = "Eigenschaft ist schreibgeschützt" ;
+ 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 propriété 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 ] = "W³aœciwoœæ 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 lesegesch³tzt : Eigenschaft ist lesegeschtzt */
+ Text = "Eigenschaft ist lesegeschützt" ;
+ 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 propriété est en écriture seule" ;
+ Text [ dutch ] = "Eigenschap is leesbeveiligd" ;
+ Text [ spanish ] = "Propiedad es solo escritura" ;
+ Text [ danish ] = "Egenskaben er læsebeskyttet" ;
+ Text [ swedish ] = "Egenskapen är lässkyddad" ;
+ Text [ finnish ] = "Property is write only" ;
+ Text [ english_us ] = "This property is write only" ;
+ Text[ chinese_simplified ] = "·À¶ÁÈ¡µÄÊôÐÔ";
+ Text[ russian ] = "Ñâîéñòâî âîçìîæíî òîëüêî çàïèñàòü";
+ Text[ polish ] = "W³aœciwoœæ 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? Ung³ltige Objektreferenz : Ungltige Objektreferenz */
+ Text = "Ungültige 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 ] = "Referência do objecto não-válida" ;
+ Text [ french ] = "Référence d'objet incorrecte" ;
+ Text [ dutch ] = "Ongeldige objectverwijzing" ;
+ Text [ spanish ] = "Referencia al objeto no válida" ;
+ 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 ] = "Niewa¿ne odwo³anie obiektu";
+ Text[ japanese ] = "–³Œø‚ȵÌÞ¼Þª¸ÄŽQÆ";
+ Text[ chinese_traditional ] = "µL®Äªºª«¥ó°Ñ·Ó";
+ Text[ arabic ] = "ãÑÌÚ ÇáßÇÆä ÛíÑ ÕÇáÍ";
+ Text[ dutch ] = "Ongeldige objectverwijzing";
+ Text[ chinese_simplified ] = "ÎÞЧµÄ¶ÔÏóÒýÓÃ";
+ Text[ greek ] = "Ìç Ýãêõñç áíáöïñÜ áíôéêåéìÝíïõ";
+ Text[ korean ] = "À߸øµÈ °³Ã¼ ÂüÁ¶";
+ Text[ turkish ] = "Geçersiz 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 método não encontrados" ;
+ Text [ french ] = "Propriété ou méthode introuvable" ;
+ Text [ dutch ] = "Eigenschap of methode niet gevonden" ;
+ Text [ spanish ] = "No se encontró la propiedad o el método" ;
+ 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 w³aœciwoœci 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 yöntem 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 ] = "Necessário objecto" ;
+ Text [ french ] = "Objet requis" ;
+ Text [ dutch ] = "Object vereist" ;
+ Text [ spanish ] = "Se requiere un objeto" ;
+ Text [ danish ] = "Objekt kræves" ;
+ Text [ swedish ] = "Objekt krävs" ;
+ Text [ finnish ] = "Object required" ;
+ Text [ english_us ] = "Object required" ;
+ Text[ chinese_simplified ] = "ÒªÇó¶ÔÏó";
+ Text[ russian ] = "Íåîáõîäèì îáúåêò";
+ Text[ polish ] = "Wymagany obiekt";
+ Text[ japanese ] = "µÌÞ¼Þª¸Ä‚ª•K—v‚Å‚·";
+ Text[ chinese_traditional ] = "­n¨Dª«¥ó";
+ 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 erróneo de un objeto" ;
+ Text [ danish ] = "Ugyldig brug af et objekt" ;
+ Text [ swedish ] = "Felaktig användning av ett objekt" ;
+ Text [ finnish ] = "Invalid use of object" ;
+ Text [ english_us ] = "Invalid use of an object" ;
+ Text[ chinese_simplified ] = "´íÎóʹÓöÔÏó";
+ Text[ russian ] = "Íåïðàâèëüíîå èñïîëüçîâàíèå îáúåêòà";
+ Text[ polish ] = "Nieprawid³owe u¿ycie obiektu";
+ Text[ japanese ] = "µÌÞ¼Þª¸Ä‚ÌŒë‚Á‚½Žg—p";
+ Text[ chinese_traditional ] = "¿ù»~¨Ï¥Îª«¥ó";
+ Text[ arabic ] = "ÇÓÊÎÏÇã ÎÇØÆ áßÇÆä";
+ Text[ dutch ] = "Ongeldig gebruik van object";
+ Text[ chinese_simplified ] = "´íÎóʹÓöÔÏó";
+ Text[ greek ] = "ËáíèáóìÝíç ÷ñÞóç åíüò áíôéêåéìÝíïõ";
+ Text[ korean ] = "°³Ã¼ÀÇ À߸øµÈ »ç¿ë";
+ Text[ turkish ] = "Nesne kullanýmý yanlýþ";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_OLE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? OLE-Automatisierung wird von diesem Objekt nicht unterst³tzt : OLE-Automatisierung wird von diesem Objekt nicht untersttzt */
+ Text = "OLE-Automatisierung wird von diesem Objekt nicht unterstützt" ;
+ 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 não suporta a automatação 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 automatización OLE" ;
+ Text [ danish ] = "OLE-automatiseringen understøttes ikke af dette objekt" ;
+ Text [ swedish ] = "OLE-automatiseringen stöds 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 obs³ugiwana 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 tarafýndan desteklenmiyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_METHOD & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Objekt unterst³tzt diese Eigenschaft oder Methode nicht : Objekt untersttzt diese Eigenschaft oder Methode nicht */
+ Text = "Objekt unterstützt 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 não suporta nem a característica nem o método" ;
+ Text [ french ] = "L'objet ne supporte pas cette propriété ou méthode" ;
+ Text [ dutch ] = "Deze eigenschap of methode wordt niet ondersteund door het aangegeven object" ;
+ Text [ spanish ] = "El objeto no apoya esta propiedad o método" ;
+ Text [ danish ] = "Objektet understøtter ikke denne egenskab eller metode" ;
+ Text [ swedish ] = "Objektet understödjer 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 obs³uguje tej w³aœciwoœci 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 özelliði ya da yöntemi 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 automatação OLE" ;
+ Text [ french ] = "Erreur lors de l'automatisation OLE" ;
+ Text [ dutch ] = "Fout bij OLE-automatisering" ;
+ Text [ spanish ] = "Error en la automatización 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 ] = "B³¹d 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 unterst³tzt : Diese Aktion wird vom angegebenen Objekt nicht untersttzt */
+ Text = "Diese Aktion wird vom angegebenen Objekt nicht unterstützt" ;
+ 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 não suporta esta acção" ;
+ Text [ french ] = "L'objet indiqué ne supporte pas cette action" ;
+ Text [ dutch ] = "Deze activiteit wordt niet ondersteund door het aangegeven object" ;
+ Text [ spanish ] = "Esta acción no es apoyada por el objeto dado" ;
+ Text [ danish ] = "Denne handling understøttes ikke at det angivne objekt." ;
+ Text [ swedish ] = "Denna åtgärd understöds 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 obs³ugiwana 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 iþlem belirtilen nesne tarafýndan desteklenmiyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_NAMED_ARGS & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Benannte Argumente werden vom angegebenen Objekt nicht unterst³tzt : Benannte Argumente werden vom angegebenen Objekt nicht untersttzt */
+ Text = "Benannte Argumente werden vom angegebenen Objekt nicht unterstützt" ;
+ 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 não suporta os argumentos mencionados" ;
+ Text [ french ] = "L'objet indiqué ne supporte pas les arguments cités" ;
+ Text [ dutch ] = "Genoemde argumenten wordt niet ondersteund door het aangegeven object" ;
+ Text [ spanish ] = "El objeto indicado no apoya los argumentos nombrados" ;
+ Text [ danish ] = "Nævnte argumenter understøttes ikke af det angivne objekt" ;
+ Text [ swedish ] = "Angivna argument understöds 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¹ obs³ugiwane przez podany obiekt";
+ Text[ japanese ] = "Žw–¼‚³‚ꂽˆø”‚ÍŽw’肳‚ꂽµÌÞ¼Þª¸Ä‚©‚çŽx‰‡‚³‚ê‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "«ü©wªº¦ÛÅܶq¤£¨ü«ü©wª«¥óªº¤ä´©";
+ Text[ arabic ] = "ÇáßÇÆä ÇáãÏÑÌ áÇ íÏÚã ÇáæÓÇÆØ ÇáãÓãÇÉ";
+ Text[ dutch ] = "Genoemde argumenten wordt niet ondersteund door het aangegeven object";
+ Text[ chinese_simplified ] = "¸ø¶¨¶ÔÏó²»Ö§³ÖÖ¸¶¨µÄ×Ô±äÁ¿";
+ Text[ greek ] = "Ôá ïíïìáæüìåíá ïñßóìáôá äåí õðïóôçñßæïíôáé áðü ôï äåäïìÝíï áíôéêåßìåíï";
+ Text[ korean ] = "ÁöÁ¤µÈ µ¶¸³ º¯¼ö´Â ÁÖ¾îÁø °³Ã¼ÀÇ Áö¿øÀ» ¹ÞÁö ¾Ê½À´Ï´Ù.";
+ Text[ turkish ] = "Adlandýrýlmýþ argümanlar, belirtilen nesne tarafýndan desteklenmiyor";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_LOCALE & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Das aktuelle Gebietsschema wird vom angegebenen Objekt nicht unterst³tzt : Das aktuelle Gebietsschema wird vom angegebenen Objekt nicht untersttzt */
+ Text = "Das aktuelle Gebietsschema wird vom angegebenen Objekt nicht unterstützt" ;
+ 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 não suporta a configuração local actual" ;
+ Text [ french ] = "L'objet indiqué ne supporte pas les paramètres régionaux sélectionnés" ;
+ Text [ dutch ] = "Dit actuele gebiedschema wordt niet ondersteund door het aangegeven object" ;
+ Text [ spanish ] = "La configuración local actual no es apoyada por el objeto dado" ;
+ Text [ danish ] = "Det aktuelle områdeskema understøttes ikke af det angivne objekt" ;
+ Text [ swedish ] = "De aktuella lokala inställningarna understöds 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 ] = "Bie¿¹ce ustawienie lokalne nie jest obs³ugiwane przez podany obiekt";
+ Text[ japanese ] = "Œ»Ý‚ÌÛ°¶ÙÝ’è‚ÍŽw’肵‚½µÌÞ¼Þª¸Ä‚©‚çŽx‰‡‚³‚ê‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "·í«eªº§½³¡³]©w¤£¨ü«ü©wª«¥óªº¤ä´©";
+ Text[ arabic ] = "ÇáßÇÆä ÇáãÚØì áÇ íÏÚã ÇáÅÚÏÇÏ ÇáãÍáí ÇáÍÇáí";
+ Text[ dutch ] = "Dit actuele gebiedschema wordt niet ondersteund door het aangegeven object";
+ Text[ chinese_simplified ] = "µ±Ç°µÄ¾Ö²¿É趨²»Êܸø¶¨¶ÔÏóµÄÖ§³Ö";
+ Text[ greek ] = "Ïé ôñÝ÷ïõóåò ôïðéêÝò ñõèìßóåéò äåí õðïóôçñßæïíôáé áðü ôï äåäïìÝíï áíôéêåßìåíï";
+ Text[ korean ] = "ÇöÀçÀÇ ·ÎÄà ¼³Á¤Àº ÁÖ¾îÁø °³Ã¼¿¡ÀÇÇؼ­ Áö¿øµÇÁö ¾Ê½À´Ï´Ù.";
+ Text[ turkish ] = "Yürülükteki yerel ayarlar, belirtilen nesne tarafýndan 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 ] = "Impossível 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 nævnte 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 ] = "¨S¦³§ä¨ì«ü©wªº¦ÛÅܶq";
+ Text[ arabic ] = "áã íñÚËÑ Úáì ÇáæÓíØÉ ÇáãÓãÇÉ";
+ Text[ dutch ] = "Genoemd argument niet gevonden";
+ Text[ chinese_simplified ] = "ûÓÐÕÒµ½Ö¸¶¨µÄ×Ô±äÁ¿";
+ Text[ greek ] = "Ôï ïíïìáæüìåíï üñéóìá äåí âñÝèçêå";
+ Text[ korean ] = "ÁöÁ¤µÈ µ¶¸³ º¯¼ö°¡ ¹ß°ßµÇÁö ¾Ê½À´Ï´Ù.";
+ Text[ turkish ] = "Adlandýrýlan argüman 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 não é 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 ] = "«D¥i¿ïªº¦ÛÅܶq";
+ Text[ arabic ] = "ÇáæÓíØÉ ÛíÑ ÇÎÊíÇÑíÉ";
+ Text[ dutch ] = "Argument niet optioneel";
+ Text[ chinese_simplified ] = "·Ç¿ÉÑ¡µÄ×Ô±äÁ¿";
+ Text[ greek ] = "Ôï üñéóìá äåí åßíáé ðñïáéñåôéêü";
+ Text[ korean ] = "µ¶¸³ º¯¼ö´Â ¿É¼ÇÀÌ ¾Æ´Õ´Ï´Ù.";
+ Text[ turkish ] = "Argüman isteðe baðlý deðil";
+ 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 ] = "Número de argumentos incorrecto" ;
+ Text [ french ] = "Nombre d'arguments incorrect" ;
+ Text [ dutch ] = "Foutief aantal argumenten" ;
+ Text [ spanish ] = "Número erróneo 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 ] = "Nieprawid³owa iloœæ argumentów";
+ Text[ japanese ] = "ˆø”‚Ì”‚ª³‚µ‚­‚ ‚è‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "µL®Äªº¦ÛÅܶq¼Æ¥Ø";
+ Text[ arabic ] = "ÚÏÏ ÇáæÓÇÆØ ÛíÑ ÕÇáÍ";
+ Text[ dutch ] = "Foutief aantal argumenten";
+ Text[ chinese_simplified ] = "ÎÞЧµÄ×Ô±äÁ¿ÊýÄ¿";
+ Text[ greek ] = "ËÜèïò ðëÞèïò ïñéóìÜôùí";
+ Text[ korean ] = "µ¶¸³º¯¼ö °³¼ö°¡ Ʋ¸²";
+ Text[ turkish ] = "Argüman sayýsý 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 não é 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 deðil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_ORDINAL & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ordnungszahl ung³ltig : Ordnungszahl ungltig */
+ Text = "Ordnungszahl ungültig" ;
+ 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 ] = "Número ordinal no válido" ;
+ 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 ] = "Nieprawid³owa liczba porz¹dkowa";
+ Text[ japanese ] = "˜”‚Í–³Œø‚Å‚·";
+ Text[ chinese_traditional ] = "§Ç¸¹µL®Ä";
+ Text[ arabic ] = "ÚÏÏ ÊÑÊíÈí ÛíÑ ÕÇáÍ";
+ Text[ dutch ] = "Ongeldig ranggetal";
+ Text[ chinese_simplified ] = "ÐòºÅÎÞЧ";
+ Text[ greek ] = "Ìç Ýãêõñïò áñéèìüò ôÜîçò";
+ Text[ korean ] = "À߸øµÈ ¼­¼ö";
+ Text[ turkish ] = "Sýra sayýsý geçersiz";
+ 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 ] = "Função DLL especificada não foi encontrada" ;
+ Text [ french ] = "La fonction DLL indiquée est introuvable" ;
+ Text [ dutch ] = "Aangegeven DLL- functie niet gevonden" ;
+ Text [ spanish ] = "No se encontró la función 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 ] = "¨S¦³§ä¨ì«ü©wªºDLL¥\\¯à";
+ Text[ arabic ] = "ÇáãÍÏÏÉ ÛíÑ ãæÌæÏÉ DLL ÏÇáÉ";
+ Text[ dutch ] = "Aangegeven DLL- functie niet gevonden";
+ Text[ chinese_simplified ] = "ûÓÐÕÒµ½Ö¸¶¨µÄ DLL ¹¦ÄÜ";
+ Text[ greek ] = "Äåí âñÝèçêå ç áíáöåñüìåíç ëåéôïõñãßá DLL";
+ Text[ korean ] = "¸í±âµÈ DLL ÇÔ¼ö°¡ ¹ß°ßµÇÁö ¾Ê¾Ò½À´Ï´Ù.";
+ Text[ turkish ] = "Belirtilen DLL iþlevi bulunamadý";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_CLIPBD_FORMAT & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ung³ltiges Clipboard-Format : Ungltiges Clipboard-Format */
+ Text = "Ungültiges 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 transferência não válido" ;
+ Text [ french ] = "Le format de presse-papiers souhaité est incorrect." ;
+ Text [ dutch ] = "Ongeldig Clipboard- formaat" ;
+ Text [ spanish ] = "Formato de portapapeles no válido" ;
+ 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 ] = "Nieprawid³owy 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 ] = "Geçersiz 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 não tem esta propriedade" ;
+ Text [ french ] = "L'objet ne possède pas cette propriété" ;
+ 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 w³aœciwoœci";
+ 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 özelliðe sahip deðil";
+ 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 não dispõe deste método" ;
+ Text [ french ] = "L'objet ne possède pas cette méthode" ;
+ Text [ dutch ] = "Object kent deze methode niet" ;
+ Text [ spanish ] = "El objeto no tiene este método" ;
+ 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 yönteme sahip deðil";
+ 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 necessário" ;
+ Text [ french ] = "L'argument requis fait défaut" ;
+ Text [ dutch ] = "Noordzakelijk argument ontbreekt" ;
+ Text [ spanish ] = "Falta el argumento requerido" ;
+ Text [ danish ] = "Påkrævet argument mangler" ;
+ Text [ swedish ] = "Nödvändigt 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 ] = "•K—v‚Ȉø”‚ª‘«‚è‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "¯Ê¤Ö¥²­nªº¦ÛÅܶq";
+ Text[ arabic ] = "ÇáæÓíØÉ ÇáãØáæÈÉ ÛíÑ ãÊÇÍÉ";
+ Text[ dutch ] = "Noordzakelijk argument ontbreekt";
+ Text[ chinese_simplified ] = "ȱÉÙ±ØÒªµÄ×Ô±äÁ¿";
+ Text[ greek ] = "Ëåßðåé áðáéôïýìåíï üñéóìá";
+ Text[ korean ] = "¿äûµÈ µ¶¸³º¯¼ö°¡ ¾ø½À´Ï´Ù";
+ Text[ turkish ] = "Gerekli argüman eksik";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_BAD_NUMBER_OF_ARGS & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Ung³ltige Anzahl von Argumenten : Ungltige Anzahl von Argumenten */
+ Text = "Ungültige 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 ] = "Número de argumentos incorrecto" ;
+ Text [ french ] = "Nombre d'arguments incorrect" ;
+ Text [ dutch ] = "Ongeldig aantal argumenten" ;
+ Text [ spanish ] = "Número de argumentos no válido" ;
+ 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 ] = "Nieprawid³owa iloœæ argumentów";
+ Text[ japanese ] = "ˆø”‚Ì”‚É–â‘肪‚ ‚è‚Ü‚·";
+ Text[ chinese_traditional ] = "¦ÛÅܶq¼Æ¥ØµL®Ä";
+ Text[ arabic ] = "ÚÏÏ æÓÇÆØ ÛíÑ ÕÇáÍ";
+ Text[ dutch ] = "Ongeldig aantal argumenten";
+ Text[ chinese_simplified ] = "ÎÞЧµÄ×Ô±äÁ¿ÊýÄ¿";
+ Text[ greek ] = "ËÜèïò ðëÞèïò ïñéóìÜôùí";
+ Text[ korean ] = "µ¶¸³º¯¼ö °³¼ö°¡ À¯È¿ÇÏÁö ¾ÊÀ½";
+ Text[ turkish ] = "Argüman sayýsý geçersiz";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_METHOD_FAILED & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Fehler in Ausf³hrung einer Methode : Fehler in Ausfhrung einer Methode */
+ Text = "Fehler in Ausführung 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 método" ;
+ Text [ french ] = "Erreur dans l'exécution d'une méthode" ;
+ Text [ dutch ] = "Fout in uitvoering van een methode" ;
+ Text [ spanish ] = "Error al ejecutar un método" ;
+ Text [ danish ] = "Fejl ved udførelsen af en metode" ;
+ Text [ swedish ] = "Fel vid utförandet av en metod" ;
+ Text [ finnish ] = "Method failed" ;
+ Text [ english_us ] = "Error executing a method" ;
+ Text[ chinese_simplified ] = "ÔËÐз½·¨Ê±·¢Éú´íÎó";
+ Text[ russian ] = "Îøèáêà â âûïîëíåíèè ìåòîäà";
+ Text[ polish ] = "B³¹d w wykonywaniu metody";
+ Text[ japanese ] = "Ò¿¯ÄÞŽÀs’†‚Ì´×°";
+ Text[ chinese_traditional ] = "¹B¦æ¤èªk®Éµo¥Í¿ù»~";
+ Text[ arabic ] = "ÎØà Ýí ÊäÝíÐ ÇáÃÓáæÈ";
+ Text[ dutch ] = "Fout in uitvoering van een methode";
+ Text[ chinese_simplified ] = "ÔËÐз½·¨Ê±·¢Éú´íÎó";
+ Text[ greek ] = "ÓöÜëìá êáôÜ ôçí åöáñìïãÞ ìéáò ìåèüäïõ";
+ Text[ korean ] = "¸Þ¼Òµå ½ÇÇà ¿À·ù";
+ Text[ turkish ] = "Yöntemin yürütülmesinde 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 impossível definir propriedade" ;
+ Text [ french ] = "Impossible de définir la propriété" ;
+ 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 ] = "W³aœciwoœæ nie mog³a zostaæ zdefiniowana";
+ Text[ japanese ] = "‘®«‚ÍŽw’è‚Å‚«‚Ü‚¹‚ñ‚Å‚µ‚½";
+ Text[ chinese_traditional ] = "µLªk½T©wÄÝ©Ê";
+ Text[ arabic ] = "ÊÚÐÑ ÊÚííä ÇáÎÇÕíÉ";
+ Text[ dutch ] = "Eigenschap kon niet worden gedefinieerd";
+ Text[ chinese_simplified ] = "ÎÞ·¨È·¶¨ÊôÐÔ";
+ Text[ greek ] = "Äåí Þôáí äõíáôüí íá ïñéóôåß áõôÞ ç éäéüôçôá";
+ Text[ korean ] = "ÇÁ·ÎÆÛƼ ¼³Á¤À» ÇÒ¼ö ¾ø½À´Ï´Ù.";
+ Text[ turkish ] = "Özellik tanýmlanamadý";
+ 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 impossível determinar a propriedade" ;
+ Text [ french ] = "Impossible de déterminer la propriété" ;
+ 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 bestämmas" ;
+ Text [ finnish ] = "Unable to get property" ;
+ Text [ english_us ] = "Unable to determine property" ;
+ Text[ chinese_simplified ] = "ÎÞ·¨¶Á³öÊôÐÔ";
+ Text[ russian ] = "Ñâîéñòâî îïðåäåëèòü íåâîçìîæíî";
+ Text[ polish ] = "W³aœciwoœæ nie mog³a zostaæ zdefiniowana";
+ Text[ japanese ] = "‘®«‚ÍŠm‚©‚߂邱‚Æ‚ª‚Å‚«‚Ü‚¹‚ñ‚Å‚µ‚½";
+ Text[ chinese_traditional ] = "µLªkŪ¥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 ] = "Símbolo inesperado: $(ARG1)" ;
+ Text [ french ] = "Symbole imprévu : $(ARG1)" ;
+ Text [ dutch ] = "Onverwacht symbool: $(ARG1)" ;
+ Text [ spanish ] = "Símbolo inesperado: $(ARG1)" ;
+ Text [ danish ] = "Uventet symbol: $(ARG1)" ;
+ Text [ swedish ] = "Oväntad 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 ] = "•s“K“–‚ȼÝÎÞÙ: $(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 ] = "Förväntad: $(ARG1)" ;
+ Text [ finnish ] = "Expected: $(ARG1)" ;
+ Text [ english_us ] = "Expected: $(ARG1)" ;
+ Text[ chinese_simplified ] = "µÈ´ý£º$(ARG1)";
+ Text[ russian ] = "Ïðåäâèäèòñÿ: $(ARG1)";
+ Text[ polish ] = "Oczekiwany: $(ARG1)";
+ Text[ japanese ] = "•K—v€–Ú: $(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 ] = "Símbolo esperado" ;
+ Text [ french ] = "Symbole requis" ;
+ Text [ dutch ] = "Symbool verwacht" ;
+ Text [ spanish ] = "Símbolo esperado" ;
+ Text [ danish ] = "Symbol forventes" ;
+ Text [ swedish ] = "Symbol förväntad" ;
+ Text [ finnish ] = "Symbol expected" ;
+ Text [ english_us ] = "Symbol expected" ;
+ Text[ chinese_simplified ] = "µÈ´ýͼ±ê";
+ Text[ russian ] = "Ïðåäâèäåííûé ñèìâîë";
+ Text[ polish ] = "Oczekiwany symbol";
+ Text[ japanese ] = "¼ÝÎÞÙ‚ª•K—v‚Å‚·";
+ 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 ] = "Variável esperada" ;
+ Text [ french ] = "Variable requise" ;
+ Text [ dutch ] = "Variabele verwacht" ;
+ Text [ spanish ] = "Se requiere una variable" ;
+ Text [ danish ] = "Variabel forventes" ;
+ Text [ swedish ] = "Variabel förväntad" ;
+ Text [ finnish ] = "Variable expected" ;
+ Text [ english_us ] = "Variable expected" ;
+ Text[ chinese_simplified ] = "µÈ´ý±äÁ¿";
+ Text[ russian ] = "Ïðåäâèäåííàÿ ïåðåìåííàÿ";
+ Text[ polish ] = "Zmienna oczekiwana";
+ Text[ japanese ] = "•Ï”‚ª•K—v‚Å‚·";
+ Text[ chinese_traditional ] = "µ¥«ÝÅܶq";
+ Text[ arabic ] = "ãÊæÞÚ ãÊÛíÑÉ";
+ Text[ dutch ] = "Variabele verwacht";
+ Text[ chinese_simplified ] = "µÈ´ý±äÁ¿";
+ Text[ greek ] = "ÁíáìÝíåôáé ìåôáâëçôÞ";
+ Text[ korean ] = "¿¹ÃøµÈ º¯¼ö";
+ Text[ turkish ] = "Deðiþken 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 förväntad" ;
+ Text [ finnish ] = "Label expected" ;
+ Text [ english_us ] = "Label expected" ;
+ Text[ chinese_simplified ] = "µÈ´ý±êºÅ";
+ Text[ russian ] = "Îæèäàåòñÿ ýòèêåòà";
+ Text[ polish ] = "Oczekiwana etykieta";
+ Text[ japanese ] = "×ÍÞÙ‚ª•K—v‚Å‚·";
+ 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 ] = "Impossível 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 ] = "Værdien kan ikke tildeles" ;
+ Text [ swedish ] = "Värdet kan inte tilldelas" ;
+ Text [ finnish ] = "Cannot set value" ;
+ Text [ english_us ] = "Value cannot be applied" ;
+ Text[ chinese_simplified ] = "ÎÞ·¨Ö¸¶¨ÊýÖµ";
+ Text[ russian ] = "Ïðèìåíèòü çííà÷åíèå íåâîçìîæíî";
+ Text[ polish ] = "Nie mo¿na zastosowaæ wartoœci";
+ Text[ japanese ] = "”’l‚ÍŠ„‚è“–‚Ä‚ç‚ê‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "µLªk«ü©w¼Æ­È";
+ Text[ arabic ] = "áÇ íãßä ÊØÈíÞ ÇáÞíãÉ";
+ Text[ dutch ] = "Waarde kan niet worden toegewezen";
+ Text[ chinese_simplified ] = "ÎÞ·¨Ö¸¶¨ÊýÖµ";
+ Text[ greek ] = "Äåí åßíáé äõíáôüí íá ãßíåé åöáñìïãÞ ôçò ôéìÞò";
+ Text[ korean ] = "°ªÀÌ Àû¿ëµÉ ¼ö ¾ø½À´Ï´Ù.";
+ Text[ turkish ] = "Deðer atanamýyor";
+ 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 ] = "Variável $(ARG1) já definida" ;
+ Text [ french ] = "La variable $(ARG1) est déjà définie" ;
+ 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 ] = "¤w¸g©w¸q¤FÅܶq $(ARG1)";
+ Text[ arabic ] = "ÇáãÊÛíÑÉ $(ARG1) ãÚÑøÝÉ ãÓÈÞÇð";
+ Text[ dutch ] = "Variabele $(ARG1) reeds gedefinieerd";
+ Text[ chinese_simplified ] = "ÒѾ­¶¨ÒåÁ˱äÁ¿ $(ARG1)";
+ Text[ greek ] = "Ç ìåôáâëçôÞ $(ARG1) Ý÷åé Þäç ïñéóôåß";
+ Text[ korean ] = "º¯¼ö$(ARG1)´Â ÀÌ¹Ì Á¤ÀǵǾîÀÖ½À´Ï´Ù.";
+ Text[ turkish ] = "Deðiþken $(ARG1) tanýmlanmýþ 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 função $(ARG1) já definidos" ;
+ Text [ french ] = "La sous-procédure ou procédure fonctionnelle $(ARG1) est déjà définie" ;
+ Text [ dutch ] = "Sub- of functieprocedure $(ARG1) reeds gedefinieerd" ;
+ Text [ spanish ] = "El procedimiento de función 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 podrzêdna lub funkcyjna ju¿ zosta³a zdefiniowana $(ARG1)";
+ Text[ japanese ] = "Sub‚Ü‚½‚ÍFunctionÌßÛ¼°¼Þ¬$(ARG1)‚Í‚·‚Å‚É’è‹`‚³‚ê‚Ä‚¢‚Ü‚·";
+ Text[ chinese_traditional ] = "¤w¸g©w¸q¤F¤À¹Lµ{©Î¨ç¼Æ¹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 iþlev yordamý $(ARG1) tanýmlanmýþ 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 déjà définie" ;
+ 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) zosta³a ju¿ zdefiniowana";
+ Text[ japanese ] = "×ÍÞÙ$(ARG1)‚Í‚·‚Å‚É’è‹`‚³‚ê‚Ä‚¢‚Ü‚·";
+ Text[ chinese_traditional ] = "¤w¸g©w¸q¤F¼Ð°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) tanýmlanmýþ 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 ] = "Variável $(ARG1) não 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 ] = "Deðiþken $(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 função $(ARG1) não encontrados" ;
+ Text [ french ] = "Array ou procédure $(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 ] = "¨S¦³§ä¨ì¦æ¦C©Î¹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) não encontrado" ;
+ Text [ french ] = "Procédure $(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 ] = "¨S¦³§ä¨ì¹Lµ{$(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 ] = "Rótulo $(ARG1) indefinido" ;
+ Text [ french ] = "L'étiquette $(ARG1) n'est pas définie" ;
+ 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 ] = "©|¥¼©w¸q¼Ð°O$(ARG1)";
+ Text[ arabic ] = "ÛíÑ ãÚÑÝÉ $(ARG1) ÇáÚäæäÉ";
+ Text[ dutch ] = "Label $(ARG1) ongedefinieerd";
+ Text[ chinese_simplified ] = "ÉÐ䶨Òå±ê¼Ç $(ARG1)";
+ Text[ greek ] = "Äåí ïñßóôçêå ç åðéãñáöÞ $(ARG1)";
+ Text[ korean ] = "¶óº§ $(ARG1) ÀÌ Á¤ÀǵÇÁö ¾Ê¾Ò½À´Ï´Ù.";
+ Text[ turkish ] = "Etiket $(ARG1) tanýmlanmadý";
+ 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 données $(ARG1) inconnu" ;
+ Text [ dutch ] = "Onbekend gegevenstype $(ARG1)" ;
+ Text [ spanish ] = "Tipo de datos $(ARG1) desconocido" ;
+ Text [ danish ] = "Ukendt datatype $(ARG1)" ;
+ Text [ swedish ] = "Okänd 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 ] = "Saída 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) förväntat" ;
+ 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)‚ÌI—¹‚ª•K—v‚Å‚·";
+ Text[ chinese_traditional ] = "µ¥­Ô°h¥X$(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 instruções ainda incompleto: falta $(ARG1)" ;
+ Text [ french ] = "Bloc d'instructions encore ouvert : $(ARG1) fait défaut" ;
+ 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 ] = "Açýk 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 parênteses" ;
+ Text [ french ] = "Erreur de parenthèses" ;
+ Text [ dutch ] = "Fout in het plaatsen van haakjes" ;
+ Text [ spanish ] = "Los paréntesis 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 ] = "B³¹d w ustawianiu nawiasów";
+ 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 ] = "Ayraçlar 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 símbolo $(ARG1) já tem outra definição" ;
+ Text [ french ] = "Le symbole $(ARG1) a déjà reçu une autre définition" ;
+ Text [ dutch ] = "Symbool $(ARG1) reeds anders gedefinieerd" ;
+ Text [ spanish ] = "El símbolo $(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 ] = "¤w¸g¥t¦æ©w¸q¤F¹Ï¥Ü$(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 biçimde tanýmlanmýþ 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 parâmetros não correspondem ao procedimento" ;
+ Text [ french ] = "Les paramètres ne correspondent pas à la procédure" ;
+ Text [ dutch ] = "Parameters passen niet bij procedure" ;
+ Text [ spanish ] = "Los parámetros 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Åܶq©M¹Lµ{¤£¤Ç°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? Ung³ltiges Zeichen in Zahl : Ungltiges Zeichen in Zahl */
+ Text = "Ungültiges 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 número" ;
+ Text [ french ] = "Le nombre contient un caractère incorrect" ;
+ Text [ dutch ] = "Ongeldig teken in getal" ;
+ Text [ spanish ] = "Carácter incorrecto en el número" ;
+ 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 ] = "Nieprawid³owy znak w liczbie";
+ Text[ japanese ] = "”‚É–³Œø‚È•¶Žš";
+ Text[ chinese_traditional ] = "¦b¼Æ¦r¤º§t¦³µL®Äªº¦r¤¸";
+ Text[ arabic ] = "ÍÑÝ ÛíÑ ÕÇáÍ Ýí ÇáÑÞã";
+ Text[ dutch ] = "Ongeldig teken in getal";
+ Text[ chinese_simplified ] = "Êý×ÖÄÚº¬ÓÐÎÞЧµÄ×Ö·û";
+ Text[ greek ] = "Ìç Ýãêõñïò ÷áñáêôÞñáò óôïí áñèéìü";
+ Text[ korean ] = "¼ýÀÚ¿¡ À¯È¿ÇÏÁö ¾ÊÀº ¹®ÀÚ";
+ Text[ turkish ] = "Numara geçersiz bir karakter içeriyor";
+ 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 ] = "Necessário 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 måste dimensioneras" ;
+ Text [ finnish ] = "Array needs dimensioning" ;
+ Text [ english_us ] = "Array must be dimensioned" ;
+ Text[ chinese_simplified ] = "±ØÐëΪÊý×鶨³ß¶È";
+ Text[ russian ] = "Íåîáõîäèìî çàäàòü ðàçìåðíîñòü ìàññèâà";
+ Text[ polish ] = "Macierz nale¿y zwymiarowaæ";
+ Text[ japanese ] = "”z—ñ‚ÍŽŸŒ³‰»‚³‚ê‚È‚¯‚ê‚΂Ȃè‚Ü‚¹‚ñ";
+ Text[ chinese_traditional ] = "¦æ¦C¥²¶·©w¤Ø«×";
+ Text[ arabic ] = "íÌÈ ÊÚííä ÃÈÚÇÏ ÇáÕÝíÝ";
+ Text[ dutch ] = "Array moet worden gedimensioneerd";
+ Text[ chinese_simplified ] = "±ØÐëΪÊý×鶨³ß¶È";
+ Text[ greek ] = "ÐñÝðåé íá ïñéóôïýí ïé äéáóôÜóåéò ôçò ìÞôñáò";
+ Text[ korean ] = "¹è¿­Àº ¹Ýµå½Ã ¼öÄ¡°¡ ÀÖ¾î¾ßÇÑ´Ù.";
+ Text[ turkish ] = "Dizinin boyutlandýrýlmasý 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 unzulõssig : $(ARG1) innerhalb einer Prozedur unzul§ssig */
+ Text = "$(ARG1) innerhalb einer Prozedur unzulässig" ;
+ 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) não é permitido dentro de um procedimento" ;
+ Text [ french ] = "$(ARG1) interdit dans une procédure" ;
+ 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 tillåtet 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) geçerli deðil";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NOT_IN_MAIN & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? $(ARG1) au˜erhalb einer Prozedur unzulõssig : $(ARG1) auÿerhalb einer Prozedur unzul§ssig */
+ Text = "$(ARG1) außerhalb einer Prozedur unzulässig" ;
+ 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) não é permitido fora de um procedimento" ;
+ Text [ french ] = "$(ARG1) interdit en dehors d'une procédure" ;
+ 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 tillåtet utanför 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 dýþýnda $(ARG1) geçerli deðil";
+ 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 dimensões indicadas não combinam" ;
+ Text [ french ] = "Les dimensions indiquées 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 stämmer 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 arasýnda uyuþmazlýk";
+ 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 ] = "Opção desconhecida: $(ARG1)" ;
+ Text [ french ] = "Option inconnue : $(ARG1)" ;
+ Text [ dutch ] = "Onbekende optie: $(ARG1)" ;
+ Text [ spanish ] = "Opción 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 seçenek: $(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é redéfinie" ;
+ 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 ] = "Sta³a $(ARG1) ponownie zdefiniowana";
+ Text[ japanese ] = "’è”$(ARG1)‚ÍÄ’è‹`‚³‚ê‚Ü‚·";
+ Text[ chinese_traditional ] = "­«·s©w¸q±`¼Æ$(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 tanýmlandý";
+ 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 för stort" ;
+ Text [ finnish ] = "Program is too large" ;
+ Text [ english_us ] = "Program too large" ;
+ Text[ chinese_simplified ] = "³ÌÐòÌ«´ó";
+ Text[ russian ] = "Ïðîãðàììà ñëèøêîì áîëüøàÿ";
+ Text[ polish ] = "Program jest za du¿y";
+ 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 büyük";
+ Text[ language_user1 ] = " ";
+ };
+ String SbERR_NO_STRINGS_ARRAYS & ERRCODE_RES_MASK
+ {
+ /* ### ACHTUNG: Neuer Text in Resource? Strings oder Arrays unzulõssig : Strings oder Arrays unzul§ssig */
+ Text = "Strings oder Arrays unzulässig" ;
+ 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 ] = "Séries de caracteres ou matrizes não permitidas" ;
+ Text [ french ] = "Strings ou Arrays inadmissibles" ;
+ Text [ dutch ] = "Strings of arrays niet toegestaan" ;
+ Text [ spanish ] = "No están permitidos strings o arrays" ;
+ Text [ danish ] = "Strenge eller arrays er ikke tilladte" ;
+ Text [ swedish ] = "Strings eller arrays ej tillåtna" ;
+ Text [ finnish ] = "Sorry, no strings or arrays allowed" ;
+ Text [ english_us ] = "Strings or arrays not permitted" ;
+ Text[ chinese_simplified ] = "²»ÔÊÐí×Ö´®»òÊý×é";
+ Text[ russian ] = "Ñòðîêè çíàêîâ èëè ìàññèâû íåäîïóñòèìû";
+ Text[ polish ] = "Ciagi znaków 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 geçerli deðil";
+ 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 ] = "Não 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¦³¥]§t¦bVB 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 deðil";
+ 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 execução 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 avbröts" ;
+ Text [ finnish ] = "Stopped currently running macro" ;
+ Text [ english_us ] = "The macro running has been interrupted" ;
+ Text[ chinese_simplified ] = "ÖжÏÔËÐкꡣ";
+ Text[ russian ] = "Âûïîëíåíèå ìàêðîñà ïðåðâàíî";
+ Text[ polish ] = "Wykonywane makro zosta³o 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 ] = "Yürütülen 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 referência não será guardada: ";
+ Text [ danish ] = "Referencen bliver ikke gemt: ";
+ Text [ french ] = "Impossible d'enregistrer la référence : ";
+ 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 ] = "Odwo³anie nie zosta³o zapisane: ";
+ Text[ japanese ] = "ŽQÆ‚Í•Û‘¶‚³‚ê‚Ü‚¹‚ñ: ";
+ Text[ chinese_traditional ] = "¤£Àx¦s°Ñ·Ó¡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 referÛncia nÒo serß guardada: " ;
+ Text [ french ] = "RÚfÚrence non enregistrÚe : " ;
+ 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 bibliothèque '$(ARG1)'" ;
+ Text [ dutch ] = "Fout bij laden van bibliotheek '$(ARG1)'" ;
+ Text [ swedish ] = "Fel vid laddning av bibliotek '$(ARG1)'" ;
+ Text [ danish ] = "Fejl ved indlæsning 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 ] = "B³¹d 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ýðý yükleme sýrasýnda 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 bibliothèque : '$(ARG1)'" ;
+ Text [ swedish ] = "Fel vid sparandet av bibliotek: '$(ARG1)'" ;
+ Text [ danish ] = "Fejl under forsøg 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 ] = "B³¹d przy zapisie biblioteki '$(ARG1)'";
+ Text[ japanese ] = "ײÌÞ×Ø‚Ì•Û‘¶‚ÌÛ‚Ì´×°: '$(ARG1)'";
+ Text[ chinese_traditional ] = "Àx¦sµ{¦¡®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 sýrasýnda 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 geïnitialiseerd" ;
+ 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 från filen '$(ARG1)' kunde inte initialiseras" ;
+ Text [ danish ] = "Det var ikke muligt at initialisere BASIC fra filen '$(ARG1)'" ;
+ Text [ portuguese ] = "Impossível 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 móg³ zostaæ zainicjowany";
+ Text[ japanese ] = "̧²Ù '$(ARG1)'‚©‚ç‚ÌBASIC‚͉Šú‰»‚Å‚«‚Ü‚¹‚ñ‚Å‚µ‚½";
+ Text[ chinese_traditional ] = "µLªk±qÀÉ®×'$(ARG1)'ªì©l¤ÆBASIC";
+ Text[ arabic ] = "'$(ARG1)' ãä ÇáãáÝ BASIC ÊÚÐÑ ÊåíÆÉ";
+ Text[ dutch ] = "BASIC in bestand '$(ARG1)' kon niet worden geïnitialiseerd";
+ Text[ chinese_simplified ] = "ÎÞ·¨´ÓÎļþ'$(ARG1)' ³õʼ»¯ BASIC";
+ Text[ greek ] = "Äåí Þôáí äõíáôüí íá ãßíåé áíáãíþñéóç ôïõ BASIC áðü ôï áñ÷åßï '$(ARG1)'.";
+ Text[ korean ] = "ÆÄÀÏ $(ARG1) ·Î ºÎÅÍÀÇ BASICÀº ÃʱâÈ­ µÇÁö¾Ê¾Ò½À´Ï´Ù.";
+ Text[ turkish ] = "'$(ARG1)' dosyasýndan 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 forsøg 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 ] = "B³¹d przy zapisie biblioteki BASIC: '$(ARG1)'";
+ Text[ japanese ] = "BASIC‚Ì•Û‘¶‚ÌÛ‚Ì´×°: '$(ARG1)'";
+ Text[ chinese_traditional ] = "Àx¦sBASIC®Éµ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 sýrasýnda 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 bibliothèque" ;
+ 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 ] = "B³¹d 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ýðý kaldýrma sýrasýnda 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 bibliothèque de la mémoire." ;
+ Text [ swedish ] = "Biblioteket kunde inte tas bort från minnet." ;
+ Text [ danish ] = "Det var ikke muligt at slette biblioteket fra hukommelsen." ;
+ Text [ portuguese ] = "Foi impossível remover a biblioteca da memória." ;
+ Text [ portuguese_brazilian ] = "Die Bibliothek konnte nicht aus dem Speicher entfernt werden." ;
+ Text[ chinese_simplified ] = "ÎÞ·¨´ÓÄÚ´æÇå³ý³ÌÐò¿â";
+ Text[ russian ] = "Óäàëèòü áèáëèîòåêó èç ïàìÿòè íåâîçìîæíî.";
+ Text[ polish ] = "Biblioteki nie mo¿na by³o usun¹æ z pamiêci.";
+ Text[ japanese ] = "ײÌÞ×Ø‚ÍÒÓØ‚©‚ç휂ł«‚Ü‚¹‚ñ‚Å‚µ‚½B";
+ Text[ chinese_traditional ] = "µ{¦¡®wµLªk±q°O¾ÐÅ餺²M°£¡C";
+ Text[ arabic ] = ".ÊÚÐÑ ÍÐÝ ÇáãßÊÈÉ ãä ÇáÐÇßÑÉ";
+ Text[ dutch ] = "De bibliotheek kon niet uit het geheugen worden verwijderd.";
+ Text[ chinese_simplified ] = "ÎÞ·¨´ÓÄÚ´æÇå³ý³ÌÐò¿â";
+ Text[ greek ] = "Äåí Þôáí äõíáôüí íá ãßíåé äéáãñáöÞ ôçò âéâëéïèÞêçò áðü ôç ìíÞìç";
+ Text[ korean ] = "¶óÀ̺귯¸®°¡ ¸Þ¸ð¸®·Î ºÎÅÍ »èÁ¦µÉ ¼ö ¾ø½À´Ï´Ù.";
+ Text[ turkish ] = "Kitaplýk bellekten silinemedi.";
+ Text[ language_user1 ] = " ";
+};
diff --git a/basic/source/classes/sbintern.cxx b/basic/source/classes/sbintern.cxx
new file mode 100644
index 0000000000..3dce2e0bef
--- /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 0000000000..a0e4fc4b9e
--- /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 0000000000..18e1783c42
--- /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 müssen 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 zurücksetzen
+ }
+ 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 v1.2.3 (git 2.39.1) at 2024-06-22 08:09:56 +0000