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.
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.
New library created.
+Z80Lib3D::Primitives struct collection added.
Z80Lib3D::Quaternion module with helper functions added.
Z80Lib3D::Matrix3D class with macros for applying matrices added.
Float::to_fixed16_8 method defined in fixed_float.rb file.
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+
# 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 isfalse,check0andcheck1options are being ignored.Clears a reminder (
accumulator). If this isfalse,check0,check1andk_leq_moptions 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.
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
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.
# 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-bitm. Returns a quotient inkh|kland a remainder inaccumulator.This routine utilizes a stacked up
+Macros.divmodroutines.+ +
kh,kl+- +
A dividend as two unique 8-bit registers except:
+a,b.m+- +
A divisor as an 8-bit register except:
+a,band none ofkh,kl.Options:
++
+
check0+- +
Checks if a divisor is 0, in this instance CF=1 indicates an error and nothing except the
+accumulatoris being altered.CFshould be ignored ifcheck0isfalse. It may also be a label (within the relative jump range) to indicate where to jump ifmequals 0.+
check0_far+- +
Allow to specify far (outside the relative jump range)
+check0label.+
check1+- +
Checks if a divisor equals 1, a hot path optimization. It may also be a label to indicate where to jump if
+mequals 1.+
k_leq_m+- +
Short circuits if
+khis equal or less than a divisor, a hot path optimization.+
modulo+- +
Calculates a remainder only.
++
ignore_cf+- +
Removes instruction to clear CF if
+check0is also set. This can be used ifcheck0is provided as a label instead of checking the state of the CF flag.+
optimize+- +
Optimization options:
+:size,:time,:unroll,:time_alt,:unroll_alt. SeeMacros.divmodfor details.+ +
- NOTE +
- +
A
+Macros.divmod8presents 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+
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.
# 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
# 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 @@@@ -1431,7 +1774,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
Note:
optimize- @@ -1441,13 +1784,19 @@What is more important:
+:timeor:size? Applies only ifkbit9_carryistrue.What is more important:
:timeor:size?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
+ +@@ -1860,14 +2528,22 @@+ 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 unsignedm. Returns the result inhl.This routine is so far the most optimized of the similar routines:
+Macros.mul8orMacros.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_carryoption istruethe CF flag should contain the most significant bit (bit 9th) of a 9-bit unsigned multiplier.Options:
++ +
+
tt+- +
A 16-bit temporary register (
+deorbcunlessoptimizeis:size).+
mbit9_carry+- +
If the multiplier (
+m) is 9-bit, where MSB (9th) bit is read from CARRY flag.+
optimize+- +
Optimization options:
+:size,:timeor:unroll.Modifies:
+ + + + +af,hl,tt, optionallybifoptimizeis:size.+@@ -1545,7 +2047,7 @@# 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 endNote: -
# 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 signedm. Returns the result inhl.+ +
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 (
+deorbcunlessoptimizeis:size).+
optimize+- +
Optimization options:
+:size,:timeor:unroll.Modifies:
+ + + + +af,hl,tt, optionallybifoptimizeis: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++ +@@ -1755,7 +2407,7 @@+ 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 signedCF|m. Returns the result inhl.+ +
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 (
+deorbcunlessoptimizeis:size).+
optimize+- +
Optimization options:
+:size,:timeor:unroll.Modifies:
+ + + + +af,hl,tt, optionallybifoptimizeis: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+Note:
optimize- @@ -1765,31 +2417,47 @@What is more important:
+:timeor:size? Applies only ifdoubleisfalse.What is more important:
:timeor:size?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 endNote: -
# 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- @@ -2055,14 +2739,23 @@What is more important:
+:timeor:size? Applies only ifdoubleisfalse.What is more important:
:timeor:size?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 @@@@ -2567,7 +3260,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
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.
@@ -2647,7 +3340,7 @@
k_overflow- @@ -2635,7 +3328,7 @@
Note:
optimize- -
What is more important:
+:timeor:size?Optimization options:
:size,:timeor:unroll.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 @@@@ -2807,7 +3520,7 @@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
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 + ++ + ++ ++ + + + @@ -3353,7 +4178,7 @@Shift logical left 8-bit register with a result extended to 16-bits.
++ +
bshift+- +
How many bits to shift the content of the
+tlregister.th+- +
An 8-bit register, except the
+accumulatorfor receiving the highest 8 bits of the result.tl+- +
An 8-bit register, except the
+accumulatorholding 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+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
SinCosaddress + 000000hh, tl => llllll00-
sincos- -
Address of
+SinCostable, must be aligned to 256 bytes. (LSB ofsincosaddress must be0).Address of
SinCostable, must be aligned to 256 bytes or an 8-bit register holding MSB of theSinCosaddress. LSB ofsincosaddress must be0.T-states: 30.
+Options:
++ +
+
mask+- +
An pptional 8-bit register holding preloaded mask value:
+0xFC(0b11111100).T-states: 30|27|24.
Mofifies:
@@ -294,23 +301,37 @@af,th,tl.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 enddiff --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 + + + + + + + + + + + + + + + + ++ + + + + 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 @@ + + + + + + ++ module Z80Lib3D +
+ ++ + + + ++ + + + + + + + + + + +class Z80Lib3D::Matrix3D - ruby-Z80 + + + + + + + + + + + + + + + + + + ++ + + + + 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 @@ + + + + + + ++ class Z80Lib3D::Matrix3D +
+ ++ + + + ++ +
Z80Lib3D::Matrix3D¶ ↑3D matrix related
+ +Macros.+ + + + + + + + + + + +module Z80Lib3D::Matrix3D::Macros - ruby-Z80 + + + + + + + + + + + + + + + + + + ++ + + + + 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::Matrix3D::Macros +
+ ++ + + + ++ +
Z80Lib3D::Matrix3D::Macros¶ ↑+ +
Macrosfor 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::Vertexstruct.Matrix is represented by
+ +Primitives::Matrixstruct.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:
++ +
- +
+
hlwill point to an address immediately following the vertices end marker.- +
+
spwill point to an address immediately following the matrix.Notable run-time labels:
++ +
- +
+
matrix_pcan be used to change the address of thematrix.- +
+
adjust_x_ppoints toscrx0.- +
+
adjust_y_ppoints toscry0.- +
+
adjust_z_ppoints toscrz0.- +
+
matrix_loopenter to skip reading first Z coordinate, can be used to pre-check if vertices are empty. Expects Z coordinage already inbandhlpointing 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|deare being swapped with alternatives before the multiplication, howeverxis read into theaccumulatorbefore swapping.A result is returned in the
+ +hlas a twos complement signed 16-bit integer:HL <-> HL' +HL = [SP]*x +or +HL = HL + [SP]*x+ +On completion
+sppoints 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 preservesx, 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
+ +accumulatoras a twos complement signed 8-bit integer:A = INT(([SP]*x + [SP+2]*y + [SP+4]*z + 128) / 256) ++ +On completion
+sppoints 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
+deorbcfrom the alternative register set.+
t+- +
An 8-bit temporary register from the alternative register set.
+Modifies:
+ + + + +sp,af,hl',bc',de', preservesx,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+module Z80Lib3D::Primitives - ruby-Z80 + + + + + + + + + + + + + + + + + + ++ + + + + 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 @@ + + + + + + ++ module Z80Lib3D::Primitives +
+ ++ + + + ++ +
Z80Lib3D::Primitives¶ ↑3D primitives for
+ +Z80program data.+ + + + + + + ++ + + + + + ++ +Constants
++ +
+- SinCos + +
A
+ +Z80::Utils::SinCostable entry struct.Consists of two
+words:+ +
- +
+
sin- +
+
coswhere 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].class Z80Lib3D::Primitives::Matrix - ruby-Z80 + + + + + + + + + + + + + + + + + + ++ + + + + 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::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+ + + + + + + + + + + +class Z80Lib3D::Primitives::Rotation - ruby-Z80 + + + + + + + + + + + + + + + + + + ++ + + + + 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::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)+ + + + + + + + + + + +class Z80Lib3D::Primitives::Vector - ruby-Z80 + + + + + + + + + + + + + + + + + + ++ + + + + 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::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
+ + +Vectorinstancesclass Z80Lib3D::Primitives::Vertex - ruby-Z80 + + + + + + + + + + + + + + + + + + ++ + + + + 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 @@ + + + + + + ++ class Z80Lib3D::Primitives::Vertex +
+ ++ + + + ++ +
Z80Lib3D::Primitives::Vertex¶ ↑A 3 element
+Vectorand 2 screen coordinates:+ +
- +
+
vec:Vector- +
+
xp:byte- +
+
yp:byte- +
+
scr:wordalias ofyp|xp+ + + + + + + ++ + + + + + ++ +Constants
++ +
+- S + +
A struct to represent
+ + +Vertexinstances+ + ++ + + +Public Class Methods
++ ++ + ++ make(x, y, z, scrx0:128, scry0:128, scrz0:128, persp_dshift:7) + + click to toggle source + ++ + ++ ++ + + + +Creates a
+ + + + +Vertexdata 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
+ + + + +Vertexdata 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
+ + + + +Vertexdata 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+module Z80Lib3D::Quaternion - ruby-Z80 + + + + + + + + + + + + + + + + + + ++ + + + + 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 @@+ module Z80Lib3D::Quaternion +
+ ++ + + + ++ +
Z80Lib3D::Quaternion¶ ↑+ +
Quaternionrelated 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+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
+colsis one of:ixh,ixl,iyhoriylthe routine uses self modifying code.Unless
colsis a direct label or one of:ixh,ixl,iyhoriylthe 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 @@@@ -1171,7 +1188,7 @@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 endPublic 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 passtrueto thescreen:option if bit-4 of thebankshould 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 passtrueto thescreen:option if bit-3 of thebankshould select a screen to be displayed.
screen- -
0 - Display screen from bank 5. 1 - Display screen from bank 7.
+trueto preserve screen bit-4 from thebankregister.0 - Display screen from bank 5. 1 - Display screen from bank 7.
nilto preserve screen bit-3 from thebankregister.
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 c279942..f0c8b66 100644 Binary files a/examples/ghosts.tap and b/examples/ghosts.tap differ diff --git a/examples/labyrinth.tap b/examples/labyrinth.tap index d8f6a01..d5632ba 100644 Binary files a/examples/labyrinth.tap and b/examples/labyrinth.tap differ diff --git a/examples/mathi_test.tap b/examples/mathi_test.tap index a453156..a1dd767 100644 Binary files a/examples/mathi_test.tap and b/examples/mathi_test.tap differ diff --git a/examples/quat3d128.tap b/examples/quat3d128.tap index e055c65..496d2ad 100644 Binary files a/examples/quat3d128.tap and b/examples/quat3d128.tap differ diff --git a/examples/stars.tap b/examples/stars.tap index 5c2da9f..afcdbcd 100644 Binary files a/examples/stars.tap and b/examples/stars.tap differ diff --git a/index.html b/index.html index ef7a34b..d2ab000 100644 --- a/index.html +++ b/index.html @@ -146,6 +146,26 @@
Class 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\nA 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/callconditions as constants:\n\nNZ Z NC C PO PE P M\n\nAdditionally 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
coordsvariable.\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
strmsvariable.\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.counterword 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
otherlabel 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
otherlabel 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
otherlabel 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
nameas 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
otherlabel 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/iyregisters. Example:\n\nld 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
otherlabel 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/iyregisters. Example:\n\nld 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
otherlabel 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
otherlabel 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
otherlabel 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.\nIf
indexisnil, returns a pointer label instead.\nIf
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
indexor an array of lines ifRangeis 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
indexor an array of variables ifRangeis 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
otherlabel 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
ttto a 24-bit integer inth8|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|tlregister 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
addressof the optionaltype.\n
typecan 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
addressmust be a label or a label expression.\nThe 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","()","
trueif this chunk represents a number or character array\n"],["array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-array-3F","()","
trueif 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
borcregister. …\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
inputaddresses intoborcregister. …\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
outputaddresses intoborcregister. …\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
selectaddresses intoborcregister. …\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
ZFis 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
routineaddress and acounter. 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
countbytes 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,inputand achan_name.\noutput — 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.\nProvide 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
channelname.\nA
channelcan 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. Achannelcan be an integer: 0 to 2 …\n"],["char_array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-char_array-3F","()","
trueif 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
nameas a symbol or a string. Provideargsfor 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
destusing LDIR instruction.\nT-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
destin a faster way using unrolled instructions.\nT-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|tlwith avalueas 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|tlwith another pairsh|slas 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
vawithvbas twos complement signed 8-bit integers.\nProvide
vaandvbas 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","()","
trueif 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|tlwith avalueas unsigned 16-bit integers.\nProvide
valueas 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|tlwith another pairsh|slas unsigned 16-bit integers.\n\nCF, 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
ttwithssas unsigned integers.\nA 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 inkand …\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-bitm. 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 inhland …\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
xdistance 4 times larger than theydistance.\nInput 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
xdistance larger than theydistance.\nInput 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
ydistance larger than or equal to thexdistance.\nInput …\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
preshiftdata:\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
dummylabel).\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
hlshould 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
nameas a symbol or a string. Provideargsfor 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_nameas 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:ato: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.\nProvide …\n"],["for_loop?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-for_loop-3F","()","
trueif 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
dataas 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.\nNOTE — 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
dxanddy. Used by: Macros.gfx_clip_line.\nNOTE — Swaps
bc,de,hlregisters …\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
handlregisters 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:
trueor 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
programclass. Give an optionalnameto 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
nameas 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
nameas 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
nameas 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
nameas 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
nameas 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
nameas a symbol or a string.\n"],["include?","Z80::Alloc","Z80/Alloc.html#method-c-include-3F","(alloc, label)","Return true if
labeltakes part in anallocexpression.\n"],["indexable?","Z80::Alloc","Z80/Alloc.html#method-i-indexable-3F","()",""],["indexable?","Z80::Label","Z80/Label.html#method-i-indexable-3F","()","Returns
trueif a lazy evaluated label can be offset byindex.\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
nameas a symbol or a string.\nGive 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
f1andf2registers into thearegister.\nEvaluates the given
blockafter 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
typecan 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
truefor:\n\nfoo, :foo, foo[10], ...\n"],["label_defined?","Z80::Program","Z80/Program.html#method-i-label_defined-3F","(name)","True if a label with a
nameis 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
truefor:\n\nfoo 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
programclass. Optionally imports macros.\nA 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
bbinto the 16-bit registeraa.\nA sugar for two 8-bit
ldinstructions. …\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
linesof a Basic line number equal or greater thanline_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_noargument. …\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. Repeatsrepeattimes. Ifrepeatisnilor 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. Repeatsrepeattimes. Ifrepeatisnilor 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 ofregisters…\n"],["macro_import","Z80::Program","Z80/Program.html#method-i-macro_import","(program)","Imports macros from another
programclass.\nA 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
nameas 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
nameas 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
nameas a symbol or a string. Provideargsfor 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
selfcan adjoin withother: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
sizebytes from memory areasourceto memory areadest.\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
sizebytes from memory areasourceto memory areadestusing 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
mis defined, assumemis a label name to define. Returns a named label.\nA
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— whentruechecks 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:readto 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:readto 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 unsignedm. 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 unsignedm. 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|klor 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 unsignedm. 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 unsignedm. 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 signedm.\nSee 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
nameas a symbol or a string.\nGive 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.\nPass …\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
startaddress 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
textmust be an UTF-8 encoded,line_indexandline_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
stringsare 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
nameshould contain max 10 ascii characters.\n
codeshould 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
dimsmust 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
nameshould contain max 10 ascii characters.\n
codeshould …\n"],["new_string","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_string","(name, string)","Creates a string Basic::Variable.\n
The
stringis 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_ARRAYorTYPE_CHAR_ARRAY.\n
nameshould 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
blockas sub-labels. …\n"],["number?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-number-3F","()","
trueif variable is a number variable\n"],["number_array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-number_array-3F","()","
trueif 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
nilif 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
vis 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
numto a ZX-Spectrum's real number encoded as a 5-byte binary string.\n
simplified_intindicates …\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
sourceshould be an UTF-8 encoded string.\nEach …\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
lengthperiod. Thelengthvalue 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
lengthperiod. Thelengthvalue should be a positive integer.\nThe 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
truefor:\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
aregister 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
aregister should have the …\n"],["print_fp_hl","ZXLib::Math","ZXLib/Math.html#method-i-print_fp_hl","","Call
print_fp_hlwithhlpointing to the 1st byte of aZXRealnumber to print that number to the currently …\n"],["program?","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-program-3F","()","
trueif 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
:nameargument 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
:nameargument 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
truefor:\n\nhl, 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
repeattimes. Ifrepeatisnilor 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
repeattimes. Ifrepeatisnilor 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..9or 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
trueinvokeeiinstruction …\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
fileas its argument.\nProvides additional
argsto 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
filenamespecifies 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
filenamespecifies 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
filenamespecifies the file name to save to. The “.tap” extension …\n"],["screen?","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-screen-3F","()","
trueif 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
hlpoints 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
tlinto ath.\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.\nFor …\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
fileas its argument.\nProvides additional
argsto …\n"],["split","Z80::Program::Register","Z80/Program/Register.html#method-i-split","()","Disjoins one of 16 bit registers:
bcdehlixoriyto array of 8bit registers: [hi,lo].\nUseful 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
routineand acounteraddress 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","()","
trueif 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
sregister value from a 16-bitth|tlregister 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_nameas 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_nameas 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_nameas 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.\nThe
ticksvalue 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
counterand 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.
datamust be aHash,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
infoenables 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
Structfrom members defined in a data structure.\nInstances of such a
Structare 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
Floatto a ZX-Spectrum's real number encoded as a 5-byte binary string.\nSuitable 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
nameas a symbol or a string.\nGive 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 differenttype.typecan 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.\nNOTE — 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
Numericvalue.\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_fullisniltheZflag, 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_fullisniltheZflag, 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
ticksnumber of ticks. Theticksvalue should be a positive integer …\n"],["wait","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-wait","(ticks)","Pauses tracks execution for
ticksnumber of ticks. Theticksvalue 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
aregister is duplicated and placed in thef1andf2registers.\nModifies:
af,f1and …\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
blockwithin 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
countwords 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
otherlabel 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\nA 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/callconditions as constants:\n\nNZ Z NC C PO PE P M\n\nAdditionally 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
coordsvariable.\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
strmsvariable.\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.counterword 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
otherlabel 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
otherlabel 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
otherlabel 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
nameas 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
otherlabel 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/iyregisters. Example:\n\nld 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
otherlabel 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/iyregisters. Example:\n\nld 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
otherlabel 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
otherlabel 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
otherlabel 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.\nIf
indexisnil, returns a pointer label instead.\nIf
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
indexor an array of lines ifRangeis 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
indexor an array of variables ifRangeis 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
otherlabel 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
ttto a 24-bit integer inth8|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|tlregister 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
addressof the optionaltype.\n
typecan 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
addressmust be a label or a label expression.\nThe 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","()","
trueif this chunk represents a number or character array\n"],["array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-array-3F","()","
trueif 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
borcregister. …\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
inputaddresses intoborcregister. …\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
outputaddresses intoborcregister. …\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
selectaddresses intoborcregister. …\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
ZFis 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
routineaddress and acounter. 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
countbytes 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,inputand achan_name.\noutput — 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.\nProvide 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
channelname.\nA
channelcan 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. Achannelcan be an integer: 0 to 2 …\n"],["char_array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-char_array-3F","()","
trueif 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
nameas a symbol or a string. Provideargsfor 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
destusing LDIR instruction.\nT-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
destin a faster way using unrolled instructions.\nT-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|tlwith avalueas 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|tlwith another pairsh|slas 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
vawithvbas twos complement signed 8-bit integers.\nProvide
vaandvbas 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","()","
trueif 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|tlwith avalueas unsigned 16-bit integers.\nProvide
valueas 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|tlwith another pairsh|slas unsigned 16-bit integers.\n\nCF, 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
ttwithssas unsigned integers.\nA 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 inkand …\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-bitm. 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-bitm. 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 inhland …\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
xdistance 4 times larger than theydistance.\nInput 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
xdistance larger than theydistance.\nInput 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
ydistance larger than or equal to thexdistance.\nInput …\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
preshiftdata:\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
dummylabel).\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
hlshould 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
nameas a symbol or a string. Provideargsfor 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_nameas 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:ato: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.\nProvide …\n"],["for_loop?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-for_loop-3F","()","
trueif 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
dataas 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.\nNOTE — 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
dxanddy. Used by: Macros.gfx_clip_line.\nNOTE — Swaps
bc,de,hlregisters …\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
handlregisters 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:
trueor 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
programclass. Give an optionalnameto 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
nameas 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
nameas 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
nameas 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
nameas 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
nameas 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
nameas a symbol or a string.\n"],["include?","Z80::Alloc","Z80/Alloc.html#method-c-include-3F","(alloc, label)","Return true if
labeltakes part in anallocexpression.\n"],["indexable?","Z80::Alloc","Z80/Alloc.html#method-i-indexable-3F","()",""],["indexable?","Z80::Label","Z80/Label.html#method-i-indexable-3F","()","Returns
trueif a lazy evaluated label can be offset byindex.\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
nameas a symbol or a string.\nGive 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
f1andf2registers into thearegister.\nEvaluates the given
blockafter 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
typecan 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
truefor:\n\nfoo, :foo, foo[10], ...\n"],["label_defined?","Z80::Program","Z80/Program.html#method-i-label_defined-3F","(name)","True if a label with a
nameis 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
truefor:\n\nfoo 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
programclass. Optionally imports macros.\nA 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
bbinto the 16-bit registeraa.\nA sugar for two 8-bit
ldinstructions. …\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
linesof a Basic line number equal or greater thanline_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_noargument. …\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. Repeatsrepeattimes. Ifrepeatisnilor 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. Repeatsrepeattimes. Ifrepeatisnilor 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 ofregisters…\n"],["macro_import","Z80::Program","Z80/Program.html#method-i-macro_import","(program)","Imports macros from another
programclass.\nA 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
nameas 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
nameas 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
nameas a symbol or a string. Provideargsfor 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
selfcan adjoin withother: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
sizebytes from memory areasourceto memory areadest.\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
sizebytes from memory areasourceto memory areadestusing 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
mis defined, assumemis a label name to define. Returns a named label.\nA
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— whentruechecks 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:readto 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:readto 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 unsignedm. 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 unsignedm. 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 signedm. 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 signedCF|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 unsignedm. 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|klor 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 unsignedm. 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 unsignedm. 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 signedm.\nSee 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
nameas a symbol or a string.\nGive 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.\nPass …\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
startaddress 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
textmust be an UTF-8 encoded,line_indexandline_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
stringsare 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
nameshould contain max 10 ascii characters.\n
codeshould 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
dimsmust 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
nameshould contain max 10 ascii characters.\n
codeshould …\n"],["new_string","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-c-new_string","(name, string)","Creates a string Basic::Variable.\n
The
stringis 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_ARRAYorTYPE_CHAR_ARRAY.\n
nameshould 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
blockas sub-labels. …\n"],["number?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-number-3F","()","
trueif variable is a number variable\n"],["number_array?","ZXLib::Basic::Variable","ZXLib/Basic/Variable.html#method-i-number_array-3F","()","
trueif 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
nilif 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
vis 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
numto a ZX-Spectrum's real number encoded as a 5-byte binary string.\n
simplified_intindicates …\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
sourceshould be an UTF-8 encoded string.\nEach …\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
lengthperiod. Thelengthvalue 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
lengthperiod. Thelengthvalue should be a positive integer.\nThe 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
truefor:\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
aregister 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
aregister should have the …\n"],["print_fp_hl","ZXLib::Math","ZXLib/Math.html#method-i-print_fp_hl","","Call
print_fp_hlwithhlpointing to the 1st byte of aZXRealnumber to print that number to the currently …\n"],["program?","Z80::TAP::HeaderBody","Z80/TAP/HeaderBody.html#method-i-program-3F","()","
trueif 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
:nameargument 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
:nameargument 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
truefor:\n\nhl, 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
repeattimes. Ifrepeatisnilor 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
repeattimes. Ifrepeatisnilor 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..9or 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
trueinvokeeiinstruction …\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
fileas its argument.\nProvides additional
argsto 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
filenamespecifies 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
filenamespecifies 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
filenamespecifies 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","()","
trueif 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
hlpoints 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
tlinto ath.\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.\nFor …\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
fileas its argument.\nProvides additional
argsto …\n"],["split","Z80::Program::Register","Z80/Program/Register.html#method-i-split","()","Disjoins one of 16 bit registers:
bcdehlixoriyto array of 8bit registers: [hi,lo].\nUseful 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
routineand acounteraddress 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","()","
trueif 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
sregister value from a 16-bitth|tlregister 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_nameas 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_nameas 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_nameas 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.\nThe
ticksvalue 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
counterand 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.
datamust be aHash,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
infoenables 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
Structfrom members defined in a data structure.\nInstances of such a
Structare 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
Floatto a ZX-Spectrum's real number encoded as a 5-byte binary string.\nSuitable 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
nameas a symbol or a string.\nGive 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 differenttype.typecan 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.\nNOTE — 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
Numericvalue.\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_fullisniltheZflag, 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_fullisniltheZflag, 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
ticksnumber of ticks. Theticksvalue should be a positive integer …\n"],["wait","ZXUtils::MusicBox::MultitrackCommands","ZXUtils/MusicBox/MultitrackCommands.html#method-i-wait","(ticks)","Pauses tracks execution for
ticksnumber of ticks. Theticksvalue 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
aregister is duplicated and placed in thef1andf2registers.\nModifies:
af,f1and …\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
blockwithin 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
countwords 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
otherlabel 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 080a5a1..9a82c80 100644 Binary files a/js/search_index.js.gz and b/js/search_index.js.gz differ 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 + +
- + Z80Lib3D::Matrix3D::Macros + +
+ ++ +
+ +- Z80Lib3D::Matrix3D::Macros + +
- + Z80Lib3D::Primitives + +
+ ++ +
+ +- Z80Lib3D::Primitives + +
- + Z80Lib3D::Primitives::Matrix + +
+ ++ +
+ +- Z80Lib3D::Primitives::Matrix + +
- + Z80Lib3D::Primitives::Rotation + +
+ ++ +
+ +- Z80Lib3D::Primitives::Rotation + +
- + Z80Lib3D::Primitives::SinCos + +
+ +- + Z80Lib3D::Primitives::Vector + +
+ ++ +
+ +- Z80Lib3D::Primitives::Vector + +
- + Z80Lib3D::Primitives::Vertex + +
+ ++ +
+ +- Z80Lib3D::Primitives::Vertex + +
- + Z80Lib3D::Quaternion + +
++ +
+ +- 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 +
- #~ —