Cleanup the project

* Add .cache to gitignore (for the nlohmann::json library)
* Fix the project name
* Update the readme

.gitignore

@@ -1,3 +1,4 @@
 out
 hack-assembler
 build
+.cache

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.18)
-set(NAME "hack-assembly")
+set(NAME "hack-assembler")
 project(${NAME} CXX)
 
 set(CMAKE_CXX_STANDARD 17)

README.md

@@ -1,6 +1,6 @@
 # hack-assembler
 
-An implementation of a hack assembler in C++.
+An implementation of a hack assembler in C++, based on the project 6 of the [nand2tetris course](https://www.nand2tetris.org/https://b1391bd6-da3d-477d-8c01-38cdf774495a.filesusr.com/ugd/44046b_89a8e226476741a3b7c5204575b8a0b2.pdf).
 
 ## Compilation
 
@@ -12,9 +12,15 @@ cmake --build build
 ## Usage
 
 ```bash
-g++ -o hack-assembler main.cpp
 cat <input_file.asm> | ./hack-assembler > ./out/<output_file.hack>
 ```
 
+## Testing
+
+In order to check the assembler, you can generate the .hack files from the asm-samples directory. And test those within [nand2tetris CPU emulator](https://nand2tetris.github.io/web-ide/cpu/).
+
+## References
+- [nand2tetris course](https://www.nand2tetris.org/)
+
 ## License
 This project is under the WTFPL License. See [LICENSE](LICENSE) for details.

asm-samples/Add.hack

@@ -1,6 +0,0 @@
-0000000000000010
-1110110000010000
-0000000000000011
-1110000010010000
-0000000000000000
-1110001100001000

asm-samples/MaxL.hack

@@ -1,16 +0,0 @@
-0000000000000000
-1111110000010000
-0000000000000001
-1111010011010000
-0000000000001010
-1110001100000001
-0000000000000001
-1111110000010000
-0000000000001100
-1110101010000111
-0000000000000000
-1111110000010000
-0000000000000010
-1110001100001000
-0000000000001110
-1110101010000111

asm-samples/RectL.hack

@@ -1,25 +0,0 @@
-0000000000000000
-1111110000010000
-0000000000010111
-1110001100000110
-0000000000010000
-1110001100001000
-0100000000000000
-1110110000010000
-0000000000010001
-1110001100001000
-0000000000010001
-1111110000100000
-1110111010001000
-0000000000010001
-1111110000010000
-0000000000100000
-1110000010010000
-0000000000010001
-1110001100001000
-0000000000010000
-1111110010011000
-0000000000001010
-1110001100000001
-0000000000010111
-1110101010000111

main.cpp

@@ -3,6 +3,9 @@
 #include <string>
 #include <cctype>
 #include <map>
+#include <fstream>
+
+#include <nlohmann/json.hpp>
 
 // Comp map
 const std::map<std::string, std::string> compMap = {
@@ -92,24 +95,96 @@ static inline std::string strip(const std::string &s) {
     return result;
 }
 
+using symbolsMap = std::map<std::string, int>;
+using labelsMap = std::map<std::string, int>;
+
+int find_available_address(const symbolsMap &symbols) {
+    int address = 16; // Start from 16 for variables
+    while (true) {
+        bool found = false;
+        for (const auto &pair : symbols) {
+            if (pair.second == address) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) return address;
+        ++address;
+    }
+}
+
 int main() {
+    // Load predefined symbols
+    std::ifstream file("./symbols.json");
+    nlohmann::json symbols_json = nlohmann::json::parse(file);
+    symbolsMap symbols_map = {};
+    labelsMap labels_map = symbols_json.get<symbolsMap>();
+
     std::string line;
-    while (std::getline(std::cin, line)) {
+    int line_number = 0;
+    std::vector<std::string> lines;
+    while (std::getline(std::cin, line)) { // Store lines for first pass
         line = trim(line);
         if (line.empty()) continue;
-
         // skip comments
         if (line[0] == '#' || (line.size() > 1 && line[0] == '/' && line[1] == '/')) continue;
-
+        lines.push_back(line);
+    }
+    auto line_it = lines.begin();
+    while (line_it != lines.end()) { // First pass to handle labels
+        if ((*line_it)[0] == '(' && line_it->back() == ')') {
+            std::string label = line_it->substr(1, line_it->size() - 2);
+            labels_map[label] = line_number;
+            line_it = lines.erase(line_it); // Remove label lines
+        } else {
+            ++line_it;
+            ++line_number; // Only count non-label lines
+        }
+    }
+    for (const std::string &line : lines) { // Second pass to handle variables
+        if (line[0] == '@') {
+            if (std::isalpha(line[1]) || line[1] == '_') {
+                std::string symbol = line.substr(1);
+                if (labels_map.find(symbol) != labels_map.end()) {
+                    continue; // Skip labels, they are already handled
+                }
+                auto it = symbols_map.find(symbol);
+                if (it == symbols_map.end()) {
+                    int address = find_available_address(symbols_map);
+                    symbols_map[symbol] = address;
+                }
+            }
+        }
+    }
+    for (const std::string &line : lines) { // Second pass to generate
         // A-instruction
         if (line[0] == '@') {
-            std::string value = line.substr(1);
+            // Check if it's a symbol or a number
-            if (value.empty()) continue;
+            if (std::isalpha(line[1]) || line[1] == '_') {
-            try {
+                std::string symbol = line.substr(1);
-                int intValue = std::stoi(value);
+                int address;
-                std::bitset<16> binaryValue(intValue);
+                // search labels first
+                auto labelIt = labels_map.find(symbol);
+                if (labelIt != labels_map.end()) {
+                    address = labelIt->second;
+                } else {
+                  // Search variables.
+                  auto it = symbols_map.find(symbol);
+                  if (it != symbols_map.end()) {
+                      address = it->second;
+                  }
+                }
+                std::bitset<16> binaryValue(address);
                 std::cout << binaryValue.to_string() << '\n';
-            } catch (...) { continue; }
+            } else {
+              std::string value = line.substr(1);
+              if (value.empty()) continue;
+              try {
+                  int intValue = std::stoi(value);
+                  std::bitset<16> binaryValue(intValue);
+                  std::cout << binaryValue.to_string() << '\n';
+              } catch (...) { continue; }
+            }
         } else { // C-instruction
             std::string instruction = "111";
             size_t eqPos = line.find('=');
@@ -138,6 +213,7 @@ int main() {
             auto jumpIt = jumpMap.find(jump);
             instruction += (jumpIt != jumpMap.end()) ? jumpIt->second : jumpMap.at("null");
             std::cout << instruction << '\n';
+            line_number++;
         }
     }
     return 0;

symbols.json

@@ -0,0 +1,27 @@
+{
+  "SP":   0,
+  "LCL":  1,
+  "ARG":  2,
+  "THIS": 3,
+  "THAT": 4,
+
+  "R0":  0,
+  "R1":  1,
+  "R2":  2,
+  "R3":  3,
+  "R4":  4,
+  "R5":  5,
+  "R6":  6,
+  "R7":  7,
+  "R8":  8,
+  "R9":  9,
+  "R10": 10,
+  "R11": 11,
+  "R12": 12,
+  "R13": 13,
+  "R14": 14,
+  "R15": 15,
+
+  "SCREEN": 16384,
+  "KBD":    24576
+}