[lttng-tools.git] / src / common / filter / filter-visitor-xml.c

/*
 * filter-visitor-xml.c
 *
 * LTTng filter XML pretty printer visitor
 *
 * Copyright 2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <inttypes.h>
#include "filter-ast.h"
#include "filter-parser.h"

#include <common/compat/errno.h>
#include <common/macros.h>

#define fprintf_dbg(fd, fmt, args...)	fprintf(fd, "%s: " fmt, __func__, ## args)

static
int recursive_visit_print(struct filter_node *node, FILE *stream, int indent);

static
void print_tabs(FILE *fd, int depth)
{
	int i;

	for (i = 0; i < depth; i++)
		fprintf(fd, "\t");
}

static
int recursive_visit_print_expression(struct filter_node *node,
		FILE *stream, int indent)
{
	struct filter_node *iter_node;

	if (!node) {
		fprintf(stderr, "[error] %s: NULL child\n", __func__);
		return -EINVAL;
	}
	switch (node->u.expression.type) {
	case AST_EXP_UNKNOWN:
	default:
		fprintf(stderr, "[error] %s: unknown expression\n", __func__);
		return -EINVAL;
	case AST_EXP_STRING:
		print_tabs(stream, indent);
		fprintf(stream, "<string value=\"%s\"/>\n",
			node->u.expression.u.string);
		break;
	case AST_EXP_CONSTANT:
		print_tabs(stream, indent);
		fprintf(stream, "<constant value=\"%" PRIu64 "\"/>\n",
			node->u.expression.u.constant);
		break;
	case AST_EXP_FLOAT_CONSTANT:
		print_tabs(stream, indent);
		fprintf(stream, "<float_constant value=\"%lg\"/>\n",
			node->u.expression.u.float_constant);
		break;
	case AST_EXP_IDENTIFIER:		/* fall-through */
	case AST_EXP_GLOBAL_IDENTIFIER:
		print_tabs(stream, indent);
		fprintf(stream, "<%s value=\"%s\"/>\n",
			node->u.expression.type == AST_EXP_IDENTIFIER ?
				"identifier" : "global_identifier",
			node->u.expression.u.identifier);
		iter_node = node->u.expression.next;
		while (iter_node) {
			print_tabs(stream, indent);
			fprintf(stream, "<bracket>\n");
			if (recursive_visit_print_expression(iter_node,
					stream, indent + 1)) {
				return -EINVAL;
			}
			print_tabs(stream, indent);
			fprintf(stream, "</bracket>\n");
			iter_node = iter_node->u.expression.next;

		}
		break;
	case AST_EXP_NESTED:
		return recursive_visit_print(node->u.expression.u.child,
				stream, indent + 1);
	}
	return 0;
}


