From 965f073db6e8087ebae69f9a34e8c0562838dc32 Mon Sep 17 00:00:00 2001 From: Ana Krelling Date: Thu, 8 Aug 2024 09:34:59 -0400 Subject: [PATCH 1/3] docs: add page for console-based AST repr in ASTx --- .../header.png | Bin 0 -> 24743 bytes .../index.ipynb | 644 ++++++++++++++++++ .../index.md | 522 ++++++++++++++ .../index_files/index_10_0.png | Bin 0 -> 77558 bytes .../index_files/index_12_0.png | Bin 0 -> 41729 bytes .../index_files/index_13_0.png | Bin 0 -> 1782 bytes .../index_files/index_15_0.png | Bin 0 -> 3636 bytes .../index_files/index_16_0.png | Bin 0 -> 7774 bytes .../index_files/index_17_0.png | Bin 0 -> 4423 bytes 9 files changed, 1166 insertions(+) create mode 100644 pages/blog/console-based-representation-in-astx/header.png create mode 100644 pages/blog/console-based-representation-in-astx/index.ipynb create mode 100644 pages/blog/console-based-representation-in-astx/index.md create mode 100644 pages/blog/console-based-representation-in-astx/index_files/index_10_0.png create mode 100644 pages/blog/console-based-representation-in-astx/index_files/index_12_0.png create mode 100644 pages/blog/console-based-representation-in-astx/index_files/index_13_0.png create mode 100644 pages/blog/console-based-representation-in-astx/index_files/index_15_0.png create mode 100644 pages/blog/console-based-representation-in-astx/index_files/index_16_0.png create mode 100644 pages/blog/console-based-representation-in-astx/index_files/index_17_0.png diff --git a/pages/blog/console-based-representation-in-astx/header.png b/pages/blog/console-based-representation-in-astx/header.png new file mode 100644 index 0000000000000000000000000000000000000000..84b830f40d15c1e6f2587b152bb9a9eff6d99214 GIT binary patch literal 24743 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,\n", + " 'body': {'BLOCK': {'content': [{'VariableDeclaration[a, Int32]': {'content': {'Literal[Int32]: 1': {'content': 1,\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': 'c4848732a3c542f1b3818bc799dc0b26',\n", + " 'kind': }}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}},\n", + " {'VariableDeclaration[b, Int32]': {'content': {'Literal[Int32]: 2': {'content': 2,\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': 'b63f0bf700194bb7abbdf99d8cc20336',\n", + " 'kind': }}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}},\n", + " {'VariableDeclaration[c, Int32]': {'content': {'Literal[Int32]: 4': {'content': 4,\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '0c0686b5f12a45bd9ff1a20da82702a0',\n", + " 'kind': }}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}},\n", + " {'RETURN': {'content': {'BINARY[+]': {'content': {'lhs': {'BINARY[-]': {'content': {'lhs': {'BINARY[+]': {'content': {'lhs': {'Literal[Int32]: 1': {'content': 1,\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '8d5d86d52b98484a8e5947ae4e6556f1',\n", + " 'kind': }}},\n", + " 'rhs': {'Variable[b]': {'content': 'b',\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}},\n", + " 'rhs': {'BINARY[/]': {'content': {'lhs': {'BINARY[*]': {'content': {'lhs': {'Variable[a]': {'content': 'a',\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}},\n", + " 'rhs': {'Variable[c]': {'content': 'c',\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}},\n", + " 'rhs': {'Variable[a]': {'content': 'a',\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}},\n", + " 'rhs': {'BINARY[-]': {'content': {'lhs': {'Variable[b]': {'content': 'b',\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}},\n", + " 'rhs': {'BINARY[/]': {'content': {'lhs': {'Variable[a]': {'content': 'a',\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}},\n", + " 'rhs': {'Variable[a]': {'content': 'a',\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}}],\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}}},\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}}],\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create dictionary representation\n", + "module.get_struct()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e551c944-a801-47b3-a995-bed0ae10762b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ┌────────────┐ \n", + " │MODULE[main]│ \n", + " └──────┬─────┘ \n", + " │ \n", + " v \n", + " ┌──────────────┐ \n", + " │FUNCTION[main]│ \n", + " └────┬────┬────┘ \n", + " │ │ \n", + " ┌───────────────────────┘ └────────────────────────┐ \n", + " │ │ \n", + " v │ \n", + " ┌───────┐ │ \n", + " │ body │ │ \n", + " └───┬───┘ │ \n", + " │ │ \n", + " v │ \n", + " ┌─────────┐ │ \n", + " │ BLOCK │ │ \n", + " └─┬───┬┬┬─┘ │ \n", + " │ │││ │ \n", + " ┌───────────────────────┘ ││└──────────────────────────────┐ │ \n", + " │ ┌────────────────────┘│ │ │ \n", + " v │ │ │ │ \n", + " ┌───────┐ │ │ │ │ \n", + " │ RETURN│ │ │ │ │ \n", + " └───┬───┘ │ │ │ │ \n", + " │ │ │ │ │ \n", + " ┌──────────┼──────┼─────────────────────┘ │ │ \n", + " ┌──────┘ │ │ │ │ \n", + " │ v │ │ │ \n", + " │ ┌─────────┐ │ │ │ ┌─────────┐ \n", + " │ │BINARY[+]│ │ │ │ │BINARY[+]│ \n", + " │ └───┬──┬──┘ │ │ │ └──┬─┬────┘ \n", + " │ │ │ │ │ │ │ │ ^ \n", + " │ │ │ │ │ └──────────────┐ │ │ │ \n", + " │ │ │ │ │ └───┐ │ │ │ \n", + " │ │ └────────┼──────────────────────────────────────────────┐ │ │ │ │ │ \n", + " │ └───────────┼────────────────────┐ │ │ │ │ │ │ \n", + " │ │ │ ┌──────────────────────┼──────┼──────────────────────────────────────┼───┘ │ │ \n", + " │ │ │ │ │ ┌───┼──────────────────────────────────────┼─────┘ │ \n", + " │ │ │ │ │ │ │ │ │ \n", + " │ │ v v v v │ │ │ \n", + " │ │ ┌───────┐ ┌───────┐ │ │ │ \n", + " │ │ │ rhs │ │ lhs │ │ │ │ \n", + " │ │ └──┬──┬─┘ └──┬──┬─┘ │ │ │ \n", + " │ │ │ │ │ │ │ │ │ \n", + " │ │ ┌────────────┘ └────────────┐ │ │ └────────────────────┐ │ │ \n", + " │ │ │ │ │ └────────────┐ └──┐ │ │ \n", + " │ ┌─────────────┘ │ │ │ │ │ │ │ \n", + " │ ┌─┘ │ │ │ │ │ │ │ \n", + " │ │ v │ v │ │ │ │ \n", + " │ │ ┌─────────┐ │ ┌─────────┐ │ │ │ │ \n", + " │ │ │BINARY[-]│ │ │BINARY[-]│ │ │ │ │ \n", + " │ │ └───┬──┬──┘ │ └───┬──┬──┘ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ └────────┐ │ │ └─────┐ │ │ │ │ \n", + " │ │ │ │ ┌──────────────┼─────┘ │ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ v v │ │ │ │ │ │ \n", + " │ │ │ ┌───────┐ │ │ │ │ │ │ \n", + " │ │ │ │ rhs │ │ │ │ │ │ │ \n", + " │ │ │ └───┬──┬┘ │ │ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ ┌───────┼──────────────┼───────┘ \n", + " │ │ │ v v │ │ │ │ │ │ \n", + " │ │ │ ┌─────────┐ │ │ │ │ │ │ \n", + " │ │ │ │BINARY[/]│ │ │ │ │ │ │ \n", + " │ │ │ └─┬─┬─┬─┬─┘ │ │ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ ┌──────┘ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ │ ┌─────┘ │ │ │ │ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ │ └──────┼┐ │ │ \n", + " │ │ │ │ │ │ │ │ │ │└──┐ │ │ \n", + " │ │ │ │ │ │ │ └───────────┐ │ │ │ │ │ \n", + " │ │ │ │ │ │ └───────────────────┐ │ │ │ │ │ │ \n", + " │ │ │ │ │ └───────────┐ │ │ │ │ │ │ │ \n", + " │ │ └───┼──┼───────────────────┼─────────┼────┼──┼─────────────┐ │ │ │ │ \n", + " │ │ v v │ │ │ │ │ │ │ │ │ \n", + " │ │ ┌───────┐ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ lhs │ │ │ │ │ │ │ │ │ │ \n", + " │ │ └┬────┬─┘ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ │ │ │ │ └──────────────────┐ \n", + " │ │ │ │ │ │ │ │ │ │ │ └─────┐ │ \n", + " │ │ │ │ │ │ │ └───────────┐ │ │ │ │ │ \n", + " │ │ │ │ │ │ └────────────┐ │ │ │ │ │ │ \n", + " │ │ │ └───────────────────┼─────────┼─────┐ │ │ │ │ │ │ │ \n", + " └─────┐ │ │ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ v │ │ │ │ │ │ │ │ │ │ \n", + " │ │ ┌─────────┐ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ │BINARY[*]│ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ └───┬──┬──┘ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ └─┼─┐ │ │ │ │ \n", + " │ │ │ │ │ └─────┼───────┐ │ │ │ │ │ │ │ \n", + " │ │ │ │ └───────────────┼────┐ │ │ │ │ │ │ │ │ \n", + " │ │ │ └─────────────────────────────────┐ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ └──────────────────────────┐ │ │ │ │ │ │ │ │ │ │ │ \n", + " │ └────────────────────────────┐ │ │ │ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ │ │ │ │ │ │ \n", + " v v v v │ v v │ v v │ │ v v \n", + " ┌─────────────────────────────┐ ┌─────────────────────────────┐ ┌───────┐ ┌───────┐ │ ┌───────┐ │ ┌─────┴─┐ │ ┌─────────────────────────────┐ ┌───────┐ \n", + " │VariableDeclaration[c, Int32]│ │VariableDeclaration[b, Int32]│ │ lhs │ │ rhs │ │ │ rhs │ │ │ lhs │ │ │VariableDeclaration[a, Int32]│ │ args │ \n", + " └────────┬────────────────────┘ └──────────────┬──────────────┘ └───┬───┘ └───┬───┘ │ └──┬──┬─┘ │ └───┬───┘ │ └────────────────────────────┬┘ └───┬───┘ \n", + " │ │ │ │ │ │ │ │ │ │ │ │ \n", + " │ ┌─────────────────┘ │ │ │ │ │ │ │ │ │ └──────────┐ \n", + " │ │ ┌───────────────────────┘ │ │ │ │ │ │ │ │ │ \n", + " │ │ │ ┌─────────────────┘ │ │ │ │ │ └──────────┐ │ │ \n", + " │ │ │ ┌───────────┼───────────────────────┘ │ │ │ │ │ │ │ \n", + " │ │ │ │ │ ┌────────────────┘ │ │ │ │ │ │ \n", + " │ │ │ │ │ │ ┌───────────────┘ │ │ │ │ │ \n", + " │ │ │ │ │ │ │ ┌───────┘ │ │ │ │ \n", + " │ │ │ │ │ │ │ │ │ │ │ │ \n", + " v v v v v v v v v v v v \n", + " ┌─────────────────┐ ┌─────────────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌─────────────────┐ ┌─────────────────┐ ┌────────────┐\n", + " │Literal[Int32]: 4│ │Literal[Int32]: 2│ │Variable[a]│ │Variable[c]│ │Variable[a]│ │Variable[b]│ │Variable[b]│ │Literal[Int32]: 1│ │Literal[Int32]: 1│ │Arguments(0)│\n", + " └─────────────────┘ └─────────────────┘ └───────────┘ └───────────┘ └───────────┘ └───────────┘ └───────────┘ └─────────────────┘ └─────────────────┘ └────────────┘\n" + ] + } + ], + "source": [ + "# Create ascii representation\n", + "dot_graph = traverse_ast_ascii(module.get_struct(simplified=True))\n", + "graph = graph_to_ascii(dot_graph) \n", + "print(graph)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d53ada78-86da-4b8d-9d14-cc1337e17999", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create PNG representation\n", + "module" + ] + }, + { + "cell_type": "markdown", + "id": "3bcc23a8-df87-468f-b100-84260d3347da", + "metadata": {}, + "source": [ + "We can also get the PNG representation of parts of the AST, such as `basic_op` and the variable `a`:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ec46ee68-8e7e-4b45-a316-a5522349d310", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create PNG representation\n", + "basic_op" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "15f25501-fd77-4927-b17d-15e82b3105cf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create PNG representation\n", + "a" + ] + }, + { + "cell_type": "markdown", + "id": "c23049f4-e640-4059-94e1-26e8d0de8700", + "metadata": {}, + "source": [ + "## Custom shapes\n", + "\n", + "It is also possible to use custom shapes for the output using the function `viz.visualize`. The Default shape is `box`, but `diamond`, `ellipse`, and `circle` are also avaiable options. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e765eebe-f2f8-498b-b47b-ac840b30a97f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPEAAAA7CAYAAACquGzbAAAABmJLR0QA/wD/AP+gvaeTAAAN6UlEQVR4nO2da0wc1f/Gn8Iu7AIFLHcUG6hUCy3bsuxy2UXa2vBCWxtJSEwqtWpS+kLRmCaQ9EXjJUYwjWii0BhpaDHa/kOagDbRGjWBBbrLFko3lEIEY9ul3EEWaLl9/y/8zcjsBVjYK5xPMi925uw535nMM+ec58w5s4WICAwGw2vxcXcADAZjfTARMxheDhMxg+HlMBFvYPr6+vDjjz+iu7sbzPrYuIjcHQDDMQwMDECn0wm24eFh/nhoaCgUCgUUCgWUSiUUCgViY2PdGDHDUWxh7rT3YTKZ0N7eDr1ez2937twBESEmJgZyuRxqtRoqlQp79uzB/fv3odfrodFo0NjYiK6uLiwuLvJpuS0zMxPh4eHuPj2GnTARezjz8/O4e/euQ0Voz0MgNTUVAQEBLjhTxlphIvYwent70djYKBDYo0ePsHXrVqSkpAhEm5yc7LByx8fH0draypet1WoxODgIkUiEnTt3CspVKBTw9/d3WNmM9cFE7EaMRqNArBqNBmNjYxCLxUhMTORrQ7lcjl27dsHHx7U+5HLxpaSk8LHJ5XIkJSVhy5YtLo2P8S9MxC5iYmICt2/f5pvEOp0OAwMD8PX1xbPPPusVNd3CwgK6uroEwuZaCsHBwdizZw9/DtnZ2YiPj3d3yJsCJmInsJo+J9fvzMzMRGBgoLtDXjNzc3Po7u5mxpkbYSJeJ0uNJ+5Gbm9vx8LCgsVNnJGRgYiICHeH7HQmJydx69YtwUOss7MTACyMM7lcDqlU6uaIvRsmYjsxN55u3ryJmZkZpxtP3k5/fz9aW1v563bjxg0MDQ1ZNc6USiX8/PzcHbLXwES8DObGTlNTE0ZHR3njaWmN4g7jydtZen01Gg2am5sxNTWFwMBA7N27VyBsZpzZhon4f9hjPKWlpUEikbg75A2HNeOstbUVjx8/FhhnarUa2dnZiI6OdnfIHsGmFPHU1BTa2tpWNJ64G+aJJ55wd8ibFs444x6uer3epnGWlZWFsLAwd4fscja8iM2NJ71eD51Oh9nZWYSGhiItLY03WNLT0xEZGenukBkrsJJxttQ02wzG2YYTsdFoFDy1mfG0OTA3zlpaWjA8PLwpjDOvFrG58dTc3IyRkRFmPDEA/Hd/cA/1trY2TE9PbzzjjLyE8fFxamhooPLycsrPz6fo6GgCQL6+vpSUlEQFBQVUXl5ODQ0NNDMzs+Zy2traCIBg27Fjh0W6sbExi3SexGeffcbH9eSTTzo8vS0uXbokuCaBgYFryqe4uFiQT3p6+ppj4pifnyeDwUDV1dVUVFREKpWK/P39CQCFhISQSqWioqIiunLlCj18+HDd5bkKz7rz/ofJZOIFW1BQQElJSbRlyxYCQDExMXT48GE6e/Ys1dXV0ejoqFNieOuttwgAnTlzZtl0L7/8MpWWljq8/MnJSXrmmWfopZdeWlc+MpnMLlHam94cTsQVFRVrzsMcX19fh4jYGrOzs9Ta2iq413x8fKzeayMjI06JYb24fVGAlYyn5ORkHDlyBJ9++qlLjac33ngD3377LS5evIgPP/zQalN8cHAQv/zyCyorKx1ePhFhcXERi4uLDs+b8R9isZhvUnP8888/6Ojo4O/Hixcv4oMPPgAAJCQkCEwzTzDOXC5i834KZzwFBQVBJpNBLpfj5MmTbu+nqFQqJCYmoqenB7/++ityc3Mt0ly8eBGHDh1CTEyMw8vfunUr/vzzT4fny1iZ4OBgqNVqqNVqfp+5//Lxxx9bNc7UajX27t0LX19fl8XrVBHbMp6Wnnh+fj7UajX27dvnccbTiRMncObMGVy4cMGqiC9cuICPPvrIDZExXE1sbCxiY2Nx5MgRfp95hVRbW4vp6WlBheQS48xR7fKJiQlBPzY+Pp43JRISEhxmPLmSe/fukY+PD0kkEhobGxMca2lpofDwcJqdnSUiorm5Ofrhhx/o0KFDFBUVRRKJhHbv3k3l5eW0sLDA/+/q1asCw6arq4vy8/Np27Zt/L5vvvlGkGbp9VptORxcH/fOnTv04osvUnBwMEmlUtq/fz81NjbaTG/O4OAgvfPOO7R9+3YSi8UUHh5Or7zyCrW1tQnSLdcntjd2Dmf2iR3J3NychXHm5+cnMM6Ki4uprq7OocbZmkRszQywZTx5qhmwWnJzcwkAff3114L9hYWF9N577/G/6+vrCQB98sknNDo6SkNDQ/Tll1+Sj48PnT592iLfo0ePEgDKycmh33//naampqilpYV8fX1paGhIkGapiO0tRyaTUUhICB04cIAaGxtpcnKSdDodpaSkkJ+fH/3xxx8W6c1FbDQaafv27RQVFUU//fQTTU5OksFgoJycHJJIJNTU1MSnXU7E9sbO4S0itoYrtLKiiN31dPEUvv/+ewJACoWC3zc9PU0hISHU0dHB76uvr6f9+/db/P+1114jsVhMExMTgv2cQK9du2azbFsitqccmUxGAKi5uVmwv6OjgwCQTCazSG8u4tdff50A0HfffSfY39/fT/7+/iSXy/l9K4nYntg5vFnE1ljaal06XLrWVqtAxIuLi3T37l2qqamhd999l7KyskgqlRIACgoKopycHDp9+jRdvnyZ+vr6nHWOHsXMzAyFhoYSADIYDEREVFNTI7hxl4Mbf11aWxH9J9Dh4WGb/7UmYnvLkclkJJFIaHFx0eI/sbGxBICMRqMgvbmIQ0JCyMfHx6rIUlNTCQDdu3ePiNY2xGQrdo6NJmJr/P3331RbW0slJSV08OBBCg4OJgDk7+9PSqWS3n77baqurqbOzk6LrgdvbPX19aGiogLXr1+HwWDA/Pw8AEAkEiEvLw/Hjx9HRkYGoqKiHNwr92wkEgleffVVVFZWoqqqCufOnUNVVRXefPNNQbqJiQmcO3cOV69exf379zE+Pi44Pj09bTV/e1f1WEs5YWFhVk2VyMhIGI1GDA4O2nTYHz9+jImJCQBASEiIzbh6enrw1FNPOTz2zUJcXBzi4uKQl5eH4eFhaLVa1NTUoLa2FlqtFlqtFr6+vti1axdeeOEFnDp1Cs8999y/f7b2VJidnSWDwUDnz59fcQB8uZpko3Djxg0CQJGRkdTT00NSqdTiJZPs7GwCQF988QUNDg7yNd/nn39OAOj69euC9KupZa2lsbccmUxGQUFBVvNfbU0cGhpKIpGI5ubmbMbKsVxNbG/sHBu5JnbEi01Wh5jEYjGSk5ORnJyMkydPArAcAL906RI/AL7RZ44olUokJSWhs7MTx44dw9GjRwXTExcWFqDRaBAdHY2ioiLBf2dmZhwWx1rLMZlMuHXrFmQyGb/v9u3bMBqNkMlkK45z5+XloaqqChqNBjk5OYJjpaWl+Oqrr9Db2wuRyPaIpauukSezmhl1+fn59s+oW89T5MGDB1RXV0dnz56lw4cPU3h4OAEgkUgkeJ+5tbWV5ufn11OU2ykrK+PNh59//tni+MGDBwkAlZWV0dDQEE1PT9Nvv/1GTz/9tENrYnvLkclkFBgYSGq1mlpaWshkMtntTg8MDNCOHTsoISGBrl27RuPj4zQyMkKVlZUUEBBAly9f5tMuVxPbGzuHt9bEDx48oCtXrvCG8FJ/iXtPu7q6mgwGg1XPYrU4/N1pTtjFxcWkUqkoICDAKYG7mv7+fhKJRBQXF2d1THNoaIgKCwspLi6OxGIxRUVF0YkTJ6ikpIQXv1wup+bmZouJE+bPUvOxZAB07Ngxu8oxn9Cg1WrpwIEDFBQURFKplHJycgTjxEvTc9vS98ZHRkbo/fffp4SEBBKLxRQREUG5ubkWwltOxKuN3RxvELF5hRYWFmZRoZ0/f54MBsOyY+JrwelTEZdrQoSEhGD37t18U1ypVG4642yjUVNTg4KCAlRUVODUqVMOyVMkEiEtLQ0tLS0OyW+9LO1aajQaNDQ04OHDhwAs3612xVJOTn93WiQS8f3r48ePA/h3yZWOjg5+4n59fT3KysqsLo+jUqmwbds2Z4fJYFjF/F61tpRTYWGhW+9Vj1kUwNw4a2xsRF9fHwD3PN0Ya4OriTkCAwNhMpnszqekpASlpaX87/T0dKfXxN7aavQYEVtjNRMouJkjnjiBguHZ2Fr5w+UTGNaJR4vYGquZyugNF57hWswrBFtrcLljKuF68ToRm7OaRQW4JhBbzXJzYE/XbCO80+D1IrYGW1d682DNeLK1LvVGNUk3pIitwX3hwXxYgH3hwXtY7gsRnPHEPZiff/55jzGenM2mEbE12JK3no35t5qampo25pKz62RTi9gabPF598C+mrh2mIhXgH0GxvGwz7A4FibiNWCPcZadnY3Q0FB3h+w22AfRnA8TsYNgn0ZlnyZ1F0zETmSlj5QvbTZ6o3HGPhLuGTARu5je3l7BmKa3GGfMePJcmIjdjLlxptFo0N7ejoWFBYs+Y0ZGBiIiIpwe00rG09Kht9TUVAQEBDg9JoZtmIg9EJPJhPb29hWNM7VajaysrHWJiDOelr6Pbst4yszMRHh4uAPPlOEImIi9BHuMM4VCAX9/f4s8rBlPer0ejx49EhhPnKseHx/vhjNl2AsTsRfz119/QavVQqfTQafTQa/Xw2QyQSqVYt++fVAoFEhKSkJ3dze0Wi1u3ryJqakpBAQE8Me5LTEx0d2nw1gjTMQbCK6m5USt1WrR2dmJnTt3QqFQQKlUQqFQIDk5edmVKRneBRMxg+HleNfAJIPBsICJmMHwcpiIGQwvRwTg/9wdBIPBWDv/D3BZOIM94LNdAAAAAElFTkSuQmCC", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Import visualization module\n", + "from astx import viz\n", + "\n", + "# Create PNG representation with diamond shape\n", + "viz.visualize(a.get_struct(), shape=\"diamond\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b2543b53-7c97-4280-b369-deb514c4689c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create PNG representation with circle shape\n", + "viz.visualize(a.get_struct(), shape=\"circle\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a38ab2d0-7615-4c01-9bb1-08eedb6ca83c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create PNG representation with ellipse shape\n", + "viz.visualize(a.get_struct(), shape=\"ellipse\")" + ] + }, + { + "cell_type": "markdown", + "id": "26ef1289-119b-43f2-b683-37ffc73f237b", + "metadata": {}, + "source": [ + "# Conclusion\n", + "\n", + "This guide provides clear instructions and a simple example for you to start using the ASTx library. But this is just the beginning of your journey. Make sure to check out the other tutorials available, such as the one for [variables](https://github.com/arxlang/astx/blob/main/docs/tutorials/variables.ipynb) and the one for [functions](https://github.com/arxlang/astx/blob/main/docs/tutorials/functions.ipynb)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pages/blog/console-based-representation-in-astx/index.md b/pages/blog/console-based-representation-in-astx/index.md new file mode 100644 index 00000000..e71dad0e --- /dev/null +++ b/pages/blog/console-based-representation-in-astx/index.md @@ -0,0 +1,522 @@ +--- +title: "Console-based representation in ASTx" +slug: "console-based-representation-in-astx" +date: 2024-08-08 +authors: ["Ana Krelling", "Ivan Ogasawara"] +tags: ["abstract syntax tree", "ascii", "console"] +categories: ["abstract syntax tree", "console"] +description: | + Recently, console-based AST representation was included in the ASTx framework. Such feature can enhance the debugging and analysis capabilities of ASTx, particularly in environments such as a pdb session. In this tutorial, we'll explore this new feature as well as the ASTx Graphviz visualization. +thumbnail: "/header.png" +template: "blog-post.html" +--- +# Introduction + +The ASTx library is an agnostic framework for constructing and representing Abstract Syntax Trees (ASTs). Its primary objective is to provide a versatile and language-independent structure for ASTs, with the flexibility to be utilized across various programming languages and parsing tools. ASTx doesn't aim to be a lexer or a parser, although it could be used by any programming language or parser in order to provide a high level representation of the AST. + +Many kinds of nodes (classes) are currently supported. Below is a list with just some examples: + +##### Statements: +* Function +* Function Prototype +* FunctionReturn +* ForRangeLoop +* VarDecl + +##### Operators: +* BinaryOp +* UnaryOp + +##### Data types: +* Boolean +* Literal +* Variable + + +The ASTx project is still under development, so new classes may be added to the ones above at any time. + +Below are installation instructions and an example, so you can have an overview of how you can leverage the ASTx library for your needs. + +# Installation +The first step is to install ASTx. You can do it simply by running the command below in your terminal:\ +`$ pip install astx`\ +If you need more information on installation, you can get it in the [ASTx installation page](https://github.com/arxlang/astx/blob/main/docs/installation.md). +After that, you can just open a Jupyter Notebook instance and start writing your first AST. + + +# Example: an AST of a series of mathematical operations +Here we will present a quick example of an AST of the expression \ +`basic_op = lit_1 + b - a * c / a + (b - a / a)`, in which \ +$~~~~$ `lit_1` is a defined integer, and \ +$~~~~$ `a`, `b`, and `c` are variables.\ +The first thing to do is, in your Jupyter Notebook instance, import `display`, which will allow you to have a basic visualization of the AST, and the astx library itself. + + +```python +# import display for AST visualization +from IPython.display import display +from astx.viz import traverse_ast_ascii, graph_to_ascii +import astx +``` + +Then we create an instance of the Module class, and this instance will be the first node of the tree, or the root node. After that, we declare the variables and literal that will be part of the basic operation that we will parse into an AST. + + +```python +# Create module +module = astx.Module() + +# Declare variables +decl_a = astx.VariableDeclaration(name="a", type_=astx.Int32, value=astx.LiteralInt32(1)) +decl_b = astx.VariableDeclaration(name="b", type_=astx.Int32, value=astx.LiteralInt32(2)) +decl_c = astx.VariableDeclaration(name="c", type_=astx.Int32, value=astx.LiteralInt32(4)) + +a = astx.Variable(name="a") +b = astx.Variable(name="b") +c = astx.Variable(name="c") + +# Declare literal +lit_1 = astx.LiteralInt32(1) + +# State the expression +basic_op = lit_1 + b - a * c / a + (b - a / a) +``` + +After the basic expression is stated, we create an instance of the Function class. As mentioned in the API documentation, each instance of the Function class must have a prototype and a body, so we'll create those first. + +The body is made of a block that is created and the variables, as well as the basic operation, are appended to it afterwards. + + +```python +# Create FunctionPrototype +main_proto = astx.FunctionPrototype( + name="main", args=astx.Arguments(), return_type=astx.Int32 +) + +# Create FunctionReturn +main_block = astx.Block() +main_block.append(decl_a) +main_block.append(decl_b) +main_block.append(decl_c) +main_block.append(astx.FunctionReturn(basic_op)) + +# Create Function +main_fn = astx.Function(prototype=main_proto, body=main_block) + +# Append function to module +module.block.append(main_fn) +``` + +After this, the module is complete. We can get its AST structure as a dictionary, as well as a PNG representation. + + +```python +# Create dictionary representation +module.get_struct() +``` + + + + +
+

+ OUTPUT + +

+
+  
+{'MODULE[main]': {'content': [{'FUNCTION[main]': {'content': {'args': {'Arguments(0)': {'content': [],
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}},
+'body': {'BLOCK': {'content': [{'VariableDeclaration[a, Int32]': {'content': {'Literal[Int32]: 1': {'content': 1,
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': 'c4848732a3c542f1b3818bc799dc0b26',
+'kind': }}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}},
+{'VariableDeclaration[b, Int32]': {'content': {'Literal[Int32]: 2': {'content': 2,
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': 'b63f0bf700194bb7abbdf99d8cc20336',
+'kind': }}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}},
+{'VariableDeclaration[c, Int32]': {'content': {'Literal[Int32]: 4': {'content': 4,
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '0c0686b5f12a45bd9ff1a20da82702a0',
+'kind': }}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}},
+{'RETURN': {'content': {'BINARY[+]': {'content': {'lhs': {'BINARY[-]': {'content': {'lhs': {'BINARY[+]': {'content': {'lhs': {'Literal[Int32]: 1': {'content': 1,
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '8d5d86d52b98484a8e5947ae4e6556f1',
+'kind': }}},
+'rhs': {'Variable[b]': {'content': 'b',
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}},
+'rhs': {'BINARY[/]': {'content': {'lhs': {'BINARY[*]': {'content': {'lhs': {'Variable[a]': {'content': 'a',
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}},
+'rhs': {'Variable[c]': {'content': 'c',
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}},
+'rhs': {'Variable[a]': {'content': 'a',
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}},
+'rhs': {'BINARY[-]': {'content': {'lhs': {'Variable[b]': {'content': 'b',
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}},
+'rhs': {'BINARY[/]': {'content': {'lhs': {'Variable[a]': {'content': 'a',
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}},
+'rhs': {'Variable[a]': {'content': 'a',
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}}],
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}}},
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}}],
+'metadata': {'loc': {line: -1, col: -1},
+'comment': '',
+'ref': '',
+'kind': }}}
+
+
+
+ + + + +```python +# Create ascii representation +dot_graph = traverse_ast_ascii(module.get_struct(simplified=True)) +graph = graph_to_ascii(dot_graph) +print(graph) +``` + +
+

+ OUTPUT + +

+
+  
+┌────────────┐
+│MODULE[main]│
+└──────┬─────┘
+│
+v
+┌──────────────┐
+│FUNCTION[main]│
+└────┬────┬────┘
+│    │
+┌───────────────────────┘    └────────────────────────┐
+│                                                     │
+v                                                     │
+┌───────┐                                                 │
+│  body │                                                 │
+└───┬───┘                                                 │
+│                                                     │
+v                                                     │
+┌─────────┐                                                │
+│  BLOCK  │                                                │
+└─┬───┬┬┬─┘                                                │
+│   │││                                                  │
+┌───────────────────────┘   ││└──────────────────────────────┐                   │
+│      ┌────────────────────┘│                               │                   │
+v      │                     │                               │                   │
+┌───────┐  │                     │                               │                   │
+│ RETURN│  │                     │                               │                   │
+└───┬───┘  │                     │                               │                   │
+│      │                     │                               │                   │
+┌──────────┼──────┼─────────────────────┘                               │                   │
+┌──────┘          │      │                                                     │                   │
+│                 v      │                                                     │                   │
+│        ┌─────────┐     │                                                     │                   │                   ┌─────────┐
+│        │BINARY[+]│     │                                                     │                   │                   │BINARY[+]│
+│        └───┬──┬──┘     │                                                     │                   │                   └──┬─┬────┘
+│            │  │        │                                                     │                   │                      │ │ ^
+│            │  │        │                                                     │                   └──────────────┐       │ │ │
+│            │  │        │                                                     │                                  └───┐   │ │ │
+│            │  └────────┼──────────────────────────────────────────────┐      │                                      │   │ │ │
+│            └───────────┼────────────────────┐                         │      │                                      │   │ │ │
+│                        │                    │  ┌──────────────────────┼──────┼──────────────────────────────────────┼───┘ │ │
+│                        │                    │  │                      │  ┌───┼──────────────────────────────────────┼─────┘ │
+│                        │                    │  │                      │  │   │                                      │       │
+│                        │                    v  v                      v  v   │                                      │       │
+│                        │                 ┌───────┐                 ┌───────┐ │                                      │       │
+│                        │                 │  rhs  │                 │  lhs  │ │                                      │       │
+│                        │                 └──┬──┬─┘                 └──┬──┬─┘ │                                      │       │
+│                        │                    │  │                      │  │   │                                      │       │
+│                        │       ┌────────────┘  └────────────┐         │  │   └────────────────────┐                 │       │
+│                        │       │                            │         │  └────────────┐           └──┐              │       │
+│          ┌─────────────┘       │                            │         │               │              │              │       │
+│        ┌─┘                     │                            │         │               │              │              │       │
+│        │                       v                            │         v               │              │              │       │
+│        │                  ┌─────────┐                       │ ┌─────────┐             │              │              │       │
+│        │                  │BINARY[-]│                       │ │BINARY[-]│             │              │              │       │
+│        │                  └───┬──┬──┘                       │ └───┬──┬──┘             │              │              │       │
+│        │                      │  │                          │     │  │                │              │              │       │
+│        │                      │  └────────┐                 │     │  └─────┐          │              │              │       │
+│        │                      │           │  ┌──────────────┼─────┘        │          │              │              │       │
+│        │                      │           │  │              │              │          │              │              │       │
+│        │                      │           v  v              │              │          │              │              │       │
+│        │                      │        ┌───────┐            │              │          │              │              │       │
+│        │                      │        │  rhs  │            │              │          │              │              │       │
+│        │                      │        └───┬──┬┘            │              │          │              │              │       │
+│        │                      │            │  │             │              │          │              │              │       │
+│        │                      │            │  │             │              │          │      ┌───────┼──────────────┼───────┘
+│        │                      │            v  v             │              │          │      │       │              │
+│        │                      │        ┌─────────┐          │              │          │      │       │              │
+│        │                      │        │BINARY[/]│          │              │          │      │       │              │
+│        │                      │        └─┬─┬─┬─┬─┘          │              │          │      │       │              │
+│        │                      │          │ │ │ │            │              │          │      │       │              │
+│        │                      │   ┌──────┘ │ │ │            │              │          │      │       │              │
+│        │                      │   │  ┌─────┘ │ │            │              │          │      │       │              │
+│        │                      │   │  │       │ │            │              │          └──────┼┐      │              │
+│        │                      │   │  │       │ │            │              │                 │└──┐   │              │
+│        │                      │   │  │       │ │            └───────────┐  │                 │   │   │              │
+│        │                      │   │  │       │ └───────────────────┐    │  │                 │   │   │              │
+│        │                      │   │  │       └───────────┐         │    │  │                 │   │   │              │
+│        │                      └───┼──┼───────────────────┼─────────┼────┼──┼─────────────┐   │   │   │              │
+│        │                          v  v                   │         │    │  │             │   │   │   │              │
+│        │                       ┌───────┐                 │         │    │  │             │   │   │   │              │
+│        │                       │  lhs  │                 │         │    │  │             │   │   │   │              │
+│        │                       └┬────┬─┘                 │         │    │  │             │   │   │   │              │
+│        │                        │    │                   │         │    │  │             │   │   │   │              │
+│        │                        │    │                   │         │    │  │             │   │   │   │              └──────────────────┐
+│        │                        │    │                   │         │    │  │             │   │   │   └─────┐                           │
+│        │                        │    │                   │         │    │  └───────────┐ │   │   │         │                           │
+│        │                        │    │                   │         │    └────────────┐ │ │   │   │         │                           │
+│        │                        │    └───────────────────┼─────────┼─────┐           │ │ │   │   │         │                           │
+└─────┐  │                        │                        │         │     │           │ │ │   │   │         │                           │
+│  │                        v                        │         │     │           │ │ │   │   │         │                           │
+│  │                   ┌─────────┐                   │         │     │           │ │ │   │   │         │                           │
+│  │                   │BINARY[*]│                   │         │     │           │ │ │   │   │         │                           │
+│  │                   └───┬──┬──┘                   │         │     │           │ │ │   │   │         │                           │
+│  │                       │  │                      │         │     │           │ │ │   │   │         │                           │
+│  │                       │  │                      │         │     │           │ └─┼─┐ │   │         │                           │
+│  │                       │  │                      │         └─────┼───────┐   │   │ │ │   │         │                           │
+│  │                       │  │                      └───────────────┼────┐  │   │   │ │ │   │         │                           │
+│  │                       │  └─────────────────────────────────┐    │    │  │   │   │ │ │   │         │                           │
+│  │                       └──────────────────────────┐         │    │    │  │   │   │ │ │   │         │                           │
+│  └────────────────────────────┐                     │         │    │    │  │   │   │ │ │   │         │                           │
+│                               │                     │         │    │    │  │   │   │ │ │   │         │                           │
+v                               v                     v         v    │    v  v   │   v v │   │         v                           v
+┌─────────────────────────────┐ ┌─────────────────────────────┐ ┌───────┐ ┌───────┐ │ ┌───────┐ │ ┌─────┴─┐ │ ┌─────────────────────────────┐ ┌───────┐
+│VariableDeclaration[c, Int32]│ │VariableDeclaration[b, Int32]│ │  lhs  │ │  rhs  │ │ │  rhs  │ │ │  lhs  │ │ │VariableDeclaration[a, Int32]│ │  args │
+└────────┬────────────────────┘ └──────────────┬──────────────┘ └───┬───┘ └───┬───┘ │ └──┬──┬─┘ │ └───┬───┘ │ └────────────────────────────┬┘ └───┬───┘
+│                                     │                    │         │     │    │  │   │     │     │                              │      │
+│                   ┌─────────────────┘                    │         │     │    │  │   │     │     │                              │      └──────────┐
+│                   │              ┌───────────────────────┘         │     │    │  │   │     │     │                              │                 │
+│                   │              │               ┌─────────────────┘     │    │  │   │     │     └──────────┐                   │                 │
+│                   │              │   ┌───────────┼───────────────────────┘    │  │   │     │                │                   │                 │
+│                   │              │   │           │           ┌────────────────┘  │   │     │                │                   │                 │
+│                   │              │   │           │           │   ┌───────────────┘   │     │                │                   │                 │
+│                   │              │   │           │           │   │           ┌───────┘     │                │                   │                 │
+│                   │              │   │           │           │   │           │             │                │                   │                 │
+v                   v              v   v           v           v   v           v             v                v                   v                 v
+┌─────────────────┐ ┌─────────────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌─────────────────┐ ┌─────────────────┐ ┌────────────┐
+│Literal[Int32]: 4│ │Literal[Int32]: 2│ │Variable[a]│ │Variable[c]│ │Variable[a]│ │Variable[b]│ │Variable[b]│ │Literal[Int32]: 1│ │Literal[Int32]: 1│ │Arguments(0)│
+└─────────────────┘ └─────────────────┘ └───────────┘ └───────────┘ └───────────┘ └───────────┘ └───────────┘ └─────────────────┘ └─────────────────┘ └────────────┘
+
+
+
+
+ + +```python +# Create PNG representation +module +``` + + + +![png](index_files/index_10_0.png) + + + + + + +
+

+ OUTPUT + +

+
+  
+
+
+
+
+ + + +We can also get the PNG representation of parts of the AST, such as `basic_op` and the variable `a`: + + +```python +# Create PNG representation +basic_op +``` + + + +![png](index_files/index_12_0.png) + + + + + + +
+

+ OUTPUT + +

+
+  
+
+
+
+
+ + + + +```python +# Create PNG representation +a +``` + + + +![png](index_files/index_13_0.png) + + + + + + +
+

+ OUTPUT + +

+
+  
+
+
+
+
+ + + +## Custom shapes + +It is also possible to use custom shapes for the output using the function `viz.visualize`. The Default shape is `box`, but `diamond`, `ellipse`, and `circle` are also avaiable options. + + +```python +# Import visualization module +from astx import viz + +# Create PNG representation with diamond shape +viz.visualize(a.get_struct(), shape="diamond") +``` + + + +![png](index_files/index_15_0.png) + + + + +```python +# Create PNG representation with circle shape +viz.visualize(a.get_struct(), shape="circle") +``` + + + +![png](index_files/index_16_0.png) + + + + +```python +# Create PNG representation with ellipse shape +viz.visualize(a.get_struct(), shape="ellipse") +``` + + + +![png](index_files/index_17_0.png) + + + +# Conclusion + +This guide provides clear instructions and a simple example for you to start using the ASTx library. But this is just the beginning of your journey. Make sure to check out the other tutorials available, such as the one for [variables](https://github.com/arxlang/astx/blob/main/docs/tutorials/variables.ipynb) and the one for [functions](https://github.com/arxlang/astx/blob/main/docs/tutorials/functions.ipynb). diff --git a/pages/blog/console-based-representation-in-astx/index_files/index_10_0.png b/pages/blog/console-based-representation-in-astx/index_files/index_10_0.png new file mode 100644 index 0000000000000000000000000000000000000000..297df22d8ccfdac7b55af6f3d21fa44f1e3f52dd GIT binary patch literal 77558 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
MXo8~6Qpvh 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℘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 literal 0 HcmV?d00001 diff --git a/pages/blog/console-based-representation-in-astx/index_files/index_16_0.png b/pages/blog/console-based-representation-in-astx/index_files/index_16_0.png new file mode 100644 index 0000000000000000000000000000000000000000..003acccefcc7153bf150593046728125fdf3c91f GIT binary patch literal 7774 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 P#t7B>T8dTjmM{MgFl=ZS literal 0 HcmV?d00001 diff --git a/pages/blog/console-based-representation-in-astx/index_files/index_17_0.png b/pages/blog/console-based-representation-in-astx/index_files/index_17_0.png new file mode 100644 index 0000000000000000000000000000000000000000..043b8e38838d85d9c8fe360243bb61e46edc9599 GIT binary patch literal 4423 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 m3zCqtOB(_LMJ^CMR7=1_p literal 0 HcmV?d00001 From 0e7ef570bec13b5d0e68dfa1880c4d9408aa9b5d Mon Sep 17 00:00:00 2001 From: Ana Krelling Date: Thu, 8 Aug 2024 13:33:19 -0400 Subject: [PATCH 2/3] docs: minor changes in console-based AST repr in ASTx page --- pages/blog/console-based-representation-in-astx/index.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pages/blog/console-based-representation-in-astx/index.ipynb b/pages/blog/console-based-representation-in-astx/index.ipynb index 812d7127..9c87816a 100644 --- a/pages/blog/console-based-representation-in-astx/index.ipynb +++ b/pages/blog/console-based-representation-in-astx/index.ipynb @@ -26,7 +26,7 @@ "source": [ "# Introduction\n", "\n", - "The ASTx library is an agnostic framework for constructing and representing Abstract Syntax Trees (ASTs). Its primary objective is to provide a versatile and language-independent structure for ASTs, with the flexibility to be utilized across various programming languages and parsing tools. ASTx doesn't aim to be a lexer or a parser, although it could be used by any programming language or parser in order to provide a high level representation of the AST.\n", + "The ASTx library is an agnostic framework for constructing and representing Abstract Syntax Trees (ASTs). Its primary objective is to provide a versatile and language-independent structure for ASTs, with the flexibility to be utilized across various programming languages and parsing tools. ASTx doesn't aim to be a lexer or a parser, although it could be used by any programming language or parser written in Python in order to provide a high level representation of the AST.\n", "\n", "Many kinds of nodes (classes) are currently supported. Below is a list with just some examples:\n", "\n", From b44e74cdc806ab2accc5c250a857093347da7ddf Mon Sep 17 00:00:00 2001 From: Ana Krelling Date: Thu, 8 Aug 2024 13:35:33 -0400 Subject: [PATCH 3/3] docs: minor changes in console-based AST repr in ASTx page --- pages/blog/console-based-representation-in-astx/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pages/blog/console-based-representation-in-astx/index.md b/pages/blog/console-based-representation-in-astx/index.md index e71dad0e..414249d3 100644 --- a/pages/blog/console-based-representation-in-astx/index.md +++ b/pages/blog/console-based-representation-in-astx/index.md @@ -12,7 +12,7 @@ template: "blog-post.html" --- # Introduction -The ASTx library is an agnostic framework for constructing and representing Abstract Syntax Trees (ASTs). Its primary objective is to provide a versatile and language-independent structure for ASTs, with the flexibility to be utilized across various programming languages and parsing tools. ASTx doesn't aim to be a lexer or a parser, although it could be used by any programming language or parser in order to provide a high level representation of the AST. +The ASTx library is an agnostic framework for constructing and representing Abstract Syntax Trees (ASTs). Its primary objective is to provide a versatile and language-independent structure for ASTs, with the flexibility to be utilized across various programming languages and parsing tools. ASTx doesn't aim to be a lexer or a parser, although it could be used by any programming language or parser written in Python in order to provide a high level representation of the AST. Many kinds of nodes (classes) are currently supported. Below is a list with just some examples: