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