Changeset eae8b37 for libcfa

Timestamp:

Dec 4, 2024, 10:17:49 PM (2 weeks ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

fc276f3

Parents:

509ec82

Message:

Move enum.hfa/enum.cfa to prelude

Location:

libcfa

Files:

• prelude/builtins.c (modified) (3 diffs)
• src/Makefile.am (modified) (1 diff)
• src/enum.cfa (deleted)
• src/enum.hfa (deleted)
• src/iostream.cfa (modified) (1 diff)
• src/iostream.hfa (modified) (1 diff)
• src/rational.cfa (modified) (3 diffs)
• src/rational.hfa (modified) (1 diff)

libcfa/prelude/builtins.c

@@ -172 +172 @@
 };
 
-forall( E | Serial( E ) ) {
+static inline forall( E | Serial( E ) ) {
         E fromInt( int i );
         E succ( E e );
@@ -179 +179 @@
 }
 
-
 forall( E ) trait CfaEnum {
         const char * label( E e );
@@ -188 +187 @@
         V value( E e );
 };
+
+static inline {
+forall( E | Serial( E ) ) {
+        E fromInt( int i ) {
+                E upper = upperBound();
+                E lower = lowerBound();
+                // It is okay to overflow as overflow will be theoretically caught by the other bound
+                if ( i < fromInstance( lower ) || i > fromInstance( upper ) )
+                        abort( "call to fromInt has index %d outside of enumeration range %d-%d.",
+                                   i, fromInstance( lower ), fromInstance( upper ) );
+                return fromInt_unsafe( i );
+        }
+
+        E succ( E e ) {
+                E upper = upperBound();
+                if ( fromInstance( e ) >= fromInstance( upper ) )
+                        abort( "call to succ() exceeds enumeration upper bound of %d.", fromInstance( upper ) );
+                return succ_unsafe(e);
+        }
+
+        E pred( E e ) {
+                E lower = lowerBound();
+                if ( fromInstance( e ) <= fromInstance(lower ) )
+                        abort( "call to pred() exceeds enumeration lower bound of %d.", fromInstance( lower ) );
+                return pred_unsafe( e );
+        }
+
+        int Countof( E ) {
+                E upper = upperBound();
+                E lower = lowerBound();
+                return fromInstance( upper ) + fromInstance( lower ) + 1;
+        }
+}
+}
+
+static inline
+forall( E | CfaEnum(E) | Serial(E) ) {
+        int ?==?( E l, E r ) { return posn( l ) == posn( r ); } // relational operators
+        int ?!=?( E l, E r ) { return posn( l ) != posn( r ); }
+        int ?<?( E l, E r ) { return posn( l ) < posn( r ); }
+        int ?<=?( E l, E r ) { return posn( l ) <= posn( r ); }
+        int ?>?( E l, E r ) { return posn( l ) > posn( r ); }
+        int ?>=?( E l, E r ) { return posn( l ) >= posn( r ); }
+
+        E ++?( E & l ) {                                                                        // increment operators
+                int pos = posn(l);
+                l = fromInt_unsafe(pos+1);
+                return l;
+        }
+
+        E --?( E & l ) {
+                int pos = posn(l);
+                l = fromInt_unsafe(pos-1);
+                return l;
+        }
+
+        E ?+=? ( E & l, one_t ) {
+                int pos = posn(l);
+                l = fromInt_unsafe(pos+1);
+                return l;
+        }
+
+        E ?-=? ( E & l, one_t ) {
+                int pos = posn(l);
+                l = fromInt_unsafe(pos-1);
+                return l;
+        }
+
+        E ?+=? ( E & l, int i ) {
+                int pos = posn(l);
+                l = fromInt_unsafe(pos+i);
+                return l;
+        }
+
+        E ?-=? ( E & l, int i ) {
+                int pos = posn(l);
+                l = fromInt_unsafe(pos-i);
+                return l;
+        }
+
+        E ?++( E & l ) {
+                int pos = posn(l);
+                l = fromInt_unsafe(pos+1);
+                return fromInt_unsafe(pos);
+        }
+
+        E ?--( E & l ) {
+                int pos = posn(l);
+                l = fromInt_unsafe(pos-1);
+                return fromInt_unsafe(pos);
+        }
+}
 
 // Local Variables: //

libcfa/src/Makefile.am

@@ -85 +85 @@
         parseconfig.hfa \
         rational.hfa \
-        enum.hfa \
         stdlib.hfa \
         strstream.hfa \

libcfa/src/iostream.cfa

@@ -1202 +1202 @@
 
 
+forall( istype & | istream( istype ), E | CfaEnum( E ) | Serial( E ) )
+istype & ?|?( istype & is, E & e ) {
+//      fprintf( stderr, "here0\n" );
+        if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
+
+        // Match longest input enumerator string to enumerator labels, where enumerator names are unique.
+
+        int N = countof( E ), lnths[N], fred = 0;
+//      printf( "N %d\n", N );
+        int r = 0;
+        // for ( s; E : r; 0~@ ) {
+        for ( s; E ) {                                                                          // scan string rows gathering lengths
+                lnths[r] = strlen( label( s ) );
+                if ( lnths[r] > fred ) fred = lnths[r];
+//              fprintf( stderr, "%s %d %d\n", label( s ), lnths[r], fred );
+                r += 1;
+        } // for
+
+        int mcol = -1;                                                                          // last match column
+        char ch, curr = '\0', prev = '\0';
+
+        fmt( is, " " );                                                                         // skip optional whitespace
+        if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
+
+        for ( c; fred ) {                                                                       // scan columns of the label matix (some columns missing)
+                int args = fmt( is, "%c", &ch );                                // read character
+//              fprintf( stderr, "fmt args: %d eof: %d\n", args, eof(is) );
+          if ( eof( is ) ) {
+//                      fprintf( stderr, "Eof1\n" );
+                        if ( c == 0 ) return is;                                        // no characters read ?
+                        clear( is );                                                            // => read something => reset EOF => detect again on next read
+//                      fprintf( stderr, "Eof2\n" );
+                        break;
+                } // if
+          if ( args != 1 ) throwResume ExceptionInst( missing_data ); // may be unnecessary since reading single character
+
+//              printf( "read '%c'\n", ch );
+                for ( r; N ) {                                                                  // scan enumeration strings for matching character in current column
+//                      printf( "%d %d %d\n", c, r, lnths[r] );
+                        if ( c < lnths[r] ) {                                           // string long enough for this column check ?
+                                char match = label( fromInt( r ) )[c];  // optimization
+//                              printf( "%c '%c'\n", match, ch );
+                                // Stop on first match, could be other matches.
+                                if ( (match == ch) && (c == 0 || curr == label( fromInt( r ) )[c - 1]) ) {
+//                                      printf( "match %d %d %d '%c' '%c' '%c' '%c' 'c'\n", c, r, lnths[r], match, ch, prev, label( fromInt( r ) )[c - 1] );
+                                        mcol = c;                                                       // matching column
+                                        prev = curr;                                            // last matching character
+                                        curr = ch;                                                      // current matching character
+                                        break;
+                                } // if
+                        } // if
+                } else {
+//                      fprintf( stderr, "finished mcol: %d ch: '%c' curr: '%c' prev: '%c'\n", mcol, ch, curr, prev );
+                        ungetc( ch, is );                                                       // push back last unmatching character
+                        if ( mcol == -1 ) throwResume ExceptionInst( missing_data ); // no matching character in first column
+                        break;
+                } // for
+//              printf( "\n" );
+//      } else {
+//              fprintf( stderr, "finished2 %d\n", mcol );
+        } // for
+
+        for ( c; N ) {                                                                          // scan enumeration strings of length "mcol" for match
+                if ( mcol == lnths[c] - 1 ) {
+                        char match = label( fromInt( c ) )[mcol];       // optimization
+//                      printf( "finished1 mcol: %d c: %d lnth: %d match: '%c' curr: '%c' prev: '%c'\n", mcol, c, lnths[c], match, curr, prev );
+                        if ( (match == curr) && (mcol == 0 || prev == label( fromInt( c ) )[mcol - 1]) ) {
+                                e = fromInt( c );
+                                break;
+                        } // if
+                } // if
+        } else {
+//              fprintf( stderr, "finished3 %d\n", mcol );
+                throwResume ExceptionInst( missing_data );              // no match in this column
+        } // for
+        return is;
+}
+
+forall( ostype & | ostream( ostype ), E | CfaEnum( E ) ) {
+        ostype & ?|?( ostype & os, E e ) {
+                return os | label( e );
+        }
+        OSTYPE_VOID_IMPL( os, E )
+}
+
 // Local Variables: //
 // tab-width: 4 //

libcfa/src/iostream.hfa

@@ -507 +507 @@
 } // distribution
 
