Changeset b72bad4f


Ignore:
Timestamp:
Apr 27, 2016, 10:52:23 PM (6 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
8bc4ef8
Parents:
dc5376a
Message:

add math library to user manual, fix sepDisable bug in iostream

Files:
5 edited

Legend:

Unmodified
Added
Removed
  • doc/user/user.tex

    rdc5376a rb72bad4f  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Thu Apr 21 08:15:37 2016
    14 %% Update Count     : 131
     13%% Last Modified On : Wed Apr 27 22:39:40 2016
     14%% Update Count     : 160
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    226226
    227227
    228 \section{Compiling \CFA Program}
     228\section[Compiling CFA Program]{Compiling \CFA Program}
    229229
    230230The command \lstinline@cfa@ is used to compile \CFA program(s).
     
    269269\item
    270270\hspace*{-4pt}\lstinline$__CFA_PATCH__$
    271 \index{__CFA_PATCH__@%(__CFA_PATCH__%)}\index{preprocessor variables!__CFA_PATCH__@%(__CFA_PATCH__%)}
     271\index{__CFA_PATCH__@\lstinline$__CFA_PATCH__$)}\index{preprocessor variables!__CFA_PATCH__@\lstinline$__CFA_PATCH__$}
    272272is always available during preprocessing and its value is the current patch \Index{version number} of \CFA.
    273273
    274274\item
    275275\hspace*{-4pt}\lstinline$__CFORALL__$
    276 \index{__CFORALL__@%(__CFORALL__%)}\index{preprocessor variables!__CFORALL__@%(__CFORALL__%)}
     276\index{__CFORALL__@\lstinline$__CFORALL__$}\index{preprocessor variables!__CFORALL__@\lstinline$__CFORALL__$}
    277277is always available during preprocessing and it has no value.
    278278\end{description}
     
    781781\subsection{Type Nesting}
    782782
    783 \CFA allows \Index{type nesting}, and type qualification of the nested types, where as C hoists\index{type!hoisting} (refactors) nested types into the enclosing scope and has no type qualification.
     783\CFA allows \Index{type nesting}, and type qualification of the nested types, where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification.
    784784\begin{quote2}
    785785\begin{tabular}{@{}l@{\hspace{30pt}}l|l@{}}
     
    33253325
    33263326
    3327 \subsection{Comparing Key Features of \CFA}
     3327\subsection[Comparing Key Features of CFA]{Comparing Key Features of \CFA}
    33283328
    33293329
     
    36993699
    37003700\begin{comment}
    3701 \subsubsection{Modules/Packages}
     3701\subsubsection{Modules / Packages}
    37023702
    37033703\begin{lstlisting}
     
    39413941
    39423942
    3943 \subsubsection{\CC}
     3943\subsubsection[C++]{\CC}
    39443944
    39453945\CC is a general-purpose programming language.
     
    41604160A seperator does not appear at the start or end of a line.
    41614161\begin{lstlisting}[belowskip=0pt]
    4162 sout 1 | 2 | 3 | endl;
     4162sout | 1 | 2 | 3 | endl;
    41634163\end{lstlisting}
    41644164\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
     
    41794179which is a local mechanism to disable insertion of the separator character.
    41804180\item
    4181 A seperator does not appear before a C string starting with the \Index{extended ASCII}\index{ASCII} characters: \lstinline[mathescape=off]@([{$£¥¿«@
     4181A seperator does not appear before a C string starting with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off]@([{$£¥¿«@
    41824182%$
    41834183\begin{lstlisting}[mathescape=off]
     
    41904190%$
    41914191\item
    4192 A seperator does not appear after a C string ending with the extended ASCII characters: \lstinline@,.:;!?)]}%¢»@
     4192A seperator does not appear after a C string ending with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline@,.:;!?)]}%¢»@
    41934193\begin{lstlisting}[belowskip=0pt]
    41944194sout | 1 | ", x" | 2 | ". x" | 3 | ": x" | 4 | "; x" | 5 | "! x" | 6 | "? x" | 7 | ") x" | 8 | "] x" | 9 | "} x"
     
    41994199\end{lstlisting}
    42004200\item
    4201 A seperator does not appear before or after a C string begining/ending with the characters: \lstinline@\f\n\r\t\v\`'"@
     4201A seperator does not appear before or after a C string begining/ending with the characters: \lstinline[showspaces=true]@\`'" \f\n\r\t\v@
    42024202\begin{lstlisting}[belowskip=0pt]
    4203 sout | "x '" | 1 | "' x \`" | 2 | "\` x \"" | 3 | "\" x" | endl;
     4203sout | "x\`" | 1 | "\`x'" | 2 | "'x\"" | 3 | "\"x" | "x " | 4 | " x" | endl;
    42044204\end{lstlisting}
    42054205\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    4206 x '1' x \`2\` x "3" x
     4206x\`1\`x'2'x"3"x x 4 x
    42074207\end{lstlisting}
    42084208\begin{lstlisting}[showtabs=true,aboveskip=0pt]
     
    42404240\end{lstlisting}
    42414241\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    4242 1 2 3
     4242 1 2 3
    42434243\end{lstlisting}
    42444244\begin{lstlisting}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt]
     
    42514251\end{lstlisting}
    42524252%$
    4253 \VRef[Figure]{f:ExampleIO} shows an example of input and output I/O in \CFA.
    4254 
    4255 \begin{figure}
    4256 \begin{lstlisting}[mathescape=off]
     4253\begin{comment}
    42574254#include <fstream>
    42584255
    42594256int main() {
    4260         char c;                                                                                                         // basic types
    4261         short int si;
    4262         unsigned short int usi;
    4263         int i;
    4264         unsigned int ui;
    4265         long int li;
    4266         unsigned long int uli;
    4267         long long int lli;
    4268         unsigned long long int ulli;
    4269         float f;
    4270         double d;
    4271         long double ld;
    4272         float _Complex fc;
    4273         double _Complex dc;
    4274         long double _Complex ldc;
    4275         char s1[10], s2[10];
    4276 
    4277         ifstream in;                                                                                            // create / open file
    4278         open( &in, "input.data", "r" );
    4279 
    4280         &in | &c                                                                                                        // character
    4281                 | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli             // integral
    4282                 | &f | &d | &ld                                                                                 // floating point
    4283                 | &fc | &dc | &ldc                                                                              // floating-point complex
    4284                 | cstr( s1 ) | cstr( s2, 10 );                                                  // C string, length unchecked and checked
    4285 
    4286         sout | c | ' ' | endl                                                                           // character
    4287                  | si | usi | i | ui | li | uli | lli | ulli | endl             // integral
    4288                  | f | d | ld | endl                                                                    // floating point
    4289                  | fc | dc | ldc | endl;                                                                // complex
    4290         sout | endl;
    4291         sout | f | "" | d | "" | ld | endl                                                      // floating point without separator
    4292                  | sepDisable | fc | dc | ldc | sepEnable | endl                // complex without separator
    4293                  | sepOn | s1 | sepOff | s2 | endl                                              // local separator removal
    4294                  | s1 | "" | s2 | endl;                                                                 // C string withou separator
    4295         sout | endl;
    4296         sepSet( sout, ", $" );                                                                          // change separator, maximum of 15 characters
    4297         sout | f | d | ld | endl                                                                        // floating point without separator
    4298                  | fc | dc | ldc | endl                                                                 // complex without separator
    4299                  | s1 | s2 | endl;
    4300 }
    4301 
    4302 $ cat input.data
    4303 A 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz
    4304 $ a.out
    4305 A
    4306 1 2 3 4 5 6 7 8
    4307 1.1 1.2 1.3
    4308 1.1+2.3i 1.1-2.3i 1.1-2.3i
    4309 
    4310 1.11.21.3
    4311 1.1+2.3i1.1-2.3i1.1-2.3i
    4312  abcxyz
    4313 abcxyz
    4314 
    4315 1.1, $1.2, $1.3
    4316 1.1+2.3i, $1.1-2.3i, $1.1-2.3i
    4317 abc, $xyz
    4318 \end{lstlisting}
    4319 \caption{Example I/O}
    4320 \label{f:ExampleIO}
    4321 \end{figure}
     4257        int x = 3, y = 5, z = 7;
     4258        sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
     4259        sout | 1 | 2 | 3 | endl;
     4260        sout | '1' | '2' | '3' | endl;
     4261        sout | 1 | "" | 2 | "" | 3 | endl;
     4262        sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x $" | 4 | "x £" | 5 | "x ¥" | 6 | "x ¿" | 7 | "x «" | 8 | endl;
     4263        sout | 1 | ", x" | 2 | ". x" | 3 | ": x" | 4 | "; x" | 5 | "! x" | 6 | "? x" | 7 | ") x" | 8 | "] x" | 9 | "} x"
     4264                 | 10 | "% x" | 11 | L"¢ x" | 12 | L"» x" | endl;
     4265        sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x" | "x " | 4 | " x" | endl;
     4266        sout | "x\t" | 1 | "\tx" | endl;
     4267        sout | sepOn | 1 | 2 | 3 | sepOn | endl;        // separator at start of line
     4268        sout | 1 | sepOff | 2 | 3 | endl;                       // turn off implicit separator temporarily
     4269        sout | sepDisable | 1 | 2 | 3 | endl;           // turn off implicit separation, affects all subsequent prints
     4270        sout | 1 | sepOn | 2 | 3 | endl;                        // turn on implicit separator temporarily
     4271        sout | sepEnable | 1 | 2 | 3 | endl;            // turn on implicit separation, affects all subsequent prints
     4272        sepSet( sout, ", $" );                                          // change separator from " " to ", $"
     4273        sout | 1 | 2 | 3 | endl;
     4274
     4275}
     4276
     4277// Local Variables: //
     4278// tab-width: 4 //
     4279// End: //
     4280\end{comment}
     4281%$
    43224282
    43234283
     
    43354295forall( otype T ) T * malloc( T * ptr, size_t size );
    43364296forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
    4337 forall( otype T ) T * calloc( size_t size );
     4297forall( otype T ) T * calloc( size_t nmemb );
    43384298forall( otype T ) T * realloc( T * ptr, size_t size );
    43394299forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
     
    43484308
    43494309
    4350 \subsection{ato/strto}
     4310\subsection{ato / strto}
    43514311
    43524312\begin{lstlisting}
     
    43794339
    43804340
    4381 \subsection{bsearch/qsort}
     4341\subsection{bsearch / qsort}
    43824342
    43834343\begin{lstlisting}
     
    43944354\begin{lstlisting}
    43954355char abs( char );
    4396 extern "C" {
    4397 int abs( int );                         // use default C routine for int
    4398 } // extern "C"
     4356int abs( int );
    43994357long int abs( long int );
    44004358long long int abs( long long int );
     
    44024360double abs( double );
    44034361long double abs( long double );
    4404 float _Complex abs( float _Complex );
    4405 double _Complex abs( double _Complex );
    4406 long double _Complex abs( long double _Complex );
    4407 \end{lstlisting}
    4408 
    4409 
    4410 \subsection{floor/ceil}
    4411 
    4412 \begin{lstlisting}
    4413 float floor( float );
    4414 extern "C" {
    4415 double floor( double );         // use C routine for double
    4416 } // extern "C"
    4417 long double floor( long double );
    4418 
    4419 float ceil( float );
    4420 extern "C" {
    4421 double ceil( double );          // use C routine for double
    4422 } // extern "C"
    4423 long double ceil( long double );
     4362float abs( float _Complex );
     4363double abs( double _Complex );
     4364long double abs( long double _Complex );
    44244365\end{lstlisting}
    44254366
     
    44424383
    44434384
    4444 \subsection{min/max/swap}
     4385\subsection{min / max / swap}
    44454386
    44464387\begin{lstlisting}
     
    44534394forall( otype T )
    44544395void swap( T * t1, T * t2 );
     4396\end{lstlisting}
     4397
     4398
     4399\section{Math Library}
     4400\label{s:Math Library}
     4401
     4402The goal of the \CFA math-library is to wrap many of the existing C math library-routines that are explicitly polymorphic into implicitly polymorphic versions.
     4403
     4404
     4405\subsection{General}
     4406
     4407\begin{lstlisting}
     4408float fabs( float );
     4409double fabs( double );
     4410long double fabs( long double );
     4411float cabs( float _Complex );
     4412double cabs( double _Complex );
     4413long double cabs( long double _Complex );
     4414
     4415float ?%?( float, float );
     4416float fmod( float, float );
     4417double ?%?( double, double );
     4418double fmod( double, double );
     4419long double ?%?( long double, long double );
     4420long double fmod( long double, long double );
     4421
     4422float remainder( float, float );
     4423double remainder( double, double );
     4424long double remainder( long double, long double );
     4425
     4426[ int, float ] remquo( float, float );
     4427float remquo( float, float, int * );
     4428[ int, double ] remquo( double, double );
     4429double remquo( double, double, int * );
     4430[ int, long double ] remquo( long double, long double );
     4431long double remquo( long double, long double, int * );
     4432
     4433[ int, float ] div( float, float );                                             // alternative name for remquo
     4434float div( float, float, int * );
     4435[ int, double ] div( double, double );
     4436double div( double, double, int * );
     4437[ int, long double ] div( long double, long double );
     4438long double div( long double, long double, int * );
     4439
     4440float fma( float, float, float );
     4441double fma( double, double, double );
     4442long double fma( long double, long double, long double );
     4443
     4444float fdim( float, float );
     4445double fdim( double, double );
     4446long double fdim( long double, long double );
     4447
     4448float nan( const char * );
     4449double nan( const char * );
     4450long double nan( const char * );
     4451\end{lstlisting}
     4452
     4453
     4454\subsection{Exponential}
     4455
     4456\begin{lstlisting}
     4457float exp( float );
     4458double exp( double );
     4459long double exp( long double );
     4460float _Complex exp( float _Complex );
     4461double _Complex exp( double _Complex );
     4462long double _Complex exp( long double _Complex );
     4463
     4464float exp2( float );
     4465double exp2( double );
     4466long double exp2( long double );
     4467// float _Complex exp2( float _Complex );
     4468// double _Complex exp2( double _Complex );
     4469// long double _Complex exp2( long double _Complex );
     4470
     4471float expm1( float );
     4472double expm1( double );
     4473long double expm1( long double );
     4474
     4475float log( float );
     4476double log( double );
     4477long double log( long double );
     4478float _Complex log( float _Complex );
     4479double _Complex log( double _Complex );
     4480long double _Complex log( long double _Complex );
     4481
     4482float log2( float );
     4483double log2( double );
     4484long double log2( long double );
     4485// float _Complex log2( float _Complex );
     4486// double _Complex log2( double _Complex );
     4487// long double _Complex log2( long double _Complex );
     4488
     4489float log10( float );
     4490double log10( double );
     4491long double log10( long double );
     4492// float _Complex log10( float _Complex );
     4493// double _Complex log10( double _Complex );
     4494// long double _Complex log10( long double _Complex );
     4495
     4496float log1p( float );
     4497double log1p( double );
     4498long double log1p( long double );
     4499
     4500int ilogb( float );
     4501int ilogb( double );
     4502int ilogb( long double );
     4503
     4504float logb( float );
     4505double logb( double );
     4506long double logb( long double );
     4507\end{lstlisting}
     4508
     4509
     4510\subsection{Power}
     4511
     4512\begin{lstlisting}
     4513float sqrt( float );
     4514double sqrt( double );
     4515long double sqrt( long double );
     4516float _Complex sqrt( float _Complex );
     4517double _Complex sqrt( double _Complex );
     4518long double _Complex sqrt( long double _Complex );
     4519
     4520float cbrt( float );
     4521double cbrt( double );
     4522long double cbrt( long double );
     4523
     4524float hypot( float, float );
     4525double hypot( double, double );
     4526long double hypot( long double, long double );
     4527
     4528float pow( float, float );
     4529double pow( double, double );
     4530long double pow( long double, long double );
     4531float _Complex pow( float _Complex, float _Complex );
     4532double _Complex pow( double _Complex, double _Complex );
     4533long double _Complex pow( long double _Complex, long double _Complex );
     4534\end{lstlisting}
     4535
     4536
     4537\subsection{Trigonometric}
     4538
     4539\begin{lstlisting}
     4540float sin( float );
     4541double sin( double );
     4542long double sin( long double );
     4543float _Complex sin( float _Complex );
     4544double _Complex sin( double _Complex );
     4545long double _Complex sin( long double _Complex );
     4546
     4547float cos( float );
     4548double cos( double );
     4549long double cos( long double );
     4550float _Complex cos( float _Complex );
     4551double _Complex cos( double _Complex );
     4552long double _Complex cos( long double _Complex );
     4553
     4554float tan( float );
     4555double tan( double );
     4556long double tan( long double );
     4557float _Complex tan( float _Complex );
     4558double _Complex tan( double _Complex );
     4559long double _Complex tan( long double _Complex );
     4560
     4561float asin( float );
     4562double asin( double );
     4563long double asin( long double );
     4564float _Complex asin( float _Complex );
     4565double _Complex asin( double _Complex );
     4566long double _Complex asin( long double _Complex );
     4567
     4568float acos( float );
     4569double acos( double );
     4570long double acos( long double );
     4571float _Complex acos( float _Complex );
     4572double _Complex acos( double _Complex );
     4573long double _Complex acos( long double _Complex );
     4574
     4575float atan( float );
     4576double atan( double );
     4577long double atan( long double );
     4578float _Complex atan( float _Complex );
     4579double _Complex atan( double _Complex );
     4580long double _Complex atan( long double _Complex );
     4581
     4582float atan2( float, float );
     4583double atan2( double, double );
     4584long double atan2( long double, long double );
     4585
     4586float atan( float, float );                                                             // alternative name for atan2
     4587double atan( double, double );
     4588long double atan( long double, long double );
     4589\end{lstlisting}
     4590
     4591
     4592\subsection{Hyperbolic}
     4593
     4594\begin{lstlisting}
     4595float sinh( float );
     4596double sinh( double );
     4597long double sinh( long double );
     4598float _Complex sinh( float _Complex );
     4599double _Complex sinh( double _Complex );
     4600long double _Complex sinh( long double _Complex );
     4601
     4602float cosh( float );
     4603double cosh( double );
     4604long double cosh( long double );
     4605float _Complex cosh( float _Complex );
     4606double _Complex cosh( double _Complex );
     4607long double _Complex cosh( long double _Complex );
     4608
     4609float tanh( float );
     4610double tanh( double );
     4611long double tanh( long double );
     4612float _Complex tanh( float _Complex );
     4613double _Complex tanh( double _Complex );
     4614long double _Complex tanh( long double _Complex );
     4615
     4616float asinh( float );
     4617double asinh( double );
     4618long double asinh( long double );
     4619float _Complex asinh( float _Complex );
     4620double _Complex asinh( double _Complex );
     4621long double _Complex asinh( long double _Complex );
     4622
     4623float acosh( float );
     4624double acosh( double );
     4625long double acosh( long double );
     4626float _Complex acosh( float _Complex );
     4627double _Complex acosh( double _Complex );
     4628long double _Complex acosh( long double _Complex );
     4629
     4630float atanh( float );
     4631double atanh( double );
     4632long double atanh( long double );
     4633float _Complex atanh( float _Complex );
     4634double _Complex atanh( double _Complex );
     4635long double _Complex atanh( long double _Complex );
     4636\end{lstlisting}
     4637
     4638
     4639\subsection{Error / Gamma}
     4640
     4641\begin{lstlisting}
     4642float erf( float );
     4643double erf( double );
     4644long double erf( long double );
     4645// float _Complex erf( float _Complex );
     4646// double _Complex erf( double _Complex );
     4647// long double _Complex erf( long double _Complex );
     4648
     4649float erfc( float );
     4650double erfc( double );
     4651long double erfc( long double );
     4652// float _Complex erfc( float _Complex );
     4653// double _Complex erfc( double _Complex );
     4654// long double _Complex erfc( long double _Complex );
     4655
     4656float lgamma( float );
     4657double lgamma( double );
     4658long double lgamma( long double );
     4659float lgamma( float, int * );
     4660double lgamma( double, int * );
     4661long double lgamma( long double, int * );
     4662
     4663float tgamma( float );
     4664double tgamma( double );
     4665long double tgamma( long double );
     4666\end{lstlisting}
     4667
     4668
     4669\subsection{Nearest Integer}
     4670
     4671\begin{lstlisting}[escapechar=^]
     4672float floor( float );^\index{floor@\lstinline$floor$}^
     4673double floor( double );
     4674long double floor( long double );
     4675
     4676float ceil( float );^\index{ceil@\lstinline$ceil$}^
     4677double ceil( double );
     4678long double ceil( long double );
     4679
     4680float trunc( float );^\index{trunc@\lstinline$trunc$}^
     4681double trunc( double );
     4682long double trunc( long double );
     4683
     4684float rint( float );^\index{rint@\lstinline$rint$}^
     4685long double rint( long double );
     4686long int rint( float );
     4687long int rint( double );
     4688long int rint( long double );
     4689long long int rint( float );
     4690long long int rint( double );
     4691long long int rint( long double );
     4692
     4693long int lrint( float );^\index{lrint@\lstinline$lrint$}^
     4694long int lrint( double );
     4695long int lrint( long double );
     4696long long int llrint( float );
     4697long long int llrint( double );
     4698long long int llrint( long double );
     4699
     4700float nearbyint( float );^\index{nearbyint@\lstinline$nearbyint$}^
     4701double nearbyint( double );
     4702long double nearbyint( long double );
     4703
     4704float round( float );^\index{round@\lstinline$round$}^
     4705long double round( long double );
     4706long int round( float );
     4707long int round( double );
     4708long int round( long double );
     4709long long int round( float );
     4710long long int round( double );
     4711long long int round( long double );
     4712
     4713long int lround( float );^\index{lround@\lstinline$lround$}^
     4714long int lround( double );
     4715long int lround( long double );
     4716long long int llround( float );
     4717long long int llround( double );
     4718long long int llround( long double );
     4719\end{lstlisting}
     4720
     4721
     4722\subsection{Manipulation}
     4723
     4724\begin{lstlisting}[escapechar=^]
     4725float copysign( float, float );^\index{copysign@\lstinline$copysign$}^
     4726double copysign( double, double );
     4727long double copysign( long double, long double );
     4728
     4729float frexp( float, int * );^\index{frexp@\lstinline$frexp$}^
     4730double frexp( double, int * );
     4731long double frexp( long double, int * );
     4732
     4733float ldexp( float, int );^\index{ldexp@\lstinline$ldexp$}^
     4734double ldexp( double, int );
     4735long double ldexp( long double, int );
     4736
     4737[ float, float ] modf( float );^\index{modf@\lstinline$modf$}^
     4738float modf( float, float * );
     4739[ double, double ] modf( double );
     4740double modf( double, double * );
     4741[ long double, long double ] modf( long double );
     4742long double modf( long double, long double * );
     4743
     4744float nextafter( float, float );^\index{nextafter@\lstinline$nextafter$}^
     4745double nextafter( double, double );
     4746long double nextafter( long double, long double );
     4747
     4748float nexttoward( float, long double );^\index{nexttoward@\lstinline$nexttoward$}^
     4749double nexttoward( double, long double );
     4750long double nexttoward( long double, long double );
     4751
     4752float scalbn( float, int );^\index{scalbn@\lstinline$scalbn$}^
     4753double scalbn( double, int );
     4754long double scalbn( long double, int );
     4755
     4756float scalbln( float, long int );^\index{scalbln@\lstinline$scalbln$}^
     4757double scalbln( double, long int );
     4758long double scalbln( long double, long int );
    44554759\end{lstlisting}
    44564760
  • src/examples/io.c

    rdc5376a rb72bad4f  
    1111// Created On       : Wed Mar  2 16:56:02 2016
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Wed Apr 13 23:03:14 2016
    14 // Update Count     : 22
     13// Last Modified On : Wed Apr 27 22:45:31 2016
     14// Update Count     : 26
    1515//
    1616
     
    5252                 | sepDisable | fc | dc | ldc | sepEnable | endl                // complex without separator
    5353                 | sepOn | s1 | sepOff | s2 | endl                                              // local separator removal
    54                  | s1 | "" | s2 | endl;                                                                 // C string withou separator
     54                 | s1 | "" | s2 | endl;                                                                 // C string without separator
    5555        sout | endl;
    5656
  • src/libcfa/fstream.c

    rdc5376a rb72bad4f  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Apr  6 17:55:27 2016
    13 // Update Count     : 176
     12// Last Modified On : Wed Apr 27 18:20:30 2016
     13// Update Count     : 187
    1414//
    1515
     
    9393int prtfmt( ofstream * os, const char fmt[], ... ) {
    9494    va_list args;
    95 
    9695    va_start( args, fmt );
    9796    int len = vfprintf( (FILE *)(os->file), fmt, args );
     
    103102        } // if
    104103    va_end( args );
     104
     105        sepReset( os );                                                                         // reset separator
    105106        return len;
    106107} // prtfmt
  • src/libcfa/iostream.c

    rdc5376a rb72bad4f  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Apr  6 16:13:29 2016
    13 // Update Count     : 278
     12// Last Modified On : Wed Apr 27 20:35:13 2016
     13// Update Count     : 294
    1414//
    1515
     
    3434ostype * ?|?( ostype *os, short int si ) {
    3535        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    36         sepReset( os );
    3736        prtfmt( os, "%hd", si );
    3837        return os;
     
    4241ostype * ?|?( ostype *os, unsigned short int usi ) {
    4342        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    44         sepReset( os );
    4543        prtfmt( os, "%hu", usi );
    4644        return os;
     
    5048ostype * ?|?( ostype *os, int i ) {
    5149        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    52         sepReset( os );
    5350        prtfmt( os, "%d", i );
    5451        return os;
     
    5855ostype * ?|?( ostype *os, unsigned int ui ) {
    5956        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    60         sepReset( os );
    6157        prtfmt( os, "%u", ui );
    6258        return os;
     
    6662ostype * ?|?( ostype *os, long int li ) {
    6763        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    68         sepReset( os );
    6964        prtfmt( os, "%ld", li );
    7065        return os;
     
    7469ostype * ?|?( ostype *os, unsigned long int uli ) {
    7570        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    76         sepReset( os );
    7771        prtfmt( os, "%lu", uli );
    7872        return os;
     
    8276ostype * ?|?( ostype *os, long long int lli ) {
    8377        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    84         sepReset( os );
    8578        prtfmt( os, "%lld", lli );
    8679        return os;
     
    9083ostype * ?|?( ostype *os, unsigned long long int ulli ) {
    9184        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    92         sepReset( os );
    9385        prtfmt( os, "%llu", ulli );
    9486        return os;
     
    9890ostype * ?|?( ostype *os, float f ) {
    9991        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    100         sepReset( os );
    10192        prtfmt( os, "%g", f );
    10293        return os;
     
    10697ostype * ?|?( ostype *os, double d ) {
    10798        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    108         sepReset( os );
    10999        prtfmt( os, "%.*lg", DBL_DIG, d );
    110100        return os;
     
    114104ostype * ?|?( ostype *os, long double ld ) {
    115105        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    116         sepReset( os );
    117106        prtfmt( os, "%.*Lg", LDBL_DIG, ld );
    118107        return os;
     
    161150                ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
    162151                // opening-closing delimiters
    163                 ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose,
     152                [' '] : OpenClose, ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose,
    164153                ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
    165154        }; // mask
    166155
    167         int len = strlen( cp );
    168         // null string => no separator
    169   if ( len == 0 ) { sepOff( os ); return os; }
     156  if ( cp[0] == '\0' ) { sepOff( os ); return os; }             // null string => no separator
     157
    170158        // first character IS NOT spacing or closing punctuation => add left separator
    171159        unsigned char ch = cp[0];                                                       // must make unsigned
     
    173161                prtfmt( os, "%s", sepGet( os ) );
    174162        } // if
     163
     164        // if string starts line, must reset to determine open state because separator is off
     165        sepReset( os );                                                                         // reset separator
     166
    175167        // last character IS spacing or opening punctuation => turn off separator for next item
    176         unsigned int posn = len - 1;
     168        unsigned int len = strlen( cp ), posn = len - 1;
    177169        ch = cp[posn];                                                                          // must make unsigned
    178         if ( mask[ ch ] == Open || mask[ ch ] == OpenClose ) {
     170        if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
     171                sepOn( os );
     172        } else {
    179173                sepOff( os );
    180         } else {
    181                 sepOn( os );
    182174        } // if
    183175        return write( os, cp, len );
     
    187179ostype * ?|?( ostype *os, const void *p ) {
    188180        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
    189         sepReset( os );
    190181        prtfmt( os, "%p", p );
    191182        return os;
  • src/libcfa/stdlib

    rdc5376a rb72bad4f  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Apr 21 07:55:21 2016
    13 // Update Count     : 95
     12// Last Modified On : Wed Apr 27 22:03:29 2016
     13// Update Count     : 96
    1414//
    1515
     
    4545
    4646forall( otype T ) T * aligned_alloc( size_t alignment );
    47 forall( otype T ) T * memalign( size_t alignment );
     47forall( otype T ) T * memalign( size_t alignment );             // deprecated
    4848forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
    4949
Note: See TracChangeset for help on using the changeset viewer.