Line data Source code
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 : #include "reftokenhelper.hxx"
21 : #include "document.hxx"
22 : #include "rangeutl.hxx"
23 : #include "compiler.hxx"
24 : #include "tokenarray.hxx"
25 :
26 : #include "rtl/ustring.hxx"
27 : #include "formula/grammar.hxx"
28 : #include "formula/token.hxx"
29 :
30 : using namespace formula;
31 :
32 : using ::std::vector;
33 : using ::std::auto_ptr;
34 : using ::rtl::OUString;
35 :
36 164 : void ScRefTokenHelper::compileRangeRepresentation(
37 : vector<ScTokenRef>& rRefTokens, const OUString& rRangeStr, ScDocument* pDoc,
38 : const sal_Unicode cSep, FormulaGrammar::Grammar eGrammar)
39 : {
40 164 : const sal_Unicode cQuote = '\'';
41 :
42 : // #i107275# ignore parentheses
43 164 : OUString aRangeStr = rRangeStr;
44 328 : while( (aRangeStr.getLength() >= 2) && (aRangeStr[ 0 ] == '(') && (aRangeStr[ aRangeStr.getLength() - 1 ] == ')') )
45 0 : aRangeStr = aRangeStr.copy( 1, aRangeStr.getLength() - 2 );
46 :
47 164 : bool bFailure = false;
48 164 : sal_Int32 nOffset = 0;
49 492 : while (nOffset >= 0 && !bFailure)
50 : {
51 328 : OUString aToken;
52 328 : ScRangeStringConverter::GetTokenByOffset(aToken, aRangeStr, nOffset, cSep, cQuote);
53 328 : if (nOffset < 0)
54 : break;
55 :
56 164 : ScCompiler aCompiler(pDoc, ScAddress(0,0,0));
57 164 : aCompiler.SetGrammar(eGrammar);
58 164 : auto_ptr<ScTokenArray> pArray(aCompiler.CompileString(aToken));
59 :
60 : // There MUST be exactly one reference per range token and nothing
61 : // else, and it MUST be a valid reference, not some #REF!
62 164 : sal_uInt16 nLen = pArray->GetLen();
63 164 : if (!nLen)
64 0 : continue; // Should a missing range really be allowed?
65 164 : if (nLen != 1)
66 : {
67 0 : bFailure = true;
68 : break;
69 : }
70 :
71 164 : pArray->Reset();
72 164 : const FormulaToken* p = pArray->Next();
73 164 : if (!p)
74 : {
75 0 : bFailure = true;
76 : break;
77 : }
78 :
79 164 : const ScToken* pT = static_cast<const ScToken*>(p);
80 164 : switch (pT->GetType())
81 : {
82 : case svSingleRef:
83 80 : if (!pT->GetSingleRef().Valid())
84 0 : bFailure = true;
85 80 : break;
86 : case svDoubleRef:
87 84 : if (!pT->GetDoubleRef().Valid())
88 0 : bFailure = true;
89 84 : break;
90 : case svExternalSingleRef:
91 0 : if (!pT->GetSingleRef().ValidExternal())
92 0 : bFailure = true;
93 0 : break;
94 : case svExternalDoubleRef:
95 0 : if (!pT->GetDoubleRef().ValidExternal())
96 0 : bFailure = true;
97 0 : break;
98 : case svString:
99 0 : if (!pT->GetString().Len())
100 0 : bFailure = true;
101 0 : break;
102 : default:
103 0 : bFailure = true;
104 0 : break;
105 : }
106 164 : if (!bFailure)
107 : rRefTokens.push_back(
108 164 : ScTokenRef(static_cast<ScToken*>(p->Clone())));
109 :
110 164 : }
111 164 : if (bFailure)
112 0 : rRefTokens.clear();
113 164 : }
114 :
115 : namespace {
116 :
117 : //may return a relative address
118 2010 : void singleRefToAddr(const ScSingleRefData& rRef, ScAddress& rAddr)
119 : {
120 2010 : rAddr.SetCol(rRef.nCol);
121 2010 : rAddr.SetRow(rRef.nRow);
122 2010 : rAddr.SetTab(rRef.nTab);
123 2010 : }
124 :
125 : }
126 :
127 1138 : bool ScRefTokenHelper::getRangeFromToken(ScRange& rRange, const ScTokenRef& pToken, bool bExternal)
128 : {
129 1138 : StackVar eType = pToken->GetType();
130 1138 : switch (pToken->GetType())
131 : {
132 : case svSingleRef:
133 : case svExternalSingleRef:
134 : {
135 266 : if ((eType == svExternalSingleRef && !bExternal) ||
136 : (eType == svSingleRef && bExternal))
137 0 : return false;
138 :
139 266 : const ScSingleRefData& rRefData = pToken->GetSingleRef();
140 266 : singleRefToAddr(rRefData, rRange.aStart);
141 266 : rRange.aEnd = rRange.aStart;
142 266 : return true;
143 : }
144 : case svDoubleRef:
145 : case svExternalDoubleRef:
146 : {
147 872 : if ((eType == svExternalDoubleRef && !bExternal) ||
148 : (eType == svDoubleRef && bExternal))
149 0 : return false;
150 :
151 872 : const ScComplexRefData& rRefData = pToken->GetDoubleRef();
152 872 : singleRefToAddr(rRefData.Ref1, rRange.aStart);
153 872 : singleRefToAddr(rRefData.Ref2, rRange.aEnd);
154 872 : return true;
155 : }
156 : default:
157 : ; // do nothing
158 : }
159 0 : return false;
160 : }
161 :
162 244 : void ScRefTokenHelper::getRangeListFromTokens(ScRangeList& rRangeList, const vector<ScTokenRef>& rTokens)
163 : {
164 244 : vector<ScTokenRef>::const_iterator itr = rTokens.begin(), itrEnd = rTokens.end();
165 572 : for (; itr != itrEnd; ++itr)
166 : {
167 328 : ScRange aRange;
168 328 : getRangeFromToken(aRange, *itr);
169 328 : rRangeList.Append(aRange);
170 : }
171 244 : }
172 :
173 164 : void ScRefTokenHelper::getTokenFromRange(ScTokenRef& pToken, const ScRange& rRange)
174 : {
175 : ScComplexRefData aData;
176 164 : aData.InitFlags();
177 164 : aData.Ref1.nCol = rRange.aStart.Col();
178 164 : aData.Ref1.nRow = rRange.aStart.Row();
179 164 : aData.Ref1.nTab = rRange.aStart.Tab();
180 164 : aData.Ref1.SetColRel(false);
181 164 : aData.Ref1.SetRowRel(false);
182 164 : aData.Ref1.SetTabRel(false);
183 164 : aData.Ref1.SetFlag3D(true);
184 :
185 164 : aData.Ref2.nCol = rRange.aEnd.Col();
186 164 : aData.Ref2.nRow = rRange.aEnd.Row();
187 164 : aData.Ref2.nTab = rRange.aEnd.Tab();
188 164 : aData.Ref2.SetColRel(false);
189 164 : aData.Ref2.SetRowRel(false);
190 164 : aData.Ref2.SetTabRel(false);
191 : // Display sheet name on 2nd reference only when the 1st and 2nd refs are on
192 : // different sheets.
193 164 : aData.Ref2.SetFlag3D(aData.Ref1.nTab != aData.Ref2.nTab);
194 :
195 164 : pToken.reset(new ScDoubleRefToken(aData));
196 164 : }
197 :
198 80 : void ScRefTokenHelper::getTokensFromRangeList(vector<ScTokenRef>& pTokens, const ScRangeList& rRanges)
199 : {
200 80 : vector<ScTokenRef> aTokens;
201 80 : size_t nCount = rRanges.size();
202 80 : aTokens.reserve(nCount);
203 244 : for (size_t i = 0; i < nCount; ++i)
204 : {
205 164 : const ScRange* pRange = rRanges[i];
206 164 : if (!pRange)
207 : // failed.
208 80 : return;
209 :
210 164 : ScTokenRef pToken;
211 164 : ScRefTokenHelper::getTokenFromRange(pToken,* pRange);
212 164 : aTokens.push_back(pToken);
213 164 : }
214 80 : pTokens.swap(aTokens);
215 : }
216 :
217 776 : bool ScRefTokenHelper::isRef(const ScTokenRef& pToken)
218 : {
219 776 : switch (pToken->GetType())
220 : {
221 : case svSingleRef:
222 : case svDoubleRef:
223 : case svExternalSingleRef:
224 : case svExternalDoubleRef:
225 776 : return true;
226 : default:
227 : ;
228 : }
229 0 : return false;
230 : }
231 :
232 1028 : bool ScRefTokenHelper::isExternalRef(const ScTokenRef& pToken)
233 : {
234 1028 : switch (pToken->GetType())
235 : {
236 : case svExternalSingleRef:
237 : case svExternalDoubleRef:
238 0 : return true;
239 : default:
240 : ;
241 : }
242 1028 : return false;
243 : }
244 :
245 8 : bool ScRefTokenHelper::intersects(const vector<ScTokenRef>& rTokens, const ScTokenRef& pToken)
246 : {
247 8 : if (!isRef(pToken))
248 0 : return false;
249 :
250 8 : bool bExternal = isExternalRef(pToken);
251 8 : sal_uInt16 nFileId = bExternal ? pToken->GetIndex() : 0;
252 :
253 8 : ScRange aRange;
254 8 : getRangeFromToken(aRange, pToken, bExternal);
255 :
256 8 : vector<ScTokenRef>::const_iterator itr = rTokens.begin(), itrEnd = rTokens.end();
257 12 : for (; itr != itrEnd; ++itr)
258 : {
259 8 : const ScTokenRef& p = *itr;
260 8 : if (!isRef(p))
261 0 : continue;
262 :
263 8 : if (bExternal != isExternalRef(p))
264 0 : continue;
265 :
266 8 : ScRange aRange2;
267 8 : getRangeFromToken(aRange2, p, bExternal);
268 :
269 8 : if (bExternal && nFileId != p->GetIndex())
270 : // different external file
271 0 : continue;
272 :
273 8 : if (aRange.Intersects(aRange2))
274 4 : return true;
275 : }
276 4 : return false;
277 : }
278 :
279 : namespace {
280 :
281 : class JoinRefTokenRanges
282 : {
283 : public:
284 : /**
285 : * Insert a new reference token into the existing list of reference tokens,
286 : * but in that process, try to join as many adjacent ranges as possible.
287 : *
288 : * @param rTokens existing list of reference tokens
289 : * @param rToken new token
290 : */
291 176 : void operator() (vector<ScTokenRef>& rTokens, const ScTokenRef& pToken)
292 : {
293 176 : join(rTokens, pToken);
294 176 : }
295 :
296 : private:
297 :
298 : /**
299 : * Check two 1-dimensional ranges to see if they overlap each other.
300 : *
301 : * @param nMin1 min value of range 1
302 : * @param nMax1 max value of range 1
303 : * @param nMin2 min value of range 2
304 : * @param nMax2 max value of range 2
305 : * @param rNewMin min value of new range in case they overlap
306 : * @param rNewMax max value of new range in case they overlap
307 : */
308 : template<typename T>
309 84 : static bool overlaps(T nMin1, T nMax1, T nMin2, T nMax2, T& rNewMin, T& rNewMax)
310 : {
311 84 : bool bDisjoint1 = (nMin1 > nMax2) && (nMin1 - nMax2 > 1);
312 84 : bool bDisjoint2 = (nMin2 > nMax1) && (nMin2 - nMax1 > 1);
313 84 : if (bDisjoint1 || bDisjoint2)
314 : // These two ranges cannot be joined. Move on.
315 0 : return false;
316 :
317 84 : T nMin = nMin1 < nMin2 ? nMin1 : nMin2;
318 84 : T nMax = nMax1 > nMax2 ? nMax1 : nMax2;
319 :
320 84 : rNewMin = nMin;
321 84 : rNewMax = nMax;
322 :
323 84 : return true;
324 : }
325 :
326 90 : bool isContained(const ScComplexRefData& aOldData, const ScComplexRefData& aData) const
327 : {
328 : // Check for containment.
329 90 : bool bRowsContained = (aOldData.Ref1.nRow <= aData.Ref1.nRow) && (aData.Ref2.nRow <= aOldData.Ref2.nRow);
330 90 : bool bColsContained = (aOldData.Ref1.nCol <= aData.Ref1.nCol) && (aData.Ref2.nCol <= aOldData.Ref2.nCol);
331 90 : return (bRowsContained && bColsContained);
332 : }
333 :
334 176 : void join(vector<ScTokenRef>& rTokens, const ScTokenRef& pToken)
335 : {
336 : // Normalize the token to a double reference.
337 : ScComplexRefData aData;
338 176 : if (!ScRefTokenHelper::getDoubleRefDataFromToken(aData, pToken))
339 : return;
340 :
341 : // Get the information of the new token.
342 176 : bool bExternal = ScRefTokenHelper::isExternalRef(pToken);
343 176 : sal_uInt16 nFileId = bExternal ? pToken->GetIndex() : 0;
344 176 : String aTabName = bExternal ? pToken->GetString() : String();
345 :
346 176 : bool bJoined = false;
347 176 : vector<ScTokenRef>::iterator itr = rTokens.begin(), itrEnd = rTokens.end();
348 182 : for (; itr != itrEnd; ++itr)
349 : {
350 90 : ScTokenRef& pOldToken = *itr;
351 :
352 90 : if (!ScRefTokenHelper::isRef(pOldToken))
353 : // A non-ref token should not have been added here in the first
354 : // place!
355 0 : continue;
356 :
357 90 : if (bExternal != ScRefTokenHelper::isExternalRef(pOldToken))
358 : // External and internal refs don't mix.
359 0 : continue;
360 :
361 90 : if (bExternal)
362 : {
363 0 : if (nFileId != pOldToken->GetIndex())
364 : // Different external files.
365 0 : continue;
366 :
367 0 : if (aTabName != pOldToken->GetString())
368 : // Different table names.
369 0 : continue;
370 : }
371 :
372 : ScComplexRefData aOldData;
373 90 : if (!ScRefTokenHelper::getDoubleRefDataFromToken(aOldData, pOldToken))
374 0 : continue;
375 :
376 90 : if (aData.Ref1.nTab != aOldData.Ref1.nTab || aData.Ref2.nTab != aOldData.Ref2.nTab)
377 : // Sheet ranges differ.
378 0 : continue;
379 :
380 90 : if (isContained(aOldData, aData))
381 : // This new range is part of an existing range. Skip it.
382 : return;
383 :
384 90 : bool bSameRows = (aData.Ref1.nRow == aOldData.Ref1.nRow) && (aData.Ref2.nRow == aOldData.Ref2.nRow);
385 90 : bool bSameCols = (aData.Ref1.nCol == aOldData.Ref1.nCol) && (aData.Ref2.nCol == aOldData.Ref2.nCol);
386 90 : ScComplexRefData aNewData = aOldData;
387 90 : bool bJoinRanges = false;
388 90 : if (bSameRows)
389 : {
390 : bJoinRanges = overlaps(
391 : aData.Ref1.nCol, aData.Ref2.nCol, aOldData.Ref1.nCol, aOldData.Ref2.nCol,
392 36 : aNewData.Ref1.nCol, aNewData.Ref2.nCol);
393 : }
394 54 : else if (bSameCols)
395 : {
396 : bJoinRanges = overlaps(
397 : aData.Ref1.nRow, aData.Ref2.nRow, aOldData.Ref1.nRow, aOldData.Ref2.nRow,
398 48 : aNewData.Ref1.nRow, aNewData.Ref2.nRow);
399 : }
400 :
401 90 : if (bJoinRanges)
402 : {
403 84 : if (bExternal)
404 0 : pOldToken.reset(new ScExternalDoubleRefToken(nFileId, aTabName, aNewData));
405 : else
406 84 : pOldToken.reset(new ScDoubleRefToken(aNewData));
407 :
408 84 : bJoined = true;
409 : break;
410 : }
411 : }
412 :
413 176 : if (bJoined)
414 : {
415 84 : if (rTokens.size() == 1)
416 : // There is only one left. No need to do more joining.
417 : return;
418 :
419 : // Pop the last token from the list, and keep joining recursively.
420 0 : ScTokenRef p = rTokens.back();
421 0 : rTokens.pop_back();
422 0 : join(rTokens, p);
423 : }
424 : else
425 92 : rTokens.push_back(pToken);
426 : }
427 : };
428 :
429 : }
430 :
431 176 : void ScRefTokenHelper::join(vector<ScTokenRef>& rTokens, const ScTokenRef& pToken)
432 : {
433 : JoinRefTokenRanges join;
434 176 : join(rTokens, pToken);
435 176 : }
436 :
437 266 : bool ScRefTokenHelper::getDoubleRefDataFromToken(ScComplexRefData& rData, const ScTokenRef& pToken)
438 : {
439 266 : switch (pToken->GetType())
440 : {
441 : case svSingleRef:
442 : case svExternalSingleRef:
443 : {
444 134 : const ScSingleRefData& r = pToken->GetSingleRef();
445 134 : rData.Ref1 = r;
446 134 : rData.Ref1.SetFlag3D(true);
447 134 : rData.Ref2 = r;
448 134 : rData.Ref2.SetFlag3D(false); // Don't display sheet name on second reference.
449 : }
450 134 : break;
451 : case svDoubleRef:
452 : case svExternalDoubleRef:
453 132 : rData = pToken->GetDoubleRef();
454 132 : break;
455 : default:
456 : // Not a reference token. Bail out.
457 0 : return false;
458 : }
459 266 : return true;
460 : }
461 :
462 4 : ScTokenRef ScRefTokenHelper::createRefToken(const ScAddress& rAddr)
463 : {
464 : ScSingleRefData aRefData;
465 4 : aRefData.InitAddress(rAddr);
466 4 : ScTokenRef pRef(new ScSingleRefToken(aRefData));
467 4 : return pRef;
468 : }
469 :
470 2 : ScTokenRef ScRefTokenHelper::createRefToken(const ScRange& rRange)
471 : {
472 : ScComplexRefData aRefData;
473 2 : aRefData.InitRange(rRange);
474 2 : ScTokenRef pRef(new ScDoubleRefToken(aRefData));
475 2 : return pRef;
476 : }
477 :
478 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
