_addr1 = (SedAddress *)NULL;

_addr2 = (SedAddress *)NULL;

_command = '\0';

_flags = 0;

_active = false;

// First, skip initial whitespace.

while (p < line.length() && isspace(line[p])) {

p++;

}

// Now, check for an address.

if (p < line.length() &&

(isdigit(line[p]) || line[p] == '/' || line[p] == '\\')) {

_addr1 = new SedAddress;

if (!_addr1->parse_address(line, p)) {

return false;

}

if (p < line.length() && line[p] == ',') {

// Another address.

// Skip the comma and more whitespace.

p++;

while (p < line.length() && isspace(line[p])) {

p++;

}

_addr2 = new SedAddress;

if (!_addr2->parse_address(line, p)) {

return false;

}

}

}

if (p >= line.length()) {

// It's a null command, which is acceptable; ignore it.

return true;

}

_command = line[p];

// Skip more whitespace after the command letter.

p++;

while (p < line.length() && isspace(line[p])) {

p++;

}

// At the moment, we only accept a small subset of sed commands. We

// can add more later as we see the need.

switch (_command) {

case 'd':

// No arguments.

return true;

case 's':

// /regexp/repl/flags

return parse_s_params(line, p);

default:

cerr << "Unknown command: " << _command << "\n";

return false;

}

// First, see if this command matches the pattern space.

bool matches = false;

if (_addr1 != (SedAddress *)NULL && _addr2 != (SedAddress *)NULL) {

// If the user supplied two addresses, all lines inclusive between

// the lines matched by the two addresses are considered matching.

if (_active) {

// We have previously matched _addr1. Therefore this line is

// in, but are the rest of the lines following this one?

matches = true;

if (_addr2->matches(context)) {

// If this line matches addr2, that's the end of our range for

// next time.

_active = false;

}

} else {

// We have not yet matched _addr1. This line and subsequent

// lines are in only if we match now.

if (_addr1->matches(context)) {

matches = true;

if (!_addr2->precedes(context)) {

_active = true;

}

}

}

} else if (_addr1 != (SedAddress *)NULL) {

// If the user supplied only one address, only those lines that

// exactly match the address are considered matching.

matches = _addr1->matches(context);

} else {

// If the user supplied no addresses, all lines are considered

// matching.

matches = true;

}

if (matches) {

do_command(script, context);

}

size_t p0 = p;

char delimiter = line[p];

p++;

if (p < line.length() && delimiter == '\\') {

// A backslash might escape the opening character.

delimiter = line[p];

p++;

}

size_t begin = p;

while (p < line.length() && line[p] != delimiter) {

if (line[p] == '\\') {

p++;

// A backslash could escape the closing character.

}

p++;

}

if (p >= line.length()) {

cerr << "Could not find terminating character '" << delimiter

<< "' in regular expression: " << line.substr(p0) << "\n";

return false;

}

string re = line.substr(begin, p - begin);

p++;

int error = regcomp(&_re, re.c_str(), 0);

if (error != 0) {

static const int errbuf_size = 512;

char errbuf[errbuf_size];

regerror(error, &_re, errbuf, errbuf_size);

cerr << "Invalid regular expression: " << re << "\n"

<< errbuf << "\n";

return false;

}

_flags |= F_have_re;

// Get the replacement string.

begin = p;

while (p < line.length() && line[p] != delimiter) {

if (line[p] == '\\') {

p++;

// A backslash could escape the closing character.

}

p++;

}

if (p >= line.length()) {

cerr << "Could not find terminating character '" << delimiter

<< "' in replacement string: " << line.substr(p0) << "\n";

return false;

}

_string2 = line.substr(begin, p - begin);

// Skip the final delimiter.

p++;

if (p < line.length() && line[p] == 'g') {

// Global flag.

p++;

_flags |= F_g;

}

// Skip any more whitespace after the parameters.

while (p < line.length() && isspace(line[p])) {

p++;

}

return true;

switch (_command) {

case '\0':

// Null command.

return;

case 'd':

// Delete line.

context._deleted = true;

script._next_command = script._commands.end();

return;

case 's':

// Substitute.

do_s_command(context);

return;

}

cerr << "Undefined command: " << _command << "\n";

size_t nmatch = _re.re_nsub + 1;

regmatch_t *pmatch = new regmatch_t[nmatch];

string result;

const char *str = context._pattern_space.c_str();

int error = regexec(&_re, str, nmatch, pmatch, 0);

while (error == 0) {

// Here's a match. Determine the replacement.

string repl;

size_t p = 0;

while (p < _string2.length()) {

if (_string2[p] == '\\') {

p++;

if (p < _string2.length()) {

if (isdigit(_string2[p])) {

// Here's a subexpression reference.

const char *numstr = _string2.c_str() + p;

char *numend;

int ref = strtol(numstr, &numend, 10);

p += (numend - numstr);

if (ref <= 0 || ref >= (int)nmatch) {

cerr << "Invalid subexpression number: " << ref << "\n";

} else {

repl += string(str + pmatch[ref].rm_so,

pmatch[ref].rm_eo - pmatch[ref].rm_so);

}

} else {

// Here's an escaped character.

repl += _string2[p];

p++;

}

}

} else {

// Here's a normal character.

repl += _string2[p];

p++;

}

}

// Store the result so far.

result += string(str, pmatch[0].rm_so);

result += repl;

str += pmatch[0].rm_eo;

if ((_flags & F_g) == 0) {

// If we don't have the global flag set, stop after the first iteration.

result += str;

context._pattern_space = result;

delete[] pmatch;

return;

}

error = regexec(&_re, str, nmatch, pmatch, 0);

}

// All done.

result += str;

context._pattern_space = result;

delete[] pmatch;