?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
build fix
[LibreOffice.git] / include / formula / token.hxx
bloba2376bc0fc28e61451006d3cb96a5363065b01dc
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #ifndef INCLUDED_FORMULA_TOKEN_HXX
21 #define INCLUDED_FORMULA_TOKEN_HXX
22
23 #include <sal/config.h>
24
25 #include <cstring>
26 #include <vector>
27
28 #include <formula/formuladllapi.h>
29 #include <formula/IFunctionDescription.hxx>
30 #include <formula/opcode.hxx>
31 #include <formula/types.hxx>
32 #include <osl/interlck.h>
33 #include <rtl/ustring.hxx>
34 #include <sal/types.h>
35 #include <svl/sharedstring.hxx>
36 #include <tools/mempool.hxx>
37
38 class ScJumpMatrix;
39 class ScMatrix;
40 struct ScComplexRefData;
41 struct ScSingleRefData;
42 enum class FormulaError : sal_uInt16;
43
44 namespace formula
45 {
46
47 enum StackVarEnum
48 {
49 svByte,
50 svDouble,
51 svString,
52 svSingleRef,
53 svDoubleRef,
54 svMatrix,
55 svIndex,
56 svJump,
57 svExternal, // Byte + String
58 svFAP, // FormulaAutoPilot only, ever exported
59 svJumpMatrix, // 2003-07-02
60 svRefList, // ocUnion result
61 svEmptyCell, // Result is an empty cell, e.g. in LOOKUP()
62
63 svMatrixCell, // Result is a matrix with bells and
64 // whistles as needed for _the_ matrix
65 // formula result.
66
67 svHybridCell, // A temporary condition of a formula
68 // cell during import, having a double
69 // and/or string result and a formula
70 // string to be compiled.
71
72 svExternalSingleRef,
73 svExternalDoubleRef,
74 svExternalName,
75 svSingleVectorRef,
76 svDoubleVectorRef,
77 svSubroutine, // A token with a subroutine token array.
78 svError, // error token
79 svMissing = 0x70, // 0 or ""
80 svSep, // separator, ocSep, ocOpen, ocClose
81 svUnknown // unknown StackType
82 };
83
84 #ifndef DBG_UTIL
85 // save memory since compilers tend to int an enum
86 typedef sal_uInt8 StackVar;
87 #else
88 // have enum names in debugger
89 typedef StackVarEnum StackVar;
90 #endif
91
92 class FORMULA_DLLPUBLIC FormulaToken : public IFormulaToken
93 {
94 OpCode eOp;
95 FormulaToken& operator=( const FormulaToken& ) = delete;
96 protected:
97
98 const StackVar eType; // type of data
99 mutable oslInterlockedCount mnRefCnt; // reference count
100
101 public:
102 FormulaToken( StackVar eTypeP,OpCode e = ocPush );
103 FormulaToken( const FormulaToken& r );
104
105 virtual ~FormulaToken();
106
107 inline void Delete() { delete this; }
108 inline void DeleteIfZeroRef() { if (mnRefCnt == 0) delete this; }
109 inline StackVar GetType() const { return eType; }
110 bool IsFunction() const; // pure functions, no operators
111
112 bool IsExternalRef() const;
113 bool IsRef() const;
114
115 sal_uInt8 GetParamCount() const;
116
117 inline void IncRef() const
118 {
119 osl_atomic_increment(&mnRefCnt);
120 }
121
122 inline void DecRef() const
123 {
124 if (!osl_atomic_decrement(&mnRefCnt))
125 const_cast<FormulaToken*>(this)->Delete();
126 }
127
128 inline oslInterlockedCount GetRef() const { return mnRefCnt; }
129 inline OpCode GetOpCode() const { return eOp; }
130
131 /**
132 Dummy methods to avoid switches and casts where possible,
133 the real token classes have to override the appropriate method[s].
134 The only methods valid anytime if not overridden are:
135
136 - GetByte() since this represents the count of parameters to a function
137 which of course is 0 on non-functions. FormulaByteToken and ScExternal do
138 override it.
139
140 - IsInForceArray() since also this is only used for operators and
141 functions and is false for other tokens.
142
143 Any other non-overridden method pops up an assertion.
144 */
145
146 virtual sal_uInt8 GetByte() const;
147 virtual void SetByte( sal_uInt8 n );
148 virtual bool IsInForceArray() const;
149 virtual void SetInForceArray( bool b );
150 virtual double GetDouble() const;
151 virtual double& GetDoubleAsReference();
152 virtual short GetDoubleType() const;
153 virtual svl::SharedString GetString() const;
154 virtual void SetString( const svl::SharedString& rStr );
155 virtual sal_uInt16 GetIndex() const;
156 virtual void SetIndex( sal_uInt16 n );
157 virtual sal_Int16 GetSheet() const;
158 virtual void SetSheet( sal_Int16 n );
159 virtual short* GetJump() const;
160 virtual const OUString& GetExternal() const;
161 virtual FormulaToken* GetFAPOrigToken() const;
162 virtual FormulaError GetError() const;
163 virtual void SetError( FormulaError );
164
165 virtual const ScSingleRefData* GetSingleRef() const;
166 virtual ScSingleRefData* GetSingleRef();
167 virtual const ScComplexRefData* GetDoubleRef() const;
168 virtual ScComplexRefData* GetDoubleRef();
169 virtual const ScSingleRefData* GetSingleRef2() const;
170 virtual ScSingleRefData* GetSingleRef2();
171 virtual const ScMatrix* GetMatrix() const;
172 virtual ScMatrix* GetMatrix();
173 virtual ScJumpMatrix* GetJumpMatrix() const;
174 virtual const std::vector<ScComplexRefData>* GetRefList() const;
175 virtual std::vector<ScComplexRefData>* GetRefList();
176
177 virtual FormulaToken* Clone() const { return new FormulaToken(*this); }
178
179 virtual bool TextEqual( const formula::FormulaToken& rToken ) const;
180 virtual bool operator==( const FormulaToken& rToken ) const;
181
182 virtual bool isFunction() const override
183 {
184 return IsFunction();
185 }
186
187 virtual sal_uInt32 getArgumentCount() const override
188 {
189 return GetParamCount();
190 }
191
192 /** This is dirty and only the compiler should use it! */
193 struct PrivateAccess { friend class FormulaCompiler; private: PrivateAccess() { } };
194 inline void NewOpCode( OpCode e, const PrivateAccess& ) { eOp = e; }
195 };
196
197 inline void intrusive_ptr_add_ref(const FormulaToken* p)
198 {
199 p->IncRef();
200 }
201
202 inline void intrusive_ptr_release(const FormulaToken* p)
203 {
204 p->DecRef();
205 }
206
207 class FORMULA_DLLPUBLIC FormulaByteToken : public FormulaToken
208 {
209 private:
210 sal_uInt8 nByte;
211 bool bIsInForceArray;
212 protected:
213 FormulaByteToken( OpCode e, sal_uInt8 n, StackVar v, bool b ) :
214 FormulaToken( v,e ), nByte( n ),
215 bIsInForceArray( b ) {}
216 public:
217 FormulaByteToken( OpCode e, sal_uInt8 n, bool b ) :
218 FormulaToken( svByte,e ), nByte( n ),
219 bIsInForceArray( b ) {}
220 FormulaByteToken( OpCode e, sal_uInt8 n ) :
221 FormulaToken( svByte,e ), nByte( n ),
222 bIsInForceArray( false ) {}
223 FormulaByteToken( OpCode e ) :
224 FormulaToken( svByte,e ), nByte( 0 ),
225 bIsInForceArray( false ) {}
226 FormulaByteToken( const FormulaByteToken& r ) :
227 FormulaToken( r ), nByte( r.nByte ),
228 bIsInForceArray( r.bIsInForceArray ) {}
229
230 virtual FormulaToken* Clone() const override { return new FormulaByteToken(*this); }
231 virtual sal_uInt8 GetByte() const override;
232 virtual void SetByte( sal_uInt8 n ) override;
233 virtual bool IsInForceArray() const override;
234 virtual void SetInForceArray( bool b ) override;
235 virtual bool operator==( const FormulaToken& rToken ) const override;
236
237 DECL_FIXEDMEMPOOL_NEWDEL_DLL( FormulaByteToken )
238 };
239
240
241 // A special token for the FormulaAutoPilot only. Keeps a reference pointer of
242 // the token of which it was created for comparison.
243 class FORMULA_DLLPUBLIC FormulaFAPToken : public FormulaByteToken
244 {
245 private:
246 FormulaTokenRef pOrigToken;
247 public:
248 FormulaFAPToken( OpCode e, sal_uInt8 n, FormulaToken* p ) :
249 FormulaByteToken( e, n, svFAP, false ),
250 pOrigToken( p ) {}
251 FormulaFAPToken( const FormulaFAPToken& r ) :
252 FormulaByteToken( r ), pOrigToken( r.pOrigToken ) {}
253
254 virtual FormulaToken* Clone() const override { return new FormulaFAPToken(*this); }
255 virtual FormulaToken* GetFAPOrigToken() const override;
256 virtual bool operator==( const FormulaToken& rToken ) const override;
257 };
258
259 class FORMULA_DLLPUBLIC FormulaDoubleToken : public FormulaToken
260 {
261 private:
262 double fDouble;
263 public:
264 FormulaDoubleToken( double f ) :
265 FormulaToken( svDouble ), fDouble( f ) {}
266 FormulaDoubleToken( const FormulaDoubleToken& r ) :
267 FormulaToken( r ), fDouble( r.fDouble ) {}
268
269 virtual FormulaToken* Clone() const override { return new FormulaDoubleToken(*this); }
270 virtual double GetDouble() const override;
271 virtual double& GetDoubleAsReference() override;
272 virtual short GetDoubleType() const override; ///< always returns 0 for "not typed"
273 virtual bool operator==( const FormulaToken& rToken ) const override;
274
275 DECL_FIXEDMEMPOOL_NEWDEL_DLL( FormulaDoubleToken )
276 };
277
278 class FORMULA_DLLPUBLIC FormulaTypedDoubleToken : public FormulaDoubleToken
279 {
280 private:
281 short mnType; /**< Can hold, for example, a value
282 of css::util::NumberFormat, or by
283 contract any other
284 classification. */
285 public:
286 FormulaTypedDoubleToken( double f, short nType ) :
287 FormulaDoubleToken( f ), mnType( nType ) {}
288 FormulaTypedDoubleToken( const FormulaTypedDoubleToken& r ) :
289 FormulaDoubleToken( r ), mnType( r.mnType ) {}
290
291 virtual FormulaToken* Clone() const override { return new FormulaTypedDoubleToken(*this); }
292 virtual short GetDoubleType() const override;
293 virtual bool operator==( const FormulaToken& rToken ) const override;
294
295 DECL_FIXEDMEMPOOL_NEWDEL_DLL( FormulaTypedDoubleToken )
296 };
297
298
299 class FORMULA_DLLPUBLIC FormulaStringToken : public FormulaToken
300 {
301 svl::SharedString maString;
302 public:
303 FormulaStringToken( const svl::SharedString& r );
304 FormulaStringToken( const FormulaStringToken& r );
305
306 virtual FormulaToken* Clone() const override;
307 virtual svl::SharedString GetString() const override;
308 virtual void SetString( const svl::SharedString& rStr ) override;
309 virtual bool operator==( const FormulaToken& rToken ) const override;
310
311 DECL_FIXEDMEMPOOL_NEWDEL_DLL( FormulaStringToken )
312 };
313
314
315 /** Identical to FormulaStringToken, but with explicit OpCode instead of implicit
316 ocPush, and an optional sal_uInt8 for ocBad tokens. */
317 class FORMULA_DLLPUBLIC FormulaStringOpToken : public FormulaByteToken
318 {
319 svl::SharedString maString;
320 public:
321 FormulaStringOpToken( OpCode e, const svl::SharedString& r );
322 FormulaStringOpToken( const FormulaStringOpToken& r );
323
324 virtual FormulaToken* Clone() const override;
325 virtual svl::SharedString GetString() const override;
326 virtual void SetString( const svl::SharedString& rStr ) override;
327 virtual bool operator==( const FormulaToken& rToken ) const override;
328 };
329
330 class FORMULA_DLLPUBLIC FormulaIndexToken : public FormulaToken
331 {
332 private:
333 sal_uInt16 nIndex;
334 sal_Int16 mnSheet;
335 public:
336 FormulaIndexToken( OpCode e, sal_uInt16 n, sal_Int16 nSheet = -1 ) :
337 FormulaToken( svIndex, e ), nIndex( n ), mnSheet( nSheet ) {}
338 FormulaIndexToken( const FormulaIndexToken& r ) :
339 FormulaToken( r ), nIndex( r.nIndex ), mnSheet( r.mnSheet ) {}
340
341 virtual FormulaToken* Clone() const override { return new FormulaIndexToken(*this); }
342 virtual sal_uInt16 GetIndex() const override;
343 virtual void SetIndex( sal_uInt16 n ) override;
344 virtual sal_Int16 GetSheet() const override;
345 virtual void SetSheet( sal_Int16 n ) override;
346 virtual bool operator==( const FormulaToken& rToken ) const override;
347 };
348
349
350 class FORMULA_DLLPUBLIC FormulaExternalToken : public FormulaToken
351 {
352 private:
353 OUString aExternal;
354 sal_uInt8 nByte;
355 public:
356 FormulaExternalToken( OpCode e, sal_uInt8 n, const OUString& r ) :
357 FormulaToken( svExternal, e ), aExternal( r ),
358 nByte( n ) {}
359 FormulaExternalToken( OpCode e, const OUString& r ) :
360 FormulaToken(svExternal, e ), aExternal( r ),
361 nByte( 0 ) {}
362 FormulaExternalToken( const FormulaExternalToken& r ) :
363 FormulaToken( r ), aExternal( r.aExternal ),
364 nByte( r.nByte ) {}
365
366 virtual FormulaToken* Clone() const override { return new FormulaExternalToken(*this); }
367 virtual const OUString& GetExternal() const override;
368 virtual sal_uInt8 GetByte() const override;
369 virtual void SetByte( sal_uInt8 n ) override;
370 virtual bool operator==( const FormulaToken& rToken ) const override;
371 };
372
373
374 class FORMULA_DLLPUBLIC FormulaMissingToken : public FormulaToken
375 {
376 public:
377 FormulaMissingToken() :
378 FormulaToken( svMissing,ocMissing ) {}
379 FormulaMissingToken( const FormulaMissingToken& r ) :
380 FormulaToken( r ) {}
381
382 virtual FormulaToken* Clone() const override { return new FormulaMissingToken(*this); }
383 virtual double GetDouble() const override;
384 virtual svl::SharedString GetString() const override;
385 virtual bool operator==( const FormulaToken& rToken ) const override;
386 };
387
388 class FORMULA_DLLPUBLIC FormulaJumpToken : public FormulaToken
389 {
390 private:
391 short* pJump;
392 bool bIsInForceArray;
393 public:
394 FormulaJumpToken( OpCode e, short* p ) :
395 FormulaToken( formula::svJump , e),
396 bIsInForceArray( false)
397 {
398 pJump = new short[ p[0] + 1 ];
399 memcpy( pJump, p, (p[0] + 1) * sizeof(short) );
400 }
401 FormulaJumpToken( const FormulaJumpToken& r ) :
402 FormulaToken( r ),
403 bIsInForceArray( r.bIsInForceArray)
404 {
405 pJump = new short[ r.pJump[0] + 1 ];
406 memcpy( pJump, r.pJump, (r.pJump[0] + 1) * sizeof(short) );
407 }
408 virtual ~FormulaJumpToken() override;
409 virtual short* GetJump() const override;
410 virtual bool operator==( const formula::FormulaToken& rToken ) const override;
411 virtual FormulaToken* Clone() const override { return new FormulaJumpToken(*this); }
412 virtual bool IsInForceArray() const override;
413 virtual void SetInForceArray( bool b ) override;
414 };
415
416
417 class FORMULA_DLLPUBLIC FormulaUnknownToken : public FormulaToken
418 {
419 public:
420 FormulaUnknownToken( OpCode e ) :
421 FormulaToken( svUnknown, e ) {}
422 FormulaUnknownToken( const FormulaUnknownToken& r ) :
423 FormulaToken( r ) {}
424
425 virtual FormulaToken* Clone() const override { return new FormulaUnknownToken(*this); }
426 virtual bool operator==( const FormulaToken& rToken ) const override;
427 };
428
429
430 class FORMULA_DLLPUBLIC FormulaErrorToken : public FormulaToken
431 {
432 FormulaError nError;
433 public:
434 FormulaErrorToken( FormulaError nErr ) :
435 FormulaToken( svError ), nError( nErr) {}
436 FormulaErrorToken( const FormulaErrorToken& r ) :
437 FormulaToken( r ), nError( r.nError) {}
438
439 virtual FormulaToken* Clone() const override { return new FormulaErrorToken(*this); }
440 virtual FormulaError GetError() const override;
441 virtual void SetError( FormulaError nErr ) override;
442 virtual bool operator==( const FormulaToken& rToken ) const override;
443 };
444
445
446 } // formula
447
448
449 #endif
450
451 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE