Support bitfield declarations in BASIC

Author: totalspectrum

doc/basic.md

@@ -1539,6 +1539,16 @@ Using Spin objects with `class using` is straightforward, but there are some thi
   * Spin does not have any notion of types, so most Spin functions will return type `any` and take parameters of type `any`. This can cause problems if you expect them to return something special like a pointer or float and want to use them in the middle of an expression. You can either use explicit `cast` operations, or assign the results of Spin methods to a typed variable, and then use that variable in the expression instead.
   * Spin treats strings differently than BASIC does. For example, in the Spin expression `ser.tx("A")`, `"A"` is an integer (a single element list). That would be written in BASIC as `ser.tx(asc("A"))`. Conversely, in Spin you have to write `ser.str(string("hello"))` where in BASIC you would write just `ser.str("hello")`.
 
+#### Bitfields in classes
+
+FlexBasic supports the FreeBasic syntax for declaring bitfields, which is similar to C syntax. For example, to declare a class with a 3 bit unsigned field `x` and a 4 bit signed field `y` do:
+```
+class bfield
+  x:3 as uinteger
+  y:4 as integer
+end class
+```
+
 #### Interoperation with C
 
 C files may be used as classes, but there are some restrictions. BASIC and Spin are both case insensitive languages, which means that the BASIC symbols `AVariable`, `avariable`, and `AVARIABLE` are all the same, and all are translated internally to `avariable`. In C the case of identifiers matters. This makes accessing C symbols from BASIC somewhat tricky: one must exactly match the case of the C identifier in order to access it.

expr.c

@@ -3272,6 +3272,11 @@ ExprTypeRelative(SymbolTable *table, AST *expr, Module *P)
                 return typ;
             }
             return ExprTypeRelative(&subclass->objsyms, (AST *)sym->v.ptr, P);
+        case SYM_TEMPLATE:
+        {
+            /* HACK: we need to ignore this in some cases */
+            return NULL;
+        }
         case SYM_LABEL:
         {
             Label *lref = (Label *)sym->v.ptr;

frontends/basic/basic.y

@@ -221,6 +221,7 @@ DeclareBASICMemberVariables(AST *ast)
     AST *idlist, *typ;
     AST *ident;
     int is_private = 0;
+    BitFieldState bitfield = { 0 };
 
     if (!ast) return;
     if (ast->kind == AST_SEQUENCE) {
@@ -253,11 +254,11 @@ DeclareBASICMemberVariables(AST *ast)
                 bittyp = NewAST(AST_BITFIELD, typ, ident->right);
                 ident = ident->left;
             }
-            MaybeDeclareMemberVar(current, ident, bittyp, is_private, NORMAL_VAR, NULL);
+            MaybeDeclareMemberVar(current, ident, bittyp, is_private, NORMAL_VAR, &bitfield);
             idlist = idlist->right;
         }
     } else {
-        MaybeDeclareMemberVar(current, idlist, typ, is_private, NORMAL_VAR, NULL);
+        MaybeDeclareMemberVar(current, idlist, typ, is_private, NORMAL_VAR, &bitfield);
     }
     return;
 }

frontends/basic/basiclang.c

@@ -905,6 +905,17 @@ doBasicTransform(AST **astptr, bool transformFuncall)
         }
         doBasicTransform(&ast->left, transformFuncall);
         doBasicTransform(&ast->right, transformFuncall);
+#if 1
+        // this seems pretty hacky but is needed to make new
+        // struct bitfields work; note that the similar test above
+        // is for older style bitfields like output(1) = ...
+        if (ast->left && ast->left->kind == AST_CAST && ast->left->right && ast->left->right->kind == AST_RANGEREF) {
+            ast->left = ast->left->right;
+        }
+        if (ast->left && ast->left->kind == AST_RANGEREF) {
+            *astptr = ast = TransformRangeAssign(ast->left, ast->right, ast->d.ival, 1);
+        }
+#endif        
         break;
     case AST_CASE:
     case AST_CASETABLE:
@@ -998,7 +1009,16 @@ doBasicTransform(AST **astptr, bool transformFuncall)
         doBasicTransform(&ast->left, transformFuncall);
         doBasicTransform(&ast->right, transformFuncall);
         {
-            AST *typ = ExprType(ast->left);
+            AST *typ = ExprType(ast);
+            if (typ && typ->kind == AST_USING) {
+                AST *replace = DupAST(typ->left);
+                if (replace && replace->right && replace->right->kind == AST_RANGEREF) {
+                    ast->right = replace->right->left;
+                    replace->right->left = DupAST(ast);
+                }
+                *ast = *replace;
+            }
+            typ = ExprType(ast->left);
             if (IsPointerType(typ) && !IsRefType(typ)) {
                 // WARNING(ast, "Needs a pointer dereference");
                 ast->left = NewAST(AST_ARRAYREF, ast->left, AstInteger(0));