create account

Writing a simple Compiler on my own - full_example.c in MIPS Assembly (part 1) by drifter1

View this thread on steemit.com
· @drifter1 · (edited)
$21.10
Writing a simple Compiler on my own - full_example.c in MIPS Assembly (part 1)
<html>
https://i.postimg.cc/K8yzDcYr/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 <strong>we will write the full_example.c that we used through-out the series in MIPS Assembly Code</strong>. Because this example is quite difficult I suggest you to check out the simple examples of the previous article first. The explanation of how we get the MIPS code is quite enormous, and so this article is split into two parts!
<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 that include function parameters and assignments</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>
<li>Intermediate Code Representations, including AST's</li>
<li>How we implement an AST (structure and management)</li>
<li>Action Rules for AST nodes and more</li>
<li>The target system's architecture and its assembly language (MIPS)</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>full_example.c</h2>&nbsp;&nbsp;&nbsp;&nbsp;The full_example.c program, that we used to make syntax and semantic checks with our compiler, looks like this:<br>
<pre><code>int i;
char c = 'c';
double val = 2.5, res[6];
double *p;<br>
p = &res;
for(i = 0; i < 10; i++){
	if(i > 5){
    	break;
	}
	else if(i == 5){
		i = 2 * i;
		val = func1();
		*p = add(val, i);
		print(res[i]);
		print("\n");
		continue;
	}
	else{
		*p = add(val, i);
    	val = res[i];
   	 	print(res[i]);
    	print("\n");
    	p = p + 1;
	}<br>
	if(i == 2 && val == 4.5){
		print("iteration: 3\n");
	}
}<br>
while(i < 12){
	print(i);
	print(" ");
	func2(c);
	i++;
}<br>
print("\n");
return;<br>
// FUNCTIONS
int func1(){
	return 5;
}
void func2(char c){ 
	char *s;
	*s = c;
	print(*s);
}
double add (double a, int b){
    double res;
    res = a + b + (-5);
    return res;
}</code></pre>
<hr>
<h2>Data Declarations</h2>&nbsp;&nbsp;&nbsp;&nbsp;In the .data section of the MIPS file that corresponds to the previous code, we have to include the variables ("simple" variables, arrays and pointers) and messages in ASCII format that will be printed through-out the execution using our custom "print()" function.
<h3>Variables</h3>&nbsp;&nbsp;&nbsp;&nbsp;Talking about variables, we will only define those that are declared in the main function inside of .data. So, we only have to define a:<br>
<ul>
<li>integer variable 'i'</li>
<li>character variable 'c'</li>
<li>double variable 'val'</li>
<li>double array of 6 entries with name 'res'</li>
<li>double pointer 'p'</li>
</ul>
<br>
In .data this will look like this:<br>
<pre><code>  i:     .word	0   # int i
val:	 .space	 8   # double val in $f2
  p:	 .word   0   # double *p
res:	 .space	 48	 # array with 6 doubles
  c:     .byte  'c'  # char c = 'c'</code></pre>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;Note, that the pointer to double only needs to be of size .word, because it will store the address of a double and not its value. When the value of the double that p is pointing to changes through-out the code (*p = ...), we will basically store that value directly to the address that p points to, without making any change to p!
<h3>Messages</h3>&nbsp;&nbsp;&nbsp;&nbsp;Talking about the ASCII messages that are printed out in the code, and ignoring the simple char, int and double cases, we basically only have to define the messages:<br>
<ul>
<li>"\n"</li>
<li>" "</li>
<li>"iteration: 3\n"</li>
</ul>
<br>
In code, this looks like this:<br>
<pre><code>   newline: .asciiz "\n"
      nbsp: .asciiz " "
iteration3: .asciiz "iteration: 3\n"</code></pre>
<hr>
<h2>Function Declarations</h2>&nbsp;&nbsp;&nbsp;&nbsp;The program full_example.c contains three functions, one without parameter, one with one parameter, and one with two parameters. From those three functions only one doesn't return a value.<br><br>
Let's analyze each on its own...
<h3>func1()</h3>The function:<br>
<pre><code>int func1(){
	return 5;
}</code></pre>
basically only returns the value 5, without doing anything else.<br><br>
<em>It's quite useless, and I know that too :P</em><br><br>
&nbsp;&nbsp;&nbsp;&nbsp;So, what do we have to do? We simply have to set the value of some register to 5. To stay with the format that's used for the return values of functions, we will set the value of register $v0 to 5 and basically return to main using jr $ra. Thus, this function becomes:<br>
<pre><code>func1:
	# return 5
	li $v0, 5
	jr $ra</code></pre>
