Initial commit

QUICKREF.md

@@ -0,0 +1,332 @@
+# Common Language Quick Reference
+
+## Compilation
+
+```bash
+./common source.cm output.asm
+nasm -f elf32 output.asm -o output.o
+gcc -m32 output.o -o program
+```
+
+## Types
+
+```c
+void                          // No return value
+int8   int16   int32   int64  // Signed integers
+uint8  uint16  uint32  uint64 // Unsigned integers
+type*                         // Pointer to type
+type[N]                       // Array of N elements
+```
+
+## Variables
+
+```c
+int32 x;                      // Declaration
+int32 y = 42;                 // Initialization
+int32 arr[10];                // Array
+int32 nums[3] = {1, 2, 3};   // Array with initializer
+int32 *ptr;                   // Pointer
+```
+
+## Operators
+
+### Arithmetic
+```c
++  -  *  /  %                 // Add, Sub, Mul, Div, Mod
+```
+
+### Comparison
+```c
+==  !=  <  <=  >  >=          // Equal, Not-equal, Less, etc.
+```
+
+### Logical
+```c
+&&  ||  !                     // AND, OR, NOT (short-circuit)
+```
+
+### Bitwise
+```c
+&   |   ^   ~                 // AND, OR, XOR, NOT
+<<  >>                        // Left shift, Right shift
+```
+
+### Assignment
+```c
+=   +=  -=  *=  /=  %=        // Assign, Add-assign, etc.
+&=  |=  ^=  <<=  >>=          // Bitwise assign ops
+```
+
+### Increment/Decrement
+```c
+++  --                        // Increment, Decrement (pre/post)
+```
+
+### Pointer/Array
+```c
+&x                            // Address of x
+*ptr                          // Dereference ptr
+arr[i]                        // Array index (same as *(arr+i))
+```
+
+### Ternary
+```c
+cond ? true_val : false_val   // Conditional expression
+```
+
+## Control Flow
+
+### If-Else
+```c
+if (condition)
+    statement;
+    
+if (condition) {
+    statements;
+} else {
+    statements;
+}
+```
+
+### While Loop
+```c
+while (condition) {
+    statements;
+}
+```
+
+### For Loop
+```c
+for (int32 i = 0; i < n; i++) {
+    statements;
+}
+```
+
+### Switch
+```c
+switch (expr) {
+    case 1:
+        statements;
+        break;
+    case 2:
+        statements;
+        break;
+    default:
+        statements;
+}
+```
+
+### Break/Continue/Return
+```c
+break;                        // Exit loop or switch
+continue;                     // Next loop iteration
+return;                       // Return from void function
+return expr;                  // Return value
+```
+
+## Functions
+
+### Declaration
+```c
+int32 add(int32 a, int32 b);  // Forward declaration
+```
+
+### Definition
+```c
+int32 add(int32 a, int32 b) {
+    return a + b;
+}
+```
+
+### No Parameters
+```c
+void func(void) {
+    // ...
+}
+```
+
+### Main Function
+```c
+int32 main(void) {
+    // Entry point
+    return 0;
+}
+```
+
+## Pointers
+
+```c
+int32 x = 42;
+int32 *p = &x;                // p points to x
+*p = 100;                     // Set x to 100 via pointer
+int32 y = *p;                 // Read through pointer
+```
+
+## Arrays
+
+```c
+int32 arr[5];                 // Declare
+arr[0] = 10;                  // Set element
+int32 x = arr[2];             // Get element
+
+// Array initialization
+int32 nums[5] = {1, 2, 3, 4, 5};
+
+// Arrays decay to pointers
+int32 *p = arr;               // p points to arr[0]
+```
+
+## Strings
+
+```c
+uint8 *str = "Hello";         // String literal
+printf("%s\n", str);          // Print string
+
+// String as array
+uint8 msg[] = "Hello";
+msg[0] = 'h';                 // Modify
+```
+
+## Comments
+
+```c
+// Single-line comment
+
+/* Multi-line
+   comment */
+```
+
+## Type Casting
+
+```c
+(type)expression              // Cast to type
+
+int32 x = 1000;
+uint8 y = (uint8)x;           // Truncate to 8 bits
+
+uint8 *s = (uint8*)"string";  // Pointer cast
+```
+
+## Common Patterns
+
+### Swap
+```c
+void swap(int32 *a, int32 *b) {
+    int32 temp = *a;
+    *a = *b;
+    *b = temp;
+}
+```
+
+### String Length
+```c
+int32 strlen(uint8 *s) {
+    int32 len = 0;
+    while (s[len]) len++;
+    return len;
+}
+```
+
+### Array Sum
+```c
+int32 sum(int32 *arr, int32 n) {
+    int32 total = 0;
+    for (int32 i = 0; i < n; i++)
+        total += arr[i];
+    return total;
+}
+```
+
+### Min/Max
+```c
+int32 min(int32 a, int32 b) {
+    return (a < b) ? a : b;
+}
+
+int32 max(int32 a, int32 b) {
+    return (a > b) ? a : b;
+}
+```
+
+## Calling C Functions
+
+```c
+// Declare before use
+void printf(uint8 *fmt, ...);
+void *malloc(uint32 size);
+void free(void *ptr);
+
+// Use
+printf("Value: %d\n", x);
+void *mem = malloc(100);
+free(mem);
+```
+
+## Operator Precedence (High to Low)
+
+1. `()` `[]` `.` `->`
+2. `!` `~` `++` `--` `+` `-` `*` `&` (unary) `(cast)`
+3. `*` `/` `%`
+4. `+` `-`
+5. `<<` `>>`
+6. `<` `<=` `>` `>=`
+7. `==` `!=`
+8. `&`
+9. `^`
+10. `|`
+11. `&&`
+12. `||`
+13. `?:`
+14. `=` `+=` `-=` etc.
+
+## Limitations
+
+- No structs/unions (use arrays)
+- No enums (use int32 constants)
+- No floats (integers only)
+- No preprocessor (#define, #include)
+- Single file compilation only
+- 1D arrays only (simulate 2D: `arr[row*width+col]`)
+- No goto
+- No static/extern keywords
+- 64-bit types partially supported
+
+## Common Gotchas
+
+```c
+// Assignment vs. Equality
+if (x = 5)   // WRONG: assigns 5 to x
+if (x == 5)  // RIGHT: compares x to 5
+
+// Array indexing
+int32 arr[10];
+arr[10] = 0;  // WRONG: out of bounds
+arr[9] = 0;   // RIGHT: last element
+
+// Pointer arithmetic scales by type size
+int32 *p = arr;
+p + 1;        // Points 4 bytes ahead (size of int32)
+
+// Semicolons required
+if (x > 0)
+    y = 1     // WRONG: missing semicolon
+    
+if (x > 0)
+    y = 1;    // RIGHT
+```
+
+## Error Messages
+
+```
+line N: syntax error near 'token'
+line N: Unknown char 'X'
+line N: expected expression
+line N: too many locals/globals/strings
+```
+
+Check:
+- Missing semicolons
+- Mismatched braces/parentheses
+- Undeclared variables
+- Type mismatches
+- Buffer limits exceeded