]> ocean-lang.org Git - ocean/blob - csrc/indent_test.mdc
parsergen: add token location to tracing
[ocean] / csrc / indent_test.mdc
1 This parser is primarily for testing indent and linebreak handling.
2 It reads a very simple code fragment with if/else statements and
3 simple assignments with expressions, and then prints out the same
4 with complete bracketing and indenting.
5
6 # File: indent_test.mk
7         myCFLAGS := -Wall -g -fplan9-extensions
8         CFLAGS := $(filter-out $(myCFLAGS),$(CFLAGS)) $(myCFLAGS)
9         myLDLIBS:= libparser.o libscanner.o libmdcode.o -licuuc
10         LDLIBS := $(filter-out $(myLDLIBS),$(LDLIBS)) $(myLDLIBS)
11
12         all :: itest
13         itest.c itest.h : indent_test.mdc parsergen libparser.o libscanner.o libmdcode.o
14                 ./parsergen -o itest --LALR --tag indent indent_test.mdc
15         indent_test.mk: indent_test.mdc md2c
16                 ./md2c indent_test.mdc
17         itest: itest.c
18
19         doitest: itest itest.code
20                 ./itest itest.code
21         checkitest: itest itest.code
22                 @grep -v '^#' itest.out > .tmp.out
23                 @./itest itest.code | diff -u - .tmp.out || echo itest FAILED
24                 @sed -e 'i\
25                 ' itest.code > itest2.code
26                 @./itest itest2.code| diff -u - .tmp.out || echo itest2 FAILED
27         demos :: doitest
28         tests :: checkitest
29
30 # indent: header
31
32  ./parsergen -o itest --LALR indent_test.cgm
33  cc -o itest itest.c lib*.o -licuuc -lgmp
34  ./itest itest.code
35
36         struct expression {
37                 struct text op;
38                 struct expression *left, *right;
39         };
40         struct statement {
41                 struct statement *next;
42                 struct expression *expr;
43                 struct statement *thenpart;
44                 struct statement *elsepart;
45         };
46
47 # indent: code
48         #include <unistd.h>
49         #include <stdlib.h>
50         #include <fcntl.h>
51         #include <sys/mman.h>
52         #include <stdio.h>
53         #include "mdcode.h"
54         #include "scanner.h"
55         #include "parser.h"
56         #include "itest.h"
57
58         static void free_expression(struct expression *e)
59         {
60                 if (!e)
61                         return;
62                 free_expression(e->left);
63                 free_expression(e->right);
64                 free(e);
65         }
66
67         static void free_statement(struct statement *s)
68         {
69                 if (!s)
70                         return;
71                 free_statement(s->next);
72                 free_expression(s->expr);
73                 free_statement(s->thenpart);
74                 free_statement(s->elsepart);
75                 free(s);
76         }
77
78         static void print_expression(struct expression *e)
79         {
80                 if (e->left && e->right) printf("(");
81                 if (e->left)
82                         print_expression(e->left);
83                 if (e->op.len)
84                         printf("%.*s", e->op.len, e->op.txt);
85                 if (e->right)
86                         print_expression(e->right);
87                 if (e->left && e->right) printf(")");
88         }
89
90         static void print_statement(struct statement *s, int depth)
91         {
92                 if (!s)
93                         return;
94                 if (!s->thenpart) {
95                         printf("%*.s", depth, "");
96                         print_expression(s->expr);
97                         printf(";\n");
98                 } else {
99                         printf("%*.sif ", depth, "");
100                         print_expression(s->expr);
101                         printf(":\n");
102                         print_statement(s->thenpart, depth+4);
103                         if (s->elsepart) {
104                                 printf("%*.selse:\n", depth, "");
105                                 print_statement(s->elsepart, depth+4);
106                         }
107                 }
108                 print_statement(s->next, depth);
109         }
110
111         int main(int argc, char *argv[])
112         {
113                 int fd = open(argv[1], O_RDONLY);
114                 int len = lseek(fd, 0, 2);
115                 char *file = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, 0);
116                 struct section *s = code_extract(file, file+len, NULL);
117                 struct token_config config = {
118                         .ignored = (1 << TK_line_comment)
119                                  | (1 << TK_block_comment),
120                         .number_chars = ".,_+-",
121                         .word_start = "",
122                         .word_cont = "",
123                 };
124                 parse_itest(s->code, &config, argc > 2 ? stderr : NULL);
125                 while (s) {
126                         struct section *t = s->next;
127                         code_free(s->code);
128                         free(s);
129                         s = t;
130                 }
131                 exit(0);
132         }
133
134 # indent: grammar
135
136 ~~~~~~
137
138 Program -> Statementlist ${ print_statement($1, 0); }$
139
140 $*statement
141         Newlines -> NEWLINE
142                 | Newlines NEWLINE
143         Statementlist ->  Statements ${ $0 = $<1; }$
144                 | Newlines Statements ${ $0 = $<2; }$
145
146         Statements -> Statements Statement ${
147                                 {
148                                         struct statement **s;
149                                         $0 = $<1;
150                                         s = &$0;
151                                         while (*s)
152                                                 s = &(*s)->next;
153                                         *s = $<2;
154                                 }
155                                 }$
156                         | Statement ${ $0 = $<1; }$
157                         | ERROR ${ printf("statement ERROR\n"); $0 = NULL; }$
158
159         Open -> {
160                 | Newlines {
161         Close -> }
162                 | Newlines }
163         Block -> Open Statementlist Close ${ $0 = $<2; }$
164                 | Open SimpleStatements } ${ $0 = $<2; }$
165                 | : SimpleStatements ${ $0 = $<2; }$
166                 | : StatementBlock ${ $0 = $<2; }$
167         StatementBlock -> Statementlist $$OUT ${ $0 = $<1; }$
168
169         SimpleStatements -> SimpleStatements ; SimpleStatement ${
170                         {
171                                 struct statement **s;
172                                 $0 = $<1;
173                                 s = &$0;
174                                 while (*s)
175                                         s = &(*s)->next;
176                                 *s = $<3;
177                         }
178                         }$
179                 | SimpleStatement ${ $0 = $<1; }$
180                 | SimpleStatements ; ${ $0 = $<1; }$
181
182         SimpleStatement -> Factor = Expression ${
183                         $0 = calloc(1, sizeof(struct statement));
184                         $0->expr = calloc(1, sizeof(struct expression));
185                         $0->expr->left = $<1;
186                         $0->expr->op = $2.txt;
187                         $0->expr->right = $<3;
188                         }$
189         SSline -> SimpleStatements NEWLINE ${ $0 = $<1; }$
190         Statement -> SSline ${ $0 = $<1; }$
191                 | IfStatement $$NEWLINE ${ $0 = $<1; }$
192                 | Statement NEWLINE ${ $0 = $<1; }$
193
194         $RIGHT else
195
196         IfHead -> if Expression Block ${
197                                 $0 = calloc(1, sizeof(struct statement));
198                                 $0->expr = $<2;
199                                 $0->thenpart = $<3;
200                                 }$
201                 | IfHead NEWLINE ${ $0 = $<1; }$
202
203         IfStatement -> IfHead $$else ${ $0 = $<1; }$
204                 | IfHead else Block ${
205                         $0 = $<1;
206                         $0->elsepart = $<3;
207                         }$
208                 | IfHead else IfStatement ${
209                         $0 = $<1;
210                         $0->elsepart = $<3;
211                         }$
212
213 $*expression
214         Expression -> Expression + Term ${
215                                 $0 = calloc(1, sizeof(struct expression));
216                                 $0->op = $2.txt;
217                                 $0->left = $<1;
218                                 $0->right = $<3;
219                         }$
220                     | Expression - Term ${
221                                 $0 = calloc(1, sizeof(struct expression));
222                                 $0->op = $2.txt;
223                                 $0->left = $<1;
224                                 $0->right = $<3;
225                         }$
226                     | Term ${ $0 = $<1; }$
227         Term -> Term * Factor ${
228                                 $0 = calloc(1, sizeof(struct expression));
229                                 $0->op = $2.txt;
230                                 $0->left = $<1;
231                                 $0->right = $<3;
232                         }$
233               | Term / Factor ${
234                                 $0 = calloc(1, sizeof(struct expression));
235                                 $0->op = $2.txt;
236                                 $0->left = $<1;
237                                 $0->right = $<3;
238                         }$
239               | Factor ${ $0 = $<1; }$
240         Factor -> IDENTIFIER ${
241                                 $0 = calloc(1, sizeof(struct expression));
242                                 $0->op = $1.txt;
243                         }$
244 ~~~~~~
245
246 # File: itest.code
247
248         # test code
249         ~~~~~~
250         hello = yes; mister = no;
251         there = x;
252         all = y;
253         if cond + cond2 :
254                 hello = x;
255                 hello2 = x;
256
257                 sum = val +
258                  val;
259
260                 if condX:
261                  foo = x *
262                     x +
263                     y
264                     / two;
265          else if cond2:
266                 there1 =x
267                 there1a=x
268         there2=x
269         there3=x;
270         all = y;
271         if true {yes=x;} else : no=x
272         if true: yes = no; no = yes;
273         if false: yes=ok; else: no=ok
274
275         if false {
276                 print = OK
277         } else {
278                 print = not_OK
279         }
280
281         if a:
282                 if b:
283                         c= d
284         x = y
285
286 # File: itest.out
287         (hello=yes);
288         (mister=no);
289         (there=x);
290         (all=y);
291         if (cond+cond2):
292             (hello=x);
293             (hello2=x);
294             (sum=(val+val));
295             if condX:
296                 (foo=((x*x)+(y/two)));
297         else:
298             if cond2:
299                 (there1=x);
300                 (there1a=x);
301         (there2=x);
302         (there3=x);
303         (all=y);
304         if true:
305             (yes=x);
306         else:
307             (no=x);
308         if true:
309             (yes=no);
310             (no=yes);
311         if false:
312             (yes=ok);
313         else:
314             (no=ok);
315         if false:
316             (print=OK);
317         else:
318             (print=not_OK);
319         if a:
320             if b:
321                 (c=d);
322         (x=y);