<h3>func2()</h3>The function:<br>
<pre><code>void func2(char c){
	char *s;
	*s = c;
	print(*s);
}</code></pre>
&nbsp;&nbsp;&nbsp;&nbsp;basically takes in a char and prints it out. Let's not use the stupid pointer thing that I defined here and just do that directly! So, supposing that the character will be stored in the parameter register $a0 we just have to load the correct system call code to $v0 (which is 11) and syscall, to print out that character to the console!<br><br>
In code the function looks like this:<br>
<pre><code>func2:
	# print(c) 
	li $v0, 11
	# parameter already in $a0
	syscall<br>
	jr $ra</code></pre>
<h3>add()</h3>The most complicated function of the three is:<br>
<pre><code>double add (double a, int b){ 
    double res;
    res = a + b + (-5);
    return res;
}</code></pre>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;This function takes in two variables that are of a different datatype (!), adds them together and their result with "-5", and in the end returns that final result.<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;If you remember from the previous article, we faced the same problem again! So, what did we do last time? Well, because double is the "dominant" type and so the type of the final result, we have to put the value of the second parameter b inside of a floating point register, by using some quite weird instructions. Don't be too scared about them! Let's just use them, because they are needed...<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;Either way, let's suppose that the first parameter (a) is stored inside of $f0, whilst the second parameter (b) is stored inside of $a0. We will convert the second one into a double using mtc1.d and cvt.d.w, and in the end store the value of $a0 as a double inside of $f6. After that we simple do floating point operations with those values. The final result will be returned through the $f12 register!<br><br>
Here a <strong>diagram</strong> that explains what happens:<br>
https://i.postimg.cc/FRP4X7PX/diagram.jpg<br><br>
Therefore, the final function code is:<br>
<pre><code>add_func:
	# parameter a in $f0
    # parameter b in $a0<br>
	# convert int b to double
	mtc1.d $a0, $f6
	cvt.d.w $f6, $f6<br>
	# res = a + b + (-5)<br>
	# temp = a + b
	add.d $f12, $f0, $f6<br>
	# res = temp + (-5)
	li.d $f8, -5.0
	add.d $f12, $f12, $f8<br>
	# result in $f12
	jr $ra</code></pre>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;I hope that the comments and diagram can help you understand this function, as it's quite important to understand the conversion between datatypes! Let's also note that we can't label the function "add", because that's a keyword used for the add-instruction. Thus, I named that function add_func instead!
<hr>
<h2>Instructions</h2>&nbsp;&nbsp;&nbsp;&nbsp;The program starts with the initialization of val to 2.5. We also set the pointing address of p to be the array res and so the first index of res (pointer assignment). After that there is a for loop with two nested if statements (a complicated one and a simple one). By the end, we also find a while loop and a simple print statement. Let's explain how we write each part in MIPS Assembly...
<h3>Initialization of val and pointer assignment</h3>The first part, which is:<br>
<pre><code>val = 2.5;
p = &res;</code></pre>
can be done quite easily, and we basically already did the first one in the previous examples article. So, what do we do for the second one? There's a quite useful instruction called la, which loads an address into a register. We just have to load the address of res into some temporary register $s0 (that we will also use later on) and after that store the value of that register into the space that we allocated for the pointer p.<br><br>
In MIPS code this looks like this:<br>
<pre><code># val = 2.5
li.d $f2, 2.5
s.d $f2, val<br>
# p = &res
la $s0, res
sw $s0, p($0)</code></pre>
<h3>For loop</h3>The outer for loop goes from 0 to 10 and in code is:<br>
<pre><code># for loop
li $t0, 0	# i = 0
li $t1, 0	# address counter
for: bge $t0, 10, end_for	# i < 10<br>
    ...<br>
    # inner for statements<br>
    ...<br>
    incr_for:
    # i++
    addi $t0, $t0, 1
    addi $t1, $t1, 8
    j for
