diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,11 @@ # Revision history for `c-expr-dsl` +## 0.1.0.1 -- 2026-07-22 + +### Bug fixes + +* Add a file, which is required by the test suite, to the tarball. + ## 0.1.0.0 -- 2026-07-14 ### Breaking changes diff --git a/c-expr-dsl.cabal b/c-expr-dsl.cabal --- a/c-expr-dsl.cabal +++ b/c-expr-dsl.cabal @@ -1,6 +1,6 @@ cabal-version: 3.0 name: c-expr-dsl -version: 0.1.0.0 +version: 0.1.0.1 license: BSD-3-Clause license-file: LICENSE author: Well-Typed LLP @@ -27,7 +27,10 @@ assigns types to macro expressions according to the rules implemented in c-expr-runtime. -data-files: *.golden +data-files: + *.golden + *.h + data-dir: test/fixtures source-repository head @@ -39,7 +42,7 @@ type: git location: https://github.com/well-typed/c-expr.git subdir: c-expr-dsl - tag: release-0.1.0.0 + tag: release-0.1.0.1 common lang build-depends: base >=4.16 && <4.23 diff --git a/test/fixtures/macros.h b/test/fixtures/macros.h new file mode 100644 --- /dev/null +++ b/test/fixtures/macros.h @@ -0,0 +1,219 @@ +// Fixture for c-expr-dsl golden tests. +// +// Each macro is parsed using libclang and then fed to 'parseMacro'. The +// results are compared against the golden file macros.golden. + +// --------------------------------------------------------------------------- +// Type macros: void and bool +// --------------------------------------------------------------------------- + +#define TY_VOID void +#define TY_BOOL _Bool +#define TY_BOOL_C23 bool + +// --------------------------------------------------------------------------- +// Type macros: integer types +// --------------------------------------------------------------------------- + +#define TY_INT int +#define TY_SIGNED signed +#define TY_UNSIGNED unsigned +#define TY_SHORT short +#define TY_LONG long +#define TY_LONG_LONG long long +#define TY_UNSIGNED_INT unsigned int +#define TY_SIGNED_INT signed int +#define TY_UNSIGNED_SHORT unsigned short +#define TY_UNSIGNED_LONG unsigned long +#define TY_UNSIGNED_LONG_LONG unsigned long long +#define TY_LONG_LONG_INT long long int + +// --------------------------------------------------------------------------- +// Type macros: char +// --------------------------------------------------------------------------- + +#define TY_CHAR char +#define TY_SIGNED_CHAR signed char +#define TY_UNSIGNED_CHAR unsigned char + +// --------------------------------------------------------------------------- +// Type macros: floating-point +// --------------------------------------------------------------------------- + +#define TY_FLOAT float +#define TY_DOUBLE double + +// --------------------------------------------------------------------------- +// Type macros: const qualifiers +// --------------------------------------------------------------------------- + +#define TY_CONST_INT const int +#define TY_INT_CONST int const +#define TY_CONST_VOID const void + +// --------------------------------------------------------------------------- +// Type macros: pointer types +// --------------------------------------------------------------------------- + +#define TY_INT_PTR int * +#define TY_INT_PTR_PTR int ** +#define TY_VOID_PTR void * +#define TY_CONST_INT_PTR const int * +#define TY_INT_PTR_CONST int *const + +// --------------------------------------------------------------------------- +// Type macros: mixed const pointer types +// --------------------------------------------------------------------------- + +#define PTR_TO_CONST_L const int * +#define PTR_TO_CONST_R int const * +#define CONST_PTR int *const +#define CONST_PTR_TO_CONST_L const int *const +#define CONST_PTR_TO_CONST_R int const *const +#define CONST_PTR_CHAIN_1 int const *const *const * +#define CONST_PTR_CHAIN_2 int const *const *const *const +#define CONST_PTR_CHAIN_3 int const *const **const *const +#define CONST_PTR_CHAIN_4 const int *const *const * +#define CONST_PTR_CHAIN_5 const int *const *const *const +#define CONST_PTR_CHAIN_6 const int *const **const *const +#define CONST_PTR_CHAIN_7 const int ****const +#define CONST_PTR_CHAIN_8 int const ****const +#define CONST_PTR_CHAIN_9 int ****const * + +// --------------------------------------------------------------------------- +// Type macros: tagged types (struct / union / enum) +// --------------------------------------------------------------------------- + +#define TY_STRUCT_FOO struct Foo +#define TY_UNION_BAR union Bar +#define TY_ENUM_BAZ enum Baz +#define TY_STRUCT_FOO_PTR struct Foo * + +// --------------------------------------------------------------------------- +// Type macros: named types (bare identifiers treated as typedef names) +// +// No #include is needed: libclang tokenises these as CXToken_Identifier +// regardless of whether the name is declared, which is exactly what +// 'parseMacroType' expects. +// +// This also covers bare macro-name references: a single identifier produces +// Term (Var ...) regardless of which parser handles it, because both the +// type parser and the expression parser parse a bare identifier the same way. +// To get a macro-name reference in expression position with arithmetic, use +// an expression context (e.g. EXPR_ONE + EXPR_FORTY_TWO). +// --------------------------------------------------------------------------- + +#define TY_SIZE_T size_t +#define TY_UINT32_T uint32_t +#define TY_CONST_SIZE_T const size_t +#define TY_SIZE_T_PTR size_t * +// A bare macro name parses as a named type, not an expression variable +#define TY_MACRO_REF EXPR_FORTY_TWO + +// --------------------------------------------------------------------------- +// Expression macros: integer literals +// --------------------------------------------------------------------------- + +#define EXPR_ZERO 0 +#define EXPR_ONE 1 +#define EXPR_FORTY_TWO 42 +#define EXPR_HEX 0xFF +#define EXPR_NEG (-1) + +// --------------------------------------------------------------------------- +// Expression macros: arithmetic +// --------------------------------------------------------------------------- + +#define EXPR_ADD 1 + 2 +#define EXPR_SUB 10 - 3 +#define EXPR_MUL 4 * 5 +#define EXPR_DIV 8 / 2 +#define EXPR_SHIFT_LEFT 1 << 4 +#define EXPR_BITWISE_OR 0x0F | 0xF0 + +// --------------------------------------------------------------------------- +// Expression macros: parenthesised / compound +// --------------------------------------------------------------------------- + +#define EXPR_PARENS (42) +#define EXPR_COMPOUND (1 + 2) * 3 + +// --------------------------------------------------------------------------- +// Function-like macros +// --------------------------------------------------------------------------- + +#define FUNC_IDENTITY(x) x +#define FUNC_ADD(a, b) a + b +#define FUNC_NEG(x) (-x) +#define FUNC_MULTIPLE_LOCAL_PARAMS(a, b, c, d) a + (b - (c + d)) +// TODO +// +// Ternary operator is not yet in the expression grammar (see below). +// #define FUNC_MAX(a, b) ((a) > (b) ? (a) : (b)) + +// FUNC_MULTILINE is like FUNC_SINGLELINE, but the former's definition is spread +// over multiple lines. Both macros should lead to the same parse result. +#define FUNC_SINGLELINE(xx, yy) xx * yy +#define FUN\ +C_MULTIL\ +\ +INE\ +\ +\ +(\ +xx\ +,\ +yy\ +)\ +x\ +x * y\ +y + +// --------------------------------------------------------------------------- +// Expression macros: references to other macros / typedefs +// +// Macro names and typedef names are tokenised as CXToken_Identifier, so +// the parser treats them as variable references (Var). The expression +// parser also supports call syntax: FOO(x) parses as Var "FOO" [x]. +// --------------------------------------------------------------------------- + +// Arithmetic that combines two macro-name references +#define EXPR_REF_ADD EXPR_ONE + EXPR_FORTY_TWO + +// Call a previously defined function-like macro with literal arguments +#define EXPR_CALL_ADD FUNC_ADD(1, 2) + +// Call a previously defined function-like macro inside a larger expression +#define EXPR_CALL_NESTED FUNC_ADD(EXPR_ONE, EXPR_FORTY_TWO) + 1 + +// --------------------------------------------------------------------------- +// Erroneous macros or macros with bodies the parser cannot handle +// --------------------------------------------------------------------------- + +// A macro is only function-like if there is no whitespace between the macro +// name and the opening parenthesis of the parameter list. +// +// Beware: casts look like function-like macros, but they are parsed as +// object-like macros because there is whitespace after the macro name. +#define CAST_SINGLE_NOKW (X) x +#define CAST_SINGLE_KW (int)x +#define CAST_MULTI_KW (unsigned int)x + +// This is genuine erroneous function; keywords must not be parameter names. +#define BAD_KEYWORD_AS_PARAM(int) x + +// We can parse this macro, but typecheck will fail. +#define TYPE_FUN_WITH_PARAM(X) int + +// TODO +// +// Ternary operator is not yet in the expression grammar. +#define BAD_TERNARY a ? b : c + +// 'long double' is not supported (TypeFloat only covers float/double). +#define BAD_LONG_DOUBLE long double + +// '_Pragma' is the C99 preprocessor operator, equivalent to '#pragma'. It +// expands to a preprocessing directive, not a C expression, so we reject it. +#define PACK_START _Pragma("pack(1)") +#define PACK_FINISH _Pragma("pack()")