xref: /aoo41x/main/rsc/source/res/rscstr.cxx (revision cdf0e10c) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_rsc.hxx"
30 /****************** I N C L U D E S **************************************/
31 
32 // C and C++ Includes.
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <string.h>
36 
37 // Programmabh�ngige Includes.
38 #include <rscdb.hxx>
39 #include <rscstr.hxx>
40 
41 #include <rtl/textcvt.h>
42 #include <rtl/textenc.h>
43 
44 /****************** C O D E **********************************************/
45 /****************** R s c S t r i n g ************************************/
46 /*************************************************************************
47 |*
48 |*	  RscString::RscString()
49 |*
50 |*	  Beschreibung
51 |*	  Ersterstellung	MM 25.04.91
52 |*	  Letzte Aenderung	MM 25.04.91
53 |*
54 *************************************************************************/
55 RscString::RscString( Atom nId, sal_uInt32 nTypeId )
56 				: RscTop( nId, nTypeId )
57 {
58 	nSize = ALIGNED_SIZE( sizeof( RscStringInst ) );
59 	pRefClass = NULL;
60 }
61 
62 /*************************************************************************
63 |*
64 |*	  RscString::GetClassType()
65 |*
66 |*	  Beschreibung
67 |*	  Ersterstellung	MM 25.04.91
68 |*	  Letzte Aenderung	MM 25.04.91
69 |*
70 *************************************************************************/
71 RSCCLASS_TYPE RscString::GetClassType() const
72 {
73 	return RSCCLASS_STRING;
74 }
75 
76 /*************************************************************************
77 |*
78 |*	  RscString::SetNumber()
79 |*
80 |*	  Beschreibung
81 |*	  Ersterstellung	MM 25.04.91
82 |*	  Letzte Aenderung	MM 25.04.91
83 |*
84 *************************************************************************/
85 ERRTYPE RscString::SetString( const RSCINST & rInst, const char * pStr ){
86 	char	* pTmp;
87 	ERRTYPE aError;
88 
89 	if( aError.IsOk() ){
90 		((RscStringInst *)rInst.pData)->bDflt = sal_False;
91 
92 		pTmp = ((RscStringInst *)rInst.pData)->pStr;
93 		if( pTmp ){
94 			rtl_freeMemory( pTmp );
95 			pTmp = NULL;
96 		}
97 
98 		if( pStr ){
99 			sal_uInt32	nLen = strlen( pStr ) +1;
100 			pTmp = (char *)rtl_allocateMemory( nLen );
101 			memcpy( pTmp, pStr, nLen );
102 		};
103 
104 		((RscStringInst *)rInst.pData)->pStr = pTmp;
105 	}
106 
107 	return( aError );
108 }
109 
110 /*************************************************************************
111 |*
112 |*	  RscString::GetString()
113 |*
114 |*	  Beschreibung
115 |*	  Ersterstellung	MM 25.04.91
116 |*	  Letzte Aenderung	MM 25.04.91
117 |*
118 *************************************************************************/
119 ERRTYPE RscString::GetString( const RSCINST & rInst, char ** ppStr ){
120 	*ppStr = ((RscStringInst *)rInst.pData)->pStr;
121 	return( ERR_OK );
122 }
123 
124 /*************************************************************************
125 |*
126 |*	  RscString::GetRef()
127 |*
128 |*	  Beschreibung
129 |*	  Ersterstellung	MM 22.07.91
130 |*	  Letzte Aenderung	MM 22.07.91
131 |*
132 *************************************************************************/
133 ERRTYPE RscString::GetRef( const RSCINST & rInst, RscId * pRscId ){
134 	*pRscId = ((RscStringInst *)rInst.pData)->aRefId;
135 	return( ERR_OK );
136 }
137 
138 /*************************************************************************
139 |*
140 |*	  RscString::SetRef()
141 |*
142 |*	  Beschreibung
143 |*	  Ersterstellung	MM 15.05.91
144 |*	  Letzte Aenderung	MM 15.05.91
145 |*
146 *************************************************************************/
147 ERRTYPE RscString::SetRef( const RSCINST & rInst, const RscId & rRefId ){
148 	if( pRefClass ){
149 		((RscStringInst *)rInst.pData)->aRefId = rRefId;
150 		((RscStringInst *)rInst.pData)->bDflt  = sal_False;
151 	}
152 	else
153 		return( ERR_REFNOTALLOWED );
154 
155 	return ERR_OK;
156 }
157 
158 /*************************************************************************
159 |*
160 |*	  RscString::Create()
161 |*
162 |*	  Beschreibung
163 |*	  Ersterstellung	MM 25.04.91
164 |*	  Letzte Aenderung	MM 25.04.91
165 |*
166 *************************************************************************/
167 RSCINST RscString::Create( RSCINST * pInst, const RSCINST & rDflt,
168 						   sal_Bool bOwnClass )
169 {
170 	RSCINST aInst;
171 
172 	if( !pInst ){
173 		aInst.pClass = this;
174 		aInst.pData = (CLASS_DATA)
175 					  rtl_allocateMemory( sizeof( RscStringInst ) );
176 	}
177 	else
178 		aInst = *pInst;
179 	if( !bOwnClass && rDflt.IsInst() )
180 		bOwnClass = rDflt.pClass->InHierarchy( this );
181 
182 	((RscStringInst *)aInst.pData)->aRefId.Create();
183 	((RscStringInst *)aInst.pData)->pStr = NULL;
184 	((RscStringInst *)aInst.pData)->bDflt = sal_True;
185 
186 	if( bOwnClass ){
187 		((RscStringInst *)aInst.pData)->aRefId =
188 						  ((RscStringInst *)rDflt.pData)->aRefId;
189 		SetString( aInst, ((RscStringInst *)rDflt.pData)->pStr );
190 		((RscStringInst *)aInst.pData)->bDflt =
191 							((RscStringInst *)rDflt.pData)->bDflt ;
192 	}
193 
194 	return( aInst );
195 }
196 
197 /*************************************************************************
198 |*
199 |*	  RscString::Destroy()
200 |*
201 |*	  Beschreibung
202 |*	  Ersterstellung	MM 15.05.91
203 |*	  Letzte Aenderung	MM 15.05.91
204 |*
205 *************************************************************************/
206 void RscString::Destroy( const RSCINST & rInst ){
207 	if( ((RscStringInst *)rInst.pData)->pStr )
208 		rtl_freeMemory( ((RscStringInst *)rInst.pData)->pStr );
209 	((RscStringInst *)rInst.pData)->aRefId.Destroy();
210 }
211 
212 /*************************************************************************
213 |*
214 |*	  RscString::IsValueDefault()
215 |*
216 |*	  Beschreibung
217 |*	  Ersterstellung	MM 15.01.92
218 |*	  Letzte Aenderung	MM 15.01.92
219 |*
220 *************************************************************************/
221 sal_Bool RscString::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
222 	RscStringInst * pData	 = (RscStringInst*)rInst.pData;
223 	RscStringInst * pDefData = (RscStringInst*)pDef;
224 
225 	if( pDef ){
226 		if( pData->aRefId.IsId() || pDefData->aRefId.IsId() )
227 		{
228 			if( pData->aRefId.aExp.IsNumber()
229 			  && pDefData->aRefId.aExp.IsNumber() )
230 			{
231 				// Sind die Referenzidentifier gleich
232 				if( pData->aRefId.GetNumber() == pDefData->aRefId.GetNumber() )
233 				{
234 					return sal_True;
235 				}
236 			}
237 		}
238 		else {
239 			sal_Bool bStrEmpty = sal_False;
240 			sal_Bool bDefStrEmpty = sal_False;
241 
242 			if( pData->pStr ){
243 				bStrEmpty = ('\0' == *pData->pStr);
244 			}
245 			else
246 				bStrEmpty = sal_True;
247 
248 			if( pDefData->pStr ){
249 				bDefStrEmpty = ('\0' == *pDefData->pStr);
250 			}
251 			else
252 				bDefStrEmpty = sal_True;
253 
254 			if( !bStrEmpty || !bDefStrEmpty ){
255 				return sal_False;
256 			}
257 			return sal_True;
258 		}
259 	}
260 
261 	return sal_False;
262 }
263 
264 /*************************************************************************
265 |*
266 |*	  RscString::WriteSrc()
267 |*
268 |*	  Beschreibung
269 |*	  Ersterstellung	MM 25.04.91
270 |*	  Letzte Aenderung	MM 25.04.91
271 |*
272 *************************************************************************/
273 void RscString::WriteSrc( const RSCINST & rInst, FILE * fOutput,
274 						  RscTypCont *, sal_uInt32, const char * )
275 {
276 	if ( ((RscStringInst *)rInst.pData)->aRefId.IsId() )
277 	{
278 		fprintf( fOutput, "%s",
279 				 ((RscStringInst *)rInst.pData)->aRefId.GetName().GetBuffer() );
280 	}
281 	else
282 	{
283 		RscStringInst * pStrI = ((RscStringInst *)rInst.pData);
284 		if(  pStrI->pStr ){
285 			//char *  pChangeTab = RscChar::GetChangeTab();
286 			sal_uInt32	n = 0;
287 			sal_uInt32	nPos, nSlashPos;
288 
289 			do {
290 				fputc( '\"', fOutput );
291 				nSlashPos = nPos = 0;
292 				while( pStrI->pStr[ n ]
293 				  && (nPos < 72 || nPos - nSlashPos <= 3) )
294 				{ // nach \ mindesten 3 Zeichen wegeb \xa7
295 					fputc( pStrI->pStr[ n ], fOutput );
296 					if( pStrI->pStr[ n ] == '\\' )
297 						nSlashPos = nPos;
298 					n++;
299 					nPos++;
300 				}
301 
302 				fputc( '\"', fOutput );
303 				if( pStrI->pStr[ n ] ) //nocht nicht zu ende
304 					fputc( '\n', fOutput );
305 			} while( pStrI->pStr[ n ] );
306 		}
307 		else
308 			fprintf( fOutput, "\"\"" );
309 	}
310 }
311 
312 /*************************************************************************
313 |*
314 |*	  RscString::WriteRc()
315 |*
316 |*	  Beschreibung
317 |*	  Ersterstellung	MM 15.04.91
318 |*	  Letzte Aenderung	MM 15.04.91
319 |*
320 *************************************************************************/
321 ERRTYPE RscString::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
322 							RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
323 {
324 	ERRTYPE aError;
325 	ObjNode *		pObjNode = NULL;
326 
327 
328 	if( ((RscStringInst *)rInst.pData)->aRefId.IsId() ){
329 		RscId	aId( ((RscStringInst *)rInst.pData)->aRefId );
330 		RSCINST aTmpI;
331 
332 		aTmpI.pClass = pRefClass;
333 
334 		while( aError.IsOk() && aId.IsId() ){
335 			//Erhoehen und abfragen um Endlosrekusion zu vermeiden
336 			nDeep++;
337 			if( nDeep > nRefDeep )
338 				aError = ERR_REFTODEEP;
339 			else
340 			{
341 				pObjNode = pRefClass->GetObjNode( aId );
342 				if( pObjNode )
343 				{
344 					aTmpI.pData = pObjNode->GetRscObj();
345 					aError = pRefClass->GetRef( aTmpI, &aId );
346 				}
347 				else
348 				{
349 					if( pTC )
350 					{
351 						ByteString	aMsg( pHS->getString( pRefClass->GetId() ).getStr() );
352 						aMsg += ' ';
353 						aMsg += aId.GetName();
354 						aError = WRN_STR_REFNOTFOUND;
355 						pTC->pEH->Error( aError, rInst.pClass,
356 										 RscId(), aMsg.GetBuffer() );
357 					}
358 					break;
359 				}
360 			}
361 		}
362 	}
363 
364 	if( aError.IsOk() )
365 	{
366 		if( pObjNode )
367 		{
368 			RSCINST 	aRefI;
369 
370 			aRefI = RSCINST( pRefClass, pObjNode->GetRscObj() );
371 			aError = aRefI.pClass->WriteRc( aRefI, rMem, pTC, nDeep, bExtra );
372 		}
373 		else
374 		{
375 			if( ((RscStringInst *)rInst.pData)->pStr && pTC )
376 			{
377 				char * pStr = RscChar::MakeUTF8( ((RscStringInst *)rInst.pData)->pStr,
378 												pTC->GetSourceCharSet() );
379 				rMem.PutUTF8( pStr );
380 				rtl_freeMemory( pStr );
381 			}
382 			else
383 				rMem.PutUTF8( ((RscStringInst *)rInst.pData)->pStr );
384 		};
385 	};
386 	return( aError );
387 }
388 
389 //==================================================================
390 void RscString::WriteRcAccess
391 (
392 	FILE * fOutput,
393 	RscTypCont * /*pTC*/,
394 	const char * pName
395 )
396 {
397 	fprintf( fOutput, "\t\tString aStr( (const char*)(pResData+nOffset) );\n" );
398 	fprintf( fOutput, "\t\tSet%s( aStr );\n", pName );
399 	fprintf( fOutput, "\t\tnOffset += GetStringSizeRes( aStr );\n" );
400 }
401 
402