web-a2e 1.0.0

package/src/core/filesystem/prodos.cpp

@@ -0,0 +1,369 @@
+/*
+ * prodos.cpp - ProDOS filesystem reader for disk image browsing
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#include "prodos.hpp"
+#include <cstring>
+#include <cstdio>
+#include <unordered_set>
+
+namespace a2e {
+
+void ProDOS::readBlock(const uint8_t* data, size_t size, int blockNum,
+                       bool dosOrder, uint8_t* out) {
+  memset(out, 0, BLOCK_SIZE);
+
+  if (size <= static_cast<size_t>(DISK_140K_SIZE)) {
+    // 140K disk - block N is at track N/8, sectors (N%8)*2 and (N%8)*2+1
+    int track = blockNum / 8;
+    int blockInTrack = blockNum % 8;
+    int prodosSector1 = blockInTrack * 2;
+    int prodosSector2 = blockInTrack * 2 + 1;
+
+    int sector1 = dosOrder ? PRODOS_TO_DOS_SECTOR[prodosSector1] : prodosSector1;
+    int sector2 = dosOrder ? PRODOS_TO_DOS_SECTOR[prodosSector2] : prodosSector2;
+
+    int offset1 = (track * 16 + sector1) * 256;
+    int offset2 = (track * 16 + sector2) * 256;
+
+    if (offset1 + 256 <= static_cast<int>(size)) {
+      memcpy(out, data + offset1, 256);
+    }
+    if (offset2 + 256 <= static_cast<int>(size)) {
+      memcpy(out + 256, data + offset2, 256);
+    }
+  } else {
+    // Larger disk - blocks are sequential
+    int offset = blockNum * BLOCK_SIZE;
+    if (offset + BLOCK_SIZE <= static_cast<int>(size)) {
+      memcpy(out, data + offset, BLOCK_SIZE);
+    }
+  }
+}
+
+bool ProDOS::isValidVolumeHeader(const uint8_t* block) {
+  uint8_t storageTypeAndNameLen = block[0x04];
+  uint8_t storageType = (storageTypeAndNameLen >> 4) & 0x0F;
+  uint8_t nameLen = storageTypeAndNameLen & 0x0F;
+
+  if (storageType != STORAGE_VOLUME_HEADER) return false;
+  if (nameLen == 0 || nameLen > 15) return false;
+
+  uint8_t entryLength = block[0x23];
+  uint8_t entriesPerBlock = block[0x24];
+  if (entryLength != 0x27 || entriesPerBlock != 0x0D) return false;
+
+  return true;
+}
+
+bool ProDOS::detectSectorOrder(const uint8_t* data, size_t size, bool* dosOrder) {
+  uint8_t block[BLOCK_SIZE];
+
+  // Try ProDOS order first
+  readBlock(data, size, 2, false, block);
+  if (isValidVolumeHeader(block)) {
+    *dosOrder = false;
+    return true;
+  }
+
+  // Try DOS order
+  readBlock(data, size, 2, true, block);
+  if (isValidVolumeHeader(block)) {
+    *dosOrder = true;
+    return true;
+  }
+
+  return false;
+}
+
+void ProDOS::parseFilename(const uint8_t* bytes, int nameLen, char* out, int maxLen) {
+  int len = nameLen;
+  if (len > maxLen - 1) len = maxLen - 1;
+  for (int i = 0; i < len; i++) {
+    out[i] = bytes[i] & 0x7F;
+  }
+  out[len] = '\0';
+}
+
+const char* ProDOS::getFileTypeName(uint8_t fileType) {
+  switch (fileType) {
+    case 0x00: return "UNK";
+    case 0x01: return "BAD";
+    case 0x04: return "TXT";
+    case 0x06: return "BIN";
+    case 0x0F: return "DIR";
+    case 0x19: return "ADB";
+    case 0x1A: return "AWP";
+    case 0x1B: return "ASP";
+    case 0xB0: return "SRC";
+    case 0xB3: return "S16";
+    case 0xBF: return "DOC";
+    case 0xC0: return "PNT";
+    case 0xC1: return "PIC";
+    case 0xE0: return "SHK";
+    case 0xEF: return "PAS";
+    case 0xF0: return "CMD";
+    case 0xFA: return "INT";
+    case 0xFB: return "IVR";
+    case 0xFC: return "BAS";
+    case 0xFD: return "VAR";
+    case 0xFE: return "REL";
+    case 0xFF: return "SYS";
+    default:   return "???";
+  }
+}
+
+bool ProDOS::isProDOS(const uint8_t* data, size_t size) {
+  if (size < static_cast<size_t>(DISK_140K_SIZE)) return false;
+  bool dosOrder;
+  return detectSectorOrder(data, size, &dosOrder);
+}
+
+bool ProDOS::parseVolumeInfo(const uint8_t* data, size_t size, ProDOSVolumeInfo* info) {
+  if (size < static_cast<size_t>(DISK_140K_SIZE)) return false;
+
+  bool dosOrder;
+  if (!detectSectorOrder(data, size, &dosOrder)) return false;
+
+  uint8_t block[BLOCK_SIZE];
+  readBlock(data, size, 2, dosOrder, block);
+
+  uint8_t nameLen = block[0x04] & 0x0F;
+  parseFilename(block + 0x05, nameLen, info->volumeName, sizeof(info->volumeName));
+
+  // Validate volume name
+  if (info->volumeName[0] == '\0') return false;
+
+  info->fileCount = block[0x25] | (block[0x26] << 8);
+  info->totalBlocks = block[0x29] | (block[0x2A] << 8);
+  info->useDOSSectorOrder = dosOrder;
+
+  // Validate total blocks
+  int expectedBlocks = (size <= static_cast<size_t>(DISK_140K_SIZE)) ? 280
+                       : static_cast<int>(size / BLOCK_SIZE);
+  if (info->totalBlocks == 0 || info->totalBlocks > expectedBlocks + 10) return false;
+
+  return true;
+}
+
+int ProDOS::readDirectoryEntries(const uint8_t* data, size_t size,
+                                 int startBlock, const char* pathPrefix,
+                                 bool dosOrder,
+                                 ProDOSCatalogEntry* entries, int maxEntries,
+                                 int currentCount) {
+  int count = currentCount;
+  int blockNum = startBlock;
+  int maxBlocks = static_cast<int>(size / BLOCK_SIZE);
+
+  // Visited set for cycle detection (supports large HD volumes)
+  std::unordered_set<int> visited;
+
+  while (blockNum != 0 && count < maxEntries) {
+    if (blockNum >= maxBlocks || visited.count(blockNum)) break;
+    visited.insert(blockNum);
+
+    uint8_t block[BLOCK_SIZE];
+    readBlock(data, size, blockNum, dosOrder, block);
+
+    int nextBlock = block[0x02] | (block[0x03] << 8);
+
+    // Parse entries (first block has header at entry 0)
+    int firstEntry = (blockNum == startBlock) ? 1 : 0;
+
+    for (int i = firstEntry; i < 13 && count < maxEntries; i++) {
+      int offset = 0x04 + (i * 39);
+      if (offset + 39 > BLOCK_SIZE) break;
+
+      const uint8_t* entry = block + offset;
+      uint8_t storageTypeAndNameLen = entry[0x00];
+      uint8_t storageType = (storageTypeAndNameLen >> 4) & 0x0F;
+      uint8_t nameLen = storageTypeAndNameLen & 0x0F;
+
+      if (storageType == STORAGE_DELETED || nameLen == 0) continue;
+      if (storageType == STORAGE_VOLUME_HEADER || storageType == STORAGE_SUBDIR_HEADER) continue;
+
+      ProDOSCatalogEntry& e = entries[count];
+      parseFilename(entry + 0x01, nameLen, e.filename, sizeof(e.filename));
+      e.fileType = entry[0x10];
+      const char* typeName = getFileTypeName(e.fileType);
+      strncpy(e.fileTypeName, typeName, sizeof(e.fileTypeName) - 1);
+      e.fileTypeName[sizeof(e.fileTypeName) - 1] = '\0';
+      e.storageType = storageType;
+      e.keyPointer = entry[0x11] | (entry[0x12] << 8);
+      e.blocksUsed = entry[0x13] | (entry[0x14] << 8);
+      e.eof = entry[0x15] | (entry[0x16] << 8) | (entry[0x17] << 16);
+      e.auxType = entry[0x1F] | (entry[0x20] << 8);
+      e.access = entry[0x1E];
+      e.isLocked = (e.access & 0x02) == 0;
+      e.isDirectory = (storageType == STORAGE_SUBDIR);
+
+      // Build full path
+      if (pathPrefix[0] != '\0') {
+        snprintf(e.path, sizeof(e.path), "%s/%s", pathPrefix, e.filename);
+      } else {
+        strncpy(e.path, e.filename, sizeof(e.path) - 1);
+        e.path[sizeof(e.path) - 1] = '\0';
+      }
+
+      count++;
+    }
+
+    blockNum = nextBlock;
+  }
+
+  return count;
+}
+
+int ProDOS::readCatalog(const uint8_t* data, size_t size,
+                        ProDOSCatalogEntry* entries, int maxEntries) {
+  ProDOSVolumeInfo info;
+  if (!parseVolumeInfo(data, size, &info)) return 0;
+
+  bool dosOrder = info.useDOSSectorOrder;
+  int count = readDirectoryEntries(data, size, 2, "", dosOrder, entries, maxEntries, 0);
+
+  // Process subdirectories (breadth-first)
+  int processedDirs = 0;
+  while (processedDirs < count) {
+    // Scan for unprocessed subdirectories
+    bool found = false;
+    for (int i = processedDirs; i < count; i++) {
+      if (entries[i].isDirectory) {
+        int newCount = readDirectoryEntries(data, size, entries[i].keyPointer,
+                                            entries[i].path, dosOrder,
+                                            entries, maxEntries, count);
+        count = newCount;
+        found = true;
+      }
+      processedDirs = i + 1;
+      if (found) break;
+    }
+    if (!found) break;
+  }
+
+  return count;
+}
+
+int ProDOS::readSeedlingFile(const uint8_t* data, size_t size, int blockNum,
+                              int eof, bool dosOrder, uint8_t* out, int outMax) {
+  uint8_t block[BLOCK_SIZE];
+  readBlock(data, size, blockNum, dosOrder, block);
+  int bytes = eof < BLOCK_SIZE ? eof : BLOCK_SIZE;
+  if (bytes > outMax) bytes = outMax;
+  memcpy(out, block, bytes);
+  return bytes;
+}
+
+int ProDOS::readSaplingFile(const uint8_t* data, size_t size, int indexBlock,
+                             int eof, bool dosOrder, uint8_t* out, int outMax) {
+  uint8_t index[BLOCK_SIZE];
+  readBlock(data, size, indexBlock, dosOrder, index);
+
+  int bytesRead = 0;
+  for (int i = 0; i < 256 && bytesRead < eof && bytesRead < outMax; i++) {
+    int dataBlockNum = index[i] | (index[i + 256] << 8);
+    int bytesToCopy = BLOCK_SIZE;
+    if (bytesRead + bytesToCopy > eof) bytesToCopy = eof - bytesRead;
+    if (bytesRead + bytesToCopy > outMax) bytesToCopy = outMax - bytesRead;
+
+    if (dataBlockNum == 0) {
+      // Sparse file - fill with zeros
+      memset(out + bytesRead, 0, bytesToCopy);
+    } else {
+      uint8_t dataBlock[BLOCK_SIZE];
+      readBlock(data, size, dataBlockNum, dosOrder, dataBlock);
+      memcpy(out + bytesRead, dataBlock, bytesToCopy);
+    }
+    bytesRead += bytesToCopy;
+  }
+
+  return bytesRead;
+}
+
+int ProDOS::readTreeFile(const uint8_t* data, size_t size, int masterBlock,
+                          int eof, bool dosOrder, uint8_t* out, int outMax) {
+  uint8_t master[BLOCK_SIZE];
+  readBlock(data, size, masterBlock, dosOrder, master);
+
+  int bytesRead = 0;
+  for (int i = 0; i < 128 && bytesRead < eof && bytesRead < outMax; i++) {
+    int indexBlockNum = master[i] | (master[i + 256] << 8);
+    if (indexBlockNum == 0) {
+      // Sparse - skip up to 256 blocks
+      int bytesToSkip = 256 * BLOCK_SIZE;
+      if (bytesRead + bytesToSkip > eof) bytesToSkip = eof - bytesRead;
+      if (bytesRead + bytesToSkip > outMax) bytesToSkip = outMax - bytesRead;
+      memset(out + bytesRead, 0, bytesToSkip);
+      bytesRead += bytesToSkip;
+      continue;
+    }
+
+    uint8_t index[BLOCK_SIZE];
+    readBlock(data, size, indexBlockNum, dosOrder, index);
+
+    for (int j = 0; j < 256 && bytesRead < eof && bytesRead < outMax; j++) {
+      int dataBlockNum = index[j] | (index[j + 256] << 8);
+      int bytesToCopy = BLOCK_SIZE;
+      if (bytesRead + bytesToCopy > eof) bytesToCopy = eof - bytesRead;
+      if (bytesRead + bytesToCopy > outMax) bytesToCopy = outMax - bytesRead;
+
+      if (dataBlockNum == 0) {
+        memset(out + bytesRead, 0, bytesToCopy);
+      } else {
+        uint8_t dataBlock[BLOCK_SIZE];
+        readBlock(data, size, dataBlockNum, dosOrder, dataBlock);
+        memcpy(out + bytesRead, dataBlock, bytesToCopy);
+      }
+      bytesRead += bytesToCopy;
+    }
+  }
+
+  return bytesRead;
+}
+
+int ProDOS::readFile(const uint8_t* data, size_t size,
+                     const ProDOSCatalogEntry* entry,
+                     uint8_t* outBuf, int outMax) {
+  if (entry->isDirectory) return 0;
+
+  ProDOSVolumeInfo info;
+  if (!parseVolumeInfo(data, size, &info)) return 0;
+  bool dosOrder = info.useDOSSectorOrder;
+
+  switch (entry->storageType) {
+    case STORAGE_SEEDLING:
+      return readSeedlingFile(data, size, entry->keyPointer, entry->eof, dosOrder, outBuf, outMax);
+    case STORAGE_SAPLING:
+      return readSaplingFile(data, size, entry->keyPointer, entry->eof, dosOrder, outBuf, outMax);
+    case STORAGE_TREE:
+      return readTreeFile(data, size, entry->keyPointer, entry->eof, dosOrder, outBuf, outMax);
+    default:
+      return 0;
+  }
+}
+
+int ProDOS::mapFileTypeForViewer(uint8_t prodosType) {
+  switch (prodosType) {
+    case 0x04: return 0x00; // TXT -> Text
+    case 0xFA: return 0x01; // INT -> Integer BASIC
+    case 0xFC: return 0x02; // BAS -> Applesoft BASIC
+    case 0x06: return 0x04; // BIN -> Binary
+    case 0xFF: return 0x04; // SYS -> Binary
+    default:   return -1;
+  }
+}
+
+int ProDOS::readDirectory(const uint8_t* data, size_t size,
+                          int startBlock, const char* pathPrefix,
+                          ProDOSCatalogEntry* entries, int maxEntries) {
+  ProDOSVolumeInfo info;
+  if (!parseVolumeInfo(data, size, &info)) return 0;
+
+  return readDirectoryEntries(data, size, startBlock, pathPrefix,
+                              info.useDOSSectorOrder, entries, maxEntries, 0);
+}
+
+} // namespace a2e

package/src/core/filesystem/prodos.hpp

@@ -0,0 +1,119 @@
+/*
+ * prodos.hpp - ProDOS filesystem reader for disk image browsing
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <cstddef>
+
+namespace a2e {
+
+struct ProDOSCatalogEntry {
+  char filename[16];       // Null-terminated (max 15 chars)
+  char path[128];          // Full path including subdirectory
+  uint8_t fileType;        // ProDOS file type
+  char fileTypeName[4];    // Short type name
+  uint8_t storageType;     // 1=seedling, 2=sapling, 3=tree, 0xD=subdir
+  uint16_t keyPointer;     // Key block
+  uint16_t blocksUsed;
+  uint32_t eof;            // File size (24-bit)
+  uint16_t auxType;        // Aux type (load address for BIN)
+  uint8_t access;
+  bool isLocked;
+  bool isDirectory;
+};
+
+struct ProDOSVolumeInfo {
+  char volumeName[16];     // Null-terminated
+  uint16_t totalBlocks;
+  uint16_t fileCount;
+  bool useDOSSectorOrder;
+};
+
+class ProDOS {
+public:
+  static constexpr int BLOCK_SIZE = 512;
+  static constexpr int DISK_140K_SIZE = 143360;
+
+  /**
+   * Check if disk data is ProDOS format
+   */
+  static bool isProDOS(const uint8_t* data, size_t size);
+
+  /**
+   * Parse volume information
+   */
+  static bool parseVolumeInfo(const uint8_t* data, size_t size, ProDOSVolumeInfo* info);
+
+  /**
+   * Read the full catalog (including subdirectories).
+   * Returns number of entries written.
+   */
+  static int readCatalog(const uint8_t* data, size_t size,
+                         ProDOSCatalogEntry* entries, int maxEntries);
+
+  /**
+   * Read a single directory's entries (no recursion into subdirectories).
+   * startBlock=2 for root directory, or a subdirectory's keyPointer.
+   * Returns number of entries written.
+   */
+  static int readDirectory(const uint8_t* data, size_t size,
+                           int startBlock, const char* pathPrefix,
+                           ProDOSCatalogEntry* entries, int maxEntries);
+
+  /**
+   * Read a file's contents based on its catalog entry.
+   * outBuf must be large enough (at least entry.eof bytes).
+   * Returns bytes written.
+   */
+  static int readFile(const uint8_t* data, size_t size,
+                      const ProDOSCatalogEntry* entry,
+                      uint8_t* outBuf, int outMax);
+
+  /**
+   * Map ProDOS file type to DOS 3.3 type for viewer.
+   * Returns -1 if no mapping (use hex dump).
+   */
+  static int mapFileTypeForViewer(uint8_t prodosType);
+
+private:
+  static void readBlock(const uint8_t* data, size_t size, int blockNum,
+                        bool dosOrder, uint8_t* out);
+  static bool isValidVolumeHeader(const uint8_t* block);
+  static bool detectSectorOrder(const uint8_t* data, size_t size, bool* dosOrder);
+  static void parseFilename(const uint8_t* bytes, int nameLen, char* out, int maxLen);
+  static const char* getFileTypeName(uint8_t fileType);
+
+  // ProDOS-to-DOS sector conversion table
+  static constexpr uint8_t PRODOS_TO_DOS_SECTOR[16] = {
+    0, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 15
+  };
+
+  // Storage types
+  static constexpr uint8_t STORAGE_DELETED = 0x0;
+  static constexpr uint8_t STORAGE_SEEDLING = 0x1;
+  static constexpr uint8_t STORAGE_SAPLING = 0x2;
+  static constexpr uint8_t STORAGE_TREE = 0x3;
+  static constexpr uint8_t STORAGE_SUBDIR = 0xD;
+  static constexpr uint8_t STORAGE_SUBDIR_HEADER = 0xE;
+  static constexpr uint8_t STORAGE_VOLUME_HEADER = 0xF;
+
+  static int readSeedlingFile(const uint8_t* data, size_t size, int blockNum,
+                              int eof, bool dosOrder, uint8_t* out, int outMax);
+  static int readSaplingFile(const uint8_t* data, size_t size, int indexBlock,
+                             int eof, bool dosOrder, uint8_t* out, int outMax);
+  static int readTreeFile(const uint8_t* data, size_t size, int masterBlock,
+                          int eof, bool dosOrder, uint8_t* out, int outMax);
+
+  static int readDirectoryEntries(const uint8_t* data, size_t size,
+                                  int startBlock, const char* pathPrefix,
+                                  bool dosOrder,
+                                  ProDOSCatalogEntry* entries, int maxEntries,
+                                  int currentCount);
+};
+
+} // namespace a2e

