7 changed files with 1210 additions and 1056 deletions
@ -1,404 +0,0 @@ |
|||||||
/** |
|
||||||
* Object that is created from *formatted string* (or `Text`) and stores |
|
||||||
* information about formatting used in said string. Was introduced instead of |
|
||||||
* a simple method in `MutableText` to: |
|
||||||
* 1. Allow for reporting errors caused by badly specified colors; |
|
||||||
* 2. Allow for a more complicated case of specifying a color gradient |
|
||||||
* range. |
|
||||||
* Copyright 2022 Anton Tarasenko |
|
||||||
*------------------------------------------------------------------------------ |
|
||||||
* This file is part of Acedia. |
|
||||||
* |
|
||||||
* Acedia is free software: you can redistribute it and/or modify |
|
||||||
* it under the terms of the GNU General Public License as published by |
|
||||||
* the Free Software Foundation, version 3 of the License, or |
|
||||||
* (at your option) any later version. |
|
||||||
* |
|
||||||
* Acedia is distributed in the hope that it will be useful, |
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||||||
* GNU General Public License for more details. |
|
||||||
* |
|
||||||
* You should have received a copy of the GNU General Public License |
|
||||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
|
||||||
*/ |
|
||||||
class FormattedStringData extends AcediaObject |
|
||||||
dependson(Text) |
|
||||||
dependson(FormattingErrors) |
|
||||||
dependson(FormattingCommandList); |
|
||||||
|
|
||||||
struct FormattingInfo |
|
||||||
{ |
|
||||||
var bool colored; |
|
||||||
var Color plainColor; |
|
||||||
var bool gradient; |
|
||||||
var array<Color> gradientColors; |
|
||||||
var array<float> gradientPoints; |
|
||||||
var int gradientStart; |
|
||||||
var float gradientLength; |
|
||||||
}; |
|
||||||
// Formatted `string` can have an arbitrary level of folded format definitions, |
|
||||||
// this array is used as a stack to keep track of opened formatting blocks |
|
||||||
// when appending formatted `string`. |
|
||||||
var array<FormattingInfo> formattingStack; |
|
||||||
// Keep top element copied into a separate variable for quicker access. |
|
||||||
// Must maintain invariant: if `formattingStack.length > 0` |
|
||||||
// then `formattingStack[formattingStack.length - 1] == formattingStackHead`. |
|
||||||
var FormattingInfo formattingStackHead; |
|
||||||
|
|
||||||
var private FormattingCommandList commands; |
|
||||||
var private MutableText result; |
|
||||||
var private FormattingErrors errors; |
|
||||||
|
|
||||||
protected function Finalizer() |
|
||||||
{ |
|
||||||
formattingStack.length = 0; |
|
||||||
_.memory.Free(commands); |
|
||||||
_.memory.Free(errors); |
|
||||||
_.memory.Free(result); |
|
||||||
commands = none; |
|
||||||
errors = none; |
|
||||||
result = none; |
|
||||||
} |
|
||||||
|
|
||||||
public static final function FormattedStringData FromText( |
|
||||||
Text source, |
|
||||||
optional bool doReportErrors) |
|
||||||
{ |
|
||||||
local FormattedStringData newData; |
|
||||||
if (source == none) { |
|
||||||
return none; |
|
||||||
} |
|
||||||
newData = |
|
||||||
FormattedStringData(__().memory.Allocate(class'FormattedStringData')); |
|
||||||
if (doReportErrors) |
|
||||||
{ |
|
||||||
newData.errors = |
|
||||||
FormattingErrors(__().memory.Allocate(class'FormattingErrors')); |
|
||||||
} |
|
||||||
newData.commands = class'FormattingCommandList'.static |
|
||||||
.FromText(source, newData.errors); |
|
||||||
newData.result = __().text.Empty(); |
|
||||||
newData.BuildSelf(); |
|
||||||
__().memory.Free(newData.commands); |
|
||||||
newData.commands = none; |
|
||||||
return newData; |
|
||||||
} |
|
||||||
|
|
||||||
public final function Text GetResult() |
|
||||||
{ |
|
||||||
return result.Copy(); |
|
||||||
} |
|
||||||
|
|
||||||
public final function MutableText GetResultM() |
|
||||||
{ |
|
||||||
return result.MutableCopy(); |
|
||||||
} |
|
||||||
|
|
||||||
public final function FormattingErrors BorrowErrors() |
|
||||||
{ |
|
||||||
return errors; |
|
||||||
} |
|
||||||
|
|
||||||
private final function BuildSelf() |
|
||||||
{ |
|
||||||
local int i, j, nextCharacterIndex; |
|
||||||
local Text.Formatting defaultFormatting; |
|
||||||
local array<Text.Character> nextContents; |
|
||||||
local FormattingCommandList.FormattingCommand nextCommand; |
|
||||||
SetupFormattingStack(defaultFormatting); |
|
||||||
// First element of color stack is special and has no color information; |
|
||||||
// see `BuildFormattingStackCommands()` for details. |
|
||||||
nextCommand = commands.GetCommand(0); |
|
||||||
nextContents = nextCommand.contents; |
|
||||||
result.AppendManyRawCharacters(nextContents); |
|
||||||
nextCharacterIndex = nextContents.length; |
|
||||||
_.memory.Free(nextCommand.tag); |
|
||||||
for (i = 1; i < commands.GetAmount(); i += 1) |
|
||||||
{ |
|
||||||
nextCommand = commands.GetCommand(i); |
|
||||||
if (nextCommand.type == FST_StackPush) { |
|
||||||
PushIntoFormattingStack(nextCommand); |
|
||||||
} |
|
||||||
else if (nextCommand.type == FST_StackPop) { |
|
||||||
PopFormattingStack(); |
|
||||||
} |
|
||||||
else if (nextCommand.type == FST_StackSwap) { |
|
||||||
SwapFormattingStack(nextCommand.charTag); |
|
||||||
} |
|
||||||
nextContents = nextCommand.contents; |
|
||||||
if (IsCurrentFormattingGradient()) |
|
||||||
{ |
|
||||||
for (j = 0; j < nextContents.length; j += 1) |
|
||||||
{ |
|
||||||
result.AppendRawCharacter(nextContents[j], GetFormattingFor(nextCharacterIndex)); |
|
||||||
nextCharacterIndex += 1; |
|
||||||
} |
|
||||||
} |
|
||||||
else |
|
||||||
{ |
|
||||||
result.AppendManyRawCharacters(nextContents, GetFormattingFor(nextCharacterIndex)); |
|
||||||
nextCharacterIndex += nextContents.length; |
|
||||||
} |
|
||||||
_.memory.Free(nextCommand.tag); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Following four functions are to maintain a "color stack" that will |
|
||||||
// remember unclosed colors (new colors are obtained from formatting commands |
|
||||||
// sequence) defined in formatted string, in order. |
|
||||||
// Stack array always contains one element, defined by |
|
||||||
// the `SetupFormattingStack()` call. It corresponds to the default formatting |
|
||||||
// that will be used when we pop all the other elements. |
|
||||||
// It is necessary to deal with possible folded formatting definitions in |
|
||||||
// formatted strings. |
|
||||||
private final function SetupFormattingStack(Text.Formatting defaultFormatting) |
|
||||||
{ |
|
||||||
local FormattingInfo defaultFormattingInfo; |
|
||||||
defaultFormattingInfo.colored = defaultFormatting.isColored; |
|
||||||
defaultFormattingInfo.plainColor = defaultFormatting.color; |
|
||||||
if (formattingStack.length > 0) { |
|
||||||
formattingStack.length = 0; |
|
||||||
} |
|
||||||
formattingStack[0] = defaultFormattingInfo; |
|
||||||
formattingStackHead = defaultFormattingInfo; |
|
||||||
} |
|
||||||
|
|
||||||
private final function bool IsCurrentFormattingGradient() |
|
||||||
{ |
|
||||||
if (formattingStack.length <= 0) { |
|
||||||
return false; |
|
||||||
} |
|
||||||
return formattingStackHead.gradient; |
|
||||||
} |
|
||||||
|
|
||||||
private final function Text.Formatting GetFormattingFor(int index) |
|
||||||
{ |
|
||||||
local Text.Formatting emptyFormatting; |
|
||||||
if (formattingStack.length <= 0) return emptyFormatting; |
|
||||||
if (!formattingStackHead.colored) return emptyFormatting; |
|
||||||
|
|
||||||
return _.text.FormattingFromColor(GetColorFor(index)); |
|
||||||
} |
|
||||||
//FormattedStringData Package.FormattedStringData (Function AcediaCore.FormattedStringData.GetColorFor:00FC) Accessed array 'gradientColors' out of bounds (2/2) |
|
||||||
private final function Color GetColorFor(int index) |
|
||||||
{ |
|
||||||
local int i; |
|
||||||
local float indexPosition, leftPosition, rightPosition; |
|
||||||
local array<float> points; |
|
||||||
local Color leftColor, rightColor, resultColor; |
|
||||||
if (formattingStack.length <= 0) { |
|
||||||
return resultColor; |
|
||||||
} |
|
||||||
if (!formattingStackHead.gradient) { |
|
||||||
return formattingStackHead.plainColor; |
|
||||||
} |
|
||||||
indexPosition = float(index - formattingStackHead.gradientStart) / |
|
||||||
formattingStackHead.gradientLength; |
|
||||||
points = formattingStackHead.gradientPoints; |
|
||||||
for (i = 1; i < points.length; i += 1) |
|
||||||
{ |
|
||||||
if (points[i - 1] <= indexPosition && indexPosition <= points[i]) |
|
||||||
{ |
|
||||||
leftPosition = points[i - 1]; |
|
||||||
rightPosition = points[i]; |
|
||||||
leftColor = formattingStackHead.gradientColors[i - 1]; |
|
||||||
rightColor = formattingStackHead.gradientColors[i]; |
|
||||||
break; |
|
||||||
} |
|
||||||
} |
|
||||||
indexPosition = |
|
||||||
(indexPosition - leftPosition) / (rightPosition - leftPosition); |
|
||||||
resultColor.R = Lerp(indexPosition, leftColor.R, rightColor.R); |
|
||||||
resultColor.G = Lerp(indexPosition, leftColor.G, rightColor.G); |
|
||||||
resultColor.B = Lerp(indexPosition, leftColor.B, rightColor.B); |
|
||||||
resultColor.A = Lerp(indexPosition, leftColor.A, rightColor.A); |
|
||||||
return resultColor; |
|
||||||
} |
|
||||||
|
|
||||||
private final function PushIntoFormattingStack( |
|
||||||
FormattingCommandList.FormattingCommand formattingCommand) |
|
||||||
{ |
|
||||||
formattingStackHead = ParseFormattingInfo(formattingCommand.tag); |
|
||||||
formattingStackHead.gradientStart = formattingCommand.openIndex; |
|
||||||
formattingStackHead.gradientLength = |
|
||||||
float(formattingCommand.closeIndex - formattingCommand.openIndex); |
|
||||||
formattingStack[formattingStack.length] = formattingStackHead; |
|
||||||
} |
|
||||||
|
|
||||||
private final function SwapFormattingStack(Text.Character tagCharacter) |
|
||||||
{ |
|
||||||
local FormattingInfo updatedFormatting; |
|
||||||
if (formattingStack.length > 0) { |
|
||||||
updatedFormatting = formattingStackHead; |
|
||||||
} |
|
||||||
if (_.color.ResolveShortTagColor(tagCharacter, updatedFormatting.plainColor)) |
|
||||||
{ |
|
||||||
updatedFormatting.colored = true; |
|
||||||
updatedFormatting.gradient = false; |
|
||||||
} |
|
||||||
else { |
|
||||||
Report(FSE_BadShortColorTag, _.text.FromString("^" $ Chr(tagCharacter.codePoint))); |
|
||||||
} |
|
||||||
formattingStackHead = updatedFormatting; |
|
||||||
if (formattingStack.length > 0) { |
|
||||||
formattingStack[formattingStack.length - 1] = updatedFormatting; |
|
||||||
} |
|
||||||
else { |
|
||||||
formattingStack[0] = updatedFormatting; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
private final function PopFormattingStack() |
|
||||||
{ |
|
||||||
// Remove the top of the stack |
|
||||||
if (formattingStack.length > 0) { |
|
||||||
formattingStack.length = formattingStack.length - 1; |
|
||||||
} |
|
||||||
// Update the stack head copy |
|
||||||
if (formattingStack.length > 0) { |
|
||||||
formattingStackHead = formattingStack[formattingStack.length - 1]; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
private final function FormattingInfo ParseFormattingInfo(Text colorTag) |
|
||||||
{ |
|
||||||
local int i; |
|
||||||
local Parser colorParser; |
|
||||||
local Color nextColor; |
|
||||||
local array<MutableText> specifiedColors; |
|
||||||
local Text.Character tildeCharacter; |
|
||||||
local array<Color> gradientColors; |
|
||||||
local array<float> gradientPoints; |
|
||||||
local FormattingInfo resultInfo; |
|
||||||
if (colorTag.IsEmpty()) |
|
||||||
{ |
|
||||||
Report(FSE_EmptyColorTag); |
|
||||||
return resultInfo; // not colored |
|
||||||
} |
|
||||||
tildeCharacter = _.text.GetCharacter("~"); |
|
||||||
specifiedColors = colorTag.SplitByCharacter(tildeCharacter, true); |
|
||||||
for (i = 0; i < specifiedColors.length; i += 1) |
|
||||||
{ |
|
||||||
colorParser = _.text.Parse(specifiedColors[i]); |
|
||||||
if (_.color.ParseWith(colorParser, nextColor)) |
|
||||||
{ |
|
||||||
colorParser.Confirm(); |
|
||||||
gradientColors[gradientColors.length] = nextColor; |
|
||||||
gradientPoints[gradientPoints.length] = ParsePoint(colorParser); |
|
||||||
} |
|
||||||
else { |
|
||||||
Report(FSE_BadColor, specifiedColors[i]); |
|
||||||
} |
|
||||||
_.memory.Free(colorParser); |
|
||||||
} |
|
||||||
_.memory.FreeMany(specifiedColors); |
|
||||||
gradientPoints = NormalizePoints(gradientPoints); |
|
||||||
resultInfo.colored = (gradientColors.length > 0); |
|
||||||
resultInfo.gradient = (gradientColors.length > 1); |
|
||||||
resultInfo.gradientColors = gradientColors; |
|
||||||
resultInfo.gradientPoints = gradientPoints; |
|
||||||
if (gradientColors.length > 0) { |
|
||||||
resultInfo.plainColor = gradientColors[0]; |
|
||||||
} |
|
||||||
return resultInfo; |
|
||||||
} |
|
||||||
|
|
||||||
private final function float ParsePoint(Parser parser) |
|
||||||
{ |
|
||||||
local float point; |
|
||||||
local Parser.ParserState initialState; |
|
||||||
if (!parser.Ok() || parser.HasFinished()) { |
|
||||||
return -1; |
|
||||||
} |
|
||||||
initialState = parser.GetCurrentState(); |
|
||||||
// [Necessary part] Should starts with "[" |
|
||||||
if (!parser.Match(P("[")).Ok()) |
|
||||||
{ |
|
||||||
Report(FSE_BadGradientPoint, parser.RestoreState(initialState).GetRemainder()); |
|
||||||
return -1; |
|
||||||
} |
|
||||||
// [Necessary part] Try parsing number |
|
||||||
parser.MNumber(point).Confirm(); |
|
||||||
if (!parser.Ok()) |
|
||||||
{ |
|
||||||
Report(FSE_BadGradientPoint, parser.RestoreState(initialState).GetRemainder()); |
|
||||||
return -1; |
|
||||||
} |
|
||||||
// [Optional part] Check if number is a percentage |
|
||||||
if (parser.Match(P("%")).Ok()) { |
|
||||||
point *= 0.01; |
|
||||||
} |
|
||||||
// This either confirms state of parsing "%" (on success) |
|
||||||
// or reverts to the previous state, just after parsing the number |
|
||||||
// (on failure) |
|
||||||
parser.Confirm(); |
|
||||||
parser.R(); |
|
||||||
// [Necessary part] Have to have closing parenthesis |
|
||||||
if (!parser.HasFinished()) { |
|
||||||
parser.Match(P("]")).Confirm(); |
|
||||||
} |
|
||||||
// Still return `point`, even if there was no closing parenthesis, |
|
||||||
// since that is likely what user wants |
|
||||||
if (!parser.Ok()) { |
|
||||||
Report(FSE_BadGradientPoint, parser.RestoreState(initialState).GetRemainder()); |
|
||||||
} |
|
||||||
return point; |
|
||||||
} |
|
||||||
/*FIRST-POPOPOINTS 0.00 -1.00 -1.00 -1.00 1.00 5 |
|
||||||
PRE-POPOPOINTS 0.00 -1.00 0.00 -1.00 1.00 5 */ |
|
||||||
private final function array<float> NormalizePoints(array<float> points) |
|
||||||
{ |
|
||||||
local int i, j; |
|
||||||
local int negativeSegmentStart, negativeSegmentLength; |
|
||||||
local float lowerBound, upperBound; |
|
||||||
local bool foundNegative; |
|
||||||
if (points.length > 1) |
|
||||||
{ |
|
||||||
points[0] = 0.0; |
|
||||||
points[points.length - 1] = 1.0; |
|
||||||
} |
|
||||||
for (i = 1; i < points.length - 1; i += 1) |
|
||||||
{ |
|
||||||
if (points[i] <= 0 || points[i] > 1 || points[i] <= points[i - 1]) { |
|
||||||
points[i] = -1; |
|
||||||
} |
|
||||||
} |
|
||||||
for (i = 1; i < points.length; i += 1) |
|
||||||
{ |
|
||||||
if (foundNegative && points[i] > 0) |
|
||||||
{ |
|
||||||
upperBound = points[i]; |
|
||||||
for (j = negativeSegmentStart; j < i; j += 1) |
|
||||||
{ |
|
||||||
points[j] = Lerp( float(j - negativeSegmentStart + 1) / float(negativeSegmentLength + 1), |
|
||||||
lowerBound, upperBound); |
|
||||||
} |
|
||||||
negativeSegmentLength = 0; |
|
||||||
} |
|
||||||
if (!foundNegative && points[i] < 0) |
|
||||||
{ |
|
||||||
lowerBound = points[i - 1]; |
|
||||||
negativeSegmentStart = i; |
|
||||||
} |
|
||||||
foundNegative = (points[i] < 0); |
|
||||||
if (foundNegative) { |
|
||||||
negativeSegmentLength += 1; |
|
||||||
} |
|
||||||
} |
|
||||||
return points; |
|
||||||
} |
|
||||||
|
|
||||||
public final function Report( |
|
||||||
FormattingErrors.FormattedDataErrorType type, |
|
||||||
optional Text cause) |
|
||||||
{ |
|
||||||
if (errors == none) { |
|
||||||
return; |
|
||||||
} |
|
||||||
errors.Report(type, cause); |
|
||||||
} |
|
||||||
|
|
||||||
defaultproperties |
|
||||||
{ |
|
||||||
} |
|
||||||
@ -1,296 +0,0 @@ |
|||||||
/** |
|
||||||
* Formatted string can be thought of as a string with a sequence of |
|
||||||
* formatting-changing commands specified within it (either by opening new |
|
||||||
* formatting block, swapping to color with "^" or by closing it and reverting |
|
||||||
* to the previous one). |
|
||||||
* This objects allows to directly access these commands. |
|
||||||
* Copyright 2022 Anton Tarasenko |
|
||||||
*------------------------------------------------------------------------------ |
|
||||||
* This file is part of Acedia. |
|
||||||
* |
|
||||||
* Acedia is free software: you can redistribute it and/or modify |
|
||||||
* it under the terms of the GNU General Public License as published by |
|
||||||
* the Free Software Foundation, version 3 of the License, or |
|
||||||
* (at your option) any later version. |
|
||||||
* |
|
||||||
* Acedia is distributed in the hope that it will be useful, |
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||||||
* GNU General Public License for more details. |
|
||||||
* |
|
||||||
* You should have received a copy of the GNU General Public License |
|
||||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
|
||||||
*/ |
|
||||||
class FormattingCommandList extends AcediaObject |
|
||||||
dependson(Text); |
|
||||||
|
|
||||||
enum FormattingCommandType |
|
||||||
{ |
|
||||||
// Push more data onto formatted stack |
|
||||||
FST_StackPush, |
|
||||||
// Pop data from formatted stack |
|
||||||
FST_StackPop, |
|
||||||
// Swap the top value on the formatting stack |
|
||||||
FST_StackSwap |
|
||||||
}; |
|
||||||
|
|
||||||
// Formatted `string` is separated into several (possibly nested) parts, |
|
||||||
// each with its own formatting. These can be easily handled with a formatting |
|
||||||
// stack: |
|
||||||
// * Each time a new section opens ("{<color_tag> ") we put another, |
|
||||||
// current formatting on top of the stack; |
|
||||||
// * Each time a section closes ("}") we pop the stack, returning to |
|
||||||
// a previous formatting. |
|
||||||
// * In a special case of "^" color swap that is supposed to last until |
|
||||||
// current block closes we simply swap the color of the formatting on |
|
||||||
// top of the stack. |
|
||||||
struct FormattingCommand |
|
||||||
{ |
|
||||||
// Only defined for `FST_StackPush` commands that correspond to section |
|
||||||
// openers ("{<color_tag> "). |
|
||||||
// Indices of first and last character belonging to block it opens. |
|
||||||
var int openIndex; |
|
||||||
var int closeIndex; |
|
||||||
// Did this block start by opening or closing formatted part? |
|
||||||
// Ignored for the very first block without any formatting. |
|
||||||
var FormattingCommandType type; |
|
||||||
// Full text inside the block, without any formatting |
|
||||||
var array<Text.Character> contents; |
|
||||||
// Formatting tag for the next block |
|
||||||
// (only used for `FST_StackPush` command type) |
|
||||||
var MutableText tag; |
|
||||||
// Formatting character for the "^"-type tag |
|
||||||
// (only used for `FST_StackSwap` command type) |
|
||||||
var Text.Character charTag; |
|
||||||
}; |
|
||||||
// Appending formatted `string` into the `MutableText` first requires its |
|
||||||
// transformation into series of `FormattingCommand` and then their |
|
||||||
// execution to assemble the `MutableText`. |
|
||||||
// First element of `commandList` is special and is used solely as |
|
||||||
// a container for unformatted data. It should not be used to execute |
|
||||||
// formatting stack commands. |
|
||||||
// This variable contains intermediary data. |
|
||||||
var private array<FormattingCommand> commandList; |
|
||||||
|
|
||||||
// Stack that keeps track of which (by index inside `commandList`) command |
|
||||||
// opened section we are currently parsing. This is needed to record positions |
|
||||||
// at which each block is opened and closed. |
|
||||||
var private array<int> pushCommandIndicesStack; |
|
||||||
// Store contents for the next command here, because appending array in |
|
||||||
// the struct is expensive |
|
||||||
var private array<Text.Character> currentContents; |
|
||||||
// `Parser` used to break input formatted string into commands, only used |
|
||||||
// during building this object (inside `BuildSelf()` method). |
|
||||||
var private Parser parser; |
|
||||||
// `FormattingErrors` object used to reports errors during building process. |
|
||||||
// It is "borrowed" - meaning that we do not really own it and should not |
|
||||||
// deallocate it. Only set as a field for convenience. |
|
||||||
var private FormattingErrors borrowedErrors; |
|
||||||
|
|
||||||
const CODEPOINT_ESCAPE = 27; // ASCII escape code |
|
||||||
const CODEPOINT_OPEN_FORMAT = 123; // '{' |
|
||||||
const CODEPOINT_CLOSE_FORMAT = 125; // '}' |
|
||||||
const CODEPOINT_FORMAT_ESCAPE = 38; // '&' |
|
||||||
const CODEPOINT_ACCENT = 94; // '^' |
|
||||||
const CODEPOINT_TILDE = 126; // '~' |
|
||||||
|
|
||||||
protected function Finalizer() |
|
||||||
{ |
|
||||||
local int i; |
|
||||||
_.memory.Free(parser); |
|
||||||
parser = none; |
|
||||||
borrowedErrors = none; |
|
||||||
if (currentContents.length > 0) { |
|
||||||
currentContents.length = 0; |
|
||||||
} |
|
||||||
if (pushCommandIndicesStack.length > 0) { |
|
||||||
pushCommandIndicesStack.length = 0; |
|
||||||
} |
|
||||||
for (i = 0; i < commandList.length; i += 1) { |
|
||||||
_.memory.Free(commandList[i].tag); |
|
||||||
} |
|
||||||
if (commandList.length > 0) { |
|
||||||
commandList.length = 0; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* Create `FormattingCommandList` based on given `Text`. |
|
||||||
* |
|
||||||
* @param input `Text` that should be treated as "formatted" and |
|
||||||
* to be broken into formatting commands. |
|
||||||
* @param errorsReporter If specified, will be used to report errors |
|
||||||
* (can only report `FSE_UnmatchedClosingBrackets`). |
|
||||||
* @return New `FormattingCommandList` instance that allows us to have direct |
|
||||||
* access to formatting commands. |
|
||||||
*/ |
|
||||||
public final static function FormattingCommandList FromText( |
|
||||||
Text input, |
|
||||||
optional FormattingErrors errorsReporter) |
|
||||||
{ |
|
||||||
local FormattingCommandList newList; |
|
||||||
newList = FormattingCommandList( |
|
||||||
__().memory.Allocate(class'FormattingCommandList')); |
|
||||||
newList.parser = __().text.Parse(input); |
|
||||||
newList.borrowedErrors = errorsReporter; |
|
||||||
newList.BuildSelf(); |
|
||||||
__().memory.Free(newList.parser); |
|
||||||
newList.parser = none; |
|
||||||
newList.borrowedErrors = none; |
|
||||||
return newList; |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* Returns command with index `commandIndex`. |
|
||||||
* |
|
||||||
* @param commandIndex Index of the command to return. |
|
||||||
* Must be non-negative (`>= 0`) and less than `GetAmount()`. |
|
||||||
* @return Command with index `commandIndex`. |
|
||||||
* If given `commandIndex` is out of bounds - returns invalid command. |
|
||||||
* `tag` field is guaranteed to be non-`none` and should be deallocated. |
|
||||||
*/ |
|
||||||
public final function FormattingCommand GetCommand(int commandIndex) |
|
||||||
{ |
|
||||||
local MutableText resultTag; |
|
||||||
local FormattingCommand result; |
|
||||||
if (commandIndex < 0) return result; |
|
||||||
if (commandIndex >= commandList.length) return result; |
|
||||||
|
|
||||||
result = commandList[commandIndex]; |
|
||||||
resultTag = result.tag; |
|
||||||
if (resultTag != none) { |
|
||||||
result.tag = resultTag.MutableCopy(); |
|
||||||
} |
|
||||||
return result; |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* Returns amount of commands inside caller `FormattingCommandList`. |
|
||||||
* |
|
||||||
* @return Amount of commands inside caller `FormattingCommandList`. |
|
||||||
*/ |
|
||||||
public final function int GetAmount() |
|
||||||
{ |
|
||||||
return commandList.length; |
|
||||||
} |
|
||||||
|
|
||||||
// Method that turns `parser` into proper `FormattingCommandList` object. |
|
||||||
private final function BuildSelf() |
|
||||||
{ |
|
||||||
//local int i; |
|
||||||
local int characterCounter; |
|
||||||
local Text.Character nextCharacter; |
|
||||||
local FormattingCommand nextCommand; |
|
||||||
while (!parser.HasFinished()) |
|
||||||
{ |
|
||||||
parser.MCharacter(nextCharacter); |
|
||||||
// New command by "{<formatting_info>" |
|
||||||
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_OPEN_FORMAT)) |
|
||||||
{ |
|
||||||
nextCommand = AddCommand(nextCommand, FST_StackPush, characterCounter); |
|
||||||
parser.MUntil(nextCommand.tag,, true) |
|
||||||
.MCharacter(nextCommand.charTag); // Simply to skip a char |
|
||||||
continue; |
|
||||||
} |
|
||||||
// New command by "}" |
|
||||||
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_CLOSE_FORMAT)) |
|
||||||
{ |
|
||||||
nextCommand = AddCommand(nextCommand, FST_StackPop, characterCounter); |
|
||||||
continue; |
|
||||||
} |
|
||||||
// New command by "^" |
|
||||||
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_ACCENT)) |
|
||||||
{ |
|
||||||
nextCommand = AddCommand(nextCommand, FST_StackSwap, characterCounter); |
|
||||||
parser.MCharacter(nextCommand.charTag); |
|
||||||
if (!parser.Ok()) { |
|
||||||
break; |
|
||||||
} |
|
||||||
continue; |
|
||||||
} |
|
||||||
// Escaped sequence |
|
||||||
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_FORMAT_ESCAPE)) { |
|
||||||
parser.MCharacter(nextCharacter); |
|
||||||
} |
|
||||||
if (!parser.Ok()) { |
|
||||||
break; |
|
||||||
} |
|
||||||
currentContents[currentContents.length] = nextCharacter; |
|
||||||
characterCounter += 1; |
|
||||||
} |
|
||||||
// Only put in empty command if there is nothing else. |
|
||||||
if (currentContents.length > 0 || commandList.length == 0) |
|
||||||
{ |
|
||||||
nextCommand.contents = currentContents; |
|
||||||
commandList[commandList.length] = nextCommand; |
|
||||||
} |
|
||||||
/*for (i = 0; i < commandList.length; i += 1) |
|
||||||
{ |
|
||||||
Log(">>>COMMAND LIST FOR" @ i $ "<<<"); |
|
||||||
Log("OPEN/CLOSE:" @ commandList[i].openIndex @ "/" @ commandList[i].closeIndex); |
|
||||||
Log("TYPE:" @ commandList[i].type); |
|
||||||
Log("CONTETS LENGTH:" @ commandList[i].contents.length); |
|
||||||
if (commandList[i].tag != none) { |
|
||||||
Log("TAG:" @ commandList[i].tag.ToString()); |
|
||||||
} |
|
||||||
else { |
|
||||||
Log("TAG: NONE"); |
|
||||||
} |
|
||||||
}*/ |
|
||||||
} |
|
||||||
|
|
||||||
// Helper method for a quick creation of a new `FormattingCommand` |
|
||||||
private final function FormattingCommand AddCommand( |
|
||||||
FormattingCommand nextCommand, |
|
||||||
FormattingCommandType newStackCommandType, |
|
||||||
optional int currentCharacterIndex) |
|
||||||
{ |
|
||||||
local int lastPushIndex; |
|
||||||
local FormattingCommand newCommand; |
|
||||||
nextCommand.contents = currentContents; |
|
||||||
if (currentContents.length > 0) { |
|
||||||
currentContents.length = 0; |
|
||||||
} |
|
||||||
commandList[commandList.length] = nextCommand; |
|
||||||
if (newStackCommandType == FST_StackPop) |
|
||||||
{ |
|
||||||
lastPushIndex = PopIndex(); |
|
||||||
if (lastPushIndex >= 0) { |
|
||||||
// BLABLA |
|
||||||
commandList[lastPushIndex].closeIndex = currentCharacterIndex - 1; |
|
||||||
} |
|
||||||
else if (borrowedErrors != none) { |
|
||||||
borrowedErrors.Report(FSE_UnmatchedClosingBrackets); |
|
||||||
} |
|
||||||
} |
|
||||||
newCommand.type = newStackCommandType; |
|
||||||
if (newStackCommandType == FST_StackPush) |
|
||||||
{ |
|
||||||
newCommand.openIndex = currentCharacterIndex; |
|
||||||
newCommand.closeIndex = -1; |
|
||||||
// BLABLA |
|
||||||
PushIndex(commandList.length); |
|
||||||
} |
|
||||||
return newCommand; |
|
||||||
} |
|
||||||
|
|
||||||
private final function PushIndex(int index) |
|
||||||
{ |
|
||||||
pushCommandIndicesStack[pushCommandIndicesStack.length] = |
|
||||||
commandList.length; |
|
||||||
} |
|
||||||
|
|
||||||
private final function int PopIndex() |
|
||||||
{ |
|
||||||
local int result; |
|
||||||
if (pushCommandIndicesStack.length <= 0) { |
|
||||||
return -1; |
|
||||||
} |
|
||||||
result = pushCommandIndicesStack[pushCommandIndicesStack.length - 1]; |
|
||||||
pushCommandIndicesStack.length = pushCommandIndicesStack.length - 1; |
|
||||||
return result; |
|
||||||
} |
|
||||||
|
|
||||||
defaultproperties |
|
||||||
{ |
|
||||||
} |
|
||||||
@ -0,0 +1,316 @@ |
|||||||
|
/** |
||||||
|
* Formatted string can be thought of as a string with a sequence of |
||||||
|
* formatting-changing commands specified within it, along with raw contents |
||||||
|
* to be pasted before performing next command (for more information about this |
||||||
|
* see `FormattingStringParser`). This is a class for an accessor object |
||||||
|
* that can return these individual commands based on the given `Text`/`string` |
||||||
|
* (alongside with the construction code that determines these commands). |
||||||
|
* This objects allows to directly access these commands. |
||||||
|
* Copyright 2022 Anton Tarasenko |
||||||
|
*------------------------------------------------------------------------------ |
||||||
|
* This file is part of Acedia. |
||||||
|
* |
||||||
|
* Acedia is free software: you can redistribute it and/or modify |
||||||
|
* it under the terms of the GNU General Public License as published by |
||||||
|
* the Free Software Foundation, version 3 of the License, or |
||||||
|
* (at your option) any later version. |
||||||
|
* |
||||||
|
* Acedia is distributed in the hope that it will be useful, |
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
* GNU General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||||
|
*/ |
||||||
|
class FormattingCommandsSequence extends AcediaObject |
||||||
|
dependson(Text); |
||||||
|
|
||||||
|
enum FormattingCommandType |
||||||
|
{ |
||||||
|
// Push more new formatting onto the stack. Corresponds to "{<color_tag> ". |
||||||
|
FST_StackPush, |
||||||
|
// Pop formatting from the stack. Corresponds to "}". |
||||||
|
FST_StackPop, |
||||||
|
// Swap the top value on the formatting stack for a different formatting |
||||||
|
// (pushes new one, if the stack is empty). Corresponds to "^<color_char>". |
||||||
|
FST_StackSwap |
||||||
|
}; |
||||||
|
|
||||||
|
/** |
||||||
|
* Represents formatting command + contents, alongside some additional |
||||||
|
* meta information, necessary for `FormattingStringParser`. |
||||||
|
*/ |
||||||
|
struct FormattingCommand |
||||||
|
{ |
||||||
|
var FormattingCommandType type; |
||||||
|
var array<Text.Character> contents; |
||||||
|
|
||||||
|
// Formatting character for the "^"-type tag |
||||||
|
// This parameter is only used for `FST_StackSwap` command type. |
||||||
|
var Text.Character charTag; |
||||||
|
|
||||||
|
// Rest of the parameters are only used for `FST_StackPush` |
||||||
|
// command type. |
||||||
|
// These commands correspond to section openers ("{<color_tag> "): |
||||||
|
// such openings define a *formatting block* between itself and matching |
||||||
|
// closing curly braces "}". |
||||||
|
// Meta information about these blocks is necessary for |
||||||
|
// `FormattingStringParser`. |
||||||
|
|
||||||
|
// Formatting tag for the next block - "<color_tag>" from "{<color_tag> ". |
||||||
|
var MutableText tag; |
||||||
|
// When formatting block for this command started and ended - |
||||||
|
// necessary for gradient coloring. |
||||||
|
// `closeIndex` should be equal to `-1` if it is not defined. |
||||||
|
var int openIndex; |
||||||
|
var int closeIndex; |
||||||
|
}; |
||||||
|
// All the commands we got from formatted string |
||||||
|
var private array<FormattingCommand> commandSequence; |
||||||
|
// Store contents for the next command here, because constantly appending array |
||||||
|
// inside the struct (`FormattingCommand` here) is expensive. |
||||||
|
var private array<Text.Character> currentContents; |
||||||
|
// `Parser` used to break input formatted string into commands. |
||||||
|
// It is only used during building this object (inside `BuildSelf()` method). |
||||||
|
var private Parser parser; |
||||||
|
// How many non-formatting defining characters we have parsed. |
||||||
|
// That is characters that are actually meant to be displayed to the user |
||||||
|
// and not the part of formatting definitions (e.g. "{$red", "}" or "^r"; |
||||||
|
// "&{", "&&" or "&^" are also resolved into a single displayed character). |
||||||
|
// `Parser`'s `GetParsedLength()` method is unusable here, since it |
||||||
|
// reports all parsed characters. |
||||||
|
var private int characterCounter; |
||||||
|
// Command we are currently building. |
||||||
|
// Making it a field makes code simpler and lets us avoid passing |
||||||
|
// `FormattingCommand` struct between functions. |
||||||
|
var private FormattingCommand currentCommand; |
||||||
|
// `FormattingErrorsReport` we are given to report errors to. |
||||||
|
// It is considered "borrowed": we do not really own it and will not |
||||||
|
// deallocate it. |
||||||
|
// Since, similar to `parser` field, it is only used during building this |
||||||
|
// object - there is no danger of it being deallocated while we are storing |
||||||
|
// this reference. |
||||||
|
// Only set as a field for convenience, to avoid passing it as a parameter |
||||||
|
// between methods during parsing. |
||||||
|
var private FormattingErrorsReport borrowedErrors; |
||||||
|
|
||||||
|
// Stack that keeps track of which (by index inside `commandSequence`) command |
||||||
|
// opened section we are currently parsing. This is needed to record positions |
||||||
|
// at which each block is opened and closed. |
||||||
|
|
||||||
|
// It is easy to record opening indices for each formatting block by |
||||||
|
// recording how many characters we have already processed before encountering |
||||||
|
// opening statement "{<color_tag> ". But to record closing indices we need to |
||||||
|
// correspond correct opener with correct closer ("}"). |
||||||
|
// We accomplish that by keeping track of all formatted blocks opened |
||||||
|
// at the current moment during parsing in a stack and popping the top value |
||||||
|
// upon reaching "}". |
||||||
|
// We identify each formatting block by recording index of corresponding |
||||||
|
// `FormattingCommand` inside `commandSequence` array. This makes setting |
||||||
|
// appropriate `closeIndex` simple. |
||||||
|
var private array<int> pushCommandIndicesStack; |
||||||
|
|
||||||
|
const CODEPOINT_OPEN_FORMAT = 123; // '{' |
||||||
|
const CODEPOINT_CLOSE_FORMAT = 125; // '}' |
||||||
|
const CODEPOINT_FORMAT_ESCAPE = 38; // '&' |
||||||
|
const CODEPOINT_ACCENT = 94; // '^' |
||||||
|
|
||||||
|
protected function Finalizer() |
||||||
|
{ |
||||||
|
local int i; |
||||||
|
for (i = 0; i < commandSequence.length; i += 1) { |
||||||
|
_.memory.Free(commandSequence[i].tag); |
||||||
|
} |
||||||
|
pushCommandIndicesStack.length = 0; |
||||||
|
currentContents.length = 0; |
||||||
|
commandSequence.length = 0; |
||||||
|
characterCounter = 0; |
||||||
|
// These fields should not be set at this point, but clean them up |
||||||
|
// just in case |
||||||
|
_.memory.Free(parser); |
||||||
|
parser = none; |
||||||
|
borrowedErrors = none; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Create `FormattingCommandsSequence` based on the given `Text`. |
||||||
|
* |
||||||
|
* There is not separate method for `string`, since we would require reading it |
||||||
|
* into a `Text` as a *plain string* first anyway and, as this class is |
||||||
|
* technical/internal, no convenience methods are needed. |
||||||
|
* |
||||||
|
* @param input `Text` that should be treated as "formatted" and |
||||||
|
* to be broken into formatting commands. |
||||||
|
* @param errorsReporter If specified, will be used to report errors detected |
||||||
|
* during construction of `FormattingCommandsSequence` |
||||||
|
* (can only report `FSE_UnmatchedClosingBrackets`). |
||||||
|
* @return New `FormattingCommandsSequence` instance that allows us to have |
||||||
|
* direct access to formatting commands defined in `input`. |
||||||
|
*/ |
||||||
|
public final static function FormattingCommandsSequence FromText( |
||||||
|
Text input, |
||||||
|
optional FormattingErrorsReport errorsReporter) |
||||||
|
{ |
||||||
|
local FormattingCommandsSequence newSequence; |
||||||
|
newSequence = FormattingCommandsSequence( |
||||||
|
__().memory.Allocate(class'FormattingCommandsSequence')); |
||||||
|
// Setup variables |
||||||
|
newSequence.parser = __().text.Parse(input); |
||||||
|
newSequence.borrowedErrors = errorsReporter; |
||||||
|
// Parse |
||||||
|
newSequence.BuildSelf(); |
||||||
|
// Clean up |
||||||
|
__().memory.Free(newSequence.parser); |
||||||
|
newSequence.parser = none; |
||||||
|
newSequence.borrowedErrors = none; |
||||||
|
return newSequence; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Amount of commands to reconstruct formatted string caller |
||||||
|
* `FormattingCommandsSequence` was created from. |
||||||
|
* |
||||||
|
* @return Amount of commands inside caller `FormattingCommandsSequence`. |
||||||
|
*/ |
||||||
|
public final function int GetAmount() |
||||||
|
{ |
||||||
|
return commandSequence.length; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns command with index `commandIndex`. Indexation starts from `0`. |
||||||
|
* |
||||||
|
* @param commandIndex Index of the command to return. |
||||||
|
* Must be non-negative (`>= 0`) and less than `GetAmount()`. |
||||||
|
* @return Command with index `commandIndex`. |
||||||
|
* If given `commandIndex` is out of bounds - returns invalid command. |
||||||
|
* `tag` field is guaranteed to be non-`none` for commands of type |
||||||
|
* `FST_StackPush` and should be deallocated, as per usual rules. |
||||||
|
*/ |
||||||
|
public final function FormattingCommand GetCommand(int commandIndex) |
||||||
|
{ |
||||||
|
local MutableText resultTag; |
||||||
|
local FormattingCommand result; |
||||||
|
if (commandIndex < 0) return result; |
||||||
|
if (commandIndex >= commandSequence.length) return result; |
||||||
|
|
||||||
|
result = commandSequence[commandIndex]; |
||||||
|
resultTag = result.tag; |
||||||
|
if (resultTag != none) { |
||||||
|
result.tag = resultTag.MutableCopy(); |
||||||
|
} |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
private final function BuildSelf() |
||||||
|
{ |
||||||
|
local Text.Character nextCharacter; |
||||||
|
while (!parser.HasFinished()) |
||||||
|
{ |
||||||
|
parser.MCharacter(nextCharacter); |
||||||
|
// New command by "{<formatting_info> " |
||||||
|
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_OPEN_FORMAT)) |
||||||
|
{ |
||||||
|
AddCommand(FST_StackPush); |
||||||
|
parser |
||||||
|
.MUntil(currentCommand.tag,, true) |
||||||
|
.MCharacter(currentCommand.charTag); // Simply to skip a char |
||||||
|
continue; |
||||||
|
} |
||||||
|
// New command by "}" |
||||||
|
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_CLOSE_FORMAT)) |
||||||
|
{ |
||||||
|
AddCommand(FST_StackPop); |
||||||
|
continue; |
||||||
|
} |
||||||
|
// New command by "^" |
||||||
|
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_ACCENT)) |
||||||
|
{ |
||||||
|
AddCommand(FST_StackSwap); |
||||||
|
parser.MCharacter(currentCommand.charTag); |
||||||
|
if (!parser.Ok()) { |
||||||
|
break; |
||||||
|
} |
||||||
|
continue; |
||||||
|
} |
||||||
|
// Escaped sequence |
||||||
|
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_FORMAT_ESCAPE)) { |
||||||
|
parser.MCharacter(nextCharacter); |
||||||
|
} |
||||||
|
if (!parser.Ok()) { |
||||||
|
break; |
||||||
|
} |
||||||
|
currentContents[currentContents.length] = nextCharacter; |
||||||
|
characterCounter += 1; |
||||||
|
} |
||||||
|
// Only put in empty command if there is nothing else |
||||||
|
if (currentContents.length > 0 || commandSequence.length == 0) |
||||||
|
{ |
||||||
|
currentCommand.contents = currentContents; |
||||||
|
commandSequence[commandSequence.length] = currentCommand; |
||||||
|
} |
||||||
|
// We no longer use `currentCommand` and have transferred ownership over |
||||||
|
// `currentCommand.tag` to the `commandSequence`, so better forget about it |
||||||
|
// to avoid messing up. |
||||||
|
currentCommand.tag = none; |
||||||
|
} |
||||||
|
|
||||||
|
// Helper method for a adding `currentCommand` to the command sequence and |
||||||
|
// quick creation of a new `FormattingCommand` in its place |
||||||
|
private final function AddCommand(FormattingCommandType newStackCommandType) |
||||||
|
{ |
||||||
|
local int lastPushIndex; |
||||||
|
local int lastCharacterIndex; |
||||||
|
local FormattingCommand newCommand; |
||||||
|
currentCommand.contents = currentContents; |
||||||
|
currentContents.length = 0; |
||||||
|
commandSequence[commandSequence.length] = currentCommand; |
||||||
|
// Last (so far) character index in a string equals total amount of |
||||||
|
// parsed characters minus one |
||||||
|
lastCharacterIndex = characterCounter - 1; |
||||||
|
if (newStackCommandType == FST_StackPop) |
||||||
|
{ |
||||||
|
lastPushIndex = PopIndex(); |
||||||
|
if (lastPushIndex >= 0) { |
||||||
|
commandSequence[lastPushIndex].closeIndex = lastCharacterIndex; |
||||||
|
} |
||||||
|
else if (borrowedErrors != none) { |
||||||
|
borrowedErrors.Report(FSE_UnmatchedClosingBrackets); |
||||||
|
} |
||||||
|
} |
||||||
|
newCommand.type = newStackCommandType; |
||||||
|
if (newStackCommandType == FST_StackPush) |
||||||
|
{ |
||||||
|
// Formatting should be applied to the next character, |
||||||
|
// not the currently last added one |
||||||
|
newCommand.openIndex = lastCharacterIndex + 1; |
||||||
|
newCommand.closeIndex = -1; |
||||||
|
// `FormattingCommand` that new formatting block corresponds to |
||||||
|
// is not added yet, but it is guaranteed to be added next, |
||||||
|
// we know its future index |
||||||
|
PushIndex(commandSequence.length); |
||||||
|
} |
||||||
|
currentCommand = newCommand; |
||||||
|
} |
||||||
|
|
||||||
|
private final function int PopIndex() |
||||||
|
{ |
||||||
|
local int result; |
||||||
|
if (pushCommandIndicesStack.length <= 0) { |
||||||
|
return -1; |
||||||
|
} |
||||||
|
result = pushCommandIndicesStack[pushCommandIndicesStack.length - 1]; |
||||||
|
pushCommandIndicesStack.length = pushCommandIndicesStack.length - 1; |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
private final function PushIndex(int index) |
||||||
|
{ |
||||||
|
pushCommandIndicesStack[pushCommandIndicesStack.length] = |
||||||
|
commandSequence.length; |
||||||
|
} |
||||||
|
|
||||||
|
defaultproperties |
||||||
|
{ |
||||||
|
} |
||||||
@ -0,0 +1,548 @@ |
|||||||
|
/** |
||||||
|
* A simple parser with a single public method for parsing formatted strings. |
||||||
|
* Was introduced instead of a simple method in `MutableText` to: |
||||||
|
* 1. Allow for reporting errors caused by badly specified colors; |
||||||
|
* 2. Allow for a more complicated case of specifying a color gradient |
||||||
|
* range. |
||||||
|
* Copyright 2022 Anton Tarasenko |
||||||
|
*------------------------------------------------------------------------------ |
||||||
|
* This file is part of Acedia. |
||||||
|
* |
||||||
|
* Acedia is free software: you can redistribute it and/or modify |
||||||
|
* it under the terms of the GNU General Public License as published by |
||||||
|
* the Free Software Foundation, version 3 of the License, or |
||||||
|
* (at your option) any later version. |
||||||
|
* |
||||||
|
* Acedia is distributed in the hope that it will be useful, |
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
* GNU General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||||
|
*/ |
||||||
|
class FormattingStringParser extends AcediaObject |
||||||
|
dependson(Text) |
||||||
|
dependson(FormattingErrorsReport) |
||||||
|
dependson(FormattingCommandsSequence); |
||||||
|
|
||||||
|
/** |
||||||
|
* # Usage |
||||||
|
* |
||||||
|
* Public interface of this parser consists of a single static method |
||||||
|
* `ParseFormatted()` that temporarily creates (and auto deallocates before |
||||||
|
* method has returned) instance of its own class to store the state necessary |
||||||
|
* during parsing. |
||||||
|
* |
||||||
|
* # Implementation |
||||||
|
* |
||||||
|
* ## Formatting commands |
||||||
|
* |
||||||
|
* The algorithm looks at formatting block "{<color_tag> ...}" as a set |
||||||
|
* of two operations: turn on a certain formatting ("{<color_tag>") and |
||||||
|
* turn it off ("}"). Since blocks can be folded into each other, as we parse |
||||||
|
* the string we put opened ones onto the stack, closing them upon |
||||||
|
* encountering "}". Short color tags "^<color_character>" are handled by |
||||||
|
* switching formatting within the current block. |
||||||
|
* Overall this leads us to transforming markdown of formatted string into |
||||||
|
* sequence of three operations: |
||||||
|
* 1. Put formatting onto the formatting stack (and add following |
||||||
|
* contents); |
||||||
|
* 2. Pop formatting off the formatting stack (and add following contents); |
||||||
|
* 3. Swap formatting on top of the formatting stack (and add following |
||||||
|
* contents). |
||||||
|
* Transforming formatted string in such a sequence is moved out from this |
||||||
|
* class into auxiliary `FormattingCommandsSequence`, since it task is |
||||||
|
* logically separated from the one that comes next... |
||||||
|
* |
||||||
|
* ## Building `MutableText` |
||||||
|
* |
||||||
|
* Once we have broken formatted string down into sequence of formatted |
||||||
|
* commands, we only need to go through them, command-by-command, appending |
||||||
|
* their contents to the resulting `MutableText` with formatting, specified by |
||||||
|
* the command. |
||||||
|
* The only somewhat complicated part here are formatted blocks with |
||||||
|
* specified gradient coloring |
||||||
|
* ("<color_1>:<color_2>:<color_3>[<point>]:<color_4>"). For that we make use |
||||||
|
* of the information about starting and ending indices of gradient formatted |
||||||
|
* block, given by `FormattingCommandsSequence`: |
||||||
|
* * We correct/uniformly place missing points where each intermediate |
||||||
|
* color must be at 100% on the segment [0; 1], where 0 represents |
||||||
|
* start of the formatting block and 1 its end; |
||||||
|
* * Then for each character we determine between which color it lies and |
||||||
|
* how far from each of them (again on the scale from 0 to 1, |
||||||
|
* where `0` is left color and `1` is right color); |
||||||
|
* * Finally we use linear interpolation between selected pair of colors to |
||||||
|
* determine appropriate formatting. |
||||||
|
*/ |
||||||
|
|
||||||
|
/** |
||||||
|
* Element of the formatting stack, that completely defines formatting block. |
||||||
|
*/ |
||||||
|
struct FormattingInfo |
||||||
|
{ |
||||||
|
// Is segment even colored? |
||||||
|
var bool colored; |
||||||
|
// Does it use color gradient? |
||||||
|
var bool gradient; |
||||||
|
// Color of the segment, only used when `gradient` equals `true` |
||||||
|
var Color plainColor; |
||||||
|
// All the colors for gradient inside the segment, only used when |
||||||
|
// `gradient` equals `false` |
||||||
|
var array<Color> gradientColors; |
||||||
|
// Points (from 0 to 1) at which each `gradientColors` with the same index |
||||||
|
// should be at its 100% |
||||||
|
var array<float> gradientPoints; |
||||||
|
// To decide how to color each character we need to know position of |
||||||
|
// the segment, it is convenient for us to store it as a starting point |
||||||
|
// and length. |
||||||
|
// Length is stored as `float` because it will mostly be used as |
||||||
|
// a divisor of some values and we need a `float` result. |
||||||
|
var int gradientStart; |
||||||
|
var float gradientLength; |
||||||
|
}; |
||||||
|
// Formatted `string` can have an arbitrary level of folded format definitions, |
||||||
|
// this array is used as a stack to keep track of opened formatting blocks |
||||||
|
// when appending formatted `string`. |
||||||
|
var private array<FormattingInfo> formattingStack; |
||||||
|
// Keep top element copied into a separate variable for quicker access. |
||||||
|
// Must maintain invariant: if `formattingStack.length > 0` |
||||||
|
// then `formattingStack[formattingStack.length - 1] == formattingStackHead`. |
||||||
|
var private FormattingInfo formattingStackHead; |
||||||
|
// For calculating gradient we need to know what character we are |
||||||
|
// currently adding. |
||||||
|
var private int nextCharacterIndex; |
||||||
|
// `FormattingStringParser` itself only performs "stage 2" of the algorithm, |
||||||
|
// while "stage 1" (converting formatted string into a sequence of commands is |
||||||
|
// done by this object). |
||||||
|
var private FormattingCommandsSequence commandSequence; |
||||||
|
// Text we are appending formatted string to |
||||||
|
var private MutableText borrowedTarget; |
||||||
|
var private FormattingErrorsReport borrowedErrors; |
||||||
|
|
||||||
|
// Keep this as an easy access to separator of gradient colors ':' |
||||||
|
var private Text.Character separatorCharacter; |
||||||
|
|
||||||
|
var private const int TOPENING_BRACKET, TCLOSING_BRACKET, TPERCENT; |
||||||
|
|
||||||
|
protected function Constructor() |
||||||
|
{ |
||||||
|
separatorCharacter = _.text.GetCharacter(":"); |
||||||
|
} |
||||||
|
|
||||||
|
protected function Finalizer() |
||||||
|
{ |
||||||
|
formattingStack.length = 0; |
||||||
|
_.memory.Free(commandSequence); // the only object we have owned |
||||||
|
commandSequence = none; |
||||||
|
borrowedTarget = none; |
||||||
|
borrowedErrors = none; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Parses formatted string given by the `source`. |
||||||
|
* |
||||||
|
* As a result of parsing can either append it to given `MutableText` or |
||||||
|
* report any errors in its formatting. |
||||||
|
* |
||||||
|
* @param source `Text` to parse as a formatted string. |
||||||
|
* @param target Method will append result of parsing `source` into |
||||||
|
* this parameter. Does nothing if it is equal to `none`. |
||||||
|
* @param doReportErrors Set this to `true` if you want parsing errors to be |
||||||
|
* reported in the return value and `false` otherwise. |
||||||
|
* @return Array of formatting errors in the given `source` formatted string, |
||||||
|
* each represented by `FormattedStringError` struct. |
||||||
|
* Errors are only generated if `doReportErrors` is equals to `true`. |
||||||
|
* If `doReportErrors` is `false`, then returned value is guaranteed to be |
||||||
|
* an empty array. |
||||||
|
* Each `FormattedStringError` item in array has either: |
||||||
|
* * non-`none` `cause` field or; |
||||||
|
* * strictly positive `count > 0` field. |
||||||
|
* But never both. |
||||||
|
* `count` field is always guaranteed to be non-negative. |
||||||
|
* WARNING: `FormattedStringError` struct may contain `Text` objects that |
||||||
|
* should be deallocated, as per usual rules. |
||||||
|
*/ |
||||||
|
public static final function array<FormattingErrorsReport.FormattedStringError> |
||||||
|
ParseFormatted( |
||||||
|
Text source, |
||||||
|
optional MutableText target, |
||||||
|
optional bool doReportErrors) |
||||||
|
{ |
||||||
|
local FormattingErrorsReport newErrorsReport; |
||||||
|
local FormattingStringParser newFormattingParser; |
||||||
|
local array<FormattingErrorsReport.FormattedStringError> resultErrors; |
||||||
|
if (source == none) return resultErrors; |
||||||
|
if (target == none && !doReportErrors) return resultErrors; |
||||||
|
|
||||||
|
// Setup formatting parser |
||||||
|
newFormattingParser = FormattingStringParser(__().memory |
||||||
|
.Allocate(class'FormattingStringParser')); |
||||||
|
if (doReportErrors) |
||||||
|
{ |
||||||
|
newErrorsReport = FormattingErrorsReport(__().memory |
||||||
|
.Allocate(class'FormattingErrorsReport')); |
||||||
|
newFormattingParser.borrowedErrors = newErrorsReport; |
||||||
|
} |
||||||
|
newFormattingParser.commandSequence = |
||||||
|
class'FormattingCommandsSequence'.static |
||||||
|
.FromText(source, newErrorsReport); |
||||||
|
newFormattingParser.borrowedTarget = target; |
||||||
|
// Do it and release resources |
||||||
|
newFormattingParser.DoAppend(); |
||||||
|
// We have only set these fields for access convenience and we |
||||||
|
// neither own `target` that will contain appended formatted string, |
||||||
|
// nor errors report that user requires, so release them right after use |
||||||
|
newFormattingParser.borrowedTarget = none; |
||||||
|
newFormattingParser.borrowedErrors = none; |
||||||
|
__().memory.Free(newFormattingParser); |
||||||
|
if (newErrorsReport != none) |
||||||
|
{ |
||||||
|
resultErrors = newErrorsReport.GetErrors(); |
||||||
|
__().memory.Free(newErrorsReport); |
||||||
|
} |
||||||
|
return resultErrors; |
||||||
|
} |
||||||
|
|
||||||
|
private final function DoAppend() |
||||||
|
{ |
||||||
|
local int i; |
||||||
|
local Text.Formatting emptyFormatting; |
||||||
|
local FormattingCommandsSequence.FormattingCommand nextCommand; |
||||||
|
SetupFormattingStack(emptyFormatting); |
||||||
|
// First element of color stack is special and has no color information; |
||||||
|
// see `BuildFormattingStackCommands()` for details. |
||||||
|
nextCommand = commandSequence.GetCommand(0); |
||||||
|
// First block is always not formatted |
||||||
|
if (borrowedTarget != none) { |
||||||
|
borrowedTarget.AppendManyRawCharacters(nextCommand.contents); |
||||||
|
} |
||||||
|
nextCharacterIndex = nextCommand.contents.length; |
||||||
|
_.memory.Free(nextCommand.tag); |
||||||
|
for (i = 1; i < commandSequence.GetAmount(); i += 1) |
||||||
|
{ |
||||||
|
nextCommand = commandSequence.GetCommand(i); |
||||||
|
if (nextCommand.type == FST_StackPush) { |
||||||
|
PushIntoFormattingStack(nextCommand); |
||||||
|
} |
||||||
|
else if (nextCommand.type == FST_StackPop) { |
||||||
|
PopFormattingStack(); |
||||||
|
} |
||||||
|
else if (nextCommand.type == FST_StackSwap) { |
||||||
|
SwapFormattingStack(nextCommand.charTag); |
||||||
|
} |
||||||
|
_.memory.Free(nextCommand.tag); |
||||||
|
if (borrowedTarget != none) { |
||||||
|
AppendToTarget(nextCommand.contents); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Auxiliary method for appending `contents` character with an appropriate |
||||||
|
// formatting and parser's state modification. |
||||||
|
private final function AppendToTarget(array<Text.Character> contents) |
||||||
|
{ |
||||||
|
local int i; |
||||||
|
if (!IsCurrentFormattingGradient()) |
||||||
|
{ |
||||||
|
borrowedTarget.AppendManyRawCharacters( |
||||||
|
contents, |
||||||
|
GetFormattingFor(nextCharacterIndex)); |
||||||
|
nextCharacterIndex += contents.length; |
||||||
|
return; |
||||||
|
} |
||||||
|
for (i = 0; i < contents.length; i += 1) |
||||||
|
{ |
||||||
|
borrowedTarget.AppendRawCharacter( |
||||||
|
contents[i], |
||||||
|
GetFormattingFor(nextCharacterIndex)); |
||||||
|
nextCharacterIndex += 1; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private final function Report( |
||||||
|
FormattingErrorsReport.FormattedStringErrorType type, |
||||||
|
optional Text cause) |
||||||
|
{ |
||||||
|
if (borrowedErrors == none) { |
||||||
|
return; |
||||||
|
} |
||||||
|
borrowedErrors.Report(type, cause); |
||||||
|
} |
||||||
|
|
||||||
|
private final function bool IsCurrentFormattingGradient() |
||||||
|
{ |
||||||
|
if (formattingStack.length <= 0) { |
||||||
|
return false; |
||||||
|
} |
||||||
|
return formattingStackHead.gradient; |
||||||
|
} |
||||||
|
|
||||||
|
private final function Text.Formatting GetFormattingFor(int index) |
||||||
|
{ |
||||||
|
local Text.Formatting emptyFormatting; |
||||||
|
if (formattingStack.length <= 0) return emptyFormatting; |
||||||
|
if (!formattingStackHead.colored) return emptyFormatting; |
||||||
|
|
||||||
|
return _.text.FormattingFromColor(GetColorFor(index)); |
||||||
|
} |
||||||
|
|
||||||
|
private final function Color GetColorFor(int index) |
||||||
|
{ |
||||||
|
local int i; |
||||||
|
local float indexPosition, leftPosition, rightPosition; |
||||||
|
local array<float> points; |
||||||
|
local Color leftColor, rightColor, targetColor; |
||||||
|
if (formattingStack.length <= 0) return targetColor; |
||||||
|
if (!formattingStackHead.gradient) return formattingStackHead.plainColor; |
||||||
|
|
||||||
|
indexPosition = float(index - formattingStackHead.gradientStart) / |
||||||
|
formattingStackHead.gradientLength; |
||||||
|
points = formattingStackHead.gradientPoints; |
||||||
|
for (i = 1; i < points.length; i += 1) |
||||||
|
{ |
||||||
|
if (points[i - 1] <= indexPosition && indexPosition <= points[i]) |
||||||
|
{ |
||||||
|
leftPosition = points[i - 1]; |
||||||
|
rightPosition = points[i]; |
||||||
|
leftColor = formattingStackHead.gradientColors[i - 1]; |
||||||
|
rightColor = formattingStackHead.gradientColors[i]; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
indexPosition = |
||||||
|
(indexPosition - leftPosition) / (rightPosition - leftPosition); |
||||||
|
targetColor.R = Lerp(indexPosition, leftColor.R, rightColor.R); |
||||||
|
targetColor.G = Lerp(indexPosition, leftColor.G, rightColor.G); |
||||||
|
targetColor.B = Lerp(indexPosition, leftColor.B, rightColor.B); |
||||||
|
targetColor.A = Lerp(indexPosition, leftColor.A, rightColor.A); |
||||||
|
return targetColor; |
||||||
|
} |
||||||
|
|
||||||
|
private final function FormattingInfo ParseFormattingInfo(Text colorTag) |
||||||
|
{ |
||||||
|
local int i; |
||||||
|
local Parser colorParser; |
||||||
|
local Color nextColor; |
||||||
|
local array<MutableText> specifiedColors; |
||||||
|
local array<Color> gradientColors; |
||||||
|
local array<float> gradientPoints; |
||||||
|
local FormattingInfo targetInfo; |
||||||
|
if (colorTag.IsEmpty()) |
||||||
|
{ |
||||||
|
Report(FSE_EmptyColorTag); |
||||||
|
return targetInfo; // not colored |
||||||
|
} |
||||||
|
specifiedColors = colorTag.SplitByCharacter(separatorCharacter, true); |
||||||
|
for (i = 0; i < specifiedColors.length; i += 1) |
||||||
|
{ |
||||||
|
colorParser = _.text.Parse(specifiedColors[i]); |
||||||
|
if (_.color.ParseWith(colorParser, nextColor)) |
||||||
|
{ |
||||||
|
colorParser.Confirm(); |
||||||
|
gradientColors[gradientColors.length] = nextColor; |
||||||
|
gradientPoints[gradientPoints.length] = ParsePoint(colorParser); |
||||||
|
} |
||||||
|
else { |
||||||
|
Report(FSE_BadColor, specifiedColors[i]); |
||||||
|
} |
||||||
|
_.memory.Free(colorParser); |
||||||
|
} |
||||||
|
_.memory.FreeMany(specifiedColors); |
||||||
|
gradientPoints = NormalizePoints(gradientPoints); |
||||||
|
targetInfo.colored = (gradientColors.length > 0); |
||||||
|
targetInfo.gradient = (gradientColors.length > 1); |
||||||
|
targetInfo.gradientColors = gradientColors; |
||||||
|
targetInfo.gradientPoints = gradientPoints; |
||||||
|
if (gradientColors.length > 0) { |
||||||
|
targetInfo.plainColor = gradientColors[0]; |
||||||
|
} |
||||||
|
return targetInfo; |
||||||
|
} |
||||||
|
|
||||||
|
private final function float ParsePoint(Parser parser) |
||||||
|
{ |
||||||
|
local float point; |
||||||
|
local Parser.ParserState initialState; |
||||||
|
if (!parser.Ok() || parser.HasFinished()) { |
||||||
|
return -1; |
||||||
|
} |
||||||
|
initialState = parser.GetCurrentState(); |
||||||
|
// [Necessary part] Should starts with "[" |
||||||
|
if (!parser.Match(T(TOPENING_BRACKET)).Ok()) |
||||||
|
{ |
||||||
|
Report( |
||||||
|
FSE_BadGradientPoint, |
||||||
|
parser.RestoreState(initialState).GetRemainder()); |
||||||
|
return -1; |
||||||
|
} |
||||||
|
// [Necessary part] Try parsing number |
||||||
|
parser.MNumber(point).Confirm(); |
||||||
|
if (!parser.Ok()) |
||||||
|
{ |
||||||
|
Report( |
||||||
|
FSE_BadGradientPoint, |
||||||
|
parser.RestoreState(initialState).GetRemainder()); |
||||||
|
return -1; |
||||||
|
} |
||||||
|
// [Optional part] Check if number is a percentage |
||||||
|
if (parser.Match(T(TPERCENT)).Ok()) { |
||||||
|
point *= 0.01; |
||||||
|
} |
||||||
|
// This either confirms state of parsing "%" (on success) |
||||||
|
// or reverts to the previous state, just after parsing the number |
||||||
|
// (on failure) |
||||||
|
parser.Confirm(); |
||||||
|
parser.R(); |
||||||
|
// [Necessary part] Have to have closing parenthesis |
||||||
|
if (!parser.HasFinished()) { |
||||||
|
parser.Match(T(TCLOSING_BRACKET)).Confirm(); |
||||||
|
} |
||||||
|
// Still return `point`, even if there was no closing parenthesis, |
||||||
|
// since that is likely what user wants |
||||||
|
if (!parser.Ok()) |
||||||
|
{ |
||||||
|
Report( |
||||||
|
FSE_BadGradientPoint, |
||||||
|
parser.RestoreState(initialState).GetRemainder()); |
||||||
|
} |
||||||
|
return point; |
||||||
|
} |
||||||
|
|
||||||
|
private final function array<float> NormalizePoints(array<float> points) |
||||||
|
{ |
||||||
|
local int i, j; |
||||||
|
local int negativeSegmentStart, negativeSegmentLength; |
||||||
|
local float leftPositiveBound, rightPositiveBound; |
||||||
|
local bool foundNegative; |
||||||
|
// Leftmost and rightmost points are always fixed |
||||||
|
if (points.length > 1) |
||||||
|
{ |
||||||
|
points[0] = 0.0; |
||||||
|
points[points.length - 1] = 1.0; |
||||||
|
} |
||||||
|
for (i = 1; i < points.length - 1; i += 1) |
||||||
|
{ |
||||||
|
// Each point must be in bounds (between `0` and `1`) and points |
||||||
|
// must be specified in an increasing order. |
||||||
|
// If either does not hold - simply mark point as unspecified and |
||||||
|
// let let it be regenerated naturally. |
||||||
|
if (points[i] <= 0 || points[i] > 1 || points[i] <= points[i - 1]) { |
||||||
|
points[i] = -1; |
||||||
|
} |
||||||
|
} |
||||||
|
// Check all points - if a sequence of them are undefined, then place |
||||||
|
// them uniformly between bounding non-negative points. |
||||||
|
// For example [0.5, -1, -1, -1, -1, 1] should turn into |
||||||
|
// [0.5, 0.6, 0.7, 0.8, 0.9, 1.0]. |
||||||
|
// NOTE: at the beginning of this method we have forced `points[0]` |
||||||
|
// to be `0.0` and `points[points.length - 1]` to be `1.0`. Thanks to that |
||||||
|
// there always exists left and right non-negative bounding points. |
||||||
|
for (i = 1; i < points.length; i += 1) |
||||||
|
{ |
||||||
|
// Found first element of negative sequence |
||||||
|
if (!foundNegative && points[i] < 0) |
||||||
|
{ |
||||||
|
leftPositiveBound = points[i - 1]; |
||||||
|
negativeSegmentStart = i; |
||||||
|
} |
||||||
|
// Found where negative sequence ends |
||||||
|
if (foundNegative && points[i] > 0) |
||||||
|
{ |
||||||
|
rightPositiveBound = points[i]; |
||||||
|
for (j = negativeSegmentStart; j < i; j += 1) |
||||||
|
{ |
||||||
|
points[j] = Lerp( |
||||||
|
float(j - negativeSegmentStart + 1) / |
||||||
|
float(negativeSegmentLength + 1), |
||||||
|
leftPositiveBound, |
||||||
|
rightPositiveBound); |
||||||
|
} |
||||||
|
negativeSegmentLength = 0; |
||||||
|
} |
||||||
|
foundNegative = (points[i] < 0); |
||||||
|
// Still continuing with negative segment |
||||||
|
if (foundNegative) { |
||||||
|
negativeSegmentLength += 1; |
||||||
|
} |
||||||
|
} |
||||||
|
return points; |
||||||
|
} |
||||||
|
|
||||||
|
// Following four functions are to maintain a "color stack" that will |
||||||
|
// remember unclosed colors (new colors are obtained from formatting commands |
||||||
|
// sequence) defined in formatted string, in order. |
||||||
|
// Stack array always contains one element, defined by |
||||||
|
// the `SetupFormattingStack()` call. It corresponds to the default formatting |
||||||
|
// that will be used when we pop all the other elements. |
||||||
|
// It is necessary to deal with possible folded formatting definitions in |
||||||
|
// formatted strings. |
||||||
|
private final function SetupFormattingStack(Text.Formatting defaultFormatting) |
||||||
|
{ |
||||||
|
local FormattingInfo defaultFormattingInfo; |
||||||
|
defaultFormattingInfo.colored = defaultFormatting.isColored; |
||||||
|
defaultFormattingInfo.plainColor = defaultFormatting.color; |
||||||
|
if (formattingStack.length > 0) { |
||||||
|
formattingStack.length = 0; |
||||||
|
} |
||||||
|
formattingStack[0] = defaultFormattingInfo; |
||||||
|
formattingStackHead = defaultFormattingInfo; |
||||||
|
} |
||||||
|
|
||||||
|
private final function PushIntoFormattingStack( |
||||||
|
FormattingCommandsSequence.FormattingCommand formattingCommand) |
||||||
|
{ |
||||||
|
formattingStackHead = ParseFormattingInfo(formattingCommand.tag); |
||||||
|
formattingStackHead.gradientStart = formattingCommand.openIndex; |
||||||
|
formattingStackHead.gradientLength = |
||||||
|
float(formattingCommand.closeIndex - formattingCommand.openIndex); |
||||||
|
formattingStack[formattingStack.length] = formattingStackHead; |
||||||
|
} |
||||||
|
|
||||||
|
private final function SwapFormattingStack(Text.Character tagCharacter) |
||||||
|
{ |
||||||
|
local FormattingInfo updatedFormatting; |
||||||
|
if (formattingStack.length > 0) { |
||||||
|
updatedFormatting = formattingStackHead; |
||||||
|
} |
||||||
|
if (_.color.ResolveShortTagColor(tagCharacter, updatedFormatting.plainColor)) |
||||||
|
{ |
||||||
|
updatedFormatting.colored = true; |
||||||
|
updatedFormatting.gradient = false; |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
Report( |
||||||
|
FSE_BadShortColorTag, |
||||||
|
_.text.FromString("^" $ Chr(tagCharacter.codePoint))); |
||||||
|
} |
||||||
|
formattingStackHead = updatedFormatting; |
||||||
|
if (formattingStack.length > 0) { |
||||||
|
formattingStack[formattingStack.length - 1] = updatedFormatting; |
||||||
|
} |
||||||
|
else { |
||||||
|
formattingStack[0] = updatedFormatting; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private final function PopFormattingStack() |
||||||
|
{ |
||||||
|
// Remove the top of the stack |
||||||
|
if (formattingStack.length > 0) { |
||||||
|
formattingStack.length = formattingStack.length - 1; |
||||||
|
} |
||||||
|
// Update the stack head copy |
||||||
|
if (formattingStack.length > 0) { |
||||||
|
formattingStackHead = formattingStack[formattingStack.length - 1]; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
defaultproperties |
||||||
|
{ |
||||||
|
TOPENING_BRACKET = 0 |
||||||
|
stringConstants(0) = "[" |
||||||
|
TCLOSING_BRACKET = 1 |
||||||
|
stringConstants(1) = "]" |
||||||
|
TPERCENT = 2 |
||||||
|
stringConstants(2) = "%" |
||||||
|
} |
||||||
Loading…
Reference in new issue