mathfp: remove TRAD_SYNOPSIS

Signed-off-by: Yaakov Selkowitz <yselkowi@redhat.com>
9 years ago · 9f369d3c8d
28 changed files with 28 additions and 344 deletions
--- a/newlib/libm/mathfp/e_acosh.c
+++ b/newlib/libm/mathfp/e_acosh.c
@ -10,19 +10,11 @@ acosh
 INDEX
 acoshf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double acosh(double <[x]>);
        float acoshf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double acosh(<[x]>)
-        double <[x]>;
-
-        float acoshf(<[x]>)
-        float <[x]>;
-
 DESCRIPTION
 <<acosh>> calculates the inverse hyperbolic cosine of <[x]>.
 <<acosh>> is defined as
--- a/newlib/libm/mathfp/e_atanh.c
+++ b/newlib/libm/mathfp/e_atanh.c
@ -21,19 +21,11 @@ INDEX
 INDEX
        atanhf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double atanh(double <[x]>);
        float atanhf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double atanh(<[x]>)
-        double <[x]>;
-
-        float atanhf(<[x]>)
-        float <[x]>;
-
 DESCRIPTION
        <<atanh>> calculates the inverse hyperbolic tangent of <[x]>.

--- a/newlib/libm/mathfp/e_hypot.c
+++ b/newlib/libm/mathfp/e_hypot.c
@ -19,18 +19,11 @@ INDEX
 INDEX
        hypotf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double hypot(double <[x]>, double <[y]>);
        float hypotf(float <[x]>, float <[y]>);

-TRAD_SYNOPSIS
-        double hypot(<[x]>, <[y]>)
-        double <[x]>, <[y]>;
-
-        float hypotf(<[x]>, <[y]>)
-        float <[x]>, <[y]>;
-
 DESCRIPTION
        <<hypot>> calculates the Euclidean distance
        @tex
