Claw development system, a multiplatform programming platform [multiplatform]

[DarkestEx]

I like it more actually now

Thanks

I FINISHED THE PREPROCESSOR!
It can do, expressions, hexadecimal escapes, multiline statements, defines, undefines, nested if's, ifdefs, elseifs, custom errors, file includes and more.
Also the error handling is totally finished and displays nicely formatted errors.
Feel free to test and download the version from here:
http://claw.muessigb.net/dl/clawsemble-16_aug_09-a.zip

[Dream of Omnimaga]

Awesome! I'm glad to see this progress smoothly so far. Will there be a mini tutorial in the future by the way?

[DarkestEx]

Awesome! I'm glad to see this progress smoothly so far. Will there be a mini tutorial in the future by the way?

Absolutely, as soon as I find time, I will write a full one up.
To make it easy for all of us, I kept the entire preprocessor compatible to the C one.

Little Clawsemble preprocessor overview:

Let's start with the conditionals.
They can be nested as much as desired and each if can have an unlimited amount of elseif's/elseifdef's and elseifndef's.
There can only be one else which is optional and has to be the last element in the if block.
#if (expression)    is used to only process the enclosed code if the condition is met, or the number or string inside the parantheses is non-zero
#ifdef defininition    is similar to the above but the condition is met, if a variable with the name is defined
#ifndef definition    as above, but condition is met, if the variable is not defined
#elseif (expression)    is used to provide an alternative, if the previous condition(s) is/are not met
#elseifdef definition    as above, but the condition is if a variable with that name is defined
#elseifndef definition    as above, but the if the variable is not defined
#else    if the condition is not met and the elseif's don't met their conditions either
#endif    is used to close the if-block

Expressions are simple.
All C arithmetic operators are supported and are using the same symbol, except for modulo, which is // now.
Numbers can be written with +/- prefix to show whether they are positive or negative. Negative numbers do
not need to be enclosed in parantheses. You can easily write something like: (-1 + -2 -3 - -4) and you can
even omit the spaces and Clawsemble will still be able to deal with it correctly.
Using the negative sign to negate an expression is NOT supported though. Use *-1 to do so instead.
Expressions should always be enclosed in one set of parantheses ()
Hexadecimal numbers are prefixed with an $ABAB, characters are written like this %d.

Multiple files work too.
Just use #include "filename.csm", to include other source files. They are just inserted into your main program at the position
of the #include statement and have access to the same #defines as your main program.

You can define variables.
Use #define MY_VAR 1234, #define YOUR_VAR %d, #define HEXVAR $DEADBEEF or #define ANOTHER_VAR (123 + $1242 * 123) to define your own variables
that you can check later on with the #if statement and it's companions. #undefine is used to delete a variable from memory again.
Variables can also be redefined at any point by simply calling #define again.
Be careful with the names, as they are case-sensitive. Also, all exact word-occurences of the variable name in the program are
automatically replaced by the value that the variable has at that point of time. If it changes later on in the assemblation,
the value won't change again.

Custom errors are easy to use.
Let's say, you have some conditions that have to be met for a program to be assembled correctly and you would like to prevent
the user from such accidents then you can simply use the #error statement to abort the further assemblation of the program.
You can even display an error message, the result of an expression or the contents of a variable by passing it after the #error statement:
e.g.: #error ("The architecture " + ARCH + " is unfortunately not supported at the moment!")

Make it short.
Many shorthand forms are available to save you typing:
#error, #err
#define, #def
#include, #inc
#elseif, #elif
#elseifdef, #elifdef
#elseifndef, #elifndef

Comment your code.
You can use the ; character to comment out lines if you don't want them to be parsed.
Everything after the start of a comment until a newline character is ignored and will not be processed.
You can put the comment at the beginning or the end of a line. Multiline comments are not supported.
Comments can be disabled by putting a \ in front of the comment. Like this:    \;
The \ character can also be used to break single line codes into multiple ones:
e.g.: #define MY_COMPLEX_EXPRESSION \
(123 + 124 + 23230 + 12040 + ONE_OF_MY_VARS + 12332 * 124224 - 20 + \
1402 + $BEEF)


This tutorial will be finished later on, when more of the assembler is done and ready for primetime.

[DarkestEx]

Update:

I have finished the instruction list. A lot was already there but I have finally completed it.
Can you PLEASE have a look if I am missing anything and maybe suggest some improvements?

Here is the full instruction list:
https://docs.google.com/spreadsheets/d/1Tfi8z7maQLM3RUHfQpnS50gAkGyfiizkQ54TTZGl9e4/edit?usp=sharing

