Branch data 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 <ctype.h>
21 : : #include <stdio.h>
22 : : #include <string.h>
23 : :
24 : : #include <rtl/strbuf.hxx>
25 : :
26 : : #include <tools/stream.hxx>
27 : : #include <tools/globname.hxx>
28 : :
29 : : // ImpSvGlobalName ------------------------------------------------------------
30 : :
31 : 4211 : ImpSvGlobalName::ImpSvGlobalName( const ImpSvGlobalName & rObj )
32 : : {
33 : 4211 : nRefCount = 0;
34 : 4211 : memcpy( szData, rObj.szData, sizeof( szData ) );
35 : 4211 : }
36 : :
37 : 187 : ImpSvGlobalName::ImpSvGlobalName( Empty )
38 : : {
39 : 187 : nRefCount = 1;
40 : 187 : memset( szData, 0, sizeof( szData ) );
41 : 187 : }
42 : :
43 : 423196 : sal_Bool ImpSvGlobalName::operator == ( const ImpSvGlobalName & rObj ) const
44 : : {
45 : 423196 : return !memcmp( szData, rObj.szData, sizeof( szData ) );
46 : : }
47 : :
48 : : // SvGlobalName ----------------------------------------------------------------
49 : :
50 : 48216 : SvGlobalName::SvGlobalName()
51 : : {
52 [ + + ][ + - ]: 48216 : static ImpSvGlobalName aNoName( ImpSvGlobalName::EMPTY );
53 : :
54 : 48216 : pImp = &aNoName;
55 : 48216 : pImp->nRefCount++;
56 : 48216 : }
57 : :
58 : : #ifdef WNT
59 : : struct _GUID
60 : : #else
61 : : struct GUID
62 : : #endif
63 : : {
64 : : sal_uInt32 Data1;
65 : : sal_uInt16 Data2;
66 : : sal_uInt16 Data3;
67 : : sal_uInt8 Data4[8];
68 : : };
69 : 30 : SvGlobalName::SvGlobalName( const CLSID & rId )
70 : : {
71 : 30 : pImp = new ImpSvGlobalName();
72 : 30 : pImp->nRefCount++;
73 : 30 : memcpy( pImp->szData, &rId, sizeof( pImp->szData ) );
74 : 30 : }
75 : :
76 : 505190 : SvGlobalName::SvGlobalName( sal_uInt32 n1, sal_uInt16 n2, sal_uInt16 n3,
77 : : sal_uInt8 b8, sal_uInt8 b9, sal_uInt8 b10, sal_uInt8 b11,
78 : : sal_uInt8 b12, sal_uInt8 b13, sal_uInt8 b14, sal_uInt8 b15 )
79 : : {
80 : 505190 : pImp = new ImpSvGlobalName();
81 : 505190 : pImp->nRefCount++;
82 : :
83 : 505190 : memcpy(pImp->szData, &n1, sizeof(n1));
84 : 505190 : memcpy(pImp->szData+4, &n2, sizeof(n2));
85 : 505190 : memcpy(pImp->szData+6, &n3, sizeof(n3));
86 : 505190 : pImp->szData[ 8 ] = b8;
87 : 505190 : pImp->szData[ 9 ] = b9;
88 : 505190 : pImp->szData[ 10 ] = b10;
89 : 505190 : pImp->szData[ 11 ] = b11;
90 : 505190 : pImp->szData[ 12 ] = b12;
91 : 505190 : pImp->szData[ 13 ] = b13;
92 : 505190 : pImp->szData[ 14 ] = b14;
93 : 505190 : pImp->szData[ 15 ] = b15;
94 : 505190 : }
95 : :
96 : 667852 : SvGlobalName::~SvGlobalName()
97 : : {
98 : 667852 : pImp->nRefCount--;
99 [ + + ]: 667852 : if( !pImp->nRefCount )
100 : 611585 : delete pImp;
101 : 667852 : }
102 : :
103 : 9413 : SvGlobalName & SvGlobalName::operator = ( const SvGlobalName & rObj )
104 : : {
105 : 9413 : rObj.pImp->nRefCount++;
106 : 9413 : pImp->nRefCount--;
107 [ - + ]: 9413 : if( !pImp->nRefCount )
108 : 0 : delete pImp;
109 : 9413 : pImp = rObj.pImp;
110 : 9413 : return *this;
111 : : }
112 : :
113 : 4211 : void SvGlobalName::NewImp()
114 : : {
115 [ + - ]: 4211 : if( pImp->nRefCount > 1 )
116 : : {
117 : 4211 : pImp->nRefCount--;
118 : 4211 : pImp = new ImpSvGlobalName( *pImp );
119 : 4211 : pImp->nRefCount++;
120 : : }
121 : 4211 : }
122 : :
123 : 3163 : SvStream& operator << ( SvStream& rOStr, const SvGlobalName & rObj )
124 : : {
125 : : sal_uInt32 a;
126 : 3163 : memcpy(&a, rObj.pImp->szData, sizeof(sal_uInt32));
127 [ + - ]: 3163 : rOStr << a;
128 : :
129 : : sal_uInt16 b;
130 : 3163 : memcpy(&b, rObj.pImp->szData+4, sizeof(sal_uInt16));
131 [ + - ]: 3163 : rOStr << b;
132 : :
133 : 3163 : memcpy(&b, rObj.pImp->szData+6, sizeof(sal_uInt16));
134 [ + - ]: 3163 : rOStr << b;
135 : :
136 [ + - ]: 3163 : rOStr.Write( (sal_Char *)&rObj.pImp->szData[ 8 ], 8 );
137 : 3163 : return rOStr;
138 : : }
139 : :
140 : 1126 : SvStream& operator >> ( SvStream& rStr, SvGlobalName & rObj )
141 : : {
142 [ + - ]: 1126 : rObj.NewImp(); // copy if necessary
143 : :
144 : : sal_uInt32 a;
145 [ + - ]: 1126 : rStr >> a;
146 : 1126 : memcpy(rObj.pImp->szData, &a, sizeof(sal_uInt32));
147 : :
148 : : sal_uInt16 b;
149 [ + - ]: 1126 : rStr >> b;
150 : 1126 : memcpy(rObj.pImp->szData+4, &b, sizeof(sal_uInt16));
151 : :
152 [ + - ]: 1126 : rStr >> b;
153 : 1126 : memcpy(rObj.pImp->szData+6, &b, sizeof(sal_uInt16));
154 : :
155 [ + - ]: 1126 : rStr.Read( (sal_Char *)&rObj.pImp->szData[ 8 ], 8 );
156 : 1126 : return rStr;
157 : : }
158 : :
159 : :
160 : 4436 : sal_Bool SvGlobalName::operator < ( const SvGlobalName & rObj ) const
161 : : {
162 : 4436 : int n = memcmp( pImp->szData +6, rObj.pImp->szData +6,
163 : 4436 : sizeof( pImp->szData ) -6);
164 [ - + ]: 4436 : if( n < 0 )
165 : 0 : return sal_True;
166 [ - + ]: 4436 : else if( n > 0 )
167 : 0 : return sal_False;
168 : :
169 : : sal_uInt16 Data2_a;
170 : 4436 : memcpy(&Data2_a, pImp->szData+4, sizeof(sal_uInt16));
171 : :
172 : : sal_uInt16 Data2_b;
173 : 4436 : memcpy(&Data2_b, rObj.pImp->szData+4, sizeof(sal_uInt16));
174 : :
175 [ + + ]: 4436 : if( Data2_a < Data2_b )
176 : 826 : return sal_True;
177 [ + - ]: 3610 : else if( Data2_a == Data2_b )
178 : : {
179 : : sal_uInt32 Data1_a;
180 : 3610 : memcpy(&Data1_a, pImp->szData, sizeof(sal_uInt32));
181 : :
182 : : sal_uInt32 Data1_b;
183 : 3610 : memcpy(&Data1_b, rObj.pImp->szData, sizeof(sal_uInt32));
184 : :
185 : 3610 : return Data1_a < Data1_b;
186 : : }
187 : : else
188 : 4436 : return sal_False;
189 : :
190 : : }
191 : :
192 : 2904 : SvGlobalName & SvGlobalName::operator += ( sal_uInt32 n )
193 : : {
194 [ + - ]: 2904 : NewImp();
195 : :
196 : : sal_uInt32 nOld;
197 : 2904 : memcpy(&nOld, pImp->szData, sizeof(sal_uInt32));
198 : 2904 : sal_uInt32 nNew = nOld + n;
199 : 2904 : memcpy(pImp->szData, &nNew, sizeof(sal_uInt32));
200 : :
201 [ - + ]: 2904 : if( nOld > nNew )
202 : : {
203 : : // overflow
204 : : sal_uInt16 Data2;
205 : 0 : memcpy(&Data2, pImp->szData + 4, sizeof(sal_uInt16));
206 : 0 : ++Data2;
207 : 0 : memcpy(pImp->szData + 4, &Data2, sizeof(sal_uInt16));
208 : : }
209 : 2904 : return *this;
210 : : }
211 : :
212 : 423196 : sal_Bool SvGlobalName::operator == ( const SvGlobalName & rObj ) const
213 : : {
214 : 423196 : return *pImp == *rObj.pImp;
215 : : }
216 : :
217 : 0 : void SvGlobalName::MakeFromMemory( void * pData )
218 : : {
219 : 0 : NewImp();
220 : 0 : memcpy( pImp->szData, pData, sizeof( pImp->szData ) );
221 : 0 : }
222 : :
223 : 181 : sal_Bool SvGlobalName::MakeId( const String & rIdStr )
224 : : {
225 : : rtl::OString aStr(rtl::OUStringToOString(rIdStr,
226 [ + - ][ + - ]: 181 : RTL_TEXTENCODING_ASCII_US));
227 : 181 : const sal_Char *pStr = aStr.getStr();
228 [ + - ][ + - ]: 181 : if( rIdStr.Len() == 36
[ + - ][ + - ]
[ + - ][ + - ]
229 : 362 : && '-' == pStr[ 8 ] && '-' == pStr[ 13 ]
230 : 362 : && '-' == pStr[ 18 ] && '-' == pStr[ 23 ] )
231 : : {
232 : 181 : sal_uInt32 nFirst = 0;
233 : 181 : int i = 0;
234 [ + + ]: 1629 : for( i = 0; i < 8; i++ )
235 : : {
236 [ + - ]: 1448 : if( isxdigit( *pStr ) )
237 [ + + ]: 1448 : if( isdigit( *pStr ) )
238 : 935 : nFirst = nFirst * 16 + (*pStr - '0');
239 : : else
240 : 513 : nFirst = nFirst * 16 + (toupper( *pStr ) - 'A' + 10 );
241 : : else
242 : 0 : return sal_False;
243 : 1448 : pStr++;
244 : : }
245 : :
246 : 181 : sal_uInt16 nSec = 0;
247 : 181 : pStr++;
248 [ + + ]: 905 : for( i = 0; i < 4; i++ )
249 : : {
250 [ + - ]: 724 : if( isxdigit( *pStr ) )
251 [ + + ]: 724 : if( isdigit( *pStr ) )
252 : 456 : nSec = nSec * 16 + (*pStr - '0');
253 : : else
254 : 268 : nSec = nSec * 16 + (sal_uInt16)(toupper( *pStr ) - 'A' + 10 );
255 : : else
256 : 0 : return sal_False;
257 : 724 : pStr++;
258 : : }
259 : :
260 : 181 : sal_uInt16 nThird = 0;
261 : 181 : pStr++;
262 [ + + ]: 905 : for( i = 0; i < 4; i++ )
263 : : {
264 [ + - ]: 724 : if( isxdigit( *pStr ) )
265 [ + + ]: 724 : if( isdigit( *pStr ) )
266 : 512 : nThird = nThird * 16 + (*pStr - '0');
267 : : else
268 : 212 : nThird = nThird * 16 + (sal_uInt16)(toupper( *pStr ) - 'A' + 10 );
269 : : else
270 : 0 : return sal_False;
271 : 724 : pStr++;
272 : : }
273 : :
274 : : sal_Int8 szRemain[ 8 ];
275 : 181 : memset( szRemain, 0, sizeof( szRemain ) );
276 : 181 : pStr++;
277 [ + + ]: 3077 : for( i = 0; i < 16; i++ )
278 : : {
279 [ + - ]: 2896 : if( isxdigit( *pStr ) )
280 [ + + ]: 2896 : if( isdigit( *pStr ) )
281 : 2181 : szRemain[i/2] = szRemain[i/2] * 16 + (*pStr - '0');
282 : : else
283 : 715 : szRemain[i/2] = szRemain[i/2] * 16 + (sal_Int8)(toupper( *pStr ) - 'A' + 10 );
284 : : else
285 : 0 : return sal_False;
286 : 2896 : pStr++;
287 [ + + ]: 2896 : if( i == 3 )
288 : 181 : pStr++;
289 : : }
290 : :
291 [ + - ]: 181 : NewImp();
292 : 181 : memcpy(&pImp->szData[0], &nFirst, sizeof(nFirst));
293 : 181 : memcpy(&pImp->szData[4], &nSec, sizeof(nSec));
294 : 181 : memcpy(&pImp->szData[6], &nThird, sizeof(nThird));
295 : 181 : memcpy(&pImp->szData[ 8 ], szRemain, 8);
296 : 181 : return sal_True;
297 : : }
298 : 181 : return sal_False;
299 : : }
300 : :
301 : 604 : String SvGlobalName::GetHexName() const
302 : : {
303 : 604 : rtl::OStringBuffer aHexBuffer;
304 : :
305 : : sal_Char buf[ 10 ];
306 : : sal_uInt32 Data1;
307 : 604 : memcpy(&Data1, pImp->szData, sizeof(sal_uInt32));
308 : 604 : sprintf( buf, "%8.8" SAL_PRIXUINT32, Data1 );
309 [ + - ]: 604 : aHexBuffer.append(buf);
310 [ + - ]: 604 : aHexBuffer.append('-');
311 : : sal_uInt16 i ;
312 [ + + ]: 1812 : for( i = 4; i < 8; i += 2 )
313 : : {
314 : : sal_uInt16 Data2;
315 : 1208 : memcpy(&Data2, pImp->szData+i, sizeof(sal_uInt16));
316 : 1208 : sprintf( buf, "%4.4X", Data2 );
317 [ + - ]: 1208 : aHexBuffer.append(buf);
318 [ + - ]: 1208 : aHexBuffer.append('-');
319 : : }
320 [ + + ]: 1812 : for( i = 8; i < 10; i++ )
321 : : {
322 : 1208 : sprintf( buf, "%2.2x", pImp->szData[ i ] );
323 [ + - ]: 1208 : aHexBuffer.append(buf);
324 : : }
325 [ + - ]: 604 : aHexBuffer.append('-');
326 [ + + ]: 4228 : for( i = 10; i < 16; i++ )
327 : : {
328 : 3624 : sprintf( buf, "%2.2x", pImp->szData[ i ] );
329 [ + - ]: 3624 : aHexBuffer.append(buf);
330 : : }
331 [ + - ][ + - ]: 604 : return rtl::OStringToOUString(aHexBuffer.makeStringAndClear(), RTL_TEXTENCODING_ASCII_US);
332 : : }
333 : :
334 : 91946 : com::sun::star::uno::Sequence < sal_Int8 > SvGlobalName::GetByteSequence() const
335 : : {
336 : : // platform independent representation of a "GlobalName"
337 : : // maybe transported remotely
338 [ + - ]: 91946 : com::sun::star::uno::Sequence< sal_Int8 > aResult( 16 );
339 : :
340 : : sal_uInt32 Data1;
341 : 91946 : memcpy(&Data1, pImp->szData, sizeof(sal_uInt32));
342 [ + - ]: 91946 : aResult[0] = (sal_Int8) (Data1 >> 24);
343 [ + - ]: 91946 : aResult[1] = (sal_Int8) ((Data1 << 8 ) >> 24);
344 [ + - ]: 91946 : aResult[2] = (sal_Int8) ((Data1 << 16 ) >> 24);
345 [ + - ]: 91946 : aResult[3] = (sal_Int8) ((Data1 << 24 ) >> 24);
346 : : sal_uInt16 Data2;
347 : 91946 : memcpy(&Data2, pImp->szData+4, sizeof(sal_uInt16));
348 [ + - ]: 91946 : aResult[4] = (sal_Int8) (Data2 >> 8);
349 [ + - ]: 91946 : aResult[5] = (sal_Int8) ((Data2 << 8 ) >> 8);
350 : : sal_uInt16 Data3;
351 : 91946 : memcpy(&Data3, pImp->szData+6, sizeof(sal_uInt16));
352 [ + - ]: 91946 : aResult[6] = (sal_Int8) (Data3 >> 8);
353 [ + - ]: 91946 : aResult[7] = (sal_Int8) ((Data3 << 8 ) >> 8);
354 [ + - ]: 91946 : aResult[8] = pImp->szData[ 8 ];
355 [ + - ]: 91946 : aResult[9] = pImp->szData[ 9 ];
356 [ + - ]: 91946 : aResult[10] = pImp->szData[ 10 ];
357 [ + - ]: 91946 : aResult[11] = pImp->szData[ 11 ];
358 [ + - ]: 91946 : aResult[12] = pImp->szData[ 12 ];
359 [ + - ]: 91946 : aResult[13] = pImp->szData[ 13 ];
360 [ + - ]: 91946 : aResult[14] = pImp->szData[ 14 ];
361 [ + - ]: 91946 : aResult[15] = pImp->szData[ 15 ];
362 : :
363 : 91946 : return aResult;
364 : : }
365 : :
366 : 103370 : SvGlobalName::SvGlobalName( const com::sun::star::uno::Sequence < sal_Int8 >& aSeq )
367 : : {
368 : : // create SvGlobalName from a platform independent representation
369 : : GUID aResult;
370 : 103370 : memset( &aResult, 0, sizeof( aResult ) );
371 [ + + ]: 103370 : if ( aSeq.getLength() == 16 )
372 : : {
373 : 103355 : aResult.Data1 = ( ( ( ( ( ( sal_uInt8 )aSeq[0] << 8 ) + ( sal_uInt8 )aSeq[1] ) << 8 ) + ( sal_uInt8 )aSeq[2] ) << 8 ) + ( sal_uInt8 )aSeq[3];
374 : 103355 : aResult.Data2 = ( ( sal_uInt8 )aSeq[4] << 8 ) + ( sal_uInt8 )aSeq[5];
375 : 103355 : aResult.Data3 = ( ( sal_uInt8 )aSeq[6] << 8 ) + ( sal_uInt8 )aSeq[7];
376 [ + + ]: 930195 : for( int nInd = 0; nInd < 8; nInd++ )
377 : 826840 : aResult.Data4[nInd] = ( sal_uInt8 )aSeq[nInd+8];
378 : : }
379 : :
380 [ + - ]: 103370 : pImp = new ImpSvGlobalName();
381 : 103370 : pImp->nRefCount++;
382 : 103370 : memcpy( pImp->szData, &aResult, sizeof( pImp->szData ) );
383 : 103370 : }
384 : :
385 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