--- a/newlib/libm/mathfp/e_remainder.c
+++ b/newlib/libm/mathfp/e_remainder.c
@ -19,18 +19,11 @@ INDEX
 INDEX
        remainderf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double remainder(double <[x]>, double <[y]>);
        float remainderf(float <[x]>, float <[y]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double remainder(<[x]>,<[y]>)
-        double <[x]>, <[y]>;
-        float remainderf(<[x]>,<[y]>)
-        float <[x]>, <[y]>;
-
 DESCRIPTION
 <<remainder>> and <<remainderf>> find the remainder of
 <[x]>/<[y]>; this value is in the range -<[y]>/2 .. +<[y]>/2.
--- a/newlib/libm/mathfp/er_lgamma.c
+++ b/newlib/libm/mathfp/er_lgamma.c
@ -34,7 +34,7 @@ lgamma_r
 INDEX
 lgammaf_r

-ANSI_SYNOPSIS
+SYNOPSIS
 #include <math.h>
 double gamma(double <[x]>);
 float gammaf(float <[x]>);
@ -45,29 +45,6 @@ float gammaf_r(float <[x]>, int *<[signgamp]>);
 double lgamma_r(double <[x]>, int *<[signgamp]>);
 float lgammaf_r(float <[x]>, int *<[signgamp]>);

-TRAD_SYNOPSIS
-#include <math.h>
-double gamma(<[x]>)
-double <[x]>;
-float gammaf(<[x]>)
-float <[x]>;
-double lgamma(<[x]>)
-double <[x]>;
-float lgammaf(<[x]>)
-float <[x]>;
-double gamma_r(<[x]>, <[signgamp]>)
-double <[x]>;
-int <[signgamp]>;
-float gammaf_r(<[x]>, <[signgamp]>)
-float <[x]>;
-int <[signgamp]>;
-double lgamma_r(<[x]>, <[signgamp]>)
-double <[x]>;
-int <[signgamp]>;
-float lgammaf_r(<[x]>, <[signgamp]>)
-float <[x]>;
-int <[signgamp]>;
-
 DESCRIPTION
 <<gamma>> calculates
@tex
--- a/newlib/libm/mathfp/s_acos.c
+++ b/newlib/libm/mathfp/s_acos.c
@ -10,21 +10,11 @@ INDEX
 INDEX
        acosf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double acos(double <[x]>);
        float acosf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double acos(<[x]>)
-        double <[x]>;
-
-        float acosf(<[x]>)
-        float <[x]>;
-
-
-
 DESCRIPTION

        <<acos>> computes the inverse cosine (arc cosine) of the input value.
--- a/newlib/libm/mathfp/s_asine.c
+++ b/newlib/libm/mathfp/s_asine.c
@ -24,7 +24,7 @@ INDEX
 INDEX
   asinef

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double asine(double <[x]>);
        float asinef(float <[x]>);
@ -33,26 +33,6 @@ ANSI_SYNOPSIS
        double acos(double <[x]>);
        float acosf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double asine(<[x]>);
-        double <[x]>;
-
-        float asinef(<[x]>);
-        float <[x]>;
-
-        double asin(<[x]>)
-        double <[x]>;
-
-        float asinf(<[x]>)
-        float <[x]>;
-
-        double acos(<[x]>)
-        double <[x]>;
-
-        float acosf(<[x]>)
-        float <[x]>;
-
 DESCRIPTION

 <<asin>> computes the inverse sine or cosine of the argument <[x]>.
--- a/newlib/libm/mathfp/s_asinh.c
+++ b/newlib/libm/mathfp/s_asinh.c
@ -20,19 +20,11 @@ INDEX
 INDEX
 	asinhf

-ANSI_SYNOPSIS
+SYNOPSIS
 	#include <math.h>
 	double asinh(double <[x]>);
 	float asinhf(float <[x]>);

-TRAD_SYNOPSIS
-	#include <math.h>
-	double asinh(<[x]>)
-	double <[x]>;
-
-	float asinhf(<[x]>)
-	float <[x]>;
-
 DESCRIPTION
 <<asinh>> calculates the inverse hyperbolic sine of <[x]>.
 <<asinh>> is defined as 
--- a/newlib/libm/mathfp/s_atan.c
+++ b/newlib/libm/mathfp/s_atan.c
@ -10,19 +10,11 @@ INDEX
 INDEX
   atanf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double atan(double <[x]>);
        float atanf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double atan(<[x]>);
-        double <[x]>;
-
-        float atanf(<[x]>);
-        float <[x]>;
-
 DESCRIPTION

 <<atan>> computes the inverse tangent (arc tangent) of the input value.
--- a/newlib/libm/mathfp/s_atan2.c
+++ b/newlib/libm/mathfp/s_atan2.c
@ -10,21 +10,11 @@ INDEX
 INDEX
   atan2f

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double atan2(double <[y]>,double <[x]>);
        float atan2f(float <[y]>,float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double atan2(<[y]>,<[x]>);
-        double <[y]>;
-        double <[x]>;
-
-        float atan2f(<[y]>,<[x]>);
-        float <[y]>;
-        float <[x]>;
-
 DESCRIPTION

 <<atan2>> computes the inverse tangent (arc tangent) of <[y]>/<[x]>.
--- a/newlib/libm/mathfp/s_atangent.c
+++ b/newlib/libm/mathfp/s_atangent.c
@ -20,30 +20,13 @@ INDEX
 INDEX
   atanf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double atan(double <[x]>);
        float atan(float <[x]>);
        double atan2(double <[y]>,double <[x]>);
        float atan2f(float <[y]>,float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double atan2(<[y]>,<[x]>);
-        double <[y]>;
-        double <[x]>;
-
-        float atan2f(<[y]>,<[x]>);
-        float <[y]>;
-        float <[x]>;
-
-        #include <math.h>
-        double atan(<[x]>);
-        double <[x]>;
-
-        float atanf(<[x]>);
-        float <[x]>;
-
 DESCRIPTION

 <<atan2>> computes the inverse tangent (arc tangent) of y / x.
--- a/newlib/libm/mathfp/s_cosh.c
+++ b/newlib/libm/mathfp/s_cosh.c
@ -6,19 +6,11 @@
 FUNCTION
        <<cosh>>, <<coshf>>---hyperbolic cosine

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double cosh(double <[x]>);
        float coshf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double cosh(<[x]>);
-        double <[x]>;
-
-        float coshf(<[x]>);
-        float <[x]>;
-
 DESCRIPTION

        <<cosh>> computes the hyperbolic cosine of the argument <[x]>.
--- a/newlib/libm/mathfp/s_erf.c
+++ b/newlib/libm/mathfp/s_erf.c
@ -23,26 +23,12 @@ INDEX
 INDEX
 	erfcf

-ANSI_SYNOPSIS
+SYNOPSIS
 	#include <math.h>
 	double erf(double <[x]>);
 	float erff(float <[x]>);
 	double erfc(double <[x]>);
 	float erfcf(float <[x]>);
-TRAD_SYNOPSIS
-	#include <math.h>
-
-	double erf(<[x]>)
-	double <[x]>;
-
-	float erff(<[x]>)
-	float <[x]>;
-
-	double erfc(<[x]>)
-	double <[x]>;
-
-	float erfcf(<[x]>)
-	float <[x]>;

 DESCRIPTION
 	<<erf>> calculates an approximation to the ``error function'',
--- a/newlib/libm/mathfp/s_exp.c
+++ b/newlib/libm/mathfp/s_exp.c
@ -15,19 +15,11 @@ INDEX
 INDEX
        expf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double exp(double <[x]>);
        float expf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double exp(<[x]>);
-        double <[x]>;
-
-        float expf(<[x]>);
-        float <[x]>;
-
 DESCRIPTION
        <<exp>> and <<expf>> calculate the exponential of <[x]>, that is,
        @ifnottex
--- a/newlib/libm/mathfp/s_fabs.c
+++ b/newlib/libm/mathfp/s_fabs.c
@ -9,19 +9,11 @@ INDEX
 INDEX
        fabsf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
       double fabs(double <[x]>);
       float fabsf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-       double fabs(<[x]>)
-       double <[x]>;
-
-       float fabsf(<[x]>)
-       float <[x]>;
-
 DESCRIPTION
 <<fabs>> and <<fabsf>> calculate
@tex
--- a/newlib/libm/mathfp/s_floor.c
+++ b/newlib/libm/mathfp/s_floor.c
@ -13,24 +13,13 @@ INDEX
 INDEX
        ceilf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double floor(double <[x]>);
        float floorf(float <[x]>);
        double ceil(double <[x]>);
        float ceilf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double floor(<[x]>)
-        double <[x]>;
-        float floorf(<[x]>)
-        float <[x]>;
-        double ceil(<[x]>)
-        double <[x]>;
-        float ceilf(<[x]>)
-        float <[x]>;
-
 DESCRIPTION
 <<floor>> and <<floorf>> find
@tex
--- a/newlib/libm/mathfp/s_fmod.c
+++ b/newlib/libm/mathfp/s_fmod.c
@ -20,19 +20,11 @@ fmod
 INDEX
 fmodf

-ANSI_SYNOPSIS
+SYNOPSIS
 #include <math.h>
 double fmod(double <[x]>, double <[y]>);
 float fmodf(float <[x]>, float <[y]>);

-TRAD_SYNOPSIS
-#include <math.h>
-double fmod(<[x]>, <[y]>);
-double (<[x]>, <[y]>);
-
-float fmodf(<[x]>, <[y]>);
-float (<[x]>, <[y]>);
-
 DESCRIPTION
 The <<fmod>> and <<fmodf>> functions compute the floating-point
 remainder of <[x]>/<[y]> (<[x]> modulo <[y]>).
--- a/newlib/libm/mathfp/s_frexp.c
+++ b/newlib/libm/mathfp/s_frexp.c
@ -9,22 +9,11 @@ INDEX
 INDEX
        frexpf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double frexp(double <[val]>, int *<[exp]>);
        float frexpf(float <[val]>, int *<[exp]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double frexp(<[val]>, <[exp]>)
-        double <[val]>;
-        int *<[exp]>;
-
-        float frexpf(<[val]>, <[exp]>)
-        float <[val]>;
-        int *<[exp]>;
-
-
 DESCRIPTION
        All nonzero, normal numbers can be described as <[m]> * 2**<[p]>.
        <<frexp>> represents the double <[val]> as a mantissa <[m]>
--- a/newlib/libm/mathfp/s_ldexp.c
+++ b/newlib/libm/mathfp/s_ldexp.c
@ -10,22 +10,11 @@ INDEX
 INDEX
        ldexpf

-ANSI_SYNOPSIS
+SYNOPSIS
       #include <math.h>
       double ldexp(double <[val]>, int <[exp]>);
       float ldexpf(float <[val]>, int <[exp]>);

-TRAD_SYNOPSIS
-       #include <math.h>
-
-       double ldexp(<[val]>, <[exp]>)
-              double <[val]>;
-              int <[exp]>;
-
-       float ldexpf(<[val]>, <[exp]>)
-              float <[val]>;
-              int <[exp]>;
-
 DESCRIPTION
 <<ldexp>> calculates the value
@ifnottex
--- a/newlib/libm/mathfp/s_log10.c
+++ b/newlib/libm/mathfp/s_log10.c
@ -23,19 +23,11 @@ log10
 INDEX
 log10f

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double log10(double <[x]>);
        float log10f(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double log10(<[x]>)
-        double <[x]>;
-
-        float log10f(<[x]>)
-        float <[x]>;
-
 DESCRIPTION
 <<log10>> returns the base 10 logarithm of <[x]>.
 It is implemented as <<log(<[x]>) / log(10)>>.
--- a/newlib/libm/mathfp/s_logarithm.c
+++ b/newlib/libm/mathfp/s_logarithm.c
@ -20,27 +20,13 @@ INDEX
 INDEX
    log10f

-ANSI_SYNOPSIS
+SYNOPSIS
       #include <math.h>
       double log(double <[x]>);
       float logf(float <[x]>);
       double log10(double <[x]>);
       float log10f(float <[x]>);

-TRAD_SYNOPSIS
-       #include <math.h>
-       double log(<[x]>);
-       double <[x]>;
-
-       float logf(<[x]>);
-       float <[x]>;
-
-       double log10(<[x]>);
-       double <[x]>;
-
-       float log10f(<[x]>);
-       float <[x]>;
-
 DESCRIPTION
 Return the natural or base 10 logarithm of <[x]>, that is, its logarithm base e
 (where e is the base of the natural system of logarithms, 2.71828@dots{}) or
--- a/newlib/libm/mathfp/s_pow.c
+++ b/newlib/libm/mathfp/s_pow.c
@ -10,19 +10,11 @@ INDEX
        powf


-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double pow(double <[x]>, double <[y]>);
        float pow(float <[x]>, float <[y]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double pow(<[x]>, <[y]>);
-        double <[x]>, <[y]>;
-
-        float pow(<[x]>, <[y]>);
-        float <[x]>, <[y]>;
-
 DESCRIPTION
        <<pow>> and <<powf>> calculate <[x]> raised to the exponent <[y]>.
        @tex
--- a/newlib/libm/mathfp/s_sine.c
+++ b/newlib/libm/mathfp/s_sine.c
@ -18,25 +18,13 @@ INDEX
 cos
 INDEX
 cosf
-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double sin(double <[x]>);
        float  sinf(float <[x]>);
        double cos(double <[x]>);
        float cosf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double sin(<[x]>)
-        double <[x]>;
-        float  sinf(<[x]>)
-        float <[x]>;
-
-        double cos(<[x]>)
-        double <[x]>;
-        float cosf(<[x]>)
-        float <[x]>;
-
 DESCRIPTION
        <<sin>> and <<cos>> compute (respectively) the sine and cosine
        of the argument <[x]>.  Angles are specified in radians.
--- a/newlib/libm/mathfp/s_sineh.c
+++ b/newlib/libm/mathfp/s_sineh.c
@ -20,25 +20,12 @@ INDEX
 INDEX
        coshf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double sinh(double <[x]>);
        float  sinhf(float <[x]>);
        double cosh(double <[x]>);
        float  coshf(float <[x]>);
-TRAD_SYNOPSIS
-        #include <math.h>
-        double sinh(<[x]>)
-        double <[x]>;
-
-        float  sinhf(<[x]>)
-        float <[x]>;
-
-        double cosh(<[x]>)
-        double <[x]>;
-
-        float  coshf(<[x]>)
-        float <[x]>;

 DESCRIPTION
        <<sinh>> and <<cosh>> compute the hyperbolic sine or cosine
--- a/newlib/libm/mathfp/s_sqrt.c
+++ b/newlib/libm/mathfp/s_sqrt.c
@ -16,16 +16,11 @@ INDEX
 INDEX
        sqrtf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double sqrt(double <[x]>);
        float  sqrtf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double sqrt(<[x]>);
-        float  sqrtf(<[x]>);
-
 DESCRIPTION
        <<sqrt>> computes the positive square root of the argument.

--- a/newlib/libm/mathfp/s_tan.c
+++ b/newlib/libm/mathfp/s_tan.c
@ -16,20 +16,11 @@ tan
 INDEX
 tanf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double tan(double <[x]>);
        float tanf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double tan(<[x]>)
-        double <[x]>;
-
-        float tanf(<[x]>)
-        float <[x]>;
-
-
 DESCRIPTION
 <<tan>> computes the tangent of the argument <[x]>.
 Angles are specified in radians.
--- a/newlib/libm/mathfp/s_tanh.c
+++ b/newlib/libm/mathfp/s_tanh.c
@ -17,20 +17,11 @@ tanh
 INDEX
 tanhf

-ANSI_SYNOPSIS
+SYNOPSIS
        #include <math.h>
        double tanh(double <[x]>);
        float tanhf(float <[x]>);

-TRAD_SYNOPSIS
-        #include <math.h>
-        double tanh(<[x]>)
-        double <[x]>;
-
-        float tanhf(<[x]>)
-        float <[x]>;
-
-
 DESCRIPTION

 <<tanh>> computes the hyperbolic tangent of
--- a/newlib/libm/mathfp/w_jn.c
+++ b/newlib/libm/mathfp/w_jn.c
@ -40,7 +40,7 @@ yn
 INDEX
 ynf

-ANSI_SYNOPSIS
+SYNOPSIS
 #include <math.h>
 double j0(double <[x]>);
 float j0f(float <[x]>);
@ -55,39 +55,6 @@ float y1f(float <[x]>);
 double yn(int <[n]>, double <[x]>);
 float ynf(int <[n]>, float <[x]>);

-TRAD_SYNOPSIS
-#include <math.h>
-
-double j0(<[x]>)
-double <[x]>;
-float j0f(<[x]>)
-float <[x]>;
-double j1(<[x]>)
-double <[x]>;
-float j1f(<[x]>)
-float <[x]>;
-double jn(<[n]>, <[x]>)
-int <[n]>;
-double <[x]>;
-float jnf(<[n]>, <[x]>)
-int <[n]>;
-float <[x]>;
-
-double y0(<[x]>)
-double <[x]>;
-float y0f(<[x]>)
-float <[x]>;
-double y1(<[x]>)
-double <[x]>;
-float y1f(<[x]>)
-float <[x]>;
-double yn(<[n]>, <[x]>)
-int <[n]>;
-double <[x]>;
-float ynf(<[n]>, <[x]>)
-int <[n]>;
-float <[x]>;
-
 DESCRIPTION
 The Bessel functions are a family of functions that solve the
 differential equation