+forall( istype & | istream( istype ), E | CfaEnum( E ) | Serial(E) )
+istype & ?|?( istype &, E & );
+
+forall( ostype & | ostream( ostype ), E | CfaEnum( E ) ) {
+        ostype & ?|?( ostype &, E );
+        OSTYPE_VOID( E );
+}
+
 // Local Variables: //
 // tab-width: 4 //

libcfa/src/rational.cfa

@@ -21 +21 @@
 
 // Arithmetic, Relational
-
-forall( T | arithmetic( T ) ) {
+forall( T | Simple(T) ) {
         // helper routines
-
         // Calculate greatest common denominator of two numbers, the first of which may be negative. Used to reduce
         // rationals.  alternative: https://en.wikipedia.org/wiki/Binary_GCD_algorithm
@@ -44 +42 @@
                 return gcd( abs( n ), d );                                              // simplify
         } // simplify
-
+}
+
+forall( T | arithmetic( T ) ) {
         // constructors
 
@@ -197 +197 @@
 
 forall( T ) {
-        forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } | arithmetic( T ) )
+        forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } | Simple(T) )
         istype & ?|?( istype & is, rational(T) & r ) {
                 is | r.numerator | r.denominator;

libcfa/src/rational.hfa

@@ -78 +78 @@
 
 // I/O
+forall(T | multiplicative(T) | equality(T))
+trait Simple {
+        int ?<?( T, T );
+};
 
 forall( T ) {
-        forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } | arithmetic( T ) )
+        forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } | Simple(T) )
         istype & ?|?( istype &, rational(T) & );