Debian Codegraph @

basic/source/sbx/sbxbool.cxx

raw
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 <comphelper/errcode.hxx>
21 #include <basic/sberrors.hxx>
22 #include "sbxconv.hxx"
23 #include "sbxres.hxx"
24
25 enum SbxBOOL ImpGetBool( const SbxValues* p )
26 {
27 auto SbxBoolFrom = [](auto val) { return val != 0 ? SbxTRUE : SbxFALSE; };
28 switch( +p->eType )
29 {
30 case SbxEMPTY:
31 return SbxFALSE;
32 case SbxCHAR:
33 return SbxBoolFrom(p->nChar);
34 case SbxBYREF | SbxCHAR:
35 return SbxBoolFrom(*p->pChar);
36 case SbxBYTE:
37 return SbxBoolFrom(p->nByte);
38 case SbxBYREF | SbxBYTE:
39 return SbxBoolFrom(*p->pByte);
40 case SbxINTEGER:
41 case SbxBOOL:
42 return SbxBoolFrom(p->nInteger);
43 case SbxBYREF | SbxINTEGER:
44 case SbxBYREF | SbxBOOL:
45 return SbxBoolFrom(*p->pInteger);
46 case SbxERROR:
47 case SbxUSHORT:
48 return SbxBoolFrom(p->nUShort);
49 case SbxBYREF | SbxERROR:
50 case SbxBYREF | SbxUSHORT:
51 return SbxBoolFrom(*p->pUShort);
52 case SbxLONG:
53 return SbxBoolFrom(p->nLong);
54 case SbxBYREF | SbxLONG:
55 return SbxBoolFrom(*p->pLong);
56 case SbxULONG:
57 return SbxBoolFrom(p->nULong);
58 case SbxBYREF | SbxULONG:
59 return SbxBoolFrom(*p->pULong);
60 case SbxSINGLE:
61 return SbxBoolFrom(p->nSingle);
62 case SbxBYREF | SbxSINGLE:
63 return SbxBoolFrom(*p->pSingle);
64 case SbxDATE:
65 case SbxDOUBLE:
66 return SbxBoolFrom(p->nDouble);
67 case SbxBYREF | SbxDATE:
68 case SbxBYREF | SbxDOUBLE:
69 return SbxBoolFrom(*p->pDouble);
70 case SbxDECIMAL:
71 case SbxBYREF | SbxDECIMAL:
72 if( p->pDecimal )
73 return SbxBoolFrom(p->pDecimal->getWithOverflow<double>());
74 return SbxFALSE;
75 case SbxSALINT64:
76 case SbxCURRENCY:
77 return SbxBoolFrom(p->nInt64);
78 case SbxBYREF | SbxSALINT64:
79 case SbxBYREF | SbxCURRENCY:
80 return SbxBoolFrom(*p->pnInt64);
81 case SbxSALUINT64:
82 return SbxBoolFrom(p->uInt64);
83 case SbxBYREF | SbxSALUINT64:
84 return SbxBoolFrom(*p->puInt64);
85
86 case SbxBYREF | SbxSTRING:
87 case SbxSTRING:
88 case SbxLPSTR:
89 if ( p->pOUString )
90 {
91 if( p->pOUString->equalsIgnoreAsciiCase( GetSbxRes( StringId::True ) ) )
92 return SbxTRUE;
93 if( p->pOUString->equalsIgnoreAsciiCase( GetSbxRes( StringId::False ) ) )
94 return SbxFALSE;
95
96 // it can be convertible to a number
97 double n;
98 SbxDataType t;
99 sal_Int32 nLen = 0;
100 if( ImpScan( *p->pOUString, n, t, &nLen ) == ERRCODE_NONE )
101 {
102 if( nLen == p->pOUString->getLength() )
103 {
104 return SbxBoolFrom(n);
105 }
106 }
107 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
108 }
109 return SbxFALSE;
110
111 case SbxOBJECT:
112 if (SbxValue* pVal = dynamic_cast<SbxValue*>(p->pObj))
113 return SbxBoolFrom(pVal->GetBool());
114 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT );
115 return SbxFALSE;
116
117 default:
118 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
119 return SbxFALSE;
120 }
121 }
122
123 void ImpPutBool( SbxValues* p, sal_Int16 n )
124 {
125 if( n )
126 n = SbxTRUE;
127 switch( +p->eType )
128 {
129 case SbxCHAR:
130 p->nChar = static_cast<sal_Unicode>(n); break;
131 case SbxBYREF | SbxCHAR:
132 *p->pChar = static_cast<sal_Unicode>(n); break;
133 case SbxBYTE:
134 p->nByte = static_cast<sal_uInt8>(n); break;
135 case SbxBYREF | SbxBYTE:
136 *p->pByte = static_cast<sal_uInt8>(n); break;
137 case SbxINTEGER:
138 case SbxBOOL:
139 p->nInteger = n; break;
140 case SbxBYREF | SbxINTEGER:
141 case SbxBYREF | SbxBOOL:
142 *p->pInteger = n; break;
143 case SbxERROR:
144 case SbxUSHORT:
145 p->nUShort = static_cast<sal_uInt16>(n); break;
146 case SbxBYREF | SbxERROR:
147 case SbxBYREF | SbxUSHORT:
148 *p->pUShort = static_cast<sal_uInt16>(n); break;
149 case SbxLONG:
150 p->nLong = n; break;
151 case SbxBYREF | SbxLONG:
152 *p->pLong = n; break;
153 case SbxULONG:
154 p->nULong = static_cast<sal_uInt32>(n); break;
155 case SbxBYREF | SbxULONG:
156 *p->pULong = static_cast<sal_uInt32>(n); break;
157 case SbxSINGLE:
158 p->nSingle = n; break;
159 case SbxBYREF | SbxSINGLE:
160 *p->pSingle = n; break;
161 case SbxDATE:
162 case SbxDOUBLE:
163 p->nDouble = n; break;
164 case SbxBYREF | SbxDATE:
165 case SbxBYREF | SbxDOUBLE:
166 *p->pDouble = n; break;
167 case SbxCURRENCY:
168 case SbxSALINT64:
169 p->nInt64 = n; break;
170 case SbxBYREF | SbxCURRENCY:
171 case SbxBYREF | SbxSALINT64:
172 *p->pnInt64 = n; break;
173 case SbxSALUINT64:
174 p->uInt64 = static_cast<sal_uInt64>(n); break;
175 case SbxBYREF | SbxSALUINT64:
176 *p->puInt64 = static_cast<sal_uInt64>(n); break;
177
178 case SbxDECIMAL:
179 case SbxBYREF | SbxDECIMAL:
180 ImpCreateDecimal( p )->setInt( n );
181 break;
182
183 case SbxBYREF | SbxSTRING:
184 case SbxSTRING:
185 case SbxLPSTR:
186 if ( !p->pOUString )
187 p->pOUString = new OUString( GetSbxRes( n ? StringId::True : StringId::False ) );
188 else
189 *p->pOUString = GetSbxRes( n ? StringId::True : StringId::False );
190 break;
191
192 case SbxOBJECT:
193 if (SbxValue* pVal = dynamic_cast<SbxValue*>(p->pObj))
194 pVal->PutBool( n != 0 );
195 else
196 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT );
197 break;
198
199 default:
200 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
201 }
202 }
203
204 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */