1232 lines
44 KiB
Markdown
1232 lines
44 KiB
Markdown
## Award presentation:
|
|
|
|
Watch the [Our Favorite Universe](https://www.youtube.com/@OurFavoriteUniverse)
|
|
YouTube show for this entry:
|
|
|
|
> [IOCCC28 - 2024/maffiodo - Prize in creative interpretation](https://www.youtube.com/watch?v=JEWxbOD-1UY)
|
|
|
|
|
|
## To build:
|
|
|
|
``` <!---sh-->
|
|
make all
|
|
```
|
|
|
|
## To use:
|
|
|
|
``` <!---sh-->
|
|
./prog < script.js
|
|
```
|
|
|
|
|
|
## Try:
|
|
|
|
``` <!---sh-->
|
|
./try.sh
|
|
```
|
|
|
|
|
|
## Judges' remarks:
|
|
|
|
This is the latest entry into the IOCCC compendium of programming language tools.
|
|
|
|
One example is regrettably missing: a quine.
|
|
Can you write one in the implemented subset of the language?
|
|
|
|
|
|
## Author's remarks:
|
|
|
|
|
|
### Jav\*script !!
|
|
|
|
|
|
#### What's this?
|
|
|
|
Jav\*script interpreter with Object, Array, String, Number, Functions and
|
|
Garbage Collector. Batteries are not included.
|
|
|
|
|
|
#### Run Forrest, run
|
|
|
|
If you want to execute some tests run one of these shell commands (these are
|
|
also included inside try.sh script):
|
|
|
|
``` <!---sh-->
|
|
cat test.js string.js | ./prog
|
|
cat test.js array.js | ./prog
|
|
cat test.js math.js | ./prog
|
|
cat test.js utils.js | ./prog
|
|
cat utils.js verify.js | ./prog
|
|
```
|
|
|
|
|
|
### Remarks
|
|
|
|
This interpreter has been tested on
|
|
|
|
- Ubuntu 24.10 64bit x86
|
|
- MacOS Sequoia M3 CPU
|
|
|
|
Disabled warnings via Makefile:
|
|
|
|
- **Wno-implicit-int** to reduce the number of tokens, lower than 2503
|
|
- **Wno-incompatible-pointer-types** for sprintf and strlen alias function
|
|
pointers
|
|
- **Wno-return-type** for functions that does not return a value (99% of times
|
|
are the same functions that uses implicit int as return type but do not use
|
|
any return statement)
|
|
- **Wno-deprecated-non-prototype** because on clang some function pointers like
|
|
`strdup(char*)` is aliased as `(*)()` without any explicit parameter. On gcc this
|
|
is not a problem but on MacOS clang this is needed to suppress a warning
|
|
- **Wno-deprecated-declarations** (probably not needed) on clang sprintf is
|
|
deprecated because is always better to use snprintf. This warning need to be
|
|
disabled because snprintf requires more tokens
|
|
- **Wno-parentheses** for "if (j = 0)" cases where assignment is made inside
|
|
conditional expressions, to reduce the total number of tokens used
|
|
- **Wno-unused-variable** because some of the variables are not used but assigned
|
|
- **Wno-misleading-indentation** because compiler can sometimes doubt the correct
|
|
indentation; wrong indentation can sometimes be an indicator of possible
|
|
errors, not in this case!
|
|
- **Wno-strict-prototypes** for clang, related to implicit-int for functions
|
|
declared without a full prototype
|
|
|
|
Included files via Makefile (to reduce number of tokens, lower than 5006/2):
|
|
|
|
- include stdio.h
|
|
- include string.h
|
|
- include stdlib.h
|
|
- include ctype.h
|
|
|
|
|
|
### Features
|
|
|
|
Supported and unsupported features (everything else that is not listed is
|
|
probably unsupported, but who knows...):
|
|
|
|
- supported binary operators (in execution priority order from lower to higher);
|
|
<pre>, = == != & &= && | |= || > >= >> < <= << - -= + += * \*= / /= % %= [ ( .</pre>
|
|
this is not standard so keep in mind that the standard one can be found
|
|
[here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence)
|
|
and the order of execution in this interpreter is slightly different.
|
|
- binary operator x() call functions. Ah, yes, the interpreter support both
|
|
native and interpreted functions; inside this (light) obfuscated version of
|
|
the program, only 1 native function has been included (print), to demonstrate
|
|
this feature; The interpreter support infinite native functions, as global
|
|
functions or (in theory) as Object property.
|
|
- operator x[y] can be used to access Object properties dynamically using String
|
|
or Numbers as y index.
|
|
- operator x.y works like x[y] but requires that y is an identifier
|
|
- supported unary operators: ~ ! - +
|
|
- support infinite nested Objects and Arrays
|
|
- +String does not convert the given String to a Number
|
|
- multiple unary operators cannot be chained without parenthesis
|
|
- Object properties lookup is implemented with O(N) complexity, using a linked
|
|
list instead of a dictionary or map
|
|
- UNICODE strings are not supported. Use ASCII like if we were in 1963
|
|
- Function can be used as anonymous callback inside function calls (for example
|
|
in Array.filter, see **Useful things** chapter)
|
|
- literal String can include a limited set of escape codes: \\n \\" \\'
|
|
or escape code with hexadecimal notation \\x00..\\xFF. Please note that only
|
|
ASCII characters are supported so escape codes cannot exceed two hexadecimal
|
|
characters. For example this string:
|
|
|
|
``` <!---js-->
|
|
"abc\\xffabc"
|
|
```
|
|
|
|
need to be break into two substrings to prevent "ffabc" to be parsed as a
|
|
as a single character escape code:
|
|
|
|
``` <!---js-->
|
|
"abc\\xff" + "abc"
|
|
```
|
|
|
|
- postfix and prefix ++ -- are not supported. Use
|
|
|
|
``` <!---js-->
|
|
x += 1; x -= 1;
|
|
```
|
|
|
|
- only **if else while return** and **break** statement control operations are
|
|
supported. Use **while** instead of **for**
|
|
- Number are implemented using **double** as internal data type. To save some
|
|
RAM, is possible to change this to use **float** instead but the code need
|
|
to be changed manually (there is no define or typedef for this data type).
|
|
- operators with 3 or more characters length (like === or !== or >>=) are not
|
|
implemented
|
|
- support infinite nested *small* statements (without {}) and *'fat'* statements
|
|
(with {})
|
|
- String concatenation with + and += is supported. Concatenated string does not
|
|
has a maximum length limit but literal strings are limited to 99 characters
|
|
(you can change this limit inside the code)
|
|
- comparison of Object Number and String is implemented similar to the ECMA 1
|
|
specification but not fully implemented. See **Equality** chapter
|
|
- does not support full Object or Array literal declaration, only the shortest
|
|
one with {} for Object and [] for Array
|
|
- does not support Object Prototype. Object Array Number Function and String
|
|
does not have any default methods. Only "length" property is supported and is
|
|
reserved for internal use
|
|
- **var** is supported but **let** is not
|
|
- **var** works well only with one variable at a time. If you declare multiple
|
|
variables on the same *var* line (using comma) only the first one will be
|
|
declared correctly in local scope, overriding any existing previous variable
|
|
with the same ID. If multiple variables are declared on the same *var* line,
|
|
the next variables (after the first one) will be linked with existing
|
|
variables that has the same ID.
|
|
- **var** is also optional but, when is not used, all undeclared variables will
|
|
be declared automatically in local scope (and collected after current
|
|
statement ends)
|
|
- **only** single line comments are supported
|
|
- multi line comments are not supported. Use only single line comments
|
|
- any unary operator on String value will convert String to Number
|
|
- NaN is not implemented so invalid number conversion will generate a 0 Number
|
|
- division by zero is not handled
|
|
- there is no error handling, so if something goes wrong, interpreter will
|
|
crash. If some of the unsupported language features are used, parser will
|
|
continue to parse what it can understand (wrongly)
|
|
- expressions must *always* terminate with a semicolon; otherwise, unexpected
|
|
behavior will definitely happen inside the parser
|
|
- **length** property is a reserved property name so cannot be declared in any
|
|
Object
|
|
- identifier does not include $ character, only alphanumeric characters and
|
|
the underscore character. Identifier maximum length is 99 character but you
|
|
can increment that by changing one constant in the beginning of the file
|
|
- **delete** is not implemented. You can add any property to an Object but you
|
|
cannot remove them! This can be managed by creating new Object or Array
|
|
without the property to be removed
|
|
- **true** and **false** does not exists but can be declared as variables, like
|
|
this:
|
|
|
|
``` <!---js-->
|
|
var true = 1;
|
|
var false = 0;
|
|
```
|
|
|
|
- **length** will return the number of properties inside an Object. This is
|
|
also true for Array (see **Strange(r) Things** chapter)
|
|
- **length** on String variables (or literal) return the number of characters
|
|
in the string
|
|
- there is no slice or splice in String and Array (but these feature can be
|
|
partially implemented in plain JavaScript -- see **Useful things** chapter)
|
|
- there is no Date RegEx or Math (but some of Math methods can be implemented
|
|
in plain JavaScript)
|
|
- subscript operation like
|
|
|
|
``` <!---js-->
|
|
x[1]
|
|
```
|
|
|
|
return the property 1 of the object x or returns the character at position 1
|
|
if x is a String
|
|
- subscript operation like
|
|
|
|
``` <!---js-->
|
|
x["abc"]
|
|
```
|
|
|
|
always declare a new property "abc" also when the Object x does not contains
|
|
"abc". Normally in ECMA, if a property does not exists, undefined is returned
|
|
and, if the property is assigned, a new property is created to hold a new
|
|
value. This is not true in this mini nano tiny puppy ugly interpreter
|
|
- null and undefined are not implemented but can be declared like this:
|
|
|
|
``` <!---js-->
|
|
var null = {};
|
|
var undefined = {};
|
|
```
|
|
|
|
but something different will happen when you perform some comparisons:
|
|
|
|
* null == 0 will be equal to 1
|
|
* undefined == 0 will be equal to 1
|
|
* undefined == null will be equal to 0
|
|
* null == {} will be false (correctly)
|
|
* ... some other edge cases, can you spot them?
|
|
|
|
- there is no `typeof` nor `instanceof`. You need to know the types of your
|
|
variables or track its type inside other data structures.
|
|
|
|
- `this` is missing. Inside Function you need to remember `this`.
|
|
|
|
- Function declaration is supported ONLY inside expression and not as a
|
|
standalone declarator, so instead of this:
|
|
|
|
``` <!---js-->
|
|
function x() {}
|
|
```
|
|
|
|
write this:
|
|
|
|
``` <!---js-->
|
|
var x = function () {};
|
|
```
|
|
|
|
and please look at the final semicolon! It is very important because every
|
|
expression need to terminate with that and without that strange parsing
|
|
things will happen (also probably some segmentation fault).
|
|
Functions need to be unnamed by itself.
|
|
Functions can be used as callback inside other function calls but read the
|
|
following limitation...
|
|
- there is no closure mechanism so, if your function work on some variables
|
|
outside of the function scope, be warned, something strange will happen. If
|
|
possible use a *pure functional* approach.
|
|
- **function** named parameters are not supported, for example:
|
|
|
|
``` <!---js-->
|
|
function (a, b, c) { return a+b; }
|
|
```
|
|
|
|
need to be rewritten as:
|
|
|
|
``` <!---js-->
|
|
function () { return arguments[0] + arguments[1]; }
|
|
```
|
|
|
|
using **arguments** array. Another solution is to map arguments to new local
|
|
variables using **var**, for example:
|
|
|
|
``` <!---js-->
|
|
function () {
|
|
var a = arguments[0];
|
|
var b = arguments[1];
|
|
return a+b;
|
|
}
|
|
```
|
|
|
|
- **arguments** array cannot be used directly for nested function calls, so
|
|
instead of this:
|
|
|
|
``` <!---js-->
|
|
var foo = function () {
|
|
print(arguments[0] + ' ' + arguments[1]);
|
|
};
|
|
```
|
|
|
|
you need to write that:
|
|
|
|
``` <!---js-->
|
|
var foo = function () {
|
|
var string = arguments[0] + ' ' + arguments[1];
|
|
print(string); //<-- here, inside parenthesis, arguments cannot be used and
|
|
// will cause a missmatch between the current arguments and
|
|
// the new one allocated for print Function
|
|
};
|
|
```
|
|
|
|
because internally **arguments** array will be re-declared locally, with a
|
|
stack based approach, for the next function call and can cause some variable
|
|
resolving mismatch. This is a little annoying but is also better to always
|
|
remap each arguments value to a dedicated local variable.
|
|
- early exit inside logical expression is not implemented so this code will not
|
|
be interrupted before the execution of the `foo2` function:
|
|
|
|
``` <!---js-->
|
|
if (0 && foo2(123)) { print("hello\n"); }
|
|
```
|
|
|
|
and this is clearly not standard (in ECMA, Yes you can)
|
|
- accessing properties on literal String or Number is not supported; For
|
|
example this code will not work
|
|
|
|
``` <!---js-->
|
|
'abc'.x = 1;
|
|
```
|
|
|
|
and this can cause a crash, like in many other unsupported features
|
|
- when statement execution is off (for example inside an else {} statement to be
|
|
NOT executed) the code is partially interpreted to obtain intermediate results
|
|
that will be not used and will be freed by the next GC call. Some memory is
|
|
wasted in the process.
|
|
- recursive object structure like this:
|
|
|
|
``` <!---js-->
|
|
var obj = {};
|
|
obj.x = 32;
|
|
obj["yy"] = 'hello';
|
|
obj.recursive = obj;
|
|
```
|
|
|
|
is not supported and will cause an infinite loop inside GC. Recursive
|
|
structures need to be handled with some kind of data *sentinel values*.
|
|
- maximum size of input source code is 65536 bytes but you can change the buffer
|
|
size inside main function (change 1<<16 constant)
|
|
|
|
Parsing errors are not handled so "garbage in garbage out" (but garbage is also
|
|
collected if no errors are found, ah ah).
|
|
|
|
|
|
#### Equality
|
|
|
|
Loose equality is implemented similarly as described in
|
|
[this docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Equality_comparisons_and_sameness#:~:text=is%20logged%0A%7D-,Loose%20equality%20using%20%3D%3D,-Loose%20equality%20is)
|
|
From that doc, the following paragraph is slightly different (point 2 is
|
|
missing becouse some of the required features are not present in the
|
|
interpreter):
|
|
|
|
Loose equality is symmetric: A == B always has identical semantics to B == A
|
|
for any values of A and B (except for the order of applied conversions). The
|
|
behavior for performing loose equality using == is as follows:
|
|
|
|
1. If the operands have the same type, they are compared as follows:
|
|
* Object: return 1 only if both operands reference the same object.
|
|
* String: return 1 only if both operands have the same characters in the same
|
|
order.
|
|
* Number: return 1 only if both operands have the same value. +0 and -0 are
|
|
treated as the same value. NaN is not supported
|
|
3. If one of the operands is an object and the other is a primitive, convert
|
|
the object to a primitive.
|
|
4. At this step, both operands are converted to primitives (one of String and
|
|
Number. The rest of the conversion is done case-by-case.
|
|
* If they are of the same type, compare them using step 1.
|
|
* Number to String: convert the string to a number. Conversion failure
|
|
results in 0 (not NaN), which will NOT guarantee the equality to be false.
|
|
|
|
This logic has been implemented in this (light) obfuscated code:
|
|
|
|
``` <!---c-->
|
|
if (_ == y->m) {
|
|
if (_ & 4) U = x != y;
|
|
else if (_ & 1) goto O;
|
|
else goto Q;
|
|
} else if ((_ | y->m) == 2) {
|
|
Q: U = A(Q(x)->f, Q(y)->f);
|
|
} else {
|
|
O: U = V - X;
|
|
}
|
|
// U == 0 mean true loose equality
|
|
```
|
|
|
|
*NOTE: the (light) obfuscated code can be slightly different from the final
|
|
one, due to final refinements on the obfuscation process.*
|
|
|
|
|
|
#### Garbage Collection
|
|
|
|
Garbage Collection is implemented with these two functions (in pseudocode):
|
|
|
|
``` <!---js-->
|
|
// x=item z=terminal y=mark_value
|
|
mark(x, z, y, next)
|
|
if x and x != z
|
|
if value(x) not already marked
|
|
mark(value(x), 0, y, 0)
|
|
mark(props(value(x)), 0, y, 1)
|
|
mark(props(x), 0, y, 1)
|
|
mark x = y
|
|
if next
|
|
mark(next(x), z, y, 1)
|
|
|
|
// z=terminal, stop when z is reached
|
|
gc(z)
|
|
// all values from head to z are marked to 1
|
|
mark(all, z, 1, 1)
|
|
// all values connected to props are marked to 0
|
|
mark(props, 0, 0, 1)
|
|
foreach x in all
|
|
if x marked and x not retained
|
|
if type(x) == String
|
|
freeString(x)
|
|
free(x)
|
|
else
|
|
mark x = 0
|
|
```
|
|
|
|
It is *clear and quite obvious* that this is a classical **mark & sweep**
|
|
process that marks all the local values (from a given heap starting point) and
|
|
release all values that are not referenced from any heap variable (recursively,
|
|
also for any values referenced from infinite nested objects properties).
|
|
|
|
Unfortunately, this implementation does not support recursive Object structures
|
|
where the properties tree includes the root node itself or any other parent node.
|
|
I was not able to include this in the compressed program, without exceed the
|
|
tokens limitation.
|
|
|
|
The following chart show the length of the two global linked lists (for
|
|
variables and values) while executing the internal tests in C (see **Internal
|
|
tests** chapter):
|
|
|
|
|
|
|
|
|
|
#### Values and variables
|
|
|
|
The interpreter uses the same struct to hold values and variables. The same
|
|
struct (c) is also used to store a linked list for global variables and a linked
|
|
list for all properties contained inside a variable.
|
|
|
|
Using the same struct has been useful to strip down the code for a lesser number
|
|
of tokens.
|
|
|
|
This is a semi obfuscated struct that holds variables or values (NOTE: obfuscated
|
|
symbols can be slightly different from the final obfuscated ones):
|
|
|
|
``` <!---c-->
|
|
typedef struct c*d;
|
|
struct c{
|
|
union{
|
|
char*e;
|
|
double n;
|
|
} ;
|
|
char *f, //{id} set if var is a property
|
|
g, // used in gc (mark)
|
|
h, // used in gc (retain)
|
|
l; // type (1 = number, 2 = string, 4 = object)
|
|
d d, // when this is a value, is one of the variables that use this value
|
|
x, // when this is an variable this point to the variable value
|
|
b, // next value or variable in the list (linked list)
|
|
m, // object properties head (linked list of props)
|
|
(*q)(); // native function, used then type is 2 and this is a function
|
|
int r; // array length / properties length
|
|
} ;
|
|
```
|
|
|
|
This struct is huge! It uses 72 bytes on 64bit X86 architecture. This struct is
|
|
big to fit all the useful data inside it and also something else that is
|
|
needed to compress the code. In theory can be much smaller but the final code
|
|
will uses more tokens (I have tried multiple times to implement this interpreter
|
|
but this is the only solution that I've found to match the 2503 limitation.. with
|
|
the previous limit of 2053 was really hard to stay under the limits -- for me!).
|
|
Keep in mind also that on 64bit X86 architecture each pointer cost 8 bytes...
|
|
|
|
The interpreter uses a large amount of RAM, creating many temporary values
|
|
objects that are not really necessary but are needed to compress the code.
|
|
|
|
Global variables linked list is stored inside a global pointer, and all
|
|
temporary values are stored inside another pointer. Garbage Collector work to
|
|
free a subset of unused values not pointed from current global variables list.
|
|
|
|
|
|
#### Native functions
|
|
|
|
The only native function included inside the obfuscated program is **print**,
|
|
that prints out the first parameter that receive, as a String (by converting it
|
|
to a String if is not a String type); its native code is inside the bb function:
|
|
|
|
``` <!---c-->
|
|
e bb(e u) {
|
|
printf("%s", Q(u->x->q->x));
|
|
return E(0);
|
|
}
|
|
```
|
|
|
|
This native function is declared in global scope using this code, inside main
|
|
function:
|
|
|
|
``` <!---c-->
|
|
c(g, "print");
|
|
e x = G(&q);
|
|
x->m = 2;
|
|
x->x->r = bb;
|
|
```
|
|
|
|
And the same sequence of calls over c() and G() can be iterated to declare
|
|
additional native functions inside the global context of the interpreter.
|
|
|
|
If you want you can declare other native functions. Each native function receive
|
|
a parameter of type *e* (pointer to struct c) that is the value of the temporary
|
|
**arguments** array. Each native function MUST return a new value using *E()*
|
|
function otherwise the interpreter will crash.
|
|
|
|
I'm sure that will be a little hard to add new native functions writing directly
|
|
them in this (light) obfuscated format, but in theory this is not impossible...
|
|
|
|
For example, this is a new *keys* native function that can returns an array of
|
|
all properties contained inside an object, given the target Object as first
|
|
parameter (like the Object.keys standard method):
|
|
|
|
``` <!---c-->
|
|
e be(e u) {
|
|
int y = 0; // index for properties declared in output Array
|
|
e h = u->x->q->x->q, // get first argument only
|
|
x = E(4), // declare a new value with type 4 = Object (Array!)
|
|
l;
|
|
// loop for each properties inside arg
|
|
while (h) {
|
|
c(g, "%d", y++); // format N=y for output Array index property
|
|
l = G(&x->q); // declare a new property N=y inside x
|
|
x->u++; // increment number of properties in x
|
|
l->x->m = 2; // type of new property value is 2 = String
|
|
l->x->f = D(h->g); // duplicate ID of the arg Object property
|
|
h = h->b; // jump on the next property of arg Object
|
|
}
|
|
return x;
|
|
}
|
|
```
|
|
|
|
These (light) obfuscated functions and variables are used in the previous
|
|
examples:
|
|
|
|
``` <!---c-->
|
|
c // sprintf alias
|
|
g // char[] array used for F and G functions
|
|
D // strdup
|
|
E(T) // allocate a new value of type T
|
|
F(props) // find property f[] inside props linked list
|
|
G(&props) // declare property f[] inside props linked list
|
|
```
|
|
|
|
Also, just for fun, the following **exec** native function can be used to
|
|
expose **popen** inside the interpreter, to exec any arbitrary shell subprocess
|
|
commands:
|
|
|
|
``` <!---c-->
|
|
e bc(e u) {
|
|
FILE *bd = popen(Q(u->x->q->x)->f, "r");
|
|
e x = E(2);
|
|
x->f = D("");
|
|
while (fgets(g, 99, bd) != 0) {
|
|
char *d = malloc(w(x->f) + w(g) + 1);
|
|
c(d, "%s%s", x->f, g);
|
|
free(x->f);
|
|
x->f = d;
|
|
}
|
|
pclose(bd);
|
|
return x;
|
|
}
|
|
```
|
|
|
|
Unfortunately **keys** and **exec** functions were not included in the obfuscated
|
|
*prog.c* program, due to tokens limitations.
|
|
|
|
|
|
### Strange(r) Things
|
|
|
|
The following things comes from the *Upside Down*...
|
|
Strange things can happen or can be found when using this interpreter:
|
|
|
|
- Array are implemented as Object and **length** property of Array values are
|
|
implemented assuming that Array values have a list of properties that are
|
|
numerical indexes and there are not *holes* inside the list of all indexes.
|
|
For example this array is ok:
|
|
|
|
``` <!---js-->
|
|
var x = [];
|
|
x[0] = 1;
|
|
x[1] = 'hello';
|
|
x[2] = "From\tUpside\tDown";
|
|
```
|
|
|
|
and its length is 3. The following one is instead a NOT-OK Array that contains
|
|
*holes* inside its own indexes:
|
|
|
|
``` <!---js-->
|
|
var y = [];
|
|
y[0] = 'I have';
|
|
y[2] = "one hole";
|
|
```
|
|
|
|
and its length is computed as 2 instead of 3
|
|
- Object has **length** property and the object length is equal to the number
|
|
of properties declared inside the Object (not standard)
|
|
- functions are implemented as String, so you can do strange(r) things like this:
|
|
|
|
``` <!---js-->
|
|
var x = "{ print('x'); }";
|
|
x();
|
|
```
|
|
|
|
this also mean that you can implement an eval function that can evaluate
|
|
dynamic generated code using this trick:
|
|
|
|
``` <!---js-->
|
|
var eval = function() {
|
|
arguments[0]();
|
|
}
|
|
```
|
|
|
|
this technique can also work if you create a dynamic string (like normally is
|
|
done while using eval). Please note that the given string need to include an
|
|
outer statement ({}) otherwise the execution will be interrupted after the
|
|
first expression or short statement. See **utils.js** or **verify.js** for
|
|
some real examples.
|
|
- 0.1 + 0.2 does compute 0.3 correctly. Node.js returns 0.30000000000000004
|
|
instead
|
|
- **var** can be used multiple times like this:
|
|
|
|
``` <!---js-->
|
|
var var var var a = 1;
|
|
```
|
|
|
|
and this will work like var has been typed one time. Can you find out where
|
|
this has been allowed inside the source code? (hint: goto)
|
|
- many other unknown strange things can happen in Hawkins, Indiana...
|
|
|
|
|
|
### Useful Things
|
|
|
|
Console prototype is not implemented but console.log can be implemented using
|
|
only native **print** function. The following is an example of Console
|
|
implementation (found also inside console.js file):
|
|
|
|
``` <!---js-->
|
|
var console = {};
|
|
console.log = function () {
|
|
var i = 0;
|
|
while (i < arguments.length) {
|
|
var arg = "" + arguments[i];
|
|
print(arg);
|
|
i += 1;
|
|
if (i == arguments.length) {
|
|
break;
|
|
}
|
|
print(' ');
|
|
}
|
|
print('\n');
|
|
};
|
|
```
|
|
|
|
You can use this with cat when testing the interpreter:
|
|
|
|
``` <!---sh-->
|
|
cat console.js fibo.js | ./prog
|
|
```
|
|
|
|
Other standard functions can be implement slightly different from the ECMA
|
|
standard library original ones but still something useful can be achieved:
|
|
|
|
``` <!---js-->
|
|
var String = {};
|
|
|
|
// slice(string, from, to)
|
|
String.slice = function () {
|
|
if (arguments.length < 2) {
|
|
return "";
|
|
}
|
|
var s = arguments[0];
|
|
var from = arguments[1];
|
|
var to = -1;
|
|
if (arguments.length > 2) {
|
|
to = arguments[2];
|
|
} else {
|
|
to = s.length;
|
|
}
|
|
var o = "";
|
|
var i = from;
|
|
while (i < to) {
|
|
o += s[i];
|
|
i += 1;
|
|
}
|
|
return o;
|
|
}
|
|
```
|
|
|
|
see *string.js* for additional String methods implemented using only the few
|
|
features present in this little mini voodoo interpreter.
|
|
|
|
If you need both **Console** and **String** utils, use cat:
|
|
|
|
``` <!---sh-->
|
|
cat console.js string.js YOUR_SCRIPT.js | ./prog
|
|
```
|
|
|
|
Where YOUR\_SCRIPT.js is some script that you can create, not included in this
|
|
package. If you want to try out some other scripts bundled with this package,
|
|
see **Run Forrest, run** chapter.
|
|
|
|
The following list includes a summary of all of my examples for standard JS
|
|
features implemented using this interpreter. These methods are not fully
|
|
implemented and each method work slightly differently from the one that exists
|
|
inside the ECMA standard:
|
|
|
|
``` <!---js-->
|
|
// string.js
|
|
String.slice(s, start, end);
|
|
String.split(s, singleCharSeparator);
|
|
String.charAt(s, index);
|
|
String.charCodeAt(s, index);
|
|
String.startsWith(s, prefix);
|
|
String.fromCharCode(asciiCode);
|
|
String.trimStart(s);
|
|
String.trimEnd(s);
|
|
String.trim(s);
|
|
|
|
// array.js
|
|
Array.at(array, index);
|
|
Array.join(array, separator);
|
|
Array.push(array, item1 ... itemN);
|
|
Array.pop(array); // return { new: NEW_ARRAY, removed: REMOVED_ITEM }
|
|
Array.concat(array1, array2);
|
|
Array.slice(array, start, end);
|
|
Array.toString(array);
|
|
Array.filter(array, callback);
|
|
|
|
// math.js
|
|
Math.E;
|
|
Math.e;
|
|
Math.LN2;
|
|
Math.LN10;
|
|
Math.LOG2E;
|
|
Math.LOG10E;
|
|
Math.phi;
|
|
Math.PI;
|
|
Math.pi;
|
|
Math.SQRT1_2;
|
|
Math.SQRT2;
|
|
Math.tau;
|
|
Math.sign(x);
|
|
Math.abs(x);
|
|
|
|
// console.js
|
|
console.log(...);
|
|
|
|
// utils.js
|
|
eval(string);
|
|
```
|
|
|
|
*NOTE: each file includes some unit tests that can be enabled manually inside
|
|
each file by setting a test variable equal to 1 or by prepending the test.js
|
|
script before the source file (see **Run Forrest, run** chapter)*
|
|
|
|
*NOTE(2): take a look at Array.filter! The interpreter support function callbacks*
|
|
|
|
|
|
### Internal tests
|
|
|
|
The following tests has been made in the original not-obfuscated code development.
|
|
Without these tests, the implementation of the interpreter would have been
|
|
impossible or at least exhausting.
|
|
|
|
*NOTE: some tests uses additional native functions like exec and keys that has
|
|
been stripped down in the final (light) obfuscated version of the code*
|
|
|
|
|
|
#### Tests functions
|
|
|
|
``` <!---c-->
|
|
/**
|
|
* Test a single JS Expression evaluation.
|
|
* return value MUST be equal to type
|
|
* return value, if type=1 (Number) MUST be equal to res
|
|
* return value, if type=2 (String) MUST be equal to sres
|
|
*/
|
|
void etest_base(char *src, char type, double res, char *sres);
|
|
|
|
// same as etest_base but assume that return type MUST be 1 (Number)
|
|
void etest(char *src, double res);
|
|
/**
|
|
* Test a JS Statement
|
|
* return value MUST be equal to type
|
|
* return value, if type=1 (Number) MUST be equal to res
|
|
* return value, if type=2 (String) MUST be equal to sres
|
|
*/
|
|
void stest_base(char *src, char type, double res, char *sres);
|
|
|
|
// same as stest_base but assume that return type MUST be 1 (Number)
|
|
void stest(char *src, double res);
|
|
```
|
|
|
|
|
|
#### Verify single Expressions correctness
|
|
|
|
``` <!---c-->
|
|
spf(id, "x"); decl(&props); // declare x variable
|
|
etest_base(";", 0, 0, 0);
|
|
etest_base("; 2; 3", 0, 0, 0);
|
|
etest("2*(2+3)-1", 9);
|
|
etest_base("'' + 32", 2, 0, "32");
|
|
etest_base("\"\" + 32", 2, 0, "32");
|
|
etest("x + 32", 32);
|
|
etest("x = 3", 3);
|
|
etest("x", 3);
|
|
etest("var y = 11", 11);
|
|
etest("var y = 11, z = 22", 22);
|
|
etest_base("var foo = function () { 2; }", 2, 0, "{ 2; }");
|
|
etest_base("' 1 2 \\n 23 \\' '", 2, 0, " 1 2 \n 23 \' ");
|
|
etest(" 'hello' == 'hello'; ", 1);
|
|
etest(" 'hello' == 'hello2'; ", 0);
|
|
etest(" 'hello' != 'hello2'; ", 1);
|
|
etest(" '32' == 32; ", 1);
|
|
etest(" '32' == 33; ", 0);
|
|
etest(" '32' <= 33; ", 1);
|
|
etest(" '32' <= 2; ", 0);
|
|
etest(" '2' >= 32; ", 0);
|
|
etest(" '32' >= 2; ", 1);
|
|
etest(" 32 == 32; ", 1);
|
|
etest(" 32 >= 0; ", 1);
|
|
etest(" 0 <= 32; ", 1);
|
|
etest(" 1+4 && 3-3; ", 0);
|
|
etest(" 1+4 || 3-3; ", 1);
|
|
etest(" 1<<3; ", 8);
|
|
etest(" 8>>3; ", 1);
|
|
etest(" -6; ", -6);
|
|
etest(" +'6'; ", 6);
|
|
etest(" ~'6'; ", -7);
|
|
etest(" !'6'; ", 0);
|
|
etest(" !'0'; ", 1);
|
|
etest(" !(1 && 2); ", 0);
|
|
etest(" 0.1 + 0.2 == 0.3; ", 1); // OMG
|
|
etest(" 'hello'.length; ", 5);
|
|
etest(" [].length; ", 0);
|
|
etest(" {}.length; ", 0); // Stranger Things in Hawkins, Indiana
|
|
etest_base("obj = {}", 4, 0, 0);
|
|
etest("obj.abc = 32", 32);
|
|
etest("obj[0] = 2; ", 2);
|
|
etest("obj[0]; ", 2);
|
|
etest_base("obj[1] = {}; ", 4, 0, 0);
|
|
etest("obj[1].temp = 123; ", 123);
|
|
etest("obj[1].temp; ", 123);
|
|
etest_base("print(1); ", 0, 0, 0);
|
|
etest_base("print(3*9); ", 0, 0, 0);
|
|
etest_base("print('22'); ", 0, 0, 0);
|
|
etest_base("'abc'[0];", 2, 0, "a");
|
|
etest_base("'1+2'();", 1, 3, 0);
|
|
etest("0 || 'hello'", 0);
|
|
etest("0 || '1hello'", 1);
|
|
etest_base("print(123);", 0, 0, 0);
|
|
```
|
|
|
|
|
|
#### Verify Statement correctness
|
|
|
|
``` <!---c-->
|
|
stest("; 2; 3", 3);
|
|
stest("{ { 1; }; }; 2; {{3;}}", 3);
|
|
stest("{ { return 1; } } 2; 3", 1);
|
|
stest_base("var strt = '' + 32", 2, 0, "32");
|
|
stest_base("var strt = \"\" + 32", 2, 0, "32");
|
|
stest("var foo = function () { var w = 2 * 3; }; foo(1, 2, 3)", 6);
|
|
stest("var foo = function () { \
|
|
arguments[1] * arguments[2] * arguments[0]; \
|
|
}; foo(10, 2, 3)", 60);
|
|
stest("var x = 2 + 3, y; \
|
|
if (x == 5) { \
|
|
7; \
|
|
} else { \
|
|
2; \
|
|
}", 7);
|
|
stest("var x = 2 + 3, y; \
|
|
if (x == 3) { \
|
|
7; \
|
|
} else { \
|
|
2; \
|
|
}", 2);
|
|
stest("var x = 2 + 3, y; \
|
|
if (x == 5) \
|
|
7; \
|
|
else \
|
|
2; \
|
|
", 7);
|
|
stest("var x = 2 + 3, y; \
|
|
if (x == 3) \
|
|
7; \
|
|
else \
|
|
2; \
|
|
", 2);
|
|
stest("var x = 2 + 3, y; \
|
|
if (x == 5) \
|
|
y = 7; \
|
|
else \
|
|
y = 3; \
|
|
y;", 7);
|
|
stest("var x = 2 + 3, y; \
|
|
if (x == 3) \
|
|
y = 7; \
|
|
else \
|
|
y = 3; \
|
|
y;", 3);
|
|
stest("var cnt = 0; \
|
|
while (cnt < 10) { cnt = cnt + 1; break; } \
|
|
cnt", 1);
|
|
stest("var cnt = 0; \
|
|
while (cnt < 10) { if (1) { break; } cnt = cnt + 1; } \
|
|
cnt", 0);
|
|
stest("var cnt = 0, x = 0; \
|
|
while (x < 4) { \
|
|
var y = 0; \
|
|
while (y < 4) { \
|
|
if ((y == 2) && (x == 2)) \
|
|
break; \
|
|
cnt = cnt + 1; \
|
|
y += 1; \
|
|
} \
|
|
if ((y == 2) && (x == 2)) \
|
|
break; \
|
|
x += 1; \
|
|
}\
|
|
cnt", 10);
|
|
stest("var cnt = 0; while (cnt < 10) { cnt = cnt + 1; } cnt", 10);
|
|
stest("var o2 = {}, l2 = 1; o2.l2 = 33; o2.l2", 33);
|
|
stest("var o2 = {}, l2 = 1; o2.l2 = 31; l2", 1);
|
|
stest("var w2 = 1; w2 += 3", 4);
|
|
stest("var true = 1, false = 0; 1 == true && !1 == false", 1);
|
|
stest("var s = 1; ~s; s", 1);
|
|
stest_base("var s = '1'; ~s; s", 2, 0, "1");
|
|
stest(" \n\
|
|
var number = 10, \n\
|
|
n1 = 0, \n\
|
|
n2 = 1, \n\
|
|
i = 0, \n\
|
|
nextTerm; \n\
|
|
var console = {}; \n\
|
|
console.log = print; \n\
|
|
console.log('fibonacci series:'); \n\
|
|
while (i <= number) { \n\
|
|
console.log(n1); \n\
|
|
nextTerm = n1 + n2; \n\
|
|
n1 = n2; \n\
|
|
n2 = nextTerm; \n\
|
|
i += 1; \n\
|
|
} \n\
|
|
n1; \n\
|
|
", 89);
|
|
stest(" \n\
|
|
var x = 32, y = 10; \n\
|
|
var console = {}; \n\
|
|
console.log = function () { \n\
|
|
var i = 0; \n\
|
|
while (i < arguments.length) { \n\
|
|
var arg = \"\" + arguments[i]; \n\
|
|
print(arg); \n\
|
|
i += 1; \n\
|
|
if (i == arguments.length) { \n\
|
|
break; \n\
|
|
} \n\
|
|
print(' '); \n\
|
|
} \n\
|
|
print('\\n'); \n\
|
|
}; \n\
|
|
console.log('test 123', {}, x+y, []); \n\
|
|
0; \n\
|
|
", 0);
|
|
stest(" \n\
|
|
var x = {}; \n\
|
|
x.a = 32; \n\
|
|
x.b = 1; \n\
|
|
x.prova = \"abc\"; \n\
|
|
var y = keys(x); \n\
|
|
var z = y.length; \n\
|
|
while (z) { \n\
|
|
z -= 1; \n\
|
|
print(y[z]); \n\
|
|
} \n\
|
|
0;", 0);
|
|
stest("var null = {}; var nullx = null; null == nullx;", 1);
|
|
stest("var null = {}; null == {};", 0);
|
|
stest("var null = {}; null == 0;", 1);
|
|
stest("var undefined = {}; undefined == 0;", 1);
|
|
stest("var undefined = {}, null = {}; undefined == null;", 0);
|
|
stest_base("exec('echo -n 123');", 2, 0, "123");
|
|
stest(" \n\
|
|
var recobj = {}; \n\
|
|
{ \n\
|
|
var o1 = {}; \n\
|
|
var o2 = {}; \n\
|
|
recobj.x = o1; \n\
|
|
recobj.y = o2; \n\
|
|
o1.x = 3; \n\
|
|
o2.o1 = o1; \n\
|
|
o1 = 0; \n\
|
|
o2 = 0; \n\
|
|
} \n\
|
|
recobj.y.o1.x;", 3);
|
|
stest_base(" \n\
|
|
var String = {}; \n\
|
|
// slice(string, from, to) \n\
|
|
String.slice = function () { \n\
|
|
if (arguments.length < 2) { \n\
|
|
return ''; \n\
|
|
} \n\
|
|
var s = arguments[0]; \n\
|
|
var from = arguments[1]; \n\
|
|
var to; \n\
|
|
if (arguments.length > 2) { \n\
|
|
to = arguments[2]; \n\
|
|
} else { \n\
|
|
to = s.length; \n\
|
|
} \n\
|
|
var o = ''; \n\
|
|
var i = from; \n\
|
|
while (i < to) { \n\
|
|
o += s[i]; \n\
|
|
i += 1; \n\
|
|
} \n\
|
|
return o; \n\
|
|
}; \n\
|
|
var test = 'hello world!'; \n\
|
|
//print(String.slice(test, 1) + '\\n'); \n\
|
|
print(String.slice(test, 1, 5) + '\\n');\n\
|
|
String.slice(test, 1, 5);", 2, 0, "ello");
|
|
stest_base(" \n\
|
|
// split(string, singleCharSeparator) \n\
|
|
var String = {}; \n\
|
|
String.split = function () { \n\
|
|
var o = []; \n\
|
|
var s = arguments[0]; \n\
|
|
var delimiter = arguments[1]; \n\
|
|
var start = 0; \n\
|
|
var i = 0; \n\
|
|
var oindex = 0; \n\
|
|
while (i < s.length) { \n\
|
|
if (s[i] == delimiter) { \n\
|
|
o[oindex] = String.slice(s, start, i); \n\
|
|
start = i + 1; \n\
|
|
oindex += 1; \n\
|
|
} \n\
|
|
i += 1; \n\
|
|
} \n\
|
|
if (start < s.length) { \n\
|
|
o[oindex] = String.slice(s, start); \n\
|
|
} \n\
|
|
return o; \n\
|
|
}; \n\
|
|
// slice(string, from, to) \n\
|
|
String.slice = function () { \n\
|
|
if (arguments.length < 2) { \n\
|
|
return ''; \n\
|
|
} \n\
|
|
var s = arguments[0]; \n\
|
|
var from = arguments[1]; \n\
|
|
var to; \n\
|
|
if (arguments.length > 2) { \n\
|
|
to = arguments[2]; \n\
|
|
} else { \n\
|
|
to = s.length; \n\
|
|
} \n\
|
|
var o = ''; \n\
|
|
var i = from; \n\
|
|
while (i < to) { \n\
|
|
o += s[i]; \n\
|
|
i += 1; \n\
|
|
} \n\
|
|
return o; \n\
|
|
}; \n\
|
|
var test2 = 'abc, d, e f'; \n\
|
|
var splitted = String.split(test2, ','); \n\
|
|
print(splitted.length + '\n'); \n\
|
|
print(splitted[0] + '\n'); \n\
|
|
print(splitted[1] + '\n'); \n\
|
|
print(splitted[2] + '\n'); \n\
|
|
splitted[0];", 2, 0, "abc");
|
|
stest(" \n\
|
|
var _cm = {}; // map from character to ASCII code \n\
|
|
_cm['\\x0'] = 0; _cm['\\x1'] = 1; _cm['\\x2'] = 2; \n\
|
|
_cm['\\x3'] = 3; _cm['\\x4'] = 4; _cm['\\x5'] = 5; \n\
|
|
_cm['\\x6'] = 6; _cm['\\x7'] = 7; _cm['\\x8'] = 8; \n\
|
|
_cm['\\x9'] = 9; _cm['\\xa'] = 10; _cm['\\xb'] = 11; \n\
|
|
_cm['\\xc'] = 12; _cm['\\xd'] = 13; _cm['\\xe'] = 14; \n\
|
|
_cm['\\xf'] = 15; _cm['\\x10'] = 16; _cm['\\x11'] = 17; \n\
|
|
_cm['\\x12'] = 18; _cm['\\x13'] = 19; _cm['\\x14'] = 20; \n\
|
|
_cm['\\x15'] = 21; _cm['\\x16'] = 22; _cm['\\x17'] = 23; \n\
|
|
_cm['\\x18'] = 24; _cm['\\x19'] = 25; _cm['\\x1a'] = 26; \n\
|
|
_cm.length", 27);
|
|
stest_base(" \n\
|
|
var stest = function () { return arguments[0] + '_1'; }; \n\
|
|
var s = 'abc'; \n\
|
|
s = stest(s); \n\
|
|
s = stest(s); \n\
|
|
s;", 2, 0, "abc_1_1");
|
|
stest(" \
|
|
var test = function () { \
|
|
var x = arguments[0]; \
|
|
if (x < 0) \
|
|
return 2; \
|
|
return 3; \
|
|
}; \
|
|
var t1 = test(-32); \
|
|
t1;", 2);
|
|
stest_base(" \n\
|
|
var stest = function () { \n\
|
|
var o = arguments[0] + '_'; \n\
|
|
var i = 0; \n\
|
|
while (i < 2) { \n\
|
|
o += i; \n\
|
|
i += 1; \n\
|
|
} \n\
|
|
return o; \n\
|
|
}; \n\
|
|
var s = 'abc'; \n\
|
|
s = stest(s); \n\
|
|
s = stest(s); \n\
|
|
s;", 2, 0, "abc_01_01");
|
|
stest_base(" \
|
|
var test = function () { \
|
|
var x = arguments[0]; \
|
|
var o = 'x'; \
|
|
if (x > 0) { \
|
|
o += 2; \
|
|
} else { \
|
|
o += 3; \
|
|
} \
|
|
return o; \
|
|
}; \
|
|
var t1 = test(-32); \
|
|
t1;", 2, 0, "x3");
|
|
stest(" \
|
|
var atmp = []; \
|
|
atmp[0] = 10; \
|
|
atmp[1] = 20; \
|
|
atmp[0 + 1];", 20);
|
|
```
|
|
|
|
Some of these tests has also been ported in plain JavaScript; take a look inside
|
|
the **verify.js** script. These tests uses **eval()** function to execute a test
|
|
source code string and verify its execution results. These other tests can be
|
|
executed with this command:
|
|
|
|
``` <!---sh-->
|
|
cat utils.js verify.js | ./prog
|
|
```
|
|
|
|
|
|
### F.A.Q
|
|
|
|
These are frequently asked questions that can be asked when trying to use this
|
|
little mambo jumbo interpreter:
|
|
|
|
- why? because why not
|
|
- if program crash, check if you are calling some function that is not declared
|
|
or has been misspelled. There are no safety check about this
|
|
- if program loop indefinitely, check if your function assignments includes a
|
|
final ; after }. This is required
|
|
- what is the meaning of life and everything? 42 or sometimes 2503
|
|
- if program do not do what you want, check the supported features because the
|
|
parser can easily misunderstand what you are giving as input text; for example
|
|
you can type **let** instead of **var** and, without any errors raised,
|
|
everything will go terribly wrong
|
|
- can this interpreter be used on real production environment? of course not
|
|
- what is the memory limit of this interpreter? there is no limits
|
|
- what happen if an object contains a reference to itself (object with a
|
|
recursive structure)? An infinite loop is triggered because the Garbage
|
|
Collector cannot recognize this kind of structure
|
|
|
|
|
|
### Final Thoughts
|
|
|
|
I've tried multiple time to rewrite this interpreter and compress the final
|
|
obfuscated source code to match the previous IOCCC limit but without success.
|
|
|
|
The increased limitation of tokens from 2053 to 2503 has made possible to use
|
|
this iteration of the interpreter without continue to retry to rewrite that to
|
|
compress the final source code. Probably with more iterations the 2053 limit
|
|
should be reached, who knows.
|
|
|
|
The most tricky part in the development process has been to find out a minimal
|
|
bare bones subset of JavaScript features, small enough to allow to build some
|
|
other standard features on top of the bare bones interpreter.
|
|
|
|
In many tests I've tried to include the Object.keys features (to obtain the
|
|
list of property keys inside a given Object) but, in all of my attempts, the
|
|
limitation on tokens count was exceeded. With Object.keys would have been
|
|
possible to build up also Object.values and other Object methods. Also the lack
|
|
of prefix/postfix ++ and -- it's a pity... Damn it!
|
|
May be without the Garbage Collector some other features should be packed into
|
|
the program but it's too late to change that.
|
|
|
|
Have fun!
|
|
|
|
|
|
|
|
<!--
|
|
|
|
Copyright © 1984-2025 by Landon Curt Noll and Leonid A. Broukhis. All Rights Reserved.
|
|
|
|
You are free to share and adapt this file under the terms of this license:
|
|
|
|
Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)
|
|
|
|
For more information, see:
|
|
|
|
https://creativecommons.org/licenses/by-sa/4.0/
|
|
|
|
-->
|