public static String decodeText()

in geronimo-mail_2.1_spec/src/main/java/jakarta/mail/internet/MimeUtility.java [122:219]
65 lines of code
14 McCabe index (conditional complexity)

    public static String decodeText(final String text) throws UnsupportedEncodingException {
        // if the text contains any encoded tokens, those tokens will be marked with "=?".  If the
        // source string doesn't contain that sequent, no decoding is required.
        if (text.indexOf("=?") < 0) {
            return text;
        }

        // we have two sets of rules we can apply.
        if (!SessionUtil.getBooleanProperty(MIME_DECODE_TEXT_STRICT, true)) {
            return decodeTextNonStrict(text);
        }

        int offset = 0;
        final int endOffset = text.length();

        int startWhiteSpace = -1;
        int endWhiteSpace = -1;

        final StringBuffer decodedText = new StringBuffer(text.length());

        boolean previousTokenEncoded = false;

        while (offset < endOffset) {
            char ch = text.charAt(offset);

            // is this a whitespace character?
            if (linearWhiteSpace.indexOf(ch) != -1) {
                startWhiteSpace = offset;
                while (offset < endOffset) {
                    // step over the white space characters.
                    ch = text.charAt(offset);
                    if (linearWhiteSpace.indexOf(ch) != -1) {
                        offset++;
                    }
                    else {
                        // record the location of the first non lwsp and drop down to process the
                        // token characters.
                        endWhiteSpace = offset;
                        break;
                    }
                }
            }
            else {
                // we have a word token.  We need to scan over the word and then try to parse it.
                final int wordStart = offset;

                while (offset < endOffset) {
                    // step over the white space characters.
                    ch = text.charAt(offset);
                    if (linearWhiteSpace.indexOf(ch) == -1) {
                        offset++;
                    }
                    else {
                        break;
                    }

                    //NB:  Trailing whitespace on these header strings will just be discarded.
                }
                // pull out the word token.
                final String word = text.substring(wordStart, offset);
                // is the token encoded?  decode the word
                if (word.startsWith("=?")) {
                    try {
                        // if this gives a parsing failure, treat it like a non-encoded word.
                        final String decodedWord = decodeWord(word);

                        // are any whitespace characters significant?  Append 'em if we've got 'em.
                        if (!previousTokenEncoded) {
                            if (startWhiteSpace != -1) {
                                decodedText.append(text.substring(startWhiteSpace, endWhiteSpace));
                                startWhiteSpace = -1;
                            }
                        }
                        // this is definitely a decoded token.
                        previousTokenEncoded = true;
                        // and add this to the text.
                        decodedText.append(decodedWord);
                        // we continue parsing from here...we allow parsing errors to fall through
                        // and get handled as normal text.
                        continue;

                    } catch (final ParseException e) {
                    }
                }
                // this is a normal token, so it doesn't matter what the previous token was.  Add the white space
                // if we have it.
                if (startWhiteSpace != -1) {
                    decodedText.append(text.substring(startWhiteSpace, endWhiteSpace));
                    startWhiteSpace = -1;
                }
                // this is not a decoded token.
                previousTokenEncoded = false;
                decodedText.append(word);
            }
        }

        return decodedText.toString();
    }