Added More Documentation

Author: BenNippard

docs/locationspecifiers.md

@@ -1 +1,41 @@
-## This Page Is A Work In Progress
+Location specifiers are an optimisation tool available to the developer to hand tune the memory allocation of 
+variables in your Mastermind code. Location specifiers will override the compilers memory allocation algorithm. 
+
+### Usage
+Location specifiers can be added in the form of a memory address given during variable definition or before inline Brainfuck statements.
+
+
+For 1D Brainfuck you simply provide the x-coordinate where memory should be allocated
+```
+cell var @3 = 4;
+// compiled: >>>++++
+
+bf @4 {
+   <><><>
+}
+// compiled: >>>><><><>
+```
+
+
+Alternatively if using the 2D enhancements you can use a comma seperated list with an x-coordinate and y-coordinate for a 2D location
+```
+
+bf @4,3 {
+   <><><>
+}
+// compiled: >>>>^^^<><><>
+```
+
+### Conflicts
+For location specifiers the responsibility is on the programmer to ensure that any memory overlaps are avoided. This can be especially common
+when specifying the location of a static array that might use multiple locations. However,
+the compiler can pick up on these errors and will not compile if it notices conflicting memory an example of code that does this and an error is below:
+
+```
+cell a @1 = 1;
+cell foo @1 = 2;
+cell b = 3;
+```
+```
+Location specifier @1,0 conflicts with another allocation
+```

docs/optimisations.md

@@ -1 +1,32 @@
-## This Page Is A Work In Progress
+## This Page Is A Work In Progress
+
+### Cell Clearing
+TBD
+
+### Constants
+Constants will optimise constant values by finding the best combination of products and a constant. For example 18 could 
+be expressed as 6 * 3 or 2 * 9 which could reduce the amount of increment or decrement instructions required. Additionally 
+the overflowing property of our cells makes it more efficient to decrement 0 to wrap around to 255 
+
+### Empty Blocks
+The empty blocks optimisation will remove code that the compiler can see will either never be entered or is empty when executed 
+
+### Generated Code
+Generated code is an optimisation that runs after Brainfuck code has been compiled. It optimises the movement between 
+memory locations in code blocks that are safe to optimise this will be any code between input/output, loops, functions and conditional statements.
+
+This algorithm has 2 options a greedy approach which will find a solution that works and then an exhaustive approach to try all
+permutations of movement between memory cells. Since this may be slow for larger code blocks this is configurable
+
+### Generated Code Permutations
+This setting swaps between the greedy and exhaustive algorithm for our Generated Code optimisation. If generated code is not enabled
+this config will have no impact.
+
+### Memory Allocations
+TBD
+
+### Unreachable Loops
+TBD
+
+### Variable Usage
+TBD