Add named INT and FLT (closes #198).

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -94,7 +94,9 @@
 
 A symbol MAY be declared without a value using `TYPE name`. Such a declaration records the symbol's static type but does not create a readable runtime binding until an assignment occurs. The type and name MUST be separated by one or more space characters, and no other character MAY appear between them.
 
-The first assignment to a symbol MUST use a typed form such as `TYPE name = expression`, with one or more spaces between the type and name and optional spaces around `=`. Subsequent assignments MAY omit the type annotation, but the symbol's type MUST remain unchanged for the lifetime of that name, including after deletion and re-assignment.
+For `INT` and `FLT` types, a declaration MAY name a specific numeric base by writing `TYPE{base} name`, where `base` is an `INT` literal in the range `2` through `64`. A named-base type is a subtype of its parent numeric type: `INT{base}` values are `INT`s and `FLT{base}` values are `FLT`s, but an assignment to a named-base binding requires the value's base to match the declared base. The parent types `INT` and `FLT` (equivalent to `INT{0}` and `FLT{0}`) accept values of any valid numeric base.
+
+The first assignment to a symbol MUST use a typed form such as `TYPE name = expression` or `TYPE{base} name = expression`, with one or more spaces between the type annotation and the name and optional spaces around `=`. Subsequent assignments MAY omit the type annotation, but the symbol's type MUST remain unchanged for the lifetime of that name, including after deletion and re-assignment.
 
 Assignments to undeclared identifiers without a type annotation MUST raise a runtime error. A binding MUST remain allocated until it is deleted with `DEL("name")`.
 
@@ -172,6 +174,8 @@
 
 Prefix MUST support eight types: `BOOL` (booleans), `STR` (strings), `INT` (integers), `FLT` (floating-point numbers), `TNS` (tensors), `MAP` (maps), `FUNC` (functions), and `THR` (threads). The type of a symbol is determined when it is first declared, and cannot be changed, even after deletion of the original symbol.
 
+`INT` and `FLT` additionally support named-base variants written `INT{base}` and `FLT{base}`, where `base` is a numeric base in the range `2` through `64` or `0` to denote the parent type. A named-base type and its parent are the same runtime type, but static type checking treats mismatched bases as incompatible. `INT` and `FLT` (base `0`) accept any valid numeric base; `INT{base}` and `FLT{base}` only accept values whose stored base equals the declared base.
+
 ---
 
 ### 4.0 Booleans
@@ -432,6 +436,8 @@
 
 A declaration MUST record the symbol's static type without necessarily creating a readable runtime value. A readable binding is created only when a value is first assigned. In all type annotations, the type and name MUST be separated by one or more space characters, and other characters MUST NOT appear between them.
 
+`INT` and `FLT` type annotations MAY include a base specifier written immediately after the type name with no intervening whitespace, in the form `INT{base}` or `FLT{base}`. The `{base}` suffix is part of the type annotation and therefore MUST appear before the required space that separates the type from the declared name. For example, `INT{0d2} value` declares a binary integer, while `FLT{0x} value` declares a hexadecimal float. A base of `0` (typically written as the bare type name) denotes the parent type and accepts any valid numeric base.
+
 Reading an undeclared symbol, a declared-but-never-assigned symbol, or a deleted symbol MUST raise a runtime error. Removing a binding MUST preserve its recorded static type, so any later re-assignment to the same name MUST still match the original type.
 
 Re-assignment MUST preserve the declared type for the lifetime of the symbol, including after deletion and re-creation. Symbol existence, lifetime, and mutability MAY be inspected or modified only through the language's dedicated symbol-management facilities.

src/ast.c

@@ -61,12 +61,13 @@ Expr *expr_ident(char *name, int line, int column) {
     return expr;
 }
 
-Expr *expr_typed_ident(DeclType decl_type, char *name, int line, int column) {
+Expr *expr_typed_ident(DeclType decl_type, int decl_base, char *name, int line, int column) {
     Expr *expr = ast_alloc(sizeof(Expr));
     expr->type = EXPR_TYPED_IDENT;
     expr->line = line;
     expr->column = column;
     expr->as.typed_ident.decl_type = decl_type;
+    expr->as.typed_ident.decl_base = decl_base;
     expr->as.typed_ident.name = name;
     return expr;
 }
@@ -145,13 +146,14 @@ Expr *expr_wildcard(int line, int column) {
     return expr;
 }
 
-Expr *expr_lambda(ParamList params, DeclType return_type, Stmt *body, int line, int column) {
+Expr *expr_lambda(ParamList params, DeclType return_type, int return_base, Stmt *body, int line, int column) {
     Expr *expr = ast_alloc(sizeof(Expr));
     expr->type = EXPR_LAMBDA;
     expr->line = line;
     expr->column = column;
     expr->as.lambda.params = params;
     expr->as.lambda.return_type = return_type;
+    expr->as.lambda.return_base = return_base;
     expr->as.lambda.body = body;
     return expr;
 }
@@ -221,25 +223,28 @@ Stmt *stmt_expr(Expr *expr, int line, int column) {
     return stmt;
 }
 
-Stmt *stmt_assign(bool has_type, DeclType decl_type, char *name, Expr *target, Expr *value, int line, int column) {
+Stmt *stmt_assign(bool has_type, DeclType decl_type, int decl_base, char *name, Expr *target, Expr *value, int line,
+                  int column) {
     Stmt *stmt = ast_alloc(sizeof(Stmt));
     stmt->type = STMT_ASSIGN;
     stmt->line = line;
     stmt->column = column;
     stmt->as.assign.has_type = has_type;
     stmt->as.assign.decl_type = decl_type;
+    stmt->as.assign.decl_base = decl_base;
     stmt->as.assign.name = name;
     stmt->as.assign.target = target;
     stmt->as.assign.value = value;
     return stmt;
 }
 
-Stmt *stmt_decl(DeclType decl_type, char *name, int line, int column) {
+Stmt *stmt_decl(DeclType decl_type, int decl_base, char *name, int line, int column) {
     Stmt *stmt = ast_alloc(sizeof(Stmt));
     stmt->type = STMT_DECL;
     stmt->line = line;
     stmt->column = column;
     stmt->as.decl.decl_type = decl_type;
+    stmt->as.decl.decl_base = decl_base;
     stmt->as.decl.name = name;
     return stmt;
 }
@@ -286,13 +291,14 @@ Stmt *stmt_parfor(char *counter, Expr *target, Stmt *body, int line, int column)
     return stmt;
 }
 
-Stmt *stmt_func(char *name, DeclType ret, Stmt *body, int line, int column) {
+Stmt *stmt_func(char *name, DeclType ret, int return_base, Stmt *body, int line, int column) {
     Stmt *stmt = ast_alloc(sizeof(Stmt));
     stmt->type = STMT_FUNC;
     stmt->line = line;
     stmt->column = column;
     stmt->as.func_stmt.name = name;
     stmt->as.func_stmt.return_type = ret;
+    stmt->as.func_stmt.return_base = return_base;
     stmt->as.func_stmt.body = body;
     return stmt;
 }

src/ast.h

@@ -20,6 +20,7 @@ typedef struct Stmt Stmt;
 
 typedef struct Param {
     DeclType type;
+    int num_base; // 0 = parent INT/FLT, 2..64 = named base
     char *name;
     bool coerced;
     Expr *default_value; // optional
@@ -74,12 +75,9 @@ struct Expr {
         char *ident;
         struct {
             DeclType decl_type;
+            int decl_base; // 0 = parent INT/FLT, 2..64 = named base
             char *name;
         } typed_ident;
-        char *ptr_name;
-        struct {
-            Stmt *block;
-        } async;
         struct {
             Expr *callee;
             ExprList args;
@@ -88,25 +86,30 @@ struct Expr {
             size_t kw_count;
             size_t kw_capacity;
         } call;
+        struct {
+            Stmt *block;
+        } async;
+        struct {
+            ParamList params;
+            DeclType return_type;
+            int return_base; // 0 = parent INT/FLT, 2..64 = named base
+            Stmt *body;
+        } lambda;
+        ExprList tns_items;
+        struct {
+            ExprList keys;
+            ExprList values;
+        } map_items;
         struct {
             Expr *target;
             ExprList indices;
-            bool is_map; /* true if angle-bracket indexing '<...>' was used */
+            bool is_map;
         } index;
         struct {
             Expr *start;
             Expr *end;
         } range;
-        struct {
-            ExprList keys;
-            ExprList values;
-        } map_items;
-        struct {
-            ParamList params;
-            DeclType return_type;
-            Stmt *body;
-        } lambda;
-        ExprList tns_items;
+        char *ptr_name;
     } as;
 };
 
@@ -150,12 +153,14 @@ struct Stmt {
         struct {
             bool has_type;
             DeclType decl_type;
+            int decl_base; // 0 = parent INT/FLT, 2..64 = named base
             char *name;
             Expr *target;
             Expr *value;
         } assign;
         struct {
             DeclType decl_type;
+            int decl_base; // 0 = parent INT/FLT, 2..64 = named base
             char *name;
         } decl;
         struct {
@@ -183,6 +188,7 @@ struct Stmt {
             char *name;
             ParamList params;
             DeclType return_type;
+            int return_base; // 0 = parent INT/FLT, 2..64 = named base
             Stmt *body;
         } func_stmt;
         struct {
@@ -221,7 +227,7 @@ Expr *expr_flt(double value, int base, int base_is_nan, int line, int column);
 Expr *expr_str(char *value, int line, int column);
 Expr *expr_ptr(char *name, int line, int column);
 Expr *expr_ident(char *name, int line, int column);
-Expr *expr_typed_ident(DeclType decl_type, char *name, int line, int column);
+Expr *expr_typed_ident(DeclType decl_type, int decl_base, char *name, int line, int column);
 Expr *expr_call(Expr *callee, int line, int column);
 void call_kw_add(Expr *call, char *name, Expr *value);
 Expr *expr_tns(int line, int column);
@@ -230,19 +236,20 @@ Expr *expr_map(int line, int column);
 Expr *expr_index(Expr *target, int line, int column, bool is_map);
 Expr *expr_range(Expr *start, Expr *end, int line, int column);
 Expr *expr_wildcard(int line, int column);
-Expr *expr_lambda(ParamList params, DeclType return_type, Stmt *body, int line, int column);
+Expr *expr_lambda(ParamList params, DeclType return_type, int return_base, Stmt *body, int line, int column);
 void expr_list_add(ExprList *list, Expr *expr);
 
 Stmt *stmt_block(int line, int column);
 Stmt *stmt_async(Stmt *body, int line, int column);
 Stmt *stmt_expr(Expr *expr, int line, int column);
-Stmt *stmt_assign(bool has_type, DeclType decl_type, char *name, Expr *target, Expr *value, int line, int column);
-Stmt *stmt_decl(DeclType decl_type, char *name, int line, int column);
+Stmt *stmt_assign(bool has_type, DeclType decl_type, int decl_base, char *name, Expr *target, Expr *value, int line,
+                  int column);
+Stmt *stmt_decl(DeclType decl_type, int decl_base, char *name, int line, int column);
 Stmt *stmt_if(Expr *cond, Stmt *then_branch, int line, int column);
 Stmt *stmt_while(Expr *cond, Stmt *body, int line, int column);
 Stmt *stmt_for(char *counter, Expr *target, Stmt *body, int line, int column);
 Stmt *stmt_parfor(char *counter, Expr *target, Stmt *body, int line, int column);
-Stmt *stmt_func(char *name, DeclType ret, Stmt *body, int line, int column);
+Stmt *stmt_func(char *name, DeclType ret, int return_base, Stmt *body, int line, int column);
 Stmt *stmt_return(Expr *value, int line, int column);
 Stmt *stmt_pop(Expr *expr, int line, int column);
 Stmt *stmt_break(Expr *value, int line, int column);