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 :
21 : #include <limits.h>
22 : #include <ctype.h>
23 : #include <bastype.hxx>
24 : #include <lex.hxx>
25 : #include <globals.hxx>
26 : #include <hash.hxx>
27 : #include <database.hxx>
28 :
29 203 : static sal_Bool ReadRangeSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm,
30 : sal_uLong nMin, sal_uLong nMax, sal_uLong* pValue )
31 : {
32 203 : sal_uInt32 nTokPos = rInStm.Tell();
33 203 : SvToken * pTok = rInStm.GetToken_Next();
34 203 : if( pTok->Is( pName ) )
35 : {
36 0 : sal_Bool bOk = sal_False;
37 0 : if( rInStm.Read( '=' ) )
38 : {
39 0 : pTok = rInStm.GetToken_Next();
40 0 : if( pTok->IsInteger() )
41 : {
42 0 : sal_uLong n = pTok->GetNumber();
43 0 : if ( n >= nMin && n <= nMax )
44 : {
45 0 : *pValue = n;
46 0 : bOk = sal_True;
47 : }
48 : }
49 : }
50 :
51 0 : if( bOk )
52 0 : return sal_True;
53 : }
54 :
55 203 : rInStm.Seek( nTokPos );
56 203 : return sal_False;
57 : }
58 :
59 0 : sal_uInt32 SvUINT32::Read( SvStream & rStm )
60 : {
61 0 : return SvPersistStream::ReadCompressed( rStm );
62 : }
63 :
64 0 : void SvUINT32::Write( SvStream & rStm, sal_uInt32 nVal )
65 : {
66 0 : SvPersistStream::WriteCompressed( rStm, nVal );
67 0 : }
68 :
69 163645 : SvStream& operator << (SvStream & rStm, const SvBOOL & rb )
70 : {
71 163645 : sal_uInt8 n = rb.nVal;
72 163645 : if( rb.bSet )
73 163645 : n |= 0x02;
74 163645 : rStm << n;
75 163645 : return rStm;
76 : }
77 0 : SvStream& operator >> (SvStream & rStm, SvBOOL & rb )
78 : {
79 : sal_uInt8 n;
80 0 : rStm >> n;
81 0 : rb.nVal = (n & 0x01) ? sal_True : sal_False;
82 0 : rb.bSet = (n & 0x02) ? sal_True : sal_False;
83 0 : if( n & ~0x03 )
84 : {
85 0 : rStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
86 : OSL_FAIL( "format error" );
87 : }
88 0 : return rStm;
89 : }
90 :
91 0 : SvStream& operator << (SvStream & rStm, const SvVersion & r )
92 : {
93 0 : if( (r.GetMajorVersion() || r.GetMinorVersion())
94 0 : && r.GetMajorVersion() <= 0x0F && r.GetMinorVersion() <= 0x0F )
95 : { // compress version number in 1 byte
96 : // format first 4 bit for major, then 4 bit for minor
97 : // 0.0 gets not compressed
98 :
99 0 : int n = r.GetMajorVersion() << 4;
100 0 : n |= r.GetMinorVersion();
101 0 : rStm << (sal_uInt8)n;
102 : }
103 : else
104 : {
105 0 : rStm << (sal_uInt8)0;
106 0 : rStm << r.GetMajorVersion();
107 0 : rStm << r.GetMinorVersion();
108 : }
109 0 : return rStm;
110 : }
111 :
112 0 : SvStream& operator >> (SvStream & rStm, SvVersion & r )
113 : {
114 : sal_uInt8 n;
115 0 : rStm >> n;
116 0 : if( n == 0 )
117 : { // not compressed
118 0 : rStm >> r.nMajorVersion;
119 0 : rStm >> r.nMinorVersion;
120 : }
121 : else
122 : { // compressed
123 0 : r.nMajorVersion = (n >> 4) & 0x0F;
124 0 : r.nMinorVersion = n & 0x0F;
125 : }
126 0 : return rStm;
127 : }
128 :
129 :
130 4975522 : sal_Bool SvBOOL::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
131 : {
132 4975522 : sal_uInt32 nTokPos = rInStm.Tell();
133 4975522 : SvToken * pTok = rInStm.GetToken_Next();
134 :
135 4975522 : if( pTok->Is( pName ) )
136 : {
137 131976 : sal_Bool bOk = sal_True;
138 131976 : sal_Bool bBraket = rInStm.Read( '(' );
139 131976 : if( bBraket || rInStm.Read( '=' ) )
140 : {
141 107912 : pTok = rInStm.GetToken();
142 107912 : if( pTok->IsBool() )
143 : {
144 99901 : *this = pTok->GetBool();
145 :
146 99901 : rInStm.GetToken_Next();
147 : }
148 107912 : if( bOk && bBraket )
149 0 : bOk = rInStm.Read( ')' );
150 : }
151 : else
152 24064 : *this = sal_True; //default action set to TRUE
153 131976 : if( bOk )
154 131976 : return sal_True;
155 : }
156 4843546 : rInStm.Seek( nTokPos );
157 4843546 : return sal_False;
158 : }
159 :
160 1139 : sal_Bool SvBOOL::WriteSvIdl( SvStringHashEntry * pName, SvStream & rOutStm )
161 : {
162 1139 : if( nVal )
163 640 : rOutStm << pName->GetName().getStr();
164 : else
165 499 : rOutStm << pName->GetName().getStr() << "(FALSE)";
166 1139 : return sal_True;
167 : }
168 :
169 23423 : rtl::OString SvBOOL::GetSvIdlString( SvStringHashEntry * pName )
170 : {
171 23423 : if( nVal )
172 22861 : return pName->GetName();
173 :
174 562 : return rtl::OStringBuffer(pName->GetName()).
175 1124 : append(RTL_CONSTASCII_STRINGPARAM("(FALSE)")).
176 562 : makeStringAndClear();
177 : }
178 :
179 1124229 : sal_Bool SvIdentifier::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
180 : {
181 1124229 : sal_uInt32 nTokPos = rInStm.Tell();
182 1124229 : SvToken * pTok = rInStm.GetToken_Next();
183 :
184 1124229 : if( pTok->Is( pName ) )
185 : {
186 15285 : sal_Bool bOk = sal_True;
187 15285 : sal_Bool bBraket = rInStm.Read( '(' );
188 15285 : if( bBraket || rInStm.Read( '=' ) )
189 : {
190 15285 : pTok = rInStm.GetToken();
191 15285 : if( pTok->IsIdentifier() )
192 : {
193 14973 : setString(pTok->GetString());
194 14973 : rInStm.GetToken_Next();
195 : }
196 15285 : if( bOk && bBraket )
197 0 : bOk = rInStm.Read( ')' );
198 : }
199 15285 : if( bOk )
200 15285 : return sal_True;
201 : }
202 1108944 : rInStm.Seek( nTokPos );
203 1108944 : return sal_False;
204 : }
205 :
206 15129 : sal_Bool SvIdentifier::WriteSvIdl( SvStringHashEntry * pName,
207 : SvStream & rOutStm,
208 : sal_uInt16 /*nTab */ )
209 : {
210 15129 : rOutStm << pName->GetName().getStr() << '(';
211 15129 : rOutStm << getString().getStr() << ')';
212 15129 : return sal_True;
213 : }
214 :
215 35977 : SvStream& operator << (SvStream & rStm, const SvIdentifier & r )
216 : {
217 35977 : write_lenPrefixed_uInt8s_FromOString<sal_uInt16>(rStm, r.getString());
218 35977 : return rStm;
219 : }
220 :
221 0 : SvStream& operator >> (SvStream & rStm, SvIdentifier & r )
222 : {
223 0 : r.setString(read_lenPrefixed_uInt8s_ToOString<sal_uInt16>(rStm));
224 0 : return rStm;
225 : }
226 :
227 :
228 321233 : sal_Bool SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
229 : SvStringHashEntry * pName,
230 : SvTokenStream & rInStm )
231 : {
232 321233 : if( SvIdentifier::ReadSvIdl( pName, rInStm ) )
233 : {
234 : sal_uLong n;
235 0 : if( rBase.FindId( getString(), &n ) )
236 : {
237 0 : nValue = n;
238 0 : return sal_True;
239 : }
240 : else
241 : {
242 : rtl::OStringBuffer aStr(RTL_CONSTASCII_STRINGPARAM(
243 0 : "no value for identifier <"));
244 0 : aStr.append(getString()).append(RTL_CONSTASCII_STRINGPARAM("> "));
245 0 : rBase.SetError( aStr.makeStringAndClear(), rInStm.GetToken() );
246 0 : rBase.WriteError( rInStm );
247 : }
248 : }
249 321233 : return sal_False;
250 : }
251 :
252 12803 : sal_Bool SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
253 : SvTokenStream & rInStm )
254 : {
255 12803 : sal_uInt32 nTokPos = rInStm.Tell();
256 12803 : SvToken * pTok = rInStm.GetToken_Next();
257 :
258 12803 : if( pTok->IsIdentifier() )
259 : {
260 : sal_uLong n;
261 12772 : if( rBase.FindId( pTok->GetString(), &n ) )
262 : {
263 12772 : setString(pTok->GetString());
264 12772 : nValue = n;
265 12772 : return sal_True;
266 : }
267 : else
268 : {
269 : rtl::OStringBuffer aStr(RTL_CONSTASCII_STRINGPARAM(
270 0 : "no value for identifier <"));
271 0 : aStr.append(getString()).append(RTL_CONSTASCII_STRINGPARAM("> "));
272 0 : rBase.SetError( aStr.makeStringAndClear(), rInStm.GetToken() );
273 0 : rBase.WriteError( rInStm );
274 : }
275 : }
276 31 : rInStm.Seek( nTokPos );
277 31 : return sal_False;
278 : }
279 :
280 12803 : SvStream& operator << (SvStream & rStm, const SvNumberIdentifier & r )
281 : {
282 12803 : rStm << (SvIdentifier &)r;
283 12803 : SvPersistStream::WriteCompressed( rStm, r.nValue );
284 12803 : return rStm;
285 : }
286 :
287 0 : SvStream& operator >> (SvStream & rStm, SvNumberIdentifier & r )
288 : {
289 0 : rStm >> (SvIdentifier &)r;
290 0 : r.nValue = SvPersistStream::ReadCompressed( rStm );
291 0 : return rStm;
292 : }
293 :
294 :
295 963936 : sal_Bool SvString::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
296 : {
297 963936 : sal_uInt32 nTokPos = rInStm.Tell();
298 963936 : SvToken * pTok = rInStm.GetToken_Next();
299 :
300 963936 : if( pTok->Is( pName ) )
301 : {
302 629 : sal_Bool bOk = sal_True;
303 629 : sal_Bool bBraket = rInStm.Read( '(' );
304 629 : if( bBraket || rInStm.Read( '=' ) )
305 : {
306 629 : pTok = rInStm.GetToken();
307 629 : if( pTok->IsString() )
308 : {
309 629 : setString(pTok->GetString());
310 629 : rInStm.GetToken_Next();
311 : }
312 629 : if( bOk && bBraket )
313 23 : bOk = rInStm.Read( ')' );
314 : }
315 629 : if( bOk )
316 629 : return sal_True;
317 : }
318 963307 : rInStm.Seek( nTokPos );
319 963307 : return sal_False;
320 : }
321 :
322 618 : sal_Bool SvString::WriteSvIdl( SvStringHashEntry * pName, SvStream & rOutStm,
323 : sal_uInt16 /*nTab */ )
324 : {
325 618 : rOutStm << pName->GetName().getStr() << "(\"";
326 618 : rOutStm << m_aStr.getStr() << "\")";
327 618 : return sal_True;
328 : }
329 :
330 20595 : SvStream& operator << (SvStream & rStm, const SvString & r )
331 : {
332 20595 : write_lenPrefixed_uInt8s_FromOString<sal_uInt16>(rStm, r.getString());
333 20595 : return rStm;
334 : }
335 :
336 0 : SvStream& operator >> (SvStream & rStm, SvString & r )
337 : {
338 0 : r.setString(read_lenPrefixed_uInt8s_ToOString<sal_uInt16>(rStm));
339 0 : return rStm;
340 : }
341 :
342 :
343 160718 : sal_Bool SvHelpText::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
344 : {
345 160718 : return SvString::ReadSvIdl( SvHash_HelpText(), rInStm );
346 : }
347 :
348 8 : sal_Bool SvHelpText::WriteSvIdl( SvIdlDataBase &, SvStream & rOutStm, sal_uInt16 nTab )
349 : {
350 8 : return SvString::WriteSvIdl( SvHash_HelpText(), rOutStm, nTab );
351 : }
352 :
353 203 : sal_Bool SvUUId::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
354 : {
355 203 : sal_uInt32 nTokPos = rInStm.Tell();
356 203 : SvToken * pTok = rInStm.GetToken_Next();
357 :
358 203 : if( pTok->Is( SvHash_uuid() ) )
359 : {
360 68 : sal_Bool bOk = sal_True;
361 68 : sal_Bool bBraket = rInStm.Read( '(' );
362 68 : if( bBraket || rInStm.Read( '=' ) )
363 : {
364 68 : pTok = rInStm.GetToken();
365 68 : if( pTok->IsString() )
366 : {
367 68 : pTok = rInStm.GetToken_Next();
368 68 : bOk = MakeId(rtl::OStringToOUString(pTok->GetString(), RTL_TEXTENCODING_ASCII_US));
369 : }
370 68 : if( bOk && bBraket )
371 26 : bOk = rInStm.Read( ')' );
372 : }
373 68 : if( bOk )
374 68 : return sal_True;
375 : }
376 135 : rInStm.Seek( nTokPos );
377 135 : return sal_False;
378 : }
379 :
380 68 : sal_Bool SvUUId::WriteSvIdl( SvStream & rOutStm )
381 : {
382 : // write global id
383 68 : rOutStm << SvHash_uuid()->GetName().getStr() << "(\"";
384 68 : rOutStm << rtl::OUStringToOString(GetHexName(), RTL_TEXTENCODING_UTF8).getStr() << "\")";
385 68 : return sal_True;
386 : }
387 :
388 :
389 203 : sal_Bool SvVersion::ReadSvIdl( SvTokenStream & rInStm )
390 : {
391 203 : sal_uLong n = 0;
392 :
393 203 : sal_uInt32 nTokPos = rInStm.Tell();
394 203 : if( ReadRangeSvIdl( SvHash_Version(), rInStm, 0 , 0xFFFF, &n ) )
395 : {
396 0 : nMajorVersion = (sal_uInt16)n;
397 0 : if( rInStm.Read( '.' ) )
398 : {
399 0 : SvToken * pTok = rInStm.GetToken_Next();
400 0 : if( pTok->IsInteger() && pTok->GetNumber() <= 0xFFFF )
401 : {
402 0 : nMinorVersion = (sal_uInt16)pTok->GetNumber();
403 0 : return sal_True;
404 : }
405 : }
406 : else
407 0 : return sal_True;
408 : }
409 203 : rInStm.Seek( nTokPos );
410 203 : return sal_False;
411 : }
412 :
413 0 : sal_Bool SvVersion::WriteSvIdl( SvStream & rOutStm )
414 : {
415 0 : rOutStm << SvHash_Version()->GetName().getStr() << '('
416 0 : << rtl::OString::valueOf(static_cast<sal_Int32>(nMajorVersion)).getStr()
417 0 : << '.'
418 0 : << rtl::OString::valueOf(static_cast<sal_Int32>(nMinorVersion)).getStr()
419 0 : << ')';
420 0 : return sal_True;
421 : }
422 :
423 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
