Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : : #include "common.hxx"
30 : : #include "sal/config.h"
31 : :
32 : : #include <cstdio>
33 : : #include <cstdlib>
34 : : #include <cstring>
35 : :
36 : : #include "boost/scoped_ptr.hpp"
37 : : #include "rtl/strbuf.hxx"
38 : :
39 : : #include "common.hxx"
40 : : #include "export.hxx"
41 : : #include "cfgmerge.hxx"
42 : : #include "tokens.h"
43 : :
44 : : void yyerror(char const *);
45 : :
46 : : namespace {
47 : :
48 : : namespace global {
49 : :
50 : : bool mergeMode = false;
51 : : char const * prj = 0;
52 : : char const * prjRoot = 0;
53 : : char const * inputPathname = 0;
54 : : char const * outputPathname = 0;
55 : : char const * mergeSrc;
56 : 0 : boost::scoped_ptr< CfgParser > parser;
57 : :
58 : : }
59 : :
60 : 0 : void handleArguments(int argc, char ** argv) {
61 : 0 : for (int i = 1; i != argc; ++i) {
62 : 0 : if (std::strcmp(argv[i], "-e") == 0) {
63 : : // ignored, used to be "Disable writing errorlog"
64 : 0 : } else if (std::strcmp(argv[i], "-i") == 0) {
65 : 0 : if (++i == argc) {
66 : 0 : global::inputPathname = 0; // no valid command line
67 : 0 : break;
68 : : }
69 : 0 : global::inputPathname = argv[i];
70 : 0 : } else if (std::strcmp(argv[i], "-l") == 0) {
71 : 0 : if (++i == argc) {
72 : 0 : global::inputPathname = 0; // no valid command line
73 : 0 : break;
74 : : }
75 : 0 : Export::sLanguages = argv[i];
76 : 0 : } else if (std::strcmp(argv[i], "-m") == 0) {
77 : 0 : if (++i == argc) {
78 : 0 : global::inputPathname = 0; // no valid command line
79 : 0 : break;
80 : : }
81 : 0 : global::mergeSrc = argv[i];
82 : 0 : global::mergeMode = true;
83 : 0 : } else if (std::strcmp(argv[i], "-o") == 0) {
84 : 0 : if (++i == argc) {
85 : 0 : global::inputPathname = 0; // no valid command line
86 : 0 : break;
87 : : }
88 : 0 : global::outputPathname = argv[i];
89 : 0 : } else if (std::strcmp(argv[i], "-p") == 0) {
90 : 0 : if (++i == argc) {
91 : 0 : global::inputPathname = 0; // no valid command line
92 : 0 : break;
93 : : }
94 : 0 : global::prj = argv[i];
95 : 0 : } else if (std::strcmp(argv[i], "-r") == 0) {
96 : 0 : if (++i == argc) {
97 : 0 : global::inputPathname = 0; // no valid command line
98 : 0 : break;
99 : : }
100 : 0 : global::prjRoot = argv[i];
101 : : } else {
102 : 0 : global::inputPathname = 0; // no valid command line
103 : 0 : break;
104 : : }
105 : : }
106 : 0 : if (global::inputPathname == 0 || global::outputPathname == 0) {
107 : : std::fprintf(
108 : : stderr,
109 : : ("Syntax: cfgex [-p Prj] [-r PrjRoot] -i FileIn -o FileOut"
110 : : " [-m DataBase] [-e] [-l l1,l2,...]\n"
111 : : " Prj: Project\n"
112 : : " PrjRoot: Path to project root (../.. etc.)\n"
113 : : " FileIn: Source files (*.src)\n"
114 : : " FileOut: Destination file (*.*)\n"
115 : : " DataBase: Mergedata (*.sdf)\n"
116 : : " -e: ignored\n"
117 : : " -l: Restrict the handled languages; l1, l2, ... are elements of"
118 : 0 : " (de, en-US, ...)\n"));
119 : 0 : std::exit(EXIT_FAILURE);
120 : : }
121 : 0 : Export::InitLanguages();
122 : 0 : }
123 : :
124 : : }
125 : :
126 : : extern "C" {
127 : :
128 : 0 : FILE * init(int argc, char ** argv) {
129 : 0 : handleArguments(argc, argv);
130 : :
131 : 0 : FILE * pFile = std::fopen(global::inputPathname, "r");
132 : 0 : if (pFile == 0) {
133 : : std::fprintf(
134 : : stderr, "Error: Cannot open file \"%s\"\n",
135 : 0 : global::inputPathname);
136 : 0 : std::exit(EXIT_FAILURE);
137 : : }
138 : :
139 : 0 : if (global::mergeMode) {
140 : : global::parser.reset(
141 : : new CfgMerge(
142 : : global::mergeSrc, global::outputPathname,
143 : 0 : global::inputPathname));
144 : : } else {
145 : : global::parser.reset(
146 : : new CfgExport(
147 : : global::outputPathname, global::prj,
148 : 0 : common::pathnameToken(global::inputPathname, global::prjRoot)));
149 : : }
150 : :
151 : 0 : return pFile;
152 : : }
153 : :
154 : 0 : void workOnTokenSet(int nTyp, char * pTokenText) {
155 : 0 : global::parser->Execute( nTyp, pTokenText );
156 : 0 : }
157 : :
158 : : }
159 : :
160 : : //
161 : : // class CfgStackData
162 : : //
163 : :
164 : 0 : CfgStackData* CfgStack::Push(const rtl::OString &rTag, const rtl::OString &rId)
165 : : {
166 : 0 : CfgStackData *pD = new CfgStackData( rTag, rId );
167 : 0 : maList.push_back( pD );
168 : 0 : return pD;
169 : : }
170 : :
171 : : //
172 : : // class CfgStack
173 : : //
174 : :
175 : : /*****************************************************************************/
176 : 0 : CfgStack::~CfgStack()
177 : : /*****************************************************************************/
178 : : {
179 : 0 : for ( size_t i = 0, n = maList.size(); i < n; i++ )
180 : 0 : delete maList[ i ];
181 : 0 : maList.clear();
182 : 0 : }
183 : :
184 : 0 : rtl::OString CfgStack::GetAccessPath( size_t nPos )
185 : : {
186 : 0 : rtl::OStringBuffer sReturn;
187 : 0 : for (size_t i = 0; i <= nPos; ++i)
188 : : {
189 : 0 : if (i)
190 : 0 : sReturn.append('.');
191 : 0 : sReturn.append(maList[i]->GetIdentifier());
192 : : }
193 : :
194 : 0 : return sReturn.makeStringAndClear();
195 : : }
196 : :
197 : : /*****************************************************************************/
198 : 0 : CfgStackData *CfgStack::GetStackData()
199 : : /*****************************************************************************/
200 : : {
201 : 0 : if (!maList.empty())
202 : 0 : return maList[maList.size() - 1];
203 : : else
204 : 0 : return 0;
205 : : }
206 : :
207 : : //
208 : : // class CfgParser
209 : : //
210 : :
211 : : /*****************************************************************************/
212 : 0 : CfgParser::CfgParser()
213 : : /*****************************************************************************/
214 : : : pStackData( NULL ),
215 : 0 : bLocalize( sal_False )
216 : : {
217 : 0 : }
218 : :
219 : 0 : CfgParser::~CfgParser()
220 : : {
221 : 0 : }
222 : :
223 : 0 : sal_Bool CfgParser::IsTokenClosed(const rtl::OString &rToken)
224 : : {
225 : 0 : return rToken[rToken.getLength() - 2] == '/';
226 : : }
227 : :
228 : : /*****************************************************************************/
229 : 0 : void CfgParser::AddText(
230 : : rtl::OString &rText,
231 : : const rtl::OString &rIsoLang,
232 : : const rtl::OString &rResTyp
233 : : )
234 : : /*****************************************************************************/
235 : : {
236 : : rText = rText.replaceAll(rtl::OString('\n'), rtl::OString()).
237 : : replaceAll(rtl::OString('\r'), rtl::OString()).
238 : 0 : replaceAll(rtl::OString('\t'), rtl::OString());
239 : 0 : pStackData->sResTyp = rResTyp;
240 : 0 : WorkOnText( rText, rIsoLang );
241 : 0 : pStackData->sText[ rIsoLang ] = rText;
242 : 0 : }
243 : :
244 : : /*****************************************************************************/
245 : 0 : int CfgParser::ExecuteAnalyzedToken( int nToken, char *pToken )
246 : : /*****************************************************************************/
247 : : {
248 : 0 : rtl::OString sToken( pToken );
249 : :
250 : 0 : if ( sToken == " " || sToken == "\t" )
251 : 0 : sLastWhitespace += sToken;
252 : :
253 : 0 : rtl::OString sTokenName;
254 : 0 : rtl::OString sTokenId;
255 : :
256 : 0 : sal_Bool bOutput = sal_True;
257 : :
258 : 0 : switch ( nToken ) {
259 : : case CFG_TOKEN_PACKAGE:
260 : : case CFG_TOKEN_COMPONENT:
261 : : case CFG_TOKEN_TEMPLATE:
262 : : case CFG_TOKEN_CONFIGNAME:
263 : : case CFG_TOKEN_OORNAME:
264 : : case CFG_TOKEN_OORVALUE:
265 : : case CFG_TAG:
266 : : case ANYTOKEN:
267 : : case CFG_TEXT_START:
268 : : {
269 : : sTokenName = sToken.getToken(1, '<').getToken(0, '>').
270 : 0 : getToken(0, ' ');
271 : :
272 : 0 : if ( !IsTokenClosed( sToken )) {
273 : 0 : rtl::OString sSearch;
274 : 0 : switch ( nToken ) {
275 : : case CFG_TOKEN_PACKAGE:
276 : 0 : sSearch = "package-id=";
277 : 0 : break;
278 : : case CFG_TOKEN_COMPONENT:
279 : 0 : sSearch = "component-id=";
280 : 0 : break;
281 : : case CFG_TOKEN_TEMPLATE:
282 : 0 : sSearch = "template-id=";
283 : 0 : break;
284 : : case CFG_TOKEN_CONFIGNAME:
285 : 0 : sSearch = "cfg:name=";
286 : 0 : break;
287 : : case CFG_TOKEN_OORNAME:
288 : 0 : sSearch = "oor:name=";
289 : 0 : bLocalize = sal_True;
290 : 0 : break;
291 : : case CFG_TOKEN_OORVALUE:
292 : 0 : sSearch = "oor:value=";
293 : 0 : break;
294 : : case CFG_TEXT_START: {
295 : 0 : if ( sCurrentResTyp != sTokenName ) {
296 : 0 : WorkOnResourceEnd();
297 : 0 : rtl::OString sCur;
298 : 0 : for( unsigned int i = 0; i < aLanguages.size(); ++i ){
299 : 0 : sCur = aLanguages[ i ];
300 : 0 : pStackData->sText[ sCur ] = rtl::OString();
301 : 0 : }
302 : : }
303 : 0 : sCurrentResTyp = sTokenName;
304 : :
305 : 0 : rtl::OString sTemp = sToken.copy( sToken.indexOf( "xml:lang=" ));
306 : 0 : sCurrentIsoLang = sTemp.getToken(1, '"');
307 : :
308 : 0 : if ( sCurrentIsoLang == NO_TRANSLATE_ISO )
309 : 0 : bLocalize = sal_False;
310 : :
311 : 0 : pStackData->sTextTag = sToken;
312 : :
313 : 0 : sCurrentText = "";
314 : : }
315 : 0 : break;
316 : : }
317 : 0 : if ( !sSearch.isEmpty())
318 : : {
319 : 0 : rtl::OString sTemp = sToken.copy( sToken.indexOf( sSearch ));
320 : 0 : sTokenId = sTemp.getToken(1, '"');
321 : : }
322 : 0 : pStackData = aStack.Push( sTokenName, sTokenId );
323 : :
324 : 0 : if ( sSearch == "cfg:name=" ) {
325 : 0 : rtl::OString sTemp( sToken.toAsciiUpperCase() );
326 : 0 : bLocalize = (( sTemp.indexOf( "CFG:TYPE=\"STRING\"" ) != -1 ) &&
327 : 0 : ( sTemp.indexOf( "CFG:LOCALIZED=\"sal_True\"" ) != -1 ));
328 : 0 : }
329 : : }
330 : 0 : else if ( sTokenName == "label" ) {
331 : 0 : if ( sCurrentResTyp != sTokenName ) {
332 : 0 : WorkOnResourceEnd();
333 : 0 : rtl::OString sCur;
334 : 0 : for( unsigned int i = 0; i < aLanguages.size(); ++i ){
335 : 0 : sCur = aLanguages[ i ];
336 : 0 : pStackData->sText[ sCur ] = rtl::OString();
337 : 0 : }
338 : : }
339 : 0 : sCurrentResTyp = sTokenName;
340 : : }
341 : : }
342 : 0 : break;
343 : : case CFG_CLOSETAG:
344 : : {
345 : : sTokenName = sToken.getToken(1, '/').getToken(0, '>').
346 : 0 : getToken(0, ' ');
347 : 0 : if ( aStack.GetStackData() && ( aStack.GetStackData()->GetTagType() == sTokenName ))
348 : : {
349 : 0 : if (sCurrentText.isEmpty())
350 : 0 : WorkOnResourceEnd();
351 : 0 : aStack.Pop();
352 : 0 : pStackData = aStack.GetStackData();
353 : : }
354 : : else
355 : : {
356 : 0 : rtl::OString sError( "Misplaced close tag: " );
357 : 0 : rtl::OString sInFile(" in file ");
358 : 0 : sError += sToken;
359 : 0 : sError += sInFile;
360 : 0 : sError += global::inputPathname;
361 : 0 : Error( sError );
362 : 0 : std::exit(EXIT_FAILURE);
363 : : }
364 : : }
365 : 0 : break;
366 : :
367 : : case CFG_TEXTCHAR:
368 : 0 : sCurrentText += sToken;
369 : 0 : bOutput = sal_False;
370 : 0 : break;
371 : :
372 : : case CFG_TOKEN_NO_TRANSLATE:
373 : 0 : bLocalize = sal_False;
374 : 0 : break;
375 : : }
376 : :
377 : 0 : if ( !sCurrentText.isEmpty() && nToken != CFG_TEXTCHAR )
378 : : {
379 : 0 : AddText( sCurrentText, sCurrentIsoLang, sCurrentResTyp );
380 : 0 : Output( sCurrentText );
381 : 0 : sCurrentText = rtl::OString();
382 : 0 : pStackData->sEndTextTag = sToken;
383 : : }
384 : :
385 : 0 : if ( bOutput )
386 : 0 : Output( sToken );
387 : :
388 : 0 : if ( sToken != " " && sToken != "\t" )
389 : 0 : sLastWhitespace = "";
390 : :
391 : 0 : return 1;
392 : : }
393 : :
394 : 0 : void CfgExport::Output(const rtl::OString&)
395 : : {
396 : 0 : }
397 : :
398 : : /*****************************************************************************/
399 : 0 : int CfgParser::Execute( int nToken, char * pToken )
400 : : /*****************************************************************************/
401 : : {
402 : 0 : rtl::OString sToken( pToken );
403 : :
404 : 0 : switch ( nToken ) {
405 : : case CFG_TAG:
406 : 0 : if ( sToken.indexOf( "package-id=" ) != -1 )
407 : 0 : return ExecuteAnalyzedToken( CFG_TOKEN_PACKAGE, pToken );
408 : 0 : else if ( sToken.indexOf( "component-id=" ) != -1 )
409 : 0 : return ExecuteAnalyzedToken( CFG_TOKEN_COMPONENT, pToken );
410 : 0 : else if ( sToken.indexOf( "template-id=" ) != -1 )
411 : 0 : return ExecuteAnalyzedToken( CFG_TOKEN_TEMPLATE, pToken );
412 : 0 : else if ( sToken.indexOf( "cfg:name=" ) != -1 )
413 : 0 : return ExecuteAnalyzedToken( CFG_TOKEN_OORNAME, pToken );
414 : 0 : else if ( sToken.indexOf( "oor:name=" ) != -1 )
415 : 0 : return ExecuteAnalyzedToken( CFG_TOKEN_OORNAME, pToken );
416 : 0 : else if ( sToken.indexOf( "oor:value=" ) != -1 )
417 : 0 : return ExecuteAnalyzedToken( CFG_TOKEN_OORVALUE, pToken );
418 : 0 : break;
419 : : }
420 : 0 : return ExecuteAnalyzedToken( nToken, pToken );
421 : : }
422 : :
423 : 0 : void CfgParser::Error(const rtl::OString& rError)
424 : : {
425 : 0 : yyerror(rError.getStr());
426 : 0 : }
427 : :
428 : : //
429 : : // class CfgOutputParser
430 : : //
431 : :
432 : 0 : CfgOutputParser::CfgOutputParser(const rtl::OString &rOutputFile)
433 : : {
434 : : pOutputStream.open(
435 : 0 : rOutputFile.getStr(), std::ios_base::out | std::ios_base::trunc);
436 : 0 : if (!pOutputStream.is_open())
437 : : {
438 : 0 : rtl::OStringBuffer sError(RTL_CONSTASCII_STRINGPARAM("ERROR: Unable to open output file: "));
439 : 0 : sError.append(rOutputFile);
440 : 0 : Error(sError.makeStringAndClear());
441 : 0 : std::exit(EXIT_FAILURE);
442 : : }
443 : 0 : }
444 : :
445 : : /*****************************************************************************/
446 : 0 : CfgOutputParser::~CfgOutputParser()
447 : : /*****************************************************************************/
448 : : {
449 : 0 : pOutputStream.close();
450 : 0 : }
451 : :
452 : : //
453 : : // class CfgExport
454 : : //
455 : :
456 : : /*****************************************************************************/
457 : 0 : CfgExport::CfgExport(
458 : : const rtl::OString &rOutputFile,
459 : : const rtl::OString &rProject,
460 : : const rtl::OString &rFilePath
461 : : )
462 : : /*****************************************************************************/
463 : : : CfgOutputParser( rOutputFile ),
464 : : sPrj( rProject ),
465 : 0 : sPath( rFilePath )
466 : : {
467 : 0 : Export::InitLanguages( false );
468 : 0 : aLanguages = Export::GetLanguages();
469 : 0 : }
470 : :
471 : : /*****************************************************************************/
472 : 0 : CfgExport::~CfgExport()
473 : : /*****************************************************************************/
474 : : {
475 : 0 : }
476 : :
477 : : /*****************************************************************************/
478 : 0 : void CfgExport::WorkOnResourceEnd()
479 : : /*****************************************************************************/
480 : : {
481 : 0 : if ( bLocalize ) {
482 : 0 : if ( pStackData->sText[rtl::OString(RTL_CONSTASCII_STRINGPARAM("en-US"))].getLength() )
483 : : {
484 : 0 : rtl::OString sFallback = pStackData->sText[rtl::OString(RTL_CONSTASCII_STRINGPARAM("en-US"))];
485 : 0 : rtl::OString sXComment = pStackData->sText[rtl::OString(RTL_CONSTASCII_STRINGPARAM("x-comment"))];
486 : 0 : rtl::OString sLocalId = pStackData->sIdentifier;
487 : 0 : rtl::OString sGroupId;
488 : 0 : if ( aStack.size() == 1 ) {
489 : 0 : sGroupId = sLocalId;
490 : 0 : sLocalId = "";
491 : : }
492 : : else {
493 : 0 : sGroupId = aStack.GetAccessPath( aStack.size() - 2 );
494 : : }
495 : :
496 : 0 : for (size_t n = 0; n < aLanguages.size(); n++)
497 : : {
498 : 0 : rtl::OString sCur = aLanguages[ n ];
499 : :
500 : 0 : rtl::OString sText = pStackData->sText[ sCur ];
501 : 0 : if ( sText.isEmpty())
502 : 0 : sText = sFallback;
503 : :
504 : 0 : sText = Export::UnquoteHTML( sText );
505 : :
506 : 0 : rtl::OString sOutput( sPrj ); sOutput += "\t";
507 : 0 : sOutput += sPath;
508 : 0 : sOutput += "\t0\t";
509 : 0 : sOutput += pStackData->sResTyp; sOutput += "\t";
510 : 0 : sOutput += sGroupId; sOutput += "\t";
511 : 0 : sOutput += sLocalId; sOutput += "\t\t\t0\t";
512 : 0 : sOutput += sCur;
513 : 0 : sOutput += "\t";
514 : :
515 : 0 : sOutput += sText; sOutput += "\t";
516 : 0 : sOutput += sXComment; sOutput += "\t\t\t";
517 : :
518 : 0 : pOutputStream << sOutput.getStr() << '\n';
519 : 0 : }
520 : : }
521 : : }
522 : 0 : }
523 : :
524 : 0 : void CfgExport::WorkOnText(
525 : : rtl::OString &rText,
526 : : const rtl::OString &rIsoLang
527 : : )
528 : : {
529 : 0 : if( rIsoLang.getLength() ) rText = Export::UnquoteHTML( rText );
530 : 0 : }
531 : :
532 : :
533 : : //
534 : : // class CfgMerge
535 : : //
536 : :
537 : 0 : CfgMerge::CfgMerge(
538 : : const rtl::OString &rMergeSource, const rtl::OString &rOutputFile,
539 : : const rtl::OString &rFilename)
540 : : : CfgOutputParser( rOutputFile ),
541 : : pMergeDataFile( NULL ),
542 : : pResData( NULL ),
543 : : sFilename( rFilename ),
544 : 0 : bEnglish( sal_False )
545 : : {
546 : 0 : if (rMergeSource.getLength())
547 : : {
548 : : pMergeDataFile = new MergeDataFile(
549 : 0 : rMergeSource, global::inputPathname, true );
550 : 0 : if (Export::sLanguages.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("ALL")))
551 : : {
552 : 0 : Export::SetLanguages( pMergeDataFile->GetLanguages() );
553 : 0 : aLanguages = pMergeDataFile->GetLanguages();
554 : : }
555 : 0 : else aLanguages = Export::GetLanguages();
556 : : }
557 : : else
558 : 0 : aLanguages = Export::GetLanguages();
559 : 0 : }
560 : :
561 : : /*****************************************************************************/
562 : 0 : CfgMerge::~CfgMerge()
563 : : /*****************************************************************************/
564 : : {
565 : 0 : delete pMergeDataFile;
566 : 0 : delete pResData;
567 : 0 : }
568 : :
569 : 0 : void CfgMerge::WorkOnText(rtl::OString &rText, const rtl::OString& rLangIndex)
570 : : {
571 : :
572 : 0 : if ( pMergeDataFile && bLocalize ) {
573 : 0 : if ( !pResData ) {
574 : 0 : rtl::OString sLocalId = pStackData->sIdentifier;
575 : 0 : rtl::OString sGroupId;
576 : 0 : if ( aStack.size() == 1 ) {
577 : 0 : sGroupId = sLocalId;
578 : 0 : sLocalId = rtl::OString();
579 : : }
580 : : else {
581 : 0 : sGroupId = aStack.GetAccessPath( aStack.size() - 2 );
582 : : }
583 : :
584 : 0 : rtl::OString sPlatform;
585 : :
586 : 0 : pResData = new ResData( sPlatform, sGroupId , sFilename );
587 : 0 : pResData->sId = sLocalId;
588 : 0 : pResData->sResTyp = pStackData->sResTyp;
589 : : }
590 : :
591 : 0 : if (rLangIndex.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("en-US")))
592 : 0 : bEnglish = sal_True;
593 : :
594 : 0 : PFormEntrys *pEntrys = pMergeDataFile->GetPFormEntrysCaseSensitive( pResData );
595 : 0 : if ( pEntrys ) {
596 : 0 : rtl::OString sContent;
597 : 0 : pEntrys->GetText( sContent, STRING_TYP_TEXT, rLangIndex );
598 : :
599 : 0 : if ( Export::isAllowed( rLangIndex ) &&
600 : 0 : ( sContent != "-" ) && !sContent.isEmpty())
601 : : {
602 : 0 : rText = Export::QuoteHTML( rText );
603 : 0 : }
604 : : }
605 : : }
606 : 0 : }
607 : :
608 : 0 : void CfgMerge::Output(const rtl::OString& rOutput)
609 : : {
610 : 0 : pOutputStream << rOutput.getStr();
611 : 0 : }
612 : :
613 : : /*****************************************************************************/
614 : 0 : void CfgMerge::WorkOnResourceEnd()
615 : : /*****************************************************************************/
616 : : {
617 : :
618 : 0 : if ( pMergeDataFile && pResData && bLocalize && bEnglish ) {
619 : 0 : PFormEntrys *pEntrys = pMergeDataFile->GetPFormEntrysCaseSensitive( pResData );
620 : 0 : if ( pEntrys ) {
621 : 0 : rtl::OString sCur;
622 : :
623 : 0 : for( unsigned int i = 0; i < aLanguages.size(); ++i ){
624 : 0 : sCur = aLanguages[ i ];
625 : :
626 : 0 : rtl::OString sContent;
627 : 0 : pEntrys->GetText( sContent, STRING_TYP_TEXT, sCur , sal_True );
628 : 0 : if (
629 : 0 : ( !sCur.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("en-US")) ) &&
630 : :
631 : 0 : ( sContent != "-" ) && !sContent.isEmpty())
632 : : {
633 : :
634 : 0 : rtl::OString sText = Export::QuoteHTML( sContent);
635 : :
636 : 0 : rtl::OString sAdditionalLine( "\t" );
637 : :
638 : 0 : rtl::OString sTextTag = pStackData->sTextTag;
639 : 0 : rtl::OString sTemp = sTextTag.copy( sTextTag.indexOf( "xml:lang=" ));
640 : :
641 : 0 : sal_Int32 n = 0;
642 : 0 : rtl::OString sSearch = sTemp.getToken(0, '"', n);
643 : 0 : sSearch += "\"";
644 : 0 : sSearch += sTemp.getToken(0, '"', n);
645 : 0 : sSearch += "\"";
646 : :
647 : 0 : rtl::OString sReplace = sTemp.getToken(0, '"');
648 : 0 : sReplace += "\"";
649 : 0 : sReplace += sCur;
650 : 0 : sReplace += "\"";
651 : :
652 : 0 : sTextTag = sTextTag.replaceFirst(sSearch, sReplace);
653 : :
654 : 0 : sAdditionalLine += sTextTag;
655 : 0 : sAdditionalLine += sText;
656 : 0 : sAdditionalLine += pStackData->sEndTextTag;
657 : :
658 : 0 : sAdditionalLine += "\n";
659 : 0 : sAdditionalLine += sLastWhitespace;
660 : :
661 : 0 : Output( sAdditionalLine );
662 : : }
663 : 0 : }
664 : : }
665 : : }
666 : 0 : delete pResData;
667 : 0 : pResData = NULL;
668 : 0 : bEnglish = sal_False;
669 : 0 : }
670 : :
671 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
