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