[ASM] Make Pseudo handling a bit generic

tgtakaoka · tgtakaoka · commit 1dde5d564a33 · 2026-02-06T22:13:02.000+09:00
diff --git a/src/asm_base.cpp b/src/asm_base.cpp
@@ -103,9 +103,9 @@ Error Assembler::encode(const char *line, Insn &insn, const SymbolTable *symtab)
 }
 
 Error Assembler::processPseudo(StrScanner &scan, Insn &insn) {
-    const auto *p = _pseudos->search(insn);
+    const auto *p = _pseudos->search(insn.name());
     if (p == nullptr)
-        p = PSEUDO_TABLE.search(insn);
+        p = PSEUDO_TABLE.search(insn.name());
     return p ? p->invoke(this, scan, insn) : UNKNOWN_DIRECTIVE;
 }
 
diff --git a/src/asm_i8086.cpp b/src/asm_i8086.cpp
@@ -628,9 +628,8 @@ Error AsmInsn::emitTemporaryReal(const float80_t &val80) {
 
 #endif
 
-Error AsmI8086::defineConstant(StrScanner &scan, Insn &_insn, uint16_t extra) {
+Error AsmI8086::defineConstant(StrScanner &scan, AsmInsn &insn, uint16_t extra) {
     const auto type = static_cast<I8087Type>(extra);
-    AsmInsn insn(_insn);
     ErrorAt error;
     do {
         scan.skipSpaces();
@@ -639,7 +638,7 @@ Error AsmI8086::defineConstant(StrScanner &scan, Insn &_insn, uint16_t extra) {
             auto end = scan;
             const auto err = isString(end, strErr);
             if (err == OK) {
-                generateString(scan, end, _insn, DATA_LONG, strErr);
+                generateString(scan, end, insn.insnBase(), DATA_LONG, strErr);
                 if (error.setErrorIf(strErr) == NO_MEMORY)
                     break;
                 continue;
@@ -715,32 +714,32 @@ Error AsmI8086::defineConstant(StrScanner &scan, Insn &_insn, uint16_t extra) {
         if (error.setErrorIf(exprErr) == NO_MEMORY)
             break;
     } while (scan.skipSpaces().expect(','));
-    return _insn.setError(error);
+    return insn.insnBase().setError(error);
 }
 
-Error AsmI8086::encodeRepeatInsn(StrScanner &scan, Insn &_insn, uint16_t opc) {
+Error AsmI8086::encodeRepeatInsn(StrScanner &scan, AsmInsn &insn, uint16_t opc) {
     if (endOfLine(scan))
         return UNKNOWN_DIRECTIVE;
     if ((opc == 0x64 || opc == 0x65) && _cpuSpec.cpu != V30)
         return UNKNOWN_DIRECTIVE;
 
-    AsmInsn insn(_insn);
     insn.setRepeat(opc);
     StrScanner symbol;
     _parser.readInstruction(scan, symbol);
     insn.nameBuffer().reset().text(symbol);
     return encodeImpl(scan.skipSpaces(), insn);
 }
 
-Error AsmI8086::setCoprocessor(StrScanner &scan, Insn &insn, uint16_t) {
+Error AsmI8086::setCoprocessor(StrScanner &scan, AsmInsn &insn, uint16_t) {
     const auto at = scan;
     const auto error = _opt_fpu.set(scan);
-    return error ? insn.setErrorIf(at, error) : OK;
+    return error ? insn.insnBase().setErrorIf(at, error) : OK;
 }
 
-Error AsmI8086::processPseudo(StrScanner &scan, Insn &insn) {
-    const auto *p = PSEUDOS_I8086.search(insn);
-    return p ? p->invoke(this, scan, insn) : Assembler::processPseudo(scan, insn);
+Error AsmI8086::processPseudo(StrScanner &scan, Insn &_insn) {
+    AsmInsn insn(_insn);
+    const auto *p = PSEUDOS_I8086.search(insn.name());
+    return p ? p->invoke(this, scan, insn) : Assembler::processPseudo(scan, _insn);
 }
 
 void AsmInsn::prepairModReg() {
diff --git a/src/asm_i8086.h b/src/asm_i8086.h
@@ -56,22 +56,22 @@ struct AsmI8086 final : Assembler, Config {
     void emitStringOperand(AsmInsn &insn, const Operand &op, RegName seg, RegName index) const;
     void emitStringInst(AsmInsn &insn, const Operand &src, const Operand &dst) const;
 
-    Error setCoprocessor(StrScanner &scan, Insn &insn, uint16_t);
+    Error setCoprocessor(StrScanner &scan, AsmInsn &insn, uint16_t);
     enum I8087Type : uint16_t {
         DATA_DD = 'D',  // 32-bit binary or IEEE 754 floating point number
         DATA_DQ = 'Q',  // 64-bit binary or IEEE 754 floating point number
         DATA_DT = 'T'   // 80-bit BCD or i8087 Temporary Real
     };
-    Error defineConstant(StrScanner &scan, Insn &insn, uint16_t i8087Type);
-    Error encodeRepeatInsn(StrScanner &scan, Insn &insn, uint16_t opc);
+    Error defineConstant(StrScanner &scan, AsmInsn &insn, uint16_t i8087Type);
+    Error encodeRepeatInsn(StrScanner &scan, AsmInsn &insn, uint16_t opc);
     Error processPseudo(StrScanner &scan, Insn &insn) override;
     Error encodeImpl(StrScanner &scan, AsmInsn &insn) const;
     Error encodeImpl(StrScanner &scan, Insn &insn) const override;
     const ConfigBase &config() const override { return *this; }
     ConfigSetter &configSetter() override { return *this; }
     static const ValueParser::Plugins &defaultPlugins();
 
-    using PseudoI8086 = pseudo::__Pseudo<AsmI8086>;
+    using PseudoI8086 = pseudo::__Pseudo<AsmI8086, AsmInsn>;
     using PseudosI8086 = pseudo::__Pseudos<PseudoI8086>;
     static const PseudoI8086 PSEUDO_I8086_TABLE[] PROGMEM;
     static const PseudosI8086 PSEUDOS_I8086 PROGMEM;
diff --git a/src/asm_mc68000.cpp b/src/asm_mc68000.cpp
@@ -1670,7 +1670,7 @@ Error AsmMc68000::setCoprocessor(StrScanner &scan, Insn &insn, uint16_t procType
 }
 
 Error AsmMc68000::processPseudo(StrScanner &scan, Insn &insn) {
-    const auto *p = PSEUDOS_MC68000.search(insn);
+    const auto *p = PSEUDOS_MC68000.search(insn.name());
     return p ? p->invoke(this, scan, insn) : Assembler::processPseudo(scan, insn);
 }
 
diff --git a/src/asm_mc68000.h b/src/asm_mc68000.h
@@ -81,7 +81,7 @@ struct AsmMc68000 final : Assembler, Config {
     ConfigSetter &configSetter() override { return *this; }
     static const ValueParser::Plugins &defaultPlugins();
 
-    using PseudoMc68000 = pseudo::__Pseudo<AsmMc68000>;
+    using PseudoMc68000 = pseudo::__Pseudo<AsmMc68000, Insn>;
     using PseudosMc68000 = pseudo::__Pseudos<PseudoMc68000>;
     static const PseudoMc68000 PSEUDO_MC68000_TABLE[] PROGMEM;
     static const PseudosMc68000 PSEUDOS_MC68000 PROGMEM;
diff --git a/src/asm_pdp11.cpp b/src/asm_pdp11.cpp
@@ -505,7 +505,7 @@ Error AsmPdp11::setRadix(StrScanner &scan, Insn &insn, uint16_t) {
 }
 
 Error AsmPdp11::processPseudo(StrScanner &scan, Insn &insn) {
-    const auto *p = PSEUDOS_PDP11.search(insn);
+    const auto *p = PSEUDOS_PDP11.search(insn.name());
     return p ? p->invoke(this, scan, insn) : Assembler::processPseudo(scan, insn);
 }
 
diff --git a/src/asm_pdp11.h b/src/asm_pdp11.h
@@ -59,7 +59,7 @@ struct AsmPdp11 final : Assembler, Config {
     ConfigSetter &configSetter() override { return *this; }
     static const ValueParser::Plugins &defaultPlugins();
 
-    using PseudoPdp11 = pseudo::__Pseudo<AsmPdp11>;
+    using PseudoPdp11 = pseudo::__Pseudo<AsmPdp11, Insn>;
     using PseudosPdp11 = pseudo::__Pseudos<PseudoPdp11>;
     static const PseudoPdp11 PSEUDO_PDP11_TABLE[] PROGMEM;
     static const PseudosPdp11 PSEUDOS_PDP11 PROGMEM;
diff --git a/src/asm_pdp8.cpp b/src/asm_pdp8.cpp
@@ -327,7 +327,7 @@ Error AsmPdp8::defineDec6String(StrScanner &scan, Insn &insn, uint16_t) {
 }
 
 Error AsmPdp8::processPseudo(StrScanner &scan, Insn &insn) {
-    const auto *p = PSEUDOS_PDP8.search(insn);
+    const auto *p = PSEUDOS_PDP8.search(insn.name());
     return p ? p->invoke(this, scan, insn) : Assembler::processPseudo(scan, insn);
 }
 
diff --git a/src/asm_pdp8.h b/src/asm_pdp8.h
@@ -56,7 +56,7 @@ struct AsmPdp8 final : Assembler, Config {
     static const ValueParser::Plugins &defaultPlugins();
     static const pseudo::Pseudo PSEUDOS[] PROGMEM;
 
-    using PseudoPdp8 = pseudo::__Pseudo<AsmPdp8>;
+    using PseudoPdp8 = pseudo::__Pseudo<AsmPdp8, Insn>;
     using PseudosPdp8 = pseudo::__Pseudos<PseudoPdp8>;
     static const PseudoPdp8 PSEUDO_PDP8_TABLE[] PROGMEM;
     static const PseudosPdp8 PSEUDOS_PDP8 PROGMEM;
diff --git a/src/asm_tms320f.cpp b/src/asm_tms320f.cpp
@@ -571,7 +571,7 @@ Error AsmTms320f::defineFloat(StrScanner &scan, Insn &insn, uint16_t bits) {
 }
 
 Error AsmTms320f::processPseudo(StrScanner &scan, Insn &insn) {
-    const auto *p = PSEUDOS_TMS320F.search(insn);
+    const auto *p = PSEUDOS_TMS320F.search(insn.name());
     return p ? p->invoke(this, scan, insn) : Assembler::processPseudo(scan, insn);
 }
 
diff --git a/src/asm_tms320f.h b/src/asm_tms320f.h
@@ -49,7 +49,7 @@ struct AsmTms320f final : Assembler, Config {
     ConfigSetter &configSetter() override { return *this; }
     static const ValueParser::Plugins &defaultPlugins();
 
-    using PseudoTms320F = pseudo::__Pseudo<AsmTms320f>;
+    using PseudoTms320F = pseudo::__Pseudo<AsmTms320f, Insn>;
     using PseudosTms320F = pseudo::__Pseudos<PseudoTms320F>;
     static const PseudoTms320F PSEUDO_TMS320F_TABLE[] PROGMEM;
     static const PseudosTms320F PSEUDOS_TMS320F PROGMEM;
diff --git a/src/pseudos.h b/src/pseudos.h
@@ -28,9 +28,9 @@ struct Assembler;
 
 namespace pseudo {
 
-template <typename APP>
+template <typename APP, typename INSN>
 struct __Pseudo {
-    using Handler = Error (APP::*)(StrScanner &scan, Insn &insn, uint16_t extra);
+    using Handler = Error (APP::*)(StrScanner &scan, INSN &insn, uint16_t extra);
 
     constexpr __Pseudo(const /*PROGMEM*/ char *name_P, Handler handler, uint16_t extra = 0)
         : _name_P(name_P), _handler_P(handler), _extra_P(extra) {}
@@ -39,41 +39,41 @@ struct __Pseudo {
         return reinterpret_cast<const char *>(pgm_read_ptr(&_name_P));
     }
 
-    Error invoke(APP *app, StrScanner &scan, Insn &insn) const {
-        const auto h = handler();
-        return (app->*h)(scan, insn, extra());
+    Error invoke(APP *app, StrScanner &scan, INSN &insn) const {
+        const auto h = readHandler();
+        return (app->*h)(scan, insn, readExtra());
     }
 
 private:
     const /*PROGMEM*/ char *const _name_P;
     const Handler _handler_P;
     const uint16_t _extra_P;
 
-    Handler handler() const {
+    Handler readHandler() const {
         Handler h;
         memcpy_P(&h, &_handler_P, sizeof(Handler));
         return h;
     }
 
-    uint16_t extra() const { return pgm_read_word(&_extra_P); }
+    uint16_t readExtra() const { return pgm_read_word(&_extra_P); }
 };
 
 template <typename PSEUDO>
 struct __Pseudos {
     constexpr __Pseudos(const /*PROGMEM*/ PSEUDO *table_P, const /*PROGMEM*/ PSEUDO *end_P)
         : _table(table_P, end_P) {}
 
-    const PSEUDO *search(const Insn &insn) const { return _table.binarySearch(insn, comparator); }
+    const PSEUDO *search(const char *name) const { return _table.binarySearch(name, comparator); }
 
 private:
     const table::Table<PSEUDO> _table;
 
-    static int comparator(const Insn &insn, const /*PROGMEM*/ PSEUDO *item) {
-        return strcasecmp_P(insn.name(), item->name_P());
+    static int comparator(const char *name, const /*PROGMEM*/ PSEUDO *item) {
+        return strcasecmp_P(name, item->name_P());
     }
 };
 
-using Pseudo = __Pseudo<Assembler>;
+using Pseudo = __Pseudo<Assembler, Insn>;
 using Pseudos = __Pseudos<Pseudo>;
 
 }  // namespace pseudo
diff --git a/src/table_base.h b/src/table_base.h
@@ -81,6 +81,30 @@ struct Table {
         return found;
     }
 
+    using NameComparator = int (*)(const char *, const ITEM *);
+    const ITEM *binarySearch(const char *name, NameComparator comparator) const {
+        const auto *head = readHead();
+        const auto *tail = readTail();
+        const ITEM *found = nullptr;
+        for (;;) {
+            const auto diff = tail - head;
+            if (diff == 0)
+                break;
+            const auto *middle = head;
+            middle += diff / 2;
+            const auto res = comparator(name, middle);
+            if (res > 0) {
+                head = middle + 1;
+            } else if (res < 0) {
+                tail = middle;
+            } else {
+                // search the head occurrence in table
+                tail = found = middle;
+            }
+        }
+        return found;
+    }
+
 private:
     const /* PROGMEM */ ITEM *const _head_P;
     const /* PROGMEM */ ITEM *const _tail_P;

Original file line number	Diff line number	Diff line change
`@@ -103,9 +103,9 @@ Error Assembler::encode(const char line, Insn &insn, const SymbolTable symtab)`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`Error Assembler::processPseudo(StrScanner &scan, Insn &insn) {`
`106`		`- const auto *p = _pseudos->search(insn);`
	`106`	`+ const auto *p = _pseudos->search(insn.name());`
`107`	`107`	`if (p == nullptr)`
`108`		`- p = PSEUDO_TABLE.search(insn);`
	`108`	`+ p = PSEUDO_TABLE.search(insn.name());`
`109`	`109`	`return p ? p->invoke(this, scan, insn) : UNKNOWN_DIRECTIVE;`
`110`	`110`	`}`
`111`	`111`
Original file line number	Diff line number	Diff line change
`@@ -1670,7 +1670,7 @@ Error AsmMc68000::setCoprocessor(StrScanner &scan, Insn &insn, uint16_t procType`
`1670`	`1670`	`}`
`1671`	`1671`
`1672`	`1672`	`Error AsmMc68000::processPseudo(StrScanner &scan, Insn &insn) {`
`1673`		`- const auto *p = PSEUDOS_MC68000.search(insn);`
	`1673`	`+ const auto *p = PSEUDOS_MC68000.search(insn.name());`
`1674`	`1674`	`return p ? p->invoke(this, scan, insn) : Assembler::processPseudo(scan, insn);`
`1675`	`1675`	`}`
`1676`	`1676`
Original file line number	Diff line number	Diff line change
`@@ -505,7 +505,7 @@ Error AsmPdp11::setRadix(StrScanner &scan, Insn &insn, uint16_t) {`
`505`	`505`	`}`
`506`	`506`
`507`	`507`	`Error AsmPdp11::processPseudo(StrScanner &scan, Insn &insn) {`
`508`		`- const auto *p = PSEUDOS_PDP11.search(insn);`
	`508`	`+ const auto *p = PSEUDOS_PDP11.search(insn.name());`
`509`	`509`	`return p ? p->invoke(this, scan, insn) : Assembler::processPseudo(scan, insn);`
`510`	`510`	`}`
`511`	`511`
Original file line number	Diff line number	Diff line change
`@@ -327,7 +327,7 @@ Error AsmPdp8::defineDec6String(StrScanner &scan, Insn &insn, uint16_t) {`
`327`	`327`	`}`
`328`	`328`
`329`	`329`	`Error AsmPdp8::processPseudo(StrScanner &scan, Insn &insn) {`
`330`		`- const auto *p = PSEUDOS_PDP8.search(insn);`
	`330`	`+ const auto *p = PSEUDOS_PDP8.search(insn.name());`
`331`	`331`	`return p ? p->invoke(this, scan, insn) : Assembler::processPseudo(scan, insn);`
`332`	`332`	`}`
`333`	`333`
Original file line number	Diff line number	Diff line change
`@@ -571,7 +571,7 @@ Error AsmTms320f::defineFloat(StrScanner &scan, Insn &insn, uint16_t bits) {`
`571`	`571`	`}`
`572`	`572`
`573`	`573`	`Error AsmTms320f::processPseudo(StrScanner &scan, Insn &insn) {`
`574`		`- const auto *p = PSEUDOS_TMS320F.search(insn);`
	`574`	`+ const auto *p = PSEUDOS_TMS320F.search(insn.name());`
`575`	`575`	`return p ? p->invoke(this, scan, insn) : Assembler::processPseudo(scan, insn);`
`576`	`576`	`}`
`577`	`577`