arch-jedi/nx01
1
0
Fork 0
Code Issues Pull requests Releases Packages Activity Actions

FC18: Converted to choco taste pig numbers

Browse source
This commit is contained in:
Willem Cazander 2025-09-05 16:13:02 +02:00
parent badf68fc25
commit 0699d23c52
25 changed files with 1314 additions and 864 deletions
Download patch file Download diff file Expand all files Collapse all files

135
nx01-x4o-fc18/src/main/java/org/x4o/fc18/FourCornerUnicodeDisplay.java
View file

@ -40,12 +40,15 @@ import org.x4o.fc18.cake2.pie9d.FCDotPIE9DDash09;
import org.x4o.fc18.cake2.zero33.FCDotCDC1604DashP6;
import org.x4o.fc18.octal8.PrimordialOctal;
import org.x4o.fc18.zion7.FourCornerZion7Candlelier;
import org.x4o.fc18.zion7.FourCornerZion7FremanBase8;
import org.x4o.fc18.zion7.FourCornerZion7NumberGram;
import org.x4o.fc18.zion7.FourCornerZion7SalahSequence;
import org.x4o.fc18.zion7.FourCornerZion7FremanBase2;
import org.x4o.fc18.zion7.FourCornerZionStenoLexer;
import org.x4o.fc18.zion7.FourCornerZionStenoLexerSmoke;
import org.x4o.fc18.zion7.flame4.FCFlameFremanChocoBase8;
import org.x4o.fc18.zion7.flame4.FCFlameFremanLegoBase2;
import org.x4o.fc18.zion7.flame4.FCFlameFremanLegoBase8;
import org.x4o.fc18.zion7.flame4.FCFlameFremanSignedBase2;
import org.x4o.fc18.zion7.flame4.FCFlameNumberTaste;
import org.x4o.fc18.zion7.flame4.FCFlameNumberGram;
/// Renders unicode from four corner 18 bit text.
///
@ -244,27 +247,57 @@ public class FourCornerUnicodeDisplay {
}
@Override
public void strobeNumberBASE2(FourCornerZion7FremanBase2 type, BigInteger value) {
public void strobeNumberBASE2Lego(FCFlameFremanLegoBase2 type, BigInteger value) {
List<Integer> numberCandy = new ArrayList<>();
//numberCandy.add(FCDotCDC1604DashP6.NX15_O.ordinal());
//numberCandy.add(FCDotCDC1604DashP6.NX24_X.ordinal());
//FourCornerRecipe.toDecimalsX18(numberCandy, type.bytes());
//numberCandy.add(FCDotCDC1604DashP6.NY15_COLON.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, value);
renderFromInt18(numberCandy, output);
}
@Override
public void strobeNumberBASE8(FourCornerZion7FremanBase8 type, BigInteger value) {
public void strobeNumberBASE2Int(FCFlameFremanSignedBase2 type, boolean sign, BigInteger value) {
List<Integer> numberCandy = new ArrayList<>();
//numberCandy.add(FCDotCDC1604DashP6.NX15_O.ordinal());
//numberCandy.add(FCDotCDC1604DashP6.NX24_X.ordinal());
//FourCornerRecipe.toDecimalsX18(numberCandy, type.octals());
//numberCandy.add(FCDotCDC1604DashP6.NY15_COLON.ordinal());
if (sign) {
numberCandy.add(FCDotCDC1604DashP6.NY19_MINUS.ordinal()); // TODO: use name word symbols
}
FourCornerRecipe.toDecimalsX18(numberCandy, value);
renderFromInt18(numberCandy, output);
}
@Override
public void strobeNumberBASE8Lego(FCFlameFremanLegoBase8 type, BigInteger value) {
List<Integer> numberCandy = new ArrayList<>();
FourCornerRecipe.toDecimalsX18(numberCandy, value);
renderFromInt18(numberCandy, output);
}
@Override
public void strobeNumberBASE8Choco(FCFlameFremanChocoBase8 type, FCFlameNumberTaste taste, BigInteger value) {
List<Integer> numberCandy = new ArrayList<>();
if (taste.statusFlag()) {
numberCandy.add(FCDotCDC1604DashP6.NX14_N.ordinal());
numberCandy.add(FCDotCDC1604DashP6.NX01_A.ordinal());
numberCandy.add(FCDotCDC1604DashP6.NX14_N.ordinal());
numberCandy.add(FCDotCDC1604DashP6.NY15_COLON.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, taste.ordinal()); // fixme use HEX
renderFromInt18(numberCandy, output);
return;
}
if (taste.statusSignNegative()) {
numberCandy.add(FCDotCDC1604DashP6.NY19_MINUS.ordinal()); // TODO: use name word symbols
}
if (taste.statusCarryOke()) {
numberCandy.add(FCDotCDC1604DashP6.NY20_PLUS.ordinal()); // TODO: use name word symbols
}
if (taste.numberValidInfinity()) {
numberCandy.add(FCDotCDC1604DashP6.NX09_I.ordinal()); // TODO: use name word symbols
numberCandy.add(FCDotCDC1604DashP6.NX14_N.ordinal());
numberCandy.add(FCDotCDC1604DashP6.NX06_F.ordinal());
} else {
FourCornerRecipe.toDecimalsX18(numberCandy, value);
}
renderFromInt18(numberCandy, output);
}
@Override
public void strobeSandWorm(List<PrimordialOctal> sandWalk, List<PrimordialOctal> sandSpice) {
// todo; select plugin for renderer
@ -281,7 +314,7 @@ public class FourCornerUnicodeDisplay {
}
@Override
public void strobeNumberGrams(FourCornerZion7NumberGram gram, List<Integer> values) {
public void strobeNumberGrams(FCFlameNumberGram gram, List<Integer> values) {
// todo use external words
List<Integer> math = new ArrayList<>();
for (Integer num : values) {
@ -291,7 +324,15 @@ public class FourCornerUnicodeDisplay {
}
@Override
public void strobeNumberNCR1632(BigInteger numerator, BigInteger denominator) {
public void strobeNumberChocoMarriedPigsRational(FCFlameNumberTaste tasteMale, FCFlameNumberTaste tasteFemale, BigInteger numerator, BigInteger denominator) {
// TODO: write full format for all new numbers in short FC6 encoding like; (ratio and choco int's)
// auto ratio = 0R.0TrD-123.-123; // = 0rX12FF.12FF = 0tNAN = 0tD123.456 (use pure upper case FC6 AND also have FC6PLus version)
if (tasteMale.statusSignNegative()) {
numerator = numerator.negate(); // fixme add sign+carry+inf support for sup/supprt notation...
}
if (tasteFemale.statusSignNegative()) {
denominator = denominator.negate();
}
List<Integer> numberCandy = new ArrayList<>();
FourCornerRecipe.toScriptSuperX18(numberCandy, numerator);
numberCandy.add(FCDotCDC1604DashP6.NY02_BAR_V_RIGHT.ordinal());
@ -300,35 +341,69 @@ public class FourCornerUnicodeDisplay {
}
@Override
public void strobeNumberDEC576(BigInteger coefficient, BigInteger exponent) {
List<Integer> numberCandy = new ArrayList<>();
FourCornerRecipe.toDecimalsX18(numberCandy, coefficient);
numberCandy.add(FCDotCDC1604DashP6.NY18_ASTERISK.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, 1);
FourCornerRecipe.toDecimalsX18(numberCandy, 0);
FourCornerRecipe.toScriptSuperX18(numberCandy, exponent);
renderFromInt18(numberCandy, output);
}
@Override
public void strobeNumberE503M72(boolean sign, BigInteger exponent, BigInteger mantissa) {
public void strobeNumberChocoPigDecimal(FCFlameNumberTaste taste, boolean bias, BigInteger power, BigInteger coefficient) {
if (bias) {
power = power.negate();
}
List<Integer> numberCandy = new ArrayList<>();
numberCandy.add(FCDotCDC1604DashP6.NY25_ROUND_LEFT.ordinal());
numberCandy.add(FCDotCDC1604DashP6.NY19_MINUS.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, 1);
numberCandy.add(FCDotCDC1604DashP6.NY24_ROUND_RIGHT.ordinal());
FourCornerRecipe.toScriptSuperX18(numberCandy, sign?1:0);
FourCornerRecipe.toScriptSuperX18(numberCandy, taste.statusSignNegative()?1:0); // TODO: add full taste printer
numberCandy.add(FCDotCDC1604DashP6.NY18_ASTERISK.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, 10);
FourCornerRecipe.toScriptSuperX18(numberCandy, power);
numberCandy.add(FCDotCDC1604DashP6.NY18_ASTERISK.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, coefficient);
renderFromInt18(numberCandy, output);
}
@Override
public void strobeNumberChocoPigFloat(FCFlameNumberTaste taste, boolean bias, BigInteger exponent, BigInteger mantissa) {
if (bias) {
exponent = exponent.negate();
}
List<Integer> numberCandy = new ArrayList<>();
numberCandy.add(FCDotCDC1604DashP6.NY25_ROUND_LEFT.ordinal());
numberCandy.add(FCDotCDC1604DashP6.NY19_MINUS.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, 1);
numberCandy.add(FCDotCDC1604DashP6.NY24_ROUND_RIGHT.ordinal());
FourCornerRecipe.toScriptSuperX18(numberCandy, taste.statusSignNegative()?1:0); // TODO: add full taste printer
numberCandy.add(FCDotCDC1604DashP6.NY18_ASTERISK.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, 2);
FourCornerRecipe.toScriptSuperX18(numberCandy, exponent);
FourCornerRecipe.toScriptSuperX18(numberCandy, -127);
numberCandy.add(FCDotCDC1604DashP6.NY18_ASTERISK.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, 1);
if (BigInteger.ZERO.equals(exponent)) {
FourCornerRecipe.toDecimalsX18(numberCandy, 0); // subnormal
} else {
FourCornerRecipe.toDecimalsX18(numberCandy, 1);
}
numberCandy.add(FCDotCDC1604DashP6.NY16_DOT.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, mantissa);
renderFromInt18(numberCandy, output);
}
@Override
public void strobeNumberChocoPigFixed(FCFlameNumberTaste taste, BigInteger quake, BigInteger fraction) {
// TODO: add pure FC6 too like; auto fixedQ = 0QTPF.D2F3432F.A2B43F242E;
List<Integer> numberCandy = new ArrayList<>();
FourCornerRecipe.toDecimalsX18(numberCandy, 0);
numberCandy.add(FCDotCDC1604DashP6.NX17_Q.ordinal());
numberCandy.add(FCDotCDC1604DashP6.NX20_T.ordinal());
if (taste.statusSignPositive()) {
numberCandy.add(FCDotCDC1604DashP6.NX16_P.ordinal());
} else {
numberCandy.add(FCDotCDC1604DashP6.NX14_N.ordinal());
}
numberCandy.add(FCDotCDC1604DashP6.NX01_A.ordinal()); // 10 = decicmals
numberCandy.add(FCDotCDC1604DashP6.NY16_DOT.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, quake);
numberCandy.add(FCDotCDC1604DashP6.NY16_DOT.ordinal());
FourCornerRecipe.toDecimalsX18(numberCandy, fraction);
renderFromInt18(numberCandy, output);
}
@Override
public void burnMonoPipe(int line, int col, String pipeError) {
StringBuilder errBuf = new StringBuilder();

170
nx01-x4o-fc18/src/main/java/org/x4o/fc18/cake2/FourCornerDotCake.java
View file

@ -312,7 +312,7 @@ public enum FourCornerDotCake {
// =========== Define digital document structures
//FC_TXTBLK_64 <== LAST cake slice to have "external" defined words for display
// - FC_F4TXT0001_SP
// - FC_F4TXT0001_SP // <= FC18, FC6 => esc seq (note in 6 bit display char-ROM first few chars are none candy letters)
// - commentTXT start + stop + comment to end of line ?
// - commentDOC start + stop + anno ???
// - decimal seperator (. or ,)
@ -345,7 +345,7 @@ public enum FourCornerDotCake {
FC_XDBX2048_ATTR(0x02D000, 4096, "XML4 StringID of Attribute"),
FC_XDBX2048_TAG(0x02E000, 4096, "XML4 StringID of Element"),
// =========== Allow big sand worms and sand dunes filled the freman
// =========== Allow big sand worms to be called with walking the sand
/// Sand walk steps for calling up a sand worm
FC_SANDWALK_12(0x02F000, 4096, "Sand walk octals to call the olgoi khorkhoi"),
@ -356,94 +356,92 @@ public enum FourCornerDotCake {
/// With the ESC_SAND_WALKER preamble the binary octal mime-type information must be send first.
FC_SANDWORM_15(0x030000, 32768, "Sand octal spice of the olgoi khorkhoi"),
// =========== Allow big math with new counting rods integer types
/// 16x256=4096+1020 cake points to embed base2 number types
FC_BA2U0016_SEL0(0x038000, 2, "Embed number unsigned 16 bit select"),
FC_BA2U0016_BANK(0x038002, 256, "Embed number unsigned 16 bit bank"),
FC_BA2U0032_SEL0(0x038102, 4, "Embed number unsigned 32 bit select"),
FC_BA2U0032_BANK(0x038106, 256, "Embed number unsigned 32 bit bank"),
FC_BA2U0064_SEL0(0x038206, 8, "Embed number unsigned 64 bit select"),
FC_BA2U0064_BANK(0x03820E, 256, "Embed number unsigned 64 bit bank"),
FC_BA2U0128_SEL0(0x03830E, 16, "Embed number unsigned 128 bit select"),
FC_BA2U0128_BANK(0x03831E, 256, "Embed number unsigned 128 bit bank"),
FC_BA2U0256_SEL0(0x03841E, 32, "Embed number unsigned 256 bit select"),
FC_BA2U0256_BANK(0x03843E, 256, "Embed number unsigned 256 bit bank"),
FC_BA2U0512_SEL0(0x03853E, 64, "Embed number unsigned 512 bit select"),
FC_BA2U0512_BANK(0x03857E, 256, "Embed number unsigned 512 bit bank"),
FC_BA2U1024_SEL0(0x03867E, 128, "Embed number unsigned 1024 bit select"),
FC_BA2U1024_BANK(0x0386FE, 256, "Embed number unsigned 1024 bit bank"),
FC_BA2U2048_SEL0(0x0387FE, 256, "Embed number unsigned 2048 bit select"),
FC_BA2U2048_BANK(0x0388FE, 256, "Embed number unsigned 2048 bit bank"),
FC_BA2I0016_SEL0(0x0389FE, 2, "Embed number signed 16 bit select"),
FC_BA2I0016_BANK(0x038A00, 256, "Embed number signed 16 bit bank"),
FC_BA2I0032_SEL0(0x038B00, 4, "Embed number signed 32 bit select"),
FC_BA2I0032_BANK(0x038B04, 256, "Embed number signed 32 bit bank"),
FC_BA2I0064_SEL0(0x038C04, 8, "Embed number signed 64 bit select"),
FC_BA2I0064_BANK(0x038C0C, 256, "Embed number signed 64 bit bank"),
FC_BA2I0128_SEL0(0x038D0C, 16, "Embed number signed 128 bit select"),
FC_BA2I0128_BANK(0x038D1C, 256, "Embed number signed 128 bit bank"),
FC_BA2I0256_SEL0(0x038E1C, 32, "Embed number signed 256 bit select"),
FC_BA2I0256_BANK(0x038E3C, 256, "Embed number signed 256 bit bank"),
FC_BA2I0512_SEL0(0x038F3C, 64, "Embed number signed 512 bit select"),
FC_BA2I0512_BANK(0x038F7C, 256, "Embed number signed 512 bit bank"),
FC_BA2I1024_SEL0(0x03907C, 128, "Embed number signed 1024 bit select"),
FC_BA2I1024_BANK(0x0390FC, 256, "Embed number signed 1024 bit bank"),
FC_BA2I2048_SEL0(0x0391FC, 256, "Embed number signed 2048 bit select"),
FC_BA2I2048_BANK(0x0392FC, 256, "Embed number signed 2048 bit bank"),
FC_BA2L0016_SEL0(0x038000, 2, "Number lego 16 bit select"),
FC_BA2L0016_BANK(0x038002, 256, "Number lego 16 bit bank"),
FC_BA2L0032_SEL0(0x038102, 4, "Number lego 32 bit select"),
FC_BA2L0032_BANK(0x038106, 256, "Number lego 32 bit bank"),
FC_BA2L0064_SEL0(0x038206, 8, "Number lego 64 bit select"),
FC_BA2L0064_BANK(0x03820E, 256, "Number lego 64 bit bank"),
FC_BA2L0128_SEL0(0x03830E, 16, "Number lego 128 bit select"),
FC_BA2L0128_BANK(0x03831E, 256, "Number lego 128 bit bank"),
FC_BA2L0256_SEL0(0x03841E, 32, "Number lego 256 bit select"),
FC_BA2L0256_BANK(0x03843E, 256, "Number lego 256 bit bank"),
FC_BA2L0512_SEL0(0x03853E, 64, "Number lego 512 bit select"),
FC_BA2L0512_BANK(0x03857E, 256, "Number lego 512 bit bank"),
FC_BA2L1024_SEL0(0x03867E, 128, "Number lego 1024 bit select"),
FC_BA2L1024_BANK(0x0386FE, 256, "Number lego 1024 bit bank"),
FC_BA2L2048_SEL0(0x0387FE, 256, "Number lego 2048 bit select"),
FC_BA2L2048_BANK(0x0388FE, 256, "Number lego 2048 bit bank"),
FC_BA2I0016_SEL0(0x0389FE, 2, "Number integer 16 bit select"),
FC_BA2I0016_BANK(0x038A00, 256, "Number integer 16 bit bank"),
FC_BA2I0032_SEL0(0x038B00, 4, "Number integer 32 bit select"),
FC_BA2I0032_BANK(0x038B04, 256, "Number integer 32 bit bank"),
FC_BA2I0064_SEL0(0x038C04, 8, "Number integer 64 bit select"),
FC_BA2I0064_BANK(0x038C0C, 256, "Number integer 64 bit bank"),
FC_BA2I0128_SEL0(0x038D0C, 16, "Number integer 128 bit select"),
FC_BA2I0128_BANK(0x038D1C, 256, "Number integer 128 bit bank"),
FC_BA2I0256_SEL0(0x038E1C, 32, "Number integer 256 bit select"),
FC_BA2I0256_BANK(0x038E3C, 256, "Number integer 256 bit bank"),
FC_BA2I0512_SEL0(0x038F3C, 64, "Number integer 512 bit select"),
FC_BA2I0512_BANK(0x038F7C, 256, "Number integer 512 bit bank"),
FC_BA2I1024_SEL0(0x03907C, 128, "Number integer 1024 bit select"),
FC_BA2I1024_BANK(0x0390FC, 256, "Number integer 1024 bit bank"),
FC_BA2I2048_SEL0(0x0391FC, 256, "Number integer 2048 bit select"),
FC_BA2I2048_BANK(0x0392FC, 256, "Number integer 2048 bit bank"),
/// 16x512=8192+1020 cake points to embed base8 number types
FC_BA8U0018_SEL0(0x0393FC, 2, "Embed number unsigned 18 bit select"),
FC_BA8U0018_BANK(0x0393FE, 512, "Embed number unsigned 18 bit bank"),
FC_BA8U0036_SEL0(0x0395FE, 4, "Embed number unsigned 36 bit select"),
FC_BA8U0036_BANK(0x039602, 512, "Embed number unsigned 36 bit bank"),
FC_BA8U0072_SEL0(0x039802, 8, "Embed number unsigned 72 bit select"),
FC_BA8U0072_BANK(0x03980A, 512, "Embed number unsigned 72 bit bank"),
FC_BA8U0144_SEL0(0x039A0A, 16, "Embed number unsigned 144 bit select"),
FC_BA8U0144_BANK(0x039A1A, 512, "Embed number unsigned 144 bit bank"),
FC_BA8U0288_SEL0(0x039C1A, 32, "Embed number unsigned 288 bit select"),
FC_BA8U0288_BANK(0x039C3A, 512, "Embed number unsigned 288 bit bank"),
FC_BA8U0576_SEL0(0x039E3A, 64, "Embed number unsigned 576 bit select"),
FC_BA8U0576_BANK(0x039E7A, 512, "Embed number unsigned 576 bit bank"),
FC_BA8U1152_SEL0(0x03A07A, 128, "Embed number unsigned 1152 bit select"),
FC_BA8U1152_BANK(0x03A0FA, 512, "Embed number unsigned 1152 bit bank"),
FC_BA8U2304_SEL0(0x03A2FA, 256, "Embed number unsigned 2304 bit select"),
FC_BA8U2304_BANK(0x03A3FA, 512, "Embed number unsigned 2304 bit bank"),
FC_BA8I0018_SEL0(0x03A5FA, 2, "Embed number signed 18 bit select"),
FC_BA8I0018_BANK(0x03A5FC, 512, "Embed number signed 18 bit bank"),
FC_BA8I0036_SEL0(0x03A7FC, 4, "Embed number signed 36 bit select"),
FC_BA8I0036_BANK(0x03A800, 512, "Embed number signed 36 bit bank"),
FC_BA8I0072_SEL0(0x03AA00, 8, "Embed number signed 72 bit select"),
FC_BA8I0072_BANK(0x03AA08, 512, "Embed number signed 72 bit bank"),
FC_BA8I0144_SEL0(0x03AC08, 16, "Embed number signed 144 bit select"),
FC_BA8I0144_BANK(0x03AC18, 512, "Embed number signed 144 bit bank"),
FC_BA8I0288_SEL0(0x03AE18, 32, "Embed number signed 288 bit select"),
FC_BA8I0288_BANK(0x03AE38, 512, "Embed number signed 288 bit bank"),
FC_BA8I0576_SEL0(0x03B038, 64, "Embed number signed 576 bit select"),
FC_BA8I0576_BANK(0x03B078, 512, "Embed number signed 576 bit bank"),
FC_BA8I1152_SEL0(0x03B278, 128, "Embed number signed 1152 bit select"),
FC_BA8I1152_BANK(0x03B2F8, 512, "Embed number signed 1152 bit bank"),
FC_BA8I2304_SEL0(0x03B4F8, 256, "Embed number signed 2304 bit select"),
FC_BA8I2304_BANK(0x03B5F8, 512, "Embed number signed 2304 bit bank"),
FC_BA8L0018_SEL0(0x0393FC, 2, "Number lego 18 bit select"),
FC_BA8L0018_BANK(0x0393FE, 512, "Number lego 18 bit bank"),
FC_BA8L0036_SEL0(0x0395FE, 4, "Number lego 36 bit select"),
FC_BA8L0036_BANK(0x039602, 512, "Number lego 36 bit bank"),
FC_BA8L0072_SEL0(0x039802, 8, "Number lego 72 bit select"),
FC_BA8L0072_BANK(0x03980A, 512, "Number lego 72 bit bank"),
FC_BA8L0144_SEL0(0x039A0A, 16, "Number lego 144 bit select"),
FC_BA8L0144_BANK(0x039A1A, 512, "Number lego 144 bit bank"),
FC_BA8L0288_SEL0(0x039C1A, 32, "Number lego 288 bit select"),
FC_BA8L0288_BANK(0x039C3A, 512, "Number lego 288 bit bank"),
FC_BA8L0576_SEL0(0x039E3A, 64, "Number lego 576 bit select"),
FC_BA8L0576_BANK(0x039E7A, 512, "Number lego 576 bit bank"),
FC_BA8L1152_SEL0(0x03A07A, 128, "Number lego 1152 bit select"),
FC_BA8L1152_BANK(0x03A0FA, 512, "Number lego 1152 bit bank"),
FC_BA8L2304_SEL0(0x03A2FA, 256, "Number lego 2304 bit select"),
FC_BA8L2304_BANK(0x03A3FA, 512, "Number lego 2304 bit bank"),
// =========== Allow big terminators to learn a computer math
FC_BA8C0018_SEL0(0x03A5FA, 2, "Number choco 18 bit select"),
FC_BA8C0018_BANK(0x03A5FC, 512, "Number choco 18 bit bank"),
FC_BA8C0036_SEL0(0x03A7FC, 4, "Number choco 36 bit select"),
FC_BA8C0036_BANK(0x03A800, 512, "Number choco 36 bit bank"),
FC_BA8C0072_SEL0(0x03AA00, 8, "Number choco 72 bit select"),
FC_BA8C0072_BANK(0x03AA08, 512, "Number choco 72 bit bank"),
FC_BA8C0144_SEL0(0x03AC08, 16, "Number choco 144 bit select"),
FC_BA8C0144_BANK(0x03AC18, 512, "Number choco 144 bit bank"),
FC_BA8C0288_SEL0(0x03AE18, 32, "Number choco 288 bit select"),
FC_BA8C0288_BANK(0x03AE38, 512, "Number choco 288 bit bank"),
FC_BA8C0576_SEL0(0x03B038, 64, "Number choco 576 bit select"),
FC_BA8C0576_BANK(0x03B078, 512, "Number choco 576 bit bank"),
FC_BA8C1152_SEL0(0x03B278, 128, "Number choco 1152 bit select"),
FC_BA8C1152_BANK(0x03B2F8, 512, "Number choco 1152 bit bank"),
FC_BA8C2304_SEL0(0x03B4F8, 256, "Number choco 2304 bit select"),
FC_BA8C2304_BANK(0x03B5F8, 512, "Number choco 2304 bit bank"),
/// New Counting Rods, Select one of 48 numerator pages to use.
FC_NCR1632_SEL0N(0x03B7F8, 48, "New Counting Rods Numerator Select"),
/// New Counting Rods, Select one of 48 denominator pages to use.
FC_NCR1632_SEL1D(0x03B828, 48, "New Counting Rods Denominator Select"),
/// New Counting Rods fractions of two 576 bit numbers
/// Divided in 48 paged banks of 12 bit
FC_NCR1632_BANK(0x03B858, 4096, "New Counting Rods Page octals"),
// =========== Allow big math with new counting rods fraction types
FC_DEC576_SEL0(0x03C858, 48, "Embed number 576 bit base 10 decimal select"),
FC_DEC576_BANK(0x03C888, 4096, "Embed number 576 bit base 10 decimal bank"),
FC_E503M72_SEL0(0x03D888, 48, "Embed number 576 bit binary floating point select"),
FC_E503M72_BANK(0x03D8B8, 4096, "Embed number 576 bit binary floating point bank"),
//FC_Q503F72_SEL0(0x03D888, 48, "Embed number 576 bit binary fixed point select"),
//FC_Q503F72_BANK(0x03D8B8, 4096, "Embed number 576 bit binary fixed point bank"),
FC_RATIONAL4608_SEL0(0x03B7F8, 384, "Number choco pigs 4608 bit rational fraction select"),
FC_RATIONAL4608_BANK(0x03B978, 4096, "Number choco pigs 4608 bit rational fraction bank"),
FC_DECIMAL2304_SEL0(0x03C978, 192, "Number choco pig 2304 bit decimal point select"),
FC_DECIMAL2304_BANK(0x03CA38, 4096, "Number choco pig 2304 bit decimal point bank"),
FC_FLOAT2304_SEL0(0x03DA38, 192, "Number choco pig 2304 bit floating point select"),
FC_FLOAT2304_BANK(0x03DAF8, 4096, "Number choco pig 2304 bit floating point bank"),
FC_FIXED2304_SEL0(0x03EAF8, 192, "Number choco pig 2304 bit fixed point select"),
FC_FIXED2304_BANK(0x03EBB8, 4096, "Number choco pig 2304 bit fixed point bank"),
__RESERVED_FREE(0x03E8B8, 0x3F000 - 0x03E8B8),
// =========== Allow adult escape sequences
__RESERVED_ESC(0x03F000, 4096 - 27),
__RESERVED_ESC(0x03FBB8, 0x03FFE5 - 0x03FBB8),
FC_DEC2701_PX0(0x03FFE5, 27, FCDotDEC2701DashPX0.values(), "Direct or Escaped Control"),
;
private static final FourCornerDotCake[] VALUES = values();
@ -561,7 +559,13 @@ public enum FourCornerDotCake {
if (idx <= FC_CLK1K_Z.ordinal()) {
return FourCornerDotCakeTower.TXT_KODES;
}
return FourCornerDotCakeTower.TXT_EMBEDS;
if (idx <= FC_SANDWORM_15.ordinal()) {
return FourCornerDotCakeTower.TXT_EMBEDS;
}
if (idx <= FC_FIXED2304_BANK.ordinal()) {
return FourCornerDotCakeTower.TXT_NCR;
}
return FourCornerDotCakeTower.TXT_ESC;
}
public String nameSpec() {

2
nx01-x4o-fc18/src/main/java/org/x4o/fc18/cake2/FourCornerDotCakeTower.java
View file

@ -37,6 +37,8 @@ public enum FourCornerDotCakeTower {
TXT_INDEX("Normal text words"),
TXT_KODES("Special koder words"),
TXT_EMBEDS("Embedded data words"),
TXT_NCR("Embedded new counting rods"),
TXT_ESC("Embedded escape sequences"),
;
private static final FourCornerDotCakeTower[] VALUES = values();
private final String nameNice;

4
nx01-x4o-fc18/src/main/java/org/x4o/fc18/cake2/zero33/FCDotCDC1604DashP6.java
View file

@ -29,7 +29,7 @@ import org.x4o.fc18.cake2.FourCornerX00PetitVideCoinCarneFrapper;
import org.x4o.fc18.cake2.FourCornerX00PetitVideCoinCarneFrapperRetrait;
///
/// "FC.CDC1604-P6" Four Corner Core Data Cake has 27 pie slice number systems "Packed" for MATH and BASIC letters.
/// "FC.CDC1604-P6" Four Corner Control Data Character have 27 pie slice number systems "Packed" for MATH and BASIC letters.
///
/// This is used as the first 64 word numbers of the china four corner method, and acts like ascii glue for adult 18 bit computers.
///
@ -43,7 +43,7 @@ public enum FCDotCDC1604DashP6 implements FourCornerDotColleZero33 {
// |_\/ @ABC DEFG HIJK
// LMNO PQRS TUVW XYZ&
/// Indicator for termination of pussy strings, which is the compatibility duel octal, with the CDC 1604 computers.
/// This compatibility indicator is not a candy letter but a control data character string termination code.
_NUL('\u0000'),
/// Goto direct escaped control with sequence of 3 escapes on 6 bit systems.

7
nx01-x4o-fc18/src/main/java/org/x4o/fc18/cake2/zero33/dec1/FCDotCMD5401Dash2D.java
View file

@ -25,7 +25,6 @@ package org.x4o.fc18.cake2.zero33.dec1;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import org.x4o.fc18.cake2.FourCornerX06BaklavaPointSequence;
import org.x4o.fc18.cake2.FourCornerX08MuffinPointSequence;
@ -78,13 +77,13 @@ public enum FCDotCMD5401Dash2D implements FourCornerX06BaklavaPointSequence, Fou
return muffinPointSequence();
}
static public Optional<FCDotCMD5401Dash2D> valueOfCDC(int cdcPoint) {
static public FCDotCMD5401Dash2D valueOfCDC(int cdcPoint) {
for (FCDotCMD5401Dash2D value : values()) {
if (value.selector.baklavaPointDotIndex() == cdcPoint) {
return Optional.of(value);
return value;
}
}
return Optional.empty();
return null;
}
static public int valuesLength() {

35
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/FourCornerZion7Bereshit.java
View file

@ -26,6 +26,11 @@ import java.math.BigInteger;
import java.util.List;
import org.x4o.fc18.octal8.PrimordialOctal;
import org.x4o.fc18.zion7.flame4.FCFlameFremanChocoBase8;
import org.x4o.fc18.zion7.flame4.FCFlameFremanLegoBase2;
import org.x4o.fc18.zion7.flame4.FCFlameFremanLegoBase8;
import org.x4o.fc18.zion7.flame4.FCFlameFremanSignedBase2;
import org.x4o.fc18.zion7.flame4.FCFlameNumberTaste;
/// Handles the main four corner cake strobes.
///
@ -38,15 +43,21 @@ public interface FourCornerZion7Bereshit extends FourCornerZion7AlphaOmega {
/// Block of word cake points.
void strobeTheWords(List<Integer> cakePoints);
//void strobeStructSpacePastor(); // DOC: esc seq, in 6 bit display char-ROM use ZERO for space, as _NUL is not a candy letter but a control data character string terminator code.
//void strobeStructSpacePastor();
//void strobeStructNunLine();
/// Embed a retro computer number.
void strobeNumberBASE2(FourCornerZion7FremanBase2 type, BigInteger value);
/// Embed base2 computer lego number.
void strobeNumberBASE2Lego(FCFlameFremanLegoBase2 type, BigInteger value);
/// Embed a dune of octals sand.
void strobeNumberBASE8(FourCornerZion7FremanBase8 type, BigInteger value);
/// Embed base2 computer integer number.
void strobeNumberBASE2Int(FCFlameFremanSignedBase2 type, boolean sign, BigInteger value);
/// Embed base8 computer lego number.
void strobeNumberBASE8Lego(FCFlameFremanLegoBase8 type, BigInteger value);
/// Embed base8 computer chocolate number.
void strobeNumberBASE8Choco(FCFlameFremanChocoBase8 type, FCFlameNumberTaste taste, BigInteger value);
/// Embed sand spice using a sand walk to call the identified great sand worm which leaves the spice in the sand.
void strobeSandWorm(List<PrimordialOctal> sandWalk, List<PrimordialOctal> sandSpice);
@ -65,11 +76,19 @@ public interface FourCornerZion7Bereshit extends FourCornerZion7AlphaOmega {
}
@Override
default void strobeNumberBASE2(FourCornerZion7FremanBase2 type, BigInteger value) {
default void strobeNumberBASE2Lego(FCFlameFremanLegoBase2 type, BigInteger value) {
}
@Override
default void strobeNumberBASE8(FourCornerZion7FremanBase8 type, BigInteger value) {
default void strobeNumberBASE2Int(FCFlameFremanSignedBase2 type, boolean sign, BigInteger value) {
}
@Override
default void strobeNumberBASE8Lego(FCFlameFremanLegoBase8 type, BigInteger value) {
}
@Override
default void strobeNumberBASE8Choco(FCFlameFremanChocoBase8 type, FCFlameNumberTaste taste, BigInteger value) {
}
@Override

41
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/FourCornerZion7Candlelier.java
View file

@ -25,28 +25,32 @@ package org.x4o.fc18.zion7;
import java.math.BigInteger;
import java.util.List;
/// Handles the big numbers in four corner cake strobes.
import org.x4o.fc18.zion7.flame4.FCFlameNumberTaste;
import org.x4o.fc18.zion7.flame4.FCFlameNumberGram;
/// Handles the embedded numbers in four corner cake strobes.
///
/// NOTE: "Big" is unlimited, thus "Pig" weight is 2304 bits or 768 octals.
///
/// @author Willem Cazander
/// @version 1.0 Jan 09, 2025
public interface FourCornerZion7Candlelier extends FourCornerZion7Bereshit {
/// Embed one or more number grams of the given supported base degree type.
void strobeNumberGrams(FourCornerZion7NumberGram gram, List<Integer> values);
void strobeNumberGrams(FCFlameNumberGram gram, List<Integer> values);
/// Embed NCR1632 "decimal fractional" number. (s576+s576)
void strobeNumberNCR1632(BigInteger numerator, BigInteger denominator);
/// Embed choco married pig rational number. (4+2300+4+2300)
void strobeNumberChocoMarriedPigsRational(FCFlameNumberTaste tasteMale, FCFlameNumberTaste tasteFemale, BigInteger numerator, BigInteger denominator);
/// Embed DEC576 todo: REDO as "decimal floating point" number. (s504+s72)
void strobeNumberDEC576(BigInteger coefficient, BigInteger exponent);
//void strobeNumberC503S72(boolean negative, BigInteger combination, BigInteger significand);
/// Embed choco pig decimal number. (4+284+2016)
void strobeNumberChocoPigDecimal(FCFlameNumberTaste taste, boolean bias, BigInteger power, BigInteger coefficient);
/// Embed E503M72 "binary floating point" number. (s+u503+u72)
void strobeNumberE503M72(boolean negative, BigInteger exponent, BigInteger mantissa);
/// Embed choco pig floating point number. (4+284+2016)
void strobeNumberChocoPigFloat(FCFlameNumberTaste taste, boolean bias, BigInteger exponent, BigInteger mantissa);
// Embed Q503F72 "binary fixed point" number. (s+u503+u72)
//void strobeNumberQ503F72(boolean negative, BigInteger quake, BigInteger fraction);
// XDBX18: doom.wad uses (ARM) Q16.16 which is equal to the real (Texas) Q15.16 (because doom map like E3M2 = 6 bit float)
/// Embed fixed point number. (4+1148+1152)
void strobeNumberChocoPigFixed(FCFlameNumberTaste taste, BigInteger quake, BigInteger fraction);
// XDBX18: doom.wad uses (ARM) Q16.16 which is equal to the real (Texas) Q15.16 (because doom map like E2M3 = 6 bit float)
//void strobeStructBlockRemark(boolean beginOrEnd, boolean textOrDoc);
//void strobeStruct...(...);
@ -54,19 +58,24 @@ public interface FourCornerZion7Candlelier extends FourCornerZion7Bereshit {
interface Adapter extends FourCornerZion7Candlelier, FourCornerZion7Bereshit.Adapter {
@Override
default void strobeNumberGrams(FourCornerZion7NumberGram gram, List<Integer> values) {
default void strobeNumberGrams(FCFlameNumberGram gram, List<Integer> values) {
}
@Override
default void strobeNumberNCR1632(BigInteger numerator, BigInteger denominator) {
default void strobeNumberChocoMarriedPigsRational(FCFlameNumberTaste tasteMale, FCFlameNumberTaste tasteFemale,
BigInteger numerator, BigInteger denominator) {
}
@Override
default void strobeNumberDEC576(BigInteger coefficient, BigInteger exponent) {
default void strobeNumberChocoPigDecimal(FCFlameNumberTaste taste, boolean bias, BigInteger power, BigInteger coefficient) {
}
@Override
default void strobeNumberE503M72(boolean sign, BigInteger exponent, BigInteger mantissa) {
default void strobeNumberChocoPigFloat(FCFlameNumberTaste taste, boolean bias, BigInteger exponent, BigInteger mantissa) {
}
@Override
default void strobeNumberChocoPigFixed(FCFlameNumberTaste taste, BigInteger quake, BigInteger fraction) {
}
}
}

51
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/FourCornerZion7Petroglyphs.java
View file

@ -1,51 +0,0 @@
/*
* Copyright (c) 2004-2014, Willem Cazander
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided
* that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the
* following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
* the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.x4o.fc18.zion7;
import java.math.BigInteger;
import java.util.List;
/// Rock carvings of special variables.
///
/// @author Willem Cazander
/// @version 1.0 Aug 24, 2025
public final class FourCornerZion7Petroglyphs {
public static final BigInteger MASK_BITS_3 = new BigInteger("7", 16);
public static final BigInteger MASK_BITS_8 = new BigInteger("FF", 16);
public static final BigInteger MASK_BITS_9 = new BigInteger("1FF", 16);
public static final BigInteger MASK_BITS_12 = new BigInteger("FFF", 16);
public static final BigInteger INT576_SIGNED_MAX = new BigInteger("7FFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF", 16);
public static final BigInteger DEC576_COEFFICIENT_MAX = new BigInteger("7FFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF", 16);
public static final BigInteger DEC576_EXPONENT_MAX = new BigInteger("7FFFFFFFFFFFFFFFFF", 16);
public static final BigInteger E503M72_MANTISSA_MAX = new BigInteger("3FFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF", 16);
public static final BigInteger E503M72_EXPONENT_MAX = new BigInteger("FFFFFFFFFFFFFFFFFF", 16);
public static final List<Integer> SAND_WORM_SIGNS = List.of(24,48,72,96,120,144,168,192);
private FourCornerZion7Petroglyphs() {
}
}

397
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/FourCornerZionStenoGrapher.java
View file

@ -30,14 +30,21 @@ import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.IntConsumer;
import org.x4o.fc18.cake2.FourCornerDotCake;
import org.x4o.fc18.cake2.zero33.FCDotCDC1604DashP6;
import org.x4o.fc18.cake2.zero33.dec1.FCDotDEC2701DashPX0;
import org.x4o.fc18.octal8.PrimordialOctal;
import org.x4o.fc18.octal8.PrimordialOctalOrangeJuice;
import org.x4o.fc18.octal8.PrimordialOctalOrangeString;
import org.x4o.fc18.zion7.flame4.FCFlameFremanChocoBase8;
import org.x4o.fc18.zion7.flame4.FCFlameFremanLegoBase2;
import org.x4o.fc18.zion7.flame4.FCFlameFremanLegoBase8;
import org.x4o.fc18.zion7.flame4.FCFlameFremanSignedBase2;
import org.x4o.fc18.zion7.flame4.FCFlameFremanSuit;
import org.x4o.fc18.zion7.flame4.FCFlameNumberTaste;
import org.x4o.fc18.zion7.flame4.FCFlameNumberGram;
/// Write steno for zion.
///
@ -111,7 +118,7 @@ public class FourCornerZionStenoGrapher {
}
*/
static public final class FourCornerWriter implements FourCornerZion7Candlelier,FourCornerZion7TempleScrolls {
static public final class FourCornerWriter implements FourCornerZionStenoPetroglyphs, FourCornerZion7Candlelier, FourCornerZion7TempleScrolls {
private final IntConsumer out;
private final Runnable outFlush;
@ -133,11 +140,68 @@ public class FourCornerZionStenoGrapher {
private void outAddAll(List<Integer> values) {
int listSize = values.size();
for (int i = 0; i < listSize; i++) {
for (int i = NCR_ZERO; i < listSize; i++) {
outAdd(values.get(i));
}
}
private void outAddBankCake(int bankBits, BigInteger bankMask, int cakeSel0, int cakeBank, int bankStart, BigInteger value, Function<Integer, Integer> overrideMsb) {
boolean strobePage = true;
for (int i = bankStart; i >= 0; i--) {
int bankValue = value.shiftRight(i * bankBits).and(bankMask).intValue();
if (overrideMsb != null && i == bankStart) {
bankValue = overrideMsb.apply(bankValue);
}
if (bankValue == 0 && i > 0) {
strobePage = true;
continue;
}
if (strobePage) {
strobePage = false;
outAdd(cakeSel0 + i);
}
outAdd(cakeBank + bankValue);
}
outFlush();
}
private void outAddFremanCake8(FCFlameFremanSuit suit, int bankStart, BigInteger value, Function<Integer, Integer> overrideMsb) {
//TODO if (isSixBit) {
outAddBankCake(NCR_BANK8_BITS, BIG_BITS_8, suit.cakeOffsetSel0(), suit.cakeOffsetBank(), bankStart, value, overrideMsb);
}
private void outAddFremanCake9(FCFlameFremanSuit suit, int bankStart, BigInteger value, Function<Integer, Integer> overrideMsb) {
//TODO if (isSixBit) {
outAddBankCake(NCR_BANK9_BITS, BIG_BITS_9, suit.cakeOffsetSel0(), suit.cakeOffsetBank(), bankStart, value, overrideMsb);
}
private void outAddBankCake12(int cakeSel0, int cakeBank, int bankStart, BigInteger value, Function<Integer, Integer> overrideMsb) {
outAddBankCake(NCR_BANK12_BITS, BIG_BITS_12, cakeSel0, cakeBank, bankStart, value, overrideMsb);
}
private BigInteger requireBigPositive(BigInteger value) {
if (value.signum() == NCR_SIGNUM_NEGATIVE) {
throw new IllegalArgumentException("Value can't be negative: " + value);
}
return value;
}
private BigInteger requireBigMax(BigInteger value, BigInteger valueMax) {
if (value.compareTo(valueMax) > 0) {
throw new IllegalArgumentException("Value is larger than max: " + valueMax);
}
return value;
}
private BigInteger requireBigNoneZero(BigInteger value) {
if (BigInteger.ZERO.equals(value)) {
throw new IllegalArgumentException("Value can't be zero: " + value);
}
return value;
}
// --------------------------------------- BEGIN FC6
@Override
public void strobeDocumentAlpha() {
}
@ -149,10 +213,10 @@ public class FourCornerZionStenoGrapher {
@Override
public void strobeTheWord(int cakePoint) {
if (isSixBit && cakePoint > 63) {
if (isSixBit && cakePoint > CAKE_POINT_MAX_FC6) {
throw new IllegalArgumentException("Cake point is larger than baklave point limit: 0x" + Integer.toHexString(cakePoint));
}
if (cakePoint > PrimordialOctalOrangeJuice.MAX_VALUE) {
if (cakePoint > CAKE_POINT_MAX_FC18) {
throw new IllegalArgumentException("Cake point is larger than max value limit: 0x" + Integer.toHexString(cakePoint));
}
outAdd(cakePoint);
@ -162,85 +226,54 @@ public class FourCornerZionStenoGrapher {
public void strobeTheWords(List<Integer> cakePoints) {
Objects.requireNonNull(cakePoints);
int cakeSize = cakePoints.size();
for (int i = 0; i < cakeSize; i++) {
for (int i = NCR_ZERO; i < cakeSize; i++) {
strobeTheWord(cakePoints.get(i));
}
outFlush();
}
@Override
public void strobeNumberBASE2(FourCornerZion7FremanBase2 type, BigInteger value) {
public void strobeNumberBASE2Lego(FCFlameFremanLegoBase2 type, BigInteger value) {
Objects.requireNonNull(type);
Objects.requireNonNull(value);
BigInteger valuePos = value;
boolean negative = false;
if (value.signum() == -1) {
valuePos = value.negate();
negative = true;
}
if (type.isSigned() == false && negative) {
throw new IllegalArgumentException("Unsiged value can't be negative: " + value);
}
boolean strobePage = true;
int bankStart = type.bytes() - 1;
for (int i = bankStart; i >= 0; i--) {
int bankValue = valuePos.shiftRight(i * 8).and(FourCornerZion7Petroglyphs.MASK_BITS_8).intValue();
if (i == bankStart && negative) {
bankValue = (bankValue & 0x7F) + 0x80;
}
if (bankValue == 0 && i > 0) {
strobePage = true;
continue;
}
if (strobePage) {
strobePage = false;
outAdd(type.cakeOffsetSel0() + i);
}
//TODO if (isSixBit) {
outAdd(type.cakeOffsetBank() + bankValue);
}
outFlush();
requireBigPositive(value);
requireBigMax(value, type.maxWaterLevel());
outAddFremanCake8(type, type.bytes() - 1, value, null);
}
@Override
public void strobeNumberBASE8(FourCornerZion7FremanBase8 type, BigInteger value) {
public void strobeNumberBASE2Int(FCFlameFremanSignedBase2 type, boolean sign, BigInteger value) {
Objects.requireNonNull(type);
Objects.requireNonNull(value);
BigInteger valuePos = value;
boolean negative = false;
if (value.signum() == -1) {
valuePos = value.negate();
negative = true;
}
if (type.isSigned() == false && negative) {
throw new IllegalArgumentException("Unsiged value can't be negative: " + value);
}
boolean strobePage = true;
int bankStart = type.octals()/3 - 1;
for (int i = bankStart; i >= 0; i--) {
int bankValue = valuePos.shiftRight(i * 9).and(FourCornerZion7Petroglyphs.MASK_BITS_9).intValue();
if (i == bankStart && negative) {
bankValue = (bankValue & 0xFF) + 0x100;
}
if (bankValue == 0 && i > 0) {
strobePage = true;
continue;
}
if (strobePage) {
strobePage = false;
outAdd(type.cakeOffsetSel0() + i);
}
//TODO if (isSixBit) {
outAdd(type.cakeOffsetBank() + bankValue);
}
outFlush();
requireBigPositive(value);
requireBigMax(value, type.maxWaterLevel());
outAddFremanCake8(type, type.bytes() - 1, value, v -> (v & 0x7F) + (sign?0x80:0));
}
@Override
public void strobeNumberBASE8Lego(FCFlameFremanLegoBase8 type, BigInteger value) {
Objects.requireNonNull(type);
Objects.requireNonNull(value);
requireBigPositive(value);
requireBigMax(value, type.maxWaterLevel());
outAddFremanCake9(type, type.octals()/3 - 1, value, null);
}
@Override
public void strobeNumberBASE8Choco(FCFlameFremanChocoBase8 type, FCFlameNumberTaste taste, BigInteger value) {
Objects.requireNonNull(type);
Objects.requireNonNull(taste);
Objects.requireNonNull(value);
requireBigPositive(value);
requireBigMax(value, type.maxWaterLevel());
outAddFremanCake9(type, type.octals()/3 - 1, value, v -> v = (v & 0x1F) + (taste.ordinal() << 5));
}
@Override
public void strobeSandWorm(List<PrimordialOctal> sandWalk, List<PrimordialOctal> sandSpice) {
Objects.requireNonNull(sandWalk);
Objects.requireNonNull(sandSpice);
if (!FourCornerZion7Petroglyphs.SAND_WORM_SIGNS.contains(sandWalk.size())) {
if (!SAND_WORM_SIGNS.contains(sandWalk.size())) {
throw new IllegalArgumentException("Sand walk rhythm is not 72 bit aligned: " + sandWalk.size());
}
if (0 != (sandSpice.size() % 5)) {
@ -258,24 +291,24 @@ public class FourCornerZionStenoGrapher {
outAdd(FCDotCDC1604DashP6.NX01_A.cakePointDotIndex() + spiceItr.next().ordinal());
}
outAdd(FCDotCDC1604DashP6._SALAH_EXCLAMATION.cakePointDotIndex());
return;
}
while (walkItr.hasNext()) {
int bitValue12 = 0;
bitValue12 += (walkItr.next().ordinal() << 9);
bitValue12 += (walkItr.next().ordinal() << 6);
bitValue12 += (walkItr.next().ordinal() << 3);
bitValue12 += (walkItr.next().ordinal() << 0);
outAdd(FourCornerDotCake.FC_SANDWALK_12.getStart() + bitValue12);
}
while (spiceItr.hasNext()) {
int bitValue15 = 0;
bitValue15 += (spiceItr.next().ordinal() << 12);
bitValue15 += (spiceItr.next().ordinal() << 9);
bitValue15 += (spiceItr.next().ordinal() << 6);
bitValue15 += (spiceItr.next().ordinal() << 3);
bitValue15 += (spiceItr.next().ordinal() << 0);
outAdd(FourCornerDotCake.FC_SANDWORM_15.getStart() + bitValue15);
} else {
while (walkItr.hasNext()) {
int bitValue12 = 0;
bitValue12 += (walkItr.next().ordinal() << 9);
bitValue12 += (walkItr.next().ordinal() << 6);
bitValue12 += (walkItr.next().ordinal() << 3);
bitValue12 += (walkItr.next().ordinal() << 0);
outAdd(FourCornerDotCake.FC_SANDWALK_12.getStart() + bitValue12);
}
while (spiceItr.hasNext()) {
int bitValue15 = 0;
bitValue15 += (spiceItr.next().ordinal() << 12);
bitValue15 += (spiceItr.next().ordinal() << 9);
bitValue15 += (spiceItr.next().ordinal() << 6);
bitValue15 += (spiceItr.next().ordinal() << 3);
bitValue15 += (spiceItr.next().ordinal() << 0);
outAdd(FourCornerDotCake.FC_SANDWORM_15.getStart() + bitValue15);
}
}
outFlush();
}
@ -285,16 +318,16 @@ public class FourCornerZionStenoGrapher {
Objects.requireNonNull(type);
Objects.requireNonNull(arguments);
int arguSize = arguments.size();
for (int y = 0; y < arguSize; y++) {
for (int y = NCR_ZERO; y < arguSize; y++) {
List<Integer> arguValue = arguments.get(y);
int listSize = arguValue.size();
for (int i = 0; i < listSize; i++) {
for (int i = NCR_ZERO; i < listSize; i++) {
int value = arguValue.get(i);
if (value < 0) {
if (value < NCR_ZERO) {
throw new IllegalArgumentException("Value below zero: " + value);
}
if (value > 63) {
throw new IllegalArgumentException("Value above 63: " + value);
if (value > CAKE_POINT_MAX_FC6) {
throw new IllegalArgumentException("Value above 6 bits: " + value);
}
}
}
@ -325,13 +358,13 @@ public class FourCornerZionStenoGrapher {
// ----------------------------- END FC6
@Override
public void strobeNumberGrams(FourCornerZion7NumberGram gram, List<Integer> values) {
public void strobeNumberGrams(FCFlameNumberGram gram, List<Integer> values) {
Objects.requireNonNull(gram);
Objects.requireNonNull(values);
int gramCount = values.size();
for (int i = 0; i < gramCount; i++) {
for (int i = NCR_ZERO; i < gramCount; i++) {
int gramValue = values.get(i);
if (gramValue < 0) {
if (gramValue < NCR_ZERO) {
throw new IllegalArgumentException("Gram value is smaller than zero");
}
if (gramValue > gram.cutCount()) {
@ -343,149 +376,67 @@ public class FourCornerZionStenoGrapher {
}
@Override
public void strobeNumberNCR1632(BigInteger numerator, BigInteger denominator) {
public void strobeNumberChocoMarriedPigsRational(
FCFlameNumberTaste tasteMale, FCFlameNumberTaste tasteFemale,
BigInteger numerator, BigInteger denominator
) {
Objects.requireNonNull(tasteMale);
Objects.requireNonNull(tasteFemale);
Objects.requireNonNull(numerator);
requireBigPositive(numerator);
requireBigMax(numerator, BIG_BITS_2300);
Objects.requireNonNull(denominator);
if (denominator.equals(BigInteger.ZERO)) { // 0/1 = zero but 1/0 is NaN
throw new IllegalArgumentException("The denominator value ZERO is not allowed.");
}
if (numerator.compareTo(FourCornerZion7Petroglyphs.INT576_SIGNED_MAX) > 0) {
throw new IllegalArgumentException("Value numerator is larger than 576 bit: " + numerator);
}
if (denominator.compareTo(FourCornerZion7Petroglyphs.INT576_SIGNED_MAX) > 0) {
throw new IllegalArgumentException("Value denominator is larger than 576 bit: " + denominator);
}
BigInteger numeratorPos = numerator;
boolean numeratorNegative = false;
if (numerator.signum() == -1) {
numeratorPos = numerator.negate();
numeratorNegative = true;
}
BigInteger denominatorPos = denominator;
boolean denominatorNegative = false;
if (denominator.signum() == -1) {
denominatorPos = denominator.negate();
denominatorNegative = true;
}
boolean strobePage = true;
for (int i = 47; i >= 0; i--) {
int bankValue = numeratorPos.shiftRight(i * 12).and(FourCornerZion7Petroglyphs.MASK_BITS_12).intValue();
if (i == 47 && numeratorNegative) {
bankValue = (bankValue & 0x7FF) + 0x800;
}
if (bankValue == 0 && i > 0) {
strobePage = true; // skip zero values, so page again
continue;
}
if (strobePage) {
strobePage = false; // auto-- per value
outAdd(FourCornerDotCake.FC_NCR1632_SEL0N.getStart() + i);
}
outAdd(FourCornerDotCake.FC_NCR1632_BANK.getStart() + bankValue);
}
strobePage = true;
for (int i = 47; i >= 0; i--) {
int bankValue = denominatorPos.shiftRight(i * 12).and(FourCornerZion7Petroglyphs.MASK_BITS_12).intValue();
if (i == 47 && denominatorNegative) {
bankValue = (bankValue & 0x7FF) + 0x800;
}
if (bankValue == 0 && i > 0) {
strobePage = true;
continue;
}
if (strobePage) {
strobePage = false;
outAdd(FourCornerDotCake.FC_NCR1632_SEL1D.getStart() + i);
}
outAdd(FourCornerDotCake.FC_NCR1632_BANK.getStart() + bankValue);
}
outFlush();
requireBigPositive(denominator);
requireBigMax(denominator, BIG_BITS_2300);
requireBigNoneZero(denominator);
outAddBankCake12(192 + FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart(), FourCornerDotCake.FC_RATIONAL4608_BANK.getStart(), NCR_BANK_IDX_TOPPAGE_2304, numerator, v -> {
return (v & 0xFF) + (tasteMale.ordinal() << 8);
});
outAddBankCake12(FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart(), FourCornerDotCake.FC_RATIONAL4608_BANK.getStart(), NCR_BANK_IDX_TOPPAGE_2304, denominator, v -> {
return (v & 0xFF) + (tasteFemale.ordinal() << 8);
});
}
@Override
public void strobeNumberDEC576(BigInteger coefficient, BigInteger exponent) {
public void strobeNumberChocoPigDecimal(FCFlameNumberTaste taste, boolean bias, BigInteger power, BigInteger coefficient) {
Objects.requireNonNull(power);
Objects.requireNonNull(coefficient);
if (coefficient.compareTo(FourCornerZion7Petroglyphs.DEC576_COEFFICIENT_MAX) > 0) {
throw new IllegalArgumentException("DEC144 coefficient is larger than 503 bit: " + coefficient);
}
if (exponent.compareTo(FourCornerZion7Petroglyphs.DEC576_EXPONENT_MAX) > 0) {
throw new IllegalArgumentException("DEC144 exponent is larger than 71 bit: " + exponent);
}
BigInteger coefficientPos = coefficient;
boolean coefficientNegative = false;
if (coefficient.signum() == -1) {
coefficientPos = coefficient.negate();
coefficientNegative = true;
}
BigInteger exponentPos = exponent;
boolean exponentNegative = false;
if (exponent.signum() == -1) {
exponentPos = exponent.negate();
exponentNegative = true;
}
boolean strobePage = true;
for (int i = 47; i >= 0; i--) {
int bankValue = 0;
if (i > 5) {
bankValue = coefficientPos.shiftRight((i - 6) * 12).and(FourCornerZion7Petroglyphs.MASK_BITS_12).intValue();
} else {
bankValue = exponentPos.shiftRight(i * 12).and(FourCornerZion7Petroglyphs.MASK_BITS_12).intValue();
}
if (i == 47 && coefficientNegative) {
bankValue = (bankValue & 0x7FF) + 0x800;
}
if (i == 5 && exponentNegative) {
bankValue = (bankValue & 0x7FF) + 0x800;
}
if (bankValue == 0 && i > 0) {
strobePage = true; // skip zero values, so page again
continue;
}
if (strobePage) {
strobePage = false; // auto-- per value
outAdd(FourCornerDotCake.FC_DEC576_SEL0.getStart() + i);
}
outAdd(FourCornerDotCake.FC_DEC576_BANK.getStart() + bankValue);
}
requireBigPositive(power);
requireBigMax(power, BIG_BITS_284);
requireBigPositive(coefficient);
requireBigMax(coefficient, BIG_BITS_2016);
BigInteger pig = power.shiftLeft(2016).add(coefficient);
outAddBankCake12(FourCornerDotCake.FC_DECIMAL2304_SEL0.getStart(), FourCornerDotCake.FC_DECIMAL2304_BANK.getStart(), NCR_BANK_IDX_TOPPAGE_2304, pig, v -> {
return (v & 0x7F) + (taste.ordinal() << 8) + (bias ? 1 << 7 : 0);
});
}
@Override
public void strobeNumberE503M72(boolean negative, BigInteger exponent, BigInteger mantissa) {
public void strobeNumberChocoPigFloat(FCFlameNumberTaste taste, boolean bias, BigInteger exponent, BigInteger mantissa) {
Objects.requireNonNull(exponent);
Objects.requireNonNull(mantissa);
if (exponent.compareTo(FourCornerZion7Petroglyphs.E503M72_EXPONENT_MAX) > 0) {
throw new IllegalArgumentException("E503M72 exponent is larger than 72 bit: " + exponent);
}
if (exponent.signum() == -1) {
throw new IllegalArgumentException("E503M72 exponent is smaller than zero: " + exponent);
}
if (mantissa.compareTo(FourCornerZion7Petroglyphs.E503M72_MANTISSA_MAX) > 0) {
throw new IllegalArgumentException("E503M72 mantissa is larger than 503 bit: " + mantissa);
}
if (mantissa.signum() == -1) {
throw new IllegalArgumentException("E503M72 mantissa is smaller than zero: " + mantissa);
}
boolean strobePage = true;
for (int i = 47; i >= 0; i--) {
int bankValue = 0;
if (i > 41) {
bankValue = exponent.shiftRight((i - 42) * 12).and(FourCornerZion7Petroglyphs.MASK_BITS_12).intValue();
} else {
bankValue = mantissa.shiftRight(i * 12).and(FourCornerZion7Petroglyphs.MASK_BITS_12).intValue();
}
if (i == 47 && negative) {
bankValue = (bankValue & 0x7FF) + 0x800;
}
if (bankValue == 0 && i > 0) {
strobePage = true; // skip zero values, so page again
continue;
}
if (strobePage) {
strobePage = false; // auto-- per value
outAdd(FourCornerDotCake.FC_E503M72_SEL0.getStart() + i);
}
outAdd(FourCornerDotCake.FC_E503M72_BANK.getStart() + bankValue);
}
requireBigPositive(exponent);
requireBigMax(exponent, BIG_BITS_284);
requireBigPositive(mantissa);
requireBigMax(mantissa, BIG_BITS_2016);
BigInteger pig = exponent.shiftLeft(2016).add(mantissa);
outAddBankCake12(FourCornerDotCake.FC_FLOAT2304_SEL0.getStart(), FourCornerDotCake.FC_FLOAT2304_BANK.getStart(), NCR_BANK_IDX_TOPPAGE_2304, pig, v -> {
return (v & 0x7F) + (taste.ordinal() << 8) + (bias ? 1 << 7 : 0);
});
}
@Override
public void strobeNumberChocoPigFixed(FCFlameNumberTaste taste, BigInteger quake, BigInteger fraction) {
Objects.requireNonNull(quake);
Objects.requireNonNull(fraction);
requireBigPositive(quake);
requireBigMax(quake, BIG_BITS_1148);
requireBigPositive(fraction);
requireBigMax(fraction, BIG_BITS_1152);
BigInteger pig = quake.shiftLeft(1152).add(fraction);
outAddBankCake12(FourCornerDotCake.FC_FIXED2304_SEL0.getStart(), FourCornerDotCake.FC_FIXED2304_BANK.getStart(), NCR_BANK_IDX_TOPPAGE_2304, pig, v -> {
return (v & 0xFF) + (taste.ordinal() << 8);
});
}
}
}

511
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/FourCornerZionStenoLexer.java
View file

@ -28,7 +28,6 @@ import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import org.x4o.fc18.cake2.FourCornerDotCake;
import org.x4o.fc18.cake2.FourCornerDotCakeTower;
@ -40,12 +39,19 @@ import org.x4o.fc18.cake2.zero33.dec1.FCDotDEC0801DashE10;
import org.x4o.fc18.cake2.zero33.dec1.FCDotDEC2701DashPX0;
import org.x4o.fc18.cake2.zero33.dec1.FCDotINC0801DashP8;
import org.x4o.fc18.octal8.PrimordialOctal;
import org.x4o.fc18.zion7.flame4.FCFlameFremanChocoBase8;
import org.x4o.fc18.zion7.flame4.FCFlameFremanLegoBase2;
import org.x4o.fc18.zion7.flame4.FCFlameFremanLegoBase8;
import org.x4o.fc18.zion7.flame4.FCFlameFremanSignedBase2;
import org.x4o.fc18.zion7.flame4.FCFlameNumberTaste;
import org.x4o.fc18.zion7.flame4.FCFlameNumberGram;
import org.x4o.fc18.zion7.flame4.FCFlameNumberSparklerSmoke;
/// Parsed FC text and calls the handler methods for the classified strobe lights.
///
/// @author Willem Cazander
/// @version 1.0 Jan 09, 2025
public class FourCornerZionStenoLexer {
public class FourCornerZionStenoLexer implements FourCornerZionStenoPetroglyphs {
private final static FourCornerZionStenoLexerFire CLEAN_FIRE = new FourCornerZionStenoLexerFire.Adapter() {};
private final static FourCornerZionStenoLexerSmoke CLEAN_SMOKE = new FourCornerZionStenoLexerSmoke.Adapter() {};
@ -53,9 +59,7 @@ public class FourCornerZionStenoLexer {
private final boolean handlerEscape;
private final FourCornerZion7Candlelier handler;
private final FourCornerZion7TempleScrolls handlerTempleScrolls;
//private final short numberBank[] = new short[256]; // up to 9 bit values
private final int numeratorBank[] = new int[48];
private final int denominatorBank[] = new int[numeratorBank.length];
private final int numberBank[] = new int[NCR_BANK_SIZE];
private List<Integer> input;
private int inputIndex = 0;
private int currLine = 0;
@ -71,8 +75,11 @@ public class FourCornerZionStenoLexer {
private FourCornerZionStenoLexerFire fireSignals = CLEAN_FIRE;
static {
Iterator<FourCornerZion7FremanBase2> fremanBase2Itr = Arrays.asList(FourCornerZion7FremanBase2.values()).iterator();
Iterator<FourCornerZion7FremanBase8> fremanBase8Itr = Arrays.asList(FourCornerZion7FremanBase8.values()).iterator();
Iterator<FCFlameFremanLegoBase2> fremanBase2LegoItr = Arrays.asList(FCFlameFremanLegoBase2.values()).iterator();
Iterator<FCFlameFremanSignedBase2> fremanBase2IntItr = Arrays.asList(FCFlameFremanSignedBase2.values()).iterator();
Iterator<FCFlameFremanLegoBase8> fremanBase8LegoItr = Arrays.asList(FCFlameFremanLegoBase8.values()).iterator();
Iterator<FCFlameFremanChocoBase8> fremanBase8IntItr = Arrays.asList(FCFlameFremanChocoBase8.values()).iterator();
// fixme: inverse loop to multiple small sets
for (FourCornerDotCake cakeSlice : FourCornerDotCake.values()) {
if (cakeSlice.name().startsWith("__")) {
continue; // can't handle reserved, we be reported as
@ -100,38 +107,45 @@ public class FourCornerZionStenoLexer {
if (FourCornerDotCake.FC_SANDWORM_15.equals(cakeSlice)) {
continue; // parse nether body manually
}
if (FourCornerDotCake.FC_NCR1632_SEL0N.equals(cakeSlice)) {
if (FourCornerDotCake.FC_RATIONAL4608_SEL0.equals(cakeSlice)) {
continue; // parse block manually
}
if (FourCornerDotCake.FC_NCR1632_SEL1D.equals(cakeSlice)) {
if (FourCornerDotCake.FC_RATIONAL4608_BANK.equals(cakeSlice)) {
continue; // parse block manually
}
if (FourCornerDotCake.FC_NCR1632_BANK.equals(cakeSlice)) {
if (FourCornerDotCake.FC_DECIMAL2304_SEL0.equals(cakeSlice)) {
continue; // parse block manually
}
if (FourCornerDotCake.FC_DEC576_SEL0.equals(cakeSlice)) {
if (FourCornerDotCake.FC_DECIMAL2304_BANK.equals(cakeSlice)) {
continue; // parse block manually
}
if (FourCornerDotCake.FC_DEC576_BANK.equals(cakeSlice)) {
if (FourCornerDotCake.FC_FLOAT2304_SEL0.equals(cakeSlice)) {
continue; // parse block manually
}
if (FourCornerDotCake.FC_E503M72_SEL0.equals(cakeSlice)) {
if (FourCornerDotCake.FC_FLOAT2304_BANK.equals(cakeSlice)) {
continue; // parse block manually
}
if (FourCornerDotCake.FC_E503M72_BANK.equals(cakeSlice)) {
continue; // parse block manually
}
if (cakeSlice.name().startsWith("FC_BA") && cakeSlice.name().endsWith("_SEL0")) {
if (cakeSlice.name().endsWith("_SEL0") && cakeSlice.name().startsWith("FC_BA")) {
continue; // done by bank slices below
}
if (cakeSlice.name().startsWith("FC_BA2") && cakeSlice.name().endsWith("_BANK")) {
if (cakeSlice.name().startsWith("FC_BA2L") && cakeSlice.name().endsWith("_BANK")) {
FourCornerDotCake cakeSliceSel = FourCornerDotCake.valueOf(cakeSlice.ordinal() - 1);
CAKE_SLICE_EATERS.add(new StenoScannerNumberBase2(cakeSliceSel, cakeSlice, fremanBase2Itr.next()));
CAKE_SLICE_EATERS.add(new StenoScannerNumberBase2Lego(cakeSliceSel, cakeSlice, fremanBase2LegoItr.next()));
continue;
}
if (cakeSlice.name().startsWith("FC_BA8") && cakeSlice.name().endsWith("_BANK")) {
if (cakeSlice.name().startsWith("FC_BA2I") && cakeSlice.name().endsWith("_BANK")) {
FourCornerDotCake cakeSliceSel = FourCornerDotCake.valueOf(cakeSlice.ordinal() - 1);
CAKE_SLICE_EATERS.add(new StenoScannerNumberBase8(cakeSliceSel, cakeSlice, fremanBase8Itr.next()));
CAKE_SLICE_EATERS.add(new StenoScannerNumberBase2Int(cakeSliceSel, cakeSlice, fremanBase2IntItr.next()));
continue;
}
if (cakeSlice.name().startsWith("FC_BA8L") && cakeSlice.name().endsWith("_BANK")) {
FourCornerDotCake cakeSliceSel = FourCornerDotCake.valueOf(cakeSlice.ordinal() - 1);
CAKE_SLICE_EATERS.add(new StenoScannerNumberBase8Lego(cakeSliceSel, cakeSlice, fremanBase8LegoItr.next()));
continue;
}
if (cakeSlice.name().startsWith("FC_BA8C") && cakeSlice.name().endsWith("_BANK")) {
FourCornerDotCake cakeSliceSel = FourCornerDotCake.valueOf(cakeSlice.ordinal() - 1);
CAKE_SLICE_EATERS.add(new StenoScannerNumberBase8Choco(cakeSliceSel, cakeSlice, fremanBase8IntItr.next()));
continue;
}
if (FourCornerDotCakeTower.TXT_GRAMS.equals(cakeSlice.tower())) {
@ -141,9 +155,10 @@ public class FourCornerZionStenoLexer {
CAKE_SLICE_EATERS.add(new StenoScannerWordCakeSlice(cakeSlice));
}
CAKE_SLICE_EATERS.add(new StenoScannerSandWorm());
CAKE_SLICE_EATERS.add(new StenoScannerNumberNCR1632());
CAKE_SLICE_EATERS.add(new StenoScannerNumberDEC576());
CAKE_SLICE_EATERS.add(new StenoScannerNumberE503M72());
CAKE_SLICE_EATERS.add(new StenoScannerNumberChocoRational());
CAKE_SLICE_EATERS.add(new StenoScannerNumberChocoDecimal());
CAKE_SLICE_EATERS.add(new StenoScannerNumberChocoFloat());
CAKE_SLICE_EATERS.add(new StenoScannerNumberChocoFixed());
ArrayList.class.cast(CAKE_SLICE_EATERS).trimToSize();
}
@ -235,37 +250,6 @@ public class FourCornerZionStenoLexer {
return true;
}
private void ncrBankFire() {
boolean numeratorNegetive = false;
boolean denominatorNegetive = false;
if ((numeratorBank[47] & 0x800) == 0x800) {
numeratorNegetive = true;
numeratorBank[47] = numeratorBank[47] & 0x7FF;
}
if ((denominatorBank[47] & 0x800) == 0x800) {
denominatorNegetive = true;
denominatorBank[47] = denominatorBank[47] & 0x7FF;
}
BigInteger numerator = BigInteger.ZERO;
BigInteger denominator = BigInteger.ZERO;
for (int i = 0; i < numeratorBank.length; i++) {
numerator = numerator.add(BigInteger.valueOf(numeratorBank[i]).shiftLeft(i * 12));
denominator = denominator.add(BigInteger.valueOf(denominatorBank[i]).shiftLeft(i * 12));
}
if (numeratorNegetive) {
numerator = numerator.negate();
}
if (denominatorNegetive) {
denominator = denominator.negate();
}
handler.strobeNumberNCR1632(numerator, denominator);
// reset the bank after each fire
for (int i = 0; i < numeratorBank.length; i++) {
numeratorBank[i] = 0;
denominatorBank[i] = 0;
}
}
private void decModeReset() {
cdcDECMode = null;
cdcDECModeInc = null;
@ -274,7 +258,46 @@ public class FourCornerZionStenoLexer {
cdcDECModePieAlt = null;
}
abstract static private class StenoScanner {
private void numberBankReset() {
for (int i = NCR_BANK_SIZE - NCR_ONE; i >= NCR_ZERO; i--) {
numberBank[i] = NCR_ZERO;
}
}
private FCFlameNumberTaste numberBankEatTasteBits8Plus(int bankIdx) {
FCFlameNumberTaste taste = FCFlameNumberTaste.valueOf(numberBank[bankIdx] >> 8);
numberBank[bankIdx] = numberBank[bankIdx] & 0xFF; // <== eating
return taste;
}
private boolean numberBankEatBit7(int bankIdx) {
boolean result = (numberBank[bankIdx] & 0x80) == 0x80;
numberBank[bankIdx] = numberBank[bankIdx] & 0xF7F;
return result;
}
private BigInteger numberBankReadBigPaged(int bankBits, int bankPageBegin) {
BigInteger result = BigInteger.ZERO;
for (int i = bankPageBegin; i >= NCR_ZERO; i--) {
int bankValue = numberBank[i];
result = result.add(BigInteger.valueOf(bankValue).shiftLeft(i * bankBits));
}
return result;
}
private BigInteger numberBankReadBig8(int bankPageBegin) {
return numberBankReadBigPaged(NCR_BANK8_BITS, bankPageBegin);
}
private BigInteger numberBankReadBig9(int bankPageBegin) {
return numberBankReadBigPaged(NCR_BANK9_BITS, bankPageBegin);
}
private BigInteger numberBankReadBig12(int bankPageBegin) {
return numberBankReadBigPaged(NCR_BANK12_BITS, bankPageBegin);
}
abstract static private class StenoScanner implements FourCornerZionStenoPetroglyphs {
protected final int blockStart;
protected final int blockStop;
@ -288,7 +311,7 @@ public class FourCornerZionStenoLexer {
this(cakeSlice.getStart(), cakeSlice.getStop());
}
final public ScanResult scan(FourCornerZionStenoLexer lexer) {
public final ScanResult scan(FourCornerZionStenoLexer lexer) {
if (lexer.inputIndex >= lexer.input.size()) {
return ScanResult.EOF; // only for empty input with size zero
}
@ -316,7 +339,52 @@ public class FourCornerZionStenoLexer {
return result;
}
abstract void process(FourCornerZionStenoLexer lexer, int idxFirst, int idxLast);
abstract protected void process(FourCornerZionStenoLexer lexer, int idxFirst, int idxLast);
}
abstract static private class StenoScannerNumberBank extends StenoScanner {
protected final FourCornerDotCake cakeSliceSel;
protected final int numberBankTop;
protected final int numberBankCakePointOffset;
protected final FCFlameNumberSparklerSmoke smokeSparkler;
public StenoScannerNumberBank(FourCornerDotCake cakeSliceSel, FourCornerDotCake cakeSliceBank, int numberBankSize, FCFlameNumberSparklerSmoke smokeSparkler) {
super(cakeSliceSel.getStart(), cakeSliceBank.getStop());
this.cakeSliceSel = Objects.requireNonNull(cakeSliceSel);
this.numberBankTop = numberBankSize - NCR_ONE;
this.numberBankCakePointOffset = cakeSliceBank.getStart();
this.smokeSparkler = Objects.requireNonNull(smokeSparkler);
}
@Override
protected final void process(FourCornerZionStenoLexer lexer, int idxFirst, int idxLast) {
lexer.numberBankReset();
int valueBankIndex = numberBankTop;
boolean missingSparkler = true;
for (int i = idxFirst; i <= idxLast; i++) {
int cakePoint = lexer.input.get(i);
if (cakePoint >= cakeSliceSel.getStart() && cakePoint <= cakeSliceSel.getStop()) {
valueBankIndex = cakePoint - cakeSliceSel.getStart();
missingSparkler = true;
continue;
}
lexer.numberBank[valueBankIndex] = cakePoint - numberBankCakePointOffset;
valueBankIndex--;
missingSparkler = true;
if (valueBankIndex < NCR_ZERO) {
valueBankIndex = numberBankTop;
missingSparkler = false;
processBankZero(lexer);
lexer.numberBankReset();
}
}
if (missingSparkler) {
lexer.smokeSignals.burnNumberMissingSparkler(lexer.currLine, lexer.currCol, smokeSparkler);
}
}
abstract protected void processBankZero(FourCornerZionStenoLexer lexer);
}
static final class StenoScannerWordCakeSlice extends StenoScanner {
@ -335,99 +403,66 @@ public class FourCornerZionStenoLexer {
}
}
static final class StenoScannerNumberBase2 extends StenoScanner {
static final class StenoScannerNumberBase2Lego extends StenoScannerNumberBank {
private final FourCornerDotCake cakeSliceSel;
private final FourCornerZion7FremanBase2 numberFreman;
private final int numberFremanBankMax;
private final FCFlameFremanLegoBase2 numberFreman;
public StenoScannerNumberBase2(FourCornerDotCake cakeSliceSel, FourCornerDotCake cakeSliceBank, FourCornerZion7FremanBase2 numberFreman) {
super(cakeSliceSel.getStart(), cakeSliceBank.getStop());
this.cakeSliceSel = cakeSliceSel;
public StenoScannerNumberBase2Lego(FourCornerDotCake cakeSliceSel, FourCornerDotCake cakeSliceBank, FCFlameFremanLegoBase2 numberFreman) {
super(cakeSliceSel, cakeSliceBank, numberFreman.bytes(), FCFlameNumberSparklerSmoke.BASE2_LEGO);
this.numberFreman = numberFreman;
this.numberFremanBankMax = numberFreman.bytes() - 1;
}
@Override
public void process(FourCornerZionStenoLexer lexer, int idxFirst, int idxLast) {
int valueBank[] = new int[256]; // TODO: move to lexer
int valueBankIndex = numberFremanBankMax;
for (int i = idxFirst; i <= idxLast; i++) {
int cakePoint = lexer.input.get(i);
if (cakePoint >= cakeSliceSel.getStart() && cakePoint <= cakeSliceSel.getStop()) {
valueBankIndex = cakePoint - cakeSliceSel.getStart();
continue;
}
valueBank[valueBankIndex] = cakePoint - (cakeSliceSel.getStop() + 1);
valueBankIndex--;
if (valueBankIndex < 0) {
valueBankIndex = numberFremanBankMax;
boolean valueNegative = false;
if (numberFreman.isSigned() && (valueBank[numberFremanBankMax] & 0x80) == 0x80) {
valueNegative = true;
valueBank[numberFremanBankMax] = valueBank[numberFremanBankMax] & 0x7F;
}
BigInteger valueNumber = BigInteger.ZERO;
for (int ii = numberFremanBankMax; ii >= 0; ii--) {
valueNumber = valueNumber.add(BigInteger.valueOf(valueBank[ii]).shiftLeft(ii * 8));
}
if (valueNegative) {
valueNumber = valueNumber.negate();
}
lexer.handler.strobeNumberBASE2(numberFreman, valueNumber);
for (int ii = 0; ii < valueBank.length; ii++) {
valueBank[ii] = 0;
}
}
}
protected void processBankZero(FourCornerZionStenoLexer lexer) {
lexer.handler.strobeNumberBASE2Lego(numberFreman, lexer.numberBankReadBig8(numberBankTop));
}
}
static final class StenoScannerNumberBase8 extends StenoScanner {
static final class StenoScannerNumberBase2Int extends StenoScannerNumberBank {
private final FourCornerDotCake cakeSliceSel;
private final FourCornerZion7FremanBase8 numberFreman;
private final int numberFremanBankMax;
private final FCFlameFremanSignedBase2 numberFreman;
public StenoScannerNumberBase8(FourCornerDotCake cakeSliceSel, FourCornerDotCake cakeSliceBank, FourCornerZion7FremanBase8 numberFreman) {
super(cakeSliceSel.getStart(), cakeSliceBank.getStop());
this.cakeSliceSel = cakeSliceSel;
public StenoScannerNumberBase2Int(FourCornerDotCake cakeSliceSel, FourCornerDotCake cakeSliceBank, FCFlameFremanSignedBase2 numberFreman) {
super(cakeSliceSel, cakeSliceBank, numberFreman.bytes(), FCFlameNumberSparklerSmoke.BASE2_INT);
this.numberFreman = numberFreman;
this.numberFremanBankMax = (numberFreman.octals()/3) - 1;
}
@Override
public void process(FourCornerZionStenoLexer lexer, int idxFirst, int idxLast) {
int valueBank[] = new int[256]; // TODO: move to lexer
int valueBankIndex = numberFremanBankMax;
for (int i = idxFirst; i <= idxLast; i++) {
int cakePoint = lexer.input.get(i);
if (cakePoint >= cakeSliceSel.getStart() && cakePoint <= cakeSliceSel.getStop()) {
valueBankIndex = cakePoint - cakeSliceSel.getStart();
continue;
}
valueBank[valueBankIndex] = cakePoint - (cakeSliceSel.getStop() + 1);
valueBankIndex--;
if (valueBankIndex < 0) {
valueBankIndex = numberFremanBankMax;
boolean valueNegative = false;
if (numberFreman.isSigned() && (valueBank[numberFremanBankMax] & 0x100) == 0x100) {
valueNegative = true;
valueBank[numberFremanBankMax] = valueBank[numberFremanBankMax] & 0xFF;
}
BigInteger valueNumber = BigInteger.ZERO;
for (int ii = numberFremanBankMax; ii >= 0; ii--) {
valueNumber = valueNumber.add(BigInteger.valueOf(valueBank[ii]).shiftLeft(ii * 9));
}
if (valueNegative) {
valueNumber = valueNumber.negate();
}
lexer.handler.strobeNumberBASE8(numberFreman, valueNumber);
for (int ii = 0; ii < valueBank.length; ii++) {
valueBank[ii] = 0;
}
}
}
protected void processBankZero(FourCornerZionStenoLexer lexer) {
boolean sign = lexer.numberBankEatBit7(numberBankTop);
lexer.handler.strobeNumberBASE2Int(numberFreman, sign, lexer.numberBankReadBig8(numberBankTop));
}
}
static final class StenoScannerNumberBase8Lego extends StenoScannerNumberBank {
private final FCFlameFremanLegoBase8 numberFreman;
public StenoScannerNumberBase8Lego(FourCornerDotCake cakeSliceSel, FourCornerDotCake cakeSliceBank, FCFlameFremanLegoBase8 numberFreman) {
super(cakeSliceSel, cakeSliceBank, numberFreman.octals() / 3, FCFlameNumberSparklerSmoke.BASE8_LEGO);
this.numberFreman = numberFreman;
}
@Override
protected void processBankZero(FourCornerZionStenoLexer lexer) {
lexer.handler.strobeNumberBASE8Lego(numberFreman, lexer.numberBankReadBig9(numberBankTop));
}
}
static final class StenoScannerNumberBase8Choco extends StenoScannerNumberBank {
private final FCFlameFremanChocoBase8 numberFreman;
public StenoScannerNumberBase8Choco(FourCornerDotCake cakeSliceSel, FourCornerDotCake cakeSliceBank, FCFlameFremanChocoBase8 numberFreman) {
super(cakeSliceSel, cakeSliceBank, numberFreman.octals() / 3, FCFlameNumberSparklerSmoke.BASE8_CHOCO);
this.numberFreman = numberFreman;
}
@Override
protected void processBankZero(FourCornerZionStenoLexer lexer) {
FCFlameNumberTaste valueChoco = FCFlameNumberTaste.valueOf(lexer.numberBank[numberBankTop] >> 5);
lexer.numberBank[numberBankTop] = lexer.numberBank[numberBankTop] & 0x1F;
lexer.handler.strobeNumberBASE8Choco(numberFreman, valueChoco, lexer.numberBankReadBig9(numberBankTop));
}
}
@ -469,7 +504,7 @@ public class FourCornerZionStenoLexer {
sandSpice.add(PrimordialOctal.valueOf((bitValue15 >> 3) & 0b111));
sandSpice.add(PrimordialOctal.valueOf((bitValue15 >> 0) & 0b111));
}
if (!FourCornerZion7Petroglyphs.SAND_WORM_SIGNS.contains(sandWalk.size())) {
if (!FourCornerZionStenoPetroglyphs.SAND_WORM_SIGNS.contains(sandWalk.size())) {
lexer.smokeSignals.burnSandWalkerStepUnaligned(lexer.currLine, lexer.currCol, -1); // TODO: fixme
} else {
lexer.handler.strobeSandWorm(sandWalk, sandSpice);
@ -479,11 +514,11 @@ public class FourCornerZionStenoLexer {
static final class StenoScannerNumberGramSlice extends StenoScanner {
private final FourCornerZion7NumberGram numberGram;
private final FCFlameNumberGram numberGram;
public StenoScannerNumberGramSlice(FourCornerDotCake cakeSlice) {
super(cakeSlice);
this.numberGram = FourCornerZion7NumberGram.valueByCutCount(cakeSlice.getStop() - cakeSlice.getStart());
this.numberGram = FCFlameNumberGram.valueByCutCount(cakeSlice.getStop() - cakeSlice.getStart());
}
@Override
@ -496,162 +531,70 @@ public class FourCornerZionStenoLexer {
}
}
static final class StenoScannerNumberNCR1632 extends StenoScanner {
static final class StenoScannerNumberChocoRational extends StenoScannerNumberBank {
public StenoScannerNumberNCR1632() {
super(FourCornerDotCake.FC_NCR1632_SEL0N.getStart(), FourCornerDotCake.FC_NCR1632_BANK.getStop());
public StenoScannerNumberChocoRational() {
super(FourCornerDotCake.FC_RATIONAL4608_SEL0, FourCornerDotCake.FC_RATIONAL4608_BANK, NCR_BANK12_SIZE * 2, FCFlameNumberSparklerSmoke.CHOCO_RATIONAL);
}
@Override
public void process(FourCornerZionStenoLexer lexer, int idxFirst, int idxLast) {
boolean missingSparkler = true;
boolean numOrDen = true;
int pageX = -1;
for (int i = idxFirst; i <= idxLast; i++) {
int cakePoint = lexer.input.get(i);
if (cakePoint >= FourCornerDotCake.FC_NCR1632_SEL0N.getStart() && cakePoint <= FourCornerDotCake.FC_NCR1632_SEL0N.getStop()) {
pageX = cakePoint - FourCornerDotCake.FC_NCR1632_SEL0N.getStart();
numOrDen = true;
continue;
}
if (cakePoint >= FourCornerDotCake.FC_NCR1632_SEL1D.getStart() && cakePoint <= FourCornerDotCake.FC_NCR1632_SEL1D.getStop()) {
pageX = cakePoint - FourCornerDotCake.FC_NCR1632_SEL1D.getStart();
numOrDen = false;
continue;
}
if (pageX == -1) {
// smoke signal
continue;
}
int valueX = cakePoint - FourCornerDotCake.FC_NCR1632_BANK.getStart();
if (numOrDen) {
lexer.numeratorBank[pageX] = valueX;
} else {
lexer.denominatorBank[pageX] = valueX;
}
if (numOrDen || pageX > 0) {
pageX--;
missingSparkler = true;
continue; // Only fire fraction on lowest value select
}
lexer.ncrBankFire();
pageX = -1;
missingSparkler = false;
}
if (missingSparkler) {
lexer.smokeSignals.burnNumberNCR1632MissingSparkler(lexer.currLine, lexer.currCol);
}
public void processBankZero(FourCornerZionStenoLexer lexer) {
FCFlameNumberTaste tasteMale = lexer.numberBankEatTasteBits8Plus(NCR_BANK_IDX_TOPPAGE_4608);
FCFlameNumberTaste tasteFemale = lexer.numberBankEatTasteBits8Plus(NCR_BANK_IDX_TOPPAGE_2304);
BigInteger marriedPig = lexer.numberBankReadBig12(numberBankTop);
BigInteger numerator = marriedPig.shiftRight(2304);
BigInteger denominator = marriedPig.and(BIG_BITS_2304);
lexer.handler.strobeNumberChocoMarriedPigsRational(tasteMale, tasteFemale, numerator, denominator);
}
}
static final class StenoScannerNumberDEC576 extends StenoScanner {
static final class StenoScannerNumberChocoDecimal extends StenoScannerNumberBank {
public StenoScannerNumberDEC576() {
super(FourCornerDotCake.FC_DEC576_SEL0.getStart(), FourCornerDotCake.FC_DEC576_BANK.getStop());
public StenoScannerNumberChocoDecimal() {
super(FourCornerDotCake.FC_DECIMAL2304_SEL0, FourCornerDotCake.FC_DECIMAL2304_BANK, NCR_BANK12_SIZE, FCFlameNumberSparklerSmoke.CHOCO_DECIMAL);
}
@Override
public void process(FourCornerZionStenoLexer lexer, int idxFirst, int idxLast) {
int valueBank[] = new int[48];
boolean missingSparkler = true;
int pageX = -1;
for (int i = idxFirst; i <= idxLast; i++) {
int cakePoint = lexer.input.get(i);
if (cakePoint >= FourCornerDotCake.FC_DEC576_SEL0.getStart() && cakePoint <= FourCornerDotCake.FC_DEC576_SEL0.getStop()) {
pageX = cakePoint - FourCornerDotCake.FC_DEC576_SEL0.getStart();
continue;
}
if (pageX == -1) {
// smoke signal
continue;
}
int valueX = cakePoint - FourCornerDotCake.FC_DEC576_BANK.getStart();
valueBank[pageX] = valueX;
pageX--;
if (pageX > 0) {
missingSparkler = true;
continue;
}
BigInteger coefficient = BigInteger.ZERO;
BigInteger exponent = BigInteger.ZERO;
for (int ii = 47; ii >= 0; ii--) {
if (ii > 5) {
coefficient = coefficient.add(BigInteger.valueOf(valueBank[ii]).shiftLeft((ii - 6) * 12));
} else {
exponent = exponent.add(BigInteger.valueOf(valueBank[ii]).shiftLeft(ii * 12));
}
}
if ((valueBank[47] & 0x800) == 0x800) {
coefficient = coefficient.negate();
}
if ((valueBank[5] & 0x800) == 0x800) {
exponent = exponent.negate();
}
lexer.handler.strobeNumberDEC576(coefficient, exponent);
for (int ii = 0; ii < valueBank.length; ii++) {
valueBank[ii] = 0;
}
pageX = -1;
missingSparkler = false;
}
if (missingSparkler) {
lexer.smokeSignals.burnNumberDEC576MissingSparkler(lexer.currLine, lexer.currCol);
}
public void processBankZero(FourCornerZionStenoLexer lexer) {
FCFlameNumberTaste taste = lexer.numberBankEatTasteBits8Plus(numberBankTop);
boolean bias = lexer.numberBankEatBit7(numberBankTop);
BigInteger pig = lexer.numberBankReadBig12(numberBankTop);
BigInteger power = pig.shiftRight(2016);
BigInteger coefficient = pig.and(BIG_BITS_2016);
lexer.handler.strobeNumberChocoPigDecimal(taste, bias, power, coefficient);
}
}
static final class StenoScannerNumberE503M72 extends StenoScanner {
static final class StenoScannerNumberChocoFloat extends StenoScannerNumberBank {
public StenoScannerNumberE503M72() {
super(FourCornerDotCake.FC_E503M72_SEL0.getStart(), FourCornerDotCake.FC_E503M72_BANK.getStop());
public StenoScannerNumberChocoFloat() {
super(FourCornerDotCake.FC_FLOAT2304_SEL0, FourCornerDotCake.FC_FLOAT2304_BANK, NCR_BANK12_SIZE, FCFlameNumberSparklerSmoke.CHOCO_FLOAT);
}
@Override
public void process(FourCornerZionStenoLexer lexer, int idxFirst, int idxLast) {
int valueBank[] = new int[48];
boolean missingSparkler = true;
int pageX = -1;
for (int i = idxFirst; i <= idxLast; i++) {
int cakePoint = lexer.input.get(i);
if (cakePoint >= FourCornerDotCake.FC_E503M72_SEL0.getStart() && cakePoint <= FourCornerDotCake.FC_E503M72_SEL0.getStop()) {
pageX = cakePoint - FourCornerDotCake.FC_E503M72_SEL0.getStart();
continue;
}
if (pageX == -1) {
// smoke signal
continue;
}
int valueX = cakePoint - FourCornerDotCake.FC_E503M72_BANK.getStart();
valueBank[pageX] = valueX;
pageX--;
if (pageX > 0) {
missingSparkler = true;
continue;
}
boolean negative = false;
if ((valueBank[47] & 0x800) == 0x800) {
negative = true;
valueBank[47] = valueBank[47] & 0x7FF;
}
BigInteger exponent = BigInteger.ZERO;
BigInteger mantissa = BigInteger.ZERO;
for (int ii = 47; ii >= 0; ii--) {
if (ii > 41) {
exponent = exponent.add(BigInteger.valueOf(valueBank[ii]).shiftLeft((ii - 42) * 12));
} else {
mantissa = mantissa.add(BigInteger.valueOf(valueBank[ii]).shiftLeft(ii * 12));
}
}
lexer.handler.strobeNumberE503M72(negative, exponent, mantissa);
for (int ii = 0; ii < valueBank.length; ii++) {
valueBank[ii] = 0;
}
pageX = -1;
missingSparkler = false;
}
if (missingSparkler) {
lexer.smokeSignals.burnNumberE503M72MissingSparkler(lexer.currLine, lexer.currCol);
}
public void processBankZero(FourCornerZionStenoLexer lexer) {
FCFlameNumberTaste taste = lexer.numberBankEatTasteBits8Plus(numberBankTop);
boolean bias = lexer.numberBankEatBit7(numberBankTop);
BigInteger pig = lexer.numberBankReadBig12(numberBankTop);
BigInteger exponent = pig.shiftRight(2016);
BigInteger mantissa = pig.and(BIG_BITS_2016);
lexer.handler.strobeNumberChocoPigFloat(taste, bias, exponent, mantissa);
}
}
static final class StenoScannerNumberChocoFixed extends StenoScannerNumberBank {
public StenoScannerNumberChocoFixed() {
super(FourCornerDotCake.FC_FIXED2304_SEL0, FourCornerDotCake.FC_FIXED2304_BANK, NCR_BANK12_SIZE, FCFlameNumberSparklerSmoke.CHOCO_FIXED);
}
@Override
public void processBankZero(FourCornerZionStenoLexer lexer) {
FCFlameNumberTaste taste = lexer.numberBankEatTasteBits8Plus(numberBankTop);
BigInteger pig = lexer.numberBankReadBig12(numberBankTop);
BigInteger quake = pig.shiftRight(1152);
BigInteger fraction = pig.and(BIG_BITS_1152);
lexer.handler.strobeNumberChocoPigFixed(taste, quake, fraction);
}
}
@ -661,10 +604,6 @@ public class FourCornerZionStenoLexer {
super(cakeSlice);
}
//public StenoScannerCDCDEC() {
// super(FourCornerDotCake.FC_CDC1604_P6.getStart(), FourCornerDotCake.FC_DEC2701_PX0.getStop());
//}
@Override
public void process(FourCornerZionStenoLexer lexer, int idxFirst, int idxLast) {
lexer.decModeReset();
@ -679,11 +618,6 @@ public class FourCornerZionStenoLexer {
}
int cdcDECPoint = lexer.input.get(lexer.cdcDECScanIndex);
lexer.handler.strobeTheWord(cdcDECPoint);
// if (FourCornerDotCake.FC_DEC2701_PX0.contains(cdcDECPoint)) {
// lexer.handler.strobeWord(FourCornerDotCake.FC_DEC2701_PX0, cdcDECPoint - FourCornerDotCake.FC_DEC2701_PX0.getStart());
// } else {
// lexer.handler.strobeWord(FourCornerDotCake.FC_CDC1604_P6, cdcDECPoint);
// }
}
}
@ -861,13 +795,12 @@ public class FourCornerZionStenoLexer {
private boolean handleCMD(FourCornerZionStenoLexer lexer) {
int cdcPoint = lexer.input.get(lexer.cdcDECScanIndex);
Optional<FCDotCMD5401Dash2D> cmdModeOpt = FCDotCMD5401Dash2D.valueOfCDC(cdcPoint);
if (cmdModeOpt.isEmpty()) {
FCDotCMD5401Dash2D cmdMode = FCDotCMD5401Dash2D.valueOfCDC(cdcPoint);
if (cmdMode == null) {
lexer.decModeReset();
lexer.smokeSignals.burnControlCommandUnsupported(lexer.currLine, lexer.currCol, cdcPoint);
return false;
}
FCDotCMD5401Dash2D cmdMode = cmdModeOpt.get();
if (FCDotCMD5401Dash2D.CMD_F4TXT0001_SP.equals(cmdMode)) {
lexer.decModeReset();
//lexer.handler.strobeWord(FourCornerDotCake.FC_F4TXT0001_SP, 0); // white space

31
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/FourCornerZionStenoLexerSmoke.java
View file

@ -22,6 +22,8 @@
*/
package org.x4o.fc18.zion7;
import org.x4o.fc18.zion7.flame4.FCFlameNumberSparklerSmoke;
/// Provides lexer smoke signals feedback.
///
/// @author Willem Cazander
@ -42,11 +44,8 @@ public interface FourCornerZionStenoLexerSmoke {
void burnSandWalkerStepUnaligned(int line, int col, int size);
void burnNumberNCR1632MissingSparkler(int line, int col);
void burnNumberDEC576MissingSparkler(int line, int col);
void burnNumberE503M72MissingSparkler(int line, int col);
void burnNumberMissingSparkler(int line, int col, FCFlameNumberSparklerSmoke sparkler);
interface Adapter extends FourCornerZionStenoLexerSmoke {
@ -75,15 +74,7 @@ public interface FourCornerZionStenoLexerSmoke {
}
@Override
default void burnNumberNCR1632MissingSparkler(int line, int col) {
}
@Override
default void burnNumberDEC576MissingSparkler(int line, int col) {
}
@Override
default void burnNumberE503M72MissingSparkler(int line, int col) {
default void burnNumberMissingSparkler(int line, int col, FCFlameNumberSparklerSmoke sparkler) {
}
}
@ -122,18 +113,8 @@ public interface FourCornerZionStenoLexerSmoke {
}
@Override
default void burnNumberNCR1632MissingSparkler(int line, int col) {
burnMonoPipe(line, col, "burnNumberNCR1632MissingSparkler");
}
@Override
default void burnNumberDEC576MissingSparkler(int line, int col) {
burnMonoPipe(line, col, "burnNumberDEC576MissingSparkler");
}
@Override
default void burnNumberE503M72MissingSparkler(int line, int col) {
burnMonoPipe(line, col, "burnNumberE503M72MissingSparkler");
default void burnNumberMissingSparkler(int line, int col, FCFlameNumberSparklerSmoke sparkler) {
burnMonoPipe(line, col, "burnNumberMissingSparkler:"+sparkler.name());
}
}
}

92
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/FourCornerZionStenoPetroglyphs.java Normal file
View file

@ -0,0 +1,92 @@
/*
* Copyright (c) 2004-2014, Willem Cazander
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided
* that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the
* following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
* the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.x4o.fc18.zion7;
import java.math.BigInteger;
import java.util.List;
/// Rock carvings of special variables.
///
/// @author Willem Cazander
/// @version 1.0 Aug 24, 2025
public interface FourCornerZionStenoPetroglyphs {
static final List<Integer> SAND_WORM_SIGNS = List.of(24,48,72,96,120,144,168,192);
static final BigInteger BIG_BITS_3 = valueOfBitMaskBig(3);
static final BigInteger BIG_BITS_8 = valueOfBitMaskBig(8);
static final BigInteger BIG_BITS_9 = valueOfBitMaskBig(9);
static final BigInteger BIG_BITS_12 = valueOfBitMaskBig(12);
static final BigInteger BIG_BITS_284 = valueOfBitMaskBig(284);
static final BigInteger BIG_BITS_1148 = valueOfBitMaskBig(1148);
static final BigInteger BIG_BITS_1152 = valueOfBitMaskBig(1152);
static final BigInteger BIG_BITS_2016 = valueOfBitMaskBig(2016);
static final BigInteger BIG_BITS_2300 = valueOfBitMaskBig(2300);
static final BigInteger BIG_BITS_2304 = valueOfBitMaskBig(2304);
static final int CAKE_POINT_MAX_FC18 = valueOfBitMaskInt(18);
static final int CAKE_POINT_MAX_FC6 = valueOfBitMaskInt(6);
static final int NCR_ZERO = 0;
static final int NCR_ONE = 1;
static final int NCR_SIGNUM_NEGATIVE = -NCR_ONE;
static final int NCR_BANK8_BITS = 8;
static final int NCR_BANK9_BITS = 9;
static final int NCR_BANK12_BITS = 12;
static final int NCR_BANK12_SIZE = 192;
static final int NCR_BANK_IDX_TOPPAGE_288 = 288 / NCR_BANK12_BITS - NCR_ONE;
static final int NCR_BANK_IDX_TOPPAGE_1152 = 1152 / NCR_BANK12_BITS - NCR_ONE;
static final int NCR_BANK_IDX_TOPPAGE_2304 = 2304 / NCR_BANK12_BITS - NCR_ONE;
static final int NCR_BANK_IDX_TOPPAGE_4608 = 4608 / NCR_BANK12_BITS - NCR_ONE;
/// max used for 256*9bit and 384*12bit
static final int NCR_BANK_SIZE = NCR_BANK12_SIZE + NCR_BANK12_SIZE;
static private String valueOfBitMaskString(int zirri, int zorro) {
StringBuilder buf = new StringBuilder();
for (int i = zirri; i > NCR_ZERO; i--) {
buf.append('1');
}
for (int i = zorro; i > NCR_ZERO; i--) {
buf.append('0');
}
return buf.toString();
}
static public BigInteger valueOfBitMaskBig(int zirri) {
return valueOfBitMaskBig(zirri, NCR_ZERO);
}
static public BigInteger valueOfBitMaskBig(int zirri, int zorro) {
return new BigInteger(valueOfBitMaskString(zirri, zorro), 2);
}
static public Integer valueOfBitMaskInt(int zirri) {
return valueOfBitMaskInt(zirri, NCR_ZERO);
}
static public Integer valueOfBitMaskInt(int zirri, int zorro) {
return Integer.valueOf(valueOfBitMaskString(zirri, zorro), 2);
}
}

84
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/flame4/FCFlameFremanChocoBase8.java Normal file
View file

@ -0,0 +1,84 @@
/*
* Copyright (c) 2004-2014, Willem Cazander
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided
* that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the
* following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
* the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.x4o.fc18.zion7.flame4;
import java.math.BigInteger;
import org.x4o.fc18.cake2.FourCornerDotCake;
import org.x4o.fc18.zion7.FourCornerZionStenoPetroglyphs;
/// The supported choco sand dune formations.
///
/// @author Willem Cazander
/// @version 1.0 Sep 3, 2025
public enum FCFlameFremanChocoBase8 implements FCFlameFremanSuit {
CHOCO_0018(6, FourCornerDotCake.FC_BA8C0018_BANK),
CHOCO_0036(12, FourCornerDotCake.FC_BA8C0036_BANK),
CHOCO_0072(24, FourCornerDotCake.FC_BA8C0072_BANK),
CHOCO_0144(48, FourCornerDotCake.FC_BA8C0144_BANK),
CHOCO_0288(96, FourCornerDotCake.FC_BA8C0288_BANK),
CHOCO_0576(192, FourCornerDotCake.FC_BA8C0576_BANK),
CHOCO_1152(384, FourCornerDotCake.FC_BA8C1152_BANK),
CHOCO_2304(768, FourCornerDotCake.FC_BA8C2304_BANK),
;
private static final FCFlameFremanChocoBase8[] VALUES = values();
private final int cakeOffsetSel0;
private final int cakeOffsetBank;
private final int octals;
private final BigInteger maxWaterLevel;
private FCFlameFremanChocoBase8(int octals, FourCornerDotCake cakeSlice) {
this.octals = octals;
this.cakeOffsetSel0 = cakeSlice.getStart() - (octals/3);
this.cakeOffsetBank = cakeSlice.getStart();
this.maxWaterLevel = FourCornerZionStenoPetroglyphs.valueOfBitMaskBig((octals * 3) - 4); // remove 4 bit choco
}
@Override
public int cakeOffsetSel0() {
return cakeOffsetSel0;
}
@Override
public int cakeOffsetBank() {
return cakeOffsetBank;
}
@Override
public BigInteger maxWaterLevel() {
return maxWaterLevel;
}
public int octals() {
return octals;
}
static public int valuesLength() {
return VALUES.length;
}
static public FCFlameFremanChocoBase8 valueOf(int idx) {
return VALUES[idx];
}
}

84
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/flame4/FCFlameFremanLegoBase2.java Normal file
View file

@ -0,0 +1,84 @@
/*
* Copyright (c) 2004-2014, Willem Cazander
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided
* that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the
* following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
* the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.x4o.fc18.zion7.flame4;
import java.math.BigInteger;
import org.x4o.fc18.cake2.FourCornerDotCake;
import org.x4o.fc18.zion7.FourCornerZionStenoPetroglyphs;
/// The supported lego sand man bait marks.
///
/// @author Willem Cazander
/// @version 1.0 Sep 3, 2025
public enum FCFlameFremanLegoBase2 implements FCFlameFremanSuit {
LEGO_0016(2, FourCornerDotCake.FC_BA2L0016_BANK),
LEGO_0032(4, FourCornerDotCake.FC_BA2L0032_BANK),
LEGO_0064(8, FourCornerDotCake.FC_BA2L0064_BANK),
LEGO_0128(16, FourCornerDotCake.FC_BA2L0128_BANK),
LEGO_0256(32, FourCornerDotCake.FC_BA2L0256_BANK),
LEGO_0512(64, FourCornerDotCake.FC_BA2L0512_BANK),
LEGO_1024(128, FourCornerDotCake.FC_BA2L1024_BANK),
LEGO_2048(256, FourCornerDotCake.FC_BA2L2048_BANK),
;
private static final FCFlameFremanLegoBase2[] VALUES = values();
private final int cakeOffsetSel0;
private final int cakeOffsetBank;
private final int bytes;
private final BigInteger maxWaterLevel;
private FCFlameFremanLegoBase2(int bytes, FourCornerDotCake cakeSlice) {
this.bytes = bytes;
this.cakeOffsetSel0 = cakeSlice.getStart() - bytes;
this.cakeOffsetBank = cakeSlice.getStart();
this.maxWaterLevel = FourCornerZionStenoPetroglyphs.valueOfBitMaskBig(bytes * 8);
}
@Override
public int cakeOffsetSel0() {
return cakeOffsetSel0;
}
@Override
public int cakeOffsetBank() {
return cakeOffsetBank;
}
@Override
public BigInteger maxWaterLevel() {
return maxWaterLevel;
}
public int bytes() {
return bytes;
}
static public int valuesLength() {
return VALUES.length;
}
static public FCFlameFremanLegoBase2 valueOf(int idx) {
return VALUES[idx];
}
}

53
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/FourCornerZion7FremanBase8.java → nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/flame4/FCFlameFremanLegoBase8.java
View file

@ -20,66 +20,65 @@
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.x4o.fc18.zion7;
package org.x4o.fc18.zion7.flame4;
import java.math.BigInteger;
import org.x4o.fc18.cake2.FourCornerDotCake;
import org.x4o.fc18.zion7.FourCornerZionStenoPetroglyphs;
/// The supported sand dune formations.
/// The supported lego sand dune formations.
///
/// @author Willem Cazander
/// @version 1.0 Aug 28, 2025
public enum FourCornerZion7FremanBase8 {
public enum FCFlameFremanLegoBase8 implements FCFlameFremanSuit {
UNSIGNED_0018(6, FourCornerDotCake.FC_BA8U0018_BANK),
UNSIGNED_0036(12, FourCornerDotCake.FC_BA8U0036_BANK),
UNSIGNED_0072(24, FourCornerDotCake.FC_BA8U0072_BANK),
UNSIGNED_0144(48, FourCornerDotCake.FC_BA8U0144_BANK),
UNSIGNED_0288(96, FourCornerDotCake.FC_BA8U0288_BANK),
UNSIGNED_0576(192, FourCornerDotCake.FC_BA8U0576_BANK),
UNSIGNED_1152(384, FourCornerDotCake.FC_BA8U1152_BANK),
UNSIGNED_2304(768, FourCornerDotCake.FC_BA8U2304_BANK),
SIGNED_0018(6, FourCornerDotCake.FC_BA8I0018_BANK),
SIGNED_0036(12, FourCornerDotCake.FC_BA8I0036_BANK),
SIGNED_0072(24, FourCornerDotCake.FC_BA8I0072_BANK),
SIGNED_0144(48, FourCornerDotCake.FC_BA8I0144_BANK),
SIGNED_0288(96, FourCornerDotCake.FC_BA8I0288_BANK),
SIGNED_0576(192, FourCornerDotCake.FC_BA8I0576_BANK),
SIGNED_1152(384, FourCornerDotCake.FC_BA8I1152_BANK),
SIGNED_2304(768, FourCornerDotCake.FC_BA8I2304_BANK),
LEGO_0018(6, FourCornerDotCake.FC_BA8L0018_BANK),
LEGO_0036(12, FourCornerDotCake.FC_BA8L0036_BANK),
LEGO_0072(24, FourCornerDotCake.FC_BA8L0072_BANK),
LEGO_0144(48, FourCornerDotCake.FC_BA8L0144_BANK),
LEGO_0288(96, FourCornerDotCake.FC_BA8L0288_BANK),
LEGO_0576(192, FourCornerDotCake.FC_BA8L0576_BANK),
LEGO_1152(384, FourCornerDotCake.FC_BA8L1152_BANK),
LEGO_2304(768, FourCornerDotCake.FC_BA8L2304_BANK),
;
private static final FourCornerZion7FremanBase8[] VALUES = values();
private static final FCFlameFremanLegoBase8[] VALUES = values();
private final int cakeOffsetSel0;
private final int cakeOffsetBank;
private final int octals;
private final BigInteger maxWaterLevel;
private FourCornerZion7FremanBase8(int octals, FourCornerDotCake cakeSlice) {
private FCFlameFremanLegoBase8(int octals, FourCornerDotCake cakeSlice) {
this.octals = octals;
this.cakeOffsetSel0 = cakeSlice.getStart() - (octals/3);
this.cakeOffsetBank = cakeSlice.getStart();
this.maxWaterLevel = FourCornerZionStenoPetroglyphs.valueOfBitMaskBig(octals * 3);
}
@Override
public int cakeOffsetSel0() {
return cakeOffsetSel0;
}
@Override
public int cakeOffsetBank() {
return cakeOffsetBank;
}
@Override
public BigInteger maxWaterLevel() {
return maxWaterLevel;
}
public int octals() {
return octals;
}
public boolean isSigned() {
return ordinal() >= SIGNED_0018.ordinal();
}
static public int valuesLength() {
return VALUES.length;
}
static public FourCornerZion7FremanBase8 valueOf(int idx) {
static public FCFlameFremanLegoBase8 valueOf(int idx) {
return VALUES[idx];
}
}

37
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/FourCornerZion7FremanBase2.java → nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/flame4/FCFlameFremanSignedBase2.java
View file

@ -20,24 +20,18 @@
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.x4o.fc18.zion7;
package org.x4o.fc18.zion7.flame4;
import java.math.BigInteger;
import org.x4o.fc18.cake2.FourCornerDotCake;
import org.x4o.fc18.zion7.FourCornerZionStenoPetroglyphs;
/// The supported sand man bait marks.
/// The supported signed sand man bait marks.
///
/// @author Willem Cazander
/// @version 1.0 Aug 30, 2025
public enum FourCornerZion7FremanBase2 {
UNSIGNED_0016(2, FourCornerDotCake.FC_BA2U0016_BANK),
UNSIGNED_0032(4, FourCornerDotCake.FC_BA2U0032_BANK),
UNSIGNED_0064(8, FourCornerDotCake.FC_BA2U0064_BANK),
UNSIGNED_0128(16, FourCornerDotCake.FC_BA2U0128_BANK),
UNSIGNED_0256(32, FourCornerDotCake.FC_BA2U0256_BANK),
UNSIGNED_0512(64, FourCornerDotCake.FC_BA2U0512_BANK),
UNSIGNED_1024(128, FourCornerDotCake.FC_BA2U1024_BANK),
UNSIGNED_2048(256, FourCornerDotCake.FC_BA2U2048_BANK),
public enum FCFlameFremanSignedBase2 implements FCFlameFremanSuit {
SIGNED_0016(2, FourCornerDotCake.FC_BA2I0016_BANK),
SIGNED_0032(4, FourCornerDotCake.FC_BA2I0032_BANK),
@ -48,38 +42,43 @@ public enum FourCornerZion7FremanBase2 {
SIGNED_1024(128, FourCornerDotCake.FC_BA2I1024_BANK),
SIGNED_2048(256, FourCornerDotCake.FC_BA2I2048_BANK),
;
private static final FourCornerZion7FremanBase2[] VALUES = values();
private static final FCFlameFremanSignedBase2[] VALUES = values();
private final int cakeOffsetSel0;
private final int cakeOffsetBank;
private final int bytes;
private final BigInteger maxWaterLevel;
private FourCornerZion7FremanBase2(int bytes, FourCornerDotCake cakeSlice) {
private FCFlameFremanSignedBase2(int bytes, FourCornerDotCake cakeSlice) {
this.bytes = bytes;
this.cakeOffsetSel0 = cakeSlice.getStart() - bytes;
this.cakeOffsetBank = cakeSlice.getStart();
this.maxWaterLevel = FourCornerZionStenoPetroglyphs.valueOfBitMaskBig((bytes * 8) - 1); // remove sign bit
}
@Override
public int cakeOffsetSel0() {
return cakeOffsetSel0;
}
@Override
public int cakeOffsetBank() {
return cakeOffsetBank;
}
@Override
public BigInteger maxWaterLevel() {
return maxWaterLevel;
}
public int bytes() {
return bytes;
}
public boolean isSigned() {
return ordinal() >= SIGNED_0016.ordinal();
}
static public int valuesLength() {
return VALUES.length;
}
static public FourCornerZion7FremanBase2 valueOf(int idx) {
static public FCFlameFremanSignedBase2 valueOf(int idx) {
return VALUES[idx];
}
}

41
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/flame4/FCFlameFremanSuit.java Normal file
View file

@ -0,0 +1,41 @@
/*
* Copyright (c) 2004-2014, Willem Cazander
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided
* that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the
* following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
* the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.x4o.fc18.zion7.flame4;
import java.math.BigInteger;
/// The freman suite for taste amd water management
///
/// @author Willem Cazander
/// @version 1.0 Sep 4, 2025
public interface FCFlameFremanSuit {
// copy from enum
String name();
int cakeOffsetSel0();
int cakeOffsetBank();
BigInteger maxWaterLevel();
}

14
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/FourCornerZion7NumberGram.java → nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/flame4/FCFlameNumberGram.java
View file

@ -20,7 +20,7 @@
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.x4o.fc18.zion7;
package org.x4o.fc18.zion7.flame4;
import org.x4o.fc18.cake2.FourCornerDotCake;
@ -28,7 +28,7 @@ import org.x4o.fc18.cake2.FourCornerDotCake;
///
/// @author Willem Cazander
/// @version 1.0 Aug 25, 2025
public enum FourCornerZion7NumberGram {
public enum FCFlameNumberGram {
CUT_2(FourCornerDotCake.FC_BMW0102_S2),
CUT_10(FourCornerDotCake.FC_AMD0110_SA),
@ -50,11 +50,11 @@ public enum FourCornerZion7NumberGram {
CUT_512(FourCornerDotCake.FC_OCE0864_H9),
CUT_2048(FourCornerDotCake.FC_BIP0039_2K),
;
private static final FourCornerZion7NumberGram[] VALUES = values();
private static final FCFlameNumberGram[] VALUES = values();
private final int cutCount;
private final int cutZeroCakePoint;
private FourCornerZion7NumberGram(FourCornerDotCake slice) {
private FCFlameNumberGram(FourCornerDotCake slice) {
cutCount = slice.getStop() - slice.getStart();
cutZeroCakePoint = slice.getStart();
}
@ -71,14 +71,14 @@ public enum FourCornerZion7NumberGram {
return VALUES.length;
}
static public FourCornerZion7NumberGram valueOf(int idx) {
static public FCFlameNumberGram valueOf(int idx) {
return VALUES[idx];
}
static public FourCornerZion7NumberGram valueByCutCount(int cutCount) {
static public FCFlameNumberGram valueByCutCount(int cutCount) {
final int valuesLength = valuesLength();
for (int i = 0; i < valuesLength; i++) {
FourCornerZion7NumberGram gram = valueOf(i);
FCFlameNumberGram gram = valueOf(i);
if (gram.cutCount() == cutCount) {
return gram;
}

53
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/flame4/FCFlameNumberSparklerSmoke.java Normal file
View file

@ -0,0 +1,53 @@
/*
* Copyright (c) 2004-2014, Willem Cazander
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided
* that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the
* following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
* the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.x4o.fc18.zion7.flame4;
/// The sparker flame smoke signals.
///
/// @author Willem Cazander
/// @version 1.0 Sep 4 2025
public enum FCFlameNumberSparklerSmoke {
BASE2_LEGO,
BASE2_INT,
BASE8_LEGO,
BASE8_CHOCO,
CHOCO_RATIONAL,
CHOCO_DECIMAL,
CHOCO_FLOAT,
CHOCO_FIXED,
;
private static final FCFlameNumberSparklerSmoke[] VALUES = values();
private FCFlameNumberSparklerSmoke() {
}
static public int valuesLength() {
return VALUES.length;
}
static public FCFlameNumberSparklerSmoke valueOf(int idx) {
return VALUES[idx];
}
}

131
nx01-x4o-fc18/src/main/java/org/x4o/fc18/zion7/flame4/FCFlameNumberTaste.java Normal file
View file

@ -0,0 +1,131 @@
/*
* Copyright (c) 2004-2014, Willem Cazander
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided
* that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the
* following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
* the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.x4o.fc18.zion7.flame4;
/// The supported chocolate number tastes.
///
/// @author Willem Cazander
/// @version 1.0 Sep 3 2025
public enum FCFlameNumberTaste {
/// 0000
NUMBER_POSITIVE,
/// 0001
NUMBER_NEGATIVE,
/// 0010
NUMBER_POSITIVE_CARRY,
/// 0011
NUMBER_NEGATIVE_CARRY,
/// 0100
INFINITY_POSITIVE,
/// 0101
INFINITY_NEGATIVE,
/// 0110
INFINITY_POSITIVE_CARRY,
/// 0111
INFINITY_NEGATIVE_CARRY,
/// 1000
FLAG_NAN,
/// 1001
FLAG_ROUNDED,
/// 1010
FLAG_CLAMPED,
/// 1011
FLAG_INEXACT,
/// 1100
FLAG_UDERFLOW,
/// 1101
FLAG_OVERFLOW,
/// 1110
FLAG_DIV_BY_ZERO,
/// 1111
FLAG_INVALID_OPERATION,
;
private static final FCFlameNumberTaste[] VALUES = values();
private static final int CHOCO_LETTER_ZERO = NUMBER_POSITIVE.ordinal();
private static final int CHOCO_HEAT_CYCLE_STEP = NUMBER_POSITIVE_CARRY.ordinal() - NUMBER_POSITIVE.ordinal();
private static final int CHOCO_MASK_BIT_1000 = FLAG_NAN.ordinal();
private static final int CHOCO_MASK_BIT_0100 = INFINITY_POSITIVE.ordinal();
private static final int CHOCO_MASK_BIT_0001 = NUMBER_NEGATIVE.ordinal();
private FCFlameNumberTaste() {
}
public boolean numberValid() {
return CHOCO_LETTER_ZERO == (ordinal() & CHOCO_MASK_BIT_1000);
}
public boolean numberValidInteger() {
return numberValid() && CHOCO_LETTER_ZERO == (ordinal() & CHOCO_MASK_BIT_0100);
}
public boolean numberValidInfinity() {
return numberValid() && CHOCO_LETTER_ZERO != (ordinal() & CHOCO_MASK_BIT_0100);
}
public boolean statusSignPositive() {
return false == statusSignNegative();
}
public boolean statusSignNegative() {
return numberValid() && CHOCO_LETTER_ZERO != (ordinal() & CHOCO_MASK_BIT_0001);
}
public boolean statusCarryLess() {
return false == statusCarryOke();
}
public boolean statusCarryOke() {
return this == NUMBER_POSITIVE_CARRY || this == NUMBER_NEGATIVE_CARRY || this == INFINITY_POSITIVE_CARRY || this == INFINITY_NEGATIVE_CARRY;
}
public boolean statusFlag() {
return false == numberValid();
}
public FCFlameNumberTaste chocoRemeltUp() {
if (statusFlag()) {
return FLAG_NAN;
}
return valueOf(ordinal() + CHOCO_HEAT_CYCLE_STEP);
}
public FCFlameNumberTaste chocoRemeltDown() {
if (statusFlag()) {
return FLAG_NAN;
}
if (ordinal() <= NUMBER_NEGATIVE.ordinal()) {
return this;
}
return valueOf(ordinal() - CHOCO_HEAT_CYCLE_STEP);
}
static public int valuesLength() {
return VALUES.length;
}
static public FCFlameNumberTaste valueOf(int idx) {
return VALUES[idx];
}
}

12
nx01-x4o-fc18/src/test/java/org/x4o/fc18/cake2/gram5/FCNumberGramTest.java
View file

@ -29,8 +29,8 @@ import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.x4o.fc18.FourCornerUnicodeDisplay;
import org.x4o.fc18.zion7.FourCornerZion7Candlelier;
import org.x4o.fc18.zion7.FourCornerZion7NumberGram;
import org.x4o.fc18.zion7.FourCornerZionStenoGrapher;
import org.x4o.fc18.zion7.flame4.FCFlameNumberGram;
/**
* Tests txt grams encoding.
@ -44,7 +44,7 @@ public class FCNumberGramTest {
public void testCut10Simple() throws Exception {
List<Integer> out = new ArrayList<>();
FourCornerZion7Candlelier writer = FourCornerZionStenoGrapher.writerX18(out);
writer.strobeNumberGrams(FourCornerZion7NumberGram.CUT_10, List.of(0,1,2,3,4,5,6,7,8,9));
writer.strobeNumberGrams(FCFlameNumberGram.CUT_10, List.of(0,1,2,3,4,5,6,7,8,9));
String res = FourCornerUnicodeDisplay.text().renderFromInt18(out);
Assertions.assertEquals("0123456789", res);
}
@ -54,16 +54,16 @@ public class FCNumberGramTest {
List<Integer> out = new ArrayList<>();
FourCornerZion7Candlelier writer = FourCornerZionStenoGrapher.writerX18(out);
Assertions.assertThrows(IllegalArgumentException.class, () -> {
writer.strobeNumberGrams(FourCornerZion7NumberGram.CUT_10, List.of(10));
writer.strobeNumberGrams(FCFlameNumberGram.CUT_10, List.of(10));
});
Assertions.assertThrows(IllegalArgumentException.class, () -> {
writer.strobeNumberGrams(FourCornerZion7NumberGram.CUT_10, List.of(11));
writer.strobeNumberGrams(FCFlameNumberGram.CUT_10, List.of(11));
});
Assertions.assertThrows(IllegalArgumentException.class, () -> {
writer.strobeNumberGrams(FourCornerZion7NumberGram.CUT_10, List.of(-1));
writer.strobeNumberGrams(FCFlameNumberGram.CUT_10, List.of(-1));
});
Assertions.assertThrows(IllegalArgumentException.class, () -> {
writer.strobeNumberGrams(FourCornerZion7NumberGram.CUT_1, List.of(1));
writer.strobeNumberGrams(FCFlameNumberGram.CUT_1, List.of(1));
});
}
}

107
nx01-x4o-fc18/src/test/java/org/x4o/fc18/zion7/StenoGrapherTest.java
View file

@ -38,6 +38,11 @@ import org.x4o.fc18.cake2.flag4.FCDotF4TTY0001DashNL;
import org.x4o.fc18.cake2.zero33.FCDotCDC1604DashP6;
import org.x4o.fc18.octal8.PrimordialOctal;
import org.x4o.fc18.octal8.PrimordialOctalOrangeString;
import org.x4o.fc18.zion7.flame4.FCFlameFremanChocoBase8;
import org.x4o.fc18.zion7.flame4.FCFlameFremanLegoBase2;
import org.x4o.fc18.zion7.flame4.FCFlameFremanLegoBase8;
import org.x4o.fc18.zion7.flame4.FCFlameFremanSignedBase2;
import org.x4o.fc18.zion7.flame4.FCFlameNumberTaste;
/**
* Tests four corner grapher parts.
@ -67,55 +72,99 @@ public class StenoGrapherTest {
public void testBASE2Values() throws Exception {
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
writerX18.strobeNumberBASE2(FourCornerZion7FremanBase2.SIGNED_0032, BigInteger.valueOf(123));
writerX18.strobeNumberBASE2Lego(FCFlameFremanLegoBase2.LEGO_0032, BigInteger.valueOf(123));
writerX18.strobeTheWord(FCDotCDC1604DashP6.NY09_EQUALS.ordinal());
writerX18.strobeNumberBASE2(FourCornerZion7FremanBase2.SIGNED_0128, BigInteger.valueOf(-123));
writerX18.strobeNumberBASE2Int(FCFlameFremanSignedBase2.SIGNED_0128, true, BigInteger.valueOf(123));
String resX18 = FourCornerUnicodeDisplay.text().renderFromInt18(outX18);
Assertions.assertEquals("123=-123", resX18);
}
@Test
public void testBASE8Values() throws Exception {
public void testBASE8Lego123() throws Exception {
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
writerX18.strobeNumberBASE8(FourCornerZion7FremanBase8.SIGNED_0144, BigInteger.valueOf(123));
writerX18.strobeTheWord(FCDotCDC1604DashP6.NY19_MINUS.ordinal());
writerX18.strobeNumberBASE8(FourCornerZion7FremanBase8.SIGNED_0144, new BigInteger("11150372599265311570767859136324180752990207", 10));
writerX18.strobeNumberBASE8(FourCornerZion7FremanBase8.SIGNED_0144, BigInteger.valueOf(-123));
writerX18.strobeNumberBASE8Lego(FCFlameFremanLegoBase8.LEGO_0144, BigInteger.valueOf(123));
String resX18 = FourCornerUnicodeDisplay.text().renderFromInt18(outX18);
Assertions.assertEquals("123-11150372599265311570767859136324180752990207-123", resX18);
Assertions.assertEquals("123", resX18);
}
@Test
public void testDEC576Values() throws Exception {
public void testBASE8Lego123456() throws Exception {
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
writerX18.strobeNumberDEC576(BigInteger.valueOf(123), BigInteger.valueOf(456));
writerX18.strobeTheWord(FCDotCDC1604DashP6.NY09_EQUALS.ordinal());
writerX18.strobeNumberDEC576(FourCornerZion7Petroglyphs.DEC576_COEFFICIENT_MAX, FourCornerZion7Petroglyphs.DEC576_EXPONENT_MAX);
writerX18.strobeNumberBASE8Lego(FCFlameFremanLegoBase8.LEGO_0144, BigInteger.valueOf(123456));
String resX18 = FourCornerUnicodeDisplay.text().renderFromInt18(outX18);
Assertions.assertEquals("123*10⁴⁵⁶=26187124863169134960105517574620793217733136368344518315866330944769070371237396439066160738607233257207093473020480568073738052367083144426628220715007*10²³⁶¹¹⁸³²⁴¹⁴³⁴⁸²²⁶⁰²⁷⁵²", resX18);
Assertions.assertEquals("123456", resX18);
}
@Test
public void testE503M72Values() throws Exception {
public void testBASE8Choco123() throws Exception {
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
writerX18.strobeNumberE503M72(true, BigInteger.valueOf(456), BigInteger.valueOf(123));
writerX18.strobeNumberBASE8Choco(FCFlameFremanChocoBase8.CHOCO_0144, FCFlameNumberTaste.NUMBER_POSITIVE, new BigInteger("123", 10));
String resX18 = FourCornerUnicodeDisplay.text().renderFromInt18(outX18);
Assertions.assertEquals("(-1)¹*2⁴⁵⁶⁻¹²⁷*1.123", resX18);
Assertions.assertEquals("123", resX18);
}
@Test
public void testNCRValues() throws Exception {
public void testBASE8Choco123456Neg() throws Exception {
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
writerX18.strobeNumberBASE8Choco(FCFlameFremanChocoBase8.CHOCO_0144, FCFlameNumberTaste.NUMBER_NEGATIVE, new BigInteger("123456", 10));
String resX18 = FourCornerUnicodeDisplay.text().renderFromInt18(outX18);
Assertions.assertEquals("-123456", resX18);
}
@Test
public void testBASE8ChocoLarge() throws Exception {
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
writerX18.strobeNumberBASE8Choco(FCFlameFremanChocoBase8.CHOCO_0144, FCFlameNumberTaste.NUMBER_POSITIVE, new BigInteger("1393796574908163946345982392040522594123775", 10));
String resX18 = FourCornerUnicodeDisplay.text().renderFromInt18(outX18);
Assertions.assertEquals("1393796574908163946345982392040522594123775", resX18);
}
@Test
public void testBankDecimalValues() throws Exception {
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
writerX18.strobeNumberChocoPigDecimal(FCFlameNumberTaste.NUMBER_POSITIVE, false, BigInteger.valueOf(123), BigInteger.valueOf(456));
Assertions.assertEquals(4, outX18.size());
String resX18 = FourCornerUnicodeDisplay.text().renderFromInt18(outX18);
Assertions.assertEquals("(-1)⁰*10¹²³*456", resX18);
}
@Test
public void testBankDecimalValuesMax() throws Exception {
Assertions.assertEquals(284, FourCornerZionStenoPetroglyphs.BIG_BITS_284.toString(2).length());
Assertions.assertEquals(2016, FourCornerZionStenoPetroglyphs.BIG_BITS_2016.toString(2).length());
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
writerX18.strobeNumberChocoPigDecimal(FCFlameNumberTaste.NUMBER_POSITIVE, false, FourCornerZionStenoPetroglyphs.BIG_BITS_284, FourCornerZionStenoPetroglyphs.BIG_BITS_2016);
Assertions.assertEquals(193, outX18.size());
String resX18 = FourCornerUnicodeDisplay.text().renderFromInt18(outX18);
Assertions.assertEquals("(-1)⁰*10¹⁵⁵⁴¹³⁵¹¹³⁷⁸⁰⁵⁸³²⁵⁶⁷³⁵⁵⁶⁹⁵²⁵⁴⁵⁸⁸¹⁵¹²⁵³¹³⁹²⁵⁴⁷¹²⁴¹⁷¹¹⁶¹⁷⁰⁰¹⁴⁴⁹⁹²⁷⁷⁹¹¹²³⁴²⁸¹⁶⁴¹⁶⁶⁷⁹⁸⁵⁴⁰⁷*7524389324549354450012295667238056650488661292408472865850279440061341770661038088891003609523855490537527473858068236032063038821912119420032983735773778315780422968627185582125139830259059580693966159220800634538007951025529707819651368618588002973837229854435730968342995245834129352264002058451047722604571453619205472623157541916371455764131661512732115122042085430429090324954236930736866452001076451671762299658372499364800367306988138217572983729940207496105489713305332746758395131148149101871456611571055068153665866066783899124296271513772531723497342815490725823828326183977758546404902789185535", resX18);
}
@Test
public void testBankFloatValues() throws Exception {
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
writerX18.strobeNumberChocoPigFloat(FCFlameNumberTaste.NUMBER_NEGATIVE, false, BigInteger.valueOf(456), BigInteger.valueOf(123));
String resX18 = FourCornerUnicodeDisplay.text().renderFromInt18(outX18);
Assertions.assertEquals("(-1)¹*2⁴⁵⁶*1.123", resX18);
}
@Test
public void testBankRationalValues() throws Exception {
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
BigInteger v1 = BigInteger.valueOf(123);
writerX18.strobeNumberNCR1632(BigInteger.ONE, v1);
writerX18.strobeNumberChocoMarriedPigsRational(FCFlameNumberTaste.NUMBER_POSITIVE, FCFlameNumberTaste.NUMBER_POSITIVE, BigInteger.ONE, v1);
BigInteger v2 = BigInteger.valueOf(12345);
writerX18.strobeNumberNCR1632(BigInteger.ONE, v2);
BigInteger v3 = BigInteger.valueOf(-5432);
writerX18.strobeNumberNCR1632(v3, v3);
writerX18.strobeNumberChocoMarriedPigsRational(FCFlameNumberTaste.NUMBER_POSITIVE, FCFlameNumberTaste.NUMBER_POSITIVE, BigInteger.ONE, v2);
BigInteger v3 = BigInteger.valueOf(5432);
writerX18.strobeNumberChocoMarriedPigsRational(FCFlameNumberTaste.NUMBER_NEGATIVE, FCFlameNumberTaste.NUMBER_NEGATIVE, v3, v3);
String resX18 = FourCornerUnicodeDisplay.text().renderFromInt18(outX18);
Assertions.assertEquals("¹/₁₂₃¹/₁₂₃₄₅⁻⁵⁴³²/₋₅₄₃₂", resX18);
}
@ -130,7 +179,7 @@ public class StenoGrapherTest {
writerX18.strobeDocumentAlpha();
for (int x = 1; x <= 1025 /*_999999*/; x++) {
BigInteger v = BigInteger.valueOf(x);
writerX18.strobeNumberNCR1632(BigInteger.ONE, v);
writerX18.strobeNumberChocoMarriedPigsRational(FCFlameNumberTaste.NUMBER_POSITIVE, FCFlameNumberTaste.NUMBER_POSITIVE, BigInteger.ONE, v);
writerX18.strobeTheWord(FCDotF4TTY0001DashNL.NETHER_LINE.cakePointDotIndex());
}
writerX18.strobeDocumentOmega();
@ -150,12 +199,12 @@ public class StenoGrapherTest {
}
@Test
public void testNCRCount1024() throws Exception {
public void testBankRationalCount1024() throws Exception {
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
for (int x = 1; x <= 1025; x++) {
BigInteger v = BigInteger.valueOf(x);
writerX18.strobeNumberNCR1632(BigInteger.ONE, v);
writerX18.strobeNumberChocoMarriedPigsRational(FCFlameNumberTaste.NUMBER_POSITIVE, FCFlameNumberTaste.NUMBER_POSITIVE, BigInteger.ONE, v);
}
String resX18 = FourCornerUnicodeDisplay.text().renderFromInt18(outX18);
Assertions.assertTrue(resX18.startsWith("¹/₁¹/₂¹/₃"), "missing " + resX18);
@ -164,16 +213,16 @@ public class StenoGrapherTest {
}
@Test
public void testNCRMaxValue() throws Exception {
public void testBankRationalValuesMax() throws Exception {
List<Integer> outX18 = new ArrayList<>();
FourCornerZion7Candlelier writerX18 = FourCornerZionStenoGrapher.writerX18(outX18);
BigInteger maxValue = new BigInteger("7FFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF"+"FFFFFFFFFFFFFFFFFF", 16);
writerX18.strobeNumberNCR1632(maxValue, maxValue);
BigInteger maxValue = FourCornerZionStenoPetroglyphs.BIG_BITS_2300;
writerX18.strobeNumberChocoMarriedPigsRational(FCFlameNumberTaste.NUMBER_POSITIVE, FCFlameNumberTaste.NUMBER_POSITIVE, maxValue, maxValue);
Assertions.assertThrows(IllegalArgumentException.class, () -> {
writerX18.strobeNumberNCR1632(maxValue, maxValue.add(BigInteger.ONE));
writerX18.strobeNumberChocoMarriedPigsRational(FCFlameNumberTaste.NUMBER_POSITIVE, FCFlameNumberTaste.NUMBER_POSITIVE, maxValue, maxValue.add(BigInteger.ONE));
});
Assertions.assertThrows(IllegalArgumentException.class, () -> {
writerX18.strobeNumberNCR1632(maxValue.add(BigInteger.ONE), maxValue);
writerX18.strobeNumberChocoMarriedPigsRational(FCFlameNumberTaste.NUMBER_POSITIVE, FCFlameNumberTaste.NUMBER_POSITIVE, maxValue.add(BigInteger.ONE), maxValue);
});
}
}

82
nx01-x4o-fc18/src/test/java/org/x4o/fc18/zion7/StenoLexerNCRTest.java
View file

@ -47,29 +47,27 @@ public class StenoLexerNCRTest {
lexer.withSmokeSignals(smokeReader);
List<Integer> cdc = new ArrayList<>();
cdc.add(FourCornerDotCake.FC_NCR1632_SEL1D.getStart() + (512*3) + 1); /// auto NXX_001
cdc.add(192 + FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart() + 1);
Assertions.assertEquals(0, smokeReader.pipeSmokeClouds);
lexer.read(cdc);
Assertions.assertEquals(1, smokeReader.pipeSmokeClouds);
Assertions.assertEquals("burnNumberNCR1632MissingSparkler", smokeReader.pipeError);
Assertions.assertEquals("burnNumberMissingSparkler:CHOCO_RATIONAL", smokeReader.pipeError);
cdc.addAll(FCDotDEC2701DashPX0.ESC_STOP.baklavaPointSequence());
cdc.add(FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart() + 123);
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 123);
cdc.addAll(FCDotDEC2701DashPX0.ESC_STOP.baklavaPointSequence());
cdc.addAll(FCDotDEC2701DashPX0.ESC_STOP.baklavaPointSequence()); // the print above auto value + next test
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStart() - 1 + 123); // normal NXX_123
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStart() + (512*4) + 2); /// auto NXX_123 + this
smokeReader.reset();
lexer.read(cdc);
Assertions.assertEquals(2, smokeReader.pipeSmokeClouds);
cdc.addAll(FCDotDEC2701DashPX0.ESC_STOP.cakePointSequence()); // the print above auto value + next test (normal bank reset)
cdc.add(FourCornerDotCake.FC_NCR1632_SEL1D.getStart() + 11);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL1D.getStart() + (512*3) + 12);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStart() + (512*4) + 13);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStart() + (512*5) + 14);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStart()); // and one which prints
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStart() + 123); // normal NXX_123
cdc.addAll(FCDotDEC2701DashPX0.ESC_STOP.cakePointSequence());
cdc.add(192 + FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart() + 11);
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart());
smokeReader.reset();
lexer.read(cdc);
String res = "[0:1:burnNumberNCR1632MissingSparkler][0:8:burnNumberNCR1632MissingSparkler][0:16:burnNumberNCR1632MissingSparkler]";
String res = "[0:1:burnNumberMissingSparkler:CHOCO_RATIONAL][0:8:burnNumberMissingSparkler:CHOCO_RATIONAL][0:16:burnNumberMissingSparkler:CHOCO_RATIONAL]";
Assertions.assertEquals(res, FourCornerUnicodeDisplay.text().renderFromInt18(cdc));
}
@ -79,49 +77,45 @@ public class StenoLexerNCRTest {
cdc.add(FCDotCDC1604DashP6.NX24_X.ordinal()); // = X
cdc.add(FCDotCDC1604DashP6.NY09_EQUALS.ordinal());
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStart());
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStart() + 11);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL1D.getStart());
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStart() + 1);
cdc.add(192 + FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart());
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 1);
cdc.add(FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart());
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 11);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStart());
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStart() + 1);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL1D.getStart());
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStart() + 1);
cdc.add(192 + FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart());
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 1);
cdc.add(FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart());
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 1);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStart());
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStart() + 14);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL1D.getStart());
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStart() + 15);
cdc.add(192 + FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart());
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 14);
cdc.add(FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart());
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 15);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStart());
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStart() + 123);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL1D.getStart() + 1);
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStart() + 1); // 4096
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStart() + 1); // +1 = 4097
cdc.add(192 + FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart());
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 123);
cdc.add(FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart() + 1);
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 1); // 4096
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 1); // +1 = 4097
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStart());
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStart() + 4);
cdc.add(FourCornerDotCake.FC_NCR1632_SEL1D.getStart());
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStart() + 1);
cdc.add(192 + FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart());
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 4);
cdc.add(FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart());
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStart() + 1);
cdc.add(FCDotCDC1604DashP6.NY14_SEMICOLON.ordinal());
Assertions.assertEquals("X=¹¹/₁¹/₁¹⁴/₁₅¹²³/₄₀₉₇⁴/₁;", FourCornerUnicodeDisplay.text().renderFromInt18(cdc));
Assertions.assertEquals("X=¹/₁₁¹/₁¹⁴/₁₅¹²³/₄₀₉₇⁴/₁;", FourCornerUnicodeDisplay.text().renderFromInt18(cdc));
}
@Test
public void testNCRLargestF576() throws Exception {
List<Integer> cdc = new ArrayList<>();
cdc.add(FourCornerDotCake.FC_NCR1632_SEL0N.getStop());
for (int i = FourCornerDotCake.FC_NCR1632_SEL0N.getStop(); i >= FourCornerDotCake.FC_NCR1632_SEL0N.getStart(); i--) {
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStop());
cdc.add(FourCornerDotCake.FC_RATIONAL4608_SEL0.getStop());
for (int i = FourCornerDotCake.FC_RATIONAL4608_SEL0.getStop(); i >= FourCornerDotCake.FC_RATIONAL4608_SEL0.getStart(); i--) {
cdc.add(FourCornerDotCake.FC_RATIONAL4608_BANK.getStop());
}
cdc.add(FourCornerDotCake.FC_NCR1632_SEL1D.getStop());
for (int i = FourCornerDotCake.FC_NCR1632_SEL1D.getStop(); i >= FourCornerDotCake.FC_NCR1632_SEL1D.getStart(); i--) {
cdc.add(FourCornerDotCake.FC_NCR1632_BANK.getStop());
}
String resSuper = "⁻¹²³⁶⁶⁵²⁰⁰⁷³⁶⁵⁵²²⁶⁷⁰³⁰²⁵¹²⁶⁰⁵⁰⁹⁸²³⁵⁹⁵⁰¹⁷⁵⁶⁵⁶⁷⁴⁵⁵⁰⁶⁰⁵⁹¹⁹⁹⁵⁷⁰³¹⁵²⁸⁰⁴⁶⁴⁴⁸⁶¹²⁵⁵³²⁶⁵⁹³³⁵⁸⁵¹⁵⁸²⁰⁰⁵³⁰⁶²¹⁵²²⁴⁹⁴⁷⁹⁸⁸³⁵⁷¹³⁰⁰⁸⁰⁶⁹⁶⁶⁹⁶⁷⁵⁶⁸²⁵¹⁷¹⁵³³⁷⁵⁶⁰⁴⁹⁸³⁷⁷³⁰⁷⁷⁵⁵⁰⁹⁴⁶⁵⁸³⁹⁵⁸³⁰³³⁸⁶⁰⁷⁴³⁴⁹⁵⁶⁷";
String resSuber = "₋₁₂₃₆₆₅₂₀₀₇₃₆₅₅₂₂₆₇₀₃₀₂₅₁₂₆₀₅₀₉₈₂₃₅₉₅₀₁₇₅₆₅₆₇₄₅₅₀₆₀₅₉₁₉₉₅₇₀₃₁₅₂₈₀₄₆₄₄₈₆₁₂₅₅₃₂₆₅₉₃₃₅₈₅₁₅₈₂₀₀₅₃₀₆₂₁₅₂₂₄₉₄₇₉₈₈₃₅₇₁₃₀₀₈₀₆₉₆₆₉₆₇₅₆₈₂₅₁₇₁₅₃₃₇₅₆₀₄₉₈₃₇₇₃₀₇₇₅₅₀₉₄₆₅₈₃₉₅₈₃₀₃₃₈₆₀₇₄₃₄₉₅₆₇";
String resSuper = "²³³⁸⁷⁸³⁵³¹⁸⁰⁷⁵⁸³³⁹⁵²²⁹⁹⁹⁹⁸⁵⁸⁴⁶¹⁴⁵¹⁵³⁷⁰¹⁶²⁰⁵⁵¹⁴⁷⁰⁴⁷³⁴⁹¹⁸³⁴²⁰³⁶⁵²⁷³²¹⁷³⁵¹⁵⁹⁰⁴⁹⁴⁶²⁶⁰³⁴¹⁷⁴⁵²⁷⁸¹³³⁹⁹⁵⁵⁶³³⁹⁸⁵⁴³⁸³³⁰⁰²⁷³⁷³⁰⁵⁷⁵⁵²⁶⁵⁶⁶⁷⁵⁴⁰²⁹⁰⁷²⁷⁷⁶⁶⁸⁰⁷⁴⁹³²¹²⁸⁷⁶⁹⁰⁹⁸⁷⁵⁵⁹⁴⁶⁵⁹⁹⁹⁰⁵²⁵¹⁴⁹⁵¹¹⁶⁶⁸⁵⁸⁴³¹⁴⁵⁴¹⁰⁸⁰⁵²⁹²³²⁹²⁰⁵⁰⁷³³⁹²⁸⁰³⁶⁶⁶⁰⁸⁵⁴³²⁸⁴¹⁰⁰⁷²⁹³²³⁷⁰⁷⁷⁴⁴⁸⁴⁷⁵²⁹²⁴⁴⁰²⁸⁷⁰⁴³⁷⁵²²²⁸²⁸⁰⁷⁵⁰⁴⁸⁰⁵³⁴⁴¹⁸⁷³⁰⁶⁶⁸⁴¹⁴³¹⁸⁸⁶⁷⁷⁰⁹⁹⁶⁸⁰⁸⁷⁴⁰⁸²⁷²¹¹⁶⁰³⁴⁷⁵⁰³⁸³⁷⁸¹⁷⁴⁹⁷⁶⁷¹²⁶⁸¹⁵¹⁰⁶²²²²⁶¹⁰⁵⁰⁴²⁹³³⁷⁰¹⁰⁸¹⁶³⁹⁴²⁰⁷⁹⁶⁴⁵⁶⁶²⁵⁸³²⁰⁵³⁴⁸⁰⁷⁹²⁸⁴⁰¹⁷⁰²⁰¹⁹⁷⁸⁷⁴⁶⁸⁶³⁸⁷⁵⁶⁵³⁹³⁰⁵³⁶¹³⁰⁶⁹²¹¹⁴⁵³⁴⁵⁵³⁵⁰⁸²¹³⁷⁷³⁶⁷⁷⁵⁴³⁹⁹⁰⁸⁵⁵⁴⁰²⁸⁴⁵⁹⁵²⁶⁹⁰⁹⁶⁶⁴²²⁹⁷⁹⁹⁹⁶⁶¹¹²⁸⁵²¹⁴⁴⁷²¹²⁴¹⁷⁶²⁵⁸⁴²⁰³⁴¹⁶⁹⁰⁷⁰⁹⁶¹⁵⁰¹⁶⁸⁷⁵⁹⁵⁰⁰⁷⁸⁹³⁴⁷⁴⁰⁴⁸⁹⁵³⁶⁸⁶⁶⁶⁶⁵⁰⁶³⁷³⁰⁰⁹⁸¹⁸⁸⁵²³⁵¹⁷⁴⁸¹⁴⁶⁷¹⁹⁵⁸³¹⁰⁹⁴⁸⁴⁶³⁷⁹⁵⁹⁷³⁶⁹⁸⁵⁹⁶⁶⁹³⁴⁶⁹⁰⁵⁴³³⁵⁹⁰⁹²⁶⁴²⁷⁹⁰³²²⁷⁰¹⁷⁵³⁴⁴⁰¹¹⁸¹⁹³⁴¹⁴¹⁴¹⁰²⁴⁹⁴⁸¹²⁰³⁴⁴⁶¹⁵⁵⁰¹¹⁷⁴¹⁰²³⁸⁹⁷⁹¹⁶³⁵⁰²²⁶³⁷³⁸⁷³⁸⁵²⁷⁰⁰⁷⁵⁸⁰²⁸⁵⁰⁵³¹⁷³⁷⁵";
String resSuber = "₂₃₃₈₇₈₃₅₃₁₈₀₇₅₈₃₃₉₅₂₂₉₉₉₉₈₅₈₄₆₁₄₅₁₅₃₇₀₁₆₂₀₅₅₁₄₇₀₄₇₃₄₉₁₈₃₄₂₀₃₆₅₂₇₃₂₁₇₃₅₁₅₉₀₄₉₄₆₂₆₀₃₄₁₇₄₅₂₇₈₁₃₃₉₉₅₅₆₃₃₉₈₅₄₃₈₃₃₀₀₂₇₃₇₃₀₅₇₅₅₂₆₅₆₆₇₅₄₀₂₉₀₇₂₇₇₆₆₈₀₇₄₉₃₂₁₂₈₇₆₉₀₉₈₇₅₅₉₄₆₅₉₉₉₀₅₂₅₁₄₉₅₁₁₆₆₈₅₈₄₃₁₄₅₄₁₀₈₀₅₂₉₂₃₂₉₂₀₅₀₇₃₃₉₂₈₀₃₆₆₆₀₈₅₄₃₂₈₄₁₀₀₇₂₉₃₂₃₇₀₇₇₄₄₈₄₇₅₂₉₂₄₄₀₂₈₇₀₄₃₇₅₂₂₂₈₂₈₀₇₅₀₄₈₀₅₃₄₄₁₈₇₃₀₆₆₈₄₁₄₃₁₈₈₆₇₇₀₉₉₆₈₀₈₇₄₀₈₂₇₂₁₁₆₀₃₄₇₅₀₃₈₃₇₈₁₇₄₉₇₆₇₁₂₆₈₁₅₁₀₆₂₂₂₂₆₁₀₅₀₄₂₉₃₃₇₀₁₀₈₁₆₃₉₄₂₀₇₉₆₄₅₆₆₂₅₈₃₂₀₅₃₄₈₀₇₉₂₈₄₀₁₇₀₂₀₁₉₇₈₇₄₆₈₆₃₈₇₅₆₅₃₉₃₀₅₃₆₁₃₀₆₉₂₁₁₄₅₃₄₅₅₃₅₀₈₂₁₃₇₇₃₆₇₇₅₄₃₉₉₀₈₅₅₄₀₂₈₄₅₉₅₂₆₉₀₉₆₆₄₂₂₉₇₉₉₉₆₆₁₁₂₈₅₂₁₄₄₇₂₁₂₄₁₇₆₂₅₈₄₂₀₃₄₁₆₉₀₇₀₉₆₁₅₀₁₆₈₇₅₉₅₀₀₇₈₉₃₄₇₄₀₄₈₉₅₃₆₈₆₆₆₆₅₀₆₃₇₃₀₀₉₈₁₈₈₅₂₃₅₁₇₄₈₁₄₆₇₁₉₅₈₃₁₀₉₄₈₄₆₃₇₉₅₉₇₃₆₉₈₅₉₆₆₉₃₄₆₉₀₅₄₃₃₅₉₀₉₂₆₄₂₇₉₀₃₂₂₇₀₁₇₅₃₄₄₀₁₁₈₁₉₃₄₁₄₁₄₁₀₂₄₉₄₈₁₂₀₃₄₄₆₁₅₅₀₁₁₇₄₁₀₂₃₈₉₇₉₁₆₃₅₀₂₂₆₃₇₃₈₇₃₈₅₂₇₀₀₇₅₈₀₂₈₅₀₅₃₁₇₃₇₅";
Assertions.assertEquals(resSuper + "/" + resSuber, FourCornerUnicodeDisplay.text().renderFromInt18(cdc));
}
}