feat: Add support for bitwise attribute for strong typedefs.

The `sparse` tool can validate these.

src/Language/Cimple/Ast.hs

@@ -102,6 +102,8 @@ data NodeF lexeme a
     | Struct lexeme [a]
     | Union lexeme [a]
     | MemberDecl a (Maybe lexeme)
+    | TyBitwise a
+    | TyForce a
     | TyConst a
     | TyPointer a
     | TyStruct lexeme

src/Language/Cimple/DescribeAst.hs

@@ -147,10 +147,10 @@ describeExpected options
     | wants ["break", "const", "continue", "ID_CONST", "VLA"] = "statement or declaration"
     | wants ["ID_FUNC_TYPE", "non_null", "static", "'#include'"] = "top-level declaration or definition"
     | options == ["ID_STD_TYPE", "ID_SUE_TYPE", "struct", "void"] = "type specifier"
-    | options == ["ID_STD_TYPE", "ID_SUE_TYPE", "const", "struct", "void"] = "type specifier"
+    | options == ["ID_STD_TYPE", "ID_SUE_TYPE", "bitwise", "const", "force", "struct", "void"] = "type specifier"
     | options == ["ID_CONST", "ID_VAR", "LIT_CHAR", "LIT_FALSE", "LIT_INTEGER", "'{'"] = "constant or literal"
     | ["ID_FUNC_TYPE", "ID_STD_TYPE", "ID_SUE_TYPE", "ID_VAR"] `isPrefixOf` options = "type specifier or variable name"
-    | ["ID_FUNC_TYPE", "ID_STD_TYPE", "ID_SUE_TYPE", "const"] `isPrefixOf` options = "type specifier"
+    | ["ID_FUNC_TYPE", "ID_STD_TYPE", "ID_SUE_TYPE", "bitwise", "const"] `isPrefixOf` options = "type specifier"
     | ["ID_CONST", "sizeof", "LIT_CHAR", "LIT_FALSE", "LIT_TRUE", "LIT_INTEGER"] `isPrefixOf` options = "constant expression"
     | ["ID_CONST", "ID_SUE_TYPE", "'/*'"] `isPrefixOf` options = "enumerator, type name, or comment"
     | wants ["'defined'"] = "preprocessor constant expression"

src/Language/Cimple/Lexer.x

@@ -151,6 +151,7 @@ tokens :-
 <0>		"#define"				{ mkL PpDefine `andBegin` ppSC }
 <0>		"#undef"				{ mkL PpUndef }
 <0>		"#include"				{ mkL PpInclude }
+<0,ppSC>	"bitwise"				{ mkL KwBitwise }
 <0,ppSC>	"break"					{ mkL KwBreak }
 <0,ppSC>	"case"					{ mkL KwCase }
 <0,ppSC>	"const"					{ mkL KwConst }
@@ -161,6 +162,7 @@ tokens :-
 <0,ppSC>	"enum"					{ mkL KwEnum }
 <0,ppSC>	"extern"				{ mkL KwExtern }
 <0,ppSC>	"for"					{ mkL KwFor }
+<0,ppSC>	"force"					{ mkL KwForce }
 <0,ppSC>	"goto"					{ mkL KwGoto }
 <0,ppSC>	"if"					{ mkL KwIf }
 <0,ppSC>	"non_null"				{ mkL KwNonNull }

src/Language/Cimple/MapAst.hs

@@ -327,6 +327,10 @@ instance MapAst itext otext (Node (Lexeme itext)) where
             Fix <$> (Union <$> recurse name <*> recurse members)
         MemberDecl decl bits ->
             Fix <$> (MemberDecl <$> recurse decl <*> recurse bits)
+        TyBitwise ty ->
+            Fix <$> (TyBitwise <$> recurse ty)
+        TyForce ty ->
+            Fix <$> (TyForce <$> recurse ty)
         TyConst ty ->
             Fix <$> (TyConst <$> recurse ty)
         TyPointer ty ->

src/Language/Cimple/Parser.y

@@ -43,6 +43,7 @@ import           Language.Cimple.Tokens      (LexemeClass (..))
     ID_STD_TYPE			{ L _ IdStdType			_ }
     ID_SUE_TYPE			{ L _ IdSueType			_ }
     ID_VAR			{ L _ IdVar			_ }
