?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m57
[ooovba.git] / sc / source / core / tool / address.cxx
blob553f6667c794ea6bca6e050a6e704b51fa635c87
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: address.cxx,v $
10 * $Revision: 1.11.30.3 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33
34 #include "address.hxx"
35 #include "global.hxx"
36 #include "compiler.hxx"
37 #include "document.hxx"
38 #include "externalrefmgr.hxx"
39
40 #include "globstr.hrc"
41 #include <sal/alloca.h>
42
43 #include <com/sun/star/frame/XModel.hpp>
44 #include <com/sun/star/beans/XPropertySet.hpp>
45 #include <com/sun/star/sheet/ExternalLinkInfo.hpp>
46 #include <com/sun/star/sheet/ExternalLinkType.hpp>
47 #include <sfx2/objsh.hxx>
48 #include <tools/urlobj.hxx>
49 using namespace ::com::sun::star;
50
51 ////////////////////////////////////////////////////////////////////////////
52 const ScAddress::Details ScAddress::detailsOOOa1( formula::FormulaGrammar::CONV_OOO, 0, 0 );
53
54 ScAddress::Details::Details ( const ScDocument* pDoc,
55 const ScAddress & rAddr ) :
56 eConv( pDoc->GetAddressConvention() ),
57 nRow( rAddr.Row() ),
58 nCol( rAddr.Col() )
59 {
60 }
61
62 //UNUSED2009-05 void ScAddress::Details::SetPos ( const ScDocument* pDoc,
63 //UNUSED2009-05 const ScAddress & rAddr )
64 //UNUSED2009-05 {
65 //UNUSED2009-05 nRow = rAddr.Row();
66 //UNUSED2009-05 nCol = rAddr.Col();
67 //UNUSED2009-05 eConv = pDoc->GetAddressConvention();
68 //UNUSED2009-05 }
69
70 ////////////////////////////////////////////////////////////////////////////
71
72 #include <iostream>
73
74 /**
75 * Parse from the opening single quote to the closing single quote. Inside
76 * the quotes, a single quote character is encoded by double single-quote
77 * characters.
78 *
79 * @param p pointer to the first character to begin parsing.
80 * @param rName (reference) parsed name within the quotes. If the name is
81 * empty, either the parsing failed or it's an empty quote.
82 *
83 * @return pointer to the character immediately after the closing single
84 * quote.
85 */
86 static const sal_Unicode* lcl_ParseQuotedName( const sal_Unicode* p, String& rName )
87 {
88 rName.Erase();
89 if (*p != '\'')
90 return p;
91
92 const sal_Unicode* pStart = p;
93 sal_Unicode cPrev = 0;
94 for (++p; *p; ++p)
95 {
96 if (*p == '\'')
97 {
98 if (cPrev == '\'')
99 {
100 // double single-quote equals one single quote.
101 rName += *p;
102 cPrev = 0;
103 continue;
104 }
105 }
106 else if (cPrev == '\'')
107 // We are past the closing quote. We're done!
108 return p;
109 else
110 rName += *p;
111 cPrev = *p;
112 }
113 rName.Erase();
114 return pStart;
115 }
116
117 static long int
118 sal_Unicode_strtol ( const sal_Unicode* p,
119 const sal_Unicode** pEnd )
120 {
121 long int accum = 0, prev = 0;
122 bool is_neg = false;
123
124 if( *p == '-' )
125 {
126 is_neg = true;
127 p++;
128 }
129 else if( *p == '+' )
130 p++;
131
132 while (CharClass::isAsciiDigit( *p ))
133 {
134 accum = accum * 10 + *p - '0';
135 if( accum < prev )
136 {
137 *pEnd = NULL;
138 return 0;
139 }
140 prev = accum;
141 p++;
142 }
143
144 *pEnd = p;
145 return is_neg ? -accum : accum;
146 }
147
148 const sal_Unicode* lcl_eatWhiteSpace( const sal_Unicode* p )
149 {
150 if ( p )
151 {
152 while( *p == ' ' )
153 ++p;
154 }
155 return p;
156 }
157
158 /** Determines the number of sheets an external reference spans and sets
159 rRange.aEnd.nTab accordingly. If a sheet is not found, the corresponding
160 bits in rFlags are cleared. pExtInfo is filled if it wasn't already. If in
161 cached order rStartTabName comes after rEndTabName, pExtInfo->maTabName
162 is set to rEndTabName.
163 @returns <FALSE/> if pExtInfo is already filled and rExternDocName does not
164 result in the identical file ID. Else <TRUE/>.
165 */
166 static bool lcl_ScRange_External_TabSpan(
167 ScRange & rRange,
168 USHORT & rFlags,
169 ScAddress::ExternalInfo* pExtInfo,
170 const String & rExternDocName,
171 const String & rStartTabName,
172 const String & rEndTabName,
173 ScDocument* pDoc )
174 {
175 if (!rExternDocName.Len())
176 return !pExtInfo || !pExtInfo->mbExternal;
177
178 ScExternalRefManager* pRefMgr = pDoc->GetExternalRefManager();
179 if (pRefMgr->isOwnDocument( rExternDocName))
180 return !pExtInfo || !pExtInfo->mbExternal;
181
182 sal_uInt16 nFileId = pRefMgr->getExternalFileId( rExternDocName);
183
184 if (pExtInfo)
185 {
186 if (pExtInfo->mbExternal)
187 {
188 if (pExtInfo->mnFileId != nFileId)
189 return false;
190 }
191 else
192 {
193 pExtInfo->mbExternal = true;
194 pExtInfo->maTabName = rStartTabName;
195 pExtInfo->mnFileId = nFileId;
196 }
197 }
198
199 if (!rEndTabName.Len() || rStartTabName == rEndTabName)
200 {
201 rRange.aEnd.SetTab( rRange.aStart.Tab());
202 return true;
203 }
204
205 SCsTAB nSpan = pRefMgr->getCachedTabSpan( nFileId, rStartTabName, rEndTabName);
206 if (nSpan == -1)
207 rFlags &= ~(SCA_VALID_TAB | SCA_VALID_TAB2);
208 else if (nSpan == 0)
209 rFlags &= ~SCA_VALID_TAB2;
210 else if (nSpan >= 1)
211 rRange.aEnd.SetTab( rRange.aStart.Tab() + nSpan - 1);
212 else // (nSpan < -1)
213 {
214 rRange.aEnd.SetTab( rRange.aStart.Tab() - nSpan - 1);
215 if (pExtInfo)
216 pExtInfo->maTabName = rEndTabName;
217 }
218 return true;
219 }
220
221 // Returns NULL if the string should be a sheet name, but is invalid.
222 // Returns a pointer to the first character after the sheet name, if there was
223 // any, else pointer to start.
224 static const sal_Unicode *
225 lcl_XL_ParseSheetRef( const sal_Unicode* start,
226 String& rExternTabName,
227 bool allow_3d )
228 {
229 String aTabName;
230 const sal_Unicode *p = start;
231
232 if( *p == '\'' ) // XL only seems to use single quotes for sheet names
233 {
234 p = lcl_ParseQuotedName(p, aTabName);
235 if (!aTabName.Len())
236 return NULL;
237 }
238 else
239 {
240 bool only_digits = TRUE;
241
242 /*
243 * Valid: Normal!a1
244 * Valid: x.y!a1
245 * Invalid: .y!a1
246 *
247 * Some names starting with digits are actually valid, but
248 * unparse quoted. Things are quite tricky: most sheet names
249 * starting with a digit are ok, but not those starting with
250 * "[0-9]*\." or "[0-9]+[eE]".
251 *
252 * Valid: 42!a1
253 * Valid: 4x!a1
254 * Invalid: 1.!a1
255 * Invalid: 1e!a1
256 */
257 while( 1 )
258 {
259 const sal_Unicode uc = *p;
260 if( CharClass::isAsciiAlpha( uc ) || uc == '_' )
261 {
262 if( only_digits && p != start &&
263 (uc == 'e' || uc == 'E' ) )
264 {
265 p = start;
266 break;
267 }
268 only_digits = FALSE;
269 p++;
270 }
271 else if( CharClass::isAsciiDigit( uc ))
272 {
273 p++;
274 }
275 else if( uc == '.' )
276 {
277 if( only_digits ) // Valid, except after only digits.
278 {
279 p = start;
280 break;
281 }
282 p++;
283 }
284 else if (uc > 127)
285 {
286 // non ASCII character is allowed.
287 ++p;
288 }
289 else
290 break;
291 }
292
293 if( *p != '!' &&( !allow_3d || *p != ':' ) )
294 return start;
295
296 aTabName.Append( start, sal::static_int_cast<xub_StrLen>( p - start ) );
297 }
298
299 rExternTabName = aTabName;
300 return p;
301 }
302
303
304 const sal_Unicode* ScRange::Parse_XL_Header(
305 const sal_Unicode* p,
306 const ScDocument* pDoc,
307 String& rExternDocName,
308 String& rStartTabName,
309 String& rEndTabName,
310 USHORT& nFlags,
311 bool bOnlyAcceptSingle,
312 const uno::Sequence< const sheet::ExternalLinkInfo > * pExternalLinks )
313 {
314 const sal_Unicode* startTabs, *start = p;
315 USHORT nSaveFlags = nFlags;
316
317 // Is this an external reference ?
318 rStartTabName.Erase();
319 rEndTabName.Erase();
320 rExternDocName.Erase();
321 if (*p == '[')
322 {
323 ++p;
324 // Only single quotes are correct, and a double single quote escapes a
325 // single quote text inside the quoted text.
326 if (*p == '\'')
327 {
328 p = lcl_ParseQuotedName(p, rExternDocName);
329 if (!*p || *p != ']' || !rExternDocName.Len())
330 return start;
331 }
332 else
333 {
334 // non-quoted file name.
335 p = ScGlobal::UnicodeStrChr( start+1, ']' );
336 if( p == NULL )
337 return start;
338 rExternDocName.Append( start+1, sal::static_int_cast<xub_StrLen>( p-(start+1) ) );
339 }
340 ++p;
341
342 // 1-based, sequence starts with an empty element.
343 if (pExternalLinks && pExternalLinks->getLength() > 1)
344 {
345 // A numeric "document name" is an index into the sequence.
346 if (CharClass::isAsciiNumeric( rExternDocName))
347 {
348 sal_Int32 i = rExternDocName.ToInt32();
349 if (i <= 0 || i >= pExternalLinks->getLength())
350 return start;
351 const sheet::ExternalLinkInfo & rInfo = (*pExternalLinks)[i];
352 switch (rInfo.Type)
353 {
354 case sheet::ExternalLinkType::DOCUMENT :
355 {
356 rtl::OUString aStr;
357 if (!(rInfo.Data >>= aStr))
358 {
359 DBG_ERROR1( "ScRange::Parse_XL_Header: Data type mismatch for ExternalLinkInfo %d", i);
360 return NULL;
361 }
362 rExternDocName = aStr;
363 }
364 break;
365 default:
366 DBG_ERROR2( "ScRange::Parse_XL_Header: unhandled ExternalLinkType %d for index %d",
367 rInfo.Type, i);
368 return NULL;
369 }
370 }
371 }
372 rExternDocName = ScGlobal::GetAbsDocName(rExternDocName, pDoc->GetDocumentShell());
373 }
374
375 startTabs = p;
376 p = lcl_XL_ParseSheetRef( p, rStartTabName, !bOnlyAcceptSingle );
377 if( NULL == p )
378 return start; // invalid tab
379 if (bOnlyAcceptSingle && *p == ':')
380 return NULL; // 3D
381 if( p != startTabs )
382 {
383 nFlags |= SCA_VALID_TAB | SCA_TAB_3D | SCA_TAB_ABSOLUTE;
384 if( *p == ':' ) // 3d ref
385 {
386 p = lcl_XL_ParseSheetRef( p+1, rEndTabName, false );
387 if( p == NULL )
388 {
389 nFlags = nSaveFlags;
390 return start; // invalid tab
391 }
392 nFlags |= SCA_VALID_TAB2 | SCA_TAB2_3D | SCA_TAB2_ABSOLUTE;
393 }
394 else
395 {
396 // If only one sheet is given, the full reference is still valid,
397 // only the second 3D flag is not set.
398 nFlags |= SCA_VALID_TAB2 | SCA_TAB2_ABSOLUTE;
399 aEnd.SetTab( aStart.Tab() );
400 }
401
402 if( *p++ != '!' )
403 {
404 nFlags = nSaveFlags;
405 return start; // syntax error
406 }
407 else
408 p = lcl_eatWhiteSpace( p );
409 }
410 else
411 {
412 nFlags |= SCA_VALID_TAB | SCA_VALID_TAB2;
413 // Use the current tab, it needs to be passed in. : aEnd.SetTab( .. );
414 }
415
416 if (!rExternDocName.Len())
417 {
418 // Internal reference.
419 if (!rStartTabName.Len())
420 {
421 nFlags = nSaveFlags;
422 return start;
423 }
424
425 SCTAB nTab;
426 if (!pDoc->GetTable(rStartTabName, nTab))
427 {
428 // invalid table name.
429 nFlags &= ~SCA_VALID_TAB;
430 nTab = -1;
431 }
432
433 aStart.SetTab(nTab);
434 aEnd.SetTab(nTab);
435
436 if (rEndTabName.Len())
437 {
438 if (!pDoc->GetTable(rEndTabName, nTab))
439 {
440 // invalid table name.
441 nFlags &= ~SCA_VALID_TAB2;
442 nTab = -1;
443 }
444
445 aEnd.SetTab(nTab);
446 }
447 }
448 return p;
449 }
450
451
452 static const sal_Unicode*
453 lcl_r1c1_get_col( const sal_Unicode* p,
454 const ScAddress::Details& rDetails,
455 ScAddress* pAddr, USHORT* nFlags )
456 {
457 const sal_Unicode *pEnd;
458 long int n;
459 bool isRelative;
460
461 if( p[0] == '\0' )
462 return NULL;
463
464 p++;
465 if( (isRelative = (*p == '[') ) != false )
466 p++;
467 n = sal_Unicode_strtol( p, &pEnd );
468 if( NULL == pEnd )
469 return NULL;
470
471 if( p == pEnd ) // C is a relative ref with offset 0
472 {
473 if( isRelative )
474 return NULL;
475 n = rDetails.nCol;
476 }
477 else if( isRelative )
478 {
479 if( *pEnd != ']' )
480 return NULL;
481 n += rDetails.nCol;
482 pEnd++;
483 }
484 else
485 {
486 *nFlags |= SCA_COL_ABSOLUTE;
487 n--;
488 }
489
490 if( n < 0 || n >= MAXCOLCOUNT )
491 return NULL;
492 pAddr->SetCol( static_cast<SCCOL>( n ) );
493 *nFlags |= SCA_VALID_COL;
494
495 return pEnd;
496 }
497 static inline const sal_Unicode*
498 lcl_r1c1_get_row( const sal_Unicode* p,
499 const ScAddress::Details& rDetails,
500 ScAddress* pAddr, USHORT* nFlags )
501 {
502 const sal_Unicode *pEnd;
503 long int n;
504 bool isRelative;
505
506 if( p[0] == '\0' )
507 return NULL;
508
509 p++;
510 if( (isRelative = (*p == '[') ) != false )
511 p++;
512 n = sal_Unicode_strtol( p, &pEnd );
513 if( NULL == pEnd )
514 return NULL;
515
516 if( p == pEnd ) // R is a relative ref with offset 0
517 {
518 if( isRelative )
519 return NULL;
520 n = rDetails.nRow;
521 }
522 else if( isRelative )
523 {
524 if( *pEnd != ']' )
525 return NULL;
526 n += rDetails.nRow;
527 pEnd++;
528 }
529 else
530 {
531 *nFlags |= SCA_ROW_ABSOLUTE;
532 n--;
533 }
534
535 if( n < 0 || n >= MAXROWCOUNT )
536 return NULL;
537 pAddr->SetRow( static_cast<SCROW>( n ) );
538 *nFlags |= SCA_VALID_ROW;
539
540 return pEnd;
541 }
542
543 static USHORT
544 lcl_ScRange_Parse_XL_R1C1( ScRange& r,
545 const sal_Unicode* p,
546 ScDocument* pDoc,
547 const ScAddress::Details& rDetails,
548 bool bOnlyAcceptSingle,
549 ScAddress::ExternalInfo* pExtInfo )
550 {
551 const sal_Unicode* pTmp = NULL;
552 String aExternDocName, aStartTabName, aEndTabName;
553 USHORT nFlags = SCA_VALID | SCA_VALID_TAB, nFlags2 = SCA_VALID_TAB2;
554
555 #if 0
556 {
557 ByteString aStr(p, RTL_TEXTENCODING_UTF8);
558 aStr.Append(static_cast< char >(0));
559 std::cerr << "parse::XL::R1C1 \'" << aStr.GetBuffer() << '\'' << std::endl;
560 }
561 #endif
562 p = r.Parse_XL_Header( p, pDoc, aExternDocName, aStartTabName,
563 aEndTabName, nFlags, bOnlyAcceptSingle, NULL );
564
565 if (aExternDocName.Len() > 0)
566 lcl_ScRange_External_TabSpan( r, nFlags, pExtInfo, aExternDocName,
567 aStartTabName, aEndTabName, pDoc);
568
569 if( NULL == p )
570 return 0;
571
572 if( *p == 'R' || *p == 'r' )
573 {
574 if( NULL == (p = lcl_r1c1_get_row( p, rDetails, &r.aStart, &nFlags )) )
575 goto failed;
576
577 if( *p != 'C' && *p != 'c' ) // full row R#
578 {
579 if( p[0] != ':' || (p[1] != 'R' && p[1] != 'r' ) ||
580 NULL == (pTmp = lcl_r1c1_get_row( p+1, rDetails, &r.aEnd, &nFlags2 )))
581 {
582 // Only the initial row number is given, or the second row
583 // number is invalid. Fallback to just the initial R
584 nFlags |= (nFlags << 4);
585 r.aEnd.SetRow( r.aStart.Row() );
586 }
587 else
588 {
589 // Full row range successfully parsed.
590 nFlags |= (nFlags2 << 4);
591 p = pTmp;
592 }
593
594 if (p && p[0] != 0)
595 {
596 // any trailing invalid character must invalidate the whole address.
597 nFlags &= ~(SCA_VALID | SCA_VALID_COL | SCA_VALID_ROW | SCA_VALID_TAB);
598 return nFlags;
599 }
600
601 nFlags |=
602 SCA_VALID_COL | SCA_VALID_COL2 |
603 SCA_COL_ABSOLUTE | SCA_COL2_ABSOLUTE;
604 r.aStart.SetCol( 0 );
605 r.aEnd.SetCol( MAXCOL );
606
607 return bOnlyAcceptSingle ? 0 : nFlags;
608 }
609 else if( NULL == (p = lcl_r1c1_get_col( p, rDetails, &r.aStart, &nFlags )))
610 goto failed;
611
612 if( p[0] != ':' ||
613 (p[1] != 'R' && p[1] != 'r') ||
614 NULL == (pTmp = lcl_r1c1_get_row( p+1, rDetails, &r.aEnd, &nFlags2 )) ||
615 (*pTmp != 'C' && *pTmp != 'c') ||
616 NULL == (pTmp = lcl_r1c1_get_col( pTmp, rDetails, &r.aEnd, &nFlags2 )))
617 {
618 // single cell reference
619
620 if (p && p[0] != 0)
621 {
622 // any trailing invalid character must invalidate the whole address.
623 nFlags &= ~(SCA_VALID | SCA_VALID_COL | SCA_VALID_ROW | SCA_VALID_TAB);
624 return nFlags;
625 }
626
627 return bOnlyAcceptSingle ? nFlags : 0;
628 }
629 p = pTmp;
630
631 // double reference
632
633 if (p && p[0] != 0)
634 {
635 // any trailing invalid character must invalidate the whole range.
636 nFlags &= ~(SCA_VALID | SCA_VALID_COL | SCA_VALID_ROW | SCA_VALID_TAB |
637 SCA_VALID_COL2 | SCA_VALID_ROW2 | SCA_VALID_TAB2);
638 return nFlags;
639 }
640
641 nFlags |= (nFlags2 << 4);
642 return bOnlyAcceptSingle ? 0 : nFlags;
643 }
644 else if( *p == 'C' || *p == 'c' ) // full col C#
645 {
646 if( NULL == (p = lcl_r1c1_get_col( p, rDetails, &r.aStart, &nFlags )))
647 goto failed;
648
649 if( p[0] != ':' || (p[1] != 'C' && p[1] != 'c') ||
650 NULL == (pTmp = lcl_r1c1_get_col( p+1, rDetails, &r.aEnd, &nFlags2 )))
651 { // Fallback to just the initial C
652 nFlags |= (nFlags << 4);
653 r.aEnd.SetCol( r.aStart.Col() );
654 }
655 else
656 {
657 nFlags |= (nFlags2 << 4);
658 p = pTmp;
659 }
660
661 if (p && p[0] != 0)
662 {
663 // any trailing invalid character must invalidate the whole address.
664 nFlags &= ~(SCA_VALID | SCA_VALID_COL | SCA_VALID_ROW | SCA_VALID_TAB);
665 return nFlags;
666 }
667
668 nFlags |=
669 SCA_VALID_ROW | SCA_VALID_ROW2 |
670 SCA_ROW_ABSOLUTE | SCA_ROW2_ABSOLUTE;
671 r.aStart.SetRow( 0 );
672 r.aEnd.SetRow( MAXROW );
673
674 return bOnlyAcceptSingle ? 0 : nFlags;
675 }
676
677 failed :
678 return 0;
679 }
680
681 static inline const sal_Unicode*
682 lcl_a1_get_col( const sal_Unicode* p, ScAddress* pAddr, USHORT* nFlags )
683 {
684 SCCOL nCol;
685
686 if( *p == '$' )
687 *nFlags |= SCA_COL_ABSOLUTE, p++;
688
689 if( !CharClass::isAsciiAlpha( *p ) )
690 return NULL;
691
692 nCol = sal::static_int_cast<SCCOL>( toupper( char(*p++) ) - 'A' );
693 while (nCol <= MAXCOL && CharClass::isAsciiAlpha(*p))
694 nCol = sal::static_int_cast<SCCOL>( ((nCol + 1) * 26) + toupper( char(*p++) ) - 'A' );
695 if( nCol > MAXCOL || CharClass::isAsciiAlpha( *p ) )
696 return NULL;
697
698 *nFlags |= SCA_VALID_COL;
699 pAddr->SetCol( nCol );
700
701 return p;
702 }
703
704 static inline const sal_Unicode*
705 lcl_a1_get_row( const sal_Unicode* p, ScAddress* pAddr, USHORT* nFlags )
706 {
707 const sal_Unicode *pEnd;
708 long int n;
709
710 if( *p == '$' )
711 *nFlags |= SCA_ROW_ABSOLUTE, p++;
712
713 n = sal_Unicode_strtol( p, &pEnd ) - 1;
714 if( NULL == pEnd || p == pEnd || n < 0 || n > MAXROW )
715 return NULL;
716
717 *nFlags |= SCA_VALID_ROW;
718 pAddr->SetRow( static_cast<SCROW>(n) );
719
720 return pEnd;
721 }
722
723 static USHORT
724 lcl_ScRange_Parse_XL_A1( ScRange& r,
725 const sal_Unicode* p,
726 ScDocument* pDoc,
727 bool bOnlyAcceptSingle,
728 ScAddress::ExternalInfo* pExtInfo,
729 const uno::Sequence< const sheet::ExternalLinkInfo > * pExternalLinks )
730 {
731 const sal_Unicode* tmp1, *tmp2;
732 String aExternDocName, aStartTabName, aEndTabName; // for external link table
733 USHORT nFlags = SCA_VALID | SCA_VALID_TAB, nFlags2 = SCA_VALID_TAB;
734
735 #if 0
736 {
737 ByteString aStr(p, RTL_TEXTENCODING_UTF8);
738 aStr.Append(static_cast< char >(0));
739 std::cerr << "parse::XL::A1 \'" << aStr.GetBuffer() << '\'' << std::endl;
740 }
741 #endif
742 p = r.Parse_XL_Header( p, pDoc, aExternDocName, aStartTabName,
743 aEndTabName, nFlags, bOnlyAcceptSingle, pExternalLinks );
744
745 if (aExternDocName.Len() > 0)
746 lcl_ScRange_External_TabSpan( r, nFlags, pExtInfo, aExternDocName,
747 aStartTabName, aEndTabName, pDoc);
748
749 if( NULL == p )
750 return 0;
751
752 tmp1 = lcl_a1_get_col( p, &r.aStart, &nFlags );
753 if( tmp1 == NULL ) // Is it a row only reference 3:5
754 {
755 if( bOnlyAcceptSingle ) // by definition full row refs are ranges
756 return 0;
757
758 tmp1 = lcl_a1_get_row( p, &r.aStart, &nFlags );
759
760 tmp1 = lcl_eatWhiteSpace( tmp1 );
761 if( !tmp1 || *tmp1++ != ':' ) // Even a singleton requires ':' (eg 2:2)
762 return 0;
763
764 tmp1 = lcl_eatWhiteSpace( tmp1 );
765 tmp2 = lcl_a1_get_row( tmp1, &r.aEnd, &nFlags2 );
766 if( !tmp2 )
767 return 0;
768
769 r.aStart.SetCol( 0 ); r.aEnd.SetCol( MAXCOL );
770 nFlags |=
771 SCA_VALID_COL | SCA_VALID_COL2 |
772 SCA_COL_ABSOLUTE | SCA_COL2_ABSOLUTE;
773 nFlags |= (nFlags2 << 4);
774 return nFlags;
775 }
776
777 tmp2 = lcl_a1_get_row( tmp1, &r.aStart, &nFlags );
778 if( tmp2 == NULL ) // check for col only reference F:H
779 {
780 if( bOnlyAcceptSingle ) // by definition full col refs are ranges
781 return 0;
782
783 tmp1 = lcl_eatWhiteSpace( tmp1 );
784 if( *tmp1++ != ':' ) // Even a singleton requires ':' (eg F:F)
785 return 0;
786
787 tmp1 = lcl_eatWhiteSpace( tmp1 );
788 tmp2 = lcl_a1_get_col( tmp1, &r.aEnd, &nFlags2 );
789 if( !tmp2 )
790 return 0;
791
792 r.aStart.SetRow( 0 ); r.aEnd.SetRow( MAXROW );
793 nFlags |=
794 SCA_VALID_ROW | SCA_VALID_ROW2 |
795 SCA_ROW_ABSOLUTE | SCA_ROW2_ABSOLUTE;
796 nFlags |= (nFlags2 << 4);
797 return nFlags;
798 }
799
800 // prepare as if it's a singleton, in case we want to fall back */
801 r.aEnd.SetCol( r.aStart.Col() );
802 r.aEnd.SetRow( r.aStart.Row() ); // don't overwrite sheet number as parsed in Parse_XL_Header()
803
804 if ( bOnlyAcceptSingle )
805 {
806 if ( *tmp2 == 0 )
807 return nFlags;
808 else
809 {
810 // any trailing invalid character must invalidate the address.
811 nFlags &= ~(SCA_VALID | SCA_VALID_COL | SCA_VALID_ROW | SCA_VALID_TAB);
812 return nFlags;
813 }
814 }
815
816 tmp2 = lcl_eatWhiteSpace( tmp2 );
817 if( *tmp2 != ':' )
818 {
819 // Sheet1:Sheet2!C4 is a valid range, without a second sheet it is
820 // not. Any trailing invalid character invalidates the range.
821 if (*tmp2 == 0 && (nFlags & SCA_TAB2_3D))
822 {
823 if (nFlags & SCA_COL_ABSOLUTE)
824 nFlags |= SCA_COL2_ABSOLUTE;
825 if (nFlags & SCA_ROW_ABSOLUTE)
826 nFlags |= SCA_ROW2_ABSOLUTE;
827 }
828 else
829 nFlags &= ~(SCA_VALID |
830 SCA_VALID_COL | SCA_VALID_ROW | SCA_VALID_TAB |
831 SCA_VALID_COL2 | SCA_VALID_ROW2 | SCA_VALID_TAB2);
832 return nFlags;
833 }
834
835 p = tmp2;
836 p = lcl_eatWhiteSpace( p+1 );
837 tmp1 = lcl_a1_get_col( p, &r.aEnd, &nFlags2 );
838 if( !tmp1 ) // strange, but valid singleton
839 return nFlags;
840
841 tmp2 = lcl_a1_get_row( tmp1, &r.aEnd, &nFlags2 );
842 if( !tmp2 ) // strange, but valid singleton
843 return nFlags;
844
845 if ( *tmp2 != 0 )
846 {
847 // any trailing invalid character must invalidate the range.
848 nFlags &= ~(SCA_VALID | SCA_VALID_COL | SCA_VALID_ROW | SCA_VALID_TAB |
849 SCA_VALID_COL2 | SCA_VALID_ROW2 | SCA_VALID_TAB2);
850 return nFlags;
851 }
852
853 nFlags |= (nFlags2 << 4);
854 return nFlags;
855 }
856
857 /**
858 @param pRange pointer to range where rAddr effectively is *pRange->aEnd,
859 used in conjunction with pExtInfo to determine the tab span
860 of a 3D reference.
861 */
862 static USHORT
863 lcl_ScAddress_Parse_OOo( const sal_Unicode* p, ScDocument* pDoc, ScAddress& rAddr,
864 ScAddress::ExternalInfo* pExtInfo = NULL, ScRange* pRange = NULL )
865 {
866 USHORT nRes = 0;
867 String aDocName; // der pure Dokumentenname
868 String aTab;
869 bool bExtDoc = false;
870 bool bExtDocInherited = false;
871 const ScAddress aCurPos(rAddr);
872
873 // Lets see if this is a reference to something in an external file. A
874 // document name is always quoted and has a trailing #.
875 if (*p == '\'')
876 {
877 const sal_Unicode* pStart = p;
878 p = lcl_ParseQuotedName(p, aDocName);
879 if (*p++ == SC_COMPILER_FILE_TAB_SEP)
880 bExtDoc = true;
881 else
882 // This is not a document name. Perhaps a quoted relative table
883 // name.
884 p = pStart;
885 }
886 else if (pExtInfo && pExtInfo->mbExternal)
887 {
888 // This is an external reference.
889 bExtDoc = bExtDocInherited = true;
890 }
891
892 SCCOL nCol = 0;
893 SCROW nRow = 0;
894 SCTAB nTab = 0;
895 USHORT nBits = SCA_VALID_TAB;
896 const sal_Unicode* q;
897 if ( ScGlobal::FindUnquoted( p, '.') )
898 {
899 nRes |= SCA_TAB_3D;
900 if ( bExtDoc )
901 nRes |= SCA_TAB_ABSOLUTE;
902 if (*p == '$')
903 nRes |= SCA_TAB_ABSOLUTE, p++;
904
905 if (*p == '\'')
906 {
907 // Tokens that start at ' can have anything in them until a final
908 // ' but '' marks an escaped '. We've earlier guaranteed that a
909 // string containing '' will be surrounded by '.
910 p = lcl_ParseQuotedName(p, aTab);
911 }
912 else
913 {
914 while (*p)
915 {
916 if( *p == '.')
917 break;
918
919 if( *p == '\'' )
920 {
921 p++; break;
922 }
923 aTab += *p++;
924 }
925 }
926 if( *p++ != '.' )
927 nBits = 0;
928
929 if (!bExtDoc && (!pDoc || !pDoc->GetTable( aTab, nTab )))
930 nBits = 0;
931 }
932 else
933 {
934 if (bExtDoc && !bExtDocInherited)
935 return nRes; // After a document a sheet must follow.
936 nTab = rAddr.Tab();
937 }
938 nRes |= nBits;
939
940 q = p;
941 if (*p)
942 {
943 nBits = SCA_VALID_COL;
944 if (*p == '$')
945 nBits |= SCA_COL_ABSOLUTE, p++;
946
947 if (CharClass::isAsciiAlpha( *p ))
948 {
949 nCol = sal::static_int_cast<SCCOL>( toupper( char(*p++) ) - 'A' );
950 while (nCol < MAXCOL && CharClass::isAsciiAlpha(*p))
951 nCol = sal::static_int_cast<SCCOL>( ((nCol + 1) * 26) + toupper( char(*p++) ) - 'A' );
952 }
953 else
954 nBits = 0;
955
956 if( nCol > MAXCOL || CharClass::isAsciiAlpha( *p ) )
957 nBits = 0;
958 nRes |= nBits;
959 if( !nBits )
960 p = q;
961 }
962
963 q = p;
964 if (*p)
965 {
966 nBits = SCA_VALID_ROW;
967 if (*p == '$')
968 nBits |= SCA_ROW_ABSOLUTE, p++;
969 if( !CharClass::isAsciiDigit( *p ) )
970 {
971 nBits = 0;
972 nRow = SCROW(-1);
973 }
974 else
975 {
976 String aTmp( p );
977 long n = aTmp.ToInt32() - 1;
978 while (CharClass::isAsciiDigit( *p ))
979 p++;
980 if( n < 0 || n > MAXROW )
981 nBits = 0;
982 nRow = static_cast<SCROW>(n);
983 }
984 nRes |= nBits;
985 if( !nBits )
986 p = q;
987 }
988
989 rAddr.Set( nCol, nRow, nTab );
990
991 if (!*p && bExtDoc)
992 {
993 if (!pDoc)
994 nRes = 0;
995 else
996 {
997 ScExternalRefManager* pRefMgr = pDoc->GetExternalRefManager();
998
999 // Need document name if inherited.
1000 if (bExtDocInherited)
1001 {
1002 const String* pFileName = pRefMgr->getExternalFileName( pExtInfo->mnFileId);
1003 if (pFileName)
1004 aDocName = *pFileName;
1005 else
1006 nRes = 0;
1007 }
1008 pRefMgr->convertToAbsName(aDocName);
1009
1010 if ((!pExtInfo || !pExtInfo->mbExternal) && pRefMgr->isOwnDocument(aDocName))
1011 {
1012 if (!pDoc->GetTable( aTab, nTab ))
1013 nRes = 0;
1014 else
1015 {
1016 rAddr.SetTab( nTab);
1017 nRes |= SCA_VALID_TAB;
1018 }
1019 }
1020 else
1021 {
1022 if (!pExtInfo)
1023 nRes = 0;
1024 else
1025 {
1026 if (!pExtInfo->mbExternal)
1027 {
1028 sal_uInt16 nFileId = pRefMgr->getExternalFileId(aDocName);
1029
1030 pExtInfo->mbExternal = true;
1031 pExtInfo->maTabName = aTab;
1032 pExtInfo->mnFileId = nFileId;
1033
1034 if (pRefMgr->getSingleRefToken(nFileId, aTab,
1035 ScAddress(nCol, nRow, 0), NULL,
1036 &nTab).get())
1037 {
1038 rAddr.SetTab( nTab);
1039 nRes |= SCA_VALID_TAB;
1040 }
1041 else
1042 nRes = 0;
1043 }
1044 else
1045 {
1046 // This is a call for the second part of the reference,
1047 // we must have the range to adapt tab span.
1048 if (!pRange)
1049 nRes = 0;
1050 else
1051 {
1052 USHORT nFlags = nRes | SCA_VALID_TAB2;
1053 if (!lcl_ScRange_External_TabSpan( *pRange, nFlags,
1054 pExtInfo, aDocName,
1055 pExtInfo->maTabName, aTab, pDoc))
1056 nRes &= ~SCA_VALID_TAB;
1057 else
1058 {
1059 if (nFlags & SCA_VALID_TAB2)
1060 {
1061 rAddr.SetTab( pRange->aEnd.Tab());
1062 nRes |= SCA_VALID_TAB;
1063 }
1064 else
1065 nRes &= ~SCA_VALID_TAB;
1066 }
1067 }
1068 }
1069 }
1070 }
1071 }
1072 }
1073
1074 if ( !(nRes & SCA_VALID_ROW) && (nRes & SCA_VALID_COL)
1075 && !( (nRes & SCA_TAB_3D) && (nRes & SCA_VALID_TAB)) )
1076 { // no Row, no Tab, but Col => DM (...), B (...) et al
1077 nRes = 0;
1078 }
1079 if( !*p )
1080 {
1081 USHORT nMask = nRes & ( SCA_VALID_ROW | SCA_VALID_COL | SCA_VALID_TAB );
1082 if( nMask == ( SCA_VALID_ROW | SCA_VALID_COL | SCA_VALID_TAB ) )
1083 nRes |= SCA_VALID;
1084 }
1085 else
1086 nRes = 0;
1087 return nRes;
1088 }
1089
1090 static USHORT
1091 lcl_ScAddress_Parse ( const sal_Unicode* p, ScDocument* pDoc, ScAddress& rAddr,
1092 const ScAddress::Details& rDetails,
1093 ScAddress::ExternalInfo* pExtInfo = NULL,
1094 const uno::Sequence< const sheet::ExternalLinkInfo > * pExternalLinks = NULL )
1095 {
1096 if( !*p )
1097 return 0;
1098
1099 switch (rDetails.eConv)
1100 {
1101 default :
1102 case formula::FormulaGrammar::CONV_OOO:
1103 {
1104 return lcl_ScAddress_Parse_OOo( p, pDoc, rAddr, pExtInfo, NULL );
1105 }
1106
1107 case formula::FormulaGrammar::CONV_XL_A1:
1108 case formula::FormulaGrammar::CONV_XL_OOX:
1109 {
1110 ScRange r = rAddr;
1111 USHORT nFlags = lcl_ScRange_Parse_XL_A1( r, p, pDoc, true, pExtInfo,
1112 (rDetails.eConv == formula::FormulaGrammar::CONV_XL_OOX ? pExternalLinks : NULL) );
1113 rAddr = r.aStart;
1114 return nFlags;
1115 }
1116 case formula::FormulaGrammar::CONV_XL_R1C1:
1117 {
1118 ScRange r = rAddr;
1119 USHORT nFlags = lcl_ScRange_Parse_XL_R1C1( r, p, pDoc, rDetails, true, pExtInfo );
1120 rAddr = r.aStart;
1121 return nFlags;
1122 }
1123 }
1124 }
1125
1126
1127 bool ConvertSingleRef( ScDocument* pDoc, const String& rRefString,
1128 SCTAB nDefTab, ScRefAddress& rRefAddress,
1129 const ScAddress::Details& rDetails,
1130 ScAddress::ExternalInfo* pExtInfo /* = NULL */ )
1131 {
1132 bool bRet = false;
1133 if (pExtInfo || (ScGlobal::FindUnquoted( rRefString, SC_COMPILER_FILE_TAB_SEP) == STRING_NOTFOUND))
1134 {
1135 ScAddress aAddr( 0, 0, nDefTab );
1136 USHORT nRes = aAddr.Parse( rRefString, pDoc, rDetails, pExtInfo);
1137 if ( nRes & SCA_VALID )
1138 {
1139 rRefAddress.Set( aAddr,
1140 ((nRes & SCA_COL_ABSOLUTE) == 0),
1141 ((nRes & SCA_ROW_ABSOLUTE) == 0),
1142 ((nRes & SCA_TAB_ABSOLUTE) == 0));
1143 bRet = true;
1144 }
1145 }
1146 return bRet;
1147 }
1148
1149
1150 bool ConvertDoubleRef( ScDocument* pDoc, const String& rRefString, SCTAB nDefTab,
1151 ScRefAddress& rStartRefAddress, ScRefAddress& rEndRefAddress,
1152 const ScAddress::Details& rDetails,
1153 ScAddress::ExternalInfo* pExtInfo /* = NULL */ )
1154 {
1155 bool bRet = false;
1156 if (pExtInfo || (ScGlobal::FindUnquoted( rRefString, SC_COMPILER_FILE_TAB_SEP) == STRING_NOTFOUND))
1157 {
1158 ScRange aRange( ScAddress( 0, 0, nDefTab));
1159 USHORT nRes = aRange.Parse( rRefString, pDoc, rDetails, pExtInfo);
1160 if ( nRes & SCA_VALID )
1161 {
1162 rStartRefAddress.Set( aRange.aStart,
1163 ((nRes & SCA_COL_ABSOLUTE) == 0),
1164 ((nRes & SCA_ROW_ABSOLUTE) == 0),
1165 ((nRes & SCA_TAB_ABSOLUTE) == 0));
1166 rEndRefAddress.Set( aRange.aEnd,
1167 ((nRes & SCA_COL2_ABSOLUTE) == 0),
1168 ((nRes & SCA_ROW2_ABSOLUTE) == 0),
1169 ((nRes & SCA_TAB2_ABSOLUTE) == 0));
1170 bRet = true;
1171 }
1172 }
1173 return bRet;
1174 }
1175
1176
1177 USHORT ScAddress::Parse( const String& r, ScDocument* pDoc,
1178 const Details& rDetails,
1179 ExternalInfo* pExtInfo,
1180 const uno::Sequence< const sheet::ExternalLinkInfo > * pExternalLinks )
1181 {
1182 return lcl_ScAddress_Parse( r.GetBuffer(), pDoc, *this, rDetails, pExtInfo, pExternalLinks );
1183 }
1184
1185
1186 bool ScRange::Intersects( const ScRange& r ) const
1187 {
1188 return !(
1189 Min( aEnd.Col(), r.aEnd.Col() ) < Max( aStart.Col(), r.aStart.Col() )
1190 || Min( aEnd.Row(), r.aEnd.Row() ) < Max( aStart.Row(), r.aStart.Row() )
1191 || Min( aEnd.Tab(), r.aEnd.Tab() ) < Max( aStart.Tab(), r.aStart.Tab() )
1192 );
1193 }
1194
1195
1196 void ScRange::Justify()
1197 {
1198 SCCOL nTempCol;
1199 if ( aEnd.Col() < (nTempCol = aStart.Col()) )
1200 {
1201 aStart.SetCol(aEnd.Col()); aEnd.SetCol(nTempCol);
1202 }
1203 SCROW nTempRow;
1204 if ( aEnd.Row() < (nTempRow = aStart.Row()) )
1205 {
1206 aStart.SetRow(aEnd.Row()); aEnd.SetRow(nTempRow);
1207 }
1208 SCTAB nTempTab;
1209 if ( aEnd.Tab() < (nTempTab = aStart.Tab()) )
1210 {
1211 aStart.SetTab(aEnd.Tab()); aEnd.SetTab(nTempTab);
1212 }
1213 }
1214
1215 void ScRange::ExtendTo( const ScRange& rRange )
1216 {
1217 DBG_ASSERT( rRange.IsValid(), "ScRange::ExtendTo - cannot extend to invalid range" );
1218 if( IsValid() )
1219 {
1220 aStart.SetCol( ::std::min( aStart.Col(), rRange.aStart.Col() ) );
1221 aStart.SetRow( ::std::min( aStart.Row(), rRange.aStart.Row() ) );
1222 aStart.SetTab( ::std::min( aStart.Tab(), rRange.aStart.Tab() ) );
1223 aEnd.SetCol( ::std::max( aEnd.Col(), rRange.aEnd.Col() ) );
1224 aEnd.SetRow( ::std::max( aEnd.Row(), rRange.aEnd.Row() ) );
1225 aEnd.SetTab( ::std::max( aEnd.Tab(), rRange.aEnd.Tab() ) );
1226 }
1227 else
1228 *this = rRange;
1229 }
1230
1231 static USHORT
1232 lcl_ScRange_Parse_OOo( ScRange &aRange, const String& r, ScDocument* pDoc, ScAddress::ExternalInfo* pExtInfo = NULL )
1233 {
1234 USHORT nRes1 = 0, nRes2 = 0;
1235 xub_StrLen nPos = ScGlobal::FindUnquoted( r, ':');
1236 if (nPos != STRING_NOTFOUND)
1237 {
1238 String aTmp( r );
1239 sal_Unicode* p = aTmp.GetBufferAccess();
1240 p[ nPos ] = 0;
1241 if( (nRes1 = lcl_ScAddress_Parse_OOo( p, pDoc, aRange.aStart, pExtInfo, NULL ) ) != 0 )
1242 {
1243 aRange.aEnd = aRange.aStart; // sheet must be initialized identical to first sheet
1244 if ( (nRes2 = lcl_ScAddress_Parse_OOo( p + nPos+ 1, pDoc, aRange.aEnd, pExtInfo, &aRange ) ) != 0 )
1245 {
1246 // PutInOrder / Justify
1247 USHORT nMask, nBits1, nBits2;
1248 SCCOL nTempCol;
1249 if ( aRange.aEnd.Col() < (nTempCol = aRange.aStart.Col()) )
1250 {
1251 aRange.aStart.SetCol(aRange.aEnd.Col()); aRange.aEnd.SetCol(nTempCol);
1252 nMask = (SCA_VALID_COL | SCA_COL_ABSOLUTE);
1253 nBits1 = nRes1 & nMask;
1254 nBits2 = nRes2 & nMask;
1255 nRes1 = (nRes1 & ~nMask) | nBits2;
1256 nRes2 = (nRes2 & ~nMask) | nBits1;
1257 }
1258 SCROW nTempRow;
1259 if ( aRange.aEnd.Row() < (nTempRow = aRange.aStart.Row()) )
1260 {
1261 aRange.aStart.SetRow(aRange.aEnd.Row()); aRange.aEnd.SetRow(nTempRow);
1262 nMask = (SCA_VALID_ROW | SCA_ROW_ABSOLUTE);
1263 nBits1 = nRes1 & nMask;
1264 nBits2 = nRes2 & nMask;
1265 nRes1 = (nRes1 & ~nMask) | nBits2;
1266 nRes2 = (nRes2 & ~nMask) | nBits1;
1267 }
1268 SCTAB nTempTab;
1269 if ( aRange.aEnd.Tab() < (nTempTab = aRange.aStart.Tab()) )
1270 {
1271 aRange.aStart.SetTab(aRange.aEnd.Tab()); aRange.aEnd.SetTab(nTempTab);
1272 nMask = (SCA_VALID_TAB | SCA_TAB_ABSOLUTE | SCA_TAB_3D);
1273 nBits1 = nRes1 & nMask;
1274 nBits2 = nRes2 & nMask;
1275 nRes1 = (nRes1 & ~nMask) | nBits2;
1276 nRes2 = (nRes2 & ~nMask) | nBits1;
1277 }
1278 if ( ((nRes1 & ( SCA_TAB_ABSOLUTE | SCA_TAB_3D ))
1279 == ( SCA_TAB_ABSOLUTE | SCA_TAB_3D ))
1280 && !(nRes2 & SCA_TAB_3D) )
1281 nRes2 |= SCA_TAB_ABSOLUTE;
1282 }
1283 else
1284 nRes1 = 0; // #38840# keine Tokens aus halben Sachen
1285 }
1286 }
1287 nRes1 = ( ( nRes1 | nRes2 ) & SCA_VALID )
1288 | nRes1
1289 | ( ( nRes2 & SCA_BITS ) << 4 );
1290 return nRes1;
1291 }
1292
1293 USHORT ScRange::Parse( const String& r, ScDocument* pDoc,
1294 const ScAddress::Details& rDetails,
1295 ScAddress::ExternalInfo* pExtInfo,
1296 const uno::Sequence< const sheet::ExternalLinkInfo > * pExternalLinks )
1297 {
1298 if ( r.Len() <= 0 )
1299 return 0;
1300
1301 switch (rDetails.eConv)
1302 {
1303 default :
1304 case formula::FormulaGrammar::CONV_OOO:
1305 return lcl_ScRange_Parse_OOo( *this, r, pDoc, pExtInfo );
1306
1307 case formula::FormulaGrammar::CONV_XL_A1:
1308 case formula::FormulaGrammar::CONV_XL_OOX:
1309 return lcl_ScRange_Parse_XL_A1( *this, r.GetBuffer(), pDoc, false, pExtInfo,
1310 (rDetails.eConv == formula::FormulaGrammar::CONV_XL_OOX ? pExternalLinks : NULL) );
1311
1312 case formula::FormulaGrammar::CONV_XL_R1C1:
1313 return lcl_ScRange_Parse_XL_R1C1( *this, r.GetBuffer(), pDoc, rDetails, false, pExtInfo );
1314 }
1315 }
1316
1317
1318 // Accept a full range, or an address
1319 USHORT ScRange::ParseAny( const String& r, ScDocument* pDoc,
1320 const ScAddress::Details& rDetails )
1321 {
1322 USHORT nRet = Parse( r, pDoc, rDetails );
1323 const USHORT nValid = SCA_VALID | SCA_VALID_COL2 | SCA_VALID_ROW2 |
1324 SCA_VALID_TAB2;
1325
1326 if ( (nRet & nValid) != nValid )
1327 {
1328 ScAddress aAdr;
1329 nRet = aAdr.Parse( r, pDoc, rDetails );
1330 if ( nRet & SCA_VALID )
1331 aStart = aEnd = aAdr;
1332 }
1333 return nRet;
1334 }
1335
1336 // Parse only full row references
1337 USHORT ScRange::ParseCols( const String& rStr, ScDocument* pDoc,
1338 const ScAddress::Details& rDetails )
1339 {
1340 const sal_Unicode* p = rStr.GetBuffer();
1341 USHORT nRes = 0, ignored = 0;
1342
1343 if( NULL == p )
1344 return 0;
1345
1346 pDoc = NULL; // make compiler shutup we may need this later
1347
1348 switch (rDetails.eConv)
1349 {
1350 default :
1351 case formula::FormulaGrammar::CONV_OOO: // No full col refs in OOO yet, assume XL notation
1352 case formula::FormulaGrammar::CONV_XL_A1:
1353 case formula::FormulaGrammar::CONV_XL_OOX:
1354 if (NULL != (p = lcl_a1_get_col( p, &aStart, &ignored ) ) )
1355 {
1356 if( p[0] == ':')
1357 {
1358 if( NULL != (p = lcl_a1_get_col( p+1, &aEnd, &ignored )))
1359 {
1360 nRes = SCA_VALID_COL;
1361 }
1362 }
1363 else
1364 {
1365 aEnd = aStart;
1366 nRes = SCA_VALID_COL;
1367 }
1368 }
1369 break;
1370
1371 case formula::FormulaGrammar::CONV_XL_R1C1:
1372 if ((p[0] == 'C' || p[0] != 'c') &&
1373 NULL != (p = lcl_r1c1_get_col( p, rDetails, &aStart, &ignored )))
1374 {
1375 if( p[0] == ':')
1376 {
1377 if( (p[1] == 'C' || p[1] == 'c') &&
1378 NULL != (p = lcl_r1c1_get_col( p+1, rDetails, &aEnd, &ignored )))
1379 {
1380 nRes = SCA_VALID_COL;
1381 }
1382 }
1383 else
1384 {
1385 aEnd = aStart;
1386 nRes = SCA_VALID_COL;
1387 }
1388 }
1389 break;
1390 }
1391
1392 return (p != NULL && *p == '\0') ? nRes : 0;
1393 }
1394
1395 // Parse only full row references
1396 USHORT ScRange::ParseRows( const String& rStr, ScDocument* pDoc,
1397 const ScAddress::Details& rDetails )
1398 {
1399 const sal_Unicode* p = rStr.GetBuffer();
1400 USHORT nRes = 0, ignored = 0;
1401
1402 if( NULL == p )
1403 return 0;
1404
1405 pDoc = NULL; // make compiler shutup we may need this later
1406
1407 switch (rDetails.eConv)
1408 {
1409 default :
1410 case formula::FormulaGrammar::CONV_OOO: // No full row refs in OOO yet, assume XL notation
1411 case formula::FormulaGrammar::CONV_XL_A1:
1412 case formula::FormulaGrammar::CONV_XL_OOX:
1413 if (NULL != (p = lcl_a1_get_row( p, &aStart, &ignored ) ) )
1414 {
1415 if( p[0] == ':')
1416 {
1417 if( NULL != (p = lcl_a1_get_row( p+1, &aEnd, &ignored )))
1418 {
1419 nRes = SCA_VALID_COL;
1420 }
1421 }
1422 else
1423 {
1424 aEnd = aStart;
1425 nRes = SCA_VALID_COL;
1426 }
1427 }
1428 break;
1429
1430 case formula::FormulaGrammar::CONV_XL_R1C1:
1431 if ((p[0] == 'R' || p[0] != 'r') &&
1432 NULL != (p = lcl_r1c1_get_row( p, rDetails, &aStart, &ignored )))
1433 {
1434 if( p[0] == ':')
1435 {
1436 if( (p[1] == 'R' || p[1] == 'r') &&
1437 NULL != (p = lcl_r1c1_get_row( p+1, rDetails, &aEnd, &ignored )))
1438 {
1439 nRes = SCA_VALID_COL;
1440 }
1441 }
1442 else
1443 {
1444 aEnd = aStart;
1445 nRes = SCA_VALID_COL;
1446 }
1447 }
1448 break;
1449 }
1450
1451 return (p != NULL && *p == '\0') ? nRes : 0;
1452 }
1453
1454 static inline void
1455 lcl_a1_append_c ( String &r, int nCol, bool bIsAbs )
1456 {
1457 if( bIsAbs )
1458 r += '$';
1459 ScColToAlpha( r, sal::static_int_cast<SCCOL>(nCol) );
1460 }
1461
1462 static inline void
1463 lcl_a1_append_r ( String &r, int nRow, bool bIsAbs )
1464 {
1465 if ( bIsAbs )
1466 r += '$';
1467 r += String::CreateFromInt32( nRow+1 );
1468 }
1469
1470 static inline void
1471 lcl_r1c1_append_c ( String &r, int nCol, bool bIsAbs,
1472 const ScAddress::Details& rDetails )
1473 {
1474 r += 'C';
1475 if (bIsAbs)
1476 {
1477 r += String::CreateFromInt32( nCol + 1 );
1478 }
1479 else
1480 {
1481 nCol -= rDetails.nCol;
1482 if (nCol != 0) {
1483 r += '[';
1484 r += String::CreateFromInt32( nCol );
1485 r += ']';
1486 }
1487 }
1488 }
1489 static inline void
1490 lcl_r1c1_append_r ( String &r, int nRow, bool bIsAbs,
1491 const ScAddress::Details& rDetails )
1492 {
1493 r += 'R';
1494 if (bIsAbs)
1495 {
1496 r += String::CreateFromInt32( nRow + 1 );
1497 }
1498 else
1499 {
1500 nRow -= rDetails.nRow;
1501 if (nRow != 0) {
1502 r += '[';
1503 r += String::CreateFromInt32( nRow );
1504 r += ']';
1505 }
1506 }
1507 }
1508
1509 static String
1510 getFileNameFromDoc( const ScDocument* pDoc )
1511 {
1512 // TODO : er points at ScGlobal::GetAbsDocName()
1513 // as a better template. Look into it
1514 String sFileName;
1515 SfxObjectShell* pShell;
1516
1517 if( NULL != pDoc &&
1518 NULL != (pShell = pDoc->GetDocumentShell() ) )
1519 {
1520 uno::Reference< frame::XModel > xModel( pShell->GetModel(), uno::UNO_QUERY );
1521 if( xModel.is() )
1522 {
1523 if( xModel->getURL().getLength() )
1524 {
1525 INetURLObject aURL( xModel->getURL() );
1526 sFileName = aURL.GetLastName();
1527 }
1528 else
1529 sFileName = pShell->GetTitle();
1530 }
1531 }
1532 #if 0
1533 {
1534 ByteString aStr( sFileName, RTL_TEXTENCODING_UTF8 );
1535 aStr.Append(static_cast< char >(0));
1536 std::cerr << "docname \'" << aStr.GetBuffer() << '\'' << std::endl;
1537 }
1538 #endif
1539 return sFileName;
1540 }
1541
1542 void ScAddress::Format( String& r, USHORT nFlags, ScDocument* pDoc,
1543 const Details& rDetails) const
1544 {
1545 r.Erase();
1546 if( nFlags & SCA_VALID )
1547 nFlags |= ( SCA_VALID_ROW | SCA_VALID_COL | SCA_VALID_TAB );
1548 if( pDoc && (nFlags & SCA_VALID_TAB ) )
1549 {
1550 if ( nTab >= pDoc->GetTableCount() )
1551 {
1552 r = ScGlobal::GetRscString( STR_NOREF_STR );
1553 return;
1554 }
1555 // if( nFlags & ( SCA_TAB_ABSOLUTE | SCA_TAB_3D ) )
1556 if( nFlags & SCA_TAB_3D )
1557 {
1558 String aTabName, aDocName;
1559 pDoc->GetName( nTab, aTabName );
1560 // External Reference, same as in ScCompiler::MakeTabStr()
1561 if( aTabName.GetChar(0) == '\'' )
1562 { // "'Doc'#Tab"
1563 xub_StrLen nPos = ScGlobal::FindUnquoted( aTabName, SC_COMPILER_FILE_TAB_SEP);
1564 if (nPos != STRING_NOTFOUND && nPos > 0 && aTabName.GetChar(nPos-1) == '\'')
1565 {
1566 aDocName = aTabName.Copy( 0, nPos + 1 );
1567 aTabName.Erase( 0, nPos + 1 );
1568 }
1569 }
1570 else if( nFlags & SCA_FORCE_DOC )
1571 {
1572 // VBA has an 'external' flag that forces the addition of the
1573 // tab name _and_ the doc name. The VBA code would be
1574 // needlessly complicated if it constructed an actual external
1575 // reference so we add this somewhat cheesy kludge to force the
1576 // addition of the document name even for non-external references
1577 aDocName = getFileNameFromDoc( pDoc );
1578 }
1579 ScCompiler::CheckTabQuotes( aTabName, rDetails.eConv);
1580
1581 switch( rDetails.eConv )
1582 {
1583 default :
1584 case formula::FormulaGrammar::CONV_OOO:
1585 r += aDocName;
1586 if( nFlags & SCA_TAB_ABSOLUTE )
1587 r += '$';
1588 r += aTabName;
1589 r += '.';
1590 break;
1591
1592 case formula::FormulaGrammar::CONV_XL_A1:
1593 case formula::FormulaGrammar::CONV_XL_R1C1:
1594 case formula::FormulaGrammar::CONV_XL_OOX:
1595 if (aDocName.Len() > 0)
1596 {
1597 r += '[';
1598 r += aDocName;
1599 r += ']';
1600 }
1601 r += aTabName;
1602 r += '!';
1603 break;
1604 }
1605 }
1606 }
1607 switch( rDetails.eConv )
1608 {
1609 default :
1610 case formula::FormulaGrammar::CONV_OOO:
1611 case formula::FormulaGrammar::CONV_XL_A1:
1612 case formula::FormulaGrammar::CONV_XL_OOX:
1613 if( nFlags & SCA_VALID_COL )
1614 lcl_a1_append_c ( r, nCol, nFlags & SCA_COL_ABSOLUTE );
1615 if( nFlags & SCA_VALID_ROW )
1616 lcl_a1_append_r ( r, nRow, nFlags & SCA_ROW_ABSOLUTE );
1617 break;
1618
1619 case formula::FormulaGrammar::CONV_XL_R1C1:
1620 if( nFlags & SCA_VALID_ROW )
1621 lcl_r1c1_append_r ( r, nRow, nFlags & SCA_ROW_ABSOLUTE, rDetails );
1622 if( nFlags & SCA_VALID_COL )
1623 lcl_r1c1_append_c ( r, nCol, nFlags & SCA_COL_ABSOLUTE, rDetails );
1624 break;
1625 }
1626 }
1627
1628 static void
1629 lcl_Split_DocTab( const ScDocument* pDoc, SCTAB nTab,
1630 const ScAddress::Details& rDetails,
1631 USHORT nFlags,
1632 String& rTabName, String& rDocName )
1633 {
1634 pDoc->GetName( nTab, rTabName );
1635 rDocName.Erase();
1636 #if 0
1637 {
1638 ByteString aStr(rTabName, RTL_TEXTENCODING_UTF8);
1639 aStr.Append(static_cast< char >(0));
1640 std::cerr << "tabname \'" << aStr.GetBuffer() << '\'' << std::endl;
1641 }
1642 #endif
1643 // External reference, same as in ScCompiler::MakeTabStr()
1644 if ( rTabName.GetChar(0) == '\'' )
1645 { // "'Doc'#Tab"
1646 xub_StrLen nPos = ScGlobal::FindUnquoted( rTabName, SC_COMPILER_FILE_TAB_SEP);
1647 if (nPos != STRING_NOTFOUND && nPos > 0 && rTabName.GetChar(nPos-1) == '\'')
1648 {
1649 rDocName = rTabName.Copy( 0, nPos + 1 );
1650 rTabName.Erase( 0, nPos + 1 );
1651 }
1652 }
1653 else if( nFlags & SCA_FORCE_DOC )
1654 {
1655 // VBA has an 'external' flag that forces the addition of the
1656 // tab name _and_ the doc name. The VBA code would be
1657 // needlessly complicated if it constructed an actual external
1658 // reference so we add this somewhat cheesy kludge to force the
1659 // addition of the document name even for non-external references
1660 rDocName = getFileNameFromDoc( pDoc );
1661 }
1662 ScCompiler::CheckTabQuotes( rTabName, rDetails.eConv);
1663 }
1664
1665 static void
1666 lcl_ScRange_Format_XL_Header( String& r, const ScRange& rRange,
1667 USHORT nFlags, ScDocument* pDoc,
1668 const ScAddress::Details& rDetails )
1669 {
1670 if( nFlags & SCA_TAB_3D )
1671 {
1672 String aTabName, aDocName;
1673 lcl_Split_DocTab( pDoc, rRange.aStart.Tab(), rDetails, nFlags,
1674 aTabName, aDocName );
1675 if( aDocName.Len() > 0 )
1676 {
1677 r += '[';
1678 r += aDocName;
1679 r += ']';
1680 }
1681 r += aTabName;
1682
1683 if( nFlags & SCA_TAB2_3D )
1684 {
1685 lcl_Split_DocTab( pDoc, rRange.aEnd.Tab(), rDetails, nFlags,
1686 aTabName, aDocName );
1687 r += ':';
1688 r += aTabName;
1689 }
1690 r += '!';
1691 }
1692 }
1693
1694 void ScRange::Format( String& r, USHORT nFlags, ScDocument* pDoc,
1695 const ScAddress::Details& rDetails ) const
1696 {
1697 r.Erase();
1698 if( !( nFlags & SCA_VALID ) )
1699 {
1700 r = ScGlobal::GetRscString( STR_NOREF_STR );
1701 return;
1702 }
1703
1704 #define absrel_differ(nFlags, mask) (((nFlags) & (mask)) ^ (((nFlags) >> 4) & (mask)))
1705 switch( rDetails.eConv ) {
1706 default :
1707 case formula::FormulaGrammar::CONV_OOO: {
1708 BOOL bOneTab = (aStart.Tab() == aEnd.Tab());
1709 if ( !bOneTab )
1710 nFlags |= SCA_TAB_3D;
1711 aStart.Format( r, nFlags, pDoc, rDetails );
1712 if( aStart != aEnd ||
1713 absrel_differ( nFlags, SCA_COL_ABSOLUTE ) ||
1714 absrel_differ( nFlags, SCA_ROW_ABSOLUTE ))
1715 {
1716 String aName;
1717 nFlags = ( nFlags & SCA_VALID ) | ( ( nFlags >> 4 ) & 0x070F );
1718 if ( bOneTab )
1719 pDoc = NULL;
1720 else
1721 nFlags |= SCA_TAB_3D;
1722 aEnd.Format( aName, nFlags, pDoc, rDetails );
1723 r += ':';
1724 r += aName;
1725 }
1726 }
1727 break;
1728
1729 case formula::FormulaGrammar::CONV_XL_A1:
1730 case formula::FormulaGrammar::CONV_XL_OOX:
1731 lcl_ScRange_Format_XL_Header( r, *this, nFlags, pDoc, rDetails );
1732 if( aStart.Col() == 0 && aEnd.Col() >= MAXCOL )
1733 {
1734 // Full col refs always require 2 rows (2:2)
1735 lcl_a1_append_r( r, aStart.Row(), nFlags & SCA_ROW_ABSOLUTE );
1736 r += ':';
1737 lcl_a1_append_r( r, aEnd.Row(), nFlags & SCA_ROW2_ABSOLUTE );
1738 }
1739 else if( aStart.Row() == 0 && aEnd.Row() >= MAXROW )
1740 {
1741 // Full row refs always require 2 cols (A:A)
1742 lcl_a1_append_c( r, aStart.Col(), nFlags & SCA_COL_ABSOLUTE );
1743 r += ':';
1744 lcl_a1_append_c( r, aEnd.Col(), nFlags & SCA_COL2_ABSOLUTE );
1745 }
1746 else
1747 {
1748 lcl_a1_append_c ( r, aStart.Col(), nFlags & SCA_COL_ABSOLUTE );
1749 lcl_a1_append_r ( r, aStart.Row(), nFlags & SCA_ROW_ABSOLUTE );
1750 if( aStart.Col() != aEnd.Col() ||
1751 absrel_differ( nFlags, SCA_COL_ABSOLUTE ) ||
1752 aStart.Row() != aEnd.Row() ||
1753 absrel_differ( nFlags, SCA_ROW_ABSOLUTE )) {
1754 r += ':';
1755 lcl_a1_append_c ( r, aEnd.Col(), nFlags & SCA_COL2_ABSOLUTE );
1756 lcl_a1_append_r ( r, aEnd.Row(), nFlags & SCA_ROW2_ABSOLUTE );
1757 }
1758 }
1759 break;
1760
1761 case formula::FormulaGrammar::CONV_XL_R1C1:
1762 lcl_ScRange_Format_XL_Header( r, *this, nFlags, pDoc, rDetails );
1763 if( aStart.Col() == 0 && aEnd.Col() >= MAXCOL )
1764 {
1765 lcl_r1c1_append_r( r, aStart.Row(), nFlags & SCA_ROW_ABSOLUTE, rDetails );
1766 if( aStart.Row() != aEnd.Row() ||
1767 absrel_differ( nFlags, SCA_ROW_ABSOLUTE )) {
1768 r += ':';
1769 lcl_r1c1_append_r( r, aEnd.Row(), nFlags & SCA_ROW2_ABSOLUTE, rDetails );
1770 }
1771 }
1772 else if( aStart.Row() == 0 && aEnd.Row() >= MAXROW )
1773 {
1774 lcl_r1c1_append_c( r, aStart.Col(), nFlags & SCA_COL_ABSOLUTE, rDetails );
1775 if( aStart.Col() != aEnd.Col() ||
1776 absrel_differ( nFlags, SCA_COL_ABSOLUTE )) {
1777 r += ':';
1778 lcl_r1c1_append_c( r, aEnd.Col(), nFlags & SCA_COL2_ABSOLUTE, rDetails );
1779 }
1780 }
1781 else
1782 {
1783 lcl_r1c1_append_r( r, aStart.Row(), nFlags & SCA_ROW_ABSOLUTE, rDetails );
1784 lcl_r1c1_append_c( r, aStart.Col(), nFlags & SCA_COL_ABSOLUTE, rDetails );
1785 if( aStart.Col() != aEnd.Col() ||
1786 absrel_differ( nFlags, SCA_COL_ABSOLUTE ) ||
1787 aStart.Row() != aEnd.Row() ||
1788 absrel_differ( nFlags, SCA_ROW_ABSOLUTE )) {
1789 r += ':';
1790 lcl_r1c1_append_r( r, aEnd.Row(), nFlags & SCA_ROW2_ABSOLUTE, rDetails );
1791 lcl_r1c1_append_c( r, aEnd.Col(), nFlags & SCA_COL2_ABSOLUTE, rDetails );
1792 }
1793 }
1794 }
1795 #undef absrel_differ
1796 }
1797
1798 bool ScAddress::Move( SCsCOL dx, SCsROW dy, SCsTAB dz, ScDocument* pDoc )
1799 {
1800 SCsTAB nMaxTab = pDoc ? pDoc->GetTableCount() : MAXTAB+1;
1801 dx = Col() + dx;
1802 dy = Row() + dy;
1803 dz = Tab() + dz;
1804 BOOL bValid = TRUE;
1805 if( dx < 0 )
1806 dx = 0, bValid = FALSE;
1807 else if( dx > MAXCOL )
1808 dx = MAXCOL, bValid =FALSE;
1809 if( dy < 0 )
1810 dy = 0, bValid = FALSE;
1811 else if( dy > MAXROW )
1812 dy = MAXROW, bValid =FALSE;
1813 if( dz < 0 )
1814 dz = 0, bValid = FALSE;
1815 else if( dz >= nMaxTab )
1816 dz = nMaxTab-1, bValid =FALSE;
1817 Set( dx, dy, dz );
1818 return bValid;
1819 }
1820
1821
1822 bool ScRange::Move( SCsCOL dx, SCsROW dy, SCsTAB dz, ScDocument* pDoc )
1823 {
1824 // Einfahces &, damit beides ausgefuehrt wird!!
1825 return aStart.Move( dx, dy, dz, pDoc ) & aEnd.Move( dx, dy, dz, pDoc );
1826 }
1827
1828
1829 String ScAddress::GetColRowString( bool bAbsolute,
1830 const Details& rDetails ) const
1831 {
1832 String aString;
1833
1834 switch( rDetails.eConv )
1835 {
1836 default :
1837 case formula::FormulaGrammar::CONV_OOO:
1838 case formula::FormulaGrammar::CONV_XL_A1:
1839 case formula::FormulaGrammar::CONV_XL_OOX:
1840 if (bAbsolute)
1841 aString.Append( '$' );
1842
1843 ScColToAlpha( aString, nCol);
1844
1845 if ( bAbsolute )
1846 aString.Append( '$' );
1847
1848 aString += String::CreateFromInt32(nRow+1);
1849 break;
1850
1851 case formula::FormulaGrammar::CONV_XL_R1C1:
1852 lcl_r1c1_append_r ( aString, nRow, bAbsolute, rDetails );
1853 lcl_r1c1_append_c ( aString, nCol, bAbsolute, rDetails );
1854 break;
1855 }
1856
1857 return aString;
1858 }
1859
1860
1861 String ScRefAddress::GetRefString( ScDocument* pDoc, SCTAB nActTab,
1862 const ScAddress::Details& rDetails ) const
1863 {
1864 if ( !pDoc )
1865 return EMPTY_STRING;
1866 if ( Tab()+1 > pDoc->GetTableCount() )
1867 return ScGlobal::GetRscString( STR_NOREF_STR );
1868
1869 String aString;
1870 USHORT nFlags = SCA_VALID;
1871 if ( nActTab != Tab() )
1872 {
1873 nFlags |= SCA_TAB_3D;
1874 if ( !bRelTab )
1875 nFlags |= SCA_TAB_ABSOLUTE;
1876 }
1877 if ( !bRelCol )
1878 nFlags |= SCA_COL_ABSOLUTE;
1879 if ( !bRelRow )
1880 nFlags |= SCA_ROW_ABSOLUTE;
1881
1882 aAdr.Format( aString, nFlags, pDoc, rDetails );
1883
1884 return aString;
1885 }
1886
1887 //------------------------------------------------------------------------
1888
1889 void ScColToAlpha( rtl::OUStringBuffer& rBuf, SCCOL nCol )
1890 {
1891 if (nCol < 26*26)
1892 {
1893 if (nCol < 26)
1894 rBuf.append( static_cast<sal_Unicode>( 'A' +
1895 static_cast<sal_uInt16>(nCol)));
1896 else
1897 {
1898 rBuf.append( static_cast<sal_Unicode>( 'A' +
1899 (static_cast<sal_uInt16>(nCol) / 26) - 1));
1900 rBuf.append( static_cast<sal_Unicode>( 'A' +
1901 (static_cast<sal_uInt16>(nCol) % 26)));
1902 }
1903 }
1904 else
1905 {
1906 String aStr;
1907 while (nCol >= 26)
1908 {
1909 SCCOL nC = nCol % 26;
1910 aStr += static_cast<sal_Unicode>( 'A' +
1911 static_cast<sal_uInt16>(nC));
1912 nCol = sal::static_int_cast<SCCOL>( nCol - nC );
1913 nCol = nCol / 26 - 1;
1914 }
1915 aStr += static_cast<sal_Unicode>( 'A' +
1916 static_cast<sal_uInt16>(nCol));
1917 aStr.Reverse();
1918 rBuf.append( aStr);
1919 }
1920 }
1921
1922
1923 bool AlphaToCol( SCCOL& rCol, const String& rStr)
1924 {
1925 SCCOL nResult = 0;
1926 xub_StrLen nStop = rStr.Len();
1927 xub_StrLen nPos = 0;
1928 sal_Unicode c;
1929 while (nResult <= MAXCOL && nPos < nStop && (c = rStr.GetChar( nPos)) != 0 &&
1930 CharClass::isAsciiAlpha(c))
1931 {
1932 if (nPos > 0)
1933 nResult = (nResult + 1) * 26;
1934 nResult += ScGlobal::ToUpperAlpha(c) - 'A';
1935 ++nPos;
1936 }
1937 bool bOk = (ValidCol(nResult) && nPos > 0);
1938 if (bOk)
1939 rCol = nResult;
1940 return bOk;
1941 }
vba interoperability for OOo