适配上游C++现代化和Boost移除（基于上游arch1t3cht#182）

- 适配上游提交 10843b9：C++20标准、Boost移除、std::filesystem替换
- 修复编译错误：agi::make_unique→std::make_unique、fs_fwd.h→filesystem
- 修复链接错误：统一函数签名为string_view
- 修复thesaurus透明比较器、dispatch DoInvoke签名、mkv_wrap string_view适配
- 保留自定义功能：压缩字幕支持(mkv_wrap)、DirectWrite字体(font_file_lister_gdi)
- .gitignore：排除docs/*.md和docs/*.txt临时文件

Author: mojie126

.gitignore

@@ -60,5 +60,10 @@ subprojects/expat-*
 subprojects/vpl
 subprojects/libvpl-*
 subprojects/wxWidgets-master
+subprojects/curl-*
+subprojects/LuaJIT-*
 .idea
 .vscode
+# Documentation (generated/temporary)
+docs/*.md
+docs/*.txt

automation/tests/aegisub.cpp

@@ -20,8 +20,8 @@
 
 #include <libaegisub/dispatch.h>
 #include <libaegisub/log.h>
+#include <libaegisub/util.h>
 
-#include <boost/locale/generator.hpp>
 #include <cstdio>
 #include <cstdlib>
 
@@ -36,7 +36,7 @@ void check(lua_State *L, int status) {
 }
 
 int close_and_exit(lua_State *L) {
-	int status = lua_tointeger(L, 1);
+	int status = (int)lua_tointeger(L, 1);
 	lua_close(L);
 	exit(status);
 }
@@ -48,7 +48,7 @@ int main(int argc, char **argv) {
 		return 1;
 	}
 
-	std::locale::global(boost::locale::generator().generate(""));
+	agi::util::InitLocale();
 	agi::dispatch::Init([](agi::dispatch::Thunk f) { });
 	agi::log::log = new agi::log::LogSink;
 

libaegisub/ass/dialogue_parser.cpp

@@ -16,22 +16,20 @@
 
 #include "libaegisub/ass/dialogue_parser.h"
 
+#include "libaegisub/exception.h"
 #include "libaegisub/spellchecker.h"
-
-#include <boost/locale/boundary/index.hpp>
-#include <boost/locale/boundary/segment.hpp>
-#include <boost/locale/boundary/types.hpp>
+#include "libaegisub/unicode.h"
 
 namespace {
 
-typedef std::vector<agi::ass::DialogueToken> TokenVec;
+using TokenVec = std::vector<agi::ass::DialogueToken>;
 using namespace agi::ass;
 namespace dt = DialogueTokenType;
 namespace ss = SyntaxStyle;
 
 class SyntaxHighlighter {
 	TokenVec ranges;
-	std::string const& text;
+	std::string_view text;
 	agi::SpellChecker *spellchecker;
 
 	void SetStyling(size_t len, int type) {
@@ -42,7 +40,7 @@ class SyntaxHighlighter {
 	}
 
 public:
-	SyntaxHighlighter(std::string const& text, agi::SpellChecker *spellchecker)
+	SyntaxHighlighter(std::string_view text, agi::SpellChecker *spellchecker)
 	: text(text)
 	, spellchecker(spellchecker)
 	{ }
@@ -97,7 +95,7 @@ class SyntaxHighlighter {
 };
 
 class WordSplitter {
-	std::string const& text;
+	std::string_view text;
 	std::vector<DialogueToken> &tokens;
 	size_t pos = 0;
 
@@ -113,14 +111,34 @@ class WordSplitter {
 	}
 
 	void SplitText(size_t &i) {
-		using namespace boost::locale::boundary;
-		ssegment_index map(word, text.begin() + pos, text.begin() + pos + tokens[i].length);
-		for (auto const& segment : map) {
-			auto len = static_cast<size_t>(distance(begin(segment), end(segment)));
-			if (segment.rule() & word_letters)
-				SwitchTo(i, dt::WORD, len);
-			else
-				SwitchTo(i, dt::TEXT, len);
+		UErrorCode err = U_ZERO_ERROR;
+		thread_local std::unique_ptr<icu::BreakIterator> bi(icu::BreakIterator::createWordInstance(icu::Locale::getDefault(), err));
+		agi::UTextPtr ut(utext_openUTF8(nullptr, text.data() + pos, tokens[i].length, &err));
+		bi->setText(ut.get(), err);
+		if (U_FAILURE(err)) throw agi::InternalError(u_errorName(err));
+		size_t pos = 0;
+		while (bi->next() != UBRK_DONE) {
+			auto len = bi->current() - pos;
+
+			std::vector<int32_t> rules(8);
+			int n = bi->getRuleStatusVec(rules.data(), rules.size(), err);
+			if (err == U_BUFFER_OVERFLOW_ERROR) {
+				err = U_ZERO_ERROR;
+				bi->getRuleStatusVec(rules.data(), rules.size(), err);
+			}
+
+			if (U_FAILURE(err)) throw agi::InternalError(u_errorName(err));
+
+			auto token_type = dt::TEXT;
+
+			for (size_t i = 0; i < n; i++) {
+				if (rules[i] >= UBRK_WORD_LETTER && rules[i] < UBRK_WORD_IDEO_LIMIT) {
+					token_type = dt::WORD;
+					break;
+				}
+			}
+			SwitchTo(i, token_type, len);
+			pos = bi->current();
 		}
 	}
 
@@ -183,7 +201,7 @@ class WordSplitter {
 	}
 
 public:
-	WordSplitter(std::string const& text, std::vector<DialogueToken> &tokens)
+	WordSplitter(std::string_view text, std::vector<DialogueToken> &tokens)
 	: text(text)
 	, tokens(tokens)
 	{ }
@@ -204,14 +222,15 @@ class WordSplitter {
 };
 }
 
-namespace agi {
-namespace ass {
+namespace agi::ass {
 
-std::vector<DialogueToken> SyntaxHighlight(std::string const& text, std::vector<DialogueToken> const& tokens, SpellChecker *spellchecker) {
+std::vector<DialogueToken> SyntaxHighlight(std::string_view text,
+	                                       std::vector<DialogueToken> const& tokens,
+	                                       SpellChecker *spellchecker) {
 	return SyntaxHighlighter(text, spellchecker).Highlight(tokens);
 }
 
-void MarkDrawings(std::string const& str, std::vector<DialogueToken> &tokens) {
+void MarkDrawings(std::string_view str, std::vector<DialogueToken> &tokens) {
 	if (tokens.empty()) return;
 
 	size_t last_ovr_end = 0;
@@ -233,7 +252,7 @@ void MarkDrawings(std::string const& str, std::vector<DialogueToken> &tokens) {
 					tokens[i].type = dt::DRAWING_FULL;
 				break;
 			case dt::TAG_NAME:
-				if (i + 3 < tokens.size() && (len == 4 || len == 5) && !strncmp(str.c_str() + pos + len - 4, "clip", 4)) {
+				if (i + 3 < tokens.size() && (len == 4 || len == 5) && !strncmp(str.data() + pos + len - 4, "clip", 4)) {
 					if (tokens[i + 1].type != dt::OPEN_PAREN)
 						goto tag_p;
 
@@ -318,10 +337,8 @@ void MarkDrawings(std::string const& str, std::vector<DialogueToken> &tokens) {
 	}
 }
 
-void SplitWords(std::string const& str, std::vector<DialogueToken> &tokens) {
+void SplitWords(std::string_view str, std::vector<DialogueToken> &tokens) {
 	MarkDrawings(str, tokens);
 	WordSplitter(str, tokens).SplitWords();
 }
-
-}
 }

libaegisub/ass/karaoke.cpp

@@ -0,0 +1,205 @@
+// Copyright (c) 2022, Thomas Goyne <plorkyeran@aegisub.org>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+//
+// Aegisub Project http://www.aegisub.org/
+
+#include <libaegisub/ass/karaoke.h>
+
+#include <libaegisub/karaoke_matcher.h>
+#include <libaegisub/format.h>
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/trim.hpp>
+
+namespace agi::ass {
+std::string KaraokeSyllable::GetText(bool k_tag) const {
+	std::string ret;
+
+	if (k_tag)
+		ret = agi::format("{%s%d}", tag_type, ((duration + 5) / 10));
+
+	std::string_view sv = text;
+	size_t idx = 0;
+	for (auto const& ovr : ovr_tags) {
+		ret += sv.substr(idx, ovr.first - idx);
+		ret += ovr.second;
+		idx = ovr.first;
+	}
+	ret += sv.substr(idx);
+	return ret;
+}
+
+void Karaoke::SetLine(std::vector<KaraokeSyllable>&& syls, bool auto_split, std::optional<int> end_time) {
+	this->syls = std::move(syls);
+
+	if (end_time) {
+		Normalize(*end_time);
+	}
+
+	// Add karaoke splits at each space
+	if (auto_split && size() == 1) {
+		AutoSplit();
+	}
+
+	AnnounceSyllablesChanged();
+}
+
+void Karaoke::Normalize(int end_time) {
+	auto& last_syl = syls.back();
+	int last_end = last_syl.start_time + last_syl.duration;
+
+	// Total duration is shorter than the line length so just extend the last
+	// syllable; this has no effect on rendering but is easier to work with
+	if (last_end < end_time)
+		last_syl.duration += end_time - last_end;
+	else if (last_end > end_time) {
+		// Truncate any syllables that extend past the end of the line
+		for (auto& syl : syls) {
+			if (syl.start_time > end_time) {
+				syl.start_time = end_time;
+				syl.duration = 0;
+			}
+			else {
+				syl.duration = std::min(syl.duration, end_time - syl.start_time);
+			}
+		}
+	}
+}
+
+void Karaoke::AutoSplit() {
+	size_t pos;
+	while ((pos = syls.back().text.find(' ')) != std::string::npos)
+		DoAddSplit(syls.size() - 1, pos + 1);
+}
+
+std::string Karaoke::GetText() const {
+	std::string text;
+	text.reserve(size() * 10);
+
+	for (auto const& syl : syls)
+		text += syl.GetText(true);
+
+	return text;
+}
+
+std::string_view Karaoke::GetTagType() const {
+	return begin()->tag_type;
+}
+
+void Karaoke::SetTagType(std::string_view new_type) {
+	for (auto& syl : syls)
+		syl.tag_type = new_type;
+}
+
+void Karaoke::DoAddSplit(size_t syl_idx, size_t pos) {
+	syls.insert(syls.begin() + syl_idx + 1, KaraokeSyllable());
+	KaraokeSyllable &syl = syls[syl_idx];
+	KaraokeSyllable &new_syl = syls[syl_idx + 1];
+
+	// If the syl is empty or the user is adding a syllable past the last
+	// character then pos will be out of bounds. Doing this is a bit goofy,
+	// but it's sometimes required for complex karaoke scripts
+	if (pos < syl.text.size()) {
+		new_syl.text = syl.text.substr(pos);
+		syl.text = syl.text.substr(0, pos);
+	}
+
+	if (new_syl.text.empty())
+		new_syl.duration = 0;
+	else if (syl.text.empty()) {
+		new_syl.duration = syl.duration;
+		syl.duration = 0;
+	}
+	else {
+		new_syl.duration = (syl.duration * new_syl.text.size() / (syl.text.size() + new_syl.text.size()) + 5) / 10 * 10;
+		syl.duration -= new_syl.duration;
+	}
+
+	assert(syl.duration >= 0);
+
+	new_syl.start_time = syl.start_time + syl.duration;
+	new_syl.tag_type = syl.tag_type;
+
+	// Move all override tags after the split to the new syllable and fix the indices
+	size_t text_len = syl.text.size();
+	for (auto it = syl.ovr_tags.begin(); it != syl.ovr_tags.end(); ) {
+		if (it->first < text_len)
+			++it;
+		else {
+			new_syl.ovr_tags[it->first - text_len] = it->second;
+			syl.ovr_tags.erase(it++);
+		}
+	}
+}
+
+void Karaoke::AddSplit(size_t syl_idx, size_t pos) {
+	DoAddSplit(syl_idx, pos);
+	AnnounceSyllablesChanged();
+}
+
+void Karaoke::RemoveSplit(size_t syl_idx) {
+	// Don't allow removing the first syllable
+	if (syl_idx == 0) return;
+
+	KaraokeSyllable &syl = syls[syl_idx];
+	KaraokeSyllable &prev = syls[syl_idx - 1];
+
+	prev.duration += syl.duration;
+	for (auto const& tag : syl.ovr_tags)
+		prev.ovr_tags[tag.first + prev.text.size()] = tag.second;
+	prev.text += syl.text;
+
+	syls.erase(syls.begin() + syl_idx);
+
+	AnnounceSyllablesChanged();
+}
+
+void Karaoke::SetStartTime(size_t syl_idx, int time) {
+	// Don't allow moving the first syllable
+	if (syl_idx == 0) return;
+
+	KaraokeSyllable &syl = syls[syl_idx];
+	KaraokeSyllable &prev = syls[syl_idx - 1];
+
+	assert(time >= prev.start_time);
+	assert(time <= syl.start_time + syl.duration);
+
+	int delta = time - syl.start_time;
+	syl.start_time = time;
+	syl.duration -= delta;
+	prev.duration += delta;
+}
+
+void Karaoke::SetLineTimes(int start_time, int end_time) {
+	assert(end_time >= start_time);
+
+	size_t idx = 0;
+	// Chop off any portion of syllables starting before the new start_time
+	do {
+		int delta = start_time - syls[idx].start_time;
+		syls[idx].start_time = start_time;
+		syls[idx].duration = std::max(0, syls[idx].duration - delta);
+	} while (++idx < syls.size() && syls[idx].start_time < start_time);
+
+	// And truncate any syllables ending after the new end_time
+	idx = syls.size() - 1;
+	while (syls[idx].start_time > end_time) {
+		syls[idx].start_time = end_time;
+		syls[idx].duration = 0;
+		--idx;
+	}
+	syls[idx].duration = end_time - syls[idx].start_time;
+}
+
+} // namespace agi::ass

libaegisub/ass/time.cpp

@@ -39,7 +39,7 @@ static void decompose_time(int ms_time, int& h, int& m, int& s, int& ms) {
 namespace agi {
 Time::Time(int time) : time(util::mid(0, time, MAX_TIME)) { }
 
-Time::Time(std::string const& text) {
+Time::Time(std::string_view text) {
 	int after_decimal = -1;
 	int current = 0;
 	for (char c : text) {