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 "sal/config.h"
21 :
22 : #include <cstddef>
23 : #include <cstring>
24 :
25 : #include "boost/scoped_ptr.hpp"
26 : #include <stdio.h>
27 : #include <stdlib.h>
28 : #include "common.hxx"
29 : #include "export.hxx"
30 : #include "helper.hxx"
31 : #include "tokens.h"
32 : #include <iostream>
33 : #include <rtl/strbuf.hxx>
34 :
35 : void yyerror( const char * );
36 : void YYWarning( const char * );
37 :
38 : namespace {
39 :
40 14 : rtl::OString sActFileName; //TODO
41 : MergeDataFile * pMergeDataFile = 0; //TODO
42 :
43 : namespace global {
44 :
45 14 : OString prj;
46 14 : OString prjRoot;
47 14 : OString inputPathname;
48 14 : boost::scoped_ptr< Export > exporter;
49 :
50 : }
51 : }
52 :
53 : extern "C" {
54 :
55 14 : FILE * init(int argc, char ** argv) {
56 :
57 14 : HandledArgs aArgs;
58 14 : if ( !Export::handleArguments(argc, argv, aArgs) )
59 : {
60 0 : Export::writeUsage("transex3","src/hrc");
61 0 : std::exit(EXIT_FAILURE);
62 : }
63 14 : Export::InitLanguages();
64 14 : global::prj = aArgs.m_sPrj;
65 14 : global::prjRoot = aArgs.m_sPrjRoot;
66 14 : global::inputPathname = aArgs.m_sInputFile;
67 :
68 14 : FILE * pFile = std::fopen(global::inputPathname.getStr(), "r");
69 14 : if (pFile == 0) {
70 : std::fprintf(
71 : stderr, "Error: Cannot open file \"%s\"\n",
72 0 : global::inputPathname.getStr());
73 0 : std::exit(EXIT_FAILURE);
74 : }
75 :
76 14 : if (aArgs.m_bMergeMode) {
77 : global::exporter.reset(
78 14 : new Export(aArgs.m_sMergeSrc.getStr(), aArgs.m_sOutputFile.getStr()));
79 : } else {
80 : sActFileName =
81 : common::pathnameToken(
82 0 : global::inputPathname.getStr(), global::prjRoot.getStr());
83 0 : global::exporter.reset(new Export(aArgs.m_sOutputFile.getStr()));
84 : }
85 :
86 14 : global::exporter->Init();
87 :
88 14 : return pFile;
89 : }
90 :
91 269 : int Parse( int nTyp, const char *pTokenText ){
92 269 : global::exporter->Execute( nTyp , pTokenText );
93 269 : return 1;
94 : }
95 14 : void Close(){
96 14 : global::exporter->pParseQueue->Close();
97 14 : global::exporter.reset();
98 : // avoid nontrivial Export dtor being executed during exit
99 14 : }
100 :
101 31933 : int WorkOnTokenSet( int nTyp, char *pTokenText )
102 : {
103 :
104 31933 : global::exporter->pParseQueue->Push( QueueEntry( nTyp , rtl::OString(pTokenText) ) );
105 31933 : return 1;
106 : }
107 :
108 : } // extern
109 :
110 : extern "C" {
111 : /*****************************************************************************/
112 0 : int SetError()
113 : /*****************************************************************************/
114 : {
115 : // set error at global instance of class Export
116 0 : global::exporter->SetError();
117 0 : return 1;
118 : }
119 : }
120 :
121 : extern "C" {
122 : /*****************************************************************************/
123 14 : int GetError()
124 : /*****************************************************************************/
125 : {
126 : // get error at global instance of class Export
127 14 : if (global::exporter->GetError())
128 0 : return 1;
129 14 : return sal_False;
130 : }
131 : }
132 :
133 : //
134 : // class ResData
135 : //
136 :
137 : /*****************************************************************************/
138 1107 : sal_Bool ResData::SetId( const rtl::OString& rId, sal_uInt16 nLevel )
139 : /*****************************************************************************/
140 : {
141 1107 : if ( nLevel > nIdLevel )
142 : {
143 701 : nIdLevel = nLevel;
144 701 : sId = rId;
145 :
146 701 : if ( bChild && bChildWithText )
147 : {
148 0 : rtl::OString sError(RTL_CONSTASCII_STRINGPARAM("ResId after child definition"));
149 0 : yyerror(sError.getStr());
150 0 : SetError();
151 : }
152 :
153 701 : if ( sId.getLength() > 255 )
154 : {
155 0 : YYWarning( "LocalId > 255 chars, truncating..." );
156 0 : sId = sId.copy(0, 255).trim();
157 : }
158 :
159 701 : return sal_True;
160 : }
161 :
162 406 : return sal_False;
163 : }
164 :
165 : //
166 : // class Export
167 : //
168 :
169 0 : Export::Export(const rtl::OString &rOutput)
170 : :
171 : pWordTransformer( NULL ),
172 : bDefine( sal_False ),
173 : bNextMustBeDefineEOL( sal_False ),
174 : nLevel( 0 ),
175 : nList( LIST_NON ),
176 : nListIndex( 0 ),
177 : nListLevel( 0 ),
178 : bSkipFile( false ),
179 : sProject( global::prj ),
180 : sRoot( global::prjRoot ),
181 : bMergeMode( false ),
182 : bError( sal_False ),
183 : bReadOver( sal_False ),
184 : bDontWriteOutput( sal_False ),
185 0 : sFilename( global::inputPathname )
186 : {
187 0 : pParseQueue = new ParserQueue( *this );
188 :
189 0 : if( !isInitialized ) InitLanguages();
190 : // used when export is enabled
191 :
192 : // open output stream
193 0 : aOutput.open(rOutput.getStr(), std::ios_base::out | std::ios_base::trunc);
194 0 : if (!aOutput.is_open()) {
195 0 : fprintf(stderr, "ERROR : Can't open file %s\n", rOutput.getStr());
196 0 : exit ( -1 );
197 : }
198 0 : }
199 :
200 14 : Export::Export(const rtl::OString &rMergeSource, const rtl::OString &rOutput)
201 : :
202 : pWordTransformer( NULL ),
203 : bDefine( sal_False ),
204 : bNextMustBeDefineEOL( sal_False ),
205 : nLevel( 0 ),
206 : nList( LIST_NON ),
207 : nListIndex( 0 ),
208 : nListLevel( 0 ),
209 : bSkipFile( false ),
210 : sProject( global::prj ),
211 : sRoot( global::prjRoot ),
212 : bMergeMode( sal_True ),
213 : sMergeSrc( rMergeSource ),
214 : bError( sal_False ),
215 : bReadOver( sal_False ),
216 : bDontWriteOutput( sal_False ),
217 14 : sFilename( global::inputPathname )
218 : {
219 14 : pParseQueue = new ParserQueue( *this );
220 14 : if( !isInitialized ) InitLanguages( bMergeMode );
221 : // used when merge is enabled
222 :
223 : // open output stream
224 14 : aOutput.open(rOutput.getStr(), std::ios_base::out | std::ios_base::trunc);
225 14 : }
226 :
227 : /*****************************************************************************/
228 14 : void Export::Init()
229 : /*****************************************************************************/
230 : {
231 : // resets the internal status, used before parseing another file
232 14 : sActPForm = "";
233 14 : bDefine = sal_False;
234 14 : bNextMustBeDefineEOL = sal_False;
235 14 : nLevel = 0;
236 14 : nList = LIST_NON;
237 14 : m_sListLang = rtl::OString();
238 14 : nListIndex = 0;
239 14 : for ( size_t i = 0, n = aResStack.size(); i < n; ++i )
240 0 : delete aResStack[ i ];
241 14 : aResStack.clear();
242 14 : }
243 :
244 : /*****************************************************************************/
245 28 : Export::~Export()
246 : /*****************************************************************************/
247 : {
248 14 : if( pParseQueue )
249 14 : delete pParseQueue;
250 14 : aOutput.close();
251 16 : for ( size_t i = 0, n = aResStack.size(); i < n; ++i )
252 2 : delete aResStack[ i ];
253 14 : aResStack.clear();
254 :
255 14 : if ( bMergeMode ) {
256 14 : if ( !pMergeDataFile )
257 0 : pMergeDataFile = new MergeDataFile(sMergeSrc, global::inputPathname, false);
258 :
259 14 : delete pMergeDataFile;
260 : }
261 14 : }
262 :
263 : /*****************************************************************************/
264 32226 : int Export::Execute( int nToken, const char * pToken )
265 : /*****************************************************************************/
266 : {
267 :
268 32226 : rtl::OString sToken( pToken );
269 32226 : rtl::OString sOrig( sToken );
270 32226 : sal_Bool bWriteToMerged = bMergeMode;
271 :
272 32226 : if ( nToken == CONDITION )
273 : {
274 159 : rtl::OString sTestToken(pToken);
275 : sTestToken = sTestToken.replaceAll("\t", rtl::OString()).
276 159 : replaceAll(" ", rtl::OString());
277 159 : if (( !bReadOver ) && ( sTestToken.indexOf("#ifndef__RSC_PARSER") == 0 ))
278 0 : bReadOver = sal_True;
279 159 : else if (( bReadOver ) && ( sTestToken.indexOf("#endif") == 0 ))
280 0 : bReadOver = sal_False;
281 : }
282 87566 : if ((( nToken < FILTER_LEVEL ) || ( bReadOver )) &&
283 27673 : (!(( bNextMustBeDefineEOL ) && ( sOrig == "\n" )))) {
284 : // this tokens are not mandatory for parsing, so ignore them ...
285 27669 : if ( bMergeMode )
286 27669 : WriteToMerged( sOrig , false ); // ... ore whrite them directly to dest.
287 27669 : return 0;
288 : }
289 :
290 4557 : ResData *pResData = NULL;
291 4557 : if ( nLevel ) {
292 : // res. exists at cur. level
293 3933 : pResData = ( (nLevel-1) < aResStack.size() ) ? aResStack[ nLevel-1 ] : NULL;
294 : }
295 624 : else if (( nToken != RESOURCE ) &&
296 : ( nToken != RESOURCEEXPR ) &&
297 : ( nToken != SMALRESOURCE ) &&
298 : ( nToken != LEVELUP ) &&
299 : ( nToken != NORMDEFINE ) &&
300 : ( nToken != RSCDEFINE ) &&
301 : ( nToken != CONDITION ) &&
302 : ( nToken != PRAGMA ))
303 : {
304 : // no res. exists at cur. level so return
305 182 : if ( bMergeMode )
306 182 : WriteToMerged( sOrig , false );
307 182 : return 0;
308 : }
309 : // #define NO_LOCALIZE_EXPORT
310 4375 : if( bSkipFile ){
311 0 : if ( bMergeMode ) {
312 0 : WriteToMerged( sOrig , false );
313 : }
314 0 : return 1;
315 : }
316 :
317 :
318 4375 : if ( bDefine ) {
319 2711 : if (( nToken != EMPTYLINE ) && ( nToken != LEVELDOWN ) && ( nToken != LEVELUP )) {
320 : // cur. res. defined in macro
321 2051 : if ( bNextMustBeDefineEOL ) {
322 2 : if ( nToken != RSCDEFINELEND ) {
323 : // end of macro found, so destroy res.
324 2 : bDefine = sal_False;
325 2 : Execute( LEVELDOWN, "" );
326 2 : bNextMustBeDefineEOL = sal_False;
327 : }
328 : else {
329 : // next line also in macro definition
330 0 : bNextMustBeDefineEOL = sal_False;
331 0 : if ( bMergeMode )
332 0 : WriteToMerged( sOrig , false );
333 0 : return 1;
334 : }
335 : }
336 : }
337 : }
338 :
339 4375 : sal_Bool bExecuteDown = sal_False;
340 4375 : if ( nToken != LEVELDOWN ) {
341 3514 : sal_uInt16 nOpen = 0;
342 3514 : sal_uInt16 nClose = 0;
343 3514 : sal_Bool bReadOver1 = sal_False;
344 3514 : sal_uInt16 i = 0;
345 111428 : for ( i = 0; i < sToken.getLength(); i++ ) {
346 107914 : if ( sToken[i] == '"' )
347 912 : bReadOver1 = !bReadOver1;
348 107914 : if ( !bReadOver1 && ( sToken[i] == '{' ))
349 594 : nOpen++;
350 : }
351 :
352 3514 : bReadOver1 = sal_False;
353 111428 : for ( i = 0; i < sToken.getLength(); i++ ) {
354 107914 : if ( sToken[i] == '"' )
355 912 : bReadOver1 = !bReadOver1;
356 107914 : if ( !bReadOver1 && ( sToken[i] == '}' ))
357 3 : nClose++;
358 : }
359 :
360 3514 : if ( nOpen < nClose )
361 0 : bExecuteDown = sal_True;
362 : }
363 4375 : switch ( nToken ) {
364 :
365 : case NORMDEFINE:
366 73 : sToken = sToken.replace('\r', ' ').replace('\t', ' ');
367 429 : for (;;) {
368 502 : sal_Int32 n = 0;
369 502 : sToken = sToken.replaceFirst(" ", " ", &n);
370 502 : if (n == -1) {
371 : break;
372 : }
373 : }
374 73 : if( sToken.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("#define NO_LOCALIZE_EXPORT")) ){
375 0 : bSkipFile = true;
376 0 : return 0;
377 : }
378 73 : if ( bMergeMode )
379 73 : WriteToMerged( sOrig , false );
380 :
381 73 : return 0;
382 :
383 :
384 : case RSCDEFINE:
385 274 : bDefine = sal_True; // res. defined in macro
386 :
387 : case RESOURCE:
388 : case RESOURCEEXPR: {
389 417 : bDontWriteOutput = sal_False;
390 417 : if ( nToken != RSCDEFINE )
391 143 : bNextMustBeDefineEOL = sal_False;
392 : // this is the beginning of a new res.
393 417 : nLevel++;
394 417 : if ( nLevel > 1 ) {
395 116 : aResStack[ nLevel - 2 ]->bChild = sal_True;
396 : }
397 :
398 : // create new instance for this res. and fill mandatory fields
399 :
400 417 : pResData = new ResData( sActPForm, FullId() , sFilename );
401 417 : aResStack.push_back( pResData );
402 : sToken = sToken.replaceAll("\n", rtl::OString()).
403 : replaceAll("\r", rtl::OString()).
404 417 : replaceAll("{", rtl::OString()).replace('\t', ' ');
405 417 : sToken = sToken.trim();
406 417 : rtl::OString sTLower = sToken.getToken(0, ' ').toAsciiLowerCase();
407 417 : pResData->sResTyp = sTLower;
408 417 : rtl::OString sId( sToken.copy( pResData->sResTyp.getLength() + 1 ));
409 417 : rtl::OString sCondition;
410 417 : if ( sId.indexOf( '#' ) != -1 )
411 : {
412 : // between ResTyp, Id and paranthes is a precomp. condition
413 22 : sCondition = "#";
414 22 : sal_Int32 n = 0;
415 22 : sId = sId.getToken(0, '#', n);
416 22 : sCondition += sId.getToken(0, '#', n);
417 : }
418 417 : sId = sId.getToken(0, '/');
419 417 : CleanValue( sId );
420 417 : sId = sId.replaceAll("\t", rtl::OString());
421 417 : pResData->SetId( sId, ID_LEVEL_IDENTIFIER );
422 417 : if (!sCondition.isEmpty())
423 : {
424 22 : Execute( CONDITION, ""); // execute the precomp. condition
425 417 : }
426 : }
427 417 : break;
428 : case SMALRESOURCE: {
429 385 : bDontWriteOutput = sal_False;
430 : // this is the beginning of a new res.
431 385 : bNextMustBeDefineEOL = sal_False;
432 385 : nLevel++;
433 385 : if ( nLevel > 1 ) {
434 385 : aResStack[ nLevel - 2 ]->bChild = sal_True;
435 : }
436 :
437 : // create new instance for this res. and fill mandatory fields
438 :
439 385 : pResData = new ResData( sActPForm, FullId() , sFilename );
440 385 : aResStack.push_back( pResData );
441 : sToken = sToken.replaceAll("\n", rtl::OString()).
442 : replaceAll("\r", rtl::OString()).
443 : replaceAll("{", rtl::OString()).
444 : replaceAll("\t", rtl::OString()).
445 : replaceAll(" ", rtl::OString()).
446 385 : replaceAll("\\", rtl::OString()).toAsciiLowerCase();
447 385 : pResData->sResTyp = sToken;
448 : }
449 385 : break;
450 : case LEVELUP: {
451 : // push
452 59 : if ( nList )
453 0 : nListLevel++;
454 59 : if ( nList )
455 : break;
456 :
457 59 : bDontWriteOutput = sal_False;
458 59 : rtl::OString sLowerTyp;
459 59 : if ( pResData )
460 59 : sLowerTyp = "unknown";
461 59 : nLevel++;
462 59 : if ( nLevel > 1 ) {
463 59 : aResStack[ nLevel - 2 ]->bChild = sal_True;
464 : }
465 :
466 59 : ResData *pNewData = new ResData( sActPForm, FullId() , sFilename );
467 59 : pNewData->sResTyp = sLowerTyp;
468 59 : aResStack.push_back( pNewData );
469 : }
470 59 : break;
471 : case LEVELDOWN: {
472 : // pop
473 861 : if ( !nList ) {
474 859 : bDontWriteOutput = sal_False;
475 859 : if ( nLevel ) {
476 859 : if ( bDefine && (nLevel == 1 )) {
477 1 : bDefine = sal_False;
478 1 : bNextMustBeDefineEOL = sal_False;
479 : }
480 859 : WriteData( pResData );
481 859 : ResStack::iterator it = aResStack.begin();
482 859 : ::std::advance( it, nLevel-1 );
483 859 : delete *it;
484 859 : aResStack.erase( it );
485 859 : nLevel--;
486 : }
487 : }
488 : else {
489 2 : if ( bDefine )
490 2 : bNextMustBeDefineEOL = sal_True;
491 2 : if ( !nListLevel ) {
492 2 : if ( bMergeMode )
493 2 : MergeRest( pResData, MERGE_MODE_LIST );
494 2 : nList = LIST_NON;
495 : }
496 : else
497 0 : nListLevel--;
498 : }
499 : }
500 861 : break;
501 : case ASSIGNMENT:
502 : {
503 1114 : bDontWriteOutput = sal_False;
504 : // interpret different types of assignement
505 1114 : sal_Int32 n = 0;
506 : rtl::OString sKey = sToken.getToken(0, '=', n).
507 : replaceAll(" ", rtl::OString()).
508 1114 : replaceAll("\t", rtl::OString());
509 1114 : rtl::OString sValue = sToken.getToken(0, '=', n);
510 1114 : CleanValue( sValue );
511 1114 : sKey = sKey.toAsciiUpperCase();
512 1114 : if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("IDENTIFIER")))
513 : {
514 : rtl::OString sId(
515 : sValue.replaceAll("\t", rtl::OString()).
516 365 : replaceAll(" ", rtl::OString()));
517 365 : pResData->SetId(sId, ID_LEVEL_IDENTIFIER);
518 : }
519 749 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("HELPID")))
520 : {
521 338 : pResData->sHelpId = sValue;
522 : }
523 411 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("STRINGLIST")))
524 : {
525 0 : pResData->bList = sal_True;
526 0 : nList = LIST_STRING;
527 0 : m_sListLang = SOURCE_LANGUAGE;
528 0 : nListIndex = 0;
529 0 : nListLevel = 0;
530 : }
531 411 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("FILTERLIST")))
532 : {
533 0 : pResData->bList = sal_True;
534 0 : nList = LIST_FILTER;
535 0 : m_sListLang = SOURCE_LANGUAGE;
536 0 : nListIndex = 0;
537 0 : nListLevel = 0;
538 : }
539 411 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("UIENTRIES")))
540 : {
541 0 : pResData->bList = sal_True;
542 0 : nList = LIST_UIENTRIES;
543 0 : m_sListLang = SOURCE_LANGUAGE;
544 0 : nListIndex = 0;
545 0 : nListLevel = 0;
546 : }
547 1114 : if (sToken.indexOf( '{' ) != -1
548 0 : && (helper::countOccurrences(sToken, '{')
549 0 : > helper::countOccurrences(sToken, '}')))
550 : {
551 0 : Parse( LEVELUP, "" );
552 1114 : }
553 : }
554 1114 : break;
555 : case UIENTRIES:
556 : case LISTASSIGNMENT:
557 : {
558 4 : bDontWriteOutput = sal_False;
559 : rtl::OString sTmpToken(
560 4 : sToken.replaceAll(" ", rtl::OString()).toAsciiLowerCase());
561 4 : sal_Int32 nPos = sTmpToken.indexOf("[en-us]=");
562 4 : if (nPos != -1) {
563 : rtl::OString sKey(
564 : sTmpToken.copy(0 , nPos).replaceAll(" ", rtl::OString()).
565 2 : replaceAll("\t", rtl::OString()));
566 2 : rtl::OString sValue = sToken.getToken(1, '=');
567 2 : CleanValue( sValue );
568 2 : sKey = sKey.toAsciiUpperCase();
569 2 : if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("STRINGLIST")))
570 : {
571 2 : pResData->bList = sal_True;
572 2 : nList = LIST_STRING;
573 2 : m_sListLang = SOURCE_LANGUAGE;
574 2 : nListIndex = 0;
575 2 : nListLevel = 0;
576 : }
577 0 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("FILTERLIST")))
578 : {
579 0 : pResData->bList = sal_True;
580 0 : nList = LIST_FILTER;
581 0 : m_sListLang = SOURCE_LANGUAGE;
582 0 : nListIndex = 0;
583 0 : nListLevel = 0;
584 : }
585 : // PairedList
586 0 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("PAIREDLIST")))
587 : {
588 0 : pResData->bList = sal_True;
589 0 : nList = LIST_PAIRED;
590 0 : m_sListLang = SOURCE_LANGUAGE;
591 0 : nListIndex = 0;
592 0 : nListLevel = 0;
593 : }
594 0 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("ITEMLIST")))
595 : {
596 0 : pResData->bList = sal_True;
597 0 : nList = LIST_ITEM;
598 0 : m_sListLang = SOURCE_LANGUAGE;
599 0 : nListIndex = 0;
600 0 : nListLevel = 0;
601 : }
602 0 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("UIENTRIES")))
603 : {
604 0 : pResData->bList = sal_True;
605 0 : nList = LIST_UIENTRIES;
606 0 : m_sListLang = SOURCE_LANGUAGE;
607 0 : nListIndex = 0;
608 0 : nListLevel = 0;
609 2 : }
610 : }
611 : else
612 : {
613 : // new res. is a String- or FilterList
614 2 : sal_Int32 n = 0;
615 : rtl::OString sKey(
616 : sToken.getToken(0, '[', n).replaceAll(" ", rtl::OString()).
617 2 : replaceAll("\t", rtl::OString()).toAsciiUpperCase());
618 2 : if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("STRINGLIST")))
619 0 : nList = LIST_STRING;
620 2 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("FILTERLIST")))
621 0 : nList = LIST_FILTER;
622 2 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("PAIREDLIST")))
623 0 : nList = LIST_PAIRED; // abcd
624 2 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("ITEMLIST")))
625 0 : nList = LIST_ITEM;
626 2 : else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("UIENTRIES")))
627 0 : nList = LIST_UIENTRIES;
628 2 : if ( nList ) {
629 0 : rtl::OString sLang = sToken.getToken(0, ']', n);
630 0 : CleanValue( sLang );
631 0 : m_sListLang = sLang;
632 0 : nListIndex = 0;
633 0 : nListLevel = 0;
634 2 : }
635 4 : }
636 : }
637 4 : break;
638 : case TEXT:
639 : case _LISTTEXT:
640 : case LISTTEXT: {
641 : // this is an entry for a String- or FilterList
642 23 : if ( nList ) {
643 17 : SetChildWithText();
644 17 : sal_Int32 n = 0;
645 17 : rtl::OString sEntry(sToken.getToken(1, '"', n));
646 17 : if ( helper::countOccurrences(sToken, '"') > 2 )
647 0 : sEntry += "\"";
648 17 : if ( sEntry == "\\\"" )
649 0 : sEntry = "\"";
650 17 : InsertListEntry( sEntry, sOrig );
651 17 : if ( bMergeMode && ( sEntry != "\"" ))
652 : {
653 17 : PrepareTextToMerge( sOrig, nList, m_sListLang, pResData );
654 17 : }
655 : }
656 : }
657 23 : break;
658 : case LONGTEXTLINE:
659 : case TEXTLINE:
660 432 : bDontWriteOutput = sal_False;
661 432 : if ( nLevel )
662 : {
663 432 : CutComment( sToken );
664 :
665 : // this is a text line!!!
666 432 : rtl::OString t(sToken.getToken(0, '='));
667 : rtl::OString sKey(
668 : t.getToken(0, '[').replaceAll(" ", rtl::OString()).
669 432 : replaceAll("\t", rtl::OString()));
670 432 : rtl::OString sText( GetText( sToken, nToken ));
671 432 : rtl::OString sLang;
672 432 : if ( sToken.getToken(0, '=').indexOf('[') != -1 )
673 : {
674 : sLang = sToken.getToken(0, '=').getToken(1, '[').
675 331 : getToken(0, ']');
676 331 : CleanValue( sLang );
677 : }
678 432 : rtl::OString sLangIndex = sLang;
679 432 : rtl::OString sOrigKey = sKey;
680 432 : if ( !sText.isEmpty() && !sLang.isEmpty() )
681 : {
682 326 : sKey = sKey.toAsciiUpperCase();
683 326 : if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("TEXT")) ||
684 0 : sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("MESSAGE")) ||
685 0 : sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("CUSTOMUNITTEXT")) ||
686 0 : sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("SLOTNAME")) ||
687 0 : sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("UINAME")))
688 : {
689 326 : SetChildWithText();
690 326 : if ( Export::isSourceLanguage( sLangIndex ) )
691 325 : pResData->SetId( sText, ID_LEVEL_TEXT );
692 :
693 326 : pResData->bText = sal_True;
694 326 : pResData->sTextTyp = sOrigKey;
695 326 : if ( bMergeMode ) {
696 326 : PrepareTextToMerge( sOrig, STRING_TYP_TEXT, sLangIndex, pResData );
697 : }
698 : else
699 : {
700 0 : if (!pResData->sText[ sLangIndex ].isEmpty())
701 : {
702 0 : rtl::OStringBuffer sError(RTL_CONSTASCII_STRINGPARAM("Language "));
703 0 : sError.append(sLangIndex);
704 0 : sError.append(RTL_CONSTASCII_STRINGPARAM("defined twice"));
705 0 : yyerror(sError.getStr());
706 : }
707 0 : pResData->sText[ sLangIndex ] = sText;
708 : }
709 : }
710 0 : else if ( sKey == "HELPTEXT" ) {
711 0 : SetChildWithText();
712 0 : pResData->bHelpText = sal_True;
713 0 : if ( bMergeMode )
714 0 : PrepareTextToMerge( sOrig, STRING_TYP_HELPTEXT, sLangIndex, pResData );
715 : else
716 : {
717 0 : if (!pResData->sHelpText[ sLangIndex ].isEmpty())
718 : {
719 0 : rtl::OStringBuffer sError(RTL_CONSTASCII_STRINGPARAM("Language "));
720 0 : sError.append(sLangIndex);
721 0 : sError.append(" defined twice");
722 0 : YYWarning(sError.getStr());
723 : }
724 0 : pResData->sHelpText[ sLangIndex ] = sText;
725 : }
726 : }
727 0 : else if ( sKey == "QUICKHELPTEXT" ) {
728 0 : SetChildWithText();
729 0 : pResData->bQuickHelpText = sal_True;
730 0 : if ( bMergeMode )
731 0 : PrepareTextToMerge( sOrig, STRING_TYP_QUICKHELPTEXT, sLangIndex, pResData );
732 : else
733 : {
734 0 : if (!pResData->sQuickHelpText[ sLangIndex ].isEmpty())
735 : {
736 0 : rtl::OStringBuffer sError(RTL_CONSTASCII_STRINGPARAM("Language "));
737 0 : sError.append(sLangIndex);
738 0 : sError.append(RTL_CONSTASCII_STRINGPARAM(" defined twice"));
739 0 : YYWarning(sError.getStr());
740 : }
741 0 : pResData->sQuickHelpText[ sLangIndex ] = sText;
742 : }
743 : }
744 0 : else if ( sKey == "TITLE" ) {
745 0 : SetChildWithText();
746 0 : pResData->bTitle = sal_True;
747 0 : if ( bMergeMode )
748 0 : PrepareTextToMerge( sOrig, STRING_TYP_TITLE, sLangIndex, pResData );
749 : else
750 : {
751 0 : if ( !pResData->sTitle[ sLangIndex ].isEmpty())
752 : {
753 0 : rtl::OStringBuffer sError(RTL_CONSTASCII_STRINGPARAM("Language "));
754 0 : sError.append(sLangIndex);
755 0 : sError.append(RTL_CONSTASCII_STRINGPARAM(" defined twice"));
756 0 : YYWarning(sError.getStr());
757 : }
758 0 : pResData->sTitle[ sLangIndex ] = sText;
759 : }
760 : }
761 0 : else if ( sKey == "ACCESSPATH" ) {
762 0 : pResData->SetId( sText, ID_LEVEL_ACCESSPATH );
763 : }
764 0 : else if ( sKey == "FIELDNAME" ) {
765 0 : pResData->SetId( sText, ID_LEVEL_FIELDNAME );
766 : }
767 432 : }
768 : }
769 432 : break;
770 : case NEWTEXTINRES: {
771 0 : bDontWriteOutput = sal_True;
772 : }
773 0 : break;
774 : case APPFONTMAPPING:
775 : {
776 233 : bDontWriteOutput = sal_False;
777 : // this is a AppfontMapping, so look if its a definition
778 : // of field size
779 233 : sal_Int32 n = 0;
780 : rtl::OString sKey(
781 : sToken.getToken(0, '=', n).replaceAll(" ", rtl::OString()).
782 233 : replaceAll("\t", rtl::OString()));
783 233 : rtl::OString sMapping = sToken.getToken(0, '=', n);
784 233 : sMapping = sMapping.getToken(1, '(');
785 : sMapping = sMapping.getToken(0, ')').
786 : replaceAll(rtl::OString(' '), rtl::OString()).
787 : replaceAll(rtl::OString('\t'), rtl::OString()).
788 233 : toAsciiUpperCase();
789 233 : if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("SIZE"))) {
790 0 : pResData->nWidth = sMapping.getToken(0, ',').toInt32();
791 233 : } else if (sKey.equalsL(RTL_CONSTASCII_STRINGPARAM("POSSIZE"))) {
792 0 : pResData->nWidth = sMapping.getToken(2, ',').toInt32();
793 233 : }
794 : }
795 233 : break;
796 : case RSCDEFINELEND:
797 233 : bDontWriteOutput = sal_False;
798 233 : break;
799 : case CONDITION: {
800 159 : bDontWriteOutput = sal_False;
801 159 : sToken = sToken.replace('\r', ' ').replace('\t', ' ');
802 3 : for (;;) {
803 162 : sal_Int32 n = 0;
804 162 : sToken = sToken.replaceFirst(" ", " ", &n);
805 162 : if (n == -1) {
806 : break;
807 : }
808 : }
809 159 : sal_Int32 n = 0;
810 159 : rtl::OString sCondition(sToken.getToken(0, ' ', n));
811 159 : if ( sCondition == "#ifndef" ) {
812 12 : sActPForm = "!defined ";
813 12 : sActPForm += sToken.getToken(0, ' ', n);
814 : }
815 147 : else if ( sCondition == "#ifdef" ) {
816 0 : sActPForm = "defined ";
817 0 : sActPForm += sToken.getToken(0, ' ', n);
818 : }
819 147 : else if ( sCondition == "#if" ) {
820 54 : sActPForm = sToken.copy( 4 ).replaceAll("||", "\\or");
821 : }
822 93 : else if ( sCondition == "#elif" ) {
823 23 : sActPForm = sToken.copy( 6 ).replaceAll("||", "\\or");
824 : }
825 70 : else if ( sCondition == "#else" ) {
826 4 : sActPForm = sCondition;
827 : }
828 66 : else if ( sCondition == "#endif" ) {
829 44 : sActPForm = "";
830 : }
831 : else break;
832 137 : if ( nLevel ) {
833 69 : WriteData( pResData, sal_True );
834 69 : pResData->sPForm = sActPForm;
835 159 : }
836 : }
837 137 : break;
838 : case EMPTYLINE : {
839 368 : bDontWriteOutput = sal_False;
840 368 : if ( bDefine ) {
841 264 : bNextMustBeDefineEOL = sal_False;
842 264 : bDefine = sal_False;
843 797 : while ( nLevel )
844 269 : Parse( LEVELDOWN, "" );
845 : }
846 : }
847 368 : break;
848 : case PRAGMA : {
849 0 : bDontWriteOutput = sal_False;
850 0 : fprintf(stderr, "ERROR: archaic PRAGMA %s\n", sToken.getStr());
851 0 : exit(-1);
852 : }
853 : break;
854 : case TEXTREFID : {
855 12 : bDontWriteOutput = sal_True;
856 : }
857 : }
858 4302 : if ( bWriteToMerged ) {
859 : // the current token must be written to dest. without merging
860 :
861 4302 : if( bDefine && sOrig.getLength() > 2 ){
862 88481 : for( sal_uInt16 n = 0 ; n < sOrig.getLength() ; n++ ){
863 86205 : if( sOrig[n] == '\n' && sOrig[n-1] != '\\'){
864 0 : sOrig = sOrig.replaceAt(n++, 0, "\\");
865 : }
866 : }
867 : }
868 4302 : WriteToMerged( sOrig , false);
869 : }
870 :
871 4302 : if ( bExecuteDown ) {
872 0 : Parse( LEVELDOWN, "" );
873 : }
874 :
875 4302 : return 1;
876 : }
877 :
878 : /*****************************************************************************/
879 432 : void Export::CutComment( rtl::OString &rText )
880 : /*****************************************************************************/
881 : {
882 432 : if (rText.indexOf("//") != -1) {
883 0 : rtl::OString sWork(rText.replaceAll("\\\"", "XX"));
884 0 : bool bInner = false;
885 0 : for (sal_Int32 i = 0; i < sWork.getLength() - 1; ++i) {
886 0 : if (sWork[i] == '"') {
887 0 : bInner = !bInner;
888 0 : } else if (sWork[i] == '/' && !bInner && sWork[i + 1] == '/' ) {
889 0 : rText = rText.copy(0, i);
890 0 : break;
891 : }
892 0 : }
893 : }
894 432 : }
895 :
896 : /*****************************************************************************/
897 928 : sal_Bool Export::WriteData( ResData *pResData, sal_Bool bCreateNew )
898 : /*****************************************************************************/
899 : {
900 928 : if ( bMergeMode ) {
901 928 : MergeRest( pResData );
902 928 : return sal_True;
903 : }
904 :
905 : // mandatory to export: en-US
906 :
907 0 : if (( !pResData->sText[ SOURCE_LANGUAGE ].isEmpty())
908 : ||
909 0 : ( !pResData->sHelpText[ SOURCE_LANGUAGE ].isEmpty())
910 : ||
911 0 : ( !pResData->sQuickHelpText[ SOURCE_LANGUAGE ].isEmpty())
912 : ||
913 0 : ( !pResData->sTitle[ SOURCE_LANGUAGE ].isEmpty()))
914 :
915 : {
916 0 : rtl::OString sGID = pResData->sGId;
917 0 : rtl::OString sLID;
918 0 : if (sGID.isEmpty())
919 0 : sGID = pResData->sId;
920 : else
921 0 : sLID = pResData->sId;
922 :
923 0 : rtl::OString sXText;
924 0 : rtl::OString sXHText;
925 0 : rtl::OString sXQHText;
926 0 : rtl::OString sXTitle;
927 :
928 0 : sXText = pResData->sText[ SOURCE_LANGUAGE ];
929 0 : if (!pResData->sText[ X_COMMENT ].isEmpty())
930 0 : sXHText = pResData->sText[ X_COMMENT ];
931 : else
932 0 : sXHText = pResData->sHelpText[ SOURCE_LANGUAGE ];
933 0 : sXQHText = pResData->sQuickHelpText[ SOURCE_LANGUAGE ];
934 0 : sXTitle = pResData->sTitle[ SOURCE_LANGUAGE ];
935 :
936 0 : if (sXText.isEmpty())
937 0 : sXText = "-";
938 :
939 0 : rtl::OString sOutput( sProject ); sOutput += "\t";
940 0 : if ( !sRoot.isEmpty())
941 0 : sOutput += sActFileName;
942 0 : sOutput += "\t0\t";
943 0 : sOutput += pResData->sResTyp; sOutput += "\t";
944 0 : sOutput += sGID; sOutput += "\t";
945 0 : sOutput += sLID; sOutput += "\t";
946 0 : sOutput += pResData->sHelpId; sOutput += "\t";
947 0 : sOutput += pResData->sPForm; sOutput += "\t";
948 0 : sOutput += rtl::OString::valueOf(pResData->nWidth); sOutput += "\t";
949 0 : sOutput += "en-US"; sOutput += "\t";
950 :
951 :
952 0 : sOutput += sXText; sOutput += "\t";
953 0 : sOutput += sXHText; sOutput += "\t";
954 0 : sOutput += sXQHText; sOutput+= "\t";
955 0 : sOutput += sXTitle; sOutput += "\t";
956 :
957 0 : aOutput << sOutput.getStr() << '\n';
958 :
959 0 : if ( bCreateNew ) {
960 0 : pResData->sText[ SOURCE_LANGUAGE ] = "";
961 0 : pResData->sHelpText[ SOURCE_LANGUAGE ] = "";
962 0 : pResData->sQuickHelpText[ SOURCE_LANGUAGE ]= "";
963 0 : pResData->sTitle[ SOURCE_LANGUAGE ] = "";
964 0 : }
965 : }
966 0 : if ( pResData->pStringList ) {
967 0 : rtl::OString sList( "stringlist" );
968 0 : WriteExportList( pResData, pResData->pStringList, sList, bCreateNew );
969 0 : if ( bCreateNew )
970 0 : pResData->pStringList = 0;
971 : }
972 0 : if ( pResData->pFilterList ) {
973 0 : rtl::OString sList( "filterlist" );
974 0 : WriteExportList( pResData, pResData->pFilterList, sList, bCreateNew );
975 0 : if ( bCreateNew )
976 0 : pResData->pFilterList = 0;
977 : }
978 0 : if ( pResData->pItemList ) {
979 0 : rtl::OString sList( "itemlist" );
980 0 : WriteExportList( pResData, pResData->pItemList, sList, bCreateNew );
981 0 : if ( bCreateNew )
982 0 : pResData->pItemList = 0;
983 : }
984 0 : if ( pResData->pPairedList ) {
985 0 : rtl::OString sList( "pairedlist" );
986 0 : WriteExportList( pResData, pResData->pPairedList, sList, bCreateNew );
987 0 : if ( bCreateNew )
988 0 : pResData->pItemList = 0;
989 : }
990 0 : if ( pResData->pUIEntries ) {
991 0 : rtl::OString sList( "uientries" );
992 0 : WriteExportList( pResData, pResData->pUIEntries, sList, bCreateNew );
993 0 : if ( bCreateNew )
994 0 : pResData->pUIEntries = 0;
995 : }
996 0 : return sal_True;
997 : }
998 :
999 0 : rtl::OString Export::GetPairedListID(const rtl::OString& rText)
1000 : {
1001 : // < "STRING" ; IDENTIFIER ; > ;
1002 0 : return rText.getToken(1, ';').toAsciiUpperCase().replace('\t', ' ').trim();
1003 : }
1004 :
1005 0 : rtl::OString Export::GetPairedListString(const rtl::OString& rText)
1006 : {
1007 : // < "STRING" ; IDENTIFIER ; > ;
1008 0 : rtl::OString sString(rText.getToken(0, ';').replace('\t', ' '));
1009 0 : sString = sString.trim();
1010 0 : rtl::OString s1(sString.copy(sString.indexOf('"') + 1));
1011 0 : sString = s1.copy(0, s1.lastIndexOf('"'));
1012 0 : return sString.trim();
1013 : }
1014 :
1015 0 : rtl::OString Export::StripList(const rtl::OString & rText)
1016 : {
1017 0 : rtl::OString s1 = rText.copy( rText.indexOf('\"') + 1);
1018 0 : return s1.copy( 0 , s1.lastIndexOf('\"'));
1019 : }
1020 :
1021 0 : sal_Bool Export::WriteExportList(ResData *pResData, ExportList *pExportList,
1022 : const rtl::OString &rTyp, sal_Bool bCreateNew)
1023 : {
1024 0 : rtl::OString sGID(pResData->sGId);
1025 0 : if (sGID.isEmpty())
1026 0 : sGID = pResData->sId;
1027 : else {
1028 0 : sGID += ".";
1029 0 : sGID += pResData->sId;
1030 0 : while (sGID.getLength() != 0 && sGID[sGID.getLength() - 1] == '.') {
1031 0 : sGID = sGID.copy(0, sGID.getLength() - 1);
1032 : }
1033 : }
1034 :
1035 0 : rtl::OString sCur;
1036 0 : for ( size_t i = 0; pExportList != NULL && i < pExportList->size(); i++ )
1037 : {
1038 0 : ExportListEntry *pEntry = (*pExportList)[ i ];
1039 :
1040 0 : rtl::OString sLID(rtl::OString::valueOf(static_cast<sal_Int64>(i + 1)));
1041 0 : for (unsigned int n = 0; n < aLanguages.size(); ++n)
1042 : {
1043 0 : sCur = aLanguages[ n ];
1044 0 : if (!(*pEntry)[ SOURCE_LANGUAGE ].isEmpty())
1045 : {
1046 0 : rtl::OString sText((*pEntry)[ SOURCE_LANGUAGE ] );
1047 :
1048 : // Strip PairList Line String
1049 0 : if (rTyp.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("pairedlist")))
1050 : {
1051 0 : sLID = GetPairedListID( sText );
1052 0 : if (!(*pEntry)[ sCur ].isEmpty())
1053 0 : sText = (*pEntry)[ sCur ];
1054 0 : sText = GetPairedListString( sText );
1055 : }
1056 : else
1057 : {
1058 0 : sText = StripList( (*pEntry)[ sCur ] );
1059 0 : if( sText == "\\\"" )
1060 0 : sText = "\"";
1061 : }
1062 :
1063 0 : rtl::OStringBuffer sOutput(sProject);
1064 0 : sOutput.append('\t');
1065 0 : if ( !sRoot.isEmpty())
1066 0 : sOutput.append(sActFileName);
1067 0 : sOutput.append("\t0\t");
1068 0 : sOutput.append(rTyp).append('\t');
1069 0 : sOutput.append(sGID).append('\t');
1070 0 : sOutput.append(sLID).append("\t\t");
1071 0 : sOutput.append(pResData->sPForm).append("\t0\t");
1072 0 : sOutput.append(sCur).append('\t');
1073 :
1074 0 : sOutput.append(sText).append("\t\t\t\t");
1075 :
1076 0 : aOutput << sOutput.makeStringAndClear().getStr() << '\n';
1077 : }
1078 : }
1079 0 : if ( bCreateNew )
1080 0 : delete [] pEntry;
1081 0 : }
1082 0 : if ( bCreateNew )
1083 0 : delete pExportList;
1084 :
1085 0 : return sal_True;
1086 : }
1087 :
1088 861 : rtl::OString Export::FullId()
1089 : {
1090 861 : rtl::OStringBuffer sFull;
1091 861 : if ( nLevel > 1 )
1092 : {
1093 560 : sFull.append(aResStack[ 0 ]->sId);
1094 954 : for ( size_t i = 1; i < nLevel - 1; ++i )
1095 : {
1096 394 : rtl::OString sToAdd = aResStack[ i ]->sId;
1097 394 : if (!sToAdd.isEmpty())
1098 102 : sFull.append('.').append(sToAdd);
1099 394 : }
1100 : }
1101 861 : if (sFull.getLength() > 255)
1102 : {
1103 0 : rtl::OString sError(RTL_CONSTASCII_STRINGPARAM("GroupId > 255 chars"));
1104 0 : printf("GroupID = %s\n", sFull.getStr());
1105 0 : yyerror(sError.getStr());
1106 : }
1107 :
1108 861 : return sFull.makeStringAndClear();
1109 : }
1110 :
1111 17 : void Export::InsertListEntry(const rtl::OString &rText, const rtl::OString &rLine)
1112 : {
1113 17 : ResData *pResData = ( nLevel-1 < aResStack.size() ) ? aResStack[ nLevel-1 ] : NULL;
1114 :
1115 17 : ExportList *pList = NULL;
1116 17 : if ( nList == LIST_STRING ) {
1117 17 : pList = pResData->pStringList;
1118 17 : if ( !pList ) {
1119 2 : pResData->pStringList = new ExportList();
1120 2 : pList = pResData->pStringList;
1121 2 : nListIndex = 0;
1122 : }
1123 : }
1124 0 : else if ( nList == LIST_FILTER ) {
1125 0 : pList = pResData->pFilterList;
1126 0 : if ( !pList ) {
1127 0 : pResData->pFilterList = new ExportList();
1128 0 : pList = pResData->pFilterList;
1129 0 : nListIndex = 0;
1130 : }
1131 : }
1132 0 : else if ( nList == LIST_ITEM ) {
1133 0 : pList = pResData->pItemList;
1134 0 : if ( !pList ) {
1135 0 : pResData->pItemList = new ExportList();
1136 0 : pList = pResData->pItemList;
1137 0 : nListIndex = 0;
1138 : }
1139 : }
1140 0 : else if ( nList == LIST_PAIRED ) {
1141 0 : pList = pResData->pPairedList;
1142 0 : if ( !pList ) {
1143 0 : pResData->pPairedList = new ExportList();
1144 0 : pList = pResData->pPairedList;
1145 0 : nListIndex = 0;
1146 : }
1147 : }
1148 0 : else if ( nList == LIST_UIENTRIES ) {
1149 0 : pList = pResData->pUIEntries;
1150 0 : if ( !pList ) {
1151 0 : pResData->pUIEntries = new ExportList();
1152 0 : pList = pResData->pUIEntries;
1153 0 : nListIndex = 0;
1154 : }
1155 : }
1156 : else
1157 17 : return;
1158 :
1159 17 : if ( nListIndex + 1 > pList->size())
1160 : {
1161 17 : ExportListEntry *pNew = new ExportListEntry();
1162 17 : (*pNew)[LIST_REFID] = rtl::OString::valueOf(static_cast<sal_Int32>(REFID_NONE));
1163 17 : pList->push_back(pNew);
1164 : }
1165 17 : ExportListEntry *pCurEntry = (*pList)[ nListIndex ];
1166 :
1167 : // For paired list use the line to set proper lid
1168 17 : if( nList == LIST_PAIRED ){
1169 0 : (*pCurEntry)[ m_sListLang ] = rLine;
1170 : }else
1171 17 : (*pCurEntry)[ m_sListLang ] = rText;
1172 :
1173 17 : if ( Export::isSourceLanguage( m_sListLang ) ) {
1174 17 : (*pCurEntry)[ SOURCE_LANGUAGE ] = rLine;
1175 :
1176 17 : pList->NewSourceLanguageListEntry();
1177 : }
1178 :
1179 17 : nListIndex++;
1180 : }
1181 :
1182 : /*****************************************************************************/
1183 2296 : void Export::CleanValue( rtl::OString &rValue )
1184 : /*****************************************************************************/
1185 : {
1186 6013 : while ( !rValue.isEmpty()) {
1187 3691 : if (( rValue[0] == ' ' ) || ( rValue[0] == '\t' ))
1188 1421 : rValue = rValue.copy( 1 );
1189 : else
1190 2270 : break;
1191 : }
1192 :
1193 2296 : if ( !rValue.isEmpty()) {
1194 37834 : for ( sal_Int32 i = rValue.getLength() - 1; i > 0; i-- ) {
1195 40064 : if (( rValue[i] == ' ' ) || ( rValue[i] == '\t' ) ||
1196 11160 : ( rValue[i] == '\n' ) || ( rValue[i] == ';' ) ||
1197 7747 : ( rValue[i] == '{' ) || ( rValue[i] == '\\' ) ||
1198 2255 : ( rValue[i] == '\r' ))
1199 16647 : rValue = rValue.copy(0, i);
1200 : else
1201 2255 : break;
1202 : }
1203 : }
1204 2296 : }
1205 :
1206 : #define TXT_STATE_NON 0x000
1207 : #define TXT_STATE_TEXT 0x001
1208 : #define TXT_STATE_MACRO 0x002
1209 :
1210 432 : rtl::OString Export::GetText(const rtl::OString &rSource, int nToken)
1211 : {
1212 432 : rtl::OString sReturn;
1213 432 : switch ( nToken )
1214 : {
1215 : case TEXTLINE:
1216 : case LONGTEXTLINE:
1217 : {
1218 432 : rtl::OString sTmp(rSource.copy(rSource.indexOf('=')));
1219 432 : CleanValue( sTmp );
1220 : sTmp = sTmp.replaceAll("\n", rtl::OString()).
1221 : replaceAll("\r", rtl::OString()).
1222 : replaceAll("\\\\\"", "-=<[BSlashBSlashHKom]>=-\"").
1223 : replaceAll("\\\"", "-=<[Hochkomma]>=-").
1224 : replaceAll("\\", "-=<[0x7F]>=-").
1225 432 : replaceAll("\\0x7F", "-=<[0x7F]>=-");
1226 :
1227 432 : sal_uInt16 nState = TXT_STATE_TEXT;
1228 1296 : for (sal_Int32 i = 1; i <= helper::countOccurrences(sTmp, '"'); ++i)
1229 : {
1230 864 : rtl::OString sToken(sTmp.getToken(i, '"'));
1231 864 : if (!sToken.isEmpty()) {
1232 427 : if ( nState == TXT_STATE_TEXT ) {
1233 427 : sReturn += sToken;
1234 427 : nState = TXT_STATE_MACRO;
1235 : }
1236 : else {
1237 0 : sToken = sToken.replace('\t', ' ');
1238 0 : for (;;) {
1239 0 : sal_Int32 n = 0;
1240 0 : sToken = sToken.replaceFirst(" ", " ", &n);
1241 0 : if (n == -1) {
1242 : break;
1243 : }
1244 : }
1245 0 : sToken = sToken.trim();
1246 0 : if (!sToken.isEmpty()) {
1247 0 : sReturn += "\\\" ";
1248 0 : sReturn += sToken;
1249 0 : sReturn += " \\\"";
1250 : }
1251 0 : nState = TXT_STATE_TEXT;
1252 : }
1253 : }
1254 864 : }
1255 :
1256 : sReturn = sReturn.replaceAll("-=<[0x7F]>=-", "").
1257 : replaceAll("-=<[Hochkomma]>=-", "\"").
1258 : replaceAll("-=<[BSlashBSlashHKom]>=-", "\\\\").
1259 : replaceAll("\\\\", "-=<[BSlashBSlash]>=-").
1260 432 : replaceAll("-=<[BSlashBSlash]>=-", "\\");
1261 : }
1262 432 : break;
1263 : }
1264 432 : return sReturn;
1265 : }
1266 :
1267 32226 : void Export::WriteToMerged(const rtl::OString &rText , bool bSDFContent)
1268 : {
1269 32226 : rtl::OString sText(rText);
1270 0 : for (;;) {
1271 32226 : sal_Int32 n = 0;
1272 32226 : sText = sText.replaceFirst(" \n", "\n", &n);
1273 32226 : if (n == -1) {
1274 : break;
1275 : }
1276 : }
1277 32226 : if (pParseQueue->bNextIsM && bSDFContent && sText.getLength() > 2) {
1278 0 : for (sal_Int32 n = 0; n < sText.getLength(); ++n) {
1279 0 : if (sText[n] == '\n' && sText[n - 1] != '\\') {
1280 0 : sText = sText.replaceAt(n++, 0, "\\");
1281 : }
1282 : }
1283 32226 : } else if (pParseQueue->bLastWasM && sText.getLength() > 2) {
1284 78307 : for (sal_Int32 n = 0; n < sText.getLength(); ++n) {
1285 75678 : if (sText[n] == '\n' && sText[n - 1] != '\\') {
1286 0 : sText = sText.replaceAt(n++, 0, "\\");
1287 : }
1288 75678 : if (sText[n] == '\n') {
1289 641 : pParseQueue->bMflag = true;
1290 : }
1291 : }
1292 29597 : } else if (pParseQueue->bCurrentIsM && bSDFContent && sText.getLength() > 2)
1293 : {
1294 0 : for (sal_Int32 n = 0; n < sText.getLength(); ++n) {
1295 0 : if (sText[n] == '\n' && sText[n - 1] != '\\') {
1296 0 : sText = sText.replaceAt(n++, 0, "\\");
1297 0 : pParseQueue->bMflag = true;
1298 : }
1299 : }
1300 29597 : } else if (pParseQueue->bMflag) {
1301 8652 : for (sal_Int32 n = 1; n < sText.getLength(); ++n) {
1302 6547 : if (sText[n] == '\n' && sText[n - 1] != '\\') {
1303 0 : sText = sText.replaceAt(n++, 0, "\\");
1304 : }
1305 : }
1306 204812 : } for (sal_Int32 i = 0; i < sText.getLength(); ++i) {
1307 172586 : if (sText[i] == '\n') {
1308 5476 : aOutput << '\n';
1309 : } else {
1310 167110 : char cChar = sText[i];
1311 167110 : aOutput << cChar;
1312 : }
1313 32226 : }
1314 32226 : }
1315 :
1316 : /*****************************************************************************/
1317 0 : void Export::ConvertMergeContent( rtl::OString &rText )
1318 : /*****************************************************************************/
1319 : {
1320 0 : sal_Bool bNoOpen = ( rText.indexOf( "\\\"" ) != 0 );
1321 0 : sal_Bool bNoClose = !rText.endsWithL(RTL_CONSTASCII_STRINGPARAM("\\\""));
1322 0 : rtl::OStringBuffer sNew;
1323 0 : for ( sal_Int32 i = 0; i < rText.getLength(); i++ )
1324 : {
1325 0 : rtl::OString sChar( rText[i]);
1326 0 : if (sChar.equalsL(RTL_CONSTASCII_STRINGPARAM("\\")))
1327 : {
1328 0 : if (( i + 1 ) < rText.getLength())
1329 : {
1330 0 : sal_Char cNext = rText[i + 1];
1331 0 : if ( cNext == '\"' )
1332 : {
1333 0 : sChar = rtl::OString('\"');
1334 0 : i++;
1335 : }
1336 0 : else if ( cNext == 'n' )
1337 : {
1338 0 : sChar = rtl::OString(RTL_CONSTASCII_STRINGPARAM("\\n"));
1339 0 : i++;
1340 : }
1341 0 : else if ( cNext == 't' )
1342 : {
1343 0 : sChar = rtl::OString(RTL_CONSTASCII_STRINGPARAM("\\t"));
1344 0 : i++;
1345 : }
1346 0 : else if ( cNext == '\'' )
1347 : {
1348 0 : sChar = rtl::OString(RTL_CONSTASCII_STRINGPARAM("\\\'"));
1349 0 : i++;
1350 : }
1351 : else
1352 : {
1353 0 : sChar = rtl::OString(RTL_CONSTASCII_STRINGPARAM("\\\\"));
1354 : }
1355 : }
1356 : else
1357 : {
1358 0 : sChar = rtl::OString(RTL_CONSTASCII_STRINGPARAM("\\\\"));
1359 : }
1360 : }
1361 0 : else if (sChar.equalsL(RTL_CONSTASCII_STRINGPARAM("\"")))
1362 : {
1363 0 : sChar = rtl::OString(RTL_CONSTASCII_STRINGPARAM("\\\""));
1364 : }
1365 0 : else if (sChar.equalsL(RTL_CONSTASCII_STRINGPARAM("")))
1366 : {
1367 0 : sChar = rtl::OString(RTL_CONSTASCII_STRINGPARAM("\\0x7F"));
1368 : }
1369 0 : sNew.append(sChar);
1370 0 : }
1371 :
1372 0 : rText = sNew.makeStringAndClear();
1373 :
1374 0 : if ( bNoOpen ) {
1375 0 : rtl::OString sTmp( rText );
1376 0 : rText = "\"";
1377 0 : rText += sTmp;
1378 : }
1379 0 : if ( bNoClose )
1380 0 : rText += "\"";
1381 0 : }
1382 :
1383 345 : sal_Bool Export::PrepareTextToMerge(rtl::OString &rText, sal_uInt16 nTyp,
1384 : rtl::OString &rLangIndex, ResData *pResData)
1385 : {
1386 : // position to merge in:
1387 345 : sal_Int32 nStart = 0;
1388 345 : sal_Int32 nEnd = 0;
1389 345 : rtl::OString sOldId = pResData->sId;
1390 345 : rtl::OString sOldGId = pResData->sGId;
1391 345 : rtl::OString sOldTyp = pResData->sResTyp;
1392 :
1393 345 : rtl::OString sOrigText( rText );
1394 :
1395 345 : switch ( nTyp ) {
1396 : case LIST_STRING :
1397 : case LIST_UIENTRIES :
1398 : case LIST_FILTER :
1399 : case LIST_PAIRED:
1400 : case LIST_ITEM :
1401 : {
1402 19 : ExportList *pList = NULL;
1403 19 : switch ( nTyp ) {
1404 : case LIST_STRING : {
1405 19 : pResData->sResTyp = "stringlist";
1406 19 : pList = pResData->pStringList;
1407 : }
1408 19 : break;
1409 : case LIST_UIENTRIES : {
1410 0 : pResData->sResTyp = "uientries";
1411 0 : pList = pResData->pUIEntries;
1412 : }
1413 0 : break;
1414 : case LIST_FILTER : {
1415 0 : pResData->sResTyp = "filterlist";
1416 0 : pList = pResData->pFilterList;
1417 : }
1418 0 : break;
1419 : case LIST_ITEM : {
1420 0 : pResData->sResTyp = "itemlist";
1421 0 : pList = pResData->pItemList;
1422 : }
1423 0 : break;
1424 : case LIST_PAIRED : {
1425 0 : pResData->sResTyp = "pairedlist";
1426 0 : pList = pResData->pPairedList;
1427 : }
1428 0 : break;
1429 :
1430 : }
1431 19 : if (pList)
1432 : {
1433 19 : ExportListEntry *pCurEntry = (*pList)[ nListIndex - 1 ];
1434 19 : if ( pCurEntry )
1435 17 : rText = (*pCurEntry)[ SOURCE_LANGUAGE ];
1436 : }
1437 :
1438 19 : nStart = rText.indexOf( '"' );
1439 19 : if ( nStart == -1 ) {
1440 0 : rText = sOrigText;
1441 0 : return sal_False;
1442 : }
1443 :
1444 19 : sal_Bool bFound = sal_False;
1445 210 : for ( nEnd = nStart + 1; nEnd < rText.getLength() && !bFound; nEnd++ ) {
1446 191 : if ( rText[nEnd] == '\"' )
1447 19 : bFound = sal_True;
1448 : }
1449 19 : if ( !bFound ) {
1450 0 : rText = sOrigText;
1451 0 : return sal_False;
1452 : }
1453 :
1454 19 : nEnd --;
1455 19 : sLastListLine = rText;
1456 24 : if (( sLastListLine.indexOf( '>' ) != -1 ) &&
1457 5 : ( sLastListLine.indexOf( '<' ) == -1 ))
1458 : {
1459 1 : rtl::OString sTmp = sLastListLine;
1460 1 : sLastListLine = "<";
1461 1 : sLastListLine += sTmp;
1462 : }
1463 19 : if ( pResData->sResTyp.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("pairedlist")) )
1464 : {
1465 0 : pResData->sId = GetPairedListID( sLastListLine );
1466 : }
1467 19 : else pResData->sId = rtl::OString::valueOf(static_cast<sal_Int32>(nListIndex));
1468 :
1469 19 : if (!pResData->sGId.isEmpty())
1470 0 : pResData->sGId = pResData->sGId + rtl::OString('.');
1471 19 : pResData->sGId = pResData->sGId + sOldId;
1472 19 : nTyp = STRING_TYP_TEXT;
1473 : }
1474 19 : break;
1475 : case STRING_TYP_TEXT :
1476 : case STRING_TYP_HELPTEXT :
1477 : case STRING_TYP_QUICKHELPTEXT :
1478 : case STRING_TYP_TITLE :
1479 : {
1480 326 : nStart = rText.indexOf( '=' );
1481 326 : if ( nStart == -1 ) {
1482 0 : rText = sOrigText;
1483 0 : return sal_False;
1484 : }
1485 :
1486 326 : nStart++;
1487 326 : sal_Bool bFound = sal_False;
1488 1304 : while(( nStart < rText.getLength()) && !bFound ) {
1489 652 : if (( rText[nStart] != ' ' ) && ( rText[nStart] != '\t' ))
1490 326 : bFound = sal_True;
1491 : else
1492 326 : nStart ++;
1493 : }
1494 :
1495 : // no start position found
1496 326 : if ( !bFound ) {
1497 0 : rText = sOrigText;
1498 0 : return sal_False;
1499 : }
1500 :
1501 : // position to end mergeing in
1502 326 : nEnd = rText.getLength() - 1;
1503 326 : bFound = sal_False;
1504 :
1505 4061 : while (( nEnd > nStart ) && !bFound ) {
1506 6927 : if (( rText[nEnd] != ' ' ) && ( rText[nEnd] != '\t' ) &&
1507 2248 : ( rText[nEnd] != '\n' ) && ( rText[nEnd] != ';' ) &&
1508 1270 : ( rText[nEnd] != '{' ) && ( rText[nEnd] != '\\' ))
1509 : {
1510 326 : bFound = sal_True;
1511 : }
1512 : else
1513 3083 : nEnd --;
1514 : }
1515 : }
1516 326 : break;
1517 : }
1518 :
1519 : // search for merge data
1520 345 : if ( !pMergeDataFile ){
1521 8 : pMergeDataFile = new MergeDataFile( sMergeSrc, global::inputPathname, false );
1522 :
1523 : // Init Languages
1524 8 : if( Export::sLanguages.equalsIgnoreAsciiCase("ALL") )
1525 8 : SetLanguages( pMergeDataFile->GetLanguages() );
1526 0 : else if( !isInitialized )InitLanguages();
1527 :
1528 : }
1529 :
1530 345 : PFormEntrys *pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
1531 345 : pResData->sId = sOldId;
1532 345 : pResData->sGId = sOldGId;
1533 345 : pResData->sResTyp = sOldTyp;
1534 :
1535 345 : if ( !pEntrys ) {
1536 345 : rText = sOrigText;
1537 345 : return sal_False; // no data found
1538 : }
1539 :
1540 0 : rtl::OString sContent;
1541 0 : pEntrys->GetTransex3Text(sContent, nTyp, rLangIndex);
1542 0 : if (sContent.isEmpty() && (!Export::isSourceLanguage(rLangIndex)))
1543 : {
1544 0 : rText = sOrigText;
1545 0 : return sal_False; // no data found
1546 : }
1547 :
1548 0 : if (Export::isSourceLanguage(rLangIndex))
1549 0 : return sal_False;
1550 :
1551 0 : rtl::OString sPostFix( rText.copy( ++nEnd ));
1552 0 : rText = rText.copy(0, nStart);
1553 :
1554 0 : ConvertMergeContent( sContent );
1555 :
1556 :
1557 :
1558 : // merge new res. in text line
1559 0 : rText += sContent;
1560 0 : rText += sPostFix;
1561 :
1562 0 : return sal_True;
1563 : }
1564 :
1565 0 : void Export::ResData2Output( PFormEntrys *pEntry, sal_uInt16 nType, const rtl::OString& rTextType )
1566 : {
1567 0 : sal_Bool bAddSemicolon = sal_False;
1568 0 : sal_Bool bFirst = sal_True;
1569 0 : rtl::OString sCur;
1570 :
1571 0 : for( unsigned int n = 0; n < aLanguages.size(); n++ ){
1572 0 : sCur = aLanguages[ n ];
1573 :
1574 0 : rtl::OString sText;
1575 0 : sal_Bool bText = pEntry->GetTransex3Text( sText, nType, sCur , sal_True );
1576 0 : if ( bText && !sText.isEmpty() && sText != "-" ) {
1577 0 : rtl::OString sOutput;
1578 0 : if ( bNextMustBeDefineEOL) {
1579 0 : if ( bFirst )
1580 0 : sOutput += "\t\\\n";
1581 : else
1582 0 : sOutput += ";\t\\\n";
1583 : }
1584 0 : bFirst=sal_False;
1585 0 : sOutput += "\t";
1586 :
1587 0 : sOutput += rTextType;
1588 :
1589 0 : if ( ! Export::isSourceLanguage( sCur ) ) {
1590 0 : sOutput += "[ ";
1591 0 : sOutput += sCur;
1592 0 : sOutput += " ] ";
1593 : }
1594 0 : sOutput += "= ";
1595 0 : ConvertMergeContent( sText );
1596 0 : sOutput += sText;
1597 :
1598 0 : if ( bDefine )
1599 0 : sOutput += ";\\\n";
1600 0 : else if ( !bNextMustBeDefineEOL )
1601 0 : sOutput += ";\n";
1602 : else
1603 0 : bAddSemicolon = sal_True;
1604 0 : for ( sal_uInt16 j = 1; j < nLevel; j++ )
1605 0 : sOutput += "\t";
1606 0 : WriteToMerged( sOutput , true );
1607 : }
1608 0 : }
1609 :
1610 :
1611 0 : if ( bAddSemicolon ) {
1612 0 : rtl::OString sOutput( ";" );
1613 0 : WriteToMerged( sOutput , false );
1614 0 : }
1615 0 : }
1616 :
1617 : /*****************************************************************************/
1618 930 : void Export::MergeRest( ResData *pResData, sal_uInt16 nMode )
1619 : /*****************************************************************************/
1620 : {
1621 930 : if ( !pMergeDataFile ){
1622 6 : pMergeDataFile = new MergeDataFile( sMergeSrc, global::inputPathname, false );
1623 :
1624 : // Init Languages
1625 6 : if (Export::sLanguages.equalsIgnoreAsciiCase("ALL"))
1626 6 : SetLanguages( pMergeDataFile->GetLanguages() );
1627 0 : else if( !isInitialized )InitLanguages();
1628 :
1629 : }
1630 930 : switch ( nMode ) {
1631 : case MERGE_MODE_NORMAL : {
1632 928 : PFormEntrys *pEntry = pMergeDataFile->GetPFormEntrys( pResData );
1633 :
1634 928 : if ( pEntry ) {
1635 0 : if ( pResData->bText )
1636 0 : ResData2Output( pEntry, STRING_TYP_TEXT, pResData->sTextTyp );
1637 :
1638 0 : if ( pResData->bQuickHelpText )
1639 0 : ResData2Output( pEntry, STRING_TYP_QUICKHELPTEXT, rtl::OString("QuickHelpText") );
1640 :
1641 0 : if ( pResData->bTitle )
1642 0 : ResData2Output( pEntry, STRING_TYP_TITLE, rtl::OString("Title") );
1643 : }
1644 :
1645 : // Merge Lists
1646 :
1647 928 : if ( pResData->bList ) {
1648 2 : bool bPairedList = false;
1649 2 : rtl::OString sOldId = pResData->sId;
1650 2 : rtl::OString sOldGId = pResData->sGId;
1651 2 : rtl::OString sOldTyp = pResData->sResTyp;
1652 2 : if (!pResData->sGId.isEmpty())
1653 0 : pResData->sGId = pResData->sGId + rtl::OString('.');
1654 2 : pResData->sGId = pResData->sGId + sOldId;
1655 2 : rtl::OString sSpace;
1656 2 : for ( sal_uInt16 i = 1; i < nLevel-1; i++ )
1657 0 : sSpace += "\t";
1658 18 : for ( sal_uInt16 nT = LIST_STRING; nT <= LIST_UIENTRIES; nT++ ) {
1659 16 : ExportList *pList = NULL;
1660 16 : switch ( nT ) {
1661 2 : case LIST_STRING : pResData->sResTyp = "stringlist"; pList = pResData->pStringList; bPairedList = false; break;
1662 2 : case LIST_FILTER : pResData->sResTyp = "filterlist"; pList = pResData->pFilterList; bPairedList = false; break;
1663 2 : case LIST_UIENTRIES : pResData->sResTyp = "uientries"; pList = pResData->pUIEntries;bPairedList = false; break;
1664 2 : case LIST_ITEM : pResData->sResTyp = "itemlist"; pList = pResData->pItemList; bPairedList = false; break;
1665 2 : case LIST_PAIRED : pResData->sResTyp = "pairedlist"; pList = pResData->pPairedList; bPairedList = true; break;
1666 : }
1667 16 : rtl::OString sCur;
1668 16 : for( unsigned int n = 0; n < aLanguages.size(); n++ )
1669 : {
1670 0 : sCur = aLanguages[ n ];
1671 0 : sal_uInt16 nIdx = 1;
1672 :
1673 : // Set matching pairedlist identifier
1674 0 : if( bPairedList && pResData->pPairedList && ( nIdx == 1 ) ){
1675 0 : ExportListEntry* pListE = ( ExportListEntry* ) (*pResData->pPairedList)[ nIdx-1 ];
1676 0 : pResData->sId = GetPairedListID ( (*pListE)[ SOURCE_LANGUAGE ] );
1677 : }
1678 : else
1679 0 : pResData->sId = "1";
1680 :
1681 : PFormEntrys *pEntrys;
1682 0 : std::size_t nLIndex = 0;
1683 0 : std::size_t nMaxIndex = 0;
1684 0 : if ( pList )
1685 0 : nMaxIndex = pList->GetSourceLanguageListEntryCount();
1686 :
1687 : /**
1688 : * Check whether count of listentries match with count
1689 : * of translated items. If not than write origin items
1690 : * to the list to avoid mixed translations
1691 : * (exclude pairedlist)
1692 : */
1693 0 : sal_Bool bTranslateList = true;
1694 0 : if( !bPairedList ){
1695 0 : pResData->sId = OString::valueOf(static_cast<sal_Int32>(nMaxIndex));
1696 0 : pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
1697 0 : if ( !pEntrys )
1698 0 : bTranslateList = false;
1699 0 : pResData->sId = OString::valueOf(static_cast<sal_Int32>(nMaxIndex+1));
1700 0 : pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
1701 0 : if ( pEntrys )
1702 0 : bTranslateList = false;
1703 0 : pResData->sId = "1";
1704 : }
1705 :
1706 0 : pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
1707 0 : while(( nLIndex < nMaxIndex )) {
1708 0 : if ( nIdx == 1 )
1709 : {
1710 0 : rtl::OStringBuffer sHead;
1711 0 : if ( bNextMustBeDefineEOL )
1712 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM("\\\n\t"));
1713 0 : sHead.append(sSpace);
1714 0 : switch ( nT )
1715 : {
1716 : case LIST_STRING:
1717 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM("StringList "));
1718 0 : break;
1719 : case LIST_FILTER:
1720 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM("FilterList "));
1721 0 : break;
1722 : case LIST_ITEM:
1723 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM("ItemList "));
1724 0 : break;
1725 : case LIST_PAIRED:
1726 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM("PairedList "));
1727 0 : break;
1728 : case LIST_UIENTRIES:
1729 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM("UIEntries "));
1730 0 : break;
1731 : }
1732 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM("[ "));
1733 0 : sHead.append(sCur);
1734 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM(" ] "));
1735 0 : if ( bDefine || bNextMustBeDefineEOL )
1736 : {
1737 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM("= \\\n"));
1738 0 : sHead.append(sSpace);
1739 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM("\t{\\\n\t"));
1740 : }
1741 : else
1742 : {
1743 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM("= \n"));
1744 0 : sHead.append(sSpace);
1745 0 : sHead.append(RTL_CONSTASCII_STRINGPARAM("\t{\n\t"));
1746 : }
1747 0 : WriteToMerged(sHead.makeStringAndClear() , true);
1748 : }
1749 0 : rtl::OString sLine;
1750 0 : if ( pList && (*pList)[ nLIndex ] )
1751 0 : sLine = ( *(*pList)[ nLIndex ])[ SOURCE_LANGUAGE ];
1752 0 : if ( sLine.isEmpty())
1753 0 : sLine = sLastListLine;
1754 :
1755 0 : if ( sLastListLine.indexOf( '<' ) != -1 ) {
1756 0 : if (( nT != LIST_UIENTRIES ) &&
1757 0 : (( sLine.indexOf( '{' ) == -1 ) ||
1758 0 : ( sLine.indexOf( '{' ) >= sLine.indexOf( '"' ))) &&
1759 0 : (( sLine.indexOf( '<' ) == -1 ) ||
1760 0 : ( sLine.indexOf( '<' ) >= sLine.indexOf( '"' ))))
1761 : {
1762 0 : sLine = sLine.replaceFirst("\"", "< \"" );
1763 : }
1764 : }
1765 :
1766 0 : if( bTranslateList )
1767 : {
1768 0 : OString sText;
1769 0 : sal_Bool bText = false;
1770 0 : if ( pEntrys )
1771 0 : bText = pEntrys->GetTransex3Text( sText, STRING_TYP_TEXT, sCur, sal_True );
1772 0 : if ( bText && !sText.isEmpty() )
1773 : {
1774 : sal_Int32 nStart, nEnd;
1775 0 : nStart = sLine.indexOf( '"' );
1776 :
1777 0 : rtl::OString sPostFix;
1778 0 : if( !bPairedList ){
1779 0 : nEnd = sLine.lastIndexOf( '"' );
1780 0 : sPostFix = sLine.copy( ++nEnd );
1781 0 : sLine = sLine.copy(0, nStart);
1782 : }
1783 :
1784 :
1785 0 : ConvertMergeContent( sText );
1786 :
1787 : // merge new res. in text line
1788 0 : if( bPairedList ){
1789 0 : sLine = MergePairedList( sLine , sText );
1790 : }
1791 : else{
1792 0 : sLine += sText;
1793 0 : sLine += sPostFix;
1794 0 : }
1795 0 : }
1796 : }
1797 :
1798 0 : rtl::OString sText1( "\t" );
1799 0 : sText1 += sLine;
1800 0 : if ( bDefine || bNextMustBeDefineEOL )
1801 0 : sText1 += " ;\\\n";
1802 : else
1803 0 : sText1 += " ;\n";
1804 0 : sText1 += sSpace;
1805 0 : sText1 += "\t";
1806 0 : WriteToMerged( sText1 ,true );
1807 0 : nIdx++;
1808 0 : if ( bTranslateList )
1809 : {
1810 : // Set matching pairedlist identifier
1811 0 : if ( bPairedList ){
1812 0 : ExportListEntry* pListE = ( ExportListEntry* )(*pResData->pPairedList)[ ( nIdx ) -1 ];
1813 0 : if( pListE ){
1814 0 : pResData->sId = GetPairedListID ( (*pListE)[ SOURCE_LANGUAGE ] );
1815 : }
1816 : }
1817 : else
1818 0 : pResData->sId = rtl::OString::valueOf(static_cast<sal_Int32>(nIdx));
1819 0 : PFormEntrys *oldEntry = pEntrys;
1820 0 : pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
1821 0 : if( !pEntrys )
1822 0 : pEntrys = oldEntry;
1823 : }
1824 0 : nLIndex++;
1825 0 : }
1826 0 : if ( nIdx > 1 ) {
1827 0 : rtl::OString sFooter;
1828 0 : if (!sSpace.isEmpty()) {
1829 0 : sFooter = sSpace.copy(1);
1830 : }
1831 0 : if ( bNextMustBeDefineEOL )
1832 0 : sFooter += "};";
1833 0 : else if ( !bDefine )
1834 0 : sFooter += "};\n\t";
1835 : else
1836 0 : sFooter += "\n\n";
1837 0 : WriteToMerged( sFooter ,true );
1838 : }
1839 : }
1840 16 : }
1841 :
1842 2 : pResData->sId = sOldId;
1843 2 : pResData->sGId = sOldGId;
1844 2 : pResData->sResTyp = sOldTyp;
1845 : }
1846 : }
1847 928 : break;
1848 : case MERGE_MODE_LIST : {
1849 2 : ExportList *pList = NULL;
1850 2 : switch ( nList ) {
1851 : // PairedList
1852 2 : case LIST_STRING : pList = pResData->pStringList; break;
1853 0 : case LIST_FILTER : pList = pResData->pFilterList; break;
1854 0 : case LIST_UIENTRIES : pList = pResData->pUIEntries; break;
1855 0 : case LIST_ITEM : pList = pResData->pItemList; break;
1856 0 : case LIST_PAIRED : pList = pResData->pPairedList; break;
1857 :
1858 : }
1859 :
1860 2 : nListIndex++;
1861 2 : std::size_t nMaxIndex = 0;
1862 2 : if ( pList )
1863 2 : nMaxIndex = pList->GetSourceLanguageListEntryCount();
1864 2 : rtl::OString sLine;
1865 2 : if ( pList && (*pList)[ nListIndex ] )
1866 0 : sLine = ( *(*pList)[ nListIndex ])[ SOURCE_LANGUAGE ];
1867 2 : if ( sLine.isEmpty())
1868 2 : sLine = sLastListLine;
1869 :
1870 2 : if ( sLastListLine.indexOf( '<' ) != -1 ) {
1871 4 : if (( nList != LIST_UIENTRIES ) &&
1872 1 : (( sLine.indexOf( '{' ) == -1 ) ||
1873 0 : ( sLine.indexOf( '{' ) >= sLine.indexOf( '"' ))) &&
1874 1 : (( sLine.indexOf( '<' ) == -1 ) ||
1875 1 : ( sLine.indexOf( '<' ) >= sLine.indexOf( '"' ))))
1876 : {
1877 0 : sLine = sLine.replaceFirst("\"", "< \"");
1878 : }
1879 : }
1880 :
1881 4 : while( PrepareTextToMerge( sLine, nList, m_sListLang, pResData ) && ( nListIndex <= nMaxIndex )) {
1882 0 : rtl::OString sText( "\t" );
1883 0 : sText += sLine;
1884 0 : sText += " ;";
1885 0 : sText += "\n";
1886 0 : for ( sal_uInt16 i = 0; i < nLevel; i++ )
1887 0 : sText += "\t";
1888 0 : WriteToMerged( sText ,false );
1889 0 : nListIndex++;
1890 0 : if ( pList && (*pList)[ nListIndex ])
1891 0 : sLine = ( *(*pList)[ nListIndex ])[ SOURCE_LANGUAGE ];
1892 0 : if ( sLine.isEmpty())
1893 0 : sLine = sLastListLine;
1894 0 : sLine += " ;";
1895 2 : }
1896 : }
1897 2 : break;
1898 : }
1899 930 : pParseQueue->bMflag = false;
1900 930 : }
1901 :
1902 0 : rtl::OString Export::MergePairedList( rtl::OString const & sLine , rtl::OString const & sText ){
1903 : // < "xy" ; IDENTIFIER ; >
1904 0 : rtl::OString sPre = sLine.copy( 0 , sLine.indexOf('"') );
1905 0 : rtl::OString sPost = sLine.copy( sLine.lastIndexOf('"') + 1 );
1906 0 : sPre += sText;
1907 0 : sPre += sPost;
1908 0 : return sPre;
1909 : }
1910 :
1911 : /*****************************************************************************/
1912 343 : void Export::SetChildWithText()
1913 : /*****************************************************************************/
1914 : {
1915 343 : if ( aResStack.size() > 1 ) {
1916 673 : for ( size_t i = 0; i < aResStack.size() - 1; i++ ) {
1917 423 : aResStack[ i ]->bChildWithText = sal_True;
1918 : }
1919 : }
1920 343 : }
1921 :
1922 31933 : void ParserQueue::Push( const QueueEntry& aEntry )
1923 : {
1924 31933 : sal_Int32 nLen = aEntry.sLine.getLength();
1925 :
1926 31933 : if( !bStart ){
1927 24365 : aQueueCur->push( aEntry );
1928 24365 : if( nLen > 1 && aEntry.sLine[nLen-1] == '\n' )
1929 12 : bStart = true;
1930 24353 : else if ( aEntry.nTyp != IGNOREDTOKENS ){
1931 20891 : if( nLen > 1 && ( aEntry.sLine[nLen-1] == '\\') ){
1932 : // Next is Macro
1933 392 : bCurrentIsM = true;
1934 : }else{
1935 : // Next is no Macro
1936 20499 : bCurrentIsM = false;
1937 : }
1938 : }
1939 : }
1940 : else{
1941 7568 : aQueueNext->push( aEntry );
1942 7568 : if( nLen > 1 && aEntry.sLine[nLen-1] != '\n' ){
1943 3109 : if( nLen > 1 && ( aEntry.sLine[nLen-1] == '\\') ){
1944 : // Next is Macro
1945 1381 : bNextIsM = true;
1946 : }
1947 : else{
1948 : // Next is no Macro
1949 1728 : bNextIsM = false;
1950 : }
1951 4459 : }else if( nLen > 2 && aEntry.sLine[nLen-1] == '\n' ){
1952 420 : if( aEntry.nTyp != IGNOREDTOKENS ){
1953 420 : if( nLen > 2 && ( aEntry.sLine[nLen-2] == '\\') ){
1954 : // Next is Macro
1955 401 : bNextIsM = true;
1956 : }
1957 : else{
1958 : // Next is no Macro
1959 19 : bNextIsM = false;
1960 : }
1961 : }
1962 : // Pop current
1963 420 : Pop( *aQueueCur );
1964 420 : bLastWasM = bCurrentIsM;
1965 : // next -> current
1966 420 : bCurrentIsM = bNextIsM;
1967 420 : aQref = aQueueCur;
1968 420 : aQueueCur = aQueueNext;
1969 420 : aQueueNext = aQref;
1970 :
1971 : }
1972 :
1973 : else{
1974 : // Pop current
1975 4039 : Pop( *aQueueCur );
1976 4039 : bLastWasM = bCurrentIsM;
1977 : // next -> current
1978 4039 : bCurrentIsM = bNextIsM;
1979 4039 : aQref = aQueueCur;
1980 4039 : aQueueCur = aQueueNext;
1981 4039 : aQueueNext = aQref;
1982 : }
1983 : }
1984 31933 : }
1985 :
1986 14 : void ParserQueue::Close(){
1987 : // Pop current
1988 14 : Pop( *aQueueCur );
1989 : // next -> current
1990 14 : bLastWasM = bCurrentIsM;
1991 14 : bCurrentIsM = bNextIsM;
1992 14 : aQref = aQueueCur;
1993 14 : aQueueCur = aQueueNext;
1994 14 : aQueueNext = aQref;
1995 14 : bNextIsM = false;
1996 14 : Pop( *aQueueNext );
1997 14 : };
1998 :
1999 4487 : void ParserQueue::Pop( std::queue<QueueEntry>& aQueue )
2000 : {
2001 40907 : while (!aQueue.empty())
2002 : {
2003 31933 : QueueEntry aEntry = aQueue.front();
2004 31933 : aQueue.pop();
2005 31933 : aExport.Execute(aEntry.nTyp, aEntry.sLine.getStr());
2006 31933 : }
2007 4487 : }
2008 :
2009 14 : ParserQueue::ParserQueue( Export& aExportObj )
2010 : :
2011 : bCurrentIsM( false ),
2012 : bNextIsM( false ) ,
2013 : bLastWasM( false ),
2014 : bMflag( false ) ,
2015 : aExport( aExportObj ) ,
2016 14 : bStart( false )
2017 : {
2018 14 : aQueueNext = new std::queue<QueueEntry>;
2019 14 : aQueueCur = new std::queue<QueueEntry>;
2020 14 : }
2021 :
2022 :
2023 14 : ParserQueue::~ParserQueue(){
2024 14 : if( aQueueNext ) delete aQueueNext;
2025 14 : if( aQueueCur ) delete aQueueCur;
2026 56 : }
2027 :
2028 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
