diff options
55 files changed, 1488 insertions, 6293 deletions
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<str#; i++ ) - self = self.add(str[i]); - return self; - }; - - // Add an char to the string, possibly growing - val add = { u8 e -> - 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<len; i++ ) - v2[i] = [i]; - v2.len = len; - sys.libc.free(this); // Needs a better Mem Management solution - return v2; - }; - - val print { -> 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<str#; i++ ) + self = self.add(str[i]); + return self; + }; + + // Add an char to the string, possibly growing + val add = { u8 e -> + 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<len; i++ ) + v2[i] = [i]; + v2.len = len; + sys.libc.free(this); // Needs a better Mem Management solution + return v2; + }; + + val print { -> 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<nOuts(); i++ ) - if( out(i) instanceof PhiNode phi && phi.nIns()==nIns() ) + if( out(i) instanceof PhiNode phi && phi.nIns()==nIns() ) { + CodeGen.CODE.addAll(phi.in(path)._outputs); CodeGen.CODE.addAll(phi.delDef(path)._outputs); + } } return isDead() ? Parser.XCTRL : delDef(path); } @@ -165,4 +167,4 @@ public class RegionNode extends CFGNode { // Never equal if inProgress @Override public boolean eq( Node n ) { return !inProgress(); } -}
\ No newline at end of file +} diff --git a/chapter24/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java b/chapter24/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java index 1c61bb37..a5dac751 100644 --- a/chapter24/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java +++ b/chapter24/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java @@ -216,7 +216,9 @@ public class arm extends Machine { assert 0 <= rm && rm < 32; assert 0 <= rn && rn < 32; assert 0 <= rd && rd < 32; - return (opcode << 21) | (rm << 16) | (cond.ordinal() << 12) | (0b01 << 10) | (rn << 5) | rd; + // Is one of the standard conditions, excluding AL and NV, encoded in the "cond" field with its least significant bit inverted. + int actualCond = cond.ordinal() ^ 1; + return (opcode << 21) | (rm << 16) | (actualCond << 12) | (0b01 << 10) | (rn << 5) | rd; } static public int cset(int opcode, COND cond, int rn, int rd) { @@ -563,29 +565,6 @@ public class arm extends Machine { return (opcode << 26) | delta; } - @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; i<idx; i++ ) - if( tfp.arg(i-2) instanceof TypeFloat) - fcnt++; - // Floats up to XMMS in XMM registers - if( tfp.arg(idx-2) instanceof TypeFloat ) { - if( fcnt < XMMS.length ) - return XMMS[fcnt]; - } else { - RegMask[] cargs = CALLINMASK; - if( idx-2-fcnt < cargs.length ) - return cargs[idx-2-fcnt]; - } - throw Utils.TODO(); // Pass on stack slot - } - public static long decodeImm12(int imm12) { int immr = (imm12 >> 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; i<idx; i++ ) + if( tfp.arg(i-2) instanceof TypeFloat) + fcnt++; + // Floats up to XMMS in XMM registers + if( tfp.arg(idx-2) instanceof TypeFloat ) { + if( fcnt < XMMS.length ) + return XMMS[fcnt]; + } else { + RegMask[] cargs = CALLINMASK; + if( idx-2-fcnt < cargs.length ) + return cargs[idx-2-fcnt]; + } + // Pass on stack slot (8 and higher) + if( maxArgSlot>0 ) 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<brain_fuck.length(); i++ ) assertEquals(brain_fuck.charAt(i), R5.ld1z(ptr+4+i)); - EvalArm64 A5 = TestArm64.build("brain_fuck", 0, 28, false); + EvalArm64 A5 = TestArm64.build("brain_fuck", src, 0, 28, false); int trap_arm = A5.step(100000); assertEquals(0,trap_arm); assertEquals(0,trap); diff --git a/chapter24/src/test/java/com/seaofnodes/simple/Chapter19Test.java b/chapter24/src/test/java/com/seaofnodes/simple/Chapter19Test.java index e2a155ce..19d0f501 100644 --- a/chapter24/src/test/java/com/seaofnodes/simple/Chapter19Test.java +++ b/chapter24/src/test/java/com/seaofnodes/simple/Chapter19Test.java @@ -23,7 +23,38 @@ return 0; @Test public void testString() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/stringHash.smp")); + 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; +}; +"""; 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<ary#; i++ ) + ary[i] = i; +// Fill [0,1,3,6,10,...] +for( int i=0; i<ary#-1; i++ ) + ary[i+1] += ary[i]; +return ary[1] * 1000 + ary[3]; // 1 * 1000 + 6 +"""; testCPU(src,"x86_64_v2", "SystemV",-1,"return .[];"); testCPU(src,"riscv" , "SystemV", 8,"return (add,.[],(mul,.[],1000));"); testCPU(src,"arm" , "SystemV", 5,"return (add,.[],(mul,.[],1000));"); @@ -101,7 +123,38 @@ return sqrt(arg) + sqrt(cast_int); @Test public void testString() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/stringHash.smp")); + 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; +}; +"""; 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<<new s0.v4) {} +if(0) { + if(0) { + flt !P5ZUD4=new s0.v2; + } + while(0) {} +} +return new s0.v1; +"""; testCPU(src,"x86_64_v2", "Win64" ,-1,null); testCPU(src,"riscv" , "SystemV",-1,null); testCPU(src,"arm" , "SystemV",-1,null); @@ -48,7 +66,17 @@ public class Chapter21Test { @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<ary#; i++ ) + ary[i] = i; +// Fill [0,1,3,6,10,...] +for( int i=0; i<ary#-1; i++ ) + ary[i+1] += ary[i]; +return ary[1] * 1000 + ary[3]; // 1 * 1000 + 6 +"""; testCPU(src,"x86_64_v2", "SystemV",-1,"return .[];"); testCPU(src,"riscv" , "SystemV", 7,"return (add,.[],(mul,.[],1000));"); testCPU(src,"arm" , "SystemV", 5,"return (add,.[],(mul,.[],1000));"); @@ -56,7 +84,19 @@ public class Chapter21Test { @Test public void testAntiDeps1() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/antiDep1.smp")); + String src = +""" +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; +"""; testCPU(src,"x86_64_v2", "SystemV", 7,"return mov(mov(S));"); testCPU(src,"riscv" , "SystemV",10,"return mov(mov(S));"); testCPU(src,"arm" , "SystemV",10,"return mov(mov(S));"); @@ -64,18 +104,92 @@ public class Chapter21Test { @Test public void testString() throws IOException { - String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/stringHash.smp")); + 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; +}; +"""; 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<<new s0.v4) {} + if(0) { + if(0) { + flt !P5ZUD4=new s0.v2; + } + while(0) {} + } + return new s0.v1; + """; testCPU(src,"x86_64_v2", "Win64" ,-1,null); testCPU(src,"riscv" , "SystemV",-1,null); testCPU(src,"arm" , "SystemV",-1,null); @@ -51,11 +68,11 @@ return 0; assertEquals(56, testCPUSize(src, "arm","SystemV",4,"return 0;")); // do assertEquals here - EvalRisc5 R5 = TestRisc5.build("sext_str_not_fold_away", 0, 4, false); + EvalRisc5 R5 = TestRisc5.build("sext_str_not_fold_away", src,0, 4, false); int trap = R5.step(100); assertEquals(0,trap); - EvalArm64 A5 = TestArm64.build("sext_str_not_fold_away", 0, 4, false); + EvalArm64 A5 = TestArm64.build("sext_str_not_fold_away", src, 0, 4, false); trap = A5.step(100); assertEquals(0,trap); @@ -71,11 +88,11 @@ return 0; return 0; """; - EvalRisc5 R5 = TestRisc5.build("sext_str_not_fold_away_2", 0, 4, false); + EvalRisc5 R5 = TestRisc5.build("sext_str_not_fold_away_2", src, 0, 4, false); int trap = R5.step(100); assertEquals(0,trap); - EvalArm64 A5 = TestArm64.build("sext_str_not_fold_away_2", 0, 4, false); + EvalArm64 A5 = TestArm64.build("sext_str_not_fold_away_2", src, 0, 4, false); int trap_arm = A5.step(100); assertEquals(0,trap_arm); @@ -95,11 +112,11 @@ p.age = (arg<<48)>>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<ary#; i++ ) - ary[i] = i; -// Fill [0,1,3,6,10,...] -for( int i=0; i<ary#-1; i++ ) - ary[i+1] += ary[i]; -return ary[1] * 1000 + ary[3]; // 1 * 1000 + 6 diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/brain_fuck.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/brain_fuck.smp deleted file mode 100644 index ed90cb84..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/brain_fuck.smp +++ /dev/null @@ -1,46 +0,0 @@ -// -*- 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]; - - 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<<new s0.v4) {} -if(0) { - if(0) { - flt !P5ZUD4=new s0.v2; - } - while(0) {} -} -return new s0.v1; diff --git a/chapter24/src/test/java/com/seaofnodes/simple/progs/large.smp b/chapter24/src/test/java/com/seaofnodes/simple/progs/large.smp deleted file mode 100644 index 7f151f60..00000000 --- a/chapter24/src/test/java/com/seaofnodes/simple/progs/large.smp +++ /dev/null @@ -1,5344 +0,0 @@ - -struct stbi_io_callbacks { - { i64 u8[] int -> 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 <stdio.h> +#include <stdbool.h> +#include <stdlib.h> + +__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 <stdio.h> +#include <stdbool.h> +#include <stdlib.h> + +__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 <stdio.h> +#include <stdbool.h> +#include <stdlib.h> + +__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; -}; |