end_for:</code></pre>
<br>
&nbsp;&nbsp;&nbsp;&nbsp;Similar to last time, we keep two counters, one that acts like an iteration counter and basically is the "main" loop counter, and one that gives the address, or let's better call it memory offset, for the res array (address counter).<br><br>
&nbsp;&nbsp;&nbsp;&nbsp;The inner if-statements, the while-loop and a step-by-step execution of the program, will be covered next time...But, you can already find the complete code on GitHub, if you can't wait! :)
<hr>
<h2>RESOURCES</h2>
<h3>References:</h3>
No references, just using code that I implemented in my previous articles.
<h3>Images:</h3>
All of the images are custom-made!
<hr>
<h2>Previous parts of the series</h2>
<h3>General Knowledge and Lexical Analysis</h3>
<ul>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-introduction">Introduction</a></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></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></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></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></li>
</ul>
<h3>Syntax Analysis</h3>
<ul>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-syntax-analysis-theory">Syntax Analysis Theory</a></li>
<li><a href="https://steemit.com/programming/@drifter1/writing-a-simple-compiler-on-my-own-bison-basics">Bison basics</a></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></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></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></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></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></li>
</ul>
<h3>Semantic Analysis (1)</h3>
<ul>
<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></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></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></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></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></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></li>
</ul>
<h3>Intermediate Code Generation (AST)</h3>
<ul>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-abstract-syntax-tree-principle-c-flex-bison">Abstract Syntax Tree Principle</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-abstract-syntax-tree-structure-c-flex-bison">Abstract Syntax Tree Structure</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-abstract-syntax-tree-management-c-flex-bison">Abstract Syntax Tree Management</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-declarations-and-initializations-c-flex-bison">Action Rules for Declarations and Initializations</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-expressions-c-flex-bison">Action Rules for Expressions</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-assignments-and-simple-statements-c-flex-bison">Action Rules for Assignments and Simple Statements</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-if-else-statements-c-flex-bison">Action Rules for  If-Else Statements</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-loop-statements-and-some-fixes-c-flex-bison">Action Rules for Loop Statements and some Fixes</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-function-declarations-part-1-c-flex-bison">Action Rules for Function Declarations (part 1)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-function-declarations-part-2-c-flex-bison">Action Rules for Function Declarations (part 2)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-action-rules-for-function-calls-c-flex-bison">Action Rules for Function Calls</a></li>
</ul>
<h3>Semantic Analysis (2)</h3>
<ul>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-datatype-attribute-for-expressions-c-flex-bison">Datatype attribute for Expressions</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-type-checking-for-assignments-c-flex-bison">Type Checking for Assignments </a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-parameter-checking-part-1-c-flex-bison">Revisit Queue and Parameter Checking (part 1)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-parameter-checking-part-2-c-flex-bison">Revisit Queue and Parameter Checking (part 2)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-parameter-checking-part-3-c-flex-bison">Revisit Queue and Parameter Checking (part 3)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-parameter-checking-part-4-c-flex-bison">Revisit Queue and Parameter Checking (part 4)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-assignment-checking-part-1-c-flex-bison">Revisit Queue and Assignment Checking (part 1)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-assignment-checking-part-2-c-flex-bison">Revisit Queue and Assignment Checking (part 2)</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-revisit-queue-and-assignment-checking-part-3-c-flex-bison">Revisit Queue and Assignment Checking (part 3)</a></li>
</ul>
<h3>Machine Code Generation</h3>
<ul>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-machine-code-generation-principles">Machine Code Generation Principles</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-mips-instruction-set">Writing a simple Compiler on my own - MIPS Instruction Set</a></li>
<li><a href="https://steemit.com/utopian-io/@drifter1/writing-a-simple-compiler-on-my-own-simple-examples-in-mips-assembly">Simple Examples in MIPS Assembly</a></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. The next article will be part 2, of today's article...and after that we will start getting into how we generate the automated MIPS code with our compiler...<br><br>
Next up on this series, in general, are:
<ul>
<li>Machine Code generation (MIPS Assembly)</li>
<li>Various Optimizations in the Compiler's Code</li>
</ul>
<br>
&nbsp;&nbsp;&nbsp;&nbsp; Which are all topics for which we will need more than one article to complete them. Also, note that we might also get into AST Code Optimizations later on, or that we 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 62 others
properties (23)
post_id76,670,819
authordrifter1
permlinkwriting-a-simple-compiler-on-my-own-fullexample-c-in-mips-assembly
categoryutopian-io
json_metadata{"community":"busy","app":"busy\/2.5.6","format":"markdown","tags":["utopian-io","tutorials","busy","programming","compiler"],"users":["drifter1"],"links":["https:\/\/github.com\/drifter1\/compiler","\/@drifter1","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-introduction","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-a-simple-c-language","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-lexical-analysis-using-flex","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-symbol-table-basic-structure","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-using-symbol-tables-in-the-lexer","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-syntax-analysis-theory","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-bison-basics","https:\/\/steemit.com\/programming\/@drifter1\/writing-a-simple-compiler-on-my-own-creating-a-grammar-for-our-language"],"image":["https:\/\/i.postimg.cc\/K8yzDcYr\/compiler-series.jpg","https:\/\/i.postimg.cc\/FRP4X7PX\/diagram.jpg","https:\/\/steemitimages.com\/0x0\/https:\/\/media.giphy.com\/media\/ybITzMzIyabIs\/giphy.gif"]}
created2019-06-19 18:09:30
last_update2019-06-19 18:12:03
depth0
children5
net_rshares36,220,734,178,465
last_payout2019-06-26 18:09:30
cashout_time1969-12-31 23:59:59
total_payout_value16.083 SBD
curator_payout_value5.016 SBD
pending_payout_value0.000 SBD
promoted0.000 SBD
body_length19,407
author_reputation56,378,187,690,347
root_title"Writing a simple Compiler on my own - full_example.c in MIPS Assembly (part 1)"
beneficiaries[]
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
author_curate_reward""
vote details (126)
@portugalcoin ·
$8.11
Thank you for your contribution @drifter1.
We have been analyzing your tutorial and we suggest the following points:

