Changeset 1dd5fd1

Timestamp:

Jul 15, 2024, 10:39:57 PM (3 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

2363147

Parents:

d796be70 (diff), 09dd830 (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 branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• doc/theses/jiada_liang_MMath/CFAenum.tex (modified) (15 diffs)
• src/ResolvExpr/CandidateFinder.cpp (modified) (1 diff)
• tests/enum_tests/.expect/planet.txt (added)
• tests/enum_tests/.in/planet.txt (added)
• tests/enum_tests/planet.cfa (added)

doc/theses/jiada_liang_MMath/CFAenum.tex

@@ -7 +7 @@
 The following sections detail all of my new contributions to enumerations in \CFA.
 
-
-\section{Aliasing}
-
-C already provides @const@-style aliasing using the unnamed enumerator \see{\VRef{s:TypeName}}, even if the name @enum@ is misleading (@const@ would be better).
-Given the existence of this form, it is straightforward to extend it with types other than @int@.
-\begin{cfa}
-enum E { Size = 20u, PI = 3.14159L, Jack = L"John" };
-\end{cfa}
-which matches with @const@ aliasing in other programming languages.
-Here, the type of the enumerator is the type of the initialization constant, \eg @typeof(20u)@ for @Size@ implies @unsigned int@.
-Auto-initialization is restricted to the case where all constants are @int@, matching with C.
-As seen in \VRef{s:EnumeratorTyping}, this feature is just a shorthand for multiple typed-enumeration declarations.
+\begin{comment}
+        Not support. 
+\end{comment}
+% \section{Aliasing}
+
+% C already provides @const@-style aliasing using the unnamed enumerator \see{\VRef{s:TypeName}}, even if the name @enum@ is misleading (@const@ would be better).
+% Given the existence of this form, it is straightforward to extend it with types other than @int@.
+% \begin{cfa}
+% enum E { Size = 20u, PI = 3.14159L, Jack = L"John" };
+% \end{cfa}
+% which matches with @const@ aliasing in other programming languages.
+% Here, the type of the enumerator is the type of the initialization constant, \eg @typeof(20u)@ for @Size@ implies @unsigned int@.
+% Auto-initialization is restricted to the case where all constants are @int@, matching with C.
+% As seen in \VRef{s:EnumeratorTyping}, this feature is just a shorthand for multiple typed-enumeration declarations.
 
 
@@ -28 +30 @@
 
 The \CFA type-system allows extensive overloading, including enumerators.
-Furthermore, \CFA uses the left-hand of assignment in type resolution to pinpoint the best overloaded name.
+Furthermore, \CFA uses the environment, such as the left-had of assignment and function parameter, to pinpoint the best overloaded name. 
+% Furthermore, \CFA uses the left-hand of assignment in type resolution to pinpoint the best overloaded name.
 Finally, qualification and casting are provided to disambiguate any ambiguous situations.
 \begin{cfa}
@@ -35 +38 @@
 E1 f() { return Third; }                                $\C{// overloaded functions, different return types}$
 E2 f() { return Fourth; }
+void g(E1 e);
+void h(E2 e);
 void foo() {
         E1 e1 = First;   E2 e2 = First;         $\C{// initialization}$
         e1 = Second;   e2 = Second;                     $\C{// assignment}$
-        e1 = f();   e2 = f();                           $\C{// function call}$
+        e1 = f();   e2 = f();                           $\C{// function return}$
+        g(First); h(First);                                     $\C{// function parameter}$
         int i = @E1.@First + @E2.@First;        $\C{// disambiguate with qualification}$
         int j = @(E1)@First + @(E2)@First;      $\C{// disambiguate with cast}$
@@ -72 +78 @@
 
 
-\section{Enumeration Trait}
-
-The header file \lstinline[deletekeywords=enum]{<enum.hfa>} defines the set of traits containing operators and helper functions for @enum@.
+\section{Enumeration Traits}
+
+\CFA defines the set of traits containing operators and helper functions for @enum@.
 A \CFA enumeration satisfies all of these traits allowing it to interact with runtime features in \CFA.
 Each trait is discussed in detail.
 
-The trait @Bounded@:
+The trait @CfaEnum@:
+\begin{cfa}
+forall( E ) trait CfaEnum {
+        char * label( E e );
+        unsigned int posn( E e );
+};
+\end{cfa}
+
+describes an enumeration as a named constant with position. And @TypeEnum@
+\begin{cfa}
+forall( E, V ) trait TypeEnum {
+        V value( E e );
+};      
+\end{cfa}
+asserts two types @E@ and @T@, with @T@ being the base type for the enumeration @E@. 
+
+The declarative syntax
+\begin{cfa}
+enum(T) E { A = ..., B = ..., C = ... };
+\end{cfa}
+creates an enumerated type E with @label@, @posn@ and @value@ implemented automatically.
+
+\begin{cfa}
+void foo( T t ) { ... }
+void bar(E e) {
+        choose (e) {
+                case A: printf("\%d", posn(e));
+                case B: printf("\%s", label(e));
+                case C: foo(value(e));
+        } 
+}
+\end{cfa}
+
+Implementing general functions across all enumeration types is possible by asserting @CfaEnum( E, T )@, \eg:
+\begin{cfa}
+#include <string.hfa>
+forall( E, T | CfaEnum( E, T ) | {unsigned int toUnsigned(T)} )
+string formatEnum( E e ) {
+        unsigned int v = toUnsigned(value(e));
+        string out = label(e) + '(' + v +')';
+        return out;
+}
+printEunm( Week.Mon );
+printEnum( RGB.Green );
+\end{cfa}
+
+\CFA does not define attribute functions for C style enumeration. But it is possilbe for users to explicitly implement
+enumeration traits for C enum and any other types.
+
+\begin{cfa}
+enum Fruit { Apple, Bear, Cherry };                     $\C{// C enum}$
+char * label(Fruit f) {
+        switch(f) {
+                case Apple: "A"; break;
+                case Bear: "B"; break;
+                case Cherry: "C"; break;
+        }
+}
+unsigned posn(Fruit f) { return f; }
+char* value(Fruit f) { return ""; }             $\C{// value can return any non void type}$
+formatEnum( Apple );                                                    $\C{// Fruit is now a Cfa enum}$
+\end{cfa}
+
+A type that implements trait @CfaEnum@, \ie, a type has no @value@, is called an opaque enum.
+
+% \section{Enumerator Opaque Type}
+
+% \CFA provides a special opaque enumeration type, where the internal representation is chosen by the compiler and only equality operations are available.
+\begin{cfa}
+enum@()@ Planets { MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE };
+\end{cfa}
+
+
+In addition, \CFA implements @Bound@ and @Serial@ for \CFA Enums.
 \begin{cfa}
 forall( E ) trait Bounded {
@@ -85 +164 @@
 };
 \end{cfa}
-defines the bounds of the enumeration, where @first()@ returns the first enumerator and @last()@ returns the last, \eg:
+The function @first()@ and @last()@ of enumerated type E return the first and the last enumerator declared in E, respectively. \eg:
 \begin{cfa}
 Workday day = first();                                  $\C{// Mon}$
@@ -93 +172 @@
 Calling either functions without a context results in a type ambiguity, except in the rare case where the type environment has only one enumeration.
 \begin{cfa}
-@first();@                                                              $\C{// ambiguous Workday and Planet implement Bounded}$
+@first();@                                                              $\C{// ambiguous because both Workday and Planet implement Bounded}$
 sout | @last()@;
 Workday day = first();                                  $\C{// day provides type Workday}$
@@ -116 +195 @@
 Specifically, for enumerator @E@ declaring $N$ enumerators, @fromInt( i )@ returns the $i-1_{th}$ enumerator, if $0 \leq i < N$, or raises the exception @enumBound@.
 
-The @Serial@ trait also requires interface functions @succ( E e )@ and @pred( E e )@ be implemented for a serial type, which imply the enumeration positions are consecutive and ordinal. 
+The @succ( E e )@ and @pred( E e )@ imply the enumeration positions are consecutive and ordinal. 
 Specifically, if @e@ is the $i_{th}$ enumerator, @succ( e )@ returns the $i+1_{th}$ enumerator when $e \ne last()$, and @pred( e )@ returns the $i-1_{th}$ enumerator when $e \ne first()$. 
 The exception @enumRange@ is raised if the result of either operation is outside the range of type @E@.
 
-The trait @TypedEnum@:
-\begin{cfa}
-forall( E, T ) trait TypedEnum {
-        T valueE( E e );
-        char * labelE( E e );
-        unsigned int posE( E e );
-};
-\end{cfa}
-captures three basic attributes of an enumeration type: value, label, and position. 
-@TypedEnum@ asserts two types @E@ and @T@, with @T@ being the base type of the enumeration @E@, \eg @enum( T ) E { ... };@.
-Implementing general functions across all enumeration types is possible by asserting @TypeEnum( E, T )@, \eg:
-\begin{cfa}
-forall( E, T | TypeEnum( E, T ) )
-void printEnum( E e ) {
-        sout | "Enum "| labelE( e );
-}
-printEunm( MARS );
-\end{cfa}
-
 Finally, there is an associated trait defining comparison operators among enumerators. 
 \begin{cfa}
-forall( E, T | TypedEnum( E, T ) ) {
+forall( E, T | CfaEnum( E, T ) ) {
         // comparison
         int ?==?( E l, E r );           $\C{// true if l and r are same enumerators}$
@@ -152 +212 @@
 }
 \end{cfa}
-Note, the overloaded operators are defined only when the header @<enum.hfa>@ is included.
-If not, the compiler converts an enumerator to its value, and applies the operators defined for the value type @E@, \eg:
-\begin{cfa}
-// if not include <enum.hfa>
-enum( int ) Fruits { APPLE = 2, BANANA = 10, CHERRY = 2 };
-APPLE == CHERRY; // true because valueE( APPLE ) == valueE( CHERRY )
-
-#include <enum.hfa>
-APPLE == CHERRY; // false because posE( APPLE ) != posE( CHERRY )
-\end{cfa}
-An enumerator returns its @position@ by default.
-In particular, @printf( ... )@ from @<stdio.h>@ functions provides no context to its parameter type, so it prints @position@. 
-On the other hand, the pipeline operator @?|?( ostream os, E enumType )@ provides type context for type @E@, and \CFA has overwritten this operator to print the enumeration @value@ over @position@.
-\begin{cfa}
-printf( "Position of BANANA is \%d", BANANA ); // Position of BANANA is 1
-sout | "Value of BANANA is " | BANANA; // Value of BANANA is 10
-\end{cfa}
-Programmers can overwrite this behaviour by overloading the pipeline operator themselves.
-\PAB{This needs discussing because including \lstinline{<enum.hfa>} can change the entire meaning of a program.}
-
-
-% \section{Enumeration Pseudo-functions}
-
-% Pseudo-functions are function-like operators that do not result in any run-time computations, \ie like @sizeof@, @alignof@, @typeof@.
-% A pseudo-function call is often substituted with information extracted from the compilation symbol-table, like storage size or alignment associated with the underlying architecture.
-
-% The attributes of an enumerator are accessed by pseudo-functions @posE@, @valueE@, and @labelE@.
-% \begin{cfa}
-% int jane_pos = @posE@( Names.Jane );   $\C{// 2}$
-% char * jane_value = @valueE@( Names.Jane ); $\C{// "JANE"}$
-% char * jane_label = @labelE@( Names.Jane ); $\C{// "Jane"}$
-% sout | posE( Names.Jane) | labelE( Names.Jane ) | valueE( Names.Jane );
-% \end{cfa}
-% Note the ability to print all of an enumerator's properties.
-
-
-\section{Enumerator Typing}
+
+\section{Typed Enum}
 \label{s:EnumeratorTyping}
 
@@ -256 +281 @@
 calling constructors happens at runtime (dynamic).
 
-
-\section{Enumerator Opaque Type}
-
-\CFA provides a special opaque enumeration type, where the internal representation is chosen by the compiler and only equality operations are available.
-\begin{cfa}
-enum@()@ Planets { MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE };
-\end{cfa}
-
-
 \section{Enumeration Inheritance}
 
 \CFA Plan-9 inheritance may be used with enumerations, where Plan-9 inheritance is containment inheritance with implicit unscoping (like a nested unnamed @struct@/@union@ in C).
+
 \begin{cfa}
 enum( char * ) Names { /* as above */ };
 enum( char * ) Names2 { @inline Names@, Jack = "JACK", Jill = "JILL" };
-@***@enum /* inferred */ Names3 { @inline Names2@, Sue = "SUE", Tom = "TOM" };
-\end{cfa}
+enum( char * ) Names3 { @inline Names2@, Sue = "SUE", Tom = "TOM" };
+\end{cfa}
+
 Enumeration @Name2@ inherits all the enumerators and their values from enumeration @Names@ by containment, and a @Names@ enumeration is a subtype of enumeration @Name2@.
-Note, enumerators must be unique in inheritance but enumerator values may be repeated.
-
-The enumeration type for the inheriting type must be the same as the inherited type;
-hence the enumeration type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for @Name3@.
+Note, that enumerators must be unique in inheritance but enumerator values may be repeated.
+
+% The enumeration type for the inheriting type must be the same as the inherited type;
+% hence the enumeration type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for @Name3@.
 % When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important.
 Specifically, the inheritance relationship for @Names@ is:
 \begin{cfa}
-Names $\(\subset\)$ Names2 $\(\subset\)$ Names3 $\(\subset\)$ const char * $\C{// enum type of Names}$
+Names $\(\subset\)$ Names2 $\(\subset\)$ Names3 $\C{// enum type of Names}$
+\end{cfa}
+A subtype can be cast to its supertype, assigned to a supertype variable, or be used as a function argument that expects the supertype.
+\begin{cfa}
+Names fred = Name.Fred;
+(Names2) fred; (Names3) fred; (Name3) Names.Jack;  $\C{// cast to super type}$
+Names2 fred2 = fred; Names3 fred3 = fred2; $\C{// assign to super type}$
 \end{cfa}
 For the given function prototypes, the following calls are valid.
@@ -297 +321 @@
 g( Fred );   g( Jill );
 h( Fred );   h( Jill );   h( Sue );
- j( Fred );    j( Jill );    j( Sue );    j( "WILL" );
+j( Fred );    j( Jill );    j( Sue );    j( "WILL" );
 \end{cfa}
 \end{tabular}
@@ -303 +327 @@
 Note, the validity of calls is the same for call-by-reference as for call-by-value, and @const@ restrictions are the same as for other types.
 
-
 \section{Enumerator Control Structures}
 
@@ -309 +332 @@
 In most programming languages, an enumerator is implicitly converted to its value (like a typed macro substitution).
 However, enumerator synonyms and typed enumerations make this implicit conversion to value incorrect in some contexts.
-In these contexts, a programmer's initition assumes an implicit conversion to postion.
-
-For example, an intuitive use of enumerations is with the \CFA @switch@/@choose@ statement, where @choose@ performs an implict @break@ rather than a fall-through at the end of a @case@ clause.
+In these contexts, a programmer's initition assumes an implicit conversion to position.
+
+For example, an intuitive use of enumerations is with the \CFA @switch@/@choose@ statement, where @choose@ performs an implicit @break@ rather than a fall-through at the end of a @case@ clause.
 \begin{cquote}
 \begin{cfa}
@@ -344 +367 @@
 enum Count { First, Second, Third @= First@, Fourth };
 \end{cfa}
-which make @Third == First@ and @Fourth == Second@, causing a compilation error because of duplicase @case@ clauses.
+which make @Third == First@ and @Fourth == Second@, causing a compilation error because of duplicate @case@ clauses.
 To better match with programmer intuition, \CFA toggles between value and position semantics depending on the language context.
-For conditional clauses and switch statments, \CFA uses the robust position implementation.
+For conditional clauses and switch statements, \CFA uses the robust position implementation.
 \begin{cfa}
 choose( @position@( e ) ) {
@@ -364 +387 @@
 \end{cfa}
 
-
-@if@ statement
-
-@switch@ statement
-
-looping statements
-
+\begin{cfa}
+for (d; Workday) { sout | d; }
+for (p; +~=Planet) { sout | p; }
+for (c: -~=Alphabet ) { sout | c; }
+\end{cfa}
+The @range loop@ for enumeration is a syntax sugar that loops over all enumerators and assigns each enumeration to a variable in every iteration.
+The loop control of the range loop consists of two parts: a variable declaration and a @range expression@, with the type of the variable
+can be inferred from the range expression.
+
+The range expression is an enumeration type, optionally prefixed by @+~=@ or @-~=@. Without a prefix, or prefixed with @+~=@, the control
+loop over all enumerators from the first to the last. With a @-~=@ prefix, the control loops backward.
+
+On a side note, the loop syntax
+\begin{cfa}
+for ( typeof(Workday) d; d <= last(); d = succ(d) );
+\end{cfa}
+does not work. When d == last(), the loop control will still attempt to assign succ(d) to d, which causes an @enumBound@ exception.
+
+\CFA reduces conditionals to its "if case" if the predicate is not equal to ( @!=@ ) zero, and the "else case" otherwise.
+Overloading the @!=@ operator with an enumeration type against the zero defines a conceptual conversion from
+enum to boolean, which can be used as predicates.
+
+\begin{cfa}
+enum(int) ErrorCode { Normal = 0, Slow = 1, Overheat = 1000, OutOfResource = 1001 };
+bool ?!=?(ErrorCode lhs, zero_t) { return value(lhs) >= 1000; }
+ErrorCode code = /.../
+if (code) { scream(); }
+\end{cfa}
+
+Incidentally, \CFA does not define boolean conversion for enumeration. If no 
+@?!=?(ErrorCode, zero_t)@ 
+overloading defined,
+\CFA looks for the boolean conversion in terms of its value and gives a compiler error if no such conversion is available.
+
+\begin{cfa}
+enum(int) Weekday { Mon, Tues, Wed, Thurs, Fri, Sat, Sun, };
+enum() Colour { Red, Green, Blue };
+enum(S) Fruit { Apple, Banana, Cherry }
+Weekday w = ...; Colour c = ...; Fruit f = ...;
+if (w) { ... } // w is true if and only if w != Mon, because value(Mon) == 0 (auto initialized)
+if (c) { ... } // error
+if (s) { ... } // depends on ?!=?(S lhs, zero_t ), and error if no such overloading available
+\end{cfa}
+
+As an alternative, users can define the boolean conversion for CfaEnum:
+
+\begin{cfa}
+forall(E | CfaEnum(E))
+bool ?!=?(E lhs, zero_t) {
+        return posn(lhs) != 0;
+}
+\end{cfa}
+which effectively turns the first enumeration as a logical zero and non-zero for others.
 
 \section{Enumerated Arrays}
-Enumerated array use an \CFA array as their index.
+Enumerated arrays use an \CFA array as their index.
 \begin{cfa}
 enum() Colour {
@@ -388 +457 @@
 \VRef[Figure]{f:PlanetExample} shows an archetypal enumeration example illustrating most of the \CFA enumeration features.
 @Planet@ is an enumeration of type @MR@.
-Each of the planet enumerators is initialized to a specific mass/radius, @MR@, value.
+Each planet enumerator is initialized to a specific mass/radius, @MR@, value.
 The unnamed enumeration provides the gravitational-constant enumerator @G@.
 Function @surfaceGravity@ uses the @with@ clause to remove @p@ qualification from fields @mass@ and @radius@.
 The program main uses the pseudo function @countof@ to obtain the number of enumerators in @Planet@, and safely converts the random value into a @Planet@ enumerator using @fromInt@.
 The resulting random orbital-body is used in a @choose@ statement.
-The enumerators in the @case@ clause use enumerator position for testing.
+The enumerators in the @case@ clause use the enumerator position for testing.
 The prints use @label@ to print an enumerator's name.
 Finally, a loop enumerates through the planets computing the weight on each planet for a given earth mass.

src/ResolvExpr/CandidateFinder.cpp

@@ -1485 +1485 @@
 
         void Finder::postvisit( const ast::CountExpr * countExpr ) {
-                const ast::UntypedExpr * untyped;
+                const ast::UntypedExpr * untyped = nullptr;
                 if ( countExpr->type ) {
                         auto enumInst = countExpr->type.as<ast::EnumInstType>();