Recent changes to learining gCode

learining gCode modified by griefer@work

griefer@work — Wed, 05 Mar 2014 08:43:14 -0000

--- v45
+++ v46
@@ -6,14 +6,15 @@
 [TOC]

 #1. Statements
-Single statements allways end with a ';'.
+Single statements allways end with a ";".
 Statements may contain more statements. These statements are treated differently.
 They are either composed from a single statement or are encased in a block-statement.
 ##1.1. block-statement
-Block statements are collections of normal statements that begin with 'begin' or '{' and end with 'end' or '}'
-Within this tutorial I will only use 'begin' and 'end'. But you can allways allso use alternative.
+Block statements are collections of normal statements that begin with "begin" or "{" and end with "end" or "}"
+Within this tutorial I will only use "begin" and "end". But you can allways allso use the alternative.
+
 ##1.2. difference statement/inline-statement
-gCode is internally seperated to 3 types of code:
+gCode is internally seperated to 4 types of code:
  * Statements
  * inline-statements
  * value setters
@@ -23,6 +24,7 @@
  * Statements use value getters and setters and other statements
  * value getters use inline statements 
  * inline statements use value getters and statements
+
 #2. Commenting
 gCode offers multiple ways to insert comments into your code:
 > // this is a line comment! it ends once this line ends
@@ -31,7 +33,7 @@

 > /end/

-NOTE: there are multiple synonys for /begin/ and /end/:
+NOTE: there are multiple synonyms for /begin/ and /end/:
 /\* ... \*/   (\* ... \*)   /{/ ... /}/

@@ -49,8 +51,8 @@
 > 6 --> f;

 ###3.1.1. modifying var assignment
-NOTE: these actions can be performed inline (they returm the new value of the var being modified)
 > a = 21;
+> // NOTE: the following actions can be performed inline (they returm the new value of the var being modified)
 > a += 19; // a is now 40
 > a -= 20; // a is now 20
 > a *= 4;  // a is now 80
@@ -64,16 +66,15 @@
 > a = 'foobar'; // easy
 > b = 'foo'\r\n'bar'; // new line inbetween (method 1)
 > c = 'foo
-> bar'; // a real new line between (within the code)
+> bar'; // a real new line between (within the code -- method 2)
 > d = 'Hello, I''m foo.'; // string containing a '
 > e = \t'hello'; // string starting with a tab
 > f = 'hello'\t; // string ending with a tab

-Please note that when using print to output a string, gCode will try to recreate the sytax (probably) used to write the string!
-To output a raw string, please be patient, until modules are covered and look here [console]
+Please note that when using print to output a string directly, gCode will not try to recreate the sytax (probably) used to write the string, which it will do if the string is nested in a tuple or somthing else!

 ##3.3. Del statement
-Deleteing vars is simple:
+Deleting vars is simple (the print statement is covered in the next chapter):
 > a = 5;
 > print a; // print 5 (expected)
 > del a; // deletes a
@@ -93,7 +94,7 @@
 #5. Tuples
 Anything in gCode can be merged into a single value. This is how a [Method] is able to return multiple values.
 Tuples are created more often than you might think:
-whenever you have multiple values seperated by ',' (see print statement -- 3.), you are creating a tuple internally.
+whenever you have multiple values seperated by ',' (see print statement -- 4.), you are creating a tuple internally.
 Tuples work both ways: you can merge values into 1 by having too many inputs and you can expand them by having too many outputs:
 > a = 1,2; // too many inputs
 > print a; // this will display as '(1,2)'
@@ -102,19 +103,26 @@
 > print c; // this will display as '2'

 ##5.1. Stacked/Forced Tuples
-Sometimes it isn't possible to create a tuple even if you need 1:
+Sometimes it isn't possible to create a tuple even if you need one:
 You want a tuple containing another tuple.
 This is done by forcing gCode to create a tuple by saying:
 > a = (1,2),3;
 > print a; // this will display as '((true 2) 3)'
 Using brackets you can force gCode to create tuples
-CAUTION: this only works for 2 and more values (for single values this behaves like the normal mathematical brackets):
+CAUTION: this only works for 2 or more values (for single values this behaves like the normal mathematical brackets):
 > a = (1),2;
 > print a; // this will display as '(1 2)'
 Allso be aware of the fact, that because of that same rule: 
 > a = 1,2,3; // this does the same
 > a = (1,2,3); // as this
