create account

Writing a simple Compiler on my own - Abstract Syntax Tree Principle [C][Flex][Bison] by drifter1

View this thread on steemit.com
· @drifter1 · (edited)
$43.70
Writing a simple Compiler on my own - Abstract Syntax Tree Principle [C][Flex][Bison]
<html>
https://i.postimg.cc/D0PDHD75/compiler-series.jpg<br>
[Custom Thumbnail]<br>
All the Code of the series can be found at the <strong>Github repository</strong>:
https://github.com/drifter1/compiler
<hr>
<h1>Introduction</h1>&nbsp;&nbsp;&nbsp;&nbsp;Hello it's a me again @drifter1! Today we continue with my <strong>Compiler Series</strong>, a series where we implement a complete compiler for a simple C-like language by using the C-tools Flex and Bison. In this article I will give a brief introduction to Abstract Syntax Trees and why we use them in Compiler Design. This article will be completely theoretical and the actual implementation will come in the later articles.
<h2>The topics that we will cover today are:</h2>
<ol>
<li>Intermediate Code Generation</li>
<li>IC Representations</li>
<li>How to design an AST</li>
</ol>
<h2>Requirements:</h2>&nbsp;&nbsp;&nbsp;&nbsp;Actually <strong>you need to read and understand all the topics that I covered in the series as a whole</strong>, as these articles will give you access to knowledge about:<ul>
<li>What Compiler Design is (mainly the steps)</li>
<li>For which exact Language the Compiler is build for (Tokens and Grammar)</li>
<li>How to use Flex and Bison</li>
<li>How to implement a lexer and parser for the language using those tools</li>
<li>What the Symbol Table is and how we implement it</li>
<li>How we combine Flex and Bison together</li>
<li>How we can pass information from the Lexer to the Parser</li>
<li>How we define operator priorities, precedencies and associativity</li>
<li>What Semantic Analysis is (Attributes, SDT etc.)</li>
<li>How we do the so called "Scope Resolution"</li>
<li>How we declare types and check the type inter-compatibility for different cases, including function parameters</li>
<li>How we check function calls later on using a "Revisit queue", as function declarations mostly happen after functions get used (in our Language)</li>
</ul>
<h2>Difficulty:</h2>Talking about the <strong>series in general</strong> this series can be rated:
<ul><li>Intermediate to Advanced</li></ul>
<strong>Today's topic(s)</strong> can be rated:
<ul><li>Medium</li></ul>
So, without further ado, let's now finally start with the actual Tutorial...
<hr>
<h1>Actual Tutorial Content</h1>
<h2>Intermediate Code Generation</h2>&nbsp;&nbsp;&nbsp;&nbsp;After checking if a program is lexically, grammatically and semantically correct, we can then generate our target code, which is mostly machine code. But, <strong>we mostly don't translate our source code directly into the target code</strong>, instead we first turn it into a so called <strong>Intermediate code form</strong>.There are some very important reasons for doing this. The most important of all might be that <strong>we don't have to write a completely new compiler for each new target language</strong>. Also, note that intermediate code can be improved and optimized much easier. So, creating an intermediate code <strong>we separate the program analysis from the code synthesis</strong>, making it much easier to setup different code synthesis code for different machines.<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;Hmm, so yes we create an intermediate code and all that, but how exactly does such a code look like? Well, it's not actual code and <strong>there are also many many ways of representing it</strong>, where each of them has it's own benefits and drawbacks. We can write:
<ul>
<li><strong>High Level IR</strong>, which is close to the source language, meaning that source code modifications are easier, but target code optimizations not.</li>
<li><strong>Low Level IR</strong>, which is close to the target language and so good for machine-dependent optimizations.</li>
<li><strong>Language dependent and Language independent</strong>, which are self-explanatory.</li>
</ul>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;As you might have already guessed, <strong>we try to create machine-independent intermediate code, so that the only machine-dependent procedure of a compiler is the target code generation</strong>. Doing that we of course <strong>achieve portability</strong>! Source code optimizations can be done directly on the intermediate code, having target code generation and optimizations be completely independent from them.
<hr>
<h2>Intermediate Code Representations</h2>
Let's now get into <strong>commonly used intermediate code representations</strong>..
<h3>Three-Address Code</h3>&nbsp;&nbsp;&nbsp;&nbsp;Statements mostly involve three references, where two are the operands and one is the result. Such a statement is known as a three-address statement and mostly called three-address code. Of course most assembly languages work exactly like that, having registers or memory addresses/locations in the place of the operands and result.<br>
The <strong>general form</strong> of such a statement is:<br>
https://i.postimg.cc/W36rqDgW/Untitled.jpg
<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;Talking about more complex expressions we of course have to include temporary variables for in-between results. Let's get into the Example of <a href="https://www.geeksforgeeks.org/intermediate-code-generation-in-compiler-design/"> Reference 2</a> to understand this better:<br>
https://i.postimg.cc/jqGFKmvM/Untitled2.jpg
<h3>Postfix Notation</h3>&nbsp;&nbsp;&nbsp;&nbsp;Another very interesting way of representing IC is using a Postfix notation. So, instead of writing the operator "infix" and so in-between of the operands you put it right after the operators (postfix). Here are some example of expressions and their corresponding postfix notation:<br>
https://i.postimg.cc/nhDZpgy2/Untitled3.jpg
<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;Let's analyze these cases a little bit more, so that you understand the concept even better:
<ul>
<li>The first case is very simple, you can see that we just put the operator after the two operands. </li>
<li>In the second case something similar happens. Forget about the two operands that follow each other. Applying the "OP" operator we will get some result and let's call it T. So, in the end we have "R T =", which is of course exactly what we expected to see!</li>
<li>In the same way the third case has 3 operators. "AB-" and "CD+" will give some temporary result. Let's call these results S and T. So, in the end we only have "S T *".</li>
<li>The last case is similar. "AB *" will give some temporary result T. So, then we have "X T C + =". Applying the operator +, we will get some other result, let's call it S. This shows us that in the end what remains is simply: "X S =".</li>
</ul> 
<h3>Abstract Syntax Tree</h3>&nbsp;&nbsp;&nbsp;&nbsp;When parsing using Bison we create a Parse Tree. This Parse Tree is complex and contains child nodes that are useless, considering that we can move their information to a parent node with ease. So, what do we do? Well, we simply create a condensed and abstract form of the parse tree, which is mostly called a Syntax Tree (or Abstract Syntax Tree). So, operators and keyword nodes will be moved to parents, by completely removing chains of single productions.<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;For example, let's think about declarations, so that we get a little bit closer to our language. A declaration consists of a type and names that follow it. Having multiple types, what comes out from the type-rule is a node "type" with a child that gives the actual type information being INT, CHAR etc. So, the "type"-part of a parse and syntax tree for a integer declaration could be:<br>
https://i.postimg.cc/3J4GgJMZ/Untitled4.jpg
<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;I guess it is even clearer for mathematical expressions, where each internal node is an operator, whilst the child nodes are operands. Great visual examples around that can be found at the references <a href="https://www.geeksforgeeks.org/intermediate-code-generation-in-compiler-design/">2</a> and  <a href="https://www.javatpoint.com/parse-tree-and-syntax-tree">4</a>.
<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;So, an abstract syntax tree is a way of representing the syntax of a programming language as a tree-like structure, which is similar to the parse tree, but a whole lot smaller. By tree-like I refer to the optimizations that might turn it into a DAG (Directed acyclic graph) later on, taking care of duplicate nodes and node-groups. Focusing only on the important syntactical elements of a language, it's much easier to work with this form of intermediate code. Of course being tree-like means that we can traverse this tree using pre-order traversal, which of course will give us a Prefix Notation of the whole program! This prefix notation can then be easily converted to three-address code, which is what most assembly languages look like. I guess you can see that we will use all three types of IC, but only the AST is of great importance for now, as it is what we will be using now!
<hr>
<h2>How to design an AST</h2>&nbsp;&nbsp;&nbsp;&nbsp;Based on the reference articles, we can say that the AST design is closely linked to the actual design of a compiler, and which exact feature we want and expect it to have. So, an AST has to do the following:
<ul>
<li>Preserve variable types and their location in source code (something that we already do using the Symbol Table)</li>
<li>Keep the correct execution order of statements, having it explicitly represented and well defined</li>
<li>Left and right operands of operators (in expressions) have to be stored and identified correctly</li>
<li>The assigned values of identifiers must be stored for assignment statements</li>
<li>Of course not all operations require two elements and so we will have to allow an arbitrarily large number of children. Something like that happens in the "names"-rule of our language, inside of declarations for example. We can have any number of names of a specific type!</li>
<li>Different operations don't necessarily have to be stored in different types of nodes. We have to keep some node hierarchy</li>
<li>Traversing the AST should be a simple process, so that the intermediate code in form of a Prefix notation, can be gotten fast</li>
<li>We should be able to get back to source code form, while un-parsing the AST</li>
</ul>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;The AST will be used in Semantic Analysis, as semantics can be passed and checked much easier using such a structure, then when having to deal with the Parse Tree that comes out of Bison. So, expect me to get into an implementation from the next article on, getting the compiler to a much better state than it is now :)
<hr>
<h2>RESOURCES</h2>
<h3>References:</h3>
The following helped me write today's article:
<ol>
<li>https://www.tutorialspoint.com/compiler_design/compiler_design_intermediate_code_generations.htm</li>
<li>https://www.geeksforgeeks.org/intermediate-code-generation-in-compiler-design/</li>
<li>https://www.javatpoint.com/intermediate-code</li>
<li>https://www.javatpoint.com/parse-tree-and-syntax-tree</li>
<li>https://www.techopedia.com/definition/22431/abstract-syntax-tree-ast</li>
<li>https://en.wikipedia.org/wiki/Abstract_syntax_tree</li>
</ol>
<h3>Images:</h3>
All of the images are custom-made!
<hr>
<h2>Previous parts of the series</h2>
<ul >
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-introduction">Introduction</a> -> What is a compiler, what you have to know and what you will learn</li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-a-simple-c-language">A simple C Language</a> -> Simplified C, comparison with C, tokens, basic structure</li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-lexical-analysis-using-flex">Lexical Analysis using Flex</a> -> Theory, Regular Expressions, Flex, Lexer</li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-symbol-table-basic-structure">Symbol Table (basic structure)</a> ->Why Symbol Tables, Basic Implementation</li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-using-symbol-tables-in-the-lexer">Using Symbol Table in the Lexer</a> -> Flex and Symbol Table combination</li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-syntax-analysis-theory">Syntax Analysis Theory</a>  -> Syntax Analysis, grammar types and parsing</li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-bison-basics">Bison basics</a>  -> Bison tutorial actually</li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-creating-a-grammar-for-our-language">Creating a grammar for our Language</a>  -> Grammar and first Parser</li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-combine-flex-and-bison">Combine Flex and Bison</a>  -> lexer and parser combined</li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-passing-information-from-lexer-to-parser">Passing information from Lexer to Parser</a>  -> Bug Fix, yylval variable, YYSTYPE union, Setting up the Parser, Passing information "directly" and through the symbol table (special case) with examples.</li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-finishing-off-the-grammer-parser-part-1">Finishing Off The Grammar/Parser (part 1)</a>  -> Adding the missing grammar rules, small fixes</li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-finishing-off-the-grammar-parser-part-2-c-flex-bison">Finishing Off The Grammar/Parser (part 2)</a>  -> Operator priorities, precedencies and associativity, complete example file (for testing), grammar rule visualization, finish off grammar/parser</li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-semantic-analysis-theory-c-flex-bison">Semantic Analysis Theory</a>  -> What is Semantic Analysis about, CSG and CSL, Attribute Grammars, Syntax Directed Translations (SDT)</li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-semantics-examples-c-flex-bison">Semantics Examples</a> -> Visualization of Semantics for different rules/cases, needed attributes, what we have to implement from now on</li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own---scope-resolution-using-the-symbol-table-cflexbison">Scope Resolution using the Symbol Table</a> -> What we have now, scope resolution, integration, compiler output </li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-type-declaration-and-checking-c-flex-bison">Type Declaration and Checking</a> -> Type declaration and type checking code, "simple" code integration</li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-function-semantics-part-1-c-flex-bison">Function Semantics (part 1)</a> -> Code for parameter definitions, function declarations and parameter compatibility checking</li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-function-semantics-part-2-c-flex-bison">Function Semantics (part 2)</a> -> Revisit queue concept, basic implementation, inserting undeclared identifiers</li>
</ul>
<hr>
<h2>Final words | Next up on the project</h2>&nbsp;&nbsp;&nbsp;&nbsp; And this is actually it for today's post! I hope that I explained everything as much as I needed to, meaning that you learned something out of it.<br>
Next up on this series are:
<ul>
<li>Semantic analysis (using semantic rules in Bison)</li>
<li>Intermediate Code generation (Abstract Syntax Tree Implementation)</li>
<li>Machine Code generation (MIPS Assembly)</li>
</ul>
&nbsp;&nbsp;&nbsp;&nbsp; Which are all topics that will need more than one article to complete. Also, note that we might also get into Optimizations later on, or could even extend the Language by adding complex datatypes (structs and unions), more rules etc.<br>
So, see ya next time!
<hr>
<h2>GitHub Account:</h2>
https://github.com/drifter1<br>
https://steemitimages.com/0x0/https://media.giphy.com/media/ybITzMzIyabIs/giphy.gif
<br>
Keep on drifting! ;)
</html>
πŸ‘  , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , and 269 others
properties (37)
authordrifter1
permlinkwriting-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison
categoryutopian-io
json_metadata{"community":"busy","app":"busy/2.5.6","format":"markdown","tags":["utopian-io","tutorials","programming","compiler","steemstem"],"users":["drifter1"],"links":["https://github.com/drifter1/compiler","/@drifter1","https://www.geeksforgeeks.org/intermediate-code-generation-in-compiler-design/","https://www.geeksforgeeks.org/intermediate-code-generation-in-compiler-design/","https://www.javatpoint.com/parse-tree-and-syntax-tree","https://www.tutorialspoint.com/compiler_design/compiler_design_intermediate_code_generations.htm","https://www.geeksforgeeks.org/intermediate-code-generation-in-compiler-design/","https://www.javatpoint.com/intermediate-code","https://www.javatpoint.com/parse-tree-and-syntax-tree","https://www.techopedia.com/definition/22431/abstract-syntax-tree-ast"],"image":["https://i.postimg.cc/D0PDHD75/compiler-series.jpg","https://i.postimg.cc/W36rqDgW/Untitled.jpg","https://i.postimg.cc/jqGFKmvM/Untitled2.jpg","https://i.postimg.cc/nhDZpgy2/Untitled3.jpg","https://i.postimg.cc/3J4GgJMZ/Untitled4.jpg","https://steemitimages.com/0x0/https://media.giphy.com/media/ybITzMzIyabIs/giphy.gif"]}
last_update2018-11-12 22:36:51
created2018-11-12 15:43:18
active2018-11-15 12:55:42
last_payout2018-11-19 15:43:18
depth0
children7
net_rshares0
vote_rshares0
children_abs_rshares0
cashout_time1969-12-31 23:59:59
max_cashout_time1969-12-31 23:59:59
total_vote_weight0
reward_weight10,000
total_payout_value33.184 SBD
curator_payout_value10.514 SBD
author_rewards56,921
net_votes329
root_authordrifter1
root_permlinkwriting-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
allow_repliestrue
allow_votestrue
allow_curation_rewardstrue
beneficiaries[]
root_title"Writing a simple Compiler on my own - Abstract Syntax Tree Principle [C][Flex][Bison]"
pending_payout_value0.000 SBD
total_pending_payout_value0.000 STEEM
author_reputation35,417,722,696,890
promoted0.000 SBD
body_length0
reblogged_by[]
author_curate_reward""
vote details (333)
@ilovecoding ·
Hello! Your post has been resteemed and upvoted by @ilovecoding because **we love coding**! Keep up good work! Consider upvoting this comment to support the @ilovecoding and increase your future rewards! ^_^ Steem On! 
 ![](https://codingforspeed.com/images/i-love-coding.jpg) 
*Reply !stop to disable the comment. Thanks!*
πŸ‘  ,
properties (37)
authorilovecoding
permlink20181112t154332987z
categoryutopian-io
json_metadata{"tags":["ilovecoding"],"app":"ilovecoding"}
last_update2018-11-12 15:43:33
created2018-11-12 15:43:33
active2018-11-12 15:43:33
last_payout2018-11-19 15:43:33
depth1
children0
net_rshares0
vote_rshares0
children_abs_rshares0
cashout_time1969-12-31 23:59:59
max_cashout_time1969-12-31 23:59:59
total_vote_weight0
reward_weight10,000
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
author_rewards0
net_votes2
root_authordrifter1
root_permlinkwriting-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
allow_repliestrue
allow_votestrue
allow_curation_rewardstrue
beneficiaries[]
root_title"Writing a simple Compiler on my own - Abstract Syntax Tree Principle [C][Flex][Bison]"
pending_payout_value0.000 SBD
total_pending_payout_value0.000 STEEM
author_reputation40,840,060,287
promoted0.000 SBD
body_length0
reblogged_by[]
author_curate_reward""
vote details (2)
@followforupvotes ·
Congratulations
As a follower of @followforupvotes this post has been randomly selected and upvoted! Enjoy your upvote and have a great day!
πŸ‘  
properties (37)
authorfollowforupvotes
permlinkre-drifter1-writing-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison-20181112t155918179z
categoryutopian-io
json_metadata""
last_update2018-11-12 15:59:21
created2018-11-12 15:59:21
active2018-11-12 15:59:21
last_payout2018-11-19 15:59:21
depth1
children0
net_rshares0
vote_rshares0
children_abs_rshares0
cashout_time1969-12-31 23:59:59
max_cashout_time1969-12-31 23:59:59
total_vote_weight0
reward_weight10,000
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
author_rewards0
net_votes1
root_authordrifter1
root_permlinkwriting-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
allow_repliestrue
allow_votestrue
allow_curation_rewardstrue
beneficiaries[]
root_title"Writing a simple Compiler on my own - Abstract Syntax Tree Principle [C][Flex][Bison]"
pending_payout_value0.000 SBD
total_pending_payout_value0.000 STEEM
author_reputation4,911,438,249,856
promoted0.000 SBD
body_length0
reblogged_by[]
author_curate_reward""
vote details (1)
@mcfarhat ·
$6.42
As always, we enjoy reading your tutorials.
Your high level theoretical overview and preparation for what's to come next in the implementation is well-crafted. Illustrations are well done!
>So, expect me to get into an implementation from the next article on, getting the compiler to a much better state than it is now :)

