Files
JetCore/Operand.cpp
Brad ArantandClaude Opus 5.5 ec3e40b71a Add ltrim and rtrim expression functions
ltrim(x) removes leading blanks and rtrim(x) removes trailing blanks,
using the same characters trim removes (space, tab, newline). rtrim
counts by index so an all-blank value becomes empty. The manual now
documents trim, ltrim and rtrim with examples.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-20 15:07:33 +00:00

881 lines
31 KiB
C++

#include "Operand.h"
#include "Exception.h"
#include <format>
#include <iostream>
#include <algorithm>
#include <time.h>
#include <chrono>
#include <cmath>
#include <vector>
#include <random>
namespace jet {
Operand::Operand(coreutils::ZString &in, Tag &tag, bool stop) : in(in), tag(tag) {
doubleValue = 0;
in.skipWhitespace();
if(in.startsWith("$[") || in.startsWith("#[")) {
string = tag.getVariable(in);
doubleValue = string.asDouble();
isNumber = string.eod();
string.reset();
if((string == "false") || (string == "true"))
boolean = (string == "true");
} else if(in.ifNext("(")) {
Operand op(in, tag);
string = op.string;
doubleValue = op.doubleValue;
isNumber = op.isNumber;
// A parenthesized sub-expression's own comparison result was never
// propagated to the wrapping Operand - only string/doubleValue/
// isNumber were copied, leaving this Operand's own `boolean`
// genuinely uninitialized (Operand.h declares it with no default
// value). Confirmed via debug tracing: printed as garbage stack
// bytes, which "and"/"or" then combined instead of the real
// true/false result.
boolean = op.boolean;
if(!in.ifNext(")"))
throw coreutils::Exception("expected ) in expression.");
} else if(in.ifNextIgnoreCase("SUBSTRING_INDEX")) {
// MySQL SUBSTRING_INDEX(str, delim, count): with a positive count,
// returns everything before the count-th occurrence of delim
// (counting from the left); with a negative count, everything
// after the |count|-th occurrence (counting from the right). If
// delim doesn't occur that many times, the whole string is
// returned unchanged. Genuinely missing (like LOCATE was) - real
// content (index2.cgi's own URI-parsing logic, ported as part of
// the /var/www/barant jet-2.0 conversion) relies on it to peel a
// path apart one segment at a time:
// substring_index(substring_index('$[REQUEST_URI]','?',1),'/',2).
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for SUBSTRING_INDEX parameters.");
Operand parm1(in, tag);
if(!in.ifNext(","))
throw coreutils::Exception("Expecting , in SUBSTRING_INDEX expression.");
Operand parm2(in, tag);
if(!in.ifNext(","))
throw coreutils::Exception("Expecting , in SUBSTRING_INDEX expression.");
Operand parm3(in, tag);
if(in.ifNext(")")) {
coreutils::MString haystack = parm1.string;
haystack.reset();
coreutils::MString delim = parm2.string;
delim.reset();
int count = parm3.string.asInteger();
int delimLen = (int)delim.getLength();
std::vector<int> positions;
if(delimLen > 0) {
int base = 0;
while(true) {
coreutils::MString scan = haystack.substring(base);
scan.reset();
int pos = scan.find(delim);
if(pos == -1) break;
positions.push_back(base + pos);
base += pos + delimLen;
}
}
if(count >= 0) {
size_t n = (size_t)count;
if(n == 0 || positions.size() < n) {
string = haystack.substring(0);
} else {
string = haystack.substring(0, positions[n - 1]);
}
} else {
size_t n = (size_t)(-count);
if(positions.size() < n) {
string = haystack.substring(0);
} else {
int idx = positions[positions.size() - n];
string = haystack.substring(idx + delimLen);
}
}
} else
throw coreutils::Exception("Expecting ) at end of SUBSTRING_INDEX expression.");
} else if(in.ifNextIgnoreCase("SUBSTRING")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for SUBSTRING parameters.");
Operand parm1(in, tag);
if(!in.ifNext(","))
throw coreutils::Exception("Expecting , in SUBSTRING expression.");
Operand parm2(in, tag);
if(in.ifNext(")")) {
string = parm1.string.substring(parm2.string.asInteger());
} else {
// Real, pre-existing bug fixed here: the 3-arg-only branch below
// used to run unconditionally (missing braces around this
// else-if), so even after the 2-arg form above already
// succeeded, it fell through into trying to parse a third
// argument from whatever was left (nothing, since the closing
// ")" was already consumed) - always throwing "operand is not
// valid." right after computing the correct 2-arg result.
// Confirmed via real debug tracing showing an extra Operand
// constructed on empty input immediately after a successful
// 2-arg substring(str, start) call - the 2-arg form was
// completely unusable before this fix.
if(!in.ifNext(","))
throw coreutils::Exception("Expecting , in SUBSTRING expression.");
Operand parm3(in, tag);
if(in.ifNext(")")) {
string = parm1.string.substring(parm2.string.asInteger(), parm3.string.asInteger());
} else
throw coreutils::Exception("Expecting ) at end of substring expression.");
}
} else if(in.ifNextIgnoreCase("LOCATE")) {
// MySQL-style LOCATE(needle, haystack): 1-based position of the
// first occurrence of needle within haystack, or 0 if not found -
// a genuinely missing function (like <eval> was a genuinely
// missing tag). Real 1.4 content depends on it for exactly this
// "is #[name] present in the space-padded $[errfield] list"
// pattern (barant.tag's own <field> definition:
// locate(' #[name] ','$[errfield]') != 0), used throughout for
// marking a field's input as erroring after a failed validation.
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for LOCATE parameters.");
Operand parm1(in, tag);
if(!in.ifNext(","))
throw coreutils::Exception("Expecting , in LOCATE expression.");
Operand parm2(in, tag);
if(in.ifNext(")")) {
coreutils::MString haystack = parm2.string;
haystack.reset();
int pos = haystack.find(parm1.string);
doubleValue = (pos == -1) ? 0 : (pos + 1);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else {
// Optional 3rd start_pos argument (MySQL LOCATE(substr, str,
// pos)): search begins at the given 1-based position instead of
// the start of the string. Needed by index2.cgi's own real
// URI-parsing logic (walking a path one '/' at a time), ported
// as part of the /var/www/barant jet-2.0 conversion.
if(!in.ifNext(","))
throw coreutils::Exception("Expecting , in LOCATE expression.");
Operand parm3(in, tag);
if(in.ifNext(")")) {
coreutils::MString haystack = parm2.string;
haystack.reset();
int totalLen = (int)haystack.getLength();
int startPos = parm3.string.asInteger() - 1;
if(startPos < 0) startPos = 0;
if(startPos >= totalLen) {
doubleValue = 0;
} else {
coreutils::MString sub = haystack.substring(startPos);
sub.reset();
int pos = sub.find(parm1.string);
doubleValue = (pos == -1) ? 0 : (startPos + pos + 1);
}
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of LOCATE expression.");
}
} else if(in.ifNextIgnoreCase("LEFT")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for LEFT parameters.");
Operand parm1(in, tag);
if(!in.ifNext(","))
throw coreutils::Exception("Expecting , in LEFT expression.");
Operand parm2(in, tag);
if(in.ifNext(")")) {
string = parm1.string.substring(0, parm2.string.asInteger());
} else
throw coreutils::Exception("Expecting ) at end of LEFT expression.");
} else if(in.ifNextIgnoreCase("EXPR")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for EXPR parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
Operand op(parm1.string, tag);
string = op.string;
isNumber = op.isNumber;
if(isNumber) {
doubleValue = op.doubleValue;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
}
boolean = op.boolean;
} else
throw coreutils::Exception("Expecting ) at end of EXPR expression.");
} else if(in.ifNextIgnoreCase("RIGHT")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for RIGHT parameters.");
Operand parm1(in, tag);
if(!in.ifNext(","))
throw coreutils::Exception("Expecting , in RIGHT expression.");
Operand parm2(in, tag);
if(in.ifNext(")")) {
int len = parm1.string.getLength();
int size = parm2.string.asInteger();
int start = len - size;
string = parm1.string.substring(start, size);
} else
throw coreutils::Exception("Expecting ) at end of RIGHT expression.");
} else if(in.ifNextIgnoreCase("TRIM")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for TRIM parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
string = parm1.string.trim();
} else
throw coreutils::Exception("Expecting ) at end of TRIM expression.");
} else if(in.ifNextIgnoreCase("LTRIM")) {
// Leading blanks only - the same characters TRIM removes (space,
// tab, newline).
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for LTRIM parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
const char *data = parm1.string.getData();
int len = parm1.string.getLength();
int start = 0;
while((start < len) && ((data[start] == ' ') || (data[start] == '\t') || (data[start] == '\n')))
++start;
string = parm1.string.substring(start, len - start);
} else
throw coreutils::Exception("Expecting ) at end of LTRIM expression.");
} else if(in.ifNextIgnoreCase("RTRIM")) {
// Trailing blanks only. Counted by index rather than with
// trimTrailingWhitespace(), which stops one character short and
// would leave " " for an all-blank value.
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for RTRIM parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
const char *data = parm1.string.getData();
int len = parm1.string.getLength();
while((len > 0) && ((data[len - 1] == ' ') || (data[len - 1] == '\t') || (data[len - 1] == '\n')))
--len;
string = parm1.string.substring(0, len);
} else
throw coreutils::Exception("Expecting ) at end of RTRIM expression.");
} else if(in.ifNextIgnoreCase("TOUPPER")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for TOUPPER parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
string = parm1.string.toUpper();
} else
throw coreutils::Exception("Expecting ) at end of TOUPPER expression.");
} else if(in.ifNextIgnoreCase("TOLOWER")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for TOLOWER parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
string = parm1.string.toLower();
} else
throw coreutils::Exception("Expecting ) at end of TOLOWER expression.");
} else if(in.ifNextIgnoreCase("REVERSE")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for REVERSE parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
std::string reversed = parm1.string.str();
std::reverse(reversed.begin(), reversed.end());
string = reversed;
} else
throw coreutils::Exception("Expecting ) at end of REVERSE expression.");
} else if(in.ifNextIgnoreCase("CONCAT")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for CONCAT parameters.");
Operand parm1(in, tag);
string = parm1.string;
while(in.ifNext(",")) {
Operand parm(in, tag);
string << parm.string;
}
if(!in.ifNext(")"))
throw coreutils::Exception("Expecting ) at end of CONCAT expression.");
} else if(in.ifNextIgnoreCase("INTEGER")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for INTEGER parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
string = parm1.string.asInteger();
} else
throw coreutils::Exception("Expecting ) at end of INTEGER expression.");
} else if(in.ifNextIgnoreCase("ROUND")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for ROUND parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = round(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of ROUND expression.");
} else if(in.ifNextIgnoreCase("RANDOM")) {
unsigned int seed = (unsigned int)clock();
doubleValue = (double) rand_r(&seed) / (RAND_MAX + 1.0);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else if(in.ifNextIgnoreCase("ABS")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for ABS parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = abs(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of ABS expression.");
} else if(in.ifNextIgnoreCase("MAX")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for MAX parameters.");
Operand *parm = new Operand(in, tag);
string = parm->string;
doubleValue = parm->doubleValue;
isNumber = parm->isNumber;
delete parm;
while(in.ifNext(",")) {
parm = new Operand(in, tag);
if(isNumber != parm->isNumber)
throw coreutils::Exception("All parameters in MAX expression must be same type.");
if(isNumber) {
if(parm->doubleValue > doubleValue) {
doubleValue = parm->doubleValue;
string = parm->string;
}
} else {
if(parm->string > string) {
doubleValue = parm->doubleValue;
string = parm->string;
}
}
delete parm;
}
if(!in.ifNext(")")) {
throw coreutils::Exception("Expecting ) at end of MAX expression.");
}
string.removeTrailingZeros();
} else if(in.ifNextIgnoreCase("MIN")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for MIN parameters.");
Operand *parm = new Operand(in, tag);
string = parm->string;
doubleValue = parm->doubleValue;
isNumber = parm->isNumber;
delete parm;
while(in.ifNext(",")) {
parm = new Operand(in, tag);
if(isNumber != parm->isNumber)
throw coreutils::Exception("All parameters in MIN expression must be same type.");
if(isNumber) {
if(parm->doubleValue < doubleValue) {
doubleValue = parm->doubleValue;
string = parm->string;
}
} else {
if(parm->string < string) {
doubleValue = parm->doubleValue;
string = parm->string;
}
}
delete parm;
}
if(!in.ifNext(")")) {
throw coreutils::Exception("Expecting ) at end of MIN expression.");
}
string.removeTrailingZeros();
} else if(in.ifNextIgnoreCase("POW")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for POW parameters.");
Operand parm1(in, tag);
if(!in.ifNext(","))
throw coreutils::Exception("Expecting , in POW expression.");
Operand parm2(in, tag);
if(in.ifNext(")")) {
doubleValue = pow(parm1.doubleValue, parm2.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of substring expression.");
} else if(in.ifNextIgnoreCase("SIN")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for SIN parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = sin(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of SIN expression.");
} else if(in.ifNextIgnoreCase("ASIN")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for ASIN parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = asin(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of ASIN expression.");
} else if(in.ifNextIgnoreCase("COS")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for COS parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = cos(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of COS expression.");
} else if(in.ifNextIgnoreCase("ACOS")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for ACOS parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = acos(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of ACOS expression.");
} else if(in.ifNextIgnoreCase("ATAN")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for ATAN parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = atan(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of ATAN expression.");
} else if(in.ifNextIgnoreCase("SQRT")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for SQRT parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = sqrt(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of SQRT expression.");
} else if(in.ifNextIgnoreCase("DEG")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for DEG parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = parm1.doubleValue * 180 / 3.14159;
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of DEG expression.");
} else if(in.ifNextIgnoreCase("RAD")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for RAD parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = parm1.doubleValue * 3.14159 / 180;
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of RAD expression.");
} else if(in.ifNextIgnoreCase("TAN")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for TAN parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = tan(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of TAN expression.");
} else if(in.ifNextIgnoreCase("TRUNC")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for TRUNC parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = trunc(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of TRUNC expression.");
} else if(in.ifNextIgnoreCase("CEIL")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for CEIL parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = ceil(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of CEIL expression.");
} else if(in.ifNextIgnoreCase("FLOOR")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for FLOOR parameters.");
Operand parm1(in, tag);
if(in.ifNext(")")) {
doubleValue = floor(parm1.doubleValue);
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of FLOOR expression.");
} else if(in.ifNextIgnoreCase("UNIXTIME") || in.ifNextIgnoreCase("UNIX_TIMESTAMP")) {
// Real content (cart.page's own <set expr="unix_timestamp()">)
// calls MySQL's real function name, not this codebase's own
// "UNIXTIME" - same value, just accept both spellings.
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for UNIXTIME.");
if(in.ifNext(")")) {
auto now = std::chrono::system_clock::now();
auto duration_since_epoch = now.time_since_epoch();
auto seconds_since_epoch = std::chrono::duration_cast<std::chrono::seconds>(duration_since_epoch);
int unixtime = seconds_since_epoch.count();
string << unixtime;
} else
throw coreutils::Exception("Expecting ) at end of UNIXTIME.");
}
else if(in.ifNextIgnoreCase("NOW")) {
// MySQL's now() - real content (SESSIONCTL.tag's own
// createsession definition: <set name="_timestamp" expr="now()">,
// embedded directly into a DATETIME column via a raw SQL literal:
// timestamp='$[_timestamp]') expects a MySQL DATETIME-formatted
// string ("YYYY-MM-DD HH:MM:SS"), not a Unix timestamp (that's
// UNIX_TIMESTAMP, just above).
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for NOW.");
if(in.ifNext(")")) {
std::time_t t = std::time(nullptr);
std::tm tmVal;
gmtime_r(&t, &tmVal);
char buf[32];
std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tmVal);
string = buf;
isNumber = false;
} else
throw coreutils::Exception("Expecting ) at end of NOW.");
}
else if(in.ifNextIgnoreCase("UUID")) {
// MySQL's uuid() - real content (SESSIONCTL.tag's own
// createsession definition: <set name="_uuid" expr="uuid()">)
// uses this to mint a new session id, stored as sessions.uuid and
// handed back to the browser as the _session_id cookie. A real
// random (v4) UUID, not MySQL's actual v1 (time+MAC-derived)
// algorithm - the schema only ever treats this as an opaque
// unique string, nothing depends on v1's specific bit layout.
// Seeded from std::random_device (real entropy), not RANDOM's
// existing clock()-seeded rand_r() above - this value doubles as
// a session token, so it needs to be unguessable, not just unique.
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for UUID.");
if(in.ifNext(")")) {
static thread_local std::mt19937_64 rng(std::random_device{}());
std::uniform_int_distribution<int> hexDigit(0, 15);
const char *hex = "0123456789abcdef";
char buf[37];
int p = 0;
for(int i = 0; i < 36; i++) {
if(i == 8 || i == 13 || i == 18 || i == 23) { buf[p++] = '-'; continue; }
int v;
if(i == 14) v = 4; // version 4
else if(i == 19) v = 8 + hexDigit(rng) % 4; // variant 10xx
else v = hexDigit(rng);
buf[p++] = hex[v];
}
buf[p] = '\0';
string = buf;
isNumber = false;
} else
throw coreutils::Exception("Expecting ) at end of UUID.");
}
else if(in.ifNextIgnoreCase("DATEDIFF")) {
if(!in.ifNext("("))
throw coreutils::Exception("Expecting ( for DATEDIFF.");
Operand parm1(in, tag);
if(!in.ifNext(","))
throw coreutils::Exception("Expecting , in DATEDIFF expression.");
Operand parm2(in, tag);
if(in.ifNext(")")) {
// Matches MySQL's DATEDIFF(expr1, expr2): expr1 - expr2 expressed
// as a whole number of days, ignoring any time-of-day component.
// Dates are parsed as YYYY-MM-DD (a leading date portion of a
// longer "YYYY-MM-DD HH:MM:SS" value parses fine too, since
// strptime only consumes what the format string asks for) and
// interpreted as UTC via timegm() (not mktime(), which is
// local-timezone-dependent) so the result doesn't shift with the
// server's own timezone setting.
struct tm tm1 = {};
struct tm tm2 = {};
if(!strptime(parm1.string.c_str(), "%Y-%m-%d", &tm1))
throw coreutils::Exception("DATEDIFF: first argument is not a valid date (expected YYYY-MM-DD).");
if(!strptime(parm2.string.c_str(), "%Y-%m-%d", &tm2))
throw coreutils::Exception("DATEDIFF: second argument is not a valid date (expected YYYY-MM-DD).");
time_t t1 = timegm(&tm1);
time_t t2 = timegm(&tm2);
doubleValue = difftime(t1, t2) / 86400.0;
isNumber = true;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("Expecting ) at end of DATEDIFF expression.");
} else if(in.ifNextIgnoreCase("true")) {
boolean = true;
string = "true";
} else if(in.ifNextIgnoreCase("false")) {
boolean = false;
string = "false";
} else if(in.startsWithNumber()) {
doubleValue = in.asDouble();
string = std::format("{:.12f}", doubleValue);
isNumber = true;
} else if(in.ifNext("'")) {
coreutils::MString raw = in.getTokenExclude("'");
in.ifNext("'");
coreutils::MString resolved;
raw.reset();
while(!raw.eod()) {
if(raw.startsWith("$[") || raw.startsWith("#["))
resolved.write(tag.getVariable(raw));
else {
resolved.write(raw.charAt(0));
raw.nextChar();
}
}
string = resolved;
isNumber = false;
} else
throw coreutils::Exception("operand is not valid.");
in.skipWhitespace();
if(!stop)
parseOperator();
return;
}
int Operand::parseOperator() {
if(in.ifNext("!=") || in.ifNext("<>")) {
Operand op(in, tag);
if(isNumber && op.isNumber) {
if(doubleValue != op.doubleValue) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
} else if(!isNumber && !op.isNumber) {
if(string != op.string) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
}
}
if(in.ifNext("<=")) {
Operand op(in, tag);
if(isNumber && op.isNumber) {
if(doubleValue <= op.doubleValue) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
} else if(!isNumber && !op.isNumber) {
if(string <= op.string) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
}
}
if(in.ifNext(">=")) {
Operand op(in, tag);
if(isNumber && op.isNumber) {
if(doubleValue >= op.doubleValue) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
} else if(!isNumber && !op.isNumber) {
if(string >= op.string) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
}
}
if(in.ifNext("=")) {
Operand op(in, tag);
if(isNumber && op.isNumber) {
if(doubleValue == op.doubleValue) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
} else if(!isNumber && !op.isNumber) {
if(string == op.string) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
}
}
if(in.ifNext("<")) {
Operand op(in, tag);
if(isNumber && op.isNumber) {
if(doubleValue < op.doubleValue) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
} else if(!isNumber && !op.isNumber) {
if(string < op.string) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
}
}
if(in.ifNext(">")) {
Operand op(in, tag);
if(isNumber && op.isNumber) {
if(doubleValue > op.doubleValue) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
} else if(!isNumber && !op.isNumber) {
if(string > op.string) {
boolean = true;
isNumber = false;
string = "true";
} else {
boolean = false;
isNumber = false;
string = "false";
}
}
}
if(in.ifNext("+")) {
if(isNumber) {
Operand op(in, tag);
if(op.isNumber) {
doubleValue += op.doubleValue;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("operand is not a number.");
} else
throw coreutils::Exception("operand is not a number.");
} else if(in.ifNext("-")) {
if(isNumber) {
Operand op(in, tag);
if(op.isNumber) {
doubleValue -= op.doubleValue;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
} else
throw coreutils::Exception("operand is not a number.");
} else
throw coreutils::Exception("operand is not a number.");
} else if(in.ifNext("*")) {
if(isNumber) {
Operand op(in, tag, true);
if(op.isNumber) {
doubleValue *= op.doubleValue;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
parseOperator();
} else
throw coreutils::Exception("operand is not a number.");
} else
throw coreutils::Exception("operand is not a number.");
} else if(in.ifNext("/")) {
if(isNumber) {
Operand op(in, tag, true);
if(op.isNumber) {
doubleValue /= op.doubleValue;
string = std::format("{:.12f}", doubleValue);
string.removeTrailingZeros();
parseOperator();
} else
throw coreutils::Exception("operand is not a number.");
} else
throw coreutils::Exception("operand is not a number.");
}
in.skipWhitespace();
if(in.ifNextIgnoreCase("and")) {
Operand op(in, tag);
boolean = boolean && op.boolean;
isNumber = false;
string = boolean ? "true" : "false";
} else if(in.ifNextIgnoreCase("or")) {
Operand op(in, tag);
boolean = boolean || op.boolean;
isNumber = false;
string = boolean ? "true" : "false";
}
return true;
}
}