xref: /trunk/main/svl/source/misc/adrparse.cxx (revision 1ecadb572e7010ff3b3382ad9bf179dbc6efadbb) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_svl.hxx"
30 #include <tools/inetmime.hxx>
31 #include <svl/adrparse.hxx>
32 
33 namespace unnamed_svl_adrparse {}
34 using namespace unnamed_svl_adrparse;
35     // unnamed namespaces don't work well yet
36 
37 //============================================================================
38 namespace unnamed_svl_adrparse {
39 
40 enum ElementType { ELEMENT_START, ELEMENT_DELIM, ELEMENT_ITEM, ELEMENT_END };
41 
42 //============================================================================
43 struct ParsedAddrSpec
44 {
45     sal_Unicode const * m_pBegin;
46     sal_Unicode const * m_pEnd;
47     ElementType m_eLastElem;
48     bool m_bAtFound;
49     bool m_bReparse;
50 
51     ParsedAddrSpec() { reset(); }
52 
53     bool isPoorlyValid() const { return m_eLastElem >= ELEMENT_ITEM; }
54 
55     bool isValid() const { return isPoorlyValid() && m_bAtFound; }
56 
57     inline void reset();
58 
59     inline void finish();
60 };
61 
62 inline void ParsedAddrSpec::reset()
63 {
64     m_pBegin = 0;
65     m_pEnd = 0;
66     m_eLastElem = ELEMENT_START;
67     m_bAtFound = false;
68     m_bReparse = false;
69 }
70 
71 inline void ParsedAddrSpec::finish()
72 {
73     if (isPoorlyValid())
74         m_eLastElem = ELEMENT_END;
75     else
76         reset();
77 }
78 
79 }
80 
81 //============================================================================
82 class SvAddressParser_Impl
83 {
84     enum State { BEFORE_COLON, BEFORE_LESS, AFTER_LESS, AFTER_GREATER };
85 
86     enum TokenType { TOKEN_QUOTED = 0x80000000, TOKEN_DOMAIN, TOKEN_COMMENT,
87                      TOKEN_ATOM };
88 
89     sal_Unicode const * m_pInputPos;
90     sal_Unicode const * m_pInputEnd;
91     sal_uInt32 m_nCurToken;
92     sal_Unicode const * m_pCurTokenBegin;
93     sal_Unicode const * m_pCurTokenEnd;
94     sal_Unicode const * m_pCurTokenContentBegin;
95     sal_Unicode const * m_pCurTokenContentEnd;
96     bool m_bCurTokenReparse;
97     ParsedAddrSpec m_aOuterAddrSpec;
98     ParsedAddrSpec m_aInnerAddrSpec;
99     ParsedAddrSpec * m_pAddrSpec;
100     sal_Unicode const * m_pRealNameBegin;
101     sal_Unicode const * m_pRealNameEnd;
102     sal_Unicode const * m_pRealNameContentBegin;
103     sal_Unicode const * m_pRealNameContentEnd;
104     bool m_bRealNameReparse;
105     bool m_bRealNameFinished;
106     sal_Unicode const * m_pFirstCommentBegin;
107     sal_Unicode const * m_pFirstCommentEnd;
108     bool m_bFirstCommentReparse;
109     State m_eState;
110     TokenType m_eType;
111 
112     inline void resetRealNameAndFirstComment();
113 
114     inline void reset();
115 
116     inline void addTokenToAddrSpec(ElementType eTokenElem);
117 
118     inline void addTokenToRealName();
119 
120     bool readToken();
121 
122     static UniString reparse(sal_Unicode const * pBegin,
123                              sal_Unicode const * pEnd, bool bAddrSpec);
124 
125     static UniString reparseComment(sal_Unicode const * pBegin,
126                                     sal_Unicode const * pEnd);
127 
128 public:
129     SvAddressParser_Impl(SvAddressParser * pParser, UniString const & rInput);
130 };
131 
132 inline void SvAddressParser_Impl::resetRealNameAndFirstComment()
133 {
134     m_pRealNameBegin = 0;
135     m_pRealNameEnd = 0;
136     m_pRealNameContentBegin = 0;
137     m_pRealNameContentEnd = 0;
138     m_bRealNameReparse = false;
139     m_bRealNameFinished = false;
140     m_pFirstCommentBegin = 0;
141     m_pFirstCommentEnd = 0;
142     m_bFirstCommentReparse = false;
143 }
144 
145 inline void SvAddressParser_Impl::reset()
146 {
147     m_aOuterAddrSpec.reset();
148     m_aInnerAddrSpec.reset();
149     m_pAddrSpec = &m_aOuterAddrSpec;
150     resetRealNameAndFirstComment();
151     m_eState = BEFORE_COLON;
152     m_eType = TOKEN_ATOM;
153 }
154 
155 inline void SvAddressParser_Impl::addTokenToAddrSpec(ElementType eTokenElem)
156 {
157     if (!m_pAddrSpec->m_pBegin)
158         m_pAddrSpec->m_pBegin = m_pCurTokenBegin;
159     else if (m_pAddrSpec->m_pEnd < m_pCurTokenBegin)
160         m_pAddrSpec->m_bReparse = true;
161     m_pAddrSpec->m_pEnd = m_pCurTokenEnd;
162     m_pAddrSpec->m_eLastElem = eTokenElem;
163 }
164 
165 inline void SvAddressParser_Impl::addTokenToRealName()
166 {
167     if (!m_bRealNameFinished && m_eState != AFTER_LESS)
168     {
169         if (!m_pRealNameBegin)
170             m_pRealNameBegin = m_pRealNameContentBegin = m_pCurTokenBegin;
171         else if (m_pRealNameEnd < m_pCurTokenBegin - 1
172                  || (m_pRealNameEnd == m_pCurTokenBegin - 1
173                     && *m_pRealNameEnd != ' '))
174             m_bRealNameReparse = true;
175         m_pRealNameEnd = m_pRealNameContentEnd = m_pCurTokenEnd;
176     }
177 }
178 
179 //============================================================================
180 //
181 //  SvAddressParser_Impl
182 //
183 //============================================================================
184 
185 bool SvAddressParser_Impl::readToken()
186 {
187     m_nCurToken = m_eType;
188     m_bCurTokenReparse = false;
189     switch (m_eType)
190     {
191         case TOKEN_QUOTED:
192         {
193             m_pCurTokenBegin = m_pInputPos - 1;
194             m_pCurTokenContentBegin = m_pInputPos;
195             bool bEscaped = false;
196             for (;;)
197             {
198                 if (m_pInputPos >= m_pInputEnd)
199                     return false;
200                 sal_Unicode cChar = *m_pInputPos++;
201                 if (bEscaped)
202                 {
203                     m_bCurTokenReparse = true;
204                     bEscaped = false;
205                 }
206                 else if (cChar == '"')
207                 {
208                     m_pCurTokenEnd = m_pInputPos;
209                     m_pCurTokenContentEnd = m_pInputPos - 1;
210                     return true;
211                 }
212                 else if (cChar == '\\')
213                     bEscaped = true;
214             }
215         }
216 
217         case TOKEN_DOMAIN:
218         {
219             m_pCurTokenBegin = m_pInputPos - 1;
220             m_pCurTokenContentBegin = m_pInputPos;
221             bool bEscaped = false;
222             for (;;)
223             {
224                 if (m_pInputPos >= m_pInputEnd)
225                     return false;
226                 sal_Unicode cChar = *m_pInputPos++;
227                 if (bEscaped)
228                     bEscaped = false;
229                 else if (cChar == ']')
230                 {
231                     m_pCurTokenEnd = m_pInputPos;
232                     return true;
233                 }
234                 else if (cChar == '\\')
235                     bEscaped = true;
236             }
237         }
238 
239         case TOKEN_COMMENT:
240         {
241             m_pCurTokenBegin = m_pInputPos - 1;
242             m_pCurTokenContentBegin = 0;
243             m_pCurTokenContentEnd = 0;
244             bool bEscaped = false;
245             xub_StrLen nLevel = 0;
246             for (;;)
247             {
248                 if (m_pInputPos >= m_pInputEnd)
249                     return false;
250                 sal_Unicode cChar = *m_pInputPos++;
251                 if (bEscaped)
252                 {
253                     m_bCurTokenReparse = true;
254                     m_pCurTokenContentEnd = m_pInputPos;
255                     bEscaped = false;
256                 }
257                 else if (cChar == '(')
258                 {
259                     if (!m_pCurTokenContentBegin)
260                         m_pCurTokenContentBegin = m_pInputPos - 1;
261                     m_pCurTokenContentEnd = m_pInputPos;
262                     ++nLevel;
263                 }
264                 else if (cChar == ')')
265                     if (nLevel)
266                     {
267                         m_pCurTokenContentEnd = m_pInputPos;
268                         --nLevel;
269                     }
270                     else
271                         return true;
272                 else if (cChar == '\\')
273                 {
274                     if (!m_pCurTokenContentBegin)
275                         m_pCurTokenContentBegin = m_pInputPos - 1;
276                     bEscaped = true;
277                 }
278                 else if (cChar > ' ' && cChar != 0x7F) // DEL
279                 {
280                     if (!m_pCurTokenContentBegin)
281                         m_pCurTokenContentBegin = m_pInputPos - 1;
282                     m_pCurTokenContentEnd = m_pInputPos;
283                 }
284             }
285         }
286 
287         default:
288         {
289             sal_Unicode cChar;
290             for (;;)
291             {
292                 if (m_pInputPos >= m_pInputEnd)
293                     return false;
294                 cChar = *m_pInputPos++;
295                 if (cChar > ' ' && cChar != 0x7F) // DEL
296                     break;
297             }
298             m_pCurTokenBegin = m_pInputPos - 1;
299             if (cChar == '"' || cChar == '(' || cChar == ')' || cChar == ','
300                 || cChar == '.' || cChar == ':' || cChar == ';'
301                 || cChar == '<' || cChar == '>' || cChar == '@'
302                 || cChar == '[' || cChar == '\\' || cChar == ']')
303             {
304                 m_nCurToken = cChar;
305                 m_pCurTokenEnd = m_pInputPos;
306                 return true;
307             }
308             else
309                 for (;;)
310                 {
311                     if (m_pInputPos >= m_pInputEnd)
312                     {
313                         m_pCurTokenEnd = m_pInputPos;
314                         return true;
315                     }
316                     cChar = *m_pInputPos++;
317                     if (cChar <= ' ' || cChar == '"' || cChar == '('
318                         || cChar == ')' || cChar == ',' || cChar == '.'
319                         || cChar == ':' || cChar == ';' || cChar == '<'
320                         || cChar == '>' || cChar == '@' || cChar == '['
321                         || cChar == '\\' || cChar == ']'
322                         || cChar == 0x7F) // DEL
323                     {
324                         m_pCurTokenEnd = --m_pInputPos;
325                         return true;
326                     }
327                 }
328         }
329     }
330 }
331 
332 //============================================================================
333 // static
334 UniString SvAddressParser_Impl::reparse(sal_Unicode const * pBegin,
335                                         sal_Unicode const * pEnd,
336                                         bool bAddrSpec)
337 {
338     UniString aResult;
339     TokenType eMode = TOKEN_ATOM;
340     bool bEscaped = false;
341     bool bEndsWithSpace = false;
342     xub_StrLen nLevel = 0;
343     while (pBegin < pEnd)
344     {
345         sal_Unicode cChar = *pBegin++;
346         switch (eMode)
347         {
348             case TOKEN_QUOTED:
349                 if (bEscaped)
350                 {
351                     aResult += cChar;
352                     bEscaped = false;
353                 }
354                 else if (cChar == '"')
355                 {
356                     if (bAddrSpec)
357                         aResult += cChar;
358                     eMode = TOKEN_ATOM;
359                 }
360                 else if (cChar == '\\')
361                 {
362                     if (bAddrSpec)
363                         aResult += cChar;
364                     bEscaped = true;
365                 }
366                 else
367                     aResult += cChar;
368                 break;
369 
370             case TOKEN_DOMAIN:
371                 if (bEscaped)
372                 {
373                     aResult += cChar;
374                     bEscaped = false;
375                 }
376                 else if (cChar == ']')
377                 {
378                     aResult += cChar;
379                     eMode = TOKEN_ATOM;
380                 }
381                 else if (cChar == '\\')
382                 {
383                     if (bAddrSpec)
384                         aResult += cChar;
385                     bEscaped = true;
386                 }
387                 else
388                     aResult += cChar;
389                 break;
390 
391             case TOKEN_COMMENT:
392                 if (bEscaped)
393                     bEscaped = false;
394                 else if (cChar == '(')
395                     ++nLevel;
396                 else if (cChar == ')')
397                     if (nLevel)
398                         --nLevel;
399                     else
400                         eMode = TOKEN_ATOM;
401                 else if (cChar == '\\')
402                     bEscaped = true;
403                 break;
404 
405             case TOKEN_ATOM:
406                 if (cChar <= ' ' || cChar == 0x7F) // DEL
407                 {
408                     if (!bAddrSpec && !bEndsWithSpace)
409                     {
410                         aResult += ' ';
411                         bEndsWithSpace = true;
412                     }
413                 }
414                 else if (cChar == '(')
415                 {
416                     if (!bAddrSpec && !bEndsWithSpace)
417                     {
418                         aResult += ' ';
419                         bEndsWithSpace = true;
420                     }
421                     eMode = TOKEN_COMMENT;
422                 }
423                 else
424                 {
425                     bEndsWithSpace = false;
426                     if (cChar == '"')
427                     {
428                         if (bAddrSpec)
429                             aResult += cChar;
430                         eMode = TOKEN_QUOTED;
431                     }
432                     else if (cChar == '[')
433                     {
434                         aResult += cChar;
435                         eMode = TOKEN_QUOTED;
436                     }
437                     else
438                         aResult += cChar;
439                 }
440                 break;
441         }
442     }
443     return aResult;
444 }
445 
446 //============================================================================
447 // static
448 UniString SvAddressParser_Impl::reparseComment(sal_Unicode const * pBegin,
449                                                sal_Unicode const * pEnd)
450 {
451     UniString aResult;
452     while (pBegin < pEnd)
453     {
454         sal_Unicode cChar = *pBegin++;
455         if (cChar == '\\')
456             cChar = *pBegin++;
457         aResult += cChar;
458     }
459     return aResult;
460 }
461 
462 //============================================================================
463 SvAddressParser_Impl::SvAddressParser_Impl(SvAddressParser * pParser,
464                                            UniString const & rInput)
465 {
466     m_pInputPos = rInput.GetBuffer();
467     m_pInputEnd = m_pInputPos + rInput.Len();
468 
469     reset();
470     bool bDone = false;
471     for (;;)
472     {
473         if (!readToken())
474         {
475             m_bRealNameFinished = true;
476             if (m_eState == AFTER_LESS)
477                 m_nCurToken = '>';
478             else
479             {
480                 m_nCurToken = ',';
481                 bDone = true;
482             }
483         }
484         switch (m_nCurToken)
485         {
486             case TOKEN_QUOTED:
487                 if (m_pAddrSpec->m_eLastElem != ELEMENT_END)
488                 {
489                     if (m_pAddrSpec->m_bAtFound
490                         || m_pAddrSpec->m_eLastElem <= ELEMENT_DELIM)
491                         m_pAddrSpec->reset();
492                     addTokenToAddrSpec(ELEMENT_ITEM);
493                 }
494                 if (!m_bRealNameFinished && m_eState != AFTER_LESS)
495                 {
496                     if (m_bCurTokenReparse)
497                     {
498                         if (!m_pRealNameBegin)
499                             m_pRealNameBegin = m_pCurTokenBegin;
500                         m_pRealNameEnd = m_pCurTokenEnd;
501                         m_bRealNameReparse = true;
502                     }
503                     else if (m_bRealNameReparse)
504                         m_pRealNameEnd = m_pCurTokenEnd;
505                     else if (!m_pRealNameBegin)
506                     {
507                         m_pRealNameBegin = m_pCurTokenBegin;
508                         m_pRealNameContentBegin = m_pCurTokenContentBegin;
509                         m_pRealNameEnd = m_pRealNameContentEnd
510                             = m_pCurTokenContentEnd;
511                     }
512                     else
513                     {
514                         m_pRealNameEnd = m_pCurTokenEnd;
515                         m_bRealNameReparse = true;
516                     }
517                 }
518                 m_eType = TOKEN_ATOM;
519                 break;
520 
521             case TOKEN_DOMAIN:
522                 if (m_pAddrSpec->m_eLastElem != ELEMENT_END)
523                 {
524                     if (m_pAddrSpec->m_bAtFound
525                         && m_pAddrSpec->m_eLastElem == ELEMENT_DELIM)
526                         addTokenToAddrSpec(ELEMENT_ITEM);
527                     else
528                         m_pAddrSpec->reset();
529                 }
530                 addTokenToRealName();
531                 m_eType = TOKEN_ATOM;
532                 break;
533 
534             case TOKEN_COMMENT:
535                 if (!m_bRealNameFinished && m_eState != AFTER_LESS
536                     && !m_pFirstCommentBegin && m_pCurTokenContentBegin)
537                 {
538                     m_pFirstCommentBegin = m_pCurTokenContentBegin;
539                     m_pFirstCommentEnd = m_pCurTokenContentEnd;
540                     m_bFirstCommentReparse = m_bCurTokenReparse;
541                 }
542                 m_eType = TOKEN_ATOM;
543                 break;
544 
545             case TOKEN_ATOM:
546                 if (m_pAddrSpec->m_eLastElem != ELEMENT_END)
547                 {
548                     if (m_pAddrSpec->m_eLastElem != ELEMENT_DELIM)
549                         m_pAddrSpec->reset();
550                     addTokenToAddrSpec(ELEMENT_ITEM);
551                 }
552                 addTokenToRealName();
553                 break;
554 
555             case '(':
556                 m_eType = TOKEN_COMMENT;
557                 break;
558 
559             case ')':
560             case '\\':
561             case ']':
562                 m_pAddrSpec->finish();
563                 addTokenToRealName();
564                 break;
565 
566             case '<':
567                 switch (m_eState)
568                 {
569                     case BEFORE_COLON:
570                     case BEFORE_LESS:
571                         m_aOuterAddrSpec.finish();
572                         if (m_pRealNameBegin)
573                             m_bRealNameFinished = true;
574                         m_pAddrSpec = &m_aInnerAddrSpec;
575                         m_eState = AFTER_LESS;
576                         break;
577 
578                     case AFTER_LESS:
579                         m_aInnerAddrSpec.finish();
580                         break;
581 
582                     case AFTER_GREATER:
583                         m_aOuterAddrSpec.finish();
584                         addTokenToRealName();
585                         break;
586                 }
587                 break;
588 
589             case '>':
590                 if (m_eState == AFTER_LESS)
591                 {
592                     m_aInnerAddrSpec.finish();
593                     if (m_aInnerAddrSpec.isValid())
594                         m_aOuterAddrSpec.m_eLastElem = ELEMENT_END;
595                     m_pAddrSpec = &m_aOuterAddrSpec;
596                     m_eState = AFTER_GREATER;
597                 }
598                 else
599                 {
600                     m_aOuterAddrSpec.finish();
601                     addTokenToRealName();
602                 }
603                 break;
604 
605             case '@':
606                 if (m_pAddrSpec->m_eLastElem != ELEMENT_END)
607                 {
608                     if (!m_pAddrSpec->m_bAtFound
609                         && m_pAddrSpec->m_eLastElem == ELEMENT_ITEM)
610                     {
611                         addTokenToAddrSpec(ELEMENT_DELIM);
612                         m_pAddrSpec->m_bAtFound = true;
613                     }
614                     else
615                         m_pAddrSpec->reset();
616                 }
617                 addTokenToRealName();
618                 break;
619 
620             case ',':
621             case ';':
622                 if (m_eState == AFTER_LESS)
623                     if (m_nCurToken == ',')
624                     {
625                         if (m_aInnerAddrSpec.m_eLastElem
626                              != ELEMENT_END)
627                             m_aInnerAddrSpec.reset();
628                     }
629                     else
630                         m_aInnerAddrSpec.finish();
631                 else
632                 {
633                     m_pAddrSpec = m_aInnerAddrSpec.isValid()
634                                   || (!m_aOuterAddrSpec.isValid()
635                                          && m_aInnerAddrSpec.isPoorlyValid()) ?
636                                       &m_aInnerAddrSpec :
637                                   m_aOuterAddrSpec.isPoorlyValid() ?
638                                       &m_aOuterAddrSpec : 0;
639                     if (m_pAddrSpec)
640                     {
641                         UniString aTheAddrSpec;
642                         if (m_pAddrSpec->m_bReparse)
643                             aTheAddrSpec = reparse(m_pAddrSpec->m_pBegin,
644                                                    m_pAddrSpec->m_pEnd, true);
645                         else
646                         {
647                             xub_StrLen nLen =
648                                 sal::static_int_cast< xub_StrLen >(
649                                     m_pAddrSpec->m_pEnd
650                                     - m_pAddrSpec->m_pBegin);
651                             if (nLen == rInput.Len())
652                                 aTheAddrSpec = rInput;
653                             else
654                                 aTheAddrSpec
655                                     = rInput.Copy(
656                                         sal::static_int_cast< xub_StrLen >(
657                                             m_pAddrSpec->m_pBegin
658                                             - rInput.GetBuffer()),
659                                         nLen);
660                         }
661                         UniString aTheRealName;
662                         if (!m_pRealNameBegin
663                             || (m_pAddrSpec == &m_aOuterAddrSpec
664                                && m_pRealNameBegin
665                                       == m_aOuterAddrSpec.m_pBegin
666                                && m_pRealNameEnd == m_aOuterAddrSpec.m_pEnd
667                                && m_pFirstCommentBegin))
668                             if (!m_pFirstCommentBegin)
669                                 aTheRealName = aTheAddrSpec;
670                             else if (m_bFirstCommentReparse)
671                                 aTheRealName
672                                     = reparseComment(m_pFirstCommentBegin,
673                                                      m_pFirstCommentEnd);
674                             else
675                                 aTheRealName
676                                     = rInput.Copy(
677                                         sal::static_int_cast< xub_StrLen >(
678                                             m_pFirstCommentBegin
679                                             - rInput.GetBuffer()),
680                                         sal::static_int_cast< xub_StrLen >(
681                                             m_pFirstCommentEnd
682                                             - m_pFirstCommentBegin));
683                         else if (m_bRealNameReparse)
684                             aTheRealName = reparse(m_pRealNameBegin,
685                                                    m_pRealNameEnd, false);
686                         else
687                         {
688                             xub_StrLen nLen =
689                                 sal::static_int_cast< xub_StrLen >(
690                                     m_pRealNameContentEnd
691                                     - m_pRealNameContentBegin);
692                             if (nLen == rInput.Len())
693                                 aTheRealName = rInput;
694                             else
695                                 aTheRealName
696                                     = rInput.Copy(
697                                         sal::static_int_cast< xub_StrLen >(
698                                             m_pRealNameContentBegin
699                                             - rInput.GetBuffer()),
700                                         nLen);
701                         }
702                         if (pParser->m_bHasFirst)
703                             pParser->m_aRest.Insert(new SvAddressEntry_Impl(
704                                                             aTheAddrSpec,
705                                                             aTheRealName),
706                                                     LIST_APPEND);
707                         else
708                         {
709                             pParser->m_bHasFirst = true;
710                             pParser->m_aFirst.m_aAddrSpec = aTheAddrSpec;
711                             pParser->m_aFirst.m_aRealName = aTheRealName;
712                         }
713                     }
714                     if (bDone)
715                         return;
716                     reset();
717                 }
718                 break;
719 
720             case ':':
721                 switch (m_eState)
722                 {
723                     case BEFORE_COLON:
724                         m_aOuterAddrSpec.reset();
725                         resetRealNameAndFirstComment();
726                         m_eState = BEFORE_LESS;
727                         break;
728 
729                     case BEFORE_LESS:
730                     case AFTER_GREATER:
731                         m_aOuterAddrSpec.finish();
732                         addTokenToRealName();
733                         break;
734 
735                     case AFTER_LESS:
736                         m_aInnerAddrSpec.reset();
737                         break;
738                 }
739                 break;
740 
741             case '"':
742                 m_eType = TOKEN_QUOTED;
743                 break;
744 
745             case '.':
746                 if (m_pAddrSpec->m_eLastElem != ELEMENT_END)
747                 {
748                     if (m_pAddrSpec->m_eLastElem != ELEMENT_DELIM)
749                         addTokenToAddrSpec(ELEMENT_DELIM);
750                     else
751                         m_pAddrSpec->reset();
752                 }
753                 addTokenToRealName();
754                 break;
755 
756             case '[':
757                 m_eType = TOKEN_DOMAIN;
758                 break;
759         }
760     }
761 }
762 
763 //============================================================================
764 //
765 //  SvAddressParser
766 //
767 //============================================================================
768 
769 SvAddressParser::SvAddressParser(UniString const & rInput): m_bHasFirst(false)
770 {
771     SvAddressParser_Impl(this, rInput);
772 }
773 
774 //============================================================================
775 SvAddressParser::~SvAddressParser()
776 {
777     for (sal_uLong i = m_aRest.Count(); i != 0;)
778         delete m_aRest.Remove(--i);
779 }
780 
781 //============================================================================
782 // static
783 bool SvAddressParser::createRFC822Mailbox(String const & rPhrase,
784                                           String const & rAddrSpec,
785                                           String & rMailbox)
786 {
787     String aTheAddrSpec;
788     sal_Unicode const * p = rAddrSpec.GetBuffer();
789     sal_Unicode const * pEnd = p + rAddrSpec.Len();
790     {for (bool bSegment = false;;)
791     {
792         p = INetMIME::skipLinearWhiteSpaceComment(p, pEnd);
793         if (p == pEnd)
794             return false;
795         if (bSegment)
796         {
797             sal_Unicode c = *p++;
798             if (c == '@')
799                 break;
800             else if (c != '.')
801                 return false;
802             aTheAddrSpec += '.';
803             p = INetMIME::skipLinearWhiteSpaceComment(p, pEnd);
804             if (p == pEnd)
805                 return false;
806         }
807         else
808             bSegment = true;
809         if (*p == '"')
810         {
811             aTheAddrSpec += *p++;
812             for (;;)
813             {
814                 if (INetMIME::startsWithLineFolding(p, pEnd))
815                     p += 2;
816                 if (p == pEnd)
817                     return false;
818                 if (*p == '"')
819                     break;
820                 if (*p == '\x0D' || (*p == '\\' && ++p == pEnd)
821                     || !INetMIME::isUSASCII(*p))
822                     return false;
823                 if (INetMIME::needsQuotedStringEscape(*p))
824                     aTheAddrSpec += '\\';
825                 aTheAddrSpec += *p++;
826             }
827             aTheAddrSpec += *p++;
828         }
829         else if (INetMIME::isAtomChar(*p))
830             while (p != pEnd && INetMIME::isAtomChar(*p))
831                 aTheAddrSpec += *p++;
832         else
833             return false;
834     }}
835     aTheAddrSpec += '@';
836     {for (bool bSegment = false;;)
837     {
838         p = INetMIME::skipLinearWhiteSpaceComment(p, pEnd);
839         if (p == pEnd)
840         {
841             if (bSegment)
842                 break;
843             else
844                 return false;
845         }
846         if (bSegment)
847         {
848             if (*p++ != '.')
849                 return false;
850             aTheAddrSpec += '.';
851             p = INetMIME::skipLinearWhiteSpaceComment(p, pEnd);
852             if (p == pEnd)
853                 return false;
854         }
855         else
856             bSegment = true;
857         if (*p == '[')
858         {
859             aTheAddrSpec += *p++;
860             for (;;)
861             {
862                 if (INetMIME::startsWithLineFolding(p, pEnd))
863                     p += 2;
864                 if (p == pEnd)
865                     return false;
866                 if (*p == ']')
867                     break;
868                 if (*p == '\x0D' || *p == '[' || (*p == '\\' && ++p == pEnd)
869                     || !INetMIME::isUSASCII(*p))
870                     return false;
871                 if (*p >= '[' && *p <= ']')
872                     aTheAddrSpec += '\\';
873                 aTheAddrSpec += *p++;
874             }
875             aTheAddrSpec += *p++;
876         }
877         else if (INetMIME::isAtomChar(*p))
878             while (p != pEnd && INetMIME::isAtomChar(*p))
879                 aTheAddrSpec += *p++;
880         else
881             return false;
882     }}
883 
884     if (rPhrase.Len() == 0)
885         rMailbox = aTheAddrSpec;
886     else
887     {
888         bool bQuotedString = false;
889         p = rPhrase.GetBuffer();
890         pEnd = p + rPhrase.Len();
891         for (;p != pEnd; ++p)
892             if (!(INetMIME::isAtomChar(*p)))
893             {
894                 bQuotedString = true;
895                 break;
896             }
897         String aTheMailbox;
898         if (bQuotedString)
899         {
900             aTheMailbox = '"';
901             for (p = rPhrase.GetBuffer(); p != pEnd; ++p)
902             {
903                 if (INetMIME::needsQuotedStringEscape(*p))
904                     aTheMailbox += '\\';
905                 aTheMailbox += *p;
906             }
907             aTheMailbox += '"';
908         }
909         else
910             aTheMailbox = rPhrase;
911         aTheMailbox.AppendAscii(RTL_CONSTASCII_STRINGPARAM(" <"));
912         aTheMailbox += aTheAddrSpec;
913         aTheMailbox += '>';
914         rMailbox = aTheMailbox;
915     }
916     return true;
917 }
918 
919