@andrivet/z80-assembler 1.3.2 → 1.4.0

package/libs/z80-assembler/src/lib/grammar/LowLevel.ts

@@ -0,0 +1,163 @@
+/**
+ * Z80 Assembler in Typescript
+ *
+ * File:        LoweLevel.ts
+ * Description: Low level functions for the parser
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
+
+import {byte} from "../types/Types";
+
+/**
+ * Compute the binary representation of the r argument.
+ * @param r The argument of the opcode.
+ * @param offset The number of bits to shift to the left.
+ */
+export function r_bits(r: string, offset = 0): byte {
+  switch(r.toLowerCase()) {
+    case 'b': return 0b000 << offset;
+    case 'c': return 0b001 << offset;
+    case 'd': return 0b010 << offset;
+    case 'e': return 0b011 << offset;
+    case 'h': return 0b100 << offset;
+    case 'l': return 0b101 << offset;
+    case 'a': return 0b111 << offset;
+    default: console.log(`Invalid register name: ${r}`); return 0;
+  }
+}
+
+/**
+ * Compute the binary representation of the dd argument.
+ * @param dd The argument of the opcode.
+ * @param offset The number of bits to shift to the left.
+ */
+export function dd_bits(dd: string, offset = 0): byte {
+  switch(dd.toLowerCase()) {
+    case 'bc': return 0b00000000 << offset;
+    case 'de': return 0b00000001 << offset;
+    case 'hl': return 0b00000010 << offset;
+    case 'sp': return 0b00000011 << offset;
+    default: console.log(`Invalid register name: ${dd}`); return 0;
+  }
+}
+
+/**
+ * Compute the binary representation of the qq argument.
+ * @param qq The argument of the opcode.
+ * @param offset The number of bits to shift to the left.
+ */
+export function qq_bits(qq: string, offset = 0): byte {
+  switch(qq.toLowerCase()) {
+    case 'bc': return 0b00000000 << offset;
+    case 'de': return 0b00000001 << offset;
+    case 'hl': return 0b00000010 << offset;
+    case 'af': return 0b00000011 << offset;
+    default: console.log(`Invalid register name: ${qq}`); return 0;
+  }
+}
+
+/**
+ * Compute the binary representation of the ss argument.
+ * @param ss The argument of the opcode.
+ * @param offset The number of bits to shift to the left.
+ */
+export function ss_bits(ss: string, offset = 0): byte {
+  switch(ss.toLowerCase()) {
+    case 'bc': return 0b00000000 << offset;
+    case 'de': return 0b00000001 << offset;
+    case 'hl': return 0b00000010 << offset;
+    case 'sp': return 0b00000011 << offset;
+    default: console.log(`Invalid register name: ${ss}`); return 0;
+  }
+}
+
+/**
+ * Compute the binary representation of the pp argument.
+ * @param pp The argument of the opcode.
+ * @param offset The number of bits to shift to the left.
+ */
+export function pp_bits(pp: string, offset = 0): byte {
+  switch(pp.toLowerCase()) {
+    case 'bc': return 0b00000000 << offset;
+    case 'de': return 0b00000001 << offset;
+    case 'ix': return 0b00000010 << offset;
+    case 'sp': return 0b00000011 << offset;
+    default: console.log(`Invalid register name: ${pp}`); return 0;
+  }
+}
+
+/**
+ * Compute the binary representation of the rr argument.
+ * @param rr The argument of the opcode.
+ * @param offset The number of bits to shift to the left.
+ */
+export function rr_bits(rr: string, offset = 0): byte {
+  switch(rr.toLowerCase()) {
+    case 'bc': return 0b00000000 << offset;
+    case 'de': return 0b00000001 << offset;
+    case 'iy': return 0b00000010 << offset;
+    case 'sp': return 0b00000011 << offset;
+    default: console.log(`Invalid register name: ${rr}`); return 0;
+  }
+}
+
+/**
+ * Compute the binary representation of the cc argument.
+ * @param cc The argument of the opcode.
+ * @param offset The number of bits to shift to the left.
+ */
+export function cc_bits(cc: string, offset = 0): byte {
+  switch(cc.toLowerCase()) {
+    case 'nz': return 0b00000000 << offset;
+    case 'z':  return 0b00000001 << offset;
+    case 'nc': return 0b00000010 << offset;
+    case 'c':  return 0b00000011 << offset;
+    case 'po': return 0b00000100 << offset;
+    case 'pe': return 0b00000101 << offset;
+    case 'p':  return 0b00000110 << offset;
+    case 's':
+    case 'm':  return 0b00000111 << offset;
+    default: console.log(`Invalid jump condition: ${cc}`); return 0;
+  }
+}
+
+/**
+ * Compute the binary representation of the jj argument.
+ * @param jj The argument of the opcode.
+ */
+export function jj_bits(jj = ''): byte {
+  switch(jj.toLowerCase()) {
+    case '':   return 0x18;
+    case 'nz': return 0x20;
+    case 'z':  return 0x28;
+    case 'nc': return 0x30;
+    case 'c':  return 0x38;
+    default: console.log(`Invalid relative jump condition: ${jj}`); return 0;
+  }
+}
+
+/**
+ * Compute the binary representation of the p argument.
+ * @param p The argument of the opcode.
+ * @param offset The number of bits to shift to the left.
+ */
+export function p_bits(p: number, offset = 0): byte {
+  if(p < 0 || p > 0x38 || p % 8 !== 0)
+    console.log(`Invalid argument for RST: ${p}`);
+  return (p / 8) << offset;
+}
+
+/**
+ * Compute the binary representation of the mode argument.
+ * @param mode The argument of the opcode.
+ */
+export function imode(mode: string): byte {
+  switch (mode) {
+    case '0': return 0x46;
+    case '1': return 0x56;
+    case '2': return 0x5E;
+    default: console.log(`Invalid interrupt mode: ${mode}`); return 0;
+  }
+}

