Changeset 14256 in webkit for trunk/JavaScriptCore


Ignore:
Timestamp:
May 9, 2006, 2:27:55 AM (19 years ago)
Author:
mjs
Message:

JavaScriptCore:

Rubber stamped by Anders.


  • renamed kxmlcore to wtf


kxmlcore --> wtf
KXMLCore --> WTF
WKC --> WTF

  • JavaScriptCore.xcodeproj/project.pbxproj:
  • bindings/c/c_instance.cpp:
  • bindings/objc/WebScriptObject.mm:
  • kjs/JSImmediate.h:
  • kjs/Parser.cpp:
  • kjs/Parser.h:
  • kjs/array_object.cpp:
  • kjs/collector.cpp: (KJS::Collector::registerThread):
  • kjs/collector.h:
  • kjs/config.h:
  • kjs/function.cpp: (KJS::isStrWhiteSpace):
  • kjs/function.h:
  • kjs/identifier.cpp:
  • kjs/internal.cpp:
  • kjs/internal.h:
  • kjs/lexer.cpp: (Lexer::shift): (Lexer::isWhiteSpace): (Lexer::isIdentStart): (Lexer::isIdentPart):
  • kjs/lookup.cpp:
  • kjs/nodes.cpp:
  • kjs/nodes.h:
  • kjs/number_object.cpp:
  • kjs/object.h:
  • kjs/property_map.cpp:
  • kjs/property_map.h:
  • kjs/string_object.cpp: (StringProtoFunc::callAsFunction):
  • kjs/testkjs.cpp: (testIsInteger):
  • kjs/ustring.cpp:
  • kjs/ustring.h:
  • kxmlcore: Removed.
  • kxmlcore/AlwaysInline.h: Removed.
  • kxmlcore/Assertions.cpp: Removed.
  • kxmlcore/Assertions.h: Removed.
  • kxmlcore/FastMalloc.cpp: Removed.
  • kxmlcore/FastMalloc.h: Removed.
  • kxmlcore/FastMallocInternal.h: Removed.
  • kxmlcore/Forward.h: Removed.
  • kxmlcore/HashCountedSet.h: Removed.
  • kxmlcore/HashFunctions.h: Removed.
  • kxmlcore/HashMap.h: Removed.
  • kxmlcore/HashSet.h: Removed.
  • kxmlcore/HashTable.cpp: Removed.
  • kxmlcore/HashTable.h: Removed.
  • kxmlcore/HashTraits.h: Removed.
  • kxmlcore/ListRefPtr.h: Removed.
  • kxmlcore/Noncopyable.h: Removed.
  • kxmlcore/OwnArrayPtr.h: Removed.
  • kxmlcore/OwnPtr.h: Removed.
  • kxmlcore/PassRefPtr.h: Removed.
  • kxmlcore/Platform.h: Removed.
  • kxmlcore/RefPtr.h: Removed.
  • kxmlcore/TCPageMap.h: Removed.
  • kxmlcore/TCSpinLock.h: Removed.
  • kxmlcore/TCSystemAlloc.cpp: Removed.
  • kxmlcore/TCSystemAlloc.h: Removed.
  • kxmlcore/UnusedParam.h: Removed.
  • kxmlcore/Vector.h: Removed.
  • kxmlcore/VectorTraits.h: Removed.
  • kxmlcore/unicode: Removed.
  • kxmlcore/unicode/Unicode.h: Removed.
  • kxmlcore/unicode/UnicodeCategory.h: Removed.
  • kxmlcore/unicode/icu: Removed.
  • kxmlcore/unicode/icu/UnicodeIcu.h: Removed.
  • kxmlcore/unicode/posix: Removed.
  • kxmlcore/unicode/qt3: Removed.
  • kxmlcore/unicode/qt4: Removed.
  • kxmlcore/unicode/qt4/UnicodeQt4.h: Removed.
  • pcre/pcre_get.c:
  • wtf: Added.
  • wtf/Assertions.cpp:
  • wtf/Assertions.h:
  • wtf/FastMalloc.cpp: (WTF::TCMalloc_ThreadCache::Scavenge): (WTF::do_malloc): (WTF::do_free): (WTF::TCMallocGuard::TCMallocGuard): (WTF::malloc): (WTF::free): (WTF::calloc): (WTF::cfree): (WTF::realloc):
  • wtf/FastMalloc.h:
  • wtf/FastMallocInternal.h:
  • wtf/Forward.h:
  • wtf/HashCountedSet.h:
  • wtf/HashFunctions.h:
  • wtf/HashMap.h:
  • wtf/HashSet.h:
  • wtf/HashTable.cpp:
  • wtf/HashTable.h:
  • wtf/HashTraits.h:
  • wtf/ListRefPtr.h:
  • wtf/Noncopyable.h:
  • wtf/OwnArrayPtr.h:
  • wtf/OwnPtr.h:
  • wtf/PassRefPtr.h:
  • wtf/RefPtr.h:
  • wtf/TCSystemAlloc.cpp: (TCMalloc_SystemAlloc):
  • wtf/Vector.h:
  • wtf/VectorTraits.h:
  • wtf/unicode/UnicodeCategory.h:
  • wtf/unicode/icu/UnicodeIcu.h:

JavaScriptGlue:

Rubber stamped by Anders.


  • renamed kxmlcore to wtf


kxmlcore --> wtf
KXMLCore --> WTF
WKC --> WTF

  • config.h:
  • kxmlcore: Removed.
  • kxmlcore/AlwaysInline.h: Removed.
  • kxmlcore/Assertions.h: Removed.
  • kxmlcore/FastMalloc.h: Removed.
  • kxmlcore/Forward.h: Removed.
  • kxmlcore/HashCountedSet.h: Removed.
  • kxmlcore/HashSet.h: Removed.
  • kxmlcore/Noncopyable.h: Removed.
  • kxmlcore/OwnArrayPtr.h: Removed.
  • kxmlcore/OwnPtr.h: Removed.
  • kxmlcore/PassRefPtr.h: Removed.
  • kxmlcore/Platform.h: Removed.
  • kxmlcore/RefPtr.h: Removed.
  • kxmlcore/Vector.h: Removed.
  • wtf: Added.

WebCore:

Rubber stamped by Anders.


  • renamed kxmlcore to wtf


kxmlcore --> wtf
KXMLCore --> WTF
WKC --> WTF

  • ForwardingHeaders/kxmlcore: Removed.
  • ForwardingHeaders/kxmlcore/AlwaysInline.h: Removed.
  • ForwardingHeaders/kxmlcore/Assertions.h: Removed.
  • ForwardingHeaders/kxmlcore/FastMalloc.h: Removed.
  • ForwardingHeaders/kxmlcore/Forward.h: Removed.
  • ForwardingHeaders/kxmlcore/HashCountedSet.h: Removed.
  • ForwardingHeaders/kxmlcore/HashMap.h: Removed.
  • ForwardingHeaders/kxmlcore/HashSet.h: Removed.
  • ForwardingHeaders/kxmlcore/HashTraits.h: Removed.
  • ForwardingHeaders/kxmlcore/Noncopyable.h: Removed.
  • ForwardingHeaders/kxmlcore/OwnArrayPtr.h: Removed.
  • ForwardingHeaders/kxmlcore/OwnPtr.h: Removed.
  • ForwardingHeaders/kxmlcore/PassRefPtr.h: Removed.
  • ForwardingHeaders/kxmlcore/Platform.h: Removed.
  • ForwardingHeaders/kxmlcore/RefPtr.h: Removed.
  • ForwardingHeaders/kxmlcore/Vector.h: Removed.
  • ForwardingHeaders/wtf: Added.
  • bindings/js/JSHTMLElementWrapperFactory.h:
  • bindings/js/kjs_binding.cpp:
  • bindings/js/kjs_window.h:
  • bindings/objc/DOMImplementationFront.h:
  • bridge/JavaAppletWidget.h:
  • bridge/mac/WebCoreFrameNamespaces.mm:
  • bridge/mac/WebCorePageBridge.mm: (initializeLogChannel):
  • bridge/mac/WebCoreStringTruncator.mm:
  • bridge/mac/WebCoreViewFactory.m:
  • config.h:
  • css/css_base.h:
  • css/css_valueimpl.h:
  • css/csshelper.cpp:
  • css/cssparser.h:
  • dom/DOMImplementation.h:
  • dom/Document.h:
  • dom/NamedNodeMap.h:
  • dom/Node.h:
  • dom/NodeList.h:
  • dom/QualifiedName.cpp:
  • dom/Range.h:
  • dom/StyledElement.cpp:
  • dom/dom2_traversalimpl.h:
  • dom/xml_tokenizer.h:
  • editing/RebalanceWhitespaceCommand.cpp:
  • editing/RemoveCSSPropertyCommand.cpp:
  • editing/RemoveNodeAttributeCommand.cpp:
  • editing/RemoveNodeCommand.cpp:
  • editing/RemoveNodePreservingChildrenCommand.cpp:
  • editing/ReplaceSelectionCommand.h:
  • editing/Selection.cpp:
  • editing/SetNodeAttributeCommand.cpp:
  • editing/SplitElementCommand.cpp:
  • editing/SplitTextNodeCommand.cpp:
  • editing/SplitTextNodeContainingElementCommand.cpp:
  • editing/TextIterator.h:
  • editing/htmlediting.h:
  • editing/markup.h:
  • html/CanvasGradient.h:
  • html/CanvasRenderingContext2D.h:
  • html/CanvasStyle.cpp:
  • html/HTMLCollection.h:
  • html/HTMLElementFactory.h:
  • kcanvas/KCanvasFilters.cpp:
  • kcanvas/KCanvasPath.h:
  • kcanvas/RenderPath.cpp:
  • kcanvas/RenderSVGImage.cpp:
  • kcanvas/RenderSVGText.cpp:
  • kcanvas/device/quartz/KCanvasItemQuartz.mm:
  • kcanvas/device/quartz/KRenderingPaintServerGradientQuartz.mm:
  • kcanvas/device/quartz/QuartzSupport.mm:
  • ksvg2/misc/KSVGTimeScheduler.h:
  • ksvg2/misc/SVGDocumentExtensions.h:
  • ksvg2/scripts/make_names.pl:
  • ksvg2/svg/SVGDOMImplementation.cpp:
  • ksvg2/svg/SVGExternalResourcesRequired.h:
  • ksvg2/svg/SVGFilterPrimitiveStandardAttributes.cpp:
  • ksvg2/svg/SVGForeignObjectElement.cpp:
  • ksvg2/svg/SVGImageElement.cpp:
  • ksvg2/svg/SVGMaskElement.cpp:
  • ksvg2/svg/SVGStyledElement.cpp:
  • ksvg2/svg/SVGTests.h:
  • ksvg2/svg/SVGTransform.h:
  • ksvg2/svg/SVGTransformable.cpp:
  • kwq/AccessibilityObjectCache.h:
  • kwq/KWQCString.cpp:
  • kwq/KWQFormData.mm:
  • kwq/KWQListBox.mm:
  • kwq/KWQResourceLoader.mm:
  • kwq/KWQTextEdit.mm:
  • loader/Cache.h:
  • loader/CachedObject.h:
  • loader/CachedObjectClientWalker.h:
  • loader/Decoder.h:
  • loader/DocLoader.h:
  • loader/loader.cpp:
  • loader/loader.h:
  • page/DOMWindow.h:
  • page/Frame.h:
  • page/FramePrivate.h:
  • page/FrameTree.cpp:
  • page/Page.cpp:
  • page/Page.h:
  • page/Plugin.h:
  • platform/Arena.cpp:
  • platform/ArrayImpl.h:
  • platform/AtomicString.cpp:
  • platform/CharsetNames.cpp:
  • platform/Color.cpp:
  • platform/DeprecatedPtrListImpl.cpp:
  • platform/DeprecatedValueListImpl.h:
  • platform/FontFallbackList.h:
  • platform/GraphicsContext.h:
  • platform/GraphicsTypes.cpp:
  • platform/Image.h:
  • platform/KURL.cpp:
  • platform/Logging.cpp:
  • platform/Logging.h:
  • platform/PlatformString.h:
  • platform/PlugInInfoStore.h:
  • platform/StreamingTextDecoder.cpp:
  • platform/StreamingTextDecoder.h:
  • platform/String.cpp:
  • platform/StringHash.h:
  • platform/StringImpl.cpp:
  • platform/StringImpl.h:
  • platform/TextEncoding.cpp:
  • platform/Timer.cpp:
  • platform/Timer.h:
  • platform/TransferJob.h:
  • platform/TransferJobInternal.h:
  • platform/mac/BlockExceptions.mm:
  • platform/mac/ColorMac.mm:
  • platform/mac/FontData.mm:
  • platform/mac/KURLMac.mm:
  • platform/mac/QStringMac.mm:
  • platform/mac/SharedTimerMac.cpp:
  • platform/mac/TextEncodingMac.cpp:
  • platform/mac/WebCoreImageRendererFactory.m:
  • platform/mac/WebCoreKeyGenerator.m:
  • platform/mac/WebCoreTextArea.mm:
  • platform/mac/WebCoreTextField.mm:
  • platform/mac/WebTextRendererFactory.h:
  • platform/mac/WebTextRendererFactory.mm:
  • platform/win/TemporaryLinkStubs.cpp: (JavaAppletWidget::JavaAppletWidget):
  • rendering/InlineTextBox.cpp:
  • rendering/RenderText.cpp:
  • rendering/RenderTreeAsText.cpp:
  • rendering/bidi.cpp:
  • xml/XSLTProcessor.h:
  • xpath/impl/XPathExpressionNode.h:
  • xpath/impl/XPathParser.h:
  • xpath/impl/XPathPath.h:
  • xpath/impl/XPathUtil.h:

WebKit:

Rubber stamped by Anders.


  • renamed kxmlcore to wtf


kxmlcore --> wtf
KXMLCore --> WTF
WKC --> WTF

  • Misc/WebKitLogging.h:
  • Misc/WebKitLogging.m: (initializeLogChannel):
