{

std::string Name;

YAML::NodeType NodeType;

bool Required;

bool Nullable;

inline NodeRequirement() : Name(""),

NodeType(YAML::NodeType::Scalar),

Required(false),

Nullable(true)

{}

inline NodeRequirement( const std::string& name,

YAML::NodeType nodeType,

bool required,

bool nullable) : Name(name),

NodeType(nodeType),

Required(required),

Nullable(nullable)

{}

const std::string& childName,

bool nullable = false)

{

ssLOG_FUNC_DEBUG();

if(node->GetChildrenCount() > 0 && node->IsMap() && node->HasMapKey(childName))

{

YAML::ConstNodePtr mapVal = node->GetMapValueNode(childName);

if(!mapVal)

return false;

if(!nullable && mapVal->IsScalar() && mapVal->GetScalar<StringView>().value_or("").empty())

return false;

return true;

}

return false;

const std::string childName,

YAML::NodeType childType,

bool required,

bool nullable)

{

ssLOG_FUNC_DEBUG();

if(!parentNode->IsMap())

{

ssLOG_ERROR("Node is not a map: " << parentNode->Value.index());

return false;

}

ssLOG_DEBUG("Checking: " << childName << " exists");

if(!ExistAndHasChild(parentNode, childName, nullable))

{

if(required)

{

if(false)

{

ssLOG_DEBUG("node.num_children(): " << parentNode->GetChildrenCount());

for(int j = 0; j < parentNode->GetChildrenCount(); ++j)

ssLOG_DEBUG(parentNode->GetMapKeyScalarAt<std::string>(j).value_or(""));

}

ssLOG_ERROR("Required field not found: " << childName);

return false;

}

return true;

}

//If type is nullable, we cannot verify it's type, so just continue

YAML::ConstNodePtr childNode = parentNode->GetMapValueNode(childName);

if(nullable && childNode->IsScalar() && childNode->GetScalar<StringView>().value_or("").empty())

return true;

if(childNode->GetType() != childType)

{

ssLOG_ERROR("Field type is invalid: " << childName);

ssLOG_ERROR("Expected: " << YAML::NodeTypeToString(childType));

ssLOG_ERROR("Found: " << YAML::NodeTypeToString(childNode->GetType()));

return false;

}

return true;

const std::vector<NodeRequirement>& requirements)

{

ssLOG_FUNC_DEBUG();

if(!node->IsMap())

{

ssLOG_ERROR("Node is not a map: " << YAML::NodeTypeToString(node->GetType()));

ssLOG_ERROR("Node is not a map");

return false;

}

//All keys must be unique

{

std::unordered_set<std::string> childKeys;

for(int i = 0; i < node->GetChildrenCount(); ++i)

{

YAML::ConstNodePtr keyNode = node->GetMapKeyNodeAt(i);

if(!keyNode->IsScalar())

{

ssLOG_ERROR("Key must be scalar");

return false;

}

std::string currentKey = (std::string)keyNode->GetScalar<StringView>().value_or("");

if(childKeys.count(currentKey) != 0)

{

ssLOG_ERROR("Duplicate key found for: " << currentKey);

return false;

}

else

childKeys.insert(currentKey);

}

}

for(int i = 0; i < requirements.size(); ++i)

{

if(!CheckNodeRequirement( node,

requirements[i].Name,

requirements[i].NodeType,

requirements[i].Required,

requirements[i].Nullable))

{

return false;

}

}

return true;

std::string& outParsableInfo)

