From 080dde496d028702bb2dc3fea8ce9794e5a5cc8a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tam=C3=A1s=20Hadh=C3=A1zy?= <85063808+Hels15@users.noreply.github.com> Date: Thu, 14 Aug 2025 19:23:59 +0100 Subject: chapter24 chaining operator test cases (#227) * Update Chapter14Test.java * fixed order of operands * base rex fixup * more bug fix * remove jukn files * minimal "make release" * further fixes * minor fixes * minor fixes * minor fixes * base != -1 check, precedence fix * Add regkills in IFG building Fix bug LRG union stats Adjust self-conflict splits to be slightly less aggressive In every use-side split, dont split-after-split same block. NewNode is a multi, does not define a register * 64 bit encoding for gpr(s) load * RA improvements Attempt to commute to keep reg-masks compatible. Clones with kills (x86 XOR killing flags to zero) fail before the flag-def. Bugfix failed to color last lrg. More smarts on picking trivial LRGs during coloring Drop isSplit, add SplitNode Pass regalloc round to all splits for debugging Self-conflict no split on loop backedge. Handle split that gets made goes dead No-reg-mask spilling handles case with many def/uses. Add DivIX86 BrainFuck, MergeSort now allocate as testing * 8 bit imm support * conditional jump fix * Push l,ast change, unbreak branch * XOR remove extra opcode, imm size supports 8 bit. * Finally pass the `new [u8]` double-copy test * Fix several ARM reg setup problems Finish Split bypass check ARM: rsp is also a fixed zero, in R31. R0 is a valid register. CallArm prints args, passes TFP for arg selection. Does not return a register. All CallEndARM which DOES return a register. Parms missing tfp for float args. ProjARM after a New missing regs. RetARM missing RPC. Remove hopeful DivIX86 * 64 bit imm for alu ops encoded in extra reg then use it in Op as an operand * Bunch of minor arm, risc fixes small constants not cloning * jump invert encoding * warning comment * Much ARM fixage One More Go-Round with Better Biased Colors Fix bug picking deepest spills to bias. ARM: remove default 2-address. Fix regmask overflow. Rename some ops to be canonical. * Fixes to release Port does not have to be in a Simple named directory. Call convention is just a string, no enum Missed some tests running RISC, ARM. * Minor release change to allow another foreign port * better split encoding and fix CallInMask * notNode * fix callInMask * riscv init * riscv basic ALU ops and types of instructions * Allowing non-Simple repo ports Expanding public API slightly so alternative (non-Simple repo) ports can happen. RegMask supports single-bit-set and a long bitmask. Bugfix GCM splitting multiple global constants. Bugfix LCM grabbing a projection vs multi Bugfix RegAlloc when avoiding splitting a clonable Source code in release More timing in CodeGen * riscv indirect addressing and function calls * Cleanup call ABI presentation Everybody uses the same names, same code shapes * Caller save regs ...not callee save yet * Expose caller save regs * Store Risc adjustments, no imm in MemOpRISC * specific print encoding for cpus * merge fixup * More x86,risc,arm call convention fixes Collect callee and caller save masks (inverts of each other, except for spills). Reorg layout to be closer to each other; remove dead mask definitions; add final keyword * lui fix up with 32 bit immediates * Callee-save registers Callee-save registers and masks and inserting LRGs for same and spilling and picking good spills. Insert CalleeSaveNodes and edges to RetXXXs and RegMasks for those edges. Iterators for regmask. Better printing post-allocation * RegMask supports 128 bits All regs available arm, risc. MergeSort compiles & runs * added flags splitting * Fix risc5 compares No flags on risc5. Branch takes 2 inputs (one can be imm12). Float compare only sets a GPR to 0/1. Bool has a isFloat Common risc5 imm-form handling * extend test cases * imm encoding, flags fixed * grep for Todo: relocs * float riscv fixed * flags for set * lui fix for small bits [0, 12] * arm init * arm last touches * fmov still needs fix * minor fixes * minor fixes(2) * got rid of unnecessary stuff * create ch21 * remove encodings from chapter20 dir * 1/2 pass cleaning up ARM encoding API * ARM encoding compiles * Risc R_TYPE and I_TYPE * Progress RISC encodings Missing lots of stuff still * progress risc encoding * risc encodings compile * Update README.md * Fold up redundant OP/OP-FP risc5 encoding * x86 mem opcodes first cut break out MemOp encodings into parts; change x86 indirectAdr to use Encoding class, remove redundant asserts & code * x86 mem op encodings * x86 reg+imm forms * most reg-reg forms * More x86 encodings * Last few encodings * switch to binary literals over decimals for opcodes * logical immediates fixed, bitwise ops imm forms * tfp and setArm fixed * PC relative float for riscv * readme init * Merged pr/169 * Fixed the array1 test encodings Clean up branch invert logic during BB layout Cleanup branch target printing for RISC,ARM ImmRISC ops mask imm12 to 12 bits Fix NewRISC; hardcode RPC as part of call Fix RISC inverting branchs >,>= * floatarm encoding * tfparm and intarm * uncontional jump encoding for arm and riscv * smarter IntARM, Intx86 does not always include rex. * REX after PREFIX * fixup load and store indirect * updated rex prefix, if its 0x40 then its not needed * Rex fix for floats, got rid of unnecessary stuff. * rename to camel case, better param name * add test export * merged * store opt * store and load optimised forms handled * tfp patch * Store/load float arm/riscv/x64 * got rid of debug print * splits for x86, riscv and arm * readme fixups * fix global symbol numbering for constants * fix TFP pathc on arm and riscv, keep symbols in good order. * fix opcode for store and loads, memOpRisc for Store and splitting * replace hard coded opcodes with major opcodes * replace hard coded opcodes with major opcodes * add asserts and fix reg numbering * add asserts and fix reg numbering * minor updates * revert changes * remove constant pool from encoder TODO: add flag for JIT * extend test cases * minor fixes * minor fixes * update float test case * stringHash fix on x64 * remove conditional ConstantPool write * brainfuck minor fixes * minor arm fixes * split fix * brainfuck and fib * brain fuck * arg_count, person * add ignore * typo * riscv test sieve attempt * minor changes * riscv5 emulator additions * arm eval setup * Update riscv.java * arm eval basics * delta fixes * arm fixes * testfib arm * arg_count * small update for test newton * small update for test newton * testNewton runs on x64, riscv and arm * arm additions * arm pc eval fix * arm workings * debugging * Progress sieve on ARM Most ops need WMASK as the output, to exclude RSP. calloc sentinal changes to multiple of 4 NewArm needs to set arg X0 to #1; arg X1 is length. Fix EvalARM calling calloc & not advancing PC. Fix EvalARM using ints vs longs. Fix EvalARM missing AndI encoding. * Fix some arm encoding Fix some OBOB in R5 calloc encoding. Sort EvalArm by major opcodes. Add ASL. Remove leading switch. Fix OBOB in calloc. Fix shift in ld/st with reg+offset * arm sieve test * test person push * brainFuck arm * "and" "or" syntactic sugar * update encoding * ch23 `and` `or` * hack parse trinary for and, or * close * fixed or issue * Update CallEndNode.java * fix type issue * fixed * Adjust parseTrinary precedence vs && || * Fix arm simulation return * Formatting * Formatting * simplify rn to be always 0. * ch24 init * stacked rel * stack init * stack rel * remove parenthesis * got rid of old test case * update * upgrade eval * arm encoding bugs encodeing cset had a shift wrong eval missed using 0 for r31 * remove debug prints * force main to encode first * fix for missing main * got rid of debug prints * backwards with ch23 * simple new test cases * update test cases * enable old test * got rid of own test case * fix test11 * inline Api * inline x86_64 * inline test cases * fix stacked_r_5 * got rid of redundant rdid -1 set * Several new fuzzer addDeps/keep bugs. Fix risc/arm spill code values for passing 20 args. * Update README Move ch23_ch24 branch into ROADMAP --------- Co-authored-by: Cliff Click --- chapter24/README.md | 432 +- chapter24/ROADMAP.md | 391 ++ .../main/java/com/seaofnodes/simple/Parser.java | 8 +- .../com/seaofnodes/simple/node/CallEndNode.java | 3 +- .../com/seaofnodes/simple/node/RegionNode.java | 6 +- .../com/seaofnodes/simple/node/cpus/arm/arm.java | 52 +- .../java/com/seaofnodes/simple/BrainFuckTest.java | 55 +- .../java/com/seaofnodes/simple/Chapter19Test.java | 83 +- .../java/com/seaofnodes/simple/Chapter20Test.java | 61 +- .../java/com/seaofnodes/simple/Chapter21Test.java | 235 +- .../java/com/seaofnodes/simple/Chapter22Test.java | 72 +- .../java/com/seaofnodes/simple/Chapter23Test.java | 148 +- .../java/com/seaofnodes/simple/Chapter24Test.java | 340 +- .../test/java/com/seaofnodes/simple/EvalArm64.java | 15 +- .../java/com/seaofnodes/simple/MergeSortTest.java | 44 +- .../test/java/com/seaofnodes/simple/TestArm64.java | 12 +- .../src/test/java/com/seaofnodes/simple/TestC.java | 17 + .../test/java/com/seaofnodes/simple/TestRisc5.java | 12 +- .../test/java/com/seaofnodes/simple/progs/and1.smp | 10 - .../test/java/com/seaofnodes/simple/progs/and2.smp | 16 - .../test/java/com/seaofnodes/simple/progs/and3.smp | 14 - .../java/com/seaofnodes/simple/progs/antiDep1.smp | 11 - .../java/com/seaofnodes/simple/progs/arg_count.smp | 6 - .../java/com/seaofnodes/simple/progs/array1.smp | 9 - .../com/seaofnodes/simple/progs/brain_fuck.smp | 46 - .../test/java/com/seaofnodes/simple/progs/echo.smp | 3 - .../test/java/com/seaofnodes/simple/progs/fib.smp | 11 - .../com/seaofnodes/simple/progs/helloWorld.smp | 3 - .../test/java/com/seaofnodes/simple/progs/jig.smp | 19 - .../java/com/seaofnodes/simple/progs/large.smp | 5344 -------------------- .../java/com/seaofnodes/simple/progs/loop2.smp | 10 - .../com/seaofnodes/simple/progs/newtonFloat.smp | 12 - .../seaofnodes/simple/progs/no_stack_arg_count.smp | 6 - .../test/java/com/seaofnodes/simple/progs/or1.smp | 12 - .../test/java/com/seaofnodes/simple/progs/or2.smp | 23 - .../java/com/seaofnodes/simple/progs/person.smp | 9 - .../java/com/seaofnodes/simple/progs/print.smp | 8 - .../java/com/seaofnodes/simple/progs/ptrand.smp | 10 - .../com/seaofnodes/simple/progs/riscv_load.smp | 4 - .../com/seaofnodes/simple/progs/sext_str_1.smp | 4 - .../seaofnodes/simple/progs/sext_str_fold_away.smp | 5 - .../simple/progs/sext_str_not_fold_away.smp | 4 - .../simple/progs/sext_str_not_fold_away_2.smp | 4 - .../java/com/seaofnodes/simple/progs/sieve.smp | 31 - .../test/java/com/seaofnodes/simple/progs/sort.smp | 38 - .../com/seaofnodes/simple/progs/stacked_r_1.smp | 9 - .../com/seaofnodes/simple/progs/stacked_r_10x.c | 13 + .../com/seaofnodes/simple/progs/stacked_r_11x.c | 13 + .../com/seaofnodes/simple/progs/stacked_r_2.smp | 9 - .../com/seaofnodes/simple/progs/stacked_r_3.smp | 10 - .../com/seaofnodes/simple/progs/stacked_r_4.smp | 9 - .../com/seaofnodes/simple/progs/stacked_r_5.smp | 14 - .../com/seaofnodes/simple/progs/stacked_r_9x.c | 13 + .../com/seaofnodes/simple/progs/store_peep.smp | 3 - .../com/seaofnodes/simple/progs/stringHash.smp | 30 - 55 files changed, 1488 insertions(+), 6293 deletions(-) create mode 100644 chapter24/ROADMAP.md delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/and1.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/and2.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/and3.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/antiDep1.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/arg_count.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/array1.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/brain_fuck.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/echo.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/fib.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/helloWorld.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/jig.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/large.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/loop2.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/newtonFloat.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/no_stack_arg_count.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/or1.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/or2.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/person.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/print.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/ptrand.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/riscv_load.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_1.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_fold_away.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_not_fold_away.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_not_fold_away_2.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/sieve.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/sort.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_1.smp create mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_10x.c create mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_11x.c delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_2.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_3.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_4.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_5.smp create mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_9x.c delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/store_peep.smp delete mode 100644 chapter24/src/test/java/com/seaofnodes/simple/progs/stringHash.smp (limited to 'chapter24') diff --git a/chapter24/README.md b/chapter24/README.md index c9a70775..268fbfcc 100644 --- a/chapter24/README.md +++ b/chapter24/README.md @@ -1,417 +1,89 @@ +# Chapter 24: Chaining relationals and Sparse Conditional Constant Propagation +You can also read [this chapter](https://github.com/SeaOfNodes/Simple/tree/linear-chapter23) in a linear Git revision history on the [linear](https://github.com/SeaOfNodes/Simple/tree/linear) branch and [compare](https://github.com/SeaOfNodes/Simple/compare/linear-chapter22...linear-chapter23) it to the previous chapter. -## Unifying Structs and Arrays -The idea is that structs have fields indexed by names, and arrays have fields -indexed by numbers, and these ideas are compatible with each other. This idea -has been used by the C language for a long time - an array can follow a normal -struct C and can index it with the usual array syntax. +## Chaining relationals -The alternative, using a field to hold a pointer to an array, exchanges some -flexibility for an extra indirection. The obvious flexibility allows swapping -the array out (generally for a larger one) and this is the basis of very common -`Vector` or `ArrayList` generic containers. +Chainged relationals offer a cleaner, more readable way to write chained +comparisons without repeating the same variable. - -```java -struct str { - int hash; // A cache of the strings hash code - u32 #; // The array length - u8 []; // Array of bytes -}; - -str X = "abc"; -print(X.hash); // Read the hash field -X[0]=='a'; // Read array element 0 -X#; // Length of the array - -``` - -Here, the field named `#` holds the array length and the field named `[]` is -the actual array, which follows the other fields directly in memory. -Here is another example for variable length array: - -```java -struct vecInt { - u32 size; // Actual number of elements - u32 #; // The array length or capacity - int []; // Array of integers. -}; -``` - -The obvious limit here is that the array cannot be directly resized; it is -literally in the same memory block as the leading fields. Such a `vecInt` can -be *re-allocated* to a new larger `vecInt`, but the original `vecInt` will be -reclaimed - you cannot use the same `vecInt` reference forever. - -Any number of named fields are allowed: - -```java -struct Class { - str className; - str professor; - int time; - int credits; - Class prerequisite; - u16 #; // Limit of 65535 students per class - Student []; -}; -``` - -Or self-reference: - -```java -struct NTree { - Some val; - u8 #; // Length is 0-255 - NTree []; // More NTrees -}; -``` - -The syntax rules are: -- the last field is named `[]` and can be of any type. -- the second-to-last field is named `#` and must be some unsigned integer type - representing the maximum array length. -- may require a leading space in front of ` []` - - - -### Constructors and Arrays - -The allocation includes the array length, and can include a constructor: -`new NTree{val=17;}[2];` - -The constructor is optional, the array length is not. - -Optional function for initializing arrays, allows for write-once final arrays: -`new u8[buffer#,{ u32 idx -> buffer[idx].toUpperCase() }]` - - - -### Changing array max length - -An issue for large numbers of range-checked small arrays is that reserving a -full 4 bytes for array length can substantially increase the array overhead. -Simple allows for arrays to have smaller max lengths, although these are -treated as a different type than arrays with different max lengths. - -```java -struct x0 { u8 #; u8[]; }; // Array limited to 0-255 length -struct x1 { u16 #; u8[]; }; // Array limited to 0-65535 length -struct x2 { u32 #; u8[]; }; // -struct x3 { u64 #; u8[]; }; // - -x0 x = "abc"; // 4 bytes total: [3, 'a', 'b', 'c'] -x1 y = "def"; // 6 bytes total: [3, 0 , 'd', 'e', 'f', 0,]; 1 pad byte to acheieve 2-byte alignment -x = y; // ERROR, "x1 is not x0", no auto-widening -x += y; // OK, 7 bytes total: [6, 'a', 'b', 'c', 'd', 'e', 'f'] -y += x; // OK, 8 bytes total: [6, 0 , 'd', 'e', 'f', 'a', 'b', 'c'] - -x += "VeryLongString.... ....255_chars"; // Runtime RangeCheck - -// Explicit conversion to widen string -y = "" + x; -``` - - -### Two flavors of extendable arrays/strings: an extra indirection or not - -With an extra indirection you get e.g. Java `ArrayList` or C++ `Vector`. - -Without, then any call which extends the extendable array return a potentially -new object, only growing as needed. - -```java -val vec1 = new vecInt[0].add(2); // len=1, capacity=1 -val vec2 = vec1.add(3); // NEW vecInt returned, only is deleted; len=2; capacity=2; -vec1[0]; // ERROR, vec1 has been freed by call to `vec1.add(3)` -vec2[0]; // OK -vec2[1]; // OK -vec2[2]; // Runtime error, AIOOBE +```java +if (min <= x && x < max) ``` +becomes -## A String Implementation - -Default strings have names like "str", "cstr", "ustr" or such. - -Always unicode8 with explicit u8 manipulations. Unicode "characters" will come -as function calls over the base implementation, probably in another string class. - -## Default string - -Efficiently growable via concantenation. Supports a variety of IO/printf functions. -The underlying array can be shared mutable if you ask for this. -The defaults will always be private mutable and read-only shared. - -```java -struct str { - - // Add a string to the string, possibly growing - val add = { str str -> - val self = this; - for( int i=0; i - if( len >= # ) return copy(# ? #*2 : 1).add(e); - [size++] = e; - return this; - }; - - // Copy 'this' to a new larger size - val copy = { int sz2 -> - val v2 = new str[sz2]; - for( int i=0; i sys.libc.write(1/*stdout*/,[]/*array base as argument to C*/,len); return this; } - - u32 len; // In-use size - u32 #; // Max length is 4Gig, although variants can request smaller lengths - u8 []; // Character data -}; +```java +if (min <= x < max) ``` +This syntax saves space and makes the condition more intuitive, similar to how +range checks are written in mathematics. E.g. -### A Final String - -Intended to be a **immutable** string, possibly used as a base for a **secure** -string. This needs to be created all at once, and probably requires a -defensive copy. - -```java -struct sstr { - // Possible static call syntax; no references to "this" - val make { str str -> new sstr[str#,str.at] }; - - // Array contents are immutable. - // Still figuring out good syntax for this. - u8 #; - u8 [~]; // Middlin '~'? Makes primitive array contents *immutable* and requires constructor syntax -}; - -// Construction requires a function that produces the array contents. -// Here we are defining a defensive copy over `buf`. -sstr safe = new sstr[buf.len,{ int idx -> buf[idx]; }]; -sstr safe = sstr.make("abc"); // Defensive copy is made +```java +int score = 75; +if (60 <= score < 90) { + sys.io.p("Pass"); +} ``` +This checks if score is between 60 (inclusive) and 90 (exclusive), without repeating `score`. - -### A Extendable String (aka StringBuilder or StringBuffer) - -This API is intended to be a drop-in for a `StringBuilder` style, and takes an -extra indirection with each usage. +Expressions that mix opposite directions of comparison, like using both <= and +>=, are not allowed, because they create ambiguous logic. ```java -struct xstr { - str !_str; // The extra indirection is here - val add = { str str -> _str = str.add2(str); }; - val write = { int fd -> _str.write(fd); }; -}; +if (a <= b >= c) ``` -### A Unicode String -This API is intended to support unicode character manipulation over a plain `str` +## Operator direction rules +Stacked comparisons are *only valid* if all the comparison operators +"point" the same way: +- `<` with `<` +- `<` with `<=` +- `>` with `>` +- `>` with `>=` -```java -struct ustr { - // Assuming idx is at the start of a character, return the character - // as a 32b integer. Returns junk integer if not at a character start. - // For all ASCII strings this will amount to a simple byte load. - // For bytes with high order bits set, this may read 1-4 characters. - val at = { int idx -> ... }; -}; -// Unicode character iterator -struct ucharator { -// Return successive unicode character codes -}; +It is not allowed to mix directions in a single chain: +```java +if (a <= b >= c) // Invalid ``` -### A "C" string - -A zero-terminated string, but the length has to be available directly - +Comparisons can be forced into numeric context using booleans. +This is valid but unusual: ```java -struct cstr { - u8 #; // length including the trailing zero - u8[]; // always ends in a zero byte; suitable for direct passing to C string functions -}; +return (0 < arg) > 1; ``` - -### A "german string": a very short string that can exist in a register - -Length in memory is 1 byte (3 bits?) of length, then 0-7 chars; max 8 chars. -Fits in a 64 bit register. - +Depending on the result of (0 < arg) this will turn into either ```java -struct gstr { // aka germanString, or blend string and register "streg" - u3 #; // Size is 0-7 bytes??? - u8 []; // Up to 7 bytes -} -// Using inlined object (see below). All these strings are short and are -// represented as packed integers in a 64b register. -*gstr prize1 = "gold"; -*gstr prize2 = "silver"; -*gstr prize3 = "bronze"; - +return 0 > 1; ``` - -### Main becomes `val main = { str[] args -> ...}` - - -## Structs can be inlined - -Structs are normally by-reference, but can be converted to by-value by using -the `*` operator, pronounced "contents of" (this name might be changed to -e.g. `inline`). - -This is a name-space change only, you cannot take the address of the internal -struct without entirely consuming its lifetime. No "escaping". - +OR ```java -// 2 64-bit words, no other overheads -struct Complex { f64 x,y; val len = { ->Math.sqrt(x*x+y*y); }; }; - -// Current Simple rules: always by-reference -struct ByRef { - Complex c; // 4-byte pointer to a Complex -}; -print(new ByRef.c.y); // Lookup requires 1 extra memory load from ref to c - -// New behavior: by value (inlining a struct) -// The '*' syntax indicator can be something else, e.g. a keyword "inline" -// I am pronouncing '*' as "contents of" -struct ByValue { - *Complex c; // c is inlined, full 16 bytes into ByValue -}; -print(new ByValue.c.y); // x,y inlined into ByValue, no extra memory load - -// Mixing Refs and Struct Values. Basically, a ref can be converted -// to a value by taking the "contents of" the ref, and values cannot -// be *converted* to a ref, although they can be copied over a ref. -ref. c = val.c; // Error, mixing refs and values -ref.*c = val.c; // Allowed, whole structure copy. Does not allocate, requires ref.c not-null -val. c = ref.c; // Error, mixing refs and values -val. c = *ref.c; // Allowed, whole structure copy -ref. c = ref.c; // Allowed, pointer copy -val. c = val.c; // Allowed, whole structure copy. -val *c = val.c; // Error, cannot take "contents of" a value - -// Alternative syntax, to avoid the "contents of" being on LHS and field applying to being on RHS: -ref.c = val.*c; // Assign into ref.c the "contents of" val.c - -// Arrays of inlined structures -var ary = new *Complex[99]; // Array of 99 Complex objects, inlined - -// Calling methods has the same syntax -ref.c.len(); -val.c.len(); - -// Function arguments use the same typing, so can pass-by-value -val math.sin = { *Complex c -> ... }; // Passes a complex by value -math.sin(ref.*c); // Requires de-reference to pass by value -math.sin(val. c); // Pass by value - +return 1 > 1; ``` - - - -## RoadMap for other chapters - -`&&` and `||` -Drop `int` to `i32`. -Drop `TypeMemPtr` to 4 bytes; using `mmap` to make heap in low 4G. -Add optimistic pass SCCP to `opto` -Default parser for-loop construction, or partial peel. - `for( init; test; next ) body` -becomes: -```java -{ init; // Normal scope entry to bound lifetime of index variable -if( !test ) { // Zero-trip count test - do { - body; - next; - } while( test ); // Exit test at loop bottom by default -} }; +The equality operator is valid in this form, but since it has lower precedence than comparisons, +```java +a < b == c ``` - -## `&&` and `||` - -The logical operators && (AND) and || (OR) are short-circuiting, meaning they may skip evaluating the second condition if the first one already determines the result: - -- `&&` stops if the first operand is false. -- `||` stops if the first operand is true. - -They are syntactic sugar—used for cleaner control flow—but they don't create new nodes in the execution model. - -The `&&` and `||` constructs are simple syntactic sugars that only modify the control flow and do not -introduce new nodes. - -Consider this example: +is parsed as: ```java -int a = 1; -int b = 0; - -if(a++ || b++ ) { - if(b == 0 && a == 2) { - sys.io.p("Or"); - } -} else{ - sys.io.p("And"); -} -return 0; +(a < b) == c ``` -- `a++` evaluates to 1 (true), so `b++` is not evaluated. -- As a result, `b` stays 0, `a` becomes 2, and "Or" is printed. - -```java -int a = 1; -int b = 1; - -int x=1; -int y=1; -int z=0; - -int g = x++ && y++ && z++; -... +This might not be the intended chained comparison. +A more explicit alternative is: +```java +a < b && b == c ``` -Here: -- `x++` is true (1), so it evaluates `y++`, which is also true. -- Then it evaluates `z++`, which is false (0). -- Since `&&` requires all conditions to be true, the final result `g` is 0. -- All operands up to the false one are evaluated, so `x`, `y`, and `z` are all incremented. +Comparisons can be chained together in any length, and different comparison +operators may be mixed freely as long as they point in the same direction. +Equality(`==`) and inequality(`!=`) operators may be combined with any other +comparisons at any point in the chain. E.g: -## Stacked relational(Operator chaining) -Stacked Relationals offer a cleaner, more readable way to write chained comparisons without repeating the same variable. -```java -if (min <= x && x < max) -``` -becomes -```java -if (min <= x < max) ``` -This syntax saves space and makes the condition more intuitive, similar to how range checks are written in mathematics. -Eg -```java -int score = 75; -if (60 <= score < 90) { - sys.io.p("Pass"); -} -``` -Expressions that mix opposite directions of comparison, like using both <= and >=, are not allowed, because they create ambiguous logic. -```java -if (a <= b >= c) +return 0 < arg < arg+1 < 4; ``` -This checks if score is between 60 (inclusive) and 90 (exclusive), without repeating score. ## SCCP(top-down) \ No newline at end of file diff --git a/chapter24/ROADMAP.md b/chapter24/ROADMAP.md new file mode 100644 index 00000000..4eea9da7 --- /dev/null +++ b/chapter24/ROADMAP.md @@ -0,0 +1,391 @@ + + +## Unifying Structs and Arrays + +The idea is that structs have fields indexed by names, and arrays have fields +indexed by numbers, and these ideas are compatible with each other. This idea +has been used by the C language for a long time - an array can follow a normal +struct C and can index it with the usual array syntax. + +The alternative, using a field to hold a pointer to an array, exchanges some +flexibility for an extra indirection. The obvious flexibility allows swapping +the array out (generally for a larger one) and this is the basis of very common +`Vector` or `ArrayList` generic containers. + + +```java +struct str { + int hash; // A cache of the strings hash code + u32 #; // The array length + u8 []; // Array of bytes +}; + +str X = "abc"; +print(X.hash); // Read the hash field +X[0]=='a'; // Read array element 0 +X#; // Length of the array + +``` + +Here, the field named `#` holds the array length and the field named `[]` is +the actual array, which follows the other fields directly in memory. +Here is another example for variable length array: + +```java +struct vecInt { + u32 size; // Actual number of elements + u32 #; // The array length or capacity + int []; // Array of integers. +}; +``` + +The obvious limit here is that the array cannot be directly resized; it is +literally in the same memory block as the leading fields. Such a `vecInt` can +be *re-allocated* to a new larger `vecInt`, but the original `vecInt` will be +reclaimed - you cannot use the same `vecInt` reference forever. + +Any number of named fields are allowed: + +```java +struct Class { + str className; + str professor; + int time; + int credits; + Class prerequisite; + u16 #; // Limit of 65535 students per class + Student []; +}; +``` + +Or self-reference: + +```java +struct NTree { + Some val; + u8 #; // Length is 0-255 + NTree []; // More NTrees +}; +``` + +The syntax rules are: +- the last field is named `[]` and can be of any type. +- the second-to-last field is named `#` and must be some unsigned integer type + representing the maximum array length. +- may require a leading space in front of ` []` + + + +### Constructors and Arrays + +The allocation includes the array length, and can include a constructor: +`new NTree{val=17;}[2];` + +The constructor is optional, the array length is not. + +Optional function for initializing arrays, allows for write-once final arrays: +`new u8[buffer#,{ u32 idx -> buffer[idx].toUpperCase() }]` + + + +### Changing array max length + +An issue for large numbers of range-checked small arrays is that reserving a +full 4 bytes for array length can substantially increase the array overhead. +Simple allows for arrays to have smaller max lengths, although these are +treated as a different type than arrays with different max lengths. + +```java +struct x0 { u8 #; u8[]; }; // Array limited to 0-255 length +struct x1 { u16 #; u8[]; }; // Array limited to 0-65535 length +struct x2 { u32 #; u8[]; }; // +struct x3 { u64 #; u8[]; }; // + +x0 x = "abc"; // 4 bytes total: [3, 'a', 'b', 'c'] +x1 y = "def"; // 6 bytes total: [3, 0 , 'd', 'e', 'f', 0,]; 1 pad byte to acheieve 2-byte alignment +x = y; // ERROR, "x1 is not x0", no auto-widening +x += y; // OK, 7 bytes total: [6, 'a', 'b', 'c', 'd', 'e', 'f'] +y += x; // OK, 8 bytes total: [6, 0 , 'd', 'e', 'f', 'a', 'b', 'c'] + +x += "VeryLongString.... ....255_chars"; // Runtime RangeCheck + +// Explicit conversion to widen string +y = "" + x; +``` + + +### Two flavors of extendable arrays/strings: an extra indirection or not + +With an extra indirection you get e.g. Java `ArrayList` or C++ `Vector`. + +Without, then any call which extends the extendable array return a potentially +new object, only growing as needed. + +```java +val vec1 = new vecInt[0].add(2); // len=1, capacity=1 +val vec2 = vec1.add(3); // NEW vecInt returned, only is deleted; len=2; capacity=2; +vec1[0]; // ERROR, vec1 has been freed by call to `vec1.add(3)` +vec2[0]; // OK +vec2[1]; // OK +vec2[2]; // Runtime error, AIOOBE +``` + + +## A String Implementation + +Default strings have names like "str", "cstr", "ustr" or such. + +Always unicode8 with explicit u8 manipulations. Unicode "characters" will come +as function calls over the base implementation, probably in another string class. + +## Default string + +Efficiently growable via concantenation. Supports a variety of IO/printf functions. +The underlying array can be shared mutable if you ask for this. +The defaults will always be private mutable and read-only shared. + +```java +struct str { + + // Add a string to the string, possibly growing + val add = { str str -> + val self = this; + for( int i=0; i + if( len >= # ) return copy(# ? #*2 : 1).add(e); + [size++] = e; + return this; + }; + + // Copy 'this' to a new larger size + val copy = { int sz2 -> + val v2 = new str[sz2]; + for( int i=0; i sys.libc.write(1/*stdout*/,[]/*array base as argument to C*/,len); return this; } + + u32 len; // In-use size + u32 #; // Max length is 4Gig, although variants can request smaller lengths + u8 []; // Character data +}; +``` + + +### A Final String + +Intended to be a **immutable** string, possibly used as a base for a **secure** +string. This needs to be created all at once, and probably requires a +defensive copy. + +```java +struct sstr { + // Possible static call syntax; no references to "this" + val make { str str -> new sstr[str#,str.at] }; + + // Array contents are immutable. + // Still figuring out good syntax for this. + u8 #; + u8 [~]; // Middlin '~'? Makes primitive array contents *immutable* and requires constructor syntax +}; + +// Construction requires a function that produces the array contents. +// Here we are defining a defensive copy over `buf`. +sstr safe = new sstr[buf.len,{ int idx -> buf[idx]; }]; +sstr safe = sstr.make("abc"); // Defensive copy is made +``` + + +### A Extendable String (aka StringBuilder or StringBuffer) + +This API is intended to be a drop-in for a `StringBuilder` style, and takes an +extra indirection with each usage. + +```java +struct xstr { + str !_str; // The extra indirection is here + val add = { str str -> _str = str.add2(str); }; + val write = { int fd -> _str.write(fd); }; +}; +``` + +### A Unicode String + +This API is intended to support unicode character manipulation over a plain `str` + +```java +struct ustr { + // Assuming idx is at the start of a character, return the character + // as a 32b integer. Returns junk integer if not at a character start. + // For all ASCII strings this will amount to a simple byte load. + // For bytes with high order bits set, this may read 1-4 characters. + val at = { int idx -> ... }; +}; +// Unicode character iterator +struct ucharator { +// Return successive unicode character codes +}; +``` + +### A "C" string + +A zero-terminated string, but the length has to be available directly + +```java +struct cstr { + u8 #; // length including the trailing zero + u8[]; // always ends in a zero byte; suitable for direct passing to C string functions +}; +``` + +### A "german string": a very short string that can exist in a register + +Length in memory is 1 byte (3 bits?) of length, then 0-7 chars; max 8 chars. +Fits in a 64 bit register. + +```java +struct gstr { // aka germanString, or blend string and register "streg" + u3 #; // Size is 0-7 bytes??? + u8 []; // Up to 7 bytes +} +// Using inlined object (see below). All these strings are short and are +// represented as packed integers in a 64b register. +*gstr prize1 = "gold"; +*gstr prize2 = "silver"; +*gstr prize3 = "bronze"; + +``` + +### Main becomes `val main = { str[] args -> ...}` + + +## Structs can be inlined + +Structs are normally by-reference, but can be converted to by-value by using +the `*` operator, pronounced "contents of" (this name might be changed to +e.g. `inline`). + +This is a name-space change only, you cannot take the address of the internal +struct without entirely consuming its lifetime. No "escaping". + +```java +// 2 64-bit words, no other overheads +struct Complex { f64 x,y; val len = { ->Math.sqrt(x*x+y*y); }; }; + +// Current Simple rules: always by-reference +struct ByRef { + Complex c; // 4-byte pointer to a Complex +}; +print(new ByRef.c.y); // Lookup requires 1 extra memory load from ref to c + +// New behavior: by value (inlining a struct) +// The '*' syntax indicator can be something else, e.g. a keyword "inline" +// I am pronouncing '*' as "contents of" +struct ByValue { + *Complex c; // c is inlined, full 16 bytes into ByValue +}; +print(new ByValue.c.y); // x,y inlined into ByValue, no extra memory load + +// Mixing Refs and Struct Values. Basically, a ref can be converted +// to a value by taking the "contents of" the ref, and values cannot +// be *converted* to a ref, although they can be copied over a ref. +ref. c = val.c; // Error, mixing refs and values +ref.*c = val.c; // Allowed, whole structure copy. Does not allocate, requires ref.c not-null +val. c = ref.c; // Error, mixing refs and values +val. c = *ref.c; // Allowed, whole structure copy +ref. c = ref.c; // Allowed, pointer copy +val. c = val.c; // Allowed, whole structure copy. +val *c = val.c; // Error, cannot take "contents of" a value + +// Alternative syntax, to avoid the "contents of" being on LHS and field applying to being on RHS: +ref.c = val.*c; // Assign into ref.c the "contents of" val.c + +// Arrays of inlined structures +var ary = new *Complex[99]; // Array of 99 Complex objects, inlined + +// Calling methods has the same syntax +ref.c.len(); +val.c.len(); + +// Function arguments use the same typing, so can pass-by-value +val math.sin = { *Complex c -> ... }; // Passes a complex by value +math.sin(ref.*c); // Requires de-reference to pass by value +math.sin(val. c); // Pass by value + +``` + + + +## RoadMap for other chapters + +`&&` and `||` +Drop `int` to `i32`. +Drop `TypeMemPtr` to 4 bytes; using `mmap` to make heap in low 4G. +Add optimistic pass SCCP to `opto` +Default parser for-loop construction, or partial peel. + `for( init; test; next ) body` +becomes: +```java +{ init; // Normal scope entry to bound lifetime of index variable +if( !test ) { // Zero-trip count test + do { + body; + next; + } while( test ); // Exit test at loop bottom by default +} }; +``` + +## `&&` and `||` + +The logical operators && (AND) and || (OR) are short-circuiting, meaning they may skip evaluating the second condition if the first one already determines the result: + +- `&&` stops if the first operand is false. +- `||` stops if the first operand is true. + +They are syntactic sugar—used for cleaner control flow—but they don't create new nodes in the execution model. + +The `&&` and `||` constructs are simple syntactic sugars that only modify the control flow and do not +introduce new nodes. + +Consider this example: +```java +int a = 1; +int b = 0; + +if(a++ || b++ ) { + if(b == 0 && a == 2) { + sys.io.p("Or"); + } +} else{ + sys.io.p("And"); +} +return 0; +``` +- `a++` evaluates to 1 (true), so `b++` is not evaluated. +- As a result, `b` stays 0, `a` becomes 2, and "Or" is printed. + +```java +int a = 1; +int b = 1; + +int x=1; +int y=1; +int z=0; + +int g = x++ && y++ && z++; +... +``` +Here: +- `x++` is true (1), so it evaluates `y++`, which is also true. +- Then it evaluates `z++`, which is false (0). +- Since `&&` requires all conditions to be true, the final result `g` is 0. +- All operands up to the false one are evaluated, so `x`, `y`, and `z` are all incremented. diff --git a/chapter24/src/main/java/com/seaofnodes/simple/Parser.java b/chapter24/src/main/java/com/seaofnodes/simple/Parser.java index 43908685..65c4abf7 100644 --- a/chapter24/src/main/java/com/seaofnodes/simple/Parser.java +++ b/chapter24/src/main/java/com/seaofnodes/simple/Parser.java @@ -1055,7 +1055,9 @@ public class Parser { boolean eq = false; if( match("==") ) eq = true; else if( !match("!=") ) break; - lhs = peep(new BoolNode.EQ(lhs,parseComparison())); + lhs.keep(); + Node rhs = parseComparison(); + lhs = peep(new BoolNode.EQ(lhs.unkeep(),rhs)); if( !eq ) lhs = peep(new NotNode(lhs)); } return lhs; @@ -1082,14 +1084,14 @@ public class Parser { else if( match("<" ) ) dir0 = 1; else if( match(">" ) ) dir0 = 2; else break; + lhs.keep(); // Check and record direction if( dir==0 ) { dir = Math.abs(dir0); Node rhs = parseShift(); - lhs = makeCompBool(dir0,lhs,rhs); // Convert to a bool + lhs = makeCompBool(dir0,lhs.unkeep(),rhs); // Convert to a bool } else if( dir == Math.abs(dir0) ) { // e0 < lhs < ??? - lhs.keep(); Node ifNode = new IfNode(ctrl(), lhs).peephole(); Node ifT = new CProjNode(ifNode. keep(), 0, "True" ).peephole(); Node ifF = new CProjNode(ifNode.unkeep(), 1, "False").peephole(); diff --git a/chapter24/src/main/java/com/seaofnodes/simple/node/CallEndNode.java b/chapter24/src/main/java/com/seaofnodes/simple/node/CallEndNode.java index d95af697..8c25c158 100644 --- a/chapter24/src/main/java/com/seaofnodes/simple/node/CallEndNode.java +++ b/chapter24/src/main/java/com/seaofnodes/simple/node/CallEndNode.java @@ -76,8 +76,9 @@ public class CallEndNode extends CFGNode implements MultiNode { CFGNode idom = call; while( !(idom instanceof FunNode) && idom!=null ) idom = idom.idom(); + if( idom!=null ) addDep(idom); // Inline? - if( idom != fun && idom != null ) { + if( idom != fun && idom != null && !((FunNode)idom)._folding ) { // Trivial inline: rewrite _folding = true; // Rewrite Fun so the normal RegionNode ideal collapses diff --git a/chapter24/src/main/java/com/seaofnodes/simple/node/RegionNode.java b/chapter24/src/main/java/com/seaofnodes/simple/node/RegionNode.java index f6d96410..8f0bddb6 100644 --- a/chapter24/src/main/java/com/seaofnodes/simple/node/RegionNode.java +++ b/chapter24/src/main/java/com/seaofnodes/simple/node/RegionNode.java @@ -101,8 +101,10 @@ public class RegionNode extends CFGNode { while( nouts != nOuts() ) { nouts = nOuts(); for( int i=0; i= tfp.nargs() ) return null; // Anti-dependence - // Count floats in signature up to index - int fcnt=0; - for( int i=2; i> 6) & 0x3F; int imms = imm12 & 0x3F; @@ -609,6 +588,31 @@ public class arm extends Machine { return val; } + @Override public RegMask callArgMask(TypeFunPtr tfp, int idx, int maxArgSlot ) { return callInMask(tfp,idx,maxArgSlot); } + static RegMask callInMask(TypeFunPtr tfp, int idx, int maxArgSlot ) { + if( idx==0 ) return CodeGen.CODE._rpcMask; + if( idx==1 ) return null; + // Count floats in signature up to index + if( idx-2 >= tfp.nargs() ) return null; // Anti-dependence + // Count floats in signature up to index + int fcnt=0; + for( int i=2; i0 ) throw Utils.TODO(); + return new RegMask(MAX_REG + 1 + (idx - 2)); + } + // Return the max stack slot used by this signature, or 0 @Override public short maxArgSlot( TypeFunPtr tfp ) { int icnt=0, fcnt=0; // Count of ints, floats diff --git a/chapter24/src/test/java/com/seaofnodes/simple/BrainFuckTest.java b/chapter24/src/test/java/com/seaofnodes/simple/BrainFuckTest.java index 1e1a1dc3..c1467c07 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/BrainFuckTest.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/BrainFuckTest.java @@ -14,9 +14,58 @@ public class BrainFuckTest { @Test public void testBrainFuck() throws IOException { String brain_fuck = "Hello World!\n"; - TestC.run("brain_fuck", brain_fuck, 40); + String src = +""" +// -*- mode: java; -*- +val brain_fuck = { -> + u8[] !program = new u8[106];program[0] = 43;program[1] = 43;program[2] = 43;program[3] = 43;program[4] = 43;program[5] = 43;program[6] = 43;program[7] = 43;program[8] = 91;program[9] = 62;program[10] = 43;program[11] = 43;program[12] = 43;program[13] = 43;program[14] = 91;program[15] = 62;program[16] = 43;program[17] = 43;program[18] = 62;program[19] = 43;program[20] = 43;program[21] = 43;program[22] = 62;program[23] = 43;program[24] = 43;program[25] = 43;program[26] = 62;program[27] = 43;program[28] = 60;program[29] = 60;program[30] = 60;program[31] = 60;program[32] = 45;program[33] = 93;program[34] = 62;program[35] = 43;program[36] = 62;program[37] = 43;program[38] = 62;program[39] = 45;program[40] = 62;program[41] = 62;program[42] = 43;program[43] = 91;program[44] = 60;program[45] = 93;program[46] = 60;program[47] = 45;program[48] = 93;program[49] = 62;program[50] = 62;program[51] = 46;program[52] = 62;program[53] = 45;program[54] = 45;program[55] = 45;program[56] = 46;program[57] = 43;program[58] = 43;program[59] = 43;program[60] = 43;program[61] = 43;program[62] = 43;program[63] = 43;program[64] = 46;program[65] = 46;program[66] = 43;program[67] = 43;program[68] = 43;program[69] = 46;program[70] = 62;program[71] = 62;program[72] = 46;program[73] = 60;program[74] = 45;program[75] = 46;program[76] = 60;program[77] = 46;program[78] = 43;program[79] = 43;program[80] = 43;program[81] = 46;program[82] = 45;program[83] = 45;program[84] = 45;program[85] = 45;program[86] = 45;program[87] = 45;program[88] = 46;program[89] = 45;program[90] = 45;program[91] = 45;program[92] = 45;program[93] = 45;program[94] = 45;program[95] = 45;program[96] = 45;program[97] = 46;program[98] = 62;program[99] = 62;program[100] = 43;program[101] = 46;program[102] = 62;program[103] = 43;program[104] = 43;program[105] = 46; + int d = 0; + u8[] !output = new u8[0]; + u8[] !data = new u8[100]; - EvalRisc5 R5 = TestRisc5.build("brain_fuck", 0, 28, false); + for( int pc = 0; pc < program#; pc++ ) { + var command = program[pc]; + if (command == 62) { + d++; + } else if (command == 60) { + d--; + } else if (command == 43) { + data[d]++; + } else if (command == 45) { + data[d]--; + } else if (command == 46) { + // Output a byte; increase the output array size + var old = output; + output = new u8[output# + 1]; + for( int i = 0; i < old#; i++ ) + output[i] = old[i]; + output[old#] = data[d]; // Add the extra byte on the end + } else if (command == 44) { + data[d] = 42; + } else if (command == 91) { + if (data[d] == 0) { + for( int d = 1; d > 0; ) { + command = program[++pc]; + if (command == 91) d++; + if (command == 93) d--; + } + } + } else if (command == 93) { + if (data[d]) { + for( int d = 1; d > 0; ) { + command = program[--pc]; + if (command == 93) d++; + if (command == 91) d--; + } + } + } + } + return output; +}; +"""; + TestC.run(src,"brain_fuck", null, brain_fuck, 40); + + EvalRisc5 R5 = TestRisc5.build("brain_fuck", src, 0, 28, false); int trap = R5.step(100000); assertEquals(0,trap); int ptr = (int)R5.regs[riscv.A0]; @@ -24,7 +73,7 @@ public class BrainFuckTest { for( int i=0; i + if( self == s ) return true; + if( self.cs# != s.cs# ) return false; + for( int i=0; i< self.cs#; i++ ) + if( self.cs[i] != s.cs[i] ) + return false; + return true; +}; + +// Return the String hashCode (cached, and never 0) +val hashCode = { String self -> + self._hashCode + ? self._hashCode + : (self._hashCode = _hashCodeString(self)); +}; + +val _hashCodeString = { String self -> + int hash=0; + for( int i=0; i< self.cs#; i++ ) + hash = hash*31 + self.cs[i]; + if( !hash ) hash = 123456789; + return hash; +}; +"""; CodeGen code = new CodeGen(src).parse().opto().typeCheck().GCM().localSched(); assertEquals("Stop[ return Phi(Region,1,0,0,1); return Phi(Region,._hashCode,Phi(Region,123456789,Phi(Loop,0,(.[]+((Phi_hash<<5)-Phi_hash))))); ]", code._stop.toString()); //assertEquals("-4898613127354160978", Eval2.eval(code, 2)); @@ -292,8 +323,20 @@ return A[1]; @Test public void testNewton() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/newtonFloat.smp")) - + "flt farg = arg; return test_sqrt(farg);"; + String src = +""" +val test_sqrt = { flt x -> + flt epsilon = 1e-15; + flt guess = x; + while( 1 ) { + flt next = (x/guess + guess)/2; + if( guess-epsilon <= next & next <= guess+epsilon ) return guess; + //if( guess==next ) return guess; + guess = next; + } +}; +flt farg = arg; return test_sqrt(farg); +"""; CodeGen code = new CodeGen(src).driver(Phase.LocalSched,"x86_64_v2", "SystemV"); assertEquals("return Phi(Loop,(cvtf,arg),(mulf,(addf,(divf,cvtf,Phi_guess),Phi_guess),0.5f));", code.print()); }; @@ -301,7 +344,39 @@ return A[1]; @Test public void sieveOfEratosthenes() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/sieve.smp")); + String src = +""" +val sieve = { int N -> + // The main Sieve array + bool[] !ary = new bool[N]; + // The primes less than N + u32[] !primes = new u32[N>>1]; + // Number of primes so far, searching at index p + int nprimes = 0, p=2; + // Find primes while p^2 < N + while( p*p < N ) { + // skip marked non-primes + while( ary[p] ) p++; + // p is now a prime + primes[nprimes++] = p; + // Mark out the rest non-primes + for( int i = p + p; i < ary#; i+= p ) + ary[i] = true; + p++; + } + + // Now just collect the remaining primes, no more marking + for( ; p < N; p++ ) + if( !ary[p] ) + primes[nprimes++] = p; + + // Copy/shrink the result array + u32[] !rez = new u32[nprimes]; + for( int j=0; j < nprimes; j++ ) + rez[j] = primes[j]; + return rez; +}; +"""; CodeGen code = new CodeGen(src).driver(Phase.LocalSched,"x86_64_v2", "SystemV"); assertEquals("return []u32;", code.print()); //assertEquals("u32[ 2,3,5,7,11,13,17,19]",Eval2.eval(code, 20)); diff --git a/chapter24/src/test/java/com/seaofnodes/simple/Chapter20Test.java b/chapter24/src/test/java/com/seaofnodes/simple/Chapter20Test.java index dcea5c87..b04ba24c 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/Chapter20Test.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/Chapter20Test.java @@ -73,8 +73,20 @@ return sqrt(arg) + sqrt(cast_int); @Test public void testNewtonFloat() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/newtonFloat.smp")) - + "flt farg = arg; return test_sqrt(farg) + test_sqrt(farg+2.0);"; + String src = +""" +val test_sqrt = { flt x -> + flt epsilon = 1e-15; + flt guess = x; + while( 1 ) { + flt next = (x/guess + guess)/2; + if( guess-epsilon <= next & next <= guess+epsilon ) return guess; + //if( guess==next ) return guess; + guess = next; + } +}; +flt farg = arg; return test_sqrt(farg) + test_sqrt(farg+2.0); +"""; testCPU(src,"x86_64_v2", "SystemV",39,null); testCPU(src,"riscv" , "SystemV",17,null); testCPU(src,"arm" , "SystemV",18,null); @@ -92,7 +104,17 @@ return sqrt(arg) + sqrt(cast_int); @Test public void testArray1() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/array1.smp")); + String src = +""" +int[] !ary = new int[arg]; +// Fill [0,1,2,3,4,...] +for( int i=0; i + if( self == s ) return true; + if( self.cs# != s.cs# ) return false; + for( int i=0; i< self.cs#; i++ ) + if( self.cs[i] != s.cs[i] ) + return false; + return true; +}; + +// Return the String hashCode (cached, and never 0) +val hashCode = { String self -> + self._hashCode + ? self._hashCode + : (self._hashCode = _hashCodeString(self)); +}; + +val _hashCodeString = { String self -> + int hash=0; + for( int i=0; i< self.cs#; i++ ) + hash = hash*31 + self.cs[i]; + if( !hash ) hash = 123456789; + return hash; +}; +"""; testCPU(src,"x86_64_v2", "SystemV", 9,null); testCPU(src,"riscv" , "SystemV", 3,null); testCPU(src,"arm" , "SystemV", 3,null); diff --git a/chapter24/src/test/java/com/seaofnodes/simple/Chapter21Test.java b/chapter24/src/test/java/com/seaofnodes/simple/Chapter21Test.java index 7f4898e0..ec55735e 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/Chapter21Test.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/Chapter21Test.java @@ -15,7 +15,25 @@ public class Chapter21Test { @Test public void testJig() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/jig.smp")); + String src = +""" +struct s0 { + bool v1; + i16 v2; + int v3; + i8 v4; + byte v5; +}; +while(new s0.v3) + while(new s0.v5< + if( self == s ) return true; + if( self.cs# != s.cs# ) return false; + for( int i=0; i< self.cs#; i++ ) + if( self.cs[i] != s.cs[i] ) + return false; + return true; +}; + +// Return the String hashCode (cached, and never 0) +val hashCode = { String self -> + self._hashCode + ? self._hashCode + : (self._hashCode = _hashCodeString(self)); +}; + +val _hashCodeString = { String self -> + int hash=0; + for( int i=0; i< self.cs#; i++ ) + hash = hash*31 + self.cs[i]; + if( !hash ) hash = 123456789; + return hash; +}; +"""; testCPU(src,"x86_64_v2", "SystemV", 9,null); testCPU(src,"riscv" , "SystemV", 3,null); testCPU(src,"arm" , "SystemV", 3,null); } @Test public void testStringExport() throws IOException { - TestC.run("stringHash", 9); + String src = +""" +struct String { + u8[] cs; + int _hashCode; +}; + +// Compare two Strings +val equals = { String self, String s -> + if( self == s ) return true; + if( self.cs# != s.cs# ) return false; + for( int i=0; i< self.cs#; i++ ) + if( self.cs[i] != s.cs[i] ) + return false; + return true; +}; + +// Return the String hashCode (cached, and never 0) +val hashCode = { String self -> + self._hashCode + ? self._hashCode + : (self._hashCode = _hashCodeString(self)); +}; + +val _hashCodeString = { String self -> + int hash=0; + for( int i=0; i< self.cs#; i++ ) + hash = hash*31 + self.cs[i]; + if( !hash ) hash = 123456789; + return hash; +}; +"""; + TestC.run(src, "stringHash",null, "", 9); } @Test public void testLoop2() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/loop2.smp")); + String src = +""" +int i = 0; +while(true) { + i += 1; + if( i==0 ) continue; + if( i==1 ) continue; + if( i==2 ) break; + continue; +} +return i; +"""; testCPU(src,"x86_64_v2", "Win64" ,0,"return (inc,Phi(Loop,0,inc));"); testCPU(src,"riscv" , "SystemV",0,"return ( Phi(Loop,0,addi) + #1 );"); testCPU(src,"arm" , "SystemV",0,"return (inc,Phi(Loop,0,inc));"); @@ -94,9 +208,22 @@ public class Chapter21Test { 8 2.828427 (4.44089e-16) 9 3.000000 (0) """; - TestC.run("newtonFloat",result,34); + String src = +""" +val test_sqrt = { flt x -> + flt epsilon = 1e-15; + flt guess = x; + while( 1 ) { + flt next = (x/guess + guess)/2; + if( guess-epsilon <= next & next <= guess+epsilon ) return guess; + //if( guess==next ) return guess; + guess = next; + } +}; +"""; + TestC.run(src, "newtonFloat", null, result, 34); - EvalRisc5 R5 = TestRisc5.build("newtonFloat", 0, 10, false); + EvalRisc5 R5 = TestRisc5.build("newtonFloat",src, 0, 10, false); R5.fregs[riscv.FA0 - riscv.F_OFFSET] = 3.0; int trap_r5 = R5.step(1000); assertEquals(0,trap_r5); @@ -104,7 +231,7 @@ public class Chapter21Test { assertEquals(1.732051,R5.fregs[riscv.FA0 - riscv.F_OFFSET], 0.00001); // arm - EvalArm64 A5 = TestArm64.build("newtonFloat", 0, 10, false); + EvalArm64 A5 = TestArm64.build("newtonFloat", src,0, 10, false); A5.fregs[arm.D0 - arm.D_OFFSET] = 3.0; int trap_arm = A5.step(1000); assertEquals(0,trap_arm); @@ -113,6 +240,39 @@ public class Chapter21Test { @Test public void testSieve() throws IOException { + String src = +""" +val sieve = { int N -> + // The main Sieve array + bool[] !ary = new bool[N]; + // The primes less than N + u32[] !primes = new u32[N>>1]; + // Number of primes so far, searching at index p + int nprimes = 0, p=2; + // Find primes while p^2 < N + while( p*p < N ) { + // skip marked non-primes + while( ary[p] ) p++; + // p is now a prime + primes[nprimes++] = p; + // Mark out the rest non-primes + for( int i = p + p; i < ary#; i+= p ) + ary[i] = true; + p++; + } + + // Now just collect the remaining primes, no more marking + for( ; p < N; p++ ) + if( !ary[p] ) + primes[nprimes++] = p; + + // Copy/shrink the result array + u32[] !rez = new u32[nprimes]; + for( int j=0; j < nprimes; j++ ) + rez[j] = primes[j]; + return rez; +}; +"""; // The primes int[] primes = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, }; SB sb = new SB().p(primes.length).p("["); @@ -121,11 +281,11 @@ public class Chapter21Test { String sprimes = sb.p("]").toString(); // Compile, link against native C; expect the above string of primes to be printed out by C - TestC.run("sieve",sprimes, 257); + TestC.run(src, "sieve", null, sprimes, 257); // Evaluate on RISC5 emulator; expect return of an array of primes in // the simulated heap. - EvalRisc5 R5 = TestRisc5.build("sieve", 100, 160, false); + EvalRisc5 R5 = TestRisc5.build("sieve", src, 100, 160, false); int trap = R5.step(10000); assertEquals(0,trap); // Return register A0 holds sieve(100) @@ -137,7 +297,7 @@ public class Chapter21Test { // Evaluate on ARM5 emulator; expect return of an array of primes in // the simulated heap. - EvalArm64 A5 = TestArm64.build("sieve", 100, 160, false); + EvalArm64 A5 = TestArm64.build("sieve", src, 100, 160, false); int trap_arm = A5.step(10000); assertEquals(0, trap_arm); int ary_arm = (int)A5.regs[arm.X0]; @@ -148,17 +308,30 @@ public class Chapter21Test { } @Test public void testFibExport() throws IOException { + String src = +""" +val fib = {int n -> + int f1=1; + int f2=1; + while( n-- > 1 ){ + int temp = f1+f2; + f1=f2; + f2=temp; + } + return f2; +}; +"""; String fib = "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]"; - TestC.run("fib", fib, 24); + TestC.run(src, "fib", null, fib, 24); - EvalRisc5 R5 = TestRisc5.build("fib", 9, 17, false); + EvalRisc5 R5 = TestRisc5.build("fib", src, 9, 17, false); int trap = R5.step(100); assertEquals(0,trap); // Return register A0 holds fib(8)==55 assertEquals(55,R5.regs[riscv.A0]); // arm - EvalArm64 A5 = TestArm64.build("fib", 9, 17, false); + EvalArm64 A5 = TestArm64.build("fib", src, 9, 17, false); int trap_arm = A5.step(100); assertEquals(0,trap_arm); // Return register X0 holds fib(8)==55 @@ -166,8 +339,19 @@ public class Chapter21Test { } @Test public void testPerson() throws IOException { + String src = + """ + struct Person { + i32 age; + }; + + val fcn = { Person?[] ps, int x -> + if( ps[x] ) + ps[x].age++; + }; + """; String person = "6\n"; - TestC.run("person", person, 0); + TestC.run(src, "person", null, person, 0); // Memory layout starting at PS: int ps = 1<<16; // Person array pointer starts at heap start @@ -178,7 +362,7 @@ public class Chapter21Test { int p1 = ps+4*8+1*8; // P2 = { age } // sizeof=8 int p2 = ps+4*8+2*8; - EvalRisc5 R5 = TestRisc5.build("person", ps, 0, false); + EvalRisc5 R5 = TestRisc5.build("person", src, ps, 0, false); R5.regs[riscv.A1] = 1; // Index 1 R5.st8(ps,3); // Length R5.st8(ps+1*8,p0); @@ -194,7 +378,7 @@ public class Chapter21Test { assertEquals(17+1,R5.ld8(p1)); assertEquals(60+0,R5.ld8(p2)); - EvalArm64 A5 = TestArm64.build("person", ps, 0, false); + EvalArm64 A5 = TestArm64.build("person", src, ps, 0, false); A5.regs[arm.X1] = 1; // Index 1 A5.st8(ps, 3); A5.st8(ps+1*8,p0); @@ -214,12 +398,19 @@ public class Chapter21Test { @Test public void testArgCount() throws IOException { // Test passes more args than registers in Sys5, which is far far more // than what Win64 allows - so Win64 gets a lot more spills here. + String src = +""" +val addAll = { int i0, flt f1, int i2, flt f3, int i4, flt f5, int i6, flt f7, int x8, flt f9, int i10, flt f11, int i12, flt f13, int i14, flt f15, int x16, flt f17 int x18, flt f19 -> + return + i0 + f1+ i2+ f3+ i4+ f5+ i6+ f7+ x8 +f9 + + i10+f11+i12+f13+i14+f15+x16+f17+x18+f19 ; +}; +"""; String arg_count = "191.000000\n"; - TestC.run("arg_count", arg_count, - TestC.CALL_CONVENTION.equals("Win64") ? 42 : 15); + TestC.run(src, "arg_count", null, arg_count, TestC.CALL_CONVENTION.equals("Win64") ? 42 : 15); - EvalRisc5 R5 = TestRisc5.build("no_stack_arg_count", 0, 0, false); + EvalRisc5 R5 = TestRisc5.build("no_stack_arg_count", src, 0, 4, false); // Todo: handle stack(imaginary stack in emulator) // pass in float arguments @@ -249,7 +440,7 @@ public class Chapter21Test { assertEquals(22.8, result, 0.00001); // arm - EvalArm64 A5 = TestArm64.build("no_stack_arg_count", 0, 0, false); + EvalArm64 A5 = TestArm64.build("no_stack_arg_count", src, 0, 4, false); A5.fregs[arm.D0 - arm.D_OFFSET] = 1.1; A5.fregs[arm.D1 - arm.D_OFFSET] = 1.1; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/Chapter22Test.java b/chapter24/src/test/java/com/seaofnodes/simple/Chapter22Test.java index 13322d3d..9e230bcd 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/Chapter22Test.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/Chapter22Test.java @@ -13,10 +13,27 @@ import static org.junit.Assert.*; public class Chapter22Test { - @Test @Ignore + @Test public void testJig() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/jig.smp")); - //String src = Files.readString(Path.of("docs/examples/BubbleSort.smp")); + String src = + """ + struct s0 { + bool v1; + i16 v2; + int v3; + i8 v4; + byte v5; + }; + while(new s0.v3) + while(new s0.v5<>48; return 0; """; - EvalRisc5 R5 = TestRisc5.build("sext_str_fold_away", 0, 5, false); + EvalRisc5 R5 = TestRisc5.build("sext_str_fold_away", src, 0, 5, false); int trap = R5.step(100); assertEquals(0,trap); - EvalArm64 A5 = TestArm64.build("sext_str_fold_away", 0, 5, false); + EvalArm64 A5 = TestArm64.build("sext_str_fold_away", src, 0, 5, false); int trap_arm = A5.step(100); assertEquals(0,trap_arm); @@ -112,8 +129,19 @@ return 0; // Int now is changed to 4 bytes. @Test public void testPerson() throws IOException { + String src = +""" +struct Person { + i32 age; +}; + +val fcn = { Person?[] ps, int x -> + if( ps[x] ) + ps[x].age++; +}; +"""; String person = "6\n"; - TestC.run("person", person, 0); + TestC.run(src, "person", null, person, 0); // Memory layout starting at PS: int ps = 1<<16; // Person array pointer starts at heap start @@ -124,7 +152,7 @@ return 0; int p1 = ps+4*8+1*8; // P2 = { age } // sizeof=8 int p2 = ps+4*8+2*8; - EvalRisc5 R5 = TestRisc5.build("person", ps, 0, false); + EvalRisc5 R5 = TestRisc5.build("person", src, ps, 0, false); R5.regs[riscv.A1] = 1; // Index 1 R5.st8(ps,3); // Length R5.st8(ps+1*8,p0); @@ -140,7 +168,7 @@ return 0; assertEquals(17+1,R5.ld8(p1)); assertEquals(60+0,R5.ld8(p2)); - EvalArm64 A5 = TestArm64.build("person", ps, 0, false); + EvalArm64 A5 = TestArm64.build("person", src, ps, 0, false); A5.regs[arm.X1] = 1; // Index 1 A5.st8(ps, 3); A5.st8(ps+1*8,p0); @@ -179,18 +207,22 @@ return cc.cz; @Test public void testHelloWorld() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/helloWorld.smp")); + String src = +""" +sys.io.p("Hello, World!"); +return 0; +"""; TestC.run(src,TestC.CALL_CONVENTION,null, null,null,"build/objs/helloWorld","","Hello, World!",0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("helloWorld", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("helloWorld", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("Hello, World!",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("helloWorld", 0, 2, false); + EvalArm64 arm = TestArm64.build("helloWorld", src,0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -220,17 +252,21 @@ return sum(is); @Test @Ignore public void testEcho() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/echo.smp")); + String src = +""" +// Echo stdin to stdout. +return sys.io.p( sys.io.stdin() ); +"""; TestC.run(src,TestC.CALL_CONVENTION,null, null,null,"build/objs/echo","","",0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("echo", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("echo", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("echo", 0, 2, false); + EvalArm64 arm = TestArm64.build("echo", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); diff --git a/chapter24/src/test/java/com/seaofnodes/simple/Chapter23Test.java b/chapter24/src/test/java/com/seaofnodes/simple/Chapter23Test.java index 267bb3e0..94e13a87 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/Chapter23Test.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/Chapter23Test.java @@ -35,17 +35,32 @@ public class Chapter23Test { @Test public void testOr() throws IOException { - TestC.runS("or1","Or",0); + String src = + """ + int a = 1; + int b = 0; + + if(a++ || b++ ) { + if(b == 0 && a == 2) { + sys.io.p("Or"); + } + } else{ + sys.io.p("And"); + } + return 0; + """; + + TestC.runSF("or1", src, null, "Or", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("or1", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("or1", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("Or",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("or1", 0, 2, false); + EvalArm64 arm = TestArm64.build("or1", src,0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -54,17 +69,29 @@ public class Chapter23Test { @Test public void testAnd() throws IOException { - TestC.runS("and1","And",0); + String src = + """ + int a = 1; + int b = 1; + + if(a && b) { + sys.io.p("And"); + } else { + sys.io.p("Or"); + } + return 0; + """; + TestC.runSF("and1", src, null, "And", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("and1", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("and1", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("And",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("and1", 0, 2, false); + EvalArm64 arm = TestArm64.build("and1", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -73,24 +100,38 @@ public class Chapter23Test { @Test public void testAndPtr() throws IOException { + // Todo: have one src here String src = -""" -struct S { S? fld; }; -val ptr = arg == 1 ? null : new S{fld = arg==1 ? null : new S{fld = null;};}; -return ptr && ptr.fld ? "true" : "false"; - """; + """ + struct S { S? fld; }; + val ptr = arg == 1 ? null : new S{fld = arg==1 ? null : new S{fld = null;};}; + return ptr && ptr.fld ? "true" : "false"; + """; + String src2 = + """ + struct S { S? fld; }; + + val ptr = arg == 1 ? null : new S{fld = arg==1 ? null : new S{fld = null;};}; + if( ptr && ptr.fld ) { + sys.io.p("true"); + } else { + sys.io.p("false"); + } + + return 0; + """; CodeGen code = new CodeGen(src).parse().opto().typeCheck(); assertEquals("[97-117][ 116,114,117,101]", Eval2.eval(code, 0)); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("ptrand", 1, 8, false); + EvalRisc5 R5 = TestRisc5.build("ptrand",src2, 1, 8, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("false",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("ptrand", 1, 8, false); + EvalArm64 arm = TestArm64.build("ptrand", src2, 1, 8, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -100,37 +141,80 @@ return ptr && ptr.fld ? "true" : "false"; // conditional side effect @Test public void testCondSideEffAnd() throws IOException { - TestC.runS("and2","Effected",0); + String src = + """ + int a = 1; + int b = 1; + + int x=1; + int y=1; + int z=0; + + int g = x++ && y++ && z++; + + if(x == 2 && y == 2 && z == 1 && g == 0) { + sys.io.p("Effected"); + } else { + sys.io.p("Not effected"); + } + return 0; + """; + + TestC.runSF("and2", src, null, "Effected", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("and2", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("and2", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("Effected",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("and2", 0, 2, false); + EvalArm64 arm = TestArm64.build("and2", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); assertEquals("Effected",arm._stdout.toString()); } - @Test public void testCondSideEffOr() throws IOException { - TestC.runS("or2","Effected",0); + String src = + """ + int a = 1; + int b = 1; + + int x = -1; + int y=1; + int z= -1; + + int g = x++ || y++ || z++; + + int switch = 0; + if(x == 4 || y == 4 || z == 4) { + switch = -1; + } else { + switch = 1; + } + int cd = 1; + if((x == 0 && y == 1 && z==-1) && switch && g) { + sys.io.p("Effected"); + } else { + sys.io.p("Not effected"); + } + return 0; + """; + TestC.runSF("or2", src, null, "Effected", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("or2", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("or2", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("Effected",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("or2", 0, 2, false); + EvalArm64 arm = TestArm64.build("or2", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -140,23 +224,41 @@ return ptr && ptr.fld ? "true" : "false"; // test it with function calls @Test public void testFuncCall() throws IOException { - TestC.runS("and3","Or",0); + String src = + """ + // -*- mode: java; -*- + int a = 1; + int b = 1; + + var sq = { int x -> + x*x; + }; + + if(a && sq(0)) { + sys.io.p("And"); + } else { + sys.io.p("Or"); + } + return 0; + """; + TestC.runSF("and3", src, null, "Or", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("and3", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("and3", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("Or",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("and3", 0, 2, false); + EvalArm64 arm = TestArm64.build("and3", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); assertEquals("Or",arm._stdout.toString()); } + @Test public void testFRefFields() { String src = diff --git a/chapter24/src/test/java/com/seaofnodes/simple/Chapter24Test.java b/chapter24/src/test/java/com/seaofnodes/simple/Chapter24Test.java index dcb7216f..cf6290e4 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/Chapter24Test.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/Chapter24Test.java @@ -7,6 +7,7 @@ import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; +import com.seaofnodes.simple.type.TypeInteger; import org.junit.Test; import static org.junit.Assert.*; @@ -33,17 +34,32 @@ public class Chapter24Test { @Test public void testOr() throws IOException { - TestC.runS("or1","Or",0); + String src = +""" +int a = 1; +int b = 0; + +if(a++ || b++ ) { + if(b == 0 && a == 2) { + sys.io.p("Or"); + } +} else{ + sys.io.p("And"); +} +return 0; +"""; + + TestC.runSF("or1", src, null, "Or", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("or1", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("or1", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("Or",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("or1", 0, 2, false); + EvalArm64 arm = TestArm64.build("or1", src,0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -52,17 +68,29 @@ public class Chapter24Test { @Test public void testAnd() throws IOException { - TestC.runS("and1","And",0); + String src = +""" +int a = 1; +int b = 1; + +if(a && b) { + sys.io.p("And"); +} else { + sys.io.p("Or"); +} +return 0; +"""; + TestC.runSF("and1", src, null, "And", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("and1", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("and1", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("And",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("and1", 0, 2, false); + EvalArm64 arm = TestArm64.build("and1", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -71,24 +99,38 @@ public class Chapter24Test { @Test public void testAndPtr() throws IOException { + // Todo: have one src here String src = """ struct S { S? fld; }; val ptr = arg == 1 ? null : new S{fld = arg==1 ? null : new S{fld = null;};}; return ptr && ptr.fld ? "true" : "false"; +"""; + String src2 = +""" +struct S { S? fld; }; + +val ptr = arg == 1 ? null : new S{fld = arg==1 ? null : new S{fld = null;};}; +if( ptr && ptr.fld ) { + sys.io.p("true"); +} else { + sys.io.p("false"); +} + +return 0; """; CodeGen code = new CodeGen(src).parse().opto().typeCheck(); assertEquals("[97-117][ 116,114,117,101]", Eval2.eval(code, 0)); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("ptrand", 1, 8, false); + EvalRisc5 R5 = TestRisc5.build("ptrand",src2, 1, 8, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("false",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("ptrand", 1, 8, false); + EvalArm64 arm = TestArm64.build("ptrand", src2, 1, 8, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -98,17 +140,36 @@ return ptr && ptr.fld ? "true" : "false"; // conditional side effect @Test public void testCondSideEffAnd() throws IOException { - TestC.runS("and2","Effected",0); + String src = +""" +int a = 1; +int b = 1; + +int x=1; +int y=1; +int z=0; + +int g = x++ && y++ && z++; + +if(x == 2 && y == 2 && z == 1 && g == 0) { + sys.io.p("Effected"); +} else { + sys.io.p("Not effected"); +} +return 0; +"""; + + TestC.runSF("and2", src, null, "Effected", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("and2", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("and2", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("Effected",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("and2", 0, 2, false); + EvalArm64 arm = TestArm64.build("and2", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -118,17 +179,42 @@ return ptr && ptr.fld ? "true" : "false"; @Test public void testCondSideEffOr() throws IOException { - TestC.runS("or2","Effected",0); + String src = +""" +int a = 1; +int b = 1; + +int x = -1; +int y=1; +int z= -1; + +int g = x++ || y++ || z++; + +int switch = 0; +if(x == 4 || y == 4 || z == 4) { + switch = -1; +} else { + switch = 1; +} +int cd = 1; +if((x == 0 && y == 1 && z==-1) && switch && g) { + sys.io.p("Effected"); +} else { + sys.io.p("Not effected"); +} +return 0; +"""; + TestC.runSF("or2", src, null, "Effected", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("or2", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("or2", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("Effected",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("or2", 0, 2, false); + EvalArm64 arm = TestArm64.build("or2", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -138,17 +224,34 @@ return ptr && ptr.fld ? "true" : "false"; // test it with function calls @Test public void testFuncCall() throws IOException { - TestC.runS("and3","Or",0); + String src = +""" +// -*- mode: java; -*- +int a = 1; +int b = 1; + +var sq = { int x -> + x*x; +}; + +if(a && sq(0)) { + sys.io.p("And"); +} else { + sys.io.p("Or"); +} +return 0; +"""; + TestC.runSF("and3", src, null, "Or", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("and3", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("and3", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("Or",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("and3", 0, 2, false); + EvalArm64 arm = TestArm64.build("and3", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -158,17 +261,29 @@ return ptr && ptr.fld ? "true" : "false"; // test it with function calls @Test public void testStack1() throws IOException { - TestC.runS("stacked_r_1","In Range",0); + String src = +""" +int something_specific = 11; + +if (10 < something_specific < 20) { + sys.io.p("In Range"); +} else { + sys.io.p("Out of Range"); +} +return 0; +"""; + + TestC.runSF("stacked_r_1", src, null, "In Range", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("stacked_r_1", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("stacked_r_1", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("In Range",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("stacked_r_1", 0, 2, false); + EvalArm64 arm = TestArm64.build("stacked_r_1", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -177,55 +292,92 @@ return ptr && ptr.fld ? "true" : "false"; @Test public void testStack2() throws IOException { - TestC.runS("stacked_r_2","In range",0); + String src = +""" +int score = 75; + +if (60 <= score < 90) { + sys.io.p("In Range"); +} else { +sys.io.p("Out of range"); +} +return 0; +"""; + + TestC.runSF("stacked_r_2", src, null, "In Range", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("stacked_r_2", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("stacked_r_2", src, 0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); - assertEquals("In range",R5._stdout.toString()); + assertEquals("In Range",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("stacked_r_2", 0, 2, false); + EvalArm64 arm = TestArm64.build("stacked_r_2", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); - assertEquals("In range",arm._stdout.toString()); + assertEquals("In Range",arm._stdout.toString()); } @Test public void testStack3() throws IOException { - TestC.runS("stacked_r_3","In range",5); + String src = +""" +var sq = { int x -> + x*x; +}; + +int score = 5; + +val str = (sq(2) <= score < sq(3)) ? "In Range" : "Out of range"; +sys.io.p(str); +return 0; +"""; + + TestC.runSF("stacked_r_3", src, null, "In Range", 5); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("stacked_r_3", 0, 5, false); + EvalRisc5 R5 = TestRisc5.build("stacked_r_3", src, 0, 5, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); - assertEquals("In range",R5._stdout.toString()); + assertEquals("In Range",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("stacked_r_3", 0, 5, false); + EvalArm64 arm = TestArm64.build("stacked_r_3", src, 0, 5, false); int trap_1 = arm.step(100); assertEquals(0,trap_1); assertEquals(0,arm.regs[0]); - assertEquals("In range",arm._stdout.toString()); + assertEquals("In Range",arm._stdout.toString()); } @Test public void testStack4() throws IOException { - TestC.runS("stacked_r_4","Out of Range",0); + String src = +""" +int something_specific = 9; + +if (10 < something_specific < 20) { + sys.io.p("In Range"); +} else { + sys.io.p("Out of Range"); +} +return 0; +"""; + + TestC.runSF("stacked_r_4", src, null, "Out of Range", 0); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("stacked_r_4", 0, 2, false); + EvalRisc5 R5 = TestRisc5.build("stacked_r_4", src,0, 2, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("Out of Range",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("stacked_r_4", 0, 2, false); + EvalArm64 arm = TestArm64.build("stacked_r_4", src, 0, 2, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); @@ -234,24 +386,136 @@ return ptr && ptr.fld ? "true" : "false"; @Test public void testStack5() throws IOException { - TestC.runS("stacked_r_5","In range",5); + String src = +""" +var sq = { int x -> + x*x; +}; + +int score = 5; + +if (sq(2) <= score < sq(3)) { +sys.io.p("In Range"); +} else { +sys.io.p("Out of range"); +} + +return 0; +"""; + TestC.runSF("stacked_r_5", src, null, "In Range", 5); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build("stacked_r_5", 0, 7, false); + EvalRisc5 R5 = TestRisc5.build("stacked_r_5", src, 0, 7, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); - assertEquals("In range",R5._stdout.toString()); + assertEquals("In Range",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("stacked_r_5", 0, 7, false); + EvalArm64 arm = TestArm64.build("stacked_r_5", src, 0, 7, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); - assertEquals("In range",arm._stdout.toString()); + assertEquals("In Range",arm._stdout.toString()); + } + + + @Test + public void testStack6() { + try { new CodeGen( + """ + return 0 < arg > 1; + """ + ).parse(); fail(); } + catch( RuntimeException e ) { assertEquals("Mixing relational directions in a chained relational test",e.getMessage()); } + } + + @Test + public void testStack9() throws IOException { + String stack9 = "1"; + String src = +""" +var stack9 = { int x -> + (x < 1) == 1; +}; +"""; + String src2 = +""" +return (0 < 1) == 1; +"""; + TestC.run(src, "stacked_r_9x", null, stack9,0); + + // Evaluate on RISC5 emulator + EvalRisc5 R5 = TestRisc5.build("stacked_r_9", src2, 0, 0, false); + int trap = R5.step(100); + assertEquals(0,trap); + assertEquals(1,R5.regs[riscv.A0]); + + // Evaluate on ARM emulator + EvalArm64 arm = TestArm64.build("stacked_r_9", src2, 0, 0, false); + trap = arm.step(100); + assertEquals(0,trap); + assertEquals(1,arm.regs[0]); + } + + @Test + public void testStack10() throws IOException { + String stack10 = "1"; + String src = +""" +var stack10 = { int x -> + (x < 1) == (1>x); +}; +"""; + String src2 = +""" +return (0 < 1) == (1>0); +"""; + TestC.run(src, "stacked_r_10x", null, stack10,0); + + // Evaluate on RISC5 emulator + EvalRisc5 R5 = TestRisc5.build("stacked_r_10", src2, 0, 0, false); + int trap = R5.step(100); + assertEquals(0,trap); + assertEquals(1,R5.regs[riscv.A0]); + + // Evaluate on ARM emulator + EvalArm64 arm = TestArm64.build("stacked_r_10", src2,0, 0, false); + trap = arm.step(100); + assertEquals(0,trap); + assertEquals(1,arm.regs[0]); + } + + @Test + public void testStack11() throws IOException { + String stack11 = "1"; + String src = +""" +var stack11 = { int x -> + 0 < x < x+1 < 4; +}; +"""; + String src2 = +""" +return 0 < arg < arg+1 < 4; +"""; + TestC.run(src, "stacked_r_11x", null, stack11,0); + + // Evaluate on RISC5 emulator + EvalRisc5 R5 = TestRisc5.build("stacked_r_11", src2, 1, 2, false); + int trap = R5.step(100); + assertEquals(0,trap); + assertEquals(1,R5.regs[riscv.A0]); + + // Evaluate on ARM emulator + EvalArm64 arm = TestArm64.build("stacked_r_11", src2, 1, 2, false); + trap = arm.step(100); + assertEquals(0,trap); + assertEquals(1,arm.regs[0]); } + @Test public void testFRefFields() { String src = diff --git a/chapter24/src/test/java/com/seaofnodes/simple/EvalArm64.java b/chapter24/src/test/java/com/seaofnodes/simple/EvalArm64.java index 078bc9e8..9575d9fe 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/EvalArm64.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/EvalArm64.java @@ -341,7 +341,6 @@ public class EvalArm64 { regs[arm.X0] = _heap; _heap += (int)size; pc = (int)rval; - rdid = -1; } if( pc == Encoding.SENTINEL_WRITE ) { ByteArrayOutputStream baos = switch((int)regs[0]) { @@ -352,17 +351,19 @@ public class EvalArm64 { baos.write(_buf,(int)regs[1],(int)regs[2]); regs[0] = regs[2]; pc = (int)rval; - rdid = -1; } pc -= 4; + rdid = -1; break; } case 0x9A: { + int encodedCond = (ir >> 12) & 0xF; + int decodedCond = encodedCond ^ 1; // conditional select(csel) int rm = (ir >> 16) & 0x1F; int rn = (ir >> 5) & 0x1F; - boolean cond = switch ((ir >> 12) & 0xF) { + boolean cond = switch (decodedCond) { case 0x0 -> Z ; // eq case 0x1 -> !Z ; // ne case 0x2 -> C ; // cs @@ -381,9 +382,11 @@ public class EvalArm64 { case 0xF -> false ; // never default -> throw Utils.TODO(); }; - int reg = cond ? rn : rm; - rval = reg==31 ? 0 : regs[reg]; - if( cond ) rval++; +// int reg = cond ? rn : rm; +// rval = reg==31 ? 0 : regs[reg]; +// if( cond ) rval++; + if(cond) rval = 1; + else rval = 0; break; } case 0x9B: { // mul diff --git a/chapter24/src/test/java/com/seaofnodes/simple/MergeSortTest.java b/chapter24/src/test/java/com/seaofnodes/simple/MergeSortTest.java index 65eb525c..9c7c1360 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/MergeSortTest.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/MergeSortTest.java @@ -13,15 +13,54 @@ import static org.junit.Assert.fail; public class MergeSortTest { @Test public void testMergeSort0() throws IOException { + // Test merge sort on a small array of primes + String src = +""" + val merge_sort = { int[] a -> + int[] !b = new int[a#]; + copy_array (a, 0, a#, b); + split_merge(a, 0, a#, b); + }; + + val split_merge = { int[] b, int begin, int end, int[] a -> + if (end - begin <= 1) + return 0; + int middle = (end + begin) / 2; + split_merge(a, begin, middle, b); + split_merge(a, middle, end, b); + merge(b, begin, middle, end, a); + return 0; + }; + + val merge = { int[] b, int begin, int middle, int end, int[] a -> + int i = begin, j = middle; + + for (int k = begin; k < end; k++) { + // && and || + bool cond = false; + if (i < middle) { + if (j >= end) cond = true; + else if (a[i] <= a[j]) cond = true; + } + if (cond) b[k] = a[i++]; + else b[k] = a[j++]; + } + }; + + val copy_array = { int[] a, int begin, int end, int[] b -> + for (int k = begin; k < end; k++) + b[k] = a[k]; + }; +"""; int[] primes = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, }; SB sb = new SB().p(primes.length).p("["); for( int prime : primes ) sb.p(prime).p(", "); String sprimes = sb.p("]").toString(); - TestC.run("sort", sprimes, 40); + TestC.run(src, "sort", null, sprimes, 40); - EvalRisc5 R5 = TestRisc5.build("src/test/java/com/seaofnodes/simple/progs", "sort", "merge_sort", 0, 36, false); + EvalRisc5 R5 = TestRisc5.build("src/test/java/com/seaofnodes/simple/progs",src, "sort", "merge_sort", 0, 36, false); // Allocate an array of primes, filled in reverse order int ps = R5._heap; R5._heap += (primes.length+1)*8; // 25 primes, and length @@ -39,7 +78,6 @@ public class MergeSortTest { assertEquals(primes[i], R5.ld8(ps+(i+1)*8)); // TODO: replace with ARM Eval - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/sort.smp")); Chapter21Test.testCPU(src,"arm", "SystemV",36,null); } } diff --git a/chapter24/src/test/java/com/seaofnodes/simple/TestArm64.java b/chapter24/src/test/java/com/seaofnodes/simple/TestArm64.java index 5d7d1361..a1c02ede 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/TestArm64.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/TestArm64.java @@ -14,13 +14,19 @@ import static org.junit.Assert.assertEquals; public class TestArm64 { public static EvalArm64 build( String file, int arg, int spills, boolean print ) throws IOException { - return build("src/test/java/com/seaofnodes/simple/progs",file, arg, spills, print); + String dir = "src/test/java/com/seaofnodes/simple/progs"; + String src = Files.readString(Path.of(dir + "/"+file+".smp")); + return build(dir,src, file, arg, spills, print); + } + + public static EvalArm64 build( String name, String src, int arg, int spills, boolean print ) throws IOException { + String dir = "src/test/java/com/seaofnodes/simple/progs"; + return build(dir, src ,name, arg, spills, print); } // Compile and run a simple program - public static EvalArm64 build( String dir, String file, int arg, int spills, boolean print ) throws IOException { + public static EvalArm64 build( String dir, String src, String file, int arg, int spills, boolean print ) throws IOException { // Compile and export Simple - String src = Files.readString(Path.of(dir+"/"+file+".smp")); CodeGen code = new CodeGen(src).driver("arm", "SystemV",null); if( print ) { code.print_as_hex(); System.out.print(code.asm()); } diff --git a/chapter24/src/test/java/com/seaofnodes/simple/TestC.java b/chapter24/src/test/java/com/seaofnodes/simple/TestC.java index dbe9f02f..f1831929 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/TestC.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/TestC.java @@ -40,14 +40,31 @@ public abstract class TestC { String src = Files.readString(Path.of(sfile)); run(src,CALL_CONVENTION,arg, "",standalone? null: cfile,efile,"S",expected,spills); } + + // link with c and also inline + public static void run(String src, String file, TypeInteger arg, String expected, int spills) throws IOException { + String dir = "src/test/java/com/seaofnodes/simple/progs"; + String cfile = dir+"/"+file+".c"; + String efile = "build/objs/"+file; + run(src, CALL_CONVENTION, arg, "", cfile, efile, "S", expected, spills); + } + public static void run(String dir, String file, String expected, int spills ) throws IOException { run(dir, file,null, expected, spills, false); } + // Do not link with c file - no inline. public static void runS(String file, String expected, int spills ) throws IOException { run("src/test/java/com/seaofnodes/simple/progs", file, null, expected, spills, true); } + + // Do not link with c file - just inline with source. + public static void runSF(String name, String src, TypeInteger arg, String expected, int spills ) throws IOException { + String efile = "build/objs/"+name; + run(src,CALL_CONVENTION,arg, "",null,efile,"S",expected,spills); + } + public static void runS(String file, TypeInteger arg, String expected, int spills ) throws IOException { run("src/test/java/com/seaofnodes/simple/progs", file, arg, expected, spills, true); } diff --git a/chapter24/src/test/java/com/seaofnodes/simple/TestRisc5.java b/chapter24/src/test/java/com/seaofnodes/simple/TestRisc5.java index 041ed833..a8f6817e 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/TestRisc5.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/TestRisc5.java @@ -13,13 +13,19 @@ import static org.junit.Assert.*; public abstract class TestRisc5 { public static EvalRisc5 build( String file, int arg, int spills, boolean print ) throws IOException { - return build("src/test/java/com/seaofnodes/simple/progs",file, null, arg, spills, print); + String dir = "src/test/java/com/seaofnodes/simple/progs"; + String src = Files.readString(Path.of(dir + "/"+file+".smp")); + return build(dir,src, file, null, arg, spills, print); + } + + public static EvalRisc5 build( String name, String src, int arg, int spills, boolean print ) throws IOException { + String dir = "src/test/java/com/seaofnodes/simple/progs"; + return build(dir, src ,name, null, arg, spills, print); } // Compile and run a simple program - public static EvalRisc5 build( String dir, String file, String main, int arg, int spills, boolean print ) throws IOException { + public static EvalRisc5 build( String dir, String src, String file, String main, int arg, int spills, boolean print ) throws IOException { // Compile and export Simple - String src = Files.readString(Path.of(dir+"/"+file+".smp")); CodeGen code = new CodeGen(src).driver("riscv", "SystemV",null); if( print ) { code.print_as_hex(); System.out.print(code.asm()); } diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/and1.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/and1.smp deleted file mode 100644 index ef4c904f..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/and1.smp +++ /dev/null @@ -1,10 +0,0 @@ -// -*- mode: java; -*- -int a = 1; -int b = 1; - -if(a && b) { - sys.io.p("And"); -} else { - sys.io.p("Or"); -} -return 0; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/and2.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/and2.smp deleted file mode 100644 index 2a463c94..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/and2.smp +++ /dev/null @@ -1,16 +0,0 @@ -// -*- mode: java; -*- -int a = 1; -int b = 1; - -int x=1; -int y=1; -int z=0; - -int g = x++ && y++ && z++; - -if(x == 2 && y == 2 && z == 1 && g == 0) { - sys.io.p("Effected"); -} else { - sys.io.p("Not effected"); -} -return 0; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/and3.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/and3.smp deleted file mode 100644 index aadbdfed..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/and3.smp +++ /dev/null @@ -1,14 +0,0 @@ -// -*- mode: java; -*- -int a = 1; -int b = 1; - -var sq = { int x -> - x*x; -}; - -if(a && sq(0)) { - sys.io.p("And"); -} else { - sys.io.p("Or"); -} -return 0; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/antiDep1.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/antiDep1.smp deleted file mode 100644 index b18dfd16..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/antiDep1.smp +++ /dev/null @@ -1,11 +0,0 @@ -// -*- mode: java; -*- -struct S { int f; }; -var v0 = new S; -S? v1; -if (arg) v1 = new S; -if (v1) { - v0.f = v1.f; -} else { - v0.f = 2; -} -return v0; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/arg_count.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/arg_count.smp deleted file mode 100644 index 6b6bc0ae..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/arg_count.smp +++ /dev/null @@ -1,6 +0,0 @@ -// -*- mode: java; -*- -val addAll = { int i0, flt f1, int i2, flt f3, int i4, flt f5, int i6, flt f7, int x8, flt f9, int i10, flt f11, int i12, flt f13, int i14, flt f15, int x16, flt f17 int x18, flt f19 -> - return - i0 + f1+ i2+ f3+ i4+ f5+ i6+ f7+ x8 +f9 + - i10+f11+i12+f13+i14+f15+x16+f17+x18+f19 ; -}; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/array1.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/array1.smp deleted file mode 100644 index 6b10f92c..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/array1.smp +++ /dev/null @@ -1,9 +0,0 @@ -// -*- mode: java; -*- -int[] !ary = new int[arg]; -// Fill [0,1,2,3,4,...] -for( int i=0; i - u8[] !program = new u8[106];program[0] = 43;program[1] = 43;program[2] = 43;program[3] = 43;program[4] = 43;program[5] = 43;program[6] = 43;program[7] = 43;program[8] = 91;program[9] = 62;program[10] = 43;program[11] = 43;program[12] = 43;program[13] = 43;program[14] = 91;program[15] = 62;program[16] = 43;program[17] = 43;program[18] = 62;program[19] = 43;program[20] = 43;program[21] = 43;program[22] = 62;program[23] = 43;program[24] = 43;program[25] = 43;program[26] = 62;program[27] = 43;program[28] = 60;program[29] = 60;program[30] = 60;program[31] = 60;program[32] = 45;program[33] = 93;program[34] = 62;program[35] = 43;program[36] = 62;program[37] = 43;program[38] = 62;program[39] = 45;program[40] = 62;program[41] = 62;program[42] = 43;program[43] = 91;program[44] = 60;program[45] = 93;program[46] = 60;program[47] = 45;program[48] = 93;program[49] = 62;program[50] = 62;program[51] = 46;program[52] = 62;program[53] = 45;program[54] = 45;program[55] = 45;program[56] = 46;program[57] = 43;program[58] = 43;program[59] = 43;program[60] = 43;program[61] = 43;program[62] = 43;program[63] = 43;program[64] = 46;program[65] = 46;program[66] = 43;program[67] = 43;program[68] = 43;program[69] = 46;program[70] = 62;program[71] = 62;program[72] = 46;program[73] = 60;program[74] = 45;program[75] = 46;program[76] = 60;program[77] = 46;program[78] = 43;program[79] = 43;program[80] = 43;program[81] = 46;program[82] = 45;program[83] = 45;program[84] = 45;program[85] = 45;program[86] = 45;program[87] = 45;program[88] = 46;program[89] = 45;program[90] = 45;program[91] = 45;program[92] = 45;program[93] = 45;program[94] = 45;program[95] = 45;program[96] = 45;program[97] = 46;program[98] = 62;program[99] = 62;program[100] = 43;program[101] = 46;program[102] = 62;program[103] = 43;program[104] = 43;program[105] = 46; - int d = 0; - u8[] !output = new u8[0]; - u8[] !data = new u8[100]; - - for( int pc = 0; pc < program#; pc++ ) { - var command = program[pc]; - if (command == 62) { - d++; - } else if (command == 60) { - d--; - } else if (command == 43) { - data[d]++; - } else if (command == 45) { - data[d]--; - } else if (command == 46) { - // Output a byte; increase the output array size - var old = output; - output = new u8[output# + 1]; - for( int i = 0; i < old#; i++ ) - output[i] = old[i]; - output[old#] = data[d]; // Add the extra byte on the end - } else if (command == 44) { - data[d] = 42; - } else if (command == 91) { - if (data[d] == 0) { - for( int d = 1; d > 0; ) { - command = program[++pc]; - if (command == 91) d++; - if (command == 93) d--; - } - } - } else if (command == 93) { - if (data[d]) { - for( int d = 1; d > 0; ) { - command = program[--pc]; - if (command == 93) d++; - if (command == 91) d--; - } - } - } - } - return output; -}; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/echo.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/echo.smp deleted file mode 100644 index 8eafd73b..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/echo.smp +++ /dev/null @@ -1,3 +0,0 @@ -// -*- mode: java; -*- -// Echo stdin to stdout. -return sys.io.p( sys.io.stdin() ); diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/fib.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/fib.smp deleted file mode 100644 index 1512541b..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/fib.smp +++ /dev/null @@ -1,11 +0,0 @@ -// -*- mode: java; -*- -val fib = {int n -> - int f1=1; - int f2=1; - while( n-- > 1 ){ - int temp = f1+f2; - f1=f2; - f2=temp; - } - return f2; -}; \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/helloWorld.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/helloWorld.smp deleted file mode 100644 index 07ff935f..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/helloWorld.smp +++ /dev/null @@ -1,3 +0,0 @@ -// -*- mode: java; -*- -sys.io.p("Hello, World!"); -return 0; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/jig.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/jig.smp deleted file mode 100644 index 001e8eae..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/jig.smp +++ /dev/null @@ -1,19 +0,0 @@ -// -*- mode: java; -*- -//2298769344378917493 -//========= Reduced ========= -struct s0 { - bool v1; - i16 v2; - int v3; - i8 v4; - byte v5; -}; -while(new s0.v3) - while(new s0.v5< int } read = "C"; // fill 'data' with 'size' bytes. return number of bytes actually read - { i64 int -> int } skip = "C"; // skip the next 'n' bytes, or 'unget' the last -n bytes if negative - { i64 -> int } eof = "C"; // returns nonzero if we are at end of file/data -}; - -struct stbi__context { - u32 img_x, img_y; - int img_n, img_out_n; - - stbi_io_callbacks io; - u8[]io_user_data; - - int read_from_callbacks; - int buflen; - u8[] buffer_start; - int callback_already_read; - - u8[] img_buffer; - int img_buffer_end; - u8[] img_buffer_original; - int img_buffer_original_end; -}; - -{ stbi__context -> u8 } stbi__get8 = "C"; - -val sample = { stbi__context s, int pal_len -> - var palette = new u8[1024]; - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - for (int i=0; i < pal_len; ++i) { - palette[i*4+3] = 0; - - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - for (int j=0; j < pal_len; ++j) { - palette[j*4+3] = 0; - - palette[j*4+0] = stbi__get8(s); - palette[j*4+1] = stbi__get8(s); - palette[j*4+2] = stbi__get8(s); - palette[j*4+3] = 255; - } - } - - return palette; -}; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/loop2.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/loop2.smp deleted file mode 100644 index 01ec827e..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/loop2.smp +++ /dev/null @@ -1,10 +0,0 @@ -// -*- mode: java; -*- -int i = 0; -while(true) { - i += 1; - if( i==0 ) continue; - if( i==1 ) continue; - if( i==2 ) break; - continue; -} -return i; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/newtonFloat.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/newtonFloat.smp deleted file mode 100644 index be2dffec..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/newtonFloat.smp +++ /dev/null @@ -1,12 +0,0 @@ -// -*- mode: java; -*- -// Newtons approximation to the square root -val test_sqrt = { flt x -> - flt epsilon = 1e-15; - flt guess = x; - while( 1 ) { - flt next = (x/guess + guess)/2; - if( guess-epsilon <= next & next <= guess+epsilon ) return guess; - //if( guess==next ) return guess; - guess = next; - } -}; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/no_stack_arg_count.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/no_stack_arg_count.smp deleted file mode 100644 index 20a05445..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/no_stack_arg_count.smp +++ /dev/null @@ -1,6 +0,0 @@ -// -*- mode: java; -*- -val addAll = { int i0, flt f1, int i2, flt f3, int i4, flt f5, int i6, flt f7, int x8, flt f9, int i10, flt f11, int i12, flt f13, int i14, flt f15 -> - return - i0 + f1+ i2+ f3+ i4+ f5+ i6+ f7+ x8 +f9 + - i10+f11+i12+f13+i14+f15; -}; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/or1.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/or1.smp deleted file mode 100644 index f5f526c3..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/or1.smp +++ /dev/null @@ -1,12 +0,0 @@ -// -*- mode: java; -*- -int a = 1; -int b = 0; - -if(a++ || b++ ) { - if(b == 0 && a == 2) { - sys.io.p("Or"); - } -} else{ - sys.io.p("And"); -} -return 0; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/or2.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/or2.smp deleted file mode 100644 index ac688b5a..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/or2.smp +++ /dev/null @@ -1,23 +0,0 @@ -// -*- mode: java; -*- -int a = 1; -int b = 1; - -int x = -1; -int y=1; -int z= -1; - -int g = x++ || y++ || z++; - -int switch = 0; -if(x == 4 || y == 4 || z == 4) { - switch = -1; -} else { - switch = 1; -} -int cd = 1; -if((x == 0 && y == 1 && z==-1) && switch && g) { - sys.io.p("Effected"); -} else { - sys.io.p("Not effected"); -} -return 0; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/person.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/person.smp deleted file mode 100644 index 507fb83b..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/person.smp +++ /dev/null @@ -1,9 +0,0 @@ -// -*-java-*- -struct Person { - i32 age; -}; - -val fcn = { Person?[] ps, int x -> - if( ps[x] ) - ps[x].age++; -}; \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/print.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/print.smp deleted file mode 100644 index 3bb86268..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/print.smp +++ /dev/null @@ -1,8 +0,0 @@ -int x = 1; - -int y = 2; -if(x == 1) { -y = 1; -} - -return y; \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/ptrand.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/ptrand.smp deleted file mode 100644 index 9d7bce88..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/ptrand.smp +++ /dev/null @@ -1,10 +0,0 @@ -struct S { S? fld; }; - -val ptr = arg == 1 ? null : new S{fld = arg==1 ? null : new S{fld = null;};}; -if( ptr && ptr.fld ) { - sys.io.p("true"); -} else { - sys.io.p("false"); -} - -return 0; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/riscv_load.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/riscv_load.smp deleted file mode 100644 index 67369feb..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/riscv_load.smp +++ /dev/null @@ -1,4 +0,0 @@ -struct Person { i32 age;}; -Person !p = new Person; -p.age += arg; -return p.age; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_1.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_1.smp deleted file mode 100644 index cfb3fbcc..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_1.smp +++ /dev/null @@ -1,4 +0,0 @@ -struct Person {i64 age;} -Person !p = new Person; -p.age += arg; -return p.age; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_fold_away.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_fold_away.smp deleted file mode 100644 index 0cf70392..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_fold_away.smp +++ /dev/null @@ -1,5 +0,0 @@ -// Should fold away sign extend -struct Person { i8 age;}; -Person !p = new Person; -p.age = (arg<<48)>>48; -return 0; \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_not_fold_away.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_not_fold_away.smp deleted file mode 100644 index 48cc6409..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_not_fold_away.smp +++ /dev/null @@ -1,4 +0,0 @@ -struct Person { i32 age;}; -Person !p = new Person; -p.age = (arg<<17)>>17; -return 0; \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_not_fold_away_2.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_not_fold_away_2.smp deleted file mode 100644 index 3120429b..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/sext_str_not_fold_away_2.smp +++ /dev/null @@ -1,4 +0,0 @@ -struct Person { i32 age;}; -Person !p = new Person; -p.age = (arg<<48)>>48; -return 0; \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/sieve.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/sieve.smp deleted file mode 100644 index 569dbb96..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/sieve.smp +++ /dev/null @@ -1,31 +0,0 @@ -// -*- mode: java; -*- -val sieve = { int N -> - // The main Sieve array - bool[] !ary = new bool[N]; - // The primes less than N - u32[] !primes = new u32[N>>1]; - // Number of primes so far, searching at index p - int nprimes = 0, p=2; - // Find primes while p^2 < N - while( p*p < N ) { - // skip marked non-primes - while( ary[p] ) p++; - // p is now a prime - primes[nprimes++] = p; - // Mark out the rest non-primes - for( int i = p + p; i < ary#; i+= p ) - ary[i] = true; - p++; - } - - // Now just collect the remaining primes, no more marking - for( ; p < N; p++ ) - if( !ary[p] ) - primes[nprimes++] = p; - - // Copy/shrink the result array - u32[] !rez = new u32[nprimes]; - for( int j=0; j < nprimes; j++ ) - rez[j] = primes[j]; - return rez; -}; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/sort.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/sort.smp deleted file mode 100644 index ae3f4f23..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/sort.smp +++ /dev/null @@ -1,38 +0,0 @@ -// -*- mode: java; -*- -// based on the top-down version from https://en.wikipedia.org/wiki/Merge_sort - -val merge_sort = { int[] a -> - int[] !b = new int[a#]; - copy_array (a, 0, a#, b); - split_merge(a, 0, a#, b); -}; - -val split_merge = { int[] b, int begin, int end, int[] a -> - if (end - begin <= 1) - return 0; - int middle = (end + begin) / 2; - split_merge(a, begin, middle, b); - split_merge(a, middle, end, b); - merge(b, begin, middle, end, a); - return 0; -}; - -val merge = { int[] b, int begin, int middle, int end, int[] a -> - int i = begin, j = middle; - - for (int k = begin; k < end; k++) { - // && and || - bool cond = false; - if (i < middle) { - if (j >= end) cond = true; - else if (a[i] <= a[j]) cond = true; - } - if (cond) b[k] = a[i++]; - else b[k] = a[j++]; - } -}; - -val copy_array = { int[] a, int begin, int end, int[] b -> - for (int k = begin; k < end; k++) - b[k] = a[k]; -}; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_1.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_1.smp deleted file mode 100644 index 43d7a5d1..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_1.smp +++ /dev/null @@ -1,9 +0,0 @@ -// -*- mode: java; -*- -int something_specific = 11; - -if (10 < something_specific < 20) { - sys.io.p("In Range"); -} else { - sys.io.p("Out of Range"); -} -return 0; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_10x.c b/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_10x.c new file mode 100644 index 00000000..d44d5387 --- /dev/null +++ b/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_10x.c @@ -0,0 +1,13 @@ +#include +#include +#include + +__attribute__ ((CALL_CONV)) +extern int stack10(int x); + +int main() { +int result = stack10(0); + +printf("%d", result); +return 0; +} \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_11x.c b/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_11x.c new file mode 100644 index 00000000..d71979d1 --- /dev/null +++ b/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_11x.c @@ -0,0 +1,13 @@ +#include +#include +#include + +__attribute__ ((CALL_CONV)) +extern int stack11(int x); + +int main() { +int result = stack11(1); + +printf("%d", result); +return 0; +} \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_2.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_2.smp deleted file mode 100644 index a867267e..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_2.smp +++ /dev/null @@ -1,9 +0,0 @@ -// -*- mode: java; -*- -int score = 75; - -if (60 <= score < 90) { - sys.io.p("In range"); -} else { -sys.io.p("Out of range"); -} -return 0; \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_3.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_3.smp deleted file mode 100644 index 27fe15ea..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_3.smp +++ /dev/null @@ -1,10 +0,0 @@ -// -*- mode: java; -*- -var sq = { int x -> - x*x; -}; - -int score = 5; - -val str = (sq(2) <= score < sq(3)) ? "In range" : "Out of range"; -sys.io.p(str); -return 0; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_4.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_4.smp deleted file mode 100644 index 029245ed..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_4.smp +++ /dev/null @@ -1,9 +0,0 @@ -// -*- mode: java; -*- -int something_specific = 9; - -if (10 < something_specific < 20) { - sys.io.p("In Range"); -} else { - sys.io.p("Out of Range"); -} -return 0; \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_5.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_5.smp deleted file mode 100644 index 13a3dbff..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_5.smp +++ /dev/null @@ -1,14 +0,0 @@ -// -*- mode: java; -*- -var sq = { int x -> - x*x; -}; - -int score = 5; - -if (sq(2) <= score < sq(3)) { -sys.io.p("In range"); -} else { -sys.io.p("Out of range"); -} - -return 0; \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_9x.c b/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_9x.c new file mode 100644 index 00000000..4f93ba24 --- /dev/null +++ b/chapter24/src/test/java/com/seaofnodes/simple/progs/stacked_r_9x.c @@ -0,0 +1,13 @@ +#include +#include +#include + +__attribute__ ((CALL_CONV)) +extern int stack9(int x); + +int main() { +int result = stack9(0); + +printf("%d", result); +return 0; +} \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/store_peep.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/store_peep.smp deleted file mode 100644 index c3feddd5..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/store_peep.smp +++ /dev/null @@ -1,3 +0,0 @@ -i64 a = 123456789012345; -i32 b = a; // truncate high order bits -return b; \ No newline at end of file diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/stringHash.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/stringHash.smp deleted file mode 100644 index 3fa2174c..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/stringHash.smp +++ /dev/null @@ -1,30 +0,0 @@ -// -*- mode: java; -*- -struct String { - u8[] cs; - int _hashCode; -}; - -// Compare two Strings -val equals = { String self, String s -> - if( self == s ) return true; - if( self.cs# != s.cs# ) return false; - for( int i=0; i< self.cs#; i++ ) - if( self.cs[i] != s.cs[i] ) - return false; - return true; -}; - -// Return the String hashCode (cached, and never 0) -val hashCode = { String self -> - self._hashCode - ? self._hashCode - : (self._hashCode = _hashCodeString(self)); -}; - -val _hashCodeString = { String self -> - int hash=0; - for( int i=0; i< self.cs#; i++ ) - hash = hash*31 + self.cs[i]; - if( !hash ) hash = 123456789; - return hash; -}; -- cgit v1.2.3