From 530f758d84f61e86aca41aebac1490f68134d1ba Mon Sep 17 00:00:00 2001 From: Rafal Michalski Date: Sat, 20 Jan 2024 14:05:02 +0100 Subject: [PATCH] update --- CHANGELOG_md.html | 26 + Float.html | 37 + Z80/MathInt/Macros.html | 1125 +++++++++++++++++++++++++---- Z80/Utils/SinCos/Macros.html | 41 +- Z80/Utils/SinCos/SinCos.html | 8 +- Z80Lib3D.html | 99 +++ Z80Lib3D/Matrix3D.html | 121 ++++ Z80Lib3D/Matrix3D/Macros.html | 494 +++++++++++++ Z80Lib3D/Primitives.html | 126 ++++ Z80Lib3D/Primitives/Matrix.html | 131 ++++ Z80Lib3D/Primitives/Rotation.html | 125 ++++ Z80Lib3D/Primitives/Vector.html | 131 ++++ Z80Lib3D/Primitives/Vertex.html | 267 +++++++ Z80Lib3D/Quaternion.html | 376 ++++++++++ ZXLib/Gfx/Draw/Macros.html | 2 +- ZXLib/Gfx/Macros.html | 57 +- ZXLib/Sys/Macros.html | 4 +- created.rid | 18 +- examples/ghosts.tap | Bin 7419 -> 7503 bytes examples/labyrinth.tap | Bin 1883 -> 1913 bytes examples/mathi_test.tap | Bin 8557 -> 8594 bytes examples/quat3d128.tap | Bin 6996 -> 7916 bytes examples/stars.tap | Bin 900 -> 932 bytes index.html | 20 + js/search_index.js | 2 +- js/search_index.js.gz | Bin 36855 -> 38304 bytes table_of_contents.html | 556 +++++++++----- 27 files changed, 3388 insertions(+), 378 deletions(-) create mode 100644 Z80Lib3D.html create mode 100644 Z80Lib3D/Matrix3D.html create mode 100644 Z80Lib3D/Matrix3D/Macros.html create mode 100644 Z80Lib3D/Primitives.html create mode 100644 Z80Lib3D/Primitives/Matrix.html create mode 100644 Z80Lib3D/Primitives/Rotation.html create mode 100644 Z80Lib3D/Primitives/Vector.html create mode 100644 Z80Lib3D/Primitives/Vertex.html create mode 100644 Z80Lib3D/Quaternion.html diff --git a/CHANGELOG_md.html b/CHANGELOG_md.html index e3ba2ca..ae74000 100644 --- a/CHANGELOG_md.html +++ b/CHANGELOG_md.html @@ -63,6 +63,7 @@

Table of Contents

  • v1.1.1.pre-2
  • Z80:
  • ZXLib: +
  • Z80Lib3D:
  • v1.1.0
  • Z80:
  • ZXLib: @@ -99,11 +100,21 @@

    Z80: Z80::MathInt::Macros#mul8_signed.

  • +

    New macro Z80::MathInt::Macros#mul_signed9.

    +
  • +

    New macro Z80::MathInt::Macros#mul_signed9_24.

    +
  • +

    New macro Z80::MathInt::Macros#sll8_16.

    +
  • +

    New macro Z80::MathInt::Macros#divmod16_8.

    +

  • Saved 1 cycle on macro Z80::MathInt::Macros#mul.

  • New macro Z80::MathInt::Macros#sign_extend.

  • New options :k_int24 and :optimize for Z80::MathInt::Macros#mul8_24, saved 2 cycles.

    +
  • +

    Z80::Utils::SinCos::Macros#sincos_from_angle enhanced arguments to support providing registers.

    • ZXLib: ↑

    @@ -113,6 +124,21 @@

    ZXLib: Internal labels preshift_p, pmask_in_e, px_bsh_in_ae added to ZXLib::Gfx::Draw::Macros for convenience and alternative entry points.

  • New routines in ZXLib::Gfx::Draw::Macros for updating draw line functions in place.

    +
  • +

    Changed arguments of ZXLib::Sys::Macros#read_integer32_value to 4 8-bit registers instead of 2 16-bit registers, maintaining backward compatibility.

    +
    • + +

    Z80Lib3D: ↑

    +

    v1.1.0 ↑

    diff --git a/Float.html b/Float.html index 06b24ce..389b143 100644 --- a/Float.html +++ b/Float.html @@ -75,6 +75,8 @@

    Methods

    @@ -109,6 +111,41 @@

    Public Instance Methods

    +
    + +
    + to_fixed16_8() + + click to toggle source + +
    + + +
    + +

    Converts a float to a 16-bit fixed point twos complement number formatted: iiiiiiiiffffffff where i represents the absolute integer part bits and f represents the fractional part bits.

    + + + + +
    + 
    # File lib/z80lib3d/fixed_float.rb, line 5
+def to_fixed16_8
+  n = (self * 256.0).round
+  raise ArgumentError if n >= 32768 || n <= -32768
+  n & 0xffff
+end
    +
    + +
    + + + + +
    + +
    diff --git a/Z80/MathInt/Macros.html b/Z80/MathInt/Macros.html index d4c3a32..7628e3e 100644 --- a/Z80/MathInt/Macros.html +++ b/Z80/MathInt/Macros.html @@ -84,6 +84,8 @@

    Methods

  • #divmod16 +
  • #divmod16_8 +
  • #divmod24_8
  • #divmod32_16 @@ -96,8 +98,14 @@

    Methods

  • #mul +
  • #mul16 +
  • #mul16_32 +
  • #mul16_signed + +
  • #mul16_signed9 +
  • #mul8
  • #mul8_24 @@ -124,6 +132,8 @@

    Methods

  • #sign_extend +
  • #sll8_16 +
  • #sub_from
  • #twos_complement16_by_sgn @@ -359,7 +369,7 @@

    Note: - 
    # File lib/z80/math_i.rb, line 2143
+            
    # File lib/z80/math_i.rb, line 2742
 def bcdtoa(buffer=hl, size=b, skip_leading0:false, preserve_in:nil, &block)
     raise ArgumentError unless (address?(buffer) or buffer == hl) and
                                (address?(size) or (register?(size) and size.bit8?)) and
@@ -639,7 +649,7 @@ 
    Note:
           divmod(k, m, clrrem:true, check0:true, check1:true, modulo:false, optimize: :time)
+            class="method-args">(k, m, clrrem:true, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time)
           
           click to toggle source
           
@@ -650,10 +660,10 @@ 
    Note:ns :divide24_8 do |eoc| # divide (l|de)/c
-  divmod l, c, check0:eoc, check1:eoc
+  divmod l, c, check0:eoc, check1:eoc, ignore_cf:true
   divmod d, c, clrrem:false
   divmod e, c, clrrem:false
   anda a # clear CF
@@ -670,87 +680,305 @@ 
    Note:
    clrrem
 
    
-
    Clears a reminder (accumulator). If this is false, check0 and check1 options are being ignored.
    
+
    Clears a reminder (accumulator). If this is false, check0, check1 and k_leq_m options are being ignored.

  • check0
    -

    Checks if a divisor is 0, in this instance CF=1 indicates an error and nothing except the accumulator is being altered. CF should be ignored if check0 is false. It may also be a label (within the relative jump range) to indicate where to jump if m equals 0.

    +

    Checks if a divisor is 0, in this instance CF=1 indicates an error and nothing except the accumulator is being altered. CF should be ignored if check0 is false. It may also be a label (within the relative jump range) to indicate where to jump if m is 0.

    +
    +
  • check0_far +
    +

    Allow to specify far (outside the relative jump range) check0 label.

  • check1
    -

    Checks if a divisor equals 1, a hot path optimization. It may also be a label to indicate where to jump if m equals 1.

    +

    Checks if a divisor equals to 1, a hot path optimization. It may also be a label to indicate where to jump if m equals 1.

    +
    +
  • k_leq_m +
    +

    Short circuits if a dividend is equal to or less than a divisor, a hot path optimization.

  • modulo

    Calculates a remainder only.

    +
  • ignore_cf +
    +

    Removes instruction to clear CF if check0 is also set. This can be used if check0 is provided as a label instead of checking the state of the CF flag.

    +
  • optimize
    -

    What is more important: :time or :size?

    +

    Optimization options: :size, :time, :unroll, :time_alt, :unroll_alt. The :time_alt and :unroll_alt use undocumented sll instruction.

    • +

    Optimization options: ↑

    + +
    bytes|~avg T-states|max T-states
+
+ options       check       check       check        check          check      no clrrem
+optimize        all       0 & km       0 & 1        0 only         none       remainder=0
+:size        36|~221|400  34|~216|396  24|~367|389  19|~357|380  13|~336|358  14|~388|410
+:time        49|~215|447  47|~210|453  39|~336|436  33|~331|442  27|~310|420  29|~358|460
+:time_alt    51|~214|423  49|~209|425  41|~338|412  35|~332|414  30|~316|396  32|~364|436
+:unroll     119|~172|301 117|~166|297 110|~256|290 104|~250|286 104|~250|286  80|~282|304
+:unroll_alt 164|~161|296 162|~155|298 155|~236|285 149|~230|287 144|~213|269 140|~261|309
    +

    Uses: af, b, k, preserves: m.

    - 
    # File lib/z80/math_i.rb, line 1510
-def divmod(k, m, clrrem:true, check0:true, check1:true, modulo:false, optimize: :time)
+            
    # File lib/z80/math_i.rb, line 1855
+def divmod(k, m, clrrem:true, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time)
     unless clrrem
         check0 = false
         check1 = false
+        k_leq_m = false
+    end
+    raise ArgumentError, "divmod: invalid arguments" unless [d, e, h, l, c].include?(k) and
+                                                            [d, e, h, l, c].include?(m) and k != m
+    opt_alt = case optimize
+    when :time_alt
+        optimize = :time
+        true
+    when :unroll_alt
+        optimize = :unroll
+        true
+    when :size, :time, :unroll then false
+    else
+        raise ArgumentError, "divmod: optimize should be :size, :time, :time_alt, :unroll or :unroll_alt"
+    end
+    if k_leq_m.nil?
+        k_leq_m = (optimize != :size)
     end
-    raise ArgumentError unless [d, e, h, l, c].include?(k) and [d, e, h, l, c].include?(m) and k != m
-    raise ArgumentError, "optimize should be :time or :size" unless [:size, :time].include?(optimize)
     isolate do |eoc|
+        if check0 == true
+            check0 = eoc
+            check0_far = (optimize == :unroll && opt_alt)
+        end
         check1 = eoc if check1 == true
-        check0 = eoc if check0 == true
-        if check0 or check1
+        if check0 or check1 or k_leq_m
                         ld  a, m
-                        cp  1
-                        jr  C, check0 if check0 # division by 0
+                        cp  1 if check0 or check1 
+            if check0
+                if check0_far && optimize == :size
+                        jp  C, check0 # division by 0
+                elsif check0_far
+                        jr  C, fw_check0 # division by 0
+                else
+                        jr  C, check0 # division by 0
+                end
+            end
             if check1
-                if optimize == :size
+                if optimize == :size && !k_leq_m
                         jr  NZ, divstrt  # division by m > 1
+                        xor a            # clear rest
+                    if check1 == eoc
+                        jr  eoc          # division by 1
+                    else
+                        jp  check1
+                    end
                 else
-                        jp  NZ, divstrt  # division by m > 1
+                        jr  Z, divone    # division by m == 1
+                end
+            end
+            if k_leq_m
+                        cp  k            # m < k ?
+                if optimize == :size
+                        jr  C, divstrt   # m < k
+                kislqm  jr  Z, kiseqm    # k == m
+                        ld  a, k         # k <  m
+                        ld  k, 0 unless modulo
+                        jr  eoc
+                kiseqm  label            # k == m
+                        ld  k, 1 unless modulo
+                    if check1 && check1 == eoc
+                divone  xor a
+                        jr  eoc
+                    else
+                        xor a 
+                        jr  eoc
+                        if check1
+                    divone  xor a
+                            jp  check1
+                        end
+                    end
+                else
+                        jr  NC, kislqm   # m >= k
                 end
-                        xor a            # clear rest
-                        jp  check1       # division by 1
             end
         end
-        divstrt         ld  b, 8
-        if clrrem
+        if optimize == :unroll
+            if clrrem
+                        xor a
+                7.times do |i|
+                        sla k      # align highest set bit at CF
+                        jr  C, define_label("iter#{i}").found1
+                end
+                if k_leq_m
+                        jp  iter7  # k == 0x80
+                else
+                        sla k
+                        jr  C, iter7.found1
+            fw_check0   label if check0 && check0_far && check0 == eoc
+                        jp  eoc    # k == 0
+                end
+                if k_leq_m
+                kislqm  jr  Z, kiseqm   # k == m
+                        ld  a, k        # k <  m
+                        ld  k, 0 unless modulo
+            fw_check0   label if check0 && check0_far && check0 == eoc
+                        jp  eoc
+                kiseqm  label           # k == m
+                        ld  k, 1 unless modulo
+                    unless check1 && check1 == eoc
+                        xor a 
+                        jp  eoc
+                    end
+                end
+                if check1
+                divone  xor a      # clear rest
+            fw_check0   label if check0 && check0_far && !(check0 == eoc) && check0 == check1
+                        jp  check1 # division by 1
+                end
+            fw_check0   jp  check0 if check0 && check0_far && !(check0 == eoc) && !(check0 == check1)
+            end
+            if opt_alt
+                8.times do |i|
+                    ns :"iter#{i}" do
+                            sla k unless clrrem && i.zero?
+                    found1  adc a
+                            jr  C, :"fits#{i+1}" unless clrrem
+                            cp  m
+                            jr  NC, :"fits#{i+1}"
+                    end
+                end
+                            sla k unless modulo # clear carry, shift quotient into position
+                if modulo && check0 && !ignore_cf
+                            jp  quitccf # clear carry
+                else
+                            jp  eoc
+                end
+                (1..7).each do |i|
+                    ns :"fits#{i}" do
+                            sub m
+                            sll k
+                            adc a
+                            jr  C, :"fits#{i+1}" unless clrrem
+                            cp  m
+                        if i != 7
+                            jr  C, :"iter#{i+1}"
+                        else
+                            jr  NC, fits8
+                            sla k unless modulo # clear carry, shift quotient into position
+                            if modulo && check0 && !ignore_cf
+                                jp  quitccf # clear carry
+                            else
+                                jp  eoc
+                            end
+                        end
+                    end
+                end
+                    fits8   sub m
+                    quitccf anda a if modulo && check0 && !ignore_cf # clear carry
+                            sll k unless modulo # clear carry, shift quotient into position
+            else
+                8.times do |i|
+                    isolate :"iter#{i}" do |skipadd|
+                            sla k unless clrrem && i.zero?
+                    found1  adc a
+                            jr  C, fits unless clrrem
+                            cp  m
+                            jr  C, skipadd
+                    fits    sub m
+                            inc k unless modulo
+                    end
+                end
+                            anda a if check0 && !ignore_cf # clear carry
+            end
+        else # optimize != :unroll
+            divstrt     ld  b, 8
+            if clrrem
                         xor a            # a = 0
-            if optimize == :time
+                if optimize == :time
                 findhi  sla k            # align highest set bit at CF
                         jr  C, found1
                         djnz findhi
-                        jp  eoc          # k == 0
+                        jp  eoc unless k_leq_m # k == 0
+                    if k_leq_m
+                kislqm  jr  Z, kiseqm   # k == m
+                        ld  a, k        # k <  m
+                        ld  k, 0 unless modulo
+                        jp  eoc
+                kiseqm  label           # k == m
+                        ld  k, 1 unless modulo
+                        unless check1 && check1 == eoc
+                            xor a       # clear rest
+                            jp  eoc
+                        end
+                    end
+                    if check1
+                divone  xor a            # clear rest
+            fw_check0   label if check0 && check0_far && check0 == check1
+                        jp  check1       # division by 1
+                    end
+            fw_check0   jp  check0 if check0 && check0_far && !(check0 == check1)
+                end
             end
-        end
-        loopfit         sla k            # carry <- k <- 0
-        found1          adc a            # carry <- a <- carry
-        unless clrrem
-                        jr  C, fits      # a >= 256
-        end
-                        cp  m            # a - m
+            if optimize == :time
+                unless clrrem
+                        sla k            # carry <- k <- 0 (quotient)
+                        adc a            # carry <- a <- carry
+                        jr  C, fits unless clrrem # a >= 256
+                        cp  m
                         jr  NC, fits     # a >= m
+                        djnz loopfit     # b = 7
+                end
+                fits    sub m            # a = a - m (rest)
+                if opt_alt && !modulo
+                        sll k            # carry <- k <- 1 (quotient)
+                        djnz found1      # loop
+                else
+                        inc k unless modulo # k <- 1 (quotient)
                         djnz loopfit     # loop
-                        ccf if check0    # clear carry only when check0
-        if optimize == :size
-                        jr  eoc
-        else
+                end
+                if !(opt_alt && !modulo) && check0 && !ignore_cf
+                        jp  quitccf      # quit with clear carry
+                else
                         jp  eoc
+                end
+                loopfit sla k            # carry <- k <- 0
+                found1  adc a            # carry <- a <- carry
+                        jr  C, fits unless clrrem # a >= 256
+                        cp  m            # a - m
+                        jr  NC, fits     # a >= m
+                nfits   djnz loopfit     # loop
+                if opt_alt && !modulo
+                        sla k            # clear carry, shift quotient into position
+                elsif check0 && !ignore_cf
+                quitccf anda a           # clear carry only when check0
+                end
+            elsif optimize == :size
+                loopfit sla k            # carry <- k <- 0
+                        adc a            # carry <- a <- carry
+                if modulo && clrrem
+                        sub m
+                        jr  NC, fits
+                        add m
+                fits    djnz loopfit
+                else
+                        jr  C, fits unless clrrem # a >= 256
+                        cp  m
+                        jr  C, nfits
+                fits    sub m
+                        inc k unless modulo # k <- 1 (quotient)
+                nfits   djnz loopfit
+                end
+                        anda a if check0 && !ignore_cf # clear carry
+            end
         end
-        fits            sub m            # a = a - m (rest)
-        unless modulo
-                        inc k            # k <- 1 (quotient)
-        end
-                        djnz loopfit     # loop
-                        ora  a if check0 # clear carry only when check0
     end
 end
    @@ -797,7 +1025,7 @@

    Note:
    quick8
    -

    Checks if a divisor fits in 8 bits and in this instance uses a different, optimized for 8-bit division code. It can also be set to :divmod8 to use Macros.divmod8 (smaller code) instead of stacked Macros.divmod for an 8-bit division.

    +

    Checks if a divisor fits in 8 bits and in this instance uses a different, optimized for 8-bit division code. quick8 can also be set to :divmod8 to use Macros.divmod8 (smaller code) instead of stacked Macros.divmod for an 8-bit division.

    @@ -807,7 +1035,7 @@

    Note: - 
    # File lib/z80/math_i.rb, line 1637
+            
    # File lib/z80/math_i.rb, line 2222
 def divmod16(x=ixl, check0:true, check1:true, modulo:false, quick8:true)
     raise ArgumentError unless [ixh, ixl, iyh, iyl].include?(x)
     isolate do |eoc|
@@ -821,7 +1049,7 @@ 
    Note:if quick8 == :divmod8
                             divmod8 e, check0:(check0 && qcheck0), check1:(check1 && qcheck1), modulo:modulo
                 else
-                            divmod h, e, check0:(check0 && qcheck0), check1:(check1 && qcheck1), modulo:modulo, optimize: :time
+                            divmod h, e, check0:(check0 && qcheck0), check1:(check1 && qcheck1), modulo:modulo, optimize: :time, ignore_cf:true
                             divmod l, e, clrrem:false, optimize: :time
                             anda a if check0
                 end
@@ -843,29 +1071,35 @@ 
    Note:cp  1
                             jr  C, check0 if check0 # division by 0
                 if check1
-                            jp  NZ, div16strt # division by m > 1
-                            ld  bc, 0         # clear rest
-                            jp  check1        # division by 1
+                            jr  Z, divone     # division by m == 1
                 end
             end
         end
         div16strt           xor a            # a = 0 hi remainder
                             ld  c, a         # c = 0 lo remainder
                             ld  b, 16
+        findhi              add hl, hl       # align highest set bit at CF
+                            jr  C, found
+                            djnz findhi
+                            jp  eoc          # hl == 0, bc == 0
         loopfit             add hl, hl       # carry <- hl <- 0
-                            rl  c            # carry <- c <- carry
+        found               rl  c            # carry <- c <- carry
                             adc a            # carry <- a <- carry
                             cp  d            # a - d
                             jr  NC, fitshi   # a >= d
                             djnz loopfit     # loop
                             ccf if check0
                             jp  over
+        if check1 && !quick8
+            divone          ld  bc, 0         # clear rest
+                            jp  check1        # division by 1
+        end
         fitshi              ld  x, a
                             ld  a, c
                             jr  NZ, fitslo   # a > d, ignore e
                             cp  e            # a == d: c - e
                             jr  NC, fitslo   # a >= e
-                            ld  a, x 
+                            ld  a, x
                             djnz loopfit     # loop
                             ccf if check0
                             jp  over
@@ -887,6 +1121,95 @@ 
    Note:
+        
+        
    
+          divmod16_8(kh, kl, m, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Creates a routine that performs an euclidean division of unsigned 16-bit: kh|kl / 8-bit m. Returns a quotient in kh|kl and a remainder in accumulator.
    
+
+
    This routine utilizes a stacked up Macros.divmod routines.
    
+
    kh, kl
+
    
+
    A dividend as two unique 8-bit registers except: a, b.
    
+
    m
+
    
+
    A divisor as an 8-bit register except: a, b and none of kh, kl.
    
+
    
+
+
    Options:
    
+
    • check0
+
      
+
      Checks if a divisor is 0, in this instance CF=1 indicates an error  and nothing except the accumulator is being altered. CF should be ignored if check0 is false. It may also be a label (within the relative jump range) to indicate where to jump if m equals 0.
      
+
      
+
    • check0_far
+
      
+
      Allow to specify far (outside the relative jump range) check0 label.
      
+
      
+
    • check1
+
      
+
      Checks if a divisor equals 1, a hot path optimization. It may also be a label to indicate where to jump if m equals 1.
      
+
      
+
    • k_leq_m
+
      
+
      Short circuits if kh is equal or less than a divisor, a hot path optimization.
      
+
      
+
    • modulo
+
      
+
      Calculates a remainder only.
      
+
      
+
    • ignore_cf
+
      
+
      Removes instruction to clear CF if check0 is also set. This can be used if check0 is provided as a label instead of checking the state of the CF flag.
      
+
      
+
    • optimize
+
      
+
      Optimization options: :size, :time, :unroll, :time_alt, :unroll_alt. See Macros.divmod for details.
      
+
      
+
    
+
    NOTE
+
    
+
    A Macros.divmod8 presents a slower (up to 12%) but a significantly smaller (x1.5) alternative.
    
+
    
+
+
    Uses: af, b, kh, kl, preserves: m.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80/math_i.rb, line 2192
+def divmod16_8(kh, kl, m, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time)
+    raise ArgumentError unless [kh, kl, m].uniq.size == 3
+    isolate do |eoc|
+        if check0 == true
+            check0 = eoc
+            check0_far = (optimize == :unroll || optimize == :unroll_alt)
+        end
+        check1 = eoc if check1 == true
+        divmod kh, m, check0:check0, check0_far:check0_far, check1:check1, k_leq_m:k_leq_m, modulo:modulo, optimize:optimize, ignore_cf:true
+        divmod kl, m, clrrem:false, modulo:modulo, optimize:optimize
+        anda a if check0 && !ignore_cf # clear CF unless ignored
+    end
+end
    
+          
    
+          
+        
    
+
+        
+
+

    @@ -894,7 +1217,7 @@

    Note: divmod24_8(kh, km, kl, m, check0:true, check1:true, modulo:false, optimize: :time) + class="method-args">(kh, km, kl, m, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time) click to toggle source @@ -919,17 +1242,29 @@

    Note:
    check0_far +
    +

    Allow to specify far (outside the relative jump range) check0 label.

    +
  • check1

    Checks if a divisor equals 1, a hot path optimization. It may also be a label to indicate where to jump if m equals 1.

    +
  • k_leq_m +
    +

    Short circuits if kh is equal or less than a divisor, a hot path optimization.

    +
  • modulo

    Calculates a remainder only.

    +
  • ignore_cf +
    +

    Removes instruction to clear CF if check0 is also set. This can be used if check0 is provided as a label instead of checking the state of the CF flag.

    +
  • optimize
    -

    What is more important: :time or :size?

    +

    Optimization options: :size, :time, :unroll, :time_alt, :unroll_alt. See Macros.divmod for details.

    • @@ -939,16 +1274,19 @@

    Note: - 
    # File lib/z80/math_i.rb, line 1729
-def divmod24_8(kh, km, kl, m, check0:true, check1:true, modulo:false, optimize: :time)
+            
    # File lib/z80/math_i.rb, line 2325
+def divmod24_8(kh, km, kl, m, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time)
     raise ArgumentError unless [kh, km, kl, m].uniq.size == 4
     isolate do |eoc|
-        check0 = eoc if check0 == true
+        if check0 == true
+            check0 = eoc
+            check0_far = (optimize == :unroll || optimize == :unroll_alt)
+        end
         check1 = eoc if check1 == true
-        divmod kh, m, check0:check0, check1:check1, modulo:modulo, optimize:optimize
+        divmod kh, m, check0:check0, check0_far:check0_far, check1:check1, k_leq_m:k_leq_m, modulo:modulo, optimize:optimize, ignore_cf:true
         divmod km, m, clrrem:false, modulo:modulo, optimize:optimize
         divmod kl, m, clrrem:false, modulo:modulo, optimize:optimize
-        anda a if check0 # clear CF
+        anda a if check0 && !ignore_cf # clear CF unless ignored
     end
 end

    @@ -1005,7 +1343,7 @@

    Note: - 
    # File lib/z80/math_i.rb, line 1827
+            
    # File lib/z80/math_i.rb, line 2426
 def divmod32_16(x:ixl, check0:true, check1:true, modulo:false, quick8:true)
     raise ArgumentError unless [ixh, ixl, iyh, iyl].include?(x)
     isolate do |eoc|
@@ -1167,7 +1505,7 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 1758
+            
    # File lib/z80/math_i.rb, line 2357
 def divmod32_8(m=c, mt:c, check0:true, check1:true, modulo:false)
     raise ArgumentError unless [c, d, e].include?(m)
     isolate do |eoc|
@@ -1275,7 +1613,7 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 1583
+            
    # File lib/z80/math_i.rb, line 2122
 def divmod8(m=c, check0:true, check1:true, modulo:false)
     raise ArgumentError unless [c, d, e].include?(m)
     isolate do |eoc|
@@ -1286,9 +1624,7 @@ 
    Note:cp  1
                         jr  C, check0 if check0 # division by 0
             if check1
-                        jp  NZ, divstrt  # division by m > 1
-                        xor a            # clear rest
-                        jp  check1       # division by 1
+                        jr  Z, divone    # division by m == 1
             end
         end
         divstrt         xor a            # a = 0
@@ -1297,20 +1633,27 @@ 
    Note:jr  C, found
                         djnz findhi
                         jp  eoc          # hl == 0
+        if check1
+            divone      xor a            # clear rest
+                        jp  check1       # division by 1
+        end
         loopfit         add hl, hl       # carry <- hl <- 0
         found           adc a            # carry <- a <- carry
                         jr  C, fits      # a >= 256
                         cp  m            # a - m
                         jr  NC, fits     # a >= m
                         djnz loopfit     # loop
-                        ccf if check0    # clear carry only when check0
+        if check0
+                        jp  quitccf      # clear carry only when check0
+        else
                         jp  eoc
+        end
         fits            sub m            # a = a - m (rest)
         unless modulo
                         inc l            # hl <- 1 (quotient)
         end
                         djnz loopfit     # loop
-                        ora  a if check0 # clear carry only when check0
+        quitccf         anda a if check0 # clear carry only when check0
     end
 end
    
           
@@ -1431,7 +1774,7 @@ 
    Note:
    optimize
 
    
-
    What is more important: :time or :size? Applies only if kbit9_carry is true.
    
+
    What is more important: :time or :size?
    
 
    
 
 
@@ -1441,13 +1784,19 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 638
+            
    # File lib/z80/math_i.rb, line 905
 def mul(k=d, m=a, tt:de, clrhl:true, signed_k:false, kbit9_carry:false, tl_is_zero:false, optimize: :time)
+    raise ArgumentError, "mul: invalid arguments" if tt == hl or k == a
+    raise ArgumentError, "mul: optimize should be :time or :size" unless [:size, :time].include?(optimize)
     th, tl = tt.split
-    raise ArgumentError if tt == hl or m == th
+    srx = if signed_k
+        proc {|t| sra t}
+    else
+        proc {|t| srl t}
+    end
     isolate do |eoc|
-                ld   th, k unless k == th
                 ld   a, m unless m == a
+                ld   th, k unless k == th
         if clrhl
                 ld   hl, 0
                 ld   tl, l unless tl_is_zero
@@ -1456,28 +1805,181 @@ 
    Note:end
         if kbit9_carry
                 rr   th
-            if optimize == :size
-                jr   cont9
-            elsif optimize == :time
+            if optimize == :time
                 rr   tl
                 add  a, a
                 jr   NC, noadd9
                 add  hl, tt
         noadd9  jr   Z, eoc
             else
-                raise ArgumentError, "optimize should be :time or :size"
+                jr   cont9
             end
+        elsif optimize == :time
+                srx[th]
+                rr   tl
+                add  a, a
+                jr   NC, noadd8
+                add  hl, tt
+        noadd8  jr   Z, eoc
         end
-        if signed_k
-            loop1   sra  th
-        else
-            loop1   srl  th
-        end
+        loop1   srx[th]
         cont9   rr   tl
                 add  a, a
+        if optimize == :time
+                jr   NC, loop1
+        else
                 jr   NC, noadd
+        end
                 add  hl, tt
+        if optimize == :time
+                jp   NZ, loop1
+        else
         noadd   jr   NZ, loop1
+        end
+    end
+end
    
+          
+          
+        
+
+        
+
+        
+      
+
+    
+      
    
+        
+        
    
+          mul16(kh=h, kl=l, m=a, tt:de, mbit9_carry:false, optimize: :time)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Creates a routine that performs a multiplication of a 16-bit integer kh|kl * 8(9)-bit unsigned m. Returns the result in hl.
    
+
+
    This routine is so far the most optimized of the similar routines: Macros.mul8 or Macros.mul. However there is no way to accumulate results using this code.
    
+
    kh
+
    
+
    The MSB part of the multiplicand as an immediate value or an 8-bit register.
    
+
    kl
+
    
+
    The LSB part of the multiplicand as an immediate value or an 8-bit register.
    
+
    m
+
    
+
    An 8-bit multiplier or the lowest 8-bits of a multiplier.
    
+
    
+
+
    If mbit9_carry option is true the CF flag should contain the most significant bit (bit 9th) of a 9-bit unsigned multiplier.
    
+
+
    Options:
    
+
    • tt
+
      
+
      A 16-bit temporary register (de or bc unless optimize is :size).
      
+
      
+
    • mbit9_carry
+
      
+
      If the multiplier (m) is 9-bit, where MSB (9th) bit is read from CARRY flag.
      
+
      
+
    • optimize
+
      
+
      Optimization options: :size, :time or :unroll.
      
+
      
+
    
+
+
    Modifies: af, hl, tt, optionally b if optimize is :size.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80/math_i.rb, line 622
+def mul16(kh=h, kl=l, m=a, tt:de, mbit9_carry:false, optimize: :time)
+    th, tl = tt.split
+    raise ArgumentError, "mul16: invalid arguments" if tt == hl or [kh, kl].include?(a)
+    raise ArgumentError, "mul16: tt must be +de+ if optimize is :size" if tt == bc && optimize == :size
+    isolate do |eoc|
+                        ld   a, m  unless  m == a
+        if kh == tl
+            raise ArgumentError, "mul16: invalid arguments" if kl == th
+                        ld   th, kh
+                        ld   tl, kl unless kl == tl
+        else
+                        ld   tl, kl unless kl == tl
+                        ld   th, kh unless kh == th
+        end
+        if optimize == :time
+                        ld   l, tl unless kl == l
+                        ld   h, th unless kh == h
+            if mbit9_carry
+                        jr   C, start9    # bit9 of m
+            end
+                        scf               # terminator
+                        adc  a, a         # CF <- m <- 1
+                        jr   C, cont1
+                loop0   add  a, a         # CF <- m <- 0
+                        jr   NC, loop0
+                        jp   NZ, cont1
+                        ld   h, a         # m == 0
+                        ld   l, a
+                        jp   eoc
+            if mbit9_carry
+                start9  adc  a, a         # CF <- m <- 1
+                        jr   C, doadd1
+            end
+                loop1   add  hl, hl       # hl * 2
+                cont1   add  a, a         # CF <- m <- 0
+                        jr   NC, loop1
+                        jr   Z, eoc
+                doadd1  add  hl, hl       # hl * 2
+                        add  hl, tt       # hl + tt
+                        add  a, a         # CF <- m <- 0
+                        jr   NC, loop1
+                        jp   NZ, doadd1
+        elsif optimize == :size
+                        ld   hl, 0
+            if mbit9_carry
+                        ld   b, 9
+                        jr   cont1
+            else
+                        ld   b, 8
+            end
+                loop1   add  hl, hl       # hl * 2
+                        add  a, a         # CF <- m <- 0
+                cont1   jr   NC, skip1
+                        add  hl, tt       # hl + tt
+                skip1   djnz loop1
+        elsif optimize == :unroll
+                        ld   l, tl unless kl == l
+                        ld   h, th unless kh == h
+            if mbit9_carry
+                        jr   C, iter0     # bit9 of m
+            end
+            7.times do |i|
+                        add  a, a
+                        jr   C, :"iter#{i+1}"
+            end
+                        add  a, a
+                        jr   C, eoc
+                        ld   h, a         # m == 0
+                        ld   l, a
+                        jp   eoc
+            (if mbit9_carry then 0 else 1 end..7).each do |i|
+                ns :"iter#{i}" do |eoc|
+                        add  hl, hl
+                skip9   add  a, a
+                        jr   NC, eoc
+                doadd   add  hl, tt
+                end
+            end
+        else
+            raise ArgumentError, "mul16: optimize should be :size, :time or :unroll"
+        end
     end
 end
    
           
    
@@ -1545,7 +2047,7 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 1326
+            
    # File lib/z80/math_i.rb, line 1654
 def mul16_32(mm=bc, tt:bc, clrhlhl:true, signed_hl:false, optimize: :time)
     raise ArgumentError unless [bc, de].include?(mm) and [bc, de].include?(tt)
     mh, ml = mm.split
@@ -1706,6 +2208,156 @@ 
    Note:
+        
+        
    
+          mul16_signed(kh=h, kl=l, m=b, tt:de, optimize: :time)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Creates a routine that performs a multiplication of a 16-bit integer kh|kl * 8-bit signed m. Returns the result in hl.
    
+
    kh
+
    
+
    The MSB part of the multiplicand as an immediate value or an 8-bit register.
    
+
    kl
+
    
+
    The LSB part of the multiplicand as an immediate value or an 8-bit register.
    
+
    m
+
    
+
    An 8-bit multiplier.
    
+
    
+
+
    Options:
    
+
    • tt
+
      
+
      A 16-bit temporary register (de or bc unless optimize is :size).
      
+
      
+
    • optimize
+
      
+
      Optimization options: :size, :time or :unroll.
      
+
      
+
    
+
+
    Modifies: af, hl, tt, optionally b if optimize is :size.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80/math_i.rb, line 583
+def mul16_signed(kh=h, kl=l, m=b, tt:de, optimize: :time)
+    th, tl = tt.split
+    raise ArgumentError, "mul16_signed: invalid arguments" if [kh, kl].include?(m)
+    t = if register?(m) && m.bit8? && m != a
+        m
+    else
+        [l, h, tl, th].find {|r| r != kh && r != kl}
+    end
+    isolate do
+                ld   a, m unless m == a
+                anda a
+                jp   P, mult        # m >= 0
+                ld   t, a unless t == m
+                neg16 kh, kl
+                xor  a
+                sub  t              # a: -m
+        mult    mul16(kh, kl, a, tt:tt, optimize:optimize)
+    end
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+      
    
+        
+        
    
+          mul16_signed9(kh=h, kl=l, m=b, tt:de, m_overflow:nil, optimize: :time)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Creates a routine that performs a multiplication of a 16-bit integer kh|kl * 9-bit signed CF|m. Returns the result in hl.
    
+
    kh
+
    
+
    The MSB part of the multiplicand as an immediate value or an 8-bit register.
    
+
    kl
+
    
+
    The LSB part of the multiplicand as an immediate value or an 8-bit register.
    
+
    m
+
    
+
    The lowest 8-bits of the multiplier.
    
+
    
+
+
    The CF flag should contain the sign bit (bit 9th) of a 9-bit twos complement multiplier.
    
+
+
    Options:
    
+
    • tt
+
      
+
      A 16-bit temporary register (de or bc unless optimize is :size).
      
+
      
+
    • optimize
+
      
+
      Optimization options: :size, :time or :unroll.
      
+
      
+
    
+
+
    Modifies: af, hl, tt, optionally b if optimize is :size.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80/math_i.rb, line 547
+def mul16_signed9(kh=h, kl=l, m=b, tt:de, m_overflow:nil, optimize: :time)
+    th, tl = tt.split
+    raise ArgumentError, "mul16_signed: invalid arguments" if [kh, kl].include?(m)
+    t = if register?(m) && m.bit8? && m != a
+        m
+    else
+        [l, h, tl, th].find {|r| r != kh && r != kl}
+    end
+    isolate do
+                ld   a, m unless m == a
+                jr   NC, mult     # m >= 0
+                ld   t, a unless t == m
+                neg16 kh, kl
+                xor  a
+                sub  t              # a: -m
+        if m_overflow
+                jr   NC, m_overflow # m == 256
+        else
+                ccf                 # CF: 1 when m == 256, otherwise CF: 0
+        end
+        mult    mul16(kh, kl, a, tt:tt, mbit9_carry:!m_overflow, optimize:optimize)
+    end
+end
    
+          
    
+          
+        
    
+
+        
+
+        
       
    
 
     
@@ -1755,7 +2407,7 @@ 
    Note:
    optimize
 
    
-
    What is more important: :time or :size? Applies only if double is false.
    
+
    What is more important: :time or :size?
    
 
    
 
 
@@ -1765,31 +2417,47 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 920
+            
    # File lib/z80/math_i.rb, line 1218
 def mul8(kh=h, kl=l, m=a, tt:de, clrhl:true, double:false, optimize: :time)
+    raise ArgumentError, "mul8: optimize should be :time or :size" unless [:size, :time].include?(optimize)
     th, tl = tt.split
-    raise ArgumentError if tt == hl or [th,tl].include?(m) or tl == kh or th == kl or !register?(m)
+    raise ArgumentError, "mul8: invalid arguments" if tt == hl or [th, tl].include?(m) or
+                                                      !register?(m) or !m.bit8?
     isolate do |eoc|
+        if kh == tl
+            raise ArgumentError, "mul8: invalid arguments" if kl == th
+                ld   th, kh
+                ld   tl, kl unless kl == tl
+        else
                 ld   tl, kl unless kl == tl
                 ld   th, kh unless kh == th
+        end
                 ld   hl, 0 if clrhl
-        unless double
-            if optimize == :size
-                jr   muls1
-            elsif optimize == :time
+        if optimize == :time
+            if double
+                sla  tl
+                rl   th
+            end
                 srl  m
                 jr   C, doadd
                 jr   Z, eoc
-            else
-                raise ArgumentError, "optimize should be :time or :size"
-            end
+        elsif !double
+                jr   muls1
         end
         loop1   sla  tl
                 rl   th
         muls1   srl  m
+        if optimize == :time
+                jr   NC, loop1
+        else
                 jr   NC, noadd
+        end
         doadd   add  hl, tt
+        if optimize == :time
+                jp   NZ, loop1
+        else
         noadd   jr   NZ, loop1
+        end
     end
 end
    
           
    
@@ -1860,14 +2528,22 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 1055
+            
    # File lib/z80/math_i.rb, line 1374
 def mul8_24(kh=h, kl=l, m=b, t:c, tt:de, clrahl:true, k_int24: false, optimize: :time)
     th, tl = tt.split
-    raise ArgumentError if tt == hl or [a,th,tl,t].include?(m) or [a,th,tl,m].include?(t) or
-                           tl == kh or th == kl or !register?(m) or !register?(t)
+    raise ArgumentError, "mul8_24: invalid arguments" if tt == hl or [a, th, tl, t].include?(m) or
+                                                        [a, th, tl, m].include?(t) or
+                                                        !register?(m) or !register?(t) or
+                                                        !m.bit8? or !t.bit8?
     isolate do |eoc|
+        if kh == tl
+            raise ArgumentError, "mul_signed9_24: invalid arguments" if kl == th
+                    ld  th, kh
+                    ld  tl, kl unless kl == tl
+        else
                     ld  tl, kl unless kl == tl
                     ld  th, kh unless kh == th
+        end
         if clrahl
                     xor a
                     ld  h, a
@@ -1889,19 +2565,20 @@ 
    Note:last    jr  NC, eoc
                     add hl, tt      # last add
                     adc a, t
-        elsif optimize == :time     # 27 bytes
+        elsif optimize == :time     # 29 bytes
                     srl m           # 0 -> multiplier -> carry
-                    jp  NZ, loop1   # m != 0 ? start regular loop
+                    jp  NZ, skip0   # m != 0 ? start regular loop
                     jr  C, skadd    # m == 1 ? add and quit
                     jp  eoc         # m == 0 ? just quit
-            loop1   jr  NC, noadd   # carry == 0 ? don't add
-                    add hl, tt      # add multiplicand to result lo16
+            skip0   jr  NC, noadd   # carry == 0 ? don't add
+            doadd   add hl, tt      # add multiplicand to result lo16
                     adc a, t        # add multiplicand to result hi8
             noadd   sla tl          # multiplicand *= 2
                     rl  th
                     rl  t
                     srl m           # 0 -> multiplier -> carry
-                    jp  NZ, loop1   # m != 0 ? loop
+                    jr  NC, noadd   # carry == 0 ? don't add
+                    jp  NZ, doadd   # carry == 1 and m != 0 ? loop
             skadd   add hl, tt      # last add b.c. carry == 1
                     adc a, t
         else
@@ -1967,13 +2644,20 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 842
+            
    # File lib/z80/math_i.rb, line 1124
 def mul8_c(kh=h, kl=l, m=a, tt:de, clrhl:true)
     th, tl = tt.split
-    raise ArgumentError if tt == hl or [th,tl].include?(m) or tl == kh or th == kl or !register?(m)
+    raise ArgumentError, "mul8_c: invalid arguments" if tt == hl or [th, tl].include?(m) or
+                                                        !register?(m) or !m.bit8?
     isolate do |eoc|
+        if kh == tl
+            raise ArgumentError, "mul8_c: invalid arguments" if kl == th
+                ld   th, kh
+                ld   tl, kl unless kl == tl
+        else
                 ld   tl, kl unless kl == tl
                 ld   th, kh unless kh == th
+        end
                 ld   hl, 0 if clrhl
         loop1   srl  m
                 jr   NC, noadd
@@ -2045,7 +2729,7 @@ 
    Note:
    optimize
 
    
-
    What is more important: :time or :size? Applies only if double is false.
    
+
    What is more important: :time or :size?
    
 
    
 
 
@@ -2055,14 +2739,23 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 882
+            
    # File lib/z80/math_i.rb, line 1171
 def mul8_signed(kh=h, kl=l, m=c, tt:de, t:m, clrhl:true, double:false, optimize: :time)
     th, tl = tt.split
-    raise ArgumentError if !register?(t) or !t.bit8? or [a, tl, th].include?(t)
+    raise ArgumentError, "mul8_signed: invalid arguments" if !register?(t) or !t.bit8? or
+                                                             [a, tl, th].include?(t) or
+                                                             [kh, kl].include?(a)
+
     isolate do
+                ld   a, m unless m == a
+        if kh == tl
+            raise ArgumentError, "mul8_signed: invalid arguments" if kl == th
+                ld   th, kh
+                ld   tl, kl unless kl == tl
+        else
                 ld   tl, kl unless kl == tl
                 ld   th, kh unless kh == th
-                ld   a, m unless m == a
+        end
                 anda a
                 jp   P, mul_it      # m >= 0
                 ld   t, a unless t == m
@@ -2133,7 +2826,7 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 699
+            
    # File lib/z80/math_i.rb, line 981
 def mul_const(k=d, m=0, tt:de, clrhl:true, signed_k:false)
     raise ArgumentError unless tt != hl and m.is_a?(Integer) and (0..256).include?(m)
     tt = hl if clrhl and (m & (m - 1)) == 0
@@ -2323,7 +3016,7 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 1126
+            
    # File lib/z80/math_i.rb, line 1454
 def mul_const8_24(kh=h, kl=l, m=0, t:c, tt:de, clrahl:true, signed_k:false)
     th, tl = tt.split
     throw ArgumentError unless m.is_a?(Integer) and (0..256).include?(m) and [bc, de].include?(tt) and
@@ -2514,7 +3207,7 @@ 
    Note:
           mul_signed(k=d, m=a, tt:de, clrhl:true)
+            class="method-args">(k=d, m=a, tt:de, clrhl:true, optimize: :time)
           
           click to toggle source
           
@@ -2531,13 +3224,13 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 462
-def mul_signed(k=d, m=a, tt:de, clrhl:true)
+            
    # File lib/z80/math_i.rb, line 709
+def mul_signed(k=d, m=a, tt:de, clrhl:true, optimize: :time)
     th, tl = tt.split
-    raise ArgumentError if tt == hl or m == th
+    raise ArgumentError, "mul_signed: invalid arguments" if tt == hl or k == a
     isolate do
-                ld   th, k unless k == th
                 ld   a, m unless m == a
+                ld   th, k unless k == th
                 anda a
                 jp   P, mul_it      # m >= 0
                 ld   tl, a if m == a
@@ -2550,7 +3243,7 @@ 
    Note:else
                 sub  m
             end
-        mul_it  mul(th, a, tt:tt, clrhl:clrhl, signed_k:true)
+        mul_it  mul(th, a, tt:tt, clrhl:clrhl, signed_k:true, optimize:optimize)
     end
 end
    
           
@@ -2567,7 +3260,7 @@ 
    Note:
           mul_signed9(kh=c, kl=d, m=a, s:kh, tt:de, m_neg_cond:C, k_full_range:true, m_full_range:true, k_overflow:nil, m_is_zero_zf:false, optimize: :time)
+            class="method-args">(kh, kl, m=a, s:kh, tt:de, m_neg_cond:C, k_full_range:true, m_full_range:true, k_overflow:nil, m_is_zero_zf:false, optimize: :time)
           
           click to toggle source
           
@@ -2619,11 +3312,11 @@ 
    Note:
    k_full_range
 
    
-
    Determines whether the multiplicand is allowed to be equal to -256. Saves 7 T-states and 18-21 bytes if disabled.
    
+
    Determines whether the multiplicand is allowed to be equal to (-256). Saves 7 T-states and 18-21 bytes if disabled.
    
 
    
 
  • m_full_range
 
    
-
    Determines whether the multiplier is allowed to be equal to -256. Saves 7 T-states and 6-9 bytes if disabled.
    
+
    Determines whether the multiplier is allowed to be equal to (-256). Saves 7 T-states and 6-9 bytes if disabled.
    
 
    
 
  • k_overflow
 
    
@@ -2635,7 +3328,7 @@ 
    Note:
    optimize
 
    
-
    What is more important: :time or :size?
    
+
    Optimization options: :size, :time or :unroll.
    
 
    
 
    • 
 
@@ -2647,7 +3340,7 @@ 
    Note:Note:
-            
    # File lib/z80/math_i.rb, line 546
-def mul_signed9(kh=c, kl=d, m=a, s:kh, tt:de, m_neg_cond:C, k_full_range:true, m_full_range:true, k_overflow:nil, m_is_zero_zf:false, optimize: :time)
-    th, tl = tt.split
-    raise ArgumentError, "mul_signed9: invalid arguments" if tt == hl or m == th or kh == kl or 
+            
    # File lib/z80/math_i.rb, line 793
+def mul_signed9(kh, kl, m=a, s:kh, tt:de, m_neg_cond:C, k_full_range:true, m_full_range:true, k_overflow:nil, m_is_zero_zf:false, optimize: :time)
+    if optimize == :size
+        th, tl = tt.split
+    else
+        tl, th = tt.split
+    end
+    raise ArgumentError, "mul_signed9: invalid arguments" if tt == hl or kh == kl or
+                                                             [kh, kl].include?(a) or
                                                              [th, tl, h, l, a].include?(s)
     raise ArgumentError, "mul_signed9: invalid options" if k_overflow and k_full_range and !m_full_range
     raise ArgumentError, "mul_signed9: m_neg_cond must be a Condition" unless m_neg_cond.is_a?(Condition)
@@ -2670,10 +3368,16 @@ 
    Note:end
     end
     isolate do |eoc|
+                ld   a, m unless m == a
+        if th == kh
+            raise ArgumentError, "mul_signed9: invalid arguments" if s == kl
+                ld   s, kh unless s == kh
+                ld   th, kl unless kl == th
+        else
                 ld   th, kl unless kl == th
                 ld   s, kh unless s == kh
-                ld   a, m unless m == a
-                ld   hl, 0
+        end
+                ld   hl, 0 if optimize == :size
                 # m < 0
         if m_neg_cond.jr_ok?
                 jr   m_neg_cond, m_neg
@@ -2682,49 +3386,58 @@ 
    Note:end
                 anda a unless m_is_zero_zf
                 jump.call NZ, mul_it # m != 0
-                ld   s, l            # clear sign
+        if k_full_range && m_full_range && !k_overflow && m_is_zero_zf && m_neg_cond != C
+                xor  a               # clear CF
+        end
+                ld   s, a            # clear sign
+        unless optimize == :size
+                ld   h, a
+                ld   l, a
+        end
                 jump.call nil, eoc   # CF=0
 
         if k_full_range              # k = -(-256)
-        k_over  ld   s, l            # clear sign
-                xor  a
+        k_over  xor  a
+                ld   s, a            # clear sign (-256 * m) where m < 0
+                ld   l, a unless optimize == :size
                 sub  tl              # a = -m, CF = 1 (unless m == -256)
             if m_full_range
-                # m == -256
+                # m == (-256)
                 jp   NC, k_overflow if k_overflow
-                jr   NC, km_n256 unless k_overflow
+                ccf unless k_overflow # CF:1 when m == -256
             end
-                ld   tt, 0x8000      # th: (MSB=1|0x00) >> 1 = 0x80
-                add  a, a            # m is never 0 here
-                jr   NC, skipadd     # if NC then we are SURE +a+ can't be 0 now
-                add  hl, tt
-                jr   Z, eoc
-        skipadd srl  th              # make sure to insert 0 in S (bit 7) position
-                jump.call nil, mult.cont9
+                ld   h, a            # hl: 256 * -m where m < 0
+                jump.call nil, eoc   # CF=0|1 depending on overflow unless k_overflow is set
         end
 
         if m_full_range
-        km_n256 scf unless k_overflow or !k_full_range
-        m_n256  ld   h, th      # hl: k * -256
-                jump.call nil, eoc   # CF=0|1 depending on overflow
+        m_n256  ld   h, th           # hl: k * (-256)
+                ld   l, a unless optimize == :size
+                jump.call nil, eoc   # CF=0|1 depending on overflow unless k_overflow is set
         end
 
-        m_neg   ld   tl, a
+        m_neg   label
+                ld   tl, a unless m == tl
                 neg16 s, th, th:a # a: 0|FF depending on th == 0
         if k_full_range
                 jr   C, k_over    # 0-0:CF=0, 0-FF:CF=1, FF-0:CF=0, FF-FF:CF=0
         elsif k_overflow
                 jp   C, k_overflow
         end
-                ld   s, a       # s|k = -(s|k)
+                ld   s, a         # s|k = -(s|k)
                 xor  a
-                sub  tl         # a = -m
+                sub  tl           # a = -m
         if m_full_range
-                jr   Z, m_n256  # m == -256
+                jr   Z, m_n256    # m == (-256)
         end
-        mul_it  rrc  s          # k sign -> CF
+        if optimize == :size
+        mul_it  sra  s            # k sign -> CF
                 ld   tl, l
-        mult    mul(th, a, tt:tt, clrhl:false, signed_k:true, kbit9_carry:true, tl_is_zero:true, optimize:optimize)
+        mult    mul(th, a, tt:tt, clrhl:false, signed_k:true, kbit9_carry:true, tl_is_zero:true, optimize: :size)
+        else
+        mul_it  mul16(s, th, a, tt:tt, mbit9_carry:false, optimize:optimize)
+                anda a if k_full_range && m_full_range && !k_overflow # clear CF
+        end
     end
 end
    
           
@@ -2807,7 +3520,7 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 982
+            
    # File lib/z80/math_i.rb, line 1296
 def mul_signed9_24(ks=c, kh=h, kl=l, m=b, tt:de, m_pos_cond:NC, m_full_range:true, optimize: :time, &restore_a)
     th, tl = tt.split
     raise ArgumentError, "mul_signed9_24: invalid arguments" if tt == hl or [th, tl, ks, h, l, a].include?(m) or
@@ -2822,9 +3535,14 @@ 
    Note:end
     end
     isolate do |eoc|
+        if kh == tl
+            raise ArgumentError, "mul_signed9_24: invalid arguments" if kl == th
+                ld   th, kh
+                ld   tl, kl unless kl == tl
+        else
                 ld   tl, kl unless kl == tl
                 ld   th, kh unless kh == th
-
+        end
         if m_pos_cond.jr_ok?
                 jr   m_pos_cond, mul_it # m >= 0
         else
@@ -2836,7 +3554,7 @@ 
    Note:sub  m
                 ld   m, a
         if m_full_range
-                jump.call NZ, mul_it # m != -256
+                jump.call NZ, mul_it # m != (-256)
             if clrahl
                 ld   l, a             # a: 0
                 ld   h, tl
@@ -3046,7 +3764,7 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 1945
+            
    # File lib/z80/math_i.rb, line 2544
 def rnd
     isolate do |eoc|
                         inc hl          # seed + 1
@@ -3079,8 +3797,8 @@ 
    Note:ld  h, a
                         ld  a, c
                         dec hl          # hl = hl - 1, in effect: borrow|hl = 0x1_nnnn - 0x1_0001 = 0x0_mmmm
-                                                        # no need to check for overflow here since 65536 is never a result of n*75
-        mloopck         jr  Z, fits     # b==0: (seed + 1) * 75 == 0x0001_nnnn
+                                        # no need to check for overflow here since 65536 is never a result of n*75
+                        jr  Z, fits     # b==0: (seed + 1) * 75 == 0x0001_nnnn
         mloop1          add a           # shift left hl|a, highest bit to CF
                         adc hl, hl
                         jr  NC, mnext   # CF == 0: continue
@@ -3146,6 +3864,113 @@ 
    Note:
+        
+        
    
+          sll8_16(bshift, th=h, tl=l)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Shift logical left 8-bit register with a result extended to 16-bits.
    
+
    bshift
+
    
+
    How many bits to shift the content of the tl register.
    
+
    th
+
    
+
    An 8-bit register, except the accumulator for receiving the highest 8 bits of the result.
    
+
    tl
+
    
+
    An 8-bit register, except the accumulator holding the initial value and receiving the lowest 8-bit of the result.
    
+
    
+
+
    Modifies: af, th, tl.
    
+
+
    T-states: 7,18|23,29|35,39,43,39,35,31,11,19,23,27,31,26,30,34,10|11.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80/math_i.rb, line 469
+def sll8_16(bshift, th=h, tl=l)
+    raise ArgumentError, "lshift8_16: invalid arguments!" unless Integer === bshift and bshift >= 0 and
+                                                             register?(th) and th.bit8? and th != a
+                                                             register?(tl) and tl.bit8? and tl != a
+    isolate do
+        case bshift
+        when 0 # 7
+                          ld   th, 0
+        when 1 # 18|23
+                          ld   th, 0
+            if th == h && tl == l
+                          add  hl, hl
+            else
+                          sla  tl
+                          rr   th
+            end
+        when 2..7 # 29|35,39,43,39,35,31
+            if bshift == 2 && th == h && tl == l # 29
+                          ld   h, 0
+                          add  hl, hl
+                          add  hl, hl
+            else
+                          ld   a, tl
+              if bshift > 4
+                          (8-bshift).times { rrca }
+                          ld   th, a
+                          anda (0xFF << bshift) & 0xFF
+                          ld   tl, a
+                          xor  th
+                          ld   th, a
+              else
+                          bshift.times { rlca }
+                          ld   tl, a
+                          anda (1 << bshift) - 1
+                          ld   th, a
+                          xor  tl
+                          ld   tl, a
+              end
+            end
+        when 8 # 11
+                          ld   th, tl
+                          ld   tl, 0
+        when 9..12 # 19,23,27,31
+                          ld   a, tl
+                          (bshift-8).times { add a }
+                          ld   th, a
+                          ld   tl, 0
+        when 13..15 # 26,30,34
+                          ld   a, tl
+                          (16-bshift).times { rrca }
+                          anda (0xFF << (bshift-8)) & 0xFF
+                          ld   th, a
+                          ld   tl, 0
+        else # 10 | 11
+            if th.match16?(tl)
+                          ld   th|tl, 0
+            else
+                          ld   tl, 0
+                          ld   th, tl
+            end
+        end
+    end
+end
    
+          
    
+          
+        
    
+
+        
+
+        
       
 
     
@@ -3353,7 +4178,7 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 2049
+            
    # File lib/z80/math_i.rb, line 2648
 def utobcd(bufend, input=de, size: 4, r: d, rr: de, byteorder: :lsb, input_end:false)
     raise ArgumentError unless address?(bufend) and
                                (address?(input) or input == rr) and
@@ -3459,7 +4284,7 @@ 
    Note:
-            
    # File lib/z80/math_i.rb, line 2001
+            
    # File lib/z80/math_i.rb, line 2600
 def utobcd_step(bufend, r, buflen=1, t=c, r_in_a=false)
     raise ArgumentError unless address?(bufend) and
                                [c,d,e].include?(r) and [c,d,e].include?(t) and r != t and
diff --git a/Z80/Utils/SinCos/Macros.html b/Z80/Utils/SinCos/Macros.html
index 73ffa2e..5435b27 100644
--- a/Z80/Utils/SinCos/Macros.html
+++ b/Z80/Utils/SinCos/Macros.html
@@ -141,7 +141,7 @@ 
    Public Instance Methods
    
 
           
           
    
-            
    # File lib/z80/utils/sincos.rb, line 146
+            
    # File lib/z80/utils/sincos.rb, line 163
 def create_sincos_from_sintable(sincos, sintable:hl)
     isolate do
         sincos0     addr 0, SinCos
@@ -269,7 +269,7 @@ 
    Public Instance Methods
    
         
         
    
           sincos_from_angle(sincos, th=h, tl=l)
+            class="method-args">(sincos, th=h, tl=l, mask:nil)
           
           click to toggle source
           
@@ -283,10 +283,17 @@ 
    Public Instance Methods
    
 
    For each angle: a <= llllllhh; th =>  MSB SinCos address + 000000hh, tl => llllll00
    
 
    sincos
 
    
-
    Address of SinCos table, must be aligned to 256 bytes. (LSB of sincos address must be 0).
    
+
    Address of SinCos table, must be aligned to 256 bytes or an 8-bit register holding MSB of the SinCos address. LSB of sincos address must be 0.
    
 
    
 
-
    T-states: 30.
    
+
    Options:
    
+
    • mask
+
      
+
      An pptional 8-bit register holding preloaded mask value: 0xFC (0b11111100).
      
+
      
+
    
+
+
    T-states: 30|27|24.
    
 
 
    Mofifies: af, th, tl.
    
           
@@ -294,23 +301,37 @@ 
    Public Instance Methods
    
 
           
           
    
-            
    # File lib/z80/utils/sincos.rb, line 115
-def sincos_from_angle(sincos, th=h, tl=l)
+            
    # File lib/z80/utils/sincos.rb, line 118
+def sincos_from_angle(sincos, th=h, tl=l, mask:nil)
     raise ArgumentError, "sincos must be a direct address" if pointer?(sincos)
     if immediate?(sincos)
         sincos = sincos.to_i
         raise ArgumentError, "sincos address must be aligned to 256 bytes" unless (sincos & 0x00FF).zero?
     end
+    raise ArgumentError, "invalid mask argument" unless mask.nil? or
+            (register?(mask) and mask.bit8? and ![a, th, tl, sincos].include?(mask))
+    mask = 0b11111100 if mask.nil?
     isolate do
-        select(sincos & 0x00FF, &:zero?).then do |_|
+        if register?(sincos)
+            raise ArgumentError, "invalid sincos register" unless sincos.bit8? and 
+                                                            ![a, th, tl].include?(sincos)
+                ld   th, a
+                anda mask
+                ld   tl, a
+                xor  th
+                add  sincos
+                ld   th, a
+        else
+            select(sincos & 0x00FF, &:zero?).then do |_|
                 ld   th, a
-                anda 0b11111100
+                anda mask
                 ld   tl, a
                 xor  th
                 add  sincos >> 8
                 ld   th, a
-        end.else do
-            raise ArgumentError, "sincos address must be aligned to 256 bytes"
+            end.else do
+                raise ArgumentError, "sincos address must be aligned to 256 bytes"
+            end
         end
     end
 end
    
diff --git a/Z80/Utils/SinCos/SinCos.html b/Z80/Utils/SinCos/SinCos.html
index ed432f5..e8b3b9a 100644
--- a/Z80/Utils/SinCos/SinCos.html
+++ b/Z80/Utils/SinCos/SinCos.html
@@ -4,7 +4,7 @@
 
 
 
-class Z80::Utils::SinCos::SinCos - ruby-Z80
+class Z80Lib3D::Primitives::SinCos - ruby-Z80
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    
+  
    
+    module Z80Lib3D
+  
    
+
+  
    
+    
+  
    
+
+  
+  
    
+    
+
+    
+
+    
+
+    
+
+    
+  
    
+
+
    
+
+
+
+
diff --git a/Z80Lib3D/Matrix3D.html b/Z80Lib3D/Matrix3D.html
new file mode 100644
index 0000000..12f0d04
--- /dev/null
+++ b/Z80Lib3D/Matrix3D.html
@@ -0,0 +1,121 @@
+
+
+
+
+
+
+class Z80Lib3D::Matrix3D - ruby-Z80
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    
+  
    
+    class Z80Lib3D::Matrix3D
+  
    
+
+  
    
+    
+
    Z80Lib3D::Matrix3D ↑
    
+
+
    3D matrix related Macros.
    
+
+  
    
+
+  
+  
    
+    
+
+    
+
+    
+
+    
+
+    
+  
    
+
+
    
+
+
+
+
diff --git a/Z80Lib3D/Matrix3D/Macros.html b/Z80Lib3D/Matrix3D/Macros.html
new file mode 100644
index 0000000..ef24a74
--- /dev/null
+++ b/Z80Lib3D/Matrix3D/Macros.html
@@ -0,0 +1,494 @@
+
+
+
+
+
+
+module Z80Lib3D::Matrix3D::Macros - ruby-Z80
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    
+  
    
+    module Z80Lib3D::Matrix3D::Macros
+  
    
+
+  
    
+    
+
    Z80Lib3D::Matrix3D::Macros ↑
    
+
+
    Macros for applying 3D matrix to vertices.
    
+
+  
    
+
+  
+  
    
+    
+
+    
+
+    
+
+    
+
+    
+     
    
+       
    
+         
    Public Instance Methods
    
+       
    
+
+    
+      
    
+        
+        
    
+          apply_matrix(matrix, vertices:hl, scrx0:128, scry0:128, scrz0:128, persp_dshift:7, optimize: :time)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Applies a transformation matrix to vertices and calculates screen coordinates (xp, yp) for each one.
    
+
+
    X = M[0]*vx + M[1]*vy + M[2]*vz
+Y = M[3]*vx + M[4]*vy + M[5]*vz
+Z = M[6]*vx + M[7]*vy + M[8]*vz
+
+XP =  ((X << persp_dshift) / (Z + scrz0)) + scrx0
+YP = -((Y << persp_dshift) / (Z + scrz0)) + scry0
+
    
+
+
    Vertices list must be terminated with a (-128) octet and must not be empty.
    
+
+
    Vertices are represented by Primitives::Vertex struct.
    
+
+
    Matrix is represented by Primitives::Matrix struct.
    
+
+
    Each matrix element should be a 16-bit fixed point twos complement signed number with an 8-bit fractional part.
    
+
+
    NOTE: The routine uses stack pointer to read matrix data, so disable interrupts first.
    
+
    matrix
+
    
+
    An address of matrix data as a label or a pointer.
    
+
    
+
+
    Options:
    
+
    • vertices
+
      
+
      An address of object vertices or hl.
      
+
      
+
    • scrx0
+
      
+
      A X coordinate adjustment used for calculating screen coordinates.
      
+
      
+
    • scry0
+
      
+
      A Y coordinate adjustment used for calculating screen coordinates.
      
+
      
+
    • scrz0
+
      
+
      A Z coordinate adjustment used for calculating screen coordinates.
      
+
      
+
    • persp_dshift
+
      
+
      A screen coordinates perspective adjustment: 0-7.
      
+
      
+
    
+
+
    When the routine completes:
    
+
    • 
+
      hl will point to an address immediately following the vertices end marker.
      
+
    • 
+
      sp will point to an address immediately following the matrix.
      
+
    
+
+
    Notable run-time labels:
    
+
    • 
+
      matrix_p can be used to change the address of the matrix.
      
+
    • 
+
      adjust_x_p points to scrx0.
      
+
    • 
+
      adjust_y_p points to scry0.
      
+
    • 
+
      adjust_z_p points to scrz0.
      
+
    • 
+
      matrix_loop enter to skip reading first Z coordinate, can be used to pre-check if vertices are empty. Expects Z coordinage already in b and hl pointing to the next coordinate.
      
+
    
+
+
    Modifies: sp, af, af', hl, bc, de, hl', bc', de'.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/matrix.rb, line 61
+def apply_matrix(matrix, vertices:hl, scrx0:128, scry0:128, scrz0:128, persp_dshift:7, optimize: :time)
+  raise ArgumentError, "apply_matrix: invalid arguments" unless [scrx0, scry0, scrz0].all?{|l| direct_address?(l) }
+  mx_optimize = case optimize
+  when :time_alt then :time
+  when :unroll_alt then :unroll
+  else
+    optimize
+  end
+  check0_far = (optimize == :unroll || optimize == :unroll_alt)
+  isolate do
+                    ld   hl, vertices unless vertices==hl
+                    ld   b, [hl]                # b: z
+                    inc  hl                     # hl: -> y
+    matrix_loop     ld   sp, matrix
+    matrix_p        as matrix_loop + 1          # a label pointer to a matrix argument
+                    ld   d, [hl]                # d: y
+                    inc  hl                     # hl: -> x
+                    ld   e, [hl]                # e: x
+                    # af: x = qxx*x + qxy*y + qxz*z
+                    apply_matrix_row e, d, b, optimize:mx_optimize
+                    ex   af, af                 # a': new x
+                    # af: y = qyx*x + qyy*y + qyz*z
+                    apply_matrix_row e, d, b, optimize:mx_optimize
+                    ld   c, a                   # c: new y
+                    # af: z = qzx*x + qzy*y + qzz*z
+                    apply_matrix_row e, d, b, optimize:mx_optimize
+                    inc  hl                     # hl: -> xp
+    # calculate xp, yp
+                    exx
+    adjust_z_a      add  scrz0            # a: z + 128 (make Z positive)
+    adjust_z_p      as adjust_z_a + 1     # a label pointer to scrz0
+                    ld   c, a             # c: z
+    # xp = ((x << PERSP_DSHIFT)/(z + 128)) + scrx0
+                    ex   af, af           # a: x
+                    anda a                # clear CF, change SF
+                    jp   P, pos_x
+                    neg                   # CF: 1
+    pos_x           ld   e, a             # x
+                    ex   af, af           # f': CF: z sign
+                     # (x << PERSP_DSHIFT) / z
+                    sll8_16 persp_dshift, d, e # de: x << PERSP_DSHIFT
+                    divmod16_8 d, e, c, check0:x_overflow, check0_far:check0_far, check1:false, ignore_cf:true, optimize:optimize
+                    # jr   C, x_overflow    # z=0
+                    ld   a, d
+                    anda a
+                    jr   NZ, x_overflow   # de >= 256
+                                          # de < 256
+                    ex   af, af           # f: CF: sign
+    adjust_x_a      ld   a, scrx0         # x to screen coordinates
+    adjust_x_p      as adjust_x_a + 1     # a label pointer to scrx0
+                    jr   C, x_negative
+
+    x_positive      add  e                # x  >= 0
+                    jr   NC, skip_neg_x   # xp <  256
+                                          # xp >= 256
+    x_overflow      ld   a, 255           # store xp=255, yp=255 (out of screen)
+                    exx
+                    ld   [hl], a
+                    inc  hl
+                    jp   skip_overflow_x
+
+    x_negative      sub  e                # x  <  0: x to screen coordinates
+                    jr   C, x_overflow    # xp <  0
+    skip_neg_x      exx
+                    ld   [hl], a          # store xp
+                    inc  hl
+    # yp = -((y << PERSP_DSHIFT)/(z + 128)) + scry0
+                    ld   a, c             # y
+                    exx
+                    anda a
+                    jp   P, pos_y
+                    neg
+    pos_y           ld   e, a             # y
+                    ex   af, af           # f': CF: sign
+                    # (y << PERSP_DSHIFT) / z
+                    sll8_16 persp_dshift, d, e # de: y << PERSP_DSHIFT
+                    divmod16_8 d, e, c, check0:y_overflow, check0_far:check0_far, check1:false, ignore_cf:true, optimize:optimize
+                    # jr   C, y_overflow    # z=0
+                    ld   a, d
+                    anda a
+                    jr   NZ, y_overflow   # de >= 256
+                                          # de < 256
+                    ex   af, af           # f: CF: sign
+    adjust_y_a      ld   a, scry0         # y  >= 0
+    adjust_y_p      as adjust_y_a + 1        # a label pointer to scry0
+                    jr   C, y_negative
+
+    y_positive      sub  e                # y to screen coordinates
+                    jr   NC, skip_neg_y   # yp <  256
+
+    y_overflow      ld   a, 255           # yp >= 256
+                    jr   skip_neg_y
+
+    y_negative      add  e                # y  <  0: y to screen coordinates
+                    jr   C, y_overflow    # yp <  0
+    skip_neg_y      exx
+    skip_overflow_x ld   [hl], a          # store yp
+                    inc  hl               # -> z
+                    ld   a, [hl]          # a: z
+                    inc  hl
+                    cp   -128             # is end marker?
+                    ld   b, a             # b: z
+                    jp   NZ, matrix_loop
+  end
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+      
    
+        
+        
    
+          apply_matrix_element(x, clrhl:false, optimize: :time)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Applies a matrix element of the transformation matrix to a scalar.
    
+
+
    Matrix element should be a 16-bit fixed point twos complement signed number with an 8-bit fractional part.
    
+
+
    The address of a matrix element should be present in the stack pointer (sp) register.
    
+
+
    NOTE: The registers hl|bc|de are being swapped with alternatives before the multiplication, however x is read into the accumulator before swapping.
    
+
+
    A result is returned in the hl as a twos complement signed 16-bit integer:
    
+
+
    HL <-> HL'
+HL = [SP]*x
+or
+HL = HL + [SP]*x
    
+
+
    On completion sp points to the next matrix element (+2 bytes).
    
+
    x
+
    
+
    A signed 8-bit integer representing scalar as an 8-bit register or an address.
    
+
    
+
+
    Options:
    
+
    • clrhl
+
      
+
      Whether the result should be set (true) or added to the previous value (false).
      
+
      
+
    
+
+
    Modifies: sp, af, hl', bc', de', optionally preserves x, swaps registers.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/matrix.rb, line 231
+def apply_matrix_element(x, clrhl:false, optimize: :time)
+  isolate do |eoc|
+                ld   a, x unless x == a
+                exx
+                pop  bc     # bc: qxx = iiiiiiiiffffffff
+    if optimize == :size
+      multiply  mul8_signed(b, c, a, tt:bc, t:e, clrhl:clrhl, double:false, optimize: :size)
+    else
+      unless clrhl
+                ex   de, hl # de: sum
+      end
+      multiply  mul16_signed(b, c, a, tt:bc, optimize:optimize)
+      unless clrhl
+                add  hl, de # hl: add previous value
+      end
+    end
+  end
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+      
    
+        
+        
    
+          apply_matrix_row(x, y, z, optimize: :time)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Applies a row of the transformation matrix to a 3D vector.
    
+
+
    Each matrix element should be a 16-bit fixed point twos complement signed number with an 8-bit fractional part.
    
+
+
    The address of a matrix row should be present in the stack pointer (sp) register.
    
+
+
    A rounded result is returned in the accumulator as a twos complement signed 8-bit integer:
    
+
+
    A = INT(([SP]*x + [SP+2]*y + [SP+4]*z + 128) / 256)
+
    
+
+
    On completion sp points to the next matrix row elements (+6 bytes).
    
+
    x
+
    
+
    A signed 8-bit integer representing x coordinate as an 8-bit register or an address.
    
+
    y
+
    
+
    A signed 8-bit integer representing y coordinate as an 8-bit register or an address.
    
+
    z
+
    
+
    A signed 8-bit integer representing z coordinate as an 8-bit register or an address.
    
+
    
+
+
    Options:
    
+
    • tt
+
      
+
      A 16-bit temporary register de or bc from the alternative register set.
      
+
      
+
    • t
+
      
+
      An 8-bit temporary register from the alternative register set.
      
+
      
+
    
+
+
    Modifies: sp, af, hl', bc', de', preserves x, y, z.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/matrix.rb, line 189
+def apply_matrix_row(x, y, z, optimize: :time)
+  raise ArgumentError, "apply_matrix_row: invalid arguments" if y == a or z == a
+  isolate do
+                apply_matrix_element x, clrhl: true,  optimize:optimize #  qxx*x
+                exx
+                apply_matrix_element y, clrhl: false, optimize:optimize # +qxy*y
+                exx
+                apply_matrix_element z, clrhl: false, optimize:optimize # +qxz*z
+
+                xor  a
+                sla  l
+                adc  h                                 # (sum+128)/256
+
+                exx
+  end
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+    
    
+  
+  
    
+
+
    
+
+
+
+
diff --git a/Z80Lib3D/Primitives.html b/Z80Lib3D/Primitives.html
new file mode 100644
index 0000000..79ea606
--- /dev/null
+++ b/Z80Lib3D/Primitives.html
@@ -0,0 +1,126 @@
+
+
+
+
+
+
+module Z80Lib3D::Primitives - ruby-Z80
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    
+  
    
+    module Z80Lib3D::Primitives
+  
    
+
+  
    
+    
+
    Z80Lib3D::Primitives ↑
    
+
+
    3D primitives for Z80 program data.
    
+
+  
    
+
+  
+  
    
+    
+
+    
+
+    
+    
    
+      
    
+        
    Constants
    
+      
    
+      
    
+      
+        
    SinCos
+        
+        
    A Z80::Utils::SinCos table entry struct.
    
+
+
    Consists of two words:
    
+
    • 
+
      sin
      
+
    • 
+
      cos
      
+
    
+
+
    where each of them is a signed 16bit word (LSB 1st) fixed point number with the integral part in its high 8 bits and the fractional part in its low 8 bits. Each of them contain a corresponding trigonometric function value: [-1.0, 1.0].
    
+        
+      
+      
    
+    
    
+    
+
+    
+
+    
+  
    
+
+
    
+
+
+
+
diff --git a/Z80Lib3D/Primitives/Matrix.html b/Z80Lib3D/Primitives/Matrix.html
new file mode 100644
index 0000000..5e5cf5d
--- /dev/null
+++ b/Z80Lib3D/Primitives/Matrix.html
@@ -0,0 +1,131 @@
+
+
+
+
+
+
+class Z80Lib3D::Primitives::Matrix - ruby-Z80
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    
+  
    
+    class Z80Lib3D::Primitives::Matrix
+  
    
+
+  
    
+    
+
    Z80Lib3D::Primitives::Matrix ↑
    
+
+
    A type representing a transformation matrix 3x3.
    
+
+
    Each matrix element should be a 16-bit fixed point twos complement signed number with an 8-bit fractional part.
    
+
    • 
+
      xx: word
      
+
    • 
+
      xy: word
      
+
    • 
+
      xz: word
      
+
    • 
+
      yx: word
      
+
    • 
+
      yy: word
      
+
    • 
+
      yz: word
      
+
    • 
+
      zx: word
      
+
    • 
+
      zy: word
      
+
    • 
+
      zz: word
      
+
    
+
+  
    
+
+  
+  
    
+    
+
+    
+
+    
+
+    
+
+    
+  
    
+
+
    
+
+
+
+
diff --git a/Z80Lib3D/Primitives/Rotation.html b/Z80Lib3D/Primitives/Rotation.html
new file mode 100644
index 0000000..b97b75f
--- /dev/null
+++ b/Z80Lib3D/Primitives/Rotation.html
@@ -0,0 +1,125 @@
+
+
+
+
+
+
+class Z80Lib3D::Primitives::Rotation - ruby-Z80
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    
+  
    
+    class Z80Lib3D::Primitives::Rotation
+  
    
+
+  
    
+    
+
    Z80Lib3D::Primitives::Rotation ↑
    
+
+
    A type representing 3D rotation.
    
+
+
    Each rotation element should be a 16-bit fixed point twos complement signed number with an 8-bit fractional part.
    
+
    • 
+
      sin_a: word (yaw)
      
+
    • 
+
      cos_a: word (yaw)
      
+
    • 
+
      sin_b: word (pitch)
      
+
    • 
+
      cos_b: word (pitch)
      
+
    • 
+
      sin_c: word (roll)
      
+
    • 
+
      cos_c: word (roll)
      
+
    
+
+  
    
+
+  
+  
    
+    
+
+    
+
+    
+
+    
+
+    
+  
    
+
+
    
+
+
+
+
diff --git a/Z80Lib3D/Primitives/Vector.html b/Z80Lib3D/Primitives/Vector.html
new file mode 100644
index 0000000..bc91719
--- /dev/null
+++ b/Z80Lib3D/Primitives/Vector.html
@@ -0,0 +1,131 @@
+
+
+
+
+
+
+class Z80Lib3D::Primitives::Vector - ruby-Z80
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    
+  
    
+    class Z80Lib3D::Primitives::Vector
+  
    
+
+  
    
+    
+
    Z80Lib3D::Primitives::Vector ↑
    
+
+
    A 3 element vector of 8-bit signed integers:
    
+
    • 
+
      z: byte
      
+
    • 
+
      y: byte
      
+
    • 
+
      x: byte
      
+
    
+
+  
    
+
+  
+  
    
+    
+
+    
+
+    
+    
    
+      
    
+        
    Constants
    
+      
    
+      
    
+      
+        
    S
+        
+        
    A struct to represent Vector instances
    
+        
+      
+      
    
+    
    
+    
+
+    
+
+    
+  
    
+
+
    
+
+
+
+
diff --git a/Z80Lib3D/Primitives/Vertex.html b/Z80Lib3D/Primitives/Vertex.html
new file mode 100644
index 0000000..8c45c1a
--- /dev/null
+++ b/Z80Lib3D/Primitives/Vertex.html
@@ -0,0 +1,267 @@
+
+
+
+
+
+
+class Z80Lib3D::Primitives::Vertex - ruby-Z80
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    
+  
    
+    class Z80Lib3D::Primitives::Vertex
+  
    
+
+  
    
+    
+
    Z80Lib3D::Primitives::Vertex ↑
    
+
+
    A 3 element Vector and 2 screen coordinates:
    
+
    • 
+
      vec: Vector
      
+
    • 
+
      xp:  byte
      
+
    • 
+
      yp:  byte
      
+
    • 
+
      scr: word alias of yp|xp
      
+
    
+
+  
    
+
+  
+  
    
+    
+
+    
+
+    
+    
    
+      
    
+        
    Constants
    
+      
    
+      
    
+      
+        
    S
+        
+        
    A struct to represent Vertex instances
    
+        
+      
+      
    
+    
    
+    
+
+    
+
+    
+     
    
+       
    
+         
    Public Class Methods
    
+       
    
+
+    
+      
    
+        
+        
    
+          make(x, y, z, scrx0:128, scry0:128, scrz0:128, persp_dshift:7)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Creates a Vertex data argument for given coordinates.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/primitives.rb, line 46
+def Vertex.make(x, y, z, scrx0:128, scry0:128, scrz0:128, persp_dshift:7)
+  x, y, z = x.round, y.round, z.round
+  scrxmax = scrx0 * 2 - 1
+  scrymax = scry0 * 2 - 1
+  xp =  ((x << persp_dshift) / (z + scrz0)) + scrx0
+  yp = -((y << persp_dshift) / (z + scrz0)) + scry0
+  if xp < 0 || xp > scrxmax || yp < 0 || yp > scrymax
+    raise ArgumentError, "Vertex.make: vertex screen coordinates out of bounds"
+  end
+  S.new(Vector::S.new(z, y, x), xp, yp)
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+      
    
+        
+        
    
+          make_many(*args, scrx0:128, scry0:128, scrz0:128, persp_dshift:7)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Creates many Vertex data arguments from triplets: [x, y, z].
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/primitives.rb, line 59
+def Vertex.make_many(*args, scrx0:128, scry0:128, scrz0:128, persp_dshift:7)
+  args.map{|x, y, z| Vertex.make(x, y, z, scrx0:scrx0, scry0:scry0, scrz0:scrz0, persp_dshift:persp_dshift)}
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+      
    
+        
+        
    
+          scale(sc, vertex, scrx0:128, scry0:128, scrz0:128, persp_dshift:7)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Creates a re-scaled Vertex data arguments.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/primitives.rb, line 64
+def Vertex.scale(sc, vertex, scrx0:128, scry0:128, scrz0:128, persp_dshift:7)
+  if vertex.is_a?(Array)
+    vertex.map{|v| Vertex.scale(sc, v, scrx0:scrx0, scry0:scry0, scrz0:scrz0, persp_dshift:persp_dshift)}
+  else
+    vec = vertex.vec
+    Vertex.make(vec.x*sc, vec.y*sc, vec.z*sc, scrx0:scrx0, scry0:scry0, scrz0:scrz0, persp_dshift:persp_dshift)
+  end
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+    
    
+  
+  
    
+
+
    
+
+
+
+
diff --git a/Z80Lib3D/Quaternion.html b/Z80Lib3D/Quaternion.html
new file mode 100644
index 0000000..fe6690b
--- /dev/null
+++ b/Z80Lib3D/Quaternion.html
@@ -0,0 +1,376 @@
+
+
+
+
+
+
+module Z80Lib3D::Quaternion - ruby-Z80
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    
+  
    
+    module Z80Lib3D::Quaternion
+  
    
+
+  
    
+    
+
    Z80Lib3D::Quaternion ↑
    
+
+
    Quaternion related helper methods.
    
+
+  
    
+
+  
+  
    
+    
+
+    
+
+    
+
+    
+
+    
+     
    
+       
    
+         
    Public Instance Methods
    
+       
    
+
+    
+      
    
+        
+        
    
+          normalize_quaternion(q)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Returns a normalized quaternion.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/quaternion.rb, line 27
+def normalize_quaternion(q)
+  n = quaternion_norm(q)
+  s, x, y, z = q
+  [s/n, x/n, y/n, z/n]
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+      
    
+        
+        
    
+          quaternion2matrix(q)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Returns a transformation matrix from a quaternion.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/quaternion.rb, line 44
+def quaternion2matrix(q)
+  sq, xq, yq, zq = normalize_quaternion(q)
+
+  xq2 = xq*xq
+  yq2 = yq*yq
+  zq2 = zq*zq
+
+  xqyq = xq*yq
+  sqzq = sq*zq
+  xqzq = xq*zq
+  sqyq = sq*yq
+  yqzq = yq*zq
+  sqxq = sq*xq
+
+  qxx = 1.0 - 2.0*(yq2 + zq2)
+  qyy = 1.0 - 2.0*(xq2 + zq2)
+  qzz = 1.0 - 2.0*(xq2 + yq2)
+
+  qxy = (xqyq - sqzq)*2.0
+  qxz = (xqzq + sqyq)*2.0
+  qyx = (xqyq + sqzq)*2.0
+  qyz = (yqzq - sqxq)*2.0
+  qzx = (xqzq - sqyq)*2.0
+  qzy = (yqzq + sqxq)*2.0
+
+  [qxx, qxy, qxz,
+   qyx, qyy, qyz,
+   qzx, qzy, qzz]
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+      
    
+        
+        
    
+          quaternion_cross_product(a, b)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Returns a quaternion as a cross product of quaternions a and b.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/quaternion.rb, line 34
+def quaternion_cross_product(a, b)
+  sa, xa, ya, za = a
+  sb, xb, yb, zb = b
+  [sa*sb - xa*xb - ya*yb - za*zb,
+   sa*xb + sb*xa + ya*zb - yb*za,
+   sa*yb + sb*ya + za*xb - zb*xa,
+   sa*zb + sb*za + xa*yb - xb*ya]
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+      
    
+        
+        
    
+          quaternion_norm(q)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Returns a quaternion norm.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/quaternion.rb, line 22
+def quaternion_norm(q)
+  sqrt(quaternion_norm_q(q))
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+      
    
+        
+        
    
+          quaternion_norm_q(q)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Returns a quaternion square norm.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/quaternion.rb, line 16
+def quaternion_norm_q(q)
+  s, x, y, z = q
+  s*s + x*x + y*y + z*z
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+      
    
+        
+        
    
+          rotor_quaternion(rad, av)
+          
+          click to toggle source
+          
+        
    
+        
+
+        
    
+          
+          
    Returns a rotor quaternion from radians and a unit vector.
    
+          
+          
+
+          
+          
    
+            
    # File lib/z80lib3d/quaternion.rb, line 9
+def rotor_quaternion(rad, av)
+  sn = sin(rad/2)
+  x, y, z = av
+  [cos(rad/2),sn*x,sn*y,sn*z]
+end
    
+          
    
+          
+        
    
+
+        
+
+        
+      
    
+
+    
+    
    
+  
+  
    
+
+
    
+
+
+
+
diff --git a/ZXLib/Gfx/Draw/Macros.html b/ZXLib/Gfx/Draw/Macros.html
index 177d52a..8e3fa0b 100644
--- a/ZXLib/Gfx/Draw/Macros.html
+++ b/ZXLib/Gfx/Draw/Macros.html
@@ -503,7 +503,7 @@ 
    Public Instance Methods
    
     end
                   ld   tmp, dy
                   ld   xcount, dx
-                  divmod xcount, tmp, check0:horizontal, check1: true
+                  divmod xcount, tmp, check0:horizontal, check0_far:false, check1:true, k_leq_m:false, ignore_cf:true
                                          # xcount: int(dx/dy), a: dx%dy
                   ld   quot, xcount      # quot: int(dx/dy)
                   ld   size, xcount      # size: quot
diff --git a/ZXLib/Gfx/Macros.html b/ZXLib/Gfx/Macros.html
index c52a0a4..24dde65 100644
--- a/ZXLib/Gfx/Macros.html
+++ b/ZXLib/Gfx/Macros.html
@@ -240,7 +240,7 @@ 
    Public Instance Methods
    
 
           
           
    
-            
    # File lib/zxlib/gfx.rb, line 837
+            
    # File lib/zxlib/gfx.rb, line 838
 def clear_attrs_region_fast(address=hl, rows=a, cols=2, value=0, disable_intr:true, enable_intr:true, save_sp:true, addr_mode: :optimal, unroll_rows:false, scraddr:nil, subroutine:false)
   raise ArgumentError, "invalid scraddr argument" unless scraddr.nil? or (Integer === scraddr and scraddr == (scraddr & 0xE000)) or direct_label?(scraddr)
   raise ArgumentError, "address should be an address or a pointer or hl" unless address == hl or address?(address)
@@ -571,6 +571,7 @@ 
    Public Instance Methods
    
         end
       end
     end
+                  ld   c, 8 unless fits_single_row
                   di if disable_intr
                   ld   [restore_sp_p], sp if save_sp
     loop0         label
@@ -595,10 +596,10 @@ 
    Public Instance Methods
    
                   jr   C, skip_adj unless scraddr
                   ld   a, h
                   jr   C, check_oos if scraddr
-                  sub  0x08
+                  sub  c          # c: 8
                   ld   h, a
       skip_adj    ex   af, af     # a: remaining lines
-                  ld   b, 8
+                  ld   b, c       # c: 8
                   sub  b
                   jr   NC, loop0
                   add  b
@@ -691,7 +692,7 @@ 
    Public Instance Methods
    
 
           
           
    
-            
    # File lib/zxlib/gfx.rb, line 1136
+            
    # File lib/zxlib/gfx.rb, line 1154
 def copy_shadow_attrs_region(address=de, rows=a, cols=c, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, subroutine:false)
   raise ArgumentError, "invalid tgtaddr argument" unless (Integer === tgtaddr and tgtaddr == (tgtaddr & 0xE000)) or direct_label?(tgtaddr)
   raise ArgumentError, "invalid srcaddr argument" unless (Integer === srcaddr and srcaddr == (srcaddr & 0xE000)) or direct_label?(srcaddr)
@@ -832,7 +833,7 @@ 
    Public Instance Methods
    
 
           
           
    
-            
    # File lib/zxlib/gfx.rb, line 1378
+            
    # File lib/zxlib/gfx.rb, line 1396
 def copy_shadow_attrs_region_quick(address=de, rows=b, cols=32, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, size_limit_opt:false, subroutine:false)
   raise ArgumentError, "invalid tgtaddr argument" unless (Integer === tgtaddr and tgtaddr == (tgtaddr & 0xE000)) or direct_label?(tgtaddr)
   raise ArgumentError, "invalid srcaddr argument" unless (Integer === srcaddr and srcaddr == (srcaddr & 0xE000)) or direct_label?(srcaddr)
@@ -954,7 +955,7 @@ 
    Public Instance Methods
    
 
 
    NOTE
 
    
-
    Unless cols is one of: ixh, ixl, iyh or iyl the routine uses self modifying code.
    
+
    Unless cols is a direct label or one of: ixh, ixl, iyh or iyl the routine uses self modifying code.
    
 
    
 
 
    Options:
    
@@ -986,7 +987,7 @@ 
    Public Instance Methods
    
 
           
           
    
-            
    # File lib/zxlib/gfx.rb, line 1003
+            
    # File lib/zxlib/gfx.rb, line 1005
 def copy_shadow_screen_region(address=de, lines=a, cols=c, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, subroutine:false)
   raise ArgumentError, "invalid tgtaddr argument" unless (Integer === tgtaddr and tgtaddr == (tgtaddr & 0xE000)) or direct_label?(tgtaddr)
   raise ArgumentError, "invalid srcaddr argument" unless (Integer === srcaddr and srcaddr == (srcaddr & 0xE000)) or direct_label?(srcaddr)
@@ -995,12 +996,15 @@ 
    Public Instance Methods
    
   raise ArgumentError, "address should be an address or a pointer or de" unless address == de or address?(address)
   raise ArgumentError, "lines should be a label or a pointer or a register" unless (register?(lines) and lines.bit8?) or
                                                                                   address?(lines)
-  raise ArgumentError, "cols should be a label or a pointer or a register" unless (register?(lines) and lines.bit8?) or
-                                                                                  address?(lines)
+  raise ArgumentError, "cols should be a label or a pointer or a register" unless (register?(cols) and cols.bit8?) or
+                                                                                  address?(cols)
+  fits_single_row = Integer === address && Integer === lines && lines <= (8 - (address>>8) % 8)
   isolate do |eoc|
+    unless fits_single_row
                     ld   a, lines unless lines == a
                     ex   af, af     # a': lines
-    unless [ixh,ixl,iyh,iyl].include?(cols)
+    end
+    unless [ixh,ixl,iyh,iyl].include?(cols) || direct_address?(cols)
                     ld   a, cols unless cols == a
                     ld   [cols_p], a
                     ld   c, a if check_edge && cols != c
@@ -1008,18 +1012,26 @@ 
    Public Instance Methods
    
                     ld   b, 0
                     ld   de, address unless address == de
     if direct_address?(address)
+      if fits_single_row
+                    ld   h, ((address>>8) + (scrdiff>>8)) & 0xff
+      else
                     ld   a, d
                     add  scrdiff>>8
                     ld   h, a
+      end
                     ld   a, e
                     exx
+      if fits_single_row
+                    ld   b, lines
+      else
                     ld   b, 8 - (address>>8) % 8
+      end
     else
       if check_edge
         ns do |eoc|
                     ld   a, e
                     ora  ~31
-          if [ixh,ixl,iyh,iyl].include?(cols)
+          if [ixh,ixl,iyh,iyl].include?(cols) || direct_address?(cols)
                     add  cols
           else
                     add  c
@@ -1042,6 +1054,7 @@ 
    Public Instance Methods
    
                     ld   a, e
                     exx
     end
+    unless fits_single_row
                     ex   af, af     # a: lines, a': lo
                     ld   c, a       # c: lines
                     dec  a          # a: lines - 1 (remaining lines)
@@ -1049,11 +1062,12 @@ 
    Public Instance Methods
    
                     jr   NC, start
                     ld   b, c       # b: counter = c: lines
 
-    start           ex   af, af     # a': remaining rows - 1; CF': 1 == last batch, a: lo
+      start         ex   af, af     # a': remaining rows - 1; CF': 1 == last batch, a: lo
+    end
     rloop           exx
     loop0           ld   e, a
     loop1           ld   l, a
-    if [ixh,ixl,iyh,iyl].include?(cols)
+    if [ixh,ixl,iyh,iyl].include?(cols) || direct_address?(cols)
                     ld   c, cols
     else
       cols_a        ld   c, 0 # self-modified
@@ -1066,12 +1080,14 @@ 
    Public Instance Methods
    
                     inc  h
                     exx
                     djnz rloop
+                    ret if subroutine && fits_single_row
+    unless fits_single_row
                     ex   af, af     # a: remaining lines, a': lo
-    if subroutine
+      if subroutine
                     ret  C
-    else
+      else
                     jr   C, eoc
-    end
+      end
                     ld   b, 8
                     sub  b
                     jr   NC, loop8
@@ -1079,7 +1095,7 @@ 
    Public Instance Methods
    
                     ld   b, a
                     inc  b
 
-    loop8           exx
+      loop8         exx
                     ex   af, af     # a: lo, a': remaining lines
                     add  0x20       # a: lo + 0x20
                     jr   C, loop0 unless break_oos
@@ -1092,11 +1108,12 @@ 
    Public Instance Methods
    
                     ld   h, a
                     ld   a, e
                     jp   loop1
-    if break_oos
-      check_ooscr   cp   (tgtaddr >> 8)|0x18
+      if break_oos
+        check_ooscr cp   (tgtaddr >> 8)|0x18
                     ld   a, e
                     jr   C, loop1
                     ret if subroutine
+      end
     end
   end
 end
    
@@ -1171,7 +1188,7 @@ 
    Public Instance Methods
    
 
           
           
    
-            
    # File lib/zxlib/gfx.rb, line 1225
+            
    # File lib/zxlib/gfx.rb, line 1243
 def copy_shadow_screen_region_quick(address=de, lines=c, cols=32, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, size_limit_opt:false, subroutine:false)
   raise ArgumentError, "invalid tgtaddr argument" unless (Integer === tgtaddr and tgtaddr == (tgtaddr & 0xE000)) or direct_label?(tgtaddr)
   raise ArgumentError, "invalid srcaddr argument" unless (Integer === srcaddr and srcaddr == (srcaddr & 0xE000)) or direct_label?(srcaddr)
diff --git a/ZXLib/Sys/Macros.html b/ZXLib/Sys/Macros.html
index fe1cdc5..92808d7 100644
--- a/ZXLib/Sys/Macros.html
+++ b/ZXLib/Sys/Macros.html
@@ -783,11 +783,11 @@ 
    Public Instance Methods
    
 
    Options:
    
 
    • bank
 
      
-
      Selects a memory bank available at 0xC000-0xFFFF as an integer or any of the 8-bit registers except a, or indirect memory address via a 16-bit register. In this instance you should pass true to the screen: option if bit-4 of  the bank should select a screen to be displayed.
      
+
      Selects a memory bank available at 0xC000-0xFFFF as an integer or any of the 8-bit registers except a, or indirect memory address via a 16-bit register. In this instance you should pass true to the screen: option if bit-3 of  the bank should select a screen to be displayed.
      
 
      
 
    • screen
 
      
-
      0 - Display screen from bank 5. 1 - Display screen from bank 7. true to preserve screen bit-4 from the bank register.
      
+
      0 - Display screen from bank 5. 1 - Display screen from bank 7. nil to preserve screen bit-3 from the bank register.
      
 
      
 
    • disable_intr
 
      
diff --git a/created.rid b/created.rid
index 630fb5c..005992e 100644
--- a/created.rid
+++ b/created.rid
@@ -1,11 +1,11 @@
-Wed, 10 Jan 2024 21:58:26 +0100
+Sat, 20 Jan 2024 14:04:29 +0100
 README.rdoc	Mon, 08 Jan 2024 22:28:06 +0100
 LICENSE.md	Tue, 12 Nov 2019 19:21:22 +0100
-CHANGELOG.md	Thu, 04 Jan 2024 05:06:44 +0100
+CHANGELOG.md	Fri, 12 Jan 2024 23:37:32 +0100
 lib/z80.rb	Wed, 04 Jan 2023 15:29:22 +0100
 lib/z80/labels.rb	Wed, 04 Jan 2023 15:09:14 +0100
 lib/z80/macros.rb	Wed, 04 Jan 2023 15:09:46 +0100
-lib/z80/math_i.rb	Wed, 10 Jan 2024 21:56:01 +0100
+lib/z80/math_i.rb	Sat, 20 Jan 2024 13:54:34 +0100
 lib/z80/mnemonics.rb	Wed, 04 Jan 2023 15:13:54 +0100
 lib/z80/registers.rb	Wed, 04 Jan 2023 15:14:26 +0100
 lib/z80/select.rb	Wed, 04 Jan 2023 15:14:50 +0100
@@ -13,17 +13,17 @@ lib/z80/stdlib.rb	Fri, 29 Oct 2021 02:54:07 +0200
 lib/z80/tap.rb	Wed, 04 Jan 2023 15:15:55 +0100
 lib/z80/version.rb	Wed, 04 Jan 2023 15:16:41 +0100
 lib/z80/utils/shuffle.rb	Mon, 12 Dec 2022 04:30:31 +0100
-lib/z80/utils/sincos.rb	Tue, 09 Nov 2021 15:00:20 +0100
+lib/z80/utils/sincos.rb	Mon, 15 Jan 2024 03:47:23 +0100
 lib/z80/utils/sort.rb	Tue, 13 Dec 2022 02:14:11 +0100
 lib/z80/utils/vec_deque.rb	Tue, 02 Nov 2021 19:29:36 +0100
 lib/zxlib/ay_sound.rb	Tue, 02 Nov 2021 19:23:20 +0100
 lib/zxlib/basic.rb	Wed, 04 Jan 2023 15:18:40 +0100
-lib/zxlib/gfx.rb	Tue, 23 Nov 2021 01:49:00 +0100
+lib/zxlib/gfx.rb	Sun, 14 Jan 2024 02:30:48 +0100
 lib/zxlib/math.rb	Tue, 02 Nov 2021 19:23:37 +0100
-lib/zxlib/sys.rb	Wed, 10 Jan 2024 01:32:06 +0100
+lib/zxlib/sys.rb	Sun, 14 Jan 2024 01:22:24 +0100
 lib/zxlib/gfx/bobs.rb	Sun, 14 Nov 2021 16:06:20 +0100
 lib/zxlib/gfx/clip.rb	Fri, 29 Oct 2021 02:54:09 +0200
-lib/zxlib/gfx/draw.rb	Fri, 26 Nov 2021 23:26:23 +0100
+lib/zxlib/gfx/draw.rb	Wed, 17 Jan 2024 16:18:22 +0100
 lib/zxlib/gfx/sprite8.rb	Sun, 07 Nov 2021 15:06:42 +0100
 lib/zxutils/ay_music.rb	Wed, 10 Nov 2021 17:10:03 +0100
 lib/zxutils/ay_music_player.rb	Tue, 02 Nov 2021 19:45:34 +0100
@@ -40,3 +40,7 @@ lib/zxutils/music_box/multitrack.rb	Wed, 04 Jan 2023 15:23:44 +0100
 lib/zxutils/music_box/resolver.rb	Wed, 04 Jan 2023 15:24:14 +0100
 lib/zxutils/music_box/song.rb	Wed, 04 Jan 2023 15:25:13 +0100
 lib/zxutils/music_box/track.rb	Wed, 04 Jan 2023 15:27:33 +0100
+lib/z80lib3d/fixed_float.rb	Fri, 12 Jan 2024 00:31:48 +0100
+lib/z80lib3d/matrix.rb	Sat, 20 Jan 2024 14:01:41 +0100
+lib/z80lib3d/primitives.rb	Fri, 12 Jan 2024 14:06:05 +0100
+lib/z80lib3d/quaternion.rb	Fri, 12 Jan 2024 00:30:23 +0100
diff --git a/examples/ghosts.tap b/examples/ghosts.tap
index c27994231cc95775ab90635653efcaff6eff27ad..f0c8b66364f8234e0f18ea898f950067007d756f 100644
GIT binary patch
delta 1396
zcmaJ>eQXnD7{BY+u61p1V{5uGw_Z1A2ZeRt#~_z2DkU*&BN9fiGB8S!sErKwO*a-z
z6)@X;WB82JV8Ys7`>v~T;*8=>ND6tGU`DtZ%(mEq!73^ngJp+zo%2ubk9&U4@Ao{v
z%lp31dkgEvtNW|96}Iwn9fsY9SoPK21G&b5rc|QBR#7H$i{a)fTwP(Sl9IF`5W%ni
zFM*F_qoPzg;&SqN$4G3J!Z7Pj>o%*~Y90kj
z-P)(i{k&?9yXqI_ZR%T;&1;Zx<^EgLE^meyL4z(+R^|sz-7~4X{FhSndVO5Z9rpvT
zvH{%D6;~slo%_-kv1Cc!t44j?eZOceE_mePtkpd-cGtgHiD8MxnaQ&YE!^Z;epQPj
z|KJy6IRUUmU$OPMz~(od?W-*sPhy`cUz%~ETUE90yo1J_0hz6o05FMO|t`5^4_`HyAU*;`M9wwi*L>1$@!>I
za(OBs*e++Xb0&ha2XQr)CKs|tOnM>_wkR1Hr-4k`Kzj6j*U?X$#J3iLks}R+>Cx;%
z!piiUH&%M6SA$8>oxjHwW5AKL-0pgI58K8bW>2wR_8iNyVV0T?s%oH7=FTUWnttBS
z)byY~gH
zArt_L70-4%15C7ZUx3;G&3l5>T4>%Iq%^P+!(~|7Q!p_^9f6!3{v<>vs3Mr$ft|Yb
z3}GOV8!|?NNetJb7?zVaB~~IkWE4mXxx*}VYANHiFs54%4FqzD=PY#@j7ew_;j}?*
zOC~gOgUE^<_)(zC$lH1#h}yi=$su#4W15fhF?7^B%`Zrx>$4?dID~!_p~S&bxloD;
z$QN34UlmGBuQPb5+EJ=;RJS=wTO8;}09_BEDR3wwcayYgIG);aDpPwjlW)z
zI?+EY8V*76)Q#VuWF3xSy!5q;6S2h0$HLT!@Rf~YABF|fU7Pix>zl@3-gfn_AC#O@$qgA;WL-sZ%UOE;T&McPW??q;e
HS&DxF!O~^~

delta 1315
zcmZuxeM}Q)7{9xga;lP+jsGn0
z9`OaTs;iL|6=E-_%5aNa33>$uJ;-e-#4uI+s~w$hcAC-EScCP=cBa~)Pid{dE$z>!=>)NNw$+3vfqBM*P|Ba
zV***C#6ap(Va
zf{VFLxvSZ+nU`ADYcP56E(sQMZSFc&_%U6XDj5-7gBvV9wrsvbnA_mD>gueIny%z~
z#5T5W^m$f%H+U>QGlzn0ZMNMuzs=$U`|~PRPqLC`UOW^`KeTIa)AoRY5GUE&^vi)F
zR6$R6F>#9pA7($5qYhrl&d<+Jsl>V<2xRR9%gIXjLDnPgWn)&8l3ng&#gBq08a+XL
zY|iG7kM;#0J26ady*qVju}hq~B$ao0OHX`0IuZoo{LOXuf=#ctA6;+NosnO&t4#K9
zsQLAlF7F8`fi~RCrabK7RQ8DRFT@Og`ckS>t;bV$4%-eXHdsR$2vnR@du|pwmBJ?{
z1A^4{tjrmK12^wmhOG7OpxUSEo9ky$z2la>y*r-3^&)gS)
z@4~s(Zj*G_BvB6&>5W%Uhtl?|!=ZUINzZb)7SpTJE8^ySQjS`)7(yK48T~*(;_Z&J
zAGDKSTS-O*hj^hNvEpQUWx?dlm1pR@Ffzd{eOb?JNXM<>D!6)XE4Q87$?f9k%VAA}
zU?lvdB-79@d6V&gAqlUx0Si#YrB_IYO0e&rBg>Q*z43#Qe7jv3S>VE)CsYV(A

diff --git a/examples/labyrinth.tap b/examples/labyrinth.tap
index d8f6a01d126aee7b6198d61c5108382fe22ed924..d5632ba37361d86dd2400fc8c076e5accf6ab71b 100644
GIT binary patch
delta 306
zcmV-20nPr~4*3qSj{y(g1pt5mfQI1({}>JxAK#On0azyWgW2UcD$N6d&9s2c!h`_;
z03kPm&G>-L%zzOAf6c~#&9i{bWwRUtr2zrLlfnZo4Z?&N4?2xp_CW4G&4!cx1N46k
z%OT4U%R4am3Bp-}$=S^df#uoZ?OP0hud>3tgL}L%2?hwS%Op4y5c((te8ZcAufv;z
zlMn;Ln}f?FkGnAR5cmcN%O#IE1-mc;5C@Yi5Cg-wgUcn4IP|+P@euY;!|Q{uPX-Vv
zI0g{=!|Q`7%Mp*dFa;3z!|H?GZ+S5w3cD}|-F*<~!|H>RPu+c*5Z*^B3V;dAe#paS
zgDQ4h*(wNtEA2}LfVb^J*yYV;lY<3M0cMla1uOy=gp&aV-3i--^D1~;+0AB?=LT~D
E#K9Gdpa1{>

delta 276
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
k{m@Q39PQBWaOb`>{h5!Hn

literal 8557
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
D5*PS-

diff --git a/examples/quat3d128.tap b/examples/quat3d128.tap
index e055c65c53e5535f47d15d608c2edb87f8c6a517..496d2ada658cb51aac4d38b3a2c5232665975391 100644
GIT binary patch
delta 3835
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
Z;RCDt^6`n)h4{qE!tNFMM{_dX{u{_Np}hbA

diff --git a/examples/stars.tap b/examples/stars.tap
index 5c2da9ff1a032cba2dcc9cd3359f0e90839152c3..afcdbcd39cdf28837ab4802039720f4c4ae8d92c 100644
GIT binary patch
delta 535
zcmZo+U&1~ilHJsVkAZ>d)5L@#JriLD2Ik_D#G+ya5ZJ-Q@PVPBZx_@5n@`W4{J8%1
zKmBL&3P0@J&o23RmhsahMy2`>*^rGKZvCxIWQRoFOAtM*&4?lfQ$;Fx&Y6ezpr14!ia&U%9n0^d%n)+|@x
z;IQDUJ=S2rSIMzHJU#z#_D8#hsTQB|UqdZ?foUPnN05a)A0Za=KGi(450AZiHujTJ^yDZe)wtas
zPbxAvm@zQ^7Z+r7c)I}@JbyvK^GmBN<|Z41AOpkIn?TjEVhkWnu^{aT#!Z1oHLATY1eh34VV5ZxQKtYs(+r
z6gUjhda`EiGiL=RJI1^D5}Oqn7?f+b9Lk-n$!x|rWpVBsfA
z|LH%ISNLJ)ezxJ`*}ESnF)G#fe3THg^7^=3iVtiY>rbm#unYV;Jmte_mHwRu
zYyv;*f$WJY0w1=sahz7|x8T@mz$)hMm;rB^4hP!%6O|V
dTClass and Module Index
    
   
     
  • Z80::Utils::VecDeque::VecDequeState
   
+    
  • Z80Lib3D
+  
+    
  • Z80Lib3D::Matrix3D
+  
+    
  • Z80Lib3D::Matrix3D::Macros
+  
+    
  • Z80Lib3D::Primitives
+  
+    
  • Z80Lib3D::Primitives::Matrix
+  
+    
  • Z80Lib3D::Primitives::Rotation
+  
+    
  • Z80Lib3D::Primitives::SinCos
+  
+    
  • Z80Lib3D::Primitives::Vector
+  
+    
  • Z80Lib3D::Primitives::Vertex
+  
+    
  • Z80Lib3D::Quaternion
+  
     
  • ZX7
   
     
  • ZX7::Macros
diff --git a/js/search_index.js b/js/search_index.js
index 1ff977e..9553f7e 100644
--- a/js/search_index.js
+++ b/js/search_index.js
@@ -1 +1 @@
-var search_data = {"index":{"searchIndex":["aytest","bench","echo","float","musictest","object","symbol","z80","alloc","compileerror","conditionalblock","label","mathint","integers","macros","program","condition","macros","mnemonics","register","stdlib","macros","syntax","tap","headerbody","tapeerror","tzx","utils","shuffle","macros","sincos","macros","sincos","sincostable","sort","macros","vecdeque","macros","vecdequestate","zx7","macros","zxlib","aysound","envelopecontrol","macros","mixer","registers","volumecontrol","basic","line","program","tokenizer","patterns","variable","variableparseerror","variabletypes","vars","gfx","bobs","macros","clip","macros","outcode","draw","constants","macros","macros","sprite8","macros","math","macros","zxreal","sys","coords","cursor","if1vars","macros","strms","vars","vars128","zxutils","aybasicplayer","aymusic","ayregistermirror","channelcontrol","chordcontrol","envelopecontrol","instrumentcontrol","macros","maskcontrol","musiccontrol","toneprogresscontrol","trackcontrol","trackstackentry","vibratocontrol","aymusicplayer","musictracks","trackinfo","benchmark","macros","bigfont","macros","bigfonthires","emu","gallery","formats","multitasking","macros","taskinfo","taskvars","multitaskingio","bufferio","macros","taskvarsio","musicbox","ayenvelopedurationcommand","ayenvelopeshapecommand","chord","chordcommand","command","headers","metacommand","commoninstrumentcommands","emptytrack","envelope","envelopecommand","indexcommand","instrument","instrumentcommand","instrumentcommands","loopcommand","markcommand","mask","maskcommand","multitrack","multitrackcommands","noisepitchcommand","notechordcommand","notecommand","noteprogressperiodcommand","pausecommand","resolver","song","playermodule","songmodule","songcommands","subinstrumentcommand","subtrackcommand","toneprogresscommand","track","trackcommands","trackconfigcommands","vibratoamplitudecommand","vibratoanglecommand","vibratostepcommand","volumelevelcommand","%()","%()","&()","&()","*()","*()","**()","**()","+()","+()","+()","+@()","+@()","+@()","-()","-()","-()","-@()","-@()","/()","/()","<<()","<<()","<<()","==()",">>()",">>()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","^()","^()","add24_16()","add_code()","add_reloc()","adda_to()","addr()","address?()","alias?()","alias?()","alias_label()","all_ch()","all_channels()","api()","array?()","array?()","as()","ay_expand_notes()","ay_expand_notes_faster()","ay_get_register_value()","ay_get_set_env_shape()","ay_get_set_mixer()","ay_hz2tp()","ay_init()","ay_io_load_const_reg_bc()","ay_io_swap2inp_bc()","ay_io_swap2out_bc()","ay_io_swap2sel_bc()","ay_music_finished?()","ay_music_init()","ay_music_note_to_fine_tone_cursor_table_factory()","ay_music_preserve_io_ports_state()","ay_music_tone_progress_table_factory()","ay_set_envelope_duration()","ay_set_noise_pitch()","ay_set_register_value()","ay_set_tone_period()","ay_set_volume()","ay_tone_periods()","bcdtoa()","bench()","bit8?()","bobs_copy_attrs()","bobs_copy_attrs_fast()","bobs_copy_pixels()","bobs_copy_pixels_fast()","bobs_draw_pixels_fast()","bobs_draw_pixels_fast_jump_table()","bobs_draw_pixels_fast_routines()","bobs_rshift_bitmap_pixels_7times()","bobs_rshift_bitmap_pixels_once()","byte()","bytes()","bytesize()","bytesize()","byteslice()","calculate_benchmark_tstates()","ce()","ceo()","ch_a()","ch_b()","ch_c()","chan_exists()","channel()","channel_name_to_index()","channel_track()","char_array?()","char_ptr_from_code()","chord()","chord_off()","clear!()","clear_attrs_region_fast()","clear_screen_region_fast()","clrmem()","clrmem8()","clrmem_fastest()","clrmem_quick()","cmp_i16n()","cmp_i16r()","cmp_i8()","code()","code()","code?()","compress()","copy_shadow_attrs_region()","copy_shadow_attrs_region_quick()","copy_shadow_screen_region()","copy_shadow_screen_region_quick()","cp16n()","cp16r()","cp16rr()","create_chan_and_open()","create_sincos_from_sintable()","cursor_key_pressed?()","data()","db()","dc!()","debug()","debug_comment()","define_label()","direct_address?()","direct_label?()","disable_ay_volume_ctrl()","divmod()","divmod16()","divmod24_8()","divmod32_16()","divmod32_8()","divmod8()","draw_line()","draw_line_dx_gt_4dy()","draw_line_dx_gt_dy()","draw_line_dy_gte_dx()","draw_line_fx_data()","draw_line_fx_data_dx_gt_4dy()","draw_line_fx_data_dx_gt_dy()","draw_line_fx_data_dy_gte_dx()","draw_line_fx_data_vertical()","draw_line_update()","draw_line_update_dx_gt_4dy()","draw_line_update_dx_gt_dy()","draw_line_update_dy_gte_dx()","draw_line_update_vertical()","draw_line_vertical()","draw_sprite8()","dummy()","dummy?()","dummy?()","dup()","dw()","dzx7_agilercs()","dzx7_mega()","dzx7_smartrcs()","dzx7_standard()","dzx7_turbo()","each_var()","ei()","else()","else_select()","enable_ay_volume_ctrl()","enlarge_char8_16()","envd()","envdur()","envelope()","envelope_duration()","envelope_shape()","envs()","envsh()","equal_tempered_scale_notes_hz()","estimate_tstates_per_interrupt()","export()","expression?()","expression?()","find_channel()","find_channel_arg()","find_def_fn_args()","find_emulator()","find_input_handle()","find_io_handles()","find_output_handle()","find_record()","first_octave_note()","fixed_volume()","for_ch()","for_channels()","for_loop?()","fp_to_integer32()","from_data()","from_program_data()","from_tap_chunk()","fv()","get()","get_adjustment()","get_counter()","get_emulator_path()","get_frames()","get_idle()","get_int8_norm_arg()","get_stream_arg()","getset_tsframe()","gfx_clip_calculate_8bit_dx_dy_exx()","gfx_clip_compute_outcode()","gfx_clip_coords_to_draw_line_args()","gfx_clip_dimension()","gfx_clip_line()","gfx_sprite8_calculate_coords()","gfx_sprite8_calculate_screen_address()","gfx_sprite8_draw()","gfx_sprite8_flip_horizontally()","head()","i()","immediate?()","immediate?()","immediate?()","import()","import_chord()","import_envelope()","import_file()","import_instrument()","import_mask()","import_multitrack()","import_track()","include?()","indexable?()","indexable?()","init()","init()","init_multitasking()","init_music()","initialize()","initialize_io()","insertion_sort_bytes_max256()","instrument()","instruments()","int()","integer32_to_fp()","interlace_pixels16()","isolate()","jr_ok?()","kernel_org()","kernel_org()","key_pressed?()","label()","label?()","label_defined?()","label_immediate?()","label_import()","ld16()","length()","limit()","line()","line_index()","list()","loop_to()","loop_to()","lt()","lt()","m()","m()","m1()","m2()","macro()","macro_import()","make_draw_line_subroutines()","mark()","mark()","mask()","mask_ay_volume_envelope()","mask_ay_volume_envelope_off()","mask_noise()","mask_noise_off()","mask_tone()","mask_tone_off()","match16?()","me()","members_of_struct()","memcpy()","memcpy_quick()","meo()","method_missing()","method_missing()","method_missing()","method_missing()","mix_lines8_16()","mmu128_select_bank()","mmu128_swap_screens()","mn()","mno()","mode1()","mode2()","move_basic_above_scld_screen_memory()","mt()","mtio_drain()","mtio_getc()","mtio_gets()","mtio_putc()","mtio_puts()","mtio_ready?()","mtio_wait()","mto()","mul()","mul16_32()","mul8()","mul8_24()","mul8_c()","mul8_signed()","mul_const()","mul_const8_24()","mul_signed()","mul_signed9()","mul_signed9_24()","multitrack()","mute_sound()","n()","n0()","n1()","name=()","name=()","names()","names()","ne()","neg16()","neg_int()","neg_sintable256_pi_half_no_zero_lo()","neo()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new_char_array()","new_code()","new_for_loop()","new_kernel()","new_kernel()","new_number()","new_number_array()","new_program()","new_string()","new_var_array()","next_token()","nextline()","nextpixel()","nextrow()","noise()","noise_envelope_off()","noise_off()","noise_on()","note_progress()","np()","ns()","number?()","number_array?()","offset_of_()","one_of?()","one_of?()","only_one_bit_set_or_zero?()","open_io()","org()","p()","p()","pack_number()","parse_each()","parse_file()","parse_file()","parse_source()","parse_source_line()","parse_tap()","parse_tap()","pause()","pause()","pc()","pch()","peek_token()","play()","play()","play_chord()","play_interval()","play_loop()","plot_pixel()","pointer?()","pointer?()","pointer?()","pointer?()","prepare_args_draw_line_to()","preshifted_pixel_mask_data()","prevline()","prevpixel()","print_char()","print_char_hires()","print_fp_hl()","program?()","program_text_to_string()","quicksort_bytes()","rctoattr()","rctoscr()","rdoc_mark_find_def_fn_arg()","read_arg_string()","read_chunk()","read_chunk()","read_data()","read_data()","read_integer32_value()","read_integer_value()","read_positive_int_value()","read_source()","read_tap()","register?()","reinitialize()","repeat()","repeat()","report_error()","report_error_unless()","respond_to_missing?()","restore_rom_interrupt_handler()","return_with_fp()","rnd()","rpt()","rpt()","run()","save_tap()","save_tap()","save_tap()","screen?()","scrtoattr()","select()","selection_sort_bytes_max256()","set_empty_instrument()","set_instrument()","setup()","setup_custom_interrupt_handler()","shuffle_bytes_source_max256()","sign_extend()","sincos_from_angle()","sincos_table_descriptors()","size()","spawn()","split()","stack_space_free()","start()","start()","start_chord()","start_noise_envelope()","start_volume_envelope()","statement()","step()","string?()","string_to_program_text()","sub()","sub()","sub()","sub_from()","sub_instrument()","sub_track()","sub_track()","sublabel?()","sublabel?()","sublabel_access_expression?()","sublabel_access_expression?()","synchronize_channels()","t0()","t1()","task?()","task_id()","task_stack_bytes_free()","task_yield()","tempo()","terminate()","terminated?()","text()","then()","ticks_counter()","to_a()","to_aliased_name()","to_aliased_name()","to_alloc()","to_alloc()","to_data()","to_debug()","to_i()","to_i()","to_i()","to_i()","to_i()","to_label()","to_label()","to_label()","to_module()","to_name()","to_name()","to_player_module()","to_player_module()","to_program()","to_program()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_source()","to_str()","to_str()","to_struct()","to_tap()","to_tap()","to_tap()","to_tap_chunk()","to_tap_chunk()","to_tap_chunk()","to_tap_chunk()","to_z80bin()","tone_off()","tone_on()","tone_progress()","tp()","track()","twos_complement16_by_sgn()","union()","unknown()","unpack_number()","unused_item_names()","unwrap_pointer()","utobcd()","utobcd_step()","v()","va()","validate_recursion_depth!()","value()","variable_volume()","ve()","vec_deque_clear()","vec_deque_empty?()","vec_deque_full?()","vec_deque_length()","vec_deque_next_back()","vec_deque_next_front()","vec_deque_pop_back()","vec_deque_pop_front()","vec_deque_push_back()","vec_deque_push_front()","veo()","vg()","vibrato_amplitude()","vibrato_angle()","vibrato_off()","vibrato_step()","vo()","volume()","volume_envelope_off()","vs()","vv()","w()","w()","wait()","wait()","wait_io()","widen_pixels8_16()","with_saved()","word()","words()","xy_to_attr_addr()","xy_to_pixel_addr()","xytoscr()","ytoattr()","ytoscr()","yxtoscr()","|()","|()","|()","~()","~()","changelog","license","readme"],"longSearchIndex":["aytest","bench","echo","float","musictest","object","symbol","z80","z80::alloc","z80::compileerror","z80::conditionalblock","z80::label","z80::mathint","z80::mathint::integers","z80::mathint::macros","z80::program","z80::program::condition","z80::program::macros","z80::program::mnemonics","z80::program::register","z80::stdlib","z80::stdlib::macros","z80::syntax","z80::tap","z80::tap::headerbody","z80::tap::tapeerror","z80::tzx","z80::utils","z80::utils::shuffle","z80::utils::shuffle::macros","z80::utils::sincos","z80::utils::sincos::macros","z80::utils::sincos::sincos","z80::utils::sincos::sincostable","z80::utils::sort","z80::utils::sort::macros","z80::utils::vecdeque","z80::utils::vecdeque::macros","z80::utils::vecdeque::vecdequestate","zx7","zx7::macros","zxlib","zxlib::aysound","zxlib::aysound::envelopecontrol","zxlib::aysound::macros","zxlib::aysound::mixer","zxlib::aysound::registers","zxlib::aysound::volumecontrol","zxlib::basic","zxlib::basic::line","zxlib::basic::program","zxlib::basic::tokenizer","zxlib::basic::tokenizer::patterns","zxlib::basic::variable","zxlib::basic::variableparseerror","zxlib::basic::variabletypes","zxlib::basic::vars","zxlib::gfx","zxlib::gfx::bobs","zxlib::gfx::bobs::macros","zxlib::gfx::clip","zxlib::gfx::clip::macros","zxlib::gfx::clip::outcode","zxlib::gfx::draw","zxlib::gfx::draw::constants","zxlib::gfx::draw::macros","zxlib::gfx::macros","zxlib::gfx::sprite8","zxlib::gfx::sprite8::macros","zxlib::math","zxlib::math::macros","zxlib::math::zxreal","zxlib::sys","zxlib::sys::coords","zxlib::sys::cursor","zxlib::sys::if1vars","zxlib::sys::macros","zxlib::sys::strms","zxlib::sys::vars","zxlib::sys::vars128","zxutils","zxutils::aybasicplayer","zxutils::aymusic","zxutils::aymusic::ayregistermirror","zxutils::aymusic::channelcontrol","zxutils::aymusic::chordcontrol","zxutils::aymusic::envelopecontrol","zxutils::aymusic::instrumentcontrol","zxutils::aymusic::macros","zxutils::aymusic::maskcontrol","zxutils::aymusic::musiccontrol","zxutils::aymusic::toneprogresscontrol","zxutils::aymusic::trackcontrol","zxutils::aymusic::trackstackentry","zxutils::aymusic::vibratocontrol","zxutils::aymusicplayer","zxutils::aymusicplayer::musictracks","zxutils::aymusicplayer::trackinfo","zxutils::benchmark","zxutils::benchmark::macros","zxutils::bigfont","zxutils::bigfont::macros","zxutils::bigfonthires","zxutils::emu","zxutils::gallery","zxutils::gallery::formats","zxutils::multitasking","zxutils::multitasking::macros","zxutils::multitasking::taskinfo","zxutils::multitasking::taskvars","zxutils::multitaskingio","zxutils::multitaskingio::bufferio","zxutils::multitaskingio::macros","zxutils::multitaskingio::taskvarsio","zxutils::musicbox","zxutils::musicbox::ayenvelopedurationcommand","zxutils::musicbox::ayenvelopeshapecommand","zxutils::musicbox::chord","zxutils::musicbox::chordcommand","zxutils::musicbox::command","zxutils::musicbox::command::headers","zxutils::musicbox::command::metacommand","zxutils::musicbox::commoninstrumentcommands","zxutils::musicbox::emptytrack","zxutils::musicbox::envelope","zxutils::musicbox::envelopecommand","zxutils::musicbox::indexcommand","zxutils::musicbox::instrument","zxutils::musicbox::instrumentcommand","zxutils::musicbox::instrumentcommands","zxutils::musicbox::loopcommand","zxutils::musicbox::markcommand","zxutils::musicbox::mask","zxutils::musicbox::maskcommand","zxutils::musicbox::multitrack","zxutils::musicbox::multitrackcommands","zxutils::musicbox::noisepitchcommand","zxutils::musicbox::notechordcommand","zxutils::musicbox::notecommand","zxutils::musicbox::noteprogressperiodcommand","zxutils::musicbox::pausecommand","zxutils::musicbox::resolver","zxutils::musicbox::song","zxutils::musicbox::song::playermodule","zxutils::musicbox::song::songmodule","zxutils::musicbox::songcommands","zxutils::musicbox::subinstrumentcommand","zxutils::musicbox::subtrackcommand","zxutils::musicbox::toneprogresscommand","zxutils::musicbox::track","zxutils::musicbox::trackcommands","zxutils::musicbox::trackconfigcommands","zxutils::musicbox::vibratoamplitudecommand","zxutils::musicbox::vibratoanglecommand","zxutils::musicbox::vibratostepcommand","zxutils::musicbox::volumelevelcommand","z80::alloc#%()","z80::label#%()","z80::alloc#&()","z80::label#&()","z80::alloc#*()","z80::label#*()","z80::alloc#**()","z80::label#**()","z80::alloc#+()","z80::label#+()","z80::program::register#+()","z80::alloc#+@()","z80::label#+@()","z80::label::+@()","z80::alloc#-()","z80::label#-()","z80::program::register#-()","z80::alloc#-@()","z80::label#-@()","z80::alloc#/()","z80::label#/()","z80::alloc#<<()","z80::label#<<()","zxlib::basic::vars#<<()","z80::alloc#==()","z80::alloc#>>()","z80::label#>>()","z80#[]()","z80::alloc#[]()","z80::label#[]()","z80::program#[]()","z80::program::condition::[]()","z80::program::register::[]()","z80::program::register#[]()","zxlib::basic::program#[]()","zxlib::basic::variable#[]()","zxlib::basic::vars#[]()","z80::alloc#^()","z80::label#^()","z80::mathint::macros#add24_16()","z80::add_code()","z80::add_reloc()","z80::mathint::macros#adda_to()","z80::program#addr()","z80::program#address?()","z80::alloc#alias?()","z80::label#alias?()","z80::program#alias_label()","zxutils::musicbox::multitrackcommands#all_ch()","zxutils::musicbox::multitrackcommands#all_channels()","zxutils::multitasking#api()","z80::tap::headerbody#array?()","zxlib::basic::variable#array?()","z80::program#as()","zxlib::aysound::macros#ay_expand_notes()","zxlib::aysound::macros#ay_expand_notes_faster()","zxlib::aysound::macros#ay_get_register_value()","zxlib::aysound::macros#ay_get_set_env_shape()","zxlib::aysound::macros#ay_get_set_mixer()","zxlib::aysound::macros#ay_hz2tp()","zxlib::aysound::macros#ay_init()","zxlib::aysound::macros#ay_io_load_const_reg_bc()","zxlib::aysound::macros#ay_io_swap2inp_bc()","zxlib::aysound::macros#ay_io_swap2out_bc()","zxlib::aysound::macros#ay_io_swap2sel_bc()","zxutils::aymusic::macros#ay_music_finished?()","zxutils::aymusic::macros#ay_music_init()","zxutils::aymusic::macros#ay_music_note_to_fine_tone_cursor_table_factory()","zxutils::aymusic::macros#ay_music_preserve_io_ports_state()","zxutils::aymusic::macros#ay_music_tone_progress_table_factory()","zxlib::aysound::macros#ay_set_envelope_duration()","zxlib::aysound::macros#ay_set_noise_pitch()","zxlib::aysound::macros#ay_set_register_value()","zxlib::aysound::macros#ay_set_tone_period()","zxlib::aysound::macros#ay_set_volume()","zxlib::aysound::macros#ay_tone_periods()","z80::mathint::macros#bcdtoa()","zxutils::benchmark#bench()","z80::program::register#bit8?()","zxlib::gfx::bobs::macros#bobs_copy_attrs()","zxlib::gfx::bobs::macros#bobs_copy_attrs_fast()","zxlib::gfx::bobs::macros#bobs_copy_pixels()","zxlib::gfx::bobs::macros#bobs_copy_pixels_fast()","zxlib::gfx::bobs::macros#bobs_draw_pixels_fast()","zxlib::gfx::bobs::macros#bobs_draw_pixels_fast_jump_table()","zxlib::gfx::bobs::macros#bobs_draw_pixels_fast_routines()","zxlib::gfx::bobs::macros#bobs_rshift_bitmap_pixels_7times()","zxlib::gfx::bobs::macros#bobs_rshift_bitmap_pixels_once()","z80::label::byte()","z80::program#bytes()","zxlib::basic::variable#bytesize()","zxutils::musicbox::track#bytesize()","zxlib::basic::variable#byteslice()","zxutils::benchmark::macros#calculate_benchmark_tstates()","zxutils::musicbox::commoninstrumentcommands#ce()","zxutils::musicbox::commoninstrumentcommands#ceo()","zxutils::musicbox::multitrackcommands#ch_a()","zxutils::musicbox::multitrackcommands#ch_b()","zxutils::musicbox::multitrackcommands#ch_c()","zxlib::sys::macros#chan_exists()","zxutils::musicbox::multitrackcommands#channel()","zxutils::musicbox::multitrackcommands::channel_name_to_index()","zxutils::musicbox::multitrack#channel_track()","zxlib::basic::variable#char_array?()","zxlib::sys::macros#char_ptr_from_code()","zxutils::musicbox::songcommands#chord()","zxutils::musicbox::commoninstrumentcommands#chord_off()","zxlib::basic::vars#clear!()","zxlib::gfx::macros#clear_attrs_region_fast()","zxlib::gfx::macros#clear_screen_region_fast()","z80::stdlib::macros#clrmem()","z80::stdlib::macros#clrmem8()","z80::stdlib::macros#clrmem_fastest()","z80::stdlib::macros#clrmem_quick()","z80::mathint::macros#cmp_i16n()","z80::mathint::macros#cmp_i16r()","z80::mathint::macros#cmp_i8()","zxlib::basic::program#code()","zxlib::basic::variable#code()","z80::tap::headerbody#code?()","zx7::compress()","zxlib::gfx::macros#copy_shadow_attrs_region()","zxlib::gfx::macros#copy_shadow_attrs_region_quick()","zxlib::gfx::macros#copy_shadow_screen_region()","zxlib::gfx::macros#copy_shadow_screen_region_quick()","z80::program::macros#cp16n()","z80::program::macros#cp16r()","z80::program::macros#cp16rr()","zxlib::sys::macros#create_chan_and_open()","z80::utils::sincos::macros#create_sincos_from_sintable()","zxlib::sys::macros#cursor_key_pressed?()","z80::program#data()","z80::program#db()","z80::program#dc!()","z80#debug()","z80::program#debug_comment()","z80::program#define_label()","z80::program#direct_address?()","z80::program#direct_label?()","zxutils::musicbox::commoninstrumentcommands#disable_ay_volume_ctrl()","z80::mathint::macros#divmod()","z80::mathint::macros#divmod16()","z80::mathint::macros#divmod24_8()","z80::mathint::macros#divmod32_16()","z80::mathint::macros#divmod32_8()","z80::mathint::macros#divmod8()","zxlib::gfx::draw::macros#draw_line()","zxlib::gfx::draw::macros#draw_line_dx_gt_4dy()","zxlib::gfx::draw::macros#draw_line_dx_gt_dy()","zxlib::gfx::draw::macros#draw_line_dy_gte_dx()","zxlib::gfx::draw::macros#draw_line_fx_data()","zxlib::gfx::draw::macros#draw_line_fx_data_dx_gt_4dy()","zxlib::gfx::draw::macros#draw_line_fx_data_dx_gt_dy()","zxlib::gfx::draw::macros#draw_line_fx_data_dy_gte_dx()","zxlib::gfx::draw::macros#draw_line_fx_data_vertical()","zxlib::gfx::draw::macros#draw_line_update()","zxlib::gfx::draw::macros#draw_line_update_dx_gt_4dy()","zxlib::gfx::draw::macros#draw_line_update_dx_gt_dy()","zxlib::gfx::draw::macros#draw_line_update_dy_gte_dx()","zxlib::gfx::draw::macros#draw_line_update_vertical()","zxlib::gfx::draw::macros#draw_line_vertical()","zxlib::gfx::sprite8#draw_sprite8()","z80::label::dummy()","z80::alloc#dummy?()","z80::label#dummy?()","z80::alloc#dup()","z80::program#dw()","zx7::macros#dzx7_agilercs()","zx7::macros#dzx7_mega()","zx7::macros#dzx7_smartrcs()","zx7::macros#dzx7_standard()","zx7::macros#dzx7_turbo()","zxlib::basic::vars#each_var()","zxutils::musicbox::trackcommands#ei()","z80::conditionalblock#else()","z80::conditionalblock#else_select()","zxutils::musicbox::commoninstrumentcommands#enable_ay_volume_ctrl()","zxutils::bigfont::macros#enlarge_char8_16()","zxutils::musicbox::commoninstrumentcommands#envd()","zxutils::musicbox::commoninstrumentcommands#envdur()","zxutils::musicbox::songcommands#envelope()","zxutils::musicbox::commoninstrumentcommands#envelope_duration()","zxutils::musicbox::commoninstrumentcommands#envelope_shape()","zxutils::musicbox::commoninstrumentcommands#envs()","zxutils::musicbox::commoninstrumentcommands#envsh()","zxlib::aysound::macros#equal_tempered_scale_notes_hz()","zxutils::benchmark::macros#estimate_tstates_per_interrupt()","z80::program#export()","z80::alloc#expression?()","z80::label#expression?()","zxutils::multitaskingio#find_channel()","zxutils::multitaskingio#find_channel_arg()","zxlib::sys::macros#find_def_fn_args()","zxutils::emu::find_emulator()","zxutils::multitaskingio#find_input_handle()","zxutils::multitaskingio#find_io_handles()","zxutils::multitaskingio#find_output_handle()","zxlib::sys::macros#find_record()","zxutils::musicbox::trackconfigcommands#first_octave_note()","zxutils::musicbox::commoninstrumentcommands#fixed_volume()","zxutils::musicbox::multitrackcommands#for_ch()","zxutils::musicbox::multitrackcommands#for_channels()","zxlib::basic::variable#for_loop?()","zxlib::math::macros#fp_to_integer32()","zxlib::basic::variable::from_data()","zxlib::basic::from_program_data()","zxlib::basic::from_tap_chunk()","zxutils::musicbox::commoninstrumentcommands#fv()","zxlib::basic::vars#get()","zxutils::benchmark#get_adjustment()","zxutils::aybasicplayer#get_counter()","zxutils::emu::get_emulator_path()","zxutils::benchmark#get_frames()","zxutils::benchmark#get_idle()","zxutils::multitaskingio#get_int8_norm_arg()","zxutils::multitaskingio#get_stream_arg()","zxutils::benchmark#getset_tsframe()","zxlib::gfx::clip::macros#gfx_clip_calculate_8bit_dx_dy_exx()","zxlib::gfx::clip::macros#gfx_clip_compute_outcode()","zxlib::gfx::clip::macros#gfx_clip_coords_to_draw_line_args()","zxlib::gfx::clip::macros#gfx_clip_dimension()","zxlib::gfx::clip::macros#gfx_clip_line()","zxlib::gfx::sprite8::macros#gfx_sprite8_calculate_coords()","zxlib::gfx::sprite8::macros#gfx_sprite8_calculate_screen_address()","zxlib::gfx::sprite8::macros#gfx_sprite8_draw()","zxlib::gfx::sprite8::macros#gfx_sprite8_flip_horizontally()","zxlib::basic::variable#head()","zxutils::musicbox::trackcommands#i()","z80::alloc#immediate?()","z80::label#immediate?()","z80::program#immediate?()","z80::program#import()","zxutils::musicbox::songcommands#import_chord()","zxutils::musicbox::songcommands#import_envelope()","z80::program#import_file()","zxutils::musicbox::songcommands#import_instrument()","zxutils::musicbox::songcommands#import_mask()","zxutils::musicbox::songcommands#import_multitrack()","zxutils::musicbox::songcommands#import_track()","z80::alloc::include?()","z80::alloc#indexable?()","z80::label#indexable?()","zxutils::aymusic#init()","zxutils::aymusicplayer#init()","zxutils::multitasking#init_multitasking()","zxutils::aybasicplayer#init_music()","z80::label#initialize()","zxutils::multitaskingio#initialize_io()","z80::utils::sort::macros#insertion_sort_bytes_max256()","zxutils::musicbox::songcommands#instrument()","zxutils::musicbox::song#instruments()","z80::mathint::macros#int()","zxlib::math::macros#integer32_to_fp()","zxutils::bigfont::macros#interlace_pixels16()","z80::program#isolate()","z80::program::condition#jr_ok?()","zxutils::multitasking::kernel_org()","zxutils::multitaskingio::kernel_org()","zxlib::sys::macros#key_pressed?()","z80::program#label()","z80::program#label?()","z80::program#label_defined?()","z80::program#label_immediate?()","z80::program#label_import()","z80::program::macros#ld16()","zxlib::basic::variable#length()","zxlib::basic::variable#limit()","zxlib::basic::variable#line()","zxlib::basic::program#line_index()","zxlib::basic::program#list()","zxutils::musicbox::commoninstrumentcommands#loop_to()","zxutils::musicbox::multitrackcommands#loop_to()","zxutils::musicbox::commoninstrumentcommands#lt()","zxutils::musicbox::multitrackcommands#lt()","zxutils::musicbox::commoninstrumentcommands#m()","zxutils::musicbox::multitrackcommands#m()","zxutils::musicbox::commoninstrumentcommands#m1()","zxutils::musicbox::commoninstrumentcommands#m2()","z80::program::macros#macro()","z80::program#macro_import()","zxlib::gfx::draw::macros#make_draw_line_subroutines()","zxutils::musicbox::commoninstrumentcommands#mark()","zxutils::musicbox::multitrackcommands#mark()","zxutils::musicbox::songcommands#mask()","zxutils::musicbox::commoninstrumentcommands#mask_ay_volume_envelope()","zxutils::musicbox::commoninstrumentcommands#mask_ay_volume_envelope_off()","zxutils::musicbox::commoninstrumentcommands#mask_noise()","zxutils::musicbox::commoninstrumentcommands#mask_noise_off()","zxutils::musicbox::commoninstrumentcommands#mask_tone()","zxutils::musicbox::commoninstrumentcommands#mask_tone_off()","z80::program::register#match16?()","zxutils::musicbox::commoninstrumentcommands#me()","z80::label::members_of_struct()","z80::stdlib::macros#memcpy()","z80::stdlib::macros#memcpy_quick()","zxutils::musicbox::commoninstrumentcommands#meo()","z80::alloc#method_missing()","z80::label::method_missing()","z80::label#method_missing()","z80::program#method_missing()","zxutils::bigfont::macros#mix_lines8_16()","zxlib::sys::macros#mmu128_select_bank()","zxlib::sys::macros#mmu128_swap_screens()","zxutils::musicbox::commoninstrumentcommands#mn()","zxutils::musicbox::commoninstrumentcommands#mno()","zxutils::musicbox::commoninstrumentcommands#mode1()","zxutils::musicbox::commoninstrumentcommands#mode2()","zxlib::sys::macros#move_basic_above_scld_screen_memory()","zxutils::musicbox::commoninstrumentcommands#mt()","zxutils::multitaskingio::macros#mtio_drain()","zxutils::multitaskingio::macros#mtio_getc()","zxutils::multitaskingio::macros#mtio_gets()","zxutils::multitaskingio::macros#mtio_putc()","zxutils::multitaskingio::macros#mtio_puts()","zxutils::multitaskingio::macros#mtio_ready?()","zxutils::multitaskingio::macros#mtio_wait()","zxutils::musicbox::commoninstrumentcommands#mto()","z80::mathint::macros#mul()","z80::mathint::macros#mul16_32()","z80::mathint::macros#mul8()","z80::mathint::macros#mul8_24()","z80::mathint::macros#mul8_c()","z80::mathint::macros#mul8_signed()","z80::mathint::macros#mul_const()","z80::mathint::macros#mul_const8_24()","z80::mathint::macros#mul_signed()","z80::mathint::macros#mul_signed9()","z80::mathint::macros#mul_signed9_24()","zxutils::musicbox::songcommands#multitrack()","zxutils::aymusicplayer#mute_sound()","zxutils::musicbox::commoninstrumentcommands#n()","zxutils::musicbox::commoninstrumentcommands#n0()","zxutils::musicbox::commoninstrumentcommands#n1()","z80::alloc#name=()","z80::label#name=()","z80::program::condition::names()","z80::program::register::names()","zxutils::musicbox::commoninstrumentcommands#ne()","z80::mathint::macros#neg16()","z80::mathint::macros#neg_int()","z80::utils::sincos::macros#neg_sintable256_pi_half_no_zero_lo()","zxutils::musicbox::commoninstrumentcommands#neo()","z80::alloc::new()","z80::label::new()","z80::program#new()","z80::program::condition::new()","z80::program::register::new()","z80::tap::headerbody::new()","zxlib::basic::line::new()","zxlib::basic::program::new()","zxlib::basic::tokenizer::new()","zxlib::basic::variableparseerror::new()","zxlib::basic::vars::new()","zxutils::musicbox::chord::new()","zxutils::musicbox::envelope::new()","zxutils::musicbox::mask::new()","zxutils::musicbox::multitrack::new()","zxutils::musicbox::song::new()","zxutils::musicbox::track::new()","zxlib::basic::variable::new_char_array()","z80::tap::headerbody::new_code()","zxlib::basic::variable::new_for_loop()","zxutils::multitasking::new_kernel()","zxutils::multitaskingio::new_kernel()","zxlib::basic::variable::new_number()","zxlib::basic::variable::new_number_array()","z80::tap::headerbody::new_program()","zxlib::basic::variable::new_string()","z80::tap::headerbody::new_var_array()","zxlib::basic::tokenizer#next_token()","zxlib::gfx::macros#nextline()","zxlib::gfx::macros#nextpixel()","zxlib::gfx::macros#nextrow()","zxutils::musicbox::commoninstrumentcommands#noise()","zxutils::musicbox::commoninstrumentcommands#noise_envelope_off()","zxutils::musicbox::commoninstrumentcommands#noise_off()","zxutils::musicbox::commoninstrumentcommands#noise_on()","zxutils::musicbox::commoninstrumentcommands#note_progress()","zxutils::musicbox::commoninstrumentcommands#np()","z80::program#ns()","zxlib::basic::variable#number?()","zxlib::basic::variable#number_array?()","z80::label::offset_of_()","z80::program::condition#one_of?()","z80::program::register#one_of?()","zxlib::gfx::macros#only_one_bit_set_or_zero?()","zxutils::multitaskingio#open_io()","z80::program#org()","zxutils::musicbox::commoninstrumentcommands#p()","zxutils::musicbox::multitrackcommands#p()","zxlib::math::pack_number()","zxlib::basic::tokenizer#parse_each()","z80::tap::parse_file()","z80::tap::parse_file()","zxlib::basic::parse_source()","zxlib::basic::line::parse_source_line()","z80::tap::parse_tap()","z80::tap::parse_tap()","zxutils::musicbox::commoninstrumentcommands#pause()","zxutils::musicbox::multitrackcommands#pause()","z80::program#pc()","zxutils::musicbox::trackcommands#pch()","zxlib::basic::tokenizer#peek_token()","zxutils::aymusic#play()","zxutils::musicbox::trackcommands#play()","zxutils::musicbox::trackcommands#play_chord()","zxutils::aybasicplayer#play_interval()","zxutils::aybasicplayer#play_loop()","zxlib::gfx::draw::macros#plot_pixel()","z80::alloc#pointer?()","z80::label#pointer?()","z80::program#pointer?()","z80::program::register#pointer?()","zxlib::gfx::draw::macros#prepare_args_draw_line_to()","zxlib::gfx::draw::macros#preshifted_pixel_mask_data()","zxlib::gfx::macros#prevline()","zxlib::gfx::macros#prevpixel()","zxutils::bigfont#print_char()","zxutils::bigfonthires#print_char_hires()","zxlib::math#print_fp_hl()","z80::tap::headerbody#program?()","zxlib::basic::vars::program_text_to_string()","z80::utils::sort::macros#quicksort_bytes()","zxlib::gfx::macros#rctoattr()","zxlib::gfx::macros#rctoscr()","zxutils::multitasking#rdoc_mark_find_def_fn_arg()","zxlib::sys::macros#read_arg_string()","z80::tap::read_chunk()","z80::tap::read_chunk()","z80::tap::read_data()","z80::tap::read_data()","zxlib::sys::macros#read_integer32_value()","zxlib::sys::macros#read_integer_value()","zxlib::sys::macros#read_positive_int_value()","zxlib::basic::read_source()","zxlib::basic::read_tap()","z80::program#register?()","z80::alloc#reinitialize()","zxutils::musicbox::commoninstrumentcommands#repeat()","zxutils::musicbox::multitrackcommands#repeat()","zxlib::sys::macros#report_error()","zxlib::sys::macros#report_error_unless()","z80::alloc#respond_to_missing?()","zxlib::sys::macros#restore_rom_interrupt_handler()","zxlib::sys::macros#return_with_fp()","z80::mathint::macros#rnd()","zxutils::musicbox::commoninstrumentcommands#rpt()","zxutils::musicbox::multitrackcommands#rpt()","zxutils::emu::run()","z80::tap#save_tap()","z80::tap#save_tap()","z80::tap::headerbody#save_tap()","z80::tap::headerbody#screen?()","zxlib::gfx::macros#scrtoattr()","z80::program#select()","z80::utils::sort::macros#selection_sort_bytes_max256()","zxutils::musicbox::trackcommands#set_empty_instrument()","zxutils::musicbox::trackcommands#set_instrument()","zxutils::aymusicplayer#setup()","zxlib::sys::macros#setup_custom_interrupt_handler()","z80::utils::shuffle::macros#shuffle_bytes_source_max256()","z80::mathint::macros#sign_extend()","z80::utils::sincos::macros#sincos_from_angle()","z80::utils::sincos::macros#sincos_table_descriptors()","z80::program::register#size()","zxutils::emu::spawn()","z80::program::register#split()","zxutils::multitasking#stack_space_free()","zxutils::benchmark#start()","zxutils::gallery#start()","zxutils::musicbox::commoninstrumentcommands#start_chord()","zxutils::musicbox::commoninstrumentcommands#start_noise_envelope()","zxutils::musicbox::commoninstrumentcommands#start_volume_envelope()","zxlib::basic::variable#statement()","zxlib::basic::variable#step()","zxlib::basic::variable#string?()","zxlib::basic::vars::string_to_program_text()","zxutils::musicbox::instrumentcommands#sub()","zxutils::musicbox::multitrackcommands#sub()","zxutils::musicbox::trackcommands#sub()","z80::mathint::macros#sub_from()","zxutils::musicbox::instrumentcommands#sub_instrument()","zxutils::musicbox::multitrackcommands#sub_track()","zxutils::musicbox::trackcommands#sub_track()","z80::alloc#sublabel?()","z80::label#sublabel?()","z80::alloc#sublabel_access_expression?()","z80::label#sublabel_access_expression?()","zxutils::musicbox::multitrackcommands#synchronize_channels()","zxutils::musicbox::commoninstrumentcommands#t0()","zxutils::musicbox::commoninstrumentcommands#t1()","zxutils::multitasking::macros#task?()","zxutils::multitasking::macros#task_id()","zxutils::multitasking::macros#task_stack_bytes_free()","zxutils::multitasking#task_yield()","zxutils::musicbox::trackconfigcommands#tempo()","zxutils::multitasking#terminate()","zxlib::basic::tokenizer#terminated?()","zxlib::basic::line#text()","z80::conditionalblock#then()","zxutils::musicbox::track#ticks_counter()","zxlib::basic::vars#to_a()","z80::alloc#to_aliased_name()","z80::label#to_aliased_name()","z80::alloc#to_alloc()","z80::label#to_alloc()","z80::label::to_data()","z80::program::register#to_debug()","z80::alloc#to_i()","z80::label::to_i()","z80::label#to_i()","z80::program::condition#to_i()","z80::program::register#to_i()","symbol#to_label()","z80::alloc#to_label()","z80::label#to_label()","zxutils::musicbox::song#to_module()","z80::alloc#to_name()","z80::label#to_name()","zxutils::musicbox::song#to_player_module()","zxutils::musicbox::song::songmodule#to_player_module()","zxutils::musicbox::song#to_program()","zxutils::musicbox::song::songmodule#to_program()","z80::alloc#to_s()","z80::label#to_s()","z80::tap::headerbody#to_s()","zxlib::basic::line#to_s()","zxlib::basic::program#to_s()","zxlib::basic::variable#to_s()","zxlib::basic::vars#to_s()","zxlib::basic::program#to_source()","z80::alloc#to_str()","z80::label#to_str()","z80::label::to_struct()","z80::tap#to_tap()","z80::tap#to_tap()","z80::tap::headerbody#to_tap()","z80::tap#to_tap_chunk()","z80::tap#to_tap_chunk()","zxlib::basic::program#to_tap_chunk()","zxlib::basic::variable#to_tap_chunk()","float#to_z80bin()","zxutils::musicbox::commoninstrumentcommands#tone_off()","zxutils::musicbox::commoninstrumentcommands#tone_on()","zxutils::musicbox::commoninstrumentcommands#tone_progress()","zxutils::musicbox::commoninstrumentcommands#tp()","zxutils::musicbox::songcommands#track()","z80::mathint::macros#twos_complement16_by_sgn()","z80::program#union()","zxutils::multitasking#unknown()","zxlib::math::unpack_number()","zxutils::musicbox::song#unused_item_names()","z80::program#unwrap_pointer()","z80::mathint::macros#utobcd()","z80::mathint::macros#utobcd_step()","zxutils::musicbox::commoninstrumentcommands#v()","zxutils::musicbox::commoninstrumentcommands#va()","zxutils::musicbox::song#validate_recursion_depth!()","zxlib::basic::variable#value()","zxutils::musicbox::commoninstrumentcommands#variable_volume()","zxutils::musicbox::commoninstrumentcommands#ve()","z80::utils::vecdeque::macros#vec_deque_clear()","z80::utils::vecdeque::macros#vec_deque_empty?()","z80::utils::vecdeque::macros#vec_deque_full?()","z80::utils::vecdeque::macros#vec_deque_length()","z80::utils::vecdeque::macros#vec_deque_next_back()","z80::utils::vecdeque::macros#vec_deque_next_front()","z80::utils::vecdeque::macros#vec_deque_pop_back()","z80::utils::vecdeque::macros#vec_deque_pop_front()","z80::utils::vecdeque::macros#vec_deque_push_back()","z80::utils::vecdeque::macros#vec_deque_push_front()","zxutils::musicbox::commoninstrumentcommands#veo()","zxutils::musicbox::commoninstrumentcommands#vg()","zxutils::musicbox::commoninstrumentcommands#vibrato_amplitude()","zxutils::musicbox::commoninstrumentcommands#vibrato_angle()","zxutils::musicbox::commoninstrumentcommands#vibrato_off()","zxutils::musicbox::commoninstrumentcommands#vibrato_step()","zxutils::musicbox::commoninstrumentcommands#vo()","zxutils::musicbox::commoninstrumentcommands#volume()","zxutils::musicbox::commoninstrumentcommands#volume_envelope_off()","zxutils::musicbox::commoninstrumentcommands#vs()","zxutils::musicbox::commoninstrumentcommands#vv()","zxutils::musicbox::commoninstrumentcommands#w()","zxutils::musicbox::multitrackcommands#w()","zxutils::musicbox::commoninstrumentcommands#wait()","zxutils::musicbox::multitrackcommands#wait()","zxutils::multitaskingio#wait_io()","zxutils::bigfont::macros#widen_pixels8_16()","z80::program::macros#with_saved()","z80::label::word()","z80::program#words()","zxlib::gfx::macros#xy_to_attr_addr()","zxlib::gfx::macros#xy_to_pixel_addr()","zxlib::gfx::macros#xytoscr()","zxlib::gfx::macros#ytoattr()","zxlib::gfx::macros#ytoscr()","zxlib::gfx::macros#yxtoscr()","z80::alloc#|()","z80::label#|()","z80::program::register#|()","z80::alloc#~()","z80::label#~()","","",""],"info":[["AYTest","","AYTest.html","",""],["Bench","","Bench.html","",""],["Echo","","Echo.html","",""],["Float","","Float.html","",""],["MusicTest","","MusicTest.html","",""],["Object","","Object.html","",""],["Symbol","","Symbol.html","",""],["Z80","","Z80.html","","
    Include this module in your program class to turn it to a powerfull Z80 macro assembler.\n
    To fully benefit …\n"],["Z80::Alloc","","Z80/Alloc.html","","
    Alloc class is used internally by relocation mechanizm and lazy evaluation of labels' values. See …\n"],["Z80::CompileError","","Z80/CompileError.html","","
    Error raised during program compilation (while creating instance).\n"],["Z80::ConditionalBlock","","Z80/ConditionalBlock.html","","
    See Program.select.\n"],["Z80::Label","","Z80/Label.html","","
    Z80 Label\n\n
    myloop  inc [hl]\n        inc hl\n        djnz myloop\n
    \n
    A label in a Z80::Program represents an address, …\n"],["Z80::MathInt","","Z80/MathInt.html","","
    Z80::MathInt - integer math common routines.\n
    in Z80::MathInt::Macros\n\n
    require 'z80'\n\nclass Program\n  include ...
    \n"],["Z80::MathInt::Integers","","Z80/MathInt/Integers.html","","
    Z80::MathInt Integers\n
    This module holds integer data types created on the fly by the Macros.int macro. …\n"],["Z80::MathInt::Macros","","Z80/MathInt/Macros.html","","
    Z80::MathInt Macros\n"],["Z80::Program","","Z80/Program.html","","
    This module defines methods that become your program's class methods when you include the Z80 module. …\n"],["Z80::Program::Condition","","Z80/Program/Condition.html","","
    Creates jr/jp/ret/call conditions as constants:\n\n
    NZ Z NC C PO PE P M\n
    \n
    Additionally NV = PO and V = PE conditions …\n"],["Z80::Program::Macros","","Z80/Program/Macros.html","","
    Z80 Macros\n
    A few handy macros.\n"],["Z80::Program::Mnemonics","","Z80/Program/Mnemonics.html","","
    Z80 Mnemonics\n
    All Z80 instructions are created as singleton methods. They produce machine code which is …\n"],["Z80::Program::Register","","Z80/Program/Register.html","","
    Z80 registers are populated as singleton methods. You must not create instances of this class directly. …\n"],["Z80::Stdlib","","Z80/Stdlib.html","","
    Z80::Stdlib - Macros with commonly used memory routines.\n\n
    require 'z80'\n\nclass MyLib\n    include Z80\n  ...
    \n"],["Z80::Stdlib::Macros","","Z80/Stdlib/Macros.html","","
    Z80::Stdlib Macros.\n"],["Z80::Syntax","","Z80/Syntax.html","","
    Error raised during program parsing.\n"],["Z80::TAP","","Z80/TAP.html","","
    Adds the TAP format support to your program.\n
    Example:\n\n
    puts Z80::TAP.parse_file("examples/calculator.tap").to_a ...\n
    \n"],["Z80::TAP::HeaderBody","","Z80/TAP/HeaderBody.html","","
    A class that represents the optional header and the single body chunk of a TAP file.\n
    Instances of this …\n"],["Z80::TAP::TapeError","","Z80/TAP/TapeError.html","",""],["Z80::TZX","","Z80/TZX.html","","
    Adds the TAP format support to your program.\n
    Example:\n\n
    puts Z80::TAP.parse_file("examples/calculator.tap").to_a ...\n
    \n"],["Z80::Utils","","Z80/Utils.html","",""],["Z80::Utils::Shuffle","","Z80/Utils/Shuffle.html","","
    Z80::Utils::Shuffle\n
    A routine to efficiently shuffle bytes in Z80::Utils::Shuffle::Macros\n"],["Z80::Utils::Shuffle::Macros","","Z80/Utils/Shuffle/Macros.html","","
    Z80::Utils::Shuffle Macros\n\n
    for i from 0 to length − 1 do\n    j ← random integer such that 0 ≤ j ≤ i\n  ...
    \n"],["Z80::Utils::SinCos","","Z80/Utils/SinCos.html","","
    Z80::Utils::SinCos - integer sinus-cosinus table routines.\n
    in Z80::Utils::SinCos::Macros\n
    Structs\n"],["Z80::Utils::SinCos::Macros","","Z80/Utils/SinCos/Macros.html","","
    Z80::Utils::SinCos Macros\n"],["Z80::Utils::SinCos::SinCos","","Z80/Utils/SinCos/SinCos.html","","
    A Z80::Utils::SinCos table entry struct.\n
    Consists of two words:\n
    sin\n"],["Z80::Utils::SinCos::SinCosTable","","Z80/Utils/SinCos/SinCosTable.html","","
    Z80::Utils::SinCos table struct.\n
    The angle [0,256) being used in this table translates to radians in the …\n"],["Z80::Utils::Sort","","Z80/Utils/Sort.html","","
    Z80::Utils::Sort\n
    Implementations of various sorting algorithms in Z80::Utils::Sort::Macros\n
    Example performance …\n"],["Z80::Utils::Sort::Macros","","Z80/Utils/Sort/Macros.html","","
    Z80::Utils::Sort macros\n"],["Z80::Utils::VecDeque","","Z80/Utils/VecDeque.html","","
    Z80::Utils::VecDeque.\n
    Routines for appending, removing and iterating byte elements from double ended queues. …\n"],["Z80::Utils::VecDeque::Macros","","Z80/Utils/VecDeque/Macros.html","","
    Z80::Utils::VecDeque macros.\n
    Macros producing routines for working with double ended queues.\n"],["Z80::Utils::VecDeque::VecDequeState","","Z80/Utils/VecDeque/VecDequeState.html","","
    A descriptor type for a double ended queue.\n"],["ZX7","","ZX7.html","","
    ZX7 decoding routines.\n
    in ZX7::Macros\n
    Example:\n"],["ZX7::Macros","","ZX7/Macros.html","",""],["ZXLib","","ZXLib.html","",""],["ZXLib::AYSound","","ZXLib/AYSound.html","","
    ZXLib::AYSound.\n
    Macros to help program the AY-3-8910/8912 sound chipsets.\n
    Sources — \n
    www.armory.com/~rstevew/Public/SoundSynth/Novelty/AY3-8910/start.html …\n"],["ZXLib::AYSound::EnvelopeControl","","ZXLib/AYSound/EnvelopeControl.html","","
    Bit masks and bit numbers for the AY-3-891x envelope shape control register Registers::ENV_SHAPE.\n"],["ZXLib::AYSound::Macros","","ZXLib/AYSound/Macros.html","","
    ZXLib::AYSound macros.\n
    The AYSound Macros provide functions to create note tables and some basic routines …\n"],["ZXLib::AYSound::Mixer","","ZXLib/AYSound/Mixer.html","","
    Bit masks and bit numbers for the AY-3-891x mixer register Registers::MIXER.\n"],["ZXLib::AYSound::Registers","","ZXLib/AYSound/Registers.html","","
    Constants with the names of the AY-3-8910 registers.\n"],["ZXLib::AYSound::VolumeControl","","ZXLib/AYSound/VolumeControl.html","","
    Bit masks and bit numbers for the AY-3-891x volume registers: VOLUME_A, VOLUME_B, VOLUME_C.\n"],["ZXLib::Basic","","ZXLib/Basic.html","","
    A module with ZX Spectrum's BASIC program utilities.\n
    SE BASIC extensions are supported.\n
    See: ZXLib::Basic::Program …\n"],["ZXLib::Basic::Line","","ZXLib/Basic/Line.html","","
    Represents a ZX Basic program line.\n
    The original program line without line number, its length and a terminating …\n"],["ZXLib::Basic::Program","","ZXLib/Basic/Program.html","","
    Represents a ZX Basic program in a semi-parsed form.\n"],["ZXLib::Basic::Tokenizer","","ZXLib/Basic/Tokenizer.html","","
    A Basic program tokenizer.\n"],["ZXLib::Basic::Tokenizer::Patterns","","ZXLib/Basic/Tokenizer/Patterns.html","",""],["ZXLib::Basic::Variable","","ZXLib/Basic/Variable.html","","
    Represents a ZX Spectrum's Basic variable with various methods to create new variables, inspect their …\n"],["ZXLib::Basic::VariableParseError","","ZXLib/Basic/VariableParseError.html","",""],["ZXLib::Basic::VariableTypes","","ZXLib/Basic/VariableTypes.html","",""],["ZXLib::Basic::Vars","","ZXLib/Basic/Vars.html","","
    A container class for collecting and inspecting ZX-Spectrum's Basic program variables.\n
    Variables can …\n"],["ZXLib::Gfx","","ZXLib/Gfx.html","","
    A module with Z80 Macros for common ZX Spectrum graphics tasks\n
    Example:\n\n
    require 'zxlib/gfx'\n\nclass Program ...
    \n"],["ZXLib::Gfx::Bobs","","ZXLib/Gfx/Bobs.html","","
    Bitmap objects related routines.\n
    See also ZXLib::Gfx::Bobs::Macros.\n\n
    ░░░░░░░░████░░░░░░████░░░░░░░░░░\n░░░░░░████████░░██████████░░░░░░ ...\n
    \n"],["ZXLib::Gfx::Bobs::Macros","","ZXLib/Gfx/Bobs/Macros.html","","
    ZXLib::Gfx::Bobs macros.\n
    Bobs::Macros require:\n\n
    macro_import MathInt\nmacro_import Gfx\n
    \n"],["ZXLib::Gfx::Clip","","ZXLib/Gfx/Clip.html","","
    A module with Z80 Macros for clipping lines.\n"],["ZXLib::Gfx::Clip::Macros","","ZXLib/Gfx/Clip/Macros.html","","
    ZXLib::Gfx::Clip Macros for clipping lines to viewport rectangles.\n
    Macros.gfx_clip_line.\n
    Macros.gfx_clip_coords_to_draw_line_args …\n"],["ZXLib::Gfx::Clip::Outcode","","ZXLib/Gfx/Clip/Outcode.html","",""],["ZXLib::Gfx::Draw","","ZXLib/Gfx/Draw.html","","
    A module with Z80 Macros for drawing lines and plotting pixels on the ZX Spectrum.\n
    Example:\n\n
    require 'zxlib/gfx/draw' ...\n
    \n"],["ZXLib::Gfx::Draw::Constants","","ZXLib/Gfx/Draw/Constants.html","",""],["ZXLib::Gfx::Draw::Macros","","ZXLib/Gfx/Draw/Macros.html","","
    ZXLib::Gfx::Draw macros for drawing lines and plotting pixels on the ZX Spectrum.\n
    Coordinate system and …\n"],["ZXLib::Gfx::Macros","","ZXLib/Gfx/Macros.html","","
    ZXLib::Gfx macros.\n"],["ZXLib::Gfx::Sprite8","","ZXLib/Gfx/Sprite8.html","","
    Sprite drawing routines.\n
    See also ZXLib::Gfx::Sprite8::Macros.\n
    By default all drawing method routines are …\n"],["ZXLib::Gfx::Sprite8::Macros","","ZXLib/Gfx/Sprite8/Macros.html","","
    ZXLib::Gfx::Sprite8 Macros.\n
    Sprite8::Macros require:\n\n
    macro_import MathInt\nmacro_import Gfx\n
    \n"],["ZXLib::Math","","ZXLib/Math.html","","
    A module with the ZXReal struct definition and ZX-Spectrum FP helpers.\n
    Macros can be used to convert 32-bit …\n"],["ZXLib::Math::Macros","","ZXLib/Math/Macros.html","","
    ZXLib::Math Macros\n
    Macros require:\n\n
    macro_import MathInt\n
    \n"],["ZXLib::Math::ZXReal","","ZXLib/Math/ZXReal.html","","
    A struct representing a ZX-Spectrum's FP calculator's real number data type.\n
    See:\n
    www.worldofspectrum.org/ZXBasicManual/zxmanchap24.html …\n"],["ZXLib::Sys","","ZXLib/Sys.html","","
    A module with Z80 macros for common ZX Spectrum system tasks.\n
    Contains:\n
    labels for some of ZX Spectrum …\n"],["ZXLib::Sys::Coords","","ZXLib/Sys/Coords.html","","
    A struct for ZX Spectrum coords variable.\n"],["ZXLib::Sys::Cursor","","ZXLib/Sys/Cursor.html","","
    A struct for various ZX Spectrum variables.\n"],["ZXLib::Sys::If1Vars","","ZXLib/Sys/If1Vars.html","","
    ZX Interface 1 variables.\n"],["ZXLib::Sys::Macros","","ZXLib/Sys/Macros.html","","
    ZXLib::Sys Macros\n
    Some of the macros require:\n\n
    require 'zxlib/math'\n# ...\n  macro_import MathInt\n  macro_import ...\n
    \n"],["ZXLib::Sys::Strms","","ZXLib/Sys/Strms.html","","
    A struct for ZX Spectrum strms variable.\n"],["ZXLib::Sys::Vars","","ZXLib/Sys/Vars.html","","
    ZX Spectrum Basic and System variables.\n"],["ZXLib::Sys::Vars128","","ZXLib/Sys/Vars128.html","","
    ZX Spectrum 128 variables.\n"],["ZXUtils","","ZXUtils.html","",""],["ZXUtils::AYBasicPlayer","","ZXUtils/AYBasicPlayer.html","","
    AY-3-8910/8912 Basic player\n
    This is a wrapper over AYMusicPlayer with interfaces suitable to be used directly …\n"],["ZXUtils::AYMusic","","ZXUtils/AYMusic.html","","
    The AY-3-8910/8912 music engine\n
    Low-level but highly configurable music player routines and Macros. See …\n"],["ZXUtils::AYMusic::AYRegisterMirror","","ZXUtils/AYMusic/AYRegisterMirror.html","","
    The AY-3-891x register mirror.\n"],["ZXUtils::AYMusic::ChannelControl","","ZXUtils/AYMusic/ChannelControl.html","","
    The single channel control structure.\n"],["ZXUtils::AYMusic::ChordControl","","ZXUtils/AYMusic/ChordControl.html","","
    data: loop_offset(,delay<<5|+ delta 0..31)*,0 (init: counter=1, cursor=+1, loop_at=cursor+loop_offset) …\n"],["ZXUtils::AYMusic::EnvelopeControl","","ZXUtils/AYMusic/EnvelopeControl.html","","
    data: loop_offset(,counter,delta)*,0 (init: counter=1, cursor=, loop_at=cursor+loop_offset+1)\n"],["ZXUtils::AYMusic::InstrumentControl","","ZXUtils/AYMusic/InstrumentControl.html","","
    The instrument track control structure\n"],["ZXUtils::AYMusic::Macros","","ZXUtils/AYMusic/Macros.html","","
    AYMusic engine utilities.\n
    NOTE — Some of the AYMusic Macros require Z80::MathInt::Macros and some require …\n\n"],["ZXUtils::AYMusic::MaskControl","","ZXUtils/AYMusic/MaskControl.html","","
    data: loop_offset(,counter,mask)*,0 (init: counter=1, cursor=+1, loop_at=cursor+loop_offset)\n"],["ZXUtils::AYMusic::MusicControl","","ZXUtils/AYMusic/MusicControl.html","","
    The main music control structure.\n
    The most important is the music_control.counter word entry which can …\n"],["ZXUtils::AYMusic::ToneProgressControl","","ZXUtils/AYMusic/ToneProgressControl.html","","
    data: delta,counter,current\n"],["ZXUtils::AYMusic::TrackControl","","ZXUtils/AYMusic/TrackControl.html","","
    The music track control structure\n"],["ZXUtils::AYMusic::TrackStackEntry","","ZXUtils/AYMusic/TrackStackEntry.html","","
    The data type of the track stack entry.\n"],["ZXUtils::AYMusic::VibratoControl","","ZXUtils/AYMusic/VibratoControl.html","","
    data: step,angle,amplitude (init: enabled:-1)\n"],["ZXUtils::AYMusicPlayer","","ZXUtils/AYMusicPlayer.html","","
    AY-3-8910/8912 music player\n
    The music module player based on ZXUtils::AYMusic engine.\n
    ZXUtils::MusicBox …\n"],["ZXUtils::AYMusicPlayer::MusicTracks","","ZXUtils/AYMusicPlayer/MusicTracks.html","","
    The struct representing music module header.\n"],["ZXUtils::AYMusicPlayer::TrackInfo","","ZXUtils/AYMusicPlayer/TrackInfo.html","","
    The struct of MusicTracks.tracks_info\n"],["ZXUtils::Benchmark","","ZXUtils/Benchmark.html","","
    ZXUtils::Benchmark\n
    Benchmarking utilities.\n
    NOTE — Currently the code must be located at 0x8000.\n"],["ZXUtils::Benchmark::Macros","","ZXUtils/Benchmark/Macros.html","","
    ZXUtils::Benchmark macros.\n"],["ZXUtils::BigFont","","ZXUtils/BigFont.html","","
    BigFont\n
    Z80 Macros producing routines to create and display 16x15 characters from a 8x8 font (e.g: a default …\n"],["ZXUtils::BigFont::Macros","","ZXUtils/BigFont/Macros.html","","
    ZXUtils::BigFont macros.\n"],["ZXUtils::BigFontHires","","ZXUtils/BigFontHires.html","","
    BigFontHires\n
    See also: BigFont.\n"],["ZXUtils::Emu","","ZXUtils/Emu.html","","
    ZXUtils::Emu\n
    Simple tools for finding and running ZX Spectrum emulator.\n
    Compile your program, save to tap …\n"],["ZXUtils::Gallery","","ZXUtils/Gallery.html","","
    ZXUtils::Gallery.\n
    A program to load from tape and display various ZX Spectrum screen formats.\n
    Supported …\n"],["ZXUtils::Gallery::Formats","","ZXUtils/Gallery/Formats.html","","
    ZXUtils::Gallery Formats\n
    The sizes of the supported .SCR file formats.\n"],["ZXUtils::Multitasking","","ZXUtils/Multitasking.html","","
    ZXUtils::Multitasking\n
    Run machine code programs (a.k.a. “tasks”) in parallel with the ZX Spectrum's …\n"],["ZXUtils::Multitasking::Macros","","ZXUtils/Multitasking/Macros.html","","
    ZXUtils::Multitasking Macros for tasks.\n"],["ZXUtils::Multitasking::TaskInfo","","ZXUtils/Multitasking/TaskInfo.html","","
    Task info structure. Each running task has one.\n"],["ZXUtils::Multitasking::TaskVars","","ZXUtils/Multitasking/TaskVars.html","","
    Definition of mtvars.\n"],["ZXUtils::MultitaskingIO","","ZXUtils/MultitaskingIO.html","","
    ZXUtils::MultitaskingIO\n
    Asynchronous communication channels between tasks running in parallel with ZX …\n"],["ZXUtils::MultitaskingIO::BufferIO","","ZXUtils/MultitaskingIO/BufferIO.html","","
    I/O Buffer structure.\n"],["ZXUtils::MultitaskingIO::Macros","","ZXUtils/MultitaskingIO/Macros.html","","
    ZXUtils::MultitaskingIO Macros for tasks.\n
    Most of the routines created by MultitaskingIO::Macros expects …\n"],["ZXUtils::MultitaskingIO::TaskVarsIO","","ZXUtils/MultitaskingIO/TaskVarsIO.html","","
    Extended Multitasking::TaskVars structure.\n"],["ZXUtils::MusicBox","","ZXUtils/MusicBox.html","","
    MusicBox\n
    MusicBox is a Ruby Domain Specific Language designed to create AY-3-8910/8912 music.\n
    The music …\n"],["ZXUtils::MusicBox::AYEnvelopeDurationCommand","","ZXUtils/MusicBox/AYEnvelopeDurationCommand.html","",""],["ZXUtils::MusicBox::AYEnvelopeShapeCommand","","ZXUtils/MusicBox/AYEnvelopeShapeCommand.html","",""],["ZXUtils::MusicBox::Chord","","ZXUtils/MusicBox/Chord.html","","
    MusicBox Chord\n
    Instances of this class represent the chords applicable to the played note's tone. …\n"],["ZXUtils::MusicBox::ChordCommand","","ZXUtils/MusicBox/ChordCommand.html","",""],["ZXUtils::MusicBox::Command","","ZXUtils/MusicBox/Command.html","",""],["ZXUtils::MusicBox::Command::Headers","","ZXUtils/MusicBox/Command/Headers.html","",""],["ZXUtils::MusicBox::Command::MetaCommand","","ZXUtils/MusicBox/Command/MetaCommand.html","",""],["ZXUtils::MusicBox::CommonInstrumentCommands","","ZXUtils/MusicBox/CommonInstrumentCommands.html","","
    MusicBox CommonInstrumentCommands\n
    Common Instrument and Track commands.\n"],["ZXUtils::MusicBox::EmptyTrack","","ZXUtils/MusicBox/EmptyTrack.html","","
    MusicBox EmptyTrack\n
    An empty track used by the MusicBox::Song compilation. Should stay empty.\n"],["ZXUtils::MusicBox::Envelope","","ZXUtils/MusicBox/Envelope.html","","
    MusicBox Envelope\n
    Instances of this class represent the envelopes applicable to the volume level or the …\n"],["ZXUtils::MusicBox::EnvelopeCommand","","ZXUtils/MusicBox/EnvelopeCommand.html","",""],["ZXUtils::MusicBox::IndexCommand","","ZXUtils/MusicBox/IndexCommand.html","",""],["ZXUtils::MusicBox::Instrument","","ZXUtils/MusicBox/Instrument.html","","
    MusicBox Instrument\n
    An instrument consists of the ZXUtils::AYMusic commands.\n
    To create a custom instrument …\n"],["ZXUtils::MusicBox::InstrumentCommand","","ZXUtils/MusicBox/InstrumentCommand.html","",""],["ZXUtils::MusicBox::InstrumentCommands","","ZXUtils/MusicBox/InstrumentCommands.html","","
    MusicBox InstrumentCommands\n
    Instrument only commands.\n"],["ZXUtils::MusicBox::LoopCommand","","ZXUtils/MusicBox/LoopCommand.html","",""],["ZXUtils::MusicBox::MarkCommand","","ZXUtils/MusicBox/MarkCommand.html","",""],["ZXUtils::MusicBox::Mask","","ZXUtils/MusicBox/Mask.html","","
    MusicBox Mask\n
    Instances of this class represent the bit masks applicable to the channel's mixer tone …\n"],["ZXUtils::MusicBox::MaskCommand","","ZXUtils/MusicBox/MaskCommand.html","",""],["ZXUtils::MusicBox::Multitrack","","ZXUtils/MusicBox/Multitrack.html","","
    MusicBox Multitrack\n
    A multi-track consists of the three tracks, each one for each of the AY-3-891x channels. …\n"],["ZXUtils::MusicBox::MultitrackCommands","","ZXUtils/MusicBox/MultitrackCommands.html","","
    MusicBox MultitrackCommands\n
    Commands for multi-tracks.\n
    For the other available commands see: TrackConfigCommands …\n"],["ZXUtils::MusicBox::NoisePitchCommand","","ZXUtils/MusicBox/NoisePitchCommand.html","",""],["ZXUtils::MusicBox::NoteChordCommand","","ZXUtils/MusicBox/NoteChordCommand.html","",""],["ZXUtils::MusicBox::NoteCommand","","ZXUtils/MusicBox/NoteCommand.html","",""],["ZXUtils::MusicBox::NoteProgressPeriodCommand","","ZXUtils/MusicBox/NoteProgressPeriodCommand.html","",""],["ZXUtils::MusicBox::PauseCommand","","ZXUtils/MusicBox/PauseCommand.html","",""],["ZXUtils::MusicBox::Resolver","","ZXUtils/MusicBox/Resolver.html","",""],["ZXUtils::MusicBox::Song","","ZXUtils/MusicBox/Song.html","","
    MusicBox Song\n
    A song is a special Multitrack that also organizes other multi-tracks, sub-tracks, instruments, …\n"],["ZXUtils::MusicBox::Song::PlayerModule","","ZXUtils/MusicBox/Song/PlayerModule.html","","
    MusicBox Song PlayerModule\n
    A PlayerModule instance contains a compiled Song in the form suitable for the …\n"],["ZXUtils::MusicBox::Song::SongModule","","ZXUtils/MusicBox/Song/SongModule.html","","
    MusicBox Song SongModule\n
    An instance of this class can be created by calling Song.to_module instance method …\n"],["ZXUtils::MusicBox::SongCommands","","ZXUtils/MusicBox/SongCommands.html","","
    MusicBox SongCommands\n
    Commands for a Song.\n
    For the other available commands see: MultitrackCommands and …\n"],["ZXUtils::MusicBox::SubInstrumentCommand","","ZXUtils/MusicBox/SubInstrumentCommand.html","",""],["ZXUtils::MusicBox::SubTrackCommand","","ZXUtils/MusicBox/SubTrackCommand.html","",""],["ZXUtils::MusicBox::ToneProgressCommand","","ZXUtils/MusicBox/ToneProgressCommand.html","",""],["ZXUtils::MusicBox::Track","","ZXUtils/MusicBox/Track.html","","
    MusicBox Track\n
    A track consists of the ZXUtils::AYMusic commands.\n
    To create a custom track you need to …\n"],["ZXUtils::MusicBox::TrackCommands","","ZXUtils/MusicBox/TrackCommands.html","","
    MusicBox TrackCommands\n
    Track commands for playing notes, setting instruments and yielding to other tracks. …\n"],["ZXUtils::MusicBox::TrackConfigCommands","","ZXUtils/MusicBox/TrackConfigCommands.html","","
    MusicBox TrackConfigCommands\n
    Common Track and Multitrack commands for changing track configuration options. …\n"],["ZXUtils::MusicBox::VibratoAmplitudeCommand","","ZXUtils/MusicBox/VibratoAmplitudeCommand.html","",""],["ZXUtils::MusicBox::VibratoAngleCommand","","ZXUtils/MusicBox/VibratoAngleCommand.html","",""],["ZXUtils::MusicBox::VibratoStepCommand","","ZXUtils/MusicBox/VibratoStepCommand.html","",""],["ZXUtils::MusicBox::VolumeLevelCommand","","ZXUtils/MusicBox/VolumeLevelCommand.html","",""],["%","Z80::Alloc","Z80/Alloc.html#method-i-25","(other)",""],["%","Z80::Label","Z80/Label.html#method-i-25","(other)","
    Returns a lazy evaluated remainder of a label divided by an other label or an integer.\n"],["&","Z80::Alloc","Z80/Alloc.html#method-i-26","(other)",""],["&","Z80::Label","Z80/Label.html#method-i-26","(m)","
    Returns a lazy evaluated bitwise “and” of a label and an other label or an integer.\n"],["*","Z80::Alloc","Z80/Alloc.html#method-i-2A","(other)",""],["*","Z80::Label","Z80/Label.html#method-i-2A","(other)","
    Returns a lazy evaluated label multiplied by an other label or an integer.\n"],["**","Z80::Alloc","Z80/Alloc.html#method-i-2A-2A","(m)",""],["**","Z80::Label","Z80/Label.html#method-i-2A-2A","(name)","
    Returns a member by its name as a separate label. This is used internally. Use Label#[] and Label#method_missing …\n"],["+","Z80::Alloc","Z80/Alloc.html#method-i-2B","(other)",""],["+","Z80::Label","Z80/Label.html#method-i-2B","(other)","
    Returns a lazy evaluated label offset by an other label or an integer.\n"],["+","Z80::Program::Register","Z80/Program/Register.html#method-i-2B","(other)","
    This method makes possible to write indexed expressions with ix/iy registers. Example:\n\n
    ld a, [ix + 7]\n
    \n"],["+@","Z80::Alloc","Z80/Alloc.html#method-i-2B-40","()",""],["+@","Z80::Label","Z80/Label.html#method-i-2B-40","()","
    Returns a lazy evaluated size of a type of a label.\n"],["+@","Z80::Label","Z80/Label.html#method-c-2B-40","()","
    Returns a lazy evaluated size of a data structure. Better for debugging than Label.to_i.\n"],["-","Z80::Alloc","Z80/Alloc.html#method-i-2D","(other)",""],["-","Z80::Label","Z80/Label.html#method-i-2D","(other)","
    Returns a lazy evaluated label negatively offset by an other label or an integer.\n"],["-","Z80::Program::Register","Z80/Program/Register.html#method-i-2D","(other)","
    This method makes possible to write indexed expressions with ix/iy registers. Example:\n\n
    ld a, [ix - 7]\n
    \n"],["-@","Z80::Alloc","Z80/Alloc.html#method-i-2D-40","()",""],["-@","Z80::Label","Z80/Label.html#method-i-2D-40","()","
    Returns a lazy evaluated negative label.\n"],["/","Z80::Alloc","Z80/Alloc.html#method-i-2F","(other)",""],["/","Z80::Label","Z80/Label.html#method-i-2F","(other)","
    Returns a lazy evaluated quotient of a label divided by an other label or an integer.\n"],["<<","Z80::Alloc","Z80/Alloc.html#method-i-3C-3C","(other)",""],["<<","Z80::Label","Z80/Label.html#method-i-3C-3C","(m)","
    Returns a lazy evaluated label left shifted by a number of bits as an other label or an integer.\n"],["<<","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-3C-3C","(var)","
    Adds a Basic::Variable to self.\n"],["==","Z80::Alloc","Z80/Alloc.html#method-i-3D-3D","(other)",""],[">>","Z80::Alloc","Z80/Alloc.html#method-i-3E-3E","(other)",""],[">>","Z80::Label","Z80/Label.html#method-i-3E-3E","(m)","
    Returns a lazy evaluated label right shifted by a number of bits as an other label or an integer.\n"],["[]","Z80","Z80.html#method-i-5B-5D","(name)","
    Returns an evaluated label's value by its name.\n"],["[]","Z80::Alloc","Z80/Alloc.html#method-i-5B-5D","(index = nil)",""],["[]","Z80::Label","Z80/Label.html#method-i-5B-5D","(index = nil)","
    Returns a lazy evaluated label offset by index.\n
    If index is nil, returns a pointer label instead.\n
    If index …\n"],["[]","Z80::Program","Z80/Program.html#method-i-5B-5D","(label)","
    Method used internally by mnemonics to make a pointer of a label or a Register.\n
    Example:\n\n
    ld  hl, [foo] ...\n
    \n"],["[]","Z80::Program::Condition","Z80/Program/Condition.html#method-c-5B-5D","(index)",""],["[]","Z80::Program::Register","Z80/Program/Register.html#method-c-5B-5D","(index)",""],["[]","Z80::Program::Register","Z80/Program/Register.html#method-i-5B-5D","(index = 0, sgn = :+)","
    Method used internally by mnemonics to make pointer of a label or register. Example:\n\n
    ld  b, [ix + 2]\nld ...\n
    \n"],["[]","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-5B-5D","(index)","
    Returns a Basic::Line at index or an array of lines if Range is given.\n"],["[]","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-5B-5D","(*at)","
    Returns a selected portion of an array variable according to the provided dimension indices.\n
    The indices …\n"],["[]","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-5B-5D","(index)","
    Returns a Basic::Variable at index or an array of variables if Range is given.\n"],["^","Z80::Alloc","Z80/Alloc.html#method-i-5E","(other)",""],["^","Z80::Label","Z80/Label.html#method-i-5E","(m)","
    Returns a lazy evaluated bitwise “exclusive or” of a label and an other label or an integer. …\n"],["add24_16","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-add24_16","(th8=c, tl16=hl, tt=de, signed:true)","
    Creates a routine that adds a 16-bit integer in tt to a 24-bit integer in th8|tl16. Returns the result …\n"],["add_code","Z80","Z80.html#method-c-add_code","(prg, data, type = 1, mnemo = nil, *mpar)","
    Method used by Program instructions was placed here to not pollute program namespace anymore.\n"],["add_reloc","Z80","Z80.html#method-c-add_reloc","(prg, label, size, offset = 0, from = nil)","
    Method used by Program instructions was placed here to not pollute program namespace anymore.\n"],["adda_to","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-adda_to","(th, tl)","
    Creates a routine that adds an 8-bit accumulator value to a 16-bit th|tl register pair.\n
    th — A target MSB …\n"],["addr","Z80::Program","Z80/Program.html#method-i-addr","(address, type = 1, align: 1, offset: 0)","
    Returns an unnamed, immediate label at an absolute address of the optional type.\n
    type can be an integer …\n"],["address?","Z80::Program","Z80/Program.html#method-i-address-3F","(arg)","
    A convenient method for macros to check if an argument is a non-register address (direct or a pointer). …\n"],["alias?","Z80::Alloc","Z80/Alloc.html#method-i-alias-3F","()","
    This label can be the only dummy sublabel of another label and as such may exist in both members and …\n"],["alias?","Z80::Label","Z80/Label.html#method-i-alias-3F","()","
    Checks if a label is an address label (lazy alias).\n"],["alias_label","Z80::Program","Z80/Program.html#method-i-alias_label","(address, align: 1, offset: 0)","
    Returns an alias of a label or an expression.\n
    The address must be a label or a label expression.\n
    The returned …\n"],["all_ch","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-all_ch","(&block)",""],["all_channels","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-all_channels","(&block)","
    Creates a track fragments with the same commands for all the channels.\n
    Provide a block with commands suitable …\n"],["api","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-api","","
    ZX Basic API\n
    This endpoint should be invoked from the ZX Basic directly via USR or indirectly via FN. …\n"],["array?","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-array-3F","()","
    true if this chunk represents a number or character array\n"],["array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-array-3F","()","
    true if variable is a number or character array\n"],["as","Z80::Program","Z80/Program.html#method-i-as","(address, align: 1, offset: 0)",""],["ay_expand_notes","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_expand_notes","(notes=hl, octaves:8, half_tones:12)","
    Creates a routine for expanding the note to AY-3-891x tone period table to a higher number of octaves. …\n"],["ay_expand_notes_faster","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_expand_notes_faster","(notes=hl, octaves:8, half_tones:12, save_sp:true, disable_intr:true, enable_intr:true)","
    Creates a routine for expanding the note to AY-3-891x tone period table to a higher number of octaves. …\n"],["ay_get_register_value","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_get_register_value","(regn=a, regv=e, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that reads a specific AY-3-891x register's value.\n
    regn — A AY-3-891x register index …\n\n"],["ay_get_set_env_shape","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_get_set_env_shape","(sinp=a, sout=sinp, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that gets the AY-3-891x envelope shape's value applies a block of code and sets …\n"],["ay_get_set_mixer","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_get_set_mixer","(vinp=a, vout=vinp, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that gets the AY-3-891x mixer's value applies a block of code and sets the mixer …\n"],["ay_hz2tp","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_hz2tp","(hz, clock_hz:AYSound::CLOCK_HZ)","
    Converts a frequency given in Hz to AY-3-891x tone period value.\n
    Options:\n
    clock_hz — AY-3-891x clock frequency …\n"],["ay_init","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_init","(t:e, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that sets volume of all AY-3-891x sound channels to 0, disables noise on all channels …\n"],["ay_io_load_const_reg_bc","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_io_load_const_reg_bc","(io_ay=self.io_ay)","
    Creates a routine that loads a constant 8-bit part of the AY-3-891x I/O addresses into b or c register. …\n"],["ay_io_swap2inp_bc","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_io_swap2inp_bc","(io_ay=self.io_ay)","
    Creates a routine that loads a specific 8-bit part of the AY-3-891x input addresses into b or c register. …\n"],["ay_io_swap2out_bc","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_io_swap2out_bc","(io_ay=self.io_ay)","
    Creates a routine that loads a specific 8-bit part of the AY-3-891x output addresses into b or c register. …\n"],["ay_io_swap2sel_bc","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_io_swap2sel_bc","(io_ay=self.io_ay)","
    Creates a routine that loads a specific 8-bit part of the AY-3-891x select addresses into b or c register. …\n"],["ay_music_finished?","ZXUtils::AYMusic::Macros","ZXUtils/AYMusic/Macros.html#method-i-ay_music_finished-3F","(music_control, compact:false, subroutine:false, branch_not_finished: :eoc)","
    Creates a routine that detects if the currently played music is finished.\n
    As a result ZF is 1 if all of …\n"],["ay_music_init","ZXUtils::AYMusic::Macros","ZXUtils/AYMusic/Macros.html#method-i-ay_music_init","(track_a, track_b, track_c, index_table:nil, init:self.init, play:self.play, music_control:self.music_control, disable_intr:true, enable_intr:true)","
    Creates a routine that initializes music tracks and optionally the index lookup table.\n
    Provide addresses …\n"],["ay_music_note_to_fine_tone_cursor_table_factory","ZXUtils::AYMusic::Macros","ZXUtils/AYMusic/Macros.html#method-i-ay_music_note_to_fine_tone_cursor_table_factory","(note_to_cursor, play:nil, num_notes:AYMusic::MAX_NOTES_COUNT, subroutine:false)","
    Creates a routine that builds a note-to-fine tones index table.\n
    note_to_cursor — An address of the table …\n\n"],["ay_music_preserve_io_ports_state","ZXUtils::AYMusic::Macros","ZXUtils/AYMusic/Macros.html#method-i-ay_music_preserve_io_ports_state","(music_control, play, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that reads a state of the I/O ports from the AY-3-891x chip and stores it into the …\n"],["ay_music_tone_progress_table_factory","ZXUtils::AYMusic::Macros","ZXUtils/AYMusic/Macros.html#method-i-ay_music_tone_progress_table_factory","(fine_tones, hz: 440, clock_hz: ZXLib::AYSound::CLOCK_HZ, subroutine:false)","
    Creates a routine that builds a fine tones to AY-3-891x tone periods table.\n
    fine_tones — An address of the …\n\n"],["ay_set_envelope_duration","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_set_envelope_duration","(dh=d, dl=e, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that sets a AY-3-891x envelope duration.\n
    dh — The most significant 8 bits of the 16-bit …\n\n"],["ay_set_noise_pitch","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_set_noise_pitch","(pitch=e, pitch_8bit:false, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that sets a AY-3-891x noise pitch.\n
    pitch — A pitch level or an 8-bit register except  …\n\n\n"],["ay_set_register_value","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_set_register_value","(regn=a, regv=e, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that writes a value to a specific AY-3-891x register.\n
    If the block is given, the code …\n"],["ay_set_tone_period","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_set_tone_period","(ch=a, tph:d, tpl:e, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that sets a AY-3-891x channel's tone period.\n
    ch — A channel number 0..2 as an integer, …\n\n"],["ay_set_volume","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_set_volume","(ch=a, vol=e, vol_8bit:false, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that sets a AY-3-891x channel's volume level.\n
    ch — A channel number 0..2 as an integer, …\n\n"],["ay_tone_periods","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_tone_periods","(min_octave:0, max_octave:7, notes_hz:self.equal_tempered_scale_notes_hz, clock_hz:AYSound::CLOCK_HZ)","
    Returns a tone period array for the AY-3-891x chip.\n
    Options:\n
    min_octave — A minimal octave number, 0-based. …\n"],["bcdtoa","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-bcdtoa","(buffer=hl, size=b, skip_leading0:false, preserve_in:nil, &block)","
    Creates a routine that reads BCD digits from the memory buffer, one at a time, into the accumulator. …\n"],["bench","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-bench","","
    Benchmarks the tested routine. Provide a routine address and a counter. Returns a number of seconds (multiplied …\n"],["bit8?","Z80::Program::Register","Z80/Program/Register.html#method-i-bit8-3F","()",""],["bobs_copy_attrs","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_copy_attrs","(attrs=hl, rows=a, cols=c, target:de, scraddr:nil, subroutine:false)","
    Creates a routine that copies bitmap attributes to the screen as a rectangle object.\n
    attrs — An address …\n\n"],["bobs_copy_attrs_fast","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_copy_attrs_fast","(attrs, rows=a, cols=32, target:hl, disable_intr:true, enable_intr:true, save_sp:true, check_oos:false, subroutine:false)","
    Creates a routine that copies bitmap attributes to the screen as a rectangle object using unrolled POP …\n"],["bobs_copy_pixels","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_copy_pixels","(bitmap=hl, lines=a, cols=c, target:de, scraddr:nil, subroutine:false)","
    Creates a routine that copies bitmap pixels to the ink/paper screen as a rectangle object.\n
    bitmap — An address …\n\n"],["bobs_copy_pixels_fast","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_copy_pixels_fast","(bitmap, lines=c, cols=32, target:hl, disable_intr:true, enable_intr:true, save_sp:true, scraddr:nil, subroutine:false)","
    Creates a routine that copies bitmap pixels to the ink/paper screen as a rectangle object using unrolled …\n"],["bobs_draw_pixels_fast","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_draw_pixels_fast","(bitmap, lines=a, cols=2, target:hl, bshift:b, mode: :set, skip_cols: nil, lclip: false, rclip: false, no0shift: false, tx:ix, disable_intr:true, enable_intr:true, save_sp:true, scraddr:nil, jump_table:nil, subroutine:false)","
    Creates a routine that draws bitmap pixels to the ink/paper screen as a rectangle object using unrolled …\n"],["bobs_draw_pixels_fast_jump_table","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_draw_pixels_fast_jump_table","(draw_pixels_fast_label)","
    Creates a jump table for the Macros#bobs_draw_pixels_fast routine.\n
    Provide a label (or a symbol) referencing …\n"],["bobs_draw_pixels_fast_routines","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_draw_pixels_fast_routines","(next_row, cols, mode: :set, skip_cols: nil, lclip: false, rclip: false, no0shift: nil, merge: false, jump_eoc: true)","
    Creates specialized routines for Macros#bobs_draw_pixels_fast that can be used externally via jump table. …\n"],["bobs_rshift_bitmap_pixels_7times","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_rshift_bitmap_pixels_7times","(bitmap=hl, lines=c, cols=a, target:de)","
    Creates a routine that renders 7 bitmap textures by shifting 7 times each source bitmap lines by 1 bit …\n"],["bobs_rshift_bitmap_pixels_once","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_rshift_bitmap_pixels_once","(bitmap=hl, lines=c, cols=a, target:de)","
    Creates a routine that renders a bitmap texture by shifting each source bitmap lines by 1 bit to the …\n"],["byte","Z80::Label","Z80/Label.html#method-c-byte","(size = 1)","
    A data structure's field type.\n"],["bytes","Z80::Program","Z80/Program.html#method-i-bytes","(*args)","
    Returns an unnamed label and allocates count bytes with Program.data. Optionally you can provide values …\n"],["bytesize","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-bytesize","()","
    Returns original size of this variable in bytes.\n"],["bytesize","ZXUtils::MusicBox::Track","ZXUtils/MusicBox/Track.html#method-i-bytesize","()","
    Returns the size in bytes of the track's compiled body.\n"],["byteslice","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-byteslice","(*at)","
    Returns a selected portion of an array variable according to provided dimension indices as raw bytes. …\n"],["calculate_benchmark_tstates","ZXUtils::Benchmark::Macros","ZXUtils/Benchmark/Macros.html#method-i-calculate_benchmark_tstates","(counter, tsframe, frames, idle, adjustment)","
    Returns the benchmark result.\n
    Calculates: (frames*(tsframe - 102) + tsframe - (idle*512 + signed adjustment)) …\n"],["ce","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-ce","(chord_name)",""],["ceo","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-ceo","()",""],["ch_a","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-ch_a","(&block)","
    Creates a track fragment for the A channel.\n
    Provide a block with commands suitable for MusicBox::Track …\n"],["ch_b","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-ch_b","(&block)","
    Creates a track fragment for the B channel.\n
    Provide a block with commands suitable for MusicBox::Track …\n"],["ch_c","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-ch_c","(&block)","
    Creates a track fragment for the C channel.\n
    Provide a block with commands suitable for MusicBox::Track …\n"],["chan_exists","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-chan_exists","(name = nil, output: de, input: nil, chan_name: 'U', buffer: 23296)","
    Looks for a ZX Spectrum CHAN entry determined by output, input and a chan_name.\n
    output — output routine …\n\n"],["channel","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-channel","(ch_name, &block)","
    Creates a track fragment for the given channel_name.\n
    Provide a block with commands suitable for MusicBox::Track …\n"],["channel_name_to_index","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-c-channel_name_to_index","(channel)","
    Returns a channel index: 0 to 2 for the given channel name.\n
    A channel can be an integer: 0 to 2 or one …\n"],["channel_track","ZXUtils::MusicBox::Multitrack","ZXUtils/MusicBox/Multitrack.html#method-i-channel_track","(channel)","
    Returns an instance of the compiled track for the given channel. A channel can be an integer: 0 to 2 …\n"],["char_array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-char_array-3F","()","
    true if variable is a character array\n"],["char_ptr_from_code","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-char_ptr_from_code","(chars, code=a, tt:de)","
    Calculates the address of the first byte of a character. The calculated address will be available in …\n"],["chord","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-chord","(name, *args)","
    Creates a chord with the given name as a symbol or a string. Provide args for the MusicBox::Chord.new …\n"],["chord_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-chord_off","()","
    Turns off, if any, a chord applied to the played note at the current channel.\n"],["clear!","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-clear-21","()","
    Clears all variables.\n"],["clear_attrs_region_fast","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-clear_attrs_region_fast","(address=hl, rows=a, cols=2, value=0, disable_intr:true, enable_intr:true, save_sp:true, addr_mode: :optimal, unroll_rows:false, scraddr:nil, subroutine:false)","
    Creates a routine that clears a rectangle on screen attributes using unrolled PUSH instructions.\n
    NOTE … — "],["clear_screen_region_fast","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-clear_screen_region_fast","(address=hl, lines=c, cols=2, value=0, disable_intr:true, enable_intr:true, save_sp:true, addr_mode: :compat, scraddr:nil, subroutine:false)","
    Creates a routine that clears a rectangle on an ink/paper screen using unrolled PUSH instructions.\n
    NOTE … — "],["clrmem","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-clrmem","(dest=hl, size=bc, value=0)","
    Clears memory at dest using LDIR instruction.\n
    T-states: ~ 21/cleared byte.\n
    Modifies: bc, de, hl, optionally …\n"],["clrmem8","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-clrmem8","(dest=hl, size=b, value=0, rr:hl)","
    Clears max 256 bytes of memory at dest. Slower (does not use LDIR/LDDR) but involves less registers. …\n"],["clrmem_fastest","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-clrmem_fastest","(address=hl, chunks_count=b, chunk_size=2, value=0, tt:hl, disable_intr:true, enable_intr:true, save_sp:true)","
    Clears a memory area using unrolled PUSH with a tight loop.\n
    NOTE — Interrupts should be disabled during …\n\n"],["clrmem_quick","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-clrmem_quick","(dest=hl, size=1, value=0, rr:hl)","
    Clears memory at dest in a faster way using unrolled instructions.\n
    T-states: ~ 13/cleared byte.\n
    Modifies: …\n"],["cmp_i16n","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-cmp_i16n","(th, tl, value, lt:nil, gt:nil, eq:nil, jump_rel:false)","
    Compares a bitwise concatenated pair of 8-bit values th|tl with a value as twos complement signed 16-bit …\n"],["cmp_i16r","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-cmp_i16r","(th, tl, sh, sl, lt:nil, gt:nil, eq:nil, jump_rel:false)","
    Compares a bitwise concatenated pair of 8-bit values th|tl with another pair sh|sl as twos complement …\n"],["cmp_i8","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-cmp_i8","(va, vb, lt:nil, gt:nil, eq:nil, jump_rel:false)","
    Compares va with vb as twos complement signed 8-bit integers.\n
    Provide va and vb as an 8-bit registers, …\n"],["code","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-code","()","
    Returns the raw byte representation of the whole ZX Basic program as a binary string.\n"],["code","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-code","()","
    Returns a portion of data after the header.\n"],["code?","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-code-3F","()","
    true if this chunk represents a code\n"],["compress","ZX7","ZX7.html#method-c-compress","(data)","
    ZX7.compress(data) -> data (zx7 compressed)\n"],["copy_shadow_attrs_region","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-copy_shadow_attrs_region","(address=de, rows=a, cols=c, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, subroutine:false)","
    Creates a routine that copies a rectangle of screen attributes from or to a shadow screen.\n
    address — An …\n\n"],["copy_shadow_attrs_region_quick","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-copy_shadow_attrs_region_quick","(address=de, rows=b, cols=32, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, size_limit_opt:false, subroutine:false)","
    Creates a routine that copies a rectangle of screen attributes from or to a shadow screen using unrolled …\n"],["copy_shadow_screen_region","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-copy_shadow_screen_region","(address=de, lines=a, cols=c, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, subroutine:false)","
    Creates a routine that copies a rectangle of an ink/paper screen from or to a shadow screen.\n
    address — "],["copy_shadow_screen_region_quick","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-copy_shadow_screen_region_quick","(address=de, lines=c, cols=32, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, size_limit_opt:false, subroutine:false)","
    Creates a routine that copies a rectangle of an ink/paper screen from or to a shadow screen using unrolled …\n"],["cp16n","Z80::Program::Macros","Z80/Program/Macros.html#method-i-cp16n","(th, tl, value, jr_msb_c: nil, jr_msb_nz: :eoc)","
    Compares a pair of registers th|tl with a value as unsigned 16-bit integers.\n
    Provide value as an integer …\n"],["cp16r","Z80::Program::Macros","Z80/Program/Macros.html#method-i-cp16r","(th, tl, sh, sl, jr_msb_c: nil, jr_msb_nz: :eoc)","
    Compares a pair of registers th|tl with another pair sh|sl as unsigned 16-bit integers.\n\n
    CF, ZF = (th|tl ...
    \n"],["cp16rr","Z80::Program::Macros","Z80/Program/Macros.html#method-i-cp16rr","(tt, ss, jr_msb_c: nil, jr_msb_nz: :eoc)","
    Compares a pair of 16-bit registers tt with ss as unsigned integers.\n
    A sugar for:\n\n
    cp16r(th,tl, sh,sl, ...)
    \n"],["create_chan_and_open","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-create_chan_and_open","(name = nil, output:, input: nil, strm_no: 4, chan_name: 'U')","
    Creates a ZX Spectrum CHAN entry and opens it as a stream #N.\n
    output — a routine address or a 16bit register …\n\n"],["create_sincos_from_sintable","Z80::Utils::SinCos::Macros","Z80/Utils/SinCos/Macros.html#method-i-create_sincos_from_sintable","(sincos, sintable:hl)","
    Creates a subroutine that generates a full SinCosTable from a quarter sinus table obtainable from #neg_sintable256_pi_half_no_zero_lo …\n"],["cursor_key_pressed?","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-cursor_key_pressed-3F","(t:b, io:self.io)","
    Test for cursor keys being pressed.\n
    Options:\n
    t — A temporary 8-bit register.\n"],["data","Z80::Program","Z80/Program.html#method-i-data","(type = 1, size = nil, *args)","
    Returns an unnamed, relative label and adds provided data to the Program.code at Program.pc.\n
    The type …\n"],["db","Z80::Program","Z80/Program.html#method-i-db","(*args)","
    Returns an unnamed label and adds the provided integers to Program.code as bytes.\n
    See: Program.data.\n"],["dc!","Z80::Program","Z80/Program.html#method-i-dc-21","(text=''.freeze)",""],["debug","Z80","Z80.html#method-i-debug","()","
    Creates a debugger view from an instance of a Z80::Program. Returns an array of strings.\n
    Example debugger …\n"],["debug_comment","Z80::Program","Z80/Program.html#method-i-debug_comment","(text=''.freeze)","
    Appends user comment to the debug listing.\n
    The comment will be visible as text in the listing at the current …\n"],["define_label","Z80::Program","Z80/Program.html#method-i-define_label","(name, label=nil)","
    Defines a label with the given name in the current namespace's context. Returns a named label.\n
    A  …\n"],["direct_address?","Z80::Program","Z80/Program.html#method-i-direct_address-3F","(arg)","
    A convenient method for macros to check if an argument is a non-register direct address (not a pointer). …\n"],["direct_label?","Z80::Program","Z80/Program.html#method-i-direct_label-3F","(arg)","
    A convenient method for macros to check if an argument is a direct label (not a pointer).\n
    Returns true …\n"],["disable_ay_volume_ctrl","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-disable_ay_volume_ctrl","()","
    Turns off the AY-3-891x automatic volume envelope control of the current channel.\n"],["divmod","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod","(k, m, clrrem:true, check0:true, check1:true, modulo:false, optimize: :time)","
    Creates a routine that performs an euclidean division of unsigned: k / m. Returns a quotient in k and …\n"],["divmod16","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod16","(x=ixl, check0:true, check1:true, modulo:false, quick8:true)","
    Creates a routine that performs an euclidean division of unsigned 16-bit: hl / de. Returns a quotient …\n"],["divmod24_8","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod24_8","(kh, km, kl, m, check0:true, check1:true, modulo:false, optimize: :time)","
    Creates a routine that performs an euclidean division of unsigned 24-bit: kh|km|kl / 8-bit m. Returns …\n"],["divmod32_16","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod32_16","(x:ixl, check0:true, check1:true, modulo:false, quick8:true)","
    Creates a routine that performs an euclidean division of unsigned 32-bit: hl|hl' / de. Returns a …\n"],["divmod32_8","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod32_8","(m=c, mt:c, check0:true, check1:true, modulo:false)","
    Creates a routine that performs an euclidean division of unsigned 32-bit: hl|hl' / m. Returns a quotient …\n"],["divmod8","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod8","(m=c, check0:true, check1:true, modulo:false)","
    Creates a routine that performs an euclidean division of unsigned: hl / m. Returns a quotient in hl and …\n"],["draw_line","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line","(preshift_pixel, preshift_cov_lt, preshift_cov_rt, fx: :or, pixel_type: :pixel, scraddr:0x4000, check_oos:true, end_with: :eoc)","
    Creates a routine that draws an approximation to a straight line.\n
    The routine only modifies ink/paper …\n"],["draw_line_dx_gt_4dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_dx_gt_4dy","(preshift_cov_rt, direction: :down, fx: :or, pixel_type: :pixel, scraddr:0x4000, check_oos:true, end_with: :eoc)","
    Creates a routine for drawing lines with the x distance 4 times larger than the y distance.\n
    Input registers: …\n"],["draw_line_dx_gt_dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_dx_gt_dy","(preshift_cov_lt, direction: :down, fx: :or, pixel_type: :pixel, scraddr:0x4000, check_oos:true, end_with: :eoc)","
    Creates a routine for drawing lines with the x distance larger than the y distance.\n
    Input registers with …\n"],["draw_line_dy_gte_dx","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_dy_gte_dx","(preshift, direction: :down_right, fx: :or, pixel_type: :pixel, scraddr:0x4000, check_oos:true, end_with: :eoc)","
    Creates a routine for drawing lines with the y distance larger than or equal to the x distance.\n
    Input …\n"],["draw_line_fx_data","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_fx_data","(preshift_pixel, preshift_cov_lt, preshift_cov_rt, fx:, pixel_type:)","
    Creates data for draw_line_update routine.\n
    Arguments:\n
    preshift_pixel — An address of an 8-byte aligned pixel …\n"],["draw_line_fx_data_dx_gt_4dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_fx_data_dx_gt_4dy","(preshift_cov_rt, fx:, pixel_type:)","
    Creates data for draw_line_update_dx_gt_4dy routine.\n
    Arguments:\n
    preshift_cov_rt — An address of an 8-byte …\n"],["draw_line_fx_data_dx_gt_dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_fx_data_dx_gt_dy","(preshift_cov_lt, fx:, pixel_type:nil)","
    Creates data for draw_line_update_dx_gt_dy routine.\n
    Arguments:\n
    preshift_cov_lt — An address of an 8-byte …\n"],["draw_line_fx_data_dy_gte_dx","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_fx_data_dy_gte_dx","(preshift, fx:, pixel_type:nil)","
    Creates data for draw_line_update_dy_gte_dx routine.\n
    Arguments:\n
    preshift — An address of an 8-byte aligned …\n"],["draw_line_fx_data_vertical","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_fx_data_vertical","(preshift, fx:)","
    Creates data for draw_line_update_vertical routine.\n
    Arguments:\n
    preshift — An address of an 8-byte aligned …\n"],["draw_line_update","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_update","(target, fx_only:false)","
    Creates a routine that modifies the function of the draw_line code in place.\n
    target — Provide a label returned …\n\n"],["draw_line_update_dx_gt_4dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_update_dx_gt_4dy","(target, no_preshift:false, fx_only:false)","
    Creates a routine that modifies the function of the draw_line_dx_gt_4dy code in place.\n
    target — Provide …\n\n"],["draw_line_update_dx_gt_dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_update_dx_gt_dy","(target, no_preshift:false, fx_only:false)","
    Creates a routine that modifies the function of the draw_line_dx_gt_dy code in place.\n
    target — Provide a …\n\n"],["draw_line_update_dy_gte_dx","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_update_dy_gte_dx","(target, no_preshift:false, fx_only:false)","
    Creates a routine that modifies the function of the draw_line_dy_gte_dx code in place.\n
    target — Provide …\n\n"],["draw_line_update_vertical","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_update_vertical","(target, no_preshift:false)","
    Creates a routine that modifies the function of the draw_line_vertical code in place.\n
    target — Provide a …\n\n"],["draw_line_vertical","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_vertical","(preshift, direction: :down, fx: :or, scraddr:0x4000, check_oos:true, end_with: :eoc)","
    Creates a routine for drawing vertical lines.\n
    Input registers with preshift data:\n
    hl: the screen memory …\n"],["draw_sprite8","ZXLib::Gfx::Sprite8","ZXLib/Gfx/Sprite8.html#method-i-draw_sprite8","","
    Draws a sprite using one of the selected drawing methods with an arbitrary pixel height and width.\n
    Pixel …\n"],["dummy","Z80::Label","Z80/Label.html#method-c-dummy","(name = nil)","
    Creates a dummy label. Should not be used directly in programs. This is called by Program.method_missing …\n"],["dummy?","Z80::Alloc","Z80/Alloc.html#method-i-dummy-3F","()",""],["dummy?","Z80::Label","Z80/Label.html#method-i-dummy-3F","()","
    Checks if a label is not yet given value and type (in-the-future a.k.a. a dummy label).\n"],["dup","Z80::Alloc","Z80/Alloc.html#method-i-dup","()",""],["dw","Z80::Program","Z80/Program.html#method-i-dw","(*args)","
    Returns an unnamed label and adds the provided integers to Program.code as words.\n
    See: Program.data.\n"],["dzx7_agilercs","ZX7::Macros","ZX7/Macros.html#method-i-dzx7_agilercs","(name=nil)","
    “Agile” integrated RCS+ZX7 decoder by Einar Saukas (150 bytes)\n
    Parameters:\n\n
    HL: source address ...
    \n"],["dzx7_mega","ZX7::Macros","ZX7/Macros.html#method-i-dzx7_mega","(name=nil)","
    ZX7 decoder by Einar Saukas “Mega” version (244 bytes, 30% faster)\n
    Parameters:\n\n
    HL: source address ...
    \n"],["dzx7_smartrcs","ZX7::Macros","ZX7/Macros.html#method-i-dzx7_smartrcs","(name=nil)","
    “Smart” integrated RCS+ZX7 decoder by Einar Saukas (110 bytes)\n
    Parameters:\n\n
    HL: source address ...
    \n"],["dzx7_standard","ZX7::Macros","ZX7/Macros.html#method-i-dzx7_standard","(name = nil)","
    ZX7 decoder by Einar Saukas, Antonio Villena & Metalbrain “Standard” version (69 bytes …\n"],["dzx7_turbo","ZX7::Macros","ZX7/Macros.html#method-i-dzx7_turbo","(name = nil)","
    ZX7 decoder by Einar Saukas & Urusergi “Turbo” version (88 bytes, 25% faster)\n
    Parameters: …\n"],["each_var","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-each_var","(&block)","
    Returns an Enumerator of every Basic::Variable found in self.\n"],["ei","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-ei","()",""],["else","Z80::ConditionalBlock","Z80/ConditionalBlock.html#method-i-else","(&block)","
    Evaluates a block in an anonymous namespace if the condition evaluates to false. Returns an instance …\n"],["else_select","Z80::ConditionalBlock","Z80/ConditionalBlock.html#method-i-else_select","(*args, &test)","
    Evaluates additional condition if the previous condition evaluates to false. Returns an instance of  …\n"],["enable_ay_volume_ctrl","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-enable_ay_volume_ctrl","()","
    Enables the AY-3-891x automatic volume envelope control of the current channel.\n"],["enlarge_char8_16","ZXUtils::BigFont::Macros","ZXUtils/BigFont/Macros.html#method-i-enlarge_char8_16","(compact:true, over:false, scraddr:0x4000, assume_chars_aligned:true, hires:nil)","
    Outputs an enlarged 8x8 character with anti-aliasing into the screen memory.\n
    The register hl should hold …\n"],["envd","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envd","(duration)",""],["envdur","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envdur","(duration)",""],["envelope","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-envelope","(name, *args)","
    Creates an envelope with the given name as a symbol or a string. Provide args for the MusicBox::Envelope.new …\n"],["envelope_duration","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envelope_duration","(duration)","
    Sets the AY-3-891x automatic volume envelope duration: 1 to 65535.\n"],["envelope_shape","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envelope_shape","(shape)","
    Sets the shape of the AY-3-891x automatic volume envelope: 0 to 15. You may use ZXLib::AYSound::EnvelopeControl …\n"],["envs","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envs","(shape)",""],["envsh","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envsh","(shape)",""],["equal_tempered_scale_notes_hz","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-equal_tempered_scale_notes_hz","(hz:440, n0:0, steps:12)","
    Returns an array of equal tempered scale frequencies from a given base frequency.\n
    See — pages.mtu.edu/~suits/NoteFreqCalcs.html …\n\n"],["estimate_tstates_per_interrupt","ZXUtils::Benchmark::Macros","ZXUtils/Benchmark/Macros.html#method-i-estimate_tstates_per_interrupt","(stack_end, interrup_vec, forward, tsframe, idle)","
    Estimates the number of T-States between interrupts.\n"],["export","Z80::Program","Z80/Program.html#method-i-export","(label)","
    Marks label_name as exportable. Programs may import labels from another programs with Program.import …\n"],["expression?","Z80::Alloc","Z80/Alloc.html#method-i-expression-3F","()",""],["expression?","Z80::Label","Z80/Label.html#method-i-expression-3F","()","
    Checks if a label is an expression.\n"],["find_channel","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-find_channel","","
    Looks for a channel name.\n
    Input:\n
    a — A channel name as an upper-case letter code.\n"],["find_channel_arg","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-find_channel_arg","","
    Looks for a channel name from a FN string argument.\n
    NOTE — This routine must never be called from a task! …\n\n"],["find_def_fn_args","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-find_def_fn_args","(argnum=b, subroutine:true, not_found:nil, cf_on_direct:false, ¬_found_blk)","
    Gets a DEF FN argument value address.\n
    Requires: macro_import MathInt.\n
    argnum — 1-based argument index (0 …\n"],["find_emulator","ZXUtils::Emu","ZXUtils/Emu.html#method-c-find_emulator","()","
    Searches for an installed ZX Spectrum emulator program in the system. Returns a path to the executable …\n"],["find_input_handle","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-find_input_handle","","
    Looks for an input handle for tasks.\n
    Provide a channel name as an upper-case letter code in accumulator. …\n"],["find_io_handles","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-find_io_handles","","
    Looks for I/O handles.\n
    Provide a channel name as an upper-case letter code in accumulator.\n
    On success returns …\n"],["find_output_handle","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-find_output_handle","","
    Looks for an output handle for tasks.\n
    Provide a channel name as an upper-case letter code in accumulator. …\n"],["find_record","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-find_record","(th=h, tl=l)","
    Search for a record that matches a large block of memory.\n
    +th|tl'+ — address of the last byte to search …\n\n"],["first_octave_note","ZXUtils::MusicBox::TrackConfigCommands","ZXUtils/MusicBox/TrackConfigCommands.html#method-i-first_octave_note","(note=nil)","
    Gets or establishes which music note :a to :g! begins an octave. By default the first music note in an …\n"],["fixed_volume","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-fixed_volume","()",""],["for_ch","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-for_ch","(*chs, &block)",""],["for_channels","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-for_channels","(*chs, &block)","
    Creates a track fragments with the same commands for the channels indicated by channel_names.\n
    Provide …\n"],["for_loop?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-for_loop-3F","()","
    true if variable is a FOR loop variable\n"],["fp_to_integer32","ZXLib::Math::Macros","ZXLib/Math/Macros.html#method-i-fp_to_integer32","(m3=e, m2=d, m1=c, m0=b, exp:a)","
    Creates a routine that converts a ZX Basic's floating point number to a 32-bit integer.\n
    m3|m2|m1| … — "],["from_data","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-from_data","(data)","
    Creates a Basic::Variable from a ZX Spectrum's VARS raw data.\n
    Provide data as a binary string.\n"],["from_program_data","ZXLib::Basic","ZXLib/Basic.html#method-c-from_program_data","(data, prog_length=nil, start:nil)","
    Creates a Basic::Program instance from a ZX Spectrum's raw binary data.\n
    The binary data may be a snapshot …\n"],["from_tap_chunk","ZXLib::Basic","ZXLib/Basic.html#method-c-from_tap_chunk","(chunk)","
    Creates a Basic::Program or a Basic::Variable depending on the type of the chunk. The chunk should be …\n"],["fv","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-fv","()",""],["get","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-get","(name)","
    Returns the first Basic::Variable if found by the given name.\n"],["get_adjustment","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-get_adjustment","","
    Returns a signed integer. Convert with: LET x=x-(65536 AND x>=32768)\n"],["get_counter","ZXUtils::AYBasicPlayer","ZXUtils/AYBasicPlayer.html#method-i-get_counter","","
    Returns the current value of the music counter.\n"],["get_emulator_path","ZXUtils::Emu","ZXUtils/Emu.html#method-c-get_emulator_path","()","
    Returns a path to the executable file of a ZX Spectrum emulator.\n
    The path is being determined by ZXEMU_PATH …\n"],["get_frames","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-get_frames","","
    Returns an unsigned integer\n"],["get_idle","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-get_idle","","
    Returns an unsigned integer\n"],["get_int8_norm_arg","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-get_int8_norm_arg","","
    Attempts to read an integer in the range -255..255 from a FN argument.\n
    NOTE — This routine must never be …\n\n"],["get_stream_arg","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-get_stream_arg","","
    Attempts to read a stream number from a FP-value addressed by hl.\n
    NOTE — This routine must never be called …\n\n"],["getset_tsframe","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-getset_tsframe","","
    Returns a less significant 16-bit unsigned integer. Add 65536 to get the actual value.\n"],["gfx_clip_calculate_8bit_dx_dy_exx","ZXLib::Gfx::Clip::Macros","ZXLib/Gfx/Clip/Macros.html#method-i-gfx_clip_calculate_8bit_dx_dy_exx","(xx=bc, yy=de, full_range_delta:true)","
    Creates a routine that calculates dx and dy. Used by: Macros.gfx_clip_line.\n
    NOTE — Swaps bc, de, hl registers …\n\n"],["gfx_clip_compute_outcode","ZXLib::Gfx::Clip::Macros","ZXLib/Gfx/Clip/Macros.html#method-i-gfx_clip_compute_outcode","(outcode, xx=bc, yy=de, xmax:ixh, xmin:ixl, ymax:iyh, ymin:iyl, jump_rel:true, subroutine:false)","
    Creates a routine that computes the Outcode bits for the xx, yy point and the clipping region. Stores …\n"],["gfx_clip_coords_to_draw_line_args","ZXLib::Gfx::Clip::Macros","ZXLib/Gfx/Clip/Macros.html#method-i-gfx_clip_coords_to_draw_line_args","(xx=bc, yy=de, args_type: :zxlib)","
    Converts clipped 16-bit coordinates to the “draw line” routine arguments.\n
    The line endpoints …\n"],["gfx_clip_dimension","ZXLib::Gfx::Clip::Macros","ZXLib/Gfx/Clip/Macros.html#method-i-gfx_clip_dimension","(a0:bc, b0:de, d1:l, d2:h, full_range_delta:true)","
    Creates a subroutine that clips a single dimension. Used by: Macros.gfx_clip_line.\n\n
    hl = a0 + sign * d1 ...\n
    \n"],["gfx_clip_line","ZXLib::Gfx::Clip::Macros","ZXLib/Gfx/Clip/Macros.html#method-i-gfx_clip_line","(xx=bc, yy=de, xmax:ixh, xmin:ixl, ymax:iyh, ymin:iyl, full_range_delta:true, compact:true)","
    Creates a subroutine for clipping lines to the rectangle viewport area using Cohen–Sutherland algorithm. …\n"],["gfx_sprite8_calculate_coords","ZXLib::Gfx::Sprite8::Macros","ZXLib/Gfx/Sprite8/Macros.html#method-i-gfx_sprite8_calculate_coords","(outofscreen: :ret, **nsopts, &block)","
    Creates a routine that calculates coordinates and prepares registers for Sprite8.draw_sprite8.\n
    hl — An address …\n"],["gfx_sprite8_calculate_screen_address","ZXLib::Gfx::Sprite8::Macros","ZXLib/Gfx/Sprite8/Macros.html#method-i-gfx_sprite8_calculate_screen_address","(scraddr:SCREEN_ADDRESS, subroutine:false)","
    Creates a routine that calculates the screen address for Sprite8.draw_sprite8.\n
    The h and l registers should …\n"],["gfx_sprite8_draw","ZXLib::Gfx::Sprite8::Macros","ZXLib/Gfx/Sprite8/Macros.html#method-i-gfx_sprite8_draw","(draw_sprite8=self.draw_sprite8, scraddr:SCREEN_ADDRESS, calculate:CALCULATE_SCREEN_ADDRESS, **nsopts, &block)","
    Creates a subroutine that calculates the screen address before jumping to Sprite8.draw_sprite8.\n
    This subroutine …\n"],["gfx_sprite8_flip_horizontally","ZXLib::Gfx::Sprite8::Macros","ZXLib/Gfx/Sprite8/Macros.html#method-i-gfx_sprite8_flip_horizontally","(subroutine:false)","
    Creates a routine that flips sprite pixel data horizontally (mirrors sprites).\n
    hl — An address immediately …\n"],["head","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-head","()","
    Returns a header byte.\n"],["i","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-i","(instrument_name)",""],["immediate?","Z80::Alloc","Z80/Alloc.html#method-i-immediate-3F","()",""],["immediate?","Z80::Label","Z80/Label.html#method-i-immediate-3F","()","
    Checks if a label is defined and absolute: true or not (relative or dummy): (false). Prefer using Program.immediate? …\n"],["immediate?","Z80::Program","Z80/Program.html#method-i-immediate-3F","(arg)","
    A convenient method for macros to check if an argument is an immediate label or an integer.\n
    Returns true …\n"],["import","Z80::Program","Z80/Program.html#method-i-import","(program, name=nil, labels:true, code:true, macros:false, override:{}, args:[])","
    Imports code, labels or macros from another program class. Give an optional name to create a namespace …\n"],["import_chord","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_chord","(name, chord)","
    Imports a MusicBox::Chord instance with the given name as a symbol or a string.\n"],["import_envelope","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_envelope","(name, envelope)","
    Imports a MusicBox::Envelope instance with the given name as a symbol or a string.\n"],["import_file","Z80::Program","Z80/Program.html#method-i-import_file","(file, type = :any, size = nil, pipe:nil, check_size:nil, data_type:nil, **args)","
    Imports a binary file.\n
    file — A file name.\n\n
    type — A format of a binary file (as a symbol), if :any -> format …\n"],["import_instrument","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_instrument","(name, track)","
    Imports a MusicBox::Instrument class with the given name as a symbol or a string.\n"],["import_mask","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_mask","(name, mask)","
    Imports a MusicBox::Mask instance with the given name as a symbol or a string.\n"],["import_multitrack","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_multitrack","(name, multitrack)","
    Imports a MusicBox::Multitrack class with the given name as a symbol or a string.\n"],["import_track","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_track","(name, track)","
    Imports a MusicBox::Track class with the given name as a symbol or a string.\n"],["include?","Z80::Alloc","Z80/Alloc.html#method-c-include-3F","(alloc, label)","
    Return true if label takes part in an alloc expression.\n"],["indexable?","Z80::Alloc","Z80/Alloc.html#method-i-indexable-3F","()",""],["indexable?","Z80::Label","Z80/Label.html#method-i-indexable-3F","()","
    Returns true if a lazy evaluated label can be offset by index.\n"],["init","ZXUtils::AYMusic","ZXUtils/AYMusic.html#method-i-init","","
    Call to initialize music structures and reset counter, track and instrument cursors.\n
    NOTE — Stop interrupts …\n\n"],["init","ZXUtils::AYMusicPlayer","ZXUtils/AYMusicPlayer.html#method-i-init","","
    Initialize music module.\n
    Relocates index table and sets the tracks' cursors to the initial positions. …\n"],["init_multitasking","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-init_multitasking","","
    Initializes multitasking.\n
    NOTE — This routine must never be called from a task!\n\n
    Clears all tasks, sets global …\n"],["init_music","ZXUtils::AYBasicPlayer","ZXUtils/AYBasicPlayer.html#method-i-init_music","","
    Initializes music track. Sets up the player.\n
    To setup the player (once):\n\n
    RANDOMIZE USR #{player[:init_music]}\n
    \n"],["initialize","Z80::Label","Z80/Label.html#method-i-initialize","(address, type = 1, reloc = nil, members = nil)",""],["initialize_io","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-initialize_io","","
    Initializes I/O and multitasking.\n
    NOTE — This routine must never be called from a task!\n\n
    Modifies: af, bc …\n"],["insertion_sort_bytes_max256","Z80::Utils::Sort::Macros","Z80/Utils/Sort/Macros.html#method-i-insertion_sort_bytes_max256","(reverse:false, target:hl, length:b, subroutine:false, &side_effects)","
    Creates a routine that sorts an array of bytes using insertion sort.\n\n
    i ← 0\nwhile i < length(A) - 1\n   ...
    \n"],["instrument","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-instrument","(name, &block)","
    Creates an instrument with the given name as a symbol or a string.\n
    Give a block of code containing instrument …\n"],["instruments","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-instruments","()","
    Returns a hash of instruments used in a song. Keys are instrument names and values are Instrument instances. …\n"],["int","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-int","(bitsize, value, byteorder: :lsb)","
    Packs an integer of an arbitrary size and adds it to the Program.code at Program.pc. Returns an unnamed …\n"],["integer32_to_fp","ZXLib::Math::Macros","ZXLib/Math/Macros.html#method-i-integer32_to_fp","(m3=e, m2=d, m1=c, m0=b, sgn:a)","
    Creates a routine that converts a 32-bit integer to a ZX Basic's floating point value.\n
    m3|m2|m1|m0 … — "],["interlace_pixels16","ZXUtils::BigFont::Macros","ZXUtils/BigFont/Macros.html#method-i-interlace_pixels16","(f1, f2, unroll:true, &block)","
    Interlaces pixels from the f1 and f2 registers into the a register.\n
    Evaluates the given block after 8 …\n"],["isolate","Z80::Program","Z80/Program.html#method-i-isolate","(name = nil, **opts, &block)","
    Returns a relative label, as an isolated namespace, holding labels defined by the code created with  …\n"],["jr_ok?","Z80::Program::Condition","Z80/Program/Condition.html#method-i-jr_ok-3F","()",""],["kernel_org","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-c-kernel_org","()","
    The Multitasking kernel code start address.\n"],["kernel_org","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-c-kernel_org","()","
    The MultitaskingIO kernel code start address.\n"],["key_pressed?","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-key_pressed-3F","(line_mask=0, key_mask=0x1f, io:self.io)","
    Test for a key or keys being pressed.\n
    line_mask — Keyboard half-line mask, may be an 8 bit register. The …\n\n"],["label","Z80::Program","Z80/Program.html#method-i-label","(type = 1, align: nil, offset: 0)","
    Returns an unnamed, relative label at Program.pc of the optional type.\n
    type can be an integer or a data …\n"],["label?","Z80::Program","Z80/Program.html#method-i-label-3F","(arg)","
    A convenient method for macros to check if an argument is label-like.\n
    Returns true for:\n\n
    foo, :foo, foo[10], ...
    \n"],["label_defined?","Z80::Program","Z80/Program.html#method-i-label_defined-3F","(name)","
    True if a label with a name is defined in the current context.\n"],["label_immediate?","Z80::Program","Z80/Program.html#method-i-label_immediate-3F","(arg)","
    A convenient method for macros to check if an argument is an immediate label.\n
    Returns true for:\n\n
    foo addr ...\n
    \n"],["label_import","Z80::Program","Z80/Program.html#method-i-label_import","(program, name = nil, labels:true, macros:false)","
    Imports labels from another program class. Optionally imports macros.\n
    A sugar for:\n\n
    import program, code: ...
    \n"],["ld16","Z80::Program::Macros","Z80/Program/Macros.html#method-i-ld16","(aa, bb)","
    Loads a content of the 16-bit register bb into the 16-bit register aa.\n
    A sugar for two 8-bit ld instructions. …\n"],["length","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-length","()","
    For strings returns the original string length, for arrays a number of dimensions.\n"],["limit","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-limit","()","
    Returns the FOR loop limit value.\n"],["line","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-line","()","
    Returns the FOR loop line number.\n"],["line_index","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-line_index","(line_no)","
    Returns index in lines of a Basic line number equal or greater than line_no.\n"],["list","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-list","(line_no)","
    Returns a new Basic::Program instance with the subset of its lines according to the line_no argument. …\n"],["loop_to","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-loop_to","(mark_name, repeat=nil)","
    Loops execution from the marked point name. Repeats repeat times. If repeat is nil or missing loops  …\n"],["loop_to","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-loop_to","(mark_name, repeat=nil)","
    Loops execution from the marked point name. Repeats repeat times. If repeat is nil or missing loops  …\n"],["lt","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-lt","(mark_name, repeat=nil)",""],["lt","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-lt","(mark_name, repeat=nil)",""],["m","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-m","(name)",""],["m","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-m","(name)",""],["m1","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-m1","()",""],["m2","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-m2","()",""],["macro","Z80::Program::Macros","Z80/Program/Macros.html#method-i-macro","(name, *registers, **nsopts, &mblock)","
    A convenient method to create local macros.\n
    Give a name (Symbol) to your macro, an optional list of registers …\n"],["macro_import","Z80::Program","Z80/Program.html#method-i-macro_import","(program)","
    Imports macros from another program class.\n
    A sugar for:\n\n
    import program, code: false, macros: true, labels: ...
    \n"],["make_draw_line_subroutines","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-make_draw_line_subroutines","(make_line:true, make_line_over:true, make_line_inversed:true, make_lines_to:true, scraddr:0x4000, check_oos:true)","
    A convenient method to build drawing subroutines.\n
    Returns a namespace label with members including the …\n"],["mark","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mark","(name)","
    Marks a point in the track and gives it a name as a symbol or a string. You can later use CommonInstrumentCommands.loop_to …\n"],["mark","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-mark","(name)","
    Marks a point in tracks and gives it a name as a symbol or a string. You can later use MultitrackCommands.loop_to …\n"],["mask","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-mask","(name, *args)","
    Creates a mask with the given name as a symbol or a string. Provide args for the MusicBox::Mask.new. …\n"],["mask_ay_volume_envelope","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_ay_volume_envelope","(mask_name)","
    Applies a mask defined by SongCommands.mask to the current channel's envelope bit controlling the …\n"],["mask_ay_volume_envelope_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_ay_volume_envelope_off","()","
    Turns off, if any, a mask applied to the current channel's envelope bit.\n"],["mask_noise","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_noise","(mask_name)","
    Applies a mask defined by SongCommands.mask to the current channel's mixer controlling the noise …\n"],["mask_noise_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_noise_off","()","
    Turns off, if any, a mask applied to the current channel's mixer controlling the noise output.\n"],["mask_tone","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_tone","(mask_name)","
    Applies a mask defined by SongCommands.mask to the current channel's mixer controlling the tone output. …\n"],["mask_tone_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_tone_off","()","
    Turns off, if any, a mask applied to the current channel's mixer controlling the tone output.\n"],["match16?","Z80::Program::Register","Z80/Program/Register.html#method-i-match16-3F","(other)","
    Checks if self can adjoin with other: self|other\n"],["me","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-me","(mask_name)",""],["members_of_struct","Z80::Label","Z80/Label.html#method-c-members_of_struct","()","
    Returns a hash containing structure members as instances of a Member class.\n"],["memcpy","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-memcpy","(dest=de, source=hl, size=bc, reverse: nil)","
    Copies size bytes from memory area source to memory area dest.\n
    dest — A destination address as an integer, …\n"],["memcpy_quick","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-memcpy_quick","(dest=de, source=hl, size=1, reverse: nil)","
    Copies size bytes from memory area source to memory area dest using unrolled LDI/LDD.\n
    dest — A destination …\n"],["meo","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-meo","()",""],["method_missing","Z80::Alloc","Z80/Alloc.html#method-i-method_missing","(m)",""],["method_missing","Z80::Label","Z80/Label.html#method-c-method_missing","(m, struct=nil, count=1)","
    Any other method is being used as a label to a member of a data structure.\n"],["method_missing","Z80::Label","Z80/Label.html#method-i-method_missing","(m)","
    Any other method will lazy evaluate as an accessor to the member label of this label.\n"],["method_missing","Z80::Program","Z80/Program.html#method-i-method_missing","(m, label = nil)","
    If no singleton method m is defined, assume m is a label name to define. Returns a named label.\n
    A label …\n"],["mix_lines8_16","ZXUtils::BigFont::Macros","ZXUtils/BigFont/Macros.html#method-i-mix_lines8_16","(r=b, o:c, t1:d, t2:e)","
    Mixes two consecutive 8-pixel lines into the 16-pixel middle anti-aliasing line. The resulting bits from …\n"],["mmu128_select_bank","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-mmu128_select_bank","(bank:nil, screen:nil, disable_intr:true, enable_intr:true, mmu_port_in_bc:false, sys128:self.sys128)","
    Selects an upper memory bank (0-7) and/or a screen memory page (0-1) to be displayed.\n
    Options:\n
    bank — Selects …\n"],["mmu128_swap_screens","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-mmu128_swap_screens","(swap_bank:false, disable_intr:true, enable_intr:true, mmu_port_in_bc:false, sys128:self.sys128)","
    Swap displayed screens.\n
    Options:\n
    swap_bank — A boolean flag indicating that the routine should additionally …\n"],["mn","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mn","(mask_name)",""],["mno","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mno","()",""],["mode1","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mode1","()","
    Switches to play mode 1. This is the default mode. In this mode after playing a note the instrument track, …\n"],["mode2","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mode2","()","
    Switches to play mode 2. In this mode after playing a note the instrument track, if set, continues executing …\n"],["move_basic_above_scld_screen_memory","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-move_basic_above_scld_screen_memory","(check_ensure:false)","
    Moves Basic program and variables above the screen 1 (to 0x7B00).\n
    check_ensure — when true checks if a call …\n\n\n"],["mt","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mt","(mask_name)",""],["mtio_drain","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_drain","(disable_intr:true, enable_intr:true)","
    Drains the I/O buffer.\n
    Options:\n
    disable_intr — a boolean flag indicating that the routine should disable …\n"],["mtio_getc","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_getc","(char=e, tt:bc, not_ready: :eoc, subroutine: true, preserve_hl:true, disable_intr:true, enable_intr:true, mtyield: task_yield)","
    Reads a single character from the I/O buffer. Arguments:\n
    char — an 8 bit register which should receive a …\n\n\n"],["mtio_gets","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_gets","(nchars=a, check_nchars_zero:true, subroutine:true, disable_intr:true, enable_intr:true, mtyield: task_yield)","
    Reads a string of characters from the I/O buffer.\n
    Arguments:\n
    nchars — a number 1..255 or accumulator with …\n"],["mtio_putc","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_putc","(char=e, tt:bc, not_ready: :eoc, subroutine: true, preserve_hl:true, disable_intr:true, enable_intr:true, mtyield: task_yield)","
    Writes a single character to the I/O buffer.\n
    Arguments:\n
    char — a number or an 8 bit register with the character …\n"],["mtio_puts","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_puts","(nchars=a, check_nchars_zero:true, subroutine:true, disable_intr:true, enable_intr:true, mtyield: task_yield)","
    Sends a string of characters to the I/O buffer.\n
    Arguments:\n
    nchars — a number 1..255 or accumulator with a …\n"],["mtio_ready?","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_ready-3F","(action, nchars:nil, disable_intr:true, enable_intr:true)","
    Checks I/O buffer's data availability.\n
    Arguments:\n
    action — a symbol :read to get the information if the …\n"],["mtio_wait","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_wait","(action, nchars=1, disable_intr:true, enable_intr:true, mtyield:task_yield)","
    Waits for the I/O buffer's data availability.\n
    Arguments:\n
    action — a symbol :read to wait for the data …\n"],["mto","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mto","()",""],["mul","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul","(k=d, m=a, tt:de, clrhl:true, signed_k:false, kbit9_carry:false, tl_is_zero:false, optimize: :time)","
    Creates a routine that performs a multiplication of an 8(9)-bit integer k * 8-bit unsigned m. Returns …\n"],["mul16_32","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul16_32","(mm=bc, tt:bc, clrhlhl:true, signed_hl:false, optimize: :time)","
    Creates a routine that performs a multiplication of a 16-bit integer (hl) by an unsigned 16-bit integer …\n"],["mul8","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul8","(kh=h, kl=l, m=a, tt:de, clrhl:true, double:false, optimize: :time)","
    Creates a routine that performs a multiplication of a 16-bit integer kh|kl * 8bit unsigned m. Returns …\n"],["mul8_24","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul8_24","(kh=h, kl=l, m=b, t:c, tt:de, clrahl:true, k_int24: false, optimize: :time)","
    Creates a routine that performs a multiplication of a 16-bit unsigned integer kh|kl or 24-bit integer …\n"],["mul8_c","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul8_c","(kh=h, kl=l, m=a, tt:de, clrhl:true)","
    Creates a routine that performs a multiplication of an unsigned 16-bit integer kh|kl * 8-bit unsigned …\n"],["mul8_signed","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul8_signed","(kh=h, kl=l, m=c, tt:de, t:m, clrhl:true, double:false, optimize: :time)","
    Creates a routine that performs a multiplication of a 16-bit signed integer kh|kl * 8bit signed integer …\n"],["mul_const","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul_const","(k=d, m=0, tt:de, clrhl:true, signed_k:false)","
    Creates a routine that performs a multiplication of an 8-bit integer k * 8-bit unsigned m. Returns the …\n"],["mul_const8_24","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul_const8_24","(kh=h, kl=l, m=0, t:c, tt:de, clrahl:true, signed_k:false)","
    Creates a routine that performs a multiplication of an 16-bit integer kh|kl * 8-bit unsigned m. Returns …\n"],["mul_signed","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul_signed","(k=d, m=a, tt:de, clrhl:true)","
    Creates a routine that performs a multiplication of a signed 8-bit k * 8-bit signed m.\n
    See Macros.mul …\n"],["mul_signed9","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul_signed9","(kh=c, kl=d, m=a, s:kh, tt:de, m_neg_cond:C, k_full_range:true, m_full_range:true, k_overflow:nil, m_is_zero_zf:false, optimize: :time)","
    Creates a routine that performs a multiplication of a signed 9-bit integer kh|kl * 9-bit signed integer …\n"],["mul_signed9_24","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul_signed9_24","(ks=c, kh=h, kl=l, m=b, tt:de, m_pos_cond:NC, m_full_range:true, optimize: :time, &restore_a)","
    Creates a routine that performs a multiplication of a 24-bit signed integer ks|kh|kl * 9-bit signed integer …\n"],["multitrack","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-multitrack","(name, &block)","
    Creates a multi-track with the given name as a symbol or a string.\n
    Give a block of code containing multi-track …\n"],["mute_sound","ZXUtils::AYMusicPlayer","ZXUtils/AYMusicPlayer.html#method-i-mute_sound","","
    Mutes sound.\n
    Modifies: af, bc.\n"],["n","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-n","(level)",""],["n0","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-n0","()",""],["n1","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-n1","()",""],["name=","Z80::Alloc","Z80/Alloc.html#method-i-name-3D","(value)",""],["name=","Z80::Label","Z80/Label.html#method-i-name-3D","(value)","
    Gives a name to a no-named label. Should not be used directly in programs.\n"],["names","Z80::Program::Condition","Z80/Program/Condition.html#method-c-names","()",""],["names","Z80::Program::Register","Z80/Program/Register.html#method-c-names","()",""],["ne","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-ne","(envelope_name)",""],["neg16","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-neg16","(sh, sl, th:sh, tl:sl)","
    Creates a routine that changes the sign of a twos complement 16-bit integer in sh|sl.\n
    sh — An 8-bit register …\n"],["neg_int","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-neg_int","(*regs, t:nil, t_is_zero:false, optimize_last:false)","
    Creates a routine that changes the sign of a twos complement integer held in any number of regs.\n
    Pass …\n"],["neg_sintable256_pi_half_no_zero_lo","Z80::Utils::SinCos::Macros","Z80/Utils/SinCos/Macros.html#method-i-neg_sintable256_pi_half_no_zero_lo","()","
    Returns an array of 63 bytes containing the first quarter sinus table, 256-based angle, negated, fractional …\n"],["neo","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-neo","()",""],["new","Z80::Alloc","Z80/Alloc.html#method-c-new","(lhs, oper=nil, rhs=nil, index=[])",""],["new","Z80::Label","Z80/Label.html#method-c-new","(addr, type = 1, reloc = nil, members = nil)","
    Creates an instance of a label. Do not use it directly in programs. Instead use Program.data, Program.label …\n"],["new","Z80::Program","Z80/Program.html#method-i-new","(start = 0x0000, *args, override:{})","
    Compiles a program at the start address passing *args to initialize(). Returns a compiled instance of …\n"],["new","Z80::Program::Condition","Z80/Program/Condition.html#method-c-new","(name, opc)",""],["new","Z80::Program::Register","Z80/Program/Register.html#method-c-new","(name, opc)",""],["new","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-c-new","(header, body)",""],["new","ZXLib::Basic::Line","ZXLib/Basic/Line.html#method-c-new","(line_no, body)",""],["new","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-c-new","(lines, vars = nil, start = nil)",""],["new","ZXLib::Basic::Tokenizer","ZXLib/Basic/Tokenizer.html#method-c-new","(text, line_index=0, line_offset=0)","
    Creates new instance of a Basic::Tokenizer.\n
    text must be an UTF-8 encoded, line_index and line_offset …\n"],["new","ZXLib::Basic::VariableParseError","ZXLib/Basic/VariableParseError.html#method-c-new","(msg=\"Not a variable\")",""],["new","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-c-new","(data='')","
    Creates an instance of Basic::Vars.\n
    Optionally provide VARS data as a binary string.\n"],["new","ZXUtils::MusicBox::Chord","ZXUtils/MusicBox/Chord.html#method-c-new","(*args)","
    Creates an instance of the Chord with the given tuples defining the chord.\n
    counter — For how many ticks …\n"],["new","ZXUtils::MusicBox::Envelope","ZXUtils/MusicBox/Envelope.html#method-c-new","(*args)","
    Creates an instance of the Envelope with the given tuples shaping the envelope.\n
    counter — How many ticks …\n"],["new","ZXUtils::MusicBox::Mask","ZXUtils/MusicBox/Mask.html#method-c-new","(*args)","
    Creates an instance of the Mask with the given tuples defining bits for the mask.\n
    counter — For how many …\n"],["new","ZXUtils::MusicBox::Multitrack","ZXUtils/MusicBox/Multitrack.html#method-c-new","(resolver)","
    Instances of the derived classes are being created internally by the MusicBox::Song compilation process. …\n"],["new","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-c-new","()","
    Creates and instance of the song.\n"],["new","ZXUtils::MusicBox::Track","ZXUtils/MusicBox/Track.html#method-c-new","(resolver)","
    Instances of the derived classes are being created internally by the MusicBox::Song compilation process. …\n"],["new_char_array","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_char_array","(name, dims, values=nil)","
    Creates a character array Basic::Variable.\n
    The strings are parsed by Vars.program_text_to_string only …\n"],["new_code","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-c-new_code","(name, code, org)","
    Creates a HeaderBody of the type TYPE_CODE.\n
    name should contain max 10 ascii characters.\n
    code should be …\n"],["new_for_loop","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_for_loop","(name, value, limit, step, line, statement)","
    Creates a FOR loop Basic::Variable.\n"],["new_kernel","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-c-new_kernel","(*args, **opts)","
    Instantiate Multitasking kernel with the proper code address.\n"],["new_kernel","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-c-new_kernel","(*args, **opts)","
    Instantiate MultitaskingIO kernel with the proper code address.\n"],["new_number","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_number","(name, num, simplified_int=true)","
    Creates a numeric Basic::Variable.\n"],["new_number_array","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_number_array","(name, dims, values=nil)","
    Creates a numeric array Basic::Variable.\n
    dims must be an array of dimension sizes provided as positive …\n"],["new_program","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-c-new_program","(name, code, line:nil, prog_length:nil)","
    Creates a HeaderBody of the type TYPE_PROGRAM.\n
    name should contain max 10 ascii characters.\n
    code should …\n"],["new_string","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_string","(name, string)","
    Creates a string Basic::Variable.\n
    The string is parsed by Vars.program_text_to_string only if encoded …\n"],["new_var_array","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-c-new_var_array","(name, code, head)","
    Creates a HeaderBody of the type TYPE_NUMBER_ARRAY or TYPE_CHAR_ARRAY.\n
    name should contain max 10 ascii …\n"],["next_token","ZXLib::Basic::Tokenizer","ZXLib/Basic/Tokenizer.html#method-i-next_token","()",""],["nextline","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-nextline","(ah, al, bcheck = true, scraddr:0x4000, hires:false, **nsopts, &block)","
    Creates a routine that advances to the next line (down) a screen address using ah|al registers. Optionally …\n"],["nextpixel","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-nextpixel","(al, s: a)","
    Creates a routine that changes a bit shift and the pixel address for a one pixel to the right.\n
    Modifies: …\n"],["nextrow","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-nextrow","(ah, al, bcheck = true, scraddr:0x4000, **nsopts, &block)","
    Creates a routine that advances to the next text row (down 8 pixels) a screen address using ah|al registers. …\n"],["noise","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-noise","(level)","
    Sets noise pitch level: 0 to 31.\n"],["noise_envelope_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-noise_envelope_off","()","
    Turns off, if any, an envelope applied to the noise pitch level.\n"],["noise_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-noise_off","()","
    Turns off the current channel's noise output.\n"],["noise_on","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-noise_on","()","
    Turns on the current channel's noise output.\n"],["note_progress","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-note_progress","(period)","
    Enables the smooth tone frequency progression of the notes played on the current channel.\n
    period — A number …\n\n"],["np","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-np","(period)",""],["ns","Z80::Program","Z80/Program.html#method-i-ns","(name = nil, **opts)","
    Returns a relative label, as a namespace, holding labels defined by the code created with block as sub-labels. …\n"],["number?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-number-3F","()","
    true if variable is a number variable\n"],["number_array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-number_array-3F","()","
    true if variable is a number array\n"],["offset_of_","Z80::Label","Z80/Label.html#method-c-offset_of_","(name)","
    Returns a lazy evaluated, debug visible, byte offset of a struct member. Returns nil if self is not a …\n"],["one_of?","Z80::Program::Condition","Z80/Program/Condition.html#method-i-one_of-3F","(ary)",""],["one_of?","Z80::Program::Register","Z80/Program/Register.html#method-i-one_of-3F","(ary)",""],["only_one_bit_set_or_zero?","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-only_one_bit_set_or_zero-3F","(v)","
    Returns true if v is a 0 or a positive integer with only one bit set in its binary representation.\n"],["open_io","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-open_io","","
    ZX Basic API\n
    This endpoint should be invoked from the ZX Basic directly via USR or indirectly via FN. …\n"],["org","Z80::Program","Z80/Program.html#method-i-org","(address = pc, pad = 0, align: 1, offset: 0)","
    Returns an unnamed, relative label that points to the beginning of padded space. The space is being padded …\n"],["p","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-p","(length, *length_exts)",""],["p","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-p","(length, *length_exts)",""],["pack_number","ZXLib::Math","ZXLib/Math.html#method-c-pack_number","(num, simplified_int=true)","
    Converts num to a ZX-Spectrum's real number encoded as a 5-byte binary string.\n
    simplified_int indicates …\n"],["parse_each","ZXLib::Basic::Tokenizer","ZXLib/Basic/Tokenizer.html#method-i-parse_each","(&block)",""],["parse_file","Z80::TAP","Z80/TAP.html#method-c-parse_file","(filename, &block)","
    Returns an Enumerator of TAP::HeaderBody chunks representing segments of a TAP file. Optionally unwraps …\n"],["parse_file","Z80::TAP","Z80/TAP.html#method-c-parse_file","(filename, &block)","
    Returns an Enumerator of TAP::HeaderBody chunks representing segments of a TAP file. Optionally unwraps …\n"],["parse_source","ZXLib::Basic","ZXLib/Basic.html#method-c-parse_source","(source, start:nil)","
    Creates a Basic::Program from a BASIC program text.\n
    The source should be an UTF-8 encoded string.\n
    Each …\n"],["parse_source_line","ZXLib::Basic::Line","ZXLib/Basic/Line.html#method-c-parse_source_line","(line_text, last_line_no=0, line_index=0)","
    Creates a Basic::Line from a provided BASIC program text.\n
    See: Basic.parse_source\n"],["parse_tap","Z80::TAP","Z80/TAP.html#method-c-parse_tap","(tap, file='-', &block)","
    Returns an Enumerator of TAP::HeaderBody chunks representing segments of a TAP blob. Optionally unwraps …\n"],["parse_tap","Z80::TAP","Z80/TAP.html#method-c-parse_tap","(tap, file='-', &block)","
    Returns an Enumerator of TAP::HeaderBody chunks representing segments of a TAP blob. Optionally unwraps …\n"],["pause","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-pause","(length, *length_exts)","
    Pauses the current track execution for a length period. The length value should be a positive integer. …\n"],["pause","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-pause","(length, *length_exts)","
    Pauses tracks execution for a length period. The length value should be a positive integer.\n
    The number …\n"],["pc","Z80::Program","Z80/Program.html#method-i-pc","()","
    Returns the current byte offset from the beginning of the Program.code (a program counter relative to …\n"],["pch","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-pch","(*args)",""],["peek_token","ZXLib::Basic::Tokenizer","ZXLib/Basic/Tokenizer.html#method-i-peek_token","()",""],["play","ZXUtils::AYMusic","ZXUtils/AYMusic.html#method-i-play","","
    Call this routine, in turns, to play the music.\n
    NOTE — Stop interrupts (di) first before calling this routine. …\n\n"],["play","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-play","(note_name, octave, *pause_lengths)","
    To play notes on the use one of the commands:\n\n
    note_name  corresponding note\na          A\na!         A# ...\n
    \n"],["play_chord","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-play_chord","(*args)","
    Plays a chord. At least two different notes should be specified.\n"],["play_interval","ZXUtils::AYBasicPlayer","ZXUtils/AYBasicPlayer.html#method-i-play_interval","","
    Plays single music track tick. Call repeatedly on equal intervals to play music.\n
    Returns the current value …\n"],["play_loop","ZXUtils::AYBasicPlayer","ZXUtils/AYBasicPlayer.html#method-i-play_loop","","
    Plays music track in a loop until any key has been pressed.\n"],["plot_pixel","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-plot_pixel","(x, y, preshift, fx: :or, with_attributes:false, color_attr:ixl, color_mask:ixh, scraddr:0x4000)","
    Creates the plot pixel routine.\n
    x — The input register: horizontal-coordinate in the range [0, 255].\n\n
    y — The …\n"],["pointer?","Z80::Alloc","Z80/Alloc.html#method-i-pointer-3F","()",""],["pointer?","Z80::Label","Z80/Label.html#method-i-pointer-3F","()","
    Checks if label is a pointer. Prefer using Program.pointer? instead.\n"],["pointer?","Z80::Program","Z80/Program.html#method-i-pointer-3F","(arg)","
    A convenient method for macros to check if an argument is pointer-like.\n
    Returns true for:\n\n
    [foo], [:foo], ...
    \n"],["pointer?","Z80::Program::Register","Z80/Program/Register.html#method-i-pointer-3F","()",""],["prepare_args_draw_line_to","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-prepare_args_draw_line_to","()","
    Creates a routine that prepares arguments for the draw_line routine from two sets of coordinates.\n
    Registers …\n"],["preshifted_pixel_mask_data","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-preshifted_pixel_mask_data","(data_type)","
    Creates precalculated pixel mask data to be used with drawing routines.\n
    data_type:\n\n
    :pixel              ...\n
    \n"],["prevline","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-prevline","(ah, al, bcheck = true, scraddr:0x4000, hires:false, **nsopts, &block)","
    Creates a routine that moves up to the previous line a screen address using ah|al registers. Optionally …\n"],["prevpixel","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-prevpixel","(al, s: a)","
    Creates a routine that changes a bit shift and the pixel address for a one pixel to the left.\n
    Modifies: …\n"],["print_char","ZXUtils::BigFont","ZXUtils/BigFont.html#method-i-print_char","","
    ZX Spectrum's ROM compatible CHAN output routine\n
    The a register should have the output character code …\n"],["print_char_hires","ZXUtils::BigFontHires","ZXUtils/BigFontHires.html#method-i-print_char_hires","","
    ZX Spectrum's ROM compatible CHAN output routine, for hi-res mode.\n
    The a register should have the …\n"],["print_fp_hl","ZXLib::Math","ZXLib/Math.html#method-i-print_fp_hl","","
    Call print_fp_hl with hl pointing to the 1st byte of a ZXReal number to print that number to the currently …\n"],["program?","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-program-3F","()","
    true if this chunk represents a basic program\n"],["program_text_to_string","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-c-program_text_to_string","(text)","
    Converts a UTF-8 text string to a binary string encoded in a form suitable for ZX-Spectrum's Basic …\n"],["quicksort_bytes","Z80::Utils::Sort::Macros","Z80/Utils/Sort/Macros.html#method-i-quicksort_bytes","(select_pivot=:half, reverse: false, safe_args: true, pivot_reg: c, swap_same: true, &swap_items)","
    Creates a subroutine that sorts an array of bytes using quicksort algorithm.\n\n
    algorithm qsort(A, first, ...
    \n"],["rctoattr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-rctoattr","(row, col=0, ah:h, al:l, scraddr:0x4000)","
    Creates a routine that converts row and column coordinates to an address of a color attribute.\n
    Modifies: …\n"],["rctoscr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-rctoscr","(row, col=0, ah:h, al:l, scraddr:0x4000)","
    Creates a routine that converts row and column coordinates to a byte address of a top 8-pixel line.\n
    Modifies: …\n"],["rdoc_mark_find_def_fn_arg","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-rdoc_mark_find_def_fn_arg","","
    Looks for a first DEF FN argument value address.\n
    NOTE — This routine must never be called from a task!\n\n
    If …\n"],["read_arg_string","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-read_arg_string","(adh=d, adl=e, lenh=b, lenl=c)","
    Reads a string address and its length from a ZX Basic's stringish FP-value.\n
    hl — must point to the 1st …\n"],["read_chunk","Z80::TAP","Z80/TAP.html#method-c-read_chunk","(filename, name:nil, index:nil)","
    Reads a TAP::HeaderBody chunk from a TAP file.\n
    Pass additional :name argument to search for the header …\n"],["read_chunk","Z80::TAP","Z80/TAP.html#method-c-read_chunk","(filename, name:nil, index:nil)","
    Reads a TAP::HeaderBody chunk from a TAP file.\n
    Pass additional :name argument to search for the header …\n"],["read_data","Z80::TAP","Z80/TAP.html#method-c-read_data","(filename, **opts)","
    Reads a data chunk from a TAP file. Returns a binary string.\n
    Program.import_file uses this method to read …\n"],["read_data","Z80::TAP","Z80/TAP.html#method-c-read_data","(filename, **opts)","
    Reads a data chunk from a TAP file. Returns a binary string.\n
    Program.import_file uses this method to read …\n"],["read_integer32_value","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-read_integer32_value","(t3=d, t2=e, t1=b, t0=c)","
    Reads a 32-bit integer from a ZX Basic's FP-value.\n
    Requires: macro_import ::ZXLib::Math.\n
    hl — must point …\n"],["read_integer_value","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-read_integer_value","(th=d, tl=e, sgn=c, normal_negative:false, t:a)","
    Reads a signed integer from a ZX Basic's FP-value.\n
    hl — must point to the 1st byte of the FP-value. …\n"],["read_positive_int_value","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-read_positive_int_value","(th=d, tl=e)","
    Reads a positive integer from a ZX Basic's FP-value.\n
    hl — must point to the 1st byte of the FP-value. …\n"],["read_source","ZXLib::Basic","ZXLib/Basic.html#method-c-read_source","(filename, **opts)","
    Creates a Basic::Program from a BASIC text file.\n
    See parse_source for details.\n"],["read_tap","ZXLib::Basic","ZXLib/Basic.html#method-c-read_tap","(filename, **opts)","
    Creates a Basic::Program or a Basic::Variable from a TAP file.\n
    See Z80::TAP.read_chunk for arguments description. …\n"],["register?","Z80::Program","Z80/Program.html#method-i-register-3F","(arg)","
    A convenient method for macros to check if an argument is a Register.\n
    Returns true for:\n\n
    hl, a, [hl], [iy ...
    \n"],["reinitialize","Z80::Alloc","Z80/Alloc.html#method-i-reinitialize","(address, type = 1, reloc = nil, members = nil)",""],["repeat","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-repeat","(times=nil, mark:nil, &block)","
    Repeats the execution of the commands in the given block repeat times. If repeat is nil or missing repeats …\n"],["repeat","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-repeat","(times=nil, mark:nil, &block)","
    Repeats the execution of the commands in the given block repeat times. If repeat is nil or missing repeats …\n"],["report_error","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-report_error","(error)","
    Returns to ZX Basic with the error report.\n
    error — Error report signature as a number 0..9 or a letter  …\n\n\n"],["report_error_unless","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-report_error_unless","(condition, error)","
    Returns to ZX Basic with the error report if condition is NOT met.\n
    condition — NZ, Z, NC, C, PO, PE, P, …\n\n"],["respond_to_missing?","Z80::Alloc","Z80/Alloc.html#method-i-respond_to_missing-3F","(m, include_private=false)",""],["restore_rom_interrupt_handler","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-restore_rom_interrupt_handler","(enable_intr:true)","
    Restore interrupt handler ZX Spectrum ROM's standard IM1 mode.\n
    enable_intr — If true invoke ei instruction …\n\n\n"],["return_with_fp","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-return_with_fp","(pop_ret_address:true, rom:self.rom, restore_iy:self.vars_iy, restore_hl_alt:rom.end_calc)","
    Creates a routine that returns to the calling ZX-Basic's USR function an FP value.\n
    When returning …\n"],["rnd","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-rnd","()","
    Creates a Lehmer random number generator routine.\n
    See: en.wikipedia.org/wiki/Lehmer_random_number_generator …\n"],["rpt","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-rpt","(times=nil, mark:nil, &block)",""],["rpt","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-rpt","(times=nil, mark:nil, &block)",""],["run","ZXUtils::Emu","ZXUtils/Emu.html#method-c-run","(file, *args)","
    Runs a ZX Spectrum emulator program with the given file as its argument.\n
    Provides additional args to the …\n"],["save_tap","Z80::TAP","Z80/TAP.html#method-i-save_tap","(filename, append:false, name:nil, **opts)","
    Saves self in a TAP file.\n
    The tap data is being generated by #to_tap_chunk.\n
    filename specifies the file …\n"],["save_tap","Z80::TAP","Z80/TAP.html#method-i-save_tap","(filename, append:false, name:nil, **opts)","
    Saves self in a TAP file.\n
    The tap data is being generated by #to_tap_chunk.\n
    filename specifies the file …\n"],["save_tap","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-save_tap","(filename, append:false)","
    Saves this chunk as a TAP file.\n
    filename specifies the file name to save to. The “.tap” extension …\n"],["screen?","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-screen-3F","()","
    true if this chunk represents a screen data\n"],["scrtoattr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-scrtoattr","(s, o:s, scraddr:0x4000)","
    Creates a routine that converts a high byte of a pixel address to a high byte of an address of a relevant …\n"],["select","Z80::Program","Z80/Program.html#method-i-select","(*args, &test)","
    Creates a conditional block that creates alternative code based on the lazy evaluated boolean condition. …\n"],["selection_sort_bytes_max256","Z80::Utils::Sort::Macros","Z80/Utils/Sort/Macros.html#method-i-selection_sort_bytes_max256","(reverse:false, target:hl, length:b, subroutine:false, &swap_items)","
    Creates a routine that sorts an array of bytes using selection sort.\n\n
    i ← length(A) - 1\nwhile i > 0\n   ...
    \n"],["set_empty_instrument","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-set_empty_instrument","()","
    Turns off any instrument previously set up with TrackCommands.set_instrument on the current channel. …\n"],["set_instrument","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-set_instrument","(instrument_name)","
    Sets an instrument for the current channel.\n
    instrument_name — A symbol or string with the instrument name …\n\n"],["setup","ZXUtils::AYMusicPlayer","ZXUtils/AYMusicPlayer.html#method-i-setup","","
    Sets up the player.\n
    Call this ONCE the player code has been loaded to create required tables for the music …\n"],["setup_custom_interrupt_handler","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-setup_custom_interrupt_handler","(handler, enable_intr:true, vector_page:0x3B)","
    Creates a routine that sets up custom interrupt handler using ZX Spectrum ROM's unused space as a …\n"],["shuffle_bytes_source_max256","Z80::Utils::Shuffle::Macros","Z80/Utils/Shuffle/Macros.html#method-i-shuffle_bytes_source_max256","(next_rng=nil, target:hl, length:a, source:nil, &next_rng_blk)","
    Creates a routine to shuffle an array of bytes.\n
    After the shuffle is performed hl points to the memory …\n"],["sign_extend","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-sign_extend","(t=a, s=a)","
    Creates a routine that extends a sign bit from an octet indicated by tl into a th.\n
    t — A target 8-bit register …\n"],["sincos_from_angle","Z80::Utils::SinCos::Macros","Z80/Utils/SinCos/Macros.html#method-i-sincos_from_angle","(sincos, th=h, tl=l)","
    Creates code that returns an address of SinCos entry for a given 256-based angle in the register a.\n
    For …\n"],["sincos_table_descriptors","Z80::Utils::SinCos::Macros","Z80/Utils/SinCos/Macros.html#method-i-sincos_table_descriptors","()","
    Returns a SinCosTable descriptors.\n
    Example:\n\n
    sincos data SinCosTable, sincos_table_descriptors\n
    \n"],["size","Z80::Program::Register","Z80/Program/Register.html#method-i-size","()",""],["spawn","ZXUtils::Emu","ZXUtils/Emu.html#method-c-spawn","(file, *args)","
    Spawns a ZX Spectrum emulator program with the given file as its argument.\n
    Provides additional args to …\n"],["split","Z80::Program::Register","Z80/Program/Register.html#method-i-split","()","
    Disjoins one of 16 bit registers: bc de hl ix or iy to array of 8bit registers: [hi, lo].\n
    Useful when …\n"],["stack_space_free","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-stack_space_free","","
    Returns (in bc) how many bytes are available in multitasking stack space for new tasks. Reports an OOM …\n"],["start","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-start","","
    A benchmark start entry for the machine-language.\n
    Provide a routine and a counter address in the memory …\n"],["start","ZXUtils::Gallery","ZXUtils/Gallery.html#method-i-start","","
    Gallery API.\n
    This endpoint should be invoked from the ZX Basic directly via USR or indirectly via FN. …\n"],["start_chord","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-start_chord","(chord_name)","
    Applies a chord defined by SongCommands.chord to the currently played note at the current channel.\n"],["start_noise_envelope","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-start_noise_envelope","(envelope_name)","
    Applies an envelope defined by SongCommands.envelope to the noise pitch level.\n"],["start_volume_envelope","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-start_volume_envelope","(envelope_name)","
    Applies an envelope defined by SongCommands.envelope to the volume level at the current channel.\n"],["statement","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-statement","()","
    Returns the FOR loop execute statement number.\n"],["step","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-step","()","
    Returns the FOR loop step value.\n"],["string?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-string-3F","()","
    true if variable is a string variable\n"],["string_to_program_text","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-c-string_to_program_text","(data, ascii_only:false, se:false)","
    Converts a ZX-Spectrum's string variable data to a source UTF-8 text with special and control characters …\n"],["sub","ZXUtils::MusicBox::InstrumentCommands","ZXUtils/MusicBox/InstrumentCommands.html#method-i-sub","(instrument_name)",""],["sub","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-sub","(multitrack_name)",""],["sub","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-sub","(track_name)",""],["sub_from","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-sub_from","(s, th, tl)","
    Creates a routine that subtracts an 8-bit s register value from a 16-bit th|tl register pair.\n
    s — A subtractor …\n"],["sub_instrument","ZXUtils::MusicBox::InstrumentCommands","ZXUtils/MusicBox/InstrumentCommands.html#method-i-sub_instrument","(instrument_name)","
    Yields execution of the instrument to another with the given instrument_name as a symbol or string.  …\n"],["sub_track","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-sub_track","(multitrack_name)","
    Yields execution of the tracks to another multi-track with the given multitrack_name as a symbol or a …\n"],["sub_track","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-sub_track","(track_name)","
    Yields execution of the track to another sub-track with the given track_name as a symbol or string.  …\n"],["sublabel?","Z80::Alloc","Z80/Alloc.html#method-i-sublabel-3F","()",""],["sublabel?","Z80::Label","Z80/Label.html#method-i-sublabel-3F","()","
    Checks if a label is a member of a struct or a stand-alone label.\n"],["sublabel_access_expression?","Z80::Alloc","Z80/Alloc.html#method-i-sublabel_access_expression-3F","()",""],["sublabel_access_expression?","Z80::Label","Z80/Label.html#method-i-sublabel_access_expression-3F","()","
    Checks if a label is a named sub-label access expression.\n"],["synchronize_channels","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-synchronize_channels","(a:nil, b:nil, c:nil)","
    Specify ranges of allowed ticks for each channel's track synchronization. If the given track is behind …\n"],["t0","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-t0","()",""],["t1","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-t1","()",""],["task?","ZXUtils::Multitasking::Macros","ZXUtils/Multitasking/Macros.html#method-i-task-3F","(tt:hl, mtvars:self.mtvars)","
    Checks if the code is being run as a task. ZF flag will be set (Z) if not a task.\n
    tt — A temporary 16bit …\n\n"],["task_id","ZXUtils::Multitasking::Macros","ZXUtils/Multitasking/Macros.html#method-i-task_id","(oh, ol, tt:hl, check_if_system:false, disable_intr:true, enable_intr:true, mtvars:self.mtvars)","
    Retrieves current task's id.\n
    oh, ol — MSB and LSB 8-bit registers for output. Together oh|ol form a …\n\n"],["task_stack_bytes_free","ZXUtils::Multitasking::Macros","ZXUtils/Multitasking/Macros.html#method-i-task_stack_bytes_free","(tt:hl, positive_size:true, disable_intr:true, enable_intr:true, mtvars:self.mtvars)","
    Calculates how many bytes are available yet on the task's stack below SP.\n
    tt — Temporary 16bit register, …\n\n"],["task_yield","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-task_yield","","
    Yields task execution.\n
    Tasks or system programs should call this endpoint instead of invoking halt. This …\n"],["tempo","ZXUtils::MusicBox::TrackConfigCommands","ZXUtils/MusicBox/TrackConfigCommands.html#method-i-tempo","(ticks=nil)","
    Gets or alters the tempo ticks.\n
    The ticks value is being used as a base for the notes/pause duration. …\n"],["terminate","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-terminate","","
    Terminates the current task.\n
    Tasks may jump to this endpoint directly to terminate themselves. If called …\n"],["terminated?","ZXLib::Basic::Tokenizer","ZXLib/Basic/Tokenizer.html#method-i-terminated-3F","()",""],["text","ZXLib::Basic::Line","ZXLib/Basic/Line.html#method-i-text","(escape_keywords:false, ascii_only:false, se:false)","
    Creates a textual representation of this line except its number. Returns an UTF-8 encoded string.\n
    See: …\n"],["then","Z80::ConditionalBlock","Z80/ConditionalBlock.html#method-i-then","(&block)","
    Evaluates a block in an anonymous namespace if the condition evaluates to true. Returns an instance of …\n"],["ticks_counter","ZXUtils::MusicBox::Track","ZXUtils/MusicBox/Track.html#method-i-ticks_counter","(counter=0)","
    Adds a track's tick counter value to the given counter and returns it.\n"],["to_a","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-to_a","()","
    Returns an array of every Basic::Variable found in self.\n"],["to_aliased_name","Z80::Alloc","Z80/Alloc.html#method-i-to_aliased_name","(start)",""],["to_aliased_name","Z80::Label","Z80/Label.html#method-i-to_aliased_name","(start)","
    Returns an abbreviated string information about a label for aliased targets.\n"],["to_alloc","Z80::Alloc","Z80/Alloc.html#method-i-to_alloc","()",""],["to_alloc","Z80::Label","Z80/Label.html#method-i-to_alloc","()","
    Returns a lazy evaluated label as an instance of Alloc class. Use one of the lazy operators directly …\n"],["to_data","Z80::Label","Z80/Label.html#method-c-to_data","(prog, offset, data)","
    Used by Program.data. Do not use it directly in programs. data must be a Hash, Struct, Array, String …\n"],["to_debug","Z80::Program::Register","Z80/Program/Register.html#method-i-to_debug","()",""],["to_i","Z80::Alloc","Z80/Alloc.html#method-i-to_i","(start = 0, rel_to = nil, override:nil, prefix:''.freeze, size_of:false)","
    rel_to: an absolute address or :self used by ix/iy offset addressing\n"],["to_i","Z80::Label","Z80/Label.html#method-c-to_i","()","
    Returns a size of a data structure immediately.\n"],["to_i","Z80::Label","Z80/Label.html#method-i-to_i","(start = 0, rel_to = nil, override:nil, prefix:''.freeze, size_of:false)","
    Evaluates a label. This method is being used during program compilation.\n
    start — An absolute address to …\n\n"],["to_i","Z80::Program::Condition","Z80/Program/Condition.html#method-i-to_i","()",""],["to_i","Z80::Program::Register","Z80/Program/Register.html#method-i-to_i","()",""],["to_label","Symbol","Symbol.html#method-i-to_label","(program)","
    Allows to use Symbols instead of labels in some situations. Example:\n\n
    loop1 add [hl]\n      inc hl\n     ...
    \n"],["to_label","Z80::Alloc","Z80/Alloc.html#method-i-to_label","(_)",""],["to_label","Z80::Label","Z80/Label.html#method-i-to_label","(_)","
    Should return a Label or an Alloc. This method's existence indicates that something quacks like a …\n"],["to_module","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-to_module","()","
    Returns an instance of the SongModule from the compiled Song instance.\n"],["to_name","Z80::Alloc","Z80/Alloc.html#method-i-to_name","(info=false)",""],["to_name","Z80::Label","Z80/Label.html#method-i-to_name","(info=false)","
    Returns this label's name as string or nil.\n
    info enables returning made up name if this label is anonymous. …\n"],["to_player_module","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-to_player_module","()","
    Returns an instance of the PlayerModule from the compiled Song instance.\n"],["to_player_module","ZXUtils::MusicBox::Song::SongModule","ZXUtils/MusicBox/Song/SongModule.html#method-i-to_player_module","()","
    Returns an instance of the PlayerModule from the compiled SongModule instance.\n"],["to_program","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-to_program","()","
    Returns an ad-hoc Z80::Program class containing the compiled Song. See SongModule.to_program.\n"],["to_program","ZXUtils::MusicBox::Song::SongModule","ZXUtils/MusicBox/Song/SongModule.html#method-i-to_program","()","
    Returns an ad-hoc Z80::Program class containing the compiled SongModule.\n
    The returned program exports …\n"],["to_s","Z80::Alloc","Z80/Alloc.html#method-i-to_s","()",""],["to_s","Z80::Label","Z80/Label.html#method-i-to_s","()",""],["to_s","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-to_s","()","
    For humans.\n"],["to_s","ZXLib::Basic::Line","ZXLib/Basic/Line.html#method-i-to_s","(**opts)","
    Creates a textual representation of this line with the line number. Returns an UTF-8 encoded string. …\n"],["to_s","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-to_s","(escape_keywords:false, ascii_only:false, se:false)",""],["to_s","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-to_s","()","
    Returns this variable in a BASIC-like text format.\n"],["to_s","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-to_s","()","
    Returns all variables in a BASIC-like text format.\n"],["to_source","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-to_source","(escape_keywords:false, ascii_only:false, se:false)","
    Creates the textual representation of a ZX Basic::Program.\n
    Returns an UTF-8 encoded string.\n
    The conversion …\n"],["to_str","Z80::Alloc","Z80/Alloc.html#method-i-to_str","()",""],["to_str","Z80::Label","Z80/Label.html#method-i-to_str","()","
    Returns an abbreviated string information about a label, mostly used in error messages.\n"],["to_struct","Z80::Label","Z80/Label.html#method-c-to_struct","()","
    Returns a new Ruby Struct from members defined in a data structure.\n
    Instances of such a Struct are suitable …\n"],["to_tap","Z80::TAP","Z80/TAP.html#method-i-to_tap","(name, **opts)","
    Produces a TAP blob as a binary string from self.\n
    A sugar for calling TAP::HeaderBody#to_tap method on …\n"],["to_tap","Z80::TAP","Z80/TAP.html#method-i-to_tap","(name, **opts)","
    Produces a TAP blob as a binary string from self.\n
    A sugar for calling TAP::HeaderBody#to_tap method on …\n"],["to_tap","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-to_tap","()","
    Produces a TAP blob as a binary string from this chunk.\n"],["to_tap_chunk","Z80::TAP","Z80/TAP.html#method-i-to_tap_chunk","(name, org:nil)","
    Creates a TAP::HeaderBody chunk from self.\n
    By default it uses Z80#code and the Z80#org to produce the …\n"],["to_tap_chunk","Z80::TAP","Z80/TAP.html#method-i-to_tap_chunk","(name, org:nil)","
    Creates a TAP::HeaderBody chunk from self.\n
    By default it uses Z80#code and the Z80#org to produce the …\n"],["to_tap_chunk","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-to_tap_chunk","(name, line:nil)","
    Creates a Z80::TAP::HeaderBody instance from Basic::Program#code.\n
    This method is provided for the included …\n"],["to_tap_chunk","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-to_tap_chunk","(name, org:nil)","
    Creates a Z80::TAP::HeaderBody instance from Basic::Variable.\n
    This method is provided for the included …\n"],["to_z80bin","Float","Float.html#method-i-to_z80bin","(simplified_int=true)","
    Converts Float to a ZX-Spectrum's real number encoded as a 5-byte binary string.\n
    Suitable to be used …\n"],["tone_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-tone_off","()","
    Turns off the current channel's tone output.\n"],["tone_on","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-tone_on","()","
    Turns on the current channel's tone output.\n"],["tone_progress","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-tone_progress","(delta, counter)","
    Enables and controls the tone frequency progression of the current channel's tone.\n
    delta — A floating …\n"],["tp","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-tp","(delta, counter)",""],["track","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-track","(name, &block)","
    Creates a track with the given name as a symbol or a string.\n
    Give a block of code containing track commands. …\n"],["twos_complement16_by_sgn","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-twos_complement16_by_sgn","(sh, sl, sgn, th:sh, tl:sl, t:sgn)","
    Creates a routine that changes the sign of a twos complement 16-bit integer depending on the content …\n"],["union","Z80::Program","Z80/Program.html#method-i-union","(label, type, align: nil, offset: 0)","
    Returns a new, unnamed label addressed by label, but of different type. type can be an integer or a data …\n"],["unknown","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-unknown","","
    Attempts to read a positive 16-bit integer from a FP-value addressed by hl.\n
    NOTE — This routine must never …\n\n"],["unpack_number","ZXLib::Math","ZXLib/Math.html#method-c-unpack_number","(bin, simplified_int_as_fixnum=true)","
    Converts a ZX-Spectrum's real number as a 5-byte binary string to Numeric value.\n
    simplified_int_as_fixnum …\n"],["unused_item_names","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-unused_item_names","()","
    Returns a hash with unused item names in each of the item category.\n"],["unwrap_pointer","Z80::Program","Z80/Program.html#method-i-unwrap_pointer","(arg)","
    Returns a normalized pointer label, Register or an integer. Otherwise pass-through.\n
    Convenient method …\n"],["utobcd","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-utobcd","(bufend, input=de, size: 4, r: d, rr: de, byteorder: :lsb, input_end:false)","
    Creates a routine that converts an unsigned binary integer of an arbitrary size to a BCD string.\n
    bufend … — "],["utobcd_step","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-utobcd_step","(bufend, r, buflen=1, t=c, r_in_a=false)","
    Creates a routine that converts an 8-bit unsigned integer to a BCD string.\n
    Used by Macros.utobcd.\n
    bufend … — "],["v","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-v","(level)",""],["va","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-va","(amplitude=1.0)",""],["validate_recursion_depth!","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-validate_recursion_depth-21","(track_stack_depth=20)","
    Checks if maximal recursion depth of tracks and instruments is not exceeding the given threshold.\n
    Provide …\n"],["value","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-value","()","
    Returns a value of a variable.\n
    A Float or an Integer for numbers (including FOR loops).\n
    A (possibly nested) …\n"],["variable_volume","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-variable_volume","()",""],["ve","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-ve","(envelope_name)",""],["vec_deque_clear","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_clear","(vec_deque, vec_deque_bot:)","
    Creates a routine that initializes or clears the queue.\n
    vec_deque — A label of a type VecDequeState addressing …\n\n"],["vec_deque_empty?","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_empty-3F","(vec_deque, branch_not_empty: nil, branch_relative: true, tt: de)","
    Creates a routine that checks if the queue is empty.\n
    In case branch_not_full is nil the Z flag, if set, …\n"],["vec_deque_full?","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_full-3F","(vec_deque, branch_not_full: nil, branch_relative: true, tt: de)","
    Creates a routine that checks if the queue is full.\n
    In case branch_not_full is nil the Z flag, if set, …\n"],["vec_deque_length","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_length","(vec_deque, vec_deque_bot:, vec_deque_top:, tt: de, subroutine: false)","
    Creates a routine that calculates the current length of the queue.\n
    The length is made available as a 16-bit …\n"],["vec_deque_next_back","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_next_back","(vec_deque=nil, vec_deque_bot:, vec_deque_top:, cursor: de, subroutine: false)","
    Creates a routine that reads a byte element from the back of the queue advancing the cursor backwards. …\n"],["vec_deque_next_front","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_next_front","(vec_deque=nil, vec_deque_bot:, vec_deque_top:, cursor: de, subroutine: false)","
    Creates a routine that reads a byte element from the front of the queue advancing the cursor forward. …\n"],["vec_deque_pop_back","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_pop_back","(vec_deque, vec_deque_bot:, vec_deque_top:, branch_on_empty: nil, branch_relative: true, tt: de)","
    Creates a routine that removes a byte element from the back of the queue.\n
    The removed element is provided …\n"],["vec_deque_pop_front","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_pop_front","(vec_deque, vec_deque_bot:, vec_deque_top:, branch_on_empty: nil, branch_relative: true, tt: de)","
    Creates a routine that removes a byte element from the front of the queue.\n
    The removed element is provided …\n"],["vec_deque_push_back","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_push_back","(vec_deque, vec_deque_bot:, vec_deque_top:, branch_on_full: nil, branch_relative: true, tt: de)","
    Creates a routine that appends a byte element to the back of the queue.\n
    accumulator — Should hold a value …\n"],["vec_deque_push_front","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_push_front","(vec_deque, vec_deque_bot:, vec_deque_top:, branch_on_full: nil, branch_relative: true, tt: de)","
    Creates a routine that appends a byte element to the front of the queue.\n
    accumulator — Should hold a value …\n"],["veo","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-veo","()",""],["vg","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vg","(angle=0.0)",""],["vibrato_amplitude","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vibrato_amplitude","(amplitude=1.0)","
    Enables the current channel's tone vibrato and sets the distortion amplitude.\n
    amplitude — A positive …\n\n"],["vibrato_angle","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vibrato_angle","(angle=0.0)","
    Enables the current channel's tone vibrato and sets the current phase angle.\n
    angle — A positive floating …\n\n"],["vibrato_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vibrato_off","()","
    Turns off, if any, the current channel's tone vibrato distortion.\n"],["vibrato_step","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vibrato_step","(step=1.0)","
    Enables the current channel's tone vibrato and sets the distortion angle progression step.\n
    step — A …\n\n"],["vo","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vo","()",""],["volume","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-volume","(level)","
    Sets volume level for the current channel: 0 to 15.\n"],["volume_envelope_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-volume_envelope_off","()","
    Turns off, if any, an envelope applied to the volume level at the current channel.\n"],["vs","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vs","(step=1.0)",""],["vv","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vv","()",""],["w","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-w","(ticks)",""],["w","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-w","(ticks)",""],["wait","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-wait","(ticks)","
    Pauses the current track execution for ticks number of ticks. The ticks value should be a positive integer …\n"],["wait","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-wait","(ticks)","
    Pauses tracks execution for ticks number of ticks. The ticks value should be a positive integer as an …\n"],["wait_io","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-wait_io","","
    ZX Basic API\n
    This endpoint should be invoked from the ZX Basic indirectly via FN.\n\n
    2 DEF FN w(s,n)=USR wait_io: ...
    \n"],["widen_pixels8_16","ZXUtils::BigFont::Macros","ZXUtils/BigFont/Macros.html#method-i-widen_pixels8_16","(f1, f2, unroll:true)","
    Each bit of the a register is duplicated and placed in the f1 and f2 registers.\n
    Modifies: af, f1 and  …\n"],["with_saved","Z80::Program::Macros","Z80/Program/Macros.html#method-i-with_saved","(*registers, **opts, &block)","
    Adds a code that pushes specified registers on a machine stack, code from block within a namespace and …\n"],["word","Z80::Label","Z80/Label.html#method-c-word","(size = 1)","
    A data structure's field type.\n"],["words","Z80::Program","Z80/Program.html#method-i-words","(*args)","
    Returns an unnamed label and allocates count words with Program.data. Optionally you can provide values …\n"],["xy_to_attr_addr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-xy_to_attr_addr","(x, y, scraddr:0x4000)","
    Calculates a constant screen attribute address from the pixel coordinates.\n"],["xy_to_pixel_addr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-xy_to_pixel_addr","(x, y, scraddr:0x4000)","
    Calculates a constant screen pixel byte address from the pixel coordinates.\n"],["xytoscr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-xytoscr","(y, x, ah:h, al:l, s:b, t:c, scraddr:0x4000)",""],["ytoattr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-ytoattr","(y, ah:h, al:l, col:0, scraddr:0x4000)","
    Creates a routine that converts a vertical pixel coordinate to an address of a color attribute.\n
    Modifies: …\n"],["ytoscr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-ytoscr","(y, ah:h, al:l, col:nil, t:c, scraddr:0x4000, hires:false)","
    Creates a routine that converts a vertical pixel coordinate to a screen byte address.\n
    Modifies: af, ah …\n"],["yxtoscr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-yxtoscr","(y, x, ah:h, al:l, s:b, t:c, scraddr:0x4000)","
    Creates a routine that converts y,x coordinates to a screen byte address and a bits shift.\n
    Modifies:  …\n"],["|","Z80::Alloc","Z80/Alloc.html#method-i-7C","(other)",""],["|","Z80::Label","Z80/Label.html#method-i-7C","(m)","
    Returns a lazy evaluated bitwise “or” of a label and an other label or an integer.\n"],["|","Z80::Program::Register","Z80/Program/Register.html#method-i-7C","(other)","
    Adjoins two 8 bit registers to form one 16 bit register.\n
    Useful when defining macros that may use registers …\n"],["~","Z80::Alloc","Z80/Alloc.html#method-i-~","()",""],["~","Z80::Label","Z80/Label.html#method-i-~","()","
    Returns a lazy evaluated bitwise negated label.\n"],["CHANGELOG","","CHANGELOG_md.html","","
    v1.1.1.pre-2\n
    Z80:\n
    New macro Z80::MathInt::Macros#mul8_signed.\n"],["LICENSE","","LICENSE_md.html","","
    The Parity Public License 7.0.0\n
    Contributor: Rafał Michalski\n
    Source Code: github.com/royaltm/z80-rb\n"],["README","","README_rdoc.html","","
    ruby-Z80\n
    Documentation.\n
    Source repository.\n"]]}}
\ No newline at end of file
+var search_data = {"index":{"searchIndex":["aytest","bench","echo","float","musictest","object","symbol","z80","alloc","compileerror","conditionalblock","label","mathint","integers","macros","program","condition","macros","mnemonics","register","stdlib","macros","syntax","tap","headerbody","tapeerror","tzx","utils","shuffle","macros","sincos","macros","sincos","sincostable","sort","macros","vecdeque","macros","vecdequestate","z80lib3d","matrix3d","macros","primitives","matrix","rotation","sincos","vector","vertex","quaternion","zx7","macros","zxlib","aysound","envelopecontrol","macros","mixer","registers","volumecontrol","basic","line","program","tokenizer","patterns","variable","variableparseerror","variabletypes","vars","gfx","bobs","macros","clip","macros","outcode","draw","constants","macros","macros","sprite8","macros","math","macros","zxreal","sys","coords","cursor","if1vars","macros","strms","vars","vars128","zxutils","aybasicplayer","aymusic","ayregistermirror","channelcontrol","chordcontrol","envelopecontrol","instrumentcontrol","macros","maskcontrol","musiccontrol","toneprogresscontrol","trackcontrol","trackstackentry","vibratocontrol","aymusicplayer","musictracks","trackinfo","benchmark","macros","bigfont","macros","bigfonthires","emu","gallery","formats","multitasking","macros","taskinfo","taskvars","multitaskingio","bufferio","macros","taskvarsio","musicbox","ayenvelopedurationcommand","ayenvelopeshapecommand","chord","chordcommand","command","headers","metacommand","commoninstrumentcommands","emptytrack","envelope","envelopecommand","indexcommand","instrument","instrumentcommand","instrumentcommands","loopcommand","markcommand","mask","maskcommand","multitrack","multitrackcommands","noisepitchcommand","notechordcommand","notecommand","noteprogressperiodcommand","pausecommand","resolver","song","playermodule","songmodule","songcommands","subinstrumentcommand","subtrackcommand","toneprogresscommand","track","trackcommands","trackconfigcommands","vibratoamplitudecommand","vibratoanglecommand","vibratostepcommand","volumelevelcommand","%()","%()","&()","&()","*()","*()","**()","**()","+()","+()","+()","+@()","+@()","+@()","-()","-()","-()","-@()","-@()","/()","/()","<<()","<<()","<<()","==()",">>()",">>()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","^()","^()","add24_16()","add_code()","add_reloc()","adda_to()","addr()","address?()","alias?()","alias?()","alias_label()","all_ch()","all_channels()","api()","apply_matrix()","apply_matrix_element()","apply_matrix_row()","array?()","array?()","as()","ay_expand_notes()","ay_expand_notes_faster()","ay_get_register_value()","ay_get_set_env_shape()","ay_get_set_mixer()","ay_hz2tp()","ay_init()","ay_io_load_const_reg_bc()","ay_io_swap2inp_bc()","ay_io_swap2out_bc()","ay_io_swap2sel_bc()","ay_music_finished?()","ay_music_init()","ay_music_note_to_fine_tone_cursor_table_factory()","ay_music_preserve_io_ports_state()","ay_music_tone_progress_table_factory()","ay_set_envelope_duration()","ay_set_noise_pitch()","ay_set_register_value()","ay_set_tone_period()","ay_set_volume()","ay_tone_periods()","bcdtoa()","bench()","bit8?()","bobs_copy_attrs()","bobs_copy_attrs_fast()","bobs_copy_pixels()","bobs_copy_pixels_fast()","bobs_draw_pixels_fast()","bobs_draw_pixels_fast_jump_table()","bobs_draw_pixels_fast_routines()","bobs_rshift_bitmap_pixels_7times()","bobs_rshift_bitmap_pixels_once()","byte()","bytes()","bytesize()","bytesize()","byteslice()","calculate_benchmark_tstates()","ce()","ceo()","ch_a()","ch_b()","ch_c()","chan_exists()","channel()","channel_name_to_index()","channel_track()","char_array?()","char_ptr_from_code()","chord()","chord_off()","clear!()","clear_attrs_region_fast()","clear_screen_region_fast()","clrmem()","clrmem8()","clrmem_fastest()","clrmem_quick()","cmp_i16n()","cmp_i16r()","cmp_i8()","code()","code()","code?()","compress()","copy_shadow_attrs_region()","copy_shadow_attrs_region_quick()","copy_shadow_screen_region()","copy_shadow_screen_region_quick()","cp16n()","cp16r()","cp16rr()","create_chan_and_open()","create_sincos_from_sintable()","cursor_key_pressed?()","data()","db()","dc!()","debug()","debug_comment()","define_label()","direct_address?()","direct_label?()","disable_ay_volume_ctrl()","divmod()","divmod16()","divmod16_8()","divmod24_8()","divmod32_16()","divmod32_8()","divmod8()","draw_line()","draw_line_dx_gt_4dy()","draw_line_dx_gt_dy()","draw_line_dy_gte_dx()","draw_line_fx_data()","draw_line_fx_data_dx_gt_4dy()","draw_line_fx_data_dx_gt_dy()","draw_line_fx_data_dy_gte_dx()","draw_line_fx_data_vertical()","draw_line_update()","draw_line_update_dx_gt_4dy()","draw_line_update_dx_gt_dy()","draw_line_update_dy_gte_dx()","draw_line_update_vertical()","draw_line_vertical()","draw_sprite8()","dummy()","dummy?()","dummy?()","dup()","dw()","dzx7_agilercs()","dzx7_mega()","dzx7_smartrcs()","dzx7_standard()","dzx7_turbo()","each_var()","ei()","else()","else_select()","enable_ay_volume_ctrl()","enlarge_char8_16()","envd()","envdur()","envelope()","envelope_duration()","envelope_shape()","envs()","envsh()","equal_tempered_scale_notes_hz()","estimate_tstates_per_interrupt()","export()","expression?()","expression?()","find_channel()","find_channel_arg()","find_def_fn_args()","find_emulator()","find_input_handle()","find_io_handles()","find_output_handle()","find_record()","first_octave_note()","fixed_volume()","for_ch()","for_channels()","for_loop?()","fp_to_integer32()","from_data()","from_program_data()","from_tap_chunk()","fv()","get()","get_adjustment()","get_counter()","get_emulator_path()","get_frames()","get_idle()","get_int8_norm_arg()","get_stream_arg()","getset_tsframe()","gfx_clip_calculate_8bit_dx_dy_exx()","gfx_clip_compute_outcode()","gfx_clip_coords_to_draw_line_args()","gfx_clip_dimension()","gfx_clip_line()","gfx_sprite8_calculate_coords()","gfx_sprite8_calculate_screen_address()","gfx_sprite8_draw()","gfx_sprite8_flip_horizontally()","head()","i()","immediate?()","immediate?()","immediate?()","import()","import_chord()","import_envelope()","import_file()","import_instrument()","import_mask()","import_multitrack()","import_track()","include?()","indexable?()","indexable?()","init()","init()","init_multitasking()","init_music()","initialize()","initialize_io()","insertion_sort_bytes_max256()","instrument()","instruments()","int()","integer32_to_fp()","interlace_pixels16()","isolate()","jr_ok?()","kernel_org()","kernel_org()","key_pressed?()","label()","label?()","label_defined?()","label_immediate?()","label_import()","ld16()","length()","limit()","line()","line_index()","list()","loop_to()","loop_to()","lt()","lt()","m()","m()","m1()","m2()","macro()","macro_import()","make()","make_draw_line_subroutines()","make_many()","mark()","mark()","mask()","mask_ay_volume_envelope()","mask_ay_volume_envelope_off()","mask_noise()","mask_noise_off()","mask_tone()","mask_tone_off()","match16?()","me()","members_of_struct()","memcpy()","memcpy_quick()","meo()","method_missing()","method_missing()","method_missing()","method_missing()","mix_lines8_16()","mmu128_select_bank()","mmu128_swap_screens()","mn()","mno()","mode1()","mode2()","move_basic_above_scld_screen_memory()","mt()","mtio_drain()","mtio_getc()","mtio_gets()","mtio_putc()","mtio_puts()","mtio_ready?()","mtio_wait()","mto()","mul()","mul16()","mul16_32()","mul16_signed()","mul16_signed9()","mul8()","mul8_24()","mul8_c()","mul8_signed()","mul_const()","mul_const8_24()","mul_signed()","mul_signed9()","mul_signed9_24()","multitrack()","mute_sound()","n()","n0()","n1()","name=()","name=()","names()","names()","ne()","neg16()","neg_int()","neg_sintable256_pi_half_no_zero_lo()","neo()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new_char_array()","new_code()","new_for_loop()","new_kernel()","new_kernel()","new_number()","new_number_array()","new_program()","new_string()","new_var_array()","next_token()","nextline()","nextpixel()","nextrow()","noise()","noise_envelope_off()","noise_off()","noise_on()","normalize_quaternion()","note_progress()","np()","ns()","number?()","number_array?()","offset_of_()","one_of?()","one_of?()","only_one_bit_set_or_zero?()","open_io()","org()","p()","p()","pack_number()","parse_each()","parse_file()","parse_file()","parse_source()","parse_source_line()","parse_tap()","parse_tap()","pause()","pause()","pc()","pch()","peek_token()","play()","play()","play_chord()","play_interval()","play_loop()","plot_pixel()","pointer?()","pointer?()","pointer?()","pointer?()","prepare_args_draw_line_to()","preshifted_pixel_mask_data()","prevline()","prevpixel()","print_char()","print_char_hires()","print_fp_hl()","program?()","program_text_to_string()","quaternion2matrix()","quaternion_cross_product()","quaternion_norm()","quaternion_norm_q()","quicksort_bytes()","rctoattr()","rctoscr()","rdoc_mark_find_def_fn_arg()","read_arg_string()","read_chunk()","read_chunk()","read_data()","read_data()","read_integer32_value()","read_integer_value()","read_positive_int_value()","read_source()","read_tap()","register?()","reinitialize()","repeat()","repeat()","report_error()","report_error_unless()","respond_to_missing?()","restore_rom_interrupt_handler()","return_with_fp()","rnd()","rotor_quaternion()","rpt()","rpt()","run()","save_tap()","save_tap()","save_tap()","scale()","screen?()","scrtoattr()","select()","selection_sort_bytes_max256()","set_empty_instrument()","set_instrument()","setup()","setup_custom_interrupt_handler()","shuffle_bytes_source_max256()","sign_extend()","sincos_from_angle()","sincos_table_descriptors()","size()","sll8_16()","spawn()","split()","stack_space_free()","start()","start()","start_chord()","start_noise_envelope()","start_volume_envelope()","statement()","step()","string?()","string_to_program_text()","sub()","sub()","sub()","sub_from()","sub_instrument()","sub_track()","sub_track()","sublabel?()","sublabel?()","sublabel_access_expression?()","sublabel_access_expression?()","synchronize_channels()","t0()","t1()","task?()","task_id()","task_stack_bytes_free()","task_yield()","tempo()","terminate()","terminated?()","text()","then()","ticks_counter()","to_a()","to_aliased_name()","to_aliased_name()","to_alloc()","to_alloc()","to_data()","to_debug()","to_fixed16_8()","to_i()","to_i()","to_i()","to_i()","to_i()","to_label()","to_label()","to_label()","to_module()","to_name()","to_name()","to_player_module()","to_player_module()","to_program()","to_program()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_source()","to_str()","to_str()","to_struct()","to_tap()","to_tap()","to_tap()","to_tap_chunk()","to_tap_chunk()","to_tap_chunk()","to_tap_chunk()","to_z80bin()","tone_off()","tone_on()","tone_progress()","tp()","track()","twos_complement16_by_sgn()","union()","unknown()","unpack_number()","unused_item_names()","unwrap_pointer()","utobcd()","utobcd_step()","v()","va()","validate_recursion_depth!()","value()","variable_volume()","ve()","vec_deque_clear()","vec_deque_empty?()","vec_deque_full?()","vec_deque_length()","vec_deque_next_back()","vec_deque_next_front()","vec_deque_pop_back()","vec_deque_pop_front()","vec_deque_push_back()","vec_deque_push_front()","veo()","vg()","vibrato_amplitude()","vibrato_angle()","vibrato_off()","vibrato_step()","vo()","volume()","volume_envelope_off()","vs()","vv()","w()","w()","wait()","wait()","wait_io()","widen_pixels8_16()","with_saved()","word()","words()","xy_to_attr_addr()","xy_to_pixel_addr()","xytoscr()","ytoattr()","ytoscr()","yxtoscr()","|()","|()","|()","~()","~()","changelog","license","readme"],"longSearchIndex":["aytest","bench","echo","float","musictest","object","symbol","z80","z80::alloc","z80::compileerror","z80::conditionalblock","z80::label","z80::mathint","z80::mathint::integers","z80::mathint::macros","z80::program","z80::program::condition","z80::program::macros","z80::program::mnemonics","z80::program::register","z80::stdlib","z80::stdlib::macros","z80::syntax","z80::tap","z80::tap::headerbody","z80::tap::tapeerror","z80::tzx","z80::utils","z80::utils::shuffle","z80::utils::shuffle::macros","z80::utils::sincos","z80::utils::sincos::macros","z80::utils::sincos::sincos","z80::utils::sincos::sincostable","z80::utils::sort","z80::utils::sort::macros","z80::utils::vecdeque","z80::utils::vecdeque::macros","z80::utils::vecdeque::vecdequestate","z80lib3d","z80lib3d::matrix3d","z80lib3d::matrix3d::macros","z80lib3d::primitives","z80lib3d::primitives::matrix","z80lib3d::primitives::rotation","z80lib3d::primitives::sincos","z80lib3d::primitives::vector","z80lib3d::primitives::vertex","z80lib3d::quaternion","zx7","zx7::macros","zxlib","zxlib::aysound","zxlib::aysound::envelopecontrol","zxlib::aysound::macros","zxlib::aysound::mixer","zxlib::aysound::registers","zxlib::aysound::volumecontrol","zxlib::basic","zxlib::basic::line","zxlib::basic::program","zxlib::basic::tokenizer","zxlib::basic::tokenizer::patterns","zxlib::basic::variable","zxlib::basic::variableparseerror","zxlib::basic::variabletypes","zxlib::basic::vars","zxlib::gfx","zxlib::gfx::bobs","zxlib::gfx::bobs::macros","zxlib::gfx::clip","zxlib::gfx::clip::macros","zxlib::gfx::clip::outcode","zxlib::gfx::draw","zxlib::gfx::draw::constants","zxlib::gfx::draw::macros","zxlib::gfx::macros","zxlib::gfx::sprite8","zxlib::gfx::sprite8::macros","zxlib::math","zxlib::math::macros","zxlib::math::zxreal","zxlib::sys","zxlib::sys::coords","zxlib::sys::cursor","zxlib::sys::if1vars","zxlib::sys::macros","zxlib::sys::strms","zxlib::sys::vars","zxlib::sys::vars128","zxutils","zxutils::aybasicplayer","zxutils::aymusic","zxutils::aymusic::ayregistermirror","zxutils::aymusic::channelcontrol","zxutils::aymusic::chordcontrol","zxutils::aymusic::envelopecontrol","zxutils::aymusic::instrumentcontrol","zxutils::aymusic::macros","zxutils::aymusic::maskcontrol","zxutils::aymusic::musiccontrol","zxutils::aymusic::toneprogresscontrol","zxutils::aymusic::trackcontrol","zxutils::aymusic::trackstackentry","zxutils::aymusic::vibratocontrol","zxutils::aymusicplayer","zxutils::aymusicplayer::musictracks","zxutils::aymusicplayer::trackinfo","zxutils::benchmark","zxutils::benchmark::macros","zxutils::bigfont","zxutils::bigfont::macros","zxutils::bigfonthires","zxutils::emu","zxutils::gallery","zxutils::gallery::formats","zxutils::multitasking","zxutils::multitasking::macros","zxutils::multitasking::taskinfo","zxutils::multitasking::taskvars","zxutils::multitaskingio","zxutils::multitaskingio::bufferio","zxutils::multitaskingio::macros","zxutils::multitaskingio::taskvarsio","zxutils::musicbox","zxutils::musicbox::ayenvelopedurationcommand","zxutils::musicbox::ayenvelopeshapecommand","zxutils::musicbox::chord","zxutils::musicbox::chordcommand","zxutils::musicbox::command","zxutils::musicbox::command::headers","zxutils::musicbox::command::metacommand","zxutils::musicbox::commoninstrumentcommands","zxutils::musicbox::emptytrack","zxutils::musicbox::envelope","zxutils::musicbox::envelopecommand","zxutils::musicbox::indexcommand","zxutils::musicbox::instrument","zxutils::musicbox::instrumentcommand","zxutils::musicbox::instrumentcommands","zxutils::musicbox::loopcommand","zxutils::musicbox::markcommand","zxutils::musicbox::mask","zxutils::musicbox::maskcommand","zxutils::musicbox::multitrack","zxutils::musicbox::multitrackcommands","zxutils::musicbox::noisepitchcommand","zxutils::musicbox::notechordcommand","zxutils::musicbox::notecommand","zxutils::musicbox::noteprogressperiodcommand","zxutils::musicbox::pausecommand","zxutils::musicbox::resolver","zxutils::musicbox::song","zxutils::musicbox::song::playermodule","zxutils::musicbox::song::songmodule","zxutils::musicbox::songcommands","zxutils::musicbox::subinstrumentcommand","zxutils::musicbox::subtrackcommand","zxutils::musicbox::toneprogresscommand","zxutils::musicbox::track","zxutils::musicbox::trackcommands","zxutils::musicbox::trackconfigcommands","zxutils::musicbox::vibratoamplitudecommand","zxutils::musicbox::vibratoanglecommand","zxutils::musicbox::vibratostepcommand","zxutils::musicbox::volumelevelcommand","z80::alloc#%()","z80::label#%()","z80::alloc#&()","z80::label#&()","z80::alloc#*()","z80::label#*()","z80::alloc#**()","z80::label#**()","z80::alloc#+()","z80::label#+()","z80::program::register#+()","z80::alloc#+@()","z80::label::+@()","z80::label#+@()","z80::alloc#-()","z80::label#-()","z80::program::register#-()","z80::alloc#-@()","z80::label#-@()","z80::alloc#/()","z80::label#/()","z80::alloc#<<()","z80::label#<<()","zxlib::basic::vars#<<()","z80::alloc#==()","z80::alloc#>>()","z80::label#>>()","z80#[]()","z80::alloc#[]()","z80::label#[]()","z80::program#[]()","z80::program::condition::[]()","z80::program::register#[]()","z80::program::register::[]()","zxlib::basic::program#[]()","zxlib::basic::variable#[]()","zxlib::basic::vars#[]()","z80::alloc#^()","z80::label#^()","z80::mathint::macros#add24_16()","z80::add_code()","z80::add_reloc()","z80::mathint::macros#adda_to()","z80::program#addr()","z80::program#address?()","z80::alloc#alias?()","z80::label#alias?()","z80::program#alias_label()","zxutils::musicbox::multitrackcommands#all_ch()","zxutils::musicbox::multitrackcommands#all_channels()","zxutils::multitasking#api()","z80lib3d::matrix3d::macros#apply_matrix()","z80lib3d::matrix3d::macros#apply_matrix_element()","z80lib3d::matrix3d::macros#apply_matrix_row()","z80::tap::headerbody#array?()","zxlib::basic::variable#array?()","z80::program#as()","zxlib::aysound::macros#ay_expand_notes()","zxlib::aysound::macros#ay_expand_notes_faster()","zxlib::aysound::macros#ay_get_register_value()","zxlib::aysound::macros#ay_get_set_env_shape()","zxlib::aysound::macros#ay_get_set_mixer()","zxlib::aysound::macros#ay_hz2tp()","zxlib::aysound::macros#ay_init()","zxlib::aysound::macros#ay_io_load_const_reg_bc()","zxlib::aysound::macros#ay_io_swap2inp_bc()","zxlib::aysound::macros#ay_io_swap2out_bc()","zxlib::aysound::macros#ay_io_swap2sel_bc()","zxutils::aymusic::macros#ay_music_finished?()","zxutils::aymusic::macros#ay_music_init()","zxutils::aymusic::macros#ay_music_note_to_fine_tone_cursor_table_factory()","zxutils::aymusic::macros#ay_music_preserve_io_ports_state()","zxutils::aymusic::macros#ay_music_tone_progress_table_factory()","zxlib::aysound::macros#ay_set_envelope_duration()","zxlib::aysound::macros#ay_set_noise_pitch()","zxlib::aysound::macros#ay_set_register_value()","zxlib::aysound::macros#ay_set_tone_period()","zxlib::aysound::macros#ay_set_volume()","zxlib::aysound::macros#ay_tone_periods()","z80::mathint::macros#bcdtoa()","zxutils::benchmark#bench()","z80::program::register#bit8?()","zxlib::gfx::bobs::macros#bobs_copy_attrs()","zxlib::gfx::bobs::macros#bobs_copy_attrs_fast()","zxlib::gfx::bobs::macros#bobs_copy_pixels()","zxlib::gfx::bobs::macros#bobs_copy_pixels_fast()","zxlib::gfx::bobs::macros#bobs_draw_pixels_fast()","zxlib::gfx::bobs::macros#bobs_draw_pixels_fast_jump_table()","zxlib::gfx::bobs::macros#bobs_draw_pixels_fast_routines()","zxlib::gfx::bobs::macros#bobs_rshift_bitmap_pixels_7times()","zxlib::gfx::bobs::macros#bobs_rshift_bitmap_pixels_once()","z80::label::byte()","z80::program#bytes()","zxlib::basic::variable#bytesize()","zxutils::musicbox::track#bytesize()","zxlib::basic::variable#byteslice()","zxutils::benchmark::macros#calculate_benchmark_tstates()","zxutils::musicbox::commoninstrumentcommands#ce()","zxutils::musicbox::commoninstrumentcommands#ceo()","zxutils::musicbox::multitrackcommands#ch_a()","zxutils::musicbox::multitrackcommands#ch_b()","zxutils::musicbox::multitrackcommands#ch_c()","zxlib::sys::macros#chan_exists()","zxutils::musicbox::multitrackcommands#channel()","zxutils::musicbox::multitrackcommands::channel_name_to_index()","zxutils::musicbox::multitrack#channel_track()","zxlib::basic::variable#char_array?()","zxlib::sys::macros#char_ptr_from_code()","zxutils::musicbox::songcommands#chord()","zxutils::musicbox::commoninstrumentcommands#chord_off()","zxlib::basic::vars#clear!()","zxlib::gfx::macros#clear_attrs_region_fast()","zxlib::gfx::macros#clear_screen_region_fast()","z80::stdlib::macros#clrmem()","z80::stdlib::macros#clrmem8()","z80::stdlib::macros#clrmem_fastest()","z80::stdlib::macros#clrmem_quick()","z80::mathint::macros#cmp_i16n()","z80::mathint::macros#cmp_i16r()","z80::mathint::macros#cmp_i8()","zxlib::basic::program#code()","zxlib::basic::variable#code()","z80::tap::headerbody#code?()","zx7::compress()","zxlib::gfx::macros#copy_shadow_attrs_region()","zxlib::gfx::macros#copy_shadow_attrs_region_quick()","zxlib::gfx::macros#copy_shadow_screen_region()","zxlib::gfx::macros#copy_shadow_screen_region_quick()","z80::program::macros#cp16n()","z80::program::macros#cp16r()","z80::program::macros#cp16rr()","zxlib::sys::macros#create_chan_and_open()","z80::utils::sincos::macros#create_sincos_from_sintable()","zxlib::sys::macros#cursor_key_pressed?()","z80::program#data()","z80::program#db()","z80::program#dc!()","z80#debug()","z80::program#debug_comment()","z80::program#define_label()","z80::program#direct_address?()","z80::program#direct_label?()","zxutils::musicbox::commoninstrumentcommands#disable_ay_volume_ctrl()","z80::mathint::macros#divmod()","z80::mathint::macros#divmod16()","z80::mathint::macros#divmod16_8()","z80::mathint::macros#divmod24_8()","z80::mathint::macros#divmod32_16()","z80::mathint::macros#divmod32_8()","z80::mathint::macros#divmod8()","zxlib::gfx::draw::macros#draw_line()","zxlib::gfx::draw::macros#draw_line_dx_gt_4dy()","zxlib::gfx::draw::macros#draw_line_dx_gt_dy()","zxlib::gfx::draw::macros#draw_line_dy_gte_dx()","zxlib::gfx::draw::macros#draw_line_fx_data()","zxlib::gfx::draw::macros#draw_line_fx_data_dx_gt_4dy()","zxlib::gfx::draw::macros#draw_line_fx_data_dx_gt_dy()","zxlib::gfx::draw::macros#draw_line_fx_data_dy_gte_dx()","zxlib::gfx::draw::macros#draw_line_fx_data_vertical()","zxlib::gfx::draw::macros#draw_line_update()","zxlib::gfx::draw::macros#draw_line_update_dx_gt_4dy()","zxlib::gfx::draw::macros#draw_line_update_dx_gt_dy()","zxlib::gfx::draw::macros#draw_line_update_dy_gte_dx()","zxlib::gfx::draw::macros#draw_line_update_vertical()","zxlib::gfx::draw::macros#draw_line_vertical()","zxlib::gfx::sprite8#draw_sprite8()","z80::label::dummy()","z80::alloc#dummy?()","z80::label#dummy?()","z80::alloc#dup()","z80::program#dw()","zx7::macros#dzx7_agilercs()","zx7::macros#dzx7_mega()","zx7::macros#dzx7_smartrcs()","zx7::macros#dzx7_standard()","zx7::macros#dzx7_turbo()","zxlib::basic::vars#each_var()","zxutils::musicbox::trackcommands#ei()","z80::conditionalblock#else()","z80::conditionalblock#else_select()","zxutils::musicbox::commoninstrumentcommands#enable_ay_volume_ctrl()","zxutils::bigfont::macros#enlarge_char8_16()","zxutils::musicbox::commoninstrumentcommands#envd()","zxutils::musicbox::commoninstrumentcommands#envdur()","zxutils::musicbox::songcommands#envelope()","zxutils::musicbox::commoninstrumentcommands#envelope_duration()","zxutils::musicbox::commoninstrumentcommands#envelope_shape()","zxutils::musicbox::commoninstrumentcommands#envs()","zxutils::musicbox::commoninstrumentcommands#envsh()","zxlib::aysound::macros#equal_tempered_scale_notes_hz()","zxutils::benchmark::macros#estimate_tstates_per_interrupt()","z80::program#export()","z80::alloc#expression?()","z80::label#expression?()","zxutils::multitaskingio#find_channel()","zxutils::multitaskingio#find_channel_arg()","zxlib::sys::macros#find_def_fn_args()","zxutils::emu::find_emulator()","zxutils::multitaskingio#find_input_handle()","zxutils::multitaskingio#find_io_handles()","zxutils::multitaskingio#find_output_handle()","zxlib::sys::macros#find_record()","zxutils::musicbox::trackconfigcommands#first_octave_note()","zxutils::musicbox::commoninstrumentcommands#fixed_volume()","zxutils::musicbox::multitrackcommands#for_ch()","zxutils::musicbox::multitrackcommands#for_channels()","zxlib::basic::variable#for_loop?()","zxlib::math::macros#fp_to_integer32()","zxlib::basic::variable::from_data()","zxlib::basic::from_program_data()","zxlib::basic::from_tap_chunk()","zxutils::musicbox::commoninstrumentcommands#fv()","zxlib::basic::vars#get()","zxutils::benchmark#get_adjustment()","zxutils::aybasicplayer#get_counter()","zxutils::emu::get_emulator_path()","zxutils::benchmark#get_frames()","zxutils::benchmark#get_idle()","zxutils::multitaskingio#get_int8_norm_arg()","zxutils::multitaskingio#get_stream_arg()","zxutils::benchmark#getset_tsframe()","zxlib::gfx::clip::macros#gfx_clip_calculate_8bit_dx_dy_exx()","zxlib::gfx::clip::macros#gfx_clip_compute_outcode()","zxlib::gfx::clip::macros#gfx_clip_coords_to_draw_line_args()","zxlib::gfx::clip::macros#gfx_clip_dimension()","zxlib::gfx::clip::macros#gfx_clip_line()","zxlib::gfx::sprite8::macros#gfx_sprite8_calculate_coords()","zxlib::gfx::sprite8::macros#gfx_sprite8_calculate_screen_address()","zxlib::gfx::sprite8::macros#gfx_sprite8_draw()","zxlib::gfx::sprite8::macros#gfx_sprite8_flip_horizontally()","zxlib::basic::variable#head()","zxutils::musicbox::trackcommands#i()","z80::alloc#immediate?()","z80::label#immediate?()","z80::program#immediate?()","z80::program#import()","zxutils::musicbox::songcommands#import_chord()","zxutils::musicbox::songcommands#import_envelope()","z80::program#import_file()","zxutils::musicbox::songcommands#import_instrument()","zxutils::musicbox::songcommands#import_mask()","zxutils::musicbox::songcommands#import_multitrack()","zxutils::musicbox::songcommands#import_track()","z80::alloc::include?()","z80::alloc#indexable?()","z80::label#indexable?()","zxutils::aymusic#init()","zxutils::aymusicplayer#init()","zxutils::multitasking#init_multitasking()","zxutils::aybasicplayer#init_music()","z80::label#initialize()","zxutils::multitaskingio#initialize_io()","z80::utils::sort::macros#insertion_sort_bytes_max256()","zxutils::musicbox::songcommands#instrument()","zxutils::musicbox::song#instruments()","z80::mathint::macros#int()","zxlib::math::macros#integer32_to_fp()","zxutils::bigfont::macros#interlace_pixels16()","z80::program#isolate()","z80::program::condition#jr_ok?()","zxutils::multitasking::kernel_org()","zxutils::multitaskingio::kernel_org()","zxlib::sys::macros#key_pressed?()","z80::program#label()","z80::program#label?()","z80::program#label_defined?()","z80::program#label_immediate?()","z80::program#label_import()","z80::program::macros#ld16()","zxlib::basic::variable#length()","zxlib::basic::variable#limit()","zxlib::basic::variable#line()","zxlib::basic::program#line_index()","zxlib::basic::program#list()","zxutils::musicbox::commoninstrumentcommands#loop_to()","zxutils::musicbox::multitrackcommands#loop_to()","zxutils::musicbox::commoninstrumentcommands#lt()","zxutils::musicbox::multitrackcommands#lt()","zxutils::musicbox::commoninstrumentcommands#m()","zxutils::musicbox::multitrackcommands#m()","zxutils::musicbox::commoninstrumentcommands#m1()","zxutils::musicbox::commoninstrumentcommands#m2()","z80::program::macros#macro()","z80::program#macro_import()","z80lib3d::primitives::vertex::make()","zxlib::gfx::draw::macros#make_draw_line_subroutines()","z80lib3d::primitives::vertex::make_many()","zxutils::musicbox::commoninstrumentcommands#mark()","zxutils::musicbox::multitrackcommands#mark()","zxutils::musicbox::songcommands#mask()","zxutils::musicbox::commoninstrumentcommands#mask_ay_volume_envelope()","zxutils::musicbox::commoninstrumentcommands#mask_ay_volume_envelope_off()","zxutils::musicbox::commoninstrumentcommands#mask_noise()","zxutils::musicbox::commoninstrumentcommands#mask_noise_off()","zxutils::musicbox::commoninstrumentcommands#mask_tone()","zxutils::musicbox::commoninstrumentcommands#mask_tone_off()","z80::program::register#match16?()","zxutils::musicbox::commoninstrumentcommands#me()","z80::label::members_of_struct()","z80::stdlib::macros#memcpy()","z80::stdlib::macros#memcpy_quick()","zxutils::musicbox::commoninstrumentcommands#meo()","z80::alloc#method_missing()","z80::label#method_missing()","z80::label::method_missing()","z80::program#method_missing()","zxutils::bigfont::macros#mix_lines8_16()","zxlib::sys::macros#mmu128_select_bank()","zxlib::sys::macros#mmu128_swap_screens()","zxutils::musicbox::commoninstrumentcommands#mn()","zxutils::musicbox::commoninstrumentcommands#mno()","zxutils::musicbox::commoninstrumentcommands#mode1()","zxutils::musicbox::commoninstrumentcommands#mode2()","zxlib::sys::macros#move_basic_above_scld_screen_memory()","zxutils::musicbox::commoninstrumentcommands#mt()","zxutils::multitaskingio::macros#mtio_drain()","zxutils::multitaskingio::macros#mtio_getc()","zxutils::multitaskingio::macros#mtio_gets()","zxutils::multitaskingio::macros#mtio_putc()","zxutils::multitaskingio::macros#mtio_puts()","zxutils::multitaskingio::macros#mtio_ready?()","zxutils::multitaskingio::macros#mtio_wait()","zxutils::musicbox::commoninstrumentcommands#mto()","z80::mathint::macros#mul()","z80::mathint::macros#mul16()","z80::mathint::macros#mul16_32()","z80::mathint::macros#mul16_signed()","z80::mathint::macros#mul16_signed9()","z80::mathint::macros#mul8()","z80::mathint::macros#mul8_24()","z80::mathint::macros#mul8_c()","z80::mathint::macros#mul8_signed()","z80::mathint::macros#mul_const()","z80::mathint::macros#mul_const8_24()","z80::mathint::macros#mul_signed()","z80::mathint::macros#mul_signed9()","z80::mathint::macros#mul_signed9_24()","zxutils::musicbox::songcommands#multitrack()","zxutils::aymusicplayer#mute_sound()","zxutils::musicbox::commoninstrumentcommands#n()","zxutils::musicbox::commoninstrumentcommands#n0()","zxutils::musicbox::commoninstrumentcommands#n1()","z80::alloc#name=()","z80::label#name=()","z80::program::condition::names()","z80::program::register::names()","zxutils::musicbox::commoninstrumentcommands#ne()","z80::mathint::macros#neg16()","z80::mathint::macros#neg_int()","z80::utils::sincos::macros#neg_sintable256_pi_half_no_zero_lo()","zxutils::musicbox::commoninstrumentcommands#neo()","z80::alloc::new()","z80::label::new()","z80::program#new()","z80::program::condition::new()","z80::program::register::new()","z80::tap::headerbody::new()","zxlib::basic::line::new()","zxlib::basic::program::new()","zxlib::basic::tokenizer::new()","zxlib::basic::variableparseerror::new()","zxlib::basic::vars::new()","zxutils::musicbox::chord::new()","zxutils::musicbox::envelope::new()","zxutils::musicbox::mask::new()","zxutils::musicbox::multitrack::new()","zxutils::musicbox::song::new()","zxutils::musicbox::track::new()","zxlib::basic::variable::new_char_array()","z80::tap::headerbody::new_code()","zxlib::basic::variable::new_for_loop()","zxutils::multitasking::new_kernel()","zxutils::multitaskingio::new_kernel()","zxlib::basic::variable::new_number()","zxlib::basic::variable::new_number_array()","z80::tap::headerbody::new_program()","zxlib::basic::variable::new_string()","z80::tap::headerbody::new_var_array()","zxlib::basic::tokenizer#next_token()","zxlib::gfx::macros#nextline()","zxlib::gfx::macros#nextpixel()","zxlib::gfx::macros#nextrow()","zxutils::musicbox::commoninstrumentcommands#noise()","zxutils::musicbox::commoninstrumentcommands#noise_envelope_off()","zxutils::musicbox::commoninstrumentcommands#noise_off()","zxutils::musicbox::commoninstrumentcommands#noise_on()","z80lib3d::quaternion#normalize_quaternion()","zxutils::musicbox::commoninstrumentcommands#note_progress()","zxutils::musicbox::commoninstrumentcommands#np()","z80::program#ns()","zxlib::basic::variable#number?()","zxlib::basic::variable#number_array?()","z80::label::offset_of_()","z80::program::condition#one_of?()","z80::program::register#one_of?()","zxlib::gfx::macros#only_one_bit_set_or_zero?()","zxutils::multitaskingio#open_io()","z80::program#org()","zxutils::musicbox::commoninstrumentcommands#p()","zxutils::musicbox::multitrackcommands#p()","zxlib::math::pack_number()","zxlib::basic::tokenizer#parse_each()","z80::tap::parse_file()","z80::tap::parse_file()","zxlib::basic::parse_source()","zxlib::basic::line::parse_source_line()","z80::tap::parse_tap()","z80::tap::parse_tap()","zxutils::musicbox::commoninstrumentcommands#pause()","zxutils::musicbox::multitrackcommands#pause()","z80::program#pc()","zxutils::musicbox::trackcommands#pch()","zxlib::basic::tokenizer#peek_token()","zxutils::aymusic#play()","zxutils::musicbox::trackcommands#play()","zxutils::musicbox::trackcommands#play_chord()","zxutils::aybasicplayer#play_interval()","zxutils::aybasicplayer#play_loop()","zxlib::gfx::draw::macros#plot_pixel()","z80::alloc#pointer?()","z80::label#pointer?()","z80::program#pointer?()","z80::program::register#pointer?()","zxlib::gfx::draw::macros#prepare_args_draw_line_to()","zxlib::gfx::draw::macros#preshifted_pixel_mask_data()","zxlib::gfx::macros#prevline()","zxlib::gfx::macros#prevpixel()","zxutils::bigfont#print_char()","zxutils::bigfonthires#print_char_hires()","zxlib::math#print_fp_hl()","z80::tap::headerbody#program?()","zxlib::basic::vars::program_text_to_string()","z80lib3d::quaternion#quaternion2matrix()","z80lib3d::quaternion#quaternion_cross_product()","z80lib3d::quaternion#quaternion_norm()","z80lib3d::quaternion#quaternion_norm_q()","z80::utils::sort::macros#quicksort_bytes()","zxlib::gfx::macros#rctoattr()","zxlib::gfx::macros#rctoscr()","zxutils::multitasking#rdoc_mark_find_def_fn_arg()","zxlib::sys::macros#read_arg_string()","z80::tap::read_chunk()","z80::tap::read_chunk()","z80::tap::read_data()","z80::tap::read_data()","zxlib::sys::macros#read_integer32_value()","zxlib::sys::macros#read_integer_value()","zxlib::sys::macros#read_positive_int_value()","zxlib::basic::read_source()","zxlib::basic::read_tap()","z80::program#register?()","z80::alloc#reinitialize()","zxutils::musicbox::commoninstrumentcommands#repeat()","zxutils::musicbox::multitrackcommands#repeat()","zxlib::sys::macros#report_error()","zxlib::sys::macros#report_error_unless()","z80::alloc#respond_to_missing?()","zxlib::sys::macros#restore_rom_interrupt_handler()","zxlib::sys::macros#return_with_fp()","z80::mathint::macros#rnd()","z80lib3d::quaternion#rotor_quaternion()","zxutils::musicbox::commoninstrumentcommands#rpt()","zxutils::musicbox::multitrackcommands#rpt()","zxutils::emu::run()","z80::tap#save_tap()","z80::tap#save_tap()","z80::tap::headerbody#save_tap()","z80lib3d::primitives::vertex::scale()","z80::tap::headerbody#screen?()","zxlib::gfx::macros#scrtoattr()","z80::program#select()","z80::utils::sort::macros#selection_sort_bytes_max256()","zxutils::musicbox::trackcommands#set_empty_instrument()","zxutils::musicbox::trackcommands#set_instrument()","zxutils::aymusicplayer#setup()","zxlib::sys::macros#setup_custom_interrupt_handler()","z80::utils::shuffle::macros#shuffle_bytes_source_max256()","z80::mathint::macros#sign_extend()","z80::utils::sincos::macros#sincos_from_angle()","z80::utils::sincos::macros#sincos_table_descriptors()","z80::program::register#size()","z80::mathint::macros#sll8_16()","zxutils::emu::spawn()","z80::program::register#split()","zxutils::multitasking#stack_space_free()","zxutils::benchmark#start()","zxutils::gallery#start()","zxutils::musicbox::commoninstrumentcommands#start_chord()","zxutils::musicbox::commoninstrumentcommands#start_noise_envelope()","zxutils::musicbox::commoninstrumentcommands#start_volume_envelope()","zxlib::basic::variable#statement()","zxlib::basic::variable#step()","zxlib::basic::variable#string?()","zxlib::basic::vars::string_to_program_text()","zxutils::musicbox::instrumentcommands#sub()","zxutils::musicbox::multitrackcommands#sub()","zxutils::musicbox::trackcommands#sub()","z80::mathint::macros#sub_from()","zxutils::musicbox::instrumentcommands#sub_instrument()","zxutils::musicbox::multitrackcommands#sub_track()","zxutils::musicbox::trackcommands#sub_track()","z80::alloc#sublabel?()","z80::label#sublabel?()","z80::alloc#sublabel_access_expression?()","z80::label#sublabel_access_expression?()","zxutils::musicbox::multitrackcommands#synchronize_channels()","zxutils::musicbox::commoninstrumentcommands#t0()","zxutils::musicbox::commoninstrumentcommands#t1()","zxutils::multitasking::macros#task?()","zxutils::multitasking::macros#task_id()","zxutils::multitasking::macros#task_stack_bytes_free()","zxutils::multitasking#task_yield()","zxutils::musicbox::trackconfigcommands#tempo()","zxutils::multitasking#terminate()","zxlib::basic::tokenizer#terminated?()","zxlib::basic::line#text()","z80::conditionalblock#then()","zxutils::musicbox::track#ticks_counter()","zxlib::basic::vars#to_a()","z80::alloc#to_aliased_name()","z80::label#to_aliased_name()","z80::alloc#to_alloc()","z80::label#to_alloc()","z80::label::to_data()","z80::program::register#to_debug()","float#to_fixed16_8()","z80::alloc#to_i()","z80::label::to_i()","z80::label#to_i()","z80::program::condition#to_i()","z80::program::register#to_i()","symbol#to_label()","z80::alloc#to_label()","z80::label#to_label()","zxutils::musicbox::song#to_module()","z80::alloc#to_name()","z80::label#to_name()","zxutils::musicbox::song#to_player_module()","zxutils::musicbox::song::songmodule#to_player_module()","zxutils::musicbox::song#to_program()","zxutils::musicbox::song::songmodule#to_program()","z80::alloc#to_s()","z80::label#to_s()","z80::tap::headerbody#to_s()","zxlib::basic::line#to_s()","zxlib::basic::program#to_s()","zxlib::basic::variable#to_s()","zxlib::basic::vars#to_s()","zxlib::basic::program#to_source()","z80::alloc#to_str()","z80::label#to_str()","z80::label::to_struct()","z80::tap#to_tap()","z80::tap#to_tap()","z80::tap::headerbody#to_tap()","z80::tap#to_tap_chunk()","z80::tap#to_tap_chunk()","zxlib::basic::program#to_tap_chunk()","zxlib::basic::variable#to_tap_chunk()","float#to_z80bin()","zxutils::musicbox::commoninstrumentcommands#tone_off()","zxutils::musicbox::commoninstrumentcommands#tone_on()","zxutils::musicbox::commoninstrumentcommands#tone_progress()","zxutils::musicbox::commoninstrumentcommands#tp()","zxutils::musicbox::songcommands#track()","z80::mathint::macros#twos_complement16_by_sgn()","z80::program#union()","zxutils::multitasking#unknown()","zxlib::math::unpack_number()","zxutils::musicbox::song#unused_item_names()","z80::program#unwrap_pointer()","z80::mathint::macros#utobcd()","z80::mathint::macros#utobcd_step()","zxutils::musicbox::commoninstrumentcommands#v()","zxutils::musicbox::commoninstrumentcommands#va()","zxutils::musicbox::song#validate_recursion_depth!()","zxlib::basic::variable#value()","zxutils::musicbox::commoninstrumentcommands#variable_volume()","zxutils::musicbox::commoninstrumentcommands#ve()","z80::utils::vecdeque::macros#vec_deque_clear()","z80::utils::vecdeque::macros#vec_deque_empty?()","z80::utils::vecdeque::macros#vec_deque_full?()","z80::utils::vecdeque::macros#vec_deque_length()","z80::utils::vecdeque::macros#vec_deque_next_back()","z80::utils::vecdeque::macros#vec_deque_next_front()","z80::utils::vecdeque::macros#vec_deque_pop_back()","z80::utils::vecdeque::macros#vec_deque_pop_front()","z80::utils::vecdeque::macros#vec_deque_push_back()","z80::utils::vecdeque::macros#vec_deque_push_front()","zxutils::musicbox::commoninstrumentcommands#veo()","zxutils::musicbox::commoninstrumentcommands#vg()","zxutils::musicbox::commoninstrumentcommands#vibrato_amplitude()","zxutils::musicbox::commoninstrumentcommands#vibrato_angle()","zxutils::musicbox::commoninstrumentcommands#vibrato_off()","zxutils::musicbox::commoninstrumentcommands#vibrato_step()","zxutils::musicbox::commoninstrumentcommands#vo()","zxutils::musicbox::commoninstrumentcommands#volume()","zxutils::musicbox::commoninstrumentcommands#volume_envelope_off()","zxutils::musicbox::commoninstrumentcommands#vs()","zxutils::musicbox::commoninstrumentcommands#vv()","zxutils::musicbox::commoninstrumentcommands#w()","zxutils::musicbox::multitrackcommands#w()","zxutils::musicbox::commoninstrumentcommands#wait()","zxutils::musicbox::multitrackcommands#wait()","zxutils::multitaskingio#wait_io()","zxutils::bigfont::macros#widen_pixels8_16()","z80::program::macros#with_saved()","z80::label::word()","z80::program#words()","zxlib::gfx::macros#xy_to_attr_addr()","zxlib::gfx::macros#xy_to_pixel_addr()","zxlib::gfx::macros#xytoscr()","zxlib::gfx::macros#ytoattr()","zxlib::gfx::macros#ytoscr()","zxlib::gfx::macros#yxtoscr()","z80::alloc#|()","z80::label#|()","z80::program::register#|()","z80::alloc#~()","z80::label#~()","","",""],"info":[["AYTest","","AYTest.html","",""],["Bench","","Bench.html","",""],["Echo","","Echo.html","",""],["Float","","Float.html","",""],["MusicTest","","MusicTest.html","",""],["Object","","Object.html","",""],["Symbol","","Symbol.html","",""],["Z80","","Z80.html","","
    Include this module in your program class to turn it to a powerfull Z80 macro assembler.\n
    To fully benefit …\n"],["Z80::Alloc","","Z80/Alloc.html","","
    Alloc class is used internally by relocation mechanizm and lazy evaluation of labels' values. See …\n"],["Z80::CompileError","","Z80/CompileError.html","","
    Error raised during program compilation (while creating instance).\n"],["Z80::ConditionalBlock","","Z80/ConditionalBlock.html","","
    See Program.select.\n"],["Z80::Label","","Z80/Label.html","","
    Z80 Label\n\n
    myloop  inc [hl]\n        inc hl\n        djnz myloop\n
    \n
    A label in a Z80::Program represents an address, …\n"],["Z80::MathInt","","Z80/MathInt.html","","
    Z80::MathInt - integer math common routines.\n
    in Z80::MathInt::Macros\n\n
    require 'z80'\n\nclass Program\n  include ...
    \n"],["Z80::MathInt::Integers","","Z80/MathInt/Integers.html","","
    Z80::MathInt Integers\n
    This module holds integer data types created on the fly by the Macros.int macro. …\n"],["Z80::MathInt::Macros","","Z80/MathInt/Macros.html","","
    Z80::MathInt Macros\n"],["Z80::Program","","Z80/Program.html","","
    This module defines methods that become your program's class methods when you include the Z80 module. …\n"],["Z80::Program::Condition","","Z80/Program/Condition.html","","
    Creates jr/jp/ret/call conditions as constants:\n\n
    NZ Z NC C PO PE P M\n
    \n
    Additionally NV = PO and V = PE conditions …\n"],["Z80::Program::Macros","","Z80/Program/Macros.html","","
    Z80 Macros\n
    A few handy macros.\n"],["Z80::Program::Mnemonics","","Z80/Program/Mnemonics.html","","
    Z80 Mnemonics\n
    All Z80 instructions are created as singleton methods. They produce machine code which is …\n"],["Z80::Program::Register","","Z80/Program/Register.html","","
    Z80 registers are populated as singleton methods. You must not create instances of this class directly. …\n"],["Z80::Stdlib","","Z80/Stdlib.html","","
    Z80::Stdlib - Macros with commonly used memory routines.\n\n
    require 'z80'\n\nclass MyLib\n    include Z80\n  ...
    \n"],["Z80::Stdlib::Macros","","Z80/Stdlib/Macros.html","","
    Z80::Stdlib Macros.\n"],["Z80::Syntax","","Z80/Syntax.html","","
    Error raised during program parsing.\n"],["Z80::TAP","","Z80/TAP.html","","
    Adds the TAP format support to your program.\n
    Example:\n\n
    puts Z80::TAP.parse_file("examples/calculator.tap").to_a ...\n
    \n"],["Z80::TAP::HeaderBody","","Z80/TAP/HeaderBody.html","","
    A class that represents the optional header and the single body chunk of a TAP file.\n
    Instances of this …\n"],["Z80::TAP::TapeError","","Z80/TAP/TapeError.html","",""],["Z80::TZX","","Z80/TZX.html","","
    Adds the TAP format support to your program.\n
    Example:\n\n
    puts Z80::TAP.parse_file("examples/calculator.tap").to_a ...\n
    \n"],["Z80::Utils","","Z80/Utils.html","",""],["Z80::Utils::Shuffle","","Z80/Utils/Shuffle.html","","
    Z80::Utils::Shuffle\n
    A routine to efficiently shuffle bytes in Z80::Utils::Shuffle::Macros\n"],["Z80::Utils::Shuffle::Macros","","Z80/Utils/Shuffle/Macros.html","","
    Z80::Utils::Shuffle Macros\n\n
    for i from 0 to length − 1 do\n    j ← random integer such that 0 ≤ j ≤ i\n  ...
    \n"],["Z80::Utils::SinCos","","Z80/Utils/SinCos.html","","
    Z80::Utils::SinCos - integer sinus-cosinus table routines.\n
    in Z80::Utils::SinCos::Macros\n
    Structs\n"],["Z80::Utils::SinCos::Macros","","Z80/Utils/SinCos/Macros.html","","
    Z80::Utils::SinCos Macros\n"],["Z80::Utils::SinCos::SinCos","","Z80/Utils/SinCos/SinCos.html","","
    A Z80::Utils::SinCos table entry struct.\n
    Consists of two words:\n
    sin\n"],["Z80::Utils::SinCos::SinCosTable","","Z80/Utils/SinCos/SinCosTable.html","","
    Z80::Utils::SinCos table struct.\n
    The angle [0,256) being used in this table translates to radians in the …\n"],["Z80::Utils::Sort","","Z80/Utils/Sort.html","","
    Z80::Utils::Sort\n
    Implementations of various sorting algorithms in Z80::Utils::Sort::Macros\n
    Example performance …\n"],["Z80::Utils::Sort::Macros","","Z80/Utils/Sort/Macros.html","","
    Z80::Utils::Sort macros\n"],["Z80::Utils::VecDeque","","Z80/Utils/VecDeque.html","","
    Z80::Utils::VecDeque.\n
    Routines for appending, removing and iterating byte elements from double ended queues. …\n"],["Z80::Utils::VecDeque::Macros","","Z80/Utils/VecDeque/Macros.html","","
    Z80::Utils::VecDeque macros.\n
    Macros producing routines for working with double ended queues.\n"],["Z80::Utils::VecDeque::VecDequeState","","Z80/Utils/VecDeque/VecDequeState.html","","
    A descriptor type for a double ended queue.\n"],["Z80Lib3D","","Z80Lib3D.html","",""],["Z80Lib3D::Matrix3D","","Z80Lib3D/Matrix3D.html","","
    Z80Lib3D::Matrix3D\n
    3D matrix related Macros.\n"],["Z80Lib3D::Matrix3D::Macros","","Z80Lib3D/Matrix3D/Macros.html","","
    Z80Lib3D::Matrix3D::Macros\n
    Macros for applying 3D matrix to vertices.\n"],["Z80Lib3D::Primitives","","Z80Lib3D/Primitives.html","","
    Z80Lib3D::Primitives\n
    3D primitives for Z80 program data.\n"],["Z80Lib3D::Primitives::Matrix","","Z80Lib3D/Primitives/Matrix.html","","
    Z80Lib3D::Primitives::Matrix\n
    A type representing a transformation matrix 3x3.\n
    Each matrix element should …\n"],["Z80Lib3D::Primitives::Rotation","","Z80Lib3D/Primitives/Rotation.html","","
    Z80Lib3D::Primitives::Rotation\n
    A type representing 3D rotation.\n
    Each rotation element should be a 16-bit …\n"],["Z80Lib3D::Primitives::SinCos","","Z80/Utils/SinCos/SinCos.html","","
    A Z80::Utils::SinCos table entry struct.\n
    Consists of two words:\n
    sin\n"],["Z80Lib3D::Primitives::Vector","","Z80Lib3D/Primitives/Vector.html","","
    Z80Lib3D::Primitives::Vector\n
    A 3 element vector of 8-bit signed integers:\n
    z: byte\n"],["Z80Lib3D::Primitives::Vertex","","Z80Lib3D/Primitives/Vertex.html","","
    Z80Lib3D::Primitives::Vertex\n
    A 3 element Vector and 2 screen coordinates:\n
    vec: Vector\n"],["Z80Lib3D::Quaternion","","Z80Lib3D/Quaternion.html","","
    Z80Lib3D::Quaternion\n
    Quaternion related helper methods.\n"],["ZX7","","ZX7.html","","
    ZX7 decoding routines.\n
    in ZX7::Macros\n
    Example:\n"],["ZX7::Macros","","ZX7/Macros.html","",""],["ZXLib","","ZXLib.html","",""],["ZXLib::AYSound","","ZXLib/AYSound.html","","
    ZXLib::AYSound.\n
    Macros to help program the AY-3-8910/8912 sound chipsets.\n
    Sources — \n
    www.armory.com/~rstevew/Public/SoundSynth/Novelty/AY3-8910/start.html …\n"],["ZXLib::AYSound::EnvelopeControl","","ZXLib/AYSound/EnvelopeControl.html","","
    Bit masks and bit numbers for the AY-3-891x envelope shape control register Registers::ENV_SHAPE.\n"],["ZXLib::AYSound::Macros","","ZXLib/AYSound/Macros.html","","
    ZXLib::AYSound macros.\n
    The AYSound Macros provide functions to create note tables and some basic routines …\n"],["ZXLib::AYSound::Mixer","","ZXLib/AYSound/Mixer.html","","
    Bit masks and bit numbers for the AY-3-891x mixer register Registers::MIXER.\n"],["ZXLib::AYSound::Registers","","ZXLib/AYSound/Registers.html","","
    Constants with the names of the AY-3-8910 registers.\n"],["ZXLib::AYSound::VolumeControl","","ZXLib/AYSound/VolumeControl.html","","
    Bit masks and bit numbers for the AY-3-891x volume registers: VOLUME_A, VOLUME_B, VOLUME_C.\n"],["ZXLib::Basic","","ZXLib/Basic.html","","
    A module with ZX Spectrum's BASIC program utilities.\n
    SE BASIC extensions are supported.\n
    See: ZXLib::Basic::Program …\n"],["ZXLib::Basic::Line","","ZXLib/Basic/Line.html","","
    Represents a ZX Basic program line.\n
    The original program line without line number, its length and a terminating …\n"],["ZXLib::Basic::Program","","ZXLib/Basic/Program.html","","
    Represents a ZX Basic program in a semi-parsed form.\n"],["ZXLib::Basic::Tokenizer","","ZXLib/Basic/Tokenizer.html","","
    A Basic program tokenizer.\n"],["ZXLib::Basic::Tokenizer::Patterns","","ZXLib/Basic/Tokenizer/Patterns.html","",""],["ZXLib::Basic::Variable","","ZXLib/Basic/Variable.html","","
    Represents a ZX Spectrum's Basic variable with various methods to create new variables, inspect their …\n"],["ZXLib::Basic::VariableParseError","","ZXLib/Basic/VariableParseError.html","",""],["ZXLib::Basic::VariableTypes","","ZXLib/Basic/VariableTypes.html","",""],["ZXLib::Basic::Vars","","ZXLib/Basic/Vars.html","","
    A container class for collecting and inspecting ZX-Spectrum's Basic program variables.\n
    Variables can …\n"],["ZXLib::Gfx","","ZXLib/Gfx.html","","
    A module with Z80 Macros for common ZX Spectrum graphics tasks\n
    Example:\n\n
    require 'zxlib/gfx'\n\nclass Program ...
    \n"],["ZXLib::Gfx::Bobs","","ZXLib/Gfx/Bobs.html","","
    Bitmap objects related routines.\n
    See also ZXLib::Gfx::Bobs::Macros.\n\n
    ░░░░░░░░████░░░░░░████░░░░░░░░░░\n░░░░░░████████░░██████████░░░░░░ ...\n
    \n"],["ZXLib::Gfx::Bobs::Macros","","ZXLib/Gfx/Bobs/Macros.html","","
    ZXLib::Gfx::Bobs macros.\n
    Bobs::Macros require:\n\n
    macro_import MathInt\nmacro_import Gfx\n
    \n"],["ZXLib::Gfx::Clip","","ZXLib/Gfx/Clip.html","","
    A module with Z80 Macros for clipping lines.\n"],["ZXLib::Gfx::Clip::Macros","","ZXLib/Gfx/Clip/Macros.html","","
    ZXLib::Gfx::Clip Macros for clipping lines to viewport rectangles.\n
    Macros.gfx_clip_line.\n
    Macros.gfx_clip_coords_to_draw_line_args …\n"],["ZXLib::Gfx::Clip::Outcode","","ZXLib/Gfx/Clip/Outcode.html","",""],["ZXLib::Gfx::Draw","","ZXLib/Gfx/Draw.html","","
    A module with Z80 Macros for drawing lines and plotting pixels on the ZX Spectrum.\n
    Example:\n\n
    require 'zxlib/gfx/draw' ...\n
    \n"],["ZXLib::Gfx::Draw::Constants","","ZXLib/Gfx/Draw/Constants.html","",""],["ZXLib::Gfx::Draw::Macros","","ZXLib/Gfx/Draw/Macros.html","","
    ZXLib::Gfx::Draw macros for drawing lines and plotting pixels on the ZX Spectrum.\n
    Coordinate system and …\n"],["ZXLib::Gfx::Macros","","ZXLib/Gfx/Macros.html","","
    ZXLib::Gfx macros.\n"],["ZXLib::Gfx::Sprite8","","ZXLib/Gfx/Sprite8.html","","
    Sprite drawing routines.\n
    See also ZXLib::Gfx::Sprite8::Macros.\n
    By default all drawing method routines are …\n"],["ZXLib::Gfx::Sprite8::Macros","","ZXLib/Gfx/Sprite8/Macros.html","","
    ZXLib::Gfx::Sprite8 Macros.\n
    Sprite8::Macros require:\n\n
    macro_import MathInt\nmacro_import Gfx\n
    \n"],["ZXLib::Math","","ZXLib/Math.html","","
    A module with the ZXReal struct definition and ZX-Spectrum FP helpers.\n
    Macros can be used to convert 32-bit …\n"],["ZXLib::Math::Macros","","ZXLib/Math/Macros.html","","
    ZXLib::Math Macros\n
    Macros require:\n\n
    macro_import MathInt\n
    \n"],["ZXLib::Math::ZXReal","","ZXLib/Math/ZXReal.html","","
    A struct representing a ZX-Spectrum's FP calculator's real number data type.\n
    See:\n
    www.worldofspectrum.org/ZXBasicManual/zxmanchap24.html …\n"],["ZXLib::Sys","","ZXLib/Sys.html","","
    A module with Z80 macros for common ZX Spectrum system tasks.\n
    Contains:\n
    labels for some of ZX Spectrum …\n"],["ZXLib::Sys::Coords","","ZXLib/Sys/Coords.html","","
    A struct for ZX Spectrum coords variable.\n"],["ZXLib::Sys::Cursor","","ZXLib/Sys/Cursor.html","","
    A struct for various ZX Spectrum variables.\n"],["ZXLib::Sys::If1Vars","","ZXLib/Sys/If1Vars.html","","
    ZX Interface 1 variables.\n"],["ZXLib::Sys::Macros","","ZXLib/Sys/Macros.html","","
    ZXLib::Sys Macros\n
    Some of the macros require:\n\n
    require 'zxlib/math'\n# ...\n  macro_import MathInt\n  macro_import ...\n
    \n"],["ZXLib::Sys::Strms","","ZXLib/Sys/Strms.html","","
    A struct for ZX Spectrum strms variable.\n"],["ZXLib::Sys::Vars","","ZXLib/Sys/Vars.html","","
    ZX Spectrum Basic and System variables.\n"],["ZXLib::Sys::Vars128","","ZXLib/Sys/Vars128.html","","
    ZX Spectrum 128 variables.\n"],["ZXUtils","","ZXUtils.html","",""],["ZXUtils::AYBasicPlayer","","ZXUtils/AYBasicPlayer.html","","
    AY-3-8910/8912 Basic player\n
    This is a wrapper over AYMusicPlayer with interfaces suitable to be used directly …\n"],["ZXUtils::AYMusic","","ZXUtils/AYMusic.html","","
    The AY-3-8910/8912 music engine\n
    Low-level but highly configurable music player routines and Macros. See …\n"],["ZXUtils::AYMusic::AYRegisterMirror","","ZXUtils/AYMusic/AYRegisterMirror.html","","
    The AY-3-891x register mirror.\n"],["ZXUtils::AYMusic::ChannelControl","","ZXUtils/AYMusic/ChannelControl.html","","
    The single channel control structure.\n"],["ZXUtils::AYMusic::ChordControl","","ZXUtils/AYMusic/ChordControl.html","","
    data: loop_offset(,delay<<5|+ delta 0..31)*,0 (init: counter=1, cursor=+1, loop_at=cursor+loop_offset) …\n"],["ZXUtils::AYMusic::EnvelopeControl","","ZXUtils/AYMusic/EnvelopeControl.html","","
    data: loop_offset(,counter,delta)*,0 (init: counter=1, cursor=, loop_at=cursor+loop_offset+1)\n"],["ZXUtils::AYMusic::InstrumentControl","","ZXUtils/AYMusic/InstrumentControl.html","","
    The instrument track control structure\n"],["ZXUtils::AYMusic::Macros","","ZXUtils/AYMusic/Macros.html","","
    AYMusic engine utilities.\n
    NOTE — Some of the AYMusic Macros require Z80::MathInt::Macros and some require …\n\n"],["ZXUtils::AYMusic::MaskControl","","ZXUtils/AYMusic/MaskControl.html","","
    data: loop_offset(,counter,mask)*,0 (init: counter=1, cursor=+1, loop_at=cursor+loop_offset)\n"],["ZXUtils::AYMusic::MusicControl","","ZXUtils/AYMusic/MusicControl.html","","
    The main music control structure.\n
    The most important is the music_control.counter word entry which can …\n"],["ZXUtils::AYMusic::ToneProgressControl","","ZXUtils/AYMusic/ToneProgressControl.html","","
    data: delta,counter,current\n"],["ZXUtils::AYMusic::TrackControl","","ZXUtils/AYMusic/TrackControl.html","","
    The music track control structure\n"],["ZXUtils::AYMusic::TrackStackEntry","","ZXUtils/AYMusic/TrackStackEntry.html","","
    The data type of the track stack entry.\n"],["ZXUtils::AYMusic::VibratoControl","","ZXUtils/AYMusic/VibratoControl.html","","
    data: step,angle,amplitude (init: enabled:-1)\n"],["ZXUtils::AYMusicPlayer","","ZXUtils/AYMusicPlayer.html","","
    AY-3-8910/8912 music player\n
    The music module player based on ZXUtils::AYMusic engine.\n
    ZXUtils::MusicBox …\n"],["ZXUtils::AYMusicPlayer::MusicTracks","","ZXUtils/AYMusicPlayer/MusicTracks.html","","
    The struct representing music module header.\n"],["ZXUtils::AYMusicPlayer::TrackInfo","","ZXUtils/AYMusicPlayer/TrackInfo.html","","
    The struct of MusicTracks.tracks_info\n"],["ZXUtils::Benchmark","","ZXUtils/Benchmark.html","","
    ZXUtils::Benchmark\n
    Benchmarking utilities.\n
    NOTE — Currently the code must be located at 0x8000.\n"],["ZXUtils::Benchmark::Macros","","ZXUtils/Benchmark/Macros.html","","
    ZXUtils::Benchmark macros.\n"],["ZXUtils::BigFont","","ZXUtils/BigFont.html","","
    BigFont\n
    Z80 Macros producing routines to create and display 16x15 characters from a 8x8 font (e.g: a default …\n"],["ZXUtils::BigFont::Macros","","ZXUtils/BigFont/Macros.html","","
    ZXUtils::BigFont macros.\n"],["ZXUtils::BigFontHires","","ZXUtils/BigFontHires.html","","
    BigFontHires\n
    See also: BigFont.\n"],["ZXUtils::Emu","","ZXUtils/Emu.html","","
    ZXUtils::Emu\n
    Simple tools for finding and running ZX Spectrum emulator.\n
    Compile your program, save to tap …\n"],["ZXUtils::Gallery","","ZXUtils/Gallery.html","","
    ZXUtils::Gallery.\n
    A program to load from tape and display various ZX Spectrum screen formats.\n
    Supported …\n"],["ZXUtils::Gallery::Formats","","ZXUtils/Gallery/Formats.html","","
    ZXUtils::Gallery Formats\n
    The sizes of the supported .SCR file formats.\n"],["ZXUtils::Multitasking","","ZXUtils/Multitasking.html","","
    ZXUtils::Multitasking\n
    Run machine code programs (a.k.a. “tasks”) in parallel with the ZX Spectrum's …\n"],["ZXUtils::Multitasking::Macros","","ZXUtils/Multitasking/Macros.html","","
    ZXUtils::Multitasking Macros for tasks.\n"],["ZXUtils::Multitasking::TaskInfo","","ZXUtils/Multitasking/TaskInfo.html","","
    Task info structure. Each running task has one.\n"],["ZXUtils::Multitasking::TaskVars","","ZXUtils/Multitasking/TaskVars.html","","
    Definition of mtvars.\n"],["ZXUtils::MultitaskingIO","","ZXUtils/MultitaskingIO.html","","
    ZXUtils::MultitaskingIO\n
    Asynchronous communication channels between tasks running in parallel with ZX …\n"],["ZXUtils::MultitaskingIO::BufferIO","","ZXUtils/MultitaskingIO/BufferIO.html","","
    I/O Buffer structure.\n"],["ZXUtils::MultitaskingIO::Macros","","ZXUtils/MultitaskingIO/Macros.html","","
    ZXUtils::MultitaskingIO Macros for tasks.\n
    Most of the routines created by MultitaskingIO::Macros expects …\n"],["ZXUtils::MultitaskingIO::TaskVarsIO","","ZXUtils/MultitaskingIO/TaskVarsIO.html","","
    Extended Multitasking::TaskVars structure.\n"],["ZXUtils::MusicBox","","ZXUtils/MusicBox.html","","
    MusicBox\n
    MusicBox is a Ruby Domain Specific Language designed to create AY-3-8910/8912 music.\n
    The music …\n"],["ZXUtils::MusicBox::AYEnvelopeDurationCommand","","ZXUtils/MusicBox/AYEnvelopeDurationCommand.html","",""],["ZXUtils::MusicBox::AYEnvelopeShapeCommand","","ZXUtils/MusicBox/AYEnvelopeShapeCommand.html","",""],["ZXUtils::MusicBox::Chord","","ZXUtils/MusicBox/Chord.html","","
    MusicBox Chord\n
    Instances of this class represent the chords applicable to the played note's tone. …\n"],["ZXUtils::MusicBox::ChordCommand","","ZXUtils/MusicBox/ChordCommand.html","",""],["ZXUtils::MusicBox::Command","","ZXUtils/MusicBox/Command.html","",""],["ZXUtils::MusicBox::Command::Headers","","ZXUtils/MusicBox/Command/Headers.html","",""],["ZXUtils::MusicBox::Command::MetaCommand","","ZXUtils/MusicBox/Command/MetaCommand.html","",""],["ZXUtils::MusicBox::CommonInstrumentCommands","","ZXUtils/MusicBox/CommonInstrumentCommands.html","","
    MusicBox CommonInstrumentCommands\n
    Common Instrument and Track commands.\n"],["ZXUtils::MusicBox::EmptyTrack","","ZXUtils/MusicBox/EmptyTrack.html","","
    MusicBox EmptyTrack\n
    An empty track used by the MusicBox::Song compilation. Should stay empty.\n"],["ZXUtils::MusicBox::Envelope","","ZXUtils/MusicBox/Envelope.html","","
    MusicBox Envelope\n
    Instances of this class represent the envelopes applicable to the volume level or the …\n"],["ZXUtils::MusicBox::EnvelopeCommand","","ZXUtils/MusicBox/EnvelopeCommand.html","",""],["ZXUtils::MusicBox::IndexCommand","","ZXUtils/MusicBox/IndexCommand.html","",""],["ZXUtils::MusicBox::Instrument","","ZXUtils/MusicBox/Instrument.html","","
    MusicBox Instrument\n
    An instrument consists of the ZXUtils::AYMusic commands.\n
    To create a custom instrument …\n"],["ZXUtils::MusicBox::InstrumentCommand","","ZXUtils/MusicBox/InstrumentCommand.html","",""],["ZXUtils::MusicBox::InstrumentCommands","","ZXUtils/MusicBox/InstrumentCommands.html","","
    MusicBox InstrumentCommands\n
    Instrument only commands.\n"],["ZXUtils::MusicBox::LoopCommand","","ZXUtils/MusicBox/LoopCommand.html","",""],["ZXUtils::MusicBox::MarkCommand","","ZXUtils/MusicBox/MarkCommand.html","",""],["ZXUtils::MusicBox::Mask","","ZXUtils/MusicBox/Mask.html","","
    MusicBox Mask\n
    Instances of this class represent the bit masks applicable to the channel's mixer tone …\n"],["ZXUtils::MusicBox::MaskCommand","","ZXUtils/MusicBox/MaskCommand.html","",""],["ZXUtils::MusicBox::Multitrack","","ZXUtils/MusicBox/Multitrack.html","","
    MusicBox Multitrack\n
    A multi-track consists of the three tracks, each one for each of the AY-3-891x channels. …\n"],["ZXUtils::MusicBox::MultitrackCommands","","ZXUtils/MusicBox/MultitrackCommands.html","","
    MusicBox MultitrackCommands\n
    Commands for multi-tracks.\n
    For the other available commands see: TrackConfigCommands …\n"],["ZXUtils::MusicBox::NoisePitchCommand","","ZXUtils/MusicBox/NoisePitchCommand.html","",""],["ZXUtils::MusicBox::NoteChordCommand","","ZXUtils/MusicBox/NoteChordCommand.html","",""],["ZXUtils::MusicBox::NoteCommand","","ZXUtils/MusicBox/NoteCommand.html","",""],["ZXUtils::MusicBox::NoteProgressPeriodCommand","","ZXUtils/MusicBox/NoteProgressPeriodCommand.html","",""],["ZXUtils::MusicBox::PauseCommand","","ZXUtils/MusicBox/PauseCommand.html","",""],["ZXUtils::MusicBox::Resolver","","ZXUtils/MusicBox/Resolver.html","",""],["ZXUtils::MusicBox::Song","","ZXUtils/MusicBox/Song.html","","
    MusicBox Song\n
    A song is a special Multitrack that also organizes other multi-tracks, sub-tracks, instruments, …\n"],["ZXUtils::MusicBox::Song::PlayerModule","","ZXUtils/MusicBox/Song/PlayerModule.html","","
    MusicBox Song PlayerModule\n
    A PlayerModule instance contains a compiled Song in the form suitable for the …\n"],["ZXUtils::MusicBox::Song::SongModule","","ZXUtils/MusicBox/Song/SongModule.html","","
    MusicBox Song SongModule\n
    An instance of this class can be created by calling Song.to_module instance method …\n"],["ZXUtils::MusicBox::SongCommands","","ZXUtils/MusicBox/SongCommands.html","","
    MusicBox SongCommands\n
    Commands for a Song.\n
    For the other available commands see: MultitrackCommands and …\n"],["ZXUtils::MusicBox::SubInstrumentCommand","","ZXUtils/MusicBox/SubInstrumentCommand.html","",""],["ZXUtils::MusicBox::SubTrackCommand","","ZXUtils/MusicBox/SubTrackCommand.html","",""],["ZXUtils::MusicBox::ToneProgressCommand","","ZXUtils/MusicBox/ToneProgressCommand.html","",""],["ZXUtils::MusicBox::Track","","ZXUtils/MusicBox/Track.html","","
    MusicBox Track\n
    A track consists of the ZXUtils::AYMusic commands.\n
    To create a custom track you need to …\n"],["ZXUtils::MusicBox::TrackCommands","","ZXUtils/MusicBox/TrackCommands.html","","
    MusicBox TrackCommands\n
    Track commands for playing notes, setting instruments and yielding to other tracks. …\n"],["ZXUtils::MusicBox::TrackConfigCommands","","ZXUtils/MusicBox/TrackConfigCommands.html","","
    MusicBox TrackConfigCommands\n
    Common Track and Multitrack commands for changing track configuration options. …\n"],["ZXUtils::MusicBox::VibratoAmplitudeCommand","","ZXUtils/MusicBox/VibratoAmplitudeCommand.html","",""],["ZXUtils::MusicBox::VibratoAngleCommand","","ZXUtils/MusicBox/VibratoAngleCommand.html","",""],["ZXUtils::MusicBox::VibratoStepCommand","","ZXUtils/MusicBox/VibratoStepCommand.html","",""],["ZXUtils::MusicBox::VolumeLevelCommand","","ZXUtils/MusicBox/VolumeLevelCommand.html","",""],["%","Z80::Alloc","Z80/Alloc.html#method-i-25","(other)",""],["%","Z80::Label","Z80/Label.html#method-i-25","(other)","
    Returns a lazy evaluated remainder of a label divided by an other label or an integer.\n"],["&","Z80::Alloc","Z80/Alloc.html#method-i-26","(other)",""],["&","Z80::Label","Z80/Label.html#method-i-26","(m)","
    Returns a lazy evaluated bitwise “and” of a label and an other label or an integer.\n"],["*","Z80::Alloc","Z80/Alloc.html#method-i-2A","(other)",""],["*","Z80::Label","Z80/Label.html#method-i-2A","(other)","
    Returns a lazy evaluated label multiplied by an other label or an integer.\n"],["**","Z80::Alloc","Z80/Alloc.html#method-i-2A-2A","(m)",""],["**","Z80::Label","Z80/Label.html#method-i-2A-2A","(name)","
    Returns a member by its name as a separate label. This is used internally. Use Label#[] and Label#method_missing …\n"],["+","Z80::Alloc","Z80/Alloc.html#method-i-2B","(other)",""],["+","Z80::Label","Z80/Label.html#method-i-2B","(other)","
    Returns a lazy evaluated label offset by an other label or an integer.\n"],["+","Z80::Program::Register","Z80/Program/Register.html#method-i-2B","(other)","
    This method makes possible to write indexed expressions with ix/iy registers. Example:\n\n
    ld a, [ix + 7]\n
    \n"],["+@","Z80::Alloc","Z80/Alloc.html#method-i-2B-40","()",""],["+@","Z80::Label","Z80/Label.html#method-c-2B-40","()","
    Returns a lazy evaluated size of a data structure. Better for debugging than Label.to_i.\n"],["+@","Z80::Label","Z80/Label.html#method-i-2B-40","()","
    Returns a lazy evaluated size of a type of a label.\n"],["-","Z80::Alloc","Z80/Alloc.html#method-i-2D","(other)",""],["-","Z80::Label","Z80/Label.html#method-i-2D","(other)","
    Returns a lazy evaluated label negatively offset by an other label or an integer.\n"],["-","Z80::Program::Register","Z80/Program/Register.html#method-i-2D","(other)","
    This method makes possible to write indexed expressions with ix/iy registers. Example:\n\n
    ld a, [ix - 7]\n
    \n"],["-@","Z80::Alloc","Z80/Alloc.html#method-i-2D-40","()",""],["-@","Z80::Label","Z80/Label.html#method-i-2D-40","()","
    Returns a lazy evaluated negative label.\n"],["/","Z80::Alloc","Z80/Alloc.html#method-i-2F","(other)",""],["/","Z80::Label","Z80/Label.html#method-i-2F","(other)","
    Returns a lazy evaluated quotient of a label divided by an other label or an integer.\n"],["<<","Z80::Alloc","Z80/Alloc.html#method-i-3C-3C","(other)",""],["<<","Z80::Label","Z80/Label.html#method-i-3C-3C","(m)","
    Returns a lazy evaluated label left shifted by a number of bits as an other label or an integer.\n"],["<<","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-3C-3C","(var)","
    Adds a Basic::Variable to self.\n"],["==","Z80::Alloc","Z80/Alloc.html#method-i-3D-3D","(other)",""],[">>","Z80::Alloc","Z80/Alloc.html#method-i-3E-3E","(other)",""],[">>","Z80::Label","Z80/Label.html#method-i-3E-3E","(m)","
    Returns a lazy evaluated label right shifted by a number of bits as an other label or an integer.\n"],["[]","Z80","Z80.html#method-i-5B-5D","(name)","
    Returns an evaluated label's value by its name.\n"],["[]","Z80::Alloc","Z80/Alloc.html#method-i-5B-5D","(index = nil)",""],["[]","Z80::Label","Z80/Label.html#method-i-5B-5D","(index = nil)","
    Returns a lazy evaluated label offset by index.\n
    If index is nil, returns a pointer label instead.\n
    If index …\n"],["[]","Z80::Program","Z80/Program.html#method-i-5B-5D","(label)","
    Method used internally by mnemonics to make a pointer of a label or a Register.\n
    Example:\n\n
    ld  hl, [foo] ...\n
    \n"],["[]","Z80::Program::Condition","Z80/Program/Condition.html#method-c-5B-5D","(index)",""],["[]","Z80::Program::Register","Z80/Program/Register.html#method-i-5B-5D","(index = 0, sgn = :+)","
    Method used internally by mnemonics to make pointer of a label or register. Example:\n\n
    ld  b, [ix + 2]\nld ...\n
    \n"],["[]","Z80::Program::Register","Z80/Program/Register.html#method-c-5B-5D","(index)",""],["[]","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-5B-5D","(index)","
    Returns a Basic::Line at index or an array of lines if Range is given.\n"],["[]","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-5B-5D","(*at)","
    Returns a selected portion of an array variable according to the provided dimension indices.\n
    The indices …\n"],["[]","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-5B-5D","(index)","
    Returns a Basic::Variable at index or an array of variables if Range is given.\n"],["^","Z80::Alloc","Z80/Alloc.html#method-i-5E","(other)",""],["^","Z80::Label","Z80/Label.html#method-i-5E","(m)","
    Returns a lazy evaluated bitwise “exclusive or” of a label and an other label or an integer. …\n"],["add24_16","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-add24_16","(th8=c, tl16=hl, tt=de, signed:true)","
    Creates a routine that adds a 16-bit integer in tt to a 24-bit integer in th8|tl16. Returns the result …\n"],["add_code","Z80","Z80.html#method-c-add_code","(prg, data, type = 1, mnemo = nil, *mpar)","
    Method used by Program instructions was placed here to not pollute program namespace anymore.\n"],["add_reloc","Z80","Z80.html#method-c-add_reloc","(prg, label, size, offset = 0, from = nil)","
    Method used by Program instructions was placed here to not pollute program namespace anymore.\n"],["adda_to","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-adda_to","(th, tl)","
    Creates a routine that adds an 8-bit accumulator value to a 16-bit th|tl register pair.\n
    th — A target MSB …\n"],["addr","Z80::Program","Z80/Program.html#method-i-addr","(address, type = 1, align: 1, offset: 0)","
    Returns an unnamed, immediate label at an absolute address of the optional type.\n
    type can be an integer …\n"],["address?","Z80::Program","Z80/Program.html#method-i-address-3F","(arg)","
    A convenient method for macros to check if an argument is a non-register address (direct or a pointer). …\n"],["alias?","Z80::Alloc","Z80/Alloc.html#method-i-alias-3F","()","
    This label can be the only dummy sublabel of another label and as such may exist in both members and …\n"],["alias?","Z80::Label","Z80/Label.html#method-i-alias-3F","()","
    Checks if a label is an address label (lazy alias).\n"],["alias_label","Z80::Program","Z80/Program.html#method-i-alias_label","(address, align: 1, offset: 0)","
    Returns an alias of a label or an expression.\n
    The address must be a label or a label expression.\n
    The returned …\n"],["all_ch","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-all_ch","(&block)",""],["all_channels","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-all_channels","(&block)","
    Creates a track fragments with the same commands for all the channels.\n
    Provide a block with commands suitable …\n"],["api","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-api","","
    ZX Basic API\n
    This endpoint should be invoked from the ZX Basic directly via USR or indirectly via FN. …\n"],["apply_matrix","Z80Lib3D::Matrix3D::Macros","Z80Lib3D/Matrix3D/Macros.html#method-i-apply_matrix","(matrix, vertices:hl, scrx0:128, scry0:128, scrz0:128, persp_dshift:7, optimize: :time)","
    Applies a transformation matrix to vertices and calculates screen coordinates (xp, yp) for each one. …\n"],["apply_matrix_element","Z80Lib3D::Matrix3D::Macros","Z80Lib3D/Matrix3D/Macros.html#method-i-apply_matrix_element","(x, clrhl:false, optimize: :time)","
    Applies a matrix element of the transformation matrix to a scalar.\n
    Matrix element should be a 16-bit fixed …\n"],["apply_matrix_row","Z80Lib3D::Matrix3D::Macros","Z80Lib3D/Matrix3D/Macros.html#method-i-apply_matrix_row","(x, y, z, optimize: :time)","
    Applies a row of the transformation matrix to a 3D vector.\n
    Each matrix element should be a 16-bit fixed …\n"],["array?","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-array-3F","()","
    true if this chunk represents a number or character array\n"],["array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-array-3F","()","
    true if variable is a number or character array\n"],["as","Z80::Program","Z80/Program.html#method-i-as","(address, align: 1, offset: 0)",""],["ay_expand_notes","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_expand_notes","(notes=hl, octaves:8, half_tones:12)","
    Creates a routine for expanding the note to AY-3-891x tone period table to a higher number of octaves. …\n"],["ay_expand_notes_faster","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_expand_notes_faster","(notes=hl, octaves:8, half_tones:12, save_sp:true, disable_intr:true, enable_intr:true)","
    Creates a routine for expanding the note to AY-3-891x tone period table to a higher number of octaves. …\n"],["ay_get_register_value","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_get_register_value","(regn=a, regv=e, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that reads a specific AY-3-891x register's value.\n
    regn — A AY-3-891x register index …\n\n"],["ay_get_set_env_shape","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_get_set_env_shape","(sinp=a, sout=sinp, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that gets the AY-3-891x envelope shape's value applies a block of code and sets …\n"],["ay_get_set_mixer","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_get_set_mixer","(vinp=a, vout=vinp, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that gets the AY-3-891x mixer's value applies a block of code and sets the mixer …\n"],["ay_hz2tp","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_hz2tp","(hz, clock_hz:AYSound::CLOCK_HZ)","
    Converts a frequency given in Hz to AY-3-891x tone period value.\n
    Options:\n
    clock_hz — AY-3-891x clock frequency …\n"],["ay_init","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_init","(t:e, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that sets volume of all AY-3-891x sound channels to 0, disables noise on all channels …\n"],["ay_io_load_const_reg_bc","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_io_load_const_reg_bc","(io_ay=self.io_ay)","
    Creates a routine that loads a constant 8-bit part of the AY-3-891x I/O addresses into b or c register. …\n"],["ay_io_swap2inp_bc","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_io_swap2inp_bc","(io_ay=self.io_ay)","
    Creates a routine that loads a specific 8-bit part of the AY-3-891x input addresses into b or c register. …\n"],["ay_io_swap2out_bc","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_io_swap2out_bc","(io_ay=self.io_ay)","
    Creates a routine that loads a specific 8-bit part of the AY-3-891x output addresses into b or c register. …\n"],["ay_io_swap2sel_bc","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_io_swap2sel_bc","(io_ay=self.io_ay)","
    Creates a routine that loads a specific 8-bit part of the AY-3-891x select addresses into b or c register. …\n"],["ay_music_finished?","ZXUtils::AYMusic::Macros","ZXUtils/AYMusic/Macros.html#method-i-ay_music_finished-3F","(music_control, compact:false, subroutine:false, branch_not_finished: :eoc)","
    Creates a routine that detects if the currently played music is finished.\n
    As a result ZF is 1 if all of …\n"],["ay_music_init","ZXUtils::AYMusic::Macros","ZXUtils/AYMusic/Macros.html#method-i-ay_music_init","(track_a, track_b, track_c, index_table:nil, init:self.init, play:self.play, music_control:self.music_control, disable_intr:true, enable_intr:true)","
    Creates a routine that initializes music tracks and optionally the index lookup table.\n
    Provide addresses …\n"],["ay_music_note_to_fine_tone_cursor_table_factory","ZXUtils::AYMusic::Macros","ZXUtils/AYMusic/Macros.html#method-i-ay_music_note_to_fine_tone_cursor_table_factory","(note_to_cursor, play:nil, num_notes:AYMusic::MAX_NOTES_COUNT, subroutine:false)","
    Creates a routine that builds a note-to-fine tones index table.\n
    note_to_cursor — An address of the table …\n\n"],["ay_music_preserve_io_ports_state","ZXUtils::AYMusic::Macros","ZXUtils/AYMusic/Macros.html#method-i-ay_music_preserve_io_ports_state","(music_control, play, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that reads a state of the I/O ports from the AY-3-891x chip and stores it into the …\n"],["ay_music_tone_progress_table_factory","ZXUtils::AYMusic::Macros","ZXUtils/AYMusic/Macros.html#method-i-ay_music_tone_progress_table_factory","(fine_tones, hz: 440, clock_hz: ZXLib::AYSound::CLOCK_HZ, subroutine:false)","
    Creates a routine that builds a fine tones to AY-3-891x tone periods table.\n
    fine_tones — An address of the …\n\n"],["ay_set_envelope_duration","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_set_envelope_duration","(dh=d, dl=e, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that sets a AY-3-891x envelope duration.\n
    dh — The most significant 8 bits of the 16-bit …\n\n"],["ay_set_noise_pitch","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_set_noise_pitch","(pitch=e, pitch_8bit:false, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that sets a AY-3-891x noise pitch.\n
    pitch — A pitch level or an 8-bit register except  …\n\n\n"],["ay_set_register_value","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_set_register_value","(regn=a, regv=e, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that writes a value to a specific AY-3-891x register.\n
    If the block is given, the code …\n"],["ay_set_tone_period","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_set_tone_period","(ch=a, tph:d, tpl:e, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that sets a AY-3-891x channel's tone period.\n
    ch — A channel number 0..2 as an integer, …\n\n"],["ay_set_volume","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_set_volume","(ch=a, vol=e, vol_8bit:false, bc_const_loaded:false, io_ay:self.io_ay)","
    Creates a routine that sets a AY-3-891x channel's volume level.\n
    ch — A channel number 0..2 as an integer, …\n\n"],["ay_tone_periods","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-ay_tone_periods","(min_octave:0, max_octave:7, notes_hz:self.equal_tempered_scale_notes_hz, clock_hz:AYSound::CLOCK_HZ)","
    Returns a tone period array for the AY-3-891x chip.\n
    Options:\n
    min_octave — A minimal octave number, 0-based. …\n"],["bcdtoa","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-bcdtoa","(buffer=hl, size=b, skip_leading0:false, preserve_in:nil, &block)","
    Creates a routine that reads BCD digits from the memory buffer, one at a time, into the accumulator. …\n"],["bench","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-bench","","
    Benchmarks the tested routine. Provide a routine address and a counter. Returns a number of seconds (multiplied …\n"],["bit8?","Z80::Program::Register","Z80/Program/Register.html#method-i-bit8-3F","()",""],["bobs_copy_attrs","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_copy_attrs","(attrs=hl, rows=a, cols=c, target:de, scraddr:nil, subroutine:false)","
    Creates a routine that copies bitmap attributes to the screen as a rectangle object.\n
    attrs — An address …\n\n"],["bobs_copy_attrs_fast","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_copy_attrs_fast","(attrs, rows=a, cols=32, target:hl, disable_intr:true, enable_intr:true, save_sp:true, check_oos:false, subroutine:false)","
    Creates a routine that copies bitmap attributes to the screen as a rectangle object using unrolled POP …\n"],["bobs_copy_pixels","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_copy_pixels","(bitmap=hl, lines=a, cols=c, target:de, scraddr:nil, subroutine:false)","
    Creates a routine that copies bitmap pixels to the ink/paper screen as a rectangle object.\n
    bitmap — An address …\n\n"],["bobs_copy_pixels_fast","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_copy_pixels_fast","(bitmap, lines=c, cols=32, target:hl, disable_intr:true, enable_intr:true, save_sp:true, scraddr:nil, subroutine:false)","
    Creates a routine that copies bitmap pixels to the ink/paper screen as a rectangle object using unrolled …\n"],["bobs_draw_pixels_fast","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_draw_pixels_fast","(bitmap, lines=a, cols=2, target:hl, bshift:b, mode: :set, skip_cols: nil, lclip: false, rclip: false, no0shift: false, tx:ix, disable_intr:true, enable_intr:true, save_sp:true, scraddr:nil, jump_table:nil, subroutine:false)","
    Creates a routine that draws bitmap pixels to the ink/paper screen as a rectangle object using unrolled …\n"],["bobs_draw_pixels_fast_jump_table","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_draw_pixels_fast_jump_table","(draw_pixels_fast_label)","
    Creates a jump table for the Macros#bobs_draw_pixels_fast routine.\n
    Provide a label (or a symbol) referencing …\n"],["bobs_draw_pixels_fast_routines","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_draw_pixels_fast_routines","(next_row, cols, mode: :set, skip_cols: nil, lclip: false, rclip: false, no0shift: nil, merge: false, jump_eoc: true)","
    Creates specialized routines for Macros#bobs_draw_pixels_fast that can be used externally via jump table. …\n"],["bobs_rshift_bitmap_pixels_7times","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_rshift_bitmap_pixels_7times","(bitmap=hl, lines=c, cols=a, target:de)","
    Creates a routine that renders 7 bitmap textures by shifting 7 times each source bitmap lines by 1 bit …\n"],["bobs_rshift_bitmap_pixels_once","ZXLib::Gfx::Bobs::Macros","ZXLib/Gfx/Bobs/Macros.html#method-i-bobs_rshift_bitmap_pixels_once","(bitmap=hl, lines=c, cols=a, target:de)","
    Creates a routine that renders a bitmap texture by shifting each source bitmap lines by 1 bit to the …\n"],["byte","Z80::Label","Z80/Label.html#method-c-byte","(size = 1)","
    A data structure's field type.\n"],["bytes","Z80::Program","Z80/Program.html#method-i-bytes","(*args)","
    Returns an unnamed label and allocates count bytes with Program.data. Optionally you can provide values …\n"],["bytesize","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-bytesize","()","
    Returns original size of this variable in bytes.\n"],["bytesize","ZXUtils::MusicBox::Track","ZXUtils/MusicBox/Track.html#method-i-bytesize","()","
    Returns the size in bytes of the track's compiled body.\n"],["byteslice","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-byteslice","(*at)","
    Returns a selected portion of an array variable according to provided dimension indices as raw bytes. …\n"],["calculate_benchmark_tstates","ZXUtils::Benchmark::Macros","ZXUtils/Benchmark/Macros.html#method-i-calculate_benchmark_tstates","(counter, tsframe, frames, idle, adjustment)","
    Returns the benchmark result.\n
    Calculates: (frames*(tsframe - 102) + tsframe - (idle*512 + signed adjustment)) …\n"],["ce","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-ce","(chord_name)",""],["ceo","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-ceo","()",""],["ch_a","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-ch_a","(&block)","
    Creates a track fragment for the A channel.\n
    Provide a block with commands suitable for MusicBox::Track …\n"],["ch_b","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-ch_b","(&block)","
    Creates a track fragment for the B channel.\n
    Provide a block with commands suitable for MusicBox::Track …\n"],["ch_c","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-ch_c","(&block)","
    Creates a track fragment for the C channel.\n
    Provide a block with commands suitable for MusicBox::Track …\n"],["chan_exists","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-chan_exists","(name = nil, output: de, input: nil, chan_name: 'U', buffer: 23296)","
    Looks for a ZX Spectrum CHAN entry determined by output, input and a chan_name.\n
    output — output routine …\n\n"],["channel","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-channel","(ch_name, &block)","
    Creates a track fragment for the given channel_name.\n
    Provide a block with commands suitable for MusicBox::Track …\n"],["channel_name_to_index","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-c-channel_name_to_index","(channel)","
    Returns a channel index: 0 to 2 for the given channel name.\n
    A channel can be an integer: 0 to 2 or one …\n"],["channel_track","ZXUtils::MusicBox::Multitrack","ZXUtils/MusicBox/Multitrack.html#method-i-channel_track","(channel)","
    Returns an instance of the compiled track for the given channel. A channel can be an integer: 0 to 2 …\n"],["char_array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-char_array-3F","()","
    true if variable is a character array\n"],["char_ptr_from_code","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-char_ptr_from_code","(chars, code=a, tt:de)","
    Calculates the address of the first byte of a character. The calculated address will be available in …\n"],["chord","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-chord","(name, *args)","
    Creates a chord with the given name as a symbol or a string. Provide args for the MusicBox::Chord.new …\n"],["chord_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-chord_off","()","
    Turns off, if any, a chord applied to the played note at the current channel.\n"],["clear!","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-clear-21","()","
    Clears all variables.\n"],["clear_attrs_region_fast","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-clear_attrs_region_fast","(address=hl, rows=a, cols=2, value=0, disable_intr:true, enable_intr:true, save_sp:true, addr_mode: :optimal, unroll_rows:false, scraddr:nil, subroutine:false)","
    Creates a routine that clears a rectangle on screen attributes using unrolled PUSH instructions.\n
    NOTE … — "],["clear_screen_region_fast","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-clear_screen_region_fast","(address=hl, lines=c, cols=2, value=0, disable_intr:true, enable_intr:true, save_sp:true, addr_mode: :compat, scraddr:nil, subroutine:false)","
    Creates a routine that clears a rectangle on an ink/paper screen using unrolled PUSH instructions.\n
    NOTE … — "],["clrmem","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-clrmem","(dest=hl, size=bc, value=0)","
    Clears memory at dest using LDIR instruction.\n
    T-states: ~ 21/cleared byte.\n
    Modifies: bc, de, hl, optionally …\n"],["clrmem8","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-clrmem8","(dest=hl, size=b, value=0, rr:hl)","
    Clears max 256 bytes of memory at dest. Slower (does not use LDIR/LDDR) but involves less registers. …\n"],["clrmem_fastest","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-clrmem_fastest","(address=hl, chunks_count=b, chunk_size=2, value=0, tt:hl, disable_intr:true, enable_intr:true, save_sp:true)","
    Clears a memory area using unrolled PUSH with a tight loop.\n
    NOTE — Interrupts should be disabled during …\n\n"],["clrmem_quick","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-clrmem_quick","(dest=hl, size=1, value=0, rr:hl)","
    Clears memory at dest in a faster way using unrolled instructions.\n
    T-states: ~ 13/cleared byte.\n
    Modifies: …\n"],["cmp_i16n","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-cmp_i16n","(th, tl, value, lt:nil, gt:nil, eq:nil, jump_rel:false)","
    Compares a bitwise concatenated pair of 8-bit values th|tl with a value as twos complement signed 16-bit …\n"],["cmp_i16r","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-cmp_i16r","(th, tl, sh, sl, lt:nil, gt:nil, eq:nil, jump_rel:false)","
    Compares a bitwise concatenated pair of 8-bit values th|tl with another pair sh|sl as twos complement …\n"],["cmp_i8","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-cmp_i8","(va, vb, lt:nil, gt:nil, eq:nil, jump_rel:false)","
    Compares va with vb as twos complement signed 8-bit integers.\n
    Provide va and vb as an 8-bit registers, …\n"],["code","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-code","()","
    Returns the raw byte representation of the whole ZX Basic program as a binary string.\n"],["code","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-code","()","
    Returns a portion of data after the header.\n"],["code?","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-code-3F","()","
    true if this chunk represents a code\n"],["compress","ZX7","ZX7.html#method-c-compress","(data)","
    ZX7.compress(data) -> data (zx7 compressed)\n"],["copy_shadow_attrs_region","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-copy_shadow_attrs_region","(address=de, rows=a, cols=c, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, subroutine:false)","
    Creates a routine that copies a rectangle of screen attributes from or to a shadow screen.\n
    address — An …\n\n"],["copy_shadow_attrs_region_quick","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-copy_shadow_attrs_region_quick","(address=de, rows=b, cols=32, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, size_limit_opt:false, subroutine:false)","
    Creates a routine that copies a rectangle of screen attributes from or to a shadow screen using unrolled …\n"],["copy_shadow_screen_region","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-copy_shadow_screen_region","(address=de, lines=a, cols=c, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, subroutine:false)","
    Creates a routine that copies a rectangle of an ink/paper screen from or to a shadow screen.\n
    address — "],["copy_shadow_screen_region_quick","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-copy_shadow_screen_region_quick","(address=de, lines=c, cols=32, tgtaddr:0x4000, srcaddr:0x6000, check_edge:true, break_oos:true, size_limit_opt:false, subroutine:false)","
    Creates a routine that copies a rectangle of an ink/paper screen from or to a shadow screen using unrolled …\n"],["cp16n","Z80::Program::Macros","Z80/Program/Macros.html#method-i-cp16n","(th, tl, value, jr_msb_c: nil, jr_msb_nz: :eoc)","
    Compares a pair of registers th|tl with a value as unsigned 16-bit integers.\n
    Provide value as an integer …\n"],["cp16r","Z80::Program::Macros","Z80/Program/Macros.html#method-i-cp16r","(th, tl, sh, sl, jr_msb_c: nil, jr_msb_nz: :eoc)","
    Compares a pair of registers th|tl with another pair sh|sl as unsigned 16-bit integers.\n\n
    CF, ZF = (th|tl ...
    \n"],["cp16rr","Z80::Program::Macros","Z80/Program/Macros.html#method-i-cp16rr","(tt, ss, jr_msb_c: nil, jr_msb_nz: :eoc)","
    Compares a pair of 16-bit registers tt with ss as unsigned integers.\n
    A sugar for:\n\n
    cp16r(th,tl, sh,sl, ...)
    \n"],["create_chan_and_open","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-create_chan_and_open","(name = nil, output:, input: nil, strm_no: 4, chan_name: 'U')","
    Creates a ZX Spectrum CHAN entry and opens it as a stream #N.\n
    output — a routine address or a 16bit register …\n\n"],["create_sincos_from_sintable","Z80::Utils::SinCos::Macros","Z80/Utils/SinCos/Macros.html#method-i-create_sincos_from_sintable","(sincos, sintable:hl)","
    Creates a subroutine that generates a full SinCosTable from a quarter sinus table obtainable from #neg_sintable256_pi_half_no_zero_lo …\n"],["cursor_key_pressed?","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-cursor_key_pressed-3F","(t:b, io:self.io)","
    Test for cursor keys being pressed.\n
    Options:\n
    t — A temporary 8-bit register.\n"],["data","Z80::Program","Z80/Program.html#method-i-data","(type = 1, size = nil, *args)","
    Returns an unnamed, relative label and adds provided data to the Program.code at Program.pc.\n
    The type …\n"],["db","Z80::Program","Z80/Program.html#method-i-db","(*args)","
    Returns an unnamed label and adds the provided integers to Program.code as bytes.\n
    See: Program.data.\n"],["dc!","Z80::Program","Z80/Program.html#method-i-dc-21","(text=''.freeze)",""],["debug","Z80","Z80.html#method-i-debug","()","
    Creates a debugger view from an instance of a Z80::Program. Returns an array of strings.\n
    Example debugger …\n"],["debug_comment","Z80::Program","Z80/Program.html#method-i-debug_comment","(text=''.freeze)","
    Appends user comment to the debug listing.\n
    The comment will be visible as text in the listing at the current …\n"],["define_label","Z80::Program","Z80/Program.html#method-i-define_label","(name, label=nil)","
    Defines a label with the given name in the current namespace's context. Returns a named label.\n
    A  …\n"],["direct_address?","Z80::Program","Z80/Program.html#method-i-direct_address-3F","(arg)","
    A convenient method for macros to check if an argument is a non-register direct address (not a pointer). …\n"],["direct_label?","Z80::Program","Z80/Program.html#method-i-direct_label-3F","(arg)","
    A convenient method for macros to check if an argument is a direct label (not a pointer).\n
    Returns true …\n"],["disable_ay_volume_ctrl","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-disable_ay_volume_ctrl","()","
    Turns off the AY-3-891x automatic volume envelope control of the current channel.\n"],["divmod","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod","(k, m, clrrem:true, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time)","
    Creates a routine that performs an euclidean division of unsigned: k / m. Returns a quotient in k and …\n"],["divmod16","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod16","(x=ixl, check0:true, check1:true, modulo:false, quick8:true)","
    Creates a routine that performs an euclidean division of unsigned 16-bit: hl / de. Returns a quotient …\n"],["divmod16_8","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod16_8","(kh, kl, m, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time)","
    Creates a routine that performs an euclidean division of unsigned 16-bit: kh|kl / 8-bit m. Returns a …\n"],["divmod24_8","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod24_8","(kh, km, kl, m, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time)","
    Creates a routine that performs an euclidean division of unsigned 24-bit: kh|km|kl / 8-bit m. Returns …\n"],["divmod32_16","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod32_16","(x:ixl, check0:true, check1:true, modulo:false, quick8:true)","
    Creates a routine that performs an euclidean division of unsigned 32-bit: hl|hl' / de. Returns a …\n"],["divmod32_8","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod32_8","(m=c, mt:c, check0:true, check1:true, modulo:false)","
    Creates a routine that performs an euclidean division of unsigned 32-bit: hl|hl' / m. Returns a quotient …\n"],["divmod8","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-divmod8","(m=c, check0:true, check1:true, modulo:false)","
    Creates a routine that performs an euclidean division of unsigned: hl / m. Returns a quotient in hl and …\n"],["draw_line","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line","(preshift_pixel, preshift_cov_lt, preshift_cov_rt, fx: :or, pixel_type: :pixel, scraddr:0x4000, check_oos:true, end_with: :eoc)","
    Creates a routine that draws an approximation to a straight line.\n
    The routine only modifies ink/paper …\n"],["draw_line_dx_gt_4dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_dx_gt_4dy","(preshift_cov_rt, direction: :down, fx: :or, pixel_type: :pixel, scraddr:0x4000, check_oos:true, end_with: :eoc)","
    Creates a routine for drawing lines with the x distance 4 times larger than the y distance.\n
    Input registers: …\n"],["draw_line_dx_gt_dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_dx_gt_dy","(preshift_cov_lt, direction: :down, fx: :or, pixel_type: :pixel, scraddr:0x4000, check_oos:true, end_with: :eoc)","
    Creates a routine for drawing lines with the x distance larger than the y distance.\n
    Input registers with …\n"],["draw_line_dy_gte_dx","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_dy_gte_dx","(preshift, direction: :down_right, fx: :or, pixel_type: :pixel, scraddr:0x4000, check_oos:true, end_with: :eoc)","
    Creates a routine for drawing lines with the y distance larger than or equal to the x distance.\n
    Input …\n"],["draw_line_fx_data","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_fx_data","(preshift_pixel, preshift_cov_lt, preshift_cov_rt, fx:, pixel_type:)","
    Creates data for draw_line_update routine.\n
    Arguments:\n
    preshift_pixel — An address of an 8-byte aligned pixel …\n"],["draw_line_fx_data_dx_gt_4dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_fx_data_dx_gt_4dy","(preshift_cov_rt, fx:, pixel_type:)","
    Creates data for draw_line_update_dx_gt_4dy routine.\n
    Arguments:\n
    preshift_cov_rt — An address of an 8-byte …\n"],["draw_line_fx_data_dx_gt_dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_fx_data_dx_gt_dy","(preshift_cov_lt, fx:, pixel_type:nil)","
    Creates data for draw_line_update_dx_gt_dy routine.\n
    Arguments:\n
    preshift_cov_lt — An address of an 8-byte …\n"],["draw_line_fx_data_dy_gte_dx","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_fx_data_dy_gte_dx","(preshift, fx:, pixel_type:nil)","
    Creates data for draw_line_update_dy_gte_dx routine.\n
    Arguments:\n
    preshift — An address of an 8-byte aligned …\n"],["draw_line_fx_data_vertical","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_fx_data_vertical","(preshift, fx:)","
    Creates data for draw_line_update_vertical routine.\n
    Arguments:\n
    preshift — An address of an 8-byte aligned …\n"],["draw_line_update","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_update","(target, fx_only:false)","
    Creates a routine that modifies the function of the draw_line code in place.\n
    target — Provide a label returned …\n\n"],["draw_line_update_dx_gt_4dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_update_dx_gt_4dy","(target, no_preshift:false, fx_only:false)","
    Creates a routine that modifies the function of the draw_line_dx_gt_4dy code in place.\n
    target — Provide …\n\n"],["draw_line_update_dx_gt_dy","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_update_dx_gt_dy","(target, no_preshift:false, fx_only:false)","
    Creates a routine that modifies the function of the draw_line_dx_gt_dy code in place.\n
    target — Provide a …\n\n"],["draw_line_update_dy_gte_dx","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_update_dy_gte_dx","(target, no_preshift:false, fx_only:false)","
    Creates a routine that modifies the function of the draw_line_dy_gte_dx code in place.\n
    target — Provide …\n\n"],["draw_line_update_vertical","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_update_vertical","(target, no_preshift:false)","
    Creates a routine that modifies the function of the draw_line_vertical code in place.\n
    target — Provide a …\n\n"],["draw_line_vertical","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-draw_line_vertical","(preshift, direction: :down, fx: :or, scraddr:0x4000, check_oos:true, end_with: :eoc)","
    Creates a routine for drawing vertical lines.\n
    Input registers with preshift data:\n
    hl: the screen memory …\n"],["draw_sprite8","ZXLib::Gfx::Sprite8","ZXLib/Gfx/Sprite8.html#method-i-draw_sprite8","","
    Draws a sprite using one of the selected drawing methods with an arbitrary pixel height and width.\n
    Pixel …\n"],["dummy","Z80::Label","Z80/Label.html#method-c-dummy","(name = nil)","
    Creates a dummy label. Should not be used directly in programs. This is called by Program.method_missing …\n"],["dummy?","Z80::Alloc","Z80/Alloc.html#method-i-dummy-3F","()",""],["dummy?","Z80::Label","Z80/Label.html#method-i-dummy-3F","()","
    Checks if a label is not yet given value and type (in-the-future a.k.a. a dummy label).\n"],["dup","Z80::Alloc","Z80/Alloc.html#method-i-dup","()",""],["dw","Z80::Program","Z80/Program.html#method-i-dw","(*args)","
    Returns an unnamed label and adds the provided integers to Program.code as words.\n
    See: Program.data.\n"],["dzx7_agilercs","ZX7::Macros","ZX7/Macros.html#method-i-dzx7_agilercs","(name=nil)","
    “Agile” integrated RCS+ZX7 decoder by Einar Saukas (150 bytes)\n
    Parameters:\n\n
    HL: source address ...
    \n"],["dzx7_mega","ZX7::Macros","ZX7/Macros.html#method-i-dzx7_mega","(name=nil)","
    ZX7 decoder by Einar Saukas “Mega” version (244 bytes, 30% faster)\n
    Parameters:\n\n
    HL: source address ...
    \n"],["dzx7_smartrcs","ZX7::Macros","ZX7/Macros.html#method-i-dzx7_smartrcs","(name=nil)","
    “Smart” integrated RCS+ZX7 decoder by Einar Saukas (110 bytes)\n
    Parameters:\n\n
    HL: source address ...
    \n"],["dzx7_standard","ZX7::Macros","ZX7/Macros.html#method-i-dzx7_standard","(name = nil)","
    ZX7 decoder by Einar Saukas, Antonio Villena & Metalbrain “Standard” version (69 bytes …\n"],["dzx7_turbo","ZX7::Macros","ZX7/Macros.html#method-i-dzx7_turbo","(name = nil)","
    ZX7 decoder by Einar Saukas & Urusergi “Turbo” version (88 bytes, 25% faster)\n
    Parameters: …\n"],["each_var","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-each_var","(&block)","
    Returns an Enumerator of every Basic::Variable found in self.\n"],["ei","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-ei","()",""],["else","Z80::ConditionalBlock","Z80/ConditionalBlock.html#method-i-else","(&block)","
    Evaluates a block in an anonymous namespace if the condition evaluates to false. Returns an instance …\n"],["else_select","Z80::ConditionalBlock","Z80/ConditionalBlock.html#method-i-else_select","(*args, &test)","
    Evaluates additional condition if the previous condition evaluates to false. Returns an instance of  …\n"],["enable_ay_volume_ctrl","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-enable_ay_volume_ctrl","()","
    Enables the AY-3-891x automatic volume envelope control of the current channel.\n"],["enlarge_char8_16","ZXUtils::BigFont::Macros","ZXUtils/BigFont/Macros.html#method-i-enlarge_char8_16","(compact:true, over:false, scraddr:0x4000, assume_chars_aligned:true, hires:nil)","
    Outputs an enlarged 8x8 character with anti-aliasing into the screen memory.\n
    The register hl should hold …\n"],["envd","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envd","(duration)",""],["envdur","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envdur","(duration)",""],["envelope","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-envelope","(name, *args)","
    Creates an envelope with the given name as a symbol or a string. Provide args for the MusicBox::Envelope.new …\n"],["envelope_duration","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envelope_duration","(duration)","
    Sets the AY-3-891x automatic volume envelope duration: 1 to 65535.\n"],["envelope_shape","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envelope_shape","(shape)","
    Sets the shape of the AY-3-891x automatic volume envelope: 0 to 15. You may use ZXLib::AYSound::EnvelopeControl …\n"],["envs","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envs","(shape)",""],["envsh","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-envsh","(shape)",""],["equal_tempered_scale_notes_hz","ZXLib::AYSound::Macros","ZXLib/AYSound/Macros.html#method-i-equal_tempered_scale_notes_hz","(hz:440, n0:0, steps:12)","
    Returns an array of equal tempered scale frequencies from a given base frequency.\n
    See — pages.mtu.edu/~suits/NoteFreqCalcs.html …\n\n"],["estimate_tstates_per_interrupt","ZXUtils::Benchmark::Macros","ZXUtils/Benchmark/Macros.html#method-i-estimate_tstates_per_interrupt","(stack_end, interrup_vec, forward, tsframe, idle)","
    Estimates the number of T-States between interrupts.\n"],["export","Z80::Program","Z80/Program.html#method-i-export","(label)","
    Marks label_name as exportable. Programs may import labels from another programs with Program.import …\n"],["expression?","Z80::Alloc","Z80/Alloc.html#method-i-expression-3F","()",""],["expression?","Z80::Label","Z80/Label.html#method-i-expression-3F","()","
    Checks if a label is an expression.\n"],["find_channel","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-find_channel","","
    Looks for a channel name.\n
    Input:\n
    a — A channel name as an upper-case letter code.\n"],["find_channel_arg","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-find_channel_arg","","
    Looks for a channel name from a FN string argument.\n
    NOTE — This routine must never be called from a task! …\n\n"],["find_def_fn_args","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-find_def_fn_args","(argnum=b, subroutine:true, not_found:nil, cf_on_direct:false, ¬_found_blk)","
    Gets a DEF FN argument value address.\n
    Requires: macro_import MathInt.\n
    argnum — 1-based argument index (0 …\n"],["find_emulator","ZXUtils::Emu","ZXUtils/Emu.html#method-c-find_emulator","()","
    Searches for an installed ZX Spectrum emulator program in the system. Returns a path to the executable …\n"],["find_input_handle","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-find_input_handle","","
    Looks for an input handle for tasks.\n
    Provide a channel name as an upper-case letter code in accumulator. …\n"],["find_io_handles","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-find_io_handles","","
    Looks for I/O handles.\n
    Provide a channel name as an upper-case letter code in accumulator.\n
    On success returns …\n"],["find_output_handle","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-find_output_handle","","
    Looks for an output handle for tasks.\n
    Provide a channel name as an upper-case letter code in accumulator. …\n"],["find_record","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-find_record","(th=h, tl=l)","
    Search for a record that matches a large block of memory.\n
    +th|tl'+ — address of the last byte to search …\n\n"],["first_octave_note","ZXUtils::MusicBox::TrackConfigCommands","ZXUtils/MusicBox/TrackConfigCommands.html#method-i-first_octave_note","(note=nil)","
    Gets or establishes which music note :a to :g! begins an octave. By default the first music note in an …\n"],["fixed_volume","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-fixed_volume","()",""],["for_ch","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-for_ch","(*chs, &block)",""],["for_channels","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-for_channels","(*chs, &block)","
    Creates a track fragments with the same commands for the channels indicated by channel_names.\n
    Provide …\n"],["for_loop?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-for_loop-3F","()","
    true if variable is a FOR loop variable\n"],["fp_to_integer32","ZXLib::Math::Macros","ZXLib/Math/Macros.html#method-i-fp_to_integer32","(m3=e, m2=d, m1=c, m0=b, exp:a)","
    Creates a routine that converts a ZX Basic's floating point number to a 32-bit integer.\n
    m3|m2|m1| … — "],["from_data","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-from_data","(data)","
    Creates a Basic::Variable from a ZX Spectrum's VARS raw data.\n
    Provide data as a binary string.\n"],["from_program_data","ZXLib::Basic","ZXLib/Basic.html#method-c-from_program_data","(data, prog_length=nil, start:nil)","
    Creates a Basic::Program instance from a ZX Spectrum's raw binary data.\n
    The binary data may be a snapshot …\n"],["from_tap_chunk","ZXLib::Basic","ZXLib/Basic.html#method-c-from_tap_chunk","(chunk)","
    Creates a Basic::Program or a Basic::Variable depending on the type of the chunk. The chunk should be …\n"],["fv","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-fv","()",""],["get","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-get","(name)","
    Returns the first Basic::Variable if found by the given name.\n"],["get_adjustment","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-get_adjustment","","
    Returns a signed integer. Convert with: LET x=x-(65536 AND x>=32768)\n"],["get_counter","ZXUtils::AYBasicPlayer","ZXUtils/AYBasicPlayer.html#method-i-get_counter","","
    Returns the current value of the music counter.\n"],["get_emulator_path","ZXUtils::Emu","ZXUtils/Emu.html#method-c-get_emulator_path","()","
    Returns a path to the executable file of a ZX Spectrum emulator.\n
    The path is being determined by ZXEMU_PATH …\n"],["get_frames","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-get_frames","","
    Returns an unsigned integer\n"],["get_idle","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-get_idle","","
    Returns an unsigned integer\n"],["get_int8_norm_arg","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-get_int8_norm_arg","","
    Attempts to read an integer in the range -255..255 from a FN argument.\n
    NOTE — This routine must never be …\n\n"],["get_stream_arg","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-get_stream_arg","","
    Attempts to read a stream number from a FP-value addressed by hl.\n
    NOTE — This routine must never be called …\n\n"],["getset_tsframe","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-getset_tsframe","","
    Returns a less significant 16-bit unsigned integer. Add 65536 to get the actual value.\n"],["gfx_clip_calculate_8bit_dx_dy_exx","ZXLib::Gfx::Clip::Macros","ZXLib/Gfx/Clip/Macros.html#method-i-gfx_clip_calculate_8bit_dx_dy_exx","(xx=bc, yy=de, full_range_delta:true)","
    Creates a routine that calculates dx and dy. Used by: Macros.gfx_clip_line.\n
    NOTE — Swaps bc, de, hl registers …\n\n"],["gfx_clip_compute_outcode","ZXLib::Gfx::Clip::Macros","ZXLib/Gfx/Clip/Macros.html#method-i-gfx_clip_compute_outcode","(outcode, xx=bc, yy=de, xmax:ixh, xmin:ixl, ymax:iyh, ymin:iyl, jump_rel:true, subroutine:false)","
    Creates a routine that computes the Outcode bits for the xx, yy point and the clipping region. Stores …\n"],["gfx_clip_coords_to_draw_line_args","ZXLib::Gfx::Clip::Macros","ZXLib/Gfx/Clip/Macros.html#method-i-gfx_clip_coords_to_draw_line_args","(xx=bc, yy=de, args_type: :zxlib)","
    Converts clipped 16-bit coordinates to the “draw line” routine arguments.\n
    The line endpoints …\n"],["gfx_clip_dimension","ZXLib::Gfx::Clip::Macros","ZXLib/Gfx/Clip/Macros.html#method-i-gfx_clip_dimension","(a0:bc, b0:de, d1:l, d2:h, full_range_delta:true)","
    Creates a subroutine that clips a single dimension. Used by: Macros.gfx_clip_line.\n\n
    hl = a0 + sign * d1 ...\n
    \n"],["gfx_clip_line","ZXLib::Gfx::Clip::Macros","ZXLib/Gfx/Clip/Macros.html#method-i-gfx_clip_line","(xx=bc, yy=de, xmax:ixh, xmin:ixl, ymax:iyh, ymin:iyl, full_range_delta:true, compact:true)","
    Creates a subroutine for clipping lines to the rectangle viewport area using Cohen–Sutherland algorithm. …\n"],["gfx_sprite8_calculate_coords","ZXLib::Gfx::Sprite8::Macros","ZXLib/Gfx/Sprite8/Macros.html#method-i-gfx_sprite8_calculate_coords","(outofscreen: :ret, **nsopts, &block)","
    Creates a routine that calculates coordinates and prepares registers for Sprite8.draw_sprite8.\n
    hl — An address …\n"],["gfx_sprite8_calculate_screen_address","ZXLib::Gfx::Sprite8::Macros","ZXLib/Gfx/Sprite8/Macros.html#method-i-gfx_sprite8_calculate_screen_address","(scraddr:SCREEN_ADDRESS, subroutine:false)","
    Creates a routine that calculates the screen address for Sprite8.draw_sprite8.\n
    The h and l registers should …\n"],["gfx_sprite8_draw","ZXLib::Gfx::Sprite8::Macros","ZXLib/Gfx/Sprite8/Macros.html#method-i-gfx_sprite8_draw","(draw_sprite8=self.draw_sprite8, scraddr:SCREEN_ADDRESS, calculate:CALCULATE_SCREEN_ADDRESS, **nsopts, &block)","
    Creates a subroutine that calculates the screen address before jumping to Sprite8.draw_sprite8.\n
    This subroutine …\n"],["gfx_sprite8_flip_horizontally","ZXLib::Gfx::Sprite8::Macros","ZXLib/Gfx/Sprite8/Macros.html#method-i-gfx_sprite8_flip_horizontally","(subroutine:false)","
    Creates a routine that flips sprite pixel data horizontally (mirrors sprites).\n
    hl — An address immediately …\n"],["head","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-head","()","
    Returns a header byte.\n"],["i","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-i","(instrument_name)",""],["immediate?","Z80::Alloc","Z80/Alloc.html#method-i-immediate-3F","()",""],["immediate?","Z80::Label","Z80/Label.html#method-i-immediate-3F","()","
    Checks if a label is defined and absolute: true or not (relative or dummy): (false). Prefer using Program.immediate? …\n"],["immediate?","Z80::Program","Z80/Program.html#method-i-immediate-3F","(arg)","
    A convenient method for macros to check if an argument is an immediate label or an integer.\n
    Returns true …\n"],["import","Z80::Program","Z80/Program.html#method-i-import","(program, name=nil, labels:true, code:true, macros:false, override:{}, args:[])","
    Imports code, labels or macros from another program class. Give an optional name to create a namespace …\n"],["import_chord","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_chord","(name, chord)","
    Imports a MusicBox::Chord instance with the given name as a symbol or a string.\n"],["import_envelope","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_envelope","(name, envelope)","
    Imports a MusicBox::Envelope instance with the given name as a symbol or a string.\n"],["import_file","Z80::Program","Z80/Program.html#method-i-import_file","(file, type = :any, size = nil, pipe:nil, check_size:nil, data_type:nil, **args)","
    Imports a binary file.\n
    file — A file name.\n\n
    type — A format of a binary file (as a symbol), if :any -> format …\n"],["import_instrument","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_instrument","(name, track)","
    Imports a MusicBox::Instrument class with the given name as a symbol or a string.\n"],["import_mask","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_mask","(name, mask)","
    Imports a MusicBox::Mask instance with the given name as a symbol or a string.\n"],["import_multitrack","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_multitrack","(name, multitrack)","
    Imports a MusicBox::Multitrack class with the given name as a symbol or a string.\n"],["import_track","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-import_track","(name, track)","
    Imports a MusicBox::Track class with the given name as a symbol or a string.\n"],["include?","Z80::Alloc","Z80/Alloc.html#method-c-include-3F","(alloc, label)","
    Return true if label takes part in an alloc expression.\n"],["indexable?","Z80::Alloc","Z80/Alloc.html#method-i-indexable-3F","()",""],["indexable?","Z80::Label","Z80/Label.html#method-i-indexable-3F","()","
    Returns true if a lazy evaluated label can be offset by index.\n"],["init","ZXUtils::AYMusic","ZXUtils/AYMusic.html#method-i-init","","
    Call to initialize music structures and reset counter, track and instrument cursors.\n
    NOTE — Stop interrupts …\n\n"],["init","ZXUtils::AYMusicPlayer","ZXUtils/AYMusicPlayer.html#method-i-init","","
    Initialize music module.\n
    Relocates index table and sets the tracks' cursors to the initial positions. …\n"],["init_multitasking","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-init_multitasking","","
    Initializes multitasking.\n
    NOTE — This routine must never be called from a task!\n\n
    Clears all tasks, sets global …\n"],["init_music","ZXUtils::AYBasicPlayer","ZXUtils/AYBasicPlayer.html#method-i-init_music","","
    Initializes music track. Sets up the player.\n
    To setup the player (once):\n\n
    RANDOMIZE USR #{player[:init_music]}\n
    \n"],["initialize","Z80::Label","Z80/Label.html#method-i-initialize","(address, type = 1, reloc = nil, members = nil)",""],["initialize_io","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-initialize_io","","
    Initializes I/O and multitasking.\n
    NOTE — This routine must never be called from a task!\n\n
    Modifies: af, bc …\n"],["insertion_sort_bytes_max256","Z80::Utils::Sort::Macros","Z80/Utils/Sort/Macros.html#method-i-insertion_sort_bytes_max256","(reverse:false, target:hl, length:b, subroutine:false, &side_effects)","
    Creates a routine that sorts an array of bytes using insertion sort.\n\n
    i ← 0\nwhile i < length(A) - 1\n   ...
    \n"],["instrument","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-instrument","(name, &block)","
    Creates an instrument with the given name as a symbol or a string.\n
    Give a block of code containing instrument …\n"],["instruments","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-instruments","()","
    Returns a hash of instruments used in a song. Keys are instrument names and values are Instrument instances. …\n"],["int","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-int","(bitsize, value, byteorder: :lsb)","
    Packs an integer of an arbitrary size and adds it to the Program.code at Program.pc. Returns an unnamed …\n"],["integer32_to_fp","ZXLib::Math::Macros","ZXLib/Math/Macros.html#method-i-integer32_to_fp","(m3=e, m2=d, m1=c, m0=b, sgn:a)","
    Creates a routine that converts a 32-bit integer to a ZX Basic's floating point value.\n
    m3|m2|m1|m0 … — "],["interlace_pixels16","ZXUtils::BigFont::Macros","ZXUtils/BigFont/Macros.html#method-i-interlace_pixels16","(f1, f2, unroll:true, &block)","
    Interlaces pixels from the f1 and f2 registers into the a register.\n
    Evaluates the given block after 8 …\n"],["isolate","Z80::Program","Z80/Program.html#method-i-isolate","(name = nil, **opts, &block)","
    Returns a relative label, as an isolated namespace, holding labels defined by the code created with  …\n"],["jr_ok?","Z80::Program::Condition","Z80/Program/Condition.html#method-i-jr_ok-3F","()",""],["kernel_org","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-c-kernel_org","()","
    The Multitasking kernel code start address.\n"],["kernel_org","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-c-kernel_org","()","
    The MultitaskingIO kernel code start address.\n"],["key_pressed?","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-key_pressed-3F","(line_mask=0, key_mask=0x1f, io:self.io)","
    Test for a key or keys being pressed.\n
    line_mask — Keyboard half-line mask, may be an 8 bit register. The …\n\n"],["label","Z80::Program","Z80/Program.html#method-i-label","(type = 1, align: nil, offset: 0)","
    Returns an unnamed, relative label at Program.pc of the optional type.\n
    type can be an integer or a data …\n"],["label?","Z80::Program","Z80/Program.html#method-i-label-3F","(arg)","
    A convenient method for macros to check if an argument is label-like.\n
    Returns true for:\n\n
    foo, :foo, foo[10], ...
    \n"],["label_defined?","Z80::Program","Z80/Program.html#method-i-label_defined-3F","(name)","
    True if a label with a name is defined in the current context.\n"],["label_immediate?","Z80::Program","Z80/Program.html#method-i-label_immediate-3F","(arg)","
    A convenient method for macros to check if an argument is an immediate label.\n
    Returns true for:\n\n
    foo addr ...\n
    \n"],["label_import","Z80::Program","Z80/Program.html#method-i-label_import","(program, name = nil, labels:true, macros:false)","
    Imports labels from another program class. Optionally imports macros.\n
    A sugar for:\n\n
    import program, code: ...
    \n"],["ld16","Z80::Program::Macros","Z80/Program/Macros.html#method-i-ld16","(aa, bb)","
    Loads a content of the 16-bit register bb into the 16-bit register aa.\n
    A sugar for two 8-bit ld instructions. …\n"],["length","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-length","()","
    For strings returns the original string length, for arrays a number of dimensions.\n"],["limit","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-limit","()","
    Returns the FOR loop limit value.\n"],["line","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-line","()","
    Returns the FOR loop line number.\n"],["line_index","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-line_index","(line_no)","
    Returns index in lines of a Basic line number equal or greater than line_no.\n"],["list","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-list","(line_no)","
    Returns a new Basic::Program instance with the subset of its lines according to the line_no argument. …\n"],["loop_to","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-loop_to","(mark_name, repeat=nil)","
    Loops execution from the marked point name. Repeats repeat times. If repeat is nil or missing loops  …\n"],["loop_to","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-loop_to","(mark_name, repeat=nil)","
    Loops execution from the marked point name. Repeats repeat times. If repeat is nil or missing loops  …\n"],["lt","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-lt","(mark_name, repeat=nil)",""],["lt","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-lt","(mark_name, repeat=nil)",""],["m","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-m","(name)",""],["m","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-m","(name)",""],["m1","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-m1","()",""],["m2","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-m2","()",""],["macro","Z80::Program::Macros","Z80/Program/Macros.html#method-i-macro","(name, *registers, **nsopts, &mblock)","
    A convenient method to create local macros.\n
    Give a name (Symbol) to your macro, an optional list of registers …\n"],["macro_import","Z80::Program","Z80/Program.html#method-i-macro_import","(program)","
    Imports macros from another program class.\n
    A sugar for:\n\n
    import program, code: false, macros: true, labels: ...
    \n"],["make","Z80Lib3D::Primitives::Vertex","Z80Lib3D/Primitives/Vertex.html#method-c-make","(x, y, z, scrx0:128, scry0:128, scrz0:128, persp_dshift:7)","
    Creates a Vertex data argument for given coordinates.\n"],["make_draw_line_subroutines","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-make_draw_line_subroutines","(make_line:true, make_line_over:true, make_line_inversed:true, make_lines_to:true, scraddr:0x4000, check_oos:true)","
    A convenient method to build drawing subroutines.\n
    Returns a namespace label with members including the …\n"],["make_many","Z80Lib3D::Primitives::Vertex","Z80Lib3D/Primitives/Vertex.html#method-c-make_many","(*args, scrx0:128, scry0:128, scrz0:128, persp_dshift:7)","
    Creates many Vertex data arguments from triplets: [x, y, z].\n"],["mark","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mark","(name)","
    Marks a point in the track and gives it a name as a symbol or a string. You can later use CommonInstrumentCommands.loop_to …\n"],["mark","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-mark","(name)","
    Marks a point in tracks and gives it a name as a symbol or a string. You can later use MultitrackCommands.loop_to …\n"],["mask","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-mask","(name, *args)","
    Creates a mask with the given name as a symbol or a string. Provide args for the MusicBox::Mask.new. …\n"],["mask_ay_volume_envelope","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_ay_volume_envelope","(mask_name)","
    Applies a mask defined by SongCommands.mask to the current channel's envelope bit controlling the …\n"],["mask_ay_volume_envelope_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_ay_volume_envelope_off","()","
    Turns off, if any, a mask applied to the current channel's envelope bit.\n"],["mask_noise","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_noise","(mask_name)","
    Applies a mask defined by SongCommands.mask to the current channel's mixer controlling the noise …\n"],["mask_noise_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_noise_off","()","
    Turns off, if any, a mask applied to the current channel's mixer controlling the noise output.\n"],["mask_tone","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_tone","(mask_name)","
    Applies a mask defined by SongCommands.mask to the current channel's mixer controlling the tone output. …\n"],["mask_tone_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mask_tone_off","()","
    Turns off, if any, a mask applied to the current channel's mixer controlling the tone output.\n"],["match16?","Z80::Program::Register","Z80/Program/Register.html#method-i-match16-3F","(other)","
    Checks if self can adjoin with other: self|other\n"],["me","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-me","(mask_name)",""],["members_of_struct","Z80::Label","Z80/Label.html#method-c-members_of_struct","()","
    Returns a hash containing structure members as instances of a Member class.\n"],["memcpy","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-memcpy","(dest=de, source=hl, size=bc, reverse: nil)","
    Copies size bytes from memory area source to memory area dest.\n
    dest — A destination address as an integer, …\n"],["memcpy_quick","Z80::Stdlib::Macros","Z80/Stdlib/Macros.html#method-i-memcpy_quick","(dest=de, source=hl, size=1, reverse: nil)","
    Copies size bytes from memory area source to memory area dest using unrolled LDI/LDD.\n
    dest — A destination …\n"],["meo","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-meo","()",""],["method_missing","Z80::Alloc","Z80/Alloc.html#method-i-method_missing","(m)",""],["method_missing","Z80::Label","Z80/Label.html#method-i-method_missing","(m)","
    Any other method will lazy evaluate as an accessor to the member label of this label.\n"],["method_missing","Z80::Label","Z80/Label.html#method-c-method_missing","(m, struct=nil, count=1)","
    Any other method is being used as a label to a member of a data structure.\n"],["method_missing","Z80::Program","Z80/Program.html#method-i-method_missing","(m, label = nil)","
    If no singleton method m is defined, assume m is a label name to define. Returns a named label.\n
    A label …\n"],["mix_lines8_16","ZXUtils::BigFont::Macros","ZXUtils/BigFont/Macros.html#method-i-mix_lines8_16","(r=b, o:c, t1:d, t2:e)","
    Mixes two consecutive 8-pixel lines into the 16-pixel middle anti-aliasing line. The resulting bits from …\n"],["mmu128_select_bank","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-mmu128_select_bank","(bank:nil, screen:nil, disable_intr:true, enable_intr:true, mmu_port_in_bc:false, sys128:self.sys128)","
    Selects an upper memory bank (0-7) and/or a screen memory page (0-1) to be displayed.\n
    Options:\n
    bank — Selects …\n"],["mmu128_swap_screens","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-mmu128_swap_screens","(swap_bank:false, disable_intr:true, enable_intr:true, mmu_port_in_bc:false, sys128:self.sys128)","
    Swap displayed screens.\n
    Options:\n
    swap_bank — A boolean flag indicating that the routine should additionally …\n"],["mn","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mn","(mask_name)",""],["mno","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mno","()",""],["mode1","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mode1","()","
    Switches to play mode 1. This is the default mode. In this mode after playing a note the instrument track, …\n"],["mode2","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mode2","()","
    Switches to play mode 2. In this mode after playing a note the instrument track, if set, continues executing …\n"],["move_basic_above_scld_screen_memory","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-move_basic_above_scld_screen_memory","(check_ensure:false)","
    Moves Basic program and variables above the screen 1 (to 0x7B00).\n
    check_ensure — when true checks if a call …\n\n\n"],["mt","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mt","(mask_name)",""],["mtio_drain","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_drain","(disable_intr:true, enable_intr:true)","
    Drains the I/O buffer.\n
    Options:\n
    disable_intr — a boolean flag indicating that the routine should disable …\n"],["mtio_getc","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_getc","(char=e, tt:bc, not_ready: :eoc, subroutine: true, preserve_hl:true, disable_intr:true, enable_intr:true, mtyield: task_yield)","
    Reads a single character from the I/O buffer. Arguments:\n
    char — an 8 bit register which should receive a …\n\n\n"],["mtio_gets","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_gets","(nchars=a, check_nchars_zero:true, subroutine:true, disable_intr:true, enable_intr:true, mtyield: task_yield)","
    Reads a string of characters from the I/O buffer.\n
    Arguments:\n
    nchars — a number 1..255 or accumulator with …\n"],["mtio_putc","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_putc","(char=e, tt:bc, not_ready: :eoc, subroutine: true, preserve_hl:true, disable_intr:true, enable_intr:true, mtyield: task_yield)","
    Writes a single character to the I/O buffer.\n
    Arguments:\n
    char — a number or an 8 bit register with the character …\n"],["mtio_puts","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_puts","(nchars=a, check_nchars_zero:true, subroutine:true, disable_intr:true, enable_intr:true, mtyield: task_yield)","
    Sends a string of characters to the I/O buffer.\n
    Arguments:\n
    nchars — a number 1..255 or accumulator with a …\n"],["mtio_ready?","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_ready-3F","(action, nchars:nil, disable_intr:true, enable_intr:true)","
    Checks I/O buffer's data availability.\n
    Arguments:\n
    action — a symbol :read to get the information if the …\n"],["mtio_wait","ZXUtils::MultitaskingIO::Macros","ZXUtils/MultitaskingIO/Macros.html#method-i-mtio_wait","(action, nchars=1, disable_intr:true, enable_intr:true, mtyield:task_yield)","
    Waits for the I/O buffer's data availability.\n
    Arguments:\n
    action — a symbol :read to wait for the data …\n"],["mto","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-mto","()",""],["mul","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul","(k=d, m=a, tt:de, clrhl:true, signed_k:false, kbit9_carry:false, tl_is_zero:false, optimize: :time)","
    Creates a routine that performs a multiplication of an 8(9)-bit integer k * 8-bit unsigned m. Returns …\n"],["mul16","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul16","(kh=h, kl=l, m=a, tt:de, mbit9_carry:false, optimize: :time)","
    Creates a routine that performs a multiplication of a 16-bit integer kh|kl * 8(9)-bit unsigned m. Returns …\n"],["mul16_32","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul16_32","(mm=bc, tt:bc, clrhlhl:true, signed_hl:false, optimize: :time)","
    Creates a routine that performs a multiplication of a 16-bit integer (hl) by an unsigned 16-bit integer …\n"],["mul16_signed","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul16_signed","(kh=h, kl=l, m=b, tt:de, optimize: :time)","
    Creates a routine that performs a multiplication of a 16-bit integer kh|kl * 8-bit signed m. Returns …\n"],["mul16_signed9","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul16_signed9","(kh=h, kl=l, m=b, tt:de, m_overflow:nil, optimize: :time)","
    Creates a routine that performs a multiplication of a 16-bit integer kh|kl * 9-bit signed CF|m. Returns …\n"],["mul8","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul8","(kh=h, kl=l, m=a, tt:de, clrhl:true, double:false, optimize: :time)","
    Creates a routine that performs a multiplication of a 16-bit integer kh|kl * 8bit unsigned m. Returns …\n"],["mul8_24","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul8_24","(kh=h, kl=l, m=b, t:c, tt:de, clrahl:true, k_int24: false, optimize: :time)","
    Creates a routine that performs a multiplication of a 16-bit unsigned integer kh|kl or 24-bit integer …\n"],["mul8_c","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul8_c","(kh=h, kl=l, m=a, tt:de, clrhl:true)","
    Creates a routine that performs a multiplication of an unsigned 16-bit integer kh|kl * 8-bit unsigned …\n"],["mul8_signed","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul8_signed","(kh=h, kl=l, m=c, tt:de, t:m, clrhl:true, double:false, optimize: :time)","
    Creates a routine that performs a multiplication of a 16-bit signed integer kh|kl * 8bit signed integer …\n"],["mul_const","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul_const","(k=d, m=0, tt:de, clrhl:true, signed_k:false)","
    Creates a routine that performs a multiplication of an 8-bit integer k * 8-bit unsigned m. Returns the …\n"],["mul_const8_24","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul_const8_24","(kh=h, kl=l, m=0, t:c, tt:de, clrahl:true, signed_k:false)","
    Creates a routine that performs a multiplication of an 16-bit integer kh|kl * 8-bit unsigned m. Returns …\n"],["mul_signed","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul_signed","(k=d, m=a, tt:de, clrhl:true, optimize: :time)","
    Creates a routine that performs a multiplication of a signed 8-bit k * 8-bit signed m.\n
    See Macros.mul …\n"],["mul_signed9","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul_signed9","(kh, kl, m=a, s:kh, tt:de, m_neg_cond:C, k_full_range:true, m_full_range:true, k_overflow:nil, m_is_zero_zf:false, optimize: :time)","
    Creates a routine that performs a multiplication of a signed 9-bit integer kh|kl * 9-bit signed integer …\n"],["mul_signed9_24","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-mul_signed9_24","(ks=c, kh=h, kl=l, m=b, tt:de, m_pos_cond:NC, m_full_range:true, optimize: :time, &restore_a)","
    Creates a routine that performs a multiplication of a 24-bit signed integer ks|kh|kl * 9-bit signed integer …\n"],["multitrack","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-multitrack","(name, &block)","
    Creates a multi-track with the given name as a symbol or a string.\n
    Give a block of code containing multi-track …\n"],["mute_sound","ZXUtils::AYMusicPlayer","ZXUtils/AYMusicPlayer.html#method-i-mute_sound","","
    Mutes sound.\n
    Modifies: af, bc.\n"],["n","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-n","(level)",""],["n0","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-n0","()",""],["n1","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-n1","()",""],["name=","Z80::Alloc","Z80/Alloc.html#method-i-name-3D","(value)",""],["name=","Z80::Label","Z80/Label.html#method-i-name-3D","(value)","
    Gives a name to a no-named label. Should not be used directly in programs.\n"],["names","Z80::Program::Condition","Z80/Program/Condition.html#method-c-names","()",""],["names","Z80::Program::Register","Z80/Program/Register.html#method-c-names","()",""],["ne","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-ne","(envelope_name)",""],["neg16","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-neg16","(sh, sl, th:sh, tl:sl)","
    Creates a routine that changes the sign of a twos complement 16-bit integer in sh|sl.\n
    sh — An 8-bit register …\n"],["neg_int","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-neg_int","(*regs, t:nil, t_is_zero:false, optimize_last:false)","
    Creates a routine that changes the sign of a twos complement integer held in any number of regs.\n
    Pass …\n"],["neg_sintable256_pi_half_no_zero_lo","Z80::Utils::SinCos::Macros","Z80/Utils/SinCos/Macros.html#method-i-neg_sintable256_pi_half_no_zero_lo","()","
    Returns an array of 63 bytes containing the first quarter sinus table, 256-based angle, negated, fractional …\n"],["neo","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-neo","()",""],["new","Z80::Alloc","Z80/Alloc.html#method-c-new","(lhs, oper=nil, rhs=nil, index=[])",""],["new","Z80::Label","Z80/Label.html#method-c-new","(addr, type = 1, reloc = nil, members = nil)","
    Creates an instance of a label. Do not use it directly in programs. Instead use Program.data, Program.label …\n"],["new","Z80::Program","Z80/Program.html#method-i-new","(start = 0x0000, *args, override:{})","
    Compiles a program at the start address passing *args to initialize(). Returns a compiled instance of …\n"],["new","Z80::Program::Condition","Z80/Program/Condition.html#method-c-new","(name, opc)",""],["new","Z80::Program::Register","Z80/Program/Register.html#method-c-new","(name, opc)",""],["new","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-c-new","(header, body)",""],["new","ZXLib::Basic::Line","ZXLib/Basic/Line.html#method-c-new","(line_no, body)",""],["new","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-c-new","(lines, vars = nil, start = nil)",""],["new","ZXLib::Basic::Tokenizer","ZXLib/Basic/Tokenizer.html#method-c-new","(text, line_index=0, line_offset=0)","
    Creates new instance of a Basic::Tokenizer.\n
    text must be an UTF-8 encoded, line_index and line_offset …\n"],["new","ZXLib::Basic::VariableParseError","ZXLib/Basic/VariableParseError.html#method-c-new","(msg=\"Not a variable\")",""],["new","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-c-new","(data='')","
    Creates an instance of Basic::Vars.\n
    Optionally provide VARS data as a binary string.\n"],["new","ZXUtils::MusicBox::Chord","ZXUtils/MusicBox/Chord.html#method-c-new","(*args)","
    Creates an instance of the Chord with the given tuples defining the chord.\n
    counter — For how many ticks …\n"],["new","ZXUtils::MusicBox::Envelope","ZXUtils/MusicBox/Envelope.html#method-c-new","(*args)","
    Creates an instance of the Envelope with the given tuples shaping the envelope.\n
    counter — How many ticks …\n"],["new","ZXUtils::MusicBox::Mask","ZXUtils/MusicBox/Mask.html#method-c-new","(*args)","
    Creates an instance of the Mask with the given tuples defining bits for the mask.\n
    counter — For how many …\n"],["new","ZXUtils::MusicBox::Multitrack","ZXUtils/MusicBox/Multitrack.html#method-c-new","(resolver)","
    Instances of the derived classes are being created internally by the MusicBox::Song compilation process. …\n"],["new","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-c-new","()","
    Creates and instance of the song.\n"],["new","ZXUtils::MusicBox::Track","ZXUtils/MusicBox/Track.html#method-c-new","(resolver)","
    Instances of the derived classes are being created internally by the MusicBox::Song compilation process. …\n"],["new_char_array","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_char_array","(name, dims, values=nil)","
    Creates a character array Basic::Variable.\n
    The strings are parsed by Vars.program_text_to_string only …\n"],["new_code","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-c-new_code","(name, code, org)","
    Creates a HeaderBody of the type TYPE_CODE.\n
    name should contain max 10 ascii characters.\n
    code should be …\n"],["new_for_loop","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_for_loop","(name, value, limit, step, line, statement)","
    Creates a FOR loop Basic::Variable.\n"],["new_kernel","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-c-new_kernel","(*args, **opts)","
    Instantiate Multitasking kernel with the proper code address.\n"],["new_kernel","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-c-new_kernel","(*args, **opts)","
    Instantiate MultitaskingIO kernel with the proper code address.\n"],["new_number","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_number","(name, num, simplified_int=true)","
    Creates a numeric Basic::Variable.\n"],["new_number_array","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_number_array","(name, dims, values=nil)","
    Creates a numeric array Basic::Variable.\n
    dims must be an array of dimension sizes provided as positive …\n"],["new_program","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-c-new_program","(name, code, line:nil, prog_length:nil)","
    Creates a HeaderBody of the type TYPE_PROGRAM.\n
    name should contain max 10 ascii characters.\n
    code should …\n"],["new_string","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_string","(name, string)","
    Creates a string Basic::Variable.\n
    The string is parsed by Vars.program_text_to_string only if encoded …\n"],["new_var_array","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-c-new_var_array","(name, code, head)","
    Creates a HeaderBody of the type TYPE_NUMBER_ARRAY or TYPE_CHAR_ARRAY.\n
    name should contain max 10 ascii …\n"],["next_token","ZXLib::Basic::Tokenizer","ZXLib/Basic/Tokenizer.html#method-i-next_token","()",""],["nextline","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-nextline","(ah, al, bcheck = true, scraddr:0x4000, hires:false, **nsopts, &block)","
    Creates a routine that advances to the next line (down) a screen address using ah|al registers. Optionally …\n"],["nextpixel","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-nextpixel","(al, s: a)","
    Creates a routine that changes a bit shift and the pixel address for a one pixel to the right.\n
    Modifies: …\n"],["nextrow","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-nextrow","(ah, al, bcheck = true, scraddr:0x4000, **nsopts, &block)","
    Creates a routine that advances to the next text row (down 8 pixels) a screen address using ah|al registers. …\n"],["noise","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-noise","(level)","
    Sets noise pitch level: 0 to 31.\n"],["noise_envelope_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-noise_envelope_off","()","
    Turns off, if any, an envelope applied to the noise pitch level.\n"],["noise_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-noise_off","()","
    Turns off the current channel's noise output.\n"],["noise_on","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-noise_on","()","
    Turns on the current channel's noise output.\n"],["normalize_quaternion","Z80Lib3D::Quaternion","Z80Lib3D/Quaternion.html#method-i-normalize_quaternion","(q)","
    Returns a normalized quaternion.\n"],["note_progress","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-note_progress","(period)","
    Enables the smooth tone frequency progression of the notes played on the current channel.\n
    period — A number …\n\n"],["np","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-np","(period)",""],["ns","Z80::Program","Z80/Program.html#method-i-ns","(name = nil, **opts)","
    Returns a relative label, as a namespace, holding labels defined by the code created with block as sub-labels. …\n"],["number?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-number-3F","()","
    true if variable is a number variable\n"],["number_array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-number_array-3F","()","
    true if variable is a number array\n"],["offset_of_","Z80::Label","Z80/Label.html#method-c-offset_of_","(name)","
    Returns a lazy evaluated, debug visible, byte offset of a struct member. Returns nil if self is not a …\n"],["one_of?","Z80::Program::Condition","Z80/Program/Condition.html#method-i-one_of-3F","(ary)",""],["one_of?","Z80::Program::Register","Z80/Program/Register.html#method-i-one_of-3F","(ary)",""],["only_one_bit_set_or_zero?","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-only_one_bit_set_or_zero-3F","(v)","
    Returns true if v is a 0 or a positive integer with only one bit set in its binary representation.\n"],["open_io","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-open_io","","
    ZX Basic API\n
    This endpoint should be invoked from the ZX Basic directly via USR or indirectly via FN. …\n"],["org","Z80::Program","Z80/Program.html#method-i-org","(address = pc, pad = 0, align: 1, offset: 0)","
    Returns an unnamed, relative label that points to the beginning of padded space. The space is being padded …\n"],["p","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-p","(length, *length_exts)",""],["p","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-p","(length, *length_exts)",""],["pack_number","ZXLib::Math","ZXLib/Math.html#method-c-pack_number","(num, simplified_int=true)","
    Converts num to a ZX-Spectrum's real number encoded as a 5-byte binary string.\n
    simplified_int indicates …\n"],["parse_each","ZXLib::Basic::Tokenizer","ZXLib/Basic/Tokenizer.html#method-i-parse_each","(&block)",""],["parse_file","Z80::TAP","Z80/TAP.html#method-c-parse_file","(filename, &block)","
    Returns an Enumerator of TAP::HeaderBody chunks representing segments of a TAP file. Optionally unwraps …\n"],["parse_file","Z80::TAP","Z80/TAP.html#method-c-parse_file","(filename, &block)","
    Returns an Enumerator of TAP::HeaderBody chunks representing segments of a TAP file. Optionally unwraps …\n"],["parse_source","ZXLib::Basic","ZXLib/Basic.html#method-c-parse_source","(source, start:nil)","
    Creates a Basic::Program from a BASIC program text.\n
    The source should be an UTF-8 encoded string.\n
    Each …\n"],["parse_source_line","ZXLib::Basic::Line","ZXLib/Basic/Line.html#method-c-parse_source_line","(line_text, last_line_no=0, line_index=0)","
    Creates a Basic::Line from a provided BASIC program text.\n
    See: Basic.parse_source\n"],["parse_tap","Z80::TAP","Z80/TAP.html#method-c-parse_tap","(tap, file='-', &block)","
    Returns an Enumerator of TAP::HeaderBody chunks representing segments of a TAP blob. Optionally unwraps …\n"],["parse_tap","Z80::TAP","Z80/TAP.html#method-c-parse_tap","(tap, file='-', &block)","
    Returns an Enumerator of TAP::HeaderBody chunks representing segments of a TAP blob. Optionally unwraps …\n"],["pause","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-pause","(length, *length_exts)","
    Pauses the current track execution for a length period. The length value should be a positive integer. …\n"],["pause","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-pause","(length, *length_exts)","
    Pauses tracks execution for a length period. The length value should be a positive integer.\n
    The number …\n"],["pc","Z80::Program","Z80/Program.html#method-i-pc","()","
    Returns the current byte offset from the beginning of the Program.code (a program counter relative to …\n"],["pch","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-pch","(*args)",""],["peek_token","ZXLib::Basic::Tokenizer","ZXLib/Basic/Tokenizer.html#method-i-peek_token","()",""],["play","ZXUtils::AYMusic","ZXUtils/AYMusic.html#method-i-play","","
    Call this routine, in turns, to play the music.\n
    NOTE — Stop interrupts (di) first before calling this routine. …\n\n"],["play","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-play","(note_name, octave, *pause_lengths)","
    To play notes on the use one of the commands:\n\n
    note_name  corresponding note\na          A\na!         A# ...\n
    \n"],["play_chord","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-play_chord","(*args)","
    Plays a chord. At least two different notes should be specified.\n"],["play_interval","ZXUtils::AYBasicPlayer","ZXUtils/AYBasicPlayer.html#method-i-play_interval","","
    Plays single music track tick. Call repeatedly on equal intervals to play music.\n
    Returns the current value …\n"],["play_loop","ZXUtils::AYBasicPlayer","ZXUtils/AYBasicPlayer.html#method-i-play_loop","","
    Plays music track in a loop until any key has been pressed.\n"],["plot_pixel","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-plot_pixel","(x, y, preshift, fx: :or, with_attributes:false, color_attr:ixl, color_mask:ixh, scraddr:0x4000)","
    Creates the plot pixel routine.\n
    x — The input register: horizontal-coordinate in the range [0, 255].\n\n
    y — The …\n"],["pointer?","Z80::Alloc","Z80/Alloc.html#method-i-pointer-3F","()",""],["pointer?","Z80::Label","Z80/Label.html#method-i-pointer-3F","()","
    Checks if label is a pointer. Prefer using Program.pointer? instead.\n"],["pointer?","Z80::Program","Z80/Program.html#method-i-pointer-3F","(arg)","
    A convenient method for macros to check if an argument is pointer-like.\n
    Returns true for:\n\n
    [foo], [:foo], ...
    \n"],["pointer?","Z80::Program::Register","Z80/Program/Register.html#method-i-pointer-3F","()",""],["prepare_args_draw_line_to","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-prepare_args_draw_line_to","()","
    Creates a routine that prepares arguments for the draw_line routine from two sets of coordinates.\n
    Registers …\n"],["preshifted_pixel_mask_data","ZXLib::Gfx::Draw::Macros","ZXLib/Gfx/Draw/Macros.html#method-i-preshifted_pixel_mask_data","(data_type)","
    Creates precalculated pixel mask data to be used with drawing routines.\n
    data_type:\n\n
    :pixel              ...\n
    \n"],["prevline","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-prevline","(ah, al, bcheck = true, scraddr:0x4000, hires:false, **nsopts, &block)","
    Creates a routine that moves up to the previous line a screen address using ah|al registers. Optionally …\n"],["prevpixel","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-prevpixel","(al, s: a)","
    Creates a routine that changes a bit shift and the pixel address for a one pixel to the left.\n
    Modifies: …\n"],["print_char","ZXUtils::BigFont","ZXUtils/BigFont.html#method-i-print_char","","
    ZX Spectrum's ROM compatible CHAN output routine\n
    The a register should have the output character code …\n"],["print_char_hires","ZXUtils::BigFontHires","ZXUtils/BigFontHires.html#method-i-print_char_hires","","
    ZX Spectrum's ROM compatible CHAN output routine, for hi-res mode.\n
    The a register should have the …\n"],["print_fp_hl","ZXLib::Math","ZXLib/Math.html#method-i-print_fp_hl","","
    Call print_fp_hl with hl pointing to the 1st byte of a ZXReal number to print that number to the currently …\n"],["program?","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-program-3F","()","
    true if this chunk represents a basic program\n"],["program_text_to_string","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-c-program_text_to_string","(text)","
    Converts a UTF-8 text string to a binary string encoded in a form suitable for ZX-Spectrum's Basic …\n"],["quaternion2matrix","Z80Lib3D::Quaternion","Z80Lib3D/Quaternion.html#method-i-quaternion2matrix","(q)","
    Returns a transformation matrix from a quaternion.\n"],["quaternion_cross_product","Z80Lib3D::Quaternion","Z80Lib3D/Quaternion.html#method-i-quaternion_cross_product","(a, b)","
    Returns a quaternion as a cross product of quaternions a and b.\n"],["quaternion_norm","Z80Lib3D::Quaternion","Z80Lib3D/Quaternion.html#method-i-quaternion_norm","(q)","
    Returns a quaternion norm.\n"],["quaternion_norm_q","Z80Lib3D::Quaternion","Z80Lib3D/Quaternion.html#method-i-quaternion_norm_q","(q)","
    Returns a quaternion square norm.\n"],["quicksort_bytes","Z80::Utils::Sort::Macros","Z80/Utils/Sort/Macros.html#method-i-quicksort_bytes","(select_pivot=:half, reverse: false, safe_args: true, pivot_reg: c, swap_same: true, &swap_items)","
    Creates a subroutine that sorts an array of bytes using quicksort algorithm.\n\n
    algorithm qsort(A, first, ...
    \n"],["rctoattr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-rctoattr","(row, col=0, ah:h, al:l, scraddr:0x4000)","
    Creates a routine that converts row and column coordinates to an address of a color attribute.\n
    Modifies: …\n"],["rctoscr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-rctoscr","(row, col=0, ah:h, al:l, scraddr:0x4000)","
    Creates a routine that converts row and column coordinates to a byte address of a top 8-pixel line.\n
    Modifies: …\n"],["rdoc_mark_find_def_fn_arg","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-rdoc_mark_find_def_fn_arg","","
    Looks for a first DEF FN argument value address.\n
    NOTE — This routine must never be called from a task!\n\n
    If …\n"],["read_arg_string","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-read_arg_string","(adh=d, adl=e, lenh=b, lenl=c)","
    Reads a string address and its length from a ZX Basic's stringish FP-value.\n
    hl — must point to the 1st …\n"],["read_chunk","Z80::TAP","Z80/TAP.html#method-c-read_chunk","(filename, name:nil, index:nil)","
    Reads a TAP::HeaderBody chunk from a TAP file.\n
    Pass additional :name argument to search for the header …\n"],["read_chunk","Z80::TAP","Z80/TAP.html#method-c-read_chunk","(filename, name:nil, index:nil)","
    Reads a TAP::HeaderBody chunk from a TAP file.\n
    Pass additional :name argument to search for the header …\n"],["read_data","Z80::TAP","Z80/TAP.html#method-c-read_data","(filename, **opts)","
    Reads a data chunk from a TAP file. Returns a binary string.\n
    Program.import_file uses this method to read …\n"],["read_data","Z80::TAP","Z80/TAP.html#method-c-read_data","(filename, **opts)","
    Reads a data chunk from a TAP file. Returns a binary string.\n
    Program.import_file uses this method to read …\n"],["read_integer32_value","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-read_integer32_value","(t3=d, t2=e, t1=b, t0=c)","
    Reads a 32-bit integer from a ZX Basic's FP-value.\n
    Requires: macro_import ::ZXLib::Math.\n
    hl — must point …\n"],["read_integer_value","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-read_integer_value","(th=d, tl=e, sgn=c, normal_negative:false, t:a)","
    Reads a signed integer from a ZX Basic's FP-value.\n
    hl — must point to the 1st byte of the FP-value. …\n"],["read_positive_int_value","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-read_positive_int_value","(th=d, tl=e)","
    Reads a positive integer from a ZX Basic's FP-value.\n
    hl — must point to the 1st byte of the FP-value. …\n"],["read_source","ZXLib::Basic","ZXLib/Basic.html#method-c-read_source","(filename, **opts)","
    Creates a Basic::Program from a BASIC text file.\n
    See parse_source for details.\n"],["read_tap","ZXLib::Basic","ZXLib/Basic.html#method-c-read_tap","(filename, **opts)","
    Creates a Basic::Program or a Basic::Variable from a TAP file.\n
    See Z80::TAP.read_chunk for arguments description. …\n"],["register?","Z80::Program","Z80/Program.html#method-i-register-3F","(arg)","
    A convenient method for macros to check if an argument is a Register.\n
    Returns true for:\n\n
    hl, a, [hl], [iy ...
    \n"],["reinitialize","Z80::Alloc","Z80/Alloc.html#method-i-reinitialize","(address, type = 1, reloc = nil, members = nil)",""],["repeat","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-repeat","(times=nil, mark:nil, &block)","
    Repeats the execution of the commands in the given block repeat times. If repeat is nil or missing repeats …\n"],["repeat","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-repeat","(times=nil, mark:nil, &block)","
    Repeats the execution of the commands in the given block repeat times. If repeat is nil or missing repeats …\n"],["report_error","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-report_error","(error)","
    Returns to ZX Basic with the error report.\n
    error — Error report signature as a number 0..9 or a letter  …\n\n\n"],["report_error_unless","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-report_error_unless","(condition, error)","
    Returns to ZX Basic with the error report if condition is NOT met.\n
    condition — NZ, Z, NC, C, PO, PE, P, …\n\n"],["respond_to_missing?","Z80::Alloc","Z80/Alloc.html#method-i-respond_to_missing-3F","(m, include_private=false)",""],["restore_rom_interrupt_handler","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-restore_rom_interrupt_handler","(enable_intr:true)","
    Restore interrupt handler ZX Spectrum ROM's standard IM1 mode.\n
    enable_intr — If true invoke ei instruction …\n\n\n"],["return_with_fp","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-return_with_fp","(pop_ret_address:true, rom:self.rom, restore_iy:self.vars_iy, restore_hl_alt:rom.end_calc)","
    Creates a routine that returns to the calling ZX-Basic's USR function an FP value.\n
    When returning …\n"],["rnd","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-rnd","()","
    Creates a Lehmer random number generator routine.\n
    See: en.wikipedia.org/wiki/Lehmer_random_number_generator …\n"],["rotor_quaternion","Z80Lib3D::Quaternion","Z80Lib3D/Quaternion.html#method-i-rotor_quaternion","(rad, av)","
    Returns a rotor quaternion from radians and a unit vector.\n"],["rpt","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-rpt","(times=nil, mark:nil, &block)",""],["rpt","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-rpt","(times=nil, mark:nil, &block)",""],["run","ZXUtils::Emu","ZXUtils/Emu.html#method-c-run","(file, *args)","
    Runs a ZX Spectrum emulator program with the given file as its argument.\n
    Provides additional args to the …\n"],["save_tap","Z80::TAP","Z80/TAP.html#method-i-save_tap","(filename, append:false, name:nil, **opts)","
    Saves self in a TAP file.\n
    The tap data is being generated by #to_tap_chunk.\n
    filename specifies the file …\n"],["save_tap","Z80::TAP","Z80/TAP.html#method-i-save_tap","(filename, append:false, name:nil, **opts)","
    Saves self in a TAP file.\n
    The tap data is being generated by #to_tap_chunk.\n
    filename specifies the file …\n"],["save_tap","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-save_tap","(filename, append:false)","
    Saves this chunk as a TAP file.\n
    filename specifies the file name to save to. The “.tap” extension …\n"],["scale","Z80Lib3D::Primitives::Vertex","Z80Lib3D/Primitives/Vertex.html#method-c-scale","(sc, vertex, scrx0:128, scry0:128, scrz0:128, persp_dshift:7)","
    Creates a re-scaled Vertex data arguments.\n"],["screen?","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-screen-3F","()","
    true if this chunk represents a screen data\n"],["scrtoattr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-scrtoattr","(s, o:s, scraddr:0x4000)","
    Creates a routine that converts a high byte of a pixel address to a high byte of an address of a relevant …\n"],["select","Z80::Program","Z80/Program.html#method-i-select","(*args, &test)","
    Creates a conditional block that creates alternative code based on the lazy evaluated boolean condition. …\n"],["selection_sort_bytes_max256","Z80::Utils::Sort::Macros","Z80/Utils/Sort/Macros.html#method-i-selection_sort_bytes_max256","(reverse:false, target:hl, length:b, subroutine:false, &swap_items)","
    Creates a routine that sorts an array of bytes using selection sort.\n\n
    i ← length(A) - 1\nwhile i > 0\n   ...
    \n"],["set_empty_instrument","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-set_empty_instrument","()","
    Turns off any instrument previously set up with TrackCommands.set_instrument on the current channel. …\n"],["set_instrument","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-set_instrument","(instrument_name)","
    Sets an instrument for the current channel.\n
    instrument_name — A symbol or string with the instrument name …\n\n"],["setup","ZXUtils::AYMusicPlayer","ZXUtils/AYMusicPlayer.html#method-i-setup","","
    Sets up the player.\n
    Call this ONCE the player code has been loaded to create required tables for the music …\n"],["setup_custom_interrupt_handler","ZXLib::Sys::Macros","ZXLib/Sys/Macros.html#method-i-setup_custom_interrupt_handler","(handler, enable_intr:true, vector_page:0x3B)","
    Creates a routine that sets up custom interrupt handler using ZX Spectrum ROM's unused space as a …\n"],["shuffle_bytes_source_max256","Z80::Utils::Shuffle::Macros","Z80/Utils/Shuffle/Macros.html#method-i-shuffle_bytes_source_max256","(next_rng=nil, target:hl, length:a, source:nil, &next_rng_blk)","
    Creates a routine to shuffle an array of bytes.\n
    After the shuffle is performed hl points to the memory …\n"],["sign_extend","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-sign_extend","(t=a, s=a)","
    Creates a routine that extends a sign bit from an octet indicated by tl into a th.\n
    t — A target 8-bit register …\n"],["sincos_from_angle","Z80::Utils::SinCos::Macros","Z80/Utils/SinCos/Macros.html#method-i-sincos_from_angle","(sincos, th=h, tl=l, mask:nil)","
    Creates code that returns an address of SinCos entry for a given 256-based angle in the register a.\n
    For …\n"],["sincos_table_descriptors","Z80::Utils::SinCos::Macros","Z80/Utils/SinCos/Macros.html#method-i-sincos_table_descriptors","()","
    Returns a SinCosTable descriptors.\n
    Example:\n\n
    sincos data SinCosTable, sincos_table_descriptors\n
    \n"],["size","Z80::Program::Register","Z80/Program/Register.html#method-i-size","()",""],["sll8_16","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-sll8_16","(bshift, th=h, tl=l)","
    Shift logical left 8-bit register with a result extended to 16-bits.\n
    bshift — How many bits to shift the …\n"],["spawn","ZXUtils::Emu","ZXUtils/Emu.html#method-c-spawn","(file, *args)","
    Spawns a ZX Spectrum emulator program with the given file as its argument.\n
    Provides additional args to …\n"],["split","Z80::Program::Register","Z80/Program/Register.html#method-i-split","()","
    Disjoins one of 16 bit registers: bc de hl ix or iy to array of 8bit registers: [hi, lo].\n
    Useful when …\n"],["stack_space_free","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-stack_space_free","","
    Returns (in bc) how many bytes are available in multitasking stack space for new tasks. Reports an OOM …\n"],["start","ZXUtils::Benchmark","ZXUtils/Benchmark.html#method-i-start","","
    A benchmark start entry for the machine-language.\n
    Provide a routine and a counter address in the memory …\n"],["start","ZXUtils::Gallery","ZXUtils/Gallery.html#method-i-start","","
    Gallery API.\n
    This endpoint should be invoked from the ZX Basic directly via USR or indirectly via FN. …\n"],["start_chord","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-start_chord","(chord_name)","
    Applies a chord defined by SongCommands.chord to the currently played note at the current channel.\n"],["start_noise_envelope","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-start_noise_envelope","(envelope_name)","
    Applies an envelope defined by SongCommands.envelope to the noise pitch level.\n"],["start_volume_envelope","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-start_volume_envelope","(envelope_name)","
    Applies an envelope defined by SongCommands.envelope to the volume level at the current channel.\n"],["statement","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-statement","()","
    Returns the FOR loop execute statement number.\n"],["step","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-step","()","
    Returns the FOR loop step value.\n"],["string?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-string-3F","()","
    true if variable is a string variable\n"],["string_to_program_text","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-c-string_to_program_text","(data, ascii_only:false, se:false)","
    Converts a ZX-Spectrum's string variable data to a source UTF-8 text with special and control characters …\n"],["sub","ZXUtils::MusicBox::InstrumentCommands","ZXUtils/MusicBox/InstrumentCommands.html#method-i-sub","(instrument_name)",""],["sub","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-sub","(multitrack_name)",""],["sub","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-sub","(track_name)",""],["sub_from","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-sub_from","(s, th, tl)","
    Creates a routine that subtracts an 8-bit s register value from a 16-bit th|tl register pair.\n
    s — A subtractor …\n"],["sub_instrument","ZXUtils::MusicBox::InstrumentCommands","ZXUtils/MusicBox/InstrumentCommands.html#method-i-sub_instrument","(instrument_name)","
    Yields execution of the instrument to another with the given instrument_name as a symbol or string.  …\n"],["sub_track","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-sub_track","(multitrack_name)","
    Yields execution of the tracks to another multi-track with the given multitrack_name as a symbol or a …\n"],["sub_track","ZXUtils::MusicBox::TrackCommands","ZXUtils/MusicBox/TrackCommands.html#method-i-sub_track","(track_name)","
    Yields execution of the track to another sub-track with the given track_name as a symbol or string.  …\n"],["sublabel?","Z80::Alloc","Z80/Alloc.html#method-i-sublabel-3F","()",""],["sublabel?","Z80::Label","Z80/Label.html#method-i-sublabel-3F","()","
    Checks if a label is a member of a struct or a stand-alone label.\n"],["sublabel_access_expression?","Z80::Alloc","Z80/Alloc.html#method-i-sublabel_access_expression-3F","()",""],["sublabel_access_expression?","Z80::Label","Z80/Label.html#method-i-sublabel_access_expression-3F","()","
    Checks if a label is a named sub-label access expression.\n"],["synchronize_channels","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-synchronize_channels","(a:nil, b:nil, c:nil)","
    Specify ranges of allowed ticks for each channel's track synchronization. If the given track is behind …\n"],["t0","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-t0","()",""],["t1","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-t1","()",""],["task?","ZXUtils::Multitasking::Macros","ZXUtils/Multitasking/Macros.html#method-i-task-3F","(tt:hl, mtvars:self.mtvars)","
    Checks if the code is being run as a task. ZF flag will be set (Z) if not a task.\n
    tt — A temporary 16bit …\n\n"],["task_id","ZXUtils::Multitasking::Macros","ZXUtils/Multitasking/Macros.html#method-i-task_id","(oh, ol, tt:hl, check_if_system:false, disable_intr:true, enable_intr:true, mtvars:self.mtvars)","
    Retrieves current task's id.\n
    oh, ol — MSB and LSB 8-bit registers for output. Together oh|ol form a …\n\n"],["task_stack_bytes_free","ZXUtils::Multitasking::Macros","ZXUtils/Multitasking/Macros.html#method-i-task_stack_bytes_free","(tt:hl, positive_size:true, disable_intr:true, enable_intr:true, mtvars:self.mtvars)","
    Calculates how many bytes are available yet on the task's stack below SP.\n
    tt — Temporary 16bit register, …\n\n"],["task_yield","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-task_yield","","
    Yields task execution.\n
    Tasks or system programs should call this endpoint instead of invoking halt. This …\n"],["tempo","ZXUtils::MusicBox::TrackConfigCommands","ZXUtils/MusicBox/TrackConfigCommands.html#method-i-tempo","(ticks=nil)","
    Gets or alters the tempo ticks.\n
    The ticks value is being used as a base for the notes/pause duration. …\n"],["terminate","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-terminate","","
    Terminates the current task.\n
    Tasks may jump to this endpoint directly to terminate themselves. If called …\n"],["terminated?","ZXLib::Basic::Tokenizer","ZXLib/Basic/Tokenizer.html#method-i-terminated-3F","()",""],["text","ZXLib::Basic::Line","ZXLib/Basic/Line.html#method-i-text","(escape_keywords:false, ascii_only:false, se:false)","
    Creates a textual representation of this line except its number. Returns an UTF-8 encoded string.\n
    See: …\n"],["then","Z80::ConditionalBlock","Z80/ConditionalBlock.html#method-i-then","(&block)","
    Evaluates a block in an anonymous namespace if the condition evaluates to true. Returns an instance of …\n"],["ticks_counter","ZXUtils::MusicBox::Track","ZXUtils/MusicBox/Track.html#method-i-ticks_counter","(counter=0)","
    Adds a track's tick counter value to the given counter and returns it.\n"],["to_a","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-to_a","()","
    Returns an array of every Basic::Variable found in self.\n"],["to_aliased_name","Z80::Alloc","Z80/Alloc.html#method-i-to_aliased_name","(start)",""],["to_aliased_name","Z80::Label","Z80/Label.html#method-i-to_aliased_name","(start)","
    Returns an abbreviated string information about a label for aliased targets.\n"],["to_alloc","Z80::Alloc","Z80/Alloc.html#method-i-to_alloc","()",""],["to_alloc","Z80::Label","Z80/Label.html#method-i-to_alloc","()","
    Returns a lazy evaluated label as an instance of Alloc class. Use one of the lazy operators directly …\n"],["to_data","Z80::Label","Z80/Label.html#method-c-to_data","(prog, offset, data)","
    Used by Program.data. Do not use it directly in programs. data must be a Hash, Struct, Array, String …\n"],["to_debug","Z80::Program::Register","Z80/Program/Register.html#method-i-to_debug","()",""],["to_fixed16_8","Float","Float.html#method-i-to_fixed16_8","()","
    Converts a float to a 16-bit fixed point twos complement number formatted: iiiiiiiiffffffff where i represents …\n"],["to_i","Z80::Alloc","Z80/Alloc.html#method-i-to_i","(start = 0, rel_to = nil, override:nil, prefix:''.freeze, size_of:false)","
    rel_to: an absolute address or :self used by ix/iy offset addressing\n"],["to_i","Z80::Label","Z80/Label.html#method-c-to_i","()","
    Returns a size of a data structure immediately.\n"],["to_i","Z80::Label","Z80/Label.html#method-i-to_i","(start = 0, rel_to = nil, override:nil, prefix:''.freeze, size_of:false)","
    Evaluates a label. This method is being used during program compilation.\n
    start — An absolute address to …\n\n"],["to_i","Z80::Program::Condition","Z80/Program/Condition.html#method-i-to_i","()",""],["to_i","Z80::Program::Register","Z80/Program/Register.html#method-i-to_i","()",""],["to_label","Symbol","Symbol.html#method-i-to_label","(program)","
    Allows to use Symbols instead of labels in some situations. Example:\n\n
    loop1 add [hl]\n      inc hl\n     ...
    \n"],["to_label","Z80::Alloc","Z80/Alloc.html#method-i-to_label","(_)",""],["to_label","Z80::Label","Z80/Label.html#method-i-to_label","(_)","
    Should return a Label or an Alloc. This method's existence indicates that something quacks like a …\n"],["to_module","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-to_module","()","
    Returns an instance of the SongModule from the compiled Song instance.\n"],["to_name","Z80::Alloc","Z80/Alloc.html#method-i-to_name","(info=false)",""],["to_name","Z80::Label","Z80/Label.html#method-i-to_name","(info=false)","
    Returns this label's name as string or nil.\n
    info enables returning made up name if this label is anonymous. …\n"],["to_player_module","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-to_player_module","()","
    Returns an instance of the PlayerModule from the compiled Song instance.\n"],["to_player_module","ZXUtils::MusicBox::Song::SongModule","ZXUtils/MusicBox/Song/SongModule.html#method-i-to_player_module","()","
    Returns an instance of the PlayerModule from the compiled SongModule instance.\n"],["to_program","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-to_program","()","
    Returns an ad-hoc Z80::Program class containing the compiled Song. See SongModule.to_program.\n"],["to_program","ZXUtils::MusicBox::Song::SongModule","ZXUtils/MusicBox/Song/SongModule.html#method-i-to_program","()","
    Returns an ad-hoc Z80::Program class containing the compiled SongModule.\n
    The returned program exports …\n"],["to_s","Z80::Alloc","Z80/Alloc.html#method-i-to_s","()",""],["to_s","Z80::Label","Z80/Label.html#method-i-to_s","()",""],["to_s","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-to_s","()","
    For humans.\n"],["to_s","ZXLib::Basic::Line","ZXLib/Basic/Line.html#method-i-to_s","(**opts)","
    Creates a textual representation of this line with the line number. Returns an UTF-8 encoded string. …\n"],["to_s","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-to_s","(escape_keywords:false, ascii_only:false, se:false)",""],["to_s","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-to_s","()","
    Returns this variable in a BASIC-like text format.\n"],["to_s","ZXLib::Basic::Vars","ZXLib/Basic/Vars.html#method-i-to_s","()","
    Returns all variables in a BASIC-like text format.\n"],["to_source","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-to_source","(escape_keywords:false, ascii_only:false, se:false)","
    Creates the textual representation of a ZX Basic::Program.\n
    Returns an UTF-8 encoded string.\n
    The conversion …\n"],["to_str","Z80::Alloc","Z80/Alloc.html#method-i-to_str","()",""],["to_str","Z80::Label","Z80/Label.html#method-i-to_str","()","
    Returns an abbreviated string information about a label, mostly used in error messages.\n"],["to_struct","Z80::Label","Z80/Label.html#method-c-to_struct","()","
    Returns a new Ruby Struct from members defined in a data structure.\n
    Instances of such a Struct are suitable …\n"],["to_tap","Z80::TAP","Z80/TAP.html#method-i-to_tap","(name, **opts)","
    Produces a TAP blob as a binary string from self.\n
    A sugar for calling TAP::HeaderBody#to_tap method on …\n"],["to_tap","Z80::TAP","Z80/TAP.html#method-i-to_tap","(name, **opts)","
    Produces a TAP blob as a binary string from self.\n
    A sugar for calling TAP::HeaderBody#to_tap method on …\n"],["to_tap","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-to_tap","()","
    Produces a TAP blob as a binary string from this chunk.\n"],["to_tap_chunk","Z80::TAP","Z80/TAP.html#method-i-to_tap_chunk","(name, org:nil)","
    Creates a TAP::HeaderBody chunk from self.\n
    By default it uses Z80#code and the Z80#org to produce the …\n"],["to_tap_chunk","Z80::TAP","Z80/TAP.html#method-i-to_tap_chunk","(name, org:nil)","
    Creates a TAP::HeaderBody chunk from self.\n
    By default it uses Z80#code and the Z80#org to produce the …\n"],["to_tap_chunk","ZXLib::Basic::Program","ZXLib/Basic/Program.html#method-i-to_tap_chunk","(name, line:nil)","
    Creates a Z80::TAP::HeaderBody instance from Basic::Program#code.\n
    This method is provided for the included …\n"],["to_tap_chunk","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-to_tap_chunk","(name, org:nil)","
    Creates a Z80::TAP::HeaderBody instance from Basic::Variable.\n
    This method is provided for the included …\n"],["to_z80bin","Float","Float.html#method-i-to_z80bin","(simplified_int=true)","
    Converts Float to a ZX-Spectrum's real number encoded as a 5-byte binary string.\n
    Suitable to be used …\n"],["tone_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-tone_off","()","
    Turns off the current channel's tone output.\n"],["tone_on","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-tone_on","()","
    Turns on the current channel's tone output.\n"],["tone_progress","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-tone_progress","(delta, counter)","
    Enables and controls the tone frequency progression of the current channel's tone.\n
    delta — A floating …\n"],["tp","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-tp","(delta, counter)",""],["track","ZXUtils::MusicBox::SongCommands","ZXUtils/MusicBox/SongCommands.html#method-i-track","(name, &block)","
    Creates a track with the given name as a symbol or a string.\n
    Give a block of code containing track commands. …\n"],["twos_complement16_by_sgn","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-twos_complement16_by_sgn","(sh, sl, sgn, th:sh, tl:sl, t:sgn)","
    Creates a routine that changes the sign of a twos complement 16-bit integer depending on the content …\n"],["union","Z80::Program","Z80/Program.html#method-i-union","(label, type, align: nil, offset: 0)","
    Returns a new, unnamed label addressed by label, but of different type. type can be an integer or a data …\n"],["unknown","ZXUtils::Multitasking","ZXUtils/Multitasking.html#method-i-unknown","","
    Attempts to read a positive 16-bit integer from a FP-value addressed by hl.\n
    NOTE — This routine must never …\n\n"],["unpack_number","ZXLib::Math","ZXLib/Math.html#method-c-unpack_number","(bin, simplified_int_as_fixnum=true)","
    Converts a ZX-Spectrum's real number as a 5-byte binary string to Numeric value.\n
    simplified_int_as_fixnum …\n"],["unused_item_names","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-unused_item_names","()","
    Returns a hash with unused item names in each of the item category.\n"],["unwrap_pointer","Z80::Program","Z80/Program.html#method-i-unwrap_pointer","(arg)","
    Returns a normalized pointer label, Register or an integer. Otherwise pass-through.\n
    Convenient method …\n"],["utobcd","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-utobcd","(bufend, input=de, size: 4, r: d, rr: de, byteorder: :lsb, input_end:false)","
    Creates a routine that converts an unsigned binary integer of an arbitrary size to a BCD string.\n
    bufend … — "],["utobcd_step","Z80::MathInt::Macros","Z80/MathInt/Macros.html#method-i-utobcd_step","(bufend, r, buflen=1, t=c, r_in_a=false)","
    Creates a routine that converts an 8-bit unsigned integer to a BCD string.\n
    Used by Macros.utobcd.\n
    bufend … — "],["v","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-v","(level)",""],["va","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-va","(amplitude=1.0)",""],["validate_recursion_depth!","ZXUtils::MusicBox::Song","ZXUtils/MusicBox/Song.html#method-i-validate_recursion_depth-21","(track_stack_depth=20)","
    Checks if maximal recursion depth of tracks and instruments is not exceeding the given threshold.\n
    Provide …\n"],["value","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-value","()","
    Returns a value of a variable.\n
    A Float or an Integer for numbers (including FOR loops).\n
    A (possibly nested) …\n"],["variable_volume","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-variable_volume","()",""],["ve","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-ve","(envelope_name)",""],["vec_deque_clear","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_clear","(vec_deque, vec_deque_bot:)","
    Creates a routine that initializes or clears the queue.\n
    vec_deque — A label of a type VecDequeState addressing …\n\n"],["vec_deque_empty?","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_empty-3F","(vec_deque, branch_not_empty: nil, branch_relative: true, tt: de)","
    Creates a routine that checks if the queue is empty.\n
    In case branch_not_full is nil the Z flag, if set, …\n"],["vec_deque_full?","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_full-3F","(vec_deque, branch_not_full: nil, branch_relative: true, tt: de)","
    Creates a routine that checks if the queue is full.\n
    In case branch_not_full is nil the Z flag, if set, …\n"],["vec_deque_length","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_length","(vec_deque, vec_deque_bot:, vec_deque_top:, tt: de, subroutine: false)","
    Creates a routine that calculates the current length of the queue.\n
    The length is made available as a 16-bit …\n"],["vec_deque_next_back","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_next_back","(vec_deque=nil, vec_deque_bot:, vec_deque_top:, cursor: de, subroutine: false)","
    Creates a routine that reads a byte element from the back of the queue advancing the cursor backwards. …\n"],["vec_deque_next_front","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_next_front","(vec_deque=nil, vec_deque_bot:, vec_deque_top:, cursor: de, subroutine: false)","
    Creates a routine that reads a byte element from the front of the queue advancing the cursor forward. …\n"],["vec_deque_pop_back","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_pop_back","(vec_deque, vec_deque_bot:, vec_deque_top:, branch_on_empty: nil, branch_relative: true, tt: de)","
    Creates a routine that removes a byte element from the back of the queue.\n
    The removed element is provided …\n"],["vec_deque_pop_front","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_pop_front","(vec_deque, vec_deque_bot:, vec_deque_top:, branch_on_empty: nil, branch_relative: true, tt: de)","
    Creates a routine that removes a byte element from the front of the queue.\n
    The removed element is provided …\n"],["vec_deque_push_back","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_push_back","(vec_deque, vec_deque_bot:, vec_deque_top:, branch_on_full: nil, branch_relative: true, tt: de)","
    Creates a routine that appends a byte element to the back of the queue.\n
    accumulator — Should hold a value …\n"],["vec_deque_push_front","Z80::Utils::VecDeque::Macros","Z80/Utils/VecDeque/Macros.html#method-i-vec_deque_push_front","(vec_deque, vec_deque_bot:, vec_deque_top:, branch_on_full: nil, branch_relative: true, tt: de)","
    Creates a routine that appends a byte element to the front of the queue.\n
    accumulator — Should hold a value …\n"],["veo","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-veo","()",""],["vg","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vg","(angle=0.0)",""],["vibrato_amplitude","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vibrato_amplitude","(amplitude=1.0)","
    Enables the current channel's tone vibrato and sets the distortion amplitude.\n
    amplitude — A positive …\n\n"],["vibrato_angle","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vibrato_angle","(angle=0.0)","
    Enables the current channel's tone vibrato and sets the current phase angle.\n
    angle — A positive floating …\n\n"],["vibrato_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vibrato_off","()","
    Turns off, if any, the current channel's tone vibrato distortion.\n"],["vibrato_step","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vibrato_step","(step=1.0)","
    Enables the current channel's tone vibrato and sets the distortion angle progression step.\n
    step — A …\n\n"],["vo","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vo","()",""],["volume","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-volume","(level)","
    Sets volume level for the current channel: 0 to 15.\n"],["volume_envelope_off","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-volume_envelope_off","()","
    Turns off, if any, an envelope applied to the volume level at the current channel.\n"],["vs","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vs","(step=1.0)",""],["vv","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-vv","()",""],["w","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-w","(ticks)",""],["w","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-w","(ticks)",""],["wait","ZXUtils::MusicBox::CommonInstrumentCommands","ZXUtils/MusicBox/CommonInstrumentCommands.html#method-i-wait","(ticks)","
    Pauses the current track execution for ticks number of ticks. The ticks value should be a positive integer …\n"],["wait","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-wait","(ticks)","
    Pauses tracks execution for ticks number of ticks. The ticks value should be a positive integer as an …\n"],["wait_io","ZXUtils::MultitaskingIO","ZXUtils/MultitaskingIO.html#method-i-wait_io","","
    ZX Basic API\n
    This endpoint should be invoked from the ZX Basic indirectly via FN.\n\n
    2 DEF FN w(s,n)=USR wait_io: ...
    \n"],["widen_pixels8_16","ZXUtils::BigFont::Macros","ZXUtils/BigFont/Macros.html#method-i-widen_pixels8_16","(f1, f2, unroll:true)","
    Each bit of the a register is duplicated and placed in the f1 and f2 registers.\n
    Modifies: af, f1 and  …\n"],["with_saved","Z80::Program::Macros","Z80/Program/Macros.html#method-i-with_saved","(*registers, **opts, &block)","
    Adds a code that pushes specified registers on a machine stack, code from block within a namespace and …\n"],["word","Z80::Label","Z80/Label.html#method-c-word","(size = 1)","
    A data structure's field type.\n"],["words","Z80::Program","Z80/Program.html#method-i-words","(*args)","
    Returns an unnamed label and allocates count words with Program.data. Optionally you can provide values …\n"],["xy_to_attr_addr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-xy_to_attr_addr","(x, y, scraddr:0x4000)","
    Calculates a constant screen attribute address from the pixel coordinates.\n"],["xy_to_pixel_addr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-xy_to_pixel_addr","(x, y, scraddr:0x4000)","
    Calculates a constant screen pixel byte address from the pixel coordinates.\n"],["xytoscr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-xytoscr","(y, x, ah:h, al:l, s:b, t:c, scraddr:0x4000)",""],["ytoattr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-ytoattr","(y, ah:h, al:l, col:0, scraddr:0x4000)","
    Creates a routine that converts a vertical pixel coordinate to an address of a color attribute.\n
    Modifies: …\n"],["ytoscr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-ytoscr","(y, ah:h, al:l, col:nil, t:c, scraddr:0x4000, hires:false)","
    Creates a routine that converts a vertical pixel coordinate to a screen byte address.\n
    Modifies: af, ah …\n"],["yxtoscr","ZXLib::Gfx::Macros","ZXLib/Gfx/Macros.html#method-i-yxtoscr","(y, x, ah:h, al:l, s:b, t:c, scraddr:0x4000)","
    Creates a routine that converts y,x coordinates to a screen byte address and a bits shift.\n
    Modifies:  …\n"],["|","Z80::Alloc","Z80/Alloc.html#method-i-7C","(other)",""],["|","Z80::Label","Z80/Label.html#method-i-7C","(m)","
    Returns a lazy evaluated bitwise “or” of a label and an other label or an integer.\n"],["|","Z80::Program::Register","Z80/Program/Register.html#method-i-7C","(other)","
    Adjoins two 8 bit registers to form one 16 bit register.\n
    Useful when defining macros that may use registers …\n"],["~","Z80::Alloc","Z80/Alloc.html#method-i-~","()",""],["~","Z80::Label","Z80/Label.html#method-i-~","()","
    Returns a lazy evaluated bitwise negated label.\n"],["CHANGELOG","","CHANGELOG_md.html","","
    v1.1.1.pre-2\n
    Z80:\n
    New macro Z80::MathInt::Macros#mul8_signed.\n"],["LICENSE","","LICENSE_md.html","","
    The Parity Public License 7.0.0\n
    Contributor: Rafał Michalski\n
    Source Code: github.com/royaltm/z80-rb\n"],["README","","README_rdoc.html","","
    ruby-Z80\n
    Documentation.\n
    Source repository.\n"]]}}
\ No newline at end of file
diff --git a/js/search_index.js.gz b/js/search_index.js.gz
index 080a5a13659ed986a9381f9fd971b200cfb69ffd..9a82c806a3d5fb9a0072c1c237ded7fb023a4579 100644
GIT binary patch
delta 38105
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
J7&2%T0{{p2-Pr&D

delta 36729
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

diff --git a/table_of_contents.html b/table_of_contents.html
index c4fd41f..d2ab0a5 100644
--- a/table_of_contents.html
+++ b/table_of_contents.html
@@ -43,6 +43,8 @@ 
    Pages
    
 
       
  • ZXLib:
 
+      
  • Z80Lib3D:
+
       
  • v1.1.0
 
       
  • Z80:
@@ -442,6 +444,104 @@ 
    Classes and Modules
    
 
   
    • 
 
+  
  • 
+    Z80Lib3D
+
+  
    • 
+
+  
  • 
+    Z80Lib3D::Matrix3D
+
+    
+
+  
    • 
+
+  
  • 
+    Z80Lib3D::Matrix3D::Macros
+
+    
+
+  
    • 
+
+  
  • 
+    Z80Lib3D::Primitives
+
+    
+
+  
    • 
+
+  
  • 
+    Z80Lib3D::Primitives::Matrix
+
+    
+
+  
    • 
+
+  
  • 
+    Z80Lib3D::Primitives::Rotation
+
+    
+
+  
    • 
+
+  
  • 
+    Z80Lib3D::Primitives::SinCos
+
+  
    • 
+
+  
  • 
+    Z80Lib3D::Primitives::Vector
+
+    
+
+  
    • 
+
+  
  • 
+    Z80Lib3D::Primitives::Vertex
+
+    
+
+  
    • 
+
+  
  • 
+    Z80Lib3D::Quaternion
+
+    
+
+  
    • 
+
   
  • 
     ZX7
 
@@ -1324,15 +1424,25 @@ 
    Methods
    
     —
     Z80::Alloc
 
+  
  • 
+    ::kernel_org
+    —
+    ZXUtils::Multitasking
+
   
  • 
     ::kernel_org
     —
     ZXUtils::MultitaskingIO
 
   
  • 
-    ::kernel_org
+    ::make
     —
-    ZXUtils::Multitasking
+    Z80Lib3D::Primitives::Vertex
+
+  
  • 
+    ::make_many
+    —
+    Z80Lib3D::Primitives::Vertex
 
   
  • 
     ::members_of_struct
@@ -1345,49 +1455,49 @@ 
    Methods
    
     Z80::Label
 
   
  • 
-    ::names
+    ::names
     —
-    Z80::Program::Condition
+    Z80::Program::Register
 
   
  • 
-    ::names
+    ::names
     —
-    Z80::Program::Register
+    Z80::Program::Condition
 
   
  • 
-    ::new
+    ::new
     —
-    ZXLib::Basic::VariableParseError
+    ZXLib::Basic::Tokenizer
 
   
  • 
-    ::new
+    ::new
     —
-    ZXUtils::MusicBox::Track
+    ZXLib::Basic::Vars
 
   
  • 
-    ::new
+    ::new
     —
-    Z80::TAP::HeaderBody
+    ZXUtils::MusicBox::Multitrack
 
   
  • 
-    ::new
+    ::new
     —
-    Z80::Alloc
+    ZXUtils::MusicBox::Mask
 
   
  • 
-    ::new
+    ::new
     —
-    ZXUtils::MusicBox::Multitrack
+    ZXUtils::MusicBox::Chord
 
   
  • 
-    ::new
+    ::new
     —
-    ZXLib::Basic::Program
+    Z80::Program::Register
 
   
  • 
-    ::new
+    ::new
     —
-    ZXLib::Basic::Vars
+    ZXUtils::MusicBox::Envelope
 
   
  • 
     ::new
@@ -1395,44 +1505,44 @@ 
    Methods
    
     Z80::Label
 
   
  • 
-    ::new
+    ::new
     —
-    ZXLib::Basic::Line
+    Z80::TAP::HeaderBody
 
   
  • 
-    ::new
+    ::new
     —
-    Z80::Program::Register
+    Z80::Program::Condition
 
   
  • 
-    ::new
+    ::new
     —
-    ZXLib::Basic::Tokenizer
+    ZXUtils::MusicBox::Track
 
   
  • 
-    ::new
+    ::new
     —
-    ZXUtils::MusicBox::Song
+    Z80::Alloc
 
   
  • 
-    ::new
+    ::new
     —
-    Z80::Program::Condition
+    ZXUtils::MusicBox::Song
 
   
  • 
-    ::new
+    ::new
     —
-    ZXUtils::MusicBox::Envelope
+    ZXLib::Basic::Line
 
   
  • 
-    ::new
+    ::new
     —
-    ZXUtils::MusicBox::Chord
+    ZXLib::Basic::VariableParseError
 
   
  • 
-    ::new
+    ::new
     —
-    ZXUtils::MusicBox::Mask
+    ZXLib::Basic::Program
 
   
  • 
     ::new_char_array
@@ -1450,14 +1560,14 @@ 
    Methods
    
     ZXLib::Basic::Variable
 
   
  • 
-    ::new_kernel
+    ::new_kernel
     —
-    ZXUtils::MultitaskingIO
+    ZXUtils::Multitasking
 
   
  • 
-    ::new_kernel
+    ::new_kernel
     —
-    ZXUtils::Multitasking
+    ZXUtils::MultitaskingIO
 
   
  • 
     ::new_number
@@ -1564,6 +1674,11 @@ 
    Methods
    
     —
     ZXUtils::Emu
 
+  
  • 
+    ::scale
+    —
+    Z80Lib3D::Primitives::Vertex
+
   
  • 
     ::spawn
     —
@@ -1599,20 +1714,15 @@ 
    Methods
    
     —
     Z80::Label
 
-  
  • 
-    #%
-    —
-    Z80::Label
-
   
  • 
     #%
     —
     Z80::Alloc
 
   
  • 
-    #&
+    #%
     —
-    Z80::Alloc
+    Z80::Label
 
   
  • 
     #&
@@ -1620,7 +1730,7 @@ 
    Methods
    
     Z80::Label
 
   
  • 
-    #*
+    #&
     —
     Z80::Alloc
 
@@ -1630,17 +1740,17 @@ 
    Methods
    
     Z80::Label
 
   
  • 
-    #**
+    #*
     —
     Z80::Alloc
 
   
  • 
-    #**
+    #**
     —
-    Z80::Label
+    Z80::Alloc
 
   
  • 
-    #+
+    #**
     —
     Z80::Label
 
@@ -1650,14 +1760,14 @@ 
    Methods
    
     Z80::Alloc
 
   
  • 
-    #+
+    #+
     —
-    Z80::Program::Register
+    Z80::Label
 
   
  • 
-    #+@
+    #+
     —
-    Z80::Label
+    Z80::Program::Register
 
   
  • 
     #+@
@@ -1665,9 +1775,9 @@ 
    Methods
    
     Z80::Alloc
 
   
  • 
-    #-
+    #+@
     —
-    Z80::Program::Register
+    Z80::Label
 
   
  • 
     #-
@@ -1675,12 +1785,12 @@ 
    Methods
    
     Z80::Alloc
 
   
  • 
-    #-
+    #-
     —
-    Z80::Label
+    Z80::Program::Register
 
   
  • 
-    #-@
+    #-
     —
     Z80::Label
 
@@ -1690,7 +1800,7 @@ 
    Methods
    
     Z80::Alloc
 
   
  • 
-    #/
+    #-@
     —
     Z80::Label
 
@@ -1700,20 +1810,25 @@ 
    Methods
    
     Z80::Alloc
 
   
  • 
-    #<<
+    #/
     —
     Z80::Label
 
   
  • 
-    #<<
+    #<<
     —
-    ZXLib::Basic::Vars
+    Z80::Label
 
   
  • 
     #<<
     —
     Z80::Alloc
 
+  
  • 
+    #<<
+    —
+    ZXLib::Basic::Vars
+
   
  • 
     #==
     —
@@ -1730,34 +1845,34 @@ 
    Methods
    
     Z80::Label
 
   
  • 
-    #[]
+    #[]
     —
-    Z80::Program::Register
+    Z80::Program
 
   
  • 
-    #[]
+    #[]
     —
-    ZXLib::Basic::Program
+    Z80::Alloc
 
   
  • 
-    #[]
+    #[]
     —
-    Z80
+    Z80::Label
 
   
  • 
-    #[]
+    #[]
     —
-    Z80::Program
+    Z80::Program::Register
 
   
  • 
-    #[]
+    #[]
     —
-    ZXLib::Basic::Variable
+    Z80
 
   
  • 
-    #[]
+    #[]
     —
-    Z80::Label
+    ZXLib::Basic::Variable
 
   
  • 
     #[]
@@ -1765,9 +1880,9 @@ 
    Methods
    
     ZXLib::Basic::Vars
 
   
  • 
-    #[]
+    #[]
     —
-    Z80::Alloc
+    ZXLib::Basic::Program
 
   
  • 
     #^
@@ -1830,15 +1945,30 @@ 
    Methods
    
     ZXUtils::Multitasking
 
   
  • 
-    #array?
+    #apply_matrix
     —
-    Z80::TAP::HeaderBody
+    Z80Lib3D::Matrix3D::Macros
+
+  
  • 
+    #apply_matrix_element
+    —
+    Z80Lib3D::Matrix3D::Macros
+
+  
  • 
+    #apply_matrix_row
+    —
+    Z80Lib3D::Matrix3D::Macros
 
   
  • 
     #array?
     —
     ZXLib::Basic::Variable
 
+  
  • 
+    #array?
+    —
+    Z80::TAP::HeaderBody
+
   
  • 
     #as
     —
@@ -2020,14 +2150,14 @@ 
    Methods
    
     Z80::Program
 
   
  • 
-    #bytesize
+    #bytesize
     —
-    ZXUtils::MusicBox::Track
+    ZXLib::Basic::Variable
 
   
  • 
-    #bytesize
+    #bytesize
     —
-    ZXLib::Basic::Variable
+    ZXUtils::MusicBox::Track
 
   
  • 
     #byteslice
@@ -2269,6 +2399,11 @@ 
    Methods
    
     —
     Z80::MathInt::Macros
 
+  
  • 
+    #divmod16_8
+    —
+    Z80::MathInt::Macros
+
   
  • 
     #divmod24_8
     —
@@ -2669,6 +2804,11 @@ 
    Methods
    
     —
     ZXUtils::MusicBox::TrackCommands
 
+  
  • 
+    #immediate?
+    —
+    Z80::Alloc
+
   
  • 
     #immediate?
     —
@@ -2679,11 +2819,6 @@ 
    Methods
    
     —
     Z80::Label
 
-  
  • 
-    #immediate?
-    —
-    Z80::Alloc
-
   
  • 
     #import
     —
@@ -2725,14 +2860,14 @@ 
    Methods
    
     ZXUtils::MusicBox::SongCommands
 
   
  • 
-    #indexable?
+    #indexable?
     —
-    Z80::Label
+    Z80::Alloc
 
   
  • 
-    #indexable?
+    #indexable?
     —
-    Z80::Alloc
+    Z80::Label
 
   
  • 
     #init
@@ -2865,14 +3000,14 @@ 
    Methods
    
     ZXLib::Basic::Program
 
   
  • 
-    #loop_to
+    #loop_to
     —
-    ZXUtils::MusicBox::CommonInstrumentCommands
+    ZXUtils::MusicBox::MultitrackCommands
 
   
  • 
-    #loop_to
+    #loop_to
     —
-    ZXUtils::MusicBox::MultitrackCommands
+    ZXUtils::MusicBox::CommonInstrumentCommands
 
   
  • 
     #lt
@@ -2920,14 +3055,14 @@ 
    Methods
    
     ZXLib::Gfx::Draw::Macros
 
   
  • 
-    #mark
+    #mark
     —
-    ZXUtils::MusicBox::CommonInstrumentCommands
+    ZXUtils::MusicBox::MultitrackCommands
 
   
  • 
-    #mark
+    #mark
     —
-    ZXUtils::MusicBox::MultitrackCommands
+    ZXUtils::MusicBox::CommonInstrumentCommands
 
   
  • 
     #mask
@@ -2990,9 +3125,9 @@ 
    Methods
    
     ZXUtils::MusicBox::CommonInstrumentCommands
 
   
  • 
-    #method_missing
+    #method_missing
     —
-    Z80::Program
+    Z80::Alloc
 
   
  • 
     #method_missing
@@ -3000,9 +3135,9 @@ 
    Methods
    
     Z80::Label
 
   
  • 
-    #method_missing
+    #method_missing
     —
-    Z80::Alloc
+    Z80::Program
 
   
  • 
     #mix_lines8_16
@@ -3094,11 +3229,26 @@ 
    Methods
    
     —
     Z80::MathInt::Macros
 
+  
  • 
+    #mul16
+    —
+    Z80::MathInt::Macros
+
   
  • 
     #mul16_32
     —
     Z80::MathInt::Macros
 
+  
  • 
+    #mul16_signed
+    —
+    Z80::MathInt::Macros
+
+  
  • 
+    #mul16_signed9
+    —
+    Z80::MathInt::Macros
+
   
  • 
     #mul8
     —
@@ -3170,14 +3320,14 @@ 
    Methods
    
     ZXUtils::MusicBox::CommonInstrumentCommands
 
   
  • 
-    #name=
+    #name=
     —
-    Z80::Alloc
+    Z80::Label
 
   
  • 
-    #name=
+    #name=
     —
-    Z80::Label
+    Z80::Alloc
 
   
  • 
     #ne
@@ -3249,6 +3399,11 @@ 
    Methods
    
     —
     ZXUtils::MusicBox::CommonInstrumentCommands
 
+  
  • 
+    #normalize_quaternion
+    —
+    Z80Lib3D::Quaternion
+
   
  • 
     #note_progress
     —
@@ -3300,14 +3455,14 @@ 
    Methods
    
     Z80::Program
 
   
  • 
-    #p
+    #p
     —
-    ZXUtils::MusicBox::MultitrackCommands
+    ZXUtils::MusicBox::CommonInstrumentCommands
 
   
  • 
-    #p
+    #p
     —
-    ZXUtils::MusicBox::CommonInstrumentCommands
+    ZXUtils::MusicBox::MultitrackCommands
 
   
  • 
     #parse_each
@@ -3315,14 +3470,14 @@ 
    Methods
    
     ZXLib::Basic::Tokenizer
 
   
  • 
-    #pause
+    #pause
     —
-    ZXUtils::MusicBox::MultitrackCommands
+    ZXUtils::MusicBox::CommonInstrumentCommands
 
   
  • 
-    #pause
+    #pause
     —
-    ZXUtils::MusicBox::CommonInstrumentCommands
+    ZXUtils::MusicBox::MultitrackCommands
 
   
  • 
     #pc
@@ -3370,24 +3525,24 @@ 
    Methods
    
     ZXLib::Gfx::Draw::Macros
 
   
  • 
-    #pointer?
+    #pointer?
     —
-    Z80::Alloc
+    Z80::Label
 
   
  • 
-    #pointer?
+    #pointer?
     —
-    Z80::Program
+    Z80::Program::Register
 
   
  • 
-    #pointer?
+    #pointer?
     —
-    Z80::Program::Register
+    Z80::Alloc
 
   
  • 
-    #pointer?
+    #pointer?
     —
-    Z80::Label
+    Z80::Program
 
   
  • 
     #prepare_args_draw_line_to
@@ -3429,6 +3584,26 @@ 
    Methods
    
     —
     Z80::TAP::HeaderBody
 
+  
  • 
+    #quaternion2matrix
+    —
+    Z80Lib3D::Quaternion
+
+  
  • 
+    #quaternion_cross_product
+    —
+    Z80Lib3D::Quaternion
+
+  
  • 
+    #quaternion_norm
+    —
+    Z80Lib3D::Quaternion
+
+  
  • 
+    #quaternion_norm_q
+    —
+    Z80Lib3D::Quaternion
+
   
  • 
     #quicksort_bytes
     —
@@ -3480,14 +3655,14 @@ 
    Methods
    
     Z80::Alloc
 
   
  • 
-    #repeat
+    #repeat
     —
-    ZXUtils::MusicBox::CommonInstrumentCommands
+    ZXUtils::MusicBox::MultitrackCommands
 
   
  • 
-    #repeat
+    #repeat
     —
-    ZXUtils::MusicBox::MultitrackCommands
+    ZXUtils::MusicBox::CommonInstrumentCommands
 
   
  • 
     #report_error
@@ -3520,15 +3695,20 @@ 
    Methods
    
     Z80::MathInt::Macros
 
   
  • 
-    #rpt
+    #rotor_quaternion
     —
-    ZXUtils::MusicBox::MultitrackCommands
+    Z80Lib3D::Quaternion
 
   
  • 
     #rpt
     —
     ZXUtils::MusicBox::CommonInstrumentCommands
 
+  
  • 
+    #rpt
+    —
+    ZXUtils::MusicBox::MultitrackCommands
+
   
  • 
     #save_tap
     —
@@ -3609,6 +3789,11 @@ 
    Methods
    
     —
     Z80::Program::Register
 
+  
  • 
+    #sll8_16
+    —
+    Z80::MathInt::Macros
+
   
  • 
     #split
     —
@@ -3620,14 +3805,14 @@ 
    Methods
    
     ZXUtils::Multitasking
 
   
  • 
-    #start
+    #start
     —
-    ZXUtils::Gallery
+    ZXUtils::Benchmark
 
   
  • 
-    #start
+    #start
     —
-    ZXUtils::Benchmark
+    ZXUtils::Gallery
 
   
  • 
     #start_chord
@@ -3659,6 +3844,11 @@ 
    Methods
    
     —
     ZXLib::Basic::Variable
 
+  
  • 
+    #sub
+    —
+    ZXUtils::MusicBox::TrackCommands
+
   
  • 
     #sub
     —
@@ -3669,11 +3859,6 @@ 
    Methods
    
     —
     ZXUtils::MusicBox::InstrumentCommands
 
-  
  • 
-    #sub
-    —
-    ZXUtils::MusicBox::TrackCommands
-
   
  • 
     #sub_from
     —
@@ -3810,9 +3995,9 @@ 
    Methods
    
     Z80::Program::Register
 
   
  • 
-    #to_i
+    #to_fixed16_8
     —
-    Z80::Alloc
+    Float
 
   
  • 
     #to_i
@@ -3830,12 +4015,7 @@ 
    Methods
    
     Z80::Program::Register
 
   
  • 
-    #to_label
-    —
-    Z80::Label
-
-  
  • 
-    #to_label
+    #to_i
     —
     Z80::Alloc
 
@@ -3845,24 +4025,29 @@ 
    Methods
    
     Symbol
 
   
  • 
-    #to_module
+    #to_label
     —
-    ZXUtils::MusicBox::Song
+    Z80::Label
 
   
  • 
-    #to_name
+    #to_label
     —
     Z80::Alloc
 
+  
  • 
+    #to_module
+    —
+    ZXUtils::MusicBox::Song
+
   
  • 
     #to_name
     —
     Z80::Label
 
   
  • 
-    #to_player_module
+    #to_name
     —
-    ZXUtils::MusicBox::Song::SongModule
+    Z80::Alloc
 
   
  • 
     #to_player_module
@@ -3870,9 +4055,9 @@ 
    Methods
    
     ZXUtils::MusicBox::Song
 
   
  • 
-    #to_program
+    #to_player_module
     —
-    ZXUtils::MusicBox::Song
+    ZXUtils::MusicBox::Song::SongModule
 
   
  • 
     #to_program
@@ -3880,35 +4065,40 @@ 
    Methods
    
     ZXUtils::MusicBox::Song::SongModule
 
   
  • 
-    #to_s
+    #to_program
     —
-    ZXLib::Basic::Vars
+    ZXUtils::MusicBox::Song
 
   
  • 
     #to_s
     —
     Z80::TAP::HeaderBody
 
-  
  • 
-    #to_s
-    —
-    ZXLib::Basic::Program
-
   
  • 
     #to_s
     —
     Z80::Alloc
 
   
  • 
-    #to_s
+    #to_s
     —
-    ZXLib::Basic::Line
+    ZXLib::Basic::Vars
 
   
  • 
     #to_s
     —
     ZXLib::Basic::Variable
 
+  
  • 
+    #to_s
+    —
+    ZXLib::Basic::Program
+
+  
  • 
+    #to_s
+    —
+    ZXLib::Basic::Line
+
   
  • 
     #to_s
     —
@@ -3919,20 +4109,15 @@ 
    Methods
    
     —
     ZXLib::Basic::Program
 
-  
  • 
-    #to_str
-    —
-    Z80::Alloc
-
   
  • 
     #to_str
     —
     Z80::Label
 
   
  • 
-    #to_tap
+    #to_str
     —
-    Z80::TAP
+    Z80::Alloc
 
   
  • 
     #to_tap
@@ -3945,15 +4130,20 @@ 
    Methods
    
     Z80::TAP
 
   
  • 
-    #to_tap_chunk
+    #to_tap
     —
-    ZXLib::Basic::Variable
+    Z80::TAP
 
   
  • 
     #to_tap_chunk
     —
     ZXLib::Basic::Program
 
+  
  • 
+    #to_tap_chunk
+    —
+    ZXLib::Basic::Variable
+
   
  • 
     #to_tap_chunk
     —
@@ -4165,14 +4355,14 @@ 
    Methods
    
     ZXUtils::MusicBox::CommonInstrumentCommands
 
   
  • 
-    #w
+    #w
     —
-    ZXUtils::MusicBox::MultitrackCommands
+    ZXUtils::MusicBox::CommonInstrumentCommands
 
   
  • 
-    #w
+    #w
     —
-    ZXUtils::MusicBox::CommonInstrumentCommands
+    ZXUtils::MusicBox::MultitrackCommands
 
   
  • 
     #wait
@@ -4234,11 +4424,6 @@ 
    Methods
    
     —
     ZXLib::Gfx::Macros
 
-  
  • 
-    #|
-    —
-    Z80::Label
-
   
  • 
     #|
     —
@@ -4249,6 +4434,11 @@ 
    Methods
    
     —
     Z80::Program::Register
 
+  
  • 
+    #|
+    —
+    Z80::Label
+
   
  • 
     #~
     —