Quelle InternetCiter.cpp Sprache: C

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "InternetCiter.h"

#include "mozilla/Casting.h"
#include "mozilla/intl/Segmenter.h"
#include "HTMLEditUtils.h"
#include "nsAString.h"
#include "nsCOMPtr.h"
#include "nsCRT.h"
#include "nsDebug.h"
#include "nsDependentSubstring.h"
#include "nsError.h"
#include "nsServiceManagerUtils.h"
#include "nsString.h"
#include "nsStringIterator.h"

namespace mozilla {

/**
* Mail citations using the Internet style: > This is a citation.
*/

void InternetCiter::GetCiteString(const nsAString& aInString,
                                  nsAString& aOutString) {
  aOutString.Truncate();
  char16_t uch = HTMLEditUtils::kNewLine;

  // Strip trailing new lines which will otherwise turn up
  // as ugly quoted empty lines.
  nsReadingIterator<char16_t> beginIter, endIter;
  aInString.BeginReading(beginIter);
  aInString.EndReading(endIter);
  while (beginIter != endIter && (*endIter == HTMLEditUtils::kCarriageReturn ||
                                  *endIter == HTMLEditUtils::kNewLine)) {
    --endIter;
  }

  // Loop over the string:
  while (beginIter != endIter) {
    if (uch == HTMLEditUtils::kNewLine) {
      aOutString.Append(HTMLEditUtils::kGreaterThan);
      // No space between >: this is ">>> " style quoting, for
      // compatibility with RFC 2646 and format=flowed.
      if (*beginIter != HTMLEditUtils::kGreaterThan) {
        aOutString.Append(HTMLEditUtils::kSpace);
      }
    }

    uch = *beginIter;
    ++beginIter;

    aOutString += uch;
  }

  if (uch != HTMLEditUtils::kNewLine) {
    aOutString += HTMLEditUtils::kNewLine;
  }
}

static void AddCite(nsAString& aOutString, int32_t citeLevel) {
  for (int32_t i = 0; i < citeLevel; ++i) {
    aOutString.Append(HTMLEditUtils::kGreaterThan);
  }
  if (citeLevel > 0) {
    aOutString.Append(HTMLEditUtils::kSpace);
  }
}

static inline void BreakLine(nsAString& aOutString, uint32_t& outStringCol,
                             uint32_t citeLevel) {
  aOutString.Append(HTMLEditUtils::kNewLine);
  if (citeLevel > 0) {
    AddCite(aOutString, citeLevel);
    outStringCol = citeLevel + 1;
  } else {
    outStringCol = 0;
  }
}

static inline bool IsSpace(char16_t c) {
  return (nsCRT::IsAsciiSpace(c) || (c == HTMLEditUtils::kNewLine) ||
          (c == HTMLEditUtils::kCarriageReturn) || (c == HTMLEditUtils::kNBSP));
}

void InternetCiter::Rewrap(const nsAString& aInString, uint32_t aWrapCol,
                           uint32_t aFirstLineOffset, bool aRespectNewlines,
                           nsAString& aOutString) {
  // There shouldn't be returns in this string, only dom newlines.
  // Check to make sure:
#ifdef DEBUG
  int32_t crPosition = aInString.FindChar(HTMLEditUtils::kCarriageReturn);
  NS_ASSERTION(crPosition < 0, "Rewrap: CR in string gotten from DOM!\n");
#endif /* DEBUG */

  aOutString.Truncate();

  // Loop over lines in the input string, rewrapping each one.
  uint32_t posInString = 0;
  uint32_t outStringCol = 0;
  uint32_t citeLevel = 0;
  const nsPromiseFlatString& tString = PromiseFlatString(aInString);
  const uint32_t length = tString.Length();
  while (posInString < length) {
    // Get the new cite level here since we're at the beginning of a line
    uint32_t newCiteLevel = 0;
    while (posInString < length &&
           tString[posInString] == HTMLEditUtils::kGreaterThan) {
      ++newCiteLevel;
      ++posInString;
      while (posInString < length &&
             tString[posInString] == HTMLEditUtils::kSpace) {
        ++posInString;
      }
    }
    if (posInString >= length) {
      break;
    }

    // Special case: if this is a blank line, maintain a blank line
    // (retain the original paragraph breaks)
    if (tString[posInString] == HTMLEditUtils::kNewLine &&
        !aOutString.IsEmpty()) {
      if (aOutString.Last() != HTMLEditUtils::kNewLine) {
        aOutString.Append(HTMLEditUtils::kNewLine);
      }
      AddCite(aOutString, newCiteLevel);
      aOutString.Append(HTMLEditUtils::kNewLine);

      ++posInString;
      outStringCol = 0;
      continue;
    }

    // If the cite level has changed, then start a new line with the
    // new cite level (but if we're at the beginning of the string,
    // don't bother).
    if (newCiteLevel != citeLevel && posInString > newCiteLevel + 1 &&
        outStringCol) {
      BreakLine(aOutString, outStringCol, 0);
    }
    citeLevel = newCiteLevel;

    // Prepend the quote level to the out string if appropriate
    if (!outStringCol) {
      AddCite(aOutString, citeLevel);
      outStringCol = citeLevel + (citeLevel ? 1 : 0);
    }
    // If it's not a cite, and we're not at the beginning of a line in
    // the output string, add a space to separate new text from the
    // previous text.
    else if (outStringCol > citeLevel) {
      aOutString.Append(HTMLEditUtils::kSpace);
      ++outStringCol;
    }

    // find the next newline -- don't want to go farther than that
    int32_t nextNewline =
        tString.FindChar(HTMLEditUtils::kNewLine, posInString);
    if (nextNewline < 0) {
      nextNewline = length;
    }

    // For now, don't wrap unquoted lines at all.
    // This is because the plaintext edit window has already wrapped them
    // by the time we get them for rewrap, yet when we call the line
    // breaker, it will refuse to break backwards, and we'll end up
    // with a line that's too long and gets displayed as a lone word
    // on a line by itself.  Need special logic to detect this case
    // and break it ourselves without resorting to the line breaker.
    if (!citeLevel) {
      aOutString.Append(
          Substring(tString, posInString, nextNewline - posInString));
      outStringCol += nextNewline - posInString;
      if (nextNewline != (int32_t)length) {
        aOutString.Append(HTMLEditUtils::kNewLine);
        outStringCol = 0;
      }
      posInString = nextNewline + 1;
      continue;
    }

    // Otherwise we have to use the line breaker and loop
    // over this line of the input string to get all of it:
    while ((int32_t)posInString < nextNewline) {
      // Skip over initial spaces:
      while ((int32_t)posInString < nextNewline &&
             nsCRT::IsAsciiSpace(tString[posInString])) {
        ++posInString;
      }

      // If this is a short line, just append it and continue:
      if (outStringCol + nextNewline - posInString <=
          aWrapCol - citeLevel - 1) {
        // If this short line is the final one in the in string,
        // then we need to include the final newline, if any:
        if (nextNewline + 1 == (int32_t)length &&
            tString[nextNewline - 1] == HTMLEditUtils::kNewLine) {
          ++nextNewline;
        }
        // Trim trailing spaces:
        int32_t lastRealChar = nextNewline;
        while ((uint32_t)lastRealChar > posInString &&
               nsCRT::IsAsciiSpace(tString[lastRealChar - 1])) {
          --lastRealChar;
        }

        aOutString +=
            Substring(tString, posInString, lastRealChar - posInString);
        outStringCol += lastRealChar - posInString;
        posInString = nextNewline + 1;
        continue;
      }

      int32_t eol = posInString + aWrapCol - citeLevel - outStringCol;
      // eol is the prospective end of line.
      // If it's already less than our current position,
      // then our line is already too long, so break now.
      if (eol <= (int32_t)posInString) {
        BreakLine(aOutString, outStringCol, citeLevel);
        continue;  // continue inner loop, with outStringCol now at bol
      }

      MOZ_ASSERT(eol >= 0 && eol - posInString > 0);

      uint32_t breakPt = 0;
      Maybe<uint32_t> nextBreakPt;
      intl::LineBreakIteratorUtf16 lineBreakIter(Span<const char16_t>(
          tString.get() + posInString, length - posInString));
      while (true) {
        nextBreakPt = lineBreakIter.Next();
        if (!nextBreakPt ||
            *nextBreakPt > AssertedCast<uint32_t>(eol) - posInString) {
          break;
        }
        breakPt = *nextBreakPt;
      }

      if (breakPt == 0) {
        // If we couldn't find a breakpoint within the eol upper bound, and
        // we're not starting a new line, then end this line and loop around
        // again:
        if (outStringCol > citeLevel + 1) {
          BreakLine(aOutString, outStringCol, citeLevel);
          continue;  // continue inner loop, with outStringCol now at bol
        }

        MOZ_ASSERT(nextBreakPt.isSome(),
                   "Next() always treats end-of-text as a break");
        breakPt = *nextBreakPt;
      }

      // Special case: maybe we should have wrapped last time.
      // If the first breakpoint here makes the current line too long,
      // then if we already have text on the current line,
      // break and loop around again.
      // If we're at the beginning of the current line, though,
      // don't force a break since the long word might be a url
      // and breaking it would make it unclickable on the other end.
      const int SLOP = 6;
      if (outStringCol + breakPt > aWrapCol + SLOP &&
          outStringCol > citeLevel + 1) {
        BreakLine(aOutString, outStringCol, citeLevel);
        continue;
      }

      nsAutoString sub(Substring(tString, posInString, breakPt));
      // skip newlines or white-space at the end of the string
      int32_t subend = sub.Length();
      while (subend > 0 && IsSpace(sub[subend - 1])) {
        --subend;
      }
      sub.Left(sub, subend);
      aOutString += sub;
      outStringCol += sub.Length();
      // Advance past the white-space which caused the wrap:
      posInString += breakPt;
      while (posInString < length && IsSpace(tString[posInString])) {
        ++posInString;
      }

      // Add a newline and the quote level to the out string
      if (posInString < length) {  // not for the last line, though
        BreakLine(aOutString, outStringCol, citeLevel);
      }
    }  // end inner loop within one line of aInString
  }  // end outer loop over lines of aInString
}

}  // namespace mozilla

quality64%

¤ Dauer der Verarbeitung: 0.30 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.