| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_basic.hxx" | |
| #include <tools/errcode.hxx> | |
| #ifndef _APP_HXX //autogen | |
| #include <vcl/svapp.hxx> | |
| #endif | |
| #include <basic/sbx.hxx> | |
| class SbxSimpleCharClass | |
| { | |
| public: | |
| sal_Bool isAlpha( sal_Unicode c ) const | |
| { | |
| sal_Bool bRet = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); | |
| return bRet; | |
| } | |
| sal_Bool isDigit( sal_Unicode c ) const | |
| { | |
| sal_Bool bRet = (c >= '0' && c <= '9'); | |
| return bRet; | |
| } | |
| sal_Bool isAlphaNumeric( sal_Unicode c ) const | |
| { | |
| sal_Bool bRet = isDigit( c ) || isAlpha( c ); | |
| return bRet; | |
| } | |
| }; | |
| static SbxVariable* Element | |
| ( SbxObject* pObj, SbxObject* pGbl, const xub_Unicode** ppBuf, | |
| SbxClassType, const SbxSimpleCharClass& rCharClass ); | |
| static const xub_Unicode* SkipWhitespace( const xub_Unicode* p ) | |
| { | |
| while( *p && ( *p == ' ' || *p == '\t' ) ) | |
| p++; | |
| return p; | |
| } | |
| // Scannen eines Symbol. Das Symbol wird in rSym eingetragen, der Returnwert | |
| // ist die neue Scanposition. Bei Fehlern ist das Symbol leer. | |
| static const xub_Unicode* Symbol( const xub_Unicode* p, XubString& rSym, const SbxSimpleCharClass& rCharClass ) | |
| { | |
| sal_uInt16 nLen = 0; | |
| // Haben wir ein Sondersymbol? | |
| if( *p == '[' ) | |
| { | |
| rSym = ++p; | |
| while( *p && *p != ']' ) | |
| p++, nLen++; | |
| p++; | |
| } | |
| else | |
| { | |
| // Ein Symbol muss mit einem Buchstaben oder einem Underline beginnen | |
| if( !rCharClass.isAlpha( *p ) && *p != '_' ) | |
| SbxBase::SetError( SbxERR_SYNTAX ); | |
| else | |
| { | |
| rSym = p; | |
| // Dann darf es Buchstaben, Zahlen oder Underlines enthalten | |
| while( *p && (rCharClass.isAlphaNumeric( *p ) || *p == '_') ) | |
| p++, nLen++; | |
| // BASIC-Standard-Suffixe werden ignoriert | |
| if( *p && (*p == '%' || *p == '&' || *p == '!' || *p == '#' || *p == '$' ) ) | |
| p++; | |
| } | |
| } | |
| rSym.Erase( nLen ); | |
| return p; | |
| } | |
| // Qualifizierter Name. Element.Element.... | |
| static SbxVariable* QualifiedName | |
| ( SbxObject* pObj, SbxObject* pGbl, const xub_Unicode** ppBuf, SbxClassType t ) | |
| { | |
| static SbxSimpleCharClass aCharClass; | |
| SbxVariableRef refVar; | |
| const xub_Unicode* p = SkipWhitespace( *ppBuf ); | |
| if( aCharClass.isAlpha( *p ) || *p == '_' || *p == '[' ) | |
| { | |
| // Element einlesen | |
| refVar = Element( pObj, pGbl, &p, t, aCharClass ); | |
| while( refVar.Is() && (*p == '.' || *p == '!') ) | |
| { | |
| // Es folgt noch ein Objektelement. Das aktuelle Element | |
| // muss also ein SBX-Objekt sein oder liefern! | |
| pObj = PTR_CAST(SbxObject,(SbxVariable*) refVar); | |
| if( !pObj ) | |
| // Dann muss es ein Objekt liefern | |
| pObj = PTR_CAST(SbxObject,refVar->GetObject()); | |
| refVar.Clear(); | |
| if( !pObj ) | |
| break; | |
| p++; | |
| // Und das naechste Element bitte | |
| refVar = Element( pObj, pGbl, &p, t, aCharClass ); | |
| } | |
| } | |
| else | |
| SbxBase::SetError( SbxERR_SYNTAX ); | |
| *ppBuf = p; | |
| if( refVar.Is() ) | |
| refVar->AddRef(); | |
| return refVar; | |
| } | |
| // Einlesen eines Operanden. Dies kann eine Zahl, ein String oder | |
| // eine Funktion (mit optionalen Parametern) sein. | |
| static SbxVariable* Operand | |
| ( SbxObject* pObj, SbxObject* pGbl, const xub_Unicode** ppBuf, sal_Bool bVar ) | |
| { | |
| static SbxSimpleCharClass aCharClass; | |
| SbxVariableRef refVar( new SbxVariable ); | |
| const xub_Unicode* p = SkipWhitespace( *ppBuf ); | |
| if( !bVar && ( aCharClass.isDigit( *p ) | |
| || ( *p == '.' && aCharClass.isDigit( *( p+1 ) ) ) | |
| || *p == '-' | |
| || *p == '&' ) ) | |
| { | |
| // Eine Zahl kann direkt eingescant werden! | |
| sal_uInt16 nLen; | |
| if( !refVar->Scan( XubString( p ), &nLen ) ) | |
| refVar.Clear(); | |
| else | |
| p += nLen; | |
| } | |
| else if( !bVar && *p == '"' ) | |
| { | |
| // Ein String | |
| XubString aString; | |
| p++; | |
| for( ;; ) | |
| { | |
| // Das ist wohl ein Fehler | |
| if( !*p ) | |
| return NULL; | |
| // Doppelte Quotes sind OK | |
| if( *p == '"' ) | |
| if( *++p != '"' ) | |
| break; | |
| aString += *p++; | |
| } | |
| refVar->PutString( aString ); | |
| } | |
| else | |
| refVar = QualifiedName( pObj, pGbl, &p, SbxCLASS_DONTCARE ); | |
| *ppBuf = p; | |
| if( refVar.Is() ) | |
| refVar->AddRef(); | |
| return refVar; | |
| } | |
| // Einlesen einer einfachen Term. Die Operatoren +, -, * und / | |
| // werden unterstuetzt. | |
| static SbxVariable* MulDiv( SbxObject* pObj, SbxObject* pGbl, const xub_Unicode** ppBuf ) | |
| { | |
| const xub_Unicode* p = *ppBuf; | |
| SbxVariableRef refVar( Operand( pObj, pGbl, &p, sal_False ) ); | |
| p = SkipWhitespace( p ); | |
| while( refVar.Is() && ( *p == '*' || *p == '/' ) ) | |
| { | |
| xub_Unicode cOp = *p++; | |
| SbxVariableRef refVar2( Operand( pObj, pGbl, &p, sal_False ) ); | |
| if( refVar2.Is() ) | |
| { | |
| // temporaere Variable! | |
| SbxVariable* pVar = refVar; | |
| pVar = new SbxVariable( *pVar ); | |
| refVar = pVar; | |
| if( cOp == '*' ) | |
| *refVar *= *refVar2; | |
| else | |
| *refVar /= *refVar2; | |
| } | |
| else | |
| { | |
| refVar.Clear(); | |
| break; | |
| } | |
| } | |
| *ppBuf = p; | |
| if( refVar.Is() ) | |
| refVar->AddRef(); | |
| return refVar; | |
| } | |
| static SbxVariable* PlusMinus( SbxObject* pObj, SbxObject* pGbl, const xub_Unicode** ppBuf ) | |
| { | |
| const xub_Unicode* p = *ppBuf; | |
| SbxVariableRef refVar( MulDiv( pObj, pGbl, &p ) ); | |
| p = SkipWhitespace( p ); | |
| while( refVar.Is() && ( *p == '+' || *p == '-' ) ) | |
| { | |
| xub_Unicode cOp = *p++; | |
| SbxVariableRef refVar2( MulDiv( pObj, pGbl, &p ) ); | |
| if( refVar2.Is() ) | |
| { | |
| // temporaere Variable! | |
| SbxVariable* pVar = refVar; | |
| pVar = new SbxVariable( *pVar ); | |
| refVar = pVar; | |
| if( cOp == '+' ) | |
| *refVar += *refVar2; | |
| else | |
| *refVar -= *refVar2; | |
| } | |
| else | |
| { | |
| refVar.Clear(); | |
| break; | |
| } | |
| } | |
| *ppBuf = p; | |
| if( refVar.Is() ) | |
| refVar->AddRef(); | |
| return refVar; | |
| } | |
| static SbxVariable* Assign( SbxObject* pObj, SbxObject* pGbl, const xub_Unicode** ppBuf ) | |
| { | |
| const xub_Unicode* p = *ppBuf; | |
| SbxVariableRef refVar( Operand( pObj, pGbl, &p, sal_True ) ); | |
| p = SkipWhitespace( p ); | |
| if( refVar.Is() ) | |
| { | |
| if( *p == '=' ) | |
| { | |
| // Nur auf Props zuweisen! | |
| if( refVar->GetClass() != SbxCLASS_PROPERTY ) | |
| { | |
| SbxBase::SetError( SbxERR_BAD_ACTION ); | |
| refVar.Clear(); | |
| } | |
| else | |
| { | |
| p++; | |
| SbxVariableRef refVar2( PlusMinus( pObj, pGbl, &p ) ); | |
| if( refVar2.Is() ) | |
| { | |
| SbxVariable* pVar = refVar; | |
| SbxVariable* pVar2 = refVar2; | |
| *pVar = *pVar2; | |
| pVar->SetParameters( NULL ); | |
| } | |
| } | |
| } | |
| else | |
| // Einfacher Aufruf: einmal aktivieren | |
| refVar->Broadcast( SBX_HINT_DATAWANTED ); | |
| } | |
| *ppBuf = p; | |
| if( refVar.Is() ) | |
| refVar->AddRef(); | |
| return refVar; | |
| } | |
| // Einlesen eines Elements. Dies ist ein Symbol, optional gefolgt | |
| // von einer Parameterliste. Das Symbol wird im angegebenen Objekt | |
| // gesucht und die Parameterliste wird ggf. angefuegt. | |
| static SbxVariable* Element | |
| ( SbxObject* pObj, SbxObject* pGbl, const xub_Unicode** ppBuf, | |
| SbxClassType t, const SbxSimpleCharClass& rCharClass ) | |
| { | |
| XubString aSym; | |
| const xub_Unicode* p = Symbol( *ppBuf, aSym, rCharClass ); | |
| SbxVariableRef refVar; | |
| if( aSym.Len() ) | |
| { | |
| sal_uInt16 nOld = pObj->GetFlags(); | |
| if( pObj == pGbl ) | |
| pObj->SetFlag( SBX_GBLSEARCH ); | |
| refVar = pObj->Find( aSym, t ); | |
| pObj->SetFlags( nOld ); | |
| if( refVar.Is() ) | |
| { | |
| refVar->SetParameters( NULL ); | |
| // folgen noch Parameter? | |
| p = SkipWhitespace( p ); | |
| if( *p == '(' ) | |
| { | |
| p++; | |
| SbxArrayRef refPar = new SbxArray; | |
| sal_uInt16 nArg = 0; | |
| // Wird sind mal relaxed und akzeptieren auch | |
| // das Zeilen- oder Komandoende als Begrenzer | |
| // Parameter immer global suchen! | |
| while( *p && *p != ')' && *p != ']' ) | |
| { | |
| SbxVariableRef refArg = PlusMinus( pGbl, pGbl, &p ); | |
| if( !refArg ) | |
| { | |
| // Fehler beim Parsing | |
| refVar.Clear(); break; | |
| } | |
| else | |
| { | |
| // Man kopiere den Parameter, damit | |
| // man den aktuellen Zustand hat (loest auch | |
| // den Aufruf per Zugriff aus) | |
| SbxVariable* pArg = refArg; | |
| refPar->Put( new SbxVariable( *pArg ), ++nArg ); | |
| } | |
| p = SkipWhitespace( p ); | |
| if( *p == ',' ) | |
| p++; | |
| } | |
| if( *p == ')' ) | |
| p++; | |
| if( refVar.Is() ) | |
| refVar->SetParameters( refPar ); | |
| } | |
| } | |
| else | |
| SbxBase::SetError( SbxERR_NO_METHOD ); | |
| } | |
| *ppBuf = p; | |
| if( refVar.Is() ) | |
| refVar->AddRef(); | |
| return refVar; | |
| } | |
| // Hauptroutine | |
| SbxVariable* SbxObject::Execute( const XubString& rTxt ) | |
| { | |
| SbxVariable* pVar = NULL; | |
| const xub_Unicode* p = rTxt.GetBuffer(); | |
| for( ;; ) | |
| { | |
| p = SkipWhitespace( p ); | |
| if( !*p ) | |
| break; | |
| if( *p++ != '[' ) | |
| { | |
| SetError( SbxERR_SYNTAX ); break; | |
| } | |
| pVar = Assign( this, this, &p ); | |
| if( !pVar ) | |
| break; | |
| p = SkipWhitespace( p ); | |
| if( *p++ != ']' ) | |
| { | |
| SetError( SbxERR_SYNTAX ); break; | |
| } | |
| } | |
| return pVar; | |
| } | |
| SbxVariable* SbxObject::FindQualified( const XubString& rName, SbxClassType t ) | |
| { | |
| SbxVariable* pVar = NULL; | |
| const xub_Unicode* p = rName.GetBuffer(); | |
| p = SkipWhitespace( p ); | |
| if( !*p ) | |
| return NULL; | |
| pVar = QualifiedName( this, this, &p, t ); | |
| p = SkipWhitespace( p ); | |
| if( *p ) | |
| SetError( SbxERR_SYNTAX ); | |
| return pVar; | |
| } |