b997d65 · rowtype-yoga/purescript-native

git.iko.soy/rowtype-yoga/purescript-native

on golang help sign in

C++: remove need for 'L' suffix on int literals

b997d65Andy Arvanitis11 years ago

pcc/include/purescript.cc+1−32

compare with golang

unifiedsplit

@@ -187,14 +187,6 @@ auto any::contains(const char key[]) const -> bool {

187// Operator helper macros

188//-----------------------------------------------------------------------------

189

190−#define DEFINE_OPERATOR(op, ty, rty) \

191−auto operator op (const any& lhs, ty rhs) -> rty { \

192− return lhs.cast<typename std::remove_const<std::remove_reference<ty>::type>::type>() op rhs; \

193−} \

194−auto operator op (ty lhs, const any& rhs) -> rty { \

195− return lhs op rhs.cast<typename std::remove_const<std::remove_reference<ty>::type>::type>(); \

196−}

197−

198#define DEFINE_CSTR_EQUALS_OPERATOR() \

190#define DEFINE_CSTR_EQUALS_OPERATOR() \

199 auto operator==(const any& lhs_, const char * rhs) -> bool { \

191 auto operator==(const any& lhs_, const char * rhs) -> bool { \

200 const any& lhs = any::unthunkVariant(lhs_); \

192 const any& lhs = any::unthunkVariant(lhs_); \

@@ -242,11 +234,7 @@ auto operator op (ty lhs, const any& rhs) -> rty { \

242 default: assert(false && "Unsupported type for operator " #op); \

234 default: assert(false && "Unsupported type for operator " #op); \

243 } \

235 } \

244 return false; \

236 return false; \

245− } \

237+ }

246− DEFINE_OPERATOR(op, long, bool) \

247− DEFINE_OPERATOR(op, double, bool) \

248− DEFINE_OPERATOR(op, char, bool) \

249− DEFINE_OPERATOR(op, bool, bool) \

250

238

251//-----------------------------------------------------------------------------

239//-----------------------------------------------------------------------------

252// Operator definitions

240// Operator definitions

@@ -286,10 +274,6 @@ auto operator+(const any& lhs_, const any& rhs_) -> any {

286 return nullptr;

274 return nullptr;

287}

275}

288

276

289−DEFINE_OPERATOR(+, long, long)

290−DEFINE_OPERATOR(+, double, double)

291−DEFINE_OPERATOR(+, char, char)

292−

293auto operator+(const any& lhs_, const char * rhs) -> std::string {

277auto operator+(const any& lhs_, const char * rhs) -> std::string {

294 const any& lhs = any::unthunkVariant(lhs_);

278 const any& lhs = any::unthunkVariant(lhs_);

295 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);

279 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);

@@ -315,10 +299,6 @@ auto operator-(const any& lhs_, const any& rhs_) -> any {

315 return nullptr;

299 return nullptr;

316}

300}

317

301

318−DEFINE_OPERATOR(-, long, long)

319−DEFINE_OPERATOR(-, double, double)

320−DEFINE_OPERATOR(-, char, char)

321−

