1. DEATHBUNNY (Designed with EuphoriA TecHnology and Built by
- Posted by Jossarian <darkspace at HOTMAIL.COM>
Dec 22, 1995
-
Last edited Dec 23, 1995
Another crazy idea just got spawned by me, and this time it's
DEATHBUNNY, the programming language.
It is currently being developed by me (darkspace at hotmail.com) and
MikPos/Mike Burrell (mikpos at softhome.net)
I am currently mostly designing the language, and Mike is programming,
so send mail to me if you have ideas for the lang, and mail Mike if you
want to help him with the programming.
Questions? Mail me
(Any help would be appreciated)
Here are the ALPHA specs for DEATHBUNNY:
ALPHA specs for DEATHBUNNY (Designed with EuphoriA TecHnology and Built
by UNknowN Youngsters)
Needed:
--More variable handling
--A way to print special chars like !",.-+ etc and numbers
--Looping constructs? (Arrrrr, we don' need no steenkin loops! :)
--COME FROM? =)
--ETC
The DEATHBUNNY programming language is intended to be a parody. If you
think it's crazy, sick, twisted and hard to use, you're right. But if
you think that nothing can be accomplished with the language, you're
very wrong. When finished, DEATHBUNNY will be a full-fledged programming
language that can be used to do everything the user wants (if the user
is up to it, that is ;)
--PREPARE TO BE DAZZLED, PUZZLED, FRIGHTENED, ANGRIED AND VERY POSSIBLY
COMMITTED TO A MENTAL HOSPITAL--
If a function has "param" in it, it means that the parameter can be a
variable or a "normal" number.
"variable" means that it has to be a variable (but not matrix)
"value" means that the parameter has to be a number
"matrix" means that the parameter HAS to be a matrix, nothing else
There could be 7 registers, from A to G and a special register called a
flag
register that can't be written to by the programmer. The regs are 32bit.
The registers HAVE to be binary instead of trinary etc, otherwise we'll
have a hard time
figuring out the math required to do a multiply or divide in trinary
without
actually having the commands in the language =)
It's damn easy to do a divide by 2 or multiply by 2 in binary, u just
shift
the bits left or right 1 step. (I haven't the slightest clue on
multiplying with something else than 3, though =)
The selected register always "rotates" after an operation. So, if you do
a reg_chg/100|\ in the beginning of your program, it would change the A
register and then move on to B. The next operation you do will be done
on reg B.
Here are some example functions:
reg_chg/param1|\ would replace the current register's contents with
param1
(param1 is a bin8 or bin16 variable, or a binary number)
reg_add/param1|\ adds param1 to the current register
reg_sub/param1|\ duh..
reg_shift_r/param1|\ shifts the bits of the register right, param1
steps.
Bits get clipped at the "edge"
reg_shift_l/param1|\ duhduh :)
reg_xor/param1|param2|\ XORs the bits in registers param1 and param2
with
each other
reg_reverse/param1|param2|\ Reverses the bits between param1 and param2
in
the current register (does a NOT on them?)
param1 and 2 are NOT included in the operation
reg_dump/variable1|variable2|\ Dumps the first 16 bits of the
currently selected reg to bin16 variable1 (variable types explained
below), and the last 16 bits to bin16
variable2
reg_slice/param1|param2|variable1|\ Takes a slice beginning from param1
and
ending to param2, and then dumps the slice to a bin variable1 (The first
bit is the rightmost.) The slice includes the parameters, so if u do a
slice
from the 1st to the 3rd, the slice would have the first and the third
bit in
it. MAKE SURE THE SLICE IS THE RIGHT SIZE FOR THE VARIABLE!
reg_selected/|\ No parameters. Puts the currently selected register
into the
STATUS flags in the flag register (STATUS flags are the last 3 bits of
the
flag register)
so, if the selected register was now 7, and you run reg_selected/|\,
then
the flags register would be 11100000000000000000000000000000 (assuming
that
it hasn't already been modified by DEATHBUNNY)
THIS COMMAND DOESN'T ROTATE THE REGISTERS
-----------------------------NEW STUFF============
pr/param1|param2|\ The strange rotate-print function.
Imagine a wheel that has all the letters written on it's outer edge.
If you want to print a letter, you rotate the wheel. Simple :)
Param1 is a matrix or a double_matrix containing the values, and param2
is the number of letters to print.
The print function works like this:
If euphoria had a pr function, and you wanted to print ABCD on the
screen, you would do something like this: pr({0,1,1,1})
Because the "letter wheel" always starts at A, the first parameter is 0
(prints the currently selected char,) then it moves the wheel 1 step and
prints the char (B) and does it again two times. Simple :)
If you want lowercase letters, you use 100 + value (in base-10 that is,
base-7 is a bit more complicated ;)
So, if I want to print abcd on the screen, I would do a
pr({100,101,101,101})
bconv/param1|param2|\ Converts the bin8/16 variable param1 to pair/quad
param2.
DO NOT try to convert a bin8/16 variable that is larger than 66 or 6666
base-7, or
48/2400 base-10
Some operators and such:
comments are done by putting a ++ at the START of a line. The WHOLE line
will
get ignored.
declare !name as type, example:
declare !test as pair
++ declares the variable !test as a pair
-- "Normal" variable operations --
<[param1|variable1|] assignment. For example, ding = 5 would be
<[5|!ding]
+[param1|variable1|etc|] add
-[param1|variable1|etc|] substract
*[param1|variable1|etc] multiply
/[param1|variable1|etc] divide
%[param1|matrix|] adds param1 to matrix. If data is a bin8/16 variable,
it is
converted to base-7.
-- Matrix operations --
&-[matrix1|matrix2|etc|] substracts variable1 from variable2 and so
on
&+[matrix1|matrix2|etc|] add
&*[matrix1|matrix2|etc|] multiply
&/[matrix1|matrix2|etc|] divide
&>[param1|param2|matrix1|] "extract" element defined by param1 and 2 to
variable1
&?[param1|param2|matrix1|] partially ignore matrix1 so that only the
elements from param1 to param2 may be used. Any operation on the ignored
elements will be gleefully ignored.
(param1 and 2 are included in the ignore)
&![param1|param2|matrix1|] un-ignore elements param1 to param2 from
matrix1 (param1 and 2 included in un-ignore.) Trying to un-ignore
already un-ignored elements has no effect.
pair, quad, string, bin16, bin8, matrix, double_matrix
pair = max 66 (in base-7)
quad = max 6666 (base-7)
string = used in I/O operations?
bin16 = 16-bit binary variable. the last (leftmost) bit indicates the
sign of
the variable, and if set to 1, then the variable is negative
bin8 = 8-bit binary variable. Last bit indicablahblah u know :)
matrix = 5x5 matrix, that makes 25 signed quads
double_matrix = 10x10 matrix, 100 signed quads
EXAMPLE program that prints "DEATHBUNNY"
(It could be made shorter with looping constructs, but we don't have
them
yet ;)
declare !textdata as matrix
declare !temp as bin8
reg_chg/100|\
++ Now reg A is 100 (4 in base-10)
reg_chg/1100|\
++ Reg B is 1100 (12)
reg_chg/110|\
++ C is 110 (6)
reg_chg/111|\
++ D is 111 (7)
reg_chg/111|\
++ "Joke" operation to cycle regs made in reg E
reg_chg/111|\
++ Ditto, but now in F
reg_chg/111|\
++ And now in G
reg_add/10000000|\
++ Making reg A a negative number
reg_add/10000000|\
++ and B
reg_add/10000000|\
++ C
reg_add/10000000|\
++ D
reg_chg/111|\
++ But not E, just doing a joke op
reg_chg/111|\
++ F too
reg_chg/111|\
++ G
%[3|!textdata|]
%[1|!textdata|]
reg_slice/1|11|!temp|\
++ putting our negative number from reg A to !temp
%[!temp|!textdata|]
++ and add the data to the matrix
%[25|!textdata|]
reg_slice/1|11|!temp|\
++ putting our negative number from B to !temp
%[!temp|!textdata|]
++ and add the data to the matrix
reg_slice/1|11|!temp|\
++ putting our negative number from C to !temp
%[!temp|!textdata|]
++ and add the data to the matrix
%[25|!textdata|]
reg_slice/1|11|!temp|\
++ putting our negative number from D to !temp
%[!temp|!textdata|]
++ and add the data to the matrix
%[0|!textdata|]
%[14|!textdata|]
pr/!textdata|13|\
++This makes a whopping 31 commands just to print out 10 letters ;)
++They took about 15-20 minutes to write, because I had to do all the
number
++conversion, think about the registers (I took out the pair_sig to make
++life harder :) and everything
++(Comments not included in the line count)