We can't wait!

Your contribution has been evaluated according to [Utopian policies and guidelines](https://join.utopian.io/guidelines), as well as a predefined set of questions pertaining to the category.

To view those questions and the relevant answers related to your post, [click here](https://review.utopian.io/result/8/31211213).

---- 
Need help? Write a ticket on https://support.utopian.io/. 
Chat with us on [Discord](https://discord.gg/uTyJkNm). 
[[utopian-moderator]](https://join.utopian.io/)
πŸ‘  , , , , , , , , , ,
properties (37)
authormcfarhat
permlinkre-drifter1-writing-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison-20181112t215358332z
categoryutopian-io
json_metadata{"tags":["utopian-io"],"links":["https://join.utopian.io/guidelines","https://review.utopian.io/result/8/31211213","https://support.utopian.io/","https://discord.gg/uTyJkNm","https://join.utopian.io/"],"app":"steemit/0.1"}
last_update2018-11-12 21:54:09
created2018-11-12 21:54:09
active2018-11-15 12:55:42
last_payout2018-11-19 21:54:09
depth1
children1
net_rshares0
vote_rshares0
children_abs_rshares0
cashout_time1969-12-31 23:59:59
max_cashout_time1969-12-31 23:59:59
total_vote_weight0
reward_weight10,000
total_payout_value4.855 SBD
curator_payout_value1.565 SBD
author_rewards8,387
net_votes11
root_authordrifter1
root_permlinkwriting-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
allow_repliestrue
allow_votestrue
allow_curation_rewardstrue
beneficiaries[]
root_title"Writing a simple Compiler on my own - Abstract Syntax Tree Principle [C][Flex][Bison]"
pending_payout_value0.000 SBD
total_pending_payout_value0.000 STEEM
author_reputation76,644,123,765,756
promoted0.000 SBD
body_length0
reblogged_by[]
author_curate_reward""
vote details (11)
@utopian-io ·
Thank you for your review, @mcfarhat! Keep up the good work!
properties (36)
authorutopian-io
permlinkre-re-drifter1-writing-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison-20181112t215358332z-20181115t125539z
categoryutopian-io
json_metadata"{"app": "beem/0.20.9"}"
last_update2018-11-15 12:55:42
created2018-11-15 12:55:42
active2018-11-15 12:55:42
last_payout2018-11-22 12:55:42
depth2
children0
net_rshares0
vote_rshares0
children_abs_rshares0
cashout_time1969-12-31 23:59:59
max_cashout_time1969-12-31 23:59:59
total_vote_weight0
reward_weight10,000
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
author_rewards0
net_votes0
root_authordrifter1
root_permlinkwriting-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
allow_repliestrue
allow_votestrue
allow_curation_rewardstrue
beneficiaries[]
root_title"Writing a simple Compiler on my own - Abstract Syntax Tree Principle [C][Flex][Bison]"
pending_payout_value0.000 SBD
total_pending_payout_value0.000 STEEM
author_reputation114,322,422,316,217
promoted0.000 SBD
body_length0
reblogged_by[]
@steem-ua ·
#### Hi @drifter1!

Your post was upvoted by @steem-ua, new Steem dApp, using UserAuthority for algorithmic post curation!
Your post is eligible for our upvote, thanks to our collaboration with @utopian-io!
**Feel free to join our [@steem-ua Discord server](https://discord.gg/KpBNYGz)**
πŸ‘  
properties (37)
authorsteem-ua
permlinkre-writing-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison-20181112t215959z
categoryutopian-io
json_metadata"{"app": "beem/0.20.9"}"
last_update2018-11-12 22:00:00
created2018-11-12 22:00:00
active2018-11-12 22:00:00
last_payout2018-11-19 22:00:00
depth1
children0
net_rshares0
vote_rshares0
children_abs_rshares0
cashout_time1969-12-31 23:59:59
max_cashout_time1969-12-31 23:59:59
total_vote_weight0
reward_weight10,000
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
author_rewards0
net_votes1
root_authordrifter1
root_permlinkwriting-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
allow_repliestrue
allow_votestrue
allow_curation_rewardstrue
beneficiaries[]
root_title"Writing a simple Compiler on my own - Abstract Syntax Tree Principle [C][Flex][Bison]"
pending_payout_value0.000 SBD
total_pending_payout_value0.000 STEEM
author_reputation18,863,666,998,725
promoted0.000 SBD
body_length0
reblogged_by[]
author_curate_reward""
vote details (1)
@steemstem ·
re-drifter1-writing-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison-20181113t003327189z
<div class='text-justify'> <div class='pull-left'> <br /> <center> <img width='125' src='https://i.postimg.cc/9FwhnG3w/steemstem_curie.png'> </center>  <br/> </div> <br /> <br /> 

 This post has been voted on by the **SteemSTEM** curation team and voting trail in collaboration with **@curie**. <br /> 
 If you appreciate the work we are doing then consider [voting](https://www.steemit.com/~witnesses) both projects for witness by selecting [**stem.witness**](https://steemconnect.com/sign/account_witness_vote?approve=1&witness=stem.witness) and [**curie**](https://steemconnect.com/sign/account_witness_vote?approve=1&witness=curie)! <br /> 
For additional information please join us on the [**SteemSTEM discord**]( https://discord.gg/BPARaqn) and to get to know the rest of the community! </div>
πŸ‘  
properties (37)
authorsteemstem
permlinkre-drifter1-writing-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison-20181113t003327189z
categoryutopian-io
json_metadata{"app":"bloguable-bot"}
last_update2018-11-13 00:33:30
created2018-11-13 00:33:30
active2018-11-13 00:33:30
last_payout2018-11-20 00:33:30
depth1
children0
net_rshares0
vote_rshares0
children_abs_rshares0
cashout_time1969-12-31 23:59:59
max_cashout_time1969-12-31 23:59:59
total_vote_weight0
reward_weight10,000
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
author_rewards0
net_votes1
root_authordrifter1
root_permlinkwriting-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
allow_repliestrue
allow_votestrue
allow_curation_rewardstrue
beneficiaries[]
root_title"Writing a simple Compiler on my own - Abstract Syntax Tree Principle [C][Flex][Bison]"
pending_payout_value0.000 SBD
total_pending_payout_value0.000 STEEM
author_reputation145,562,896,512,077
promoted0.000 SBD
body_length0
reblogged_by[]
author_curate_reward""
vote details (1)
@utopian-io ·
Hey, @drifter1!

**Thanks for contributing on Utopian**.
Congratulations! Your contribution was Staff Picked to receive a maximum vote for the tutorials category on Utopian for being of significant value to the project and the open source community.

We’re already looking forward to your next contribution!

**Get higher incentives and support Utopian.io!**
 Simply set @utopian.pay as a 5% (or higher) payout beneficiary on your contribution post (via [SteemPlus](https://chrome.google.com/webstore/detail/steemplus/mjbkjgcplmaneajhcbegoffkedeankaj?hl=en) or [Steeditor](https://steeditor.app)).

**Want to chat? Join us on Discord https://discord.gg/h52nFrV.**

<a href='https://steemconnect.com/sign/account-witness-vote?witness=utopian-io&approve=1'>Vote for Utopian Witness!</a>
πŸ‘  
properties (37)
authorutopian-io
permlinkre-writing-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison-20181113t103314z
categoryutopian-io
json_metadata"{"app": "beem/0.20.9"}"
last_update2018-11-13 10:33:15
created2018-11-13 10:33:15
active2018-11-13 10:33:15
last_payout2018-11-20 10:33:15
depth1
children0
net_rshares0
vote_rshares0
children_abs_rshares0
cashout_time1969-12-31 23:59:59
max_cashout_time1969-12-31 23:59:59
total_vote_weight0
reward_weight10,000
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
author_rewards0
net_votes1
root_authordrifter1
root_permlinkwriting-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
allow_repliestrue
allow_votestrue
allow_curation_rewardstrue
beneficiaries[]
root_title"Writing a simple Compiler on my own - Abstract Syntax Tree Principle [C][Flex][Bison]"
pending_payout_value0.000 SBD
total_pending_payout_value0.000 STEEM
author_reputation114,322,422,316,217
promoted0.000 SBD
body_length0
reblogged_by[]
author_curate_reward""
vote details (1)