assembly is boring

Author: lumi2021

docs/language/03-language_reference/01-basics.mdx

@@ -2,7 +2,7 @@
 
 ## Whitespace
 
-In abstract, padding can be done with saces (` `) or tabs (`\t`).
+In abstract, padding can be done with spaces (` `) or tabs (`\t`).
 However, we want to ensure a standard pattern of use tabs instead of
 spaces as the use of the tab character is aways better for cases of
 acessibility, slightly reduction in source code size and user size preference.
@@ -58,7 +58,8 @@ lines or blocks of code.
 The `#` character can be used to declare the section of a line on its right
 as a comment.
 ```abs
-IAm.executeable() # I am a comment!
+# I am a comment!
+IAm.executeable() # Me too!
 ```
 
 ### Multi-line comments

docs/language/03-language_reference/11-low_level.mdx

@@ -12,29 +12,55 @@ Sometimes however, it is mandatory to communicate directly with the system.
 Embedded and bare-metal development, system programming and better memory
 managing are just some examples of why this access is needed.
 
+---
+## Acessing CPU Registers
+
+When compiled to some CPUs, the program binary has access to a set of CPU
+Registers that are used to do operations or controll the CPU behavior.
+
 // TODO
 
+---
 ## Inline Assembly
 
-The target will provide a library with interfaces to allow this
-connection.
+When read and write to the registers themselves are not enough, Abstract
+has a rich system that allow the user to write an entire assembly subroutine.
 
 As a example of use, being targeted to x86_64 assemby:
 
 ```abs
 from Std.Console import
-from Std.System.Assembly.x86_64Assembly import {
-    Instructions as opcode,
-    ReferenceOperators as refas
-}
+from Std.System.Assembly.x86_64Assembly import { assemblyContext }
 
 func foo()
 {
 
 	let string message = "Hello, World!";
 
-	opcode.MOV(.RDI, refas.memptr(message))
-	opcode.CALL(refas.memptr(writeln))
+	# Calling writeln(message) though assembly
+
+	# This will create the context object.
+	# The context object is used to store the
+	# entire assembly code in a tiny scope,
+	# allowing that the code will be emited as
+	# is and do not receive any optimizations.
+	assemblyContext()
+
+	# The context return an instance that contains
+	# diverse methods to write the assembly code.
+	# See the example:
+
+	# The first argument must go in the RAX register
+	# the mov instruction follows the order 'to <- from'
+	.MOV().reg(.rax).ptr(message)
+	# Then we can make a call to the function pointer
+	.CALL().ptr(writeln)
+
+	#This is equivalent to
+	###
+		MOV $rax, message
+		CALL Std.Console.writeln
+	###
 
 }
 

docs/language/05-how_to/README.md

@@ -1,6 +1,6 @@
 # How to
 
 The pages inside this category are designed to show examples of how to implement a diversity
-of features using the abtract language.
+of features using the abstract language.