// plaintextAutomorph: an auxilliary routine...maybe palce in NumbTh?
// Compute b(X) = a(X^k) mod Phi_m(X). Result is calclated in the output b
// "in place", so a should not alias b.
template <class RX, class RXModulus> static
void plaintextAutomorph(RX& b, const RX& a, long k, const PAlgebra& zMStar,
const RXModulus& PhimX)
{
long m = zMStar.getM();
assert(zMStar.inZmStar(k));
b.SetLength(m);
for (long j = 0; j < m; j++) b[j] = 0;
long d = deg(a);
// compute b(X) = a(X^k) mod (X^m-1)
mulmod_precon_t precon = PrepMulModPrecon(k, m);
for (long j = 0; j <= d; j++)
b[MulModPrecon(j, k, m, precon)] = a[j]; // b[j*k mod m] = a[j]
b.normalize();
rem(b, b, PhimX); // reduce modulo the m'th cyclotomic
}
bool Nibbler::getUntilRx (const std::string& regex, std::string& result)
{
if (_cursor < _length)
{
RX r (regex, true);
std::vector <int> start;
std::vector <int> end;
if (r.match (start, end, _input->substr (_cursor)))
{
result = _input->substr (_cursor, start[0]);
_cursor += start[0];
}
else
{
result = _input->substr (_cursor);
_cursor = _length;
}
return true;
}
return false;
}
bool Nibbler::skipRx (const std::string& regex)
{
if (_cursor < _length)
{
// Regex may be anchored to the beginning and include capturing parentheses,
// otherwise they are added.
std::string modified_regex;
if (regex.substr (0, 2) != "^(")
modified_regex = "^(" + regex + ")";
else
modified_regex = regex;
RX r (modified_regex, true);
std::vector <std::string> results;
if (r.match (results, _input->substr (_cursor)))
{
_cursor += results[0].length ();
return true;
}
}
return false;
}
void Task::substitute (
const std::string& from,
const std::string& to,
bool global)
{
// Get the data to modify.
std::string description = get ("description");
std::map <std::string, std::string> annotations;
getAnnotations (annotations);
bool sensitive = context.config.getBoolean ("search.case.sensitive");
// Count the changes, so we know whether to proceed to annotations, after
// modifying description.
int changes = 0;
bool done = false;
// Regex support is optional.
if (context.config.getBoolean ("regex"))
{
// Create the regex.
RX rx (from, sensitive);
std::vector <int> start;
std::vector <int> end;
// Perform all subs on description.
if (rx.match (start, end, description))
{
int skew = 0;
for (unsigned int i = 0; i < start.size () && !done; ++i)
{
description.replace (start[i + skew], end[i] - start[i], to);
skew += to.length () - (end[i] - start[i]);
++changes;
if (!global)
done = true;
}
}
if (!done)
{
// Perform all subs on annotations.
std::map <std::string, std::string>::iterator it;
for (it = annotations.begin (); it != annotations.end () && !done; ++it)
{
start.clear ();
end.clear ();
if (rx.match (start, end, it->second))
{
int skew = 0;
for (unsigned int i = 0; i < start.size () && !done; ++i)
{
it->second.replace (start[i + skew], end[i] - start[i], to);
skew += to.length () - (end[i] - start[i]);
++changes;
if (!global)
done = true;
}
}
}
}
}
else
{
// Perform all subs on description.
int counter = 0;
std::string::size_type pos = 0;
int skew = 0;
while ((pos = ::find (description, from, pos, sensitive)) != std::string::npos && !done)
{
description.replace (pos + skew, from.length (), to);
skew += to.length () - from.length ();
pos += to.length ();
++changes;
if (!global)
done = true;
if (++counter > APPROACHING_INFINITY)
throw format (STRING_INFINITE_LOOP, APPROACHING_INFINITY);
}
if (!done)
{
// Perform all subs on annotations.
counter = 0;
std::map <std::string, std::string>::iterator i;
for (i = annotations.begin (); i != annotations.end () && !done; ++i)
{
pos = 0;
skew = 0;
while ((pos = ::find (i->second, from, pos, sensitive)) != std::string::npos && !done)
{
i->second.replace (pos + skew, from.length (), to);
skew += to.length () - from.length ();
pos += to.length ();
++changes;
if (!global)
done = true;
if (++counter > APPROACHING_INFINITY)
throw format (STRING_INFINITE_LOOP, APPROACHING_INFINITY);
}
}
}
}
if (changes)
{
set ("description", description);
setAnnotations (annotations);
recalc_urgency = true;
}
}
