git @ Cat's Eye Technologies Tamsin / 0c751da
Move runtime for compiled version into libtamsin. Cat's Eye Technologies 10 years ago
10 changed file(s) with 176 addition(s) and 138 deletion(s). Raw diff Collapse all Expand all
+2
-0
.gitignore less more
00 *.pyc
1 *.o
2 *.a
+2
-0
.hgignore less more
00 syntax: glob
11
22 *.pyc
3 *.o
4 *.a
+4
-6
README.markdown less more
179179 TODO
180180 ----
181181
182 * the compiler generates *horrible* string-handling code. fix!
182 * libtamsin contains *horrible* string-handling code. fix!
183183 * meta-circular implementation of scanner -- what we have is pretty close
184184 * meta-circular implementation of parser
185185 * meta-circular implementation of interpreter!
186 * system library
186 * system library in its own Python module
187187 * `bin/tamsin runast astfile.txt` -- for testing the meta-circular parser
188 * `bin/tamsin runscan scanfile.txt` -- for testing the meta-circular scanner
189 * `bin/tamsin scan file.tamsin` -- to generate a scanfile
188190
189191 ### compiler ###
190192
191193 * handle term concatenation
192 * literal string escape sequences
193194 * render NUL as EOF. actually, we want 8-bit clean strings eventually
194 * implement any
195 * implement fail
196195 * implement !
197196 * implement alnum
198 * write `-ltamsin` library and link to it
199197
200198 ### document ###
201199
+10
-0
c_src/build.sh less more
0 #!/bin/sh
1
2 FILES="scanner term tamsin"
3
4 for FILE in $FILES; do
5 gcc -c $FILE.c -o $FILE.o
6 done
7
8 ar -r libtamsin.a scanner.o term.o tamsin.o
9
+19
-0
c_src/scanner.c less more
0 #include "tamsin.h"
1
2 char scan(struct scanner *s) {
3 char c = s->buffer[s->position];
4 if (c == '\0') {
5 return '\0';
6 } else {
7 s->position++;
8 return c;
9 }
10 };
11
12 void unscan(struct scanner *s) {
13 s->position = s->reset_position;
14 }
15
16 void commit(struct scanner *s) {
17 s->reset_position = s->position;
18 }
+48
-0
c_src/tamsin.c less more
0 #include "tamsin.h"
1
2 void tamsin_eof(struct scanner *s) {
3 char c = scan(s);
4 unscan(s);
5 if (c == '\0') {
6 result = new_term("EOF");
7 ok = 1;
8 } else {
9 char t[100];
10 sprintf(t, "expected EOF found '%c'", c);
11 result = new_term(t);
12 ok = 0;
13 }
14 }
15
16 void tamsin_any(struct scanner *s) {
17 char c = scan(s);
18 if (c == '\0') {
19 unscan(s);
20 result = new_term("expected any token, found EOF");
21 ok = 0;
22 } else {
23 char t[2];
24 commit(s);
25 sprintf(t, "%c", c);
26 result = new_term(t);
27 ok = 1;
28 }
29 }
30
31 void tamsin_expect(struct scanner *s, char *token) {
32 char c = scan(s);
33 if (c == token[0]) {
34 commit(s);
35 char s[10];
36 strcpy(s, "a");
37 s[0] = c;
38 result = new_term(s);
39 ok = 1;
40 } else {
41 unscan(s);
42 char s[100];
43 sprintf(s, "expected '%c' found '%c'", token[0], c);
44 result = new_term(s);
45 ok = 0;
46 }
47 };
+43
-0
c_src/tamsin.h less more
0 #include <stdio.h>
1 #include <stdlib.h>
2 #include <string.h>
3
4 /* terms */
5
6 struct term {
7 const char *atom;
8 struct term_list *subterms;
9 };
10
11 struct term_list {
12 struct term *term;
13 struct term_list *next;
14 };
15
16 struct term *new_term(const char *);
17 void add_subterm(struct term *, struct term *);
18 void term_format_r(struct term *t);
19 char *term_format(struct term *t);
20
21 /* scanner */
22
23 struct scanner {
24 char *buffer;
25 int position;
26 int reset_position;
27 };
28
29 char scan(struct scanner *);
30 void unscan(struct scanner *);
31 void commit(struct scanner *);
32
33 /* tamsin */
34
35 void tamsin_eof(struct scanner *);
36 void tamsin_any(struct scanner *);
37 void tamsin_expect(struct scanner *, char *);
38
39 /* global state: result of last action */
40
41 extern int ok;
42 extern struct term *result;
+42
-0
c_src/term.c less more
0 #include "tamsin.h"
1
2 struct term *new_term(const char *atom) {
3 struct term *t;
4 t = malloc(sizeof(struct term));
5 t->atom = strdup(atom);
6 t->subterms = NULL;
7 }
8
9 void add_subterm(struct term *term, struct term *subterm) {
10 struct term_list *tl;
11 tl = malloc(sizeof(struct term_list));
12 tl->term = subterm;
13 tl->next = term->subterms;
14 term->subterms = tl;
15 }
16
17 char fmtbuf[1000]; /* yeesh */
18
19 void term_format_r(struct term *t) {
20 struct term_list *tl;
21
22 strcat(fmtbuf, t->atom);
23 if (t->subterms != NULL) {
24 strcat(fmtbuf, "(");
25
26 for (tl = t->subterms; tl != NULL; tl = tl->next) {
27 term_format_r(tl->term);
28 if (tl->next != NULL) {
29 strcat(fmtbuf, ", ");
30 }
31 }
32
33 strcat(fmtbuf, ")");
34 }
35 }
36
37 char *term_format(struct term *t) {
38 strcpy(fmtbuf, "");
39 term_format_r(t);
40 return fmtbuf;
41 }
+5
-3
loadngo.sh less more
00 #!/bin/sh
11
2 INPUT=`cat`
32 bin/tamsin compile $1 > foo.c && \
4 gcc foo.c -o foo && \
5 ./foo "$INPUT"
3 gcc -Ic_src -Lc_src foo.c -o foo -ltamsin && \
4 ./foo `cat`
5 R=$?
6 rm -f foo.c foo
7 exit $R
+1
-129
src/tamsin/compiler.py less more
99 /*
1010 * Generated code! Edit at your own risk!
1111 */
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
12 #include <tamsin.h>
1513
1614 /* global state: result of last action */
1715
1816 int ok;
1917 struct term *result;
20
21 /* terms */
22
23 struct term {
24 const char *atom;
25 struct term_list *subterms;
26 };
27
28 struct term_list {
29 struct term *term;
30 struct term_list *next;
31 };
32
33 struct term *new_term(const char *atom) {
34 struct term *t;
35 t = malloc(sizeof(struct term));
36 t->atom = strdup(atom);
37 t->subterms = NULL;
38 }
39
40 void add_subterm(struct term *term, struct term *subterm) {
41 struct term_list *tl;
42 tl = malloc(sizeof(struct term_list));
43 tl->term = subterm;
44 tl->next = term->subterms;
45 term->subterms = tl;
46 }
47
48 char fmtbuf[1000]; /* yeesh */
49
50 void term_format_r(struct term *t) {
51 struct term_list *tl;
52
53 strcat(fmtbuf, t->atom);
54 if (t->subterms != NULL) {
55 strcat(fmtbuf, "(");
56
57 for (tl = t->subterms; tl != NULL; tl = tl->next) {
58 term_format_r(tl->term);
59 if (tl->next != NULL) {
60 strcat(fmtbuf, ", ");
61 }
62 }
63
64 strcat(fmtbuf, ")");
65 }
66 }
67
68 char *term_format(struct term *t) {
69 strcpy(fmtbuf, "");
70 term_format_r(t);
71 return fmtbuf;
72 }
73
74 /* scanner */
75
76 struct scanner {
77 char *buffer;
78 int position;
79 int reset_position;
80 };
81
82 char scan(struct scanner *s) {
83 char c = s->buffer[s->position];
84 if (c == '\0') {
85 return '\0';
86 } else {
87 s->position++;
88 return c;
89 }
90 };
91
92 void unscan(struct scanner *s) {
93 s->position = s->reset_position;
94 }
95
96 void commit(struct scanner *s) {
97 s->reset_position = s->position;
98 }
99
100 void tamsin_eof(struct scanner *s) {
101 char c = scan(s);
102 unscan(s);
103 if (c == '\0') {
104 result = new_term("EOF");
105 ok = 1;
106 } else {
107 char t[100];
108 sprintf(t, "expected EOF found '%c'", c);
109 result = new_term(t);
110 ok = 0;
111 }
112 }
113
114 void tamsin_any(struct scanner *s) {
115 char c = scan(s);
116 if (c == '\0') {
117 unscan(s);
118 result = new_term("expected any token, found EOF");
119 ok = 0;
120 } else {
121 char t[2];
122 commit(s);
123 sprintf(t, "%c", c);
124 result = new_term(t);
125 ok = 1;
126 }
127 }
128
129 void tamsin_expect(struct scanner *s, char *token) {
130 char c = scan(s);
131 if (c == token[0]) {
132 commit(s);
133 char s[10];
134 strcpy(s, "a");
135 s[0] = c;
136 result = new_term(s);
137 ok = 1;
138 } else {
139 unscan(s);
140 char s[100];
141 sprintf(s, "expected '%c' found '%c'", token[0], c);
142 result = new_term(s);
143 ok = 0;
144 }
145 };
14618
14719 struct scanner * scanner;
14820 '''