-NOTE: Creating tuples that only contain 1 value is possible though never really needed.
+NOTE: Creating tuples that only contain 1 value is possible though never really needed:
+> a = Tuple().setLen(1);
+> a[0] = 21; // this caused a crash in v02 (fixed in v03)
+> print a; // prints (21)
+> // working version for v02 and up
+> function toTuple([a]) return a;
+> a = toTuple(1);
+> print a;

 #6. Arrays (ndy)
 Array behave and are created much like tuples. The differences being: 
@@ -152,10 +160,10 @@
 > print 0x0F nshl 4; // inverted binary shift left (0x0F)
 > print 0xF0 shr 4; // binary shift left (0x0F)
 > print 0xF0 nshr 4; // inverted binary shift left (0xF0)
-> print -11; // prefix: range symbol
-> print not 11; // binary invertion (244)
+> print -11; // prefix: range symbol (-11)
+> print not 11; // prefix: binary invertion (244)
 > print @a; // pointer to a
-> print a^; // a being a pointer, src of a
+> print a^; // a being a pointer; src of a
 Note about comparint values:
 Every line in the upcomming code does the same!
 > print 1>=2;

learining gCode modified by griefer@work

griefer@work — Wed, 05 Mar 2014 08:26:46 -0000

--- v44
+++ v45
@@ -469,7 +469,7 @@

 #21. Binary structures
 gCode supports direct coding of binary structures. For this you can use the type [Record]. Inspired by pascal records and known as structures in C, this type can define collections of data.
-#21.1. Defining binary structures
+##21.1. Defining binary structures
 > myStruct = Record();
 > myStruct.x = SInt32; // add a field called x that is a SInt32
 > myStruct.y = SInt32; // ... called y ...
@@ -481,7 +481,7 @@

 The method "lock()" should be called once the record is completely declared. It locks the record definition from being edited again. This should be done to ensure that the record won't change while instances are being used.

-#21.2. Using binary structures
+##21.2. Using binary structures
 After a structure is defined, it can be instanciated like all other types:
 > inst = myStruct();
 > // inst is a 16-bit structure build up out of 2 SInt32s
@@ -489,7 +489,7 @@
 > inst.y = 15i; // set the y field to 15
 > print inst; // prints a big chunk of data containing all information about the structure and instance

-#21.3. Advanced integration
+##21.3. Advanced integration
 Records can not only be used to store data. You can add methods to them:
 > myStruct2 = Record();
 > myStruct2.x = SInt32;

learining gCode modified by griefer@work

griefer@work — Wed, 05 Mar 2014 08:26:11 -0000

--- v43
+++ v44
@@ -467,5 +467,67 @@
 Though this isn't necessarily a problem, you should NEVER create global pointers pointing to local vars!
 Just allways keep your pointers in a higher or the same [stack frame] than their destination.

