Commit | Line | Data |
---|---|---|
953192ba MD |
1 | /* |
2 | * filter-visitor-xml.c | |
3 | * | |
4 | * LTTng filter XML pretty printer visitor | |
5 | * | |
ab5be9fa | 6 | * Copyright 2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com> |
953192ba | 7 | * |
ab5be9fa | 8 | * SPDX-License-Identifier: LGPL-2.1-only |
953192ba | 9 | * |
953192ba MD |
10 | */ |
11 | ||
12 | #include <stdio.h> | |
13 | #include <unistd.h> | |
14 | #include <string.h> | |
15 | #include <stdlib.h> | |
953192ba | 16 | #include <inttypes.h> |
c9e313bc | 17 | #include "filter-ast.hpp" |
348ddc5c | 18 | #include "filter-parser.hpp" |
953192ba | 19 | |
c9e313bc SM |
20 | #include <common/compat/errno.hpp> |
21 | #include <common/macros.hpp> | |
a187da1a | 22 | |
953192ba MD |
23 | #define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args) |
24 | ||
25 | static | |
26 | int recursive_visit_print(struct filter_node *node, FILE *stream, int indent); | |
27 | ||
28 | static | |
29 | void print_tabs(FILE *fd, int depth) | |
30 | { | |
31 | int i; | |
32 | ||
33 | for (i = 0; i < depth; i++) | |
34 | fprintf(fd, "\t"); | |
35 | } | |
36 | ||
37 | static | |
38 | int recursive_visit_print_expression(struct filter_node *node, | |
39 | FILE *stream, int indent) | |
40 | { | |
661dfdd1 MD |
41 | struct filter_node *iter_node; |
42 | ||
953192ba MD |
43 | if (!node) { |
44 | fprintf(stderr, "[error] %s: NULL child\n", __func__); | |
45 | return -EINVAL; | |
46 | } | |
47 | switch (node->u.expression.type) { | |
48 | case AST_EXP_UNKNOWN: | |
49 | default: | |
50 | fprintf(stderr, "[error] %s: unknown expression\n", __func__); | |
51 | return -EINVAL; | |
52 | case AST_EXP_STRING: | |
53 | print_tabs(stream, indent); | |
54 | fprintf(stream, "<string value=\"%s\"/>\n", | |
55 | node->u.expression.u.string); | |
56 | break; | |
57 | case AST_EXP_CONSTANT: | |
58 | print_tabs(stream, indent); | |
59 | fprintf(stream, "<constant value=\"%" PRIu64 "\"/>\n", | |
60 | node->u.expression.u.constant); | |
61 | break; | |
e90d8561 MD |
62 | case AST_EXP_FLOAT_CONSTANT: |
63 | print_tabs(stream, indent); | |
64 | fprintf(stream, "<float_constant value=\"%lg\"/>\n", | |
65 | node->u.expression.u.float_constant); | |
66 | break; | |
586dc72f MD |
67 | case AST_EXP_IDENTIFIER: /* fall-through */ |
68 | case AST_EXP_GLOBAL_IDENTIFIER: | |
953192ba | 69 | print_tabs(stream, indent); |
586dc72f MD |
70 | fprintf(stream, "<%s value=\"%s\"/>\n", |
71 | node->u.expression.type == AST_EXP_IDENTIFIER ? | |
72 | "identifier" : "global_identifier", | |
953192ba | 73 | node->u.expression.u.identifier); |
661dfdd1 MD |
74 | iter_node = node->u.expression.next; |
75 | while (iter_node) { | |
953192ba | 76 | print_tabs(stream, indent); |
661dfdd1 MD |
77 | fprintf(stream, "<bracket>\n"); |
78 | if (recursive_visit_print_expression(iter_node, | |
79 | stream, indent + 1)) { | |
953192ba MD |
80 | return -EINVAL; |
81 | } | |
953192ba | 82 | print_tabs(stream, indent); |
661dfdd1 MD |
83 | fprintf(stream, "</bracket>\n"); |
84 | iter_node = iter_node->u.expression.next; | |
85 | ||
953192ba MD |
86 | } |
87 | break; | |
88 | case AST_EXP_NESTED: | |
89 | return recursive_visit_print(node->u.expression.u.child, | |
90 | stream, indent + 1); | |
91 | } | |
92 | return 0; | |
93 | } | |
94 | ||
95 | ||
96 | static | |
97 | int recursive_visit_print(struct filter_node *node, FILE *stream, int indent) | |
98 | { | |
99 | int ret; | |
100 | ||
101 | if (!node) { | |
102 | fprintf(stderr, "[error] %s: NULL child\n", __func__); | |
103 | return -EINVAL; | |
104 | } | |
105 | switch (node->type) { | |
106 | case NODE_UNKNOWN: | |
107 | default: | |
108 | fprintf(stderr, "[error] %s: unknown node type\n", __func__); | |
109 | return -EINVAL; | |
110 | case NODE_ROOT: | |
111 | print_tabs(stream, indent); | |
112 | fprintf(stream, "<root>\n"); | |
113 | ret = recursive_visit_print(node->u.root.child, stream, | |
114 | indent + 1); | |
115 | print_tabs(stream, indent); | |
116 | fprintf(stream, "</root>\n"); | |
117 | return ret; | |
118 | case NODE_EXPRESSION: | |
119 | print_tabs(stream, indent); | |
120 | fprintf(stream, "<expression>\n"); | |
121 | ret = recursive_visit_print_expression(node, stream, | |
122 | indent + 1); | |
123 | print_tabs(stream, indent); | |
124 | fprintf(stream, "</expression>\n"); | |
125 | return ret; | |
126 | case NODE_OP: | |
127 | print_tabs(stream, indent); | |
128 | fprintf(stream, "<op type="); | |
129 | switch (node->u.op.type) { | |
130 | case AST_OP_UNKNOWN: | |
131 | default: | |
132 | fprintf(stderr, "[error] %s: unknown op\n", __func__); | |
133 | return -EINVAL; | |
134 | case AST_OP_MUL: | |
135 | fprintf(stream, "\"*\""); | |
136 | break; | |
137 | case AST_OP_DIV: | |
138 | fprintf(stream, "\"/\""); | |
139 | break; | |
140 | case AST_OP_MOD: | |
141 | fprintf(stream, "\"%%\""); | |
142 | break; | |
143 | case AST_OP_PLUS: | |
144 | fprintf(stream, "\"+\""); | |
145 | break; | |
146 | case AST_OP_MINUS: | |
147 | fprintf(stream, "\"-\""); | |
148 | break; | |
116d3c01 | 149 | case AST_OP_BIT_RSHIFT: |
953192ba MD |
150 | fprintf(stream, "\">>\""); |
151 | break; | |
116d3c01 | 152 | case AST_OP_BIT_LSHIFT: |
953192ba MD |
153 | fprintf(stream, "\"<<\""); |
154 | break; | |
155 | case AST_OP_AND: | |
156 | fprintf(stream, "\"&&\""); | |
157 | break; | |
158 | case AST_OP_OR: | |
159 | fprintf(stream, "\"||\""); | |
160 | break; | |
bff988fa | 161 | case AST_OP_BIT_AND: |
953192ba MD |
162 | fprintf(stream, "\"&\""); |
163 | break; | |
bff988fa | 164 | case AST_OP_BIT_OR: |
953192ba MD |
165 | fprintf(stream, "\"|\""); |
166 | break; | |
bff988fa | 167 | case AST_OP_BIT_XOR: |
953192ba MD |
168 | fprintf(stream, "\"^\""); |
169 | break; | |
170 | ||
171 | case AST_OP_EQ: | |
172 | fprintf(stream, "\"==\""); | |
173 | break; | |
174 | case AST_OP_NE: | |
175 | fprintf(stream, "\"!=\""); | |
176 | break; | |
177 | case AST_OP_GT: | |
178 | fprintf(stream, "\">\""); | |
179 | break; | |
180 | case AST_OP_LT: | |
181 | fprintf(stream, "\"<\""); | |
182 | break; | |
183 | case AST_OP_GE: | |
184 | fprintf(stream, "\">=\""); | |
185 | break; | |
186 | case AST_OP_LE: | |
187 | fprintf(stream, "\"<=\""); | |
188 | break; | |
189 | } | |
190 | fprintf(stream, ">\n"); | |
191 | ret = recursive_visit_print(node->u.op.lchild, | |
192 | stream, indent + 1); | |
193 | if (ret) | |
194 | return ret; | |
195 | ret = recursive_visit_print(node->u.op.rchild, | |
196 | stream, indent + 1); | |
197 | if (ret) | |
198 | return ret; | |
199 | print_tabs(stream, indent); | |
200 | fprintf(stream, "</op>\n"); | |
201 | return ret; | |
202 | case NODE_UNARY_OP: | |
203 | print_tabs(stream, indent); | |
204 | fprintf(stream, "<unary_op type="); | |
205 | switch (node->u.unary_op.type) { | |
206 | case AST_UNARY_UNKNOWN: | |
207 | default: | |
208 | fprintf(stderr, "[error] %s: unknown unary_op\n", __func__); | |
209 | return -EINVAL; | |
210 | case AST_UNARY_PLUS: | |
211 | fprintf(stream, "\"+\""); | |
212 | break; | |
213 | case AST_UNARY_MINUS: | |
214 | fprintf(stream, "\"-\""); | |
215 | break; | |
216 | case AST_UNARY_NOT: | |
217 | fprintf(stream, "\"!\""); | |
218 | break; | |
bff988fa | 219 | case AST_UNARY_BIT_NOT: |
d804b36b CB |
220 | fprintf(stream, "\"~\""); |
221 | break; | |
953192ba MD |
222 | } |
223 | fprintf(stream, ">\n"); | |
224 | ret = recursive_visit_print(node->u.unary_op.child, | |
225 | stream, indent + 1); | |
226 | print_tabs(stream, indent); | |
227 | fprintf(stream, "</unary_op>\n"); | |
228 | return ret; | |
229 | } | |
230 | return 0; | |
231 | } | |
232 | ||
233 | int filter_visitor_print_xml(struct filter_parser_ctx *ctx, FILE *stream, | |
234 | int indent) | |
235 | { | |
236 | return recursive_visit_print(&ctx->ast->root, stream, indent); | |
237 | } |