modal/src/modal.c

275 lines
5.8 KiB
C

#include <stdio.h>
typedef struct {
unsigned int id, refs, ptr;
char *a, *b, key[0x10];
} Rule;
static int flip, quiet, cycles = 0x10000;
static Rule rules[0x1000], *rules_ = rules, lambda;
static char dict[0x8000], *dict_ = dict;
static char bank_a[0x4000], *src_ = bank_a;
static char bank_b[0x4000], *dst_ = bank_b;
#define spacer(c) (c <= ' ' || c == '(' || c == ')')
static char *
walk(char *s)
{
char c;
int depth = 0;
if(*s == '(') {
while((c = *s++)) {
if(c == '(') depth++;
if(c == ')') --depth;
if(!depth) return s;
}
}
while((c = *s) && !spacer(c)) s++;
return s;
}
static int
write_reg(char r, char *reg)
{
char c, *cap = walk(reg);
switch(r) {
case ':': /* op: output */
if(*reg == '(') reg++, --cap;
while(reg < cap) {
c = *reg++;
if(c == '\\') {
switch(*reg++) {
case 't': putc(0x09, stdout); break;
case 'n': putc(0x0a, stdout); break;
case 's': putc(0x20, stdout); break;
}
} else
putc(c, stdout);
}
return 0;
case '~': /* op: input */
while(fread(&c, 1, 1, stdin) && c >= ' ')
*dst_++ = c;
return 1;
case '^': /* op: join */
if(*reg == '(') reg++, --cap;
while(reg < cap && (c = *reg++))
if(!spacer(c)) *dst_++ = c;
return 1;
case '.': /* op: unwrap */
if(*reg == '(') reg++, --cap;
while(reg < cap) *dst_++ = *reg++;
return 1;
case '*': { /* op: explode */
int i, depth = 0;
if(*reg == '(' && reg[1] != ')') { /* tuple */
reg++;
while(reg < cap) {
while((c = *reg) && !spacer(c))
*dst_++ = c, reg++;
*dst_++ = ' ';
*dst_++ = '(', reg++, depth++;
}
} else /* token */
while((c = *reg++) && !spacer(c))
*dst_++ = c, *dst_++ = ' ', *dst_++ = '(', depth++;
for(i = 0; i < depth; i++) *dst_++ = ')';
return 1;
}
default:
while(reg < cap) *dst_++ = *reg++;
return 1;
}
}
static int
write_rule(Rule *r, char *s, int create)
{
while((*dst_++ = *s++))
;
*dst_++ = 0;
if((flip = !flip))
src_ = bank_b, dst_ = bank_a;
else
src_ = bank_a, dst_ = bank_b;
if(!quiet) {
if(create)
fprintf(stderr, "<> (%s) (%s)\n", r->a, r->b);
else
fprintf(stderr, "%02d %s\n", r->id, src_), ++r->refs;
}
return 1;
}
static int
apply_rule(Rule *r, char *s)
{
char c, *a = r->a, *regs[0x08] = {NULL}, *reg;
/* phase: match rule */
while((c = *a)) {
if(c == '?') {
char *pcap = walk(s);
unsigned int id = *(++a) - '0';
if((reg = regs[id])) { /* reg cmp */
char *rcap = walk(reg), *pp = s;
while(reg < rcap || pp < pcap)
if(*reg++ != *pp++) return 0;
} else /* reg set */
regs[id] = s;
a++, s = pcap;
if(!spacer(*a))
while((c = *a) && !spacer(c)) a++;
continue;
}
if(c != *s) return 0;
a++, s++;
}
/* phase: write rule */
if(!(c = *s) || spacer(c)) {
char *b = r->b, *origin = dst_;
while((c = *b++)) {
if(c == '?') {
unsigned int id = *b - '0';
if(id < 9 && (reg = regs[id])) {
b++;
if(!write_reg(r->key[id], reg) && dst_ != origin) dst_--;
} else
*dst_++ = c;
} else
*dst_++ = c;
}
if(dst_ == origin) {
while(*s == ' ') s++;
if(*s == ')' && *(dst_ - 1) == ' ') dst_--;
}
return write_rule(r, s, 0);
}
return 0;
}
static char *
parse_frag(char *s)
{
char c, *cap;
while((c = *s) && c == ' ') s++;
if(c != ')' && !(c == '<' && s[1] == '>')) {
cap = walk(s);
if(c == '(') {
s++;
while(s < cap - 1) *dict_++ = *s++;
s++;
} else
while(s < cap) *dict_++ = *s++;
}
*dict_++ = 0;
return s;
}
static int
find_register(Rule *r, char reg)
{
int i;
for(i = 0; i < (int)r->ptr; i++)
if(r->key[i] == reg)
return i;
return -1;
}
static void
compile_rule(Rule *r)
{
int i;
char c, *s;
r->ptr = 0;
s = r->a;
while((c = *s++)) { /* left */
if(c == '?') {
int reg = find_register(r, *s);
if(reg < 0 && *s != '(')
r->key[r->ptr] = *s, reg = r->ptr++;
*s = '0' + reg;
}
}
s = r->b;
while((c = *s++)) { /* right */
if(c == '?') {
int reg = find_register(r, *s);
if(reg >= 0)
*s = '0' + reg;
}
}
}
static int
rewrite(void)
{
char c, last = 0, *cap, *s = src_;
while(*s == ' ') s++;
while((c = *s)) {
if(spacer(last)) {
Rule *r = NULL;
if(c == '<' && s[1] == '>') { /* rule */
r = rules_++, r->id = rules_ - rules - 1;
r->a = dict_, s = parse_frag(s + 2);
r->b = dict_, s = parse_frag(s);
compile_rule(r);
while(*s == ' ') s++;
return write_rule(r, s, 1);
}
if(c == '?' && s[1] == '(') { /* lambda */
cap = walk(s + 1), lambda.id = -1;
lambda.a = dict_, s = parse_frag(s + 2);
lambda.b = dict_, parse_frag(s), s = cap;
compile_rule(&lambda);
while(*s == ' ') s++;
return apply_rule(&lambda, s);
}
for(r = rules; r < rules_; r++)
if(apply_rule(r, s)) return 1;
}
*dst_++ = last = c;
s++;
}
*dst_++ = 0;
return 0;
}
int
main(int argc, char **argv)
{
FILE *f;
int i, pl = 0, pr = 0;
char c, *w = bank_a;
if(argc < 2)
return !printf("usage: modal [-vqn] source.modal\n");
for(i = 1; i < argc && *argv[i] == '-'; i++) {
switch(argv[i][1]) {
case 'v': /* version */ return !printf("Modal Interpreter, 24 Apr 2024.\n");
case 'q': /* quiet */ quiet = 1; break;
case 'n': /* infinite */ cycles = 0xffffffff; break;
}
}
if(!(f = fopen(argv[i], "r")))
return !fprintf(stdout, "Modal file invalid: %s.\n", argv[i]);
while(fread(&c, 1, 1, f)) {
c = c <= 0x20 ? 0x20 : c;
if(w > bank_a) {
if(c == ' ' && *(w - 1) == '(') continue;
if(c == ')' && *(w - 1) == ' ') w--;
if(c == ' ' && *(w - 1) == ' ') w--;
}
if(c == '(') pl++;
if(c == ')') pr++;
*w++ = c;
}
while(*(--w) <= ' ') *w = 0;
fclose(f);
if(pr != pl)
return !fprintf(stdout, "Modal program imbalanced.\n");
while(rewrite())
if(!cycles--) return !fprintf(stdout, "Modal rewrites exceeded.\n");
while(rules_-- > rules && !quiet)
if(!rules_->refs) printf("-- Unused rule: %d <> (%s) (%s)\n", rules_->refs, rules_->a, rules_->b);
return 0;
}