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 "sal/config.h"
30 : :
31 : : #include <cstring>
32 : :
33 : : #include <stdio.h>
34 : :
35 : : #include "common.hxx"
36 : : #include "export.hxx"
37 : : #include "xrmmerge.hxx"
38 : : #include "tokens.h"
39 : : #include <iostream>
40 : : #include <fstream>
41 : : #include <vector>
42 : :
43 : : using namespace std;
44 : :
45 : : void yyerror( const char * );
46 : : void YYWarning( const char * );
47 : :
48 : : // defines to parse command line
49 : : #define STATE_NON 0x0001
50 : : #define STATE_INPUT 0x0002
51 : : #define STATE_OUTPUT 0x0003
52 : : #define STATE_PRJ 0x0004
53 : : #define STATE_ROOT 0x0005
54 : : #define STATE_MERGESRC 0x0006
55 : : #define STATE_ERRORLOG 0x0007
56 : : #define STATE_LANGUAGES 0x000C
57 : :
58 : : // set of global variables
59 : : sal_Bool bEnableExport;
60 : : sal_Bool bMergeMode;
61 : : sal_Bool bUTF8;
62 : : sal_Bool bDisplayName;
63 : : sal_Bool bExtensionDescription;
64 : 0 : rtl::OString sPrj;
65 : 0 : rtl::OString sPrjRoot;
66 : 0 : rtl::OString sInputFileName;
67 : 0 : rtl::OString sActFileName;
68 : 0 : rtl::OString sOutputFile;
69 : 0 : rtl::OString sMergeSrc;
70 : 0 : rtl::OString sLangAttribute;
71 : 0 : rtl::OString sResourceType;
72 : : XRMResParser *pParser = NULL;
73 : :
74 : : extern "C" {
75 : : // the whole interface to lexer is in this extern "C" section
76 : :
77 : : /*****************************************************************************/
78 : 0 : extern char *GetOutputFile( int argc, char* argv[])
79 : : /*****************************************************************************/
80 : : {
81 : 0 : bEnableExport = sal_False;
82 : 0 : bMergeMode = sal_False;
83 : 0 : bUTF8 = sal_True;
84 : 0 : bDisplayName = sal_False;
85 : 0 : bExtensionDescription = sal_False;
86 : 0 : sPrj = "";
87 : 0 : sPrjRoot = "";
88 : 0 : sInputFileName = "";
89 : 0 : sActFileName = "";
90 : 0 : Export::sLanguages = "";
91 : 0 : sal_uInt16 nState = STATE_NON;
92 : 0 : sal_Bool bInput = sal_False;
93 : :
94 : : // parse command line
95 : 0 : for( int i = 1; i < argc; i++ ) {
96 : 0 : if ( rtl::OString( argv[ i ] ).toAsciiUpperCase() == "-I" ) {
97 : 0 : nState = STATE_INPUT; // next token specifies source file
98 : : }
99 : 0 : else if ( rtl::OString( argv[ i ] ).toAsciiUpperCase() == "-O" ) {
100 : 0 : nState = STATE_OUTPUT; // next token specifies the dest file
101 : : }
102 : 0 : else if ( rtl::OString( argv[ i ] ).toAsciiUpperCase() == "-P" ) {
103 : 0 : nState = STATE_PRJ; // next token specifies the cur. project
104 : : }
105 : 0 : else if ( rtl::OString( argv[ i ] ).toAsciiUpperCase() == "-R" ) {
106 : 0 : nState = STATE_ROOT; // next token specifies path to project root
107 : : }
108 : 0 : else if ( rtl::OString( argv[ i ] ).toAsciiUpperCase() == "-M" ) {
109 : 0 : nState = STATE_MERGESRC; // next token specifies the merge database
110 : : }
111 : 0 : else if ( rtl::OString( argv[ i ] ).toAsciiUpperCase() == "-E" ) {
112 : 0 : nState = STATE_ERRORLOG;
113 : : }
114 : 0 : else if ( rtl::OString( argv[ i ] ).toAsciiUpperCase() == "-L" ) {
115 : 0 : nState = STATE_LANGUAGES;
116 : : }
117 : : else {
118 : 0 : switch ( nState ) {
119 : : case STATE_NON: {
120 : 0 : return NULL; // no valid command line
121 : : }
122 : : case STATE_INPUT: {
123 : 0 : sInputFileName = argv[ i ];
124 : 0 : bInput = sal_True; // source file found
125 : : }
126 : 0 : break;
127 : : case STATE_OUTPUT: {
128 : 0 : sOutputFile = argv[ i ]; // the dest. file
129 : : }
130 : 0 : break;
131 : : case STATE_PRJ: {
132 : 0 : sPrj = rtl::OString( argv[ i ]);
133 : : }
134 : 0 : break;
135 : : case STATE_ROOT: {
136 : 0 : sPrjRoot = rtl::OString( argv[ i ]); // path to project root
137 : : }
138 : 0 : break;
139 : : case STATE_MERGESRC: {
140 : 0 : sMergeSrc = rtl::OString( argv[ i ]);
141 : 0 : bMergeMode = sal_True; // activate merge mode, cause merge database found
142 : : }
143 : 0 : break;
144 : : case STATE_LANGUAGES: {
145 : 0 : Export::sLanguages = rtl::OString( argv[ i ]);
146 : : }
147 : 0 : break;
148 : : }
149 : : }
150 : : }
151 : :
152 : 0 : if ( bInput ) {
153 : : // command line is valid
154 : 0 : bEnableExport = sal_True;
155 : 0 : char *pReturn = new char[ sOutputFile.getLength() + 1 ];
156 : 0 : std::strcpy( pReturn, sOutputFile.getStr()); // #100211# - checked
157 : 0 : return pReturn;
158 : : }
159 : :
160 : : // command line is not valid
161 : 0 : return NULL;
162 : : }
163 : :
164 : : /*****************************************************************************/
165 : 0 : int InitXrmExport( char *pOutput , char* pFilename)
166 : : /*****************************************************************************/
167 : : {
168 : : // instanciate Export
169 : 0 : rtl::OString sOutput( pOutput );
170 : 0 : rtl::OString sFilename( pFilename );
171 : 0 : Export::InitLanguages( false );
172 : :
173 : 0 : if ( bMergeMode )
174 : 0 : pParser = new XRMResMerge( sMergeSrc, sOutputFile, sFilename );
175 : 0 : else if (!sOutputFile.isEmpty()) {
176 : 0 : pParser = new XRMResExport( sOutputFile, sPrj, sActFileName );
177 : : }
178 : :
179 : 0 : return 1;
180 : : }
181 : :
182 : : /*****************************************************************************/
183 : 0 : int EndXrmExport()
184 : : /*****************************************************************************/
185 : : {
186 : 0 : delete pParser;
187 : 0 : return 1;
188 : : }
189 : 0 : extern const char* getFilename()
190 : : {
191 : 0 : return sInputFileName.getStr();
192 : : }
193 : : /*****************************************************************************/
194 : 0 : extern FILE *GetXrmFile()
195 : : /*****************************************************************************/
196 : : {
197 : : // look for valid filename
198 : 0 : if (!sInputFileName.isEmpty()) {
199 : : //TODO: explicit BOM handling?
200 : 0 : FILE * pFile = fopen(sInputFileName.getStr(), "r");
201 : 0 : if ( !pFile ){
202 : : fprintf( stderr, "Error: Could not open file %s\n",
203 : 0 : sInputFileName.getStr());
204 : : }
205 : : else {
206 : 0 : if (!bMergeMode) {
207 : : sActFileName = common::pathnameToken(
208 : 0 : sInputFileName.getStr(), sPrjRoot.getStr());
209 : : }
210 : 0 : return pFile;
211 : : }
212 : : }
213 : : // this means the file could not be opened
214 : 0 : return NULL;
215 : : }
216 : :
217 : : /*****************************************************************************/
218 : 0 : int WorkOnTokenSet( int nTyp, char *pTokenText )
219 : : /*****************************************************************************/
220 : : {
221 : : //printf("Typ = %d , text = '%s'\n",nTyp , pTokenText );
222 : 0 : pParser->Execute( nTyp, pTokenText );
223 : :
224 : 0 : return 1;
225 : : }
226 : :
227 : : /*****************************************************************************/
228 : 0 : int SetError()
229 : : /*****************************************************************************/
230 : : {
231 : 0 : pParser->SetError();
232 : 0 : return 1;
233 : : }
234 : : }
235 : :
236 : : extern "C" {
237 : : /*****************************************************************************/
238 : 0 : int GetError()
239 : : /*****************************************************************************/
240 : : {
241 : 0 : return pParser->GetError();
242 : : }
243 : : }
244 : :
245 : : //
246 : : // class XRMResParser
247 : : //
248 : :
249 : :
250 : : /*****************************************************************************/
251 : 0 : XRMResParser::XRMResParser()
252 : : /*****************************************************************************/
253 : : : bError( sal_False ),
254 : 0 : bText( sal_False )
255 : : {
256 : 0 : aLanguages = Export::GetLanguages();
257 : 0 : }
258 : :
259 : : /*****************************************************************************/
260 : 0 : XRMResParser::~XRMResParser()
261 : : /*****************************************************************************/
262 : : {
263 : 0 : }
264 : :
265 : : /*****************************************************************************/
266 : 0 : int XRMResParser::Execute( int nToken, char * pToken )
267 : : /*****************************************************************************/
268 : : {
269 : 0 : rtl::OString rToken( pToken );
270 : :
271 : 0 : switch ( nToken ) {
272 : : case XRM_TEXT_START:{
273 : 0 : rtl::OString sNewLID = GetAttribute( rToken, "id" );
274 : 0 : if ( sNewLID != sLID ) {
275 : 0 : sLID = sNewLID;
276 : : }
277 : 0 : bText = sal_True;
278 : 0 : sCurrentText = "";
279 : 0 : sCurrentOpenTag = rToken;
280 : 0 : Output( rToken );
281 : : }
282 : 0 : break;
283 : :
284 : : case XRM_TEXT_END: {
285 : 0 : sCurrentCloseTag = rToken;
286 : 0 : sResourceType = rtl::OString ( "readmeitem" );
287 : 0 : sLangAttribute = rtl::OString ( "xml:lang" );
288 : 0 : WorkOnText( sCurrentOpenTag, sCurrentText );
289 : 0 : Output( sCurrentText );
290 : 0 : EndOfText( sCurrentOpenTag, sCurrentCloseTag );
291 : 0 : bText = sal_False;
292 : 0 : rToken = rtl::OString("");
293 : 0 : sCurrentText = rtl::OString("");
294 : : }
295 : 0 : break;
296 : :
297 : : case DESC_DISPLAY_NAME_START:{
298 : 0 : bDisplayName = sal_True;
299 : : }
300 : 0 : break;
301 : :
302 : : case DESC_DISPLAY_NAME_END:{
303 : 0 : bDisplayName = sal_False;
304 : : }
305 : 0 : break;
306 : :
307 : : case DESC_TEXT_START:{
308 : 0 : if (bDisplayName) {
309 : 0 : sLID = rtl::OString("dispname");
310 : 0 : bText = sal_True;
311 : 0 : sCurrentText = "";
312 : 0 : sCurrentOpenTag = rToken;
313 : 0 : Output( rToken );
314 : : }
315 : : }
316 : 0 : break;
317 : :
318 : : case DESC_TEXT_END: {
319 : 0 : if (bDisplayName) {
320 : 0 : sCurrentCloseTag = rToken;
321 : 0 : sResourceType = rtl::OString ( "description" );
322 : 0 : sLangAttribute = rtl::OString ( "lang" );
323 : 0 : WorkOnText( sCurrentOpenTag, sCurrentText );
324 : 0 : Output( sCurrentText );
325 : 0 : EndOfText( sCurrentOpenTag, sCurrentCloseTag );
326 : 0 : bText = sal_False;
327 : 0 : rToken = rtl::OString("");
328 : 0 : sCurrentText = rtl::OString("");
329 : : }
330 : : }
331 : 0 : break;
332 : :
333 : : case DESC_EXTENSION_DESCRIPTION_START: {
334 : 0 : bExtensionDescription = sal_True;
335 : : }
336 : 0 : break;
337 : :
338 : : case DESC_EXTENSION_DESCRIPTION_END: {
339 : 0 : bExtensionDescription = sal_False;
340 : : }
341 : 0 : break;
342 : :
343 : : case DESC_EXTENSION_DESCRIPTION_SRC: {
344 : 0 : if (bExtensionDescription) {
345 : 0 : sLID = rtl::OString("extdesc");
346 : 0 : sResourceType = rtl::OString ( "description" );
347 : 0 : sLangAttribute = rtl::OString ( "lang" );
348 : 0 : sCurrentOpenTag = rToken;
349 : 0 : sCurrentText = rtl::OString("");
350 : 0 : Output( rToken );
351 : 0 : WorkOnDesc( sCurrentOpenTag, sCurrentText );
352 : 0 : sCurrentCloseTag = rToken;
353 : 0 : Output( sCurrentText );
354 : 0 : rToken = rtl::OString("");
355 : 0 : sCurrentText = rtl::OString("");
356 : : }
357 : : }
358 : 0 : break;
359 : :
360 : : default:
361 : 0 : if ( bText ) {
362 : 0 : sCurrentText += rToken;
363 : : }
364 : 0 : break;
365 : : }
366 : :
367 : 0 : if ( !bText )
368 : : {
369 : 0 : Output( rToken );
370 : : }
371 : 0 : return 0;
372 : : }
373 : :
374 : : /*****************************************************************************/
375 : 0 : rtl::OString XRMResParser::GetAttribute( const rtl::OString &rToken, const rtl::OString &rAttribute )
376 : : /*****************************************************************************/
377 : : {
378 : 0 : rtl::OString sTmp( rToken );
379 : 0 : sTmp = sTmp.replace('\t', ' ');
380 : :
381 : 0 : rtl::OString sSearch( " " );
382 : 0 : sSearch += rAttribute;
383 : 0 : sSearch += "=";
384 : 0 : sal_Int32 nPos = sTmp.indexOf( sSearch );
385 : :
386 : 0 : if ( nPos != -1 )
387 : : {
388 : 0 : sTmp = sTmp.copy( nPos );
389 : 0 : rtl::OString sId = sTmp.getToken(1, '"');
390 : 0 : return sId;
391 : : }
392 : 0 : return rtl::OString();
393 : : }
394 : :
395 : :
396 : : /*****************************************************************************/
397 : 0 : void XRMResParser::Error( const rtl::OString &rError )
398 : : /*****************************************************************************/
399 : : {
400 : 0 : yyerror(( char * ) rError.getStr());
401 : 0 : }
402 : :
403 : : /*****************************************************************************/
404 : 0 : void XRMResParser::ConvertStringToDBFormat( rtl::OString &rString )
405 : : /*****************************************************************************/
406 : : {
407 : 0 : rString = rString.trim().replaceAll("\t", "\\t");
408 : 0 : }
409 : :
410 : : /*****************************************************************************/
411 : 0 : void XRMResParser::ConvertStringToXMLFormat( rtl::OString &rString )
412 : : /*****************************************************************************/
413 : : {
414 : 0 : rString = rString.replaceAll("\\t", "\t");
415 : 0 : }
416 : :
417 : :
418 : :
419 : : //
420 : : // class XRMResOutputParser
421 : : //
422 : :
423 : : /*****************************************************************************/
424 : 0 : XRMResOutputParser::XRMResOutputParser ( const rtl::OString &rOutputFile )
425 : : /*****************************************************************************/
426 : : {
427 : 0 : aLanguages = Export::GetLanguages();
428 : : pOutputStream.open(
429 : 0 : rOutputFile.getStr(), std::ios_base::out | std::ios_base::trunc);
430 : 0 : if (!pOutputStream.is_open()) {
431 : 0 : rtl::OString sError( "Unable to open output file: " );
432 : 0 : sError += rOutputFile;
433 : 0 : Error( sError );
434 : : }
435 : 0 : }
436 : :
437 : : /*****************************************************************************/
438 : 0 : XRMResOutputParser::~XRMResOutputParser()
439 : : /*****************************************************************************/
440 : : {
441 : 0 : pOutputStream.close();
442 : 0 : }
443 : :
444 : : //
445 : : // class XMLResExport
446 : : //
447 : :
448 : : /*****************************************************************************/
449 : 0 : XRMResExport::XRMResExport(
450 : : const rtl::OString &rOutputFile, const rtl::OString &rProject,
451 : : const rtl::OString &rFilePath )
452 : : /*****************************************************************************/
453 : : : XRMResOutputParser( rOutputFile ),
454 : : pResData( NULL ),
455 : : sPrj( rProject ),
456 : 0 : sPath( rFilePath )
457 : : {
458 : 0 : aLanguages = Export::GetLanguages();
459 : 0 : }
460 : :
461 : : /*****************************************************************************/
462 : 0 : XRMResExport::~XRMResExport()
463 : : /*****************************************************************************/
464 : : {
465 : 0 : delete pResData;
466 : 0 : }
467 : :
468 : 0 : void XRMResExport::Output( const rtl::OString& ) {}
469 : :
470 : : /*****************************************************************************/
471 : 0 : void XRMResExport::WorkOnDesc(
472 : : const rtl::OString &rOpenTag,
473 : : rtl::OString &rText
474 : : )
475 : : /*****************************************************************************/
476 : : {
477 : : rtl::OString sDescFileName(
478 : 0 : sInputFileName.replaceAll("description.xml", rtl::OString()));
479 : 0 : sDescFileName += GetAttribute( rOpenTag, "xlink:href" );
480 : : int size;
481 : : char * memblock;
482 : 0 : ifstream file (sDescFileName.getStr(), ios::in|ios::binary|ios::ate);
483 : 0 : if (file.is_open()) {
484 : 0 : size = static_cast<int>(file.tellg());
485 : 0 : memblock = new char [size+1];
486 : 0 : file.seekg (0, ios::beg);
487 : 0 : file.read (memblock, size);
488 : 0 : file.close();
489 : 0 : memblock[size] = '\0';
490 : 0 : rText = rtl::OString(memblock).replaceAll("\n", "\\n");
491 : 0 : delete[] memblock;
492 : : }
493 : 0 : WorkOnText( rOpenTag, rText );
494 : 0 : EndOfText( rOpenTag, rOpenTag );
495 : 0 : }
496 : :
497 : : //*****************************************************************************/
498 : 0 : void XRMResExport::WorkOnText(
499 : : const rtl::OString &rOpenTag,
500 : : rtl::OString &rText
501 : : )
502 : : /*****************************************************************************/
503 : : {
504 : 0 : rtl::OString sLang( GetAttribute( rOpenTag, sLangAttribute ));
505 : :
506 : 0 : if ( !pResData )
507 : : {
508 : 0 : rtl::OString sPlatform( "" );
509 : 0 : pResData = new ResData( sPlatform, GetGID() );
510 : 0 : pResData->sId = GetLID();
511 : : }
512 : :
513 : 0 : rtl::OString sText(rText);
514 : 0 : ConvertStringToDBFormat(sText);
515 : 0 : pResData->sText[sLang] = sText;
516 : 0 : }
517 : :
518 : : /*****************************************************************************/
519 : 0 : void XRMResExport::EndOfText(
520 : : const rtl::OString &,
521 : : const rtl::OString &
522 : : )
523 : : /*****************************************************************************/
524 : : {
525 : 0 : if ( pResData )
526 : : {
527 : 0 : rtl::OString sCur;
528 : 0 : for( unsigned int n = 0; n < aLanguages.size(); n++ )
529 : : {
530 : 0 : sCur = aLanguages[ n ];
531 : :
532 : : rtl::OString sAct(
533 : 0 : pResData->sText[sCur].replaceAll("\x0A", rtl::OString()));
534 : :
535 : 0 : rtl::OString sOutput( sPrj ); sOutput += "\t";
536 : 0 : sOutput += sPath;
537 : 0 : sOutput += "\t0\t";
538 : 0 : sOutput += sResourceType;
539 : 0 : sOutput += "\t";
540 : 0 : sOutput += pResData->sId;
541 : : // USE LID AS GID OR MERGE DON'T WORK
542 : : //sOutput += pResData->sGId;
543 : 0 : sOutput += "\t";
544 : 0 : sOutput += pResData->sId;
545 : 0 : sOutput += "\t\t\t0\t";
546 : 0 : sOutput += sCur;
547 : 0 : sOutput += "\t";
548 : :
549 : 0 : sOutput += sAct;
550 : 0 : sOutput += "\t\t\t\t";
551 : :
552 : 0 : sOutput = sOutput.replace('\0', '_');
553 : 0 : if( sAct.getLength() > 1 )
554 : 0 : pOutputStream << sOutput.getStr() << '\n';
555 : 0 : }
556 : : }
557 : 0 : delete pResData;
558 : 0 : pResData = NULL;
559 : 0 : }
560 : :
561 : : //
562 : : // class XRMResMerge
563 : : //
564 : :
565 : : /*****************************************************************************/
566 : 0 : XRMResMerge::XRMResMerge(
567 : : const rtl::OString &rMergeSource, const rtl::OString &rOutputFile,
568 : : const rtl::OString &rFilename)
569 : : /*****************************************************************************/
570 : : : XRMResOutputParser( rOutputFile ),
571 : : pMergeDataFile( NULL ),
572 : : sFilename( rFilename ) ,
573 : 0 : pResData( NULL )
574 : : {
575 : 0 : if (!rMergeSource.isEmpty())
576 : : pMergeDataFile = new MergeDataFile(
577 : 0 : rMergeSource, sInputFileName, false);
578 : 0 : if( Export::sLanguages.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("ALL")))
579 : : {
580 : 0 : Export::SetLanguages( pMergeDataFile->GetLanguages() );
581 : 0 : aLanguages = pMergeDataFile->GetLanguages();
582 : : }
583 : : else
584 : 0 : aLanguages = Export::GetLanguages();
585 : 0 : }
586 : :
587 : : /*****************************************************************************/
588 : 0 : XRMResMerge::~XRMResMerge()
589 : : /*****************************************************************************/
590 : : {
591 : 0 : delete pMergeDataFile;
592 : 0 : delete pResData;
593 : 0 : }
594 : :
595 : : /*****************************************************************************/
596 : 0 : void XRMResMerge::WorkOnDesc(
597 : : const rtl::OString &rOpenTag,
598 : : rtl::OString &rText
599 : : )
600 : : /*****************************************************************************/
601 : : {
602 : 0 : WorkOnText( rOpenTag, rText);
603 : 0 : if ( pMergeDataFile && pResData ) {
604 : 0 : PFormEntrys *pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
605 : 0 : if ( pEntrys ) {
606 : 0 : rtl::OString sCur;
607 : 0 : rtl::OString sDescFilename = GetAttribute ( rOpenTag, "xlink:href" );
608 : 0 : for( unsigned int n = 0; n < aLanguages.size(); n++ ){
609 : 0 : sCur = aLanguages[ n ];
610 : 0 : rtl::OString sContent;
611 : 0 : if ( !sCur.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("en-US")) &&
612 : : ( pEntrys->GetText(
613 : 0 : sContent, STRING_TYP_TEXT, sCur, sal_True )) &&
614 : 0 : ( sContent != "-" ) && !sContent.isEmpty())
615 : : {
616 : 0 : rtl::OString sText( sContent );
617 : 0 : rtl::OString sAdditionalLine( "\n " );
618 : 0 : sAdditionalLine += rOpenTag;
619 : 0 : rtl::OString sSearch = sLangAttribute;
620 : 0 : sSearch += "=\"";
621 : 0 : rtl::OString sReplace( sSearch );
622 : :
623 : 0 : sSearch += GetAttribute( rOpenTag, sLangAttribute );
624 : 0 : sReplace += sCur;
625 : : sAdditionalLine = sAdditionalLine.replaceFirst(
626 : 0 : sSearch, sReplace);
627 : :
628 : 0 : sSearch = rtl::OString("xlink:href=\"");
629 : 0 : sReplace = sSearch;
630 : :
631 : 0 : rtl::OString sLocDescFilename = sDescFilename;
632 : : sLocDescFilename = sLocDescFilename.replaceFirst(
633 : 0 : "en-US", sCur);
634 : :
635 : 0 : sSearch += sDescFilename;
636 : 0 : sReplace += sLocDescFilename;
637 : : sAdditionalLine = sAdditionalLine.replaceFirst(
638 : 0 : sSearch, sReplace);
639 : :
640 : 0 : Output( sAdditionalLine );
641 : :
642 : 0 : sal_Int32 i = sOutputFile.lastIndexOf('/');
643 : 0 : if (i == -1) {
644 : : std::cerr
645 : 0 : << "Error: output file " << sOutputFile.getStr()
646 : 0 : << " does not contain any /\n";
647 : 0 : throw false; //TODO
648 : : }
649 : : rtl::OString sOutputDescFile(
650 : 0 : sOutputFile.copy(0, i + 1) + sLocDescFilename);
651 : 0 : sText = sText.replaceAll("\\n", "\n");
652 : 0 : ofstream file(sOutputDescFile.getStr());
653 : 0 : if (file.is_open()) {
654 : 0 : file << sText.getStr();
655 : 0 : file.close();
656 : : } else {
657 : : std::cerr
658 : 0 : << "Error: cannot write "
659 : 0 : << sOutputDescFile.getStr() << '\n';
660 : 0 : throw false; //TODO
661 : 0 : }
662 : : }
663 : 0 : }
664 : : }
665 : : }
666 : 0 : delete pResData;
667 : 0 : pResData = NULL;
668 : 0 : }
669 : :
670 : : /*****************************************************************************/
671 : 0 : void XRMResMerge::WorkOnText(
672 : : const rtl::OString &rOpenTag,
673 : : rtl::OString &rText
674 : : )
675 : : /*****************************************************************************/
676 : : {
677 : 0 : rtl::OString sLang( GetAttribute( rOpenTag, sLangAttribute ));
678 : :
679 : 0 : if ( pMergeDataFile ) {
680 : 0 : if ( !pResData ) {
681 : 0 : rtl::OString sPlatform( "" );
682 : 0 : pResData = new ResData( sPlatform, GetLID() , sFilename );
683 : 0 : pResData->sId = GetLID();
684 : 0 : pResData->sResTyp = sResourceType;
685 : : }
686 : :
687 : 0 : PFormEntrys *pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
688 : 0 : if ( pEntrys ) {
689 : 0 : rtl::OString sContent;
690 : 0 : if ( Export::isAllowed( sLang ) &&
691 : : ( pEntrys->GetText(
692 : 0 : sContent, STRING_TYP_TEXT, sLang )) &&
693 : 0 : ( sContent != "-" ) && !sContent.isEmpty())
694 : :
695 : : {
696 : 0 : rText = sContent;
697 : 0 : ConvertStringToXMLFormat( rText );
698 : 0 : }
699 : : }
700 : 0 : }
701 : 0 : }
702 : :
703 : : /*****************************************************************************/
704 : 0 : void XRMResMerge::Output( const rtl::OString& rOutput )
705 : : /*****************************************************************************/
706 : : {
707 : 0 : if (!rOutput.isEmpty())
708 : 0 : pOutputStream << rOutput.getStr();
709 : 0 : }
710 : :
711 : : /*****************************************************************************/
712 : 0 : void XRMResMerge::EndOfText(
713 : : const rtl::OString &rOpenTag,
714 : : const rtl::OString &rCloseTag
715 : : )
716 : : /*****************************************************************************/
717 : : {
718 : :
719 : 0 : Output( rCloseTag );
720 : 0 : if ( pMergeDataFile && pResData ) {
721 : 0 : PFormEntrys *pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
722 : 0 : if ( pEntrys ) {
723 : 0 : rtl::OString sCur;
724 : 0 : for( unsigned int n = 0; n < aLanguages.size(); n++ ){
725 : 0 : sCur = aLanguages[ n ];
726 : 0 : rtl::OString sContent;
727 : 0 : if (!sCur.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("en-US")) &&
728 : : ( pEntrys->GetText(
729 : 0 : sContent, STRING_TYP_TEXT, sCur, sal_True )) &&
730 : 0 : ( sContent != "-" ) && !sContent.isEmpty())
731 : : {
732 : 0 : rtl::OString sText( sContent );
733 : 0 : rtl::OString sAdditionalLine( "\n " );
734 : 0 : sAdditionalLine += rOpenTag;
735 : 0 : rtl::OString sSearch = sLangAttribute;
736 : 0 : sSearch += "=\"";
737 : 0 : rtl::OString sReplace( sSearch );
738 : :
739 : 0 : sSearch += GetAttribute( rOpenTag, sLangAttribute );
740 : 0 : sReplace += sCur;
741 : :
742 : : sAdditionalLine = sAdditionalLine.replaceFirst(
743 : 0 : sSearch, sReplace);
744 : :
745 : 0 : sAdditionalLine += sText;
746 : 0 : sAdditionalLine += rCloseTag;
747 : :
748 : 0 : Output( sAdditionalLine );
749 : : }
750 : 0 : }
751 : : }
752 : : }
753 : 0 : delete pResData;
754 : 0 : pResData = NULL;
755 : 0 : }
756 : :
757 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
