summaryrefslogtreecommitdiff
path: root/soltools/giparser/gi_parse.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'soltools/giparser/gi_parse.cxx')
-rw-r--r--soltools/giparser/gi_parse.cxx407
1 files changed, 407 insertions, 0 deletions
diff --git a/soltools/giparser/gi_parse.cxx b/soltools/giparser/gi_parse.cxx
new file mode 100644
index 000000000000..ad960e48a1e2
--- /dev/null
+++ b/soltools/giparser/gi_parse.cxx
@@ -0,0 +1,407 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_soltools.hxx"
+
+#include <gi_parse.hxx>
+
+#include <stdio.h>
+#include <string.h>
+#include <fstream>
+#include <gilacces.hxx>
+
+
+using namespace std;
+
+
+const char * C_sLineEnd = "\r\n";
+
+
+
+inline void
+WriteStr( ostream & o_rOut, const Simstr & i_rStr )
+{
+ o_rOut.write( i_rStr.str(), i_rStr.l() );
+}
+
+inline void
+WriteStr( ostream & o_rOut, const char * i_rStr )
+{
+ o_rOut.write( i_rStr, strlen(i_rStr) );
+}
+
+inline void
+GenericInfo_Parser::SetError( E_Error i_eError )
+{
+ eErrorCode = i_eError;
+ nErrorLine = nCurLine;
+}
+
+
+GenericInfo_Parser::GenericInfo_Parser()
+ : sCurParsePosition(""),
+ nCurLine(0),
+ nLevel(0),
+ bGoon(false),
+ // sCurComment,
+ eErrorCode(ok),
+ nErrorLine(0),
+ pResult(0),
+ pResource(0)
+{
+}
+
+GenericInfo_Parser::~GenericInfo_Parser()
+{
+}
+
+bool
+GenericInfo_Parser::LoadList( GenericInfoList_Builder & o_rResult,
+ const Simstr & i_sSourceFileName )
+{
+ ifstream aFile( i_sSourceFileName.str() );
+ if ( aFile.fail() )
+ {
+ SetError(cannot_open);
+ return false;
+ }
+
+ aFile.seekg(0, ios::end);
+ UINT32 nTextSize = aFile.tellg();
+ if ( nTextSize == 0 || nTextSize == UINT32(-1) )
+ return true;
+ dpBuffer = new char[nTextSize+2];
+
+ aFile.seekg(0);
+ aFile.read( dpBuffer, nTextSize );
+ aFile.close();
+
+ sFilePtr = dpBuffer;
+ char * sLastChar = dpBuffer + nTextSize - 1;
+
+ while ( sFilePtr != sLastChar && *sFilePtr <= 32 )
+ ++sCurParsePosition;
+ if ( sFilePtr == sLastChar )
+ {
+ if ( *sFilePtr <= 32 )
+ return true;
+ }
+ else while ( *sLastChar <= 32 )
+ {
+ --sLastChar;
+ }
+
+ *(sLastChar+1) = '\n';
+ *(sLastChar+2) = '\0';
+
+ ResetState(o_rResult);
+
+ for ( ReadLine(); bGoon; ReadLine() )
+ {
+ bool bOk = InterpretLine();
+ if ( !bOk)
+ {
+ SetError(syntax_error);
+ break;
+ }
+ }
+
+ if ( nLevel > 0 && eErrorCode == ok)
+ {
+ SetError(unexpected_eof);
+ }
+ else if ( nLevel < 0 )
+ {
+ SetError(unexpected_list_end);
+ }
+
+ delete [] dpBuffer;
+ dpBuffer = 0;
+ sFilePtr = 0;
+
+ return eErrorCode == ok;
+}
+
+bool
+GenericInfo_Parser::SaveList( const Simstr & i_rOutputFile,
+ GenericInfoList_Browser & io_rListBrowser )
+{
+ ofstream aFile( i_rOutputFile.str() );
+ if ( aFile.fail() )
+ {
+ SetError(cannot_open);
+ return false;
+ }
+
+ ResetState(io_rListBrowser);
+
+ WriteList(aFile);
+
+ aFile.close();
+ return eErrorCode == ok;
+}
+
+void
+GenericInfo_Parser::ResetState( GenericInfoList_Builder & io_rResult )
+{
+ sCurParsePosition = "";
+ nCurLine = 0;
+ nLevel = 0;
+ bGoon = true;
+ sCurComment = "";
+ eErrorCode = ok;
+ nErrorLine = 0;
+ pResult = &io_rResult;
+ pResource = 0;
+}
+
+void
+GenericInfo_Parser::ResetState( GenericInfoList_Browser & io_rSrc )
+{
+ sCurParsePosition = "";
+ nCurLine = 0;
+ nLevel = 0;
+ bGoon = false;
+ sCurComment = "";
+ eErrorCode = ok;
+ nErrorLine = 0;
+ pResult = 0;
+ pResource = &io_rSrc;
+}
+
+
+void
+GenericInfo_Parser::ReadLine()
+{
+ if ( *sFilePtr == '\0' ) // See initialising of dpBuffer and sLastChar in LoadList().
+ {
+ bGoon = false;
+ return;
+ }
+
+ sCurParsePosition = sFilePtr;
+ while ( *sFilePtr != '\n' )
+ ++sFilePtr;
+ nCurLine++;
+
+ // Remove leading and trailing whitespace from line:
+ while ( sCurParsePosition != sFilePtr && *sCurParsePosition <= 32 )
+ ++sCurParsePosition;
+
+ char * sEndOfLine = sFilePtr;
+ while ( sEndOfLine != sCurParsePosition && *sEndOfLine <= 32 )
+ --sEndOfLine;
+ if ( sCurParsePosition != sEndOfLine || *sCurParsePosition > 32 )
+ ++sEndOfLine;
+ *sEndOfLine = '\0';
+
+ ++sFilePtr; // Go beyond line end to first character of next line.
+}
+
+bool
+GenericInfo_Parser::InterpretLine()
+{
+ switch ( ClassifyLine() )
+ {
+ case lt_key: ReadKey();
+ break;
+ case lt_open_list: PushLevel_Read();
+ break;
+ case lt_close_list: PopLevel_Read();
+ break;
+ case lt_comment: AddCurLine2CurComment();
+ break;
+ case lt_empty: AddCurLine2CurComment();
+ break;
+ default:
+ return false;
+ }
+ return true;
+}
+
+GenericInfo_Parser::E_LineType
+GenericInfo_Parser::ClassifyLine()
+{
+ switch ( *sCurParsePosition )
+ {
+ case '{': return lt_open_list;
+ case '}': return lt_close_list;
+ case '#': return lt_comment;
+ case '\0': return lt_empty;
+ }
+
+ return lt_key;
+}
+
+void
+GenericInfo_Parser::ReadKey()
+{
+ const char * pSearch = sCurParsePosition;
+
+ for ( ; *pSearch > 32; ++pSearch ) ;
+ UINT32 nKeyLength = pSearch - sCurParsePosition;
+
+ for ( ; *pSearch <= 32 && *pSearch > '\0'; ++pSearch ) ;
+
+ pResult->AddKey( sCurParsePosition, nKeyLength,
+ pSearch, strlen(pSearch),
+ sCurComment.str(), sCurComment.l()
+ );
+ sCurComment = "";
+}
+
+void
+GenericInfo_Parser::PushLevel_Read()
+{
+ nLevel++;
+ pResult->OpenList();
+}
+
+void
+GenericInfo_Parser::PopLevel_Read()
+{
+ nLevel--;
+ pResult->CloseList();
+}
+
+void
+GenericInfo_Parser::AddCurLine2CurComment()
+{
+ sCurComment += sCurParsePosition;
+ sCurComment += C_sLineEnd;
+}
+
+void
+GenericInfo_Parser::WriteList( ostream & o_rFile )
+{
+ static char sBuffer[32000];
+
+ for ( bGoon = pResource->Start_CurList();
+ bGoon;
+ bGoon = pResource->NextOf_CurList() )
+ {
+ pResource->Get_CurComment(&sBuffer[0]);
+ WriteComment(o_rFile,sBuffer);
+
+ pResource->Get_CurKey(&sBuffer[0]);
+ WriteKey(o_rFile,sBuffer);
+
+ pResource->Get_CurValue(&sBuffer[0]);
+ WriteValue(o_rFile,sBuffer);
+
+ if ( pResource->HasSubList_CurKey() )
+ {
+ PushLevel_Write();
+
+/*
+ WriteIndentation();
+ o_rFile.write("{",1);
+ o_rFile.write(C_sLineEnd, C_nLineEndLength);
+*/
+ WriteList(o_rFile);
+
+/*
+ WriteIndentation();
+ o_rFile.write("}",1);
+ o_rFile.write(C_sLineEnd, C_nLineEndLength);
+*/
+ PopLevel_Write();
+ }
+ } // end for
+}
+
+void
+GenericInfo_Parser::PushLevel_Write()
+{
+ nLevel++;
+ pResource->Push_CurList();
+}
+
+void
+GenericInfo_Parser::PopLevel_Write()
+{
+ nLevel--;
+ pResource->Pop_CurList();
+}
+
+void
+GenericInfo_Parser::WriteComment( ostream & o_rFile,
+ const char * i_sStr )
+{
+ WriteStr( o_rFile, i_sStr );
+ if ( i_sStr[ strlen(i_sStr)-1 ] != '\n' )
+ WriteStr( o_rFile, C_sLineEnd );
+}
+
+void
+GenericInfo_Parser::WriteKey( ostream & o_rFile,
+ const char * i_sStr )
+{
+ WriteIndentation(o_rFile);
+ WriteStr( o_rFile, i_sStr );
+}
+
+void
+GenericInfo_Parser::WriteValue( ostream & o_rFile,
+ const char * i_sStr )
+{
+ if ( i_sStr != 0 ? strlen(i_sStr) > 0 : false )
+ {
+ WriteStr(o_rFile," ");
+ WriteStr(o_rFile,i_sStr);
+ }
+
+ WriteStr(o_rFile,C_sLineEnd);
+}
+
+void
+GenericInfo_Parser::WriteIndentation( ostream & o_rFile )
+{
+ const int nIndentBound = 60;
+
+ static const char sIndentation[nIndentBound+1] =
+ "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"
+ "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"
+ "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
+
+ if ( nLevel == 0 )
+ return;
+
+ if ( nLevel <= nIndentBound )
+ o_rFile.write( sIndentation, nLevel );
+ else
+ {
+ INT16 iLevel = nLevel;
+ for ( ; iLevel > nIndentBound; iLevel-=nIndentBound )
+ o_rFile.write( sIndentation, nIndentBound );
+ o_rFile.write( sIndentation, iLevel );
+ }
+}
+
+
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-17 17:30:14 +0000