{

ssLOG_FUNC_DEBUG();

std::string source = contentToParse;

//Remove all \r characters

for(int i = 0; i < source.size(); i++)

{

if(source[i] == '\r')

{

source.erase(i, 1);

--i;

}

}

const std::string prefix = "runcpp2";

std::string currentLine;

bool insideCommentToParse = false;

bool singleLineComments = false;

bool preceedingSpace = false;

bool contentReadyToParse = false;

auto resetPrefixState = [&]()

{

//Clear values

insideCommentToParse = false;

singleLineComments = false;

preceedingSpace = false;

outParsableInfo.clear();

contentReadyToParse = false;

};

auto checkFinishedGettingParsableContent = [&]() -> DS::Result<bool>

{

if(singleLineComments)

{

//Check for end of continuous section

if(currentLine.size() < 2 || currentLine[0] != '/' || currentLine[1] != '/')

{

contentReadyToParse = true;

return true;

}

if(preceedingSpace && currentLine.size() < 3)

{

resetPrefixState();

return DS_ERROR_MSG("Inconsistent spacing for single line comment");

}

}

else

{

//Check for closing */

if( currentLine.size() >= 2 &&

currentLine[currentLine.size() - 1] == '/' &&

currentLine[currentLine.size() - 2] == '*')

{

currentLine.erase(currentLine.size() - 2, 2);

TrimRight(currentLine);

outParsableInfo += currentLine;

contentReadyToParse = true;

return true;

}

}

return false;

};

for(int i = 0; i < source.size(); i++)

{

//Just append character if not newline

if(source[i] != '\n')

currentLine.push_back(source[i]);

//Newline is reached, parse the current line

else

{

//Try to find prefix that indicates the content inside the comment for parsing

if(!insideCommentToParse)

{

Trim(currentLine);

if(currentLine == "// " + prefix || currentLine == "//" + prefix)

{

insideCommentToParse = true;

singleLineComments = true;

preceedingSpace = (currentLine + prefix).at(2) == ' ';

currentLine.clear();

continue;

}

if(currentLine == "/* " + prefix || currentLine == "/*" + prefix)

{

insideCommentToParse = true;

singleLineComments = false;

preceedingSpace = false;

currentLine.clear();

continue;

}

currentLine.clear();

}

//Parse the content

else

{

if(singleLineComments)

{

Trim(currentLine);

bool check = checkFinishedGettingParsableContent().DS_TRY();

if(check)

break;

currentLine.erase(0, (preceedingSpace ? 3 : 2));

currentLine += '\n';

outParsableInfo += currentLine;

}

//If inside block comment

else

{

TrimRight(currentLine);

bool check = checkFinishedGettingParsableContent().DS_TRY();

if(check)

break;

currentLine += '\n';

outParsableInfo += currentLine;

}

currentLine.clear();

}

} //else

//Special case for last character/line

if(i == source.size() - 1 && insideCommentToParse)

{

TrimRight(currentLine);

if(singleLineComments)

{

bool check = checkFinishedGettingParsableContent().DS_TRY();

if(check)

break;

currentLine.erase(0, (preceedingSpace ? 3 : 2));

outParsableInfo += currentLine;

contentReadyToParse = true;

}

else

{

bool check = checkFinishedGettingParsableContent().DS_TRY();

if(check)

break;

//resetPrefixState();

return DS_ERROR_MSG("Missing closing */ in block comment");

}

}

} //for(int i = 0; i < source.size(); i++)

if(!contentReadyToParse)

outParsableInfo.clear();

return {};

YAML::NodePtr nodeToMergeTo,

YAML::ResourceHandle& yamlResouce)