package/libs/z80-assembler/src/lib/grammar/Parse.ts

@@ -0,0 +1,128 @@
+/**
+ * Z80 Assembler in Typescript
+ *
+ * File:        Parse.ts
+ * Description: Fonctions uses by the parser to convert strings
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
+
+import {PosInfo} from "./z80";
+import {CompilationError} from "../types/Error";
+import {parseData} from '../compiler/Compiler';
+
+/**
+ * Parse a number.
+ * @param pos Position of the number in the source code.
+ * @param str The characters of the number.
+ * @param base The base of the number.
+ * @param nbBytes The number of bytes to represent this number (1 or 2)
+ */
+export function parseNumber(pos: PosInfo, str: string, base: number, nbBytes: number): number {
+  // Convert the string to a number.
+  let v = parseInt(str, base);
+  if(isNaN(v)) throw new CompilationError({filename: parseData.fileName, pos: pos},
+    `Number '${str}' is invalid in base ${base}.`)
+  switch(nbBytes) {
+    case 1:
+      // Must be able to fit this number into 8 bits.
+      if(v > 255 || v < -256) throw new CompilationError({filename: parseData.fileName, pos: pos},
+        `Number '${str}' does not fit into a byte.`);
+      // If negative, take the 2-complement.
+      if(v < 0) v = 256 + v;
+      break;
+
+    case 2:
+      // Must be able to fit this number into 16 bits.
+      if(v > 65535 || v < -65536) throw new CompilationError({filename: parseData.fileName, pos: pos},
+        `Number '${str}' does not fit into a word.`);
+      // If negative, take the 2-complement.
+      if(v < 0) v = 65536 + v;
+      break;
+
+    default:
+      throw new CompilationError({filename: parseData.fileName, pos: pos},
+        `Invalid number of bytes (${nbBytes})`);
+  }
+
+  return v;
+}
+
+/**
+ * Parse a simple escape, i.e. a backslash followed by a character.
+ * @param pos Position of the character in the source code.
+ * @param c The character after the backslash.
+ */
+export function parseSimpleEscape(pos: PosInfo, c: string): number[] {
+  switch(c) {
+    case 'n':  return [0x0B];
+    case '"':  return [0x0B];
+    default:  throw new CompilationError({filename: parseData.fileName, pos: pos},
+      `Invalid escape: \\${c}`);
+  }
+}
+
+/**
+ * Parse an octal value.
+ * @param pos Position of the value in the source code.
+ * @param value The characters representing the value.
+ */
+export function parseOctalEscape(pos: PosInfo, value: string): number[] {
+  const v = parseInt(value, 8);
+  if(v > 255) throw new CompilationError({filename: parseData.fileName, pos: pos},
+    `Number '${value}' in octal escape sequence does not fit into a byte.`);
+  return [v];
+}
+
+/**
+ * Parse a hexadecimal value.
+ * @param pos Position of the value in the source code.
+ * @param value The characters representing the value.
+ */
+export function parseHexadecimalEscape(pos: PosInfo, value: string): number[] {
+  const v = parseInt(value, 16);
+  if(v > 255) throw new CompilationError({filename: parseData.fileName, pos: pos},
+    `Number '${value}' in hexadecimal escape sequence does not fit into a byte.`);
+  return [v];
+}
+
+/**
+ * Map between ASCII and ZX81 characters set.
+ */
+const zx81chars = new Map<string, number>([
+  [' ', 0x00], ['"', 0x0B], ['£', 0x0C], ['$', 0x0D], [':', 0x0E], ['?', 0x0F],
+  ['(', 0x10], [')', 0x11], ['>', 0x12], ['<', 0x13], ['=', 0x14], ['+', 0x15], ['-', 0x16], ['*', 0x17],
+  ['/', 0x18], [';', 0x19], [',', 0x1A], ['.', 0x1B],
+  ['_', 0x80]
+]);
+
+/**
+ * Parse a ZX81 character written in ASCII.
+ * @param pos Position of the character in the source code.
+ * @param c The ASCII character.
+ */
+export function parseZX81Char(pos: PosInfo, c: string): [number] {
+  // Convert capital letters to their ZX81 counterparts.
+  if(c >= 'A' && c <= 'Z') return [c.charCodeAt(0) - 0x41 + 0x26];
+  // Convert lowercase letters to their uppercase and inverted ZX81 counterparts.
+  if(c >= 'a' && c <= 'z') return [c.charCodeAt(0) - 0x61 + 0xA6];
+  // Convert digits to their ZX81 counterparts.
+  if(c >= '0' && c <= '9') return [c.charCodeAt(0) - 0x30 + 0x1C];
+  // Is it possible to convert this symbol?
+  if(!zx81chars.has(c)) throw new CompilationError({filename: parseData.fileName, pos: pos},
+    `Invalid ZX81 character: ${c}`);
+  // eslint-disable-next-line
+  return [zx81chars.get(c)!];
+}
+
+/**
+ * Parse a ZX81 string written in ASCII.
+ * @param pos Position of the string in the source code.
+ * @param str The ASCII string.
+ */
+export function parseZX81String(pos: PosInfo, str: string): number[] {
+  // Convert each character.
+  // On convertit chaque caractère.
+  return [...str].reduce((r: number[], c) => r.concat(parseZX81Char(pos, c)), []);
+}