[WRAPPED] Removed GOS, renamed GODW into GOWD (#1797)

7 files changed, 71 insertions, 100 deletions

diff --git a/src/wrapped/wrappedandroidsupport_private.h b/src/wrapped/wrappedandroidsupport_private.h
index a0ed8e1f..4c8e334b 100644
--- a/src/wrapped/wrappedandroidsupport_private.h
+++ b/src/wrapped/wrappedandroidsupport_private.h
@@ -1,4 +1,4 @@
-#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA) && defined(GOS))
+#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA))
 #error Meh...
 #endif
 
diff --git a/src/wrapped/wrappediconv_private.h b/src/wrapped/wrappediconv_private.h
index a0ed8e1f..4c8e334b 100644
--- a/src/wrapped/wrappediconv_private.h
+++ b/src/wrapped/wrappediconv_private.h
@@ -1,4 +1,4 @@
-#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA) && defined(GOS))
+#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA))
 #error Meh...
 #endif
 
diff --git a/src/wrapped/wrappedlib_init.h b/src/wrapped/wrappedlib_init.h
index 18d5b9f0..c8612287 100644
--- a/src/wrapped/wrappedlib_init.h
+++ b/src/wrapped/wrappedlib_init.h
@@ -28,9 +28,9 @@
 #endif
 // regular symbol mapped to itself or another one (depending on HAVE_LD80BITS), but weak
 #ifdef HAVE_LD80BITS
-#define GODW(N, W, O) GOW(N, W)
+#define GOWD(N, W, O) GOW(N, W)
 #else
-#define GODW(N, W, O) GOW2(N, W, O)
+#define GOWD(N, W, O) GOW2(N, W, O)
 #endif
 
 // regular symbol mapped to itself
@@ -41,8 +41,6 @@
 #define GOM(N, W)
 // symbol mapped to my_symbol, but weak
 #define GOWM(N, W)
-// regular symbol mapped to itself, that returns a structure
-#define GOS(N, W)
 // symbol mapped to another one
 #define GO2(N, W, O)
 // symbol mapped to another one, but weak
@@ -87,21 +85,10 @@ static const map_onesymbol_t MAPNAME(mysymbolmap)[] = {
 };
 #undef GOM
 #undef GOWM
-#undef GOS
 #define GOM(N, W)
 #define GOWM(N, W)
-#ifdef STATICBUILD
-#define GOS(N, W) {#N, W, 0, &my_##N},
-#else
-#define GOS(N, W) {#N, W, 0},
-#endif
-static const map_onesymbol_t MAPNAME(stsymbolmap)[] = {
-    #include PRIVATE(LIBNAME)
-};
-#undef GOS
 #undef GO2
 #undef GOW2
-#define GOS(N, W)
 #ifdef STATICBUILD
 #define GO2(N, W, O) {#N, W, 0, #O, &O},
 #define GOW2(N, W, O) {#N, W, 1, #O, &O},
@@ -150,12 +137,11 @@ static const map_onedata_t MAPNAME(mydatamap)[] = {
 #undef GO
 #undef GOW
 #undef GOD
-#undef GODW
+#undef GOWD
 #undef GOM
 #undef GOWM
 #undef GO2
 #undef GOW2
-#undef GOS
 #undef DATA
 #undef DATAV
 #undef DATAB
@@ -255,19 +241,6 @@ int FUNC(_init)(library_t* lib, box64context_t* box64)
     DOIT(symbolmap)
     DOIT(mysymbolmap)
 #undef DOIT
-    cnt = sizeof(MAPNAME(stsymbolmap))/sizeof(map_onesymbol_t);
-    for (int i=0; i<cnt; ++i) {
-        k = kh_put(symbolmap, lib->w.stsymbolmap, MAPNAME(stsymbolmap)[i].name, &ret);
-        kh_value(lib->w.stsymbolmap, k).w = MAPNAME(stsymbolmap)[i].w;
-        #ifdef STATICBUILD
-        kh_value(lib->w.stsymbolmap, k).resolved = 1;
-        kh_value(lib->w.stsymbolmap, k).addr = (uintptr_t)MAPNAME(stsymbolmap)[i].addr;
-        #else
-        kh_value(lib->w.stsymbolmap, k).resolved = 0;
-        #endif
-        if(strchr(MAPNAME(stsymbolmap)[i].name, '@'))
-            AddDictionnary(box64->versym, MAPNAME(stsymbolmap)[i].name);
-    }
     cnt = sizeof(MAPNAME(symbol2map))/sizeof(map_onesymbol2_t);
     for (int i=0; i<cnt; ++i) {
         k = kh_put(symbol2map, lib->w.symbol2map, MAPNAME(symbol2map)[i].name, &ret);
diff --git a/src/wrapped/wrappedlibc_private.h b/src/wrapped/wrappedlibc_private.h
index 77ac3c48..ceaef297 100644
--- a/src/wrapped/wrappedlibc_private.h
+++ b/src/wrapped/wrappedlibc_private.h
@@ -1,4 +1,4 @@
-#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA) && defined(GOS))
+#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA))
 #error Meh...
 #endif
 
@@ -182,7 +182,7 @@ GO(copy_file_range, lFipipLu)
 //GO(__copy_grp, 
 GOW(copysign, dFdd)
 GOW(copysignf, fFff)
-GODW(copysignl, DFDD, copysign)
+GOWD(copysignl, DFDD, copysign)
 GOW(creat, iFpu)
 GOW(creat64, iFpu)
 //GO(create_module, 
@@ -394,7 +394,7 @@ GOW(finite, iFd)
 GO(__finitef, iFf)
 GOW(finitef, iFf)
 GOD(__finitel, iFD, __finite)
-GODW(finitel, iFD, finite)
+GOWD(finitel, iFD, finite)
 GO(__flbf, iFp)
 GO(flistxattr, lFipL)
 GOW(flock, iFii)
@@ -439,7 +439,7 @@ GO(freopen, pFppp)
 GO(freopen64, pFppp)
 GOW(frexp, dFdp)
 GOW(frexpf, fFfp)
-GODW(frexpl, DFDp, frexp)
+GOWD(frexpl, DFDp, frexp)
 GOM(fscanf, iFEppV)
 GO(fseek, iFpli)
 GO(fseeko, iFpIi)
@@ -964,7 +964,7 @@ GOW(isinf, iFd)
 GO(__isinff, iFf)
 GOW(isinff, iFf)
 GOD(__isinfl, iFD, __isinf)
-GODW(isinfl, iFD, isinf)
+GOWD(isinfl, iFD, isinf)
 GO(islower, iFi)
 //GO(__islower_l, 
 //GOW(islower_l, iFi!)
@@ -973,7 +973,7 @@ GOW(isnan, iFd)
 GO(__isnanf, iFf)
 GOW(isnanf, iFf)
 GOD(__isnanl, iFD, __isnan)
-GODW(isnanl, iFD, isnan)
+GOWD(isnanl, iFD, isnan)
 GO2(__isoc23_fscanf, iFEppV, my___isoc99_fscanf)
 GO2(__isoc23_sscanf, iFEppV, my___isoc99_sscanf)
 GO2(__isoc23_strtol, lFppi, strtol)
@@ -1081,7 +1081,7 @@ GO(lcong48, vFp)
 GOW(lcong48_r, iFpp)
 GOW(ldexp, dFdi)
 GOW(ldexpf, fFfi)
-GODW(ldexpl, DFDi, ldexp)
+GOWD(ldexpl, DFDi, ldexp)
 GO(ldiv, HFll)
 GOM(lfind, pFEpppLp)
 GO(lgetxattr, lFpppL)
@@ -1257,7 +1257,7 @@ GOWM(mmap, pFEpLiiil)
 GOWM(mmap64, pFEpLiiil)
 GOW(modf, dFdp)
 GOW(modff, fFfp)
-GODW(modfl, DFDp, modf)
+GOWD(modfl, DFDp, modf)
 //GOW(modify_ldt, // Deprecated
 //GOW(moncontrol, 
 //GO(__monstartup, 
@@ -1501,7 +1501,7 @@ GO(pwritev2, lFipili)
 GO(pwritev64, lFipil)
 GO(pwritev64v2, lFipili)
 GOD(qecvt, pFDipp, ecvt)
-GODW(qecvt_r, iFDipppL, ecvt_r)
+GOWD(qecvt_r, iFDipppL, ecvt_r)
 GOD(qfcvt, pFDipp, fcvt)
 GOD(qfcvt_r, iFDipppL, fcvt_r)
 GOD(qgcvt, pFDip, gcvt)
@@ -1623,7 +1623,7 @@ GO(__sbrk, pFl)
 GO(sbrk, pFl)
 GOW(scalbn, dFdi)
 GOW(scalbnf, fFfi)
-GODW(scalbnl, DFDi, scalbn)
+GOWD(scalbnl, DFDi, scalbn)
 GOWM(scandir, iFEpppp)
 GOWM(scandir64, iFEpppp)
 GOWM(scandirat, iFipppp)
@@ -1909,7 +1909,7 @@ GOW(strtof32x, dFpp)
 //GOW(strtof32x_l, dFpp!)
 GOW(strtof64, dFpp)
 //GOW(strtof64_l, dFpp!)
-GODW(strtof64x, DFpp, strtof64)
+GOWD(strtof64x, DFpp, strtof64)
 //GOW(strtof64x_l, DFpp!)
 GO(__strtof_internal, fFppi)
 GO(__strtof_l, fFppL)
@@ -1925,7 +1925,7 @@ GO(strtol, lFppi)
 GOD(strtold, DFpp, strtod)
 GOD(__strtold_internal, DFppi, __strtod_internal)
 GOD(__strtold_l, DFppp, __strtod_l)
-GODW(strtold_l, DFppp, strtod_l)
+GOWD(strtold_l, DFppp, strtod_l)
 //GO(__strtold_nan, 
 GO(__strtol_internal, lFppii)
 GO(__strtol_l, lFppi)
@@ -2262,7 +2262,7 @@ GOW(wcstof32x, dFpp)
 //GOW(wcstof32x_l, dFpp!)
 GOW(wcstof64, dFpp)
 //GOW(wcstof64_l, dFpp!)
-GODW(wcstof64x, DFpp, wcstof64)
+GOWD(wcstof64x, DFpp, wcstof64)
 //GOW(wcstof64x_l, DFpp!)
 //GO(__wcstof_internal, 
 //GO(__wcstof_l, 
diff --git a/src/wrapped/wrappedlibm_private.h b/src/wrapped/wrappedlibm_private.h
index 6f12f62c..2c4c2d41 100644
--- a/src/wrapped/wrappedlibm_private.h
+++ b/src/wrapped/wrappedlibm_private.h
@@ -10,32 +10,32 @@ GOW(acosh, dFd)
 GOW(acoshf, fFf)
 GOM(__acoshf_finite, fFf)
 GOM(__acosh_finite, dFd)
-GODW(acoshl, DFD, acosh)
-GODW(acosl, DFD, acos)
+GOWD(acoshl, DFD, acosh)
+GOWD(acosl, DFD, acos)
 GOW(asin, dFd)
 GOW(asinf, fFf)
 GOM(__asinf_finite, fFf)
 GOM(__asin_finite, dFd)
 GOW(asinh, dFd)
 GOW(asinhf, fFf)
-GODW(asinhl, DFD, asinh)
-GODW(asinl, DFD, asin)
+GOWD(asinhl, DFD, asinh)
+GOWD(asinl, DFD, asin)
 GO(atan, dFd)
 GOW(atan2, dFdd)
 GOW(atan2f, fFff)
 GOM(__atan2f_finite, fFff)
 GOM(__atan2_finite, dFdd)
-GODW(atan2l, lFDD, atan2)
+GOWD(atan2l, lFDD, atan2)
 GOW(atanf, fFf)
 GOW(atanh, dFd)
 GOW(atanhf, fFf)
 // __atanhf_finite
 // __atanh_finite
-GODW(atanhl, DFD, atanh)
-GODW(atanl, DFD, atan)
+GOWD(atanhl, DFD, atanh)
+GOWD(atanl, DFD, atan)
 GOW(cabs, XFX)
 GOW(cabsf, xFx)
-GODW(cabsl, DFY, cabs)
+GOWD(cabsl, DFY, cabs)
 GOW(cacos, XFX)
 GOW(cacosf, xFx)
 GOW(cacosh, XFX)
@@ -59,19 +59,19 @@ GOW(catanhf, xFx)
 // catanl   // Weak
 GOW(cbrt, dFd)
 GOW(cbrtf, fFf)
-GODW(cbrtl, DFD, cbrt)
+GOWD(cbrtl, DFD, cbrt)
 GOW(ccos, XFX)
 GOW(ccosf, xFx)
 GOW(ccosh, XFX)
 GOW(ccoshf, xFx)
-GODW(ccoshl, YFY, ccosh)
-GODW(ccosl, YFY, ccos)
+GOWD(ccoshl, YFY, ccosh)
+GOWD(ccosl, YFY, ccos)
 GOW(ceil, dFd)
 GOW(ceilf, fFf)
-GODW(ceill, DFD, ceil)
+GOWD(ceill, DFD, ceil)
 GOW(cexp, XFX)
 GOW(cexpf, xFx)
-GODW(cexpl, YFY, cexp)
+GOWD(cexpl, YFY, cexp)
 // cimag    // Weak
 // cimagf   // Weak
 // cimagl   // Weak
@@ -83,7 +83,7 @@ GOW(clog, XFX)
 // clog10l  // Weak
 // __clog10l
 GOW(clogf, xFx)
-GODW(clogl, YFY, clog)
+GOWD(clogl, YFY, clog)
 // conj // Weak
 // conjf    // Weak
 // conjl    // Weak
@@ -96,11 +96,11 @@ GOW(cosh, dFd)
 GOW(coshf, fFf)
 GOM(__coshf_finite, fFf)
 GOM(__cosh_finite, dFd)
-GODW(coshl, DFD, cosh)
-GODW(cosl, DFD, cos)
+GOWD(coshl, DFD, cosh)
+GOWD(cosl, DFD, cos)
 GOW(cpow, XFXX)
 GOW(cpowf, xFxx)
-GODW(cpowl, YFYY, cpow)
+GOWD(cpowl, YFYY, cpow)
 GOW(cproj, XFX)
 GOW(cprojf, xFx)
 // cprojl   // Weak
@@ -111,17 +111,17 @@ GOW(csin, XFX)
 GOW(csinf, xFx)
 GOW(csinh, XFX)
 GOW(csinhf, xFx)
-GODW(csinhl, YFY, csinh)
-GODW(csinl, YFY, csin)
+GOWD(csinhl, YFY, csinh)
+GOWD(csinl, YFY, csin)
 GOW(csqrt, XFX)
 GOW(csqrtf, xFx)
-GODW(csqrtl, YFY, csqrt)
+GOWD(csqrtl, YFY, csqrt)
 GOW(ctan, XFX)
 GOW(ctanf, xFx)
 GOW(ctanh, XFX)
 GOW(ctanhf, xFx)
-GODW(ctanhl, YFY, ctanh)
-GODW(ctanl, YFY, ctan)
+GOWD(ctanhl, YFY, ctanh)
+GOWD(ctanl, YFY, ctan)
 // __cxa_finalize  // Weak
 // drem // Weak
 // dremf    // Weak
@@ -129,9 +129,9 @@ GODW(ctanl, YFY, ctan)
 GOW(erf, dFd)
 GOW(erfc, dFd)
 GOW(erfcf, fFf)
-GODW(erfcl, DFD, erfc)
+GOWD(erfcl, DFD, erfc)
 GOW(erff, fFf)
-GODW(erfl, DFD, erf)
+GOWD(erfl, DFD, erf)
 GOW(exp, dFd)
 GOW(exp10, dFd)
 GOW(exp10f, fFf)
@@ -142,14 +142,14 @@ GOW(exp2, dFd)
 GOW(exp2f, fFf)
 GOM(__exp2f_finite, fFf)
 GOM(__exp2_finite, dFd)
-GODW(exp2l, DFD, exp2)
+GOWD(exp2l, DFD, exp2)
 GOW(expf, fFf)
 GOM(__expf_finite, fFf)
 GOM(__exp_finite, dFd)
-GODW(expl, DFD, exp)
+GOWD(expl, DFD, exp)
 GOW(expm1, dFd)
 GOW(expm1f, fFf)
-GODW(expm1l, DFD, expm1)
+GOWD(expm1l, DFD, expm1)
 GOW(fabs, dFd)
 GOW(fabsf, fFf)
 // fabsl    // Weak
@@ -178,10 +178,10 @@ GO(__finitef, iFf)
 // __finitel
 GOW(floor, dFd)
 GOW(floorf, fFf)
-GODW(floorl, DFD, floor)
+GOWD(floorl, DFD, floor)
 GOW(fma, dFddd)
 GOW(fmaf, fFfff)
-GODW(fmal, DFDDD, fma)
+GOWD(fmal, DFDDD, fma)
 GOW(fmax, dFdd)
 GOW(fmaxf, fFff)
 // fmaxl    // Weak
@@ -192,12 +192,12 @@ GOW(fmod, dFdd)
 GOW(fmodf, fFff)
 GOM(__fmodf_finite, fFff)
 GOM(__fmod_finite, dFdd)
-GODW(fmodl, DFDD, fmod)
+GOWD(fmodl, DFDD, fmod)
 GO(__fpclassify, iFd)
 GO(__fpclassifyf, iFf)
 GOW(frexp, dFdp)
 GOW(frexpf, fFfp)
-GODW(frexpl, DFDp, frexp)
+GOWD(frexpl, DFDp, frexp)
 // gamma    // Weak
 // gammaf   // Weak
 // __gammaf_r_finite
@@ -208,7 +208,7 @@ GOW(hypot, dFdd)
 GOW(hypotf, fFff)
 GOM(__hypotf_finite, fFff)
 GOM(__hypot_finite, dFdd)
-GODW(hypotl, DFDD, hypot)
+GOWD(hypotl, DFDD, hypot)
 GOW(ilogb, iFd)
 GOW(ilogbf, iFf)
 // ilogbl   // Weak
@@ -233,13 +233,13 @@ GO(jnf, fFif)
 GOD(jnl, DFiD, jn)
 GOW(ldexp, dFdi)
 GOW(ldexpf, fFfi)
-GODW(ldexpl, DFD, ldexp)
+GOWD(ldexpl, DFD, ldexp)
 GOW(lgamma, dFd)
 GOW(lgammaf, fFf)
 GOW(lgammaf_r, fFfp)
 // __lgammaf_r_finite
-GODW(lgammal, DFD, lgamma)
-GODW(lgammal_r, DFDp, lgamma_r)
+GOWD(lgammal, DFD, lgamma)
+GOWD(lgammal_r, DFDp, lgamma_r)
 GOW(lgamma_r, dFdp)
 // __lgamma_r_finite
 #ifdef STATICBUILD
@@ -258,28 +258,28 @@ GOW(log10, dFd)
 GOW(log10f, fFf)
 GOM(__log10f_finite, fFf)
 GOM(__log10_finite, dFd)
-GODW(log10l, DFD, log10) //Weak
+GOWD(log10l, DFD, log10) //Weak
 GOW(log1p, dFd)
 GOW(log1pf, fFf)
-GODW(log1pl, DFD, log1p)
+GOWD(log1pl, DFD, log1p)
 GOW(log2, dFd)
 GOW(log2f, fFf)
 GOM(__log2f_finite, fFf)
 GOM(__log2_finite, dFd)
-GODW(log2l, DFD, log2)
+GOWD(log2l, DFD, log2)
 GOW(logb, dFd)
 GOW(logbf, fFf)
 // logbl    // Weak
 GOW(logf, fFf)
 GOM(__logf_finite, fFf)
 GOM(__log_finite, dFd)
-GODW(logl, DFD, log)
+GOWD(logl, DFD, log)
 GOWM(lrint, iFEd)
 GOWM(lrintf, iFEf)
 // lrintl   // Weak
 GOW(lround, iFd)
 GOW(lroundf, iFf)
-GODW(lroundl, lFD, lround)
+GOWD(lroundl, lFD, lround)
 // matherr  // Weak
 GOW(modf, dFdp)
 GOW(modff, fFfp)
@@ -292,9 +292,9 @@ GOWM(nearbyintf, fFEf)
 // nearbyintl   // Weak
 GOW(nextafter, dFdd)
 GOW(nextafterf, fFff)
-GODW(nextafterl, DFDD, nextafter)
-GODW(nexttoward, dFdD, my_nexttoward) // This loses precision
-GODW(nexttowardf, fFfD, my_nexttowardf) // This loses precision
+GOWD(nextafterl, DFDD, nextafter)
+GOWD(nexttoward, dFdD, my_nexttoward) // This loses precision
+GOWD(nexttowardf, fFfD, my_nexttowardf) // This loses precision
 // nexttowardl  // Weak
 GOW(pow, dFdd)
 GOWM(pow10, dFd)
@@ -303,7 +303,7 @@ GOWM(pow10l, DFD)
 GOW(powf, fFff)
 GOM(__powf_finite, fFff)
 GOM(__pow_finite, dFdd)
-GODW(powl, DFDD, pow)
+GOWD(powl, DFDD, pow)
 GOW(remainder, dFdd)
 GOW(remainderf, fFff)
 // __remainderf_finite
@@ -320,7 +320,7 @@ GOW(roundf, fFf)
 GO(roundeven, dFd)  //since C23
 GO(roundevenf, fFf)
 //GO(roundevenl, DFD)
-GODW(roundl, DFD, round)
+GOWD(roundl, DFD, round)
 // scalb    // Weak
 // scalbf   // Weak
 // __scalbf_finite
@@ -341,28 +341,28 @@ DATAB(signgam, 8)
 GOW(sin, dFd)
 GOW(sincos, vFdpp)
 GOW(sincosf, vFfpp)
-GODW(sincosl, vFDpp, sincos)
+GOWD(sincosl, vFDpp, sincos)
 GOW(sinf, fFf)
 GOW(sinh, dFd)
 GOW(sinhf, fFf)
 GOM(__sinhf_finite, fFf)
 GOM(__sinh_finite, dFd)
-GODW(sinhl, DFD, sinh)
-GODW(sinl, DFD, sin)
+GOWD(sinhl, DFD, sinh)
+GOWD(sinl, DFD, sin)
 GOW(sqrt, dFd)
 GOW(sqrtf, fFf)
 GOM(__sqrtf_finite, fFf)
 GOM(__sqrt_finite, dFd)
-GODW(sqrtl, DFD, sqrt)
+GOWD(sqrtl, DFD, sqrt)
 GO(tan, dFd)
 GOW(tanf, fFf)
 GOW(tanh, dFd)
 GOW(tanhf, fFf)
-GODW(tanhl, DFD, tanh)
-GODW(tanl, DFD, tan)
+GOWD(tanhl, DFD, tanh)
+GOWD(tanl, DFD, tan)
 GOW(tgamma, dFd)
 GOW(tgammaf, fFf)
-GODW(tgammal, DFD, tgamma)
+GOWD(tgammal, DFD, tgamma)
 GOW(trunc, dFd)
 GOW(truncf, fFf)
 // truncl   // Weak
diff --git a/src/wrapped/wrappedsdl2.c b/src/wrapped/wrappedsdl2.c
index 33cbfab6..d0a933d7 100644
--- a/src/wrapped/wrappedsdl2.c
+++ b/src/wrapped/wrappedsdl2.c
@@ -550,7 +550,6 @@ static int get_sdl_priv(x64emu_t* emu, const char *sym_str, void **w, void **f)
             *f = dlsym(emu->context->box64lib, "my2_"#sym); \
             return *f != NULL; \
         }
-    #define GOS(sym, _w) GOM(sym, _w)
     #define DATA
 
     if(0);
@@ -559,7 +558,6 @@ static int get_sdl_priv(x64emu_t* emu, const char *sym_str, void **w, void **f)
     #undef GO
     #undef GOM
     #undef GO2
-    #undef GOS
     #undef DATA
     return 0;
 }
diff --git a/src/wrapped/wrappedtermuxexec_private.h b/src/wrapped/wrappedtermuxexec_private.h
index a0ed8e1f..4c8e334b 100644
--- a/src/wrapped/wrappedtermuxexec_private.h
+++ b/src/wrapped/wrappedtermuxexec_private.h
@@ -1,4 +1,4 @@
-#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA) && defined(GOS))
+#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA))
 #error Meh...
 #endif