| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef _SYMTBL_HXX |
| #define _SYMTBL_HXX |
| |
| #include <svl/svarray.hxx> |
| #include <tools/string.hxx> |
| #include <basic/sbxdef.hxx> |
| #include <basic/sbdef.hxx> |
| |
| class SbiSymDef; // Basisklasse |
| class SbiProcDef; // Prozedur |
| class SbiConstDef; // Konstante |
| class SbiSymPool; // Symbol-Pool |
| class SbiStringPool; // gepoolte Strings |
| |
| class SvStream; |
| class SbiParser; |
| |
| enum SbiSymScope { SbLOCAL, SbPARAM, SbPUBLIC, SbGLOBAL, SbRTL }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| // Der String-Pool nimmt String-Eintraege auf und sorgt dafuer, |
| // dass sie nicht doppelt vorkommen. |
| |
| SV_DECL_PTRARR_DEL(SbiStrings,String*,5,5) |
| |
| class SbiStringPool { // String-Pool |
| SbiStrings aData; // Daten |
| String aEmpty; // for convenience |
| SbiParser* pParser; // der Parser |
| public: |
| SbiStringPool( SbiParser* ); |
| ~SbiStringPool(); |
| sal_uInt16 GetSize() const { return aData.Count(); } |
| // AB 8.4.1999, Default wegen #64236 auf sal_True geaendert |
| // Wenn der Bug sauber behoben ist, wieder auf sal_False aendern. |
| short Add( const String&, sal_Bool=sal_True ); |
| short Add( double, SbxDataType ); |
| const String& Find( sal_uInt16 ) const; |
| SbiParser* GetParser() { return pParser; } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| SV_DECL_PTRARR_DEL(SbiSymbols,SbiSymDef*,5,5) |
| |
| class SbiSymPool { // Symbol-Pool |
| friend class SbiSymDef; |
| friend class SbiProcDef; |
| protected: |
| SbiStringPool& rStrings; // verwendeter Stringpool |
| SbiSymbols aData; // Daten |
| SbiSymPool* pParent; // uebergeordneter Symbol-Pool |
| SbiParser* pParser; // der Parser |
| SbiSymScope eScope; // Scope des Pools |
| sal_uInt16 nProcId; // aktuelles ProcId fuer STATIC-Variable |
| sal_uInt16 nCur; // Iterator |
| public: |
| SbiSymPool( SbiStringPool&, SbiSymScope ); |
| ~SbiSymPool(); |
| |
| void Clear(); |
| |
| void SetParent( SbiSymPool* p ) { pParent = p; } |
| void SetProcId( short n ) { nProcId = n; } |
| sal_uInt16 GetSize() const { return aData.Count(); } |
| SbiSymScope GetScope() const { return eScope; } |
| void SetScope( SbiSymScope s ) { eScope = s; } |
| SbiParser* GetParser() { return pParser; } |
| |
| SbiSymDef* AddSym( const String& ); // Symbol hinzufuegen |
| SbiProcDef* AddProc( const String& );// Prozedur hinzufuegen |
| void Add( SbiSymDef* ); // Symbol uebernehmen |
| SbiSymDef* Find( const String& ) const;// Variablenname |
| SbiSymDef* FindId( sal_uInt16 ) const; // Variable per ID suchen |
| SbiSymDef* Get( sal_uInt16 ) const; // Variable per Position suchen |
| SbiSymDef* First(), *Next(); // Iteratoren |
| |
| sal_uInt32 Define( const String& ); // Label definieren |
| sal_uInt32 Reference( const String& ); // Label referenzieren |
| void CheckRefs(); // offene Referenzen suchen |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| class SbiSymDef { // Allgemeiner Symboleintrag |
| friend class SbiSymPool; |
| protected: |
| String aName; // Name des Eintrags |
| SbxDataType eType; // Typ des Eintrags |
| SbiSymPool* pIn; // Parent-Pool |
| SbiSymPool* pPool; // Pool fuer Unterelemente |
| short nLen; // Stringlaenge bei STRING*n |
| short nDims; // Array-Dimensionen |
| sal_uInt16 nId; // Symbol-Nummer |
| sal_uInt16 nTypeId; // String-ID des Datentyps (Dim X AS Dytentyp) |
| sal_uInt16 nProcId; // aktuelles ProcId fuer STATIC-Variable |
| sal_uInt16 nPos; // Positions-Nummer |
| sal_uInt32 nChain; // Backchain-Kette |
| sal_Bool bNew : 1; // sal_True: Dim As New... |
| sal_Bool bChained : 1; // sal_True: Symbol ist in Code definiert |
| sal_Bool bByVal : 1; // sal_True: ByVal-Parameter |
| sal_Bool bOpt : 1; // sal_True: optionaler Parameter |
| sal_Bool bStatic : 1; // sal_True: STATIC-Variable |
| sal_Bool bAs : 1; // sal_True: Datentyp per AS XXX definiert |
| sal_Bool bGlobal : 1; // sal_True: Global-Variable |
| sal_Bool bParamArray : 1; // sal_True: ParamArray parameter |
| sal_Bool bWithEvents : 1; // sal_True: Declared WithEvents |
| sal_Bool bWithBrackets : 1; // sal_True: Followed by () |
| sal_uInt16 nDefaultId; // Symbol number of default value |
| short nFixedStringLength; // String length in: Dim foo As String*Length |
| public: |
| SbiSymDef( const String& ); |
| virtual ~SbiSymDef(); |
| virtual SbiProcDef* GetProcDef(); |
| virtual SbiConstDef* GetConstDef(); |
| |
| SbxDataType GetType() const { return eType; } |
| virtual void SetType( SbxDataType ); |
| const String& GetName(); |
| SbiSymScope GetScope() const; |
| sal_uInt16 GetProcId() const{ return nProcId; } |
| sal_uInt32 GetAddr() const { return nChain; } |
| sal_uInt16 GetId() const { return nId; } |
| sal_uInt16 GetTypeId() const{ return nTypeId; } |
| void SetTypeId( sal_uInt16 n ) { nTypeId = n; eType = SbxOBJECT; } |
| sal_uInt16 GetPos() const { return nPos; } |
| void SetLen( short n ){ nLen = n; } |
| short GetLen() const { return nLen; } |
| void SetDims( short n ) { nDims = n; } |
| short GetDims() const { return nDims; } |
| sal_Bool IsDefined() const{ return bChained; } |
| void SetOptional() { bOpt = sal_True; } |
| void SetParamArray() { bParamArray = sal_True; } |
| void SetWithEvents() { bWithEvents = sal_True; } |
| void SetWithBrackets(){ bWithBrackets = sal_True; } |
| void SetByVal( sal_Bool bByVal_ = sal_True ) |
| { bByVal = bByVal_; } |
| void SetStatic( sal_Bool bAsStatic = sal_True ) { bStatic = bAsStatic; } |
| void SetNew() { bNew = sal_True; } |
| void SetDefinedAs() { bAs = sal_True; } |
| void SetGlobal(sal_Bool b){ bGlobal = b; } |
| void SetDefaultId( sal_uInt16 n ) { nDefaultId = n; } |
| sal_uInt16 GetDefaultId( void ) { return nDefaultId; } |
| sal_Bool IsOptional() const{ return bOpt; } |
| sal_Bool IsParamArray() const{ return bParamArray; } |
| sal_Bool IsWithEvents() const{ return bWithEvents; } |
| sal_Bool IsWithBrackets() const{ return bWithBrackets; } |
| sal_Bool IsByVal() const { return bByVal; } |
| sal_Bool IsStatic() const { return bStatic; } |
| sal_Bool IsNew() const { return bNew; } |
| sal_Bool IsDefinedAs() const { return bAs; } |
| sal_Bool IsGlobal() const { return bGlobal; } |
| short GetFixedStringLength( void ) const { return nFixedStringLength; } |
| void SetFixedStringLength( short n ) { nFixedStringLength = n; } |
| |
| SbiSymPool& GetPool(); |
| sal_uInt32 Define(); // Symbol in Code definieren |
| sal_uInt32 Reference(); // Symbol in Code referenzieren |
| |
| private: |
| SbiSymDef( const SbiSymDef& ); |
| |
| }; |
| |
| class SbiProcDef : public SbiSymDef { // Prozedur-Definition (aus Basic): |
| SbiSymPool aParams; // Parameter |
| SbiSymPool aLabels; // lokale Sprungziele |
| String aLibName; // LIB "name" |
| String aAlias; // ALIAS "name" |
| sal_uInt16 nLine1, nLine2; // Zeilenbereich |
| PropertyMode mePropMode; // Marks if this is a property procedure and which |
| String maPropName; // Property name if property procedure (!= proc name) |
| sal_Bool bCdecl : 1; // sal_True: CDECL angegeben |
| sal_Bool bPublic : 1; // sal_True: proc ist PUBLIC |
| sal_Bool mbProcDecl : 1; // sal_True: instanciated by SbiParser::ProcDecl |
| public: |
| SbiProcDef( SbiParser*, const String&, sal_Bool bProcDecl=false ); |
| virtual ~SbiProcDef(); |
| virtual SbiProcDef* GetProcDef(); |
| virtual void SetType( SbxDataType ); |
| SbiSymPool& GetParams() { return aParams; } |
| SbiSymPool& GetLabels() { return aLabels; } |
| SbiSymPool& GetLocals() { return GetPool();} |
| String& GetLib() { return aLibName; } |
| String& GetAlias() { return aAlias; } |
| void SetPublic( sal_Bool b ) { bPublic = b; } |
| sal_Bool IsPublic() const { return bPublic; } |
| void SetCdecl( sal_Bool b = sal_True) { bCdecl = b; } |
| sal_Bool IsCdecl() const { return bCdecl; } |
| sal_Bool IsUsedForProcDecl() const { return mbProcDecl; } |
| void SetLine1( sal_uInt16 n ) { nLine1 = n; } |
| sal_uInt16 GetLine1() const { return nLine1; } |
| void SetLine2( sal_uInt16 n ) { nLine2 = n; } |
| sal_uInt16 GetLine2() const { return nLine2; } |
| PropertyMode getPropertyMode() { return mePropMode; } |
| void setPropertyMode( PropertyMode ePropMode ); |
| const String& GetPropName() { return maPropName; } |
| |
| // Match mit einer Forward-Deklaration. Die Parameternamen |
| // werden abgeglichen und die Forward-Deklaration wird |
| // durch this ersetzt |
| void Match( SbiProcDef* pForward ); |
| |
| private: |
| SbiProcDef( const SbiProcDef& ); |
| |
| }; |
| |
| class SbiConstDef : public SbiSymDef |
| { |
| double nVal; |
| String aVal; |
| public: |
| SbiConstDef( const String& ); |
| virtual ~SbiConstDef(); |
| virtual SbiConstDef* GetConstDef(); |
| void Set( double, SbxDataType ); |
| void Set( const String& ); |
| double GetValue() { return nVal; } |
| const String& GetString() { return aVal; } |
| }; |
| |
| |
| #endif |
| |
