Changeset 4e107bf
- Timestamp:
- Aug 3, 2024, 3:48:58 PM (14 months ago)
- Branches:
- master
- Children:
- 1571e4d
- Parents:
- a9ae5ca (diff), 433e2c3 (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. - Files:
-
- 14 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/theses/jiada_liang_MMath/intro.tex
ra9ae5ca r4e107bf 1 1 \chapter{Introduction} 2 2 3 All types in a programming language have a set of constants (symbols), and these constants representvalues, \eg integer types have constants @-1@, @17@, @0xff@ representing whole numbers, floating-point types have constants @5.3@, @2.3E-5@, @0xff.ffp0@ representing real numbers, character types have constants @'a'@, @"abc\n"@, \mbox{\lstinline{u8"}\texttt{\guillemotleft{na\"{i}ve}\guillemotright}\lstinline{"}} representing (human readable) text, \etc.3 All basic types in a programming language have a set of constants (symbols), and these constants represent computable values, \eg integer types have constants @-1@, @17@, @0xff@ representing whole numbers, floating-point types have constants @5.3@, @2.3E-5@, @0xff.ffp0@ representing real numbers, character types have constants @'a'@, @"abc\n"@, \mbox{\lstinline{u8"}\texttt{\guillemotleft{na\"{i}ve}\guillemotright}\lstinline{"}} representing (human readable) text, \etc. 4 4 Constants can be overloaded among types, \eg @0@ is a null pointer for all pointer types, and the value zero for integer and floating-point types. 5 5 (In \CFA, the constants @0@ and @1@ can be overloaded for any type.) 6 Higher-level types compose constants from the basic constants. 7 \begin{cfa} 8 struct S { int i, j, k; } s; 9 s = (S){ 1, 2, 3 }; $\C[2in]{// structure constant}$ 10 int x[5] = { 1, 2, 3, 4, 5 }; $\C{// array constant}\CRT$ 11 \end{cfa} 6 12 A constant's symbolic name is dictated by language syntax related to types, \eg @5.@ (double), @5.0f@ (float), @5l@ (long double). 7 In general, the representation of a constant's value is \newterm{opaque}, so the internal representation can be chosen arbitrarily .13 In general, the representation of a constant's value is \newterm{opaque}, so the internal representation can be chosen arbitrarily, \eg two's complement, IEEE floating-point. 8 14 In theory, there are an infinite set of constant names per type representing an infinite set of values. 9 15 … … 13 19 14 20 Many programming languages capture this important software-engineering capability through a mechanism called \newterm{constant} or \newterm{literal} naming, where a new constant is aliased to an existing constant. 15 Its purpose is for readability: replacing a constant name that directly represents a value with a name that is more symbolic and meaningful in the context of the program. 16 Thereafter, changing the aliasing of the new constant to another constant automatically distributes the rebinding, preventing errors. 17 % and only equality operations are available, \eg @O_RDONLY@, @O_WRONLY@, @O_CREAT@, @O_TRUNC@, @O_APPEND@. 21 Its purpose is for readability: replacing constant values in a program with symbolic names that are more meaningful to programmers in the context of the application. 22 Thereafter, associating a name to a different value automatically distributes this rebinding, preventing errors. 18 23 Because an aliased name is a constant, it cannot appear in a mutable context, \eg \mbox{$\pi$ \lstinline{= 42}} is meaningless, and a constant has no address, \ie it is an \newterm{rvalue}\footnote{ 19 24 The term rvalue defines an expression that can only appear on the right-hand side of an assignment expression.}. … … 39 44 for ( cursor in Mon, Wed, Fri, Sun } ... $\C{// every second day of week}\CRT$ 40 45 \end{cfa} 41 A set can have a partial or total ordering, making it possible to compare set elements, \eg Monday is before Friday and Friday is after.46 A set can have a partial or total ordering, making it possible to compare set elements, \eg Monday is before Tuesday and Tuesday is after. 42 47 Ordering allows iterating among the enumeration set using relational operators and advancement, \eg: 43 48 \begin{cfa} 44 for ( cursor = Monday; cursor @<=@ Friday; cursor = @succ@( cursor ) ) ... 49 for ( cursor = Monday; cursor @<=@ Friday; cursor = @succ@( cursor ) ) ... // weekdays 45 50 \end{cfa} 46 51 Here the values for the set names are logically \emph{generated} rather than listing a subset of names. … … 50 55 \item 51 56 \begin{sloppypar} 52 It provides a finite set of new constants, which are implicitly or explicitly assigned values that must be appropriate for any set operations .57 It provides a finite set of new constants, which are implicitly or explicitly assigned values that must be appropriate for any set operations, \eg increasing order. 53 58 This aspect differentiates an enumeration from general types with an infinite set of constants. 54 59 \end{sloppypar} … … 106 111 \label{s:Aliasing} 107 112 108 Some languages provide simple aliasing (renaming) , \eg:113 Some languages provide simple aliasing (renaming). 109 114 \begin{cfa} 110 115 const Size = 20, Pi = 3.14159, Name = "Jane"; … … 113 118 It is possible to compare aliases, if the constants allow it, \eg @Size < Pi@, whereas @Pi < Name@ might be disallowed depending on the language. 114 119 115 Aliasing is notmacro substitution, \eg @#define Size 20@, where a name is replaced by its value \emph{before} compilation, so the name is invisible to the programming language.120 Aliasing is \emph{not} macro substitution, \eg @#define Size 20@, where a name is replaced by its value \emph{before} compilation, so the name is invisible to the programming language. 116 121 With aliasing, each new name is part of the language, and hence, participates fully, such as name overloading in the type system. 117 Aliasing is not an immutable variable , \eg:122 Aliasing is not an immutable variable. 118 123 \begin{cfa} 119 124 extern @const@ int Size = 20; … … 123 128 Taking the address of an immutable variable makes it an \newterm{lvalue}, which implies it has storage. 124 129 With separate compilation, it is necessary to choose one translation unit to perform the initialization. 125 If aliasing does requirestorage, its address and initialization are opaque (compiler only), similar to \CC rvalue reference @&&@.130 If aliasing requires storage, its address and initialization are opaque (compiler only), similar to \CC rvalue reference @&&@. 126 131 127 132 Aliasing does provide readability and automatic resubstitution. … … 151 156 baz = C S{ i = 7, d = 7.5 } 152 157 \end{haskell} 153 the ADT has three variants (constructors), @A@, @B@, @C@ with associated types @Int@, @Double@, and @S@.158 the ADT has three variants (constructors), @A@, @B@, @C@, with associated types @Int@, @Double@, and @S@. 154 159 The constructors create an initialized value of the specific type that is bound to the immutable variables @foo@, @bar@, and @baz@. 155 160 Hence, the ADT @Foo@ is like a union containing values of the associated types, and a constructor name is used to intialize and access the value using dynamic pattern-matching. 156 161 \begin{cquote} 157 \setlength{\tabcolsep}{ 15pt}162 \setlength{\tabcolsep}{20pt} 158 163 \begin{tabular}{@{}ll@{}} 159 164 \begin{haskell} 160 165 prtfoo val = -- function 161 162 163 164 165 166 167 166 -- pattern match on constructor 167 case val of 168 @A@ a -> print a 169 @B@ b -> print b 170 @C@ (S i d) -> do 171 print i 172 print d 168 173 \end{haskell} 169 174 & 170 175 \begin{haskell} 171 176 main = do 172 173 174 177 prtfoo foo 178 prtfoo bar 179 prtfoo baz 175 180 3 176 181 3.5 … … 193 198 Note, the term \newterm{variant} is often associated with ADTs. 194 199 However, there are multiple languages with a @variant@ type that is not an ADT \see{Algol68~\cite{Algol68} or \CC \lstinline{variant}}. 195 In these languages, the variant is often a union using RTTI tags for discrimination, which cannot be used to simulate an enumeration. 200 Here, the type (and possibly the position for equivalent types) is used to discriminant the specific \emph{variant} within the variant instance. 201 For example, \VRef[Figure]{f:C++variant} shows the \CC equivalent of the two Haskell ADT types using variant types. 202 In these languages, the variant cannot be used to simulate an enumeration. 196 203 Hence, in this work the term variant is not a synonym for ADT. 204 205 \begin{figure} 206 \begin{c++} 207 struct S { char s[32]; }; 208 variant< int, double, S > vd; 209 variant< int, int, int > vs; 210 211 // discrimination based on type 212 vd = 3; 213 if ( holds_alternative<int>(vd) ) cout << "int " << get<int>(vd ) << endl; 214 vd = 3.5; 215 if ( holds_alternative<double>(vd) ) cout << "double " << get<double>(vd) << endl; 216 vd = (S){ "abc" }; 217 if ( holds_alternative<S>(vd) ) cout << "S.s " << get<S>(vd).s << endl; 218 219 // discrimination based on type and position within type 220 vs = (variant<int,int,int>){ in_place_index<0>, 12 }; 221 if ( vs.index() == 0 ) cout << "posn 0 " << get<0>(vs) << endl; 222 vs = (variant<int,int,int>){ in_place_index<1>, 4 }; 223 if ( vs.index() == 1 ) cout << "posn 1 " << get<1>(vs) << endl; 224 vs = (variant<int,int,int>){ in_place_index<2>, 5 }; 225 if ( vs.index() == 2 ) cout << "posn 2 " << get<2>(vs) << endl; 226 \end{c++} 227 \caption{\CC \lstinline[language=C++]{variant} Discrimination Using RTTI/Position} 228 \label{f:C++variant} 229 \end{figure} 197 230 198 231 % https://downloads.haskell.org/ghc/latest/docs/libraries/base-4.19.1.0-179c/GHC-Enum.html … … 200 233 201 234 The association between ADT and enumeration occurs if all the constructors have a unit (empty) type, \eg @struct unit {}@. 202 Note, the unit type is not the same as \lstinline{void} , \eg:235 Note, the unit type is not the same as \lstinline{void}. 203 236 \begin{cfa} 204 237 void foo( void ); 205 238 struct unit {} u; $\C[1.5in]{// empty type}$ 206 239 unit bar( unit ); 207 foo( foo()); $\C{// void argument does not match with void parameter}$240 foo( @foo()@ ); $\C{// void argument does not match with void parameter}$ 208 241 bar( bar( u ) ); $\C{// unit argument does match with unit parameter}\CRT$ 209 242 \end{cfa} … … 214 247 \end{haskell} 215 248 the default type for each constructor is the unit type, and deriving from @Enum@ enforces no other associated types, @Eq@ allows equality comparison, and @Show@ is for printing. 216 The nullary constructors for the unit types are numbered left-to-right from $0$ to @maxBound@$- 1$, and provides enumerating operations @succ@, @pred@, @enumFrom@ @enumFromTo@.249 The nullary constructors for the unit types are numbered left-to-right from $0$ to @maxBound@$- 1$, and provides enumerating operations @succ@, @pred@, @enumFrom@, @enumFromTo@. 217 250 \VRef[Figure]{f:HaskellEnumeration} shows enumeration comparison and iterating (enumerating). 218 251 219 252 \begin{figure} 220 253 \begin{cquote} 221 \setlength{\tabcolsep}{ 15pt}254 \setlength{\tabcolsep}{40pt} 222 255 \begin{tabular}{@{}ll@{}} 223 256 \begin{haskell} 224 257 day = Tue 225 258 main = do 226 227 228 229 230 print (enumFrom Mon) -- week 231 print (enumFromTo Mon Fri) -- weekday 232 print (enumFromTo Sat Sun) -- weekend 259 if day == Tue then 260 print day 261 else 262 putStr "not Tue" 263 print (enumFrom Mon) $\C[2.25in]{-- week}$ 264 print (enumFromTo Mon Fri) $\C{-- weekday}$ 265 print (enumFromTo Sat Sun) $\C{-- weekend}\CRT$ 233 266 \end{haskell} 234 267 & … … 251 284 252 285 The key observation is the dichotomy between an ADT and enumeration: the ADT uses the associated type resulting in a union-like data structure, and the enumeration does not use the associated type, and hence, is not a union. 253 While an enumeration is constructed using the ADT mechanism,it is so restricted it is not an ADT.286 In contrast, an enumeration may be constructed using the ADT mechanism, but it is so restricted it is not an ADT. 254 287 Furthermore, a general ADT cannot be an enumeration because the constructors generate different values making enumerating meaningless. 255 288 While functional programming languages regularly repurpose the ADT type into an enumeration type, this process seems contrived and confusing. … … 266 299 \begin{enumerate} 267 300 \item 268 overloading 301 overloading: 269 302 \item 270 303 scoping -
doc/theses/jiada_liang_MMath/uw-ethesis-frontpgs.tex
ra9ae5ca r4e107bf 131 131 \begin{center}\textbf{Abstract}\end{center} 132 132 133 % An enumeration is a type defining an ordered set of named constant values, where a name abstracts a value, \eg @PI@ versus @3.145159@. 134 % C restrict an enumeration type to the integral type @signed int@, which \CC support, meaning enumeration names bind to integer constants. 135 % \CFA extends C enumerations to allow all basic and custom types for the enumeration type, like other modern programming languages. 136 % Furthermore, \CFA adds other useful features for enumerations to support better software-engineering practices and simplify program development. 137 The \CFA (C-for-all) programming language is an evolutionary refinement of C programing language. One of its distinctive feature is the generic 138 types. But legacy data type from C, such as enumerations, does not adapt well into the \CFA generic type system. 139 140 This thesis presents an adaptation of enumerated types, in a way that integrates naturallly with the generic type feature of \CFA while being 141 backward-compatiable to C. This thesis also presents a number of smaller refinement to the \CFA overload resolution rules for enumerated types, 142 each of which improves the intuitive nature of enumerations. 143 The enumeration types improvement has been implemented into \CFA compiler and run-time environment. The root ideas behinds the change of 144 enumeration is to discover the approach of C data types working with \CFA generic types in order to improve the language expressiveity and safety. 133 An \emph{enumeration} is a type defining a (ordered) set of named constant values. 134 \begin{cfa} 135 enum Week { Mon, Tue, Wed, Thu, Fri, Sat, Sun }; 136 enum Math { PI = 3.14159, Tau = 6.28318, Phi = 1.61803 }; 137 enum RGB { Red = 100b, Green = 010b, Blue = 001b }; 138 \end{cfa} 139 Its purpose is for readability: replacing constant values in a program with symbolic names that are more meaningful to programmers in the context of the application. 140 Thereafter, associating a name to a different value automatically distributes this rebinding, preventing errors. 141 One of the key properties of an enumeration is the ability to enumerate (iterate) through the constants, and hence, access their values, if present. 142 C restricts an enumeration to the integral type @signed int@, while \CC extends enumerations to all integral types, meaning enumeration names must bind to integer constants. 143 Other modern programming languages provide bindings to any type and additional features to extend enumeration capabilities for better software-engineering practices. 144 145 The \CFA (C-for-all) programming language is an evolutionary refinement of the C programing language. 146 One of its distinctive feature is a parametric-polymorphic generic type. 147 However, legacy data types from C, such as enumerations, do not adapt well into the \CFA generic type-system. 148 149 This thesis extends the simple and unsafe enumeration type in the C programming language into a complex and safe enumeration type in the \CFA programming-language, while maintaining backwards compatibility with C. 150 The major contribution is an adaptation of enumerated types with the \CFA type-system in a way that integrates naturally with the generic types. 151 This thesis also presents a number of smaller refinement to the \CFA overload resolution rules for enumerated types, each of which improves the intuitive nature of enumeration name resolution by the compiler. 152 Finally, this work adds other useful features to enumerations that better support software-engineering practices and simplify program development. 153 145 154 \cleardoublepage 146 155 \phantomsection % allows hyperref to link to the correct page … … 151 160 \begin{center}\textbf{Acknowledgements}\end{center} 152 161 153 To begin, I would like to thank my supervisor Proferssor Peter Buhr. Thank you for your guidance and 154 support throughout my study and research. I would not be here without you. 155 156 Thanks Gregor Richards and Yzihou Zhang for reading my thesis. 162 To begin, I would like to thank my supervisor Professor Peter Buhr. 163 Thank you for your guidance and support throughout my study and research. 164 I would not be here without you. 165 166 Thanks to Gregor Richards and Yzihou Zhang for reading my thesis. 157 167 158 168 Special thanks to Andrew James Beach for your insight on the theory development on the thesis. 159 169 160 170 Thanks to Michael Brooks, Fangran Yu, Colby Parsons, Thierry Delisle, Mubeen Zulifiqar, 161 and entire Cforallteam for development of the \CFA language, making it the best language it can be.171 and the entire \CFA team for development of the \CFA language, making it the best language it can be. 162 172 163 173 Finally, a special thank you to Huawei Canada for funding this work. -
libcfa/src/enum.cfa
ra9ae5ca r4e107bf 117 117 return os | label( e ); 118 118 } 119 OSTYPE_VOID_IMPL( E )119 OSTYPE_VOID_IMPL( os, E ) 120 120 } -
libcfa/src/gmp.hfa
ra9ae5ca r4e107bf 10 10 // Created On : Tue Apr 19 08:43:43 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jul 18 11:04:54 202313 // Update Count : 3 512 // Last Modified On : Fri Aug 2 07:41:25 2024 13 // Update Count : 36 14 14 // 15 15 … … 268 268 return os; 269 269 } // ?|? 270 OSTYPE_VOID_IMPL( Int )270 OSTYPE_VOID_IMPL( os, Int ) 271 271 } // distribution 272 272 } // distribution -
libcfa/src/interpose.cfa
ra9ae5ca r4e107bf 10 10 // Created On : Wed Mar 29 16:10:31 2017 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Jan 19 16:47:35202413 // Update Count : 2 1912 // Last Modified On : Sun Jul 28 08:54:31 2024 13 // Update Count : 220 14 14 // 15 15 … … 264 264 } 265 265 266 int len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld) ", (long int)getpid() ); // use UNIX pid (versus getPid)266 int len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld): ", (long int)getpid() ); // use UNIX pid (versus getPid) 267 267 __cfaabi_bits_write( STDERR_FILENO, abort_text, len ); 268 268 -
libcfa/src/iostream.cfa
ra9ae5ca r4e107bf 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon Jul 15 08:16:48202413 // Update Count : 202 012 // Last Modified On : Fri Aug 2 07:38:44 2024 13 // Update Count : 2021 14 14 // 15 15 … … 47 47 return os; 48 48 } // ?|? 49 OSTYPE_VOID_IMPL( bool )49 OSTYPE_VOID_IMPL( os, bool ) 50 50 51 51 ostype & ?|?( ostype & os, char c ) { … … 54 54 return nosep( os ); 55 55 } // ?|? 56 OSTYPE_VOID_IMPL( char )56 OSTYPE_VOID_IMPL( os, char ) 57 57 58 58 ostype & ?|?( ostype & os, signed char sc ) { … … 61 61 return os; 62 62 } // ?|? 63 OSTYPE_VOID_IMPL( signed char )63 OSTYPE_VOID_IMPL( os, signed char ) 64 64 65 65 ostype & ?|?( ostype & os, unsigned char usc ) { … … 68 68 return os; 69 69 } // ?|? 70 OSTYPE_VOID_IMPL( unsigned char )70 OSTYPE_VOID_IMPL( os, unsigned char ) 71 71 72 72 ostype & ?|?( ostype & os, short int si ) { … … 75 75 return os; 76 76 } // ?|? 77 OSTYPE_VOID_IMPL( short int )77 OSTYPE_VOID_IMPL( os, short int ) 78 78 79 79 ostype & ?|?( ostype & os, unsigned short int usi ) { … … 82 82 return os; 83 83 } // ?|? 84 OSTYPE_VOID_IMPL( unsigned short int )84 OSTYPE_VOID_IMPL( os, unsigned short int ) 85 85 86 86 ostype & ?|?( ostype & os, int i ) { … … 89 89 return os; 90 90 } // ?|? 91 OSTYPE_VOID_IMPL( int )91 OSTYPE_VOID_IMPL( os, int ) 92 92 93 93 ostype & ?|?( ostype & os, unsigned int ui ) { … … 96 96 return os; 97 97 } // ?|? 98 OSTYPE_VOID_IMPL( unsigned int )98 OSTYPE_VOID_IMPL( os, unsigned int ) 99 99 100 100 ostype & ?|?( ostype & os, long int li ) { … … 103 103 return os; 104 104 } // ?|? 105 OSTYPE_VOID_IMPL( long int )105 OSTYPE_VOID_IMPL( os, long int ) 106 106 107 107 ostype & ?|?( ostype & os, unsigned long int uli ) { … … 110 110 return os; 111 111 } // ?|? 112 OSTYPE_VOID_IMPL( unsigned long int )112 OSTYPE_VOID_IMPL( os, unsigned long int ) 113 113 114 114 ostype & ?|?( ostype & os, long long int lli ) { … … 117 117 return os; 118 118 } // ?|? 119 OSTYPE_VOID_IMPL( long long int )119 OSTYPE_VOID_IMPL( os, long long int ) 120 120 121 121 ostype & ?|?( ostype & os, unsigned long long int ulli ) { … … 124 124 return os; 125 125 } // ?|? 126 OSTYPE_VOID_IMPL( unsigned long long int )126 OSTYPE_VOID_IMPL( os, unsigned long long int ) 127 127 128 128 #if defined( __SIZEOF_INT128__ ) … … 156 156 return os; 157 157 } // ?|? 158 OSTYPE_VOID_IMPL( int128 )158 OSTYPE_VOID_IMPL( os, int128 ) 159 159 160 160 ostype & ?|?( ostype & os, unsigned int128 ullli ) { … … 163 163 return os; 164 164 } // ?|? 165 OSTYPE_VOID_IMPL( unsigned int128 )165 OSTYPE_VOID_IMPL( os, unsigned int128 ) 166 166 #endif // __SIZEOF_INT128__ 167 167 … … 186 186 return os; 187 187 } // ?|? 188 OSTYPE_VOID_IMPL( float )188 OSTYPE_VOID_IMPL( os, float ) 189 189 190 190 ostype & ?|?( ostype & os, double d ) { … … 193 193 return os; 194 194 } // ?|? 195 OSTYPE_VOID_IMPL( double )195 OSTYPE_VOID_IMPL( os, double ) 196 196 197 197 ostype & ?|?( ostype & os, long double ld ) { … … 200 200 return os; 201 201 } // ?|? 202 OSTYPE_VOID_IMPL( long double )202 OSTYPE_VOID_IMPL( os, long double ) 203 203 204 204 ostype & ?|?( ostype & os, float _Complex fc ) { … … 210 210 return os; 211 211 } // ?|? 212 OSTYPE_VOID_IMPL( float _Complex )212 OSTYPE_VOID_IMPL( os, float _Complex ) 213 213 214 214 ostype & ?|?( ostype & os, double _Complex dc ) { … … 220 220 return os; 221 221 } // ?|? 222 OSTYPE_VOID_IMPL( double _Complex )222 OSTYPE_VOID_IMPL( os, double _Complex ) 223 223 224 224 ostype & ?|?( ostype & os, long double _Complex ldc ) { … … 230 230 return os; 231 231 } // ?|? 232 OSTYPE_VOID_IMPL( long double _Complex )232 OSTYPE_VOID_IMPL( os, long double _Complex ) 233 233 234 234 ostype & ?|?( ostype & os, const char s[] ) { … … 273 273 // return write( os, s, len ); 274 274 } // ?|? 275 OSTYPE_VOID_IMPL( const char * )275 OSTYPE_VOID_IMPL( os, const char * ) 276 276 277 277 // ostype & ?|?( ostype & os, const char16_t s[] ) { … … 300 300 return os; 301 301 } // ?|? 302 OSTYPE_VOID_IMPL( const void * )302 OSTYPE_VOID_IMPL( os, const void * ) 303 303 304 304 // manipulators … … 487 487 return os; \ 488 488 } /* ?|? */ \ 489 OSTYPE_VOID_IMPL( _Ostream_Manip(T) ) \489 OSTYPE_VOID_IMPL( os, _Ostream_Manip(T) ) \ 490 490 } // distribution 491 491 … … 585 585 return os; \ 586 586 } /* ?|? */ \ 587 OSTYPE_VOID_IMPL( _Ostream_Manip(T) ) \587 OSTYPE_VOID_IMPL( os, _Ostream_Manip(T) ) \ 588 588 } // distribution 589 589 … … 683 683 } /* ?|? */ \ 684 684 \ 685 OSTYPE_VOID_IMPL( _Ostream_Manip(T) ) \685 OSTYPE_VOID_IMPL( os, _Ostream_Manip(T) ) \ 686 686 } // distribution 687 687 … … 718 718 return os; 719 719 } // ?|? 720 OSTYPE_VOID_IMPL( _Ostream_Manip(char) )720 OSTYPE_VOID_IMPL( os, _Ostream_Manip(char) ) 721 721 } // distribution 722 722 … … 765 765 return os; 766 766 } // ?|? 767 OSTYPE_VOID_IMPL( _Ostream_Manip(const char *) )767 OSTYPE_VOID_IMPL( os, _Ostream_Manip(const char *) ) 768 768 } // distribution 769 769 -
libcfa/src/iostream.hfa
ra9ae5ca r4e107bf 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Jul 12 05:45:48202413 // Update Count : 7 5912 // Last Modified On : Fri Aug 2 07:37:57 2024 13 // Update Count : 760 14 14 // 15 15 … … 75 75 76 76 #define OSTYPE_VOID( T ) void ?|?( ostype &, T ) 77 #define OSTYPE_VOID_IMPL( T ) \77 #define OSTYPE_VOID_IMPL( os, T ) \ 78 78 void ?|?( ostype & os, T t ) { \ 79 79 (ostype &)(os | t); ends( os ); \ -
libcfa/src/rational.cfa
ra9ae5ca r4e107bf 10 10 // Created On : Wed Apr 6 17:54:28 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Oct 6 07:52:13 202313 // Update Count : 19 812 // Last Modified On : Fri Aug 2 07:41:25 2024 13 // Update Count : 199 14 14 // 15 15 … … 206 206 return os | r.numerator | '/' | r.denominator; 207 207 } // ?|? 208 OSTYPE_VOID_IMPL( rational(T) )208 OSTYPE_VOID_IMPL( os, rational(T) ) 209 209 } // distribution 210 210 } // distribution -
libcfa/src/time.cfa
ra9ae5ca r4e107bf 10 10 // Created On : Tue Mar 27 13:33:14 2018 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jul 18 10:55:01 202313 // Update Count : 7 112 // Last Modified On : Fri Aug 2 07:41:24 2024 13 // Update Count : 72 14 14 // 15 15 … … 43 43 return os; 44 44 } // ?|? 45 OSTYPE_VOID_IMPL( Duration )45 OSTYPE_VOID_IMPL( os, Duration ) 46 46 } // distribution 47 47 … … 152 152 return os; 153 153 } // ?|? 154 OSTYPE_VOID_IMPL( Time )154 OSTYPE_VOID_IMPL( os, Time ) 155 155 } // distribution 156 156 -
libcfa/src/vec/vec2.hfa
ra9ae5ca r4e107bf 283 283 return os | '<' | x | ',' | y | '>'; 284 284 } 285 OSTYPE_VOID_IMPL( vec2(T) )285 OSTYPE_VOID_IMPL( os, vec2(T) ) 286 286 } -
libcfa/src/vec/vec3.hfa
ra9ae5ca r4e107bf 292 292 return os | '<' | x | ',' | y | ',' | z | '>'; 293 293 } 294 OSTYPE_VOID_IMPL( vec3(T) )294 OSTYPE_VOID_IMPL( os, vec3(T) ) 295 295 } -
libcfa/src/vec/vec4.hfa
ra9ae5ca r4e107bf 287 287 return os | '<' | x | ',' | y | ',' | z | ',' | w | '>'; 288 288 } 289 OSTYPE_VOID_IMPL( vec4(T) )289 OSTYPE_VOID_IMPL( os, vec4(T) ) 290 290 } 291 291 -
tests/ctrl-flow/.expect/loopctrl.txt
ra9ae5ca r4e107bf 61 61 (10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)(0 0) 62 62 63 3 4 5 6 7 8 9 64 3 4 5 6 7 8 9 65 10 9 8 7 6 5 4 66 3.5 4.5 5.5 6.5 7.5 8.5 9.5 67 abcde 68 edcba 69 (0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6) 70 (1 1)(2 2)(3 3)(4 4)(5 5)(6 6) 71 (3 0)(4 1)(5 2)(6 3) 72 (7 0)(6 -1)(5 -2)(4 -3) 73 63 74 A A A A A A A A A A 64 75 B B B B B B B B B B B … … 108 119 0 -2 -4 -6 -8 109 120 0 1 2 3 4 5 6 7 8 9 121 A B C D 122 D C B A -
tests/ctrl-flow/loopctrl.cfa
ra9ae5ca r4e107bf 10 10 // Created On : Wed Aug 8 18:32:59 2018 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Thu Jun 27 11:00:09202413 // Update Count : 1 6112 // Last Modified On : Fri Aug 2 08:42:55 2024 13 // Update Count : 185 14 14 // 15 15 16 16 #include <fstream.hfa> 17 #include <enum.hfa> 17 18 18 19 void fred() { … … 81 82 for ( int j; s ~ @ ~ @ ) { if ( j == 10 ) break; sout | j; j += 1; } sout | nl; 82 83 83 // enumE { A, B, C, D };84 // for ( e; A ~= C ) { sout | j; } 85 // for ( e; A ~= D ) { sout | j; } 86 // for ( e; A -~= D ~ 2 ) { sout | j; } 87 // for ( e; E ) { sout | j; }88 // for ( e; -~ E ) { sout | j; }84 enum(int) E { A, B, C, D }; 85 // for ( E e; A ~= C ) { sout | e; } sout | nl; 86 // for ( e; A ~= D ) { sout | e; } sout | nl; 87 // for ( e; A -~= D ~ 2 ) { sout | e; } sout | nl; 88 for ( e; E ) { sout | e; } sout | nl; 89 for ( e; -~= E ) { sout | e; } sout | nl; 89 90 } 90 91 … … 95 96 void ?{}( S & s, zero_t ) { s.[i, j] = 0; } 96 97 void ?{}( S & s, one_t ) { s.[i, j] = 1; } 97 int ?<?( S t1, S t2 ) { return t1.i < t2.i && t1.j < t2.j; }98 int ?<=?( S t1, S t2 ) { return t1.i <= t2.i && t1.j <= t2.j; }99 int ?>?( S t1, S t2 ) { return t1.i > t2.i && t1.j > t2.j; }100 int ?>=?( S t1, S t2 ) { return t1.i >= t2.i && t1.j >= t2.j; }101 S ?+=?( S & t1, S t2 ) { t1.i += t2.i; t1.j += t2.j; return t1; }102 S ?+=?( S & t, one_t ) { t.i += 1; t.j += 1; return t; }103 S ?-=?( S & t1, S t2 ) { t1.i -= t2.i; t1.j -= t2.j; return t1; }104 S ?-=?( S & t, one_t ) { t.i -= 1; t.j -= 1; return t; }105 ofstream & ?|?( ofstream & os, S v ) { return os | '(' | v.i | v.j | ')'; }106 void & ?|?( ofstream & os, S v ) { (ofstream &)(os | v); ends( os ); }98 int ?<?( S s1, S s2 ) { return s1.i < s2.i || s1.j < s2.j; } 99 int ?<=?( S s1, S s2 ) { return s1.i <= s2.i || s1.j <= s2.j; } 100 int ?>?( S s1, S s2 ) { return s1.i > s2.i || s1.j > s2.j; } 101 int ?>=?( S s1, S s2 ) { return s1.i >= s2.i || s1.j >= s2.j; } 102 S ?+=?( S & s1, S s2 ) { s1.i += s2.i; s1.j += s2.j; return s1; } 103 S ?+=?( S & s, one_t ) { s.i += 1; s.j += 1; return s; } 104 S ?-=?( S & s1, S s2 ) { s1.i -= s2.i; s1.j -= s2.j; return s1; } 105 S ?-=?( S & s, one_t ) { s.i -= 1; s.j -= 1; return s; } 106 ofstream & ?|?( ofstream & os, S s ) { return os | '(' | s.i | s.j | ')'; } 107 void & ?|?( ofstream & os, S s ) { (ofstream &)(os | s); ends( os ); } 107 108 108 109 int main() { … … 183 184 for ( k; 1.5 ~ @ : j; @ -~ -5 ~ 2 : i; 10 ) { sout | i | j | k; } sout | nl; 184 185 185 for ( S s = (S){0}; s < (S){10,10}; s += (S){1} ) { sout | s; } sout | nl; 186 for ( S s = (S){0}; s < (S){10,10}; s += (S){1} ) { sout | s; } sout | nl; // 0 does not work 186 187 for ( s; (S){10,10} ) { sout | s; } sout | nl; 187 188 sout | nl; … … 196 197 for ( s; (S){0} -~= (S){10,10} ~ (S){1} ) { sout | s; } sout | nl | nl; 197 198 199 int i = 10; 200 double d = 10.; 201 char c = 'e'; 202 S s = { 7 }; 203 204 for ( anon; 3 ~ i ) sout | anon; sout | nl; 205 for ( anon; 3 ~ i ) sout | anon; sout | nl; 206 for ( anon; 3 -~ i ) sout | anon; sout | nl; 207 for ( anon; 3.5 ~ d ) sout | anon; sout | nl; 208 for ( anon; 'a' ~= c ) sout | anon; sout | nl; 209 for ( anon; 'a' -~= c ) sout | anon; sout | nl; 210 for ( anon; (S){0} ~ s ) sout | anon; sout | nl; // 0 does not work 211 for ( anon; (S){1} ~ s ) sout | anon; sout | nl; // 1 does not work 212 for ( anon; (S){3} ~ s ) sout | anon; sout | nl; 213 for ( anon; (S){3} -~ s ) sout | anon; sout | nl | nl; 214 198 215 fred(); 199 216 }
Note:
See TracChangeset
for help on using the changeset viewer.