idl/inc/lex.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #pragma once
  21
  22 #include <sal/types.h>
  23 #include "hash.hxx"
  24 #include <tools/stream.hxx>
  25 #include <vector>
  26 #include <memory>
  27
  28 enum class SVTOKENTYPE { Empty,      Comment,
  29                          Integer,    String,
  30                          Bool,       Identifier,
  31                          Char,
  32                          EndOfFile,  HashId };
  33
  34 class SvToken
  35 {
  36 friend class SvTokenStream;
  37     sal_uInt64              nLine, nColumn;
  38     SVTOKENTYPE             nType;
  39     OString                 aString;
  40     union
  41     {
  42         sal_uInt64          nLong;
  43         bool                bBool;
  44         char                cChar;
  45         SvStringHashEntry * pHash;
  46     };
  47 public:
  48             SvToken();
  49             SvToken( const SvToken & rObj ) = delete;
  50
  51     SvToken & operator = ( const SvToken & rObj );
  52
  53     OString     GetTokenAsString() const;
  54
  55     void        SetLine( sal_uInt64 nLineP )     { nLine = nLineP;       }
  56     sal_uInt64  GetLine() const             { return nLine;         }
  57
  58     void        SetColumn( sal_uInt64 nColumnP ) { nColumn = nColumnP;   }
  59     sal_uInt64  GetColumn() const           { return nColumn;       }
  60
  61     bool        IsComment() const   { return nType == SVTOKENTYPE::Comment; }
  62     bool        IsInteger() const   { return nType == SVTOKENTYPE::Integer; }
  63     bool        IsString() const    { return nType == SVTOKENTYPE::String; }
  64     bool        IsBool() const      { return nType == SVTOKENTYPE::Bool; }
  65     bool        IsIdentifierHash() const
  66                 { return nType == SVTOKENTYPE::HashId; }
  67     bool        IsIdentifier() const
  68                 {
  69                     return nType == SVTOKENTYPE::Identifier
  70                             || nType == SVTOKENTYPE::HashId;
  71                 }
  72     bool        IsChar() const      { return nType == SVTOKENTYPE::Char; }
  73     bool        IsEof() const       { return nType == SVTOKENTYPE::EndOfFile; }
  74
  75     const OString& GetString() const
  76                 {
  77                     return IsIdentifierHash()
  78                         ? pHash->GetName()
  79                         : aString;
  80                 }
  81     sal_uInt64   GetNumber() const       { return nLong;         }
  82     bool        GetBool() const         { return bBool;         }
  83     char        GetChar() const         { return cChar;         }
  84
  85     void        SetHash( SvStringHashEntry * pHashP )
  86                 { pHash = pHashP; nType = SVTOKENTYPE::HashId; }
  87     bool        Is( SvStringHashEntry const * pEntry ) const
  88                 { return IsIdentifierHash() && pHash == pEntry; }
  89 };
  90
  91 inline SvToken::SvToken()
  92     : nLine(0)
  93     , nColumn(0)
  94     , nType( SVTOKENTYPE::Empty )
  95 {
  96 }
  97
  98 class SvTokenStream
  99 {
 100     sal_uInt64      nLine, nColumn;
 101     sal_Int32       nBufPos;
 102     char            c;          // next character
 103     static const sal_uInt16 nTabSize = 4;   // length of tabulator
 104     OString         aStrTrue;
 105     OString         aStrFalse;
 106     sal_uInt32      nMaxPos;
 107
 108     std::unique_ptr<SvFileStream>          pInStream;
 109     OUString                               aFileName;
 110     std::vector<std::unique_ptr<SvToken> > aTokList;
 111     std::vector<std::unique_ptr<SvToken> >::iterator pCurToken;
 112
 113     OString         aBufStr;
 114
 115     void            InitCtor();
 116
 117     char            GetNextChar();
 118     char            GetFastNextChar()
 119                     {
 120                         return (nBufPos < aBufStr.getLength())
 121                             ? aBufStr[nBufPos++]
 122                             : '\0';
 123                     }
 124
 125     void            FillTokenList();
 126     sal_uInt64       GetNumber();
 127     bool            MakeToken( SvToken & );
 128     bool            IsEof() const { return pInStream->eof(); }
 129     void            SetMax()
 130                     {
 131                         sal_uInt32 n = Tell();
 132                         if( n > nMaxPos )
 133                             nMaxPos = n;
 134                     }
 135     void            CalcColumn()
 136                     {
 137                         // if end of line spare calculation
 138                         if( 0 != c )
 139                         {
 140                             sal_Int32 n = 0;
 141                             nColumn = 0;
 142                             while( n < nBufPos )
 143                                 nColumn += aBufStr[n++] == '\t' ? nTabSize : 1;
 144                         }
 145                     }
 146 public:
 147                     SvTokenStream( const OUString & rFileName );
 148                     ~SvTokenStream();
 149
 150     const OUString &  GetFileName() const { return aFileName; }
 151     SvStream &        GetStream() { return *pInStream; }
 152
 153     SvToken& GetToken_PrevAll()
 154     {
 155         std::vector<std::unique_ptr<SvToken> >::iterator pRetToken = pCurToken;
 156
 157         // current iterator always valid
 158         if(pCurToken != aTokList.begin())
 159             --pCurToken;
 160
 161         return *(*pRetToken);
 162     }
 163
 164     SvToken& GetToken_Next()
 165     {
 166         std::vector<std::unique_ptr<SvToken> >::iterator pRetToken = pCurToken++;
 167
 168         if (pCurToken == aTokList.end())
 169             pCurToken = pRetToken;
 170
 171         SetMax();
 172
 173         return *(*pRetToken);
 174     }
 175
 176     SvToken& GetToken() const { return *(*pCurToken); }
 177
 178     bool     ReadIf( char cChar )
 179     {
 180         if( GetToken().IsChar() && cChar == GetToken().GetChar() )
 181         {
 182             GetToken_Next();
 183             return true;
 184         }
 185         else
 186             return false;
 187     }
 188
 189     void     ReadIfDelimiter()
 190     {
 191         if( GetToken().IsChar()
 192             && (';' == GetToken().GetChar()
 193                  || ',' == GetToken().GetChar()) )
 194         {
 195             GetToken_Next();
 196         }
 197     }
 198
 199     sal_uInt32 Tell() const { return pCurToken-aTokList.begin(); }
 200
 201     void Seek( sal_uInt32 nPos )
 202     {
 203         pCurToken = aTokList.begin() + nPos;
 204         SetMax();
 205     }
 206
 207     void SeekToMax()
 208     {
 209         pCurToken = aTokList.begin()+nMaxPos;
 210     }
 211 };
 212
 213 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */