64-bit support for Mac OS X in base

base/basictypes.h

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_BASICTYPES_H_
 #define BASE_BASICTYPES_H_
 #pragma once
 
 #include <limits.h>         // So we can set the bounds of our types
 #include <stddef.h>         // For size_t
 #include <string.h>         // for memcpy
 
 #include "base/port.h"    // Types that only need exist on certain systems
 
 #ifndef COMPILER_MSVC
 // stdint.h is part of C99 but MSVC doesn't have it.
 #include <stdint.h>         // For intptr_t.
 #endif
 
 typedef signed char         schar;
 typedef signed char         int8;
 typedef short               int16;
 // TODO: Remove these type guards.  These are to avoid conflicts with
 // obsolete/protypes.h in the Gecko SDK.
 #ifndef _INT32
 #define _INT32
 typedef int                 int32;
 #endif
 
-// The NSPR system headers define 64-bit as |long| when possible.  In order to
-// not have typedef mismatches, we do the same on LP64.
-#if __LP64__
+// The NSPR system headers define 64-bit as |long| when possible, except on
+// Mac OS X.  In order to not have typedef mismatches, we do the same on LP64.
+//
+// On Mac OS X, |long long| is used for 64-bit types for compatibility with
+// <inttypes.h> format macros even in the LP64 model.
+#if __LP64__ && !defined(OS_MACOSX)

[wtc, 2011/03/22 23:46:33]

Nit: it's better to test
    defined(__LP64__)
instead of
    __LP64__
here and at line 57 below.

Your changes match the following ifdef in NSPR's prtypes.h:
#if PR_BYTES_PER_LONG == 8 && !defined(__APPLE__)
typedef long PRInt64;
typedef unsigned long PRUint64;

http://bonsai.mozilla.org/cvsblame.cgi?file=mozilla/nsprpub/pr/include/prtype...

The best way to fix this mess is to compile Chromium code
that includes any NSPR/NSS public headers with -DNO_NSPR_10_SUPPORT.

Do you want to give that a try?

 typedef long                int64;
 #else
 typedef long long           int64;
 #endif
 
 // NOTE: unsigned types are DANGEROUS in loops and other arithmetical
 // places.  Use the signed types unless your variable represents a bit
 // pattern (eg a hash value) or you really need the extra bit.  Do NOT
 // use 'unsigned' to express "this value should always be positive";
 // use assertions for this.
 
 typedef unsigned char      uint8;
 typedef unsigned short     uint16;
 // TODO: Remove these type guards.  These are to avoid conflicts with
 // obsolete/protypes.h in the Gecko SDK.
 #ifndef _UINT32
 #define _UINT32
 typedef unsigned int       uint32;
 #endif
 
 // See the comment above about NSPR and 64-bit.
-#if __LP64__
+#if __LP64__ && !defined(OS_MACOSX)
 typedef unsigned long uint64;
 #else
 typedef unsigned long long uint64;
 #endif
 
 // A type to represent a Unicode code-point value. As of Unicode 4.0,
 // such values require up to 21 bits.
 // (For type-checking on pointers, make this explicitly signed,
 // and it should always be the signed version of whatever int32 is.)
 typedef signed int         char32;
@@ skipping 290 matching lines @@
 // does nothing to the storage, AND there are no virtual methods, then a
 // constructor declared as
 //       explicit MyClass(base::LinkerInitialized x) {}
 // and invoked as
 //       static MyClass my_variable_name(base::LINKER_INITIALIZED);
 namespace base {
 enum LinkerInitialized { LINKER_INITIALIZED };
 }  // base
 
 #endif  // BASE_BASICTYPES_H_