src/Template.cpp
Rama master · réplica de lectura del repositorio original.
/*
* Copyright (C) 2004-2026 ZNC, see the NOTICE file for details.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <znc/Template.h>
#include <znc/FileUtils.h>
#include <znc/ZNCDebug.h>
#include <znc/Translation.h>
#include <algorithm>
using std::stringstream;
using std::vector;
using std::list;
using std::ostream;
using std::pair;
using std::map;
void CTemplateOptions::Parse(const CString& sLine) {
CString sName = sLine.Token(0, false, "=").Trim_n().AsUpper();
CString sValue = sLine.Token(1, true, "=").Trim_n();
if (sName == "ESC") {
m_eEscapeTo = CString::ToEscape(sValue);
} else if (sName == "ESCFROM") {
m_eEscapeFrom = CString::ToEscape(sValue);
}
}
CTemplate* CTemplateLoopContext::GetRow(unsigned int uIndex) {
size_t uSize = m_pvRows->size();
if (uIndex < uSize) {
if (m_bReverse) {
return (*m_pvRows)[uSize - uIndex - 1];
} else {
return (*m_pvRows)[uIndex];
}
}
return nullptr;
}
CString CTemplateLoopContext::GetValue(const CString& sName, bool bFromIf) {
CTemplate* pTemplate = GetCurRow();
if (!pTemplate) {
DEBUG("Loop [" + GetName() + "] has no row index [" +
CString(GetRowIndex()) + "]");
return "";
}
if (sName.Equals("__ID__")) {
return CString(GetRowIndex() + 1);
} else if (sName.Equals("__COUNT__")) {
return CString(GetRowCount());
} else if (sName.Equals("__ODD__")) {
return ((GetRowIndex() % 2) ? "" : "1");
} else if (sName.Equals("__EVEN__")) {
return ((GetRowIndex() % 2) ? "1" : "");
} else if (sName.Equals("__FIRST__")) {
return ((GetRowIndex() == 0) ? "1" : "");
} else if (sName.Equals("__LAST__")) {
return ((GetRowIndex() == m_pvRows->size() - 1) ? "1" : "");
} else if (sName.Equals("__OUTER__")) {
return ((GetRowIndex() == 0 || GetRowIndex() == m_pvRows->size() - 1)
? "1"
: "");
} else if (sName.Equals("__INNER__")) {
return ((GetRowIndex() == 0 || GetRowIndex() == m_pvRows->size() - 1)
? ""
: "1");
}
return pTemplate->GetValue(sName, bFromIf);
}
CTemplate::~CTemplate() {
for (const auto& it : m_mvLoops) {
const vector<CTemplate*>& vLoop = it.second;
for (CTemplate* pTemplate : vLoop) {
delete pTemplate;
}
}
for (CTemplateLoopContext* pContext : m_vLoopContexts) {
delete pContext;
}
}
void CTemplate::Init() {
/* We have no CConfig in ZNC land
* Hmm... Actually, we do have it now.
CString sPath(CConfig::GetValue("WebFilesPath"));
if (!sPath.empty()) {
SetPath(sPath);
}
*/
ClearPaths();
m_pParent = nullptr;
}
CString CTemplate::ExpandFile(const CString& sFilename, bool bFromInc) {
/*if (sFilename.StartsWith("/") || sFilename.StartsWith("./")) {
return sFilename;
}*/
CString sFile(ResolveLiteral(sFilename).TrimLeft_n("/"));
for (auto& it : m_lsbPaths) {
CString& sRoot = it.first;
CString sFilePath(CDir::ChangeDir(sRoot, sFile));
// Make sure path ends with a slash because "/foo/pub*" matches
// "/foo/public_keep_out/" but "/foo/pub/*" doesn't
if (!sRoot.empty() && !sRoot.EndsWith("/")) {
sRoot += "/";
}
if (it.second && !bFromInc) {
DEBUG("\t\tSkipping path (not from INC) [" + sFilePath + "]");
continue;
}
if (CFile::Exists(sFilePath)) {
if (sRoot.empty() || sFilePath.StartsWith(sRoot)) {
DEBUG(" Found [" + sFilePath + "]");
return sFilePath;
} else {
DEBUG("\t\tOutside of root [" + sFilePath + "] !~ [" + sRoot +
"]");
}
}
}
switch (m_lsbPaths.size()) {
case 0:
DEBUG("Unable to find [" + sFile + "] using the current directory");
break;
case 1:
DEBUG("Unable to find [" + sFile + "] in the defined path [" +
m_lsbPaths.begin()->first + "]");
break;
default:
DEBUG("Unable to find [" + sFile + "] in any of the " +
CString(m_lsbPaths.size()) + " defined paths");
}
return "";
}
void CTemplate::SetPath(const CString& sPaths) {
VCString vsDirs;
sPaths.Split(":", vsDirs, false);
for (const CString& sDir : vsDirs) {
AppendPath(sDir, false);
}
}
CString CTemplate::MakePath(const CString& sPath) const {
CString sRet(CDir::ChangeDir("./", sPath + "/"));
if (!sRet.empty() && !sRet.EndsWith("/")) {
sRet += "/";
}
return sRet;
}
void CTemplate::PrependPath(const CString& sPath, bool bIncludesOnly) {
DEBUG("CTemplate::PrependPath(" + sPath + ") == [" + MakePath(sPath) + "]");
m_lsbPaths.push_front(make_pair(MakePath(sPath), bIncludesOnly));
}
void CTemplate::AppendPath(const CString& sPath, bool bIncludesOnly) {
DEBUG("CTemplate::AppendPath(" + sPath + ") == [" + MakePath(sPath) + "]");
m_lsbPaths.push_back(make_pair(MakePath(sPath), bIncludesOnly));
}
void CTemplate::RemovePath(const CString& sPath) {
DEBUG("CTemplate::RemovePath(" + sPath + ") == [" +
CDir::ChangeDir("./", sPath + "/") + "]");
for (const auto& it : m_lsbPaths) {
if (it.first == sPath) {
m_lsbPaths.remove(it);
RemovePath(
sPath); // @todo probably shouldn't use recursion, being lazy
return;
}
}
}
void CTemplate::ClearPaths() { m_lsbPaths.clear(); }
bool CTemplate::SetFile(const CString& sFileName) {
m_sFileName = ExpandFile(sFileName, false);
PrependPath(sFileName + "/..");
if (sFileName.empty()) {
DEBUG("CTemplate::SetFile() - Filename is empty");
return false;
}
if (m_sFileName.empty()) {
DEBUG("CTemplate::SetFile() - [" + sFileName + "] does not exist");
return false;
}
DEBUG("Set template file to [" + m_sFileName + "]");
return true;
}
class CLoopSorter {
CString m_sType;
public:
CLoopSorter(const CString& sType) : m_sType(sType) {}
bool operator()(CTemplate* pTemplate1, CTemplate* pTemplate2) {
return (pTemplate1->GetValue(m_sType, false) <
pTemplate2->GetValue(m_sType, false));
}
};
CTemplate& CTemplate::AddRow(const CString& sName) {
CTemplate* pTmpl = new CTemplate(m_spOptions, this);
m_mvLoops[sName].push_back(pTmpl);
return *pTmpl;
}
CTemplate* CTemplate::GetRow(const CString& sName, unsigned int uIndex) {
vector<CTemplate*>* pvLoop = GetLoop(sName);
if (pvLoop) {
if (pvLoop->size() > uIndex) {
return (*pvLoop)[uIndex];
}
}
return nullptr;
}
vector<CTemplate*>* CTemplate::GetLoop(const CString& sName) {
CTemplateLoopContext* pContext = GetCurLoopContext();
if (pContext) {
CTemplate* pTemplate = pContext->GetCurRow();
if (pTemplate) {
return pTemplate->GetLoop(sName);
}
}
map<CString, vector<CTemplate*>>::iterator it = m_mvLoops.find(sName);
if (it != m_mvLoops.end()) {
return &(it->second);
}
return nullptr;
}
bool CTemplate::PrintString(CString& sRet) {
sRet.clear();
stringstream sStream;
bool bRet = Print(sStream);
sRet = sStream.str();
return bRet;
}
bool CTemplate::Print(ostream& oOut) { return Print(m_sFileName, oOut); }
bool CTemplate::Print(const CString& sFileName, ostream& oOut) {
if (sFileName.empty()) {
DEBUG("Empty filename in CTemplate::Print()");
return false;
}
CFile File(sFileName);
if (!File.Open()) {
DEBUG("Unable to open file [" + sFileName + "] in CTemplate::Print()");
return false;
}
CString sLine;
CString sSetBlockVar;
bool bValidLastIf = false;
bool bInSetBlock = false;
unsigned long uFilePos = 0;
unsigned long uCurPos = 0;
unsigned int uLineNum = 0;
unsigned int uNestedIfs = 0;
unsigned int uSkip = 0;
bool bLoopCont = false;
bool bLoopBreak = false;
bool bExit = false;
// Single template works across multiple translation domains, e.g. .tmpl of
// a module can INC'lude Footer.tmpl from core
CString sI18N;
while (File.ReadLine(sLine)) {
CString sOutput;
bool bFoundATag = false;
bool bTmplLoopHasData = false;
uLineNum++;
CString::size_type iPos = 0;
uCurPos = uFilePos;
CString::size_type uLineSize = sLine.size();
bool bBroke = false;
while (1) {
iPos = sLine.find("<?");
if (iPos == CString::npos) {
break;
}
uCurPos += iPos;
bFoundATag = true;
if (!uSkip) {
sOutput += sLine.substr(0, iPos);
}
sLine = sLine.substr(iPos + 2);
CString::size_type iPos2 = sLine.find("?>");
// Make sure our tmpl tag is ended properly
if (iPos2 == CString::npos) {
DEBUG("Template tag not ended properly in file [" + sFileName +
"] [<?" + sLine + "]");
return false;
}
uCurPos += iPos2 + 4;
CString sMid = CString(sLine.substr(0, iPos2)).Trim_n();
// Make sure we don't have a nested tag
if (!sMid.Contains("<?")) {
sLine = sLine.substr(iPos2 + 2);
CString sAction = sMid.Token(0);
CString sArgs = sMid.Token(1, true);
bool bNotFound = false;
// If we're breaking or continuing from within a loop, skip all
// tags that aren't ENDLOOP
if ((bLoopCont || bLoopBreak) && !sAction.Equals("ENDLOOP")) {
continue;
}
if (!uSkip) {
if (sAction.Equals("INC")) {
if (!Print(ExpandFile(sArgs, true), oOut)) {
DEBUG("Unable to print INC'd file [" + sArgs + "]");
return false;
}
} else if (sAction.Equals("SETOPTION")) {
m_spOptions->Parse(sArgs);
} else if (sAction.Equals("ADDROW")) {
CString sLoopName = sArgs.Token(0);
MCString msRow;
if (sArgs.Token(1, true, " ").OptionSplit(msRow)) {
CTemplate& NewRow = AddRow(sLoopName);
for (const auto& it : msRow) {
NewRow[it.first] = it.second;
}
}
} else if (sAction.Equals("SET")) {
CString sName = sArgs.Token(0);
CString sValue = sArgs.Token(1, true);
(*this)[sName] = sValue;
} else if (sAction.Equals("JOIN")) {
VCString vsArgs;
// sArgs.Split(" ", vsArgs, false, "\"", "\"");
sArgs.QuoteSplit(vsArgs);
if (vsArgs.size() > 1) {
CString sDelim = vsArgs[0];
bool bFoundOne = false;
CString::EEscape eEscape = CString::EASCII;
for (const CString& sArg : vsArgs) {
if (sArg.StartsWith("ESC=")) {
eEscape =
CString::ToEscape(sArg.LeftChomp_n(4));
} else {
CString sValue = GetValue(sArg);
if (!sValue.empty()) {
if (bFoundOne) {
sOutput += sDelim;
}
sOutput += sValue.Escape_n(eEscape);
bFoundOne = true;
}
}
}
}
} else if (sAction.Equals("SETBLOCK")) {
sSetBlockVar = sArgs;
bInSetBlock = true;
} else if (sAction.Equals("ENDSETBLOCK")) {
CString sName = sSetBlockVar.Token(0);
(*this)[sName] += sOutput;
sOutput = "";
bInSetBlock = false;
sSetBlockVar = "";
} else if (sAction.Equals("EXPAND")) {
sOutput += ExpandFile(sArgs, true);
} else if (sAction.Equals("VAR")) {
sOutput += GetValue(sArgs);
} else if (sAction.Equals("LT")) {
sOutput += "<?";
} else if (sAction.Equals("GT")) {
sOutput += "?>";
} else if (sAction.Equals("CONTINUE")) {
CTemplateLoopContext* pContext = GetCurLoopContext();
if (pContext) {
uSkip++;
bLoopCont = true;
break;
} else {
DEBUG("[" + sFileName + ":" +
CString(uCurPos - iPos2 - 4) +
"] <? CONTINUE ?> must be used inside of a "
"loop!");
}
} else if (sAction.Equals("BREAK")) {
// break from loop
CTemplateLoopContext* pContext = GetCurLoopContext();
if (pContext) {
uSkip++;
bLoopBreak = true;
break;
} else {
DEBUG(
"[" + sFileName + ":" +
CString(uCurPos - iPos2 - 4) +
"] <? BREAK ?> must be used inside of a loop!");
}
} else if (sAction.Equals("EXIT")) {
bExit = true;
} else if (sAction.Equals("DEBUG")) {
DEBUG("CTemplate DEBUG [" + sFileName + "@" +
CString(uCurPos - iPos2 - 4) + "b] -> [" + sArgs +
"]");
} else if (sAction.Equals("LOOP")) {
CTemplateLoopContext* pContext = GetCurLoopContext();
if (!pContext ||
pContext->GetFilePosition() != uCurPos) {
// we are at a brand new loop (be it new or a first
// pass at an inner loop)
CString sLoopName = sArgs.Token(0);
bool bReverse = (sArgs.Token(1).Equals("REVERSE"));
bool bSort = (sArgs.Token(1).StartsWith("SORT"));
vector<CTemplate*>* pvLoop = GetLoop(sLoopName);
if (bSort && pvLoop != nullptr &&
pvLoop->size() > 1) {
CString sKey;
if (sArgs.Token(1)
.TrimPrefix_n("SORT")
.StartsWith("ASC=")) {
sKey =
sArgs.Token(1).TrimPrefix_n("SORTASC=");
} else if (sArgs.Token(1)
.TrimPrefix_n("SORT")
.StartsWith("DESC=")) {
sKey = sArgs.Token(1)
.TrimPrefix_n("SORTDESC=");
bReverse = true;
}
if (!sKey.empty()) {
std::sort(pvLoop->begin(), pvLoop->end(),
CLoopSorter(sKey));
}
}
if (pvLoop) {
// If we found data for this loop, add it to our
// context vector
// unsigned long uBeforeLoopTag = uCurPos -
// iPos2 - 4;
unsigned long uAfterLoopTag = uCurPos;
for (CString::size_type t = 0; t < sLine.size();
t++) {
char c = sLine[t];
if (c == '\r' || c == '\n') {
uAfterLoopTag++;
} else {
break;
}
}
m_vLoopContexts.push_back(
new CTemplateLoopContext(uAfterLoopTag,
sLoopName,
bReverse, pvLoop));
} else {
// If we don't have data, just skip this loop
// and everything inside
uSkip++;
}
}
} else if (sAction.Equals("IF")) {
if (ValidIf(sArgs)) {
uNestedIfs++;
bValidLastIf = true;
} else {
uSkip++;
bValidLastIf = false;
}
} else if (sAction.Equals("REM")) {
uSkip++;
} else if (sAction.Equals("I18N")) {
sI18N = sArgs;
} else if (sAction.Equals("FORMAT") ||
sAction.Equals("PLURAL")) {
bool bHaveContext = false;
if (sArgs.TrimPrefix("CTX=")) {
bHaveContext = true;
}
VCString vsArgs;
sArgs.QuoteSplit(vsArgs);
CString sEnglish, sContext;
size_type idx = 0;
if (bHaveContext && vsArgs.size() > idx) {
sContext = vsArgs[idx];
idx++;
}
if (vsArgs.size() > idx) {
sEnglish = vsArgs[idx];
idx++;
}
CString sFormat;
if (sAction.Equals("PLURAL")) {
CString sEnglishes;
int iNum = 0;
if (vsArgs.size() > idx) {
sEnglishes = vsArgs[idx];
idx++;
}
if (vsArgs.size() > idx) {
iNum = GetValue(vsArgs[idx], true).ToInt();
idx++;
}
sFormat = CTranslation::Get().Plural(
sI18N, sContext, sEnglish, sEnglishes, iNum);
} else {
sFormat = CTranslation::Get().Singular(
sI18N, sContext, sEnglish);
}
MCString msParams;
for (size_type i = 0; i + idx < vsArgs.size(); ++i) {
msParams[CString(i + 1)] =
GetValue(vsArgs[i + idx], false);
}
sOutput += CString::NamedFormat(sFormat, msParams);
} else {
bNotFound = true;
}
} else if (sAction.Equals("REM")) {
uSkip++;
} else if (sAction.Equals("IF")) {
uSkip++;
} else if (sAction.Equals("LOOP")) {
uSkip++;
}
if (sAction.Equals("ENDIF")) {
if (uSkip) {
uSkip--;
} else {
uNestedIfs--;
}
} else if (sAction.Equals("ENDREM")) {
if (uSkip) {
uSkip--;
}
} else if (sAction.Equals("ENDLOOP")) {
if (bLoopCont && uSkip == 1) {
uSkip--;
bLoopCont = false;
}
if (bLoopBreak && uSkip == 1) {
uSkip--;
}
if (uSkip) {
uSkip--;
} else {
// We are at the end of the loop so we need to inc the
// index
CTemplateLoopContext* pContext = GetCurLoopContext();
if (pContext) {
pContext->IncRowIndex();
// If we didn't go out of bounds we need to seek
// back to the top of our loop
if (!bLoopBreak && pContext->GetCurRow()) {
uCurPos = pContext->GetFilePosition();
uFilePos = uCurPos;
uLineSize = 0;
File.Seek(uCurPos);
bBroke = true;
if (!sOutput.Trim_n().empty()) {
pContext->SetHasData();
}
break;
} else {
if (sOutput.Trim_n().empty()) {
sOutput.clear();
}
bTmplLoopHasData = pContext->HasData();
DelCurLoopContext();
bLoopBreak = false;
}
}
}
} else if (sAction.Equals("ELSE")) {
if (!bValidLastIf && uSkip == 1) {
CString sArg = sArgs.Token(0);
if (sArg.empty() || (sArg.Equals("IF") &&
ValidIf(sArgs.Token(1, true)))) {
uSkip = 0;
bValidLastIf = true;
}
} else if (!uSkip) {
uSkip = 1;
}
} else if (bNotFound) {
// Unknown tag that isn't being skipped...
vector<std::shared_ptr<CTemplateTagHandler>>&
vspTagHandlers = GetTagHandlers();
if (!vspTagHandlers.empty()) {
// @todo this should go up to the top to grab handlers
CTemplate* pTmpl = GetCurTemplate();
CString sCustomOutput;
for (const auto& spTagHandler : vspTagHandlers) {
if (spTagHandler->HandleTag(*pTmpl, sAction, sArgs,
sCustomOutput)) {
sOutput += sCustomOutput;
bNotFound = false;
break;
}
}
if (bNotFound) {
DEBUG("Unknown/Unhandled tag [" + sAction + "]");
}
}
}
continue;
}
DEBUG("Malformed tag on line " + CString(uLineNum) + " of ["
<< File.GetLongName() + "]");
DEBUG("--------------- [" + sLine + "]");
}
if (!bBroke) {
uFilePos += uLineSize;
if (!uSkip) {
sOutput += sLine;
}
}
if (!bFoundATag || bTmplLoopHasData ||
sOutput.find_first_not_of(" \t\r\n") != CString::npos) {
if (bInSetBlock) {
CString sName = sSetBlockVar.Token(0);
// CString sValue = sSetBlockVar.Token(1, true);
(*this)[sName] += sOutput;
} else {
oOut << sOutput;
}
}
if (bExit) {
break;
}
}
oOut.flush();
return true;
}
void CTemplate::DelCurLoopContext() {
if (m_vLoopContexts.empty()) {
return;
}
delete m_vLoopContexts.back();
m_vLoopContexts.pop_back();
}
CTemplateLoopContext* CTemplate::GetCurLoopContext() {
if (!m_vLoopContexts.empty()) {
return m_vLoopContexts.back();
}
return nullptr;
}
bool CTemplate::ValidIf(const CString& sArgs) {
CString sArgStr = sArgs;
// sArgStr.Replace(" ", "", "\"", "\"", true);
sArgStr.Replace(" &&", "&&", "\"", "\"", false);
sArgStr.Replace("&& ", "&&", "\"", "\"", false);
sArgStr.Replace(" ||", "||", "\"", "\"", false);
sArgStr.Replace("|| ", "||", "\"", "\"", false);
CString::size_type uOrPos = sArgStr.find("||");
CString::size_type uAndPos = sArgStr.find("&&");
while (uOrPos != CString::npos || uAndPos != CString::npos ||
!sArgStr.empty()) {
bool bAnd = false;
if (uAndPos < uOrPos) {
bAnd = true;
}
CString sExpr = sArgStr.Token(0, false, ((bAnd) ? "&&" : "||"));
sArgStr = sArgStr.Token(1, true, ((bAnd) ? "&&" : "||"));
if (ValidExpr(sExpr)) {
if (!bAnd) {
return true;
}
} else {
if (bAnd) {
return false;
}
}
uOrPos = sArgStr.find("||");
uAndPos = sArgStr.find("&&");
}
return false;
}
bool CTemplate::ValidExpr(const CString& sExpression) {
bool bNegate = false;
CString sExpr(sExpression);
CString sName;
CString sValue;
if (sExpr.TrimPrefix("!")) {
bNegate = true;
}
if (sExpr.Contains("!=")) {
sName = sExpr.Token(0, false, "!=").Trim_n();
sValue = sExpr.Token(1, true, "!=", false, "\"", "\"", true).Trim_n();
bNegate = !bNegate;
} else if (sExpr.Contains("==")) {
sName = sExpr.Token(0, false, "==").Trim_n();
sValue = sExpr.Token(1, true, "==", false, "\"", "\"", true).Trim_n();
} else if (sExpr.Contains(">=")) {
sName = sExpr.Token(0, false, ">=").Trim_n();
sValue = sExpr.Token(1, true, ">=", false, "\"", "\"", true).Trim_n();
return (GetValue(sName, true).ToLong() >= sValue.ToLong());
} else if (sExpr.Contains("<=")) {
sName = sExpr.Token(0, false, "<=").Trim_n();
sValue = sExpr.Token(1, true, "<=", false, "\"", "\"", true).Trim_n();
return (GetValue(sName, true).ToLong() <= sValue.ToLong());
} else if (sExpr.Contains(">")) {
sName = sExpr.Token(0, false, ">").Trim_n();
sValue = sExpr.Token(1, true, ">", false, "\"", "\"", true).Trim_n();
return (GetValue(sName, true).ToLong() > sValue.ToLong());
} else if (sExpr.Contains("<")) {
sName = sExpr.Token(0, false, "<").Trim_n();
sValue = sExpr.Token(1, true, "<", false, "\"", "\"", true).Trim_n();
return (GetValue(sName, true).ToLong() < sValue.ToLong());
} else {
sName = sExpr.Trim_n();
}
if (sValue.empty()) {
return (bNegate != IsTrue(sName));
}
sValue = ResolveLiteral(sValue);
return (bNegate != GetValue(sName, true).Equals(sValue));
}
bool CTemplate::IsTrue(const CString& sName) {
if (HasLoop(sName)) {
return true;
}
return GetValue(sName, true).ToBool();
}
bool CTemplate::HasLoop(const CString& sName) {
return (GetLoop(sName) != nullptr);
}
CTemplate* CTemplate::GetParent(bool bRoot) {
if (!bRoot) {
return m_pParent;
}
return (m_pParent) ? m_pParent->GetParent(bRoot) : this;
}
CTemplate* CTemplate::GetCurTemplate() {
CTemplateLoopContext* pContext = GetCurLoopContext();
if (!pContext) {
return this;
}
return pContext->GetCurRow();
}
CString CTemplate::ResolveLiteral(const CString& sString) {
if (sString.StartsWith("**")) {
// Allow string to start with a literal * by using two in a row
return sString.substr(1);
} else if (sString.StartsWith("*")) {
// If it starts with only one * then treat it as a var and do a lookup
return GetValue(sString.substr(1));
}
return sString;
}
CString CTemplate::GetValue(const CString& sArgs, bool bFromIf) {
CTemplateLoopContext* pContext = GetCurLoopContext();
CString sName = sArgs.Token(0);
CString sRest = sArgs.Token(1, true);
CString sRet;
while (sRest.Replace(" =", "=", "\"", "\"")) {
}
while (sRest.Replace("= ", "=", "\"", "\"")) {
}
VCString vArgs;
MCString msArgs;
// sRest.Split(" ", vArgs, false, "\"", "\"");
sRest.QuoteSplit(vArgs);
for (const CString& sArg : vArgs) {
msArgs[sArg.Token(0, false, "=").AsUpper()] = sArg.Token(1, true, "=");
}
/* We have no CConfig in ZNC land
* Hmm... Actually, we do have it now.
if (msArgs.find("CONFIG") != msArgs.end()) {
sRet = CConfig::GetValue(sName);
} else*/ if (msArgs.find("ROWS") != msArgs.end()) {
vector<CTemplate*>* pLoop = GetLoop(sName);
sRet = CString((pLoop) ? pLoop->size() : 0);
} else if (msArgs.find("TOP") == msArgs.end() && pContext) {
sRet = pContext->GetValue(sArgs, bFromIf);
if (!sRet.empty()) {
return sRet;
}
} else {
if (sName.TrimPrefix("*")) {
MCString::iterator it = find(sName);
sName = (it != end()) ? it->second : "";
}
MCString::iterator it = find(sName);
sRet = (it != end()) ? it->second : "";
}
vector<std::shared_ptr<CTemplateTagHandler>>& vspTagHandlers =
GetTagHandlers();
if (!vspTagHandlers
.empty()) { // @todo this should go up to the top to grab handlers
CTemplate* pTmpl = GetCurTemplate();
if (sRet.empty()) {
for (const auto& spTagHandler : vspTagHandlers) {
CString sCustomOutput;
if (!bFromIf &&
spTagHandler->HandleVar(*pTmpl, sArgs.Token(0),
sArgs.Token(1, true),
sCustomOutput)) {
sRet = sCustomOutput;
break;
} else if (bFromIf &&
spTagHandler->HandleIf(*pTmpl, sArgs.Token(0),
sArgs.Token(1, true),
sCustomOutput)) {
sRet = sCustomOutput;
break;
}
}
}
for (const auto& spTagHandler : vspTagHandlers) {
if (spTagHandler->HandleValue(*pTmpl, sRet, msArgs)) {
break;
}
}
}
if (!bFromIf) {
if (sRet.empty()) {
sRet = ResolveLiteral(msArgs["DEFAULT"]);
}
MCString::iterator it = msArgs.find("ESC");
if (it != msArgs.end()) {
VCString vsEscs;
it->second.Split(",", vsEscs, false);
for (const CString& sEsc : vsEscs) {
sRet.Escape(CString::ToEscape(sEsc));
}
} else {
sRet.Escape(m_spOptions->GetEscapeFrom(),
m_spOptions->GetEscapeTo());
}
}
return sRet;
}