-
-
+#21. Binary structures
+gCode supports direct coding of binary structures. For this you can use the type [Record]. Inspired by pascal records and known as structures in C, this type can define collections of data.
+#21.1. Defining binary structures
+> myStruct = Record();
+> myStruct.x = SInt32; // add a field called x that is a SInt32
+> myStruct.y = SInt32; // ... called y ...
+> myStruct.lock();
+
+NOTE: prior to v02, to add a field you would have to use this code:
+> // this still works, but is deprecated and may be dropped at some point
+> myStruct.addField('x',SInt32);
+
+The method "lock()" should be called once the record is completely declared. It locks the record definition from being edited again. This should be done to ensure that the record won't change while instances are being used.
+
+#21.2. Using binary structures
+After a structure is defined, it can be instanciated like all other types:
+> inst = myStruct();
+> // inst is a 16-bit structure build up out of 2 SInt32s
+> inst.x = 21i; // set the x field to 21
+> inst.y = 15i; // set the y field to 15
+> print inst; // prints a big chunk of data containing all information about the structure and instance
+
+#21.3. Advanced integration
+Records can not only be used to store data. You can add methods to them:
+> myStruct2 = Record();
+> myStruct2.x = SInt32;
+> myStruct2.y = SInt32;
+> myStruct2.sum = function(self) return self.x+self.y; // sum adds x and y together
+> myStruct2.lock();
+> inst = myStruct2()
+> inst.x = 9i;
+> inst.y = 11i;
+> print inst.sum(); // prints 20
+
+NOTE: prior to v02, to add a method you would have to use this code:
+> // this still works, but is deprecated and may be dropped at some point
+> myStruct2.addMethod('sum',function(self) return self.x+self.y);
+
+!new in v02! Using this method system, you can allso overwrite internal events:
+> myStruct3 = Record();
+> myStruct3.x = SInt32;
+> myStruct3.y = SInt32;
+> myStruct3.\_\_init\_\_ = function(self) print 'myStruct3 instance created';
+> myStruct3.\_\_del\_\_ = function(self) print 'myStruct3 instance deleted';
+> myStruct3.lock();
+> inst = myStruct3(); // \_\_init\_\_ is called in this
+> del inst; // \_\_del\_\_ is called in this
+
+Here is a list of all events, call conditions, params and expected return values
+
+Method name | call condition | params | expected return value | desc
+----------- | -------------- | ------ | --------------------- | ----
+\_\_init\_\_    | called when an instance is created | (instance) | - | could be used to specify default values a record should be created with or create custom data
+\_\_del\_\_     | called when an instance is deleted | (instance) | - | could be used to drop custom data 
+\_\_getItem\_\_ | inst\[loc\] | (instance,loc) | item at loc | could be used to create a pseudo array
+\_\_setItem\_\_ | inst\[loc\] = value | (instance,loc,value) | - | could be used to create a pseudo array
+\_\_getSlice\_\_| inst\[loc\] | (instance,loc) | slice from loc.left to loc.right | only called, if loc is a slice (\_\_getItem\_\_ is called otherwise)
+\_\_setSlice\_\_| inst\[loc\] = value | (instance,loc,value) | - | only called, if loc is a slice (\_\_setItem\_\_ is called otherwise)
+\_\_in\_\_      | value in inst | (instance,value) | boolean | returns if value is in inst
+\_\_hi\_\_      | hi#inst | (instance) | highest array index | should return the highest values that can be used in \_\_getItem\_\_ or \_\_setItem\_\_
+\_\_lo\_\_      | lo#inst | (instance) | lowest array index | should return the lowest value that can be used in \_\_getItem\_\_ or \_\_setItem\_\_
+\_\_len\_\_     | #inst | (instance) | amount of array indices | should return the amount of values that can be used in \_\_getItem\_\_ or \_\_setItem\_\_ (usually abs(hi#inst-lo#inst)+1)
+
+HINT: for a good example use of all the features of records, see "File" in module "fs"

learining gCode modified by griefer@work

griefer@work — Wed, 19 Feb 2014 18:54:00 -0000

--- v42
+++ v43
@@ -176,7 +176,7 @@
 [UInt1]  |  1   |        |   u1    | 0:1   | allso known as boolean |     yes 
 [UInt8]  |  1   |        |   u8,b  | 0:255 | allso known as byte    | yes 
 [UInt16] |  2   |        |  u16,w  | 0:65535 | allso known as word  | yes 
-[UInt32] |  4   |        | u32,lw,!new in v02!c  | 0:4294967295 | allso known as longword | yes 
+[UInt32] |  4   |        | u32,lw,
!new in v02!: c  | 0:4294967295 | allso known as longword | yes 
 [UInt64] |  8   |        |   u64   | 0:18446744073709551615 | | yes 
 [SInt8]  |  1   |        |  s8,sh  | -128:127 | allso known as shortInt | yes 
 [SInt16] |  2   |        | s16,sm  | -32768:32767 | allso known as smallInt | yes

learining gCode modified by griefer@work

griefer@work — Wed, 19 Feb 2014 18:53:19 -0000

--- v41
+++ v42
@@ -176,7 +176,7 @@
 [UInt1]  |  1   |        |   u1    | 0:1   | allso known as boolean |     yes 
 [UInt8]  |  1   |        |   u8,b  | 0:255 | allso known as byte    | yes 
 [UInt16] |  2   |        |  u16,w  | 0:65535 | allso known as word  | yes 
-[UInt32] |  4   |        | u32,lw  | 0:4294967295 | allso known as longword | yes 
+[UInt32] |  4   |        | u32,lw,!new in v02!c  | 0:4294967295 | allso known as longword | yes 
 [UInt64] |  8   |        |   u64   | 0:18446744073709551615 | | yes 
 [SInt8]  |  1   |        |  s8,sh  | -128:127 | allso known as shortInt | yes 
 [SInt16] |  2   |        | s16,sm  | -32768:32767 | allso known as smallInt | yes

learining gCode modified by griefer@work

griefer@work — Sat, 15 Feb 2014 20:13:05 -0000

