diff options
| -rw-r--r-- | sci-calculators/rpc/ChangeLog | 53 | ||||
| -rw-r--r-- | sci-calculators/rpc/Manifest | 5 | ||||
| -rw-r--r-- | sci-calculators/rpc/files/digest-rpc-0.98 | 1 | ||||
| -rw-r--r-- | sci-calculators/rpc/files/rpc-0.98-gcc-34.patch | 1178 | ||||
| -rw-r--r-- | sci-calculators/rpc/metadata.xml | 9 | ||||
| -rw-r--r-- | sci-calculators/rpc/rpc-0.98.ebuild | 30 |
6 files changed, 1276 insertions, 0 deletions
diff --git a/sci-calculators/rpc/ChangeLog b/sci-calculators/rpc/ChangeLog new file mode 100644 index 000000000000..7bcede01b569 --- /dev/null +++ b/sci-calculators/rpc/ChangeLog @@ -0,0 +1,53 @@ +# ChangeLog for app-misc/rpc +# Copyright 2002-2004 Gentoo Foundation; Distributed under the GPL v2 +# $Header: /var/cvsroot/gentoo-x86/sci-calculators/rpc/ChangeLog,v 1.1 2004/12/25 16:49:20 ribosome Exp $ + +*rpc-0.98 (25 Dec 2004) + + 25 Dec 2004; Olivier Fisette <ribosome@gentoo.org> +metadata.xml, + +files/rpc-0.98-gcc-34.patch, +rpc-0.98.ebuild: + Moved from app-misc/rpc to sci-calculators/rpc. + + 20 Oct 2004; Karol Wojtaszek,,, <sekretarz@gentoo.org> rpc-0.98.ebuild: + added ~amd64 keyword. Bug #67980 + + 06 Oct 2004; Karol Wojtaszek <sekretarz@gentoo.org> + +files/rpc-0.98-gcc-34.patch, rpc-0.98.ebuild: + Fixed gcc-3.4 compile issues. Bug #63965 + + 27 Oct 2003; Michael Sterrett <mr_bones_@gentoo.org> metadata.xml: + add metadata.xml + + 27 Oct 2003; Michael Sterrett <mr_bones_@gentoo.org> rpc-0.97-r1.ebuild, + rpc-0.97.ebuild, files/rpc-0.97-factorial-fix.diff.bz2: + remove old ebuilds and unneeded patch + + 27 Oct 2003; Michael Sterrett <mr_bones_@gentoo.org> rpc-0.98.ebuild: + Marking stable so people stop trying to use 0.97. + +*rpc-0.98 (18 Oct 2003) + + 18 Oct 2003; Michael Sterrett <mr_bones_@gentoo.org> rpc-0.98.ebuild: + more error checking and mark ~sparc (slipped thru on the last commit) + + 18 Oct 2003; Michael Sterrett <mr_bones_@gentoo.org> : + version bump + +*rpc-0.97-r1 (08 May 2003) + + 07 May 2003; George Shapovalov <george@gentoo.org> rpc-0.97-r1.ebuild, files/{rpc-0.97-factorial-fix.diff.bz2,digest-rpc-0.97-r1} : + incorporated the upstream fix to factorial function, (#19120) + thanks to Bernardo S. A. Silva <bsaslinux@globo.com> for submitting the fix! + +*rpc-0.97 (23 Feb 2003) + + 30 Mar 2003; Christian Birchinger <joker@gentoo.org> rpc-0.97.ebuild: + Added sparc stable keyword + + 23 Feb 2003; George Shapovalov <george@gentoo.org> rpc-0.97.ebuild, files/digest-rpc-0.97 : + initial release (#13209) + rpc is a fullscreen console-based RPN calculator that uses the curses library. + Its operation is similar to that of modern HP calculators, but data entry has been + optimized for efficiency on a PC keyboard. Its features include extensive scientific + calculator functionality, command completion, and a visible interactive stack. + ebuild submitted by Bernardo S. A. Silva <bsaslinux@globo.com> diff --git a/sci-calculators/rpc/Manifest b/sci-calculators/rpc/Manifest new file mode 100644 index 000000000000..ba873e02acbd --- /dev/null +++ b/sci-calculators/rpc/Manifest @@ -0,0 +1,5 @@ +MD5 49a11da07dc8e355069b9d2671376ce6 rpc-0.98.ebuild 708 +MD5 3430c4680a29fc4a3e141bfc779f2cf7 ChangeLog 2045 +MD5 27c80a8d690d932f131215d791821fcd metadata.xml 253 +MD5 6ece87b2316722560e5c1cdd6e2a6e02 files/digest-rpc-0.98 60 +MD5 d71204d211c67258865ebfb1bae7721a files/rpc-0.98-gcc-34.patch 29973 diff --git a/sci-calculators/rpc/files/digest-rpc-0.98 b/sci-calculators/rpc/files/digest-rpc-0.98 new file mode 100644 index 000000000000..47d48bb58841 --- /dev/null +++ b/sci-calculators/rpc/files/digest-rpc-0.98 @@ -0,0 +1 @@ +MD5 5eba682ae3be236d6b524be4eba71b33 rpc-0.98.tar.gz 140593 diff --git a/sci-calculators/rpc/files/rpc-0.98-gcc-34.patch b/sci-calculators/rpc/files/rpc-0.98-gcc-34.patch new file mode 100644 index 000000000000..5471fdee690c --- /dev/null +++ b/sci-calculators/rpc/files/rpc-0.98-gcc-34.patch @@ -0,0 +1,1178 @@ +diff -Naur rpc-0.98.orig/src/ccm-compat.c rpc-0.98/src/ccm-compat.c +--- rpc-0.98.orig/src/ccm-compat.c 2003-10-17 03:21:47.000000000 +0200 ++++ rpc-0.98/src/ccm-compat.c 2004-10-06 02:29:43.000000000 +0200 +@@ -28,151 +28,151 @@ + #include <ccmath.h> + #include <stdio.h> + +-inline Cpx cMul( Cpx s, Cpx t ) ++Cpx cMul( Cpx s, Cpx t ) + { + return( cmul(s, t) ); + } + + +-inline Cpx cDiv( Cpx s, Cpx t ) ++Cpx cDiv( Cpx s, Cpx t ) + { + return( cdiv(s, t) ); + } + + +-inline Cpx cAdd( Cpx s, Cpx t ) ++Cpx cAdd( Cpx s, Cpx t ) + { + return( cadd(s, t) ); + } + + +-inline Cpx cSub( Cpx s, Cpx t ) ++Cpx cSub( Cpx s, Cpx t ) + { + return( csub(s, t) ); + } + + +-inline Cpx cRmu( double a, Cpx z ) ++Cpx cRmu( double a, Cpx z ) + { + return( crmu(a, z) ); + } + + +-inline Cpx cImu( double b, Cpx z ) ++Cpx cImu( double b, Cpx z ) + { + return( cimu(b, z) ); + } + + +-inline Cpx cCng( Cpx z ) ++Cpx cCng( Cpx z ) + { + return( ccng(z) ); + } + + +-inline Cpx cDef( double r, double i ) ++Cpx cDef( double r, double i ) + { + return( cdef(r, i) ); + } + + +-inline double cAbs( Cpx c ) ++double cAbs( Cpx c ) + { + return( cabs(c) ); + } + + +-inline double cNrm( Cpx z ) ++double cNrm( Cpx z ) + { + return( cnrm(z) ); + } + + +-inline Cpx cExp( Cpx z ) ++Cpx cExp( Cpx z ) + { + return( cexp(z) ); + } + + +-inline Cpx cLog( Cpx z ) ++Cpx cLog( Cpx z ) + { + return( clog(z) ); + } + + +-inline Cpx cSinh( Cpx z ) ++Cpx cSinh( Cpx z ) + { + return( csinh(z) ); + } + + +-inline Cpx cCosh( Cpx z ) ++Cpx cCosh( Cpx z ) + { + return( ccosh(z) ); + } + + +-inline Cpx cTanh( Cpx z ) ++Cpx cTanh( Cpx z ) + { + return( ctanh(z) ); + } + + +-inline Cpx cAsinh( Cpx z ) ++Cpx cAsinh( Cpx z ) + { + return( casinh(z) ); + } + + +-inline Cpx cAcosh( Cpx z ) ++Cpx cAcosh( Cpx z ) + { + return( cacosh(z) ); + } + + +-inline Cpx cAtanh( Cpx z ) ++Cpx cAtanh( Cpx z ) + { + return( catanh(z) ); + } + + +-inline Cpx cAsin( Cpx z ) ++Cpx cAsin( Cpx z ) + { + return( casin(z) ); + } + + +-inline Cpx cAcos( Cpx z ) ++Cpx cAcos( Cpx z ) + { + return( cacos(z) ); + } + + +-inline Cpx cAtan( Cpx z ) ++Cpx cAtan( Cpx z ) + { + return( catan(z) ); + } + + +-inline Cpx cSqrt( Cpx z ) ++Cpx cSqrt( Cpx z ) + { + return( csqrt(z) ); + } + + +-inline Cpx cSin( Cpx z ) ++Cpx cSin( Cpx z ) + { + return( csin(z) ); + } + + +-inline Cpx cCos( Cpx z ) ++Cpx cCos( Cpx z ) + { + return( ccos(z) ); + } + + +-inline Cpx cTan( Cpx z ) ++Cpx cTan( Cpx z ) + { + return( ctan(z) ); + } +@@ -180,37 +180,37 @@ + + /* ------------- Matrix routines --------------- */ + +-inline void Rmmult( double* mat, double* a, double* b, int m, int k, int n) ++void Rmmult( double* mat, double* a, double* b, int m, int k, int n) + { + rmmult( mat, a, b, m, k, n ); + } + + +-inline void Cmmult( Cpx* mat, Cpx* a, Cpx* b, int m, int k, int n ) ++void Cmmult( Cpx* mat, Cpx* a, Cpx* b, int m, int k, int n ) + { + cmmult( mat, a, b, m, k, n ); + } + + +-inline int Minv( double a[], int n ) ++int Minv( double a[], int n ) + { + return( minv(a, n) ); + } + + +-inline int cMinv( Cpx a[], int n ) ++int cMinv( Cpx a[], int n ) + { + return( cminv(a, n) ); + } + + +-inline void Mattr( double* a, double* b, int m, int n ) ++void Mattr( double* a, double* b, int m, int n ) + { + mattr( a, b, m, n ); + } + + +-inline void cMattr( Cpx* a, Cpx* b, int m, int n ) ++void cMattr( Cpx* a, Cpx* b, int m, int n ) + { + cmattr( a, b, m, n ); + } +diff -Naur rpc-0.98.orig/src/RpcComplex.cpp rpc-0.98/src/RpcComplex.cpp +--- rpc-0.98.orig/src/RpcComplex.cpp 2003-10-17 03:21:47.000000000 +0200 ++++ rpc-0.98/src/RpcComplex.cpp 2004-10-06 02:31:09.000000000 +0200 +@@ -289,7 +289,7 @@ + + + // Square root function. +-inline RpcObject* RpcComplex::Sqrt( void ) ++RpcObject* RpcComplex::Sqrt( void ) + { + RpcObject* temp = new RpcComplex( data.Sqrt() ); + return( temp ); +@@ -297,7 +297,7 @@ + + + // Square function. +-inline RpcObject* RpcComplex::Sq( void ) ++RpcObject* RpcComplex::Sq( void ) + { + RpcObject* temp = new RpcComplex( data*data ); + return( temp ); +@@ -305,7 +305,7 @@ + + + // Exponential function. +-inline RpcObject* RpcComplex::Exp( void ) ++RpcObject* RpcComplex::Exp( void ) + { + RpcObject* temp = new RpcComplex( data.Exp() ); + return( temp ); +@@ -313,7 +313,7 @@ + + + // Natural logarithm. +-inline RpcObject* RpcComplex::Log( void ) ++RpcObject* RpcComplex::Log( void ) + { + RpcObject* temp = new RpcComplex( data.Log() ); + return( temp ); +@@ -321,7 +321,7 @@ + + + // Ten raised to the power x. +-inline RpcObject* RpcComplex::Ten_x( void ) ++RpcObject* RpcComplex::Ten_x( void ) + { + RpcObject* temp = new RpcComplex( data.Ten_x() ); + return( temp ); +@@ -329,7 +329,7 @@ + + + // Common logarithm. +-inline RpcObject* RpcComplex::Log10( void ) ++RpcObject* RpcComplex::Log10( void ) + { + RpcObject* temp = new RpcComplex( data.Log10() ); + return( temp ); +@@ -337,7 +337,7 @@ + + + // Sine function. +-inline RpcObject* RpcComplex::Sin( int mode ) ++RpcObject* RpcComplex::Sin( int mode ) + { + RpcObject* temp = new RpcComplex( data.Sin() ); + return( temp ); +@@ -345,7 +345,7 @@ + + + // Cosine function. +-inline RpcObject* RpcComplex::Cos( int mode ) ++RpcObject* RpcComplex::Cos( int mode ) + { + RpcObject* temp = new RpcComplex( data.Cos() ); + return( temp ); +@@ -353,7 +353,7 @@ + + + // Tangent function. +-inline RpcObject* RpcComplex::Tan( int mode ) ++RpcObject* RpcComplex::Tan( int mode ) + { + RpcObject* temp = new RpcComplex( data.Tan() ); + return( temp ); +@@ -361,7 +361,7 @@ + + + // Inverse sine function. +-inline RpcObject* RpcComplex::aSin( int mode ) ++RpcObject* RpcComplex::aSin( int mode ) + { + RpcObject* temp = new RpcComplex( data.aSin() ); + return( temp ); +@@ -369,7 +369,7 @@ + + + // Inverse cosine function. +-inline RpcObject* RpcComplex::aCos( int mode ) ++RpcObject* RpcComplex::aCos( int mode ) + { + RpcObject* temp = new RpcComplex( data.aCos() ); + return( temp ); +@@ -377,7 +377,7 @@ + + + // Inverse tangent function. +-inline RpcObject* RpcComplex::aTan( int mode ) ++RpcObject* RpcComplex::aTan( int mode ) + { + RpcObject* temp = new RpcComplex( data.aTan() ); + return( temp ); +@@ -385,7 +385,7 @@ + + + // Hyperbolic sine function. +-inline RpcObject* RpcComplex::Sinh( void ) ++RpcObject* RpcComplex::Sinh( void ) + { + RpcObject* temp = new RpcComplex( data.Sinh() ); + return( temp ); +@@ -393,7 +393,7 @@ + + + // Hyperbolic cosine function. +-inline RpcObject* RpcComplex::Cosh( void ) ++RpcObject* RpcComplex::Cosh( void ) + { + RpcObject* temp = new RpcComplex( data.Cosh() ); + return( temp ); +@@ -401,7 +401,7 @@ + + + // Hyperbolic tangent function. +-inline RpcObject* RpcComplex::Tanh( void ) ++RpcObject* RpcComplex::Tanh( void ) + { + RpcObject* temp = new RpcComplex( data.Tanh() ); + return( temp ); +@@ -409,7 +409,7 @@ + + + // Inverse hyperbolic sine function. +-inline RpcObject* RpcComplex::aSinh( void ) ++RpcObject* RpcComplex::aSinh( void ) + { + RpcObject* temp = new RpcComplex( data.aSinh() ); + return( temp ); +@@ -417,7 +417,7 @@ + + + // Inverse hyperbolic cosine function. +-inline RpcObject* RpcComplex::aCosh( void ) ++RpcObject* RpcComplex::aCosh( void ) + { + RpcObject* temp = new RpcComplex( data.aCosh() ); + return( temp ); +@@ -425,7 +425,7 @@ + + + // Inverse hyperbolic tangent function. +-inline RpcObject* RpcComplex::aTanh( void ) ++RpcObject* RpcComplex::aTanh( void ) + { + RpcObject* temp = new RpcComplex( data.aTanh() ); + return( temp ); +@@ -433,7 +433,7 @@ + + + // Real part of complex number. +-inline RpcObject* RpcComplex::Real( void ) ++RpcObject* RpcComplex::Real( void ) + { + RpcObject* temp = new RpcDouble( data.Real() ); + return( temp ); +@@ -441,7 +441,7 @@ + + + // Imaginary part of complex number. +-inline RpcObject* RpcComplex::Imag( void ) ++RpcObject* RpcComplex::Imag( void ) + { + RpcObject* temp = new RpcDouble( data.Imag() ); + return( temp ); +@@ -449,7 +449,7 @@ + + + // Inverse of complex number. +-inline RpcObject* RpcComplex::Inv( void ) ++RpcObject* RpcComplex::Inv( void ) + { + RpcObject* temp = new RpcComplex( data.Inv() ); + return( temp ); +@@ -457,7 +457,7 @@ + + + // Magnitude of complex number +-inline RpcObject* RpcComplex::Abs( void ) ++RpcObject* RpcComplex::Abs( void ) + { + RpcObject* temp = new RpcDouble( data.Abs() ); + return( temp ); +@@ -465,7 +465,7 @@ + + + // Argument of complex number +-inline RpcObject* RpcComplex::Arg( int angleMode ) ++RpcObject* RpcComplex::Arg( int angleMode ) + { + RpcObject* temp; + if( angleMode == MODE_DEG ) +@@ -481,7 +481,7 @@ + + + // Return the data. +-inline Complex RpcComplex::getData( void ) ++Complex RpcComplex::getData( void ) + { + return( data ); + } +diff -Naur rpc-0.98.orig/src/RpcComplexMatrix.cpp rpc-0.98/src/RpcComplexMatrix.cpp +--- rpc-0.98.orig/src/RpcComplexMatrix.cpp 2003-10-17 03:21:47.000000000 +0200 ++++ rpc-0.98/src/RpcComplexMatrix.cpp 2004-10-06 02:32:33.000000000 +0200 +@@ -389,7 +389,7 @@ + + + // Matrix inversion. +-inline RpcObject* RpcComplexMatrix::Inv( void ) ++RpcObject* RpcComplexMatrix::Inv( void ) + { + RpcObject* temp; + +@@ -417,7 +417,7 @@ + + + // Matrix inversion. +-inline RpcObject* RpcComplexMatrix::Trans( void ) ++RpcObject* RpcComplexMatrix::Trans( void ) + { + RpcObject* temp = new RpcComplexMatrix( data.Trans() ); + return( temp ); +@@ -426,7 +426,7 @@ + + + // Return the data. +-inline ComplexMatrix RpcComplexMatrix::getData( void ) ++ComplexMatrix RpcComplexMatrix::getData( void ) + { + return( data ); + } +diff -Naur rpc-0.98.orig/src/RpcDouble.cpp rpc-0.98/src/RpcDouble.cpp +--- rpc-0.98.orig/src/RpcDouble.cpp 2003-10-17 03:21:47.000000000 +0200 ++++ rpc-0.98/src/RpcDouble.cpp 2004-10-06 02:30:42.000000000 +0200 +@@ -256,7 +256,7 @@ + + + // Change sign operator. +-inline RpcObject* RpcDouble::operator -( void ) ++RpcObject* RpcDouble::operator -( void ) + { + RpcObject* temp = new RpcDouble( -data ); + return( temp ); +@@ -293,7 +293,7 @@ + + + // Square function. +-inline RpcObject* RpcDouble::Sq( void ) ++RpcObject* RpcDouble::Sq( void ) + { + RpcObject* temp = new RpcDouble( data*data ); + return( temp ); +@@ -301,7 +301,7 @@ + + + // Square root function. +-inline RpcObject* RpcDouble::Sqrt( void ) ++RpcObject* RpcDouble::Sqrt( void ) + { + RpcObject* temp = new RpcDouble( sqrt(data) ); + return( temp ); +@@ -309,7 +309,7 @@ + + + // Exponential function. +-inline RpcObject* RpcDouble::Exp( void ) ++RpcObject* RpcDouble::Exp( void ) + { + RpcObject* temp = new RpcDouble( exp(data) ); + return( temp ); +@@ -317,7 +317,7 @@ + + + // Natural logarithm. +-inline RpcObject* RpcDouble::Log( void ) ++RpcObject* RpcDouble::Log( void ) + { + RpcObject* temp = new RpcDouble( log(data) ); + return( temp ); +@@ -325,7 +325,7 @@ + + + // Ten raised to the power x. +-inline RpcObject* RpcDouble::Ten_x( void ) ++RpcObject* RpcDouble::Ten_x( void ) + { + RpcObject* temp = new RpcDouble( pow(10.0, data) ); + return( temp ); +@@ -333,7 +333,7 @@ + + + // Common logarithm. +-inline RpcObject* RpcDouble::Log10( void ) ++RpcObject* RpcDouble::Log10( void ) + { + RpcObject* temp = new RpcDouble( log10(data) ); + return( temp ); +@@ -341,7 +341,7 @@ + + + // Sine function. +-inline RpcObject* RpcDouble::Sin( int mode ) ++RpcObject* RpcDouble::Sin( int mode ) + { + double dtemp = data; + if( mode == MODE_DEG ) +@@ -355,7 +355,7 @@ + + + // Cosine function. +-inline RpcObject* RpcDouble::Cos( int mode ) ++RpcObject* RpcDouble::Cos( int mode ) + { + double dtemp = data; + if( mode == MODE_DEG ) +@@ -369,7 +369,7 @@ + + + // Tangent function. +-inline RpcObject* RpcDouble::Tan( int mode ) ++RpcObject* RpcDouble::Tan( int mode ) + { + double dtemp = data; + if( mode == MODE_DEG ) +@@ -383,7 +383,7 @@ + + + // Inverse sine function. +-inline RpcObject* RpcDouble::aSin( int mode ) ++RpcObject* RpcDouble::aSin( int mode ) + { + double dtemp = 1.0; + if( mode == MODE_DEG ) +@@ -397,7 +397,7 @@ + + + // Inverse cosine function. +-inline RpcObject* RpcDouble::aCos( int mode ) ++RpcObject* RpcDouble::aCos( int mode ) + { + double dtemp = 1.0; + if( mode == MODE_DEG ) +@@ -411,7 +411,7 @@ + + + // Inverse tangent function. +-inline RpcObject* RpcDouble::aTan( int mode ) ++RpcObject* RpcDouble::aTan( int mode ) + { + double dtemp = 1.0; + if( mode == MODE_DEG ) +@@ -425,7 +425,7 @@ + + + // Hyperbolic sine function. +-inline RpcObject* RpcDouble::Sinh( void ) ++RpcObject* RpcDouble::Sinh( void ) + { + RpcObject* temp = new RpcDouble( sinh(data) ); + return( temp ); +@@ -433,7 +433,7 @@ + + + // Hyperbolic cosine function. +-inline RpcObject* RpcDouble::Cosh( void ) ++RpcObject* RpcDouble::Cosh( void ) + { + RpcObject* temp = new RpcDouble( cosh(data) ); + return( temp ); +@@ -441,7 +441,7 @@ + + + // Hyperbolic tangent function. +-inline RpcObject* RpcDouble::Tanh( void ) ++RpcObject* RpcDouble::Tanh( void ) + { + RpcObject* temp = new RpcDouble( tanh(data) ); + return( temp ); +@@ -449,7 +449,7 @@ + + + // Inverse hyperbolic sine function. +-inline RpcObject* RpcDouble::aSinh( void ) ++RpcObject* RpcDouble::aSinh( void ) + { + RpcObject* temp = new RpcDouble( asinh(data) ); + return( temp ); +@@ -457,7 +457,7 @@ + + + // Inverse hyperbolic cosine function. +-inline RpcObject* RpcDouble::aCosh( void ) ++RpcObject* RpcDouble::aCosh( void ) + { + RpcObject* temp = new RpcDouble( acosh(data) ); + return( temp ); +@@ -465,7 +465,7 @@ + + + // Inverse hyperbolic tangent function. +-inline RpcObject* RpcDouble::aTanh( void ) ++RpcObject* RpcDouble::aTanh( void ) + { + RpcObject* temp = new RpcDouble( atanh(data) ); + return( temp ); +@@ -475,7 +475,7 @@ + // Euler Gamma function. + // Note: gamma() is really LogGamma[]. Who the hell chose that + // convention? +-inline RpcObject* RpcDouble::Gamma( void ) ++RpcObject* RpcDouble::Gamma( void ) + { + RpcObject* temp = new RpcDouble( exp(gamma(data)) ); + return( temp ); +@@ -483,7 +483,7 @@ + + + // Log gamma function. +-inline RpcObject* RpcDouble::LogGamma( void ) ++RpcObject* RpcDouble::LogGamma( void ) + { + RpcObject* temp = new RpcDouble( gamma(data) ); + return( temp ); +@@ -491,7 +491,7 @@ + + + // Factorial function. +-inline RpcObject* RpcDouble::Factorial( void ) ++RpcObject* RpcDouble::Factorial( void ) + { + RpcObject* temp = new RpcDouble( exp(gamma(data+1.0)) ); + return( temp ); +@@ -499,7 +499,7 @@ + + + // Error function. +-inline RpcObject* RpcDouble::Erf( void ) ++RpcObject* RpcDouble::Erf( void ) + { + RpcObject* temp = new RpcDouble( erf(data) ); + return( temp ); +@@ -507,7 +507,7 @@ + + + // Complementary error function. +-inline RpcObject* RpcDouble::Erfc( void ) ++RpcObject* RpcDouble::Erfc( void ) + { + RpcObject* temp = new RpcDouble( erfc(data) ); + return( temp ); +@@ -515,7 +515,7 @@ + + + // Real part of number. +-inline RpcObject* RpcDouble::Real( void ) ++RpcObject* RpcDouble::Real( void ) + { + // Returns same number. + RpcObject* temp = new RpcDouble( data ); +@@ -524,7 +524,7 @@ + + + // Imaginary part of number. +-inline RpcObject* RpcDouble::Imag( void ) ++RpcObject* RpcDouble::Imag( void ) + { // Returns zero-valued double. + RpcObject* temp = new RpcDouble( 0.0 ); + return( temp ); +@@ -532,7 +532,7 @@ + + + // Floor function. +-inline RpcObject* RpcDouble::Floor( void ) ++RpcObject* RpcDouble::Floor( void ) + { + RpcObject* temp = new RpcDouble( floor(data) ); + return( temp ); +@@ -540,7 +540,7 @@ + + + // Ceiling function. +-inline RpcObject* RpcDouble::Ceil( void ) ++RpcObject* RpcDouble::Ceil( void ) + { + RpcObject* temp = new RpcDouble( ceil(data) ); + return( temp ); +@@ -548,7 +548,7 @@ + + + // Nearest integer function. +-inline RpcObject* RpcDouble::NearInt( void ) ++RpcObject* RpcDouble::NearInt( void ) + { + RpcObject* temp = new RpcDouble( floor(data+0.5) ); + return( temp ); +@@ -556,7 +556,7 @@ + + + // Inverse function. +-inline RpcObject* RpcDouble::Inv( void ) ++RpcObject* RpcDouble::Inv( void ) + { + RpcObject* temp = new RpcDouble( 1.0/data ); + return( temp ); +@@ -564,7 +564,7 @@ + + + // Absolute value +-inline RpcObject* RpcDouble::Abs( void ) ++RpcObject* RpcDouble::Abs( void ) + { + RpcObject* temp; + if( data >= 0 ) +@@ -581,7 +581,7 @@ + + + // Convert to integer constant. +-inline RpcObject* RpcDouble::ToConst( void ) ++RpcObject* RpcDouble::ToConst( void ) + { + RpcObject* temp = new RpcIntegerConst( data ); + return( temp ); +@@ -589,7 +589,7 @@ + + + // Return the data. +-inline double RpcDouble::getData( void ) ++double RpcDouble::getData( void ) + { + return( data ); + } +diff -Naur rpc-0.98.orig/src/RpcIntegerConst.cpp rpc-0.98/src/RpcIntegerConst.cpp +--- rpc-0.98.orig/src/RpcIntegerConst.cpp 2003-10-17 03:21:47.000000000 +0200 ++++ rpc-0.98/src/RpcIntegerConst.cpp 2004-10-06 02:33:18.000000000 +0200 +@@ -348,7 +348,7 @@ + + + // Return the data. +-inline IntegerConst RpcIntegerConst::getData( void ) ++IntegerConst RpcIntegerConst::getData( void ) + { + return( data ); + } +diff -Naur rpc-0.98.orig/src/RpcObject.cpp rpc-0.98/src/RpcObject.cpp +--- rpc-0.98.orig/src/RpcObject.cpp 2003-10-17 03:21:47.000000000 +0200 ++++ rpc-0.98/src/RpcObject.cpp 2004-10-06 02:30:28.000000000 +0200 +@@ -96,7 +96,7 @@ + // Subtraction operator. Returns an error object. + // Should be overridden by all classes for which + // subtraction makes sense. +-inline RpcObject* RpcObject::operator -( const RpcObject* rhs ) ++RpcObject* RpcObject::operator -( const RpcObject* rhs ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -106,7 +106,7 @@ + // Multiplication operator. Returns an error object. + // Should be overridden by all classes for which + // multiplication makes sense. +-inline RpcObject* RpcObject::operator *( const RpcObject* rhs ) ++RpcObject* RpcObject::operator *( const RpcObject* rhs ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -116,7 +116,7 @@ + // Division operator. Returns an error object. + // Should be overridden by all classes for which + // division makes sense. +-inline RpcObject* RpcObject::operator /( const RpcObject* rhs ) ++RpcObject* RpcObject::operator /( const RpcObject* rhs ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -126,7 +126,7 @@ + // Change sign operator. Returns an error object. + // Should be overridden by all classes for which + // changeSign makes sense. +-inline RpcObject* RpcObject::operator -( void ) ++RpcObject* RpcObject::operator -( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -136,7 +136,7 @@ + // Power function. Returns an error object. + // Should be overridden by all classes for which + // power makes sense. +-inline RpcObject* RpcObject::Pow( const RpcObject* rhs ) ++RpcObject* RpcObject::Pow( const RpcObject* rhs ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -146,7 +146,7 @@ + // Mod function. Returns an error object. + // Should be overriden by all classes for which mod + // makes sense. +-inline RpcObject* RpcObject::Mod( const RpcObject* rhs ) ++RpcObject* RpcObject::Mod( const RpcObject* rhs ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -155,7 +155,7 @@ + + // Square root. Returns an error object. + // Should be overridden by all classes for which sqrt makes sense. +-inline RpcObject* RpcObject::Sqrt( void ) ++RpcObject* RpcObject::Sqrt( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -164,7 +164,7 @@ + + // Square. Returns an error object. + // Should be overridden by all classes for which square makes sense. +-inline RpcObject* RpcObject::Sq( void ) ++RpcObject* RpcObject::Sq( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -173,7 +173,7 @@ + + // Exponential function. Returns an error object. + // Should be overridden by all classes for which exp makes sense. +-inline RpcObject* RpcObject::Exp( void ) ++RpcObject* RpcObject::Exp( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -182,7 +182,7 @@ + + // Natural logarithm. Returns an error object. + // Should be overridden by all classes for which log makes sense. +-inline RpcObject* RpcObject::Log( void ) ++RpcObject* RpcObject::Log( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -191,7 +191,7 @@ + + // Ten raised to the power x. Returns an error object. + // Should be overridden by all classes for which ten_x makes sense. +-inline RpcObject* RpcObject::Ten_x( void ) ++RpcObject* RpcObject::Ten_x( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -200,7 +200,7 @@ + + // Common logarithm. Returns an error object. + // Should be overridden by all classes for which log10 makes sense. +-inline RpcObject* RpcObject::Log10( void ) ++RpcObject* RpcObject::Log10( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -209,7 +209,7 @@ + + // Sine function. Returns an error object. + // Should be overridden by all classes for which sine makes sense. +-inline RpcObject* RpcObject::Sin( int mode ) ++RpcObject* RpcObject::Sin( int mode ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -218,7 +218,7 @@ + + // Cosine function. Returns an error object. + // Should be overridden by all classes for which cosine makes sense. +-inline RpcObject* RpcObject::Cos( int mode ) ++RpcObject* RpcObject::Cos( int mode ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -227,7 +227,7 @@ + + // Tangent function. Returns an error object. + // Should be overridden by all classes for which tangent makes sense. +-inline RpcObject* RpcObject::Tan( int mode ) ++RpcObject* RpcObject::Tan( int mode ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -236,7 +236,7 @@ + + // Inverse sine function. Returns an error object. + // Should be overridden by all classes for which asin makes sense. +-inline RpcObject* RpcObject::aSin( int mode ) ++RpcObject* RpcObject::aSin( int mode ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -245,7 +245,7 @@ + + // Inverse cosine function. Returns an error object. + // Should be overridden by all classes for which acos makes sense. +-inline RpcObject* RpcObject::aCos( int mode ) ++RpcObject* RpcObject::aCos( int mode ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -254,7 +254,7 @@ + + // Inverse tangent function. Returns an error object. + // Should be overridden by all classes for which inverse tangent makes sense. +-inline RpcObject* RpcObject::aTan( int mode ) ++RpcObject* RpcObject::aTan( int mode ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -263,7 +263,7 @@ + + // Hyperbolic sine function. Returns an error object. + // Should be overridden by all classes for which sinh makes sense. +-inline RpcObject* RpcObject::Sinh( void ) ++RpcObject* RpcObject::Sinh( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -272,7 +272,7 @@ + + // Hyperbolic cosine function. Returns an error object. + // Should be overridden by all classes for which cosh makes sense. +-inline RpcObject* RpcObject::Cosh( void ) ++RpcObject* RpcObject::Cosh( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -281,7 +281,7 @@ + + // Hyperbolic tangent function. Returns an error object. + // Should be overridden by all classes for which tanh makes sense. +-inline RpcObject* RpcObject::Tanh( void ) ++RpcObject* RpcObject::Tanh( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -290,7 +290,7 @@ + + // Inverse hyperbolic sine function. Returns an error object. + // Should be overridden by all classes for which asinh makes sense. +-inline RpcObject* RpcObject::aSinh( void ) ++RpcObject* RpcObject::aSinh( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -299,7 +299,7 @@ + + // Inverse hyperbolic cosine function. Returns an error object. + // Should be overridden by all classes for which acosh makes sense. +-inline RpcObject* RpcObject::aCosh( void ) ++RpcObject* RpcObject::aCosh( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -308,7 +308,7 @@ + + // Inverse hyperbolic tangent function. Returns an error object. + // Should be overridden by all classes for which atanh makes sense. +-inline RpcObject* RpcObject::aTanh( void ) ++RpcObject* RpcObject::aTanh( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -317,7 +317,7 @@ + + // Euler gamma function. Returns an error object. + // Should be overridden by all classes for which gamma makes sense. +-inline RpcObject* RpcObject::Gamma( void ) ++RpcObject* RpcObject::Gamma( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -326,7 +326,7 @@ + + // Log gamma function. Returns an error object. + // Should be overridden by all classes for which LogGamma makes sense. +-inline RpcObject* RpcObject::LogGamma( void ) ++RpcObject* RpcObject::LogGamma( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -335,7 +335,7 @@ + + // Factorial function. Returns an error object. + // Should be overridden by all classes for which factorial makes sense. +-inline RpcObject* RpcObject::Factorial( void ) ++RpcObject* RpcObject::Factorial( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -345,7 +345,7 @@ + // Error function. Returns an error object (not because it is the error + // function...). Should be overridden by all classes for which erf + // makes sense. +-inline RpcObject* RpcObject::Erf( void ) ++RpcObject* RpcObject::Erf( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -354,7 +354,7 @@ + + // Complementary error function. Returns an error object. + // Should be overridden by all classes for which erfc makes sense. +-inline RpcObject* RpcObject::Erfc( void ) ++RpcObject* RpcObject::Erfc( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -363,7 +363,7 @@ + + // Real part of number. Returns an error object. + // Should be overridden by all classes for which real() makes sense. +-inline RpcObject* RpcObject::Real( void ) ++RpcObject* RpcObject::Real( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -372,7 +372,7 @@ + + // Imaginary part of number. Returns an error object. + // Should be overridden by all classes for which imag() makes sense. +-inline RpcObject* RpcObject::Imag( void ) ++RpcObject* RpcObject::Imag( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -381,7 +381,7 @@ + + // Floor function. Returns an error object. + // Should be overridden by all classes for which floor makes sense. +-inline RpcObject* RpcObject::Floor( void ) ++RpcObject* RpcObject::Floor( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -390,7 +390,7 @@ + + // Ceiling function. Returns an error object. + // Should be overridden by all classes for which ceiling makes sense. +-inline RpcObject* RpcObject::Ceil( void ) ++RpcObject* RpcObject::Ceil( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -399,7 +399,7 @@ + + // Nearest integer function. Returns an error object. + // Should be overridden by all classes for which nearest integer makes sense. +-inline RpcObject* RpcObject::NearInt( void ) ++RpcObject* RpcObject::NearInt( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -408,7 +408,7 @@ + + // Inverse function. Returns an error object. + // Should be overridden by all classes for which inverse makes sense. +-inline RpcObject* RpcObject::Inv( void ) ++RpcObject* RpcObject::Inv( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -416,7 +416,7 @@ + + + // Matrix transpose. +-inline RpcObject* RpcObject::Trans( void ) ++RpcObject* RpcObject::Trans( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -424,7 +424,7 @@ + + + // Convert to integer constant. +-inline RpcObject* RpcObject::ToConst( void ) ++RpcObject* RpcObject::ToConst( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -432,7 +432,7 @@ + + + // Magnitude +-inline RpcObject* RpcObject::Abs( void ) ++RpcObject* RpcObject::Abs( void ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +@@ -440,7 +440,7 @@ + + + // Argument of complex number +-inline RpcObject* RpcObject::Arg( int angleMode ) ++RpcObject* RpcObject::Arg( int angleMode ) + { + RpcObject* temp = new RpcObject( SIMPLE_ERROR_TYPE ); + return( temp ); +diff -Naur rpc-0.98.orig/src/RpcRealMatrix.cpp rpc-0.98/src/RpcRealMatrix.cpp +--- rpc-0.98.orig/src/RpcRealMatrix.cpp 2003-10-17 03:21:47.000000000 +0200 ++++ rpc-0.98/src/RpcRealMatrix.cpp 2004-10-06 02:30:15.000000000 +0200 +@@ -347,7 +347,7 @@ + + + // Change sign operator. +-inline RpcObject* RpcRealMatrix::operator -( void ) ++RpcObject* RpcRealMatrix::operator -( void ) + { + RpcObject* temp = new RpcRealMatrix( -data ); + return( temp ); +@@ -355,7 +355,7 @@ + + + // Matrix inversion. +-inline RpcObject* RpcRealMatrix::Inv( void ) ++RpcObject* RpcRealMatrix::Inv( void ) + { + RpcObject* temp; + +@@ -383,7 +383,7 @@ + + + // Matrix inversion. +-inline RpcObject* RpcRealMatrix::Trans( void ) ++RpcObject* RpcRealMatrix::Trans( void ) + { + RpcObject* temp = new RpcRealMatrix( data.Trans() ); + return( temp ); +@@ -392,7 +392,7 @@ + + + // Return the data. +-inline RealMatrix RpcRealMatrix::getData( void ) ++RealMatrix RpcRealMatrix::getData( void ) + { + return( data ); + } diff --git a/sci-calculators/rpc/metadata.xml b/sci-calculators/rpc/metadata.xml new file mode 100644 index 000000000000..48f507554429 --- /dev/null +++ b/sci-calculators/rpc/metadata.xml @@ -0,0 +1,9 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd"> +<pkgmetadata> +<herd>no-herd</herd> +<maintainer> +<email>mr_bones_@gentoo.org</email> +<name>Michael Sterrett</name> +</maintainer> +</pkgmetadata> diff --git a/sci-calculators/rpc/rpc-0.98.ebuild b/sci-calculators/rpc/rpc-0.98.ebuild new file mode 100644 index 000000000000..81833d52fc1c --- /dev/null +++ b/sci-calculators/rpc/rpc-0.98.ebuild @@ -0,0 +1,30 @@ +# Copyright 1999-2004 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/sci-calculators/rpc/rpc-0.98.ebuild,v 1.1 2004/12/25 16:49:20 ribosome Exp $ + +inherit eutils + +DESCRIPTION="A fullscreen console-based RPN calculator that uses the curses library" + +HOMEPAGE="http://www.eecs.umich.edu/~pelzlpj/rpc/" +SRC_URI="http://www.eecs.umich.edu/~pelzlpj/rpc/${P}.tar.gz" + +LICENSE="GPL-2" +SLOT="0" +KEYWORDS="x86 ppc sparc ~amd64" +IUSE="" + +DEPEND=">=dev-libs/ccmath-2.2 + sys-libs/ncurses" + +src_unpack() { + unpack ${A} + cd ${S} + + epatch ${FILESDIR}/${P}-gcc-34.patch +} + +src_install() { + einstall || die + dodoc ChangeLog README TODO doc/{DESIGN,manual} +} |