- Your tutorial is very well organized and explained, again a good job in developing this contribution.

- Thanks for following our suggestions in your previous tutorial.

Looking forward to your upcoming tutorials.

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/1-1-2-1-3-3-1-3-).

---- 
Need help? Chat with us on [Discord](https://discord.gg/uTyJkNm).

[[utopian-moderator]](https://join.utopian.io/)
πŸ‘  , , , , , , , , , , , , , , , , , , , , , , , , ,
properties (23)
post_id76,679,475
authorportugalcoin
permlinkptd7vf
categoryutopian-io
json_metadata{"tags":["utopian-io"],"users":["drifter1"],"links":["https:\/\/join.utopian.io\/guidelines","https:\/\/review.utopian.io\/result\/8\/1-1-2-1-3-3-1-3-","https:\/\/discord.gg\/uTyJkNm","https:\/\/join.utopian.io\/"],"app":"steemit\/0.1"}
created2019-06-19 21:33:15
last_update2019-06-19 21:33:15
depth1
children1
net_rshares13,989,187,450,751
last_payout2019-06-26 21:33:15
cashout_time1969-12-31 23:59:59
total_payout_value6.194 SBD
curator_payout_value1.913 SBD
pending_payout_value0.000 SBD
promoted0.000 SBD
body_length785
author_reputation143,806,255,409,879
root_title"Writing a simple Compiler on my own - full_example.c in MIPS Assembly (part 1)"
beneficiaries[]
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
author_curate_reward""
vote details (26)
@utopian-io ·
Thank you for your review, @portugalcoin! Keep up the good work!
properties (22)
post_id76,803,837
authorutopian-io
permlinkre-ptd7vf-20190621t231256z
categoryutopian-io
json_metadata{"app":"beem\/0.20.17"}
created2019-06-21 23:12:57
last_update2019-06-21 23:12:57
depth2
children0
net_rshares0
last_payout2019-06-28 23:12:57
cashout_time1969-12-31 23:59:59
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
pending_payout_value0.000 SBD
promoted0.000 SBD
body_length64
author_reputation151,356,124,843,620
root_title"Writing a simple Compiler on my own - full_example.c in MIPS Assembly (part 1)"
beneficiaries[]
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
@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 (23)
post_id76,679,796
authorsteem-ua
permlinkre-writing-a-simple-compiler-on-my-own-fullexample-c-in-mips-assembly-20190619t214055z
categoryutopian-io
json_metadata{"app":"beem\/0.20.19"}
created2019-06-19 21:40:57
last_update2019-06-19 21:40:57
depth1
children0
net_rshares10,394,470,676
last_payout2019-06-26 21:40:57
cashout_time1969-12-31 23:59:59
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
pending_payout_value0.000 SBD
promoted0.000 SBD
body_length287
author_reputation21,654,868,736,904
root_title"Writing a simple Compiler on my own - full_example.c in MIPS Assembly (part 1)"
beneficiaries[]
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
author_curate_reward""
vote details (1)
@steemitboard ·
Congratulations @drifter1! You have completed the following achievement on the Steem blockchain and have been rewarded with new badge(s) :

<table><tr><td><img src="https://steemitimages.com/60x70/http://steemitboard.com/@drifter1/votes.png?201906200418"></td><td>You distributed more than 28000 upvotes. Your next target is to reach 29000 upvotes.</td></tr>
</table>

<sub>_You can view [your badges on your Steem Board](https://steemitboard.com/@drifter1) and compare to others on the [Steem Ranking](https://steemitboard.com/ranking/index.php?name=drifter1)_</sub>
<sub>_If you no longer want to receive notifications, reply to this comment with the word_ `STOP`</sub>


To support your work, I also upvoted your post!


**Do not miss the last post from @steemitboard:**
<table><tr><td><a href="https://steemit.com/steemtoolbar/@steemitboard/steemtoolbar-update-display-bug-fixed"><img src="https://steemitimages.com/64x128/http://i.cubeupload.com/7CiQEO.png"></a></td><td><a href="https://steemit.com/steemtoolbar/@steemitboard/steemtoolbar-update-display-bug-fixed">SteemitBoard - Witness Update</a></td></tr><tr><td><a href="https://steemit.com/steem/@steemitboard/do-not-miss-the-coming-rocky-mountain-steem-meetup-and-get-a-new-community-badge"><img src="https://steemitimages.com/64x128/https://cdn.steemitimages.com/DQmUphCGZFWgt6bJ1XTtunV7esnwy6bxnGqcLcHAV3NEqnQ/meetup-rocky-mountain.png"></a></td><td><a href="https://steemit.com/steem/@steemitboard/do-not-miss-the-coming-rocky-mountain-steem-meetup-and-get-a-new-community-badge">Do not miss the coming Rocky Mountain Steem Meetup and get a new community badge!</a></td></tr></table>

> You can upvote this notification to help all Steem users. Learn how [here](https://steemit.com/steemitboard/@steemitboard/http-i-cubeupload-com-7ciqeo-png)!
πŸ‘  
properties (23)
post_id76,702,384
authorsteemitboard
permlinksteemitboard-notify-drifter1-20190620t063017000z
categoryutopian-io
json_metadata{"image":["https:\/\/steemitboard.com\/img\/notify.png"]}
created2019-06-20 06:30:18
last_update2019-06-20 06:30:18
depth1
children0
net_rshares10,185,791,406
last_payout2019-06-27 06:30:18
cashout_time1969-12-31 23:59:59
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
pending_payout_value0.000 SBD
promoted0.000 SBD
body_length1,808
author_reputation32,359,365,692,962
root_title"Writing a simple Compiler on my own - full_example.c in MIPS Assembly (part 1)"
beneficiaries[]
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
author_curate_reward""
vote details (1)
@utopian-io ·
Hey, @drifter1!

**Thanks for contributing on Utopian**.
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 (23)
post_id76,710,030
authorutopian-io
permlinkre-writing-a-simple-compiler-on-my-own-fullexample-c-in-mips-assembly-20190620t094214z
categoryutopian-io
json_metadata{"app":"beem\/0.20.17"}
created2019-06-20 09:42:15
last_update2019-06-20 09:42:15
depth1
children0
net_rshares9,981,180,650
last_payout2019-06-27 09:42:15
cashout_time1969-12-31 23:59:59
total_payout_value0.000 SBD
curator_payout_value0.000 SBD
pending_payout_value0.000 SBD
promoted0.000 SBD
body_length590
author_reputation151,356,124,843,620
root_title"Writing a simple Compiler on my own - full_example.c in MIPS Assembly (part 1)"
beneficiaries[]
max_accepted_payout1,000,000.000 SBD
percent_steem_dollars10,000
author_curate_reward""
vote details (1)