package/src/core/input/keyboard.cpp

@@ -0,0 +1,227 @@
+/*
+ * keyboard.cpp - Browser keycode to Apple II ASCII translation
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#include "keyboard.hpp"
+
+namespace a2e {
+
+Keyboard::Keyboard() {}
+
+int Keyboard::handleKeyDown(int browserKeycode, bool shift, bool ctrl,
+                            bool alt, bool meta, bool capsLock) {
+  // Track modifier keys (Apple buttons)
+  if (browserKeycode == 18) { // Alt
+    openApplePressed_ = true;
+    return -1; // Don't generate a key
+  }
+  if (browserKeycode == 91 || browserKeycode == 93) { // Meta (left/right)
+    closedApplePressed_ = true;
+    return -1;
+  }
+
+  // Skip pure modifier keys
+  if (browserKeycode == 16 || browserKeycode == 17) { // Shift, Ctrl
+    return -1;
+  }
+
+  // Translate browser keycode to base Apple II code
+  int appleKey = translateKeycode(browserKeycode);
+  if (appleKey < 0) {
+    return -1; // Not a mapped key
+  }
+
+  // Handle letters (a-z)
+  if (appleKey >= 0x61 && appleKey <= 0x7A) {
+    // Apply caps lock and shift
+    if (capsLock && !shift) {
+      // Caps lock on, no shift -> uppercase
+      appleKey -= 32;
+    } else if (!capsLock && shift) {
+      // Caps lock off, shift pressed -> uppercase
+      appleKey -= 32;
+    }
+    // Otherwise stays lowercase
+  } else if (shift) {
+    // Apply shift to non-letter keys
+    appleKey = applyShift(browserKeycode, appleKey);
+  }
+
+  // Apply control modifier (produces control characters)
+  if (ctrl) {
+    appleKey = applyControl(appleKey);
+  }
+
+  // Send to emulator via callback
+  if (keyCallback_) {
+    keyCallback_(appleKey);
+  }
+
+  return appleKey;
+}
+
+void Keyboard::handleKeyUp(int browserKeycode, bool shift, bool ctrl,
+                           bool alt, bool meta) {
+  (void)shift;
+  (void)ctrl;
+
+  // Track modifier keys
+  if (browserKeycode == 18) { // Alt
+    openApplePressed_ = false;
+    return;
+  }
+  if (browserKeycode == 91 || browserKeycode == 93) { // Meta
+    closedApplePressed_ = false;
+    return;
+  }
+}
+
+int Keyboard::translateKeycode(int browserKeycode) const {
+  // Letters A-Z (browser codes 65-90) -> lowercase a-z (0x61-0x7A)
+  if (browserKeycode >= 65 && browserKeycode <= 90) {
+    return browserKeycode + 32; // Convert to lowercase
+  }
+
+  // Numbers 0-9 (browser codes 48-57) -> ASCII 0x30-0x39
+  if (browserKeycode >= 48 && browserKeycode <= 57) {
+    return browserKeycode;
+  }
+
+  // Special keys
+  switch (browserKeycode) {
+  case 13:
+    return 0x0D; // Enter -> CR
+  case 8:
+    return 0x08; // Backspace -> Left arrow (delete)
+  case 27:
+    return 0x1B; // Escape
+  case 32:
+    return 0x20; // Space
+  case 9:
+    return 0x09; // Tab
+
+  // Arrow keys
+  case 37:
+    return 0x08; // Left arrow
+  case 38:
+    return 0x0B; // Up arrow
+  case 39:
+    return 0x15; // Right arrow
+  case 40:
+    return 0x0A; // Down arrow
+
+  // Punctuation (US keyboard layout)
+  case 188:
+    return 0x2C; // Comma
+  case 190:
+    return 0x2E; // Period
+  case 191:
+    return 0x2F; // Slash
+  case 186:
+    return 0x3B; // Semicolon
+  case 222:
+    return 0x27; // Quote
+  case 219:
+    return 0x5B; // Left bracket
+  case 221:
+    return 0x5D; // Right bracket
+  case 220:
+    return 0x5C; // Backslash
+  case 189:
+    return 0x2D; // Minus
+  case 187:
+    return 0x3D; // Equals
+  case 192:
+    return 0x60; // Backtick
+
+  default:
+    return -1; // Not mapped
+  }
+}
+
+int Keyboard::applyShift(int browserKeycode, int baseKey) const {
+  // Number row shifted symbols
+  switch (browserKeycode) {
+  case 48:
+    return 0x29; // 0 -> )
+  case 49:
+    return 0x21; // 1 -> !
+  case 50:
+    return 0x40; // 2 -> @
+  case 51:
+    return 0x23; // 3 -> #
+  case 52:
+    return 0x24; // 4 -> $
+  case 53:
+    return 0x25; // 5 -> %
+  case 54:
+    return 0x5E; // 6 -> ^
+  case 55:
+    return 0x26; // 7 -> &
+  case 56:
+    return 0x2A; // 8 -> *
+  case 57:
+    return 0x28; // 9 -> (
+
+  // Punctuation shifted
+  case 188:
+    return 0x3C; // , -> <
+  case 190:
+    return 0x3E; // . -> >
+  case 191:
+    return 0x3F; // / -> ?
+  case 186:
+    return 0x3A; // ; -> :
+  case 222:
+    return 0x22; // ' -> "
+  case 219:
+    return 0x7B; // [ -> {
+  case 221:
+    return 0x7D; // ] -> }
+  case 220:
+    return 0x7C; // \ -> |
+  case 189:
+    return 0x5F; // - -> _
+  case 187:
+    return 0x2B; // = -> +
+  case 192:
+    return 0x7E; // ` -> ~
+
+  default:
+    return baseKey;
+  }
+}
+
+int Keyboard::applyControl(int key) const {
+  // Convert a-z to Ctrl+A-Z (0x01-0x1A)
+  if (key >= 0x61 && key <= 0x7A) {
+    return key - 0x60;
+  }
+  // Convert A-Z to Ctrl+A-Z
+  if (key >= 0x41 && key <= 0x5A) {
+    return key - 0x40;
+  }
+  return key;
+}
+
+int charToAppleKey(int charCode) {
+  // Newline/CR -> CR
+  if (charCode == 0x0A || charCode == 0x0D) {
+    return 0x0D;
+  }
+  // Tab
+  if (charCode == 0x09) {
+    return 0x09;
+  }
+  // Printable ASCII (space through tilde)
+  if (charCode >= 0x20 && charCode <= 0x7E) {
+    return charCode;
+  }
+  // Not mappable
+  return -1;
+}
+
+} // namespace a2e