LCOV - code coverage report
Current view: top level - svl/source/misc - adrparse.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 0 383 0.0 %
Date: 2014-11-03 Functions: 0 15 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : #include <tools/inetmime.hxx>
      21             : #include <rtl/ustrbuf.hxx>
      22             : #include <svl/adrparse.hxx>
      23             : 
      24             : namespace
      25             : {
      26             : 
      27             : enum ElementType { ELEMENT_START, ELEMENT_DELIM, ELEMENT_ITEM, ELEMENT_END };
      28             : 
      29             : struct ParsedAddrSpec
      30             : {
      31             :     sal_Unicode const * m_pBegin;
      32             :     sal_Unicode const * m_pEnd;
      33             :     ElementType m_eLastElem;
      34             :     bool m_bAtFound;
      35             :     bool m_bReparse;
      36             : 
      37           0 :     ParsedAddrSpec() { reset(); }
      38             : 
      39           0 :     bool isPoorlyValid() const { return m_eLastElem >= ELEMENT_ITEM; }
      40             : 
      41           0 :     bool isValid() const { return isPoorlyValid() && m_bAtFound; }
      42             : 
      43             :     inline void reset();
      44             : 
      45             :     inline void finish();
      46             : };
      47             : 
      48           0 : inline void ParsedAddrSpec::reset()
      49             : {
      50           0 :     m_pBegin = 0;
      51           0 :     m_pEnd = 0;
      52           0 :     m_eLastElem = ELEMENT_START;
      53           0 :     m_bAtFound = false;
      54           0 :     m_bReparse = false;
      55           0 : }
      56             : 
      57           0 : inline void ParsedAddrSpec::finish()
      58             : {
      59           0 :     if (isPoorlyValid())
      60           0 :         m_eLastElem = ELEMENT_END;
      61             :     else
      62           0 :         reset();
      63           0 : }
      64             : 
      65             : }
      66             : 
      67             : class SvAddressParser_Impl
      68             : {
      69             :     enum State { BEFORE_COLON, BEFORE_LESS, AFTER_LESS, AFTER_GREATER };
      70             : 
      71             :     enum TokenType { TOKEN_QUOTED = 0x80000000, TOKEN_DOMAIN, TOKEN_COMMENT,
      72             :                      TOKEN_ATOM };
      73             : 
      74             :     sal_Unicode const * m_pInputPos;
      75             :     sal_Unicode const * m_pInputEnd;
      76             :     sal_uInt32 m_nCurToken;
      77             :     sal_Unicode const * m_pCurTokenBegin;
      78             :     sal_Unicode const * m_pCurTokenEnd;
      79             :     sal_Unicode const * m_pCurTokenContentBegin;
      80             :     sal_Unicode const * m_pCurTokenContentEnd;
      81             :     bool m_bCurTokenReparse;
      82             :     ParsedAddrSpec m_aOuterAddrSpec;
      83             :     ParsedAddrSpec m_aInnerAddrSpec;
      84             :     ParsedAddrSpec * m_pAddrSpec;
      85             :     sal_Unicode const * m_pRealNameBegin;
      86             :     sal_Unicode const * m_pRealNameEnd;
      87             :     sal_Unicode const * m_pRealNameContentBegin;
      88             :     sal_Unicode const * m_pRealNameContentEnd;
      89             :     bool m_bRealNameReparse;
      90             :     bool m_bRealNameFinished;
      91             :     sal_Unicode const * m_pFirstCommentBegin;
      92             :     sal_Unicode const * m_pFirstCommentEnd;
      93             :     bool m_bFirstCommentReparse;
      94             :     State m_eState;
      95             :     TokenType m_eType;
      96             : 
      97             :     inline void resetRealNameAndFirstComment();
      98             : 
      99             :     inline void reset();
     100             : 
     101             :     inline void addTokenToAddrSpec(ElementType eTokenElem);
     102             : 
     103             :     inline void addTokenToRealName();
     104             : 
     105             :     bool readToken();
     106             : 
     107             :     static OUString reparse(sal_Unicode const * pBegin,
     108             :                             sal_Unicode const * pEnd, bool bAddrSpec);
     109             : 
     110             :     static OUString reparseComment(sal_Unicode const * pBegin,
     111             :                                    sal_Unicode const * pEnd);
     112             : 
     113             : public:
     114             :     SvAddressParser_Impl(SvAddressParser * pParser, const OUString& rIn);
     115             : };
     116             : 
     117           0 : inline void SvAddressParser_Impl::resetRealNameAndFirstComment()
     118             : {
     119           0 :     m_pRealNameBegin = 0;
     120           0 :     m_pRealNameEnd = 0;
     121           0 :     m_pRealNameContentBegin = 0;
     122           0 :     m_pRealNameContentEnd = 0;
     123           0 :     m_bRealNameReparse = false;
     124           0 :     m_bRealNameFinished = false;
     125           0 :     m_pFirstCommentBegin = 0;
     126           0 :     m_pFirstCommentEnd = 0;
     127           0 :     m_bFirstCommentReparse = false;
     128           0 : }
     129             : 
     130           0 : inline void SvAddressParser_Impl::reset()
     131             : {
     132           0 :     m_aOuterAddrSpec.reset();
     133           0 :     m_aInnerAddrSpec.reset();
     134           0 :     m_pAddrSpec = &m_aOuterAddrSpec;
     135           0 :     resetRealNameAndFirstComment();
     136           0 :     m_eState = BEFORE_COLON;
     137           0 :     m_eType = TOKEN_ATOM;
     138           0 : }
     139             : 
     140           0 : inline void SvAddressParser_Impl::addTokenToAddrSpec(ElementType eTokenElem)
     141             : {
     142           0 :     if (!m_pAddrSpec->m_pBegin)
     143           0 :         m_pAddrSpec->m_pBegin = m_pCurTokenBegin;
     144           0 :     else if (m_pAddrSpec->m_pEnd < m_pCurTokenBegin)
     145           0 :         m_pAddrSpec->m_bReparse = true;
     146           0 :     m_pAddrSpec->m_pEnd = m_pCurTokenEnd;
     147           0 :     m_pAddrSpec->m_eLastElem = eTokenElem;
     148           0 : }
     149             : 
     150           0 : inline void SvAddressParser_Impl::addTokenToRealName()
     151             : {
     152           0 :     if (!m_bRealNameFinished && m_eState != AFTER_LESS)
     153             :     {
     154           0 :         if (!m_pRealNameBegin)
     155           0 :             m_pRealNameBegin = m_pRealNameContentBegin = m_pCurTokenBegin;
     156           0 :         else if (m_pRealNameEnd < m_pCurTokenBegin - 1
     157           0 :                  || (m_pRealNameEnd == m_pCurTokenBegin - 1
     158           0 :                     && *m_pRealNameEnd != ' '))
     159           0 :             m_bRealNameReparse = true;
     160           0 :         m_pRealNameEnd = m_pRealNameContentEnd = m_pCurTokenEnd;
     161             :     }
     162           0 : }
     163             : 
     164             : 
     165             : //  SvAddressParser_Impl
     166             : 
     167             : 
     168           0 : bool SvAddressParser_Impl::readToken()
     169             : {
     170           0 :     m_nCurToken = m_eType;
     171           0 :     m_bCurTokenReparse = false;
     172           0 :     switch (m_eType)
     173             :     {
     174             :         case TOKEN_QUOTED:
     175             :         {
     176           0 :             m_pCurTokenBegin = m_pInputPos - 1;
     177           0 :             m_pCurTokenContentBegin = m_pInputPos;
     178           0 :             bool bEscaped = false;
     179             :             for (;;)
     180             :             {
     181           0 :                 if (m_pInputPos >= m_pInputEnd)
     182           0 :                     return false;
     183           0 :                 sal_Unicode cChar = *m_pInputPos++;
     184           0 :                 if (bEscaped)
     185             :                 {
     186           0 :                     m_bCurTokenReparse = true;
     187           0 :                     bEscaped = false;
     188             :                 }
     189           0 :                 else if (cChar == '"')
     190             :                 {
     191           0 :                     m_pCurTokenEnd = m_pInputPos;
     192           0 :                     m_pCurTokenContentEnd = m_pInputPos - 1;
     193           0 :                     return true;
     194             :                 }
     195           0 :                 else if (cChar == '\\')
     196           0 :                     bEscaped = true;
     197           0 :             }
     198             :         }
     199             : 
     200             :         case TOKEN_DOMAIN:
     201             :         {
     202           0 :             m_pCurTokenBegin = m_pInputPos - 1;
     203           0 :             m_pCurTokenContentBegin = m_pInputPos;
     204           0 :             bool bEscaped = false;
     205             :             for (;;)
     206             :             {
     207           0 :                 if (m_pInputPos >= m_pInputEnd)
     208           0 :                     return false;
     209           0 :                 sal_Unicode cChar = *m_pInputPos++;
     210           0 :                 if (bEscaped)
     211           0 :                     bEscaped = false;
     212           0 :                 else if (cChar == ']')
     213             :                 {
     214           0 :                     m_pCurTokenEnd = m_pInputPos;
     215           0 :                     return true;
     216             :                 }
     217           0 :                 else if (cChar == '\\')
     218           0 :                     bEscaped = true;
     219           0 :             }
     220             :         }
     221             : 
     222             :         case TOKEN_COMMENT:
     223             :         {
     224           0 :             m_pCurTokenBegin = m_pInputPos - 1;
     225           0 :             m_pCurTokenContentBegin = 0;
     226           0 :             m_pCurTokenContentEnd = 0;
     227           0 :             bool bEscaped = false;
     228           0 :             int nLevel = 0;
     229             :             for (;;)
     230             :             {
     231           0 :                 if (m_pInputPos >= m_pInputEnd)
     232           0 :                     return false;
     233           0 :                 sal_Unicode cChar = *m_pInputPos++;
     234           0 :                 if (bEscaped)
     235             :                 {
     236           0 :                     m_bCurTokenReparse = true;
     237           0 :                     m_pCurTokenContentEnd = m_pInputPos;
     238           0 :                     bEscaped = false;
     239             :                 }
     240           0 :                 else if (cChar == '(')
     241             :                 {
     242           0 :                     if (!m_pCurTokenContentBegin)
     243           0 :                         m_pCurTokenContentBegin = m_pInputPos - 1;
     244           0 :                     m_pCurTokenContentEnd = m_pInputPos;
     245           0 :                     ++nLevel;
     246             :                 }
     247           0 :                 else if (cChar == ')')
     248           0 :                     if (nLevel)
     249             :                     {
     250           0 :                         m_pCurTokenContentEnd = m_pInputPos;
     251           0 :                         --nLevel;
     252             :                     }
     253             :                     else
     254           0 :                         return true;
     255           0 :                 else if (cChar == '\\')
     256             :                 {
     257           0 :                     if (!m_pCurTokenContentBegin)
     258           0 :                         m_pCurTokenContentBegin = m_pInputPos - 1;
     259           0 :                     bEscaped = true;
     260             :                 }
     261           0 :                 else if (cChar > ' ' && cChar != 0x7F) // DEL
     262             :                 {
     263           0 :                     if (!m_pCurTokenContentBegin)
     264           0 :                         m_pCurTokenContentBegin = m_pInputPos - 1;
     265           0 :                     m_pCurTokenContentEnd = m_pInputPos;
     266             :                 }
     267           0 :             }
     268             :         }
     269             : 
     270             :         default:
     271             :         {
     272             :             sal_Unicode cChar;
     273             :             for (;;)
     274             :             {
     275           0 :                 if (m_pInputPos >= m_pInputEnd)
     276           0 :                     return false;
     277           0 :                 cChar = *m_pInputPos++;
     278           0 :                 if (cChar > ' ' && cChar != 0x7F) // DEL
     279           0 :                     break;
     280             :             }
     281           0 :             m_pCurTokenBegin = m_pInputPos - 1;
     282           0 :             if (cChar == '"' || cChar == '(' || cChar == ')' || cChar == ','
     283           0 :                 || cChar == '.' || cChar == ':' || cChar == ';'
     284           0 :                 || cChar == '<' || cChar == '>' || cChar == '@'
     285           0 :                 || cChar == '[' || cChar == '\\' || cChar == ']')
     286             :             {
     287           0 :                 m_nCurToken = cChar;
     288           0 :                 m_pCurTokenEnd = m_pInputPos;
     289           0 :                 return true;
     290             :             }
     291             :             else
     292             :                 for (;;)
     293             :                 {
     294           0 :                     if (m_pInputPos >= m_pInputEnd)
     295             :                     {
     296           0 :                         m_pCurTokenEnd = m_pInputPos;
     297           0 :                         return true;
     298             :                     }
     299           0 :                     cChar = *m_pInputPos++;
     300           0 :                     if (cChar <= ' ' || cChar == '"' || cChar == '('
     301           0 :                         || cChar == ')' || cChar == ',' || cChar == '.'
     302           0 :                         || cChar == ':' || cChar == ';' || cChar == '<'
     303           0 :                         || cChar == '>' || cChar == '@' || cChar == '['
     304           0 :                         || cChar == '\\' || cChar == ']'
     305           0 :                         || cChar == 0x7F) // DEL
     306             :                     {
     307           0 :                         m_pCurTokenEnd = --m_pInputPos;
     308           0 :                         return true;
     309             :                     }
     310           0 :                 }
     311             :         }
     312             :     }
     313             : }
     314             : 
     315             : // static
     316           0 : OUString SvAddressParser_Impl::reparse(sal_Unicode const * pBegin,
     317             :                                        sal_Unicode const * pEnd, bool bAddrSpec)
     318             : {
     319           0 :     OUStringBuffer aResult;
     320           0 :     TokenType eMode = TOKEN_ATOM;
     321           0 :     bool bEscaped = false;
     322           0 :     bool bEndsWithSpace = false;
     323           0 :     int nLevel = 0;
     324           0 :     while (pBegin < pEnd)
     325             :     {
     326           0 :         sal_Unicode cChar = *pBegin++;
     327           0 :         switch (eMode)
     328             :         {
     329             :         case TOKEN_QUOTED:
     330           0 :             if (bEscaped)
     331             :             {
     332           0 :                 aResult.append(cChar);
     333           0 :                 bEscaped = false;
     334             :             }
     335           0 :             else if (cChar == '"')
     336             :             {
     337           0 :                 if (bAddrSpec)
     338           0 :                     aResult.append(cChar);
     339           0 :                 eMode = TOKEN_ATOM;
     340             :             }
     341           0 :             else if (cChar == '\\')
     342             :             {
     343           0 :                 if (bAddrSpec)
     344           0 :                     aResult.append(cChar);
     345           0 :                 bEscaped = true;
     346             :             }
     347             :             else
     348           0 :                 aResult.append(cChar);
     349           0 :             break;
     350             : 
     351             :         case TOKEN_DOMAIN:
     352           0 :             if (bEscaped)
     353             :             {
     354           0 :                 aResult.append(cChar);
     355           0 :                 bEscaped = false;
     356             :             }
     357           0 :             else if (cChar == ']')
     358             :             {
     359           0 :                 aResult.append(cChar);
     360           0 :                 eMode = TOKEN_ATOM;
     361             :             }
     362           0 :             else if (cChar == '\\')
     363             :             {
     364           0 :                 if (bAddrSpec)
     365           0 :                     aResult.append(cChar);
     366           0 :                 bEscaped = true;
     367             :             }
     368             :             else
     369           0 :                 aResult.append(cChar);
     370           0 :             break;
     371             : 
     372             :         case TOKEN_COMMENT:
     373           0 :             if (bEscaped)
     374           0 :                 bEscaped = false;
     375           0 :             else if (cChar == '(')
     376           0 :                 ++nLevel;
     377           0 :             else if (cChar == ')')
     378           0 :                 if (nLevel)
     379           0 :                     --nLevel;
     380             :                 else
     381           0 :                     eMode = TOKEN_ATOM;
     382           0 :             else if (cChar == '\\')
     383           0 :                 bEscaped = true;
     384           0 :             break;
     385             : 
     386             :         case TOKEN_ATOM:
     387           0 :             if (cChar <= ' ' || cChar == 0x7F) // DEL
     388             :             {
     389           0 :                 if (!bAddrSpec && !bEndsWithSpace)
     390             :                 {
     391           0 :                     aResult.append(' ');
     392           0 :                     bEndsWithSpace = true;
     393             :                 }
     394             :             }
     395           0 :             else if (cChar == '(')
     396             :             {
     397           0 :                 if (!bAddrSpec && !bEndsWithSpace)
     398             :                 {
     399           0 :                     aResult.append(' ');
     400           0 :                     bEndsWithSpace = true;
     401             :                 }
     402           0 :                 eMode = TOKEN_COMMENT;
     403             :             }
     404             :             else
     405             :             {
     406           0 :                 bEndsWithSpace = false;
     407           0 :                 if (cChar == '"')
     408             :                 {
     409           0 :                     if (bAddrSpec)
     410           0 :                         aResult.append(cChar);
     411           0 :                     eMode = TOKEN_QUOTED;
     412             :                 }
     413           0 :                 else if (cChar == '[')
     414             :                 {
     415           0 :                     aResult.append(cChar);
     416           0 :                     eMode = TOKEN_QUOTED;
     417             :                 }
     418             :                 else
     419           0 :                     aResult.append(cChar);
     420             :             }
     421           0 :             break;
     422             :         }
     423             :     }
     424           0 :     return aResult.makeStringAndClear();
     425             : }
     426             : 
     427             : // static
     428           0 : OUString SvAddressParser_Impl::reparseComment(sal_Unicode const * pBegin,
     429             :                                               sal_Unicode const * pEnd)
     430             : {
     431           0 :     OUStringBuffer aResult;
     432           0 :     while (pBegin < pEnd)
     433             :     {
     434           0 :         sal_Unicode cChar = *pBegin++;
     435           0 :         if (cChar == '\\')
     436           0 :             cChar = *pBegin++;
     437           0 :         aResult.append(cChar);
     438             :     }
     439           0 :     return aResult.makeStringAndClear();
     440             : }
     441             : 
     442           0 : SvAddressParser_Impl::SvAddressParser_Impl(SvAddressParser * pParser,
     443             :                                            const OUString& rInput)
     444             :     : m_pCurTokenBegin(NULL)
     445             :     , m_pCurTokenEnd(NULL)
     446             :     , m_pCurTokenContentBegin(NULL)
     447           0 :     , m_pCurTokenContentEnd(NULL)
     448             : {
     449           0 :     m_pInputPos = rInput.getStr();
     450           0 :     m_pInputEnd = m_pInputPos + rInput.getLength();
     451             : 
     452           0 :     reset();
     453           0 :     bool bDone = false;
     454             :     for (;;)
     455             :     {
     456           0 :         if (!readToken())
     457             :         {
     458           0 :             m_bRealNameFinished = true;
     459           0 :             if (m_eState == AFTER_LESS)
     460           0 :                 m_nCurToken = '>';
     461             :             else
     462             :             {
     463           0 :                 m_nCurToken = ',';
     464           0 :                 bDone = true;
     465             :             }
     466             :         }
     467           0 :         switch (m_nCurToken)
     468             :         {
     469             :         case TOKEN_QUOTED:
     470           0 :             if (m_pAddrSpec->m_eLastElem != ELEMENT_END)
     471             :             {
     472           0 :                 if (m_pAddrSpec->m_bAtFound
     473           0 :                     || m_pAddrSpec->m_eLastElem <= ELEMENT_DELIM)
     474           0 :                     m_pAddrSpec->reset();
     475           0 :                 addTokenToAddrSpec(ELEMENT_ITEM);
     476             :             }
     477           0 :             if (!m_bRealNameFinished && m_eState != AFTER_LESS)
     478             :             {
     479           0 :                 if (m_bCurTokenReparse)
     480             :                 {
     481           0 :                     if (!m_pRealNameBegin)
     482           0 :                         m_pRealNameBegin = m_pCurTokenBegin;
     483           0 :                     m_pRealNameEnd = m_pCurTokenEnd;
     484           0 :                     m_bRealNameReparse = true;
     485             :                 }
     486           0 :                 else if (m_bRealNameReparse)
     487           0 :                     m_pRealNameEnd = m_pCurTokenEnd;
     488           0 :                 else if (!m_pRealNameBegin)
     489             :                 {
     490           0 :                     m_pRealNameBegin = m_pCurTokenBegin;
     491           0 :                     m_pRealNameContentBegin = m_pCurTokenContentBegin;
     492           0 :                     m_pRealNameEnd = m_pRealNameContentEnd = m_pCurTokenContentEnd;
     493             :                 }
     494             :                 else
     495             :                 {
     496           0 :                     m_pRealNameEnd = m_pCurTokenEnd;
     497           0 :                     m_bRealNameReparse = true;
     498             :                 }
     499             :             }
     500           0 :             m_eType = TOKEN_ATOM;
     501           0 :             break;
     502             : 
     503             :         case TOKEN_DOMAIN:
     504           0 :             if (m_pAddrSpec->m_eLastElem != ELEMENT_END)
     505             :             {
     506           0 :                 if (m_pAddrSpec->m_bAtFound && m_pAddrSpec->m_eLastElem == ELEMENT_DELIM)
     507           0 :                     addTokenToAddrSpec(ELEMENT_ITEM);
     508             :                 else
     509           0 :                     m_pAddrSpec->reset();
     510             :             }
     511           0 :             addTokenToRealName();
     512           0 :             m_eType = TOKEN_ATOM;
     513           0 :             break;
     514             : 
     515             :         case TOKEN_COMMENT:
     516           0 :             if (!m_bRealNameFinished && m_eState != AFTER_LESS
     517           0 :                 && !m_pFirstCommentBegin && m_pCurTokenContentBegin)
     518             :             {
     519           0 :                 m_pFirstCommentBegin = m_pCurTokenContentBegin;
     520           0 :                 m_pFirstCommentEnd = m_pCurTokenContentEnd;
     521           0 :                 m_bFirstCommentReparse = m_bCurTokenReparse;
     522             :             }
     523           0 :             m_eType = TOKEN_ATOM;
     524           0 :             break;
     525             : 
     526             :         case TOKEN_ATOM:
     527           0 :             if (m_pAddrSpec->m_eLastElem != ELEMENT_END)
     528             :             {
     529           0 :                 if (m_pAddrSpec->m_eLastElem != ELEMENT_DELIM)
     530           0 :                     m_pAddrSpec->reset();
     531           0 :                 addTokenToAddrSpec(ELEMENT_ITEM);
     532             :             }
     533           0 :             addTokenToRealName();
     534           0 :             break;
     535             : 
     536             :         case '(':
     537           0 :             m_eType = TOKEN_COMMENT;
     538           0 :             break;
     539             : 
     540             :         case ')':
     541             :         case '\\':
     542             :         case ']':
     543           0 :             m_pAddrSpec->finish();
     544           0 :             addTokenToRealName();
     545           0 :             break;
     546             : 
     547             :         case '<':
     548           0 :             switch (m_eState)
     549             :             {
     550             :             case BEFORE_COLON:
     551             :             case BEFORE_LESS:
     552           0 :                 m_aOuterAddrSpec.finish();
     553           0 :                 if (m_pRealNameBegin)
     554           0 :                     m_bRealNameFinished = true;
     555           0 :                 m_pAddrSpec = &m_aInnerAddrSpec;
     556           0 :                 m_eState = AFTER_LESS;
     557           0 :                 break;
     558             : 
     559             :             case AFTER_LESS:
     560           0 :                 m_aInnerAddrSpec.finish();
     561           0 :                 break;
     562             : 
     563             :             case AFTER_GREATER:
     564           0 :                 m_aOuterAddrSpec.finish();
     565           0 :                 addTokenToRealName();
     566           0 :                 break;
     567             :             }
     568           0 :             break;
     569             : 
     570             :         case '>':
     571           0 :             if (m_eState == AFTER_LESS)
     572             :             {
     573           0 :                 m_aInnerAddrSpec.finish();
     574           0 :                 if (m_aInnerAddrSpec.isValid())
     575           0 :                     m_aOuterAddrSpec.m_eLastElem = ELEMENT_END;
     576           0 :                 m_pAddrSpec = &m_aOuterAddrSpec;
     577           0 :                 m_eState = AFTER_GREATER;
     578             :             }
     579             :             else
     580             :             {
     581           0 :                 m_aOuterAddrSpec.finish();
     582           0 :                 addTokenToRealName();
     583             :             }
     584           0 :             break;
     585             : 
     586             :         case '@':
     587           0 :             if (m_pAddrSpec->m_eLastElem != ELEMENT_END)
     588             :             {
     589           0 :                 if (!m_pAddrSpec->m_bAtFound
     590           0 :                     && m_pAddrSpec->m_eLastElem == ELEMENT_ITEM)
     591             :                 {
     592           0 :                     addTokenToAddrSpec(ELEMENT_DELIM);
     593           0 :                     m_pAddrSpec->m_bAtFound = true;
     594             :                 }
     595             :                 else
     596           0 :                     m_pAddrSpec->reset();
     597             :             }
     598           0 :             addTokenToRealName();
     599           0 :             break;
     600             : 
     601             :         case ',':
     602             :         case ';':
     603           0 :             if (m_eState == AFTER_LESS)
     604           0 :                 if (m_nCurToken == ',')
     605             :                 {
     606           0 :                     if (m_aInnerAddrSpec.m_eLastElem != ELEMENT_END)
     607           0 :                         m_aInnerAddrSpec.reset();
     608             :                 }
     609             :                 else
     610           0 :                     m_aInnerAddrSpec.finish();
     611             :             else
     612             :             {
     613           0 :                 if(m_aInnerAddrSpec.isValid() || (!m_aOuterAddrSpec.isValid() && m_aInnerAddrSpec.isPoorlyValid()))
     614             :                 {
     615           0 :                     m_pAddrSpec = &m_aInnerAddrSpec;
     616             :                 }
     617           0 :                 else if(m_aOuterAddrSpec.isPoorlyValid())
     618             :                 {
     619           0 :                     m_pAddrSpec = &m_aOuterAddrSpec;
     620             :                 }
     621             :                 else
     622             :                 {
     623           0 :                     m_pAddrSpec = 0;
     624             :                 }
     625             : 
     626           0 :                 if (m_pAddrSpec)
     627             :                 {
     628           0 :                     OUString aTheAddrSpec;
     629           0 :                     if (m_pAddrSpec->m_bReparse)
     630           0 :                         aTheAddrSpec = reparse(m_pAddrSpec->m_pBegin, m_pAddrSpec->m_pEnd, true);
     631             :                     else
     632             :                     {
     633           0 :                         sal_Int32 nLen = ( m_pAddrSpec->m_pEnd - m_pAddrSpec->m_pBegin);
     634           0 :                         if (nLen == rInput.getLength())
     635           0 :                             aTheAddrSpec = rInput;
     636             :                         else
     637           0 :                             aTheAddrSpec = rInput.copy( (m_pAddrSpec->m_pBegin - rInput.getStr()),
     638           0 :                                                         nLen);
     639             :                     }
     640           0 :                     OUString aTheRealName;
     641           0 :                     if (!m_pRealNameBegin ||
     642           0 :                         (m_pAddrSpec == &m_aOuterAddrSpec &&
     643           0 :                          m_pRealNameBegin == m_aOuterAddrSpec.m_pBegin &&
     644           0 :                          m_pRealNameEnd == m_aOuterAddrSpec.m_pEnd &&
     645             :                          m_pFirstCommentBegin))
     646             :                     {
     647           0 :                         if (!m_pFirstCommentBegin)
     648           0 :                             aTheRealName = aTheAddrSpec;
     649           0 :                         else if (m_bFirstCommentReparse)
     650           0 :                             aTheRealName = reparseComment(m_pFirstCommentBegin,
     651           0 :                                                           m_pFirstCommentEnd);
     652             :                         else
     653           0 :                             aTheRealName = rInput.copy( (m_pFirstCommentBegin - rInput.getStr()),
     654           0 :                                                         (m_pFirstCommentEnd - m_pFirstCommentBegin));
     655             :                     }
     656           0 :                     else if (m_bRealNameReparse)
     657           0 :                         aTheRealName = reparse(m_pRealNameBegin, m_pRealNameEnd, false);
     658             :                     else
     659             :                     {
     660           0 :                         sal_Int32 nLen = (m_pRealNameContentEnd - m_pRealNameContentBegin);
     661           0 :                         if (nLen == rInput.getLength())
     662           0 :                             aTheRealName = rInput;
     663             :                         else
     664           0 :                             aTheRealName = rInput.copy( (m_pRealNameContentBegin - rInput.getStr()), nLen);
     665             :                     }
     666           0 :                     if (pParser->m_bHasFirst)
     667             :                         pParser->m_aRest.push_back(new SvAddressEntry_Impl( aTheAddrSpec,
     668           0 :                                                                             aTheRealName) );
     669             :                     else
     670             :                     {
     671           0 :                         pParser->m_bHasFirst = true;
     672           0 :                         pParser->m_aFirst.m_aAddrSpec = aTheAddrSpec;
     673           0 :                         pParser->m_aFirst.m_aRealName = aTheRealName;
     674           0 :                     }
     675             :                 }
     676           0 :                 if (bDone)
     677           0 :                     return;
     678           0 :                 reset();
     679             :             }
     680           0 :             break;
     681             : 
     682             :         case ':':
     683           0 :             switch (m_eState)
     684             :             {
     685             :             case BEFORE_COLON:
     686           0 :                 m_aOuterAddrSpec.reset();
     687           0 :                 resetRealNameAndFirstComment();
     688           0 :                 m_eState = BEFORE_LESS;
     689           0 :                 break;
     690             : 
     691             :             case BEFORE_LESS:
     692             :             case AFTER_GREATER:
     693           0 :                 m_aOuterAddrSpec.finish();
     694           0 :                 addTokenToRealName();
     695           0 :                 break;
     696             : 
     697             :             case AFTER_LESS:
     698           0 :                 m_aInnerAddrSpec.reset();
     699           0 :                 break;
     700             :             }
     701           0 :             break;
     702             : 
     703             :         case '"':
     704           0 :             m_eType = TOKEN_QUOTED;
     705           0 :             break;
     706             : 
     707             :         case '.':
     708           0 :             if (m_pAddrSpec->m_eLastElem != ELEMENT_END)
     709             :             {
     710           0 :                 if (m_pAddrSpec->m_eLastElem != ELEMENT_DELIM)
     711           0 :                     addTokenToAddrSpec(ELEMENT_DELIM);
     712             :                 else
     713           0 :                     m_pAddrSpec->reset();
     714             :             }
     715           0 :             addTokenToRealName();
     716           0 :             break;
     717             : 
     718             :         case '[':
     719           0 :             m_eType = TOKEN_DOMAIN;
     720           0 :             break;
     721             :         }
     722           0 :     }
     723             : }
     724             : 
     725           0 : SvAddressParser::SvAddressParser(const OUString& rInput)
     726           0 :     : m_bHasFirst(false)
     727             : {
     728           0 :     SvAddressParser_Impl aDoParse(this, rInput);
     729           0 : }
     730             : 
     731           0 : SvAddressParser::~SvAddressParser()
     732             : {
     733           0 :     for ( size_t i = m_aRest.size(); i > 0; )
     734           0 :         delete m_aRest[ --i ];
     735           0 :     m_aRest.clear();
     736           0 : }
     737             : 
     738             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10