| /************************************************************** |
| * |
| * 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; |
| } |
| |