[Dream of Omnimaga]

I can't check all commands now due to limited time, but wouldn't it be easier for programmers to not have to press Shift+# or Alt gr+#  every three second when coding?

[DarkestEx]

I can't check all commands now due to limited time, but wouldn't it be easier for programmers to not have to press Shift+# or Alt gr+#  every three second when coding?

What 
Well, first, C and many other languages use # for preprocessor directives and second, I think on most keyboards it's quite simple to reach the # symbol.
For me it's a separate key.
I primarily wanted to keep it compatible with existing things, so I choose the most common method. I doubt you will ever use the Assembler as I assume you don't get along with assembly and I can't complain if you can't; it's still not so easy. But don't worry, Cumred's high level compiler with mostly Basic/Lua syntax is on it's way

[Dream of Omnimaga]

Oh I meant how commands are #elseif instead of elseif for example. On my French Canadian keyboard the # has no 1st level key assigned. I am ok with #, but commands will take longer to type.

Keep up the good work though

[DarkestEx]

Oh I meant how commands are #elseif instead of elseif for example. On my French Canadian keyboard the # has no 1st level key assigned. I am ok with #, but commands will take longer to type.

Keep up the good work though

Thanks

You usually don't need to use these statements as they are executed on the compiler PC and not the device. Clawsemble has own instructions for it which are just written as a word.

[DarkestEx]

I have finally finished Claw's instruction set

You can find a list with all the instructions and their descriptions and parameters here:
https://github.com/muessigb/Clawsemble/wiki/Instruction-set

[c4ooo]

Oh I meant how commands are #elseif instead of elseif for example. On my French Canadian keyboard the # has no 1st level key assigned. I am ok with #, but commands will take longer to type.

Keep up the good work though

No keyboard has a first level '#'.
If you can't be bothered to press the shift button you could get the hash-tag keyboard http://thehashkey.com/kickstarter

[DarkestEx]

Oh I meant how commands are #elseif instead of elseif for example. On my French Canadian keyboard the # has no 1st level key assigned. I am ok with #, but commands will take longer to type.

Keep up the good work though

No keyboard has a first level '#'.
If you can't be bothered to press the shift button you could get the hash-tag keyboard http://thehashkey.com/kickstarter

Do a bit of research before claiming something:

This is the german keyboard layout which has a first level # key right left to the return key.
Unfortunately the same layout makes it cumbersome to access the curly and sharp braces, as they need a modifier key to work.

[DarkestEx]

Sorry for breaking the previous instruction set, but I forgot some really important instructions.
Here is the updated list:

