Changeset 262a864

Timestamp:

Dec 16, 2024, 9:37:09 PM (9 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

2980ccb8, 9b55aa3

Parents:

9a01745 (diff), 80018f5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

merge

Files:

• doc/proposals/enums.md (modified) (6 diffs)
• src/CodeGen/OperatorTable.cpp (modified) (1 diff)
• src/Validate/ReplaceTypedef.cpp (modified) (2 diffs)
• tests/.expect/attributes.arm64.txt (modified) (1 diff)
• tests/.expect/attributes.x86.txt (modified) (1 diff)

doc/proposals/enums.md

@@ -8 +8 @@
 --------------
 Because Cforall enumerations are encoded using their position, it can be
-difficult to give them a stable encoding. The
+difficult to give them a stable encoding, this is important in seperate
+compilation.
 
 The example (provided by Gregor Richards), is a system header that defines
@@ -42 +43 @@
 (instead of a subset of int) is used in the index operation.
 
+```cfa
+enum() Colour {
+  Red,
+  Violet,
+  Blue,
+  Green
+  Yellow,
+  Orange,
+};
+
+// Declare an array with an index of an enumeration:
+int jarsOfPaint[Colour] = {0};
+
+// Index the array:
+printf("I have %d jars of blue paint.\n", jarsOfPaint[Blue]);
+jarsOfPaint[Green] = 3;
+jarsOfPaint[Red] += 1;
+
+// Use the function for higher order programming:
+int (*lookup)(int collection[Colour], Colour key) = ?[?];
+
+// ERROR! Use the enumeration index for safety:
+jarsOfPaint[0] = 0;
+```
+
 Although described differently, this is actually a generalization of typed
 enumerations, as it can be used to safely represent a constant of any type
@@ -80 +106 @@
 Or one of the new safer Cforall arrays, as the features could be combined.
 
-(Previously, a compined declaration to declare both an enumeration and
+(Previously, a combined declaration to declare both an enumeration and
 an enumerated array was proposed. That only covers the simple case that
 typed enumerations already cover.)
@@ -90 +116 @@
 generalized to work with the other features of ranges, such as going over
 just part of the enumeration (see Ranges in doc/proposals/iterators.md).
+
+This will work best with some alias labels that mark out the beginning of
+ranges. That is the ranges within the enum will often have to be an
+intended part of the interface.
+
+```cfa
+for ( kind : DataKind.BeginIntegers +~ DataKind.EndIntegers ) { ... }
+```
+
+Writing the declaration is a bit tricker, because of the lack of aliasing,
+but this should echo a common C pattern.
 
 Flag Set Enumerations
@@ -111 +148 @@
 ```
 
+Some example usages:
+```cfa
+// If it is exactly Up/Upwards, then set exactly Down
+if ( Upwards == dirs ) {
+  dirs = Down
+// Otherwise, if a vertical is set, unset them:
+} else if ( Vertical & dirs ) {
+  dirs = dirs & ~Vertical;
+// Otherwise, if any direction is set then also set Up:
+} else if ( dirs ) {
+  dirs |= Up;
+}
+```
+
 Uses the existing enumeration syntax, except that all initializers must be
 bitwise expressions, using only the operators |, & and ~ and, as leaf values,
@@ -132 +183 @@
 
 Note: Scoping rules are also waiting on the namespacing and module system.
+
+Feature (and Storage) Control
+-----------------------------
+Right now features are very coursely grouped. You have exactly three options
+for your enumeration. However since there are more than two features this
+means there are some combinations you cannot have.
+
+For instance, labels (which are mostly useful for generating debug output)
+are not available for C style enum, but for both of the new Cforall enums,
+opaque and typed. However, there is no innate connection between the
+additional type safety of the opaque enum or the associated values/payloads
+of the typed enums.
+
+Enumerations do interact with on feature that shows this orthagonality,
+and that is the scoping "no export" marker, that can be applied to any
+enumeration to change the visibility rules of the enumeration and does not
+change anything else.
+
+This is not urgent, just not using the features you don't want is almost as
+clear and the compile-time, binary-size and runtime costs are all good enough
+for now (and some day all of those may have to be improved even when the
+feature is being used). Isolating independent features is just good design.

src/CodeGen/OperatorTable.cpp

@@ -76 +76 @@
         }
 
-        if ( inputName.find_first_of( "?^*+-!", 0, 1 ) == std::string::npos ) return nullptr; // prefilter
-        const OperatorInfo * ret = inputTable.find( inputName )->second;
+        // Filter out non-operator names:
+        if ( inputName.find_first_of( "?^*+-!", 0, 1 ) == std::string::npos ) return nullptr;
+        auto entry = inputTable.find( inputName );
         // This can only happen if an invalid identifier name has been used.
+        assertf( entry != inputTable.end(), "Not a real operator: %s\n", inputName.c_str() );
+        const OperatorInfo * ret = entry->second;
         assert( ret );
         return ret;

src/Validate/ReplaceTypedef.cpp

@@ -10 +10 @@
 // Created On       : Tue Jun 29 14:59:00 2022
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Dec 14 16:11:51 2023
-// Update Count     : 4
+// Last Modified On : Mon Dec 16 20:50:42 2024
+// Update Count     : 5
 //
 
@@ -135 +135 @@
 };
 static bool dimensionPresenceMismatched( const ast::Type * t0, const ast::Type * t1) {
-        std::vector<const ast::ArrayType *> at0s = std::move(
-                ast::Pass<ArrayTypeExtractor>::read( t0 ) );
-        std::vector<const ast::ArrayType *> at1s = std::move(
-                ast::Pass<ArrayTypeExtractor>::read( t1 ) );
+        std::vector<const ast::ArrayType *> at0s = ast::Pass<ArrayTypeExtractor>::read( t0 );
+        std::vector<const ast::ArrayType *> at1s = ast::Pass<ArrayTypeExtractor>::read( t1 );
         assert( at0s.size() == at1s.size() );
         for (size_t i = 0; i < at0s.size(); i++) {

tests/.expect/attributes.arm64.txt

@@ -1337 +1337 @@
     return _X4_retS3Vad_1;
 }
+__attribute__ (( noreturn )) void _X4fredFv___1(void){
+    __attribute__ ((unused)) signed int _X1ii_2;
+    switch ( 3 ) {
+        case 2:
+            {
+                {
+                    ((void)4);
+                }
+
+            }
+        case 1:
+            {
+                {
+                    ((void)3);
+                }
+
+            }
+    }
+
+}
+__attribute__ ((noreturn)) void _X4maryFv___1(void){
+    struct __attribute__ ((aligned(64))) S {
+        signed int _X1ii_2;
+    };
+    inline void _X12_constructorFv_S1S_autogen___2(__attribute__ ((unused)) struct S *_X4_dstS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ii_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S1SS1S_autogen___2(__attribute__ ((unused)) struct S *_X4_dstS1S_2, __attribute__ ((unused)) struct S _X4_srcS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ii_2=_X4_srcS1S_2._X1ii_2) /* ?{} */);
+        }
+
+    }
+    inline void _X11_destructorFv_S1S_autogen___2(__attribute__ ((unused)) struct S *_X4_dstS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ii_2) /* ^?{} */);
+        }
+
+    }
+    inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(__attribute__ ((unused)) struct S *_X4_dstS1S_2, __attribute__ ((unused)) struct S _X4_srcS1S_2){
+        __attribute__ ((unused)) struct S _X4_retS1S_2;
+        {
+            ((void)((*_X4_dstS1S_2)._X1ii_2=_X4_srcS1S_2._X1ii_2));
+        }
+
+        {
+            ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
+        }
+
+        return _X4_retS1S_2;
+    }
+    inline void _X12_constructorFv_S1Si_autogen___2(__attribute__ ((unused)) struct S *_X4_dstS1S_2, signed int _X1ii_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ii_2=_X1ii_2) /* ?{} */);
+        }
+
+    }
+    __attribute__ ((unused)) signed int _X1ii_2;
+    switch ( 3 ) {
+        case 2:
+            {
+                {
+                    ((void)4);
+                }
+
+            }
+        case 1:
+            {
+                {
+                    ((void)3);
+                }
+
+            }
+    }
+
+}

tests/.expect/attributes.x86.txt

@@ -1337 +1337 @@
     return _X4_retS3Vad_1;
 }
+__attribute__ (( noreturn )) void _X4fredFv___1(void){
+    __attribute__ ((unused)) signed int _X1ii_2;
+    switch ( 3 ) {
+        case 2:
+            {
+                {
+                    ((void)4);
+                }
+
+            }
+        case 1:
+            {
+                {
+                    ((void)3);
+                }
+
+            }
+    }
+
+}
+__attribute__ ((noreturn)) void _X4maryFv___1(void){
+    struct __attribute__ ((aligned(64))) S {
+        signed int _X1ii_2;
+    };
+    inline void _X12_constructorFv_S1S_autogen___2(__attribute__ ((unused)) struct S *_X4_dstS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ii_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S1SS1S_autogen___2(__attribute__ ((unused)) struct S *_X4_dstS1S_2, __attribute__ ((unused)) struct S _X4_srcS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ii_2=_X4_srcS1S_2._X1ii_2) /* ?{} */);
+        }
+
+    }
+    inline void _X11_destructorFv_S1S_autogen___2(__attribute__ ((unused)) struct S *_X4_dstS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ii_2) /* ^?{} */);
+        }
+
+    }
+    inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(__attribute__ ((unused)) struct S *_X4_dstS1S_2, __attribute__ ((unused)) struct S _X4_srcS1S_2){
+        __attribute__ ((unused)) struct S _X4_retS1S_2;
+        {
+            ((void)((*_X4_dstS1S_2)._X1ii_2=_X4_srcS1S_2._X1ii_2));
+        }
+
+        {
+            ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
+        }
+
+        return _X4_retS1S_2;
+    }
+    inline void _X12_constructorFv_S1Si_autogen___2(__attribute__ ((unused)) struct S *_X4_dstS1S_2, signed int _X1ii_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ii_2=_X1ii_2) /* ?{} */);
+        }
+
+    }
+    __attribute__ ((unused)) signed int _X1ii_2;
+    switch ( 3 ) {
+        case 2:
+            {
+                {
+                    ((void)4);
+                }
+
+            }
+        case 1:
+            {
+                {
+                    ((void)3);
+                }
+
+            }
+    }
+
+}