--- v40
+++ v41
@@ -456,8 +456,8 @@

 ##20.5. Helper methods
  * addr -- [standart methods] -- addr returns the address of an object in ram.
- * !nyd! newMem -- [standart methods] -- newMem can be used to manually allocate RAM of a custom size/pos
- * !nyd! freeMem -- [standart methods] -- freeMem can be used to manually deallocate RAM of a custom size/pos
+ * !new in v02! newMem -- [standart methods] -- newMem can be used to manually allocate RAM of a custom size/pos
+ * !new in v02! freeMem -- [standart methods] -- freeMem can be used to manually deallocate RAM of a custom size/pos

 ##20.6. Risks
 The gCode var-management system (see [under the hood]) is designed to automatically and instantly unload anything thats no longer used anywhere.

learining gCode modified by griefer@work

griefer@work — Fri, 14 Feb 2014 08:36:37 -0000

--- v39
+++ v40
@@ -398,10 +398,10 @@
 NOTE: Slices do not cache all the values inbetween. Those are calculated as you request them
 NOTE2: In the future Slices will be a to retrieve multiple values from a seqence

-#18. Default fields
-Whenever an instance of gCode is started, you will start out with a bunch of default fields. These fields don't have to be imported manually but are there by default.
-Though you can overwrite and modify them, that is not recommended, because it may break code.
-For a list and description of all default fields see here [default fields].
+#18. Default Methods
+Whenever an instance of gCode is started, you will start out with a bunch of default methods. These methods don't have to be imported manually but are included by default.
+Though you can overwrite and modify them, that is not recommended, because it may break your code.
+For a list and description of all default fields see here [standart methods].

 #19. Modules
 To seperate merge and dynamically use code, gCode comes equipped with a Modules System.

learining gCode modified by griefer@work

griefer@work — Fri, 14 Feb 2014 08:35:27 -0000

--- v38
+++ v39
@@ -47,6 +47,16 @@
 > d <-- 4;
 > 5 -> e;
 > 6 --> f;
+
+###3.1.1. modifying var assignment
+NOTE: these actions can be performed inline (they returm the new value of the var being modified)
+> a = 21;
+> a += 19; // a is now 40
+> a -= 20; // a is now 20
+> a *= 4;  // a is now 80
+> a /= 3;  // a is now 26 (this value was truncated because a is not a floating point number)
+> a ^= 2;  // a is now 164
+
 ##3.2. Assigning Strings
 Strings are allways toggled on and off by using "'". In order to write a "'" you just write "''". In order to add special characters, you end the string, write \\ and either 'n','r','t' or the hexadecimal code of the char in the current context (Unicode/Ansi).
 NOTE: Strings are multi-line structures
@@ -62,14 +72,17 @@
 Please note that when using print to output a string, gCode will try to recreate the sytax (probably) used to write the string!
 To output a raw string, please be patient, until modules are covered and look here [console]

-###3.1.1. modifying var assignment
-NOTE: these actions can be performed inline (they returm the new value of the var being modified)
-> a = 21;
-> a += 19; // a is now 40
-> a -= 20; // a is now 20
-> a *= 4;  // a is now 80
-> a /= 3;  // a is now 26 (this value was truncated because a is not a floating point number)
-> a ^= 2;  // a is now 164
+##3.3. Del statement
+Deleteing vars is simple:
+> a = 5;
+> print a; // print 5 (expected)
+> del a; // deletes a
+> print a; // var not found exception here (for exception: see below)
+
+You can allso delete multiple vars at once:
+> a,b = 1,5;
+> del a,b;
+> print a,b; // the same exception

 #4. Print statement
 Anything in gCode can be displayed as a [String].
@@ -385,7 +398,27 @@
 NOTE: Slices do not cache all the values inbetween. Those are calculated as you request them
 NOTE2: In the future Slices will be a to retrieve multiple values from a seqence

