| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_idl.hxx" |
| |
| |
| #include <ctype.h> |
| #include <stdio.h> |
| |
| #include <char.hxx> |
| #include <hash.hxx> |
| #include <lex.hxx> |
| #include <globals.hxx> |
| #include <tools/bigint.hxx> |
| |
| /****************** SvToken **********************************************/ |
| /************************************************************************* |
| |* |
| |* SvToken::Print() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| ByteString SvToken::GetTokenAsString() const |
| { |
| ByteString aStr; |
| switch( nType ) |
| { |
| case SVTOKEN_EMPTY: |
| break; |
| case SVTOKEN_COMMENT: |
| aStr = aString; |
| break; |
| case SVTOKEN_INTEGER: |
| aStr = ByteString::CreateFromInt64(nLong); |
| break; |
| case SVTOKEN_STRING: |
| aStr = aString; |
| break; |
| case SVTOKEN_BOOL: |
| aStr = bBool ? "TRUE" : "FALSE"; |
| break; |
| case SVTOKEN_IDENTIFIER: |
| aStr = aString; |
| break; |
| case SVTOKEN_CHAR: |
| aStr = cChar; |
| break; |
| case SVTOKEN_RTTIBASE: |
| aStr = "RTTIBASE";//(ULONG)pComplexObj; |
| break; |
| case SVTOKEN_EOF: |
| case SVTOKEN_HASHID: |
| break; |
| } |
| |
| return aStr; |
| } |
| |
| /************************************************************************* |
| |* |
| |* SvToken::SvToken() |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| SvToken::SvToken( const SvToken & rObj ) |
| { |
| nLine = rObj.nLine; |
| nColumn = rObj.nColumn; |
| nType = rObj.nType; |
| aString = rObj.aString; |
| /* |
| if( SVTOKEN_RTTIBASE = nType ) |
| { |
| pComplexObj = rObj.pComplexObj; |
| pComplexObj->AddRef(); |
| } |
| else |
| */ |
| nLong = rObj.nLong; |
| } |
| |
| /************************************************************************* |
| |* |
| |* SvToken::operator = () |
| |* |
| |* Beschreibung |
| |* |
| *************************************************************************/ |
| SvToken & SvToken::operator = ( const SvToken & rObj ) |
| { |
| if( this != &rObj ) |
| { |
| /* |
| if( SVTOKEN_RTTIBASE = nType ) |
| pComplexObj->ReleaseRef(); |
| */ |
| nLine = rObj.nLine; |
| nColumn = rObj.nColumn; |
| nType = rObj.nType; |
| aString = rObj.aString; |
| /* |
| if( SVTOKEN_RTTIBASE = nType ) |
| { |
| pComplexObj = rObj.pComplexObj; |
| pComplexObj->AddRef(); |
| } |
| else |
| */ |
| nLong = rObj.nLong; |
| } |
| return *this; |
| } |
| |
| /****************** SvTokenStream ****************************************/ |
| /************************************************************************* |
| |* SvTokenStream::InitCtor() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvTokenStream::InitCtor() |
| { |
| SetCharSet( gsl_getSystemTextEncoding() ); |
| aStrTrue = "TRUE"; |
| aStrFalse = "FALSE"; |
| nLine = nColumn = 0; |
| nBufPos = 0; |
| nTabSize = 4; |
| pCurToken = NULL; |
| nMaxPos = 0; |
| c = GetNextChar(); |
| FillTokenList(); |
| } |
| |
| /************************************************************************* |
| |* SvTokenStream::SvTokenStream() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| SvTokenStream::SvTokenStream( const String & rFileName ) |
| : pInStream( new SvFileStream( rFileName, STREAM_STD_READ | STREAM_NOCREATE ) ) |
| , rInStream( *pInStream ) |
| , aFileName( rFileName ) |
| , aTokList( 0x8000, 0x8000 ) |
| { |
| InitCtor(); |
| } |
| |
| /************************************************************************* |
| |* SvTokenStream::SvTokenStream() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| SvTokenStream::SvTokenStream( SvStream & rStream, const String & rFileName ) |
| : pInStream( NULL ) |
| , rInStream( rStream ) |
| , aFileName( rFileName ) |
| , aTokList( 0x8000, 0x8000 ) |
| { |
| InitCtor(); |
| } |
| |
| /************************************************************************* |
| |* SvTokenStream::~SvTokenStream() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| SvTokenStream::~SvTokenStream() |
| { |
| delete pInStream; |
| SvToken * pTok = aTokList.Last(); |
| while( pTok ) |
| { |
| delete pTok; |
| pTok = aTokList.Prev(); |
| } |
| } |
| |
| /************************************************************************* |
| |* SvTokenStream::FillTokenList() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvTokenStream::FillTokenList() |
| { |
| SvToken * pToken = new SvToken(); |
| aTokList.Insert( pToken, LIST_APPEND ); |
| do |
| { |
| if( !MakeToken( *pToken ) ) |
| { |
| SvToken * p = aTokList.Prev(); |
| *pToken = SvToken(); |
| if( p ) |
| { |
| pToken->SetLine( p->GetLine() ); |
| pToken->SetColumn( p->GetColumn() ); |
| } |
| break; |
| } |
| else if( pToken->IsComment() ) |
| *pToken = SvToken(); |
| else if( pToken->IsEof() ) |
| break; |
| else |
| { |
| pToken = new SvToken(); |
| aTokList.Insert( pToken, LIST_APPEND ); |
| } |
| } |
| while( !pToken->IsEof() ); |
| pCurToken = aTokList.First(); |
| } |
| |
| /************************************************************************* |
| |* SvTokenStrem::SetCharSet() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| void SvTokenStream::SetCharSet( CharSet nSet ) |
| { |
| nCharSet = nSet; |
| |
| pCharTab = SvChar::GetTable( nSet, gsl_getSystemTextEncoding() ); |
| } |
| |
| /************************************************************************* |
| |* SvTokeStream::GetNextChar() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| int SvTokenStream::GetNextChar() |
| { |
| int nChar; |
| if( (int)aBufStr.Len() < nBufPos ) |
| { |
| if( rInStream.ReadLine( aBufStr ) ) |
| { |
| nLine++; |
| nColumn = 0; |
| nBufPos = 0; |
| } |
| else |
| { |
| aBufStr.Erase(); |
| nColumn = 0; |
| nBufPos = 0; |
| return '\0'; |
| } |
| } |
| nChar = aBufStr.GetChar( (sal_uInt16)nBufPos++ ); |
| nColumn += nChar == '\t' ? nTabSize : 1; |
| return nChar; |
| } |
| |
| /************************************************************************* |
| |* SvTokenStrem::GetNumber() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| sal_uLong SvTokenStream::GetNumber() |
| { |
| sal_uLong l = 0; |
| short nLog = 10; |
| |
| if( '0' == c ) |
| { |
| c = GetFastNextChar(); |
| if( 'x' == c ) |
| { |
| nLog = 16; |
| c = GetFastNextChar(); |
| } |
| }; |
| |
| if( nLog == 16 ) |
| { |
| while( isxdigit( c ) ) |
| { |
| if( isdigit( c ) ) |
| l = l * nLog + (c - '0'); |
| else |
| l = l * nLog + (toupper( c ) - 'A' + 10 ); |
| c = GetFastNextChar(); |
| } |
| } |
| else |
| { |
| while( isdigit( c ) || 'x' == c ) |
| { |
| l = l * nLog + (c - '0'); |
| c = GetFastNextChar(); |
| } |
| } |
| |
| return( l ); |
| } |
| |
| /************************************************************************* |
| |* SvTokenStream::MakeToken() |
| |* |
| |* Beschreibung |
| *************************************************************************/ |
| sal_Bool SvTokenStream::MakeToken( SvToken & rToken ) |
| { |
| int c1; |
| sal_uInt16 i; |
| |
| do |
| { |
| if( 0 == c ) |
| c = GetNextChar(); |
| // Leerzeichen ueberlesen |
| while( isspace( c ) || 26 == c ) |
| { |
| c = GetFastNextChar(); |
| nColumn += c == '\t' ? nTabSize : 1; |
| } |
| } |
| while( 0 == c && !IsEof() && ( SVSTREAM_OK == rInStream.GetError() ) ); |
| |
| sal_uLong nLastLine = nLine; |
| sal_uLong nLastColumn = nColumn; |
| // Kommentar |
| if( '/' == c ) |
| { |
| // Zeit Optimierung, keine Kommentare |
| //ByteString aComment( (char)c ); |
| c1 = c; |
| c = GetFastNextChar(); |
| if( '/' == c ) |
| { |
| while( '\0' != c ) |
| { |
| //aComment += (char)c; |
| c = GetFastNextChar(); |
| } |
| c = GetNextChar(); |
| rToken.nType = SVTOKEN_COMMENT; |
| //rToken.aString = aComment; |
| } |
| else if( '*' == c ) |
| { |
| //aComment += (char)c; |
| c = GetFastNextChar(); |
| do |
| { |
| //aComment += (char)c; |
| while( '*' != c ) |
| { |
| if( '\0' == c ) |
| { |
| c = GetNextChar(); |
| if( IsEof() ) |
| return sal_False; |
| } |
| else |
| c = GetFastNextChar(); |
| //aComment += (char)c; |
| } |
| c = GetFastNextChar(); |
| } |
| while( '/' != c && !IsEof() && ( SVSTREAM_OK == rInStream.GetError() ) ); |
| if( IsEof() || ( SVSTREAM_OK != rInStream.GetError() ) ) |
| return sal_False; |
| //aComment += (char)c; |
| c = GetNextChar(); |
| rToken.nType = SVTOKEN_COMMENT; |
| //rToken.aString = aComment; |
| CalcColumn(); |
| } |
| else |
| { |
| rToken.nType = SVTOKEN_CHAR; |
| rToken.cChar = (char)c1; |
| } |
| } |
| else if( c == '"' ) |
| { |
| ByteString aStr; |
| i = 0; |
| sal_Bool bDone = sal_False; |
| while( !bDone && !IsEof() && c ) |
| { |
| c = GetFastNextChar(); |
| if( '\0' == c ) |
| { |
| // Strings auch "uber das Zeilenende hinauslesen |
| aStr += '\n'; |
| c = GetNextChar(); |
| if( IsEof() ) |
| return sal_False; |
| } |
| if( c == '"' ) |
| { |
| c = GetFastNextChar(); |
| if( c == '"' ) |
| { |
| aStr += '"'; |
| aStr += '"'; |
| } |
| else |
| bDone = sal_True; |
| } |
| else if( c == '\\' ) |
| { |
| aStr += '\\'; |
| c = GetFastNextChar(); |
| if( c ) |
| aStr += (char)c; |
| } |
| else |
| aStr += (char)c; |
| } |
| if( IsEof() || ( SVSTREAM_OK != rInStream.GetError() ) ) |
| return sal_False; |
| char * pStr = (char *)aStr.GetBuffer(); |
| while( *pStr ) |
| { |
| *pStr = pCharTab[ (unsigned char)*pStr ]; |
| pStr++; |
| }; |
| rToken.nType = SVTOKEN_STRING; |
| rToken.aString = aStr; |
| } |
| else if( isdigit( c ) ) |
| { |
| rToken.nType = SVTOKEN_INTEGER; |
| rToken.nLong = GetNumber(); |
| |
| } |
| else if( isalpha (c) || (c == '_') ) |
| { |
| ByteString aStr; |
| |
| while( isalnum( c ) || c == '_' ) |
| { |
| aStr += (char)c; |
| c = GetFastNextChar(); |
| } |
| if( aStr.EqualsIgnoreCaseAscii( aStrTrue ) ) |
| { |
| rToken.nType = SVTOKEN_BOOL; |
| rToken.bBool = sal_True; |
| } |
| else if( aStr.EqualsIgnoreCaseAscii( aStrFalse ) ) |
| { |
| rToken.nType = SVTOKEN_BOOL; |
| rToken.bBool = sal_False; |
| } |
| else |
| { |
| sal_uInt32 nHashId; |
| if( IDLAPP->pHashTable->Test( aStr, &nHashId ) ) |
| rToken.SetHash( IDLAPP->pHashTable->Get( nHashId ) ); |
| else |
| { |
| rToken.nType = SVTOKEN_IDENTIFIER; |
| rToken.aString = aStr; |
| } |
| } |
| } |
| else if( IsEof() ) |
| { |
| rToken.nType = SVTOKEN_EOF; |
| } |
| else |
| { |
| rToken.nType = SVTOKEN_CHAR; |
| rToken.cChar = (char)c; |
| c = GetFastNextChar(); |
| } |
| rToken.SetLine( nLastLine ); |
| rToken.SetColumn( nLastColumn ); |
| return rInStream.GetError() == SVSTREAM_OK; |
| } |
| |