+    bitwise			{ L _ KwBitwise			_ }
     break			{ L _ KwBreak			_ }
     case			{ L _ KwCase			_ }
     const			{ L _ KwConst			_ }
@@ -53,6 +54,7 @@ import           Language.Cimple.Tokens      (LexemeClass (..))
     enum			{ L _ KwEnum			_ }
     extern			{ L _ KwExtern			_ }
     for				{ L _ KwFor			_ }
+    force			{ L _ KwForce			_ }
     GNU_PRINTF			{ L _ KwGnuPrintf		_ }
     goto			{ L _ KwGoto			_ }
     if				{ L _ KwIf			_ }
@@ -666,7 +668,9 @@ TypedefDecl
 
 QualType :: { NonTerm }
 QualType
-:	LeafType						{                                        $1 }
+:	bitwise ID_STD_TYPE					{ Fix (TyBitwise (Fix (TyStd $2))) }
+|	force LeafType						{ Fix (TyForce $2) }
+|	LeafType						{                                        $1 }
 |	LeafType '*'						{                              tyPointer $1 }
 |	LeafType '*' '*'					{          tyPointer          (tyPointer $1) }
 |	LeafType '*' '*' const					{ tyConst (tyPointer          (tyPointer $1)) }

src/Language/Cimple/Pretty.hs

@@ -27,6 +27,7 @@ import           Text.PrettyPrint.ANSI.Leijen
 indentWidth :: Int
 indentWidth = 2
 
+kwBitwise       = dullgreen $ text "bitwise"
 kwBreak         = dullred   $ text "break"
 kwCase          = dullred   $ text "case"
 kwConst         = dullgreen $ text "const"
@@ -37,6 +38,7 @@ kwElse          = dullred   $ text "else"
 kwEnum          = dullgreen $ text "enum"
 kwExtern        = dullgreen $ text "extern"
 kwFor           = dullred   $ text "for"
+kwForce         = dullgreen $ text "force"
 kwGnuPrintf     = dullgreen $ text "GNU_PRINTF"
 kwGoto          = dullred   $ text "goto"
 kwIf            = dullred   $ text "if"
@@ -402,6 +404,8 @@ ppNode = foldFix go
     DeclSpecArray Nothing     -> text "[]"
     DeclSpecArray (Just dim)  -> brackets dim
 
+    TyBitwise     ty -> kwBitwise <+> ty
+    TyForce       ty -> kwForce <+> ty
     TyPointer     ty -> ty <> char '*'
     TyConst       ty -> ty <+> kwConst
     TyUserDefined l  -> dullgreen $ ppLexeme l

src/Language/Cimple/Tokens.hs

@@ -13,6 +13,7 @@ data LexemeClass
     | IdStdType
     | IdSueType
     | IdVar
+    | KwBitwise
     | KwBreak
     | KwCase
     | KwConst
@@ -23,6 +24,7 @@ data LexemeClass
     | KwEnum
     | KwExtern
     | KwFor
+    | KwForce
     | KwGnuPrintf
     | KwGoto
     | KwIf

src/Language/Cimple/TraverseAst.hs

@@ -426,6 +426,10 @@ instance TraverseAst text (Node (Lexeme text)) where
             _ <- recurse decl
             _ <- recurse bits
             pure ()
+        TyBitwise ty ->
+            recurse ty
+        TyForce ty ->
+            recurse ty
         TyConst ty ->
             recurse ty
         TyPointer ty ->

test/Language/CimpleSpec.hs

@@ -24,6 +24,7 @@ sampleToken c = case c of
     IdStdType             -> "uint32_t"
     IdSueType             -> "Sue_Type"
     IdVar                 -> "var"
+    KwBitwise             -> "bitwise"
     KwBreak               -> "break"
     KwCase                -> "case"
     KwConst               -> "const"
@@ -34,6 +35,7 @@ sampleToken c = case c of
     KwEnum                -> "enum"
     KwExtern              -> "extern"
     KwFor                 -> "for"
+    KwForce               -> "force"
     KwGnuPrintf           -> "gnu_printf"
     KwGoto                -> "goto"
     KwIf                  -> "if"