Changeset 376 for trunk

Show
Ignore:
Timestamp:
08/27/10 18:03:02 (2 years ago)
Author:
sean
Message:

Reverted changes to stdc.math. The routines aren't pure.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/import/object.di

    r371 r376  
    1515alias typeof(int.sizeof)                    size_t; 
    1616alias typeof(cast(void*)0 - cast(void*)0)   ptrdiff_t; 
    17 static if (size_t.sizeof == 4) 
    18 { 
    19     alias int sizediff_t; 
    20 } 
    21 else 
    22 { 
    23     alias long sizediff_t; 
    24 } 
     17alias ptrdiff_t                             sizediff_t; 
    2518 
    2619alias size_t hash_t; 

  • trunk/posix.mak

    r371 r376  
    7373    src/core/sync/semaphore.d \ 
    7474    \ 
     75    src/core/sys/osx/mach/dyld.d \ 
     76    src/core/sys/osx/mach/getsect.d \ 
    7577    src/core/sys/osx/mach/kern_return.d \ 
     78    src/core/sys/osx/mach/loader.d \ 
    7679    src/core/sys/osx/mach/port.d \ 
    7780    src/core/sys/osx/mach/semaphore.d \ 
    …… 
    148151    src/rt/deh2.d \ 
    149152    src/rt/dmain2.d \ 
     153    src/rt/dylib_fixes.c \ 
     154    src/rt/image.d \ 
    150155    src/rt/invariant.d \ 
    151156    src/rt/invariant_.d \ 
    …… 
    447452$(DOCDIR)/core_%.html : src/core/%.d 
    448453    $(DMD) -c -d -o- -Isrc -Iimport -Df$@ $(DOCFMT) $< 
    449  
     454     
    450455$(DOCDIR)/core_sync_%.html : src/core/sync/%.d 
    451456    $(DMD) -c -d -o- -Isrc -Iimport -Df$@ $(DOCFMT) $< 
    …… 
    454459 
    455460import: $(IMPORTS) 
    456  
     461     
    457462$(IMPDIR)/core/%.di : src/core/%.d 
    458463    $(DMD) -c -d -o- -Isrc -Iimport -Hf$@ $< 

  • trunk/src/core/stdc/math.d

    r371 r376  
    482482  version (all) // < 8-CURRENT 
    483483  { 
    484       pure 
    485       { 
    486           real    acosl(real x) { return acos(x); } 
    487           real    asinl(real x) { return asin(x); } 
    488           real    atanl(real x) { return atan(x); } 
    489           real    atan2l(real y, real x) { return atan2(y, x); } 
    490           real    cosl(real x) { return cos(x); } 
    491           real    sinl(real x) { return sin(x); } 
    492           real    tanl(real x) { return tan(x); } 
    493           real    exp2l(real x) { return exp2(x); } 
    494           real    frexpl(real value, int* exp) { return frexp(value, exp); } 
    495           int     ilogbl(real x) { return ilogb(x); } 
    496           real    ldexpl(real x, int exp) { return ldexp(x, exp); } 
    497           real    logbl(real x) { return logb(x); } 
    498           //real    modfl(real value, real *iptr); // nontrivial conversion 
    499           real    scalbnl(real x, int n) { return scalbn(x, n); } 
    500           real    scalblnl(real x, c_long n) { return scalbln(x, n); } 
    501           real    fabsl(real x) { return fabs(x); } 
    502           real    hypotl(real x, real y) { return hypot(x, y); } 
    503           real    sqrtl(real x) { return sqrt(x); } 
    504           real    ceill(real x) { return ceil(x); } 
    505           real    floorl(real x) { return floor(x); } 
    506           real    nearbyintl(real x) { return nearbyint(x); } 
    507           real    rintl(real x) { return rint(x); } 
    508           c_long  lrintl(real x) { return lrint(x); } 
    509           real    roundl(real x) { return round(x); } 
    510           c_long  lroundl(real x) { return lround(x); } 
    511           long    llroundl(real x) { return llround(x); } 
    512           real    truncl(real x) { return trunc(x); } 
    513           real    fmodl(real x, real y) { return fmod(x, y); } 
    514           real    remainderl(real x, real y) { return remainder(x, y); } 
    515           real    remquol(real x, real y, int* quo) { return remquo(x, y, quo); } 
    516           real    copysignl(real x, real y) { return copysign(x, y); } 
     484    real    acosl(real x) { return acos(x); } 
     485    real    asinl(real x) { return asin(x); } 
     486    real    atanl(real x) { return atan(x); } 
     487    real    atan2l(real y, real x) { return atan2(y, x); } 
     488    real    cosl(real x) { return cos(x); } 
     489    real    sinl(real x) { return sin(x); } 
     490    real    tanl(real x) { return tan(x); } 
     491    real    exp2l(real x) { return exp2(x); } 
     492    real    frexpl(real value, int* exp) { return frexp(value, exp); } 
     493    int     ilogbl(real x) { return ilogb(x); } 
     494    real    ldexpl(real x, int exp) { return ldexp(x, exp); } 
     495    real    logbl(real x) { return logb(x); } 
     496    //real    modfl(real value, real *iptr); // nontrivial conversion 
     497    real    scalbnl(real x, int n) { return scalbn(x, n); } 
     498    real    scalblnl(real x, c_long n) { return scalbln(x, n); } 
     499    real    fabsl(real x) { return fabs(x); } 
     500    real    hypotl(real x, real y) { return hypot(x, y); } 
     501    real    sqrtl(real x) { return sqrt(x); } 
     502    real    ceill(real x) { return ceil(x); } 
     503    real    floorl(real x) { return floor(x); } 
     504    real    nearbyintl(real x) { return nearbyint(x); } 
     505    real    rintl(real x) { return rint(x); } 
     506    c_long  lrintl(real x) { return lrint(x); } 
     507    real    roundl(real x) { return round(x); } 
     508    c_long  lroundl(real x) { return lround(x); } 
     509    long    llroundl(real x) { return llround(x); } 
     510    real    truncl(real x) { return trunc(x); } 
     511    real    fmodl(real x, real y) { return fmod(x, y); } 
     512    real    remainderl(real x, real y) { return remainder(x, y); } 
     513    real    remquol(real x, real y, int* quo) { return remquo(x, y, quo); } 
     514    real    copysignl(real x, real y) { return copysign(x, y); } 
    517515//  double  nan(char* tagp); 
    518516//  float   nanf(char* tagp); 
    519517//  real    nanl(char* tagp); 
    520           real    nextafterl(real x, real y) { return nextafter(x, y); } 
    521           real    nexttowardl(real x, real y) { return nexttoward(x, y); } 
    522           real    fdiml(real x, real y) { return fdim(x, y); } 
    523           real    fmaxl(real x, real y) { return fmax(x, y); } 
    524           real    fminl(real x, real y) { return fmin(x, y); } 
    525           real    fmal(real x, real y, real z) { return fma(x, y, z); } 
    526       } // pure 
     518    real    nextafterl(real x, real y) { return nextafter(x, y); } 
     519    real    nexttowardl(real x, real y) { return nexttoward(x, y); } 
     520    real    fdiml(real x, real y) { return fdim(x, y); } 
     521    real    fmaxl(real x, real y) { return fmax(x, y); } 
     522    real    fminl(real x, real y) { return fmin(x, y); } 
     523    real    fmal(real x, real y, real z) { return fma(x, y, z); } 
    527524  } 
    528525  else 
    529526  { 
    530       pure 
    531       { 
    532           real    acosl(real x); 
    533           real    asinl(real x); 
    534           real    atanl(real x); 
    535           real    atan2l(real y, real x); 
    536           real    cosl(real x); 
    537           real    sinl(real x); 
    538           real    tanl(real x); 
    539           real    exp2l(real x); 
    540           real    frexpl(real value, int* exp); 
    541           int     ilogbl(real x); 
    542           real    ldexpl(real x, int exp); 
    543           real    logbl(real x); 
    544           real    modfl(real value, real *iptr); 
    545           real    scalbnl(real x, int n); 
    546           real    scalblnl(real x, c_long n); 
    547           real    fabsl(real x); 
    548           real    hypotl(real x, real y); 
    549           real    sqrtl(real x); 
    550           real    ceill(real x); 
    551           real    floorl(real x); 
    552           real    nearbyintl(real x); 
    553           real    rintl(real x); 
    554           c_long  lrintl(real x); 
    555           real    roundl(real x); 
    556           c_long  lroundl(real x); 
    557           long    llroundl(real x); 
    558           real    truncl(real x); 
    559           real    fmodl(real x, real y); 
    560           real    remainderl(real x, real y); 
    561           real    remquol(real x, real y, int* quo); 
    562           real    copysignl(real x, real y); 
    563           double  nan(char* tagp); 
    564           float   nanf(char* tagp); 
    565           real    nanl(char* tagp); 
    566           real    nextafterl(real x, real y); 
    567           real    nexttowardl(real x, real y); 
    568           real    fdiml(real x, real y); 
    569           real    fmaxl(real x, real y); 
    570           real    fminl(real x, real y); 
    571           real    fmal(real x, real y, real z); 
    572       } 
     527    real    acosl(real x); 
     528    real    asinl(real x); 
     529    real    atanl(real x); 
     530    real    atan2l(real y, real x); 
     531    real    cosl(real x); 
     532    real    sinl(real x); 
     533    real    tanl(real x); 
     534    real    exp2l(real x); 
     535    real    frexpl(real value, int* exp); 
     536    int     ilogbl(real x); 
     537    real    ldexpl(real x, int exp); 
     538    real    logbl(real x); 
     539    real    modfl(real value, real *iptr); 
     540    real    scalbnl(real x, int n); 
     541    real    scalblnl(real x, c_long n); 
     542    real    fabsl(real x); 
     543    real    hypotl(real x, real y); 
     544    real    sqrtl(real x); 
     545    real    ceill(real x); 
     546    real    floorl(real x); 
     547    real    nearbyintl(real x); 
     548    real    rintl(real x); 
     549    c_long  lrintl(real x); 
     550    real    roundl(real x); 
     551    c_long  lroundl(real x); 
     552    long    llroundl(real x); 
     553    real    truncl(real x); 
     554    real    fmodl(real x, real y); 
     555    real    remainderl(real x, real y); 
     556    real    remquol(real x, real y, int* quo); 
     557    real    copysignl(real x, real y); 
     558    double  nan(char* tagp); 
     559    float   nanf(char* tagp); 
     560    real    nanl(char* tagp); 
     561    real    nextafterl(real x, real y); 
     562    real    nexttowardl(real x, real y); 
     563    real    fdiml(real x, real y); 
     564    real    fmaxl(real x, real y); 
     565    real    fminl(real x, real y); 
     566    real    fmal(real x, real y, real z); 
    573567  } 
    574  
    575   pure 
    576   { 
    577       double  acos(double x); 
    578       float   acosf(float x); 
    579  
    580       double  asin(double x); 
    581       float   asinf(float x); 
    582  
    583       double  atan(double x); 
    584       float   atanf(float x); 
    585  
    586       pure double  atan2(double y, double x); 
    587       pure float   atan2f(float y, float x); 
    588  
    589       double  cos(double x); 
    590       float   cosf(float x); 
    591  
    592       double  sin(double x); 
    593       float   sinf(float x); 
    594  
    595       double  tan(double x); 
    596       float   tanf(float x); 
    597  
    598       double  acosh(double x); 
    599       float   acoshf(float x); 
    600       real    acoshl(real x) { return acosh(x); } 
    601  
    602       double  asinh(double x); 
    603       float   asinhf(float x); 
    604       real    asinhl(real x) { return asinh(x); } 
    605  
    606       double  atanh(double x); 
    607       float   atanhf(float x); 
    608       real    atanhl(real x) { return atanh(x); } 
    609  
    610       double  cosh(double x); 
    611       float   coshf(float x); 
    612       real    coshl(real x) { return cosh(x); } 
    613  
    614       double  sinh(double x); 
    615       float   sinhf(float x); 
    616       real    sinhl(real x) { return sinh(x); } 
    617  
    618       double  tanh(double x); 
    619       float   tanhf(float x); 
    620       real    tanhl(real x) { return tanh(x); } 
    621  
    622       pure double  exp(double x); 
    623       pure float   expf(float x); 
    624       pure real    expl(real x) { return exp(x); } 
    625  
    626       pure double  exp2(double x); 
    627       pure float   exp2f(float x); 
    628  
    629       pure double  expm1(double x); 
    630       float   expm1f(float x); 
    631       real    expm1l(real x) { return expm1(x); } 
    632  
    633       double  frexp(double value, int* exp); 
    634       float   frexpf(float value, int* exp); 
    635  
    636       int     ilogb(double x); 
    637       int     ilogbf(float x); 
    638  
    639       double  ldexp(double x, int exp); 
    640       float   ldexpf(float x, int exp); 
    641  
    642       double  log(double x); 
    643       float   logf(float x); 
    644       real    logl(real x) { return log(x); } 
    645  
    646       double  log10(double x); 
    647       float   log10f(float x); 
    648       real    log10l(real x) { return log10(x); } 
    649  
    650       double  log1p(double x); 
    651       float   log1pf(float x); 
    652       real    log1pl(real x) { return log1p(x); } 
    653  
    654       private enum real ONE_LN2 = 1 / 0x1.62e42fefa39ef358p-1L; 
    655       double  log2(double x) { return log(x) * ONE_LN2; } 
    656       float   log2f(float x) { return logf(x) * ONE_LN2; } 
    657       real    log2l(real x)  { return logl(x) * ONE_LN2; } 
    658  
    659       double  logb(double x); 
    660       float   logbf(float x); 
    661  
    662       double  modf(double value, double* iptr); 
    663       float   modff(float value, float* iptr); 
    664  
    665       double  scalbn(double x, int n); 
    666       float   scalbnf(float x, int n); 
    667  
    668       double  scalbln(double x, c_long n); 
    669       float   scalblnf(float x, c_long n); 
    670  
    671       double  cbrt(double x); 
    672       float   cbrtf(float x); 
    673       real    cbrtl(real x) { return cbrt(x); } 
    674  
    675       double  fabs(double x); 
    676       float   fabsf(float x); 
    677  
    678       double  hypot(double x, double y); 
    679       float   hypotf(float x, float y); 
    680  
    681       double  pow(double x, double y); 
    682       float   powf(float x, float y); 
    683       real    powl(real x, real y) { return pow(x, y); } 
    684  
    685       double  sqrt(double x); 
    686       float   sqrtf(float x); 
    687  
    688       double  erf(double x); 
    689       float   erff(float x); 
    690       real    erfl(real x) { return erf(x); } 
    691  
    692       double  erfc(double x); 
    693       float   erfcf(float x); 
    694       real    erfcl(real x) { return erfc(x); } 
    695  
    696       double  lgamma(double x); 
    697       float   lgammaf(float x); 
    698       real    lgammal(real x) { return lgamma(x); } 
    699  
    700       double  tgamma(double x); 
    701       float   tgammaf(float x); 
    702       real    tgammal(real x) { return tgamma(x); } 
    703  
    704       double  ceil(double x); 
    705       float   ceilf(float x); 
    706  
    707       double  floor(double x); 
    708       float   floorf(float x); 
    709  
    710       double  nearbyint(double x); 
    711       float   nearbyintf(float x); 
    712  
    713       double  rint(double x); 
    714       float   rintf(float x); 
    715  
    716       c_long  lrint(double x); 
    717       c_long  lrintf(float x); 
    718  
    719       long    llrint(double x); 
    720       long    llrintf(float x); 
    721       long    llrintl(real x) { return llrint(x); } 
    722  
    723       double  round(double x); 
    724       float   roundf(float x); 
    725  
    726       c_long  lround(double x); 
    727       c_long  lroundf(float x); 
    728  
    729       long    llround(double x); 
    730       long    llroundf(float x); 
    731  
    732       double  trunc(double x); 
    733       float   truncf(float x); 
    734  
    735       double  fmod(double x, double y); 
    736       float   fmodf(float x, float y); 
    737  
    738       double  remainder(double x, double y); 
    739       float   remainderf(float x, float y); 
    740  
    741       double  remquo(double x, double y, int* quo); 
    742       float   remquof(float x, float y, int* quo); 
    743  
    744       double  copysign(double x, double y); 
    745       float   copysignf(float x, float y); 
    746  
    747       double  nextafter(double x, double y); 
    748       float   nextafterf(float x, float y); 
    749  
    750       double  nexttoward(double x, real y); 
    751       float   nexttowardf(float x, real y); 
    752  
    753       double  fdim(double x, double y); 
    754       float   fdimf(float x, float y); 
    755  
    756       double  fmax(double x, double y); 
    757       float   fmaxf(float x, float y); 
    758  
    759       double  fmin(double x, double y); 
    760       float   fminf(float x, float y); 
    761  
    762       double  fma(double x, double y, double z); 
    763       float   fmaf(float x, float y, float z); 
    764   } 
     568    double  acos(double x); 
     569    float   acosf(float x); 
     570 
     571    double  asin(double x); 
     572    float   asinf(float x); 
     573 
     574    double  atan(double x); 
     575    float   atanf(float x); 
     576 
     577    double  atan2(double y, double x); 
     578    float   atan2f(float y, float x); 
     579 
     580    double  cos(double x); 
     581    float   cosf(float x); 
     582 
     583    double  sin(double x); 
     584    float   sinf(float x); 
     585 
     586    double  tan(double x); 
     587    float   tanf(float x); 
     588 
     589    double  acosh(double x); 
     590    float   acoshf(float x); 
     591    real    acoshl(real x) { return acosh(x); } 
     592 
     593    double  asinh(double x); 
     594    float   asinhf(float x); 
     595    real    asinhl(real x) { return asinh(x); } 
     596 
     597    double  atanh(double x); 
     598    float   atanhf(float x); 
     599    real    atanhl(real x) { return atanh(x); } 
     600 
     601    double  cosh(double x); 
     602    float   coshf(float x); 
     603    real    coshl(real x) { return cosh(x); } 
     604 
     605    double  sinh(double x); 
     606    float   sinhf(float x); 
     607    real    sinhl(real x) { return sinh(x); } 
     608 
     609    double  tanh(double x); 
     610    float   tanhf(float x); 
     611    real    tanhl(real x) { return tanh(x); } 
     612 
     613    double  exp(double x); 
     614    float   expf(float x); 
     615    real    expl(real x) { return exp(x); } 
     616 
     617    double  exp2(double x); 
     618    float   exp2f(float x); 
     619 
     620    double  expm1(double x); 
     621    float   expm1f(float x); 
     622    real    expm1l(real x) { return expm1(x); } 
     623 
     624    double  frexp(double value, int* exp); 
     625    float   frexpf(float value, int* exp); 
     626 
     627    int     ilogb(double x); 
     628    int     ilogbf(float x); 
     629 
     630    double  ldexp(double x, int exp); 
     631    float   ldexpf(float x, int exp); 
     632 
     633    double  log(double x); 
     634    float   logf(float x); 
     635    real    logl(real x) { return log(x); } 
     636 
     637    double  log10(double x); 
     638    float   log10f(float x); 
     639    real    log10l(real x) { return log10(x); } 
     640 
     641    double  log1p(double x); 
     642    float   log1pf(float x); 
     643    real    log1pl(real x) { return log1p(x); } 
     644 
     645    private enum real ONE_LN2 = 1 / 0x1.62e42fefa39ef358p-1L; 
     646    double  log2(double x) { return log(x) * ONE_LN2; } 
     647    float   log2f(float x) { return logf(x) * ONE_LN2; } 
     648    real    log2l(real x)  { return logl(x) * ONE_LN2; } 
     649 
     650    double  logb(double x); 
     651    float   logbf(float x); 
     652 
     653    double  modf(double value, double* iptr); 
     654    float   modff(float value, float* iptr); 
     655 
     656    double  scalbn(double x, int n); 
     657    float   scalbnf(float x, int n); 
     658 
     659    double  scalbln(double x, c_long n); 
     660    float   scalblnf(float x, c_long n); 
     661 
     662    double  cbrt(double x); 
     663    float   cbrtf(float x); 
     664    real    cbrtl(real x) { return cbrt(x); } 
     665 
     666    double  fabs(double x); 
     667    float   fabsf(float x); 
     668 
     669    double  hypot(double x, double y); 
     670    float   hypotf(float x, float y); 
     671 
     672    double  pow(double x, double y); 
     673    float   powf(float x, float y); 
     674    real    powl(real x, real y) { return pow(x, y); } 
     675 
     676    double  sqrt(double x); 
     677    float   sqrtf(float x); 
     678 
     679    double  erf(double x); 
     680    float   erff(float x); 
     681    real    erfl(real x) { return erf(x); } 
     682 
     683    double  erfc(double x); 
     684    float   erfcf(float x); 
     685    real    erfcl(real x) { return erfc(x); } 
     686 
     687    double  lgamma(double x); 
     688    float   lgammaf(float x); 
     689    real    lgammal(real x) { return lgamma(x); } 
     690 
     691    double  tgamma(double x); 
     692    float   tgammaf(float x); 
     693    real    tgammal(real x) { return tgamma(x); } 
     694 
     695    double  ceil(double x); 
     696    float   ceilf(float x); 
     697 
     698    double  floor(double x); 
     699    float   floorf(float x); 
     700 
     701    double  nearbyint(double x); 
     702    float   nearbyintf(float x); 
     703 
     704    double  rint(double x); 
     705    float   rintf(float x); 
     706 
     707    c_long  lrint(double x); 
     708    c_long  lrintf(float x); 
     709 
     710    long    llrint(double x); 
     711    long    llrintf(float x); 
     712    long    llrintl(real x) { return llrint(x); } 
     713 
     714    double  round(double x); 
     715    float   roundf(float x); 
     716 
     717    c_long  lround(double x); 
     718    c_long  lroundf(float x); 
     719 
     720    long    llround(double x); 
     721    long    llroundf(float x); 
     722 
     723    double  trunc(double x); 
     724    float   truncf(float x); 
     725 
     726    double  fmod(double x, double y); 
     727    float   fmodf(float x, float y); 
     728 
     729    double  remainder(double x, double y); 
     730    float   remainderf(float x, float y); 
     731 
     732    double  remquo(double x, double y, int* quo); 
     733    float   remquof(float x, float y, int* quo); 
     734 
     735    double  copysign(double x, double y); 
     736    float   copysignf(float x, float y); 
     737 
     738    double  nextafter(double x, double y); 
     739    float   nextafterf(float x, float y); 
     740 
     741    double  nexttoward(double x, real y); 
     742    float   nexttowardf(float x, real y); 
     743 
     744    double  fdim(double x, double y); 
     745    float   fdimf(float x, float y); 
     746 
     747    double  fmax(double x, double y); 
     748    float   fmaxf(float x, float y); 
     749 
     750    double  fmin(double x, double y); 
     751    float   fminf(float x, float y); 
     752 
     753    double  fma(double x, double y, double z); 
     754    float   fmaf(float x, float y, float z); 
    765755} 
    766756else 
    767757{ 
    768     pure 
    769     { 
    770         double  acos(double x); 
    771         float   acosf(float x); 
    772         real    acosl(real x); 
    773  
    774         double  asin(double x); 
    775         float   asinf(float x); 
    776         real    asinl(real x); 
    777  
    778         double  atan(double x); 
    779         float   atanf(float x); 
    780         real    atanl(real x); 
    781  
    782         pure double  atan2(double y, double x); 
    783         pure float   atan2f(float y, float x); 
    784         pure real    atan2l(real y, real x); 
    785  
    786         double  cos(double x); 
    787         float   cosf(float x); 
    788         real    cosl(real x); 
    789  
    790         double  sin(double x); 
    791         float   sinf(float x); 
    792         real    sinl(real x); 
    793  
    794         double  tan(double x); 
    795         float   tanf(float x); 
    796         pure real    tanl(real x); 
    797  
    798         double  acosh(double x); 
    799         float   acoshf(float x); 
    800         real    acoshl(real x); 
    801  
    802         double  asinh(double x); 
    803         float   asinhf(float x); 
    804         real    asinhl(real x); 
    805  
    806         double  atanh(double x); 
    807         float   atanhf(float x); 
    808         real    atanhl(real x); 
    809  
    810         double  cosh(double x); 
    811         float   coshf(float x); 
    812         real    coshl(real x); 
    813  
    814         double  sinh(double x); 
    815         float   sinhf(float x); 
    816         real    sinhl(real x); 
    817  
    818         double  tanh(double x); 
    819         float   tanhf(float x); 
    820         real    tanhl(real x); 
    821  
    822         double  exp(double x); 
    823         float   expf(float x); 
    824         real    expl(real x); 
    825  
    826         double  exp2(double x); 
    827         float   exp2f(float x); 
    828         real    exp2l(real x); 
    829  
    830         double  expm1(double x); 
    831         float   expm1f(float x); 
    832         real    expm1l(real x); 
    833  
    834         double  frexp(double value, int* exp); 
    835         float   frexpf(float value, int* exp); 
    836         real    frexpl(real value, int* exp); 
    837  
    838         int     ilogb(double x); 
    839         int     ilogbf(float x); 
    840         int     ilogbl(real x); 
    841  
    842         double  ldexp(double x, int exp); 
    843         float   ldexpf(float x, int exp); 
    844         real    ldexpl(real x, int exp); 
    845  
    846         double  log(double x); 
    847         float   logf(float x); 
    848         real    logl(real x); 
    849  
    850         double  log10(double x); 
    851         float   log10f(float x); 
    852         real    log10l(real x); 
    853  
    854         double  log1p(double x); 
    855         float   log1pf(float x); 
    856         real    log1pl(real x); 
    857  
    858         double  log2(double x); 
    859         float   log2f(float x); 
    860         real    log2l(real x); 
    861  
    862         double  logb(double x); 
    863         float   logbf(float x); 
    864         real    logbl(real x); 
    865  
    866         double  modf(double value, double* iptr); 
    867         float   modff(float value, float* iptr); 
    868         real    modfl(real value, real *iptr); 
    869  
    870         double  scalbn(double x, int n); 
    871         float   scalbnf(float x, int n); 
    872         real    scalbnl(real x, int n); 
    873  
    874         double  scalbln(double x, c_long n); 
    875         float   scalblnf(float x, c_long n); 
    876         real    scalblnl(real x, c_long n); 
    877  
    878         double  cbrt(double x); 
    879         float   cbrtf(float x); 
    880         real    cbrtl(real x); 
    881  
    882         double  fabs(double x); 
    883         float   fabsf(float x); 
    884         real    fabsl(real x); 
    885  
    886         double  hypot(double x, double y); 
    887         float   hypotf(float x, float y); 
    888         real    hypotl(real x, real y); 
    889  
    890         double  pow(double x, double y); 
    891         float   powf(float x, float y); 
    892         real    powl(real x, real y); 
    893  
    894         double  sqrt(double x); 
    895         float   sqrtf(float x); 
    896         real    sqrtl(real x); 
    897  
    898         double  erf(double x); 
    899         float   erff(float x); 
    900         real    erfl(real x); 
    901  
    902         double  erfc(double x); 
    903         float   erfcf(float x); 
    904         real    erfcl(real x); 
    905  
    906         double  lgamma(double x); 
    907         float   lgammaf(float x); 
    908         real    lgammal(real x); 
    909  
    910         double  tgamma(double x); 
    911         float   tgammaf(float x); 
    912         real    tgammal(real x); 
    913  
    914         double  ceil(double x); 
    915         float   ceilf(float x); 
    916         real    ceill(real x); 
    917  
    918         double  floor(double x); 
    919         float   floorf(float x); 
    920         real    floorl(real x); 
    921  
    922         double  nearbyint(double x); 
    923         float   nearbyintf(float x); 
    924         real    nearbyintl(real x); 
    925  
    926         double  rint(double x); 
    927         float   rintf(float x); 
    928         real    rintl(real x); 
    929  
    930         c_long  lrint(double x); 
    931         c_long  lrintf(float x); 
    932         c_long  lrintl(real x); 
    933  
    934         long    llrint(double x); 
    935         long    llrintf(float x); 
    936         long    llrintl(real x); 
    937  
    938         double  round(double x); 
    939         float   roundf(float x); 
    940         real    roundl(real x); 
    941  
    942         c_long  lround(double x); 
    943         c_long  lroundf(float x); 
    944         c_long  lroundl(real x); 
    945  
    946         long    llround(double x); 
    947         long    llroundf(float x); 
    948         long    llroundl(real x); 
    949  
    950         double  trunc(double x); 
    951         float   truncf(float x); 
    952         real    truncl(real x); 
    953  
    954         double  fmod(double x, double y); 
    955         float   fmodf(float x, float y); 
    956         real    fmodl(real x, real y); 
    957  
    958         double  remainder(double x, double y); 
    959         float   remainderf(float x, float y); 
    960         real    remainderl(real x, real y); 
    961  
    962         double  remquo(double x, double y, int* quo); 
    963         float   remquof(float x, float y, int* quo); 
    964         real    remquol(real x, real y, int* quo); 
    965  
    966         double  copysign(double x, double y); 
    967         float   copysignf(float x, float y); 
    968         real    copysignl(real x, real y); 
    969  
    970         double  nan(char* tagp); 
    971         float   nanf(char* tagp); 
    972         real    nanl(char* tagp); 
    973  
    974         double  nextafter(double x, double y); 
    975         float   nextafterf(float x, float y); 
    976         real    nextafterl(real x, real y); 
    977  
    978         double  nexttoward(double x, real y); 
    979         float   nexttowardf(float x, real y); 
    980         real    nexttowardl(real x, real y); 
    981  
    982         double  fdim(double x, double y); 
    983         float   fdimf(float x, float y); 
    984         real    fdiml(real x, real y); 
    985  
    986         double  fmax(double x, double y); 
    987         float   fmaxf(float x, float y); 
    988         real    fmaxl(real x, real y); 
    989  
    990         double  fmin(double x, double y); 
    991         float   fminf(float x, float y); 
    992         real    fminl(real x, real y); 
    993  
    994         double  fma(double x, double y, double z); 
    995         float   fmaf(float x, float y, float z); 
    996         real    fmal(real x, real y, real z); 
    997     } 
     758    double  acos(double x); 
     759    float   acosf(float x); 
     760    real    acosl(real x); 
     761 
     762    double  asin(double x); 
     763    float   asinf(float x); 
     764    real    asinl(real x); 
     765 
     766    double  atan(double x); 
     767    float   atanf(float x); 
     768    real    atanl(real x); 
     769 
     770    double  atan2(double y, double x); 
     771    float   atan2f(float y, float x); 
     772    real    atan2l(real y, real x); 
     773 
     774    double  cos(double x); 
     775    float   cosf(float x); 
     776    real    cosl(real x); 
     777 
     778    double  sin(double x); 
     779    float   sinf(float x); 
     780    real    sinl(real x); 
     781 
     782    double  tan(double x); 
     783    float   tanf(float x); 
     784    real    tanl(real x); 
     785 
     786    double  acosh(double x); 
     787    float   acoshf(float x); 
     788    real    acoshl(real x); 
     789 
     790    double  asinh(double x); 
     791    float   asinhf(float x); 
     792    real    asinhl(real x); 
     793 
     794    double  atanh(double x); 
     795    float   atanhf(float x); 
     796    real    atanhl(real x); 
     797 
     798    double  cosh(double x); 
     799    float   coshf(float x); 
     800    real    coshl(real x); 
     801 
     802    double  sinh(double x); 
     803    float   sinhf(float x); 
     804    real    sinhl(real x); 
     805 
     806    double  tanh(double x); 
     807    float   tanhf(float x); 
     808    real    tanhl(real x); 
     809 
     810    double  exp(double x); 
     811    float   expf(float x); 
     812    real    expl(real x); 
     813 
     814    double  exp2(double x); 
     815    float   exp2f(float x); 
     816    real    exp2l(real x); 
     817 
     818    double  expm1(double x); 
     819    float   expm1f(float x); 
     820    real    expm1l(real x); 
     821 
     822    double  frexp(double value, int* exp); 
     823    float   frexpf(float value, int* exp); 
     824    real    frexpl(real value, int* exp); 
     825 
     826    int     ilogb(double x); 
     827    int     ilogbf(float x); 
     828    int     ilogbl(real x); 
     829 
     830    double  ldexp(double x, int exp); 
     831    float   ldexpf(float x, int exp); 
     832    real    ldexpl(real x, int exp); 
     833 
     834    double  log(double x); 
     835    float   logf(float x); 
     836    real    logl(real x); 
     837 
     838    double  log10(double x); 
     839    float   log10f(float x); 
     840    real    log10l(real x); 
     841 
     842    double  log1p(double x); 
     843    float   log1pf(float x); 
     844    real    log1pl(real x); 
     845 
     846    double  log2(double x); 
     847    float   log2f(float x); 
     848    real    log2l(real x); 
     849 
     850    double  logb(double x); 
     851    float   logbf(float x); 
     852    real    logbl(real x); 
     853 
     854    double  modf(double value, double* iptr); 
     855    float   modff(float value, float* iptr); 
     856    real    modfl(real value, real *iptr); 
     857 
     858    double  scalbn(double x, int n); 
     859    float   scalbnf(float x, int n); 
     860    real    scalbnl(real x, int n); 
     861 
     862    double  scalbln(double x, c_long n); 
     863    float   scalblnf(float x, c_long n); 
     864    real    scalblnl(real x, c_long n); 
     865 
     866    double  cbrt(double x); 
     867    float   cbrtf(float x); 
     868    real    cbrtl(real x); 
     869 
     870    double  fabs(double x); 
     871    float   fabsf(float x); 
     872    real    fabsl(real x); 
     873 
     874    double  hypot(double x, double y); 
     875    float   hypotf(float x, float y); 
     876    real    hypotl(real x, real y); 
     877 
     878    double  pow(double x, double y); 
     879    float   powf(float x, float y); 
     880    real    powl(real x, real y); 
     881 
     882    double  sqrt(double x); 
     883    float   sqrtf(float x); 
     884    real    sqrtl(real x); 
     885 
     886    double  erf(double x); 
     887    float   erff(float x); 
     888    real    erfl(real x); 
     889 
     890    double  erfc(double x); 
     891    float   erfcf(float x); 
     892    real    erfcl(real x); 
     893 
     894    double  lgamma(double x); 
     895    float   lgammaf(float x); 
     896    real    lgammal(real x); 
     897 
     898    double  tgamma(double x); 
     899    float   tgammaf(float x); 
     900    real    tgammal(real x); 
     901 
     902    double  ceil(double x); 
     903    float   ceilf(float x); 
     904    real    ceill(real x); 
     905 
     906    double  floor(double x); 
     907    float   floorf(float x); 
     908    real    floorl(real x); 
     909 
     910    double  nearbyint(double x); 
     911    float   nearbyintf(float x); 
     912    real    nearbyintl(real x); 
     913 
     914    double  rint(double x); 
     915    float   rintf(float x); 
     916    real    rintl(real x); 
     917 
     918    c_long  lrint(double x); 
     919    c_long  lrintf(float x); 
     920    c_long  lrintl(real x); 
     921 
     922    long    llrint(double x); 
     923    long    llrintf(float x); 
     924    long    llrintl(real x); 
     925 
     926    double  round(double x); 
     927    float   roundf(float x); 
     928    real    roundl(real x); 
     929 
     930    c_long  lround(double x); 
     931    c_long  lroundf(float x); 
     932    c_long  lroundl(real x); 
     933 
     934    long    llround(double x); 
     935    long    llroundf(float x); 
     936    long    llroundl(real x); 
     937 
     938    double  trunc(double x); 
     939    float   truncf(float x); 
     940    real    truncl(real x); 
     941 
     942    double  fmod(double x, double y); 
     943    float   fmodf(float x, float y); 
     944    real    fmodl(real x, real y); 
     945 
     946    double  remainder(double x, double y); 
     947    float   remainderf(float x, float y); 
     948    real    remainderl(real x, real y); 
     949 
     950    double  remquo(double x, double y, int* quo); 
     951    float   remquof(float x, float y, int* quo); 
     952    real    remquol(real x, real y, int* quo); 
     953 
     954    double  copysign(double x, double y); 
     955    float   copysignf(float x, float y); 
     956    real    copysignl(real x, real y); 
     957 
     958    double  nan(char* tagp); 
     959    float   nanf(char* tagp); 
     960    real    nanl(char* tagp); 
     961 
     962    double  nextafter(double x, double y); 
     963    float   nextafterf(float x, float y); 
     964    real    nextafterl(real x, real y); 
     965 
     966    double  nexttoward(double x, real y); 
     967    float   nexttowardf(float x, real y); 
     968    real    nexttowardl(real x, real y); 
     969 
     970    double  fdim(double x, double y); 
     971    float   fdimf(float x, float y); 
     972    real    fdiml(real x, real y); 
     973 
     974    double  fmax(double x, double y); 
     975    float   fmaxf(float x, float y); 
     976    real    fmaxl(real x, real y); 
     977 
     978    double  fmin(double x, double y); 
     979    float   fminf(float x, float y); 
     980    real    fminl(real x, real y); 
     981 
     982    double  fma(double x, double y, double z); 
     983    float   fmaf(float x, float y, float z); 
     984    real    fmal(real x, real y, real z); 
    998985} 

  • trunk/src/core/sys/posix/unistd.d

    r371 r376  
    491491version( linux ) 
    492492{ 
    493     int fdatasync(int); 
     493    int fdatasync(int);     
    494494} 
    495495 

  • trunk/src/object_.d

    r371 r376  
    4545{ 
    4646    alias ulong size_t; 
     47    alias long  ptrdiff_t; 
    4748    alias long  sizediff_t; 
    48     alias long  ptrdiff_t; 
    4949} 
    5050else 
    5151{ 
    52     alias uint size_t; 
    53     alias int  sizediff_t; 
    54     alias int  ptrdiff_t; 
     52    alias uint size_t; 
     53    alias int  ptrdiff_t; 
     54    alias int  sizediff_t; 
    5555} 
    5656 
    …… 
    109109        return this is o; 
    110110    } 
    111  
     111     
    112112    equals_t opEquals(Object lhs, Object rhs) 
    113113    { 
    …… 
    17221722             printf("\t%.*s\n", m.name); 
    17231723         } 
    1724     } 
     1724    }     
    17251725 
    17261726    version (Windows) 
    …… 
    19681968        m = cast(shared(Monitor)*) owner.__monitor; 
    19691969    } 
    1970  
     1970     
    19711971    auto i = m.impl; 
    19721972    if (i is null) 
    …… 
    24282428    // enforce() copied from Phobos std.contracts for clear(), left out until 
    24292429    // we decide whether to use it. 
    2430  
     2430     
    24312431 
    24322432    T _enforce(T, string file = __FILE__, int line = __LINE__)