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
|
/* -*- 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 .
*/
#ifndef SC_PARCLASS_HXX
#define SC_PARCLASS_HXX
#include "formula/opcode.hxx"
#include <sys/types.h> // size_t
namespace formula
{
class FormulaToken;
}
class ScParameterClassification
{
public:
enum Type
{
Unknown = 0, // MUST be zero for initialization mechanism!
/** Out of bounds, function doesn't expect that many parameters.
However, not necessarily returned. */
Bounds,
/** In array formula: single value to be passed. Results in JumpMatrix
being created and multiple calls to function. Functions handling a
formula::svDoubleRef by means of DoubleRefToPosSingleRef() or
PopDoubleRefOrSingleRef() or GetDouble() or GetString() should have
this. */
Value,
/** In array formula: area reference must stay reference. Otherwise
don't care. Functions handling a formula::svDoubleRef by means of
PopDoubleRefOrSingleRef() should not have this. */
Reference,
/** In array formula: convert area reference to array. Function will be
called only once if no Value type is involved. Functions able to
handle a svMatrix parameter but not a formula::svDoubleRef parameter as area
should have this. */
Array,
/** Area reference must be converted to array in any case, and must
also be propagated to subsequent operators and functions being part
of a parameter of this function. */
ForceArray,
/** Area reference is not converted to array, but ForceArray must be
propagated to subsequent operators and functions being part of a
parameter of this function. Used with functions that treat
references separately from arrays, but need the forced array
calculation of parameters that are not references.*/
ReferenceOrForceArray
};
/// MUST be called once before any other method.
static void Init();
static void Exit();
/** Get one parameter type for function eOp.
@param nParameter
Which parameter, 0-based */
static Type GetParameterType( const formula::FormulaToken* pToken,
sal_uInt16 nParameter);
/** Whether OpCode has a parameter of type
ForceArray or ReferenceOrForceArray. */
static inline bool HasForceArray( OpCode eOp)
{
return 0 <= (short)eOp &&
eOp <= SC_OPCODE_LAST_OPCODE_ID &&
pData[eOp].bHasForceArray;
}
private:
struct CommonData
{
const static sal_Int32 nMaxParams = 7;
Type nParam[nMaxParams];
sal_uInt8 nRepeatLast;
};
// SUNWS7 needs a forward declared friend, otherwise members of the outer
// class are not accessible (in this case CommonData).
struct RawData;
friend struct ScParameterClassification::RawData;
struct RawData
{
OpCode eOp;
CommonData aData;
};
struct RunData;
friend struct ScParameterClassification::RunData;
struct RunData
{
CommonData aData;
sal_uInt8 nMinParams; // fix or minimum, or repeat start
bool bHasForceArray;
};
static const RawData pRawData[];
static RunData* pData;
// ocExternal AddIns
static Type GetExternalParameterType(
const formula::FormulaToken* pToken, sal_uInt16 nParameter);
#if OSL_DEBUG_LEVEL > 1
// Generate documentation to stdout if environment variable
// OOO_CALC_GENPARCLASSDOC is set.
static void GenerateDocumentation();
/* OpCodes not specified in the implementation are taken from the global
* function list and all parameters, if any, are assumed to be of type
* Value. This could also be done in the product version if needed, but we
* don't want to spoil startup time. However, doing so could propagate the
* minimum parameter count to the formula compiler, which, together with
* additional information about optional parameters, could react on missing
* parameters then. */
static void MergeArgumentsFromFunctionResource();
/** Minimum number of parameters, or fix number
of parameters if HasRepeatParameters()
returns sal_False. For opcodes not specified in
the implementation a parameter count of 1
is assumed, for opcodes out of range 0 is
assumed. If HasRepeatParameters() returns
sal_True, information is NOT related to whether
any parameters are optional, only the type
of parameters is significant. */
static inline sal_uInt8 GetMinimumParameters( OpCode eOp)
{
if ( eOp <= SC_OPCODE_LAST_OPCODE_ID )
return pData[eOp].aData.nParam[0]
== Unknown ? 1 :
pData[eOp].nMinParams;
return 0;
}
/** Whether last parameter types are repeated. */
static inline bool HasRepeatParameters( OpCode eOp)
{
return eOp <= SC_OPCODE_LAST_OPCODE_ID
&& pData[eOp].aData.nRepeatLast > 0;
}
#endif // OSL_DEBUG_LEVEL
};
#endif // SC_PARCLASS_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