Location:
trunk/JavaScriptCore
Files:
53 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r14246 r14256  
     12006-05-09  Maciej Stachowiak  <[email protected]>
     2
     3        Rubber stamped by Anders.
     4       
     5        - renamed kxmlcore to wtf
     6       
     7        kxmlcore --> wtf
     8        KXMLCore --> WTF
     9        WKC --> WTF
     10
     11        * JavaScriptCore.xcodeproj/project.pbxproj:
     12        * bindings/c/c_instance.cpp:
     13        * bindings/objc/WebScriptObject.mm:
     14        * kjs/JSImmediate.h:
     15        * kjs/Parser.cpp:
     16        * kjs/Parser.h:
     17        * kjs/array_object.cpp:
     18        * kjs/collector.cpp:
     19        (KJS::Collector::registerThread):
     20        * kjs/collector.h:
     21        * kjs/config.h:
     22        * kjs/function.cpp:
     23        (KJS::isStrWhiteSpace):
     24        * kjs/function.h:
     25        * kjs/identifier.cpp:
     26        * kjs/internal.cpp:
     27        * kjs/internal.h:
     28        * kjs/lexer.cpp:
     29        (Lexer::shift):
     30        (Lexer::isWhiteSpace):
     31        (Lexer::isIdentStart):
     32        (Lexer::isIdentPart):
     33        * kjs/lookup.cpp:
     34        * kjs/nodes.cpp:
     35        * kjs/nodes.h:
     36        * kjs/number_object.cpp:
     37        * kjs/object.h:
     38        * kjs/property_map.cpp:
     39        * kjs/property_map.h:
     40        * kjs/string_object.cpp:
     41        (StringProtoFunc::callAsFunction):
     42        * kjs/testkjs.cpp:
     43        (testIsInteger):
     44        * kjs/ustring.cpp:
     45        * kjs/ustring.h:
     46        * kxmlcore: Removed.
     47        * kxmlcore/AlwaysInline.h: Removed.
     48        * kxmlcore/Assertions.cpp: Removed.
     49        * kxmlcore/Assertions.h: Removed.
     50        * kxmlcore/FastMalloc.cpp: Removed.
     51        * kxmlcore/FastMalloc.h: Removed.
     52        * kxmlcore/FastMallocInternal.h: Removed.
     53        * kxmlcore/Forward.h: Removed.
     54        * kxmlcore/HashCountedSet.h: Removed.
     55        * kxmlcore/HashFunctions.h: Removed.
     56        * kxmlcore/HashMap.h: Removed.
     57        * kxmlcore/HashSet.h: Removed.
     58        * kxmlcore/HashTable.cpp: Removed.
     59        * kxmlcore/HashTable.h: Removed.
     60        * kxmlcore/HashTraits.h: Removed.
     61        * kxmlcore/ListRefPtr.h: Removed.
     62        * kxmlcore/Noncopyable.h: Removed.
     63        * kxmlcore/OwnArrayPtr.h: Removed.
     64        * kxmlcore/OwnPtr.h: Removed.
     65        * kxmlcore/PassRefPtr.h: Removed.
     66        * kxmlcore/Platform.h: Removed.
     67        * kxmlcore/RefPtr.h: Removed.
     68        * kxmlcore/TCPageMap.h: Removed.
     69        * kxmlcore/TCSpinLock.h: Removed.
     70        * kxmlcore/TCSystemAlloc.cpp: Removed.
     71        * kxmlcore/TCSystemAlloc.h: Removed.
     72        * kxmlcore/UnusedParam.h: Removed.
     73        * kxmlcore/Vector.h: Removed.
     74        * kxmlcore/VectorTraits.h: Removed.
     75        * kxmlcore/unicode: Removed.
     76        * kxmlcore/unicode/Unicode.h: Removed.
     77        * kxmlcore/unicode/UnicodeCategory.h: Removed.
     78        * kxmlcore/unicode/icu: Removed.
     79        * kxmlcore/unicode/icu/UnicodeIcu.h: Removed.
     80        * kxmlcore/unicode/posix: Removed.
     81        * kxmlcore/unicode/qt3: Removed.
     82        * kxmlcore/unicode/qt4: Removed.
     83        * kxmlcore/unicode/qt4/UnicodeQt4.h: Removed.
     84        * pcre/pcre_get.c:
     85        * wtf: Added.
     86        * wtf/Assertions.cpp:
     87        * wtf/Assertions.h:
     88        * wtf/FastMalloc.cpp:
     89        (WTF::TCMalloc_ThreadCache::Scavenge):
     90        (WTF::do_malloc):
     91        (WTF::do_free):
     92        (WTF::TCMallocGuard::TCMallocGuard):
     93        (WTF::malloc):
     94        (WTF::free):
     95        (WTF::calloc):
     96        (WTF::cfree):
     97        (WTF::realloc):
     98        * wtf/FastMalloc.h:
     99        * wtf/FastMallocInternal.h:
     100        * wtf/Forward.h:
     101        * wtf/HashCountedSet.h:
     102        * wtf/HashFunctions.h:
     103        * wtf/HashMap.h:
     104        * wtf/HashSet.h:
     105        * wtf/HashTable.cpp:
     106        * wtf/HashTable.h:
     107        * wtf/HashTraits.h:
     108        * wtf/ListRefPtr.h:
     109        * wtf/Noncopyable.h:
     110        * wtf/OwnArrayPtr.h:
     111        * wtf/OwnPtr.h:
     112        * wtf/PassRefPtr.h:
     113        * wtf/RefPtr.h:
     114        * wtf/TCSystemAlloc.cpp:
     115        (TCMalloc_SystemAlloc):
     116        * wtf/Vector.h:
     117        * wtf/VectorTraits.h:
     118        * wtf/unicode/UnicodeCategory.h:
     119        * wtf/unicode/icu/UnicodeIcu.h:
     120
    11212006-05-08  Timothy Hatcher  <[email protected]>
    2122

  • trunk/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r13830 r14256  
    550550                                937B63CC09E766D200A671DD /* DerivedSources.make */,
    551551                                65417200039E01BA0058BFEB /* kjs */,
    552                                 65162EF108E6A21C007556CD /* kxmlcore */,
     552                                65162EF108E6A21C007556CD /* wtf */,
    553553                                51856D950562EE9C008B9D83 /* bindings */,
    554554                                65417203039E01F90058BFEB /* pcre */,
    … …  
    649649                        sourceTree = BUILT_PRODUCTS_DIR;
    650650                };
    651                 65162EF108E6A21C007556CD /* kxmlcore */ = {
     651                65162EF108E6A21C007556CD /* wtf */ = {
    652652                        isa = PBXGroup;
    653653                        children = (
    … …  
    682682                                6592C317098B7DE10003D4F6 /* VectorTraits.h */,
    683683                        );
    684                         path = kxmlcore;
     684                        path = wtf;
    685685                        sourceTree = "<group>";
    686686                };

  • trunk/JavaScriptCore/bindings/c/c_instance.cpp

    r13589 r14256  
    3232#include "list.h"
    3333#include "npruntime_impl.h"
    34 #include <kxmlcore/Vector.h>
     34#include <wtf/Vector.h>
    3535
    3636namespace KJS {

  • trunk/JavaScriptCore/bindings/objc/WebScriptObject.mm

    r13877 r14256  
    2929#import "objc_instance.h"
    3030#import "runtime_object.h"
    31 #import <kxmlcore/UnusedParam.h>
     31#import <wtf/UnusedParam.h>
    3232
    3333using namespace KJS;

  • trunk/JavaScriptCore/kjs/JSImmediate.h

    r12784 r14256  
    2424
    2525#include "JSType.h"
    26 #include <kxmlcore/Assertions.h>
     26#include <wtf/Assertions.h>
    2727#include <stdint.h>
    2828#include <stdlib.h>

  • trunk/JavaScriptCore/kjs/Parser.cpp

    r13304 r14256  
    2828#include "lexer.h"
    2929#include "nodes.h"
    30 #include <kxmlcore/HashSet.h>
    31 #include <kxmlcore/Vector.h>
     30#include <wtf/HashSet.h>
     31#include <wtf/Vector.h>
    3232
    3333extern int kjsyyparse();

  • trunk/JavaScriptCore/kjs/Parser.h

    r13821 r14256  
    2626#define Parser_h
    2727
    28 #include <kxmlcore/Forward.h>
     28#include <wtf/Forward.h>
    2929
    3030namespace KJS {

  • trunk/JavaScriptCore/kjs/array_object.cpp

    r13821 r14256  
    2929#include "operations.h"
    3030#include "reference_list.h"
    31 #include <kxmlcore/HashSet.h>
     31#include <wtf/HashSet.h>
    3232#include <stdio.h>
    3333

  • trunk/JavaScriptCore/kjs/collector.cpp

    r14141 r14256  
    2323#include "collector.h"
    2424
    25 #include <kxmlcore/FastMalloc.h>
    26 #include <kxmlcore/FastMallocInternal.h>
    27 #include <kxmlcore/HashCountedSet.h>
     25#include <wtf/FastMalloc.h>
     26#include <wtf/FastMallocInternal.h>
     27#include <wtf/HashCountedSet.h>
    2828#include "internal.h"
    2929#include "list.h"
    … …  
    236236  if (!pthread_getspecific(registeredThreadKey)) {
    237237    pthread_t pthread = pthread_self();
    238     KXMLCore::fastMallocRegisterThread(pthread);
     238    WTF::fastMallocRegisterThread(pthread);
    239239    Collector::Thread *thread = new Collector::Thread(pthread, pthread_mach_thread_np(pthread));
    240240    thread->next = registeredThreads;

  • trunk/JavaScriptCore/kjs/collector.h

    r13830 r14256  
    2626
    2727#include "value.h"
    28 #include <kxmlcore/HashCountedSet.h>
     28#include <wtf/HashCountedSet.h>
    2929
    3030#define KJS_MEM_LIMIT 500000

  • trunk/JavaScriptCore/kjs/config.h

    r13670 r14256  
    1 #include <kxmlcore/Platform.h>
     1#include <wtf/Platform.h>
    22
    33#if PLATFORM(DARWIN)
    … …  
    4444#define HAVE_STRING_H 1
    4545
    46 #define KXC_CHANGES 1
     46#define WTF_CHANGES 1
    4747
    4848#ifdef __cplusplus
    4949#undef new
    5050#undef delete
    51 #include <kxmlcore/FastMalloc.h>
     51#include <wtf/FastMalloc.h>
    5252#endif

  • trunk/JavaScriptCore/kjs/function.cpp

    r13663 r14256  
    4141#include <ctype.h>
    4242
    43 #include <kxmlcore/unicode/Unicode.h>
     43#include <wtf/unicode/Unicode.h>
    4444
    4545namespace KJS {
    … …  
    662662            return true;
    663663        default:
    664             return KXMLCore::Unicode::isSeparatorSpace(c);
     664            return WTF::Unicode::isSeparatorSpace(c);
    665665    }
    666666}

  • trunk/JavaScriptCore/kjs/function.h

    r13304 r14256  
    2626
    2727#include "internal.h"
    28 #include <kxmlcore/OwnPtr.h>
     28#include <wtf/OwnPtr.h>
    2929
    3030namespace KJS {

  • trunk/JavaScriptCore/kjs/identifier.cpp

    r13093 r14256  
    3939#include "identifier.h"
    4040
    41 #include <kxmlcore/FastMalloc.h>
    42 #include <kxmlcore/HashSet.h>
     41#include <wtf/FastMalloc.h>
     42#include <wtf/HashSet.h>
    4343#include <string.h> // for strlen
    4444#include <new> // for placement new
    4545
    46 namespace KXMLCore {
     46namespace WTF {
    4747
    4848    template<typename T> class DefaultHash;

  • trunk/JavaScriptCore/kjs/internal.cpp

    r13865 r14256  
    4343#include "string_object.h"
    4444#include <assert.h>
    45 #include <kxmlcore/HashMap.h>
    46 #include <kxmlcore/HashSet.h>
    47 #include <kxmlcore/Vector.h>
     45#include <wtf/HashMap.h>
     46#include <wtf/HashSet.h>
     47#include <wtf/Vector.h>
    4848#include <math.h>
    4949#include <stdio.h>

  • trunk/JavaScriptCore/kjs/internal.h

    r13821 r14256  
    3434#include "ustring.h"
    3535
    36 #include <kxmlcore/Noncopyable.h>
     36#include <wtf/Noncopyable.h>
    3737
    3838#define I18N_NOOP(s) s

  • trunk/JavaScriptCore/kjs/lexer.cpp

    r13821 r14256  
    3030#include "nodes.h"
    3131#include "lookup.h"
    32 #include <kxmlcore/unicode/Unicode.h>
     32#include <wtf/unicode/Unicode.h>
    3333
    3434static bool isDecimalDigit(unsigned short c);
    … …  
    130130      }
    131131      next3 = code[pos++].uc;
    132     } while (KXMLCore::Unicode::isFormatChar(next3));
     132    } while (WTF::Unicode::isFormatChar(next3));
    133133  }
    134134}
    … …  
    565565bool Lexer::isWhiteSpace() const
    566566{
    567   return current == '\t' || current == 0x0b || current == 0x0c || KXMLCore::Unicode::isSeparatorSpace(current);
     567  return current == '\t' || current == 0x0b || current == 0x0c || WTF::Unicode::isSeparatorSpace(current);
    568568}
    569569
    … …  
    581581bool Lexer::isIdentStart(unsigned short c)
    582582{
    583   return (KXMLCore::Unicode::category(c) & (KXMLCore::Unicode::Letter_Uppercase
    584         | KXMLCore::Unicode::Letter_Lowercase
    585         | KXMLCore::Unicode::Letter_Titlecase
    586         | KXMLCore::Unicode::Letter_Modifier
    587         | KXMLCore::Unicode::Letter_Other))
     583  return (WTF::Unicode::category(c) & (WTF::Unicode::Letter_Uppercase
     584        | WTF::Unicode::Letter_Lowercase
     585        | WTF::Unicode::Letter_Titlecase
     586        | WTF::Unicode::Letter_Modifier
     587        | WTF::Unicode::Letter_Other))
    588588    || c == '$' || c == '_';
    589589}
    … …  
    591591bool Lexer::isIdentPart(unsigned short c)
    592592{
    593   return (KXMLCore::Unicode::category(c) & (KXMLCore::Unicode::Letter_Uppercase
    594         | KXMLCore::Unicode::Letter_Lowercase
    595         | KXMLCore::Unicode::Letter_Titlecase
    596         | KXMLCore::Unicode::Letter_Modifier
    597         | KXMLCore::Unicode::Letter_Other
    598         | KXMLCore::Unicode::Mark_NonSpacing
    599         | KXMLCore::Unicode::Mark_SpacingCombining
    600         | KXMLCore::Unicode::Number_DecimalDigit
    601         | KXMLCore::Unicode::Punctuation_Connector))
     593  return (WTF::Unicode::category(c) & (WTF::Unicode::Letter_Uppercase
     594        | WTF::Unicode::Letter_Lowercase
     595        | WTF::Unicode::Letter_Titlecase
     596        | WTF::Unicode::Letter_Modifier
     597        | WTF::Unicode::Letter_Other
     598        | WTF::Unicode::Mark_NonSpacing
     599        | WTF::Unicode::Mark_SpacingCombining
     600        | WTF::Unicode::Number_DecimalDigit
     601        | WTF::Unicode::Punctuation_Connector))
    602602    || c == '$' || c == '_';
    603603}

  • trunk/JavaScriptCore/kjs/lookup.cpp

    r14094 r14256  
    2626
    2727#include "lookup.h"
    28 #include <kxmlcore/Assertions.h>
     28#include <wtf/Assertions.h>
    2929
    3030using namespace KJS;

  • trunk/JavaScriptCore/kjs/nodes.cpp

    r13821 r14256  
    3737#include "operations.h"
    3838#include "reference_list.h"
    39 #include <kxmlcore/HashSet.h>
    40 #include <kxmlcore/HashCountedSet.h>
     39#include <wtf/HashSet.h>
     40#include <wtf/HashCountedSet.h>
    4141
    4242using namespace KJS;

  • trunk/JavaScriptCore/kjs/nodes.h

    r13821 r14256  
    2828#include "Parser.h"
    2929#include "internal.h"
    30 #include <kxmlcore/ListRefPtr.h>
     30#include <wtf/ListRefPtr.h>
    3131
    3232namespace KJS {

  • trunk/JavaScriptCore/kjs/number_object.cpp

    r13821 r14256  
    2727#include "lookup.h"
    2828#include "operations.h"
    29 #include <kxmlcore/Vector.h>
     29#include <wtf/Vector.h>
    3030#include <math.h>
    3131

  • trunk/JavaScriptCore/kjs/object.h

    r13821 r14256  
    3131#include "property_slot.h"
    3232#include "scope_chain.h"
    33 #include <kxmlcore/AlwaysInline.h>
     33#include <wtf/AlwaysInline.h>
    3434
    3535namespace KJS {

  • trunk/JavaScriptCore/kjs/property_map.cpp

    r13120 r14256  
    2727#include "reference_list.h"
    2828#include <algorithm>
    29 #include <kxmlcore/FastMalloc.h>
    30 #include <kxmlcore/Vector.h>
     29#include <wtf/FastMalloc.h>
     30#include <wtf/Vector.h>
    3131
    3232using std::max;

  • trunk/JavaScriptCore/kjs/property_map.h

    r12523 r14256  
    2525
    2626#include "identifier.h"
    27 #include <kxmlcore/OwnArrayPtr.h>
     27#include <wtf/OwnArrayPtr.h>
    2828
    2929namespace KJS {

  • trunk/JavaScriptCore/kjs/string_object.cpp

    r13821 r14256  
    2929#include "reference_list.h"
    3030#include "regexp_object.h"
    31 #include <kxmlcore/unicode/Unicode.h>
     31#include <wtf/unicode/Unicode.h>
    3232
    3333#include "string_object.lut.h"
    … …  
    627627    uint16_t* destIfNeeded;
    628628
    629     int len = KXMLCore::Unicode::toLower(dataPtr, u.size(), destIfNeeded);
     629    int len = WTF::Unicode::toLower(dataPtr, u.size(), destIfNeeded);
    630630    if (len >= 0)
    631631        result = jsString(UString(reinterpret_cast<UChar *>(destIfNeeded ? destIfNeeded : dataPtr), len));
    … …  
    643643    uint16_t* destIfNeeded;
    644644
    645     int len = KXMLCore::Unicode::toUpper(dataPtr, u.size(), destIfNeeded);
     645    int len = WTF::Unicode::toUpper(dataPtr, u.size(), destIfNeeded);
    646646    if (len >= 0)
    647647        result = jsString(UString(reinterpret_cast<UChar *>(destIfNeeded ? destIfNeeded : dataPtr), len));

  • trunk/JavaScriptCore/kjs/testkjs.cpp

    r14124 r14256  
    4545
    4646using namespace KJS;
    47 using namespace KXMLCore;
     47using namespace WTF;
    4848
    4949static void testIsInteger();
    … …  
    276276static void testIsInteger()
    277277{
    278   // Unit tests for KXMLCore::IsInteger. Don't have a better place for them now.
    279   // FIXME: move these once we create a unit test directory for KXMLCore.
     278  // Unit tests for WTF::IsInteger. Don't have a better place for them now.
     279  // FIXME: move these once we create a unit test directory for WTF.
    280280
    281281  assert(IsInteger<bool>::value);

  • trunk/JavaScriptCore/kjs/ustring.cpp

    r13740 r14256  
    4141#include "dtoa.h"
    4242
    43 #include <kxmlcore/Vector.h>
     43#include <wtf/Vector.h>
    4444
    4545using std::max;

  • trunk/JavaScriptCore/kjs/ustring.h

    r13740 r14256  
    2525#define _KJS_USTRING_H_
    2626
    27 #include <kxmlcore/FastMalloc.h>
    28 #include <kxmlcore/RefPtr.h>
    29 #include <kxmlcore/PassRefPtr.h>
     27#include <wtf/FastMalloc.h>
     28#include <wtf/RefPtr.h>
     29#include <wtf/PassRefPtr.h>
    3030
    3131#include <stdint.h>

  • trunk/JavaScriptCore/pcre/pcre_get.c

    r13015 r14256  
    4545
    4646#include "pcre_internal.h"
    47 #include <kxmlcore/UnusedParam.h>
     47#include <wtf/UnusedParam.h>
    4848
    4949

  • trunk/JavaScriptCore/wtf/Assertions.cpp

    r14140 r14256  
    6363}
    6464
    65 void KXCReportAssertionFailure(const char *file, int line, const char *function, const char *assertion)
     65void WTFReportAssertionFailure(const char *file, int line, const char *function, const char *assertion)
    6666{
    6767    if (assertion)
    … …  
    7171}
    7272
    73 void KXCReportAssertionFailureWithMessage(const char *file, int line, const char *function, const char *assertion, const char *format, ...)
     73void WTFReportAssertionFailureWithMessage(const char *file, int line, const char *function, const char *assertion, const char *format, ...)
    7474{
    7575    fprintf(stderr, "=================\nASSERTION FAILED: ");
    … …  
    8181}
    8282
    83 void KXCReportArgumentAssertionFailure(const char *file, int line, const char *function, const char *argName, const char *assertion)
     83void WTFReportArgumentAssertionFailure(const char *file, int line, const char *function, const char *argName, const char *assertion)
    8484{
    8585    fprintf(stderr, "=================\nARGUMENT BAD: %s, %s (%s:%d %s)\n=================\n", argName, assertion, file, line, function);
    8686}
    8787
    88 void KXCReportFatalError(const char *file, int line, const char *function, const char *format, ...)
     88void WTFReportFatalError(const char *file, int line, const char *function, const char *format, ...)
    8989{
    9090    fprintf(stderr, "=================\nFATAL ERROR: ");
    … …  
    9696}
    9797
    98 void KXCReportError(const char *file, int line, const char *function, const char *format, ...)
     98void WTFReportError(const char *file, int line, const char *function, const char *format, ...)
    9999{
    100100    fprintf(stderr, "=================\nERROR: ");
    … …  
    106106}
    107107
    108 void KXCLog(const char*, int, const char*, KXCLogChannel *channel, const char *format, ...)
     108void WTFLog(const char*, int, const char*, WTFLogChannel *channel, const char *format, ...)
    109109{   
    110     if (channel->state != KXCLogChannelOn)
     110    if (channel->state != WTFLogChannelOn)
    111111        return;
    112112   

  • trunk/JavaScriptCore/wtf/Assertions.h

    r13684 r14256  
    7474#endif
    7575
    76 typedef enum { KXCLogChannelOff, KXCLogChannelOn } KXCLogChannelState;
     76typedef enum { WTFLogChannelOff, WTFLogChannelOn } WTFLogChannelState;
    7777
    7878typedef struct {
    7979    unsigned mask;
    8080    const char *defaultName;
    81     KXCLogChannelState state;
    82 } KXCLogChannel;
     81    WTFLogChannelState state;
     82} WTFLogChannel;
    8383
    84 void KXCReportAssertionFailure(const char *file, int line, const char *function, const char *assertion);
    85 void KXCReportAssertionFailureWithMessage(const char *file, int line, const char *function, const char *assertion, const char *format, ...);
    86 void KXCReportArgumentAssertionFailure(const char *file, int line, const char *function, const char *argName, const char *assertion);
    87 void KXCReportFatalError(const char *file, int line, const char *function, const char *format, ...) ;
    88 void KXCReportError(const char *file, int line, const char *function, const char *format, ...);
    89 void KXCLog(const char *file, int line, const char *function, KXCLogChannel *channel, const char *format, ...);
     84void WTFReportAssertionFailure(const char *file, int line, const char *function, const char *assertion);
     85void WTFReportAssertionFailureWithMessage(const char *file, int line, const char *function, const char *assertion, const char *format, ...);
     86void WTFReportArgumentAssertionFailure(const char *file, int line, const char *function, const char *argName, const char *assertion);
     87void WTFReportFatalError(const char *file, int line, const char *function, const char *format, ...) ;
     88void WTFReportError(const char *file, int line, const char *function, const char *format, ...);
     89void WTFLog(const char *file, int line, const char *function, WTFLogChannel *channel, const char *format, ...);
    9090
    9191#ifdef __cplusplus
    … …  
    114114#define ASSERT(assertion) do \
    115115    if (!(assertion)) { \
    116         KXCReportAssertionFailure(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, #assertion); \
     116        WTFReportAssertionFailure(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, #assertion); \
    117117        CRASH(); \
    118118    } \
    … …  
    120120#define ASSERT_WITH_MESSAGE(assertion, ...) do \
    121121    if (!(assertion)) { \
    122         KXCReportAssertionFailureWithMessage(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, #assertion, __VA_ARGS__); \
     122        WTFReportAssertionFailureWithMessage(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, #assertion, __VA_ARGS__); \
    123123        CRASH(); \
    124124    } \
    125125while (0)
    126126#define ASSERT_NOT_REACHED() do { \
    127     KXCReportAssertionFailure(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, 0); \
     127    WTFReportAssertionFailure(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, 0); \
    128128    CRASH(); \
    129129} while (0)
    … …  
    141141#define ASSERT_ARG(argName, assertion) do \
    142142    if (!(assertion)) { \
    143         KXCReportArgumentAssertionFailure(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, #argName, #assertion); \
     143        WTFReportArgumentAssertionFailure(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, #argName, #assertion); \
    144144        CRASH(); \
    145145    } \
    … …  
    154154#else
    155155#define FATAL(...) do { \
    156     KXCReportFatalError(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, __VA_ARGS__); \
     156    WTFReportFatalError(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, __VA_ARGS__); \
    157157    CRASH(); \
    158158} while (0)
    … …  
    164164#define LOG_ERROR(...) ((void)0)
    165165#else
    166 #define LOG_ERROR(...) KXCReportError(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, __VA_ARGS__)
     166#define LOG_ERROR(...) WTFReportError(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, __VA_ARGS__)
    167167#endif
    168168
    … …  
    172172#define LOG(channel, ...) ((void)0)
    173173#else
    174 #define LOG(channel, ...) KXCLog(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, &JOIN_LOG_CHANNEL_WITH_PREFIX(LOG_CHANNEL_PREFIX, channel), __VA_ARGS__)
     174#define LOG(channel, ...) WTFLog(__FILE__, __LINE__, KXMLCORE_PRETTY_FUNCTION, &JOIN_LOG_CHANNEL_WITH_PREFIX(LOG_CHANNEL_PREFIX, channel), __VA_ARGS__)
    175175#define JOIN_LOG_CHANNEL_WITH_PREFIX(prefix, channel) JOIN_LOG_CHANNEL_WITH_PREFIX_LEVEL_2(prefix, channel)
    176176#define JOIN_LOG_CHANNEL_WITH_PREFIX_LEVEL_2(prefix, channel) prefix ## channel

  • trunk/JavaScriptCore/wtf/FastMalloc.cpp

    r14162 r14256  
    8181#endif
    8282
    83 namespace KXMLCore {
     83namespace WTF {
    8484   
    8585void *fastMalloc(size_t n)
    … …  
    109109#endif
    110110
    111 } // namespace KXMLCore
     111} // namespace WTF
    112112
    113113#else
    … …  
    135135#include <unistd.h>
    136136
    137 #if KXC_CHANGES
    138 namespace KXMLCore {
     137#if WTF_CHANGES
     138namespace WTF {
    139139
    140140#define malloc fastMalloc
    … …  
    537537}
    538538
    539 #ifndef KXC_CHANGES
     539#ifndef WTF_CHANGES
    540540static int DLL_Length(const Span* list) {
    541541  int result = 0;
    … …  
    654654
    655655  // Dump state to stderr
    656 #ifndef KXC_CHANGES
     656#ifndef WTF_CHANGES
    657657  void Dump(TCMalloc_Printer* out);
    658658#endif
    … …  
    858858}
    859859
    860 #ifndef KXC_CHANGES
     860#ifndef WTF_CHANGES
    861861void TCMalloc_PageHeap::Dump(TCMalloc_Printer* out) {
    862862  int nonempty_sizes = 0;
    … …  
    13711371  // may not release much memory, but if so we will call scavenge again
    13721372  // pretty soon and the low-water marks will be high on that call.
    1373 #ifndef KXC_CHANGES
     1373#ifndef WTF_CHANGES
    13741374  int64 start = CycleClock::Now();
    13751375#endif
    … …  
    13851385  }
    13861386
    1387 #ifndef KXC_CHANGES
     1387#ifndef WTF_CHANGES
    13881388  int64 finish = CycleClock::Now();
    13891389  CycleTimer ct;
    … …  
    15891589};
    15901590
    1591 #ifndef KXC_CHANGES
     1591#ifndef WTF_CHANGES
    15921592// Get stats into "r".  Also get per-size-class counts if class_count != NULL
    15931593static void ExtractStats(TCMallocStats* r, uint64_t* class_count) {
    … …  
    16231623#endif
    16241624
    1625 #ifndef KXC_CHANGES
     1625#ifndef WTF_CHANGES
    16261626// WRITE stats to "out"
    16271627static void DumpStats(TCMalloc_Printer* out, int level) {
    … …  
    17271727#endif
    17281728
    1729 #ifndef KXC_CHANGES
     1729#ifndef WTF_CHANGES
    17301730
    17311731// TCMalloc's support for extra malloc interfaces
    … …  
    18181818// We hack around this problem by disabling all deallocations
    18191819// after a global object destructor in this module has been called.
    1820 #ifndef KXC_CHANGES
     1820#ifndef WTF_CHANGES
    18211821static bool tcmalloc_is_destroyed = false;
    18221822#endif
    … …  
    18261826//-------------------------------------------------------------------
    18271827
    1828 #ifndef KXC_CHANGES
     1828#ifndef WTF_CHANGES
    18291829
    18301830static Span* DoSampledAllocation(size_t size) {
    … …  
    18571857static ALWAYS_INLINE void* do_malloc(size_t size) {
    18581858
    1859 #ifndef KXC_CHANGES
     1859#ifndef WTF_CHANGES
    18601860  if (TCMallocDebug::level >= TCMallocDebug::kVerbose)
    18611861    MESSAGE("In tcmalloc do_malloc(%" PRIuS")\n", size);
    18621862#endif
    18631863
    1864 #ifndef KXC_CHANGES
     1864#ifndef WTF_CHANGES
    18651865  // The following call forces module initialization
    18661866  TCMalloc_ThreadCache* heap = TCMalloc_ThreadCache::GetCache();
    … …  
    18831883    return reinterpret_cast<void*>(span->start << kPageShift);
    18841884  } else {
    1885 #ifdef KXC_CHANGES
     1885#ifdef WTF_CHANGES
    18861886      TCMalloc_ThreadCache* heap = TCMalloc_ThreadCache::GetCache();
    18871887#endif
    … …  
    18911891
    18921892static ALWAYS_INLINE void do_free(void* ptr) {
    1893 #ifndef KXC_CHANGES
     1893#ifndef WTF_CHANGES
    18941894  if (TCMallocDebug::level >= TCMallocDebug::kVerbose)
    18951895    MESSAGE("In tcmalloc do_free(%p)\n", ptr);
    18961896#endif
    1897 #if KXC_CHANGES
     1897#if WTF_CHANGES
    18981898  if (ptr == NULL) return;
    1899 #else KXC_CHANGES
     1899#else WTF_CHANGES
    19001900  if (ptr == NULL || tcmalloc_is_destroyed) return;
    19011901#endif
    … …  
    19051905  Span* span = pageheap->GetDescriptor(p);
    19061906
    1907 #ifndef KXC_CHANGES
     1907#ifndef WTF_CHANGES
    19081908  if (span == NULL) {
    19091909    // We've seen systems where a piece of memory allocated using the
    … …  
    19441944}
    19451945
    1946 #ifndef KXC_CHANGES
     1946#ifndef WTF_CHANGES
    19471947// For use by exported routines below that want specific alignments
    19481948//
    … …  
    20342034 public:
    20352035  TCMallocGuard() {
    2036 #ifndef KXC_CHANGES
     2036#ifndef WTF_CHANGES
    20372037    char *envval;
    20382038    if ((envval = getenv("TCMALLOC_DEBUG"))) {
    … …  
    20442044    TCMalloc_ThreadCache::InitTSD();
    20452045    do_free(do_malloc(1));
    2046 #ifndef KXC_CHANGES
     2046#ifndef WTF_CHANGES
    20472047    MallocExtension::Register(new TCMallocImplementation);
    20482048#endif
    20492049  }
    20502050
    2051 #ifndef KXC_CHANGES
     2051#ifndef WTF_CHANGES
    20522052  ~TCMallocGuard() {
    20532053    const char* env = getenv("MALLOCSTATS");
    … …  
    20732073//         the call to the (de)allocation function.
    20742074
    2075 #ifndef KXC_CHANGES
     2075#ifndef WTF_CHANGES
    20762076extern "C"
    20772077#endif
    20782078void* malloc(size_t size) {
    20792079  void* result = do_malloc(size);
    2080 #ifndef KXC_CHANGES
     2080#ifndef WTF_CHANGES
    20812081  MallocHook::InvokeNewHook(result, size);
    20822082#endif
    … …  
    20842084}
    20852085
    2086 #ifndef KXC_CHANGES
     2086#ifndef WTF_CHANGES
    20872087extern "C"
    20882088#endif
    20892089void free(void* ptr) {
    2090 #ifndef KXC_CHANGES
     2090#ifndef WTF_CHANGES
    20912091  MallocHook::InvokeDeleteHook(ptr);
    20922092#endif
    … …  
    20942094}
    20952095
    2096 #ifndef KXC_CHANGES
     2096#ifndef WTF_CHANGES
    20972097extern "C"
    20982098#endif
    … …  
    21022102    memset(result, 0, n * elem_size);
    21032103  }
    2104 #ifndef KXC_CHANGES
     2104#ifndef WTF_CHANGES
    21052105  MallocHook::InvokeNewHook(result, n * elem_size);
    21062106#endif
    … …  
    21082108}
    21092109
    2110 #ifndef KXC_CHANGES
     2110#ifndef WTF_CHANGES
    21112111extern "C"
    21122112#endif
    21132113void cfree(void* ptr) {
    2114 #ifndef KXC_CHANGES
     2114#ifndef WTF_CHANGES
    21152115    MallocHook::InvokeDeleteHook(ptr);
    21162116#endif
    … …  
    21182118}
    21192119
    2120 #ifndef KXC_CHANGES
     2120#ifndef WTF_CHANGES
    21212121extern "C"
    21222122#endif
    … …  
    21242124  if (old_ptr == NULL) {
    21252125    void* result = do_malloc(new_size);
    2126 #ifndef KXC_CHANGES
     2126#ifndef WTF_CHANGES
    21272127    MallocHook::InvokeNewHook(result, new_size);
    21282128#endif
    … …  
    21302130  }
    21312131  if (new_size == 0) {
    2132 #ifndef KXC_CHANGES
     2132#ifndef WTF_CHANGES
    21332133    MallocHook::InvokeDeleteHook(old_ptr);
    21342134#endif
    … …  
    21552155      return NULL;
    21562156    }
    2157 #ifndef KXC_CHANGES
     2157#ifndef WTF_CHANGES
    21582158    MallocHook::InvokeNewHook(new_ptr, new_size);
    21592159#endif
    21602160    memcpy(new_ptr, old_ptr, ((old_size < new_size) ? old_size : new_size));
    2161 #ifndef KXC_CHANGES
     2161#ifndef WTF_CHANGES
    21622162    MallocHook::InvokeDeleteHook(old_ptr);
    21632163#endif
    … …  
    21772177#endif
    21782178
    2179 #ifndef KXC_CHANGES
     2179#ifndef WTF_CHANGES
    21802180
    21812181void* operator new(size_t size) OPNEW_THROW {
    … …  
    23202320#endif
    23212321
    2322 #if KXC_CHANGES
    2323 } // namespace KXMLCore
     2322#if WTF_CHANGES
     2323} // namespace WTF
    23242324#endif
    23252325

  • trunk/JavaScriptCore/wtf/FastMalloc.h

    r13568 r14256  
    2727#include <new>
    2828
    29 namespace KXMLCore {
     29namespace WTF {
    3030
    3131    void *fastMalloc(size_t n);
    … …  
    3434    void *fastRealloc(void* p, size_t n);
    3535
    36 } // namespace KXMLCore
     36} // namespace WTF
    3737
    38 using KXMLCore::fastMalloc;
    39 using KXMLCore::fastCalloc;
    40 using KXMLCore::fastRealloc;
    41 using KXMLCore::fastFree;
     38using WTF::fastMalloc;
     39using WTF::fastCalloc;
     40using WTF::fastRealloc;
     41using WTF::fastFree;
    4242
    4343#if PLATFORM(GCC) && PLATFORM(DARWIN)

  • trunk/JavaScriptCore/wtf/FastMallocInternal.h

    r13089 r14256  
    2828#include <pthread.h>
    2929
    30 namespace KXMLCore {
     30namespace WTF {
    3131    void fastMallocRegisterThread(pthread_t thread);
    3232}

  • trunk/JavaScriptCore/wtf/Forward.h

    r13832 r14256  
    2424#include <stddef.h>
    2525
    26 namespace KXMLCore {
     26namespace WTF {
    2727    template<typename T> class ListRefPtr;
    2828    template<typename T> class OwnArrayPtr;
    … …  
    3232}
    3333
    34 using KXMLCore::ListRefPtr;
    35 using KXMLCore::OwnArrayPtr;
    36 using KXMLCore::OwnPtr;
    37 using KXMLCore::PassRefPtr;
    38 using KXMLCore::RefPtr;
     34using WTF::ListRefPtr;
     35using WTF::OwnArrayPtr;
     36using WTF::OwnPtr;
     37using WTF::PassRefPtr;
     38using WTF::RefPtr;
    3939
    4040#endif

  • trunk/JavaScriptCore/wtf/HashCountedSet.h

    r13830 r14256  
    2727#include "HashMap.h"
    2828
    29 namespace KXMLCore {
     29namespace WTF {
    3030
    3131    template<typename Value, typename HashFunctions = typename DefaultHash<Value>::Hash,
    … …  
    174174} // namespace khtml
    175175
    176 using KXMLCore::HashCountedSet;
     176using WTF::HashCountedSet;
    177177
    178178#endif /* KXMLCORE_HASH_COUNTED_SET_H */

  • trunk/JavaScriptCore/wtf/HashFunctions.h

    r13703 r14256  
    2727#include <stdint.h>
    2828
    29 namespace KXMLCore {
     29namespace WTF {
    3030
    3131    template<size_t size> struct IntTypes;
    … …  
    9797    template<typename P> struct DefaultHash<RefPtr<P> > { typedef PtrHash<RefPtr<P> > Hash; };
    9898
    99 } // namespace KXMLCore
     99} // namespace WTF
    100100
    101 using KXMLCore::DefaultHash;
    102 using KXMLCore::IntHash;
    103 using KXMLCore::PtrHash;
     101using WTF::DefaultHash;
     102using WTF::IntHash;
     103using WTF::PtrHash;
    104104
    105105#endif // KXLMCORE_HASH_FUNCTIONS_H

  • trunk/JavaScriptCore/wtf/HashMap.h

    r14221 r14256  
    2727#include "HashTable.h"
    2828
    29 namespace KXMLCore {
     29namespace WTF {
    3030
    3131    template<typename PairType> struct PairFirstExtractor;
    … …  
    321321    }
    322322
    323 } // namespace KXMLCore
    324 
    325 using KXMLCore::HashMap;
     323} // namespace WTF
     324
     325using WTF::HashMap;
    326326
    327327#endif /* KXMLCORE_HASH_MAP_H */

  • trunk/JavaScriptCore/wtf/HashSet.h

    r14221 r14256  
    2727#include "HashTable.h"
    2828
    29 namespace KXMLCore {
     29namespace WTF {
    3030
    3131    template<typename T> struct IdentityExtractor;
    … …  
    307307    }
    308308
    309 } // namespace KXMLCore
    310 
    311 using KXMLCore::HashSet;
     309} // namespace WTF
     310
     311using WTF::HashSet;
    312312
    313313#endif /* KXMLCORE_HASH_SET_H */

  • trunk/JavaScriptCore/wtf/HashTable.cpp

    r12301 r14256  
    2323#include "HashTable.h"
    2424
    25 namespace KXMLCore {
     25namespace WTF {
    2626
    2727#if DUMP_HASHTABLE_STATS
    … …  
    6060#endif
    6161
    62 } // namespace KXMLCore
     62} // namespace WTF

  • trunk/JavaScriptCore/wtf/HashTable.h

    r13821 r14256  
    2828#include <assert.h>
    2929
    30 namespace KXMLCore {
     30namespace WTF {
    3131
    3232#define DUMP_HASHTABLE_STATS 0
    … …  
    931931    };
    932932
    933 } // namespace KXMLCore
     933} // namespace WTF
    934934
    935935#endif // KXMLCORE_HASH_TABLE_H

  • trunk/JavaScriptCore/wtf/HashTraits.h

    r13703 r14256  
    2727#include <utility>
    2828
    29 namespace KXMLCore {
     29namespace WTF {
    3030
    3131    using std::pair;
    … …  
    188188    };
    189189
    190 } // namespace KXMLCore
     190} // namespace WTF
    191191
    192 using KXMLCore::HashTraits;
    193 using KXMLCore::PairHashTraits;
     192using WTF::HashTraits;
     193using WTF::PairHashTraits;
    194194
    195195#endif // KXMLCORE_HASH_TRAITS_H

  • trunk/JavaScriptCore/wtf/ListRefPtr.h

    r13821 r14256  
    2424#define KXMLCORE_LIST_REF_PTR_H
    2525
    26 #include <kxmlcore/RefPtr.h>
     26#include <wtf/RefPtr.h>
    2727
    28 namespace KXMLCore {
     28namespace WTF {
    2929
    3030    // Specialized version of RefPtr desgined for use in singly-linked lists.
    … …  
    5252    };
    5353
    54 } // namespace KXMLCore
     54} // namespace WTF
    5555
    56 using KXMLCore::ListRefPtr;
     56using WTF::ListRefPtr;
    5757
    5858#endif // KXMLCORE_LIST_REF_PTR_H

  • trunk/JavaScriptCore/wtf/Noncopyable.h

    r12523 r14256  
    2323#define KXMLCORE_NONCOPYABLE
    2424
    25 // We don't want argument-dependent lookup to pull in everything from the KXMLCore
     25// We don't want argument-dependent lookup to pull in everything from the WTF
    2626// namespace when you use Noncopyable, so put it in its own namespace.
    2727
    28 namespace KXMLCoreNoncopyable {
     28namespace WTFNoncopyable {
    2929
    3030    class Noncopyable {
    … …  
    3636    };
    3737
    38 } // namespace KXMLCoreNoncopyable
     38} // namespace WTFNoncopyable
    3939
    40 using KXMLCoreNoncopyable::Noncopyable;
     40using WTFNoncopyable::Noncopyable;
    4141
    4242#endif // KXMLCORE_NONCOPYABLE

  • trunk/JavaScriptCore/wtf/OwnArrayPtr.h

    r12523 r14256  
    2424
    2525#include <algorithm>
    26 #include <kxmlcore/Assertions.h>
    27 #include <kxmlcore/Noncopyable.h>
     26#include <wtf/Assertions.h>
     27#include <wtf/Noncopyable.h>
    2828
    29 namespace KXMLCore {
     29namespace WTF {
    3030
    3131    template <typename T> class OwnArrayPtr : Noncopyable {
    … …  
    6161    template <typename T> inline void swap(OwnArrayPtr<T>& a, OwnArrayPtr<T>& b) { a.swap(b); }
    6262
    63 } // namespace KXMLCore
     63} // namespace WTF
    6464
    65 using KXMLCore::OwnArrayPtr;
     65using WTF::OwnArrayPtr;
    6666
    6767#endif // KXMLCORE_OWN_ARRAY_PTR_H

  • trunk/JavaScriptCore/wtf/OwnPtr.h

    r12523 r14256  
    2424
    2525#include <algorithm>
    26 #include <kxmlcore/Assertions.h>
    27 #include <kxmlcore/Noncopyable.h>
     26#include <wtf/Assertions.h>
     27#include <wtf/Noncopyable.h>
    2828
    29 namespace KXMLCore {
     29namespace WTF {
    3030
    3131    template <typename T> class OwnPtr : Noncopyable {
    … …  
    5959    template <typename T> inline void swap(OwnPtr<T>& a, OwnPtr<T>& b) { a.swap(b); }
    6060
    61 } // namespace KXMLCore
     61} // namespace WTF
    6262
    63 using KXMLCore::OwnPtr;
     63using WTF::OwnPtr;
    6464
    6565#endif // KXMLCORE_OWN_PTR_H

  • trunk/JavaScriptCore/wtf/PassRefPtr.h

    r12317 r14256  
    2424#define KXMLCORE_PASS_REF_PTR_H
    2525
    26 namespace KXMLCore {
     26namespace WTF {
    2727
    2828    template<typename T> class RefPtr;
    … …  
    179179    }
    180180
    181 } // namespace KXMLCore
     181} // namespace WTF
    182182
    183 using KXMLCore::PassRefPtr;
    184 using KXMLCore::adoptRef;
    185 using KXMLCore::static_pointer_cast;
    186 using KXMLCore::const_pointer_cast;
     183using WTF::PassRefPtr;
     184using WTF::adoptRef;
     185using WTF::static_pointer_cast;
     186using WTF::const_pointer_cast;
    187187
    188188#endif // KXMLCORE_PASS_REF_PTR_H

  • trunk/JavaScriptCore/wtf/RefPtr.h

    r12737 r14256  
    2626#include <algorithm>
    2727
    28 namespace KXMLCore {
     28namespace WTF {
    2929
    3030    template <typename T> class PassRefPtr;
    … …  
    176176    }
    177177
    178 } // namespace KXMLCore
     178} // namespace WTF
    179179
    180 using KXMLCore::RefPtr;
    181 using KXMLCore::static_pointer_cast;
    182 using KXMLCore::const_pointer_cast;
     180using WTF::RefPtr;
     181using WTF::static_pointer_cast;
     182using WTF::const_pointer_cast;
    183183
    184184#endif // KXMLCORE_REF_PTR_H

  • trunk/JavaScriptCore/wtf/TCSystemAlloc.cpp

    r13089 r14256  
    6969// the mmap address space (1300MBish) are disjoint, so we need both allocators
    7070// to get as much virtual memory as possible.
    71 #ifndef KXC_CHANGES
     71#ifndef WTF_CHANGES
    7272static bool use_devmem = false;
    7373#endif
    … …  
    8080static bool mmap_failure = false;
    8181
    82 #ifndef KXC_CHANGES
     82#ifndef WTF_CHANGES
    8383DEFINE_int32(malloc_devmem_start, 0,
    8484             "Physical memory starting location in MB for /dev/mem allocation."
    … …  
    173173#endif /* HAVE(MMAP) */
    174174
    175 #ifndef KXC_CHANGES
     175#ifndef WTF_CHANGES
    176176static void* TryDevMem(size_t size, size_t alignment) {
    177177  static bool initialized = false;
    … …  
    247247
    248248void* TCMalloc_SystemAlloc(size_t size, size_t alignment) {
    249 #ifndef KXC_CHANGES
     249#ifndef WTF_CHANGES
    250250  if (TCMallocDebug::level >= TCMallocDebug::kVerbose) {
    251251    MESSAGE("TCMalloc_SystemAlloc(%" PRIuS ", %" PRIuS")\n",
    … …  
    262262  for (int i = 0; i < 2; i++) {
    263263
    264 #ifndef KXC_CHANGES
     264#ifndef WTF_CHANGES
    265265    if (use_devmem && !devmem_failure) {
    266266      void* result = TryDevMem(size, alignment);

  • trunk/JavaScriptCore/wtf/Vector.h

    r14184 r14256  
    3434#undef max
    3535
    36 namespace KXMLCore {
     36namespace WTF {
    3737
    3838    using std::min;
    … …  
    587587    }
    588588
    589 } // namespace KXMLCore
    590 
    591 using KXMLCore::Vector;
     589} // namespace WTF
     590
     591using WTF::Vector;
    592592
    593593#endif // KXMLCORE_VECTOR_H

  • trunk/JavaScriptCore/wtf/VectorTraits.h

    r13090 r14256  
    2929using std::pair;
    3030
    31 namespace KXMLCore {
     31namespace WTF {
    3232
    3333    template <typename T> struct IsPod           { static const bool value = false; };
    … …  
    106106    };
    107107
    108 } // namespace KXMLCore
     108} // namespace WTF
    109109
    110 using KXMLCore::VectorTraits;
    111 using KXMLCore::SimpleClassVectorTraits;
     110using WTF::VectorTraits;
     111using WTF::SimpleClassVectorTraits;
    112112
    113113#endif // KXMLCORE_VECTOR_TRAITS_H

  • trunk/JavaScriptCore/wtf/unicode/UnicodeCategory.h

    r13740 r14256  
    2424#define KJS_UNICODE_CATEGORY_H
    2525
    26 namespace KXMLCore {
     26namespace WTF {
    2727  namespace Unicode {
    2828    enum CharCategory {

  • trunk/JavaScriptCore/wtf/unicode/icu/UnicodeIcu.h

    r13742 r14256  
    3030#include "../UnicodeCategory.h"
    3131
    32 namespace KXMLCore {
     32namespace WTF {
    3333  namespace Unicode {
    3434
Note: See TracChangeset for help on using the changeset viewer.