fix ls and add start of ed
This commit is contained in:
parent
a94b5bcd94
commit
49f7c2be36
10 changed files with 1322 additions and 88 deletions
1
Makefile
1
Makefile
|
@ -19,6 +19,7 @@ EOF: clean build
|
||||||
dirs:
|
dirs:
|
||||||
mkdir -p ./$(BIN)
|
mkdir -p ./$(BIN)
|
||||||
mkdir -p ./$(BIN)/src
|
mkdir -p ./$(BIN)/src
|
||||||
|
mkdir -p ./$(BIN)/src/util
|
||||||
mkdir -p ./$(BIN)/src/commands
|
mkdir -p ./$(BIN)/src/commands
|
||||||
|
|
||||||
run: build
|
run: build
|
||||||
|
|
|
@ -1,4 +1,4 @@
|
||||||
#include "shared.h"
|
#include "util/shared.h"
|
||||||
|
|
||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
|
@ -19,3 +19,4 @@ COMMAND_EMPTY(user_id);
|
||||||
COMMAND(ls);
|
COMMAND(ls);
|
||||||
COMMAND(tail);
|
COMMAND(tail);
|
||||||
COMMAND(head);
|
COMMAND(head);
|
||||||
|
COMMAND(ed);
|
||||||
|
|
|
@ -2,6 +2,7 @@
|
||||||
|
|
||||||
#include <ctype.h>
|
#include <ctype.h>
|
||||||
#include <errno.h>
|
#include <errno.h>
|
||||||
|
#include <stdio.h>
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
#include <sys/stat.h>
|
#include <sys/stat.h>
|
||||||
|
|
||||||
|
@ -90,18 +91,26 @@ COMMAND(cat) {
|
||||||
flags.change_tabs = false;
|
flags.change_tabs = false;
|
||||||
flags.end_lines_dollar = false;
|
flags.end_lines_dollar = false;
|
||||||
|
|
||||||
|
int start = 0;
|
||||||
|
|
||||||
for (int i = 0; i < argc; i++) {
|
for (int i = 0; i < argc; i++) {
|
||||||
if (!prefix("-", argv[i])) {
|
if (!prefix("-", argv[i])) {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (streql("-", argv[i])) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
if (streql("--help", argv[i])) {
|
if (streql("--help", argv[i])) {
|
||||||
help();
|
help();
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t len = strlen(argv[i] + 1);
|
start++;
|
||||||
for (size_t j = 0; j < len; j++) {
|
|
||||||
char c = argv[i][j + 1];
|
size_t len = strlen(argv[i]);
|
||||||
|
for (size_t j = 1; j < len; j++) {
|
||||||
|
char c = argv[i][j];
|
||||||
switch (c) {
|
switch (c) {
|
||||||
case 'n':
|
case 'n':
|
||||||
flags.number_lines = true;
|
flags.number_lines = true;
|
||||||
|
@ -131,32 +140,18 @@ COMMAND(cat) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
bool files = false;
|
int arg_len = argc - start;
|
||||||
for (int i = 0; i < argc; i++) {
|
|
||||||
if (streql("-", argv[i])) {
|
if (arg_len < 1) {
|
||||||
files = true;
|
|
||||||
cat_file(stdin, flags);
|
cat_file(stdin, flags);
|
||||||
} else if (prefix("-", argv[i])) {
|
return EXIT_SUCCESS;
|
||||||
continue;
|
|
||||||
} else {
|
|
||||||
files = true;
|
|
||||||
struct stat s;
|
|
||||||
if (stat(argv[i], &s) < 0) {
|
|
||||||
printf("error: failed to read %s: %s\n", argv[i], strerror(errno));
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
if (!S_ISREG(s.st_mode)) {
|
|
||||||
printf("error: %s is not a file\n", argv[i]);
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
FILE* in = get_file(argv[i], "r");
|
|
||||||
cat_file(in, flags);
|
|
||||||
fclose(in);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!files) {
|
for (int i = start; i < argc; i++) {
|
||||||
cat_file(stdin, flags);
|
FILE* in = get_file(argv[i], "r");
|
||||||
|
cat_file(in, flags);
|
||||||
|
if (in != stdin)
|
||||||
|
fclose(in);
|
||||||
}
|
}
|
||||||
|
|
||||||
return EXIT_SUCCESS;
|
return EXIT_SUCCESS;
|
||||||
|
|
528
src/commands/ed.c
Normal file
528
src/commands/ed.c
Normal file
|
@ -0,0 +1,528 @@
|
||||||
|
#include "../command.h"
|
||||||
|
#include "../util//regex.h"
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
#define INPUT_LEN 1024
|
||||||
|
|
||||||
|
static char** lines = NULL;
|
||||||
|
static unsigned long line_capacity;
|
||||||
|
static unsigned long line_count;
|
||||||
|
static unsigned long line_current;
|
||||||
|
static bool pending_writes;
|
||||||
|
|
||||||
|
enum LineAddressType {
|
||||||
|
INDEX,
|
||||||
|
RANGE,
|
||||||
|
SET,
|
||||||
|
};
|
||||||
|
|
||||||
|
struct LineAddress {
|
||||||
|
enum LineAddressType type;
|
||||||
|
union {
|
||||||
|
struct {
|
||||||
|
long int i;
|
||||||
|
} index;
|
||||||
|
struct {
|
||||||
|
long int a;
|
||||||
|
long int b;
|
||||||
|
} range;
|
||||||
|
struct {
|
||||||
|
long int* b;
|
||||||
|
unsigned long c;
|
||||||
|
unsigned long s;
|
||||||
|
} set;
|
||||||
|
} data;
|
||||||
|
bool empty;
|
||||||
|
};
|
||||||
|
|
||||||
|
enum RegexDirection {
|
||||||
|
BEFORE,
|
||||||
|
AFTER,
|
||||||
|
ALL
|
||||||
|
};
|
||||||
|
|
||||||
|
static bool parse_regex(char** end, struct LineAddress* address, enum RegexDirection dir) {
|
||||||
|
char c;
|
||||||
|
char* index = *end;
|
||||||
|
char* regex_str = index;
|
||||||
|
while(true) {
|
||||||
|
c = *(index++);
|
||||||
|
if (c == '\0') {
|
||||||
|
fprintf(stderr, "error: missing regex after %c\n", dir == BEFORE ? '?' : '/');
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (c == (dir == BEFORE ? '?' : '/')) {
|
||||||
|
*(index - 1) = '\0';
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
unsigned long cap = 8;
|
||||||
|
unsigned long siz = 0;
|
||||||
|
long int* buf = malloc(cap * sizeof(unsigned long));
|
||||||
|
|
||||||
|
re_t regex = re_compile(regex_str);
|
||||||
|
unsigned long i = (dir == ALL ? 0 : line_current);
|
||||||
|
unsigned long until = (dir == BEFORE ? 0 : line_count - 1);
|
||||||
|
for (; (dir == BEFORE ? i >= until : i < until); dir == BEFORE ? i-- : i++) {
|
||||||
|
int len;
|
||||||
|
if (re_matchp(regex, lines[i], &len) == -1) {
|
||||||
|
if (dir == BEFORE && i == 0) break;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if (cap == siz) {
|
||||||
|
cap *= 2;
|
||||||
|
buf = realloc(buf, cap * sizeof(unsigned long));
|
||||||
|
}
|
||||||
|
buf[siz] = i;
|
||||||
|
siz++;
|
||||||
|
if (dir == BEFORE && i == 0) break;
|
||||||
|
}
|
||||||
|
|
||||||
|
address->type = SET;
|
||||||
|
address->data.set.s = siz;
|
||||||
|
address->data.set.c = cap;
|
||||||
|
address->data.set.b = buf;
|
||||||
|
*end = index;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool read_address(char** command, bool whitespace, struct LineAddress* a) {
|
||||||
|
char* index = *command;
|
||||||
|
struct LineAddress address;
|
||||||
|
memset(&address, 0, sizeof(struct LineAddress));
|
||||||
|
|
||||||
|
address.empty = false;
|
||||||
|
if (strlen(*command) < 1) {
|
||||||
|
address.type = INDEX;
|
||||||
|
address.data.index.i = line_current + 1;
|
||||||
|
if (line_current >= line_count) line_current = line_count - 1;
|
||||||
|
*a = address;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
char* end_pre;
|
||||||
|
long int n_pre = strtol(index, &end_pre, 10) - 1;
|
||||||
|
if (end_pre == index) {
|
||||||
|
n_pre = -1;
|
||||||
|
} else {
|
||||||
|
if (n_pre < 0) {
|
||||||
|
fprintf(stderr, "error: input cannot be negative\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
index = end_pre;
|
||||||
|
}
|
||||||
|
|
||||||
|
char pre = *(index++);
|
||||||
|
switch (pre) {
|
||||||
|
case '.':
|
||||||
|
address.type = INDEX;
|
||||||
|
address.data.index.i = line_current;
|
||||||
|
break;
|
||||||
|
case '$':
|
||||||
|
address.type = INDEX;
|
||||||
|
address.data.index.i = line_count - 1;
|
||||||
|
break;
|
||||||
|
case '-':
|
||||||
|
case '^': {
|
||||||
|
address.type = INDEX;
|
||||||
|
char* end;
|
||||||
|
long int n = strtol(index, &end, 10) - 1;
|
||||||
|
if (n < 0) {
|
||||||
|
fprintf(stderr, "error: input cannot be negative\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (index == end) {
|
||||||
|
address.data.index.i = line_current - 1;
|
||||||
|
} else {
|
||||||
|
address.data.index.i = line_current - n;
|
||||||
|
}
|
||||||
|
if (address.data.index.i < 0) {
|
||||||
|
fprintf(stderr, "error: line number %ld does not exist\n", address.data.index.i + 1);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case '+': {
|
||||||
|
address.type = INDEX;
|
||||||
|
char* end;
|
||||||
|
long int n = strtol(index, &end, 10) - 1;
|
||||||
|
if (n < 0) {
|
||||||
|
fprintf(stderr, "error: input cannot be negative\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (index == end) {
|
||||||
|
address.data.index.i = line_current + 1;
|
||||||
|
} else {
|
||||||
|
address.data.index.i = line_current + n;
|
||||||
|
}
|
||||||
|
if (address.data.index.i >= (long int) line_count) {
|
||||||
|
fprintf(stderr, "error: line number %ld does not exist\n", address.data.index.i + 1);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case '%':
|
||||||
|
address.type = RANGE;
|
||||||
|
address.data.range.a = 0;
|
||||||
|
address.data.range.b = line_count - 1;
|
||||||
|
break;
|
||||||
|
case ';':
|
||||||
|
address.type = RANGE;
|
||||||
|
address.data.range.a = line_current;
|
||||||
|
address.data.range.b = line_count - 1;
|
||||||
|
break;
|
||||||
|
case '/':
|
||||||
|
if (!parse_regex(&index, &address, AFTER)) return false;
|
||||||
|
break;
|
||||||
|
case '?':
|
||||||
|
if (!parse_regex(&index, &address, BEFORE)) return false;
|
||||||
|
break;
|
||||||
|
default: {
|
||||||
|
index--;
|
||||||
|
if (n_pre == -1) {
|
||||||
|
address.type = INDEX;
|
||||||
|
address.data.index.i = line_current;
|
||||||
|
address.empty = true;
|
||||||
|
break;
|
||||||
|
} else if (whitespace) {
|
||||||
|
address.type = INDEX;
|
||||||
|
address.data.index.i = line_current + n_pre;
|
||||||
|
} else {
|
||||||
|
address.type = INDEX;
|
||||||
|
address.data.index.i = n_pre;
|
||||||
|
}
|
||||||
|
if (address.data.index.i < 0 || address.data.index.i >= (long int) line_count) {
|
||||||
|
fprintf(stderr, "error: line number %ld does not exist\n", address.data.index.i + 1);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
*command = index;
|
||||||
|
*a = address;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void free_address (struct LineAddress address) {
|
||||||
|
if (address.type != SET) return;
|
||||||
|
free(address.data.set.b);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void free_data() {
|
||||||
|
if (lines == NULL) return;
|
||||||
|
for (unsigned long i = 0; i < line_count; i++)
|
||||||
|
free(lines[i]);
|
||||||
|
free(lines);
|
||||||
|
lines = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void load_empty() {
|
||||||
|
free_data();
|
||||||
|
|
||||||
|
line_capacity = 8;
|
||||||
|
lines = malloc(sizeof(char*) * line_capacity);
|
||||||
|
|
||||||
|
line_count = 0;
|
||||||
|
line_current = 0;
|
||||||
|
pending_writes = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void get_input(FILE* file, char*** buffer, unsigned long* capacity, unsigned long* size) {
|
||||||
|
unsigned long cap = 8;
|
||||||
|
unsigned long siz = 0;
|
||||||
|
char** buf = malloc(sizeof(char*) * cap);
|
||||||
|
|
||||||
|
char* line = NULL;
|
||||||
|
size_t offset = 0;
|
||||||
|
|
||||||
|
clearerr(stdin);
|
||||||
|
while (getline(&line, &offset, file) != -1) {
|
||||||
|
if (cap == siz) {
|
||||||
|
cap *= 2;
|
||||||
|
buf = realloc(buf, sizeof(char*) * cap);
|
||||||
|
}
|
||||||
|
buf[siz] = line;
|
||||||
|
siz++;
|
||||||
|
line = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
free(line);
|
||||||
|
|
||||||
|
*buffer = buf;
|
||||||
|
*capacity = cap;
|
||||||
|
*size = siz;
|
||||||
|
}
|
||||||
|
|
||||||
|
int ed_getline(char *buf, size_t size) {
|
||||||
|
size_t i = 0;
|
||||||
|
int ch;
|
||||||
|
clearerr(stdin);
|
||||||
|
while ((ch = getchar()) != EOF) { // Read until EOF ...
|
||||||
|
if (i + 1 < size) {
|
||||||
|
buf[i++] = ch;
|
||||||
|
}
|
||||||
|
if (ch == '\n') { // ... or end of line
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
buf[i] = '\0';
|
||||||
|
if (i == 0) {
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void load_file(FILE* file) {
|
||||||
|
free_data();
|
||||||
|
line_current = 0;
|
||||||
|
get_input(file, &lines, &line_capacity, &line_count);
|
||||||
|
if (file != stdin)
|
||||||
|
fclose(file);
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool check_if_sure() {
|
||||||
|
if (!pending_writes) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
printf("Do you really want to quit? ");
|
||||||
|
fflush(stdout);
|
||||||
|
|
||||||
|
char buf[INPUT_LEN];
|
||||||
|
if (ed_getline(buf, INPUT_LEN) == EOF) {
|
||||||
|
putchar('\n');
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return prefix("y", buf);
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool skip_whitespace(char** index) {
|
||||||
|
char c;
|
||||||
|
bool w = false;
|
||||||
|
while (c = **index, c == ' ' || c == '\t') { (*index)++; w = true; }
|
||||||
|
return w;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void expand(unsigned long count) {
|
||||||
|
if (count < line_capacity) return;
|
||||||
|
line_capacity *= 2;
|
||||||
|
if (count > line_capacity) line_capacity = count;
|
||||||
|
lines = realloc(lines, line_capacity * sizeof(char*));
|
||||||
|
}
|
||||||
|
|
||||||
|
static void append_lines(unsigned long index, char** new, unsigned long new_len) {
|
||||||
|
if (new_len < 1) return;
|
||||||
|
pending_writes = true;
|
||||||
|
expand(line_count + new_len);
|
||||||
|
if (index + 1 <= line_count)
|
||||||
|
memmove(&lines[index+new_len], &lines[index], sizeof(char*) * (line_count - index));
|
||||||
|
memcpy(&lines[index], new, sizeof(char*) * new_len);
|
||||||
|
line_count += new_len;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void delete_lines(unsigned long a, unsigned long b) {
|
||||||
|
if (b < a) return;
|
||||||
|
pending_writes = true;
|
||||||
|
for (unsigned long i = a; i <= b; i++) {
|
||||||
|
free(lines[i]);
|
||||||
|
}
|
||||||
|
if (b == line_count - 1) {
|
||||||
|
line_count = a;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
memmove(&lines[a], &lines[b+1], sizeof(char*) * (line_count - (b + 1)));
|
||||||
|
line_count -= (b - a) + 1;
|
||||||
|
line_current = a;
|
||||||
|
if (line_current >= line_count) line_current = line_count - 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool handle_append(struct LineAddress* address) {
|
||||||
|
if (address->type != INDEX) {
|
||||||
|
fprintf(stderr, "error: append command requires index addressing\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (line_count == 0) {
|
||||||
|
address->data.index.i = -1;
|
||||||
|
}
|
||||||
|
char** buf;
|
||||||
|
unsigned long cap, size;
|
||||||
|
get_input(stdin, &buf, &cap, &size);
|
||||||
|
if (size > 0) {
|
||||||
|
append_lines(address->data.index.i + 1, buf, size);
|
||||||
|
}
|
||||||
|
line_current += size;
|
||||||
|
free(buf);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool handle_delete(struct LineAddress* address) {
|
||||||
|
if (address->empty && address->data.index.i >= (long int) line_count) {
|
||||||
|
fprintf(stderr, "error: line number %ld does not exist\n", address->data.index.i + 1);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (address->type == INDEX) {
|
||||||
|
delete_lines(address->data.index.i, address->data.index.i);
|
||||||
|
} else if (address->type == RANGE) {
|
||||||
|
delete_lines(address->data.range.a, address->data.range.b);
|
||||||
|
} else if (address->type == SET) {
|
||||||
|
for (unsigned long i = 0; i < address->data.set.s; i++) {
|
||||||
|
delete_lines(address->data.set.b[i], address->data.set.b[i]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void prompt() {
|
||||||
|
printf("%ld: ", line_current + 1);
|
||||||
|
fflush(stdout);
|
||||||
|
|
||||||
|
char buf[INPUT_LEN];
|
||||||
|
if (ed_getline(buf, INPUT_LEN) == EOF) { putchar('\n'); return; }
|
||||||
|
if (buf[0] == '\0') { putchar('\n'); return; }
|
||||||
|
|
||||||
|
char* index = &buf[0];
|
||||||
|
bool whitespace = skip_whitespace(&index);
|
||||||
|
|
||||||
|
struct LineAddress address;
|
||||||
|
if (!read_address(&index, whitespace, &address)) return;
|
||||||
|
|
||||||
|
char cmd = *(index++);
|
||||||
|
|
||||||
|
if (cmd == ',') {
|
||||||
|
if (address.type != INDEX) {
|
||||||
|
fprintf(stderr, "error: comma range addressing requires two index addresses\n");
|
||||||
|
free_address(address);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
struct LineAddress address2;
|
||||||
|
whitespace = skip_whitespace(&index);
|
||||||
|
if (!read_address(&index, whitespace, &address2)) {
|
||||||
|
free_address(address);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (address2.type != INDEX) {
|
||||||
|
fprintf(stderr, "error: comma range addressing requires two index addresses\n");
|
||||||
|
free_address(address);
|
||||||
|
free_address(address2);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
address.type = RANGE;
|
||||||
|
address.data.range.a = address.data.index.i; // cursed
|
||||||
|
address.data.range.b = address2.data.index.i;
|
||||||
|
|
||||||
|
cmd = *(index++);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (address.type == RANGE && address.data.range.a > address.data.range.b) {
|
||||||
|
fprintf(stderr, "error: range addressing must be in ascending order\n");
|
||||||
|
free_address(address);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (cmd) {
|
||||||
|
case '\n':
|
||||||
|
case '\0':
|
||||||
|
if (address.empty) {
|
||||||
|
if (line_current == line_count) {
|
||||||
|
fprintf(stderr, "error: line number %ld does not exist\n", line_current + 1);
|
||||||
|
break;
|
||||||
|
} else if (line_current + 1 == line_count) {
|
||||||
|
fprintf(stderr, "error: line number %ld does not exist\n", line_current + 2);
|
||||||
|
break;
|
||||||
|
} else {
|
||||||
|
line_current++;
|
||||||
|
}
|
||||||
|
printf("%s", lines[line_current]);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (address.type == INDEX) {
|
||||||
|
line_current = address.data.index.i;
|
||||||
|
} else if (address.type == RANGE) {
|
||||||
|
line_current = address.data.range.b;
|
||||||
|
} else if (address.type == SET) {
|
||||||
|
fprintf(stderr, "error: unexpected range addressing\n");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
printf("%s", lines[line_current]);
|
||||||
|
break;
|
||||||
|
case 'a':
|
||||||
|
handle_append(&address);
|
||||||
|
break;
|
||||||
|
case 'd':
|
||||||
|
handle_delete(&address);
|
||||||
|
break;
|
||||||
|
case 'c':
|
||||||
|
if (!handle_delete(&address)) { break; }
|
||||||
|
address.type = INDEX;
|
||||||
|
address.data.index.i = line_current - 1;
|
||||||
|
handle_append(&address);
|
||||||
|
break;
|
||||||
|
case 'p':
|
||||||
|
if (address.empty && address.data.index.i >= (long int) line_count) {
|
||||||
|
fprintf(stderr, "error: line number %ld does not exist\n", address.data.index.i + 1);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (address.type == INDEX) {
|
||||||
|
printf("%s", lines[address.data.index.i]);
|
||||||
|
} else if (address.type == RANGE) {
|
||||||
|
for (long int i = address.data.range.a; i <= address.data.range.b; i++) {
|
||||||
|
printf("%s", lines[i]);
|
||||||
|
}
|
||||||
|
} else if (address.type == SET) {
|
||||||
|
for (unsigned long i = 0; i < address.data.set.s; i++) {
|
||||||
|
printf("%s", lines[address.data.set.b[i]]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 'q':
|
||||||
|
if(check_if_sure()) {
|
||||||
|
free_address(address);
|
||||||
|
free_data();
|
||||||
|
exit(EXIT_SUCCESS);
|
||||||
|
};
|
||||||
|
break;
|
||||||
|
case 'Q':
|
||||||
|
free_address(address);
|
||||||
|
free_data();
|
||||||
|
exit(EXIT_SUCCESS);
|
||||||
|
case 'g':
|
||||||
|
skip_whitespace(&index);
|
||||||
|
free_address(address);
|
||||||
|
if (*(index++) != '/') {
|
||||||
|
fprintf(stderr, "error: unexpected character at start or regex\n");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (!parse_regex(&index, &address, ALL)) { return; }
|
||||||
|
for (unsigned long i = 0; i < address.data.set.s; i++) {
|
||||||
|
printf("%s", lines[address.data.set.b[i]]);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
fprintf(stderr, "error: unimplemented command\n");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
free_address(address);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
static void prompt_loop() {
|
||||||
|
while (true) {
|
||||||
|
prompt();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
COMMAND(ed) {
|
||||||
|
if (argc < 1) {
|
||||||
|
load_empty();
|
||||||
|
prompt_loop();
|
||||||
|
} else {
|
||||||
|
FILE* file = get_file(argv[0], "r");
|
||||||
|
load_file(file);
|
||||||
|
prompt_loop();
|
||||||
|
}
|
||||||
|
return EXIT_SUCCESS;
|
||||||
|
}
|
|
@ -12,12 +12,14 @@
|
||||||
#include <ftw.h>
|
#include <ftw.h>
|
||||||
#include <limits.h>
|
#include <limits.h>
|
||||||
|
|
||||||
#define FILE_COLOR "\x1b[0m"
|
#define FILE_COLOR ANSCII BLACK COLOR
|
||||||
#define DIR_COLOR "\x1b[1;34m"
|
#define DIR_COLOR ANSCII BOLD NEXT NORMAL BLUE COLOR
|
||||||
#define SET_UID_COLOR "\x1b[41m"
|
#define DIR_COLOR_EXEC ANSCII BACKGROUND GREEN NEXT NORMAL BLACK COLOR
|
||||||
#define SET_GID_COLOR "\x1b[43m"
|
#define LINK_COLOR ANSCII BOLD NEXT HIGHLIGHT TURQUOISE COLOR
|
||||||
#define EXEC_COLOR "\x1b[1;92m"
|
#define SET_UID_COLOR ANSCII BACKGROUND RED NEXT NORMAL WHITE COLOR
|
||||||
#define LINK_COLOR "\x1b[1;96m"
|
#define SET_GID_COLOR ANSCII BACKGROUND YELLOW NEXT NORMAL BLACK COLOR
|
||||||
|
#define EXEC_COLOR ANSCII BOLD NEXT NORMAL GREEN COLOR
|
||||||
|
#define BLK_COLOR ANSCII BOLD NEXT NORMAL YELLOW COLOR
|
||||||
|
|
||||||
struct Flags {
|
struct Flags {
|
||||||
bool hidden;
|
bool hidden;
|
||||||
|
@ -25,17 +27,17 @@ struct Flags {
|
||||||
bool more_info;
|
bool more_info;
|
||||||
bool one_column;
|
bool one_column;
|
||||||
bool recurse;
|
bool recurse;
|
||||||
bool colored;
|
enum When colored;
|
||||||
};
|
};
|
||||||
|
|
||||||
struct FileInfo {
|
struct FileInfo {
|
||||||
char mode[11];
|
|
||||||
int links;
|
|
||||||
struct passwd* usr;
|
struct passwd* usr;
|
||||||
struct group* grp;
|
struct group* grp;
|
||||||
char size[5];
|
|
||||||
char date[13];
|
|
||||||
char name[PATH_MAX];
|
char name[PATH_MAX];
|
||||||
|
char date[13];
|
||||||
|
char mode[11];
|
||||||
|
char size[5];
|
||||||
|
int links;
|
||||||
bool set_uid;
|
bool set_uid;
|
||||||
bool set_gid;
|
bool set_gid;
|
||||||
bool exec;
|
bool exec;
|
||||||
|
@ -76,33 +78,58 @@ static void append_path(char buf[PATH_MAX], const char* dir_path, const char* fi
|
||||||
buf[dir_len + file_len] = '\0';
|
buf[dir_len + file_len] = '\0';
|
||||||
}
|
}
|
||||||
|
|
||||||
static bool get_file_info(struct dirent* file, const char* dir_path, struct FileInfo* info) {
|
static bool get_file_info(const char* file_path, const char* dir_path, struct FileInfo* info) {
|
||||||
|
|
||||||
uid_t uid = getuid();
|
uid_t uid = getuid();
|
||||||
gid_t gid = getgid();
|
gid_t gid = getgid();
|
||||||
|
|
||||||
char buf[PATH_MAX];
|
char buf[PATH_MAX];
|
||||||
append_path(buf, dir_path, file->d_name);
|
append_path(buf, dir_path, file_path);
|
||||||
|
|
||||||
struct stat s;
|
struct stat s;
|
||||||
memset(&s, 0, sizeof(struct stat));
|
memset(&s, 0, sizeof(struct stat));
|
||||||
|
|
||||||
if (stat(buf, &s) < 0) {
|
if (lstat(buf, &s) < 0) {
|
||||||
// printf("\x1b[0merror: failed to read file '%s': %s\n", buf, strerror(errno));
|
printf("\x1b[0merror: failed to read file '%s': %s\n", buf, strerror(errno));
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
int ty = (s.st_mode & S_IFMT) >> 12;
|
||||||
|
|
||||||
info->set_uid = false;
|
info->set_uid = false;
|
||||||
info->set_gid = false;
|
info->set_gid = false;
|
||||||
info->exec = false;
|
info->exec = false;
|
||||||
info->name[0] = '\0';
|
info->name[0] = '\0';
|
||||||
|
|
||||||
if (file->d_type == DT_DIR)
|
switch (ty) {
|
||||||
|
case DT_BLK:
|
||||||
|
info->mode[0] = 'b';
|
||||||
|
break;
|
||||||
|
case DT_CHR:
|
||||||
|
info->mode[0] = 'c';
|
||||||
|
break;
|
||||||
|
case DT_DIR:
|
||||||
info->mode[0] = 'd';
|
info->mode[0] = 'd';
|
||||||
else if (file->d_type == DT_LNK)
|
break;
|
||||||
|
case DT_FIFO:
|
||||||
|
info->mode[0] = 'f';
|
||||||
|
break;
|
||||||
|
case DT_LNK:
|
||||||
info->mode[0] = 'l';
|
info->mode[0] = 'l';
|
||||||
else
|
break;
|
||||||
|
case DT_SOCK:
|
||||||
|
info->mode[0] = 's';
|
||||||
|
break;
|
||||||
|
case DT_UNKNOWN:
|
||||||
|
info->mode[0] = 'u';
|
||||||
|
break;
|
||||||
|
case DT_WHT:
|
||||||
|
info->mode[0] = 'w';
|
||||||
|
break;
|
||||||
|
default:
|
||||||
info->mode[0] = '-';
|
info->mode[0] = '-';
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
info->mode[1] = (s.st_mode & S_IRUSR) ? 'r' : '-';
|
info->mode[1] = (s.st_mode & S_IRUSR) ? 'r' : '-';
|
||||||
info->mode[2] = (s.st_mode & S_IWUSR) ? 'w' : '-';
|
info->mode[2] = (s.st_mode & S_IWUSR) ? 'w' : '-';
|
||||||
|
@ -146,21 +173,31 @@ static bool get_file_info(struct dirent* file, const char* dir_path, struct File
|
||||||
info->usr = getpwuid(s.st_uid);
|
info->usr = getpwuid(s.st_uid);
|
||||||
info->grp = getgrgid(s.st_gid);
|
info->grp = getgrgid(s.st_gid);
|
||||||
info->links = s.st_nlink;
|
info->links = s.st_nlink;
|
||||||
info->type = file->d_type;
|
info->type = ty;
|
||||||
|
|
||||||
strcpy(info->name, file->d_name);
|
strcpy(info->name, file_path);
|
||||||
|
|
||||||
print_file_size(s.st_size, info->size);
|
print_file_size(s.st_size, info->size);
|
||||||
print_date_time(s.st_mtim.tv_sec + s.st_mtim.tv_nsec / 1000000, info->date);
|
print_date_time(s.st_mtim.tv_sec + s.st_mtim.tv_nsec / 1000000000, info->date);
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
static char* get_file_color(struct FileInfo* info) {
|
static char* get_file_color(struct FileInfo* info) {
|
||||||
char* color;
|
char* color;
|
||||||
if (info->type == DT_DIR) {
|
if (info->type == DT_DIR) {
|
||||||
|
if (info->mode[8] == 'w') {
|
||||||
|
color = DIR_COLOR_EXEC;
|
||||||
|
} else {
|
||||||
color = DIR_COLOR;
|
color = DIR_COLOR;
|
||||||
|
}
|
||||||
} else if (info->type == DT_LNK) {
|
} else if (info->type == DT_LNK) {
|
||||||
color = LINK_COLOR;
|
color = LINK_COLOR;
|
||||||
|
} else if (
|
||||||
|
info->type == DT_CHR ||
|
||||||
|
info->type == DT_BLK ||
|
||||||
|
info->type == DT_SOCK
|
||||||
|
) {
|
||||||
|
color = BLK_COLOR;
|
||||||
} else {
|
} else {
|
||||||
if (info->set_uid) {
|
if (info->set_uid) {
|
||||||
color = SET_UID_COLOR;
|
color = SET_UID_COLOR;
|
||||||
|
@ -181,7 +218,8 @@ static void list_files(struct FileInfo* files, int file_len, struct FileListInfo
|
||||||
|
|
||||||
if (!isatty(1)) {
|
if (!isatty(1)) {
|
||||||
flags->one_column = true;
|
flags->one_column = true;
|
||||||
flags->colored = false;
|
if (flags->colored == AUTO)
|
||||||
|
flags->colored = NO;
|
||||||
}
|
}
|
||||||
|
|
||||||
char* color;
|
char* color;
|
||||||
|
@ -192,7 +230,7 @@ static void list_files(struct FileInfo* files, int file_len, struct FileListInfo
|
||||||
struct FileInfo finfo = files[i];
|
struct FileInfo finfo = files[i];
|
||||||
color = get_file_color(&finfo);
|
color = get_file_color(&finfo);
|
||||||
if (flags->more_info) {
|
if (flags->more_info) {
|
||||||
printf("%s %*d %*s %*s %*s %s %s%s\x1b[0m",
|
printf("%s %*d %*s %*s %*s %s %s%s%s",
|
||||||
finfo.mode,
|
finfo.mode,
|
||||||
info.max_link,
|
info.max_link,
|
||||||
finfo.links,
|
finfo.links,
|
||||||
|
@ -203,37 +241,40 @@ static void list_files(struct FileInfo* files, int file_len, struct FileListInfo
|
||||||
info.max_size,
|
info.max_size,
|
||||||
finfo.size,
|
finfo.size,
|
||||||
finfo.date,
|
finfo.date,
|
||||||
flags->colored ? color : FILE_COLOR,
|
flags->colored != NO ? color : "",
|
||||||
finfo.name
|
finfo.name,
|
||||||
|
flags->colored != NO ? "\x1b[0m" : ""
|
||||||
);
|
);
|
||||||
if (finfo.type == DT_LNK) {
|
if (finfo.type == DT_LNK) {
|
||||||
char path[PATH_MAX];
|
char path[PATH_MAX];
|
||||||
append_path(path, dir_path, finfo.name);
|
append_path(path, dir_path, finfo.name);
|
||||||
|
|
||||||
char lnk[PATH_MAX];
|
char lnk[PATH_MAX];
|
||||||
if (readlink(path, lnk, PATH_MAX) < 0) {
|
ssize_t n;
|
||||||
putchar('\n');
|
if ((n = readlink(path, lnk, PATH_MAX)) != -1) {
|
||||||
|
printf(" -> %.*s\n", (int)n, lnk);
|
||||||
} else {
|
} else {
|
||||||
printf(" -> %s\n", lnk);
|
putchar('\n');
|
||||||
}
|
}
|
||||||
|
|
||||||
} else {
|
} else {
|
||||||
putchar('\n');
|
putchar('\n');
|
||||||
}
|
}
|
||||||
} else if (flags->one_column) {
|
} else if (flags->one_column) {
|
||||||
printf("%s%s\x1b[0m\n", color, finfo.name);
|
printf("%s%s%s\n", color, finfo.name, flags->colored != NO ? "\x1b[0m" : "");
|
||||||
} else {
|
} else {
|
||||||
if (info.total_len > w.ws_col) {
|
if (info.total_len > w.ws_col) {
|
||||||
if (i != 0 && i % row_count == 0) putchar('\n');
|
if (i != 0 && i % row_count == 0) putchar('\n');
|
||||||
printf("%s%*s\x1b[0m", flags->colored ? color : FILE_COLOR, -column_width, finfo.name);
|
printf("%s%*s%s", flags->colored != NO ? color : "", -column_width,
|
||||||
|
finfo.name, flags->colored != NO ? "\x1b[0m" : "");
|
||||||
} else {
|
} else {
|
||||||
printf("%s%s\x1b[0m ", flags->colored ? color : FILE_COLOR, finfo.name);
|
printf("%s%s%s ", flags->colored != NO ? color : "", finfo.name,
|
||||||
|
flags->colored != NO ? "\x1b[0m" : "");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (info.total_len <= w.ws_col) printf("\n");
|
if (!flags->more_info) printf("\n");
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static bool is_dot_dir(const char* path) {
|
static bool is_dot_dir(const char* path) {
|
||||||
|
@ -254,25 +295,24 @@ static void push_file(
|
||||||
struct FileInfo** files,
|
struct FileInfo** files,
|
||||||
struct FileListInfo* info,
|
struct FileListInfo* info,
|
||||||
int* size, int* capacity,
|
int* size, int* capacity,
|
||||||
struct dirent* file,
|
const char* file_path,
|
||||||
const char* dir_path
|
const char* dir_path
|
||||||
) {
|
) {
|
||||||
|
|
||||||
struct FileInfo finfo;
|
struct FileInfo finfo;
|
||||||
if (!get_file_info(file, dir_path, &finfo)) return;
|
if (!get_file_info(file_path, dir_path, &finfo)) return;
|
||||||
|
|
||||||
if (*size == *capacity) {
|
if (*size == *capacity) {
|
||||||
*capacity *= 2;
|
*capacity *= 2;
|
||||||
*files = realloc(*files, sizeof(struct FileInfo) * *capacity);
|
*files = realloc(*files, sizeof(struct FileInfo) * *capacity);
|
||||||
}
|
}
|
||||||
|
|
||||||
int user_len = strlen(finfo.usr->pw_name);
|
int user_len = strlen(finfo.usr->pw_name);
|
||||||
if (user_len > info->max_usr) info->max_usr = user_len;
|
if (user_len > info->max_usr) info->max_usr = user_len;
|
||||||
|
|
||||||
int group_len = strlen(finfo.grp->gr_name);
|
int group_len = strlen(finfo.grp->gr_name);
|
||||||
if (group_len > info->max_grp) info->max_grp = group_len;
|
if (group_len > info->max_grp) info->max_grp = group_len;
|
||||||
|
|
||||||
int name_len = strlen(file->d_name);
|
int name_len = strlen(file_path);
|
||||||
if (name_len > info->max_name) info->max_name = name_len;
|
if (name_len > info->max_name) info->max_name = name_len;
|
||||||
|
|
||||||
int size_len = strlen(finfo.size);
|
int size_len = strlen(finfo.size);
|
||||||
|
@ -307,10 +347,13 @@ static bool recurse_directory(char* path, struct Flags* flags) {
|
||||||
if (!flags->hidden && prefix(".", file->d_name)) continue;
|
if (!flags->hidden && prefix(".", file->d_name)) continue;
|
||||||
if (is_dot_dir(file->d_name)) continue;
|
if (is_dot_dir(file->d_name)) continue;
|
||||||
if (first) {
|
if (first) {
|
||||||
|
if (flags->colored == NO)
|
||||||
|
printf("\n%s:\n", path);
|
||||||
|
else
|
||||||
printf("\n%s%s:%s\n", DIR_COLOR, path, FILE_COLOR);
|
printf("\n%s%s:%s\n", DIR_COLOR, path, FILE_COLOR);
|
||||||
first = false;
|
first = false;
|
||||||
}
|
}
|
||||||
push_file(&files, &info, &size, &capacity, file, path);
|
push_file(&files, &info, &size, &capacity, file->d_name, path);
|
||||||
}
|
}
|
||||||
|
|
||||||
list_files(files, size, info, flags, path);
|
list_files(files, size, info, flags, path);
|
||||||
|
@ -355,16 +398,39 @@ static bool list_directory(char* path, struct Flags* flags) {
|
||||||
while ((file = readdir(d)) != NULL) {
|
while ((file = readdir(d)) != NULL) {
|
||||||
if (!flags->hidden && prefix(".", file->d_name)) continue;
|
if (!flags->hidden && prefix(".", file->d_name)) continue;
|
||||||
if (flags->hide_dot && is_dot_dir(file->d_name)) continue;
|
if (flags->hide_dot && is_dot_dir(file->d_name)) continue;
|
||||||
push_file(&files, &info, &size, &capacity, file, path);
|
push_file(&files, &info, &size, &capacity, file->d_name, path);
|
||||||
}
|
}
|
||||||
|
|
||||||
list_files(files, size, info, flags, path);
|
if (size > 0) list_files(files, size, info, flags, path);
|
||||||
free(files);
|
free(files);
|
||||||
|
|
||||||
closedir(d);
|
closedir(d);
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static bool is_dir(const char* path) {
|
||||||
|
struct stat s;
|
||||||
|
if (stat(path, &s) < 0) return false;
|
||||||
|
return S_ISDIR(s.st_mode);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void list_file_args(int start, int argc, char** argv, struct Flags* flags) {
|
||||||
|
int capacity = 8;
|
||||||
|
int size = 0;
|
||||||
|
struct FileInfo* files = malloc(sizeof(struct FileInfo) * capacity);
|
||||||
|
struct FileListInfo info;
|
||||||
|
memset(&info, 0, sizeof(struct FileListInfo));
|
||||||
|
|
||||||
|
for (int i = start; i < argc; i++) {
|
||||||
|
if (is_dir(argv[i])) continue;
|
||||||
|
push_file((struct FileInfo**) &files, &info, &size, &capacity, argv[i], ".");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (size > 0) list_files(files, size, info, flags, ".");
|
||||||
|
|
||||||
|
free(files);
|
||||||
|
}
|
||||||
|
|
||||||
static void help() {
|
static void help() {
|
||||||
printf("Usage: ls [FILE]...\n\n");
|
printf("Usage: ls [FILE]...\n\n");
|
||||||
printf("List directory contents\n\n");
|
printf("List directory contents\n\n");
|
||||||
|
@ -384,15 +450,24 @@ COMMAND(ls) {
|
||||||
flags.hide_dot = false;
|
flags.hide_dot = false;
|
||||||
flags.one_column = false;
|
flags.one_column = false;
|
||||||
flags.recurse = false;
|
flags.recurse = false;
|
||||||
flags.colored = false;
|
flags.colored = AUTO;
|
||||||
|
|
||||||
int start = 0;
|
int start = 0;
|
||||||
for (int i = 0; i < argc; i++) {
|
for (int i = 0; i < argc; i++) {
|
||||||
if (!prefix("-", argv[i])) break;
|
if (!prefix("-", argv[i])) break;
|
||||||
if (streql("--help", argv[i])) help();
|
if (streql("--help", argv[i])) help();
|
||||||
start++;
|
start++;
|
||||||
if (streql("--color=auto", argv[i]) || streql("--color=yes", argv[i])) {
|
if (prefix("--color=", argv[i])) {
|
||||||
flags.colored = true;
|
char* arg = argv[i] + 8;
|
||||||
|
if (streql("yes", arg) || streql("always", arg)) {
|
||||||
|
flags.colored = YES;
|
||||||
|
} else if (streql("auto", arg)) {
|
||||||
|
flags.colored = AUTO;
|
||||||
|
} else if (streql("no", arg) || streql("never", arg)) {
|
||||||
|
flags.colored = NO;
|
||||||
|
} else {
|
||||||
|
error("error: invalid color options: %s", arg);
|
||||||
|
}
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
for (size_t j = 1; j < strlen(argv[i]); j++) {
|
for (size_t j = 1; j < strlen(argv[i]); j++) {
|
||||||
|
@ -422,14 +497,19 @@ COMMAND(ls) {
|
||||||
|
|
||||||
if (argc - start == 0) {
|
if (argc - start == 0) {
|
||||||
list_directory(".", &flags);
|
list_directory(".", &flags);
|
||||||
if (!flags.more_info) printf("\n");
|
|
||||||
return EXIT_SUCCESS;
|
return EXIT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
list_file_args(start, argc, argv, &flags);
|
||||||
|
|
||||||
bool titled = argc - start > 1;
|
bool titled = argc - start > 1;
|
||||||
for (int i = start; i < argc; i++) {
|
for (int i = start; i < argc; i++) {
|
||||||
|
if (!is_dir(argv[i])) continue;
|
||||||
if (titled && !flags.recurse) {
|
if (titled && !flags.recurse) {
|
||||||
|
if (flags.colored != NO)
|
||||||
printf("\n%s%s:%s\n", DIR_COLOR, argv[i], FILE_COLOR);
|
printf("\n%s%s:%s\n", DIR_COLOR, argv[i], FILE_COLOR);
|
||||||
|
else
|
||||||
|
printf("\n%s:\n", argv[i]);
|
||||||
}
|
}
|
||||||
if (list_directory(argv[i], &flags) && i + 1 != argc)
|
if (list_directory(argv[i], &flags) && i + 1 != argc)
|
||||||
if (titled && !flags.recurse) printf("\n");
|
if (titled && !flags.recurse) printf("\n");
|
||||||
|
|
|
@ -1,4 +1,4 @@
|
||||||
#include "shared.h"
|
#include "util/shared.h"
|
||||||
#include "command.h"
|
#include "command.h"
|
||||||
|
|
||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
|
@ -20,7 +20,7 @@ int main (ARGUMENTS) {
|
||||||
if (argc < 2) {
|
if (argc < 2) {
|
||||||
printf("usage: lazysphere [function [arguments]...]\n\n");
|
printf("usage: lazysphere [function [arguments]...]\n\n");
|
||||||
printf("currently defined functions:\n");
|
printf("currently defined functions:\n");
|
||||||
printf("\tdd, cat, yes, echo, printf, id, groups, ls, tail, head\n");
|
printf("\tdd, cat, yes, echo, printf, id, groups, ls, tail, head, ed\n");
|
||||||
return EXIT_SUCCESS;
|
return EXIT_SUCCESS;
|
||||||
}
|
}
|
||||||
argc--;
|
argc--;
|
||||||
|
@ -54,6 +54,8 @@ int main (ARGUMENTS) {
|
||||||
return tail(NEXT_ARGS);
|
return tail(NEXT_ARGS);
|
||||||
} else if (streql(cmd, "head")) {
|
} else if (streql(cmd, "head")) {
|
||||||
return head(NEXT_ARGS);
|
return head(NEXT_ARGS);
|
||||||
|
} else if (streql(cmd, "ed")) {
|
||||||
|
return ed(NEXT_ARGS);
|
||||||
} else {
|
} else {
|
||||||
error("error: invalid command %s", cmd);
|
error("error: invalid command %s", cmd);
|
||||||
}
|
}
|
||||||
|
|
528
src/util/regex.c
Normal file
528
src/util/regex.c
Normal file
|
@ -0,0 +1,528 @@
|
||||||
|
/*
|
||||||
|
*
|
||||||
|
* Mini regex-module inspired by Rob Pike's regex code described in:
|
||||||
|
*
|
||||||
|
* http://www.cs.princeton.edu/courses/archive/spr09/cos333/beautiful.html
|
||||||
|
*
|
||||||
|
*
|
||||||
|
*
|
||||||
|
* Supports:
|
||||||
|
* ---------
|
||||||
|
* '.' Dot, matches any character
|
||||||
|
* '^' Start anchor, matches beginning of string
|
||||||
|
* '$' End anchor, matches end of string
|
||||||
|
* '*' Asterisk, match zero or more (greedy)
|
||||||
|
* '+' Plus, match one or more (greedy)
|
||||||
|
* '?' Question, match zero or one (non-greedy)
|
||||||
|
* '[abc]' Character class, match if one of {'a', 'b', 'c'}
|
||||||
|
* '[^abc]' Inverted class, match if NOT one of {'a', 'b', 'c'} -- NOTE: feature is currently broken!
|
||||||
|
* '[a-zA-Z]' Character ranges, the character set of the ranges { a-z | A-Z }
|
||||||
|
* '\s' Whitespace, \t \f \r \n \v and spaces
|
||||||
|
* '\S' Non-whitespace
|
||||||
|
* '\w' Alphanumeric, [a-zA-Z0-9_]
|
||||||
|
* '\W' Non-alphanumeric
|
||||||
|
* '\d' Digits, [0-9]
|
||||||
|
* '\D' Non-digits
|
||||||
|
*
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#include "regex.h"
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
|
||||||
|
/* Definitions: */
|
||||||
|
|
||||||
|
#define MAX_REGEXP_OBJECTS 30 /* Max number of regex symbols in expression. */
|
||||||
|
#define MAX_CHAR_CLASS_LEN 40 /* Max length of character-class buffer in. */
|
||||||
|
|
||||||
|
|
||||||
|
enum { UNUSED, DOT, BEGIN, END, QUESTIONMARK, STAR, PLUS, CHAR, CHAR_CLASS, INV_CHAR_CLASS, DIGIT, NOT_DIGIT, ALPHA, NOT_ALPHA, WHITESPACE, NOT_WHITESPACE, /* BRANCH */ };
|
||||||
|
|
||||||
|
typedef struct regex_t
|
||||||
|
{
|
||||||
|
unsigned char type; /* CHAR, STAR, etc. */
|
||||||
|
union
|
||||||
|
{
|
||||||
|
unsigned char ch; /* the character itself */
|
||||||
|
unsigned char* ccl; /* OR a pointer to characters in class */
|
||||||
|
} u;
|
||||||
|
} regex_t;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* Private function declarations: */
|
||||||
|
static int matchpattern(regex_t* pattern, const char* text, int* matchlength);
|
||||||
|
static int matchcharclass(char c, const char* str);
|
||||||
|
static int matchstar(regex_t p, regex_t* pattern, const char* text, int* matchlength);
|
||||||
|
static int matchplus(regex_t p, regex_t* pattern, const char* text, int* matchlength);
|
||||||
|
static int matchone(regex_t p, char c);
|
||||||
|
static int matchdigit(char c);
|
||||||
|
static int matchalpha(char c);
|
||||||
|
static int matchwhitespace(char c);
|
||||||
|
static int matchmetachar(char c, const char* str);
|
||||||
|
static int matchrange(char c, const char* str);
|
||||||
|
static int matchdot(char c);
|
||||||
|
static int ismetachar(char c);
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* Public functions: */
|
||||||
|
int re_match(const char* pattern, const char* text, int* matchlength)
|
||||||
|
{
|
||||||
|
return re_matchp(re_compile(pattern), text, matchlength);
|
||||||
|
}
|
||||||
|
|
||||||
|
int re_matchp(re_t pattern, const char* text, int* matchlength)
|
||||||
|
{
|
||||||
|
*matchlength = 0;
|
||||||
|
if (pattern != 0)
|
||||||
|
{
|
||||||
|
if (pattern[0].type == BEGIN)
|
||||||
|
{
|
||||||
|
return ((matchpattern(&pattern[1], text, matchlength)) ? 0 : -1);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
int idx = -1;
|
||||||
|
|
||||||
|
do
|
||||||
|
{
|
||||||
|
idx += 1;
|
||||||
|
|
||||||
|
if (matchpattern(pattern, text, matchlength))
|
||||||
|
{
|
||||||
|
if (text[0] == '\0')
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return idx;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
while (*text++ != '\0');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
re_t re_compile(const char* pattern)
|
||||||
|
{
|
||||||
|
/* The sizes of the two static arrays below substantiates the static RAM usage of this module.
|
||||||
|
MAX_REGEXP_OBJECTS is the max number of symbols in the expression.
|
||||||
|
MAX_CHAR_CLASS_LEN determines the size of buffer for chars in all char-classes in the expression. */
|
||||||
|
static regex_t re_compiled[MAX_REGEXP_OBJECTS];
|
||||||
|
static unsigned char ccl_buf[MAX_CHAR_CLASS_LEN];
|
||||||
|
int ccl_bufidx = 1;
|
||||||
|
|
||||||
|
char c; /* current char in pattern */
|
||||||
|
int i = 0; /* index into pattern */
|
||||||
|
int j = 0; /* index into re_compiled */
|
||||||
|
|
||||||
|
while (pattern[i] != '\0' && (j+1 < MAX_REGEXP_OBJECTS))
|
||||||
|
{
|
||||||
|
c = pattern[i];
|
||||||
|
|
||||||
|
switch (c)
|
||||||
|
{
|
||||||
|
/* Meta-characters: */
|
||||||
|
case '^': { re_compiled[j].type = BEGIN; } break;
|
||||||
|
case '$': { re_compiled[j].type = END; } break;
|
||||||
|
case '.': { re_compiled[j].type = DOT; } break;
|
||||||
|
case '*': { re_compiled[j].type = STAR; } break;
|
||||||
|
case '+': { re_compiled[j].type = PLUS; } break;
|
||||||
|
case '?': { re_compiled[j].type = QUESTIONMARK; } break;
|
||||||
|
/* case '|': { re_compiled[j].type = BRANCH; } break; <-- not working properly */
|
||||||
|
|
||||||
|
/* Escaped character-classes (\s \w ...): */
|
||||||
|
case '\\':
|
||||||
|
{
|
||||||
|
if (pattern[i+1] != '\0')
|
||||||
|
{
|
||||||
|
/* Skip the escape-char '\\' */
|
||||||
|
i += 1;
|
||||||
|
/* ... and check the next */
|
||||||
|
switch (pattern[i])
|
||||||
|
{
|
||||||
|
/* Meta-character: */
|
||||||
|
case 'd': { re_compiled[j].type = DIGIT; } break;
|
||||||
|
case 'D': { re_compiled[j].type = NOT_DIGIT; } break;
|
||||||
|
case 'w': { re_compiled[j].type = ALPHA; } break;
|
||||||
|
case 'W': { re_compiled[j].type = NOT_ALPHA; } break;
|
||||||
|
case 's': { re_compiled[j].type = WHITESPACE; } break;
|
||||||
|
case 'S': { re_compiled[j].type = NOT_WHITESPACE; } break;
|
||||||
|
|
||||||
|
/* Escaped character, e.g. '.' or '$' */
|
||||||
|
default:
|
||||||
|
{
|
||||||
|
re_compiled[j].type = CHAR;
|
||||||
|
re_compiled[j].u.ch = pattern[i];
|
||||||
|
} break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/* '\\' as last char in pattern -> invalid regular expression. */
|
||||||
|
/*
|
||||||
|
else
|
||||||
|
{
|
||||||
|
re_compiled[j].type = CHAR;
|
||||||
|
re_compiled[j].ch = pattern[i];
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
} break;
|
||||||
|
|
||||||
|
/* Character class: */
|
||||||
|
case '[':
|
||||||
|
{
|
||||||
|
/* Remember where the char-buffer starts. */
|
||||||
|
int buf_begin = ccl_bufidx;
|
||||||
|
|
||||||
|
/* Look-ahead to determine if negated */
|
||||||
|
if (pattern[i+1] == '^')
|
||||||
|
{
|
||||||
|
re_compiled[j].type = INV_CHAR_CLASS;
|
||||||
|
i += 1; /* Increment i to avoid including '^' in the char-buffer */
|
||||||
|
if (pattern[i+1] == 0) /* incomplete pattern, missing non-zero char after '^' */
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
re_compiled[j].type = CHAR_CLASS;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Copy characters inside [..] to buffer */
|
||||||
|
while ( (pattern[++i] != ']')
|
||||||
|
&& (pattern[i] != '\0')) /* Missing ] */
|
||||||
|
{
|
||||||
|
if (pattern[i] == '\\')
|
||||||
|
{
|
||||||
|
if (ccl_bufidx >= MAX_CHAR_CLASS_LEN - 1)
|
||||||
|
{
|
||||||
|
//fputs("exceeded internal buffer!\n", stderr);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (pattern[i+1] == 0) /* incomplete pattern, missing non-zero char after '\\' */
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
ccl_buf[ccl_bufidx++] = pattern[i++];
|
||||||
|
}
|
||||||
|
else if (ccl_bufidx >= MAX_CHAR_CLASS_LEN)
|
||||||
|
{
|
||||||
|
//fputs("exceeded internal buffer!\n", stderr);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
ccl_buf[ccl_bufidx++] = pattern[i];
|
||||||
|
}
|
||||||
|
if (ccl_bufidx >= MAX_CHAR_CLASS_LEN)
|
||||||
|
{
|
||||||
|
/* Catches cases such as [00000000000000000000000000000000000000][ */
|
||||||
|
//fputs("exceeded internal buffer!\n", stderr);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
/* Null-terminate string end */
|
||||||
|
ccl_buf[ccl_bufidx++] = 0;
|
||||||
|
re_compiled[j].u.ccl = &ccl_buf[buf_begin];
|
||||||
|
} break;
|
||||||
|
|
||||||
|
/* Other characters: */
|
||||||
|
default:
|
||||||
|
{
|
||||||
|
re_compiled[j].type = CHAR;
|
||||||
|
re_compiled[j].u.ch = c;
|
||||||
|
} break;
|
||||||
|
}
|
||||||
|
/* no buffer-out-of-bounds access on invalid patterns - see https://github.com/kokke/tiny-regex-c/commit/1a279e04014b70b0695fba559a7c05d55e6ee90b */
|
||||||
|
if (pattern[i] == 0)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
i += 1;
|
||||||
|
j += 1;
|
||||||
|
}
|
||||||
|
/* 'UNUSED' is a sentinel used to indicate end-of-pattern */
|
||||||
|
re_compiled[j].type = UNUSED;
|
||||||
|
|
||||||
|
return (re_t) re_compiled;
|
||||||
|
}
|
||||||
|
|
||||||
|
void re_print(regex_t* pattern)
|
||||||
|
{
|
||||||
|
const char* types[] = { "UNUSED", "DOT", "BEGIN", "END", "QUESTIONMARK", "STAR", "PLUS", "CHAR", "CHAR_CLASS", "INV_CHAR_CLASS", "DIGIT", "NOT_DIGIT", "ALPHA", "NOT_ALPHA", "WHITESPACE", "NOT_WHITESPACE", "BRANCH" };
|
||||||
|
|
||||||
|
int i;
|
||||||
|
int j;
|
||||||
|
char c;
|
||||||
|
for (i = 0; i < MAX_REGEXP_OBJECTS; ++i)
|
||||||
|
{
|
||||||
|
if (pattern[i].type == UNUSED)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
printf("type: %s", types[pattern[i].type]);
|
||||||
|
if (pattern[i].type == CHAR_CLASS || pattern[i].type == INV_CHAR_CLASS)
|
||||||
|
{
|
||||||
|
printf(" [");
|
||||||
|
for (j = 0; j < MAX_CHAR_CLASS_LEN; ++j)
|
||||||
|
{
|
||||||
|
c = pattern[i].u.ccl[j];
|
||||||
|
if ((c == '\0') || (c == ']'))
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
printf("%c", c);
|
||||||
|
}
|
||||||
|
printf("]");
|
||||||
|
}
|
||||||
|
else if (pattern[i].type == CHAR)
|
||||||
|
{
|
||||||
|
printf(" '%c'", pattern[i].u.ch);
|
||||||
|
}
|
||||||
|
printf("\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* Private functions: */
|
||||||
|
static int matchdigit(char c)
|
||||||
|
{
|
||||||
|
return isdigit(c);
|
||||||
|
}
|
||||||
|
static int matchalpha(char c)
|
||||||
|
{
|
||||||
|
return isalpha(c);
|
||||||
|
}
|
||||||
|
static int matchwhitespace(char c)
|
||||||
|
{
|
||||||
|
return isspace(c);
|
||||||
|
}
|
||||||
|
static int matchalphanum(char c)
|
||||||
|
{
|
||||||
|
return ((c == '_') || matchalpha(c) || matchdigit(c));
|
||||||
|
}
|
||||||
|
static int matchrange(char c, const char* str)
|
||||||
|
{
|
||||||
|
return ( (c != '-')
|
||||||
|
&& (str[0] != '\0')
|
||||||
|
&& (str[0] != '-')
|
||||||
|
&& (str[1] == '-')
|
||||||
|
&& (str[2] != '\0')
|
||||||
|
&& ( (c >= str[0])
|
||||||
|
&& (c <= str[2])));
|
||||||
|
}
|
||||||
|
static int matchdot(char c)
|
||||||
|
{
|
||||||
|
#if defined(RE_DOT_MATCHES_NEWLINE) && (RE_DOT_MATCHES_NEWLINE == 1)
|
||||||
|
(void)c;
|
||||||
|
return 1;
|
||||||
|
#else
|
||||||
|
return c != '\n' && c != '\r';
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
static int ismetachar(char c)
|
||||||
|
{
|
||||||
|
return ((c == 's') || (c == 'S') || (c == 'w') || (c == 'W') || (c == 'd') || (c == 'D'));
|
||||||
|
}
|
||||||
|
|
||||||
|
static int matchmetachar(char c, const char* str)
|
||||||
|
{
|
||||||
|
switch (str[0])
|
||||||
|
{
|
||||||
|
case 'd': return matchdigit(c);
|
||||||
|
case 'D': return !matchdigit(c);
|
||||||
|
case 'w': return matchalphanum(c);
|
||||||
|
case 'W': return !matchalphanum(c);
|
||||||
|
case 's': return matchwhitespace(c);
|
||||||
|
case 'S': return !matchwhitespace(c);
|
||||||
|
default: return (c == str[0]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static int matchcharclass(char c, const char* str)
|
||||||
|
{
|
||||||
|
do
|
||||||
|
{
|
||||||
|
if (matchrange(c, str))
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
else if (str[0] == '\\')
|
||||||
|
{
|
||||||
|
/* Escape-char: increment str-ptr and match on next char */
|
||||||
|
str += 1;
|
||||||
|
if (matchmetachar(c, str))
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
else if ((c == str[0]) && !ismetachar(c))
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (c == str[0])
|
||||||
|
{
|
||||||
|
if (c == '-')
|
||||||
|
{
|
||||||
|
return ((str[-1] == '\0') || (str[1] == '\0'));
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
while (*str++ != '\0');
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int matchone(regex_t p, char c)
|
||||||
|
{
|
||||||
|
switch (p.type)
|
||||||
|
{
|
||||||
|
case DOT: return matchdot(c);
|
||||||
|
case CHAR_CLASS: return matchcharclass(c, (const char*)p.u.ccl);
|
||||||
|
case INV_CHAR_CLASS: return !matchcharclass(c, (const char*)p.u.ccl);
|
||||||
|
case DIGIT: return matchdigit(c);
|
||||||
|
case NOT_DIGIT: return !matchdigit(c);
|
||||||
|
case ALPHA: return matchalphanum(c);
|
||||||
|
case NOT_ALPHA: return !matchalphanum(c);
|
||||||
|
case WHITESPACE: return matchwhitespace(c);
|
||||||
|
case NOT_WHITESPACE: return !matchwhitespace(c);
|
||||||
|
default: return (p.u.ch == c);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static int matchstar(regex_t p, regex_t* pattern, const char* text, int* matchlength)
|
||||||
|
{
|
||||||
|
int prelen = *matchlength;
|
||||||
|
const char* prepoint = text;
|
||||||
|
while ((text[0] != '\0') && matchone(p, *text))
|
||||||
|
{
|
||||||
|
text++;
|
||||||
|
(*matchlength)++;
|
||||||
|
}
|
||||||
|
while (text >= prepoint)
|
||||||
|
{
|
||||||
|
if (matchpattern(pattern, text--, matchlength))
|
||||||
|
return 1;
|
||||||
|
(*matchlength)--;
|
||||||
|
}
|
||||||
|
|
||||||
|
*matchlength = prelen;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int matchplus(regex_t p, regex_t* pattern, const char* text, int* matchlength)
|
||||||
|
{
|
||||||
|
const char* prepoint = text;
|
||||||
|
while ((text[0] != '\0') && matchone(p, *text))
|
||||||
|
{
|
||||||
|
text++;
|
||||||
|
(*matchlength)++;
|
||||||
|
}
|
||||||
|
while (text > prepoint)
|
||||||
|
{
|
||||||
|
if (matchpattern(pattern, text--, matchlength))
|
||||||
|
return 1;
|
||||||
|
(*matchlength)--;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int matchquestion(regex_t p, regex_t* pattern, const char* text, int* matchlength)
|
||||||
|
{
|
||||||
|
if (p.type == UNUSED)
|
||||||
|
return 1;
|
||||||
|
if (matchpattern(pattern, text, matchlength))
|
||||||
|
return 1;
|
||||||
|
if (*text && matchone(p, *text++))
|
||||||
|
{
|
||||||
|
if (matchpattern(pattern, text, matchlength))
|
||||||
|
{
|
||||||
|
(*matchlength)++;
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#if 0
|
||||||
|
|
||||||
|
/* Recursive matching */
|
||||||
|
static int matchpattern(regex_t* pattern, const char* text, int *matchlength)
|
||||||
|
{
|
||||||
|
int pre = *matchlength;
|
||||||
|
if ((pattern[0].type == UNUSED) || (pattern[1].type == QUESTIONMARK))
|
||||||
|
{
|
||||||
|
return matchquestion(pattern[1], &pattern[2], text, matchlength);
|
||||||
|
}
|
||||||
|
else if (pattern[1].type == STAR)
|
||||||
|
{
|
||||||
|
return matchstar(pattern[0], &pattern[2], text, matchlength);
|
||||||
|
}
|
||||||
|
else if (pattern[1].type == PLUS)
|
||||||
|
{
|
||||||
|
return matchplus(pattern[0], &pattern[2], text, matchlength);
|
||||||
|
}
|
||||||
|
else if ((pattern[0].type == END) && pattern[1].type == UNUSED)
|
||||||
|
{
|
||||||
|
return text[0] == '\0';
|
||||||
|
}
|
||||||
|
else if ((text[0] != '\0') && matchone(pattern[0], text[0]))
|
||||||
|
{
|
||||||
|
(*matchlength)++;
|
||||||
|
return matchpattern(&pattern[1], text+1);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
*matchlength = pre;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#else
|
||||||
|
|
||||||
|
/* Iterative matching */
|
||||||
|
static int matchpattern(regex_t* pattern, const char* text, int* matchlength)
|
||||||
|
{
|
||||||
|
int pre = *matchlength;
|
||||||
|
do
|
||||||
|
{
|
||||||
|
if ((pattern[0].type == UNUSED) || (pattern[1].type == QUESTIONMARK))
|
||||||
|
{
|
||||||
|
return matchquestion(pattern[0], &pattern[2], text, matchlength);
|
||||||
|
}
|
||||||
|
else if (pattern[1].type == STAR)
|
||||||
|
{
|
||||||
|
return matchstar(pattern[0], &pattern[2], text, matchlength);
|
||||||
|
}
|
||||||
|
else if (pattern[1].type == PLUS)
|
||||||
|
{
|
||||||
|
return matchplus(pattern[0], &pattern[2], text, matchlength);
|
||||||
|
}
|
||||||
|
else if ((pattern[0].type == END) && pattern[1].type == UNUSED)
|
||||||
|
{
|
||||||
|
return (text[0] == '\0');
|
||||||
|
}
|
||||||
|
/* Branching is not working properly
|
||||||
|
else if (pattern[1].type == BRANCH)
|
||||||
|
{
|
||||||
|
return (matchpattern(pattern, text) || matchpattern(&pattern[2], text));
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
(*matchlength)++;
|
||||||
|
}
|
||||||
|
while ((text[0] != '\0') && matchone(*pattern++, *text++));
|
||||||
|
|
||||||
|
*matchlength = pre;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
65
src/util/regex.h
Normal file
65
src/util/regex.h
Normal file
|
@ -0,0 +1,65 @@
|
||||||
|
/*
|
||||||
|
*
|
||||||
|
* Mini regex-module inspired by Rob Pike's regex code described in:
|
||||||
|
*
|
||||||
|
* http://www.cs.princeton.edu/courses/archive/spr09/cos333/beautiful.html
|
||||||
|
*
|
||||||
|
*
|
||||||
|
*
|
||||||
|
* Supports:
|
||||||
|
* ---------
|
||||||
|
* '.' Dot, matches any character
|
||||||
|
* '^' Start anchor, matches beginning of string
|
||||||
|
* '$' End anchor, matches end of string
|
||||||
|
* '*' Asterisk, match zero or more (greedy)
|
||||||
|
* '+' Plus, match one or more (greedy)
|
||||||
|
* '?' Question, match zero or one (non-greedy)
|
||||||
|
* '[abc]' Character class, match if one of {'a', 'b', 'c'}
|
||||||
|
* '[^abc]' Inverted class, match if NOT one of {'a', 'b', 'c'} -- NOTE: feature is currently broken!
|
||||||
|
* '[a-zA-Z]' Character ranges, the character set of the ranges { a-z | A-Z }
|
||||||
|
* '\s' Whitespace, \t \f \r \n \v and spaces
|
||||||
|
* '\S' Non-whitespace
|
||||||
|
* '\w' Alphanumeric, [a-zA-Z0-9_]
|
||||||
|
* '\W' Non-alphanumeric
|
||||||
|
* '\d' Digits, [0-9]
|
||||||
|
* '\D' Non-digits
|
||||||
|
*
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _TINY_REGEX_C
|
||||||
|
#define _TINY_REGEX_C
|
||||||
|
|
||||||
|
|
||||||
|
#ifndef RE_DOT_MATCHES_NEWLINE
|
||||||
|
/* Define to 0 if you DON'T want '.' to match '\r' + '\n' */
|
||||||
|
#define RE_DOT_MATCHES_NEWLINE 1
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
extern "C"{
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* Typedef'd pointer to get abstract datatype. */
|
||||||
|
typedef struct regex_t* re_t;
|
||||||
|
|
||||||
|
|
||||||
|
/* Compile regex string pattern to a regex_t-array. */
|
||||||
|
re_t re_compile(const char* pattern);
|
||||||
|
|
||||||
|
|
||||||
|
/* Find matches of the compiled pattern inside text. */
|
||||||
|
int re_matchp(re_t pattern, const char* text, int* matchlength);
|
||||||
|
|
||||||
|
|
||||||
|
/* Find matches of the txt pattern inside text (will compile automatically first). */
|
||||||
|
int re_match(const char* pattern, const char* text, int* matchlength);
|
||||||
|
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#endif /* ifndef _TINY_REGEX_C */
|
|
@ -18,15 +18,19 @@ void error(const char* format, ...) {
|
||||||
|
|
||||||
FILE* get_file_s(const char* path, const char* type) {
|
FILE* get_file_s(const char* path, const char* type) {
|
||||||
struct stat s;
|
struct stat s;
|
||||||
if (stat(path, &s) < 0) {
|
if (lstat(path, &s) < 0) {
|
||||||
|
if (type[0] != 'r') goto read;
|
||||||
fprintf(stderr, "error: failed to read %s: %s\n", path, strerror(errno));
|
fprintf(stderr, "error: failed to read %s: %s\n", path, strerror(errno));
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
if (!S_ISREG(s.st_mode)) {
|
if (S_ISDIR(s.st_mode)) {
|
||||||
fprintf(stderr, "error: %s is not a file\n", path);
|
fprintf(stderr, "error: %s is a directory\n", path);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
FILE* file = fopen(path, type);
|
|
||||||
|
FILE* file;
|
||||||
|
read:
|
||||||
|
file = fopen(path, type);
|
||||||
if (file == NULL) {
|
if (file == NULL) {
|
||||||
fprintf(stderr, "error: failed to open file %s: %s\n", path, strerror(errno));
|
fprintf(stderr, "error: failed to open file %s: %s\n", path, strerror(errno));
|
||||||
}
|
}
|
||||||
|
@ -34,7 +38,10 @@ FILE* get_file_s(const char* path, const char* type) {
|
||||||
}
|
}
|
||||||
|
|
||||||
FILE* get_file(const char* path, const char* type) {
|
FILE* get_file(const char* path, const char* type) {
|
||||||
if (streql("-", path)) return stdin;
|
if (streql("-", path) && type[0] == 'r') {
|
||||||
|
clearerr(stdin);
|
||||||
|
return stdin;
|
||||||
|
}
|
||||||
FILE* file = get_file_s(path, type);
|
FILE* file = get_file_s(path, type);
|
||||||
if (file == NULL) exit(EXIT_FAILURE);
|
if (file == NULL) exit(EXIT_FAILURE);
|
||||||
return file;
|
return file;
|
|
@ -4,6 +4,33 @@
|
||||||
#include <stdbool.h>
|
#include <stdbool.h>
|
||||||
#include <time.h>
|
#include <time.h>
|
||||||
|
|
||||||
|
#define ANSCII "\x1b["
|
||||||
|
#define NEXT ";"
|
||||||
|
|
||||||
|
#define RESET "0"
|
||||||
|
#define BOLD "1"
|
||||||
|
|
||||||
|
#define NORMAL "3"
|
||||||
|
#define BACKGROUND "4"
|
||||||
|
#define HIGHLIGHT "9"
|
||||||
|
|
||||||
|
#define BLACK "0"
|
||||||
|
#define RED "1"
|
||||||
|
#define GREEN "2"
|
||||||
|
#define YELLOW "3"
|
||||||
|
#define BLUE "4"
|
||||||
|
#define MAGENTA "5"
|
||||||
|
#define TURQUOISE "6"
|
||||||
|
#define WHITE "7"
|
||||||
|
|
||||||
|
#define COLOR "m"
|
||||||
|
|
||||||
|
enum When {
|
||||||
|
YES,
|
||||||
|
NO,
|
||||||
|
AUTO
|
||||||
|
};
|
||||||
|
|
||||||
__attribute__ ((__format__(printf, 1, 2)))
|
__attribute__ ((__format__(printf, 1, 2)))
|
||||||
void error(const char* format, ...);
|
void error(const char* format, ...);
|
||||||
|
|
Loading…
Reference in a new issue