{

ssLOG_FUNC_DEBUG();

if(!nodeToMergeFrom->IsMap() || !nodeToMergeTo->IsMap())

{

ssLOG_ERROR("Merge node is not map");

return false;

}

for(int i = 0; i < nodeToMergeFrom->GetChildrenCount(); ++i)

{

std::string key = nodeToMergeFrom ->GetMapKeyScalarAt<std::string>(i)

.DS_TRY_ACT(return false);

if(!ExistAndHasChild(nodeToMergeTo, key, true))

{

YAML::NodePtr fromNode = nodeToMergeFrom->GetMapValueNodeAt(i);

fromNode->CloneToMapChild(key, nodeToMergeTo, yamlResouce).DS_TRY_ACT(return false);

}

}

return true;

{

std::string output = "\"";

for(char c : input)

{

switch(c)

{

case '\\': output += "\\\\"; break;

case '\"': output += "\\\""; break;

case '\'': output += "\\\'"; break;

case '\n': output += "\\n"; break;

case '\t': output += "\\t"; break;

default: output += c;

}

}

output += "\"";

return output;

{

//Skip if not an include line

if(line.find("#include") == std::string::npos)

return false;

size_t firstQuote = line.find('\"');

size_t firstBracket = line.find('<');

//Skip if no valid include format found

if(firstQuote == std::string::npos && firstBracket == std::string::npos)

return false;

bool isQuoted = firstQuote != std::string::npos &&

(firstBracket == std::string::npos || firstQuote < firstBracket);

size_t start = isQuoted ? firstQuote + 1 : firstBracket + 1;

size_t end = line.find(isQuoted ? '\"' : '>', start);

if(end == std::string::npos)

return false;

outIncludePath = line.substr(start, end - start);

return true;

const std::string& key,

std::unordered_map<PlatformName, T>& result,

const std::string& errorMessage)

{

if(ExistAndHasChild(node, key))

{

YAML::ConstNodePtr mapNode = node->GetMapValueNode(key);

//If we skip platform profile

T defaultValue;

if(defaultValue.IsYAML_NodeParsableAsDefault(mapNode))

{

if(defaultValue.ParseYAML_NodeWithProfile(mapNode, "DefaultProfile"))

result["DefaultPlatform"] = defaultValue;

else

return false;

}

else

{

if(!CheckNodeRequirement(node, key, YAML::NodeType::Map, false, true))

return false;

for(int i = 0; i < mapNode->GetChildrenCount(); ++i)

{

PlatformName platform =

mapNode ->GetMapKeyScalarAt<std::string>(i)

.DS_TRY_ACT(ssLOG_ERROR(DS_TMP_ERROR.ToString()); return false);

T value;

YAML::ConstNodePtr currentNode = mapNode->GetMapValueNodeAt(i);

if(!value.ParseYAML_Node(currentNode))

{

ssLOG_ERROR("ScriptInfo: Failed to parse " << errorMessage);

return false;

}

result[platform] = value;

}

}

}

return true;

const std::string& escapedString,

const std::vector<std::string>& foundSubstitutions,

const std::vector<int>& substitutionsLocations,

const std::vector<int>& substitutionsLengths,

std::string& inOutSubstitutedString,

const std::vector<char>& escapeChars,

int substituteValueIndex = 0)

{

ssLOG_FUNC_DEBUG();

inOutSubstitutedString = escapedString;

for(int i = foundSubstitutions.size() - 1; i >= 0; --i)

{

const std::string& substitution = foundSubstitutions[i];

if(substitutionMap.count(substitution) == 0)

{

ssLOG_DEBUG("substitution: " << substitution << " not found in substitution map, "

"skipping...");

continue;

}

//The substitution values can either be 1

//(in which case will be the same value regardless of substituteValueIndex)

//Or the index being requested.

int useIndex = substituteValueIndex;

if(substitutionMap.at(substitution).size() == 1)

useIndex = 0;

DS_ASSERT_LT(useIndex, substitutionMap.at(substitution).size());

std::string currentValue = substitutionMap.at(substitution).at(useIndex);

//Escape escapes character at the end if any

{

if(!currentValue.empty())

{

int currentValIndex = currentValue.size();

while(currentValIndex-- > 0)

{

bool found = false;

for(int j = 0; j < escapeChars.size(); ++j)

{

if(currentValue[currentValIndex] == escapeChars[j])

{

found = true;

break;

}

}

if(!found)

{

++currentValIndex;

break;

}

}

if(currentValIndex < currentValue.size())

{

const std::string foundEscapes = currentValue.substr(currentValIndex);

std::string newEndEscapes;

//Just repeat the escape characters

for(int j = 0; j < foundEscapes.size(); ++j)

{

newEndEscapes.push_back(foundEscapes[j]);

newEndEscapes.push_back(foundEscapes[j]);

}

currentValue = currentValue.substr(0, currentValIndex) + newEndEscapes;

}

}

}

ssLOG_DEBUG("Replacing \"" << substitution << "\" with \"" << currentValue <<

"\" in \"" << escapedString << "\"");

//TODO: Instead of doing replace, we should just memcpy and rebuild the string

inOutSubstitutedString.replace( substitutionsLocations.at(i),

substitutionsLengths.at(i),

currentValue);

}

return {};

std::string& outEscapedString,

std::vector<std::string>& outFoundSubstitutions,

std::vector<int>& outFoundLocations,

std::vector<int>& outFoundLength)

{

ssLOG_FUNC_DEBUG();

outEscapedString.clear();

std::string currentSubstitution;

int lastOpenBracketIndex = -1;

for(int i = 0; i < processString.size(); ++i)

{

if(processString[i] == '{')

{

if(i == processString.size() - 1)

{

if(lastOpenBracketIndex == -1 || lastOpenBracketIndex != i - 1)

ssLOG_WARNING("Unescaped { at the end: " << processString);

outEscapedString += '{';

continue;

}

//If we have opening bracket for the next character,

//this is an escaping character

if(processString[i + 1] == '{')

{

outEscapedString += '{';

if(lastOpenBracketIndex != -1)

currentSubstitution += '{';

++i;

continue;

}

if(lastOpenBracketIndex != -1)

{

ssLOG_WARNING( "Unescaped { at index " << lastOpenBracketIndex <<

": " << processString);

}

lastOpenBracketIndex = i;

currentSubstitution = "{";

outEscapedString += '{';

}

else if(processString[i] == '}')

{

//If we have closing bracket for the next character,

//this is an escaping character

if(i < processString.size() - 1 && processString[i + 1] == '}')

{

outEscapedString += '}';

if(lastOpenBracketIndex != -1)

currentSubstitution += '}';

++i;

continue;

}

//If there's no open bracket, give warning

if(lastOpenBracketIndex == -1)

{

ssLOG_WARNING("Unescaped } at index " << i << ": " << processString);

continue;

}

//Add substitution

outEscapedString += '}';

currentSubstitution += '}';

ssLOG_DEBUG("Substitution " << currentSubstitution << " found");

outFoundSubstitutions.push_back(currentSubstitution);

outFoundLocations.push_back(outEscapedString.size() - currentSubstitution.size());

outFoundLength.push_back(currentSubstitution.size());

//Reset

lastOpenBracketIndex = -1;

currentSubstitution.clear();

}

//Normal characters

else

{

outEscapedString += processString[i];

if(lastOpenBracketIndex != -1)

currentSubstitution += processString[i];

}

}

const std::vector<char>& escapeChars,

std::string& inOutSubstitutedString)

{

std::string escapedString;

std::vector<std::string> foundSubstitutions;

std::vector<int> substitutionsLocations;

std::vector<int> substitutionsLengths;

GetEscapedStringAndExtractSubstitutions(inOutSubstitutedString,

escapedString,

foundSubstitutions,

substitutionsLocations,

substitutionsLengths);

DS_ASSERT_EQ(foundSubstitutions.size(), substitutionsLocations.size());

DS_ASSERT_EQ(foundSubstitutions.size(), substitutionsLengths.size());

PerformSubstitutionsWithInfo( substitutionMap,

escapedString,

foundSubstitutions,

substitutionsLocations,

substitutionsLengths,

inOutSubstitutedString,

escapeChars)

.DS_TRY();

return {};

const std::vector<char>& escapeChars,

const std::string& inString,

std::vector<std::string>& outStrings)

{

std::string escapedString;

std::vector<std::string> foundSubstitutions;

std::vector<int> substitutionsLocations;

std::vector<int> substitutionsLengths;

GetEscapedStringAndExtractSubstitutions(inString,

escapedString,

foundSubstitutions,

substitutionsLocations,

substitutionsLengths);

DS_ASSERT_EQ(foundSubstitutions.size(), substitutionsLocations.size());

DS_ASSERT_EQ(foundSubstitutions.size(), substitutionsLengths.size());

int foundSize = -1;

for(int i = 0; i < foundSubstitutions.size(); ++i)

{

if(substitutionMap.count(foundSubstitutions[i]) > 0)

{

if(foundSize == -1)

foundSize = substitutionMap.at(foundSubstitutions[i]).size();

else

{

if(substitutionMap.at(foundSubstitutions[i]).size() != 1)

{

if(foundSize == 1)

{

foundSize = substitutionMap.at(foundSubstitutions[i]).size();

continue;

}

else if(foundSize == substitutionMap.at(foundSubstitutions[i]).size())

continue;

return DS_ERROR_MSG("Mismatching array size when substituting with " +

foundSubstitutions[i]);

}

}

}

}

//No substitutions in the input, just pass it back out

if(foundSize == -1)

{

outStrings.emplace_back(inString);

return {};

}

for(int i = 0; i < foundSize; ++i)

{

outStrings.emplace_back(std::string());

PerformSubstitutionsWithInfo( substitutionMap,

escapedString,

foundSubstitutions,

substitutionsLocations,

substitutionsLengths,

outStrings.back(),

escapeChars,

i)

.DS_TRY();

}

return {};