static
int recursive_visit_print(struct filter_node *node, FILE *stream, int indent)
{
	int ret;

	if (!node) {
		fprintf(stderr, "[error] %s: NULL child\n", __func__);
		return -EINVAL;
	}
	switch (node->type) {
	case NODE_UNKNOWN:
	default:
		fprintf(stderr, "[error] %s: unknown node type\n", __func__);
		return -EINVAL;
	case NODE_ROOT:
		print_tabs(stream, indent);
		fprintf(stream, "<root>\n");
		ret = recursive_visit_print(node->u.root.child, stream,
					indent + 1);
		print_tabs(stream, indent);
		fprintf(stream, "</root>\n");
		return ret;
	case NODE_EXPRESSION:
		print_tabs(stream, indent);
		fprintf(stream, "<expression>\n");
		ret = recursive_visit_print_expression(node, stream,
					indent + 1);
		print_tabs(stream, indent);
		fprintf(stream, "</expression>\n");
		return ret;
	case NODE_OP:
		print_tabs(stream, indent);
		fprintf(stream, "<op type=");
		switch (node->u.op.type) {
		case AST_OP_UNKNOWN:
		default:
			fprintf(stderr, "[error] %s: unknown op\n", __func__);
			return -EINVAL;
		case AST_OP_MUL:
			fprintf(stream, "\"*\"");
			break;
		case AST_OP_DIV:
			fprintf(stream, "\"/\"");
			break;
		case AST_OP_MOD:
			fprintf(stream, "\"%%\"");
			break;
		case AST_OP_PLUS:
			fprintf(stream, "\"+\"");
			break;
		case AST_OP_MINUS:
			fprintf(stream, "\"-\"");
			break;
		case AST_OP_BIT_RSHIFT:
			fprintf(stream, "\">>\"");
			break;
		case AST_OP_BIT_LSHIFT:
			fprintf(stream, "\"<<\"");
			break;
		case AST_OP_AND:
			fprintf(stream, "\"&&\"");
			break;
		case AST_OP_OR:
			fprintf(stream, "\"||\"");
			break;
		case AST_OP_BIT_AND:
			fprintf(stream, "\"&\"");
			break;
		case AST_OP_BIT_OR:
			fprintf(stream, "\"|\"");
			break;
		case AST_OP_BIT_XOR:
			fprintf(stream, "\"^\"");
			break;

		case AST_OP_EQ:
			fprintf(stream, "\"==\"");
			break;
		case AST_OP_NE:
			fprintf(stream, "\"!=\"");
			break;
		case AST_OP_GT:
			fprintf(stream, "\">\"");
			break;
		case AST_OP_LT:
			fprintf(stream, "\"<\"");
			break;
		case AST_OP_GE:
			fprintf(stream, "\">=\"");
			break;
		case AST_OP_LE:
			fprintf(stream, "\"<=\"");
			break;
		}
		fprintf(stream, ">\n");
		ret = recursive_visit_print(node->u.op.lchild,
					stream, indent + 1);
		if (ret)
			return ret;
		ret = recursive_visit_print(node->u.op.rchild,
					stream, indent + 1);
		if (ret)
			return ret;
		print_tabs(stream, indent);
		fprintf(stream, "</op>\n");
		return ret;
	case NODE_UNARY_OP:
		print_tabs(stream, indent);
		fprintf(stream, "<unary_op type=");
		switch (node->u.unary_op.type) {
		case AST_UNARY_UNKNOWN:
		default:
			fprintf(stderr, "[error] %s: unknown unary_op\n", __func__);
			return -EINVAL;
		case AST_UNARY_PLUS:
			fprintf(stream, "\"+\"");
			break;
		case AST_UNARY_MINUS:
			fprintf(stream, "\"-\"");
			break;
		case AST_UNARY_NOT:
			fprintf(stream, "\"!\"");
			break;
		case AST_UNARY_BIT_NOT:
			fprintf(stream, "\"~\"");
			break;
		}
		fprintf(stream, ">\n");
		ret = recursive_visit_print(node->u.unary_op.child,
					stream, indent + 1);
		print_tabs(stream, indent);
		fprintf(stream, "</unary_op>\n");
		return ret;
	}
	return 0;
}

int filter_visitor_print_xml(struct filter_parser_ctx *ctx, FILE *stream,
			int indent)
{
	return recursive_visit_print(&ctx->ast->root, stream, indent);
}
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>
953192ba	17	#include "filter-ast.h"
95b9bd90	18	#include "filter-parser.h"
953192ba	19
edf4b93e	20	#include <common/compat/errno.h>
a187da1a DG	21	#include <common/macros.h>
a187da1a DG	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;
661dfdd1 MD	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 */
586dc72f MD	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;
661dfdd1 MD	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;
953192ba MD	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, "\">>\"");
953192ba MD	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, "\"&\"");
953192ba MD	163	break;
bff988fa	164	case AST_OP_BIT_OR:
953192ba MD	165	fprintf(stream, "\"\|\"");
953192ba MD	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, "\"~\"");
d804b36b CB	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	}