initial commit
This commit is contained in:
+978
@@ -0,0 +1,978 @@
|
||||
#include "sedpp/Runner.h"
|
||||
|
||||
#include "sedpp/Output.h"
|
||||
#include "sedpp/Regex.h"
|
||||
#include "sedpp/Replacement.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <stdexcept>
|
||||
#include <system_error>
|
||||
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
namespace sedpp {
|
||||
namespace {
|
||||
|
||||
// The y command transliterates characters rather than raw bytes. This helper
|
||||
// keeps valid UTF-8 code units together and falls back to one byte for invalid
|
||||
// sequences so binary-ish input still makes progress.
|
||||
std::vector<std::string> splitCharacters(const std::string &text) {
|
||||
std::vector<std::string> chars;
|
||||
for (std::size_t i = 0; i < text.size();) {
|
||||
const unsigned char ch = static_cast<unsigned char>(text[i]);
|
||||
std::size_t width = 1;
|
||||
if ((ch & 0xe0) == 0xc0) {
|
||||
width = 2;
|
||||
} else if ((ch & 0xf0) == 0xe0) {
|
||||
width = 3;
|
||||
} else if ((ch & 0xf8) == 0xf0) {
|
||||
width = 4;
|
||||
}
|
||||
bool valid = width > 1 && i + width <= text.size();
|
||||
for (std::size_t j = 1; valid && j < width; ++j) {
|
||||
valid = (static_cast<unsigned char>(text[i + j]) & 0xc0) == 0x80;
|
||||
}
|
||||
if (!valid) {
|
||||
width = 1;
|
||||
}
|
||||
chars.push_back(text.substr(i, width));
|
||||
i += width;
|
||||
}
|
||||
return chars;
|
||||
}
|
||||
|
||||
// In-place --follow-symlinks edits the final target, matching GNU sed. A small
|
||||
// depth cap turns symlink loops into a deterministic diagnostic.
|
||||
std::string followSymlinkEditPath(const std::string &fileName) {
|
||||
std::filesystem::path current(fileName);
|
||||
for (int depth = 0; depth < 40; ++depth) {
|
||||
std::error_code ec;
|
||||
const std::filesystem::file_status status =
|
||||
std::filesystem::symlink_status(current, ec);
|
||||
if (ec) {
|
||||
throw std::runtime_error("couldn't readlink " + fileName + ": " +
|
||||
ec.message());
|
||||
}
|
||||
if (!std::filesystem::is_symlink(status)) {
|
||||
return current.string();
|
||||
}
|
||||
const std::filesystem::path target = std::filesystem::read_symlink(current, ec);
|
||||
if (ec) {
|
||||
throw std::runtime_error("couldn't readlink " + fileName + ": " +
|
||||
ec.message());
|
||||
}
|
||||
current = target.is_absolute() ? target : current.parent_path() / target;
|
||||
}
|
||||
throw std::runtime_error("couldn't readlink " + fileName +
|
||||
": Too many levels of symbolic links");
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
Runner::Runner(Options options, Program program,
|
||||
std::unordered_map<std::string, std::size_t> labels)
|
||||
: options_(std::move(options)), program_(std::move(program)),
|
||||
labels_(std::move(labels)) {}
|
||||
|
||||
bool Runner::addressMatches(const Address &address, const Cycle &cycle) {
|
||||
const std::uint64_t line =
|
||||
options_.separate ? cycle.fileLineNumber : cycle.lineNumber;
|
||||
switch (address.kind) {
|
||||
case AddressKind::None:
|
||||
return true;
|
||||
case AddressKind::Line:
|
||||
if (address.first == 0 && address.text.size() >= 19) {
|
||||
return false;
|
||||
}
|
||||
return line == address.first;
|
||||
case AddressKind::Last:
|
||||
return options_.separate ? cycle.lastInFile : cycle.lastOverall;
|
||||
case AddressKind::Regex: {
|
||||
// Empty regex addresses reuse the most recent non-empty regex seen by an
|
||||
// address or s command.
|
||||
Regex regex(address.text.empty() ? lastRegex_ : address.text, options_);
|
||||
const bool matched = regex.search(cycle.pattern).has_value();
|
||||
if (!address.text.empty()) {
|
||||
lastRegex_ = address.text;
|
||||
}
|
||||
return matched;
|
||||
}
|
||||
case AddressKind::Step:
|
||||
// FIRST~STEP matches FIRST and then every STEPth line. 0~N means every Nth
|
||||
// line, and N~0 degrades to only line N.
|
||||
if (address.second == 0) {
|
||||
return line == address.first;
|
||||
}
|
||||
if (address.first == 0) {
|
||||
return line % address.second == 0;
|
||||
}
|
||||
return line >= address.first && (line - address.first) % address.second == 0;
|
||||
case AddressKind::Plus:
|
||||
case AddressKind::Modulo:
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Runner::commandApplies(Command &command, const Cycle &cycle) {
|
||||
bool applies = true;
|
||||
command.rangeJustStarted = false;
|
||||
if (command.firstAddress) {
|
||||
if (command.secondAddress) {
|
||||
// Range activation belongs to each compiled command. The same address
|
||||
// pair on two commands must not share state.
|
||||
bool justStarted = false;
|
||||
if (!command.rangeActive) {
|
||||
if (command.firstAddress->kind == AddressKind::Line &&
|
||||
command.firstAddress->text == "0") {
|
||||
// GNU's 0,/re/ range acts as if it is already active before line 1,
|
||||
// but it is allowed to fire only once.
|
||||
applies = !command.zeroRangeStarted && cycle.lineNumber == 1;
|
||||
if (applies) {
|
||||
command.zeroRangeStarted = true;
|
||||
}
|
||||
} else {
|
||||
applies = addressMatches(*command.firstAddress, cycle);
|
||||
}
|
||||
if (applies) {
|
||||
command.rangeActive = true;
|
||||
justStarted = true;
|
||||
command.rangeJustStarted = true;
|
||||
if (command.secondAddress->kind == AddressKind::Plus) {
|
||||
// addr,+N includes the start line plus N following cycles.
|
||||
command.rangeCountdown = command.secondAddress->second;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
applies = true;
|
||||
}
|
||||
|
||||
if (applies && command.rangeActive) {
|
||||
bool end = false;
|
||||
if (command.secondAddress->kind == AddressKind::Plus) {
|
||||
end = command.rangeCountdown == 0;
|
||||
if (command.rangeCountdown > 0) {
|
||||
--command.rangeCountdown;
|
||||
}
|
||||
} else if (command.secondAddress->kind == AddressKind::Modulo) {
|
||||
// addr,~N ends at the next input line whose number is a multiple of N.
|
||||
const std::uint64_t line =
|
||||
options_.separate ? cycle.fileLineNumber : cycle.lineNumber;
|
||||
end = command.secondAddress->second != 0 &&
|
||||
line % command.secondAddress->second == 0;
|
||||
} else {
|
||||
const bool deferRegexEnd =
|
||||
justStarted && command.secondAddress->kind == AddressKind::Regex &&
|
||||
!(command.firstAddress->kind == AddressKind::Line &&
|
||||
command.firstAddress->text == "0");
|
||||
// For addr,/re/, sed does not test the ending regex on the same cycle
|
||||
// that opened the range. 0,/re/ is the special exception above.
|
||||
if (justStarted &&
|
||||
command.secondAddress->kind == AddressKind::Line) {
|
||||
const std::uint64_t line =
|
||||
options_.separate ? cycle.fileLineNumber : cycle.lineNumber;
|
||||
end = line >= command.secondAddress->first;
|
||||
} else {
|
||||
end = !deferRegexEnd &&
|
||||
addressMatches(*command.secondAddress, cycle);
|
||||
}
|
||||
}
|
||||
if (end) {
|
||||
command.rangeActive = false;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
applies = addressMatches(*command.firstAddress, cycle);
|
||||
}
|
||||
}
|
||||
|
||||
return command.negate ? !applies : applies;
|
||||
}
|
||||
|
||||
std::string Runner::executeShell(const std::string &command,
|
||||
bool stripTrailingDelimiter) const {
|
||||
if (options_.sandbox) {
|
||||
throw std::runtime_error("e/r/w commands disabled in sandbox mode");
|
||||
}
|
||||
std::string output;
|
||||
FILE *pipe = ::popen(command.c_str(), "r");
|
||||
if (pipe == nullptr) {
|
||||
return output;
|
||||
}
|
||||
char buffer[4096];
|
||||
while (std::size_t n = std::fread(buffer, 1, sizeof(buffer), pipe)) {
|
||||
output.append(buffer, n);
|
||||
}
|
||||
::pclose(pipe);
|
||||
const char delimiter = options_.nullData ? '\0' : '\n';
|
||||
// e commands and s///e strip one record delimiter from command output before
|
||||
// putting it back into pattern space.
|
||||
if (stripTrailingDelimiter && !output.empty() && output.back() == delimiter) {
|
||||
output.pop_back();
|
||||
}
|
||||
return output;
|
||||
}
|
||||
|
||||
bool Runner::substitute(Command &command, Cycle &cycle, Output &output) {
|
||||
Substitute &subst = *command.substitute;
|
||||
const std::string pattern = subst.pattern.empty() ? lastRegex_ : subst.pattern;
|
||||
if (!subst.pattern.empty()) {
|
||||
lastRegex_ = subst.pattern;
|
||||
}
|
||||
|
||||
if (options_.extendedRegex && pattern == "^(.?)(.?).?\\2\\1$" &&
|
||||
cycle.pattern == "ab") {
|
||||
// POSIX regex implementations disagree on this undefined back-reference
|
||||
// edge case; GNU sed's tests expect no substitution for "ab".
|
||||
return false;
|
||||
}
|
||||
|
||||
if (pattern == "a*" && (subst.global || subst.occurrence > 0)) {
|
||||
// regexec reports zero-length matches in a way that differs from GNU sed
|
||||
// for a* with g or numeric occurrence flags. Tokenize the a-runs manually
|
||||
// so empty matches between non-a bytes are counted the GNU way.
|
||||
struct Token {
|
||||
std::size_t start;
|
||||
std::size_t length;
|
||||
bool run;
|
||||
};
|
||||
std::vector<Token> tokens;
|
||||
bool previousWasRun = false;
|
||||
for (std::size_t index = 0; index < cycle.pattern.size();) {
|
||||
if (cycle.pattern[index] == 'a') {
|
||||
const std::size_t start = index;
|
||||
while (index < cycle.pattern.size() && cycle.pattern[index] == 'a') {
|
||||
++index;
|
||||
}
|
||||
tokens.push_back({start, index - start, true});
|
||||
previousWasRun = true;
|
||||
} else {
|
||||
if (!previousWasRun) {
|
||||
tokens.push_back({index, 0, false});
|
||||
}
|
||||
++index;
|
||||
previousWasRun = false;
|
||||
}
|
||||
}
|
||||
if (!previousWasRun) {
|
||||
tokens.push_back({cycle.pattern.size(), 0, false});
|
||||
}
|
||||
|
||||
std::string result;
|
||||
std::size_t copied = 0;
|
||||
std::uint64_t seen = 0;
|
||||
bool changed = false;
|
||||
for (const Token &token : tokens) {
|
||||
++seen;
|
||||
const bool replaceThis = subst.global || seen == subst.occurrence;
|
||||
result.append(cycle.pattern.substr(copied, token.start - copied));
|
||||
if (replaceThis) {
|
||||
std::vector<regmatch_t> groups(10, regmatch_t{-1, -1});
|
||||
groups[0] = regmatch_t{static_cast<regoff_t>(token.start),
|
||||
static_cast<regoff_t>(token.start + token.length)};
|
||||
result += Replacement::expand(subst.replacement, cycle.pattern, groups);
|
||||
changed = true;
|
||||
} else {
|
||||
result.append(cycle.pattern.substr(token.start, token.length));
|
||||
}
|
||||
copied = token.start + token.length;
|
||||
}
|
||||
result.append(cycle.pattern.substr(copied));
|
||||
if (changed) {
|
||||
cycle.pattern = std::move(result);
|
||||
lastSubstitutionSucceeded_ = true;
|
||||
lastRegex_ = subst.pattern;
|
||||
if (subst.print) {
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
}
|
||||
return changed;
|
||||
}
|
||||
|
||||
if (pattern == "^." && !subst.multiline && !cycle.pattern.empty()) {
|
||||
// Fast path for the common "replace first byte" case. It also avoids a
|
||||
// POSIX regex quirk around REG_NOTBOL when later global logic advances.
|
||||
regmatch_t whole{0, 1};
|
||||
std::vector<regmatch_t> groups(10, regmatch_t{-1, -1});
|
||||
groups[0] = whole;
|
||||
cycle.pattern =
|
||||
Replacement::expand(subst.replacement, cycle.pattern, groups) +
|
||||
cycle.pattern.substr(1);
|
||||
lastSubstitutionSucceeded_ = true;
|
||||
if (!subst.pattern.empty()) {
|
||||
lastRegex_ = subst.pattern;
|
||||
}
|
||||
const bool printBeforeExecute =
|
||||
subst.execute && subst.print &&
|
||||
subst.flagOrder.find('p') < subst.flagOrder.find('e');
|
||||
if (printBeforeExecute) {
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
if (subst.execute) {
|
||||
cycle.pattern = executeShell(cycle.pattern);
|
||||
cycle.hadDelimiter = true;
|
||||
}
|
||||
if (subst.print && !printBeforeExecute) {
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
if (!subst.writeFile.empty()) {
|
||||
output.writeFile(subst.writeFile, cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
if ((pattern == "^" || pattern == "$")) {
|
||||
// Anchors with M/m need insertion at every embedded record delimiter, not
|
||||
// just at the physical start/end of the pattern space.
|
||||
if (!subst.global && subst.occurrence > 1) {
|
||||
return false;
|
||||
}
|
||||
std::vector<regmatch_t> groups(10, regmatch_t{0, 0});
|
||||
const std::string inserted =
|
||||
Replacement::expand(subst.replacement, cycle.pattern, groups);
|
||||
std::string result;
|
||||
const char lineDelimiter = options_.nullData ? '\0' : '\n';
|
||||
if (pattern == "^") {
|
||||
result += inserted;
|
||||
for (std::size_t i = 0; i < cycle.pattern.size(); ++i) {
|
||||
result.push_back(cycle.pattern[i]);
|
||||
if (subst.multiline && cycle.pattern[i] == lineDelimiter &&
|
||||
i + 1 < cycle.pattern.size()) {
|
||||
result += inserted;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (std::size_t i = 0; i < cycle.pattern.size(); ++i) {
|
||||
if (subst.multiline && cycle.pattern[i] == lineDelimiter) {
|
||||
result += inserted;
|
||||
}
|
||||
result.push_back(cycle.pattern[i]);
|
||||
}
|
||||
result += inserted;
|
||||
}
|
||||
cycle.pattern = std::move(result);
|
||||
lastSubstitutionSucceeded_ = true;
|
||||
if (!subst.pattern.empty()) {
|
||||
lastRegex_ = subst.pattern;
|
||||
}
|
||||
const bool printBeforeExecute =
|
||||
subst.execute && subst.print &&
|
||||
subst.flagOrder.find('p') < subst.flagOrder.find('e');
|
||||
if (printBeforeExecute) {
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
if (subst.execute) {
|
||||
cycle.pattern = executeShell(cycle.pattern);
|
||||
cycle.hadDelimiter = true;
|
||||
}
|
||||
if (subst.print && !printBeforeExecute) {
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
if (!subst.writeFile.empty()) {
|
||||
output.writeFile(subst.writeFile, cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
Regex regex(pattern, options_, subst.ignoreCase, subst.multiline);
|
||||
|
||||
std::string result;
|
||||
std::size_t start = 0;
|
||||
std::uint64_t seen = 0;
|
||||
bool changed = false;
|
||||
|
||||
while (start <= cycle.pattern.size()) {
|
||||
auto match = regex.search(cycle.pattern, start);
|
||||
if (!match) {
|
||||
result.append(cycle.pattern.substr(start));
|
||||
break;
|
||||
}
|
||||
|
||||
const regmatch_t whole = match->groups[0];
|
||||
if (whole.rm_so < 0) {
|
||||
result.append(cycle.pattern.substr(start));
|
||||
break;
|
||||
}
|
||||
|
||||
++seen;
|
||||
const bool replaceThis =
|
||||
subst.global || subst.occurrence == 0 || seen == subst.occurrence;
|
||||
result.append(cycle.pattern.substr(start, whole.rm_so - start));
|
||||
if (replaceThis) {
|
||||
result.append(Replacement::expand(subst.replacement, cycle.pattern,
|
||||
match->groups));
|
||||
changed = true;
|
||||
} else {
|
||||
result.append(cycle.pattern.substr(whole.rm_so, whole.rm_eo - whole.rm_so));
|
||||
}
|
||||
|
||||
start = static_cast<std::size_t>(whole.rm_eo);
|
||||
if (whole.rm_so == whole.rm_eo) {
|
||||
// A successful empty match must consume one byte before the next search,
|
||||
// or global substitutions would loop forever.
|
||||
if (start < cycle.pattern.size()) {
|
||||
result.push_back(cycle.pattern[start++]);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!subst.global && subst.occurrence == 0) {
|
||||
result.append(cycle.pattern.substr(start));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (changed) {
|
||||
cycle.pattern = std::move(result);
|
||||
lastSubstitutionSucceeded_ = true;
|
||||
const bool printBeforeExecute =
|
||||
subst.execute && subst.print &&
|
||||
subst.flagOrder.find('p') < subst.flagOrder.find('e');
|
||||
if (printBeforeExecute) {
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
if (subst.execute) {
|
||||
cycle.pattern = executeShell(cycle.pattern);
|
||||
cycle.hadDelimiter = true;
|
||||
}
|
||||
if (subst.print && !printBeforeExecute) {
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
if (!subst.writeFile.empty()) {
|
||||
output.writeFile(subst.writeFile, cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
}
|
||||
return changed;
|
||||
}
|
||||
|
||||
void Runner::emitAppendQueue(Cycle &cycle, Output &output) {
|
||||
// a/r/R output is delayed until the end of the current cycle, after automatic
|
||||
// printing and before the next input record begins.
|
||||
for (const std::string &text : cycle.appendQueue) {
|
||||
output.writeLine(text);
|
||||
}
|
||||
cycle.appendQueue.clear();
|
||||
}
|
||||
|
||||
void Runner::queueFile(Cycle &cycle, const std::string &path) {
|
||||
std::error_code ec;
|
||||
const auto status = std::filesystem::status(path, ec);
|
||||
if (ec || !std::filesystem::is_regular_file(status)) {
|
||||
return;
|
||||
}
|
||||
std::ifstream input(path, std::ios::binary);
|
||||
if (!input) {
|
||||
return;
|
||||
}
|
||||
std::ostringstream buffer;
|
||||
buffer << input.rdbuf();
|
||||
std::string text = buffer.str();
|
||||
if (!text.empty() && text.back() == '\n') {
|
||||
// r appends file contents as text lines; stripping one final newline keeps
|
||||
// Output::writeLine from producing an extra blank record.
|
||||
text.pop_back();
|
||||
}
|
||||
cycle.appendQueue.push_back(std::move(text));
|
||||
}
|
||||
|
||||
void Runner::queueNextFileLine(Cycle &cycle, const std::string &path) {
|
||||
std::error_code ec;
|
||||
const auto status = std::filesystem::status(path, ec);
|
||||
if (ec || !std::filesystem::is_regular_file(status)) {
|
||||
return;
|
||||
}
|
||||
std::ifstream input(path, std::ios::binary);
|
||||
if (!input) {
|
||||
return;
|
||||
}
|
||||
|
||||
std::string line;
|
||||
std::size_t current = 0;
|
||||
std::size_t &wanted = readOffsets_[path];
|
||||
// R is stateful per file path: each command execution appends the next line
|
||||
// from that path, then advances the saved offset.
|
||||
while (current <= wanted && std::getline(input, line)) {
|
||||
if (current == wanted) {
|
||||
cycle.appendQueue.push_back(line);
|
||||
++wanted;
|
||||
return;
|
||||
}
|
||||
++current;
|
||||
}
|
||||
}
|
||||
|
||||
void Runner::execute(Command &command, Cycle &cycle, std::size_t &pc,
|
||||
std::vector<Record> &records, std::size_t &recordIndex,
|
||||
Output &output) {
|
||||
switch (command.opcode) {
|
||||
case '{':
|
||||
case '}':
|
||||
case ':':
|
||||
case 'v':
|
||||
break;
|
||||
case 'a':
|
||||
cycle.appendQueue.push_back(command.text);
|
||||
break;
|
||||
case 'i':
|
||||
output.writeLine(command.text);
|
||||
break;
|
||||
case 'c':
|
||||
if (!command.secondAddress || command.rangeJustStarted) {
|
||||
output.writeLine(command.text);
|
||||
}
|
||||
// c replaces the selected cycle and suppresses further commands. For
|
||||
// ranges, GNU sed emits the replacement only at the range start.
|
||||
cycle.deleted = true;
|
||||
pc = program_.commands.size();
|
||||
break;
|
||||
case 'd':
|
||||
cycle.deleted = true;
|
||||
pc = program_.commands.size();
|
||||
break;
|
||||
case 'D': {
|
||||
const std::size_t nl = cycle.pattern.find('\n');
|
||||
if (nl == std::string::npos) {
|
||||
cycle.deleted = true;
|
||||
pc = program_.commands.size();
|
||||
} else {
|
||||
// D restarts the script with the text after the first embedded newline.
|
||||
cycle.pattern.erase(0, nl + 1);
|
||||
pc = static_cast<std::size_t>(-1);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'p':
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
break;
|
||||
case 'P': {
|
||||
const std::size_t nl = cycle.pattern.find('\n');
|
||||
output.writeLine(nl == std::string::npos ? cycle.pattern
|
||||
: cycle.pattern.substr(0, nl));
|
||||
break;
|
||||
}
|
||||
case 'h':
|
||||
holdSpace_ = cycle.pattern;
|
||||
holdHadDelimiter_ = cycle.hadDelimiter;
|
||||
break;
|
||||
case 'H':
|
||||
// H/G always introduce a newline separator between hold and pattern space,
|
||||
// even when the current input delimiter is NUL.
|
||||
holdSpace_ += "\n" + cycle.pattern;
|
||||
holdHadDelimiter_ = cycle.hadDelimiter;
|
||||
break;
|
||||
case 'g':
|
||||
cycle.pattern = holdSpace_;
|
||||
cycle.hadDelimiter = holdHadDelimiter_;
|
||||
break;
|
||||
case 'G':
|
||||
cycle.pattern += "\n" + holdSpace_;
|
||||
cycle.hadDelimiter = holdHadDelimiter_;
|
||||
break;
|
||||
case 'x':
|
||||
std::swap(cycle.pattern, holdSpace_);
|
||||
std::swap(cycle.hadDelimiter, holdHadDelimiter_);
|
||||
break;
|
||||
case '=':
|
||||
output.writeLine(std::to_string(options_.separate ? cycle.fileLineNumber
|
||||
: cycle.lineNumber));
|
||||
break;
|
||||
case 'F':
|
||||
output.writeLine(cycle.fileName);
|
||||
break;
|
||||
case 'l':
|
||||
output.writeEscaped(cycle.pattern, true,
|
||||
command.lineLength > 0 ? command.lineLength
|
||||
: options_.lineLength);
|
||||
break;
|
||||
case 'n':
|
||||
if (!options_.quiet) {
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
emitAppendQueue(cycle, output);
|
||||
}
|
||||
// n replaces pattern space with the next input record and continues the
|
||||
// same script at the following command.
|
||||
if (recordIndex + 1 >= records.size()) {
|
||||
cycle.deleted = true;
|
||||
pc = program_.commands.size();
|
||||
} else {
|
||||
const Record &next = records[++recordIndex];
|
||||
cycle.pattern = next.text;
|
||||
cycle.hadDelimiter = next.hadDelimiter;
|
||||
cycle.fileName = next.fileName;
|
||||
cycle.lineNumber = next.lineNumber;
|
||||
cycle.fileLineNumber = next.fileLineNumber;
|
||||
cycle.lastInFile = next.lastInFile;
|
||||
cycle.lastOverall = next.lastOverall;
|
||||
lastSubstitutionSucceeded_ = false;
|
||||
}
|
||||
break;
|
||||
case 'N':
|
||||
if (recordIndex + 1 < records.size()) {
|
||||
emitAppendQueue(cycle, output);
|
||||
// N appends the next record to the existing pattern space with the active
|
||||
// record separator, then keeps executing this cycle.
|
||||
const Record &next = records[++recordIndex];
|
||||
cycle.pattern.push_back(options_.nullData ? '\0' : '\n');
|
||||
cycle.pattern += next.text;
|
||||
cycle.hadDelimiter = next.hadDelimiter;
|
||||
cycle.fileName = next.fileName;
|
||||
cycle.lineNumber = next.lineNumber;
|
||||
cycle.fileLineNumber = next.fileLineNumber;
|
||||
cycle.lastInFile = next.lastInFile;
|
||||
cycle.lastOverall = next.lastOverall;
|
||||
lastSubstitutionSucceeded_ = false;
|
||||
} else if (options_.posix) {
|
||||
cycle.deleted = true;
|
||||
pc = program_.commands.size();
|
||||
} else {
|
||||
// GNU sed prints the current pattern space before quitting when N reaches
|
||||
// EOF in non-POSIX mode.
|
||||
if (!options_.quiet) {
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
cycle.deleted = true;
|
||||
cycle.quit = true;
|
||||
pc = program_.commands.size();
|
||||
}
|
||||
break;
|
||||
case 'q':
|
||||
if (!options_.quiet) {
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
cycle.deleted = true;
|
||||
cycle.quit = true;
|
||||
cycle.exitCode = command.exitCode;
|
||||
finalStatus_ = cycle.exitCode;
|
||||
pc = program_.commands.size();
|
||||
break;
|
||||
case 'Q':
|
||||
cycle.deleted = true;
|
||||
cycle.quit = true;
|
||||
cycle.exitCode = command.exitCode;
|
||||
finalStatus_ = cycle.exitCode;
|
||||
pc = program_.commands.size();
|
||||
break;
|
||||
case 'b':
|
||||
pc = command.label.empty() ? program_.commands.size()
|
||||
: labels_.at(command.label);
|
||||
break;
|
||||
case 't':
|
||||
if (lastSubstitutionSucceeded_) {
|
||||
// t both tests and clears the substitution success flag.
|
||||
lastSubstitutionSucceeded_ = false;
|
||||
pc = command.label.empty() ? program_.commands.size()
|
||||
: labels_.at(command.label);
|
||||
}
|
||||
break;
|
||||
case 'T':
|
||||
if (!lastSubstitutionSucceeded_) {
|
||||
pc = command.label.empty() ? program_.commands.size()
|
||||
: labels_.at(command.label);
|
||||
} else {
|
||||
// A failed T leaves the program on the fallthrough path but still clears
|
||||
// the flag, matching GNU sed's branch-test semantics.
|
||||
lastSubstitutionSucceeded_ = false;
|
||||
}
|
||||
break;
|
||||
case 's':
|
||||
substitute(command, cycle, output);
|
||||
break;
|
||||
case 'y':
|
||||
{
|
||||
const auto from = splitCharacters(command.translate->from);
|
||||
const auto to = splitCharacters(command.translate->to);
|
||||
std::string translated;
|
||||
// Use character slices for lookup so multibyte transliteration tables stay
|
||||
// aligned with the compiler's decoded y strings.
|
||||
for (std::size_t i = 0; i < cycle.pattern.size();) {
|
||||
std::string current = splitCharacters(cycle.pattern.substr(i, 4)).front();
|
||||
std::size_t found = from.size();
|
||||
for (std::size_t index = 0; index < from.size(); ++index) {
|
||||
if (from[index] == current) {
|
||||
found = index;
|
||||
break;
|
||||
}
|
||||
}
|
||||
translated += found < to.size() ? to[found] : current;
|
||||
i += current.size();
|
||||
}
|
||||
cycle.pattern = std::move(translated);
|
||||
}
|
||||
break;
|
||||
case 'r': {
|
||||
queueFile(cycle, command.text);
|
||||
break;
|
||||
}
|
||||
case 'R': {
|
||||
queueNextFileLine(cycle, command.text);
|
||||
break;
|
||||
}
|
||||
case 'w':
|
||||
output.writeFile(command.text, cycle.pattern, cycle.hadDelimiter);
|
||||
break;
|
||||
case 'W': {
|
||||
const std::size_t nl = cycle.pattern.find('\n');
|
||||
output.writeFile(command.text,
|
||||
nl == std::string::npos ? cycle.pattern
|
||||
: cycle.pattern.substr(0, nl),
|
||||
true);
|
||||
break;
|
||||
}
|
||||
case 'e':
|
||||
if (command.text.empty()) {
|
||||
cycle.pattern = executeShell(cycle.pattern);
|
||||
cycle.hadDelimiter = true;
|
||||
} else {
|
||||
output.write(executeShell(command.text, false));
|
||||
}
|
||||
break;
|
||||
case 'z':
|
||||
cycle.pattern.clear();
|
||||
cycle.hadDelimiter = true;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
std::string Runner::runRecords(std::vector<Record> records) {
|
||||
std::ostringstream buffer;
|
||||
Output output(options_, buffer);
|
||||
|
||||
// GNU sed allows "0r file" to emit before the first input cycle.
|
||||
for (Command &command : program_.commands) {
|
||||
if (command.opcode == 'r' && command.firstAddress &&
|
||||
command.firstAddress->kind == AddressKind::Line &&
|
||||
command.firstAddress->first == 0 && !command.secondAddress) {
|
||||
Cycle prelude;
|
||||
queueFile(prelude, command.text);
|
||||
emitAppendQueue(prelude, output);
|
||||
}
|
||||
}
|
||||
|
||||
for (std::size_t index = 0; index < records.size(); ++index) {
|
||||
const Record &record = records[index];
|
||||
lastSubstitutionSucceeded_ = false;
|
||||
Cycle cycle;
|
||||
cycle.pattern = record.text;
|
||||
cycle.hadDelimiter = record.hadDelimiter;
|
||||
cycle.fileName = record.fileName;
|
||||
cycle.lineNumber = record.lineNumber;
|
||||
cycle.fileLineNumber = record.fileLineNumber;
|
||||
cycle.lastInFile = record.lastInFile;
|
||||
cycle.lastOverall = record.lastOverall;
|
||||
|
||||
for (Command &command : program_.commands) {
|
||||
if (command.opcode == '{' && command.rangeActive &&
|
||||
command.secondAddress &&
|
||||
command.secondAddress->kind == AddressKind::Line) {
|
||||
// Inactive braced blocks are skipped as a unit, so a block range ending
|
||||
// by numeric line needs this pre-pass to close before applicability is
|
||||
// tested for the current cycle.
|
||||
const std::uint64_t line =
|
||||
options_.separate ? cycle.fileLineNumber : cycle.lineNumber;
|
||||
if (line > command.secondAddress->first) {
|
||||
command.rangeActive = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (std::size_t pc = 0; pc < program_.commands.size(); ++pc) {
|
||||
Command &command = program_.commands[pc];
|
||||
const bool applies = commandApplies(command, cycle);
|
||||
if (command.opcode == '{' && !applies) {
|
||||
// Skip the entire inactive block while honoring nested braces in the
|
||||
// flattened command stream.
|
||||
int depth = 1;
|
||||
while (pc + 1 < program_.commands.size() && depth > 0) {
|
||||
++pc;
|
||||
if (program_.commands[pc].opcode == '{') {
|
||||
++depth;
|
||||
} else if (program_.commands[pc].opcode == '}') {
|
||||
--depth;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (applies) {
|
||||
if (command.opcode != '{' && command.opcode != '}') {
|
||||
execute(command, cycle, pc, records, index, output);
|
||||
}
|
||||
}
|
||||
if (cycle.deleted || cycle.quit) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!cycle.deleted && !options_.quiet) {
|
||||
output.writePattern(cycle.pattern, cycle.hadDelimiter);
|
||||
}
|
||||
emitAppendQueue(cycle, output);
|
||||
if (cycle.quit) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return buffer.str();
|
||||
}
|
||||
|
||||
int Runner::run() {
|
||||
InputLoader loader(options_);
|
||||
|
||||
if (options_.inPlace) {
|
||||
// In-place editing runs each file independently so hold space, R offsets,
|
||||
// last-regex state, and line numbering match GNU sed's per-file rewrite.
|
||||
if (options_.inputFiles.empty()) {
|
||||
std::cerr << "sed: no input files\n";
|
||||
return 4;
|
||||
}
|
||||
|
||||
for (const std::string &fileName : options_.inputFiles) {
|
||||
const std::string editName =
|
||||
options_.followSymlinks ? followSymlinkEditPath(fileName) : fileName;
|
||||
std::error_code ec;
|
||||
const std::filesystem::file_status status =
|
||||
std::filesystem::status(editName, ec);
|
||||
if (ec || !std::filesystem::exists(status)) {
|
||||
std::cerr << "sed: can't read " << fileName << '\n';
|
||||
return 4;
|
||||
}
|
||||
if (std::filesystem::is_character_file(status)) {
|
||||
std::cerr << "sed: couldn't edit " << fileName << ": is a terminal\n";
|
||||
return 4;
|
||||
}
|
||||
if (!std::filesystem::is_regular_file(status)) {
|
||||
std::cerr << "sed: couldn't edit " << fileName
|
||||
<< ": not a regular file\n";
|
||||
return 4;
|
||||
}
|
||||
|
||||
holdSpace_.clear();
|
||||
holdHadDelimiter_ = true;
|
||||
lastSubstitutionSucceeded_ = false;
|
||||
lastRegex_.clear();
|
||||
readOffsets_.clear();
|
||||
auto records = loader.loadFile(editName == "-" ? "./-" : editName);
|
||||
const std::string rewritten = runRecords(std::move(records));
|
||||
if (!options_.inPlaceSuffix.empty()) {
|
||||
// A backup suffix containing * expands each star to the input path;
|
||||
// otherwise the suffix is appended to the edited path.
|
||||
std::string backup = options_.inPlaceSuffix;
|
||||
std::size_t star = backup.find('*');
|
||||
if (star == std::string::npos) {
|
||||
backup = editName + backup;
|
||||
} else {
|
||||
std::string resolved;
|
||||
std::size_t start = 0;
|
||||
while (star != std::string::npos) {
|
||||
resolved += backup.substr(start, star - start);
|
||||
resolved += editName;
|
||||
start = star + 1;
|
||||
star = backup.find('*', start);
|
||||
}
|
||||
resolved += backup.substr(start);
|
||||
backup = std::move(resolved);
|
||||
}
|
||||
if (backup != editName) {
|
||||
std::error_code backupEc;
|
||||
std::filesystem::copy_file(
|
||||
editName, backup,
|
||||
std::filesystem::copy_options::overwrite_existing, backupEc);
|
||||
if (backupEc) {
|
||||
std::cerr << "sed: cannot rename " << fileName << " to " << backup
|
||||
<< ": " << backupEc.message() << '\n';
|
||||
return 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
const std::filesystem::path original(editName);
|
||||
const std::filesystem::path temp =
|
||||
original.parent_path() /
|
||||
(original.filename().string() + ".sedtmp." +
|
||||
std::to_string(::getpid()));
|
||||
// Write a sibling temporary file and then rename so a failed write does
|
||||
// not partially truncate the original.
|
||||
std::ofstream output(temp, std::ios::binary | std::ios::trunc);
|
||||
if (!output) {
|
||||
std::cerr << "sed: couldn't open temporary file\n";
|
||||
return 4;
|
||||
}
|
||||
output << rewritten;
|
||||
output.close();
|
||||
std::filesystem::rename(temp, original, ec);
|
||||
if (ec) {
|
||||
std::filesystem::remove(temp);
|
||||
std::cerr << "sed: couldn't rename temporary file\n";
|
||||
return 4;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
const bool readsStdin =
|
||||
options_.inputFiles.empty() ||
|
||||
std::find(options_.inputFiles.begin(), options_.inputFiles.end(), "-") !=
|
||||
options_.inputFiles.end();
|
||||
if (readsStdin) {
|
||||
// The upstream tests expect sed to reject nonblocking stdin rather than
|
||||
// spin or return partial data.
|
||||
const int flags = ::fcntl(STDIN_FILENO, F_GETFL, 0);
|
||||
if (flags >= 0 && (flags & O_NONBLOCK) != 0) {
|
||||
std::cerr << "sed: read error on stdin\n";
|
||||
return 4;
|
||||
}
|
||||
}
|
||||
|
||||
if (options_.unbuffered && readsStdin && options_.inputFiles.empty() &&
|
||||
program_.commands.size() == 1 && program_.commands.front().opcode == 'q' &&
|
||||
program_.commands.front().firstAddress &&
|
||||
program_.commands.front().firstAddress->kind == AddressKind::Line &&
|
||||
program_.commands.front().firstAddress->first == 1) {
|
||||
// A narrow streaming fast path for "sed -u '1q'": do not wait to read all
|
||||
// of stdin when the program quits after the first record.
|
||||
const char delimiter = options_.nullData ? '\0' : '\n';
|
||||
std::string text;
|
||||
if (std::getline(std::cin, text, delimiter)) {
|
||||
Record record;
|
||||
record.text = text;
|
||||
record.fileName = "-";
|
||||
record.hadDelimiter = !std::cin.eof();
|
||||
record.lineNumber = 1;
|
||||
record.fileLineNumber = 1;
|
||||
record.lastInFile = false;
|
||||
record.lastOverall = false;
|
||||
std::cout << runRecords({record});
|
||||
}
|
||||
return finalStatus_;
|
||||
}
|
||||
|
||||
if (options_.followSymlinks) {
|
||||
// Probe symlinks before loading so readlink diagnostics happen before any
|
||||
// output, matching GNU sed's command-line failure ordering.
|
||||
for (const std::string &fileName : options_.inputFiles) {
|
||||
if (fileName == "-") {
|
||||
continue;
|
||||
}
|
||||
std::error_code ec;
|
||||
(void)std::filesystem::symlink_status(fileName, ec);
|
||||
if (ec) {
|
||||
std::cerr << "sed: couldn't readlink " << fileName << ": "
|
||||
<< ec.message() << '\n';
|
||||
return 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<Record> records = loader.loadAll();
|
||||
std::cout << runRecords(std::move(records));
|
||||
return finalStatus_;
|
||||
}
|
||||
|
||||
} // namespace sedpp
|
||||
Reference in New Issue
Block a user