322auto operator*(const any& lhs_, const any& rhs_) -> any {

302auto operator*(const any& lhs_, const any& rhs_) -> any {

323 const any& lhs = any::unthunkVariant(lhs_);

303 const any& lhs = any::unthunkVariant(lhs_);

324 const any& rhs = any::unthunkVariant(rhs_);

304 const any& rhs = any::unthunkVariant(rhs_);

@@ -332,10 +312,6 @@ auto operator*(const any& lhs_, const any& rhs_) -> any {

332 return nullptr;

312 return nullptr;

333}

313}

334

314

335−DEFINE_OPERATOR(*, long, long)

336−DEFINE_OPERATOR(*, double, double)

337−DEFINE_OPERATOR(*, char, char)

338−

339auto operator/(const any& lhs_, const any& rhs_) -> any {

315auto operator/(const any& lhs_, const any& rhs_) -> any {

340 const any& lhs = any::unthunkVariant(lhs_);

316 const any& lhs = any::unthunkVariant(lhs_);

341 const any& rhs = any::unthunkVariant(rhs_);

317 const any& rhs = any::unthunkVariant(rhs_);

@@ -349,10 +325,6 @@ auto operator/(const any& lhs_, const any& rhs_) -> any {

349 return nullptr;

325 return nullptr;

350}

326}

351

327

352−DEFINE_OPERATOR(/, long, long)

353−DEFINE_OPERATOR(/, double, double)

354−DEFINE_OPERATOR(/, char, char)

355−

356auto operator%(const any& lhs_, const any& rhs_) -> any {

328auto operator%(const any& lhs_, const any& rhs_) -> any {

357 const any& lhs = any::unthunkVariant(lhs_);

329 const any& lhs = any::unthunkVariant(lhs_);

358 const any& rhs = any::unthunkVariant(rhs_);

330 const any& rhs = any::unthunkVariant(rhs_);

@@ -365,9 +337,6 @@ auto operator%(const any& lhs_, const any& rhs_) -> any {

365 return nullptr;

337 return nullptr;

366}

338}

367

339

368−DEFINE_OPERATOR(%, long, long)

369−DEFINE_OPERATOR(%, char, char)

370−

371// unary negate

340// unary negate

372auto operator-(const any& rhs_) -> any {

341auto operator-(const any& rhs_) -> any {

373 const any& rhs = any::unthunkVariant(rhs_);

342 const any& rhs = any::unthunkVariant(rhs_);

pcc/include/purescript.hh+44−36

@@ -34,17 +34,30 @@

34#include <stdexcept>

35#include <iso646.h> // mostly for MS Visual Studio compiler

37−#define DECLARE_OPERATOR(op, ty, rty) \

37+#define DEFINE_OPERATOR(op, ty, rty) \

38− friend auto operator op (const any&, ty) -> rty; \

38+ inline friend auto operator op (const any& lhs, ty rhs) -> rty { \

39+ return lhs.cast<ty>() op rhs; \

40+ } \

39− friend auto operator op (ty, const any&) -> rty;

41+ inline friend auto operator op (ty lhs, const any& rhs) -> rty { \

42+ return lhs op rhs.cast<ty>(); \

43+ } \

44+

45+#define DEFINE_INT_OPERATOR(op, rty) \

46+ inline friend auto operator op (const any& lhs, int rhs) -> rty { \

47+ return lhs.cast<long>() op (long)rhs; \

48+ } \

49+ inline friend auto operator op (int lhs, const any& rhs) -> rty { \

50+ return (long)lhs op rhs.cast<long>(); \

51+ }

41#define DECLARE_COMPARISON_OPERATOR(op) \

53#define DECLARE_COMPARISON_OPERATOR(op) \

42 friend auto operator op (const any&, const any&) -> bool; \

54 friend auto operator op (const any&, const any&) -> bool; \

43− DECLARE_OPERATOR(op, long, bool) \

55+ DEFINE_OPERATOR(op, long, bool) \

44− DECLARE_OPERATOR(op, double, bool) \

56+ DEFINE_OPERATOR(op, double, bool) \

45− DECLARE_OPERATOR(op, char, bool) \

57+ DEFINE_OPERATOR(op, char, bool) \

46− DECLARE_OPERATOR(op, const char *, bool)

58+ DEFINE_INT_OPERATOR(op, bool) \

47−

59+ friend auto operator op (const any&, const char * const) -> bool; \

60+ friend auto operator op (const char * const, const any&) -> bool;

49namespace PureScript {

62namespace PureScript {

@@ -326,54 +339,49 @@ class any {

326 DECLARE_COMPARISON_OPERATOR(>)

339 DECLARE_COMPARISON_OPERATOR(>)

327 DECLARE_COMPARISON_OPERATOR(>=)

340 DECLARE_COMPARISON_OPERATOR(>=)

328

341

329− // For MS Visual Studio compiler: broken typed-enum workaround

330− DECLARE_OPERATOR(==, int, bool)

331− DECLARE_OPERATOR(!=, int, bool)

332−

333 friend auto operator+(const any&, const any&) -> any;

342 friend auto operator+(const any&, const any&) -> any;

334

343

335− DECLARE_OPERATOR(+, long, long)

344+ DEFINE_OPERATOR(+, long, long)

336− DECLARE_OPERATOR(+, double, double)

345+ DEFINE_OPERATOR(+, double, double)

337− DECLARE_OPERATOR(+, char, char)

346+ DEFINE_OPERATOR(+, char, char)

347+ DEFINE_INT_OPERATOR(+, long)

338− DECLARE_OPERATOR(+, const char *, std::string)

348+ friend auto operator+(const any& lhs, const char * const rhs) -> std::string;

349+ friend auto operator+(const char * const lhs, const any& rhs) -> std::string;

339

350

340 friend auto operator-(const any&, const any&) -> any;

351 friend auto operator-(const any&, const any&) -> any;

341

352

342− DECLARE_OPERATOR(-, long, long)

353+ DEFINE_OPERATOR(-, long, long)

343− DECLARE_OPERATOR(-, double, double)

354+ DEFINE_OPERATOR(-, double, double)

344− DECLARE_OPERATOR(-, char, char)

355+ DEFINE_OPERATOR(-, char, char)

356+ DEFINE_INT_OPERATOR(-, long)

345

357

346 friend auto operator*(const any&, const any&) -> any;

358 friend auto operator*(const any&, const any&) -> any;

347

359

348− DECLARE_OPERATOR(*, long, long)

360+ DEFINE_OPERATOR(*, long, long)

349− DECLARE_OPERATOR(*, double, double)

361+ DEFINE_OPERATOR(*, double, double)

350− DECLARE_OPERATOR(*, char, char)

362+ DEFINE_OPERATOR(*, char, char)

363+ DEFINE_INT_OPERATOR(*, long)

351

364

352 friend auto operator/(const any&, const any&) -> any;

365 friend auto operator/(const any&, const any&) -> any;

353

366

354− DECLARE_OPERATOR(/, long, long)

367+ DEFINE_OPERATOR(/, long, long)

355− DECLARE_OPERATOR(/, double, double)

368+ DEFINE_OPERATOR(/, double, double)

356− DECLARE_OPERATOR(/, char, char)

369+ DEFINE_OPERATOR(/, char, char)

370+ DEFINE_INT_OPERATOR(/, long)

357

371

358 friend auto operator%(const any&, const any&) -> any;

372 friend auto operator%(const any&, const any&) -> any;

359

373

360− DECLARE_OPERATOR(%, long, long)

374+ DEFINE_OPERATOR(%, long, long)

361− DECLARE_OPERATOR(%, char, char)

375+ DEFINE_OPERATOR(%, char, char)

376+ DEFINE_INT_OPERATOR(%, long)

362

377

363 friend auto operator-(const any&) -> any; // unary negate

378 friend auto operator-(const any&) -> any; // unary negate

364};

379};

365

380

366−// For MS Visual Studio compiler: broken typed-enum workaround

367−inline auto operator==(const any& lhs, int rhs) -> bool {

368− return lhs == (long)rhs;

369−}

370−inline auto operator!=(const any& lhs, int rhs) -> bool {

371− return lhs != (long)rhs;

372−}

373−

374} // namespace PureScript

381} // namespace PureScript

375

382

376−#undef DECLARE_OPERATOR

383+#undef DEFINE_OPERATOR

384+#undef DEFINE_INT_OPERATOR

377#undef DECLARE_COMPARISON_OPERATOR

385#undef DECLARE_COMPARISON_OPERATOR

378

386

379#endif // PureScript_HH

387#endif // PureScript_HH

src/Language/PureScript/Pretty/Cpp.hs+1−1

@@ -81,7 +81,7 @@ literals = mkPattern' match

81 match :: Cpp -> StateT PrinterState Maybe String

82 match CppNoOp = return []

83 match CppEndOfHeader = return []

84− match (CppNumericLiteral (Left n)) = return $ show n ++ "L"

84+ match (CppNumericLiteral (Left n)) = return $ show n

85 match (CppNumericLiteral n) = return $ either show show n

86 match (CppStringLiteral s) | all isAscii s = return $ string s

87 match (CppStringLiteral s) = return $ "u8" ++ string s