-#18. Pointers
+#18. Default fields
+Whenever an instance of gCode is started, you will start out with a bunch of default fields. These fields don't have to be imported manually but are there by default.
+Though you can overwrite and modify them, that is not recommended, because it may break code.
+For a list and description of all default fields see here [default fields].
+
+#19. Modules
+To seperate merge and dynamically use code, gCode comes equipped with a Modules System.
+A modules is considered to be a single file located in any on the lib folders (see [libs.ini]).
+Modules and parts of modules can be imported at any time using the include statement.
+##19.1. Include Statement
+> include math; // this includes the math modules. After this it is accessible by typing math.\*field\*
+> include pi from math; // this only include the field pi from math. After this is is accessible as pi
+> include pi from math as myPi; // does the same but pi is now accessible as myPi
+> include \* from math; // includes every field from math. these fields are accessible by typing their original name
+
+For more info on what the \* does, visit [formatted string match].
+Usage example:
+> include random from math as rand;
+> print rand(); // print a random extended in the range 0:1
+
+#20. Pointers
 I won't go over what a Pointer is in here. What I will go over is:
  * Binary, custom data interpretation
  * Creating a pointer
@@ -394,7 +427,7 @@
  * Helper methods
  * Risks

-##18.1. Binary, custom data interpretation
+##20.1. Binary, custom data interpretation
 You can Interpret anything in gCode in any way on a binary level by calling the type you wan't to 
 interpret an object as with the object as parameter.
 > a = -100;
@@ -402,11 +435,11 @@

 Hint: if you want to convert a value to a different type, goto the types page and look through its attributes

-##18.2. Creating a pointer
+##20.2. Creating a pointer
 Pointers are created by using the '@' operator (see operators above)
 > b = @a; // b is now a pointer to a

-##18.3. Getting the source of a pointer
+##20.3. Getting the source of a pointer
 Pointer sources are accessed by the '^' operator (see operators aboce)
 > c = b^; // c is not an untyped piece of data located at the source of b

@@ -416,17 +449,17 @@
 > c = type(a)(b^); // c is a fully typed var (of the same type as a) with the same data address as a
 > // NOTE: c does know, that it does not own the data it points to, and thereby will not try to do so

-##18.4. Creating custom data structures
+##20.4. Creating custom data structures
 Call the type you want to have a structor of without any parameters:
 > a = SInt8(); // a is now an empty hull for a SInt8
 To design your own data structure: see [Record] and the tutorial below

-##18.5. Helper methods
+##20.5. Helper methods
  * addr -- [standart methods] -- addr returns the address of an object in ram.
  * !nyd! newMem -- [standart methods] -- newMem can be used to manually allocate RAM of a custom size/pos
  * !nyd! freeMem -- [standart methods] -- freeMem can be used to manually deallocate RAM of a custom size/pos

-##18.6. Risks
+##20.6. Risks
 The gCode var-management system (see [under the hood]) is designed to automatically and instantly unload anything thats no longer used anywhere.
 Pointers are very natural and are not designed, to fit in with that system.
 That can lead to pointers pointing to vars that are no longer loaded.

learining gCode modified by griefer@work

griefer@work — Wed, 12 Feb 2014 13:45:43 -0000

--- v37
+++ v38
@@ -103,7 +103,7 @@
 > a = (1,2,3); // as this
 NOTE: Creating tuples that only contain 1 value is possible though never really needed.

-#6. Array (ndy)
+#6. Arrays (ndy)
 Array behave and are created much like tuples. The differences being: 
  * arrays use '[' and ']' in for their creation.
  * arrays cannot be split open by having to many outputs
@@ -321,6 +321,14 @@
 > print sum(1,2); // prints 3
 > print sum(3,4,5); // prints 12
 > print sum(6,7,8,9); // prints 30
+##14.2. Inline methods
+You can allso define methods inline by just leaving out the name:
+> foo,bar = 
+>> function() begin print 'foo'; return 1; end,
+>> function(): result begin print 'bar'; result = 2; end;
+
+> print foo(); // prints 'foo' and 1
+> print bar(); // prints 'bar' and 2

 #15. Attributes
 Anything in gCode can have attributes. Oftenly attributes are helper methods of sub-components.

learining gCode modified by griefer@work

griefer@work — Wed, 12 Feb 2014 13:28:02 -0000

--- v36
+++ v37
@@ -48,7 +48,7 @@
 > 5 -> e;
 > 6 --> f;
 ##3.2. Assigning Strings
-Strings are allways toggled on and off by using "'". In order to write a "'" you just write "''". In order to add special characters, you end the string, write "\\" and either a 'n','r','0','t' or the hexadecimal representation of the char.
+Strings are allways toggled on and off by using "'". In order to write a "'" you just write "''". In order to add special characters, you end the string, write \\ and either 'n','r','t' or the hexadecimal code of the char in the current context (Unicode/Ansi).
 NOTE: Strings are multi-line structures
 Example:
 > a = 'foobar'; // easy