#include "MarkupParser.hpp"
#include <Gosu/Utility.hpp>
#include "utf8proc.h"
#include <cstring>
using namespace std;
// Helper method for allowing CJK text to have line breaks in the absence of whitespace.
static bool should_allow_break_after_codepoint(utf8proc_int32_t cp)
{
return (cp >= 0x3040 && cp <= 0x3096) || // Hiragana
(cp >= 0x30a0 && cp <= 0x30fa) || // Katakana
(cp >= 0x4e00 && cp <= 0x9fff) || // CJK Unified Ideographs
(cp >= 0x3400 && cp <= 0x4db5) || // CJK Unified Ideographs Extension A
(cp >= 0xac00 && cp <= 0xd7af); // Precomposed Hangul syllables
}
unsigned Gosu::MarkupParser::flags() const
{
unsigned flags = 0;
if (b > 0) flags |= Gosu::FF_BOLD;
if (i > 0) flags |= Gosu::FF_ITALIC;
if (u > 0) flags |= Gosu::FF_UNDERLINE;
return flags;
}
bool Gosu::MarkupParser::match_and_skip(const char* chars, size_t length)
{
if (strncmp(markup, chars, length) != 0) return false;
// Finish building the current substring (if any) before matching.
add_current_substring();
// Skip chars.
markup += length;
return true;
}
bool Gosu::MarkupParser::parse_markup()
{
// Open and close bold text spans.
if (match_and_skip("<b>")) {
b += 1;
return true;
}
if (match_and_skip("</b>")) {
b -= 1;
return true;
}
// Open and close underlined text spans.
if (match_and_skip("<u>")) {
u += 1;
return true;
}
if (match_and_skip("</u>")) {
u -= 1;
return true;
}
// Open and close italic text spans.
if (match_and_skip("<i>")) {
i += 1;
return true;
}
if (match_and_skip("</i>")) {
i -= 1;
return true;
}
// Reset to previous color.
if (match_and_skip("</c>")) {
if (c.size() > 1) {
c.pop_back();
}
else {
// If the user pops the color stack empty, go back to the default color.
c[0] = Color::WHITE;
}
return true;
}
// Leave the trickiest case for last - changing the current text color.
if (strncmp(markup, "<c=", 3) == 0) {
// Count hex chars following the <c= string.
const char* hex = markup + 3;
const char* valid_hex_chars = "0123456789ABCDEFabcdef";
size_t hex_chars = strspn(hex, valid_hex_chars);
if (*(hex + hex_chars) != '>' || (hex_chars != 3 && hex_chars != 6 && hex_chars != 8)) {
// Does not match <c=[0-9A-Fa-f]{3,6,8}> -> not considered valid markup.
return false;
}
add_current_substring();
auto argb = strtoul(hex, nullptr, 16);
if (hex_chars == 3) {
// Expand 0xrgb to 0xFFrrggbb:
auto r = argb >> 8 & 0xf;
auto g = argb >> 4 & 0xf;
auto b = argb >> 0 & 0xf;
argb = 0xff000000 | r << 20 | r << 16 | g << 12 | g << 8 | b << 4 | b << 0;
}
else if (hex_chars == 6) {
// Expand 0xrrggbb to 0xFFrrggbb:
argb = 0xff000000 | argb;
}
c.emplace_back(argb);
markup += (4 + hex_chars);
return true;
}
// Everything else is not considered markup.
return false;
}
bool Gosu::MarkupParser::parse_escape_entity()
{
auto translate_to = [this](char ch) {
if (word_state == ADDING_WHITESPACE) {
flush_to_consumer();
word_state = ADDING_WORD;
}
add_composed_substring(u32string(1, ch));
};
// These are not entities (images) but escapes for markup characters.
if (match_and_skip("<")) {
translate_to('<');
return true;
}
if (match_and_skip(">")) {
translate_to('>');
return true;
}
if (match_and_skip("&")) {
translate_to('&');
return true;
}
// These are the only recognized entities - disregard anything else.
return false;
}
void Gosu::MarkupParser::add_current_substring()
{
if (!substring.empty()) {
add_composed_substring(utf8_to_composed_utc4(substring));
substring.clear();
}
}
void Gosu::MarkupParser::add_composed_substring(u32string&& substring)
{
FormattedString fstr;
fstr.text = substring;
fstr.flags = flags();
fstr.color = c.back();
if (!substrings.empty() && substrings.back().can_be_merged_with(fstr)) {
substrings.back().text.append(move(fstr.text));
}
else {
substrings.emplace_back(move(fstr));
}
}
void Gosu::MarkupParser::flush_to_consumer()
{
if (!substrings.empty()) {
consumer(move(substrings));
substrings.clear();
}
}
Gosu::MarkupParser::MarkupParser(unsigned base_flags, bool split_words,
function<void (vector<FormattedString>)> consumer)
: consumer(move(consumer))
{
word_state = (split_words ? ADDING_WORD : IGNORE_WORDS);
b = (base_flags & FF_BOLD) ? 1 : 0;
i = (base_flags & FF_ITALIC) ? 1 : 0;
u = (base_flags & FF_UNDERLINE) ? 1 : 0;
}
void Gosu::MarkupParser::parse(const std::string& markup_string)
{
markup = markup_string.data();
const char* end_of_markup = markup_string.data() + markup_string.length();
while (markup < end_of_markup) {
if (*markup == '<' && parse_markup()) {
continue;
}
if (*markup == '&' && parse_escape_entity()) {
continue;
}
// The newline character always terminates the current line, regardless of whether this
// parser is trying to split words.
if (*markup == '\n') {
// Explicitly add the trailing \n to the current substring so that the consumer can
// distinguish between line breaks and word breaks in split_words mode.
substring.append(1, '\n');
++markup;
add_current_substring();
flush_to_consumer();
// Avoid incrementing ++markup again.
continue;
}
utf8proc_int32_t codepoint;
auto len = utf8proc_iterate((utf8proc_uint8_t*) markup, end_of_markup - markup, &codepoint);
// Cancel parsing when invalid UTF-8 is encountered.
if (len < 1) break;
auto* properties = utf8proc_get_property(codepoint);
// Also check the BiDi class to filter out non-breaking spaces.
bool whitespace_except_newline = properties->category == UTF8PROC_CATEGORY_ZS &&
properties->bidi_class == UTF8PROC_BIDI_CLASS_WS;
if (whitespace_except_newline && word_state == ADDING_WORD) {
// We are in word-parsing mode, and this is was the end of a word.
add_current_substring();
flush_to_consumer();
word_state = ADDING_WHITESPACE;
}
else if (!whitespace_except_newline && word_state == ADDING_WHITESPACE) {
// We are in word-parsing mode, and this is was the start of a word.
add_current_substring();
flush_to_consumer();
word_state = ADDING_WORD;
}
substring.append(markup, len);
markup += len;
if (word_state != IGNORE_WORDS && should_allow_break_after_codepoint(codepoint)) {
// Flush each individual CJK character out as a word so that the TextBuilder can insert
// line breaks as needed.
add_current_substring();
flush_to_consumer();
}
}
add_current_substring();
flush_to_consumer();
}