?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / transex3 / source / gsicheck.cxx
blobcda02df9c6943dcbc5416539005cba9d9102a162
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: gsicheck.cxx,v $
10 * $Revision: 1.29 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_transex3.hxx"
33 #include <stdio.h>
34 #include <tools/fsys.hxx>
35 #include <tools/stream.hxx>
36 #include <tools/list.hxx>
37
38 // local includes
39 #include "tagtest.hxx"
40 #include "gsicheck.hxx"
41
42 #define MAX_GID_LID_LEN 250
43
44 /*****************************************************************************/
45 void PrintMessage( ByteString aType, ByteString aMsg, ByteString aPrefix,
46 ByteString aContext, BOOL bPrintContext, ULONG nLine, ByteString aUniqueId = ByteString() )
47 /*****************************************************************************/
48 {
49 fprintf( stdout, "%s %s, Line %lu", aType.GetBuffer(), aPrefix.GetBuffer(), nLine );
50 if ( aUniqueId.Len() )
51 fprintf( stdout, ", UniqueID %s", aUniqueId.GetBuffer() );
52 fprintf( stdout, ": %s", aMsg.GetBuffer() );
53
54 if ( bPrintContext )
55 fprintf( stdout, " \"%s\"", aContext.GetBuffer() );
56 fprintf( stdout, "\n" );
57 }
58
59 /*****************************************************************************/
60 void PrintError( ByteString aMsg, ByteString aPrefix,
61 ByteString aContext, BOOL bPrintContext, ULONG nLine, ByteString aUniqueId = ByteString() )
62 /*****************************************************************************/
63 {
64 PrintMessage( "Error:", aMsg, aPrefix, aContext, bPrintContext, nLine, aUniqueId );
65 }
66
67 BOOL LanguageOK( ByteString aLang )
68 {
69 if ( !aLang.Len() )
70 return FALSE;
71
72 if ( aLang.IsNumericAscii() )
73 return TRUE;
74
75 if ( aLang.GetTokenCount( '-' ) == 1 )
76 return aLang.IsAlphaAscii() && aLang.IsLowerAscii();
77 else if ( aLang.GetTokenCount( '-' ) == 2 )
78 {
79 ByteString aTok0( aLang.GetToken( 0, '-' ) );
80 ByteString aTok1( aLang.GetToken( 1, '-' ) );
81 return aTok0.Len() && aTok0.IsAlphaAscii() && aTok0.IsLowerAscii()
82 && aTok1.Len() && aTok1.IsAlphaAscii() && aTok1.IsUpperAscii()
83 && !aTok1.EqualsIgnoreCaseAscii( aTok0 );
84 }
85
86 return FALSE;
87 }
88
89
90 //
91 // class LazySvFileStream
92 //
93
94
95 class LazySvFileStream : public SvFileStream
96 {
97
98 private:
99 String aFileName;
100 BOOL bOpened;
101 StreamMode eOpenMode;
102
103 public:
104 LazySvFileStream()
105 : aFileName()
106 , bOpened( FALSE )
107 , eOpenMode( 0 )
108 {};
109
110 void SetOpenParams( const String& rFileName, StreamMode eOpenModeP )
111 {
112 aFileName = rFileName;
113 eOpenMode = eOpenModeP;
114 };
115
116 void LazyOpen();
117 };
118
119 void LazySvFileStream::LazyOpen()
120 {
121 if ( !bOpened )
122 {
123 Open( aFileName, eOpenMode );
124 if ( !IsOpen())
125 {
126 fprintf( stderr, "\nERROR: Could not open Output-File %s!\n\n", ByteString( aFileName, RTL_TEXTENCODING_ASCII_US ).GetBuffer() );
127 exit ( 4 );
128 }
129 bOpened = TRUE;
130 }
131 }
132
133
134 //
135 // class GSILine
136 //
137
138 /*****************************************************************************/
139 GSILine::GSILine( const ByteString &rLine, ULONG nLine )
140 /*****************************************************************************/
141 : ByteString( rLine )
142 , nLineNumber( nLine )
143 , bOK( TRUE )
144 , bFixed ( FALSE )
145 {
146 if ( rLine.GetTokenCount( '\t' ) == 15 )
147 {
148 aFormat = FORMAT_SDF;
149 aUniqId = rLine.GetToken( 0, '\t' );
150 aUniqId.Append("/").Append( rLine.GetToken( 1, '\t' ) ).Append("/").Append( rLine.GetToken( 3, '\t' ) ).Append("/").Append( rLine.GetToken( 4, '\t' ) ).Append("/").Append( rLine.GetToken( 5, '\t' ) ).Append("/").Append( rLine.GetToken( 6, '\t' ) ).Append("/").Append( rLine.GetToken( 7, '\t' ) );
151 aLineType = "";
152 aLangId = rLine.GetToken( 9, '\t' );
153 aText = rLine.GetToken( 10, '\t' );
154 aQuickHelpText = rLine.GetToken( 12, '\t' );
155 aTitle = rLine.GetToken( 13, '\t' );
156
157 // do some more format checks here
158 if ( !rLine.GetToken( 8, '\t' ).IsNumericAscii() )
159 {
160 PrintError( "The length field does not contain a number!", "Line format", rLine.GetToken( 8, '\t' ), TRUE, GetLineNumber(), GetUniqId() );
161 NotOK();
162 }
163 if ( !LanguageOK( aLangId ) )
164 {
165 PrintError( "The Language is invalid!", "Line format", aLangId, TRUE, GetLineNumber(), GetUniqId() );
166 NotOK();
167 }
168 // limit GID and LID to MAX_GID_LID_LEN chars each for database conformity, see #137575#
169 if ( rLine.GetToken( 4, '\t' ).Len() > MAX_GID_LID_LEN || rLine.GetToken( 5, '\t' ).Len() > MAX_GID_LID_LEN )
170 {
171 PrintError( ByteString("GID and LID may only be ").Append( ByteString::CreateFromInt32(MAX_GID_LID_LEN) ).Append( " chars long each!" ), "Line format", aLangId, TRUE, GetLineNumber(), GetUniqId() );
172 NotOK();
173 }
174 }
175 else // allow tabs in gsi files
176 {
177 aFormat = FORMAT_GSI;
178 ByteString sTmp( rLine );
179 USHORT nPos = sTmp.Search( "($$)" );
180 USHORT nStart = 0;
181 if ( nPos != STRING_NOTFOUND )
182 {
183 aUniqId = sTmp.Copy( nStart, nPos - nStart );
184 nStart = nPos + 4; // + length of the delemiter
185 nPos = sTmp.Search( "($$)", nStart );
186 }
187 if ( nPos != STRING_NOTFOUND )
188 {
189 aLineType = sTmp.Copy( nStart, nPos - nStart );
190 nStart = nPos + 4; // + length of the delemiter
191 nPos = sTmp.Search( "($$)", nStart );
192 aUniqId.Append( "/" );
193 aUniqId.Append( aLineType );
194 }
195 if ( nPos != STRING_NOTFOUND )
196 {
197 aLangId = sTmp.Copy( nStart, nPos - nStart );
198 nStart = nPos + 4; // + length of the delemiter
199 nPos = sTmp.Search( "($$)", nStart );
200 }
201 if ( nPos != STRING_NOTFOUND )
202 {
203 // ByteString aStatus = sTmp.Copy( nStart, nPos - nStart ); // ext int ...
204 nStart = nPos + 4; // + length of the delemiter
205 }
206 if ( nPos != STRING_NOTFOUND )
207 aText = sTmp.Copy( nStart );
208 else
209 aFormat = FORMAT_UNKNOWN;
210 }
211
212 if ( FORMAT_UNKNOWN == GetLineFormat() )
213 NotOK();
214 }
215
216 /*****************************************************************************/
217 void GSILine::NotOK()
218 /*****************************************************************************/
219 {
220 bOK = FALSE;
221 }
222
223 /*****************************************************************************/
224 void GSILine::ReassembleLine()
225 /*****************************************************************************/
226 {
227 ByteString aReassemble;
228 if ( GetLineFormat() == FORMAT_SDF )
229 {
230 USHORT i;
231 for ( i = 0 ; i < 10 ; i++ )
232 {
233 aReassemble.Append( GetToken( i, '\t' ) );
234 aReassemble.Append( "\t" );
235 }
236 aReassemble.Append( aText );
237 aReassemble.Append( "\t" );
238 aReassemble.Append( GetToken( 11, '\t' ) ); // should be empty but there are some places in sc. Not reflected to sources!!
239 aReassemble.Append( "\t" );
240 aReassemble.Append( aQuickHelpText );
241 aReassemble.Append( "\t" );
242 aReassemble.Append( aTitle );
243 for ( i = 14 ; i < 15 ; i++ )
244 {
245 aReassemble.Append( "\t" );
246 aReassemble.Append( GetToken( i, '\t' ) );
247 }
248 *(ByteString*)this = aReassemble;
249 }
250 else if ( GetLineFormat() == FORMAT_GSI )
251 {
252 USHORT nPos = Search( "($$)" );
253 USHORT nStart = 0;
254 if ( nPos != STRING_NOTFOUND )
255 {
256 nStart = nPos + 4; // + length of the delemiter
257 nPos = Search( "($$)", nStart );
258 }
259 if ( nPos != STRING_NOTFOUND )
260 {
261 nStart = nPos + 4; // + length of the delemiter
262 nPos = Search( "($$)", nStart );
263 }
264 if ( nPos != STRING_NOTFOUND )
265 {
266 nStart = nPos + 4; // + length of the delemiter
267 nPos = Search( "($$)", nStart );
268 }
269 if ( nPos != STRING_NOTFOUND )
270 {
271 nStart = nPos + 4; // + length of the delemiter
272 }
273 if ( nPos != STRING_NOTFOUND )
274 {
275 aReassemble = Copy( 0, nStart );
276 aReassemble += aText;
277 *(ByteString*)this = aReassemble;
278 }
279 else
280 PrintError( "Cannot reassemble GSI line (internal Error).", "Line format", "", FALSE, GetLineNumber(), GetUniqId() );
281 }
282 else
283 PrintError( "Cannot reassemble line of unknown type (internal Error).", "Line format", "", FALSE, GetLineNumber(), GetUniqId() );
284 }
285
286 //
287 // class GSIBlock
288 //
289 /*****************************************************************************/
290 GSIBlock::GSIBlock( BOOL PbPrintContext, BOOL bSource, BOOL bTrans, BOOL bRef, BOOL bAllowKID, BOOL bAllowSusp )
291 /*****************************************************************************/
292 : pSourceLine( NULL )
293 , pReferenceLine( NULL )
294 , bPrintContext( PbPrintContext )
295 , bCheckSourceLang( bSource )
296 , bCheckTranslationLang( bTrans )
297 , bReference( bRef )
298 , bAllowKeyIDs( bAllowKID )
299 , bAllowSuspicious( bAllowSusp )
300 , bHasBlockError( FALSE )
301 {
302 }
303
304 /*****************************************************************************/
305 GSIBlock::~GSIBlock()
306 /*****************************************************************************/
307 {
308 delete pSourceLine;
309 delete pReferenceLine;
310
311 for ( ULONG i = 0; i < Count(); i++ )
312 delete ( GetObject( i ));
313 }
314
315 /*****************************************************************************/
316 void GSIBlock::InsertLine( GSILine* pLine, ByteString aSourceLang)
317 /*****************************************************************************/
318 {
319 if ( pLine->GetLanguageId().Equals( aSourceLang ) )
320 {
321 if ( pSourceLine )
322 {
323 PrintError( "Source Language entry double. Treating as Translation.", "File format", "", pLine->GetLineNumber(), pLine->GetUniqId() );
324 bHasBlockError = TRUE;
325 pSourceLine->NotOK();
326 pLine->NotOK();
327 }
328 else
329 {
330 pSourceLine = pLine;
331 return;
332 }
333 }
334 ULONG nPos = 0;
335
336 if ( aSourceLang.Len() ) // only check blockstructure if source lang is given
337 {
338 while ( nPos < Count() )
339 {
340 if ( GetObject( nPos )->GetLanguageId().Equals( pLine->GetLanguageId() ) )
341 {
342 PrintError( "Translation Language entry double. Checking both.", "File format", "", pLine->GetLineNumber(), pLine->GetUniqId() );
343 bHasBlockError = TRUE;
344 GetObject( nPos )->NotOK();
345 pLine->NotOK();
346 }
347 nPos++;
348 }
349 }
350 Insert( pLine, LIST_APPEND );
351 }
352
353 /*****************************************************************************/
354 void GSIBlock::SetReferenceLine( GSILine* pLine )
355 /*****************************************************************************/
356 {
357 pReferenceLine = pLine;
358 }
359
360 /*****************************************************************************/
361 void GSIBlock::PrintMessage( ByteString aType, ByteString aMsg, ByteString aPrefix,
362 ByteString aContext, ULONG nLine, ByteString aUniqueId )
363 /*****************************************************************************/
364 {
365 ::PrintMessage( aType, aMsg, aPrefix, aContext, bPrintContext, nLine, aUniqueId );
366 }
367
368 /*****************************************************************************/
369 void GSIBlock::PrintError( ByteString aMsg, ByteString aPrefix,
370 ByteString aContext, ULONG nLine, ByteString aUniqueId )
371 /*****************************************************************************/
372 {
373 PrintMessage( "Error:", aMsg, aPrefix, aContext, nLine, aUniqueId );
374 }
375
376 /*****************************************************************************/
377 void GSIBlock::PrintList( ParserMessageList *pList, ByteString aPrefix,
378 GSILine *pLine )
379 /*****************************************************************************/
380 {
381 ULONG i;
382 for ( i = 0 ; i < pList->Count() ; i++ )
383 {
384 ParserMessage *pMsg = pList->GetObject( i );
385 ByteString aContext;
386 if ( bPrintContext )
387 {
388 if ( pMsg->GetTagBegin() == STRING_NOTFOUND )
389 aContext = pLine->GetText().Copy( 0, 300 );
390 else
391 aContext = pLine->Copy( pMsg->GetTagBegin()-150, 300 );
392 aContext.EraseTrailingChars(' ');
393 aContext.EraseLeadingChars(' ');
394 }
395
396 PrintMessage( pMsg->Prefix(), pMsg->GetErrorText(), aPrefix, aContext, pLine->GetLineNumber(), pLine->GetUniqId() );
397 }
398 }
399
400 /*****************************************************************************/
401 BOOL GSIBlock::IsUTF8( const ByteString &aTestee, BOOL bFixTags, USHORT &nErrorPos, ByteString &aErrorMsg, BOOL &bHasBeenFixed, ByteString &aFixed ) const
402 /*****************************************************************************/
403 {
404 String aUTF8Tester( aTestee, RTL_TEXTENCODING_UTF8 );
405 if ( STRING_MATCH != (nErrorPos = ByteString( aUTF8Tester, RTL_TEXTENCODING_UTF8 ).Match( aTestee )) )
406 {
407 aUTF8Tester = String( aTestee.GetBuffer(), nErrorPos, RTL_TEXTENCODING_UTF8 );
408 nErrorPos = aUTF8Tester.Len();
409 aErrorMsg = ByteString( "UTF8 Encoding seems to be broken" );
410 return FALSE;
411 }
412
413 nErrorPos = aUTF8Tester.SearchChar( String::CreateFromAscii( "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0b\x0c\x0e\x0f"
414 "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x7f" ).GetBuffer() );
415 if ( nErrorPos != STRING_NOTFOUND )
416 {
417 aErrorMsg = ByteString( "String contains illegal character" );
418 return FALSE;
419 }
420
421 if ( bFixTags )
422 {
423 bHasBeenFixed = FALSE;
424 aFixed.Erase();
425 }
426
427 if ( !bAllowKeyIDs )
428 {
429 BOOL bIsKeyID = FALSE;
430 BOOL bNewId = FALSE;
431 ByteString aID( aTestee );
432 USHORT nAfterID = 0;
433
434 if ( aTestee.Equals( "{&", 0, 2 ) )
435 { // check for strings from instset_native like "{&Tahoma8}335795.Installation Wiza ..."
436 USHORT nTagEnd = aTestee.Search( '}' );
437 if ( nTagEnd != STRING_NOTFOUND )
438 {
439 if ( bFixTags )
440 aFixed = aTestee.Copy( 0, nTagEnd+1 );
441 nErrorPos = nTagEnd+1;
442 aID = aTestee.Copy( nTagEnd+1 );
443 nAfterID = nTagEnd+1;
444 }
445 }
446
447 ByteString aDelimiter( (String)String( sal_Unicode(0x2016) ), RTL_TEXTENCODING_UTF8 );
448
449 if ( aID.Equals( aDelimiter, 6, aDelimiter.Len() ) )
450 { // New KeyId 6 Letters, digits and spechial chars followed by delimiter
451 bNewId = TRUE;
452 nErrorPos = 1;
453 aID = aID.Copy( 0, 6 );
454 nAfterID += 6;
455 nAfterID = nAfterID + aDelimiter.Len();
456 }
457 else if ( ( aID.GetChar(6) == '*' ) && aID.Equals( aDelimiter, 7, aDelimiter.Len() ) )
458 { // New KeyId 6 Letters, digits and spechial chars followed by '*delimiter' to indicate translation in progress
459 bNewId = TRUE;
460 nErrorPos = 1;
461 aID = aID.Copy( 0, 6 );
462 nAfterID += 7;
463 nAfterID = nAfterID + aDelimiter.Len();
464 }
465 else if ( aID.GetTokenCount( '.' ) > 1 )
466 { // test for old KeyIDs 5 to 6 digits followed by a dot '44373.'
467 bNewId = FALSE;
468 nErrorPos = 1;
469 aID = aID.GetToken( 0, '.' );
470 nAfterID = nAfterID + aID.Len();
471 }
472 else
473 {
474 aID.Erase();
475 }
476
477 if ( bNewId )
478 {
479 if ( aID.Len() == 6 )
480 {
481 bIsKeyID = TRUE;
482 ByteString aDigits("0123456789abcdefghijklmnopqrstuvwxyz+-<=>");
483 for ( USHORT i=0 ; i < aID.Len() ;i++ )
484 {
485 if ( aDigits.Search( aID.GetChar(i) ) == STRING_NOTFOUND )
486 bIsKeyID = FALSE;
487 }
488 }
489 }
490 else
491 {
492 if ( aID.Len() > 0 && aID.GetChar(aID.Len()-1) == '*' )
493 aID.Erase( aID.Len()-1 );
494
495 if ( aID.IsNumericAscii() && aID.Len() >= 5 )
496 bIsKeyID = TRUE;
497 }
498
499 if ( bIsKeyID )
500 {
501 aErrorMsg = ByteString( "String contains KeyID" );
502 if ( bFixTags )
503 {
504 aFixed += aTestee.Copy( nAfterID );
505 bHasBeenFixed = TRUE;
506 aErrorMsg = ByteString( "FIXED String containing KeyID" );
507 }
508 else
509 aErrorMsg = ByteString( "String contains KeyID" );
510 return FALSE;
511 }
512 }
513
514 return TRUE;
515 }
516
517 /*****************************************************************************/
518 BOOL GSIBlock::TestUTF8( GSILine* pTestee, BOOL bFixTags )
519 /*****************************************************************************/
520 {
521 USHORT nErrorPos = 0;
522 ByteString aErrorMsg;
523 BOOL bError = FALSE;
524 ByteString aFixed;
525 BOOL bHasBeenFixed = FALSE;
526 if ( !IsUTF8( pTestee->GetText(), bFixTags, nErrorPos, aErrorMsg, bHasBeenFixed, aFixed ) )
527 {
528 ByteString aContext( pTestee->GetText().Copy( nErrorPos, 20 ) );
529 PrintError( aErrorMsg.Append(" in Text at Position " ).Append( ByteString::CreateFromInt32( nErrorPos ) ), "Text format", aContext, pTestee->GetLineNumber(), pTestee->GetUniqId() );
530 bError = TRUE;
531 if ( bHasBeenFixed )
532 {
533 pTestee->SetText( aFixed );
534 pTestee->SetFixed();
535 }
536 }
537 if ( !IsUTF8( pTestee->GetQuickHelpText(), bFixTags, nErrorPos, aErrorMsg, bHasBeenFixed, aFixed ) )
538 {
539 ByteString aContext( pTestee->GetQuickHelpText().Copy( nErrorPos, 20 ) );
540 PrintError( aErrorMsg.Append(" in QuickHelpText at Position " ).Append( ByteString::CreateFromInt32( nErrorPos ) ), "Text format", aContext, pTestee->GetLineNumber(), pTestee->GetUniqId() );
541 bError = TRUE;
542 if ( bHasBeenFixed )
543 {
544 pTestee->SetQuickHelpText( aFixed );
545 pTestee->SetFixed();
546 }
547 }
548 if ( !IsUTF8( pTestee->GetTitle(), bFixTags, nErrorPos, aErrorMsg, bHasBeenFixed, aFixed ) )
549 {
550 ByteString aContext( pTestee->GetTitle().Copy( nErrorPos, 20 ) );
551 PrintError( aErrorMsg.Append(" in Title at Position " ).Append( ByteString::CreateFromInt32( nErrorPos ) ), "Text format", aContext, pTestee->GetLineNumber(), pTestee->GetUniqId() );
552 bError = TRUE;
553 if ( bHasBeenFixed )
554 {
555 pTestee->SetTitle( aFixed );
556 pTestee->SetFixed();
557 }
558 }
559 if ( bError )
560 pTestee->NotOK();
561 return !bError;
562 }
563
564
565 /*****************************************************************************/
566 BOOL GSIBlock::HasSuspiciousChars( GSILine* pTestee, GSILine* pSource )
567 /*****************************************************************************/
568 {
569 USHORT nPos = 0;
570 if ( !bAllowSuspicious && ( nPos = pTestee->GetText().Search("??")) != STRING_NOTFOUND )
571 if ( pSource->GetText().Search("??") == STRING_NOTFOUND )
572 {
573 String aUTF8Tester = String( pTestee->GetText(), 0, nPos, RTL_TEXTENCODING_UTF8 );
574 USHORT nErrorPos = aUTF8Tester.Len();
575 ByteString aContext( pTestee->GetText().Copy( nPos, 20 ) );
576 PrintError( ByteString("Found double questionmark in translation only. Looks like an encoding problem at Position " ).Append( ByteString::CreateFromInt32( nErrorPos ) ), "Text format", aContext, pTestee->GetLineNumber(), pTestee->GetUniqId() );
577 pTestee->NotOK();
578 return TRUE;
579 }
580
581 return FALSE;
582 }
583
584
585 /*****************************************************************************/
586 BOOL GSIBlock::CheckSyntax( ULONG nLine, BOOL bRequireSourceLine, BOOL bFixTags )
587 /*****************************************************************************/
588 {
589 static LingTest aTester;
590 BOOL bHasError = FALSE;
591
592 if ( !pSourceLine )
593 {
594 if ( bRequireSourceLine )
595 {
596 PrintError( "No source language entry defined!", "File format", "", nLine );
597 bHasBlockError = TRUE;
598 }
599 }
600 else
601 {
602 aTester.CheckReference( pSourceLine );
603 if ( pSourceLine->HasMessages() )
604 {
605 PrintList( pSourceLine->GetMessageList(), "ReferenceString", pSourceLine );
606 pSourceLine->NotOK();
607 bHasError = TRUE;
608 }
609 }
610 if ( bReference )
611 {
612 if ( !pReferenceLine )
613 {
614 GSILine *pSource;
615 if ( pSourceLine )
616 pSource = pSourceLine;
617 else
618 pSource = GetObject( 0 ); // get some other line
619 if ( pSource )
620 PrintError( "No reference line found. Entry is new in source file", "File format", "", pSource->GetLineNumber(), pSource->GetUniqId() );
621 else
622 PrintError( "No reference line found. Entry is new in source file", "File format", "", nLine );
623 bHasBlockError = TRUE;
624 }
625 else
626 {
627 if ( pSourceLine && !pSourceLine->Equals( *pReferenceLine ) )
628 {
629 xub_StrLen nPos = pSourceLine->Match( *pReferenceLine );
630 ByteString aContext( pReferenceLine->Copy( nPos - 5, 15) );
631 aContext.Append( "\" --> \"" ).Append( pSourceLine->Copy( nPos - 5, 15) );
632 PrintError( "Source Language Entry has changed.", "File format", aContext, pSourceLine->GetLineNumber(), pSourceLine->GetUniqId() );
633 pSourceLine->NotOK();
634 bHasError = TRUE;
635 }
636 }
637 }
638
639 if ( pSourceLine )
640 bHasError |= !TestUTF8( pSourceLine, bFixTags );
641
642 ULONG i;
643 for ( i = 0; i < Count(); i++ )
644 {
645 aTester.CheckTestee( GetObject( i ), pSourceLine != NULL, bFixTags );
646 if ( GetObject( i )->HasMessages() || aTester.HasCompareWarnings() )
647 {
648 if ( GetObject( i )->HasMessages() || aTester.GetCompareWarnings().HasErrors() )
649 GetObject( i )->NotOK();
650 bHasError = TRUE;
651 PrintList( GetObject( i )->GetMessageList(), "Translation", GetObject( i ) );
652 PrintList( &(aTester.GetCompareWarnings()), "Translation Tag Missmatch", GetObject( i ) );
653 }
654 bHasError |= !TestUTF8( GetObject( i ), bFixTags );
655 if ( pSourceLine )
656 bHasError |= HasSuspiciousChars( GetObject( i ), pSourceLine );
657 }
658
659 return bHasError || bHasBlockError;
660 }
661
662 void GSIBlock::WriteError( LazySvFileStream &aErrOut, BOOL bRequireSourceLine )
663 {
664 if ( pSourceLine && pSourceLine->IsOK() && bCheckSourceLang && !bHasBlockError )
665 return;
666
667 BOOL bHasError = FALSE;
668 BOOL bCopyAll = ( !pSourceLine && bRequireSourceLine ) || ( pSourceLine && !pSourceLine->IsOK() && !bCheckTranslationLang ) || bHasBlockError;
669 ULONG i;
670 for ( i = 0; i < Count(); i++ )
671 {
672 if ( !GetObject( i )->IsOK() || bCopyAll )
673 {
674 bHasError = TRUE;
675 aErrOut.LazyOpen();
676 aErrOut.WriteLine( *GetObject( i ) );
677 }
678 }
679
680 if ( pSourceLine && ( bHasError || !pSourceLine->IsOK() ) && !( !bHasError && bCheckTranslationLang ) )
681 {
682 aErrOut.LazyOpen();
683 aErrOut.WriteLine( *pSourceLine );
684 }
685 }
686
687 void GSIBlock::WriteCorrect( LazySvFileStream &aOkOut, BOOL bRequireSourceLine )
688 {
689 if ( ( !pSourceLine && bRequireSourceLine ) || ( pSourceLine && !pSourceLine->IsOK() && !bCheckTranslationLang ) )
690 return;
691
692 BOOL bHasOK = FALSE;
693 ULONG i;
694 for ( i = 0; i < Count(); i++ )
695 {
696 if ( ( GetObject( i )->IsOK() || bCheckSourceLang ) && !bHasBlockError )
697 {
698 bHasOK = TRUE;
699 aOkOut.LazyOpen();
700 aOkOut.WriteLine( *GetObject( i ) );
701 }
702 }
703
704 if ( ( pSourceLine && pSourceLine->IsOK() && ( Count() || !bCheckTranslationLang ) ) || ( bHasOK && bCheckTranslationLang ) )
705 {
706 aOkOut.LazyOpen();
707 aOkOut.WriteLine( *pSourceLine );
708 }
709 }
710
711 void GSIBlock::WriteFixed( LazySvFileStream &aFixOut, BOOL /*bRequireSourceLine*/ )
712 {
713 if ( pSourceLine && !pSourceLine->IsFixed() && bCheckSourceLang )
714 return;
715
716 BOOL bHasFixes = FALSE;
717 ULONG i;
718 for ( i = 0; i < Count(); i++ )
719 {
720 if ( GetObject( i )->IsFixed() )
721 {
722 bHasFixes = TRUE;
723 aFixOut.LazyOpen();
724 aFixOut.WriteLine( *GetObject( i ) );
725 }
726 }
727
728 if ( pSourceLine && ( bHasFixes || pSourceLine->IsFixed() ) )
729 {
730 aFixOut.LazyOpen();
731 aFixOut.WriteLine( *pSourceLine );
732 }
733 }
734
735
736 /*****************************************************************************/
737 /*****************************************************************************/
738 /*****************************************************************************/
739 /*****************************************************************************/
740 /*****************************************************************************/
741 /*****************************************************************************/
742 /*****************************************************************************/
743
744 /*****************************************************************************/
745 void Help()
746 /*****************************************************************************/
747 {
748 fprintf( stdout, "\n" );
749 fprintf( stdout, "gsicheck Version 1.9.0 (c)1999 - 2006 by SUN Microsystems\n" );
750 fprintf( stdout, "=========================================================\n" );
751 fprintf( stdout, "\n" );
752 fprintf( stdout, "gsicheck checks the syntax of tags in GSI-Files and SDF-Files\n" );
753 fprintf( stdout, " checks for inconsistencies and malicious UTF8 encoding\n" );
754 fprintf( stdout, " checks tags in Online Help\n" );
755 fprintf( stdout, " checks for *new* KeyIDs and relax GID/LID length to %s\n", ByteString::CreateFromInt32(MAX_GID_LID_LEN).GetBuffer() );
756 fprintf( stdout, "\n" );
757 fprintf( stdout, "Syntax: gsicheck [ -c ] [-f] [ -we ] [ -wef ErrorFilename ] [ -wc ]\n" );
758 fprintf( stdout, " [ -wcf CorrectFilename ] [ -s | -t ] [ -l LanguageID ]\n" );
759 fprintf( stdout, " [ -r ReferenceFile ] filename\n" );
760 fprintf( stdout, "\n" );
761 fprintf( stdout, "-c Add context to error message (Print the line containing the error)\n" );
762 fprintf( stdout, "-f try to fix errors. See also -wf -wff \n" );
763 fprintf( stdout, "-wf Write File containing all fixed parts\n" );
764 fprintf( stdout, "-wff Same as above but give own filename\n" );
765 fprintf( stdout, "-we Write File containing all errors\n" );
766 fprintf( stdout, "-wef Same as above but give own filename\n" );
767 fprintf( stdout, "-wc Write File containing all correct parts\n" );
768 fprintf( stdout, "-wcf Same as above but give own filename\n" );
769 fprintf( stdout, "-s Check only source language. Should be used before handing out to vendor.\n" );
770 fprintf( stdout, "-t Check only Translation language(s). Should be used before merging.\n" );
771 fprintf( stdout, "-k Allow KeyIDs to be present in strings\n" );
772 fprintf( stdout, "-e disable encoding checks. E.g.: double questionmark \'??\' which may be the\n" );
773 fprintf( stdout, " result of false conversions\n" );
774 fprintf( stdout, "-l ISO Languagecode or numerical 2 digits Identifier of the source language.\n" );
775 fprintf( stdout, " Default is en-US. Use \"\" (empty string) or 'none'\n" );
776 fprintf( stdout, " to disable source language dependent checks\n" );
777 fprintf( stdout, "-r Reference filename to check that source language entries\n" );
778 fprintf( stdout, " have not been changed\n" );
779 fprintf( stdout, "\n" );
780 }
781
782 /*****************************************************************************/
783 #if defined(UNX) || defined(OS2)
784 int main( int argc, char *argv[] )
785 #else
786 int _cdecl main( int argc, char *argv[] )
787 #endif
788 /*****************************************************************************/
789 {
790
791 BOOL bError = FALSE;
792 BOOL bPrintContext = FALSE;
793 BOOL bCheckSourceLang = FALSE;
794 BOOL bCheckTranslationLang = FALSE;
795 BOOL bWriteError = FALSE;
796 BOOL bWriteCorrect = FALSE;
797 BOOL bWriteFixed = FALSE;
798 BOOL bFixTags = FALSE;
799 BOOL bAllowKID = FALSE;
800 BOOL bAllowSuspicious = FALSE;
801 String aErrorFilename;
802 String aCorrectFilename;
803 String aFixedFilename;
804 BOOL bFileHasError = FALSE;
805 ByteString aSourceLang( "en-US" ); // English is default
806 ByteString aFilename;
807 ByteString aReferenceFilename;
808 BOOL bReferenceFile = FALSE;
809 for ( USHORT i = 1 ; i < argc ; i++ )
810 {
811 if ( *argv[ i ] == '-' )
812 {
813 switch (*(argv[ i ]+1))
814 {
815 case 'c':bPrintContext = TRUE;
816 break;
817 case 'w':
818 {
819 if ( (*(argv[ i ]+2)) == 'e' )
820 {
821 if ( (*(argv[ i ]+3)) == 'f' )
822 if ( (i+1) < argc )
823 {
824 aErrorFilename = String( argv[ i+1 ], RTL_TEXTENCODING_ASCII_US );
825 bWriteError = TRUE;
826 i++;
827 }
828 else
829 {
830 fprintf( stderr, "\nERROR: Switch %s requires parameter!\n\n", argv[ i ] );
831 bError = TRUE;
832 }
833 else
834 bWriteError = TRUE;
835 }
836 else if ( (*(argv[ i ]+2)) == 'c' )
837 if ( (*(argv[ i ]+3)) == 'f' )
838 if ( (i+1) < argc )
839 {
840 aCorrectFilename = String( argv[ i+1 ], RTL_TEXTENCODING_ASCII_US );
841 bWriteCorrect = TRUE;
842 i++;
843 }
844 else
845 {
846 fprintf( stderr, "\nERROR: Switch %s requires parameter!\n\n", argv[ i ] );
847 bError = TRUE;
848 }
849 else
850 bWriteCorrect = TRUE;
851 else if ( (*(argv[ i ]+2)) == 'f' )
852 if ( (*(argv[ i ]+3)) == 'f' )
853 if ( (i+1) < argc )
854 {
855 aFixedFilename = String( argv[ i+1 ], RTL_TEXTENCODING_ASCII_US );
856 bWriteFixed = TRUE;
857 bFixTags = TRUE;
858 i++;
859 }
860 else
861 {
862 fprintf( stderr, "\nERROR: Switch %s requires parameter!\n\n", argv[ i ] );
863 bError = TRUE;
864 }
865 else
866 {
867 bWriteFixed = TRUE;
868 bFixTags = TRUE;
869 }
870 else
871 {
872 fprintf( stderr, "\nERROR: Unknown Switch %s!\n\n", argv[ i ] );
873 bError = TRUE;
874 }
875 }
876 break;
877 case 's':bCheckSourceLang = TRUE;
878 break;
879 case 't':bCheckTranslationLang = TRUE;
880 break;
881 case 'l':
882 {
883 if ( (i+1) < argc )
884 {
885 aSourceLang = ByteString( argv[ i+1 ] );
886 if ( aSourceLang.EqualsIgnoreCaseAscii( "none" ) )
887 aSourceLang.Erase();
888 i++;
889 }
890 else
891 {
892 fprintf( stderr, "\nERROR: Switch %s requires parameter!\n\n", argv[ i ] );
893 bError = TRUE;
894 }
895 }
896 break;
897 case 'r':
898 {
899 if ( (i+1) < argc )
900 {
901 aReferenceFilename = argv[ i+1 ];
902 bReferenceFile = TRUE;
903 i++;
904 }
905 else
906 {
907 fprintf( stderr, "\nERROR: Switch %s requires parameter!\n\n", argv[ i ] );
908 bError = TRUE;
909 }
910 }
911 break;
912 case 'f':
913 {
914 bFixTags = TRUE;
915 }
916 break;
917 case 'k':
918 {
919 bAllowKID = TRUE;
920 }
921 break;
922 case 'e':
923 {
924 bAllowSuspicious = TRUE;
925 }
926 break;
927 default:
928 fprintf( stderr, "\nERROR: Unknown Switch %s!\n\n", argv[ i ] );
929 bError = TRUE;
930 }
931 }
932 else
933 {
934 if ( !aFilename.Len())
935 aFilename = ByteString( argv[ i ] );
936 else
937 {
938 fprintf( stderr, "\nERROR: Only one filename may be specified!\n\n");
939 bError = TRUE;
940 }
941 }
942 }
943
944
945 if ( !aFilename.Len() || bError )
946 {
947 Help();
948 exit ( 0 );
949 }
950
951 if ( aSourceLang.Len() && !LanguageOK( aSourceLang ) )
952 {
953 fprintf( stderr, "\nERROR: The Language '%s' is invalid!\n\n", aSourceLang.GetBuffer() );
954 Help();
955 exit ( 1 );
956 }
957
958 if ( bCheckSourceLang && bCheckTranslationLang )
959 {
960 fprintf( stderr, "\nERROR: The Options -s and -t are mutually exclusive.\nUse only one of them.\n\n" );
961 Help();
962 exit ( 1 );
963 }
964
965
966
967 DirEntry aSource = DirEntry( String( aFilename, RTL_TEXTENCODING_ASCII_US ));
968 if ( !aSource.Exists()) {
969 fprintf( stderr, "\nERROR: GSI-File %s not found!\n\n", aFilename.GetBuffer() );
970 exit ( 2 );
971 }
972
973 SvFileStream aGSI( String( aFilename, RTL_TEXTENCODING_ASCII_US ), STREAM_STD_READ );
974 if ( !aGSI.IsOpen()) {
975 fprintf( stderr, "\nERROR: Could not open GSI-File %s!\n\n", aFilename.GetBuffer() );
976 exit ( 3 );
977 }
978
979 SvFileStream aReferenceGSI;
980 if ( bReferenceFile )
981 {
982 DirEntry aReferenceSource = DirEntry( String( aReferenceFilename, RTL_TEXTENCODING_ASCII_US ));
983 if ( !aReferenceSource.Exists()) {
984 fprintf( stderr, "\nERROR: GSI-File %s not found!\n\n", aFilename.GetBuffer() );
985 exit ( 2 );
986 }
987
988 aReferenceGSI.Open( String( aReferenceFilename, RTL_TEXTENCODING_ASCII_US ), STREAM_STD_READ );
989 if ( !aReferenceGSI.IsOpen()) {
990 fprintf( stderr, "\nERROR: Could not open Input-File %s!\n\n", aFilename.GetBuffer() );
991 exit ( 3 );
992 }
993 }
994
995 LazySvFileStream aOkOut;
996 String aBaseName = aSource.GetBase();
997 if ( bWriteCorrect )
998 {
999 if ( !aCorrectFilename.Len() )
1000 {
1001 String sTmpBase( aBaseName );
1002 sTmpBase += String( "_ok", RTL_TEXTENCODING_ASCII_US );
1003 aSource.SetBase( sTmpBase );
1004 aCorrectFilename = aSource.GetFull();
1005 }
1006 aOkOut.SetOpenParams( aCorrectFilename , STREAM_STD_WRITE | STREAM_TRUNC );
1007 }
1008
1009 LazySvFileStream aErrOut;
1010 if ( bWriteError )
1011 {
1012 if ( !aErrorFilename.Len() )
1013 {
1014 String sTmpBase( aBaseName );
1015 sTmpBase += String( "_err", RTL_TEXTENCODING_ASCII_US );
1016 aSource.SetBase( sTmpBase );
1017 aErrorFilename = aSource.GetFull();
1018 }
1019 aErrOut.SetOpenParams( aErrorFilename , STREAM_STD_WRITE | STREAM_TRUNC );
1020 }
1021
1022 LazySvFileStream aFixOut;
1023 if ( bWriteFixed )
1024 {
1025 if ( !aFixedFilename.Len() )
1026 {
1027 String sTmpBase( aBaseName );
1028 sTmpBase += String( "_fix", RTL_TEXTENCODING_ASCII_US );
1029 aSource.SetBase( sTmpBase );
1030 aFixedFilename = aSource.GetFull();
1031 }
1032 aFixOut.SetOpenParams( aFixedFilename , STREAM_STD_WRITE | STREAM_TRUNC );
1033 }
1034
1035
1036 ByteString sReferenceLine;
1037 GSILine* pReferenceLine = NULL;
1038 ByteString aOldReferenceId("No Valid ID"); // just set to something which can never be an ID
1039 ULONG nReferenceLine = 0;
1040
1041 ByteString sGSILine;
1042 GSILine* pGSILine = NULL;
1043 ByteString aOldId("No Valid ID"); // just set to something which can never be an ID
1044 GSIBlock *pBlock = NULL;
1045 ULONG nLine = 0;
1046
1047 while ( !aGSI.IsEof() )
1048 {
1049 aGSI.ReadLine( sGSILine );
1050 nLine++;
1051 pGSILine = new GSILine( sGSILine, nLine );
1052 BOOL bDelete = TRUE;
1053
1054
1055 if ( pGSILine->Len() )
1056 {
1057 if ( FORMAT_UNKNOWN == pGSILine->GetLineFormat() )
1058 {
1059 PrintError( "Format of line is unknown. Ignoring!", "Line format", pGSILine->Copy( 0,40 ), bPrintContext, pGSILine->GetLineNumber() );
1060 pGSILine->NotOK();
1061 if ( bWriteError )
1062 {
1063 bFileHasError = TRUE;
1064 aErrOut.LazyOpen();
1065 aErrOut.WriteLine( *pGSILine );
1066 }
1067 }
1068 else if ( pGSILine->GetLineType().EqualsIgnoreCaseAscii("res-comment") )
1069 { // ignore comment lines, but write them to Correct Items File
1070 if ( bWriteCorrect )
1071 {
1072 aOkOut.LazyOpen();
1073 aOkOut.WriteLine( *pGSILine );
1074 }
1075 }
1076 else
1077 {
1078 ByteString aId = pGSILine->GetUniqId();
1079 if ( aId != aOldId )
1080 {
1081 if ( pBlock )
1082 {
1083 bFileHasError |= pBlock->CheckSyntax( nLine, aSourceLang.Len() != 0, bFixTags );
1084
1085 if ( bWriteError )
1086 pBlock->WriteError( aErrOut, aSourceLang.Len() != 0 );
1087 if ( bWriteCorrect )
1088 pBlock->WriteCorrect( aOkOut, aSourceLang.Len() != 0 );
1089 if ( bWriteFixed )
1090 pBlock->WriteFixed( aFixOut, aSourceLang.Len() != 0 );
1091
1092 delete pBlock;
1093 }
1094 pBlock = new GSIBlock( bPrintContext, bCheckSourceLang, bCheckTranslationLang, bReferenceFile, bAllowKID, bAllowSuspicious );
1095
1096 aOldId = aId;
1097
1098
1099 // find corresponding line in reference file
1100 if ( bReferenceFile )
1101 {
1102 BOOL bContinueSearching = TRUE;
1103 while ( ( !aReferenceGSI.IsEof() || pReferenceLine ) && bContinueSearching )
1104 {
1105 if ( !pReferenceLine )
1106 {
1107 aReferenceGSI.ReadLine( sReferenceLine );
1108 nReferenceLine++;
1109 pReferenceLine = new GSILine( sReferenceLine, nReferenceLine );
1110 }
1111 if ( pReferenceLine->GetLineFormat() != FORMAT_UNKNOWN )
1112 {
1113 if ( pReferenceLine->GetUniqId() == aId && pReferenceLine->GetLanguageId().Equals( aSourceLang ) )
1114 {
1115 pBlock->SetReferenceLine( pReferenceLine );
1116 pReferenceLine = NULL;
1117 }
1118 else if ( pReferenceLine->GetUniqId() > aId )
1119 {
1120 // if ( pGSILine->GetLanguageId() == aSourceLang )
1121 // PrintError( "No reference line found. Entry is new in source file", "File format", "", bPrintContext, pGSILine->GetLineNumber(), aId );
1122 bContinueSearching = FALSE;
1123 }
1124 else
1125 {
1126 if ( pReferenceLine->GetUniqId() < aId && pReferenceLine->GetLanguageId().Equals( aSourceLang ) )
1127 PrintError( "No Entry in source file found. Entry has been removed from source file", "File format", "", bPrintContext, pGSILine->GetLineNumber(), pReferenceLine->GetUniqId() );
1128 delete pReferenceLine;
1129 pReferenceLine = NULL;
1130 }
1131 }
1132 else
1133 {
1134 delete pReferenceLine;
1135 pReferenceLine = NULL;
1136 }
1137
1138 }
1139 }
1140
1141 }
1142
1143 pBlock->InsertLine( pGSILine, aSourceLang );
1144 bDelete = FALSE;
1145 }
1146 }
1147 if ( bDelete )
1148 delete pGSILine;
1149
1150 }
1151 if ( pBlock )
1152 {
1153 bFileHasError |= pBlock->CheckSyntax( nLine, aSourceLang.Len() != 0, bFixTags );
1154
1155 if ( bWriteError )
1156 pBlock->WriteError( aErrOut, aSourceLang.Len() != 0 );
1157 if ( bWriteCorrect )
1158 pBlock->WriteCorrect( aOkOut, aSourceLang.Len() != 0 );
1159 if ( bWriteFixed )
1160 pBlock->WriteFixed( aFixOut, aSourceLang.Len() != 0 );
1161
1162 delete pBlock;
1163 }
1164 aGSI.Close();
1165
1166 if ( bWriteError )
1167 aErrOut.Close();
1168 if ( bWriteCorrect )
1169 aOkOut.Close();
1170 if ( bWriteFixed )
1171 aFixOut.Close();
1172
1173 if ( bFileHasError )
1174 return 55;
1175 else
1176 return 0;
1177 }
vba interoperability for OOo