148 lines
5.1 KiB
C
148 lines
5.1 KiB
C
/*
|
|
* bpeg.c - Source code for the bpeg parser
|
|
*
|
|
* Grammar:
|
|
* # <comment> comment
|
|
* . any character (multiline: $.)
|
|
* ^ beginning of a line (^^: beginning of file)
|
|
* $ end of a line ($$: end of file)
|
|
* _ 0 or more spaces or tabs (__: include newlines and comments)
|
|
* `<c> character <c>
|
|
* `<a>-<z> character between <a> and <z>
|
|
* \<e> escape sequence (e.g. \n, \033)
|
|
* \<e1>-<e2> escape sequence range (e.g. \x00-\xF0)
|
|
* ! <pat> no <pat>
|
|
* ~ <pat> any character as long as it doesn't match <pat> (multiline: ~~<pat>)
|
|
* & <pat> upto and including <pat> (aka *~<pat> <pat>) (multiline: &&<pat>)
|
|
* <N=1> + <pat> [% <sep="">] <N> or more <pat>s (separated by <sep>)
|
|
* * <pat> [% <sep="">] sugar for "0+ <pat> [% <sep>]"
|
|
* <N=1> - <pat> [% <sep="">] <N> or fewer <pat>s (separated by <sep>)
|
|
* ? <pat> sugar for "1- <pat>"
|
|
* <N> - <M> <pat> <N> to <M> (inclusive) <pat>s
|
|
* < <pat> after <pat>, ...
|
|
* > <pat> before <pat>, ...
|
|
* ( <pat> ) <pat>
|
|
* @ <pat> capture <pat>
|
|
* @ [ <name> ] <pat> <pat> named <name>
|
|
* { <pat> => <str> } <pat> replaced with <str>
|
|
* "@1" or "@[1]" first capture
|
|
* "@foo" or "@[foo]" capture named "foo"
|
|
* <pat1> <pat2> <pat1> followed by <pat2>
|
|
* <pat> / <alt> <pat> otherwise <alt>
|
|
* ; <name> = <pat> <name> is defined to be <pat>
|
|
*/
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "compiler.h"
|
|
#include "grammar.h"
|
|
#include "utils.h"
|
|
#include "vm.h"
|
|
|
|
static const char *usage = (
|
|
"Usage:\n"
|
|
" bpeg [flags] <pattern> [<input files>...]\n\n"
|
|
"Flags:\n"
|
|
" -h --help\t print the usage and quit\n"
|
|
" -v --verbose\t print verbose debugging info\n"
|
|
" -s --slow\t run in slow mode for debugging\n"
|
|
" -r --replace <replacement> replace the input pattern with the given replacement\n"
|
|
" -g --grammar <grammar file> use the specified file as a grammar\n");
|
|
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int verbose = 0;
|
|
const char *pattern = NULL,
|
|
*replacement = NULL,
|
|
*grammarfile = NULL,
|
|
*infile = NULL;
|
|
|
|
grammar_t *g = new_grammar();
|
|
|
|
for (int i = 1; i < argc; i++) {
|
|
if (streq(argv[i], "--help") || streq(argv[i], "-h")) {
|
|
printf("%s\n", usage);
|
|
return 0;
|
|
} else if (streq(argv[i], "--verbose") || streq(argv[i], "-v")) {
|
|
verbose = 1;
|
|
} else if (streq(argv[i], "--replace") || streq(argv[i], "-r")) {
|
|
replacement = argv[++i];
|
|
} else if (streq(argv[i], "--grammar") || streq(argv[i], "-g")) {
|
|
grammarfile = argv[++i];
|
|
} else if (streq(argv[i], "--define") || streq(argv[i], "-d")) {
|
|
char *def = argv[++i];
|
|
char *eq = strchr(def, '=');
|
|
check(eq, usage);
|
|
*eq = '\0';
|
|
char *src = ++eq;
|
|
vm_op_t *pat = bpeg_pattern(src);
|
|
check(pat, "Failed to compile pattern");
|
|
add_def(g, src, def, pat);
|
|
} else if (pattern == NULL) {
|
|
pattern = argv[i];
|
|
} else if (infile == NULL) {
|
|
infile = argv[i];
|
|
}
|
|
}
|
|
|
|
check(pattern != NULL || grammarfile != NULL, usage);
|
|
|
|
if (grammarfile) {
|
|
// load grammar from a file (semicolon mode)
|
|
char *grammar;
|
|
if (streq(grammarfile, "-")) {
|
|
grammar = readfile(STDIN_FILENO);
|
|
} else {
|
|
int fd = open(grammarfile, O_RDONLY);
|
|
check(fd >= 0, "Couldn't open file: %s", argv[2]);
|
|
grammar = readfile(fd);
|
|
}
|
|
load_grammar(g, grammar);
|
|
} else {
|
|
// load grammar in start-with-string mode:
|
|
vm_op_t *pat = bpeg_stringpattern(pattern);
|
|
if (replacement)
|
|
pat = bpeg_replacement(pat, replacement);
|
|
|
|
add_def(g, pattern, "pattern", pat);
|
|
|
|
const char *grammar = "find = *(@pattern / \\n / .);";
|
|
load_grammar(g, grammar);
|
|
}
|
|
|
|
if (verbose) {
|
|
print_pattern(g->pattern);
|
|
}
|
|
|
|
char *input;
|
|
if (infile == NULL || streq(infile, "-")) {
|
|
input = readfile(STDIN_FILENO);
|
|
} else {
|
|
int fd = open(infile, O_RDONLY);
|
|
check(fd >= 0, "Couldn't open file: %s", argv[2]);
|
|
input = readfile(fd);
|
|
}
|
|
|
|
// Ensure string has a null byte to the left:
|
|
char *lpadded = calloc(sizeof(char), strlen(input)+2);
|
|
stpcpy(&lpadded[1], input);
|
|
input = &lpadded[1];
|
|
|
|
match_t *m = match(g, input, g->pattern);
|
|
if (m == NULL) {
|
|
printf("No match\n");
|
|
return 1;
|
|
} else {
|
|
print_match(m, "\033[0m", verbose);
|
|
printf("\033[0;2m%s\n", m->end);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//vim: ts=4
|