#	Mnemonic	Description	Operands	Static operand
0x0	NOP	Do nothing.
0x1	VNFO	Pushes the configuration flags of the virtual machine such as features and processor details.
0x2	STSZ	Pushes the current instance's allocated stack size followed by the usage.
0x3	CASZ	Pushes the current instance's allocated call stack size followed by the usage.
0x4	PLSZ	Pushes the system's allocated array pool size followed by the usage.
0x5	RICK	Rickrolls the user. This will result in the program not behaving as expected. Use with care!
0x6	HCF	Kills the current instance of the virtual machine. Displays an error message from the constant table. Use -1 to skip the message.		TABLE_ENTRY (S)
0x7	EOP	Ends the current program. Performs a normal exit.
0x8	BRK	Creates a breakpoint. Takes a constant breakpoint ID.		BREAKPOINT_ID (B)
0x9	DBPS	Prints a string from the constant table to the debug console.		TABLE_ENTRY (S)
0xa	DBDA	Dumps the contents of the current array to the debug console.
0xb	DBDV	Pops the last stack value and prints it to the debug console.	VALUE ($0)
0xc	MDP	Pushes whether the optional module is present and loaded. Takes an constant entry that contains the module name.		TABLE_ENTRY  (S)
0xd	MDL	Loads a module into the extended instruction area. Takes a constant index of the module.		MODULE_INDEX (B)
0xe	MDV	Pushes the minor, the the major version of the module onto the stack. Takes a constant index of the module.		MODULE_INDEX (B)
0xf	LRL	Loads a library/binary from a string handle. Takes the handle from the referenced constant table entry. Pushes whether the load was successful.	SLOT ($0)	TABLE_ENTRY (S)
0x10	LRD	Loads a library/binary from a string handle. Takes the handle from the currently loaded string. Pushes whether the load was successful.	SLOT ($0)
0x11	LRU	Unloads a library/binary that was previously loaded. Does not crash if the slot was empty.	SLOT ($0)
0x12	FEX	Pushes whether a function exists. Using -1 as the slot will check for a local function.	SLOT ($0), FUNCTION_INDEX ($0)
0x14	LC	Loads a numeric constant and pushes it onto the stack.		VALUE (N)
0x15	LD	Copies a lower stack value onto the top of the stack. Uses a constant relative offset.		REL_STK_OFFSET (B)
0x16	LDD	Copies a lower stack value onto the top of the stack. Uses a dynamic absolute offset.	ABS_STK_OFFSET ($0)
0x17	DV	Drops the last value from the stack.	VALUE ($0)
0x18	DP	Duplicates the uppermost value on the stack.	VALUE ($0)
0x19	SW	Swaps the two uppermost values on the stack.	VALUE ($0)
0x1a	LX	Pushes a value from an array to the stack. Uses a constant address (aligned at the numeric type).		ADDRESS (N)
0x1b	LXD	Pushes a value from an array to the stack. Uses a dynamic address (aligned at the numeric type).	ADDRESS ($0)
0x1c	LXB	Pushes a byte value from an array to the stack. Uses a constant address (aligned at the byte type).		ADDRESS (N)
0x1d	LXBD	Pushes a byte value from an array to the stack. Uses a dynamic address (aligned at the byte type).	ADDRESS ($0)
0x1e	PX	Pushes a value from the stack to the array. Uses a constant address (aligned to the numeric type).	VALUE ($0)	ADDRESS (N)
0x1f	PXD	Pushes a value from the stack to the array. Uses a dynamic address (aligned to the numeric type).	VALUE ($1), ADDRESS ($0)
0x20	PXB	Pushes a byte value from the stack to the array. Uses a constant address (aligned to the byte type).	VALUE ($0)	ADDRESS (N)
0x21	PXBD	Pushes a byte value from the stack to the array. Uses a dynamic address (aligned to the byte type).	VALUE ($1), ADDRESS ($0)
0x22	XC	Creates a new numeric array. Uses a constant size in elements. Selects the array afterwards.		SIZE (N)
0x23	XCB	Creates a new byte array. Uses a constant size in bytes. Selects the array afterwards.		SIZE (N)
0x24	XCD	Creates a new numeric array. Size in bytes is taken from the stack. Selects the array afterwards.	SIZE ($0)
0x25	XCI	Creates a new array and initializes it's contents and size with a constantly selected constant value from the constant table. Selects the array afterwards.		TABLE_ENTRY (A)
0x26	XS	Selects the current array used to share data with. Uses a constant relative offset within the current instance.		REL_ARR_OFFSET (B)
0x27	XSD	Selects the current array used to share data with. Uses a dynamic absolute identifier.	ABS_ARR_OFFSET ($0)
0x28	XSR	Selects the current array as the array assigned to the calling executable.
0x29	XAR	Sets the current array as the array assigned to the calling executable.
0x2a	XR	Resizes the currently selected array. Uses a dynamic size in elements. On some platforms only the last created array can be resized.	SIZE ($0)
0x2b	XRB	Resizes the currently selected array. Uses a dynamic size in bytes. On some platforms only the last created array can be resized.	SIZE ($0)
0x2c	XRL	Resizes the last created array. Uses a dynamic size in elements. This is guaranteed to work on any platform.	SIZE ($0)
0x2d	XRLB	Resizes the last created array. Uses a dynamic size in bytes. This is guaranteed to work on any platform.	SIZE ($0)
0x2e	XD	Drops the currently selected array. On some platforms only the last created array can be dropped.
0x2f	XDL	Drops the last created array. This is guaranteed to work on any platform.
0x30	XPO	Pushes the relative offset of the currently selected array to the stack.
0x31	XPI	Pushes the absolute index of the currently selected array to the stack.		REL_ARR_OFFSET (B)
0x32	XPS	Pushes the size in bytes of the currently selected array to the stack.
0x33	XPSB	Pushes the size in bytes of the currently selected array to the stack.
0x34	XCS	Pushes the size in bytes of the dynamically selected constant table entry. Pushes 0 if the entry does not exist.	TABLE_ENTRY ($0)
0x35	XFN	Fills the array with a value. Takes the number, the length in elements and the offset in elements from the stack.	LENGTH ($2), TAR_OFFSET ($1), VALUE ($0)
0x36	XFC	Fills the array with a constant value. Takes length in bytes and offset in bytes from the stack.	LENGTH ($1), TAR_OFFSET ($0)	VALUE (B)
0x37	XMN	Copies from the current array to another one. Takes length in elements and offset in elements from the stack. Takes a constant relative array offset.	LENGTH ($2), TAR_OFFSET ($1), SRC_OFFSET ($0)	REL_ARR_OFFSET (B)
0x38	XMB	Copies from the current array to another one. Takes length in bytes and offset in bytes from the stack. Takes a constant relative array offset.	LENGTH ($2), TAR_OFFSET ($1), SRC_OFFSET ($0)	REL_ARR_OFFSET (B)
0x39	XMD	Copies from the current array to another one. Takes length, offset and absolute offset to target from the stack.	LENGTH ($3), TAR_OFFSET ($2), SRC_OFFSET ($1), ABS_ARR_OFFSET ($0)
0x3a	XMCN	Copies a constant from the constant table to the array. Uses a constant table entry as source. Clips the constant, if it's longer than the size. Length and offset in elements.	LENGTH ($2), TAR_OFFSET ($1), SRC_OFFSET ($0)	TABLE_ENTRY (A)
0x3b	XMCB	Copies a constant from the constant table to the array. Uses a constant table entry as source. Clips the constant, if it's longer than the size. Length and offset in bytes.	LENGTH ($2), TAR_OFFSET ($1), SRC_OFFSET ($0)	TABLE_ENTRY (A)
0x3c	XMCD	Copies a constant from the constant table to the array. Uses a dynamic table entry. Clips the constant, if it's longer than the size. Length and offset in bytes.	LENGTH ($2), TARGET_OFFSET  ($1), TABLE_ENTRY ($0)
0x3d	CNB	Converts the number in elements on the stack to the equivalent number of bytes.	ELEMENTS ($0)
0x3e	CNC	Converts the constant number in elements to the equivalent number of bytes and pushes it.		ELEMENTS (N)
0x3f	CBN	Converts the number in bytes on the stack to the next equivalent number of elements.	BYTES ($0)
0x41	JP	Performs a relative jump. Takes a constant offset to the target.		OFFSET (L)
0x42	JPD	Performs a relative jump. Takes a dynamic offset to the target.	OFFSET ($0)
0x43	JPZ	Performs a relative jump, if the popped stack entry is <= 0.	DISCRIMINATOR ($0)	OFFSET (L)
0x44	JPP	Performs a relative jump, if the popped stack entry is > 0.	DISCRIMINATOR ($0)	OFFSET (L)
0x45	JPPD	Performs a relative jump to the dynamic offset, if the popped stack entry is > 0.	DISCRIMINATOR ($1), OFFSET ($0)
0x46	JS	Performs a short jump ahead if popped stack entry is > 0.	DISCRIMINATOR ($0)	OFFSET (SL)
0x47	JSB	Performs a short jump back if popped stack entry is > 0.	DISCRIMINATOR ($0)	OFFSET (SL)
0x48	CA	Calls a local function. Takes a constant function index.		FUNCTION_INDEX (F)
0x49	CAD	Calls a local function. Takes a dynamic function index.	FUNCTION_INDEX ($0)
0x4a	CL	Calls a library function. Takes a constant function index.	SLOT ($0)	FUNCTION_INDEX (F)
0x4b	CLD	Calls a library function. Takes a dynamic function index.	SLOT ($1), FUNCTION_INDEX ($0)
0x4c	RET	Returns from a function early.
0x4e	ADD	Pops $0 and $1. Pushes $1 + $0.	$0, $1
0x4f	SUB	Pops $0 and $1. Pushes $1 - $0.	$0, $1
0x50	MUL	Pops $0 and $1. Pushes $1 * $0.	$0, $1
0x51	DIV	Pops $0 and $1. Pushes $1 / $0. This is a signed division.	$0, $1
0x52	MOD	Pops $0 and $1. Pushes $1 % $0. This is a signed division.	$0, $1
0x53	POW	Pops $0 and $1. Pushes $0 to the power of $1.	$0, $1
0x54	MAX	Pops $0 and $1. Pushes the larger of both.	$0, $1
0x55	MIN	Pops $0 and $1. Pushes the smaller of both.	$0, $1
0x56	AND	Pops $0 and $1. Pushes $1 & $0. This is a bitwise function.	$0, $1
0x57	OR	Pops $0 and $1. Pushes $1 | $0. This is a bitwise function.	$0, $1
0x58	XOR	Pops $0 and $1. Pushes $1 ^ $0. This is a bitwise function.	$0, $1
0x59	BSL	Pops $0 and $1. Pushes $1 << $0. This is a bitwise function.	$0, $1
0x5a	BSR	Pops $0 and $1. Pushes $1 >> $0. This is a bitwise function.	$0, $1
0x5b	ADDC	Pops $0. Pushes $0 + c.	$0	C (N)
0x5c	SUBC	Pops $0. Pushes $0 - c.	$0	C (N)
0x5d	MULC	Pops $0. Pushes $0 * c.	$0	C (N)
0x5e	DIVC	Pops $0. Pushes $0 / c. This is a signed division.	$0	C (N)
0x5f	MODC	Pops $0. Pushes $0 % c. This is a signed division.	$0	C (N)
0x60	ANDC	Pops $0. Pushes $0 & c. This is a bitwise function.	$0	C (N)
0x61	ORC	Pops $0. Pushes $0 | c. This is a bitwise function.	$0	C (N)
0x62	XORC	Pops $0. Pushes $0 ^ c. This is a bitwise function.	$0	C (N)
0x63	BSLC	Pops $0. Pushes $0 << places. This is a bitwise function.	$0	PLACES (B)
0x64	BSRC	Pops $0. Pushes $0 >> places. This is a bitwise function.	$0	PLACES (B)
0x65	ICR	Pops $0. Pushes $0 + 1.	$0
0x66	DCR	Pops $0. Pushes $0 - 1.	$0
0x67	ABS	Pops $0. Pushes abs($0).	$0
0x68	RND	Pops $0. Pushes rand() % $0.	$0
0x69	SQRT	Pops $0. Pushes sqrt($0).	$0
0x6a	LOG2	Pops $0. Pushes log2($0).	$0
0x6b	IPW2	Pops $0. Pushes a logic true, if $0 is a power of 2 and a logic false otherwise. This is a logical function.	$0
0x6c	NEG	Pops $0. Pushes -$0.	$0
0x6d	NOT	Pops $0. Pushes ~$0. This is a bitwise function.	$0
0x6e	REV	Pops $0. Reverses the bits of $0 and pushes them. This is a bitwise function.	$0
0x6f	CBS	Pops $0. Pushes the number of active bits in $0. This is a bitwise function.	$0
0x70	CBZ	Pops $0. Pushes the number of trailing zero bits in $0. This is a bitwise function.	$0
0x71	LAND	Pops $0 and $1. Pushes $0 && $1. This is a logical function.	$0, $1
0x72	LOR	Pops $0 and $1. Pushes $0 || $1. This is a logical function.	$0, $1
0x73	LNOT	Pops $0. Pushes !$0. This is a logical function.	$0
0x74	EQ	Pops $0 and $1. Pushes $0 == $1. This is a logical function.	$0, $1
0x75	NEQ	Pops $0 and $1. Pushes $0 != $1. This is a logical function.	$0, $1
0x76	LT	Pops $0 and $1. Pushes $0 < $1. This is a logical function.	$0, $1
0x77	LTEQ	Pops $0 and $1. Pushes $0 <= $1. This is a logical function.	$0, $1
0x78	GT	Pops $0 and $1. Pushes $0 > $1. This is a logical function.	$0, $1
0x79	GTEQ	Pops $0 and $1. Pushes $0 >= $1. This is a logical function.	$0, $1	C (N)
0x7a	EQC	Pops $0. Pushes $0 == c. This is a logical function.	$0	C (N)
0x7b	NEQC	Pops $0. Pushes $0 != c. This is a logical function.	$0	C (N)
0x7c	LTC	Pops $0. Pushes $0 < c. This is a logical function.	$0	C (N)
0x7d	LTEQC	Pops $0. Pushes $0 <= c. This is a logical function.	$0	C (N)
0x7e	GTC	Pops $0. Pushes $0 > c. This is a logical function.	$0	C (N)
0x7f	GTEQC	Pops $0. Pushes $0 >= c. This is a logical function.	$0

[p2]

Uuuuh, an evil doublepost  Should better call the site Editors to fix that

Btw you should also update the spoilered list in your old post
Aaand it really looks nice 

[DarkestEx]

Uuuuh, an evil doublepost  Should better call the site Editors to fix that

Btw you should also update the spoilered list in your old post
Aaand it really looks nice 

Haha, double posts are alright to promote big updates which this absolutely is

I will and thanks

[Dream of Omnimaga]

Thanks for the instructions update. Also I'm glad this is coming along nicely. I'm still curious about how fast vector graphics will render on lower-end platforms, especially if many vector graphics are present on the screen at the same time (such as Ikaruga or Touhou shooters)