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