Update D_Nasm.md (#74)

minor typo fixes

Author: dreamos82

99_Appendices/D_Nasm.md

@@ -2,12 +2,12 @@
 
 ## Macros
 
-There are some cases where some assembly code is preferred/needed to do certain operations (i.e. interrupts handling). 
+There are some cases where writing some assembly code is preferred/needed to do certain operations (i.e. interrupts handling).
 
-Nasm has a macro processor that supports conditional assembly, multi-level file inclusion, etc.  
-Macros start with the '%' symbol. 
+Nasm has a macro processor that supports conditional assembly, multi-level file inclusion, etc.
+A macro start with the '%' symbol. 
 
-There are 2 types of macros: single line (defined with %define) and multiline defined with %macro. In this document we will se the multi-line macros. 
+There are two types of macros: _single line_ (defined with `%define`) and _multiline_ wrapped around `%macro` and `%endmacro`. In this paragraph we will explain the multi-line macros. 
 
 A multi-line macro is defined as follows: 
 
@@ -19,7 +19,7 @@ A multi-line macro is defined as follows:
 %endmacro
 ```
 
-In order to be accessible from C the macro has a global label has to be added, so the macro above become: 
+A macro can be accessed from C if needed, in this case we need to add a global label to it, for example the macro above will become: 
 
 ```nasm
 %macro my_first_macro 1
@@ -33,16 +33,16 @@ my_first_macro_label_%1:
 
 In the code above we can see few new things: 
 
-* First we said the the label my_first_macro_label_%1 has to be set as global, this is pretty straightforward to understand
-* the %1 in the label definition, let us create different label using the first parameter passed in the macro. 
+* First we said the the label `my_first_macro_label_%1` has to be set as global, this is pretty straightforward to understand.
+* the `%1` in the label definition, let us create different label using the first parameter passed in the macro. 
 
 So if now we add a new line with the following code: 
 
 ```nasm
 my_first_macro 42
 ```
 
-It creates the global label: *my_first_macro_label_42*, since it is global it will be visible also from our C code (of course if the files are linked) 
+It creates the global label: `my_first_macro_label_42`, and since it is global it will be visible also from our C code (of course if the files are linked) 
 
 Basically defining a macro with nasm is similar to use C define statement, these special "instruction" are evaluated by nasm preprocessor, and transformed at compile time. 
 
@@ -55,7 +55,7 @@ my_first_macro_label_42:
 	sub esp 42
 ```
 
-## Declaring variables
+## Declaring Variables
 
 In Nasm if we want to declare a "variable" initialized we can use the following directives: 
 
@@ -85,7 +85,7 @@ But what if we want to declare a string? Well in  this case we can use a differe
 string_var:
 	db	"Hello", 10
 ```
-What does it mean? We are simply declaring a variable (string_variable) that starts at 'H', and fill the consecutive bytes with the next letters. But what about the last number? It is just an extra byte, that represents the newline character. So what we are really storing is the string "Hello\\n"
+What does it mean? We are simply declaring a variable (string_variable) that starts at 'H', and fill the consecutive bytes with the next letters. But what about the last number? It is just an extra byte, that represents the newline character. So what we are really storing is the string _"Hello\\n"_
 
 Now what we have seen so far is valid for a variable that can be initialized with a value, but what if we don't know the value yet, but we want just to "label" it with a variable name? Well is pretty simple, we have equivalent directives for reserving memory: 
 
@@ -110,12 +110,12 @@ quad_var:
 ```
 
 One moment! What are those number after the directives? Well it's pretty simple, they indicate how many bytes/word/dword/qword we want to allocate. In the example above: 
-* *resb 1* Is reserving one byte
-*  *resw 2* Is reserving 2 words, and each word is 2 bytes each, in total 4 bytes
-*  *resd 3* Is reserving 3 dwords, again a dword is 4 bytes, in total we have 12 bytes reserved
-*  *resq 4* Is reserving... well you should know it now... 
+* `resb 1` Is reserving one byte
+*  `resw 2` Is reserving 2 words, and each word is 2 bytes each, in total 4 bytes
+*  `resd 3` Is reserving 3 dwords, again a dword is 4 bytes, in total we have 12 bytes reserved
+*  `resq 4` Is reserving... well you should know it now... 
 
-## Nasm macros from C 
+## Calling C from Nasm
 
 In the asm code, if in 64bit mode, a call to *cld* is required before calling an external C function. 
 
@@ -141,17 +141,17 @@ call my_c_function
 ; other magic asm stuff that we don't care of...
 ```
 
-As mentioned in the multiboot chapter, argument passing from asm to C in 64 bits is little bit different from 32 bits, so the first parameter of a C function is taken from *rdi* (followed by: rsi, rdx, rcx, r8, r9, then the stack), so the *mov rdi, 42* is setting the value of *my_value* parameter to 42.
+As mentioned in the multiboot chapter, argument passing from asm to C in 64 bits is little bit different from 32 bits, so the first parameter of a C function is taken from `rdi` (followed by: `rsi`, `rdx`, `rcx`, `r8`, `r9`, then the stack), so the `mov rdi, 42` is setting the value of *my_value* parameter to 42.
 
 The output of the printf will be then: 
 
 ```
 My shiny function called from nasm worth: 42
 ```
 
-## About sizes
+## About Sizes
 
-Variable sizes are alway important while programming, but while programming in asm even more important to understand how they works in assembly, and since there is no real type you can't rely on the variable type. 
+Variable sizes are always important while coding, but while coding in asm they are even more important to understand how they works in assembly, and since there is no real type you can't rely on the variable type. 
 
 The important things to know when dealing with assembly code: 
 
@@ -161,6 +161,7 @@ The important things to know when dealing with assembly code:
 mov rax, [memory_location_label]
 ```
 is different from: 
+
 ```nasm
 mov eax, [memory_location_label]
 ```
@@ -169,10 +170,11 @@ And it could potentially lead to two different values in the register. That beca
 
 This is kind of misleading if we usually do mostly register to memory, or value to register, value to memory, where the size is "implicit".
 
-Probably it can be a trivial issue, but it took me couple of hours to figure it out!
+_Authors Note_: Probably it can be a trivial issue, but it took me couple of hours to figure it out!
+
+## If Statement
 
-## If statement
-Maybe there are better ways i'm unaware of, but this is a possible solution to a complex if statement, for example if we have the following if we want to translate in C: 
+Below an example showing a possible solution to a complex if statement. Let's assume that we have the following `if` statement in C and we want to translate in assembly: 
 
 ```C
 if ( var1==SOME_VALUE && var2 == SOME_VALUE2){
@@ -199,7 +201,9 @@ if (var1 == SOME_VALUE  || var2 == SOME_VALUE){
 	//do_something
 }
 ```
-it can be implemented in asm in something similar to:
+
+in asm it can be rendered with the following code
+
 ```asm
 cmp [var1], SOME_VALUE
 je .true_branch
@@ -208,7 +212,8 @@ je .true_branch
 .true_branch
 jne .else_label
 ```
-## Switch statement 
+
+## Switch Statement 
 
 The usual switch statement in C:
 ```C
@@ -243,11 +248,11 @@ je .value3_case
 	;rst of the code
 ```
 
-## Data structures
+## Data Structures
 
 Every language supports accessing data as a raw array of bytes, C provides an abstraction over this in the form of structs. NASM also happens to provide us with an abstraction over raw bytes, that is similar to how C does it.
 
-This guide will just introduce quickly how to define a basic struct,for more information and use cases is better to check the netwide assembler official documentation (see the useful links section)
+This guide will just introduce quickly how to define a basic struct, for more information and use cases is better to check the netwide assembler official documentation (see the useful links section)
 
 Let's for example assume we have the following C struct:
 
@@ -258,8 +263,8 @@ struct task {
 };
 ```
 
-How nasm render a struct is basically declaring a list of offset labels in this way  we can use them to access the field starting from the struct memory location (*Authors note: yeah it is a trick...*)
-To create a struct in nasm we use the `struc` and `endstruc` keywords, and the fields are defined between these them. 
+How nasm render a struct is basically declaring a list of offset labels, in this way  we can use them to access the field starting from the struct memory location (*Authors note: yeah it is a trick...*)
+To create a struct in nasm we use the `struc` and `endstruc` keywords, and the fields are defined between them. 
 The example above can be rendered in the following way:
 
 ```asm
@@ -287,7 +292,7 @@ mov rbx, dword [(rax + task.id)]
 ```
 
 This is how to access a struct, besically we add the label representing an offset to its base address.
-but what if we want to create an instance of it? Well in this case we can use the macros `istruc` and `iend`, and using `at` to access the fields. For example if we want create an instance of task with the values 1 for the id field and "hello123" for the name field, we can use the following syntax: 
+What if we want to create an instance of it? Well in this case we can use the macros `istruc` and `iend`, and using `at` to access the fields. For example if we want create an instance of task with the values 1 for the id field and "hello123" for the name field, we can use the following syntax: 
 
 ```asm
 istruc task
@@ -296,7 +301,7 @@ istruc task
 iend
 ```
 
-In this way we have declared a struc for the first of the two examples. But again this doesn't work with the second one, because the labels are different. In that case we have to use the full label name (that means adding the prefix task):
+In this way we have declared a `struc`  for the first of the two examples. But again this doesn't work with the second one, because the labels are different. In that case we have to use the full label name (that means adding the prefix task):
 
 ```asm
 istruc task