1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* 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 .
*/
#pragma once
#include <memory>
#include <vector>
#include <basic/sbdef.hxx>
class SbiConstDef;
class SbiParser;
class SbiProcDef;
class SbiStringPool;
class SbiSymDef; // base class
enum SbiSymScope { SbLOCAL, SbPARAM, SbPUBLIC, SbGLOBAL, SbRTL };
// The string-pool collects string entries and
// makes sure that they don't exist twice.
class SbiStringPool {
std::vector<OUString> aData;
public:
SbiStringPool();
~SbiStringPool();
sal_uInt32 GetSize() const { return aData.size(); }
short Add( const OUString& );
short Add( double, SbxDataType );
OUString Find( sal_uInt32 ) const;
};
class SbiSymPool final {
friend class SbiSymDef;
friend class SbiProcDef;
SbiStringPool& rStrings;
std::vector<std::unique_ptr<SbiSymDef>> m_Data;
SbiSymPool* pParent;
SbiParser* pParser;
SbiSymScope eScope;
sal_uInt16 nProcId; // for STATIC-variable
sal_uInt16 nCur; // iterator
public:
SbiSymPool( SbiStringPool&, SbiSymScope, SbiParser* pParser_ );
~SbiSymPool();
void SetParent( SbiSymPool* p ) { pParent = p; }
void SetProcId( short n ) { nProcId = n; }
sal_uInt16 GetSize() const { return m_Data.size(); }
SbiSymScope GetScope() const { return eScope; }
void SetScope( SbiSymScope s ) { eScope = s; }
SbiParser* GetParser() { return pParser; }
SbiSymDef* AddSym( const OUString& );
SbiProcDef* AddProc( const OUString& );
void Add( SbiSymDef* );
SbiSymDef* Find( const OUString&, bool bSearchInParents = true ); // variable name
SbiSymDef* Get( sal_uInt16 ); // find variable per position
SbiSymDef* First(), *Next(); // iterators
sal_uInt32 Define( const OUString& );
sal_uInt32 Reference( const OUString& );
void CheckRefs();
};
class SbiSymDef { // general symbol entry
friend class SbiSymPool;
protected:
OUString aName;
SbxDataType eType;
SbiSymPool* pIn; // parent pool
std::unique_ptr<SbiSymPool> pPool; // pool for sub-elements
short nLen; // string length for STRING*n
short nDims;
sal_uInt16 nId;
sal_uInt16 nTypeId; // Dim X AS data type
sal_uInt16 nProcId;
sal_uInt16 nPos;
sal_uInt32 nChain;
bool bNew : 1; // true: Dim As New...
bool bChained : 1; // true: symbol is defined in code
bool bByVal : 1; // true: ByVal-parameter
bool bOpt : 1; // true: optional parameter
bool bStatic : 1; // true: STATIC variable
bool bAs : 1; // true: data type defined per AS XXX
bool bGlobal : 1; // true: global variable
bool bParamArray : 1; // true: ParamArray parameter
bool bWithEvents : 1; // true: Declared WithEvents
bool bWithBrackets : 1; // true: Followed by ()
sal_uInt16 nDefaultId; // Symbol number of default value
short nFixedStringLength; // String length in: Dim foo As String*Length
public:
SbiSymDef( const OUString& );
virtual ~SbiSymDef();
virtual SbiProcDef* GetProcDef();
virtual SbiConstDef* GetConstDef();
SbxDataType GetType() const { return eType; }
virtual void SetType( SbxDataType );
const OUString& GetName();
SbiSymScope GetScope() const;
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; }
bool IsDefined() const{ return bChained; }
void SetOptional() { bOpt = true; }
void SetParamArray() { bParamArray = true; }
void SetWithEvents() { bWithEvents = true; }
void SetWithBrackets(){ bWithBrackets = true; }
void SetByVal( bool bByVal_ ) { bByVal = bByVal_; }
void SetStatic( bool bAsStatic = true ) { bStatic = bAsStatic; }
void SetNew() { bNew = true; }
void SetDefinedAs() { bAs = true; }
void SetGlobal(bool b){ bGlobal = b; }
void SetDefaultId( sal_uInt16 n ) { nDefaultId = n; }
sal_uInt16 GetDefaultId() const { return nDefaultId; }
bool IsOptional() const{ return bOpt; }
bool IsParamArray() const{ return bParamArray; }
bool IsWithEvents() const{ return bWithEvents; }
bool IsWithBrackets() const{ return bWithBrackets; }
bool IsByVal() const { return bByVal; }
bool IsStatic() const { return bStatic; }
bool IsNew() const { return bNew; }
bool IsDefinedAs() const { return bAs; }
bool IsGlobal() const { return bGlobal; }
short GetFixedStringLength() const { return nFixedStringLength; }
void SetFixedStringLength( short n ) { nFixedStringLength = n; }
SbiSymPool& GetPool();
sal_uInt32 Define(); // define symbol in code
sal_uInt32 Reference(); // reference symbol in code
private:
SbiSymDef( const SbiSymDef& ) = delete;
};
class SbiProcDef final : public SbiSymDef { // procedure definition (from basic):
SbiSymPool aParams;
SbiSymPool aLabels; // local jump targets
OUString aLibName;
OUString aAlias;
sal_uInt16 nLine1, nLine2; // line area
PropertyMode mePropMode; // Marks if this is a property procedure and which
OUString maPropName; // Property name if property procedure (!= proc name)
bool bCdecl : 1; // true: CDECL given
bool bPublic : 1; // true: proc is PUBLIC
bool mbProcDecl : 1; // true: instantiated by SbiParser::ProcDecl
public:
SbiProcDef( SbiParser*, const OUString&, bool bProcDecl=false );
virtual ~SbiProcDef() override;
virtual SbiProcDef* GetProcDef() override;
virtual void SetType( SbxDataType ) override;
SbiSymPool& GetParams() { return aParams; }
SbiSymPool& GetLabels() { return aLabels; }
SbiSymPool& GetLocals() { return GetPool();}
OUString& GetLib() { return aLibName; }
OUString& GetAlias() { return aAlias; }
void SetPublic( bool b ) { bPublic = b; }
bool IsPublic() const { return bPublic; }
void SetCdecl( bool b ) { bCdecl = b; }
bool IsCdecl() const { return bCdecl; }
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() const { return mePropMode; }
void setPropertyMode( PropertyMode ePropMode );
const OUString& GetPropName() const { return maPropName; }
// Match with a forward-declaration. The parameter names are
// compared and the forward declaration is replaced by this
void Match( SbiProcDef* pForward );
private:
SbiProcDef( const SbiProcDef& ) = delete;
};
class SbiConstDef final : public SbiSymDef
{
double nVal;
OUString aVal;
public:
SbiConstDef( const OUString& );
virtual ~SbiConstDef() override;
virtual SbiConstDef* GetConstDef() override;
void Set( double, SbxDataType );
void Set( const OUString& );
double GetValue() const { return nVal; }
const OUString& GetString() const { return aVal; }
};
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
