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 00000000..84b830f4 Binary files /dev/null and b/pages/blog/console-based-representation-in-astx/header.png differ diff --git a/pages/blog/console-based-representation-in-astx/index.ipynb b/pages/blog/console-based-representation-in-astx/index.ipynb new file mode 100644 index 00000000..9c87816a --- /dev/null +++ b/pages/blog/console-based-representation-in-astx/index.ipynb @@ -0,0 +1,644 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "087f2f63-a7a4-4ca7-a007-ac84e0f40aad", + "metadata": {}, + "source": [ + "---\n", + "title: \"Console-based representation in ASTx\"\n", + "slug: \"console-based-representation-in-astx\"\n", + "date: 2024-08-08\n", + "authors: [\"Ana Krelling\", \"Ivan Ogasawara\"]\n", + "tags: [\"abstract syntax tree\", \"ascii\", \"console\"]\n", + "categories: [\"abstract syntax tree\", \"console\"]\n", + "description: |\n", + " 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.\n", + "thumbnail: \"/header.png\"\n", + "template: \"blog-post.html\"\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "dc9b5a46", + "metadata": {}, + "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 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", + "##### Statements:\n", + "* Function\n", + "* Function Prototype\n", + "* FunctionReturn\n", + "* ForRangeLoop \n", + "* VarDecl\n", + "\n", + "##### Operators:\n", + "* BinaryOp\n", + "* UnaryOp\n", + "\n", + "##### Data types:\n", + "* Boolean\n", + "* Literal \n", + "* Variable \n", + "\n", + "\n", + "The ASTx project is still under development, so new classes may be added to the ones above at any time.\n", + "\n", + "Below are installation instructions and an example, so you can have an overview of how you can leverage the ASTx library for your needs.\n", + "\n", + "# Installation\n", + "The first step is to install ASTx. You can do it simply by running the command below in your terminal:\\\n", + "`$ pip install astx`\\\n", + "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).\n", + "After that, you can just open a Jupyter Notebook instance and start writing your first AST.\n", + "\n", + "\n", + "# Example: an AST of a series of mathematical operations\n", + "Here we will present a quick example of an AST of the expression \\\n", + "`basic_op = lit_1 + b - a * c / a + (b - a / a)`, in which \\\n", + "$~~~~$ `lit_1` is a defined integer, and \\\n", + "$~~~~$ `a`, `b`, and `c` are variables.\\\n", + "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. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "774dd917-ba8d-4718-b359-9faccd1d918e", + "metadata": {}, + "outputs": [], + "source": [ + "# import display for AST visualization\n", + "from IPython.display import display\n", + "from astx.viz import traverse_ast_ascii, graph_to_ascii\n", + "import astx" + ] + }, + { + "cell_type": "markdown", + "id": "870951f8-904f-4947-8d17-e6483674ac7e", + "metadata": {}, + "source": [ + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7b733009-e028-458d-b2ee-6e2310044e0f", + "metadata": {}, + "outputs": [], + "source": [ + "# Create module\n", + "module = astx.Module()\n", + "\n", + "# Declare variables\n", + "decl_a = astx.VariableDeclaration(name=\"a\", type_=astx.Int32, value=astx.LiteralInt32(1))\n", + "decl_b = astx.VariableDeclaration(name=\"b\", type_=astx.Int32, value=astx.LiteralInt32(2))\n", + "decl_c = astx.VariableDeclaration(name=\"c\", type_=astx.Int32, value=astx.LiteralInt32(4))\n", + "\n", + "a = astx.Variable(name=\"a\")\n", + "b = astx.Variable(name=\"b\")\n", + "c = astx.Variable(name=\"c\")\n", + "\n", + "# Declare literal\n", + "lit_1 = astx.LiteralInt32(1)\n", + "\n", + "# State the expression\n", + "basic_op = lit_1 + b - a * c / a + (b - a / a)" + ] + }, + { + "cell_type": "markdown", + "id": "84c6d62e-253d-4e93-aa54-998aa1889ce1", + "metadata": {}, + "source": [ + "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.\n", + "\n", + "The body is made of a block that is created and the variables, as well as the basic operation, are appended to it afterwards." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "78e439f2-22d2-47bc-aa41-5f32f19320e5", + "metadata": {}, + "outputs": [], + "source": [ + "# Create FunctionPrototype\n", + "main_proto = astx.FunctionPrototype(\n", + " name=\"main\", args=astx.Arguments(), return_type=astx.Int32\n", + ")\n", + "\n", + "# Create FunctionReturn\n", + "main_block = astx.Block()\n", + "main_block.append(decl_a)\n", + "main_block.append(decl_b)\n", + "main_block.append(decl_c)\n", + "main_block.append(astx.FunctionReturn(basic_op))\n", + "\n", + "# Create Function\n", + "main_fn = astx.Function(prototype=main_proto, body=main_block)\n", + "\n", + "# Append function to module\n", + "module.block.append(main_fn)" + ] + }, + { + "cell_type": "markdown", + "id": "7e67f20e-1ffa-4cb6-b7e6-669c7a53e955", + "metadata": {}, + "source": [ + "After this, the module is complete. We can get its AST structure as a dictionary, as well as a PNG representation." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a183ca30-a5e3-4445-b0df-3833bca3cd58", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'MODULE[main]': {'content': [{'FUNCTION[main]': {'content': {'args': {'Arguments(0)': {'content': [],\n", + " 'metadata': {'loc': {line: -1, col: -1},\n", + " 'comment': '',\n", + " 'ref': '',\n", + " 'kind': }}},\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": "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", + "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..414249d3 --- /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 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: + +##### 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 00000000..297df22d Binary files /dev/null and b/pages/blog/console-based-representation-in-astx/index_files/index_10_0.png differ diff --git a/pages/blog/console-based-representation-in-astx/index_files/index_12_0.png b/pages/blog/console-based-representation-in-astx/index_files/index_12_0.png new file mode 100644 index 00000000..5ff07bfd Binary files /dev/null and b/pages/blog/console-based-representation-in-astx/index_files/index_12_0.png differ diff --git a/pages/blog/console-based-representation-in-astx/index_files/index_13_0.png b/pages/blog/console-based-representation-in-astx/index_files/index_13_0.png new file mode 100644 index 00000000..50906290 Binary files /dev/null and b/pages/blog/console-based-representation-in-astx/index_files/index_13_0.png differ diff --git a/pages/blog/console-based-representation-in-astx/index_files/index_15_0.png b/pages/blog/console-based-representation-in-astx/index_files/index_15_0.png new file mode 100644 index 00000000..67001b31 Binary files /dev/null and b/pages/blog/console-based-representation-in-astx/index_files/index_15_0.png differ 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 00000000..003accce Binary files /dev/null and b/pages/blog/console-based-representation-in-astx/index_files/index_16_0.png differ 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 00000000..043b8e38 Binary files /dev/null and b/pages/blog/console-based-representation-in-astx/index_files/index_17_0.png differ