D/ldc
1
0
Fork 0
mirror of https://github.com/xomboverlord/ldc.git synced 2026-01-11 18:33:14 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Removed two (!) D1/Tango runtime build systems.

Browse Source 
As discussed on IRC, Bob has been the default (and recommended) way to build Tango for LDC for quite some time now. Support for it in the CMake-based build system just created a big maintenance burden for (almost) no benefits. Besides, the build system was currently broken anyway.

The makefiles seemed to support building *.bc libs for Tango though, which Bob probably doesn't, which might be worth keeping in mind.
This commit is contained in:
David Nadlinger
2011-12-04 20:21:56 +01:00
parent 018c47762e
commit 38d1bf4cc8
71 changed files with 112 additions and 13101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@@ -267,4 +267,6 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
install(DIRECTORY bash_completion.d DESTINATION ${CONF_INST_DIR})
endif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
add_subdirectory(runtime)
if(D_VERSION EQUAL 2)
add_subdirectory(runtime)
endif()

238
runtime/CMakeLists.txt
View File

@@ -6,6 +6,10 @@ cmake_minimum_required(VERSION 2.6)
# Main configuration.
#
if(D_VERSION EQUAL 1)
message(FATAL_ERROR "Please use bob to build Tango for D1.")
endif()
include(CheckTypeSize)
check_type_size(void* ptr_size)
@@ -29,146 +33,97 @@ else(BUILD_SHARED_LIBS)
set(CXX_COMPILE_FLAGS " ")
endif(BUILD_SHARED_LIBS)
# build tango for D1, druntime for D2
if(D_VERSION EQUAL 1)
set(RUNTIME tango)
elseif(D_VERSION EQUAL 2)
set(RUNTIME druntime)
else(D_VERSION EQUAL 1)
message(FATAL_ERROR "The runtime must be built as part of the main CMake project.")
endif(D_VERSION EQUAL 1)
get_directory_property(PROJECT_PARENT_DIR DIRECTORY ${PROJECT_SOURCE_DIR} PARENT_DIRECTORY)
set(RUNTIME_DIR ${PROJECT_PARENT_DIR}/${RUNTIME} CACHE PATH "runtime source dir")
set(RUNTIME_DIR ${PROJECT_PARENT_DIR}/druntime CACHE PATH "runtime source dir")
#
# Gather source files.
#
if(D_VERSION EQUAL 1)
# copy imports to runtime dir
set(LDC_IMPORTS)
macro(imports_file SRCARG)
get_filename_component(DEST ${SRCARG} NAME)
set(SRC ${PROJECT_PARENT_DIR}/${SRCARG})
set(DEST ${RUNTIME_DIR}/ldc/${DEST})
set(PHOBOS2_DIR ${PROJECT_PARENT_DIR}/phobos CACHE PATH "phobos2 source dir")
set(RUNTIME_CC druntime-core)
set(RUNTIME_GC druntime-gc-basic)
set(RUNTIME_DC druntime-rt-ldc)
set(RUNTIME_AIO ldruntime)
set(RUNTIME_DC_DIR ${RUNTIME_DIR}/src/rt)
set(RUNTIME_GC_DIR ${RUNTIME_DIR}/src/gc)
set(RUNTIME_INCLUDE ${RUNTIME_DIR}/src)
file(GLOB CORE_D ${RUNTIME_DIR}/src/core/*.d )
file(GLOB CORE_D_SYNC ${RUNTIME_DIR}/src/core/sync/*.d )
file(GLOB CORE_D_STDC ${RUNTIME_DIR}/src/core/stdc/*.d )
file(GLOB_RECURSE GC_D ${RUNTIME_GC_DIR}/*.d)
file(GLOB_RECURSE DCRT_D ${RUNTIME_DC_DIR}/*.d)
file(GLOB_RECURSE LDC_D ${RUNTIME_DIR}/src/ldc/*.d)
list(REMOVE_ITEM DCRT_D
${RUNTIME_DC_DIR}/alloca.d
${RUNTIME_DC_DIR}/arraybyte.d
${RUNTIME_DC_DIR}/arraycast.d
${RUNTIME_DC_DIR}/arraycat.d
${RUNTIME_DC_DIR}/arraydouble.d
${RUNTIME_DC_DIR}/arrayfloat.d
${RUNTIME_DC_DIR}/arrayreal.d
${RUNTIME_DC_DIR}/arrayshort.d
${RUNTIME_DC_DIR}/critical_.d
${RUNTIME_DC_DIR}/deh.d
${RUNTIME_DC_DIR}/deh2.d
${RUNTIME_DC_DIR}/llmath.d
${RUNTIME_DC_DIR}/qsort2.d
${RUNTIME_DC_DIR}/trace.d
)
file(GLOB DCRT_C ${RUNTIME_DC_DIR}/*.c)
list(REMOVE_ITEM DCRT_C ${RUNTIME_DC_DIR}/deh.c ${RUNTIME_DC_DIR}/memory_osx.c ${RUNTIME_DC_DIR}/dylib_fixes.c)
if(UNIX)
file(GLOB_RECURSE CORE_D_SYS ${RUNTIME_DIR}/src/core/sys/posix/*.d)
elseif(WIN32)
file(GLOB_RECURSE CORE_D_SYS ${RUNTIME_DIR}/src/core/sys/windows/*.d)
elseif(APPLE)
file(GLOB_RECURSE CORE_D_SYS ${RUNTIME_DIR}/src/core/sys/osx/*.d)
endif(UNIX)
list(APPEND CORE_D ${CORE_D_SYNC} ${CORE_D_SYS} ${CORE_D_STDC} )
list(APPEND GENERATE_DI ${CORE_D})
list(APPEND CORE_D ${LDC_D} ${RUNTIME_DIR}/src/object_.d)
file(GLOB CORE_C ${RUNTIME_DIR}/src/core/stdc/*.c)
list(APPEND LDC_IMPORTS ${DEST})
add_custom_command(
OUTPUT ${DEST}
DEPENDS ${SRC}
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SRC} ${DEST}
)
endmacro(imports_file)
imports_file(import/ldc/cstdarg.di)
imports_file(import/ldc/intrinsics.di)
imports_file(import/ldc/llvmasm.di)
imports_file(internal/ldc/bitmanip.d)
imports_file(internal/ldc/vararg.d)
# library names
set(RUNTIME_CC tango-cc-tango)
set(RUNTIME_GC tango-gc-basic)
set(RUNTIME_DC ldc-runtime)
set(RUNTIME_AIO tango)
# set paths to source files, or fill lists directly
set(RUNTIME_DC_DIR ${RUNTIME_DIR}/internal)
set(RUNTIME_GC_DIR ${RUNTIME_DIR}/lib/gc/basic)
set(RUNTIME_INCLUDE ${RUNTIME_DC_DIR})
file(GLOB CORE_D ${RUNTIME_DIR}/lib/common/tango/core/*.d)
file(GLOB CORE_C ${RUNTIME_DIR}/lib/common/tango/stdc/*.c)
file(GLOB_RECURSE GC_D ${RUNTIME_GC_DIR}/*.d)
file(GLOB_RECURSE DCRT_D ${RUNTIME_DC_DIR}/*.d)
file(GLOB DCRT_C ${RUNTIME_DC_DIR}/*.c)
set(CONFIG_NAME ${LDC_EXE})
elseif(D_VERSION EQUAL 2)
set(PHOBOS2_DIR ${PROJECT_PARENT_DIR}/phobos CACHE PATH "phobos2 source dir")
set(RUNTIME_CC druntime-core)
set(RUNTIME_GC druntime-gc-basic)
set(RUNTIME_DC druntime-rt-ldc)
set(RUNTIME_AIO ldruntime)
set(RUNTIME_DC_DIR ${RUNTIME_DIR}/src/rt)
set(RUNTIME_GC_DIR ${RUNTIME_DIR}/src/gc)
set(RUNTIME_INCLUDE ${RUNTIME_DIR}/src)
file(GLOB CORE_D ${RUNTIME_DIR}/src/core/*.d )
file(GLOB CORE_D_SYNC ${RUNTIME_DIR}/src/core/sync/*.d )
file(GLOB CORE_D_STDC ${RUNTIME_DIR}/src/core/stdc/*.d )
file(GLOB_RECURSE GC_D ${RUNTIME_GC_DIR}/*.d)
file(GLOB_RECURSE DCRT_D ${RUNTIME_DC_DIR}/*.d)
file(GLOB_RECURSE LDC_D ${RUNTIME_DIR}/src/ldc/*.d)
list(REMOVE_ITEM DCRT_D
${RUNTIME_DC_DIR}/alloca.d
${RUNTIME_DC_DIR}/arraybyte.d
${RUNTIME_DC_DIR}/arraycast.d
${RUNTIME_DC_DIR}/arraycat.d
${RUNTIME_DC_DIR}/arraydouble.d
${RUNTIME_DC_DIR}/arrayfloat.d
${RUNTIME_DC_DIR}/arrayreal.d
${RUNTIME_DC_DIR}/arrayshort.d
${RUNTIME_DC_DIR}/critical_.d
${RUNTIME_DC_DIR}/deh.d
${RUNTIME_DC_DIR}/deh2.d
${RUNTIME_DC_DIR}/llmath.d
${RUNTIME_DC_DIR}/qsort2.d
${RUNTIME_DC_DIR}/trace.d
)
file(GLOB DCRT_C ${RUNTIME_DC_DIR}/*.c)
list(REMOVE_ITEM DCRT_C ${RUNTIME_DC_DIR}/deh.c ${RUNTIME_DC_DIR}/memory_osx.c ${RUNTIME_DC_DIR}/dylib_fixes.c)
if(PHOBOS2_DIR)
file(GLOB PHOBOS2_D ${PHOBOS2_DIR}/std/*.d)
file(GLOB_RECURSE PHOBOS2_D_INTERNAL ${PHOBOS2_DIR}/std/internal/*.d)
file(GLOB PHOBOS2_D_C ${PHOBOS2_DIR}/std/c/*.d)
if(UNIX)
file(GLOB_RECURSE CORE_D_SYS ${RUNTIME_DIR}/src/core/sys/posix/*.d)
file(GLOB PHOBOS2_D_C_SYS ${PHOBOS2_DIR}/std/c/linux/*.d)
elseif(WIN32)
file(GLOB_RECURSE CORE_D_SYS ${RUNTIME_DIR}/src/core/sys/windows/*.d)
file(GLOB PHOBOS2_D_C_SYS ${PHOBOS2_DIR}/std/c/windows/*.d)
elseif(APPLE)
file(GLOB_RECURSE CORE_D_SYS ${RUNTIME_DIR}/src/core/sys/osx/*.d)
file(GLOB PHOBOS2_D_C_SYS ${PHOBOS2_DIR}/std/c/osx/*.d)
endif(UNIX)
list(APPEND CORE_D ${CORE_D_SYNC} ${CORE_D_SYS} ${CORE_D_STDC} )
list(APPEND GENERATE_DI ${CORE_D})
list(APPEND CORE_D ${LDC_D} ${RUNTIME_DIR}/src/object_.d)
file(GLOB CORE_C ${RUNTIME_DIR}/src/core/stdc/*.c)
if(PHOBOS2_DIR)
file(GLOB PHOBOS2_D ${PHOBOS2_DIR}/std/*.d)
file(GLOB_RECURSE PHOBOS2_D_INTERNAL ${PHOBOS2_DIR}/std/internal/*.d)
file(GLOB PHOBOS2_D_C ${PHOBOS2_DIR}/std/c/*.d)
if(UNIX)
file(GLOB PHOBOS2_D_C_SYS ${PHOBOS2_DIR}/std/c/linux/*.d)
elseif(WIN32)
file(GLOB PHOBOS2_D_C_SYS ${PHOBOS2_DIR}/std/c/windows/*.d)
elseif(APPLE)
file(GLOB PHOBOS2_D_C_SYS ${PHOBOS2_DIR}/std/c/osx/*.d)
endif(UNIX)
file(GLOB ZLIB_C ${PHOBOS2_DIR}/etc/c/zlib/*.c)
list(REMOVE_ITEM ZLIB_C
${PHOBOS2_DIR}/etc/c/zlib/minigzip.c
${PHOBOS2_DIR}/etc/c/zlib/example.c
${PHOBOS2_DIR}/etc/c/zlib/gzio.c
)
if(WIN32)
file(GLOB PHOBOS2_D_WIN ${PHOBOS2_DIR}/std/windows/*.d)
endif(WIN32)
list(APPEND PHOBOS2_D
${PHOBOS2_D_INTERNAL}
${PHOBOS2_D_WIN}
${PHOBOS2_D_C}
${PHOBOS2_D_C_SYS}
${PHOBOS2_DIR}/etc/c/zlib.d
${PHOBOS2_DIR}/crc32.d
)
list(REMOVE_ITEM PHOBOS2_D
${PHOBOS2_DIR}/std/intrinsic.d
)
set(CONFIG_NAME ${LDC_EXE}_phobos)
else(PHOBOS2_DIR)
set(CONFIG_NAME ${LDC_EXE})
endif(PHOBOS2_DIR)
endif(D_VERSION EQUAL 1)
file(GLOB ZLIB_C ${PHOBOS2_DIR}/etc/c/zlib/*.c)
list(REMOVE_ITEM ZLIB_C
${PHOBOS2_DIR}/etc/c/zlib/minigzip.c
${PHOBOS2_DIR}/etc/c/zlib/example.c
${PHOBOS2_DIR}/etc/c/zlib/gzio.c
)
if(WIN32)
file(GLOB PHOBOS2_D_WIN ${PHOBOS2_DIR}/std/windows/*.d)
endif(WIN32)
list(APPEND PHOBOS2_D
${PHOBOS2_D_INTERNAL}
${PHOBOS2_D_WIN}
${PHOBOS2_D_C}
${PHOBOS2_D_C_SYS}
${PHOBOS2_DIR}/etc/c/zlib.d
${PHOBOS2_DIR}/crc32.d
)
list(REMOVE_ITEM PHOBOS2_D
${PHOBOS2_DIR}/std/intrinsic.d
)
set(CONFIG_NAME ${LDC_EXE}_phobos)
else(PHOBOS2_DIR)
set(CONFIG_NAME ${LDC_EXE})
endif(PHOBOS2_DIR)
# should only be necessary if run independently from ldc cmake project
if(NOT LDC_LOC)
if(NOT LDC_EXE)
if(D_VERSION EQUAL 1)
set(LDC_EXE ldc)
elseif(D_VERSION EQUAL 2)
set(LDC_EXE ldc2)
endif(D_VERSION EQUAL 1)
set(LDC_EXE ldc2)
endif(NOT LDC_EXE)
find_program(LDC_LOC ${LDC_EXE} ${PROJECT_BINARY_DIR}/../bin DOC "path to ldc binary")
@@ -264,14 +219,10 @@ macro(build_runtime d_flags c_flags ld_flags lib_suffix path_suffix)
set(DCRT_O "")
set(DCRT_BC "")
foreach(f ${DCRT_D})
if(D_VERSION EQUAL 1)
dc(${f} DCRT_O DCRT_BC "${d_flags}" ${RUNTIME_DC_DIR} "${target_suffix}")
else(D_VERSION EQUAL 1)
dc(${f} DCRT_O DCRT_BC "${d_flags}" "" "${target_suffix}")
endif(D_VERSION EQUAL 1)
dc(${f} DCRT_O DCRT_BC "${d_flags}" "" "${target_suffix}")
endforeach(f)
if(EXISTS ${PROJECT_PARENT_DIR}/${RUNTIME})
if(EXISTS ${RUNTIME_DIR})
if(BUILD_SINGLE_LIB)
add_library(${RUNTIME_AIO}${target_suffix}
${D_LIBRARY_TYPE}
@@ -296,7 +247,7 @@ macro(build_runtime d_flags c_flags ld_flags lib_suffix path_suffix)
${RUNTIME_DC}${lib_suffix}
)
endif(BUILD_SINGLE_LIB)
endif(EXISTS ${PROJECT_PARENT_DIR}/${RUNTIME})
endif()
if(BUILD_BC_LIBS)
find_program(LLVM_AR_EXE llvm-ar ${LLVM_INSTDIR}/bin DOC "path to llvm-ar tool")
@@ -389,17 +340,12 @@ endif(MULTILIB)
# Install target.
#
if(D_VERSION EQUAL 2)
install(DIRECTORY ${CMAKE_BINARY_DIR}/import/core DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.di")
if(PHOBOS2_DIR)
install(DIRECTORY ${PHOBOS2_DIR}/std DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.d")
install(DIRECTORY ${PHOBOS2_DIR}/etc DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.d")
install(FILES ${PHOBOS2_DIR}/crc32.d DESTINATION ${INCLUDE_INSTALL_DIR})
endif(PHOBOS2_DIR)
install(FILES ${RUNTIME_DIR}/import/object.di DESTINATION ${INCLUDE_INSTALL_DIR}/ldc)
install(FILES ${RUNTIME_DIR}/src/ldc/bitop.d DESTINATION ${INCLUDE_INSTALL_DIR}/core)
install(DIRECTORY ${RUNTIME_DIR}/import/ldc DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.di")
else(D_VERSION EQUAL 2)
install(DIRECTORY ${PROJECT_SOURCE_DIR}/${RUNTIME}/internal/ldc/ DESTINATION ${INCLUDE_INSTALL_DIR}/ldc)
install(DIRECTORY ${PROJECT_SOURCE_DIR}/runtime/import/ldc DESTINATION ${INCLUDE_INSTALL_DIR})
endif(D_VERSION EQUAL 2)
install(DIRECTORY ${CMAKE_BINARY_DIR}/import/core DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.di")
if(PHOBOS2_DIR)
install(DIRECTORY ${PHOBOS2_DIR}/std DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.d")
install(DIRECTORY ${PHOBOS2_DIR}/etc DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.d")
install(FILES ${PHOBOS2_DIR}/crc32.d DESTINATION ${INCLUDE_INSTALL_DIR})
endif(PHOBOS2_DIR)
install(FILES ${RUNTIME_DIR}/import/object.di DESTINATION ${INCLUDE_INSTALL_DIR}/ldc)
install(FILES ${RUNTIME_DIR}/src/ldc/bitop.d DESTINATION ${INCLUDE_INSTALL_DIR}/core)
install(DIRECTORY ${RUNTIME_DIR}/import/ldc DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.di")

40
runtime/README
View File

@@ -1,30 +1,24 @@
This should help get the runtime built.
FOR D1:
=======
1) Do a checkout of tango trunk into the ldc root dir (along dmd, gen, runtime etc).
Building druntime/Phobos for D2
---
* $ ls
* dmd dmd2 gen ir ...
* $ svn co http://svn.dsource.org/projects/tango/trunk tango
LDC currently needs custom forks of druntime and Phobos. They are integrated
with the main repository using Git submodules. To build them, make sure you
have up-to-date copies of the submodules in your local repository:
2) Compile the runtime
$ git submodule update -i
* sh build.sh
The libraries should then be built and installed automatically along with the
compiler itself. If, for some reason, you want to build them separately, the
targets are:
FOR D2:
=======
1) Check http://bitbucket.org/prokhin_alexy/ldc2/wiki/Home for up to date instructions
$ make runtime
$ make phobos2
2) At the time of writing, this works:
* $ git clone https://github.com/AlexeyProkhin/druntime
* $ git clone https://github.com/AlexeyProkhin/phobos
Building Tango for D1
---
3) Using cmake, set the D version to 2, then set the correct paths for druntime and phobos
4) Compile ldc2, druntime, and phobos
* $ make phobos2
=======
Enjoy!
This directory used to contain scripts for building Tango for LDC/D1, which
became obsolete after LDC support was added to its build system, and were
consequently removed. Please use the official Tango build system (bob) from
now on.

24
runtime/build-sharedlibs.sh
View File

@@ -1,24 +0,0 @@
#!/bin/bash
# I'm no good bash scripter ...
# copy imports
mkdir -p ../tango/ldc
cp internal/ldc/bitmanip.d ../tango/ldc/bitmanip.di
cp internal/ldc/vararg.d ../tango/ldc/vararg.di
cp import/ldc/* ../tango/ldc
# make the runtime
cp -R lib ../tango
cd ../tango/lib
make -f ldc-posix.mak clean
make -f ldc-posix.mak sharedlib
cd ../..
# install the runtime
rm -f lib/libldc-runtime-shared.so
cp runtime/internal/libldc-runtime-shared.so lib
rm -f lib/libtango-gc-basic-shared.so
cp tango/lib/gc/basic/libtango-gc-basic-shared.so lib
rm -f lib/libtango-cc-tango-shared.so
cp tango/lib/common/tango/libtango-cc-tango-shared.so lib

24
runtime/build.sh
View File

@@ -1,24 +0,0 @@
#!/bin/bash
# I'm no good bash scripter ...
# copy imports
mkdir -p ../tango/ldc
cp internal/ldc/bitmanip.d ../tango/ldc/bitmanip.di
cp internal/ldc/vararg.d ../tango/ldc/vararg.di
cp import/ldc/* ../tango/ldc
# make the runtime
cp -R lib ../tango
cd ../tango/lib
make -f ldc-posix.mak clean
make -f ldc-posix.mak lib
cd ../..
# install the runtime
rm -f lib/libldc-runtime*.a
cp runtime/internal/libldc-runtime*.a lib
rm -f lib/libtango-gc-basic*.a
cp tango/lib/gc/basic/libtango-gc-basic*.a lib
rm -f lib/libtango-cc-tango*.a
cp tango/lib/common/tango/libtango-cc-tango*.a lib

29
runtime/import/ldc/cstdarg.di
View File

@@ -1,29 +0,0 @@
/*
* vararg support for extern(C) functions
*/
module ldc.cstdarg;
// Check for the right compiler
version(LDC)
{
// OK
}
else
{
static assert(false, "This module is only valid for LDC");
}
alias void* va_list;
pragma(va_start)
void va_start(T)(va_list ap, ref T);
pragma(va_arg)
T va_arg(T)(va_list ap);
pragma(va_end)
void va_end(va_list args);
pragma(va_copy)
void va_copy(va_list dst, va_list src);

413
runtime/import/ldc/intrinsics.di
View File

@@ -1,413 +0,0 @@
/*
* This module holds declarations to LLVM intrinsics.
*
* See the LLVM language reference for more information:
*
* - http://llvm.org/docs/LangRef.html#intrinsics
*
*/
module ldc.intrinsics;
// Check for the right compiler
version(LDC)
{
// OK
}
else
{
static assert(false, "This module is only valid for LDC");
}
//
// CODE GENERATOR INTRINSICS
//
// The 'llvm.returnaddress' intrinsic attempts to compute a target-specific
// value indicating the return address of the current function or one of its
// callers.
pragma(intrinsic, "llvm.returnaddress")
void* llvm_returnaddress(uint level);
// The 'llvm.frameaddress' intrinsic attempts to return the target-specific
// frame pointer value for the specified stack frame.
pragma(intrinsic, "llvm.frameaddress")
void* llvm_frameaddress(uint level);
// The 'llvm.stacksave' intrinsic is used to remember the current state of the
// function stack, for use with llvm.stackrestore. This is useful for
// implementing language features like scoped automatic variable sized arrays
// in C99.
pragma(intrinsic, "llvm.stacksave")
void* llvm_stacksave();
// The 'llvm.stackrestore' intrinsic is used to restore the state of the
// function stack to the state it was in when the corresponding llvm.stacksave
// intrinsic executed. This is useful for implementing language features like
// scoped automatic variable sized arrays in C99.
pragma(intrinsic, "llvm.stackrestore")
void llvm_stackrestore(void* ptr);
// The 'llvm.prefetch' intrinsic is a hint to the code generator to insert a
// prefetch instruction if supported; otherwise, it is a noop. Prefetches have
// no effect on the behavior of the program but can change its performance
// characteristics.
pragma(intrinsic, "llvm.prefetch")
void llvm_prefetch(void* ptr, uint rw, uint locality);
// The 'llvm.pcmarker' intrinsic is a method to export a Program Counter (PC)
// in a region of code to simulators and other tools. The method is target
// specific, but it is expected that the marker will use exported symbols to
// transmit the PC of the marker. The marker makes no guarantees that it will
// remain with any specific instruction after optimizations. It is possible
// that the presence of a marker will inhibit optimizations. The intended use
// is to be inserted after optimizations to allow correlations of simulation
// runs.
pragma(intrinsic, "llvm.pcmarker")
void llvm_pcmarker(uint id);
// The 'llvm.readcyclecounter' intrinsic provides access to the cycle counter
// register (or similar low latency, high accuracy clocks) on those targets that
// support it. On X86, it should map to RDTSC. On Alpha, it should map to RPCC.
// As the backing counters overflow quickly (on the order of 9 seconds on
// alpha), this should only be used for small timings.
pragma(intrinsic, "llvm.readcyclecounter")
ulong readcyclecounter();
//
// STANDARD C LIBRARY INTRINSICS
//
// The 'llvm.memcpy.*' intrinsics copy a block of memory from the source
// location to the destination location.
// Note that, unlike the standard libc function, the llvm.memcpy.* intrinsics do
// not return a value, and takes an extra alignment argument.
pragma(intrinsic, "llvm.memcpy.i#")
void llvm_memcpy(T)(void* dst, void* src, T len, uint alignment);
deprecated {
alias llvm_memcpy!(uint) llvm_memcpy_i32;
alias llvm_memcpy!(ulong) llvm_memcpy_i64;
}
// The 'llvm.memmove.*' intrinsics move a block of memory from the source
// location to the destination location. It is similar to the 'llvm.memcpy'
// intrinsic but allows the two memory locations to overlap.
// Note that, unlike the standard libc function, the llvm.memmove.* intrinsics
// do not return a value, and takes an extra alignment argument.
pragma(intrinsic, "llvm.memmove.i#")
void llvm_memmove(T)(void* dst, void* src, T len, uint alignment);
deprecated {
alias llvm_memmove!(uint) llvm_memmove_i32;
alias llvm_memmove!(ulong) llvm_memmove_i64;
}
// The 'llvm.memset.*' intrinsics fill a block of memory with a particular byte
// value.
// Note that, unlike the standard libc function, the llvm.memset intrinsic does
// not return a value, and takes an extra alignment argument.
pragma(intrinsic, "llvm.memset.i#")
void llvm_memset(T)(void* dst, ubyte val, T len, uint alignment);
deprecated {
alias llvm_memset!(uint) llvm_memset_i32;
alias llvm_memset!(ulong) llvm_memset_i64;
}
// The 'llvm.sqrt' intrinsics return the sqrt of the specified operand,
// returning the same value as the libm 'sqrt' functions would. Unlike sqrt in
// libm, however, llvm.sqrt has undefined behavior for negative numbers other
// than -0.0 (which allows for better optimization, because there is no need to
// worry about errno being set). llvm.sqrt(-0.0) is defined to return -0.0 like
// IEEE sqrt.
pragma(intrinsic, "llvm.sqrt.f#")
T llvm_sqrt(T)(T val);
deprecated {
alias llvm_sqrt!(float) llvm_sqrt_f32;
alias llvm_sqrt!(double) llvm_sqrt_f64;
alias llvm_sqrt!(real) llvm_sqrt_f80; // may not actually be .f80
}
// The 'llvm.sin.*' intrinsics return the sine of the operand.
pragma(intrinsic, "llvm.sin.f#")
T llvm_sin(T)(T val);
deprecated {
alias llvm_sin!(float) llvm_sin_f32;
alias llvm_sin!(double) llvm_sin_f64;
alias llvm_sin!(real) llvm_sin_f80; // may not actually be .f80
}
// The 'llvm.cos.*' intrinsics return the cosine of the operand.
pragma(intrinsic, "llvm.cos.f#")
T llvm_cos(T)(T val);
deprecated {
alias llvm_cos!(float) llvm_cos_f32;
alias llvm_cos!(double) llvm_cos_f64;
alias llvm_cos!(real) llvm_cos_f80; // may not actually be .f80
}
// The 'llvm.powi.*' intrinsics return the first operand raised to the specified
// (positive or negative) power. The order of evaluation of multiplications is
// not defined. When a vector of floating point type is used, the second
// argument remains a scalar integer value.
pragma(intrinsic, "llvm.powi.f#")
T llvm_powi(T)(T val, int power);
deprecated {
alias llvm_powi!(float) llvm_powi_f32;
alias llvm_powi!(double) llvm_powi_f64;
alias llvm_powi!(real) llvm_powi_f80; // may not actually be .f80
}
// The 'llvm.pow.*' intrinsics return the first operand raised to the specified
// (positive or negative) power.
pragma(intrinsic, "llvm.pow.f#")
T llvm_pow(T)(T val, T power);
deprecated {
alias llvm_pow!(float) llvm_pow_f32;
alias llvm_pow!(double) llvm_pow_f64;
alias llvm_pow!(real) llvm_pow_f80; // may not actually be .f80
}
//
// BIT MANIPULATION INTRINSICS
//
// The 'llvm.bswap' family of intrinsics is used to byte swap integer values
// with an even number of bytes (positive multiple of 16 bits). These are
// useful for performing operations on data that is not in the target's native
// byte order.
pragma(intrinsic, "llvm.bswap.i#.i#")
T llvm_bswap(T)(T val);
deprecated {
alias llvm_bswap!(ushort) llvm_bswap_i16;
alias llvm_bswap!(uint) llvm_bswap_i32;
alias llvm_bswap!(ulong) llvm_bswap_i64;
}
// The 'llvm.ctpop' family of intrinsics counts the number of bits set in a
// value.
pragma(intrinsic, "llvm.ctpop.i#")
T llvm_ctpop(T)(T src);
deprecated {
alias llvm_ctpop!(ubyte) llvm_ctpop_i8;
alias llvm_ctpop!(ushort) llvm_ctpop_i16;
alias llvm_ctpop!(uint) llvm_ctpop_i32;
alias llvm_ctpop!(ulong) llvm_ctpop_i64;
}
// The 'llvm.ctlz' family of intrinsic functions counts the number of leading
// zeros in a variable.
pragma(intrinsic, "llvm.ctlz.i#")
T llvm_ctlz(T)(T src);
deprecated {
alias llvm_ctlz!(ubyte) llvm_ctlz_i8;
alias llvm_ctlz!(ushort) llvm_ctlz_i16;
alias llvm_ctlz!(uint) llvm_ctlz_i32;
alias llvm_ctlz!(ulong) llvm_ctlz_i64;
}
// The 'llvm.cttz' family of intrinsic functions counts the number of trailing
// zeros.
pragma(intrinsic, "llvm.cttz.i#")
T llvm_cttz(T)(T src);
deprecated {
alias llvm_cttz!(ubyte) llvm_cttz_i8;
alias llvm_cttz!(ushort) llvm_cttz_i16;
alias llvm_cttz!(uint) llvm_cttz_i32;
alias llvm_cttz!(ulong) llvm_cttz_i64;
}
// The 'llvm.part.select' family of intrinsic functions selects a range of bits
// from an integer value and returns them in the same bit width as the original
// value.
pragma(intrinsic, "llvm.part.select.i#")
T llvm_part_select(T)(T val, uint loBit, uint hiBit);
deprecated {
alias llvm_part_select!(ubyte) llvm_part_select_i;
alias llvm_part_select!(ushort) llvm_part_select_i;
alias llvm_part_select!(uint) llvm_part_select_i;
alias llvm_part_select!(ulong) llvm_part_select_i;
}
// The 'llvm.part.set' family of intrinsic functions replaces a range of bits
// in an integer value with another integer value. It returns the integer with
// the replaced bits.
// TODO
// declare i17 @llvm.part.set.i17.i9 (i17 %val, i9 %repl, i32 %lo, i32 %hi)
// declare i29 @llvm.part.set.i29.i9 (i29 %val, i9 %repl, i32 %lo, i32 %hi)
//
// ATOMIC OPERATIONS AND SYNCHRONIZATION INTRINSICS
//
// The llvm.memory.barrier intrinsic guarantees ordering between specific
// pairs of memory access types.
pragma(intrinsic, "llvm.memory.barrier")
void llvm_memory_barrier(bool ll, bool ls, bool sl, bool ss, bool device);
// This loads a value in memory and compares it to a given value. If they are
// equal, it stores a new value into the memory.
pragma(intrinsic, "llvm.atomic.cmp.swap.i#.p0i#")
T llvm_atomic_cmp_swap(T)(T* ptr, T cmp, T val);
// This intrinsic loads the value stored in memory at ptr and yields the value
// from memory. It then stores the value in val in the memory at ptr.
pragma(intrinsic, "llvm.atomic.swap.i#.p0i#")
T llvm_atomic_swap(T)(T* ptr, T val);
// This intrinsic adds delta to the value stored in memory at ptr. It yields
// the original value at ptr.
pragma(intrinsic, "llvm.atomic.load.add.i#.p0i#")
T llvm_atomic_load_add(T)(T* ptr, T val);
// This intrinsic subtracts delta to the value stored in memory at ptr. It
// yields the original value at ptr.
pragma(intrinsic, "llvm.atomic.load.sub.i#.p0i#")
T llvm_atomic_load_sub(T)(T* ptr, T val);
// These intrinsics bitwise the operation (and, nand, or, xor) delta to the
// value stored in memory at ptr. It yields the original value at ptr.
pragma(intrinsic, "llvm.atomic.load.and.i#.p0i#")
T llvm_atomic_load_and(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.nand.i#.p0i#")
T llvm_atomic_load_nand(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.or.i#.p0i#")
T llvm_atomic_load_or(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.xor.i#.p0i#")
T llvm_atomic_load_xor(T)(T* ptr, T val);
// These intrinsics takes the signed or unsigned minimum or maximum of delta
// and the value stored in memory at ptr. It yields the original value at ptr.
pragma(intrinsic, "llvm.atomic.load.max.i#.p0i#")
T llvm_atomic_load_max(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.min.i#.p0i#")
T llvm_atomic_load_min(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.umax.i#.p0i#")
T llvm_atomic_load_umax(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.umin.i#.p0i#")
T llvm_atomic_load_umin(T)(T* ptr, T val);
//
// ARITHMETIC-WITH-OVERFLOW INTRINSICS
//
struct OverflowRet(T) {
static assert(is(T : int), T.stringof ~ " is not an integer type!");
T result;
bool overflow;
}
// Signed and unsigned addition
pragma(intrinsic, "llvm.sadd.with.overflow.i#")
OverflowRet!(T) llvm_sadd_with_overflow(T)(T lhs, T rhs);
pragma(intrinsic, "llvm.uadd.with.overflow.i#")
OverflowRet!(T) llvm_uadd_with_overflow(T)(T lhs, T rhs);
// Signed and unsigned subtraction
pragma(intrinsic, "llvm.ssub.with.overflow.i#")
OverflowRet!(T) llvm_ssub_with_overflow(T)(T lhs, T rhs);
pragma(intrinsic, "llvm.usub.with.overflow.i#")
OverflowRet!(T) llvm_usub_with_overflow(T)(T lhs, T rhs);
// Signed and unsigned multiplication
pragma(intrinsic, "llvm.smul.with.overflow.i#")
OverflowRet!(T) llvm_smul_with_overflow(T)(T lhs, T rhs);
/* Note: LLVM documentations says:
* Warning: 'llvm.umul.with.overflow' is badly broken.
* It is actively being fixed, but it should not currently be used!
*
* See: http://llvm.org/docs/LangRef.html#int_umul_overflow
*/
//pragma(intrinsic, "llvm.umul.with.overflow.i#")
// OverflowRet!(T) llvm_umul_with_overflow(T)(T lhs, T rhs);
//
// GENERAL INTRINSICS
//
// This intrinsics is lowered to the target dependent trap instruction. If the
// target does not have a trap instruction, this intrinsic will be lowered to
// the call of the abort() function.
pragma(intrinsic, "llvm.trap")
void llvm_trap();

17
runtime/import/ldc/llvmasm.di
View File

@@ -1,17 +0,0 @@
module ldc.llvmasm;
struct __asmtuple_t(T...)
{
T v;
}
pragma(llvm_inline_asm)
{
void __asm( )(char[] asmcode, char[] constraints, ...);
T __asm(T)(char[] asmcode, char[] constraints, ...);
template __asmtuple(T...)
{
__asmtuple_t!(T) __asmtuple(char[] asmcode, char[] constraints, ...);
}
}

414
runtime/internal/aApply.d
View File

@@ -1,414 +0,0 @@
/**
* Part of the D programming language runtime library.
*/
/*
* Copyright (C) 2004-2006 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
*/
/* This code handles decoding UTF strings for foreach loops.
* There are 6 combinations of conversions between char, wchar,
* and dchar, and 2 of each of those.
*/
private import util.utf;
//debug = apply;
debug(apply)
{
extern(C) int printf(char*, ...);
}
/**********************************************
*/
// dg is D, but _aApplycd() is C
extern (D) typedef int delegate(void *) dg_t;
extern (C) int _aApplycd1(char[] aa, dg_t dg)
{ int result;
size_t i;
size_t len = aa.length;
debug(apply) printf("_aApplycd1(), len = %d\n", len);
for (i = 0; i < len; )
{ dchar d;
d = aa[i];
if (d & 0x80)
d = decode(aa, i);
else
i++;
result = dg(cast(void *)&d);
if (result)
break;
}
return result;
}
extern (C) int _aApplywd1(wchar[] aa, dg_t dg)
{ int result;
size_t i;
size_t len = aa.length;
debug(apply) printf("_aApplywd1(), len = %d\n", len);
for (i = 0; i < len; )
{ dchar d;
d = aa[i];
if (d & ~0x7F)
d = decode(aa, i);
else
i++;
result = dg(cast(void *)&d);
if (result)
break;
}
return result;
}
extern (C) int _aApplycw1(char[] aa, dg_t dg)
{ int result;
size_t i;
size_t len = aa.length;
debug(apply) printf("_aApplycw1(), len = %d\n", len);
for (i = 0; i < len; )
{ dchar d;
wchar w;
w = aa[i];
if (w & 0x80)
{ d = decode(aa, i);
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = cast(wchar)((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
result = dg(cast(void *)&w);
if (result)
break;
w = cast(wchar)(((d - 0x10000) & 0x3FF) + 0xDC00);
}
}
else
i++;
result = dg(cast(void *)&w);
if (result)
break;
}
return result;
}
extern (C) int _aApplywc1(wchar[] aa, dg_t dg)
{ int result;
size_t i;
size_t len = aa.length;
debug(apply) printf("_aApplywc1(), len = %d\n", len);
for (i = 0; i < len; )
{ dchar d;
wchar w;
char c;
w = aa[i];
if (w & ~0x7F)
{
char[4] buf;
d = decode(aa, i);
auto b = toUTF8(buf, d);
foreach (char c2; b)
{
result = dg(cast(void *)&c2);
if (result)
return result;
}
continue;
}
else
{ c = cast(char)w;
i++;
}
result = dg(cast(void *)&c);
if (result)
break;
}
return result;
}
extern (C) int _aApplydc1(dchar[] aa, dg_t dg)
{ int result;
debug(apply) printf("_aApplydc1(), len = %d\n", aa.length);
foreach (dchar d; aa)
{
char c;
if (d & ~0x7F)
{
char[4] buf;
auto b = toUTF8(buf, d);
foreach (char c2; b)
{
result = dg(cast(void *)&c2);
if (result)
return result;
}
continue;
}
else
{
c = cast(char)d;
}
result = dg(cast(void *)&c);
if (result)
break;
}
return result;
}
extern (C) int _aApplydw1(dchar[] aa, dg_t dg)
{ int result;
debug(apply) printf("_aApplydw1(), len = %d\n", aa.length);
foreach (dchar d; aa)
{
wchar w;
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = cast(wchar)((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
result = dg(cast(void *)&w);
if (result)
break;
w = cast(wchar)(((d - 0x10000) & 0x3FF) + 0xDC00);
}
result = dg(cast(void *)&w);
if (result)
break;
}
return result;
}
/****************************************************************************/
// dg is D, but _aApplycd2() is C
extern (D) typedef int delegate(void *, void *) dg2_t;
extern (C) int _aApplycd2(char[] aa, dg2_t dg)
{ int result;
size_t i;
size_t n;
size_t len = aa.length;
debug(apply) printf("_aApplycd2(), len = %d\n", len);
for (i = 0; i < len; i += n)
{ dchar d;
d = aa[i];
if (d & 0x80)
{
n = i;
d = decode(aa, n);
n -= i;
}
else
n = 1;
result = dg(&i, cast(void *)&d);
if (result)
break;
}
return result;
}
extern (C) int _aApplywd2(wchar[] aa, dg2_t dg)
{ int result;
size_t i;
size_t n;
size_t len = aa.length;
debug(apply) printf("_aApplywd2(), len = %d\n", len);
for (i = 0; i < len; i += n)
{ dchar d;
d = aa[i];
if (d & ~0x7F)
{
n = i;
d = decode(aa, n);
n -= i;
}
else
n = 1;
result = dg(&i, cast(void *)&d);
if (result)
break;
}
return result;
}
extern (C) int _aApplycw2(char[] aa, dg2_t dg)
{ int result;
size_t i;
size_t n;
size_t len = aa.length;
debug(apply) printf("_aApplycw2(), len = %d\n", len);
for (i = 0; i < len; i += n)
{ dchar d;
wchar w;
w = aa[i];
if (w & 0x80)
{ n = i;
d = decode(aa, n);
n -= i;
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
result = dg(&i, cast(void *)&w);
if (result)
break;
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
}
}
else
n = 1;
result = dg(&i, cast(void *)&w);
if (result)
break;
}
return result;
}
extern (C) int _aApplywc2(wchar[] aa, dg2_t dg)
{ int result;
size_t i;
size_t n;
size_t len = aa.length;
debug(apply) printf("_aApplywc2(), len = %d\n", len);
for (i = 0; i < len; i += n)
{ dchar d;
wchar w;
char c;
w = aa[i];
if (w & ~0x7F)
{
char[4] buf;
n = i;
d = decode(aa, n);
n -= i;
auto b = toUTF8(buf, d);
foreach (char c2; b)
{
result = dg(&i, cast(void *)&c2);
if (result)
return result;
}
continue;
}
else
{ c = cast(char)w;
n = 1;
}
result = dg(&i, cast(void *)&c);
if (result)
break;
}
return result;
}
extern (C) int _aApplydc2(dchar[] aa, dg2_t dg)
{ int result;
size_t i;
size_t len = aa.length;
debug(apply) printf("_aApplydc2(), len = %d\n", len);
for (i = 0; i < len; i++)
{ dchar d;
char c;
d = aa[i];
debug(apply) printf("d = %u\n", d);
if (d & ~0x7F)
{
char[4] buf;
auto b = toUTF8(buf, d);
foreach (char c2; b)
{
debug(apply) printf("c2 = %d\n", c2);
result = dg(&i, cast(void *)&c2);
if (result)
return result;
}
continue;
}
else
{ c = cast(char)d;
}
result = dg(&i, cast(void *)&c);
if (result)
break;
}
return result;
}
extern (C) int _aApplydw2(dchar[] aa, dg2_t dg)
{ int result;
debug(apply) printf("_aApplydw2(), len = %d\n", aa.length);
foreach (size_t i, dchar d; aa)
{
wchar w;
auto j = i;
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
result = dg(&j, cast(void *)&w);
if (result)
break;
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
}
result = dg(&j, cast(void *)&w);
if (result)
break;
}
return result;
}

975
runtime/internal/aApplyR.d
View File

@@ -1,975 +0,0 @@
/**
* Part of the D programming language runtime library.
*/
/*
* Copyright (C) 2004-2006 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
*/
/* This code handles decoding UTF strings for foreach_reverse loops.
* There are 6 combinations of conversions between char, wchar,
* and dchar, and 2 of each of those.
*/
private import util.utf;
/**********************************************/
/* 1 argument versions */
// dg is D, but _aApplyRcd() is C
extern (D) typedef int delegate(void *) dg_t;
extern (C) int _aApplyRcd1(in char[] aa, dg_t dg)
{ int result;
debug(apply) printf("_aApplyRcd1(), len = %d\n", aa.length);
for (size_t i = aa.length; i != 0; )
{ dchar d;
i--;
d = aa[i];
if (d & 0x80)
{ char c = cast(char)d;
uint j;
uint m = 0x3F;
d = 0;
while ((c & 0xC0) != 0xC0)
{ if (i == 0)
onUnicodeError("Invalid UTF-8 sequence", 0);
i--;
d |= (c & 0x3F) << j;
j += 6;
m >>= 1;
c = aa[i];
}
d |= (c & m) << j;
}
result = dg(cast(void *)&d);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRcd1.unittest\n");
char[] s = "hello"c;
int i;
foreach_reverse(dchar d; s)
{
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(dchar d; s)
{
//printf("i = %d, d = %x\n", i, d);
switch (i)
{
case 0: assert(d == 'b'); break;
case 1: assert(d == '\U00100456'); break;
case 2: assert(d == '\u1234'); break;
case 3: assert(d == 'a'); break;
default: assert(0);
}
i++;
}
assert(i == 4);
}
/*****************************/
extern (C) int _aApplyRwd1(in wchar[] aa, dg_t dg)
{ int result;
debug(apply) printf("_aApplyRwd1(), len = %d\n", aa.length);
for (size_t i = aa.length; i != 0; )
{ dchar d;
i--;
d = aa[i];
if (d >= 0xDC00 && d <= 0xDFFF)
{ if (i == 0)
onUnicodeError("Invalid UTF-16 sequence", 0);
i--;
d = ((aa[i] - 0xD7C0) << 10) + (d - 0xDC00);
}
result = dg(cast(void *)&d);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRwd1.unittest\n");
wchar[] s = "hello"w;
int i;
foreach_reverse(dchar d; s)
{
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(dchar d; s)
{
//printf("i = %d, d = %x\n", i, d);
switch (i)
{
case 0: assert(d == 'b'); break;
case 1: assert(d == '\U00100456'); break;
case 2: assert(d == '\u1234'); break;
case 3: assert(d == 'a'); break;
default: assert(0);
}
i++;
}
assert(i == 4);
}
/*****************************/
extern (C) int _aApplyRcw1(in char[] aa, dg_t dg)
{ int result;
debug(apply) printf("_aApplyRcw1(), len = %d\n", aa.length);
for (size_t i = aa.length; i != 0; )
{ dchar d;
wchar w;
i--;
w = aa[i];
if (w & 0x80)
{ char c = cast(char)w;
uint j;
uint m = 0x3F;
d = 0;
while ((c & 0xC0) != 0xC0)
{ if (i == 0)
onUnicodeError("Invalid UTF-8 sequence", 0);
i--;
d |= (c & 0x3F) << j;
j += 6;
m >>= 1;
c = aa[i];
}
d |= (c & m) << j;
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
result = dg(cast(void *)&w);
if (result)
break;
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
}
}
result = dg(cast(void *)&w);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRcw1.unittest\n");
char[] s = "hello"c;
int i;
foreach_reverse(wchar d; s)
{
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(wchar d; s)
{
//printf("i = %d, d = %x\n", i, d);
switch (i)
{
case 0: assert(d == 'b'); break;
case 1: assert(d == 0xDBC1); break;
case 2: assert(d == 0xDC56); break;
case 3: assert(d == 0x1234); break;
case 4: assert(d == 'a'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
}
/*****************************/
extern (C) int _aApplyRwc1(in wchar[] aa, dg_t dg)
{ int result;
debug(apply) printf("_aApplyRwc1(), len = %d\n", aa.length);
for (size_t i = aa.length; i != 0; )
{ dchar d;
char c;
i--;
d = aa[i];
if (d >= 0xDC00 && d <= 0xDFFF)
{ if (i == 0)
onUnicodeError("Invalid UTF-16 sequence", 0);
i--;
d = ((aa[i] - 0xD7C0) << 10) + (d - 0xDC00);
}
if (d & ~0x7F)
{
char[4] buf;
auto b = toUTF8(buf, d);
foreach (char c2; b)
{
result = dg(cast(void *)&c2);
if (result)
return result;
}
continue;
}
c = cast(char)d;
result = dg(cast(void *)&c);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRwc1.unittest\n");
wchar[] s = "hello"w;
int i;
foreach_reverse(char d; s)
{
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(char d; s)
{
//printf("i = %d, d = %x\n", i, d);
switch (i)
{
case 0: assert(d == 'b'); break;
case 1: assert(d == 0xF4); break;
case 2: assert(d == 0x80); break;
case 3: assert(d == 0x91); break;
case 4: assert(d == 0x96); break;
case 5: assert(d == 0xE1); break;
case 6: assert(d == 0x88); break;
case 7: assert(d == 0xB4); break;
case 8: assert(d == 'a'); break;
default: assert(0);
}
i++;
}
assert(i == 9);
}
/*****************************/
extern (C) int _aApplyRdc1(in dchar[] aa, dg_t dg)
{ int result;
debug(apply) printf("_aApplyRdc1(), len = %d\n", aa.length);
for (size_t i = aa.length; i != 0;)
{ dchar d = aa[--i];
char c;
if (d & ~0x7F)
{
char[4] buf;
auto b = toUTF8(buf, d);
foreach (char c2; b)
{
result = dg(cast(void *)&c2);
if (result)
return result;
}
continue;
}
else
{
c = cast(char)d;
}
result = dg(cast(void *)&c);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRdc1.unittest\n");
dchar[] s = "hello"d;
int i;
foreach_reverse(char d; s)
{
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(char d; s)
{
//printf("i = %d, d = %x\n", i, d);
switch (i)
{
case 0: assert(d == 'b'); break;
case 1: assert(d == 0xF4); break;
case 2: assert(d == 0x80); break;
case 3: assert(d == 0x91); break;
case 4: assert(d == 0x96); break;
case 5: assert(d == 0xE1); break;
case 6: assert(d == 0x88); break;
case 7: assert(d == 0xB4); break;
case 8: assert(d == 'a'); break;
default: assert(0);
}
i++;
}
assert(i == 9);
}
/*****************************/
extern (C) int _aApplyRdw1(in dchar[] aa, dg_t dg)
{ int result;
debug(apply) printf("_aApplyRdw1(), len = %d\n", aa.length);
for (size_t i = aa.length; i != 0; )
{ dchar d = aa[--i];
wchar w;
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
result = dg(cast(void *)&w);
if (result)
break;
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
}
result = dg(cast(void *)&w);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRdw1.unittest\n");
dchar[] s = "hello"d;
int i;
foreach_reverse(wchar d; s)
{
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(wchar d; s)
{
//printf("i = %d, d = %x\n", i, d);
switch (i)
{
case 0: assert(d == 'b'); break;
case 1: assert(d == 0xDBC1); break;
case 2: assert(d == 0xDC56); break;
case 3: assert(d == 0x1234); break;
case 4: assert(d == 'a'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
}
/****************************************************************************/
/* 2 argument versions */
// dg is D, but _aApplyRcd2() is C
extern (D) typedef int delegate(void *, void *) dg2_t;
extern (C) int _aApplyRcd2(in char[] aa, dg2_t dg)
{ int result;
size_t i;
size_t len = aa.length;
debug(apply) printf("_aApplyRcd2(), len = %d\n", len);
for (i = len; i != 0; )
{ dchar d;
i--;
d = aa[i];
if (d & 0x80)
{ char c = cast(char)d;
uint j;
uint m = 0x3F;
d = 0;
while ((c & 0xC0) != 0xC0)
{ if (i == 0)
onUnicodeError("Invalid UTF-8 sequence", 0);
i--;
d |= (c & 0x3F) << j;
j += 6;
m >>= 1;
c = aa[i];
}
d |= (c & m) << j;
}
result = dg(&i, cast(void *)&d);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRcd2.unittest\n");
char[] s = "hello"c;
int i;
foreach_reverse(k, dchar d; s)
{
assert(k == 4 - i);
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(k, dchar d; s)
{
//printf("i = %d, k = %d, d = %x\n", i, k, d);
switch (i)
{
case 0: assert(d == 'b'); assert(k == 8); break;
case 1: assert(d == '\U00100456'); assert(k == 4); break;
case 2: assert(d == '\u1234'); assert(k == 1); break;
case 3: assert(d == 'a'); assert(k == 0); break;
default: assert(0);
}
i++;
}
assert(i == 4);
}
/*****************************/
extern (C) int _aApplyRwd2(in wchar[] aa, dg2_t dg)
{ int result;
debug(apply) printf("_aApplyRwd2(), len = %d\n", aa.length);
for (size_t i = aa.length; i != 0; )
{ dchar d;
i--;
d = aa[i];
if (d >= 0xDC00 && d <= 0xDFFF)
{ if (i == 0)
onUnicodeError("Invalid UTF-16 sequence", 0);
i--;
d = ((aa[i] - 0xD7C0) << 10) + (d - 0xDC00);
}
result = dg(&i, cast(void *)&d);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRwd2.unittest\n");
wchar[] s = "hello"w;
int i;
foreach_reverse(k, dchar d; s)
{
//printf("i = %d, k = %d, d = %x\n", i, k, d);
assert(k == 4 - i);
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(k, dchar d; s)
{
//printf("i = %d, k = %d, d = %x\n", i, k, d);
switch (i)
{
case 0: assert(k == 4); assert(d == 'b'); break;
case 1: assert(k == 2); assert(d == '\U00100456'); break;
case 2: assert(k == 1); assert(d == '\u1234'); break;
case 3: assert(k == 0); assert(d == 'a'); break;
default: assert(0);
}
i++;
}
assert(i == 4);
}
/*****************************/
extern (C) int _aApplyRcw2(in char[] aa, dg2_t dg)
{ int result;
debug(apply) printf("_aApplyRcw2(), len = %d\n", aa.length);
for (size_t i = aa.length; i != 0; )
{ dchar d;
wchar w;
i--;
w = aa[i];
if (w & 0x80)
{ char c = cast(char)w;
uint j;
uint m = 0x3F;
d = 0;
while ((c & 0xC0) != 0xC0)
{ if (i == 0)
onUnicodeError("Invalid UTF-8 sequence", 0);
i--;
d |= (c & 0x3F) << j;
j += 6;
m >>= 1;
c = aa[i];
}
d |= (c & m) << j;
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
result = dg(&i, cast(void *)&w);
if (result)
break;
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
}
}
result = dg(&i, cast(void *)&w);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRcw2.unittest\n");
char[] s = "hello"c;
int i;
foreach_reverse(k, wchar d; s)
{
//printf("i = %d, k = %d, d = %x\n", i, k, d);
assert(k == 4 - i);
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(k, wchar d; s)
{
//printf("i = %d, k = %d, d = %x\n", i, k, d);
switch (i)
{
case 0: assert(k == 8); assert(d == 'b'); break;
case 1: assert(k == 4); assert(d == 0xDBC1); break;
case 2: assert(k == 4); assert(d == 0xDC56); break;
case 3: assert(k == 1); assert(d == 0x1234); break;
case 4: assert(k == 0); assert(d == 'a'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
}
/*****************************/
extern (C) int _aApplyRwc2(in wchar[] aa, dg2_t dg)
{ int result;
debug(apply) printf("_aApplyRwc2(), len = %d\n", aa.length);
for (size_t i = aa.length; i != 0; )
{ dchar d;
char c;
i--;
d = aa[i];
if (d >= 0xDC00 && d <= 0xDFFF)
{ if (i == 0)
onUnicodeError("Invalid UTF-16 sequence", 0);
i--;
d = ((aa[i] - 0xD7C0) << 10) + (d - 0xDC00);
}
if (d & ~0x7F)
{
char[4] buf;
auto b = toUTF8(buf, d);
foreach (char c2; b)
{
result = dg(&i, cast(void *)&c2);
if (result)
return result;
}
continue;
}
c = cast(char)d;
result = dg(&i, cast(void *)&c);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRwc2.unittest\n");
wchar[] s = "hello"w;
int i;
foreach_reverse(k, char d; s)
{
//printf("i = %d, k = %d, d = %x\n", i, k, d);
assert(k == 4 - i);
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(k, char d; s)
{
//printf("i = %d, k = %d, d = %x\n", i, k, d);
switch (i)
{
case 0: assert(k == 4); assert(d == 'b'); break;
case 1: assert(k == 2); assert(d == 0xF4); break;
case 2: assert(k == 2); assert(d == 0x80); break;
case 3: assert(k == 2); assert(d == 0x91); break;
case 4: assert(k == 2); assert(d == 0x96); break;
case 5: assert(k == 1); assert(d == 0xE1); break;
case 6: assert(k == 1); assert(d == 0x88); break;
case 7: assert(k == 1); assert(d == 0xB4); break;
case 8: assert(k == 0); assert(d == 'a'); break;
default: assert(0);
}
i++;
}
assert(i == 9);
}
/*****************************/
extern (C) int _aApplyRdc2(in dchar[] aa, dg2_t dg)
{ int result;
debug(apply) printf("_aApplyRdc2(), len = %d\n", aa.length);
for (size_t i = aa.length; i != 0; )
{ dchar d = aa[--i];
char c;
if (d & ~0x7F)
{
char[4] buf;
auto b = toUTF8(buf, d);
foreach (char c2; b)
{
result = dg(&i, cast(void *)&c2);
if (result)
return result;
}
continue;
}
else
{ c = cast(char)d;
}
result = dg(&i, cast(void *)&c);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRdc2.unittest\n");
dchar[] s = "hello"d;
int i;
foreach_reverse(k, char d; s)
{
//printf("i = %d, k = %d, d = %x\n", i, k, d);
assert(k == 4 - i);
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(k, char d; s)
{
//printf("i = %d, k = %d, d = %x\n", i, k, d);
switch (i)
{
case 0: assert(k == 3); assert(d == 'b'); break;
case 1: assert(k == 2); assert(d == 0xF4); break;
case 2: assert(k == 2); assert(d == 0x80); break;
case 3: assert(k == 2); assert(d == 0x91); break;
case 4: assert(k == 2); assert(d == 0x96); break;
case 5: assert(k == 1); assert(d == 0xE1); break;
case 6: assert(k == 1); assert(d == 0x88); break;
case 7: assert(k == 1); assert(d == 0xB4); break;
case 8: assert(k == 0); assert(d == 'a'); break;
default: assert(0);
}
i++;
}
assert(i == 9);
}
/*****************************/
extern (C) int _aApplyRdw2(in dchar[] aa, dg2_t dg)
{ int result;
debug(apply) printf("_aApplyRdw2(), len = %d\n", aa.length);
for (size_t i = aa.length; i != 0; )
{ dchar d = aa[--i];
wchar w;
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
result = dg(&i, cast(void *)&w);
if (result)
break;
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
}
result = dg(&i, cast(void *)&w);
if (result)
break;
}
return result;
}
unittest
{
debug(apply) printf("_aApplyRdw2.unittest\n");
dchar[] s = "hello"d;
int i;
foreach_reverse(k, wchar d; s)
{
//printf("i = %d, k = %d, d = %x\n", i, k, d);
assert(k == 4 - i);
switch (i)
{
case 0: assert(d == 'o'); break;
case 1: assert(d == 'l'); break;
case 2: assert(d == 'l'); break;
case 3: assert(d == 'e'); break;
case 4: assert(d == 'h'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
s = "a\u1234\U00100456b";
i = 0;
foreach_reverse(k, wchar d; s)
{
//printf("i = %d, k = %d, d = %x\n", i, k, d);
switch (i)
{
case 0: assert(k == 3); assert(d == 'b'); break;
case 1: assert(k == 2); assert(d == 0xDBC1); break;
case 2: assert(k == 2); assert(d == 0xDC56); break;
case 3: assert(k == 1); assert(d == 0x1234); break;
case 4: assert(k == 0); assert(d == 'a'); break;
default: assert(0);
}
i++;
}
assert(i == 5);
}

798
runtime/internal/aaA.d
View File

@@ -1,798 +0,0 @@
//_ aaA.d
/**
* Part of the D programming language runtime library.
* Implementation of associative arrays.
*/
/*
* Copyright (C) 2000-2008 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
* Modified by Tomas Lindquist Olsen <tomas@famolsen.dk> for use with LDC.
*/
private
{
import tango.stdc.stdarg;
import tango.stdc.string;
enum BlkAttr : uint
{
FINALIZE = 0b0000_0001,
NO_SCAN = 0b0000_0010,
NO_MOVE = 0b0000_0100,
ALL_BITS = 0b1111_1111
}
extern (C) void* gc_malloc( size_t sz, uint ba = 0 );
extern (C) void* gc_calloc( size_t sz, uint ba = 0 );
extern (C) void gc_free( void* p );
}
// Auto-rehash and pre-allocate - Dave Fladebo
static size_t[] prime_list = [
97UL, 389UL,
1_543UL, 6_151UL,
24_593UL, 98_317UL,
393_241UL, 1_572_869UL,
6_291_469UL, 25_165_843UL,
100_663_319UL, 402_653_189UL,
1_610_612_741UL, 4_294_967_291UL,
// 8_589_934_513UL, 17_179_869_143UL
];
struct aaA
{
aaA *left;
aaA *right;
hash_t hash;
/* key */
/* value */
}
struct BB
{
aaA*[] b;
size_t nodes; // total number of aaA nodes
TypeInfo keyti; // TODO: replace this with TypeInfo_AssociativeArray when available in _aaGet()
}
/* This is the type actually seen by the programmer, although
* it is completely opaque.
*/
// LDC doesn't pass structs in registers so no need to wrap it ...
alias BB* AA;
/**********************************
* Align to next pointer boundary, so that
* GC won't be faced with misaligned pointers
* in value.
*/
size_t aligntsize(size_t tsize)
{
return (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
}
extern (C):
/*************************************************
* Invariant for aa.
*/
/+
void _aaInvAh(aaA*[] aa)
{
for (size_t i = 0; i < aa.length; i++)
{
if (aa[i])
_aaInvAh_x(aa[i]);
}
}
private int _aaCmpAh_x(aaA *e1, aaA *e2)
{ int c;
c = e1.hash - e2.hash;
if (c == 0)
{
c = e1.key.length - e2.key.length;
if (c == 0)
c = memcmp((char *)e1.key, (char *)e2.key, e1.key.length);
}
return c;
}
private void _aaInvAh_x(aaA *e)
{
hash_t key_hash;
aaA *e1;
aaA *e2;
key_hash = getHash(e.key);
assert(key_hash == e.hash);
while (1)
{ int c;
e1 = e.left;
if (e1)
{
_aaInvAh_x(e1); // ordinary recursion
do
{
c = _aaCmpAh_x(e1, e);
assert(c < 0);
e1 = e1.right;
} while (e1 != null);
}
e2 = e.right;
if (e2)
{
do
{
c = _aaCmpAh_x(e, e2);
assert(c < 0);
e2 = e2.left;
} while (e2 != null);
e = e.right; // tail recursion
}
else
break;
}
}
+/
/****************************************************
* Determine number of entries in associative array.
*/
size_t _aaLen(AA aa)
in
{
//printf("_aaLen()+\n");
//_aaInv(aa);
}
out (result)
{
size_t len = 0;
void _aaLen_x(aaA* ex)
{
auto e = ex;
len++;
while (1)
{
if (e.right)
_aaLen_x(e.right);
e = e.left;
if (!e)
break;
len++;
}
}
if (aa)
{
foreach (e; aa.b)
{
if (e)
_aaLen_x(e);
}
}
assert(len == result);
//printf("_aaLen()-\n");
}
body
{
return aa ? aa.nodes : 0;
}
/*************************************************
* Get pointer to value in associative array indexed by key.
* Add entry for key if it is not already there.
*/
void* _aaGet(AA* aa_arg, TypeInfo keyti, size_t valuesize, void* pkey)
in
{
assert(aa_arg);
}
out (result)
{
assert(result);
assert(*aa_arg);
assert((*aa_arg).b.length);
//assert(_aaInAh(*aa, key));
}
body
{
//auto pkey = cast(void *)(&valuesize + 1);
size_t i;
aaA *e;
auto keysize = aligntsize(keyti.tsize());
if (!*aa_arg)
*aa_arg = new BB();
auto aa = *aa_arg;
aa.keyti = keyti;
if (!aa.b.length)
{
alias aaA *pa;
auto len = prime_list[0];
aa.b = new pa[len];
}
auto key_hash = keyti.getHash(pkey);
//printf("hash = %d\n", key_hash);
i = key_hash % aa.b.length;
auto pe = &aa.b[i];
while ((e = *pe) !is null)
{
if (key_hash == e.hash)
{
auto c = keyti.compare(pkey, e + 1);
if (c == 0)
goto Lret;
pe = (c < 0) ? &e.left : &e.right;
}
else
pe = (key_hash < e.hash) ? &e.left : &e.right;
}
// Not found, create new elem
//printf("create new one\n");
size_t size = aaA.sizeof + keysize + valuesize;
e = cast(aaA *) gc_calloc(size);
memcpy(e + 1, pkey, keysize);
e.hash = key_hash;
*pe = e;
auto nodes = ++aa.nodes;
//printf("length = %d, nodes = %d\n", (*aa).length, nodes);
if (nodes > aa.b.length * 4)
{
_aaRehash(aa_arg,keyti);
}
Lret:
return cast(void *)(e + 1) + keysize;
}
/*************************************************
* Get pointer to value in associative array indexed by key.
* Returns null if it is not already there.
* Used for both "aa[key]" and "key in aa"
* Returns:
* null not in aa
* !=null in aa, return pointer to value
*/
void* _aaIn(AA aa, TypeInfo keyti, void *pkey)
in
{
}
out (result)
{
//assert(result == 0 || result == 1);
}
body
{
if (aa)
{
//auto pkey = cast(void *)(&keyti + 1);
//printf("_aaIn(), .length = %d, .ptr = %x\n", aa.length, cast(uint)aa.ptr);
auto len = aa.b.length;
if (len)
{
auto key_hash = keyti.getHash(pkey);
//printf("hash = %d\n", key_hash);
size_t i = key_hash % len;
auto e = aa.b[i];
while (e !is null)
{
if (key_hash == e.hash)
{
auto c = keyti.compare(pkey, e + 1);
if (c == 0)
return cast(void *)(e + 1) + aligntsize(keyti.tsize());
e = (c < 0) ? e.left : e.right;
}
else
e = (key_hash < e.hash) ? e.left : e.right;
}
}
}
// Not found
return null;
}
/*************************************************
* Delete key entry in aa[].
* If key is not in aa[], do nothing.
*/
void _aaDel(AA aa, TypeInfo keyti, void *pkey)
{
//auto pkey = cast(void *)(&keyti + 1);
aaA *e;
if (aa && aa.b.length)
{
auto key_hash = keyti.getHash(pkey);
//printf("hash = %d\n", key_hash);
size_t i = key_hash % aa.b.length;
auto pe = &aa.b[i];
while ((e = *pe) !is null) // null means not found
{
if (key_hash == e.hash)
{
auto c = keyti.compare(pkey, e + 1);
if (c == 0)
{
if (!e.left && !e.right)
{
*pe = null;
}
else if (e.left && !e.right)
{
*pe = e.left;
e.left = null;
}
else if (!e.left && e.right)
{
*pe = e.right;
e.right = null;
}
else
{
*pe = e.left;
e.left = null;
do
pe = &(*pe).right;
while (*pe);
*pe = e.right;
e.right = null;
}
aa.nodes--;
gc_free(e);
break;
}
pe = (c < 0) ? &e.left : &e.right;
}
else
pe = (key_hash < e.hash) ? &e.left : &e.right;
}
}
}
/********************************************
* Produce array of values from aa.
* The actual type is painted on the return value by the frontend
* This means the returned length should be the number of elements
*/
void[] _aaValues(AA aa, size_t keysize, size_t valuesize)
in
{
assert(keysize == aligntsize(keysize));
}
body
{
size_t resi;
void[] a;
void _aaValues_x(aaA* e)
{
do
{
memcpy(a.ptr + resi * valuesize,
cast(byte*)e + aaA.sizeof + keysize,
valuesize);
resi++;
if (e.left)
{ if (!e.right)
{ e = e.left;
continue;
}
_aaValues_x(e.left);
}
e = e.right;
} while (e !is null);
}
if (aa)
{
auto len = _aaLen(aa);
auto ptr = cast(byte*) gc_malloc(len * valuesize,
valuesize < (void*).sizeof ? BlkAttr.NO_SCAN : 0);
a = ptr[0 .. len];
resi = 0;
foreach (e; aa.b)
{
if (e)
_aaValues_x(e);
}
assert(resi == a.length);
}
return a;
}
/********************************************
* Rehash an array.
*/
void* _aaRehash(AA* paa, TypeInfo keyti)
in
{
//_aaInvAh(paa);
}
out (result)
{
//_aaInvAh(result);
}
body
{
BB newb;
void _aaRehash_x(aaA* olde)
{
while (1)
{
auto left = olde.left;
auto right = olde.right;
olde.left = null;
olde.right = null;
aaA *e;
//printf("rehash %p\n", olde);
auto key_hash = olde.hash;
size_t i = key_hash % newb.b.length;
auto pe = &newb.b[i];
while ((e = *pe) !is null)
{
//printf("\te = %p, e.left = %p, e.right = %p\n", e, e.left, e.right);
assert(e.left != e);
assert(e.right != e);
if (key_hash == e.hash)
{
auto c = keyti.compare(olde + 1, e + 1);
assert(c != 0);
pe = (c < 0) ? &e.left : &e.right;
}
else
pe = (key_hash < e.hash) ? &e.left : &e.right;
}
*pe = olde;
if (right)
{
if (!left)
{ olde = right;
continue;
}
_aaRehash_x(right);
}
if (!left)
break;
olde = left;
}
}
//printf("Rehash\n");
if (*paa)
{
auto aa = *paa;
auto len = _aaLen(aa);
if (len)
{ size_t i;
for (i = 0; i < prime_list.length - 1; i++)
{
if (len <= prime_list[i])
break;
}
len = prime_list[i];
newb.b = new aaA*[len];
newb.keyti = keyti;
foreach (e; aa.b)
{
if (e)
_aaRehash_x(e);
}
newb.nodes = (*aa).nodes;
}
**paa = newb;
}
return *paa;
}
/********************************************
* Produce array of N byte keys from aa.
* The actual type is painted on the return value by the frontend
* This means the returned length should be the number of elements
*/
void[] _aaKeys(AA aa, size_t keysize)
{
byte[] res;
size_t resi;
void _aaKeys_x(aaA* e)
{
do
{
memcpy(&res[resi * keysize], cast(byte*)(e + 1), keysize);
resi++;
if (e.left)
{ if (!e.right)
{ e = e.left;
continue;
}
_aaKeys_x(e.left);
}
e = e.right;
} while (e !is null);
}
auto len = _aaLen(aa);
if (!len)
return null;
res = (cast(byte*) gc_malloc(len * keysize,
!(aa.keyti.flags() & 1) ? BlkAttr.NO_SCAN : 0)) [0 .. len * keysize];
resi = 0;
foreach (e; aa.b)
{
if (e)
_aaKeys_x(e);
}
assert(resi == len);
return res.ptr[0 .. len];
}
/**********************************************
* 'apply' for associative arrays - to support foreach
*/
// dg is D, but _aaApply() is C
extern (D) typedef int delegate(void *) dg_t;
int _aaApply(AA aa, size_t keysize, dg_t dg)
in
{
assert(aligntsize(keysize) == keysize);
}
body
{ int result;
//printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa, keysize, dg);
int treewalker(aaA* e)
{ int result;
do
{
//printf("treewalker(e = %p, dg = x%llx)\n", e, dg);
result = dg(cast(void *)(e + 1) + keysize);
if (result)
break;
if (e.right)
{ if (!e.left)
{
e = e.right;
continue;
}
result = treewalker(e.right);
if (result)
break;
}
e = e.left;
} while (e);
return result;
}
if (aa)
{
foreach (e; aa.b)
{
if (e)
{
result = treewalker(e);
if (result)
break;
}
}
}
return result;
}
// dg is D, but _aaApply2() is C
extern (D) typedef int delegate(void *, void *) dg2_t;
int _aaApply2(AA aa, size_t keysize, dg2_t dg)
in
{
assert(aligntsize(keysize) == keysize);
}
body
{ int result;
//printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa, keysize, dg);
int treewalker(aaA* e)
{ int result;
do
{
//printf("treewalker(e = %p, dg = x%llx)\n", e, dg);
result = dg(cast(void *)(e + 1), cast(void *)(e + 1) + keysize);
if (result)
break;
if (e.right)
{ if (!e.left)
{
e = e.right;
continue;
}
result = treewalker(e.right);
if (result)
break;
}
e = e.left;
} while (e);
return result;
}
if (aa)
{
foreach (e; aa.b)
{
if (e)
{
result = treewalker(e);
if (result)
break;
}
}
}
return result;
}
int _aaEq(AA aa, AA ab, TypeInfo_AssociativeArray ti)
{
return ti.equals(&aa, &ab);
}
/***********************************
* Construct an associative array of type ti from
* length pairs of key/value pairs.
*/
/+
extern (C)
BB* _d_assocarrayliteralT(TypeInfo_AssociativeArray ti, size_t length, ...)
{
auto valuesize = ti.next.tsize(); // value size
auto keyti = ti.key;
auto keysize = keyti.tsize(); // key size
BB* result;
//printf("_d_assocarrayliteralT(keysize = %d, valuesize = %d, length = %d)\n", keysize, valuesize, length);
//printf("tivalue = %.*s\n", ti.next.classinfo.name);
if (length == 0 || valuesize == 0 || keysize == 0)
{
;
}
else
{
va_list q;
va_start!(size_t)(q, length);
result = new BB();
size_t i;
for (i = 0; i < prime_list.length - 1; i++)
{
if (length <= prime_list[i])
break;
}
auto len = prime_list[i];
result.b = new aaA*[len];
size_t keystacksize = (keysize + int.sizeof - 1) & ~(int.sizeof - 1);
size_t valuestacksize = (valuesize + int.sizeof - 1) & ~(int.sizeof - 1);
size_t keytsize = aligntsize(keysize);
for (size_t j = 0; j < length; j++)
{ void* pkey = q;
q += keystacksize;
void* pvalue = q;
q += valuestacksize;
aaA* e;
auto key_hash = keyti.getHash(pkey);
//printf("hash = %d\n", key_hash);
i = key_hash % len;
auto pe = &result.b[i];
while (1)
{
e = *pe;
if (!e)
{
// Not found, create new elem
//printf("create new one\n");
e = cast(aaA *) cast(void*) new void[aaA.sizeof + keytsize + valuesize];
memcpy(e + 1, pkey, keysize);
e.hash = key_hash;
*pe = e;
result.nodes++;
break;
}
if (key_hash == e.hash)
{
auto c = keyti.compare(pkey, e + 1);
if (c == 0)
break;
pe = (c < 0) ? &e.left : &e.right;
}
else
pe = (key_hash < e.hash) ? &e.left : &e.right;
}
memcpy(cast(void *)(e + 1) + keytsize, pvalue, valuesize);
}
va_end(q);
}
return result;
}
+/

610
runtime/internal/adi.d
View File

@@ -1,610 +0,0 @@
//_ adi.d
/**
* Part of the D programming language runtime library.
* Dynamic array property support routines
*/
/*
* Copyright (C) 2000-2006 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
*/
//debug=adi; // uncomment to turn on debugging printf's
private
{
import tango.stdc.string;
import tango.stdc.stdlib;
import util.utf;
enum BlkAttr : uint
{
FINALIZE = 0b0000_0001,
NO_SCAN = 0b0000_0010,
NO_MOVE = 0b0000_0100,
ALL_BITS = 0b1111_1111
}
extern (C) void* gc_malloc( size_t sz, uint ba = 0 );
extern (C) void* gc_calloc( size_t sz, uint ba = 0 );
extern (C) void gc_free( void* p );
}
/**********************************************
* Reverse array of chars.
* Handled separately because embedded multibyte encodings should not be
* reversed.
*/
extern (C) char[] _adReverseChar(char[] a)
{
bool hadErrors = false;
if (a.length > 1)
{
char[6] tmp;
char[6] tmplo;
char* lo = a.ptr;
char* hi = &a[length - 1];
while (lo < hi)
{ auto clo = *lo;
auto chi = *hi;
debug(adi) printf("lo = %d, hi = %d\n", lo, hi);
if (clo <= 0x7F && chi <= 0x7F)
{
debug(adi) printf("\tascii\n");
*lo = chi;
*hi = clo;
lo++;
hi--;
continue;
}
uint stridelo = UTF8stride[clo];
if (stridelo > 6) { // invalid UTF-8 0xFF
stridelo = 1;
hadErrors=true;
}
uint stridehi = 1;
while ((chi & 0xC0) == 0x80 && hi >= lo)
{
chi = *--hi;
stridehi++;
}
if (lo >= hi) {
if (lo > hi) {
hadErrors = true;
}
break;
}
if (stridehi > 6) {
hadErrors = true;
stridehi = 6;
}
debug(adi) printf("\tstridelo = %d, stridehi = %d\n", stridelo, stridehi);
if (stridelo == stridehi)
{
memcpy(tmp.ptr, lo, stridelo);
memcpy(lo, hi, stridelo);
memcpy(hi, tmp.ptr, stridelo);
lo += stridelo;
hi--;
continue;
}
/* Shift the whole array. This is woefully inefficient
*/
memcpy(tmp.ptr, hi, stridehi);
memcpy(tmplo.ptr, lo, stridelo);
memmove(lo + stridehi, lo + stridelo , cast(size_t)(hi - lo) - stridelo);
memcpy(lo, tmp.ptr, stridehi);
memcpy(hi + stridehi - stridelo, tmplo.ptr, stridelo);
lo += stridehi;
hi = hi - 1 + (stridehi - stridelo);
}
}
if (hadErrors)
throw new Exception("invalid UTF-8 sequence",__FILE__,__LINE__);
return a;
}
unittest
{
char[] a = "abcd"c;
char[] r = a.dup.reverse;
//writefln(r);
assert(r == "dcba");
a = "a\u1235\u1234c";
//writefln(a);
r = a.dup.reverse;
//writefln(r);
assert(r == "c\u1234\u1235a");
a = "ab\u1234c";
//writefln(a);
r = a.dup.reverse;
//writefln(r);
assert(r == "c\u1234ba");
a = "\u3026\u2021\u3061\n";
r = a.dup.reverse;
assert(r == "\n\u3061\u2021\u3026");
}
/**********************************************
* Reverse array of wchars.
* Handled separately because embedded multiword encodings should not be
* reversed.
*/
extern (C) wchar[] _adReverseWchar(wchar[] a)
{
bool hadErrors = false;
if (a.length > 1)
{
wchar[2] tmp;
wchar* lo = a.ptr;
wchar* hi = &a[length - 1];
while (lo < hi)
{ auto clo = *lo;
auto chi = *hi;
if ((clo < 0xD800 || clo > 0xDFFF) &&
(chi < 0xD800 || chi > 0xDFFF))
{
*lo = chi;
*hi = clo;
lo++;
hi--;
continue;
}
int stridelo = 1 + (clo >= 0xD800 && clo <= 0xDBFF);
int stridehi = 1;
if (chi >= 0xDC00 && chi <= 0xDFFF)
{
chi = *--hi;
stridehi++;
}
if (lo >= hi) {
if (lo > hi) {
hadErrors = true;
}
break;
}
if (stridelo == stridehi)
{ int stmp;
assert(stridelo == 2);
assert(stmp.sizeof == 2 * (*lo).sizeof);
stmp = *cast(int*)lo;
*cast(int*)lo = *cast(int*)hi;
*cast(int*)hi = stmp;
lo += stridelo;
hi--;
continue;
}
/* Shift the whole array. This is woefully inefficient
*/
memcpy(tmp.ptr, hi, stridehi * wchar.sizeof);
memcpy(hi + stridehi - stridelo, lo, stridelo * wchar.sizeof);
memmove(lo + stridehi, lo + stridelo , (hi - (lo + stridelo)) * wchar.sizeof);
memcpy(lo, tmp.ptr, stridehi * wchar.sizeof);
lo += stridehi;
hi = hi - 1 + (stridehi - stridelo);
}
}
if (hadErrors)
throw new Exception("invalid UTF-8 sequence",__FILE__,__LINE__);
return a;
}
unittest
{
wchar[] a = "abcd";
wchar[] r;
r = a.dup.reverse;
assert(r == "dcba");
a = "a\U00012356\U00012346c";
r = a.dup.reverse;
assert(r == "c\U00012346\U00012356a");
a = "ab\U00012345c";
r = a.dup.reverse;
assert(r == "c\U00012345ba");
}
/**********************************************
* Support for array.reverse property.
* The actual type is painted on the return value by the frontend
* Given and returned length are number of elements
*/
extern (C) void[] _adReverse(void[] a, size_t szelem)
out (result)
{
assert(result.ptr is a.ptr);
}
body
{
if (a.length >= 2)
{
byte* tmp;
byte[16] buffer;
void* lo = a.ptr;
void* hi = a.ptr + (a.length - 1) * szelem;
tmp = buffer.ptr;
if (szelem > 16)
{
//version (Win32)
//tmp = cast(byte*) alloca(szelem);
//else
tmp = cast(byte*) gc_malloc(szelem);
}
for (; lo < hi; lo += szelem, hi -= szelem)
{
memcpy(tmp, lo, szelem);
memcpy(lo, hi, szelem);
memcpy(hi, tmp, szelem);
}
version (Win32)
{
}
else
{
//if (szelem > 16)
// BUG: bad code is generate for delete pointer, tries
// to call delclass.
//gc_free(tmp);
}
}
return a.ptr[0 .. a.length];
}
unittest
{
debug(adi) printf("array.reverse.unittest\n");
int[] a = new int[5];
int[] b;
size_t i;
for (i = 0; i < 5; i++)
a[i] = i;
b = a.reverse;
assert(b is a);
for (i = 0; i < 5; i++)
assert(a[i] == 4 - i);
struct X20
{ // More than 16 bytes in size
int a;
int b, c, d, e;
}
X20[] c = new X20[5];
X20[] d;
for (i = 0; i < 5; i++)
{ c[i].a = i;
c[i].e = 10;
}
d = c.reverse;
assert(d is c);
for (i = 0; i < 5; i++)
{
assert(c[i].a == 4 - i);
assert(c[i].e == 10);
}
}
/**********************************************
* Sort array of chars.
*/
extern (C) char[] _adSortChar(char[] a)
{
if (a.length > 1)
{
dchar[] da = toUTF32(a);
da.sort;
size_t i = 0;
foreach (dchar d; da)
{ char[4] buf;
auto t = toUTF8(buf, d);
a[i .. i + t.length] = t[];
i += t.length;
}
delete da;
}
return a;
}
/**********************************************
* Sort array of wchars.
*/
extern (C) wchar[] _adSortWchar(wchar[] a)
{
if (a.length > 1)
{
dchar[] da = toUTF32(a);
da.sort;
size_t i = 0;
foreach (dchar d; da)
{ wchar[2] buf;
auto t = toUTF16(buf, d);
a[i .. i + t.length] = t[];
i += t.length;
}
delete da;
}
return a;
}
/***************************************
* Support for array equality test.
* The actual type is painted on the return value by the frontend
* Given lengths are number of elements
*/
extern (C) int _adEq(void[] a1, void[] a2, TypeInfo ti)
{
debug(adi) printf("_adEq(a1.length = %d, a2.length = %d)\n", a1.length, a2.length);
if (a1.length != a2.length)
return 0; // not equal
else if (a1.ptr == a2.ptr)
return 1; // equal
// let typeinfo decide
return ti.equals(&a1, &a2);
}
unittest
{
debug(adi) printf("array.Eq unittest\n");
char[] a = "hello"c;
assert(a != "hel");
assert(a != "helloo");
assert(a != "betty");
assert(a == "hello");
assert(a != "hxxxx");
}
/***************************************
* Support for array compare test.
* The actual type is painted on the return value by the frontend
* Given lengths are number of elements
*/
extern (C) int _adCmp(void[] a1, void[] a2, TypeInfo ti)
{
debug(adi) printf("adCmp()\n");
if (a1.ptr == a2.ptr &&
a1.length == a2.length)
return 0;
auto len = a1.length;
if (a2.length < len)
len = a2.length;
// let typeinfo decide
return ti.compare(&a1, &a2);
}
unittest
{
debug(adi) printf("array.Cmp unittest\n");
char[] a = "hello"c;
assert(a > "hel");
assert(a >= "hel");
assert(a < "helloo");
assert(a <= "helloo");
assert(a > "betty");
assert(a >= "betty");
assert(a == "hello");
assert(a <= "hello");
assert(a >= "hello");
}
/***************************************
* Support for array compare test.
* The actual type is painted on the return value by the frontend
* Given lengths are number of elements
*/
extern (C) int _adCmpChar(void[] a1, void[] a2)
{
version(D_InlineAsm_X86)
{
//version = Asm86;
}
version (Asm86)
{
asm
{ naked ;
push EDI ;
push ESI ;
mov ESI,a1+4[4+ESP] ;
mov EDI,a2+4[4+ESP] ;
mov ECX,a1[4+ESP] ;
mov EDX,a2[4+ESP] ;
cmp ECX,EDX ;
jb GotLength ;
mov ECX,EDX ;
GotLength:
cmp ECX,4 ;
jb DoBytes ;
// Do alignment if neither is dword aligned
test ESI,3 ;
jz Aligned ;
test EDI,3 ;
jz Aligned ;
DoAlign:
mov AL,[ESI] ; //align ESI to dword bounds
mov DL,[EDI] ;
cmp AL,DL ;
jnz Unequal ;
inc ESI ;
inc EDI ;
test ESI,3 ;
lea ECX,[ECX-1] ;
jnz DoAlign ;
Aligned:
mov EAX,ECX ;
// do multiple of 4 bytes at a time
shr ECX,2 ;
jz TryOdd ;
repe ;
cmpsd ;
jnz UnequalQuad ;
TryOdd:
mov ECX,EAX ;
DoBytes:
// if still equal and not end of string, do up to 3 bytes slightly
// slower.
and ECX,3 ;
jz Equal ;
repe ;
cmpsb ;
jnz Unequal ;
Equal:
mov EAX,a1[4+ESP] ;
mov EDX,a2[4+ESP] ;
sub EAX,EDX ;
pop ESI ;
pop EDI ;
ret ;
UnequalQuad:
mov EDX,[EDI-4] ;
mov EAX,[ESI-4] ;
cmp AL,DL ;
jnz Unequal ;
cmp AH,DH ;
jnz Unequal ;
shr EAX,16 ;
shr EDX,16 ;
cmp AL,DL ;
jnz Unequal ;
cmp AH,DH ;
Unequal:
sbb EAX,EAX ;
pop ESI ;
or EAX,1 ;
pop EDI ;
ret ;
}
}
else
{
int len;
int c;
debug(adi) printf("adCmpChar()\n");
len = cast(int)a1.length;
if (a2.length < len)
len = cast(int)a2.length;
c = memcmp(cast(char *)a1.ptr, cast(char *)a2.ptr, len);
if (!c)
c = cast(int)a1.length - cast(int)a2.length;
return c;
}
}
unittest
{
debug(adi) printf("array.CmpChar unittest\n");
char[] a = "hello"c;
assert(a > "hel");
assert(a >= "hel");
assert(a < "helloo");
assert(a <= "helloo");
assert(a > "betty");
assert(a >= "betty");
assert(a == "hello");
assert(a <= "hello");
assert(a >= "hello");
}

153
runtime/internal/arrayInit.d
View File

@@ -1,153 +0,0 @@
private import ldc.intrinsics;
extern(C):
int memcmp(void*,void*,size_t);
size_t strlen(char*);
version(LLVM64)
alias llvm_memcpy_i64 llvm_memcpy;
else
alias llvm_memcpy_i32 llvm_memcpy;
// per-element array init routines
void _d_array_init_i16(ushort* a, size_t n, ushort v)
{
auto p = a;
auto end = a+n;
while (p !is end)
*p++ = v;
}
void _d_array_init_i32(uint* a, size_t n, uint v)
{
auto p = a;
auto end = a+n;
while (p !is end)
*p++ = v;
}
void _d_array_init_i64(ulong* a, size_t n, ulong v)
{
auto p = a;
auto end = a+n;
while (p !is end)
*p++ = v;
}
void _d_array_init_float(float* a, size_t n, float v)
{
auto p = a;
auto end = a+n;
while (p !is end)
*p++ = v;
}
void _d_array_init_double(double* a, size_t n, double v)
{
auto p = a;
auto end = a+n;
while (p !is end)
*p++ = v;
}
void _d_array_init_real(real* a, size_t n, real v)
{
auto p = a;
auto end = a+n;
while (p !is end)
*p++ = v;
}
void _d_array_init_cfloat(cfloat* a, size_t n, cfloat v)
{
auto p = a;
auto end = a+n;
while (p !is end)
*p++ = v;
}
void _d_array_init_cdouble(cdouble* a, size_t n, cdouble v)
{
auto p = a;
auto end = a+n;
while (p !is end)
*p++ = v;
}
void _d_array_init_creal(creal* a, size_t n, creal v)
{
auto p = a;
auto end = a+n;
while (p !is end)
*p++ = v;
}
void _d_array_init_pointer(void** a, size_t n, void* v)
{
auto p = a;
auto end = a+n;
while (p !is end)
*p++ = v;
}
void _d_array_init_mem(void* a, size_t na, void* v, size_t nv)
{
auto p = a;
auto end = a + na*nv;
while (p !is end) {
llvm_memcpy(p,v,nv,0);
p += nv;
}
}
/*
void _d_array_init(TypeInfo ti, void* a)
{
auto initializer = ti.next.init();
auto isize = initializer.length;
auto q = initializer.ptr;
if (isize == 1)
memset(p, *cast(ubyte*)q, size);
else if (isize == int.sizeof)
{
int init = *cast(int*)q;
size /= int.sizeof;
for (size_t u = 0; u < size; u++)
{
(cast(int*)p)[u] = init;
}
}
else
{
for (size_t u = 0; u < size; u += isize)
{
memcpy(p + u, q, isize);
}
}
}*/
// for array cast
size_t _d_array_cast_len(size_t len, size_t elemsz, size_t newelemsz)
{
if (newelemsz == 1) {
return len*elemsz;
}
else if ((len*elemsz) % newelemsz) {
throw new Exception("Bad array cast");
}
return (len*elemsz)/newelemsz;
}
// slice copy when assertions are enabled
void _d_array_slice_copy(void* dst, size_t dstlen, void* src, size_t srclen)
{
if (dstlen != srclen)
throw new Exception("lengths don't match for array copy");
else if (dst+dstlen <= src || src+srclen <= dst)
llvm_memcpy(dst, src, dstlen, 0);
else
throw new Exception("overlapping array copy");
}

196
runtime/internal/cast.d
View File

@@ -1,196 +0,0 @@
/*
* Copyright (C) 2004-2006 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
*/
extern (C):
//debug = PRINTF;
debug(PRINTF) int printf(char*, ...);
/******************************************
* Given a pointer:
* If it is an Object, return that Object.
* If it is an interface, return the Object implementing the interface.
* If it is null, return null.
* Else, undefined crash
*/
Object _d_toObject(void* p)
{ Object o;
debug(PRINTF) printf("toObject(%p)\n", p);
if (p)
{
o = cast(Object)p;
debug(PRINTF) printf("o = %p\n", o);
debug(PRINTF) printf("o.vtbl = %p\n", *cast(void**)p);
ClassInfo oc = o.classinfo;
debug(PRINTF) printf("oc = %p\n", oc);
Interface *pi = **cast(Interface ***)p;
debug(PRINTF) printf("pi = %p\n", pi);
/* Interface.offset lines up with ClassInfo.name.ptr,
* so we rely on pointers never being less than 64K,
* and interface vtable offsets never being greater.
*/
if (pi.offset < 0x10000)
{
debug(PRINTF) printf("\tpi.offset = %d\n", pi.offset);
o = cast(Object)(p - pi.offset);
}
}
debug(PRINTF) printf("toObject = %p\n", o);
return o;
}
/*************************************
* Attempts to cast Object o to class c.
* Returns o if successful, null if not.
*/
Object _d_interface_cast(void* p, ClassInfo c)
{ Object o;
debug(PRINTF) printf("_d_interface_cast(p = %p, c = '%.*s')\n", p, c.name.length, c.name.ptr);
if (p)
{
Interface *pi = **cast(Interface ***)p;
debug(PRINTF) printf("\tpi.offset = %d\n", pi.offset);
o = cast(Object)(p - pi.offset);
return _d_dynamic_cast(o, c);
}
debug(PRINTF) printf("_d_interface_cast = %p\n", o);
return o;
}
Object _d_dynamic_cast(Object o, ClassInfo c)
{ ClassInfo oc;
size_t offset = 0;
debug(PRINTF) printf("_d_dynamic_cast(o = %p, c = '%.*s')\n", o, c.name.length, c.name.ptr);
if (o)
{
oc = o.classinfo;
if (_d_isbaseof2(oc, c, offset))
{
debug(PRINTF) printf("\toffset = %d\n", offset);
o = cast(Object)(cast(void*)o + offset);
}
else
o = null;
}
//printf("\tresult = %p\n", o);
debug(PRINTF) printf("_d_dynamic_cast = %p\n", o);
return o;
}
int _d_isbaseof2(ClassInfo oc, ClassInfo c, ref size_t offset)
{ int i;
debug(PRINTF) printf("_d_isbaseof2(%.*s, %.*s, %ul)\n", oc.name.length, oc.name.ptr, c.name.length, c.name.ptr, offset);
if (oc is c)
return 1;
do
{
debug(PRINTF) printf("oc.interfaces.length = %ul\n", oc.interfaces.length);
if (oc.base is c)
return 1;
for (i = 0; i < oc.interfaces.length; i++)
{
ClassInfo ic;
ic = oc.interfaces[i].classinfo;
debug(PRINTF) printf("checking %.*s\n", ic.name.length, ic.name.ptr);
if (ic is c)
{ offset = cast(size_t)oc.interfaces[i].offset;
return 1;
}
}
for (i = 0; i < oc.interfaces.length; i++)
{
ClassInfo ic;
ic = oc.interfaces[i].classinfo;
if (_d_isbaseof2(ic, c, offset))
{ offset = cast(size_t)oc.interfaces[i].offset;
return 1;
}
}
oc = oc.base;
} while (oc);
return 0;
}
int _d_isbaseof(ClassInfo oc, ClassInfo c)
{ int i;
if (oc is c)
return 1;
do
{
if (oc.base is c)
return 1;
for (i = 0; i < oc.interfaces.length; i++)
{
ClassInfo ic;
ic = oc.interfaces[i].classinfo;
if (ic is c || _d_isbaseof(ic, c))
return 1;
}
oc = oc.base;
} while (oc);
return 0;
}
/*********************************
* Find the vtbl[] associated with Interface ic.
*/
void *_d_interface_vtbl(ClassInfo ic, Object o)
{ int i;
ClassInfo oc;
//printf("__d_interface_vtbl(o = %p, ic = %p)\n", o, ic);
assert(o);
oc = o.classinfo;
for (i = 0; i < oc.interfaces.length; i++)
{
ClassInfo oic;
oic = oc.interfaces[i].classinfo;
if (oic is ic)
{
return cast(void *)oc.interfaces[i].vtbl;
}
}
assert(0);
}

164
runtime/internal/critical.c
View File

@@ -1,164 +0,0 @@
/*
* Placed into the Public Domain
* written by Walter Bright, Digital Mars
* www.digitalmars.com
*/
/* ================================= Win32 ============================ */
#if _WIN32
#include <windows.h>
/******************************************
* Enter/exit critical section.
*/
/* We don't initialize critical sections unless we actually need them.
* So keep a linked list of the ones we do use, and in the static destructor
* code, walk the list and release them.
*/
typedef struct D_CRITICAL_SECTION
{
struct D_CRITICAL_SECTION *next;
CRITICAL_SECTION cs;
} D_CRITICAL_SECTION;
static D_CRITICAL_SECTION *dcs_list;
static D_CRITICAL_SECTION critical_section;
static volatile int inited;
void _d_criticalenter(D_CRITICAL_SECTION *dcs)
{
if (!dcs->next)
{
EnterCriticalSection(&critical_section.cs);
if (!dcs->next) // if, in the meantime, another thread didn't set it
{
dcs->next = dcs_list;
dcs_list = dcs;
InitializeCriticalSection(&dcs->cs);
}
LeaveCriticalSection(&critical_section.cs);
}
EnterCriticalSection(&dcs->cs);
}
void _d_criticalexit(D_CRITICAL_SECTION *dcs)
{
LeaveCriticalSection(&dcs->cs);
}
void _STI_critical_init()
{
if (!inited)
{ InitializeCriticalSection(&critical_section.cs);
dcs_list = &critical_section;
inited = 1;
}
}
void _STD_critical_term()
{
if (inited)
{ inited = 0;
while (dcs_list)
{
DeleteCriticalSection(&dcs_list->cs);
dcs_list = dcs_list->next;
}
}
}
#endif
/* ================================= linux ============================ */
#if linux || __APPLE__ || __FreeBSD__ || (defined(__SVR4) && defined (__sun))
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#if !linux
#define PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
#endif
/******************************************
* Enter/exit critical section.
*/
/* We don't initialize critical sections unless we actually need them.
* So keep a linked list of the ones we do use, and in the static destructor
* code, walk the list and release them.
*/
typedef struct D_CRITICAL_SECTION
{
struct D_CRITICAL_SECTION *next;
pthread_mutex_t cs;
} D_CRITICAL_SECTION;
static D_CRITICAL_SECTION *dcs_list;
static D_CRITICAL_SECTION critical_section;
static pthread_mutexattr_t _criticals_attr;
void _STI_critical_init(void);
void _STD_critical_term(void);
void _d_criticalenter(D_CRITICAL_SECTION *dcs)
{
if (!dcs_list)
{ _STI_critical_init();
atexit(_STD_critical_term);
}
//printf("_d_criticalenter(dcs = x%x)\n", dcs);
if (!dcs->next)
{
pthread_mutex_lock(&critical_section.cs);
if (!dcs->next) // if, in the meantime, another thread didn't set it
{
dcs->next = dcs_list;
dcs_list = dcs;
pthread_mutex_init(&dcs->cs, &_criticals_attr);
}
pthread_mutex_unlock(&critical_section.cs);
}
pthread_mutex_lock(&dcs->cs);
}
void _d_criticalexit(D_CRITICAL_SECTION *dcs)
{
//printf("_d_criticalexit(dcs = x%x)\n", dcs);
pthread_mutex_unlock(&dcs->cs);
}
void _STI_critical_init()
{
if (!dcs_list)
{ //printf("_STI_critical_init()\n");
pthread_mutexattr_init(&_criticals_attr);
pthread_mutexattr_settype(&_criticals_attr, PTHREAD_MUTEX_RECURSIVE_NP);
// The global critical section doesn't need to be recursive
pthread_mutex_init(&critical_section.cs, 0);
dcs_list = &critical_section;
}
}
void _STD_critical_term()
{
if (dcs_list)
{ //printf("_STI_critical_term()\n");
while (dcs_list)
{
//printf("\tlooping... %x\n", dcs_list);
pthread_mutex_destroy(&dcs_list->cs);
dcs_list = dcs_list->next;
}
}
}
#endif

284
runtime/internal/dmain2.d
View File

@@ -1,284 +0,0 @@
/*
* Placed into the Public Domain.
* written by Walter Bright
* www.digitalmars.com
*/
/*
* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
*/
private
{
import util.console;
import tango.stdc.stddef;
import tango.stdc.stdlib;
import tango.stdc.string;
import memory;
}
version( Win32 )
{
extern (Windows) void* LocalFree(void*);
extern (Windows) wchar_t* GetCommandLineW();
extern (Windows) wchar_t** CommandLineToArgvW(wchar_t*, int*);
extern (Windows) export int WideCharToMultiByte(uint, uint, wchar_t*, int, char*, int, char*, int);
//pragma(lib, "shell32.lib"); // needed for CommandLineToArgvW
//pragma(lib, "tango-win32-dmd.lib"); // links Tango's Win32 library to reduce EXE size
}
extern (C) void _STI_monitor_staticctor();
extern (C) void _STD_monitor_staticdtor();
extern (C) void _STI_critical_init();
extern (C) void _STD_critical_term();
extern (C) void gc_init();
extern (C) void gc_term();
extern (C) void _moduleCtor();
extern (C) void _moduleDtor();
extern (C) void thread_joinAll();
//debug=PRINTF;
debug(PRINTF) extern (C) int printf(char*, ...);
/***********************************
* These functions must be defined for any D program linked
* against this library.
*/
extern (C) void onAssertError( char[] file, size_t line );
extern (C) void onAssertErrorMsg( char[] file, size_t line, char[] msg );
extern (C) void onArrayBoundsError( char[] file, size_t line );
extern (C) void onSwitchError( char[] file, size_t line );
extern (C) bool runModuleUnitTests();
// this function is called from the utf module
//extern (C) void onUnicodeError( char[] msg, size_t idx );
/***********************************
* These are internal callbacks for various language errors.
*/
extern (C) void _d_assert( char[] file, uint line )
{
onAssertError( file, line );
}
extern (C) void _d_assert_msg( char[] msg, char[] file, uint line )
{
onAssertErrorMsg( file, line, msg );
}
extern (C) void _d_array_bounds( char[] file, uint line )
{
onArrayBoundsError( file, line );
}
extern (C) void _d_switch_error( char[] file, uint line )
{
onSwitchError( file, line );
}
bool _d_isHalting = false;
extern (C) bool rt_isHalting()
{
return _d_isHalting;
}
extern (C) bool rt_trapExceptions = true;
void _d_criticalInit()
{
_STI_monitor_staticctor();
_STI_critical_init();
initStaticDataPtrs();
}
alias void delegate( Exception ) ExceptionHandler;
// this is here so users can manually initialize the runtime
// for example, when there is no main function etc.
extern (C) bool rt_init( ExceptionHandler dg = null )
{
_d_criticalInit();
try
{
gc_init();
_moduleCtor();
return true;
}
catch( Exception e )
{
if( dg )
dg( e );
}
catch
{
}
_d_criticalTerm();
return false;
}
void _d_criticalTerm()
{
_STD_critical_term();
_STD_monitor_staticdtor();
}
// this is here so users can manually terminate the runtime
// for example, when there is no main function etc.
extern (C) bool rt_term( ExceptionHandler dg = null )
{
try
{
thread_joinAll();
_d_isHalting = true;
_moduleDtor();
gc_term();
return true;
}
catch( Exception e )
{
if( dg )
dg( e );
}
catch
{
}
finally
{
_d_criticalTerm();
}
return false;
}
/***********************************
* The D main() function supplied by the user's program
*/
int main(char[][] args);
/***********************************
* Substitutes for the C main() function.
* It's purpose is to wrap the call to the D main()
* function and catch any unhandled exceptions.
*/
extern (C) int main(int argc, char **argv, char** env)
{
char[][] args;
int result;
debug(PRINTF) printf("main ctors\n");
_STI_monitor_staticctor();
_STI_critical_init();
initStaticDataPtrs();
debug(PRINTF) printf("main args\n");
// GDC seems to get by without this Windows special case...
version (Win32)
{
wchar_t* wcbuf = GetCommandLineW();
size_t wclen = wcslen(wcbuf);
int wargc = 0;
wchar_t** wargs = CommandLineToArgvW(wcbuf, &wargc);
assert(wargc == argc);
char* cargp = null;
size_t cargl = WideCharToMultiByte(65001, 0, wcbuf, wclen, null, 0, null, 0);
cargp = cast(char*) alloca(cargl);
args = ((cast(char[]*) alloca(wargc * (char[]).sizeof)))[0 .. wargc];
for (size_t i = 0, p = 0; i < wargc; i++)
{
int wlen = wcslen( wargs[i] );
int clen = WideCharToMultiByte(65001, 0, &wargs[i][0], wlen, null, 0, null, 0);
args[i] = cargp[p .. p+clen];
p += clen; assert(p <= cargl);
WideCharToMultiByte(65001, 0, &wargs[i][0], wlen, &args[i][0], clen, null, 0);
}
LocalFree(wargs);
wargs = null;
wargc = 0;
}
else
{
char[]* am = cast(char[]*) malloc(argc * (char[]).sizeof);
scope(exit) free(am);
for (size_t i = 0; i < argc; i++)
{
auto len = strlen(argv[i]);
am[i] = argv[i][0 .. len];
}
args = am[0 .. argc];
}
debug(PRINTF) printf("main trap exceptions\n");
bool trapExceptions = rt_trapExceptions;
void tryExec(void delegate() dg)
{
debug(PRINTF) printf("main try exec\n");
if (trapExceptions)
{
try
{
dg();
}
catch (Exception e)
{
e.writeOut(delegate void(char[]s){ console(s); });
result = EXIT_FAILURE;
}
catch (Object o)
{
// fprintf(stderr, "%.*s\n", o.toString());
console (o.toString)("\n");
result = EXIT_FAILURE;
}
}
else
{
dg();
}
}
// NOTE: The lifetime of a process is much like the lifetime of an object:
// it is initialized, then used, then destroyed. If initialization
// fails, the successive two steps are never reached. However, if
// initialization succeeds, then cleanup will occur even if the use
// step fails in some way. Here, the use phase consists of running
// the user's main function. If main terminates with an exception,
// the exception is handled and then cleanup begins. An exception
// thrown during cleanup, however, will abort the cleanup process.
void runMain()
{
debug(PRINTF) printf("main runMain\n");
result = main(args);
}
void runAll()
{
debug(PRINTF) printf("main runAll\n");
gc_init();
_moduleCtor();
if (runModuleUnitTests())
tryExec(&runMain);
thread_joinAll();
_d_isHalting = true;
_moduleDtor();
gc_term();
}
tryExec(&runAll);
debug(PRINTF) printf("main dtor\n");
_STD_critical_term();
_STD_monitor_staticdtor();
return result;
}

430
runtime/internal/eh.d
View File

@@ -1,430 +0,0 @@
/**
* This module contains functions and structures required for
* exception handling.
*/
module eh;
import util.console;
import ldc.cstdarg;
// debug = EH_personality;
// debug = EH_personality_verbose;
// current EH implementation works on x86
// if it has a working unwind runtime
version(X86) {
version(linux) version=X86_UNWIND;
version(darwin) version=X86_UNWIND;
version(solaris) version=X86_UNWIND;
}
version(X86_64) {
version(linux) version=X86_UNWIND;
version(darwin) version=X86_UNWIND;
version(solaris) version=X86_UNWIND;
}
//version = HP_LIBUNWIND;
private extern(C) void abort();
private extern(C) int printf(char*, ...);
private extern(C) int vprintf(char*, va_list va);
// D runtime functions
extern(C) {
int _d_isbaseof(ClassInfo oc, ClassInfo c);
}
// libunwind headers
extern(C)
{
enum _Unwind_Reason_Code : int
{
NO_REASON = 0,
FOREIGN_EXCEPTION_CAUGHT = 1,
FATAL_PHASE2_ERROR = 2,
FATAL_PHASE1_ERROR = 3,
NORMAL_STOP = 4,
END_OF_STACK = 5,
HANDLER_FOUND = 6,
INSTALL_CONTEXT = 7,
CONTINUE_UNWIND = 8
}
enum _Unwind_Action : int
{
SEARCH_PHASE = 1,
CLEANUP_PHASE = 2,
HANDLER_FRAME = 4,
FORCE_UNWIND = 8
}
alias void* _Unwind_Context_Ptr;
alias void function(_Unwind_Reason_Code, _Unwind_Exception*) _Unwind_Exception_Cleanup_Fn;
struct _Unwind_Exception
{
ulong exception_class;
_Unwind_Exception_Cleanup_Fn exception_cleanup;
ptrdiff_t private_1;
ptrdiff_t private_2;
}
// interface to HP's libunwind from http://www.nongnu.org/libunwind/
version(HP_LIBUNWIND)
{
void __libunwind_Unwind_Resume(_Unwind_Exception *);
_Unwind_Reason_Code __libunwind_Unwind_RaiseException(_Unwind_Exception *);
ptrdiff_t __libunwind_Unwind_GetLanguageSpecificData(_Unwind_Context_Ptr
context);
ptrdiff_t __libunwind_Unwind_GetIP(_Unwind_Context_Ptr context);
ptrdiff_t __libunwind_Unwind_SetIP(_Unwind_Context_Ptr context,
ptrdiff_t new_value);
ptrdiff_t __libunwind_Unwind_SetGR(_Unwind_Context_Ptr context, int index,
ptrdiff_t new_value);
ptrdiff_t __libunwind_Unwind_GetRegionStart(_Unwind_Context_Ptr context);
alias __libunwind_Unwind_Resume _Unwind_Resume;
alias __libunwind_Unwind_RaiseException _Unwind_RaiseException;
alias __libunwind_Unwind_GetLanguageSpecificData
_Unwind_GetLanguageSpecificData;
alias __libunwind_Unwind_GetIP _Unwind_GetIP;
alias __libunwind_Unwind_SetIP _Unwind_SetIP;
alias __libunwind_Unwind_SetGR _Unwind_SetGR;
alias __libunwind_Unwind_GetRegionStart _Unwind_GetRegionStart;
}
else version(X86_UNWIND)
{
void _Unwind_Resume(_Unwind_Exception*);
_Unwind_Reason_Code _Unwind_RaiseException(_Unwind_Exception*);
ptrdiff_t _Unwind_GetLanguageSpecificData(_Unwind_Context_Ptr context);
ptrdiff_t _Unwind_GetIP(_Unwind_Context_Ptr context);
ptrdiff_t _Unwind_SetIP(_Unwind_Context_Ptr context, ptrdiff_t new_value);
ptrdiff_t _Unwind_SetGR(_Unwind_Context_Ptr context, int index,
ptrdiff_t new_value);
ptrdiff_t _Unwind_GetRegionStart(_Unwind_Context_Ptr context);
}
else
{
// runtime calls these directly
void _Unwind_Resume(_Unwind_Exception*)
{
console("_Unwind_Resume is not implemented on this platform.\n");
}
_Unwind_Reason_Code _Unwind_RaiseException(_Unwind_Exception*)
{
console("_Unwind_RaiseException is not implemented on this platform.\n");
return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
}
}
}
// error and exit
extern(C) private void fatalerror(char* format, ...)
{
va_list args;
va_start(args, format);
printf("Fatal error in EH code: ");
vprintf(format, args);
printf("\n");
abort();
}
// helpers for reading certain DWARF data
private ubyte* get_uleb128(ubyte* addr, ref size_t res)
{
res = 0;
size_t bitsize = 0;
// read as long as high bit is set
while(*addr & 0x80) {
res |= (*addr & 0x7f) << bitsize;
bitsize += 7;
addr += 1;
if(bitsize >= size_t.sizeof*8)
fatalerror("tried to read uleb128 that exceeded size of size_t");
}
// read last
if(bitsize != 0 && *addr >= 1 << size_t.sizeof*8 - bitsize)
fatalerror("Fatal error in EH code: tried to read uleb128 that exceeded size of size_t");
res |= (*addr) << bitsize;
return addr + 1;
}
private ubyte* get_sleb128(ubyte* addr, ref ptrdiff_t res)
{
res = 0;
size_t bitsize = 0;
// read as long as high bit is set
while(*addr & 0x80) {
res |= (*addr & 0x7f) << bitsize;
bitsize += 7;
addr += 1;
if(bitsize >= size_t.sizeof*8)
fatalerror("tried to read sleb128 that exceeded size of size_t");
}
// read last
if(bitsize != 0 && *addr >= 1 << size_t.sizeof*8 - bitsize)
fatalerror("tried to read sleb128 that exceeded size of size_t");
res |= (*addr) << bitsize;
// take care of sign
if(bitsize < size_t.sizeof*8 && ((*addr) & 0x40))
res |= cast(ptrdiff_t)(-1) ^ ((1 << (bitsize+7)) - 1);
return addr + 1;
}
// exception struct used by the runtime.
// _d_throw allocates a new instance and passes the address of its
// _Unwind_Exception member to the unwind call. The personality
// routine is then able to get the whole struct by looking at the data
// surrounding the unwind info.
struct _d_exception
{
Object exception_object;
_Unwind_Exception unwind_info;
}
// the 8-byte string identifying the type of exception
// the first 4 are for vendor, the second 4 for language
//TODO: This may be the wrong way around
char[8] _d_exception_class = "LLDCD1\0\0";
//
// x86 unwind specific implementation of personality function
// and helpers
//
version(X86_UNWIND)
{
// the personality routine gets called by the unwind handler and is responsible for
// reading the EH tables and deciding what to do
extern(C) _Unwind_Reason_Code _d_eh_personality(int ver, _Unwind_Action actions, ulong exception_class, _Unwind_Exception* exception_info, _Unwind_Context_Ptr context)
{
debug(EH_personality_verbose) printf("entering personality function. context: %p\n", context);
// check ver: the C++ Itanium ABI only allows ver == 1
if(ver != 1)
return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
// check exceptionClass
//TODO: Treat foreign exceptions with more respect
if((cast(char*)&exception_class)[0..8] != _d_exception_class)
return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
// find call site table, action table and classinfo table
// Note: callsite and action tables do not contain static-length
// data and will be parsed as needed
// Note: classinfo_table points past the end of the table
ubyte* callsite_table;
ubyte* action_table;
ClassInfo* classinfo_table;
_d_getLanguageSpecificTables(context, callsite_table, action_table, classinfo_table);
if (callsite_table is null)
return _Unwind_Reason_Code.CONTINUE_UNWIND;
/*
find landing pad and action table index belonging to ip by walking
the callsite_table
*/
ubyte* callsite_walker = callsite_table;
// get the instruction pointer
// will be used to find the right entry in the callsite_table
// -1 because it will point past the last instruction
ptrdiff_t ip = _Unwind_GetIP(context) - 1;
// address block_start is relative to
ptrdiff_t region_start = _Unwind_GetRegionStart(context);
// table entries
uint block_start_offset, block_size;
ptrdiff_t landing_pad;
size_t action_offset;
while(true) {
// if we've gone through the list and found nothing...
if(callsite_walker >= action_table)
return _Unwind_Reason_Code.CONTINUE_UNWIND;
block_start_offset = *cast(uint*)callsite_walker;
block_size = *(cast(uint*)callsite_walker + 1);
landing_pad = *(cast(uint*)callsite_walker + 2);
if(landing_pad)
landing_pad += region_start;
callsite_walker = get_uleb128(callsite_walker + 3*uint.sizeof, action_offset);
debug(EH_personality_verbose) printf("ip=%llx %d %d %llx\n", ip, block_start_offset, block_size, landing_pad);
// since the list is sorted, as soon as we're past the ip
// there's no handler to be found
if(ip < region_start + block_start_offset)
return _Unwind_Reason_Code.CONTINUE_UNWIND;
// if we've found our block, exit
if(ip < region_start + block_start_offset + block_size)
break;
}
debug(EH_personality) printf("Found correct landing pad and actionOffset %d\n", action_offset);
// now we need the exception's classinfo to find a handler
// the exception_info is actually a member of a larger _d_exception struct
// the runtime allocated. get that now
_d_exception* exception_struct = cast(_d_exception*)(cast(ubyte*)exception_info - _d_exception.unwind_info.offsetof);
// if there's no action offset and no landing pad, continue unwinding
if(!action_offset && !landing_pad)
return _Unwind_Reason_Code.CONTINUE_UNWIND;
// if there's no action offset but a landing pad, this is a cleanup handler
else if(!action_offset && landing_pad)
return _d_eh_install_finally_context(actions, landing_pad, exception_struct, context);
/*
walk action table chain, comparing classinfos using _d_isbaseof
*/
ubyte* action_walker = action_table + action_offset - 1;
ptrdiff_t ti_offset, next_action_offset;
while(true) {
action_walker = get_sleb128(action_walker, ti_offset);
// it is intentional that we not modify action_walker here
// next_action_offset is from current action_walker position
get_sleb128(action_walker, next_action_offset);
// negative are 'filters' which we don't use
if(!(ti_offset >= 0))
fatalerror("Filter actions are unsupported");
// zero means cleanup, which we require to be the last action
if(ti_offset == 0) {
if(!(next_action_offset == 0))
fatalerror("Cleanup action must be last in chain");
return _d_eh_install_finally_context(actions, landing_pad, exception_struct, context);
}
// get classinfo for action and check if the one in the
// exception structure is a base
ClassInfo catch_ci = *(classinfo_table - ti_offset);
debug(EH_personality) printf("Comparing catch %s to exception %s\n", catch_ci.name.ptr, exception_struct.exception_object.classinfo.name.ptr);
if(_d_isbaseof(exception_struct.exception_object.classinfo, catch_ci))
return _d_eh_install_catch_context(actions, ti_offset, landing_pad, exception_struct, context);
// we've walked through all actions and found nothing...
if(next_action_offset == 0)
return _Unwind_Reason_Code.CONTINUE_UNWIND;
else
action_walker += next_action_offset;
}
fatalerror("reached unreachable");
return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
}
// These are the register numbers for SetGR that
// llvm's eh.exception and eh.selector intrinsics
// will pick up.
// Hints for these can be found by looking at the
// EH_RETURN_DATA_REGNO macro in GCC, careful testing
// is required though.
version (X86_64)
{
private int eh_exception_regno = 0;
private int eh_selector_regno = 1;
} else {
private int eh_exception_regno = 0;
private int eh_selector_regno = 2;
}
private _Unwind_Reason_Code _d_eh_install_catch_context(_Unwind_Action actions, ptrdiff_t switchval, ptrdiff_t landing_pad, _d_exception* exception_struct, _Unwind_Context_Ptr context)
{
debug(EH_personality) printf("Found catch clause!\n");
if(actions & _Unwind_Action.SEARCH_PHASE)
return _Unwind_Reason_Code.HANDLER_FOUND;
else if(actions & _Unwind_Action.CLEANUP_PHASE)
{
debug(EH_personality) printf("Setting switch value to: %d!\n", switchval);
_Unwind_SetGR(context, eh_exception_regno, cast(ptrdiff_t)cast(void*)(exception_struct.exception_object));
_Unwind_SetGR(context, eh_selector_regno, cast(ptrdiff_t)switchval);
_Unwind_SetIP(context, landing_pad);
return _Unwind_Reason_Code.INSTALL_CONTEXT;
}
fatalerror("reached unreachable");
return _Unwind_Reason_Code.FATAL_PHASE2_ERROR;
}
private _Unwind_Reason_Code _d_eh_install_finally_context(_Unwind_Action actions, ptrdiff_t landing_pad, _d_exception* exception_struct, _Unwind_Context_Ptr context)
{
// if we're merely in search phase, continue
if(actions & _Unwind_Action.SEARCH_PHASE)
return _Unwind_Reason_Code.CONTINUE_UNWIND;
debug(EH_personality) printf("Calling cleanup routine...\n");
_Unwind_SetGR(context, eh_exception_regno, cast(ptrdiff_t)exception_struct);
_Unwind_SetGR(context, eh_selector_regno, 0);
_Unwind_SetIP(context, landing_pad);
return _Unwind_Reason_Code.INSTALL_CONTEXT;
}
private void _d_getLanguageSpecificTables(_Unwind_Context_Ptr context, ref ubyte* callsite, ref ubyte* action, ref ClassInfo* ci)
{
ubyte* data = cast(ubyte*)_Unwind_GetLanguageSpecificData(context);
if (data is null)
{
//printf("language specific data was null\n");
callsite = null;
action = null;
ci = null;
return;
}
//TODO: Do proper DWARF reading here
if(*data++ != 0xff)
fatalerror("DWARF header has unexpected format 1");
if(*data++ != 0x00)
fatalerror("DWARF header has unexpected format 2");
size_t cioffset;
data = get_uleb128(data, cioffset);
ci = cast(ClassInfo*)(data + cioffset);
if(*data++ != 0x03)
fatalerror("DWARF header has unexpected format 3");
size_t callsitelength;
data = get_uleb128(data, callsitelength);
action = data + callsitelength;
callsite = data;
}
} // end of x86 Linux specific implementation
extern(C) void _d_throw_exception(Object e)
{
if (e !is null)
{
_d_exception* exc_struct = new _d_exception;
exc_struct.unwind_info.exception_class = *cast(ulong*)_d_exception_class.ptr;
exc_struct.exception_object = e;
_Unwind_Reason_Code ret = _Unwind_RaiseException(&exc_struct.unwind_info);
console("_Unwind_RaiseException failed with reason code: ")(ret)("\n");
}
abort();
}
extern(C) void _d_eh_resume_unwind(_d_exception* exception_struct)
{
_Unwind_Resume(&exception_struct.unwind_info);
}

1465
runtime/internal/genobj.d
View File

File diff suppressed because it is too large Load Diff

28
runtime/internal/invariant.d
View File

@@ -1,28 +0,0 @@
/*
* Placed into the Public Domain
* written by Walter Bright
* www.digitalmars.com
*/
extern(C) void _d_invariant(Object o)
{ ClassInfo c;
//printf("__d_invariant(%p)\n", o);
// BUG: needs to be filename/line of caller, not library routine
assert(o !is null); // just do null check, not invariant check
c = o.classinfo;
do
{
if (c.classInvariant)
{
void delegate() inv;
inv.ptr = cast(void*) o;
inv.funcptr = c.classInvariant;
inv();
}
c = c.base;
} while (c);
}

261
runtime/internal/ldc.mak
View File

@@ -1,261 +0,0 @@
# Makefile to build the LDC compiler runtime D library for Linux
# Designed to work with GNU make
# Targets:
# make
# Same as make all
# make lib
# Build the compiler runtime library
# make doc
# Generate documentation
# make clean
# Delete unneeded files created by build process
LIB_TARGET_FULL=libldc-runtime.a
LIB_TARGET_BC_ONLY=libldc-runtime-bc-only.a
LIB_TARGET_C_ONLY=libldc-runtime-c-only.a
LIB_TARGET_SHARED=libldc-runtime-shared.so
LIB_MASK=libldc-runtime*.*
CP=cp -f
RM=rm -f
MD=mkdir -p
#CFLAGS=-O3 $(ADD_CFLAGS)
CFLAGS=$(ADD_CFLAGS)
#DFLAGS=-release -O3 -inline -w $(ADD_DFLAGS)
DFLAGS=-w $(ADD_DFLAGS)
#TFLAGS=-O3 -inline -w $(ADD_DFLAGS)
TFLAGS=-w $(ADD_DFLAGS)
DOCFLAGS=-version=DDoc
CC=gcc
LC=llvm-ar rsv
LLINK=llvm-link
LCC=llc
CLC=ar rsv
DC=ldc
LLC=llvm-as
LIB_DEST=..
.SUFFIXES: .s .S .c .cpp .d .ll .html .o .bc
.s.o:
$(CC) -c $(CFLAGS) $< -o$@
.S.o:
$(CC) -c $(CFLAGS) $< -o$@
.c.o:
$(CC) -c $(CFLAGS) $< -o$@
.cpp.o:
g++ -c $(CFLAGS) $< -o$@
.d.o:
$(DC) -c $(DFLAGS) $< -of$@ -output-bc
.d.html:
$(DC) -c -o- $(DOCFLAGS) -Df$*.html ldc.ddoc $<
targets : lib sharedlib doc
all : lib sharedlib doc
#lib : ldc.bclib ldc.clib ldc.lib
lib : ldc.clib ldc.lib
sharedlib : ldc.sharedlib
doc : ldc.doc
######################################################
OBJ_C= \
monitor.o \
critical.o
OBJ_BASE_BC= \
aaA.bc \
aApply.bc \
aApplyR.bc \
adi.bc \
arrayInit.bc \
cast.bc \
dmain2.bc \
eh.bc \
genobj.bc \
lifetime.bc \
memory.bc \
qsort2.bc \
switch.bc \
invariant.bc
OBJ_UTIL_BC= \
util/console.bc \
util/ctype.bc \
util/string.bc \
util/utf.bc
OBJ_LDC_BC= \
ldc/bitmanip.bc \
ldc/vararg.bc
OBJ_TI_BC= \
typeinfo/ti_AC.bc \
typeinfo/ti_Acdouble.bc \
typeinfo/ti_Acfloat.bc \
typeinfo/ti_Acreal.bc \
typeinfo/ti_Adouble.bc \
typeinfo/ti_Afloat.bc \
typeinfo/ti_Ag.bc \
typeinfo/ti_Aint.bc \
typeinfo/ti_Along.bc \
typeinfo/ti_Areal.bc \
typeinfo/ti_Ashort.bc \
typeinfo/ti_byte.bc \
typeinfo/ti_C.bc \
typeinfo/ti_cdouble.bc \
typeinfo/ti_cfloat.bc \
typeinfo/ti_char.bc \
typeinfo/ti_creal.bc \
typeinfo/ti_dchar.bc \
typeinfo/ti_delegate.bc \
typeinfo/ti_double.bc \
typeinfo/ti_float.bc \
typeinfo/ti_idouble.bc \
typeinfo/ti_ifloat.bc \
typeinfo/ti_int.bc \
typeinfo/ti_ireal.bc \
typeinfo/ti_long.bc \
typeinfo/ti_ptr.bc \
typeinfo/ti_real.bc \
typeinfo/ti_short.bc \
typeinfo/ti_ubyte.bc \
typeinfo/ti_uint.bc \
typeinfo/ti_ulong.bc \
typeinfo/ti_ushort.bc \
typeinfo/ti_void.bc \
typeinfo/ti_wchar.bc
OBJ_BASE_O= \
aaA.o \
aApply.o \
aApplyR.o \
adi.o \
arrayInit.o \
cast.o \
dmain2.o \
eh.o \
genobj.o \
lifetime.o \
memory.o \
qsort2.o \
switch.o \
invariant.o
OBJ_UTIL_O= \
util/console.o \
util/ctype.o \
util/string.o \
util/utf.o
OBJ_LDC_O= \
ldc/bitmanip.o \
ldc/vararg.o
OBJ_TI_O= \
typeinfo/ti_AC.o \
typeinfo/ti_Acdouble.o \
typeinfo/ti_Acfloat.o \
typeinfo/ti_Acreal.o \
typeinfo/ti_Adouble.o \
typeinfo/ti_Afloat.o \
typeinfo/ti_Ag.o \
typeinfo/ti_Aint.o \
typeinfo/ti_Along.o \
typeinfo/ti_Areal.o \
typeinfo/ti_Ashort.o \
typeinfo/ti_byte.o \
typeinfo/ti_C.o \
typeinfo/ti_cdouble.o \
typeinfo/ti_cfloat.o \
typeinfo/ti_char.o \
typeinfo/ti_creal.o \
typeinfo/ti_dchar.o \
typeinfo/ti_delegate.o \
typeinfo/ti_double.o \
typeinfo/ti_float.o \
typeinfo/ti_idouble.o \
typeinfo/ti_ifloat.o \
typeinfo/ti_int.o \
typeinfo/ti_ireal.o \
typeinfo/ti_long.o \
typeinfo/ti_ptr.o \
typeinfo/ti_real.o \
typeinfo/ti_short.o \
typeinfo/ti_ubyte.o \
typeinfo/ti_uint.o \
typeinfo/ti_ulong.o \
typeinfo/ti_ushort.o \
typeinfo/ti_void.o \
typeinfo/ti_wchar.o
ALL_OBJS_BC= \
$(OBJ_BASE_BC) \
$(OBJ_UTIL_BC) \
$(OBJ_TI_BC) \
$(OBJ_LDC_BC)
ALL_OBJS_O= \
$(OBJ_BASE_O) \
$(OBJ_UTIL_O) \
$(OBJ_TI_O) \
$(OBJ_LDC_O) \
$(OBJ_C)
######################################################
ALL_DOCS=
######################################################
#ldc.bclib : $(LIB_TARGET_BC_ONLY)
ldc.clib : $(LIB_TARGET_C_ONLY)
ldc.lib : $(LIB_TARGET_FULL)
ldc.sharedlib : $(LIB_TARGET_SHARED)
#$(LIB_TARGET_BC_ONLY) : $(ALL_OBJS_O)
# $(RM) $@
# $(LC) $@ $(ALL_OBJS_BC)
$(LIB_TARGET_FULL) : $(ALL_OBJS_O)
$(RM) $@
$(CLC) $@ $(ALL_OBJS_O)
$(LIB_TARGET_C_ONLY) : $(OBJ_C)
$(RM) $@
$(CLC) $@ $(OBJ_C)
$(LIB_TARGET_SHARED) : $(ALL_OBJS_O)
$(RM) $@
$(CC) -shared -o $@ $(ALL_OBJS_O)
ldc.doc : $(ALL_DOCS)
echo No documentation available.
######################################################
clean :
find . -name "*.di" | xargs $(RM)
# $(RM) $(ALL_OBJS_BC)
$(RM) $(ALL_OBJS_O)
$(RM) $(ALL_DOCS)
$(RM) $(LIB_MASK)
install :
$(MD) $(LIB_DEST)
$(CP) $(LIB_MASK) $(LIB_DEST)/.

81
runtime/internal/ldc/bitmanip.d
View File

@@ -1,81 +0,0 @@
/*
* D phobos intrinsics for LDC
*
* From GDC ... public domain!
*/
module ldc.bitmanip;
// Check for the right compiler
version(LDC)
{
// OK
}
else
{
static assert(false, "This module is only valid for LDC");
}
int bsf(uint v)
{
uint m = 1;
uint i;
for (i = 0; i < 32; i++,m<<=1) {
if (v&m)
return i;
}
return i; // supposed to be undefined
}
int bsr(uint v)
{
uint m = 0x80000000;
uint i;
for (i = 32; i ; i--,m>>>=1) {
if (v&m)
return i-1;
}
return i; // supposed to be undefined
}
int bt(uint *p, uint bitnum)
{
return (p[bitnum / (uint.sizeof*8)] & (1<<(bitnum & ((uint.sizeof*8)-1)))) ? -1 : 0 ;
}
int btc(uint *p, uint bitnum)
{
uint * q = p + (bitnum / (uint.sizeof*8));
uint mask = 1 << (bitnum & ((uint.sizeof*8) - 1));
int result = *q & mask;
*q ^= mask;
return result ? -1 : 0;
}
int btr(uint *p, uint bitnum)
{
uint * q = p + (bitnum / (uint.sizeof*8));
uint mask = 1 << (bitnum & ((uint.sizeof*8) - 1));
int result = *q & mask;
*q &= ~mask;
return result ? -1 : 0;
}
int bts(uint *p, uint bitnum)
{
uint * q = p + (bitnum / (uint.sizeof*8));
uint mask = 1 << (bitnum & ((uint.sizeof*8) - 1));
int result = *q & mask;
*q |= mask;
return result ? -1 : 0;
}
pragma(intrinsic, "llvm.bswap.i32")
uint bswap(uint val);
ubyte inp(uint p) { throw new Exception("inp intrinsic not yet implemented"); }
ushort inpw(uint p) { throw new Exception("inpw intrinsic not yet implemented"); }
uint inpl(uint p) { throw new Exception("inpl intrinsic not yet implemented"); }
ubyte outp(uint p, ubyte v) { throw new Exception("outp intrinsic not yet implemented"); }
ushort outpw(uint p, ushort v) { throw new Exception("outpw intrinsic not yet implemented"); }
uint outpl(uint p, uint v) { throw new Exception("outpl intrinsic not yet implemented"); }

43
runtime/internal/ldc/vararg.d
View File

@@ -1,43 +0,0 @@
/*
* This module holds the implementation of special vararg templates for D style var args.
*
* Provides the functions tango.core.Vararg expects to be present!
*/
module ldc.Vararg;
// Check for the right compiler
version(LDC)
{
// OK
}
else
{
static assert(false, "This module is only valid for LDC");
}
alias void* va_list;
void va_start(T) ( out va_list ap, inout T parmn )
{
// not needed !
}
T va_arg(T)(ref va_list vp)
{
T* arg = cast(T*) vp;
// ldc always aligns to size_t.sizeof in vararg lists
vp = cast(va_list) ( cast(void*) vp + ( ( T.sizeof + size_t.sizeof - 1 ) & ~( size_t.sizeof - 1 ) ) );
return *arg;
}
void va_end( va_list ap )
{
// not needed !
}
void va_copy( out va_list dst, va_list src )
{
// seems pretty useless !
dst = src;
}

1083
runtime/internal/lifetime.d
View File

File diff suppressed because it is too large Load Diff

105
runtime/internal/mars.h
View File

@@ -1,105 +0,0 @@
/*
* Placed into the Public Domain
* written by Walter Bright, Digital Mars
* www.digitalmars.com
*/
/*
* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
*/
#include <stddef.h>
#if __cplusplus
extern "C" {
#endif
struct ClassInfo;
struct Vtbl;
typedef struct Vtbl
{
size_t len;
void **vptr;
} Vtbl;
typedef struct Interface
{
struct ClassInfo *classinfo;
struct Vtbl vtbl;
int offset;
} Interface;
typedef struct Object
{
void **vptr;
void *monitor;
} Object;
typedef struct ClassInfo
{
Object object;
size_t initlen;
void *init;
size_t namelen;
char *name;
Vtbl vtbl;
size_t interfacelen;
Interface *interfaces;
struct ClassInfo *baseClass;
void *destructor;
void *invariant;
int flags;
} ClassInfo;
typedef struct Exception
{
Object object;
size_t msglen;
char* msg;
size_t filelen;
char* file;
size_t line;
struct Interface *info;
struct Exception *next;
} Exception;
typedef struct Array
{
size_t length;
void *ptr;
} Array;
typedef struct Delegate
{
void *thisptr;
void (*funcptr)();
} Delegate;
void _d_monitorenter(Object *h);
void _d_monitorexit(Object *h);
int _d_isbaseof(ClassInfo *b, ClassInfo *c);
Object *_d_dynamic_cast(Object *o, ClassInfo *ci);
Object * _d_allocclass(ClassInfo *ci);
void _d_delclass(Object **p);
void _d_OutOfMemory();
#if __cplusplus
}
#endif

635
runtime/internal/memory.d
View File

@@ -1,635 +0,0 @@
/**
* This module exposes functionality for inspecting and manipulating memory.
*
* Copyright: Copyright (C) 2005-2006 Digital Mars, www.digitalmars.com.
* All rights reserved.
* License:
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
* Authors: Walter Bright, Sean Kelly
*/
module memory;
version = GC_Use_Dynamic_Ranges;
version(darwin)
{
version = GC_Use_Data_Dyld;
version = GC_Use_Dynamic_Ranges;
}
else version(Posix)
{
version = GC_Use_Data_Proc_Maps;
}
else version(solaris)
{
version = GC_Use_Data_Proc_Maps;
}
version(GC_Use_Data_Proc_Maps)
{
version(Posix) {} else {
static assert(false, "Proc Maps only supported on Posix systems");
}
private import tango.stdc.posix.unistd;
private import tango.stdc.posix.fcntl;
private import tango.stdc.string;
version = GC_Use_Dynamic_Ranges;
}
private
{
version( linux )
{
//version = SimpleLibcStackEnd;
version( SimpleLibcStackEnd )
{
extern (C) extern void* __libc_stack_end;
}
else
{
import tango.stdc.posix.dlfcn;
}
}
pragma(intrinsic, "llvm.frameaddress")
{
void* llvm_frameaddress(uint level=0);
}
}
/**
*
*/
version( solaris ) {
version(X86_64) {
extern (C) void* _userlimit;
}
}
extern (C) void* rt_stackBottom()
{
version( Win32 )
{
void* bottom;
asm
{
mov EAX, FS:4;
mov bottom, EAX;
}
return bottom;
}
else version( linux )
{
version( SimpleLibcStackEnd )
{
return __libc_stack_end;
}
else
{
// See discussion: http://autopackage.org/forums/viewtopic.php?t=22
static void** libc_stack_end;
if( libc_stack_end == libc_stack_end.init )
{
void* handle = dlopen( null, RTLD_NOW );
libc_stack_end = cast(void**) dlsym( handle, "__libc_stack_end" );
dlclose( handle );
}
return *libc_stack_end;
}
}
else version( darwin )
{
// darwin has a fixed stack bottom
version(X86_64)
return cast(void*) 0x7fff5fc00000;
else
return cast(void*) 0xc0000000;
}
else version( solaris )
{
version(X86_64) {
return _userlimit;
}
else {
// <sys/vmparam.h>
return cast(void*) 0x8048000;
}
}
else
{
static assert( false, "Operating system not supported." );
}
}
/**
*
*/
extern (C) void* rt_stackTop()
{
version( D_InlineAsm_X86 )
{
asm
{
naked;
mov EAX, ESP;
ret;
}
}
else
{
return llvm_frameaddress();
}
}
private
{
version( Win32 )
{
extern (C)
{
extern int _data_start__;
extern int _bss_end__;
}
alias _data_start__ Data_Start;
alias _bss_end__ Data_End;
}
else version( linux )
{
extern (C)
{
extern int _data;
extern int __data_start;
extern int _end;
extern int _data_start__;
extern int _data_end__;
extern int _bss_start__;
extern int _bss_end__;
extern int __fini_array_end;
}
alias __data_start Data_Start;
alias _end Data_End;
}
else version( solaris )
{
extern(C)
{
extern int _environ;
extern int _end;
}
alias _environ Data_Start;
alias _end Data_End;
}
version( GC_Use_Dynamic_Ranges )
{
private import tango.stdc.stdlib;
struct DataSeg
{
void* beg;
void* end;
}
DataSeg* allSegs = null;
size_t numSegs = 0;
extern (C) void _d_gc_add_range( void* beg, void* end )
{
void* ptr = realloc( allSegs, (numSegs + 1) * DataSeg.sizeof );
if( ptr ) // if realloc fails, we have problems
{
allSegs = cast(DataSeg*) ptr;
allSegs[numSegs].beg = beg;
allSegs[numSegs].end = end;
numSegs++;
}
}
extern (C) void _d_gc_remove_range( void* beg )
{
for( size_t pos = 0; pos < numSegs; ++pos )
{
if( beg == allSegs[pos].beg )
{
while( ++pos < numSegs )
{
allSegs[pos-1] = allSegs[pos];
}
numSegs--;
return;
}
}
}
}
alias void delegate( void*, void* ) scanFn;
void* dataStart, dataEnd;
}
/**
*
*/
extern (C) void rt_scanStaticData( scanFn scan )
{
scan( dataStart, dataEnd );
version( GC_Use_Dynamic_Ranges )
{
for( size_t pos = 0; pos < numSegs; ++pos )
{
scan( allSegs[pos].beg, allSegs[pos].end );
}
}
}
void initStaticDataPtrs()
{
const int S = (void*).sizeof;
// Can't assume the input addresses are word-aligned
static void* adjust_up( void* p )
{
return p + ((S - (cast(size_t)p & (S-1))) & (S-1)); // cast ok even if 64-bit
}
static void * adjust_down( void* p )
{
return p - (cast(size_t) p & (S-1));
}
version( Win32 )
{
dataStart = adjust_up( &Data_Start );
dataEnd = adjust_down( &Data_End );
}
else version(linux)
{
dataStart = adjust_up( &Data_Start );
dataEnd = adjust_down( &Data_End );
}
else version(solaris)
{
dataStart = adjust_up( &Data_Start );
dataEnd = adjust_down( &Data_End );
}
else version(GC_Use_Data_Dyld)
{
_d_dyld_start();
}
else
{
static assert( false, "Operating system not supported." );
}
version( GC_Use_Data_Proc_Maps )
{
parseDataProcMaps();
}
}
version( GC_Use_Data_Proc_Maps )
{
version(solaris)
{
typedef long offset_t;
enum : uint { PRMAPSZ = 64, MA_WRITE = 0x02 }
extern(C)
{
struct prmap {
uintptr_t pr_vaddr; /* virtual address of mapping */
size_t pr_size; /* size of mapping in bytes */
char[PRMAPSZ] pr_mapname; /* name in /proc/<pid>/object */
private offset_t pr_offset; /* offset into mapped object, if any */
int pr_mflags; /* protection and attribute flags (see below) */
int pr_pagesize; /* pagesize (bytes) for this mapping */
int pr_shmid; /* SysV shmid, -1 if not SysV shared memory */
private int[1] pr_filler;
}
}
debug (ProcMaps) extern (C) int printf(char*, ...);
void parseDataProcMaps()
{
debug (ProcMaps) printf("initStaticDataPtrs()\n");
// http://docs.sun.com/app/docs/doc/816-5174/proc-4
prmap pr;
int fd = open("/proc/self/map", O_RDONLY);
scope (exit) close(fd);
while (prmap.sizeof == read(fd, &pr, prmap.sizeof))
if (pr.pr_mflags & MA_WRITE)
{
void* start = cast(void*) pr.pr_vaddr;
void* end = cast(void*)(pr.pr_vaddr + pr.pr_size);
debug (ProcMaps) printf(" vmem at %p - %p with size %d bytes\n", start, end, pr.pr_size);
// Exclude stack and dataStart..dataEnd
if ( ( !dataEnd ||
!( dataStart >= start && dataEnd <= end ) ) &&
!( &pr >= start && &pr < end ) )
{
// we already have static data from this region. anything else
// is heap (%% check)
debug (ProcMaps) printf(" Adding map range %p - %p\n", start, end);
_d_gc_add_range(start, end);
}
}
}
}
else
{
const int S = (void*).sizeof;
// TODO: This could use cleanup!
void parseDataProcMaps()
{
// TODO: Exclude zero-mapped regions
int fd = open("/proc/self/maps", O_RDONLY);
ptrdiff_t count; // %% need to configure ret for read..
char buf[2024];
char* p;
char* e;
char* s;
void* start;
void* end;
p = buf.ptr;
if (fd != -1)
{
while ( (count = read(fd, p, buf.sizeof - (p - buf.ptr))) > 0 )
{
e = p + count;
p = buf.ptr;
while (true)
{
s = p;
while (p < e && *p != '\n')
p++;
if (p < e)
{
// parse the entry in [s, p)
static if( S == 4 )
{
enum Ofs
{
Write_Prot = 19,
Start_Addr = 0,
End_Addr = 9,
Addr_Len = 8,
}
}
else static if( S == 8 )
{
//X86-64 only has 12 bytes address space(in PAE mode) - not 16
//We also need the 32 bit offsets for 32 bit apps
version(X86_64) {
enum Ofs
{
Write_Prot = 27,
Start_Addr = 0,
End_Addr = 13,
Addr_Len = 12,
Write_Prot_32 = 19,
Start_Addr_32 = 0,
End_Addr_32 = 9,
Addr_Len_32 = 8,
}
}
else
{
enum Ofs
{
Write_Prot = 35,
Start_Addr = 0,
End_Addr = 9,
Addr_Len = 17,
}
}
}
else
{
static assert( false );
}
// %% this is wrong for 64-bit:
// long strtoul(const char*,char**,int);
// but seems to work on x86-64:
// probably because C's long is 64 bit there
if( s[Ofs.Write_Prot] == 'w' )
{
s[Ofs.Start_Addr + Ofs.Addr_Len] = '\0';
s[Ofs.End_Addr + Ofs.Addr_Len] = '\0';
start = cast(void*) strtoul(s + Ofs.Start_Addr, null, 16);
end = cast(void*) strtoul(s + Ofs.End_Addr, null, 16);
// 1. Exclude anything overlapping [dataStart, dataEnd)
// 2. Exclude stack
if ( ( !dataEnd ||
!( dataStart >= start && dataEnd <= end ) ) &&
!( &buf[0] >= start && &buf[0] < end ) )
{
// we already have static data from this region. anything else
// is heap (%% check)
debug (ProcMaps) printf("Adding map range %p 0%p\n", start, end);
_d_gc_add_range(start, end);
}
}
version(X86_64)
{
//We need to check here for 32 bit apps like ldc produces
//and add them to the gc scan range
if( s[Ofs.Write_Prot_32] == 'w' )
{
s[Ofs.Start_Addr_32 + Ofs.Addr_Len_32] = '\0';
s[Ofs.End_Addr_32 + Ofs.Addr_Len_32] = '\0';
start = cast(void*) strtoul(s + Ofs.Start_Addr_32, null, 16);
end = cast(void*) strtoul(s + Ofs.End_Addr_32, null, 16);
if ( ( !dataEnd ||
!( dataStart >= start && dataEnd <= end ) ) &&
!( &buf[0] >= start && &buf[0] < end ) )
{
_d_gc_add_range(start, end);
}
}
}
p++;
}
else
{
count = p - s;
memmove(buf.ptr, s, cast(size_t)count);
p = buf.ptr + count;
break;
}
}
}
close(fd);
}
}
}
}
/*
* GDC dyld memory module:
* http://www.dsource.org/projects/tango/browser/trunk/lib/compiler/gdc/memory_dyld.c
* Port to the D programming language: Jacob Carlborg
*/
version (GC_Use_Data_Dyld)
{
private
{
const char* SEG_DATA = "__DATA".ptr;
const char* SECT_DATA = "__data".ptr;
const char* SECT_BSS = "__bss".ptr;
const char* SECT_COMMON = "__common".ptr;
struct SegmentSection
{
const char* segment;
const char* section;
}
struct mach_header
{
uint magic;
int cputype;
int cpusubtype;
uint filetype;
uint ncmds;
uint sizeofcmds;
uint flags;
version(X86_64)
uint reserved;
}
struct section
{
char[16] sectname;
char[16] segname;
version(X86_64)
{
ulong addr;
ulong size;
}
else
{
uint addr;
uint size;
}
uint offset;
uint align_;
uint reloff;
uint nreloc;
uint flags;
uint reserved1;
uint reserved2;
version(X86_64)
uint reserved3;
}
alias extern (C) void function (mach_header* mh, ptrdiff_t vmaddr_slide) DyldFuncPointer;
version(X86_64)
extern (C) /*const*/ section* getsectbynamefromheader_64(/*const*/ mach_header* mhp, /*const*/ char* segname, /*const*/ char* sectname);
else
extern (C) /*const*/ section* getsectbynamefromheader(/*const*/ mach_header* mhp, /*const*/ char* segname, /*const*/ char* sectname);
extern (C) void _dyld_register_func_for_add_image(DyldFuncPointer func);
extern (C) void _dyld_register_func_for_remove_image(DyldFuncPointer func);
const SegmentSection[3] GC_dyld_sections = [SegmentSection(SEG_DATA, SECT_DATA), SegmentSection(SEG_DATA, SECT_BSS), SegmentSection(SEG_DATA, SECT_COMMON)];
extern (C) void on_dyld_add_image (/*const*/ mach_header* hdr, ptrdiff_t slide)
{
void* start;
void* end;
/*const*/ section* sec;
foreach (s ; GC_dyld_sections)
{
version(X86_64)
sec = getsectbynamefromheader_64(hdr, s.segment, s.section);
else
sec = getsectbynamefromheader(hdr, s.segment, s.section);
if (sec == null || sec.size == 0)
continue;
start = cast(void*) (sec.addr + slide);
end = cast(void*) (start + sec.size);
_d_gc_add_range(start, end);
}
}
extern (C) void on_dyld_remove_image (/*const*/ mach_header* hdr, ptrdiff_t slide)
{
void* start;
void* end;
/*const*/ section* sec;
foreach (s ; GC_dyld_sections)
{
version(X86_64)
sec = getsectbynamefromheader_64(hdr, s.segment, s.section);
else
sec = getsectbynamefromheader(hdr, s.segment, s.section);
if (sec == null || sec.size == 0)
continue;
start = cast(void*) (sec.addr + slide);
end = cast(void*) (start + sec.size);
_d_gc_remove_range(start);
}
}
void _d_dyld_start ()
{
static bool started;
if (!started)
{
started = true;
_dyld_register_func_for_add_image(&on_dyld_add_image);
_dyld_register_func_for_remove_image(&on_dyld_remove_image);
}
}
}
}

212
runtime/internal/monitor.c
View File

@@ -1,212 +0,0 @@
// D programming language runtime library
// Public Domain
// written by Walter Bright, Digital Mars
// www.digitalmars.com
// This is written in C because nobody has written a pthreads interface
// to D yet.
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#if _WIN32
#elif linux || __APPLE__ || (defined (__SVR4) && defined (__sun))
#define USE_PTHREADS 1
#else
#endif
#if _WIN32
#include <windows.h>
#endif
#if USE_PTHREADS
#include <pthread.h>
#endif
#include "mars.h"
// This is what the monitor reference in Object points to
typedef struct Monitor
{
void* impl; // for user-level monitors
Array devt; // for internal monitors
#if _WIN32
CRITICAL_SECTION mon;
#endif
#if USE_PTHREADS
pthread_mutex_t mon;
#endif
} Monitor;
#define MONPTR(h) (&((Monitor *)(h)->monitor)->mon)
static volatile int inited;
/* =============================== Win32 ============================ */
#if _WIN32
static CRITICAL_SECTION _monitor_critsec;
void _STI_monitor_staticctor()
{
if (!inited)
{ InitializeCriticalSection(&_monitor_critsec);
inited = 1;
}
}
void _STD_monitor_staticdtor()
{
if (inited)
{ inited = 0;
DeleteCriticalSection(&_monitor_critsec);
}
}
void _d_monitor_create(Object *h)
{
/*
* NOTE: Assume this is only called when h->monitor is null prior to the
* call. However, please note that another thread may call this function
* at the same time, so we can not assert this here. Instead, try and
* create a lock, and if one already exists then forget about it.
*/
//printf("+_d_monitor_create(%p)\n", h);
assert(h);
Monitor *cs = NULL;
EnterCriticalSection(&_monitor_critsec);
if (!h->monitor)
{
cs = (Monitor *)calloc(sizeof(Monitor), 1);
assert(cs);
InitializeCriticalSection(&cs->mon);
h->monitor = (void *)cs;
cs = NULL;
}
LeaveCriticalSection(&_monitor_critsec);
if (cs)
free(cs);
//printf("-_d_monitor_create(%p)\n", h);
}
void _d_monitor_destroy(Object *h)
{
//printf("+_d_monitor_destroy(%p)\n", h);
assert(h && h->monitor && !(((Monitor*)h->monitor)->impl));
DeleteCriticalSection(MONPTR(h));
free((void *)h->monitor);
h->monitor = NULL;
//printf("-_d_monitor_destroy(%p)\n", h);
}
int _d_monitor_lock(Object *h)
{
//printf("+_d_monitor_acquire(%p)\n", h);
assert(h && h->monitor && !(((Monitor*)h->monitor)->impl));
EnterCriticalSection(MONPTR(h));
//printf("-_d_monitor_acquire(%p)\n", h);
}
void _d_monitor_unlock(Object *h)
{
//printf("+_d_monitor_release(%p)\n", h);
assert(h && h->monitor && !(((Monitor*)h->monitor)->impl));
LeaveCriticalSection(MONPTR(h));
//printf("-_d_monitor_release(%p)\n", h);
}
#endif
/* =============================== linux ============================ */
#if USE_PTHREADS
#if !linux
#define PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
#endif
// Includes attribute fixes from David Friedman's GDC port
static pthread_mutex_t _monitor_critsec;
static pthread_mutexattr_t _monitors_attr;
void _STI_monitor_staticctor()
{
if (!inited)
{
pthread_mutexattr_init(&_monitors_attr);
pthread_mutexattr_settype(&_monitors_attr, PTHREAD_MUTEX_RECURSIVE_NP);
pthread_mutex_init(&_monitor_critsec, 0);
inited = 1;
}
}
void _STD_monitor_staticdtor()
{
if (inited)
{ inited = 0;
pthread_mutex_destroy(&_monitor_critsec);
pthread_mutexattr_destroy(&_monitors_attr);
}
}
void _d_monitor_create(Object *h)
{
/*
* NOTE: Assume this is only called when h->monitor is null prior to the
* call. However, please note that another thread may call this function
* at the same time, so we can not assert this here. Instead, try and
* create a lock, and if one already exists then forget about it.
*/
//printf("+_d_monitor_create(%p)\n", h);
assert(h);
Monitor *cs = NULL;
pthread_mutex_lock(&_monitor_critsec);
if (!h->monitor)
{
cs = (Monitor *)calloc(sizeof(Monitor), 1);
assert(cs);
pthread_mutex_init(&cs->mon, & _monitors_attr);
h->monitor = (void *)cs;
cs = NULL;
}
pthread_mutex_unlock(&_monitor_critsec);
if (cs)
free(cs);
//printf("-_d_monitor_create(%p)\n", h);
}
void _d_monitor_destroy(Object *h)
{
//printf("+_d_monitor_destroy(%p)\n", h);
assert(h && h->monitor && !(((Monitor*)h->monitor)->impl));
pthread_mutex_destroy(MONPTR(h));
free((void *)h->monitor);
h->monitor = NULL;
//printf("-_d_monitor_destroy(%p)\n", h);
}
int _d_monitor_lock(Object *h)
{
//printf("+_d_monitor_acquire(%p)\n", h);
assert(h && h->monitor && !(((Monitor*)h->monitor)->impl));
pthread_mutex_lock(MONPTR(h));
//printf("-_d_monitor_acquire(%p)\n", h);
}
void _d_monitor_unlock(Object *h)
{
//printf("+_d_monitor_release(%p)\n", h);
assert(h && h->monitor && !(((Monitor*)h->monitor)->impl));
pthread_mutex_unlock(MONPTR(h));
//printf("-_d_monitor_release(%p)\n", h);
}
#endif

64
runtime/internal/qsort2.d
View File

@@ -1,64 +0,0 @@
/*
* Placed into Public Domain
* written by Walter Bright
* www.digitalmars.com
*
* This is a public domain version of qsort.d.
* All it does is call C's qsort(), but runs a little slower since
* it needs to synchronize a global variable.
*/
/*
* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
*/
//debug=qsort;
private import tango.stdc.stdlib;
private TypeInfo tiglobal;
extern (C) int cmp(void* p1, void* p2)
{
return tiglobal.compare(p1, p2);
}
extern (C) void[] _adSort(void[] a, TypeInfo ti)
{
synchronized
{
tiglobal = ti;
tango.stdc.stdlib.qsort(a.ptr, a.length, cast(size_t)ti.tsize(), &cmp);
}
return a;
}
unittest
{
debug(qsort) printf("array.sort.unittest()\n");
int a[] = new int[10];
a[0] = 23;
a[1] = 1;
a[2] = 64;
a[3] = 5;
a[4] = 6;
a[5] = 5;
a[6] = 17;
a[7] = 3;
a[8] = 0;
a[9] = -1;
a.sort;
for (int i = 0; i < a.length - 1; i++)
{
//printf("i = %d", i);
//printf(" %d %d\n", a[i], a[i + 1]);
assert(a[i] <= a[i + 1]);
}
}

425
runtime/internal/switch.d
View File

@@ -1,425 +0,0 @@
/*
* Copyright (C) 2004-2007 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly <sean@f4.ca> for use with Tango.
*/
private import tango.stdc.string;
//private import tango.stdc.stdio;
/******************************************************
* Support for switch statements switching on strings.
* Input:
* table[] sorted array of strings generated by compiler
* ca string to look up in table
* Output:
* result index of match in table[]
* -1 if not in table
*/
extern (C):
int _d_switch_string(char[][] table, char[] ca)
in
{
//printf("in _d_switch_string()\n");
assert(table.length >= 0);
assert(ca.length >= 0);
// Make sure table[] is sorted correctly
int j;
for (j = 1; j < table.length; j++)
{
size_t len1 = table[j - 1].length;
size_t len2 = table[j].length;
assert(len1 <= len2);
if (len1 == len2)
{
int ci;
ci = memcmp(table[j - 1].ptr, table[j].ptr, len1);
assert(ci < 0); // ci==0 means a duplicate
}
}
}
out (result)
{
int i;
int cj;
//printf("out _d_switch_string()\n");
if (result == -1)
{
// Not found
for (i = 0; i < table.length; i++)
{
if (table[i].length == ca.length)
{ cj = memcmp(table[i].ptr, ca.ptr, ca.length);
assert(cj != 0);
}
}
}
else
{
assert(0 <= result && result < table.length);
for (i = 0; 1; i++)
{
assert(i < table.length);
if (table[i].length == ca.length)
{
cj = memcmp(table[i].ptr, ca.ptr, ca.length);
if (cj == 0)
{
assert(i == result);
break;
}
}
}
}
}
body
{
//printf("body _d_switch_string(%.*s)\n", ca.length, ca.ptr);
size_t low;
size_t high;
size_t mid;
ptrdiff_t c;
char[] pca;
low = 0;
high = table.length;
version (none)
{
// Print table
printf("ca[] = '%s'\n", cast(char *)ca);
for (mid = 0; mid < high; mid++)
{
pca = table[mid];
printf("table[%d] = %d, '%.*s'\n", mid, pca.length, pca);
}
}
if (high &&
ca.length >= table[0].length &&
ca.length <= table[high - 1].length)
{
// Looking for 0 length string, which would only be at the beginning
if (ca.length == 0)
return 0;
char c1 = ca[0];
// Do binary search
while (low < high)
{
mid = (low + high) >> 1;
pca = table[mid];
c = cast(ptrdiff_t)(ca.length - pca.length);
if (c == 0)
{
c = cast(ubyte)c1 - cast(ubyte)pca[0];
if (c == 0)
{
c = memcmp(ca.ptr, pca.ptr, ca.length);
if (c == 0)
{ //printf("found %d\n", mid);
return cast(int)mid;
}
}
}
if (c < 0)
{
high = mid;
}
else
{
low = mid + 1;
}
}
}
//printf("not found\n");
return -1; // not found
}
unittest
{
switch (cast(char []) "c")
{
case "coo":
default:
break;
}
}
/**********************************
* Same thing, but for wide chars.
*/
int _d_switch_ustring(wchar[][] table, wchar[] ca)
in
{
//printf("in _d_switch_ustring()\n");
assert(table.length >= 0);
assert(ca.length >= 0);
// Make sure table[] is sorted correctly
int j;
for (j = 1; j < table.length; j++)
{
size_t len1 = table[j - 1].length;
size_t len2 = table[j].length;
assert(len1 <= len2);
if (len1 == len2)
{
int c;
c = memcmp(table[j - 1].ptr, table[j].ptr, len1 * wchar.sizeof);
assert(c < 0); // c==0 means a duplicate
}
}
}
out (result)
{
int i;
int c;
//printf("out _d_switch_string()\n");
if (result == -1)
{
// Not found
for (i = 0; i < table.length; i++)
{
if (table[i].length == ca.length)
{ c = memcmp(table[i].ptr, ca.ptr, ca.length * wchar.sizeof);
assert(c != 0);
}
}
}
else
{
assert(0 <= result && result < table.length);
for (i = 0; 1; i++)
{
assert(i < table.length);
if (table[i].length == ca.length)
{
c = memcmp(table[i].ptr, ca.ptr, ca.length * wchar.sizeof);
if (c == 0)
{
assert(i == result);
break;
}
}
}
}
}
body
{
//printf("body _d_switch_ustring()\n");
size_t low;
size_t high;
size_t mid;
ptrdiff_t c;
wchar[] pca;
low = 0;
high = table.length;
/*
// Print table
wprintf("ca[] = '%.*s'\n", ca);
for (mid = 0; mid < high; mid++)
{
pca = table[mid];
wprintf("table[%d] = %d, '%.*s'\n", mid, pca.length, pca);
}
*/
// Do binary search
while (low < high)
{
mid = (low + high) >> 1;
pca = table[mid];
c = cast(ptrdiff_t)(ca.length - pca.length);
if (c == 0)
{
c = memcmp(ca.ptr, pca.ptr, ca.length * wchar.sizeof);
if (c == 0)
{ //printf("found %d\n", mid);
return cast(int)mid;
}
}
if (c < 0)
{
high = mid;
}
else
{
low = mid + 1;
}
}
//printf("not found\n");
return -1; // not found
}
unittest
{
switch (cast(wchar []) "c")
{
case "coo":
default:
break;
}
}
/**********************************
* Same thing, but for wide chars.
*/
int _d_switch_dstring(dchar[][] table, dchar[] ca)
in
{
//printf("in _d_switch_dstring()\n");
assert(table.length >= 0);
assert(ca.length >= 0);
// Make sure table[] is sorted correctly
int j;
for (j = 1; j < table.length; j++)
{
size_t len1 = table[j - 1].length;
size_t len2 = table[j].length;
assert(len1 <= len2);
if (len1 == len2)
{
int c;
c = memcmp(table[j - 1].ptr, table[j].ptr, len1 * dchar.sizeof);
assert(c < 0); // c==0 means a duplicate
}
}
}
out (result)
{
int i;
int c;
//printf("out _d_switch_string()\n");
if (result == -1)
{
// Not found
for (i = 0; i < table.length; i++)
{
if (table[i].length == ca.length)
{ c = memcmp(table[i].ptr, ca.ptr, ca.length * dchar.sizeof);
assert(c != 0);
}
}
}
else
{
assert(0 <= result && result < table.length);
for (i = 0; 1; i++)
{
assert(i < table.length);
if (table[i].length == ca.length)
{
c = memcmp(table[i].ptr, ca.ptr, ca.length * dchar.sizeof);
if (c == 0)
{
assert(i == result);
break;
}
}
}
}
}
body
{
//printf("body _d_switch_ustring()\n");
size_t low;
size_t high;
size_t mid;
ptrdiff_t c;
dchar[] pca;
low = 0;
high = table.length;
/*
// Print table
wprintf("ca[] = '%.*s'\n", ca);
for (mid = 0; mid < high; mid++)
{
pca = table[mid];
wprintf("table[%d] = %d, '%.*s'\n", mid, pca.length, pca);
}
*/
// Do binary search
while (low < high)
{
mid = (low + high) >> 1;
pca = table[mid];
c = cast(ptrdiff_t)(ca.length - pca.length);
if (c == 0)
{
c = memcmp(ca.ptr, pca.ptr, ca.length * dchar.sizeof);
if (c == 0)
{ //printf("found %d\n", mid);
return cast(int)mid;
}
}
if (c < 0)
{
high = mid;
}
else
{
low = mid + 1;
}
}
//printf("not found\n");
return -1; // not found
}
unittest
{
switch (cast(dchar []) "c")
{
case "coo":
default:
break;
}
}

95
runtime/internal/typeinfo/ti_AC.d
View File

@@ -1,95 +0,0 @@
module typeinfo.ti_AC;
// Object[]
class TypeInfo_AC : TypeInfo_Array
{
hash_t getHash(void *p)
{ Object[] s = *cast(Object[]*)p;
hash_t hash = 0;
foreach (Object o; s)
{
if (o)
hash += o.toHash();
}
return hash;
}
int equals(void *p1, void *p2)
{
Object[] s1 = *cast(Object[]*)p1;
Object[] s2 = *cast(Object[]*)p2;
if (s1.length == s2.length)
{
for (size_t u = 0; u < s1.length; u++)
{ Object o1 = s1[u];
Object o2 = s2[u];
// Do not pass null's to Object.opEquals()
if (o1 is o2 ||
(!(o1 is null) && !(o2 is null) && o1.opEquals(o2)))
continue;
return 0;
}
return 1;
}
return 0;
}
int compare(void *p1, void *p2)
{
Object[] s1 = *cast(Object[]*)p1;
Object[] s2 = *cast(Object[]*)p2;
ptrdiff_t c;
c = cast(ptrdiff_t)s1.length - cast(ptrdiff_t)s2.length;
if (c == 0)
{
for (size_t u = 0; u < s1.length; u++)
{ Object o1 = s1[u];
Object o2 = s2[u];
if (o1 is o2)
continue;
// Regard null references as always being "less than"
if (o1)
{
if (!o2)
{ c = 1;
break;
}
c = o1.opCmp(o2);
if (c)
break;
}
else
{ c = -1;
break;
}
}
}
if (c < 0)
c = -1;
else
c = 1;
return cast(int)c;
}
size_t tsize()
{
return (Object[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(Object);
}
}

106
runtime/internal/typeinfo/ti_Acdouble.d
View File

@@ -1,106 +0,0 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module typeinfo.ti_Acdouble;
private import typeinfo.ti_cdouble;
// cdouble[]
class TypeInfo_Ar : TypeInfo_Array
{
char[] toString() { return "cdouble[]"; }
hash_t getHash(void *p)
{ cdouble[] s = *cast(cdouble[]*)p;
size_t len = s.length;
cdouble *str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += (cast(uint *)str)[0];
hash += (cast(uint *)str)[1];
hash += (cast(uint *)str)[2];
hash += (cast(uint *)str)[3];
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
cdouble[] s1 = *cast(cdouble[]*)p1;
cdouble[] s2 = *cast(cdouble[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_r._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
cdouble[] s1 = *cast(cdouble[]*)p1;
cdouble[] s2 = *cast(cdouble[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_r._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (cdouble[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(cdouble);
}
}

104
runtime/internal/typeinfo/ti_Acfloat.d
View File

@@ -1,104 +0,0 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module typeinfo.ti_Acfloat;
private import typeinfo.ti_cfloat;
// cfloat[]
class TypeInfo_Aq : TypeInfo_Array
{
char[] toString() { return "cfloat[]"; }
hash_t getHash(void *p)
{ cfloat[] s = *cast(cfloat[]*)p;
size_t len = s.length;
cfloat *str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += (cast(uint *)str)[0];
hash += (cast(uint *)str)[1];
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
cfloat[] s1 = *cast(cfloat[]*)p1;
cfloat[] s2 = *cast(cfloat[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_q._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
cfloat[] s1 = *cast(cfloat[]*)p1;
cfloat[] s2 = *cast(cfloat[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_q._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (cfloat[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(cfloat);
}
}

107
runtime/internal/typeinfo/ti_Acreal.d
View File

@@ -1,107 +0,0 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module typeinfo.ti_Acreal;
private import typeinfo.ti_creal;
// creal[]
class TypeInfo_Ac : TypeInfo_Array
{
char[] toString() { return "creal[]"; }
hash_t getHash(void *p)
{ creal[] s = *cast(creal[]*)p;
size_t len = s.length;
creal *str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += (cast(uint *)str)[0];
hash += (cast(uint *)str)[1];
hash += (cast(uint *)str)[2];
hash += (cast(uint *)str)[3];
hash += (cast(uint *)str)[4];
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
creal[] s1 = *cast(creal[]*)p1;
creal[] s2 = *cast(creal[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_c._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
creal[] s1 = *cast(creal[]*)p1;
creal[] s2 = *cast(creal[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_c._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (creal[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(creal);
}
}

116
runtime/internal/typeinfo/ti_Adouble.d
View File

@@ -1,116 +0,0 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module typeinfo.ti_Adouble;
private import typeinfo.ti_double;
// double[]
class TypeInfo_Ad : TypeInfo_Array
{
char[] toString() { return "double[]"; }
hash_t getHash(void *p)
{ double[] s = *cast(double[]*)p;
size_t len = s.length;
auto str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += (cast(uint *)str)[0];
hash += (cast(uint *)str)[1];
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
double[] s1 = *cast(double[]*)p1;
double[] s2 = *cast(double[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_d._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
double[] s1 = *cast(double[]*)p1;
double[] s2 = *cast(double[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_d._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (double[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(double);
}
}
// idouble[]
class TypeInfo_Ap : TypeInfo_Ad
{
char[] toString() { return "idouble[]"; }
TypeInfo next()
{
return typeid(idouble);
}
}

115
runtime/internal/typeinfo/ti_Afloat.d
View File

@@ -1,115 +0,0 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module typeinfo.ti_Afloat;
private import typeinfo.ti_float;
// float[]
class TypeInfo_Af : TypeInfo_Array
{
char[] toString() { return "float[]"; }
hash_t getHash(void *p)
{ float[] s = *cast(float[]*)p;
size_t len = s.length;
auto str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += *cast(uint *)str;
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
float[] s1 = *cast(float[]*)p1;
float[] s2 = *cast(float[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_f._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
float[] s1 = *cast(float[]*)p1;
float[] s2 = *cast(float[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_f._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (float[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(float);
}
}
// ifloat[]
class TypeInfo_Ao : TypeInfo_Af
{
char[] toString() { return "ifloat[]"; }
TypeInfo next()
{
return typeid(ifloat);
}
}

206
runtime/internal/typeinfo/ti_Ag.d
View File

@@ -1,206 +0,0 @@
module typeinfo.ti_Ag;
private import tango.stdc.string;
private import util.string;
// byte[]
class TypeInfo_Ag : TypeInfo_Array
{
char[] toString() { return "byte[]"; }
hash_t getHash(void *p)
{ byte[] s = *cast(byte[]*)p;
size_t len = s.length;
byte *str = s.ptr;
hash_t hash = 0;
while (1)
{
switch (len)
{
case 0:
return hash;
case 1:
hash *= 9;
hash += *cast(ubyte *)str;
return hash;
case 2:
hash *= 9;
hash += *cast(ushort *)str;
return hash;
case 3:
hash *= 9;
hash += (*cast(ushort *)str << 8) +
(cast(ubyte *)str)[2];
return hash;
default:
hash *= 9;
hash += *cast(uint *)str;
str += 4;
len -= 4;
break;
}
}
return hash;
}
int equals(void *p1, void *p2)
{
byte[] s1 = *cast(byte[]*)p1;
byte[] s2 = *cast(byte[]*)p2;
return s1.length == s2.length &&
memcmp(cast(byte *)s1, cast(byte *)s2, s1.length) == 0;
}
int compare(void *p1, void *p2)
{
byte[] s1 = *cast(byte[]*)p1;
byte[] s2 = *cast(byte[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int result = s1[u] - s2[u];
if (result)
return result;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (byte[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(byte);
}
}
// ubyte[]
class TypeInfo_Ah : TypeInfo_Ag
{
char[] toString() { return "ubyte[]"; }
int compare(void *p1, void *p2)
{
char[] s1 = *cast(char[]*)p1;
char[] s2 = *cast(char[]*)p2;
return stringCompare(s1, s2);
}
TypeInfo next()
{
return typeid(ubyte);
}
}
// void[]
class TypeInfo_Av : TypeInfo_Ah
{
char[] toString() { return "void[]"; }
TypeInfo next()
{
return typeid(void);
}
}
// bool[]
class TypeInfo_Ab : TypeInfo_Ah
{
char[] toString() { return "bool[]"; }
TypeInfo next()
{
return typeid(bool);
}
}
// char[]
class TypeInfo_Aa : TypeInfo_Ag
{
char[] toString() { return "char[]"; }
hash_t getHash(void *p)
{ char[] s = *cast(char[]*)p;
hash_t hash = 0;
version (all)
{
foreach (char c; s)
hash = hash * 11 + c;
}
else
{
size_t len = s.length;
char *str = s;
while (1)
{
switch (len)
{
case 0:
return hash;
case 1:
hash *= 9;
hash += *cast(ubyte *)str;
return hash;
case 2:
hash *= 9;
hash += *cast(ushort *)str;
return hash;
case 3:
hash *= 9;
hash += (*cast(ushort *)str << 8) +
(cast(ubyte *)str)[2];
return hash;
default:
hash *= 9;
hash += *cast(uint *)str;
str += 4;
len -= 4;
break;
}
}
}
return hash;
}
TypeInfo next()
{
return typeid(char);
}
}

119
runtime/internal/typeinfo/ti_Aint.d
View File

@@ -1,119 +0,0 @@
module typeinfo.ti_Aint;
private import tango.stdc.string;
// int[]
class TypeInfo_Ai : TypeInfo_Array
{
char[] toString() { return "int[]"; }
hash_t getHash(void *p)
{ int[] s = *cast(int[]*)p;
auto len = s.length;
auto str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += *cast(uint *)str;
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
int[] s1 = *cast(int[]*)p1;
int[] s2 = *cast(int[]*)p2;
return s1.length == s2.length &&
memcmp(cast(void *)s1, cast(void *)s2, s1.length * int.sizeof) == 0;
}
int compare(void *p1, void *p2)
{
int[] s1 = *cast(int[]*)p1;
int[] s2 = *cast(int[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int result = s1[u] - s2[u];
if (result)
return result;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (int[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(int);
}
}
// uint[]
class TypeInfo_Ak : TypeInfo_Ai
{
char[] toString() { return "uint[]"; }
int compare(void *p1, void *p2)
{
uint[] s1 = *cast(uint[]*)p1;
uint[] s2 = *cast(uint[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int result = s1[u] - s2[u];
if (result)
return result;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
TypeInfo next()
{
return typeid(uint);
}
}
// dchar[]
class TypeInfo_Aw : TypeInfo_Ak
{
char[] toString() { return "dchar[]"; }
TypeInfo next()
{
return typeid(dchar);
}
}

109
runtime/internal/typeinfo/ti_Along.d
View File

@@ -1,109 +0,0 @@
module typeinfo.ti_Along;
private import tango.stdc.string;
// long[]
class TypeInfo_Al : TypeInfo_Array
{
char[] toString() { return "long[]"; }
hash_t getHash(void *p)
{ long[] s = *cast(long[]*)p;
size_t len = s.length;
auto str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += *cast(uint *)str + *(cast(uint *)str + 1);
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
long[] s1 = *cast(long[]*)p1;
long[] s2 = *cast(long[]*)p2;
return s1.length == s2.length &&
memcmp(cast(void *)s1, cast(void *)s2, s1.length * long.sizeof) == 0;
}
int compare(void *p1, void *p2)
{
long[] s1 = *cast(long[]*)p1;
long[] s2 = *cast(long[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
if (s1[u] < s2[u])
return -1;
else if (s1[u] > s2[u])
return 1;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (long[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(long);
}
}
// ulong[]
class TypeInfo_Am : TypeInfo_Al
{
char[] toString() { return "ulong[]"; }
int compare(void *p1, void *p2)
{
ulong[] s1 = *cast(ulong[]*)p1;
ulong[] s2 = *cast(ulong[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
if (s1[u] < s2[u])
return -1;
else if (s1[u] > s2[u])
return 1;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
TypeInfo next()
{
return typeid(ulong);
}
}

117
runtime/internal/typeinfo/ti_Areal.d
View File

@@ -1,117 +0,0 @@
/*
* Copyright (C) 2004-2006 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module typeinfo.ti_Areal;
private import typeinfo.ti_real;
// real[]
class TypeInfo_Ae : TypeInfo_Array
{
char[] toString() { return "real[]"; }
hash_t getHash(void *p)
{ real[] s = *cast(real[]*)p;
size_t len = s.length;
auto str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += (cast(uint *)str)[0];
hash += (cast(uint *)str)[1];
hash += (cast(ushort *)str)[4];
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
real[] s1 = *cast(real[]*)p1;
real[] s2 = *cast(real[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_e._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
real[] s1 = *cast(real[]*)p1;
real[] s2 = *cast(real[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_e._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (real[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(real);
}
}
// ireal[]
class TypeInfo_Aj : TypeInfo_Ae
{
char[] toString() { return "ireal[]"; }
TypeInfo next()
{
return typeid(ireal);
}
}

132
runtime/internal/typeinfo/ti_Ashort.d
View File

@@ -1,132 +0,0 @@
module typeinfo.ti_Ashort;
private import tango.stdc.string;
// short[]
class TypeInfo_As : TypeInfo_Array
{
char[] toString() { return "short[]"; }
hash_t getHash(void *p)
{ short[] s = *cast(short[]*)p;
size_t len = s.length;
short *str = s.ptr;
hash_t hash = 0;
while (1)
{
switch (len)
{
case 0:
return hash;
case 1:
hash *= 9;
hash += *cast(ushort *)str;
return hash;
default:
hash *= 9;
hash += *cast(uint *)str;
str += 2;
len -= 2;
break;
}
}
return hash;
}
int equals(void *p1, void *p2)
{
short[] s1 = *cast(short[]*)p1;
short[] s2 = *cast(short[]*)p2;
return s1.length == s2.length &&
memcmp(cast(void *)s1, cast(void *)s2, s1.length * short.sizeof) == 0;
}
int compare(void *p1, void *p2)
{
short[] s1 = *cast(short[]*)p1;
short[] s2 = *cast(short[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int result = s1[u] - s2[u];
if (result)
return result;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (short[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(short);
}
}
// ushort[]
class TypeInfo_At : TypeInfo_As
{
char[] toString() { return "ushort[]"; }
int compare(void *p1, void *p2)
{
ushort[] s1 = *cast(ushort[]*)p1;
ushort[] s2 = *cast(ushort[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int result = s1[u] - s2[u];
if (result)
return result;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
TypeInfo next()
{
return typeid(ushort);
}
}
// wchar[]
class TypeInfo_Au : TypeInfo_At
{
char[] toString() { return "wchar[]"; }
TypeInfo next()
{
return typeid(wchar);
}
}

74
runtime/internal/typeinfo/ti_C.d
View File

@@ -1,74 +0,0 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module typeinfo.ti_C;
// Object
class TypeInfo_C : TypeInfo
{
hash_t getHash(void *p)
{
Object o = *cast(Object*)p;
return o ? o.toHash() : 0;
}
int equals(void *p1, void *p2)
{
Object o1 = *cast(Object*)p1;
Object o2 = *cast(Object*)p2;
return o1 == o2;
}
int compare(void *p1, void *p2)
{
Object o1 = *cast(Object*)p1;
Object o2 = *cast(Object*)p2;
int c = 0;
// Regard null references as always being "less than"
if (!(o1 is o2))
{
if (o1)
{ if (!o2)
c = 1;
else
c = o1.opCmp(o2);
}
else
c = -1;
}
return c;
}
size_t tsize()
{
return Object.sizeof;
}
uint flags()
{
return 1;
}
}

39
runtime/internal/typeinfo/ti_byte.d
View File

@@ -1,39 +0,0 @@
// byte
module typeinfo.ti_byte;
class TypeInfo_g : TypeInfo
{
char[] toString() { return "byte"; }
hash_t getHash(void *p)
{
return *cast(byte *)p;
}
int equals(void *p1, void *p2)
{
return *cast(byte *)p1 == *cast(byte *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(byte *)p1 - *cast(byte *)p2;
}
size_t tsize()
{
return byte.sizeof;
}
void swap(void *p1, void *p2)
{
byte t;
t = *cast(byte *)p1;
*cast(byte *)p1 = *cast(byte *)p2;
*cast(byte *)p2 = t;
}
}

66
runtime/internal/typeinfo/ti_cdouble.d
View File

@@ -1,66 +0,0 @@
// cdouble
module typeinfo.ti_cdouble;
class TypeInfo_r : TypeInfo
{
char[] toString() { return "cdouble"; }
hash_t getHash(void *p)
{
return (cast(uint *)p)[0] + (cast(uint *)p)[1] +
(cast(uint *)p)[2] + (cast(uint *)p)[3];
}
static int _equals(cdouble f1, cdouble f2)
{
return f1 == f2;
}
static int _compare(cdouble f1, cdouble f2)
{ int result;
if (f1.re < f2.re)
result = -1;
else if (f1.re > f2.re)
result = 1;
else if (f1.im < f2.im)
result = -1;
else if (f1.im > f2.im)
result = 1;
else
result = 0;
return result;
}
int equals(void *p1, void *p2)
{
return _equals(*cast(cdouble *)p1, *cast(cdouble *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(cdouble *)p1, *cast(cdouble *)p2);
}
size_t tsize()
{
return cdouble.sizeof;
}
void swap(void *p1, void *p2)
{
cdouble t;
t = *cast(cdouble *)p1;
*cast(cdouble *)p1 = *cast(cdouble *)p2;
*cast(cdouble *)p2 = t;
}
void[] init()
{ static cdouble r;
return (cast(cdouble *)&r)[0 .. 1];
}
}

65
runtime/internal/typeinfo/ti_cfloat.d
View File

@@ -1,65 +0,0 @@
// cfloat
module typeinfo.ti_cfloat;
class TypeInfo_q : TypeInfo
{
char[] toString() { return "cfloat"; }
hash_t getHash(void *p)
{
return (cast(uint *)p)[0] + (cast(uint *)p)[1];
}
static int _equals(cfloat f1, cfloat f2)
{
return f1 == f2;
}
static int _compare(cfloat f1, cfloat f2)
{ int result;
if (f1.re < f2.re)
result = -1;
else if (f1.re > f2.re)
result = 1;
else if (f1.im < f2.im)
result = -1;
else if (f1.im > f2.im)
result = 1;
else
result = 0;
return result;
}
int equals(void *p1, void *p2)
{
return _equals(*cast(cfloat *)p1, *cast(cfloat *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(cfloat *)p1, *cast(cfloat *)p2);
}
size_t tsize()
{
return cfloat.sizeof;
}
void swap(void *p1, void *p2)
{
cfloat t;
t = *cast(cfloat *)p1;
*cast(cfloat *)p1 = *cast(cfloat *)p2;
*cast(cfloat *)p2 = t;
}
void[] init()
{ static cfloat r;
return (cast(cfloat *)&r)[0 .. 1];
}
}

42
runtime/internal/typeinfo/ti_char.d
View File

@@ -1,42 +0,0 @@
module typeinfo.ti_char;
class TypeInfo_a : TypeInfo
{
char[] toString() { return "char"; }
hash_t getHash(void *p)
{
return *cast(char *)p;
}
int equals(void *p1, void *p2)
{
return *cast(char *)p1 == *cast(char *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(char *)p1 - *cast(char *)p2;
}
size_t tsize()
{
return char.sizeof;
}
void swap(void *p1, void *p2)
{
char t;
t = *cast(char *)p1;
*cast(char *)p1 = *cast(char *)p2;
*cast(char *)p2 = t;
}
void[] init()
{ static char c;
return (cast(char *)&c)[0 .. 1];
}
}

67
runtime/internal/typeinfo/ti_creal.d
View File

@@ -1,67 +0,0 @@
// creal
module typeinfo.ti_creal;
class TypeInfo_c : TypeInfo
{
char[] toString() { return "creal"; }
hash_t getHash(void *p)
{
return (cast(uint *)p)[0] + (cast(uint *)p)[1] +
(cast(uint *)p)[2] + (cast(uint *)p)[3] +
(cast(uint *)p)[4];
}
static int _equals(creal f1, creal f2)
{
return f1 == f2;
}
static int _compare(creal f1, creal f2)
{ int result;
if (f1.re < f2.re)
result = -1;
else if (f1.re > f2.re)
result = 1;
else if (f1.im < f2.im)
result = -1;
else if (f1.im > f2.im)
result = 1;
else
result = 0;
return result;
}
int equals(void *p1, void *p2)
{
return _equals(*cast(creal *)p1, *cast(creal *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(creal *)p1, *cast(creal *)p2);
}
size_t tsize()
{
return creal.sizeof;
}
void swap(void *p1, void *p2)
{
creal t;
t = *cast(creal *)p1;
*cast(creal *)p1 = *cast(creal *)p2;
*cast(creal *)p2 = t;
}
void[] init()
{ static creal r;
return (cast(creal *)&r)[0 .. 1];
}
}

44
runtime/internal/typeinfo/ti_dchar.d
View File

@@ -1,44 +0,0 @@
// dchar
module typeinfo.ti_dchar;
class TypeInfo_w : TypeInfo
{
char[] toString() { return "dchar"; }
hash_t getHash(void *p)
{
return *cast(dchar *)p;
}
int equals(void *p1, void *p2)
{
return *cast(dchar *)p1 == *cast(dchar *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(dchar *)p1 - *cast(dchar *)p2;
}
size_t tsize()
{
return dchar.sizeof;
}
void swap(void *p1, void *p2)
{
dchar t;
t = *cast(dchar *)p1;
*cast(dchar *)p1 = *cast(dchar *)p2;
*cast(dchar *)p2 = t;
}
void[] init()
{ static dchar c;
return (cast(dchar *)&c)[0 .. 1];
}
}

39
runtime/internal/typeinfo/ti_delegate.d
View File

@@ -1,39 +0,0 @@
// delegate
module typeinfo.ti_delegate;
alias void delegate(int) dg;
class TypeInfo_D : TypeInfo
{
hash_t getHash(void *p)
{ long l = *cast(long *)p;
return cast(uint)(l + (l >> 32));
}
int equals(void *p1, void *p2)
{
return *cast(dg *)p1 == *cast(dg *)p2;
}
size_t tsize()
{
return dg.sizeof;
}
void swap(void *p1, void *p2)
{
dg t;
t = *cast(dg *)p1;
*cast(dg *)p1 = *cast(dg *)p2;
*cast(dg *)p2 = t;
}
uint flags()
{
return 1;
}
}

65
runtime/internal/typeinfo/ti_double.d
View File

@@ -1,65 +0,0 @@
// double
module typeinfo.ti_double;
class TypeInfo_d : TypeInfo
{
char[] toString() { return "double"; }
hash_t getHash(void *p)
{
return (cast(uint *)p)[0] + (cast(uint *)p)[1];
}
static int _equals(double f1, double f2)
{
return f1 == f2 ||
(f1 !<>= f1 && f2 !<>= f2);
}
static int _compare(double d1, double d2)
{
if (d1 !<>= d2) // if either are NaN
{
if (d1 !<>= d1)
{ if (d2 !<>= d2)
return 0;
return -1;
}
return 1;
}
return (d1 == d2) ? 0 : ((d1 < d2) ? -1 : 1);
}
int equals(void *p1, void *p2)
{
return _equals(*cast(double *)p1, *cast(double *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(double *)p1, *cast(double *)p2);
}
size_t tsize()
{
return double.sizeof;
}
void swap(void *p1, void *p2)
{
double t;
t = *cast(double *)p1;
*cast(double *)p1 = *cast(double *)p2;
*cast(double *)p2 = t;
}
void[] init()
{ static double r;
return (cast(double *)&r)[0 .. 1];
}
}

64
runtime/internal/typeinfo/ti_float.d
View File

@@ -1,64 +0,0 @@
// float
module typeinfo.ti_float;
class TypeInfo_f : TypeInfo
{
char[] toString() { return "float"; }
hash_t getHash(void *p)
{
return *cast(uint *)p;
}
static int _equals(float f1, float f2)
{
return f1 == f2 ||
(f1 !<>= f1 && f2 !<>= f2);
}
static int _compare(float d1, float d2)
{
if (d1 !<>= d2) // if either are NaN
{
if (d1 !<>= d1)
{ if (d2 !<>= d2)
return 0;
return -1;
}
return 1;
}
return (d1 == d2) ? 0 : ((d1 < d2) ? -1 : 1);
}
int equals(void *p1, void *p2)
{
return _equals(*cast(float *)p1, *cast(float *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(float *)p1, *cast(float *)p2);
}
size_t tsize()
{
return float.sizeof;
}
void swap(void *p1, void *p2)
{
float t;
t = *cast(float *)p1;
*cast(float *)p1 = *cast(float *)p2;
*cast(float *)p2 = t;
}
void[] init()
{ static float r;
return (cast(float *)&r)[0 .. 1];
}
}

12
runtime/internal/typeinfo/ti_idouble.d
View File

@@ -1,12 +0,0 @@
// idouble
module typeinfo.ti_idouble;
private import typeinfo.ti_double;
class TypeInfo_p : TypeInfo_d
{
char[] toString() { return "idouble"; }
}

12
runtime/internal/typeinfo/ti_ifloat.d
View File

@@ -1,12 +0,0 @@
// ifloat
module typeinfo.ti_ifloat;
private import typeinfo.ti_float;
class TypeInfo_o : TypeInfo_f
{
char[] toString() { return "ifloat"; }
}

43
runtime/internal/typeinfo/ti_int.d
View File

@@ -1,43 +0,0 @@
// int
module typeinfo.ti_int;
class TypeInfo_i : TypeInfo
{
char[] toString() { return "int"; }
hash_t getHash(void *p)
{
return *cast(uint *)p;
}
int equals(void *p1, void *p2)
{
return *cast(uint *)p1 == *cast(uint *)p2;
}
int compare(void *p1, void *p2)
{
if (*cast(int*) p1 < *cast(int*) p2)
return -1;
else if (*cast(int*) p1 > *cast(int*) p2)
return 1;
return 0;
}
size_t tsize()
{
return int.sizeof;
}
void swap(void *p1, void *p2)
{
int t;
t = *cast(int *)p1;
*cast(int *)p1 = *cast(int *)p2;
*cast(int *)p2 = t;
}
}

12
runtime/internal/typeinfo/ti_ireal.d
View File

@@ -1,12 +0,0 @@
// ireal
module typeinfo.ti_ireal;
private import typeinfo.ti_real;
class TypeInfo_j : TypeInfo_e
{
char[] toString() { return "ireal"; }
}

43
runtime/internal/typeinfo/ti_long.d
View File

@@ -1,43 +0,0 @@
// long
module typeinfo.ti_long;
class TypeInfo_l : TypeInfo
{
char[] toString() { return "long"; }
hash_t getHash(void *p)
{
return *cast(uint *)p + (cast(uint *)p)[1];
}
int equals(void *p1, void *p2)
{
return *cast(long *)p1 == *cast(long *)p2;
}
int compare(void *p1, void *p2)
{
if (*cast(long *)p1 < *cast(long *)p2)
return -1;
else if (*cast(long *)p1 > *cast(long *)p2)
return 1;
return 0;
}
size_t tsize()
{
return long.sizeof;
}
void swap(void *p1, void *p2)
{
long t;
t = *cast(long *)p1;
*cast(long *)p1 = *cast(long *)p2;
*cast(long *)p2 = t;
}
}

46
runtime/internal/typeinfo/ti_ptr.d
View File

@@ -1,46 +0,0 @@
// pointer
module typeinfo.ti_ptr;
class TypeInfo_P : TypeInfo
{
hash_t getHash(void *p)
{
return cast(uint)*cast(void* *)p;
}
int equals(void *p1, void *p2)
{
return *cast(void* *)p1 == *cast(void* *)p2;
}
int compare(void *p1, void *p2)
{
auto c = *cast(void* *)p1 - *cast(void* *)p2;
if (c < 0)
return -1;
else if (c > 0)
return 1;
return 0;
}
size_t tsize()
{
return (void*).sizeof;
}
void swap(void *p1, void *p2)
{
void* t;
t = *cast(void* *)p1;
*cast(void* *)p1 = *cast(void* *)p2;
*cast(void* *)p2 = t;
}
uint flags()
{
return 1;
}
}

64
runtime/internal/typeinfo/ti_real.d
View File

@@ -1,64 +0,0 @@
// real
module typeinfo.ti_real;
class TypeInfo_e : TypeInfo
{
char[] toString() { return "real"; }
hash_t getHash(void *p)
{
return (cast(uint *)p)[0] + (cast(uint *)p)[1] + (cast(ushort *)p)[4];
}
static int _equals(real f1, real f2)
{
return f1 == f2 ||
(f1 !<>= f1 && f2 !<>= f2);
}
static int _compare(real d1, real d2)
{
if (d1 !<>= d2) // if either are NaN
{
if (d1 !<>= d1)
{ if (d2 !<>= d2)
return 0;
return -1;
}
return 1;
}
return (d1 == d2) ? 0 : ((d1 < d2) ? -1 : 1);
}
int equals(void *p1, void *p2)
{
return _equals(*cast(real *)p1, *cast(real *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(real *)p1, *cast(real *)p2);
}
size_t tsize()
{
return real.sizeof;
}
void swap(void *p1, void *p2)
{
real t;
t = *cast(real *)p1;
*cast(real *)p1 = *cast(real *)p2;
*cast(real *)p2 = t;
}
void[] init()
{ static real r;
return (cast(real *)&r)[0 .. 1];
}
}

39
runtime/internal/typeinfo/ti_short.d
View File

@@ -1,39 +0,0 @@
// short
module typeinfo.ti_short;
class TypeInfo_s : TypeInfo
{
char[] toString() { return "short"; }
hash_t getHash(void *p)
{
return *cast(short *)p;
}
int equals(void *p1, void *p2)
{
return *cast(short *)p1 == *cast(short *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(short *)p1 - *cast(short *)p2;
}
size_t tsize()
{
return short.sizeof;
}
void swap(void *p1, void *p2)
{
short t;
t = *cast(short *)p1;
*cast(short *)p1 = *cast(short *)p2;
*cast(short *)p2 = t;
}
}

43
runtime/internal/typeinfo/ti_ubyte.d
View File

@@ -1,43 +0,0 @@
// ubyte
module typeinfo.ti_ubyte;
class TypeInfo_h : TypeInfo
{
char[] toString() { return "ubyte"; }
hash_t getHash(void *p)
{
return *cast(ubyte *)p;
}
int equals(void *p1, void *p2)
{
return *cast(ubyte *)p1 == *cast(ubyte *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(ubyte *)p1 - *cast(ubyte *)p2;
}
size_t tsize()
{
return ubyte.sizeof;
}
void swap(void *p1, void *p2)
{
ubyte t;
t = *cast(ubyte *)p1;
*cast(ubyte *)p1 = *cast(ubyte *)p2;
*cast(ubyte *)p2 = t;
}
}
class TypeInfo_b : TypeInfo_h
{
char[] toString() { return "bool"; }
}

43
runtime/internal/typeinfo/ti_uint.d
View File

@@ -1,43 +0,0 @@
// uint
module typeinfo.ti_uint;
class TypeInfo_k : TypeInfo
{
char[] toString() { return "uint"; }
hash_t getHash(void *p)
{
return *cast(uint *)p;
}
int equals(void *p1, void *p2)
{
return *cast(uint *)p1 == *cast(uint *)p2;
}
int compare(void *p1, void *p2)
{
if (*cast(uint*) p1 < *cast(uint*) p2)
return -1;
else if (*cast(uint*) p1 > *cast(uint*) p2)
return 1;
return 0;
}
size_t tsize()
{
return uint.sizeof;
}
void swap(void *p1, void *p2)
{
int t;
t = *cast(uint *)p1;
*cast(uint *)p1 = *cast(uint *)p2;
*cast(uint *)p2 = t;
}
}

43
runtime/internal/typeinfo/ti_ulong.d
View File

@@ -1,43 +0,0 @@
// ulong
module typeinfo.ti_ulong;
class TypeInfo_m : TypeInfo
{
char[] toString() { return "ulong"; }
hash_t getHash(void *p)
{
return *cast(uint *)p + (cast(uint *)p)[1];
}
int equals(void *p1, void *p2)
{
return *cast(ulong *)p1 == *cast(ulong *)p2;
}
int compare(void *p1, void *p2)
{
if (*cast(ulong *)p1 < *cast(ulong *)p2)
return -1;
else if (*cast(ulong *)p1 > *cast(ulong *)p2)
return 1;
return 0;
}
size_t tsize()
{
return ulong.sizeof;
}
void swap(void *p1, void *p2)
{
ulong t;
t = *cast(ulong *)p1;
*cast(ulong *)p1 = *cast(ulong *)p2;
*cast(ulong *)p2 = t;
}
}

39
runtime/internal/typeinfo/ti_ushort.d
View File

@@ -1,39 +0,0 @@
// ushort
module typeinfo.ti_ushort;
class TypeInfo_t : TypeInfo
{
char[] toString() { return "ushort"; }
hash_t getHash(void *p)
{
return *cast(ushort *)p;
}
int equals(void *p1, void *p2)
{
return *cast(ushort *)p1 == *cast(ushort *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(ushort *)p1 - *cast(ushort *)p2;
}
size_t tsize()
{
return ushort.sizeof;
}
void swap(void *p1, void *p2)
{
ushort t;
t = *cast(ushort *)p1;
*cast(ushort *)p1 = *cast(ushort *)p2;
*cast(ushort *)p2 = t;
}
}

43
runtime/internal/typeinfo/ti_void.d
View File

@@ -1,43 +0,0 @@
// void
module typeinfo.ti_void;
class TypeInfo_v : TypeInfo
{
char[] toString() { return "void"; }
hash_t getHash(void *p)
{
assert(0);
}
int equals(void *p1, void *p2)
{
return *cast(byte *)p1 == *cast(byte *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(byte *)p1 - *cast(byte *)p2;
}
size_t tsize()
{
return void.sizeof;
}
void swap(void *p1, void *p2)
{
byte t;
t = *cast(byte *)p1;
*cast(byte *)p1 = *cast(byte *)p2;
*cast(byte *)p2 = t;
}
uint flags()
{
return 1;
}
}

43
runtime/internal/typeinfo/ti_wchar.d
View File

@@ -1,43 +0,0 @@
module typeinfo.ti_wchar;
class TypeInfo_u : TypeInfo
{
char[] toString() { return "wchar"; }
hash_t getHash(void *p)
{
return *cast(wchar *)p;
}
int equals(void *p1, void *p2)
{
return *cast(wchar *)p1 == *cast(wchar *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(wchar *)p1 - *cast(wchar *)p2;
}
size_t tsize()
{
return wchar.sizeof;
}
void swap(void *p1, void *p2)
{
wchar t;
t = *cast(wchar *)p1;
*cast(wchar *)p1 = *cast(wchar *)p2;
*cast(wchar *)p2 = t;
}
void[] init()
{ static wchar c;
return (cast(wchar *)&c)[0 .. 1];
}
}

86
runtime/internal/util/console.d
View File

@@ -1,86 +0,0 @@
/*******************************************************************************
copyright: Copyright (c) 2004 Tango group. All rights reserved
license: BSD style: $(LICENSE)
version: Initial release: July 2006
Various low-level console oriented utilities
*******************************************************************************/
module util.console;
private import util.string;
version (Win32)
{
private extern (Windows) int GetStdHandle (int);
private extern (Windows) int WriteFile (int, char*, int, int*, void*);
}
else
version (Posix)
{
private extern (C) ptrdiff_t write (int, void*, size_t);
}
/+
// emit a char[] to the console. Note that Win32 does not handle utf8, but
// then neither does fprintf (stderr). This will handle redirection though.
// May need to remedy the utf8 issue
int console (char[] s)
{
version (Win32)
{
int count;
if (WriteFile (GetStdHandle(0xfffffff5), s.ptr, s.length, &count, null))
return count;
return -1;
}
else
version (Posix)
{
return write (2, s.ptr, s.length);
}
}
// emit an integer to the console
int console (uint i)
{
char[10] tmp = void;
return console (intToUtf8 (tmp, i));
}
+/
struct Console
{
Console opCall (char[] s)
{
version (Win32)
{
int count;
WriteFile (GetStdHandle(0xfffffff5), s.ptr, s.length, &count, null);
}
else
version (Posix)
{
write (2, s.ptr, s.length);
}
return *this;
}
// emit an integer to the console
Console opCall (size_t i)
{
char[25] tmp = void;
return console (intToUtf8 (tmp, i));
}
}
Console console;

106
runtime/internal/util/ctype.d
View File

@@ -1,106 +0,0 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
// Simple ASCII char classification functions
module util.ctype;
int isalnum(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_ALP|_DIG) : 0; }
int isalpha(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_ALP) : 0; }
int iscntrl(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_CTL) : 0; }
int isdigit(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_DIG) : 0; }
int islower(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_LC) : 0; }
int ispunct(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_PNC) : 0; }
int isspace(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_SPC) : 0; }
int isupper(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_UC) : 0; }
int isxdigit(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_HEX) : 0; }
int isgraph(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_ALP|_DIG|_PNC) : 0; }
int isprint(dchar c) { return (c <= 0x7F) ? _ctype[c] & (_ALP|_DIG|_PNC|_BLK) : 0; }
int isascii(dchar c) { return c <= 0x7F; }
dchar tolower(dchar c)
out (result)
{
assert(!isupper(result));
}
body
{
return isupper(c) ? c + (cast(dchar)'a' - 'A') : c;
}
dchar toupper(dchar c)
out (result)
{
assert(!islower(result));
}
body
{
return islower(c) ? c - (cast(dchar)'a' - 'A') : c;
}
private:
enum
{
_SPC = 8,
_CTL = 0x20,
_BLK = 0x40,
_HEX = 0x80,
_UC = 1,
_LC = 2,
_PNC = 0x10,
_DIG = 4,
_ALP = _UC|_LC,
}
ubyte _ctype[128] =
[
_CTL,_CTL,_CTL,_CTL,_CTL,_CTL,_CTL,_CTL,
_CTL,_CTL|_SPC,_CTL|_SPC,_CTL|_SPC,_CTL|_SPC,_CTL|_SPC,_CTL,_CTL,
_CTL,_CTL,_CTL,_CTL,_CTL,_CTL,_CTL,_CTL,
_CTL,_CTL,_CTL,_CTL,_CTL,_CTL,_CTL,_CTL,
_SPC|_BLK,_PNC,_PNC,_PNC,_PNC,_PNC,_PNC,_PNC,
_PNC,_PNC,_PNC,_PNC,_PNC,_PNC,_PNC,_PNC,
_DIG|_HEX,_DIG|_HEX,_DIG|_HEX,_DIG|_HEX,_DIG|_HEX,
_DIG|_HEX,_DIG|_HEX,_DIG|_HEX,_DIG|_HEX,_DIG|_HEX,
_PNC,_PNC,_PNC,_PNC,_PNC,_PNC,
_PNC,_UC|_HEX,_UC|_HEX,_UC|_HEX,_UC|_HEX,_UC|_HEX,_UC|_HEX,_UC,
_UC,_UC,_UC,_UC,_UC,_UC,_UC,_UC,
_UC,_UC,_UC,_UC,_UC,_UC,_UC,_UC,
_UC,_UC,_UC,_PNC,_PNC,_PNC,_PNC,_PNC,
_PNC,_LC|_HEX,_LC|_HEX,_LC|_HEX,_LC|_HEX,_LC|_HEX,_LC|_HEX,_LC,
_LC,_LC,_LC,_LC,_LC,_LC,_LC,_LC,
_LC,_LC,_LC,_LC,_LC,_LC,_LC,_LC,
_LC,_LC,_LC,_PNC,_PNC,_PNC,_PNC,_CTL
];
unittest
{
assert(isspace(' '));
assert(!isspace('z'));
assert(toupper('a') == 'A');
assert(tolower('Q') == 'q');
assert(!isxdigit('G'));
}

50
runtime/internal/util/string.d
View File

@@ -1,50 +0,0 @@
/*******************************************************************************
copyright: Copyright (c) 2004 Tango group. All rights reserved
license: BSD style: $(LICENSE)
version: Initial release: July 2006
Various char[] utilities
*******************************************************************************/
module util.string;
private import tango.stdc.string;
// convert uint to char[], within the given buffer
// Returns a valid slice of the populated buffer
char[] intToUtf8 (char[] tmp, size_t val)
in {
assert (tmp.length >= 20, "atoi buffer should be 20 or more chars wide");
}
body
{
char* p = tmp.ptr + tmp.length;
do {
*--p = cast(char)((val % 10) + '0');
} while (val /= 10);
return tmp [cast(size_t)(p - tmp.ptr) .. $];
}
// function to compare two strings
int stringCompare (char[] s1, char[] s2)
{
auto len = s1.length;
if (s2.length < len)
len = s2.length;
int result = memcmp(s1.ptr, s2.ptr, len);
if (result == 0)
result = cast(int)s1.length - cast(int)s2.length;
return result;
}

851
runtime/internal/util/utf.d
View File

@@ -1,851 +0,0 @@
// utf.d
/*
* Copyright (C) 2003-2004 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
// Description of UTF-8 at:
// http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
// http://anubis.dkuug.dk/JTC1/SC2/WG2/docs/n1335
module util.utf;
extern (C) void onUnicodeError( char[] msg, size_t idx );
bool isValidDchar(dchar c)
{
/* Note: FFFE and FFFF are specifically permitted by the
* Unicode standard for application internal use, but are not
* allowed for interchange.
* (thanks to Arcane Jill)
*/
return c < 0xD800 ||
(c > 0xDFFF && c <= 0x10FFFF /*&& c != 0xFFFE && c != 0xFFFF*/);
}
unittest
{
debug(utf) printf("utf.isValidDchar.unittest\n");
assert(isValidDchar(cast(dchar)'a') == true);
assert(isValidDchar(cast(dchar)0x1FFFFF) == false);
}
/* This array gives the length of a UTF-8 sequence indexed by the value
* of the leading byte. An FF represents an illegal starting value of
* a UTF-8 sequence.
* FF is used instead of 0 to avoid having loops hang.
*/
ubyte[256] UTF8stride =
[
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
4,4,4,4,4,4,4,4,5,5,5,5,6,6,0xFF,0xFF,
];
uint stride(char[] s, size_t i)
{
return UTF8stride[s[i]];
}
uint stride(wchar[] s, size_t i)
{ uint u = s[i];
return 1 + (u >= 0xD800 && u <= 0xDBFF);
}
uint stride(dchar[] s, size_t i)
{
return 1;
}
/*******************************************
* Given an index into an array of char's,
* and assuming that index is at the start of a UTF character,
* determine the number of UCS characters up to that index.
*/
size_t toUCSindex(char[] s, size_t i)
{
size_t n;
size_t j;
size_t stride;
for (j = 0; j < i; j += stride)
{
stride = UTF8stride[s[j]];
if (stride == 0xFF)
goto Lerr;
n++;
}
if (j > i)
{
Lerr:
onUnicodeError("invalid UTF-8 sequence", j);
}
return n;
}
size_t toUCSindex(wchar[] s, size_t i)
{
size_t n;
size_t j;
for (j = 0; j < i; )
{ uint u = s[j];
j += 1 + (u >= 0xD800 && u <= 0xDBFF);
n++;
}
if (j > i)
{
Lerr:
onUnicodeError("invalid UTF-16 sequence", j);
}
return n;
}
size_t toUCSindex(dchar[] s, size_t i)
{
return i;
}
/******************************************
* Given a UCS index into an array of characters, return the UTF index.
*/
size_t toUTFindex(char[] s, size_t n)
{
size_t i;
while (n--)
{
uint j = UTF8stride[s[i]];
if (j == 0xFF)
onUnicodeError("invalid UTF-8 sequence", i);
i += j;
}
return i;
}
size_t toUTFindex(wchar[] s, size_t n)
{
size_t i;
while (n--)
{ wchar u = s[i];
i += 1 + (u >= 0xD800 && u <= 0xDBFF);
}
return i;
}
size_t toUTFindex(dchar[] s, size_t n)
{
return n;
}
/* =================== Decode ======================= */
dchar decode(char[] s, inout size_t idx)
in
{
assert(idx >= 0 && idx < s.length);
}
out (result)
{
assert(isValidDchar(result));
}
body
{
size_t len = s.length;
dchar V;
size_t i = idx;
char u = s[i];
if (u & 0x80)
{ uint n;
char u2;
/* The following encodings are valid, except for the 5 and 6 byte
* combinations:
* 0xxxxxxx
* 110xxxxx 10xxxxxx
* 1110xxxx 10xxxxxx 10xxxxxx
* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
* 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
* 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
*/
for (n = 1; ; n++)
{
if (n > 4)
goto Lerr; // only do the first 4 of 6 encodings
if (((u << n) & 0x80) == 0)
{
if (n == 1)
goto Lerr;
break;
}
}
// Pick off (7 - n) significant bits of B from first byte of octet
V = cast(dchar)(u & ((1 << (7 - n)) - 1));
if (i + (n - 1) >= len)
goto Lerr; // off end of string
/* The following combinations are overlong, and illegal:
* 1100000x (10xxxxxx)
* 11100000 100xxxxx (10xxxxxx)
* 11110000 1000xxxx (10xxxxxx 10xxxxxx)
* 11111000 10000xxx (10xxxxxx 10xxxxxx 10xxxxxx)
* 11111100 100000xx (10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx)
*/
u2 = s[i + 1];
if ((u & 0xFE) == 0xC0 ||
(u == 0xE0 && (u2 & 0xE0) == 0x80) ||
(u == 0xF0 && (u2 & 0xF0) == 0x80) ||
(u == 0xF8 && (u2 & 0xF8) == 0x80) ||
(u == 0xFC && (u2 & 0xFC) == 0x80))
goto Lerr; // overlong combination
for (uint j = 1; j != n; j++)
{
u = s[i + j];
if ((u & 0xC0) != 0x80)
goto Lerr; // trailing bytes are 10xxxxxx
V = (V << 6) | (u & 0x3F);
}
if (!isValidDchar(V))
goto Lerr;
i += n;
}
else
{
V = cast(dchar) u;
i++;
}
idx = i;
return V;
Lerr:
onUnicodeError("invalid UTF-8 sequence", i);
return V; // dummy return
}
unittest
{ size_t i;
dchar c;
debug(utf) printf("utf.decode.unittest\n");
static char[] s1 = "abcd";
i = 0;
c = decode(s1, i);
assert(c == cast(dchar)'a');
assert(i == 1);
c = decode(s1, i);
assert(c == cast(dchar)'b');
assert(i == 2);
static char[] s2 = "\xC2\xA9";
i = 0;
c = decode(s2, i);
assert(c == cast(dchar)'\u00A9');
assert(i == 2);
static char[] s3 = "\xE2\x89\xA0";
i = 0;
c = decode(s3, i);
assert(c == cast(dchar)'\u2260');
assert(i == 3);
static char[][] s4 =
[ "\xE2\x89", // too short
"\xC0\x8A",
"\xE0\x80\x8A",
"\xF0\x80\x80\x8A",
"\xF8\x80\x80\x80\x8A",
"\xFC\x80\x80\x80\x80\x8A",
];
for (int j = 0; j < s4.length; j++)
{
try
{
i = 0;
c = decode(s4[j], i);
assert(0);
}
catch (Object o)
{
i = 23;
}
assert(i == 23);
}
}
/********************************************************/
dchar decode(wchar[] s, inout size_t idx)
in
{
assert(idx >= 0 && idx < s.length);
}
out (result)
{
assert(isValidDchar(result));
}
body
{
char[] msg;
dchar V;
size_t i = idx;
uint u = s[i];
if (u & ~0x7F)
{ if (u >= 0xD800 && u <= 0xDBFF)
{ uint u2;
if (i + 1 == s.length)
{ msg = "surrogate UTF-16 high value past end of string";
goto Lerr;
}
u2 = s[i + 1];
if (u2 < 0xDC00 || u2 > 0xDFFF)
{ msg = "surrogate UTF-16 low value out of range";
goto Lerr;
}
u = ((u - 0xD7C0) << 10) + (u2 - 0xDC00);
i += 2;
}
else if (u >= 0xDC00 && u <= 0xDFFF)
{ msg = "unpaired surrogate UTF-16 value";
goto Lerr;
}
else if (u == 0xFFFE || u == 0xFFFF)
{ msg = "illegal UTF-16 value";
goto Lerr;
}
else
i++;
}
else
{
i++;
}
idx = i;
return cast(dchar)u;
Lerr:
onUnicodeError(msg, i);
return cast(dchar)u; // dummy return
}
/********************************************************/
dchar decode(dchar[] s, inout size_t idx)
in
{
assert(idx >= 0 && idx < s.length);
}
body
{
size_t i = idx;
dchar c = s[i];
if (!isValidDchar(c))
goto Lerr;
idx = i + 1;
return c;
Lerr:
onUnicodeError("invalid UTF-32 value", i);
return c; // dummy return
}
/* =================== Encode ======================= */
void encode(inout char[] s, dchar c)
in
{
assert(isValidDchar(c));
}
body
{
char[] r = s;
if (c <= 0x7F)
{
r ~= cast(char) c;
}
else
{
char[4] buf;
uint L;
if (c <= 0x7FF)
{
buf[0] = cast(char)(0xC0 | (c >> 6));
buf[1] = cast(char)(0x80 | (c & 0x3F));
L = 2;
}
else if (c <= 0xFFFF)
{
buf[0] = cast(char)(0xE0 | (c >> 12));
buf[1] = cast(char)(0x80 | ((c >> 6) & 0x3F));
buf[2] = cast(char)(0x80 | (c & 0x3F));
L = 3;
}
else if (c <= 0x10FFFF)
{
buf[0] = cast(char)(0xF0 | (c >> 18));
buf[1] = cast(char)(0x80 | ((c >> 12) & 0x3F));
buf[2] = cast(char)(0x80 | ((c >> 6) & 0x3F));
buf[3] = cast(char)(0x80 | (c & 0x3F));
L = 4;
}
else
{
assert(0);
}
r ~= buf[0 .. L];
}
s = r;
}
unittest
{
debug(utf) printf("utf.encode.unittest\n");
char[] s = "abcd";
encode(s, cast(dchar)'a');
assert(s.length == 5);
assert(s == "abcda");
encode(s, cast(dchar)'\u00A9');
assert(s.length == 7);
assert(s == "abcda\xC2\xA9");
//assert(s == "abcda\u00A9"); // BUG: fix compiler
encode(s, cast(dchar)'\u2260');
assert(s.length == 10);
assert(s == "abcda\xC2\xA9\xE2\x89\xA0");
}
/********************************************************/
void encode(inout wchar[] s, dchar c)
in
{
assert(isValidDchar(c));
}
body
{
wchar[] r = s;
if (c <= 0xFFFF)
{
r ~= cast(wchar) c;
}
else
{
wchar[2] buf;
buf[0] = cast(wchar) ((((c - 0x10000) >> 10) & 0x3FF) + 0xD800);
buf[1] = cast(wchar) (((c - 0x10000) & 0x3FF) + 0xDC00);
r ~= buf;
}
s = r;
}
void encode(inout dchar[] s, dchar c)
in
{
assert(isValidDchar(c));
}
body
{
s ~= c;
}
/* =================== Validation ======================= */
void validate(char[] s)
{
size_t len = s.length;
size_t i;
for (i = 0; i < len; )
{
decode(s, i);
}
}
void validate(wchar[] s)
{
size_t len = s.length;
size_t i;
for (i = 0; i < len; )
{
decode(s, i);
}
}
void validate(dchar[] s)
{
size_t len = s.length;
size_t i;
for (i = 0; i < len; )
{
decode(s, i);
}
}
/* =================== Conversion to UTF8 ======================= */
char[] toUTF8(char[4] buf, dchar c)
in
{
assert(isValidDchar(c));
}
body
{
if (c <= 0x7F)
{
buf[0] = cast(char) c;
return buf[0 .. 1];
}
else if (c <= 0x7FF)
{
buf[0] = cast(char)(0xC0 | (c >> 6));
buf[1] = cast(char)(0x80 | (c & 0x3F));
return buf[0 .. 2];
}
else if (c <= 0xFFFF)
{
buf[0] = cast(char)(0xE0 | (c >> 12));
buf[1] = cast(char)(0x80 | ((c >> 6) & 0x3F));
buf[2] = cast(char)(0x80 | (c & 0x3F));
return buf[0 .. 3];
}
else if (c <= 0x10FFFF)
{
buf[0] = cast(char)(0xF0 | (c >> 18));
buf[1] = cast(char)(0x80 | ((c >> 12) & 0x3F));
buf[2] = cast(char)(0x80 | ((c >> 6) & 0x3F));
buf[3] = cast(char)(0x80 | (c & 0x3F));
return buf[0 .. 4];
}
assert(0);
}
char[] toUTF8(char[] s)
in
{
validate(s);
}
body
{
return s;
}
char[] toUTF8(wchar[] s)
{
char[] r;
size_t i;
size_t slen = s.length;
r.length = slen;
for (i = 0; i < slen; i++)
{ wchar c = s[i];
if (c <= 0x7F)
r[i] = cast(char)c; // fast path for ascii
else
{
r.length = i;
foreach (dchar c; s[i .. slen])
{
encode(r, c);
}
break;
}
}
return r;
}
char[] toUTF8(dchar[] s)
{
char[] r;
size_t i;
size_t slen = s.length;
r.length = slen;
for (i = 0; i < slen; i++)
{ dchar c = s[i];
if (c <= 0x7F)
r[i] = cast(char)c; // fast path for ascii
else
{
r.length = i;
foreach (dchar d; s[i .. slen])
{
encode(r, d);
}
break;
}
}
return r;
}
/* =================== Conversion to UTF16 ======================= */
wchar[] toUTF16(wchar[2] buf, dchar c)
in
{
assert(isValidDchar(c));
}
body
{
if (c <= 0xFFFF)
{
buf[0] = cast(wchar) c;
return buf[0 .. 1];
}
else
{
buf[0] = cast(wchar) ((((c - 0x10000) >> 10) & 0x3FF) + 0xD800);
buf[1] = cast(wchar) (((c - 0x10000) & 0x3FF) + 0xDC00);
return buf[0 .. 2];
}
}
wchar[] toUTF16(char[] s)
{
wchar[] r;
size_t slen = s.length;
r.length = slen;
r.length = 0;
for (size_t i = 0; i < slen; )
{
dchar c = s[i];
if (c <= 0x7F)
{
i++;
r ~= cast(wchar)c;
}
else
{
c = decode(s, i);
encode(r, c);
}
}
return r;
}
wchar* toUTF16z(char[] s)
{
wchar[] r;
size_t slen = s.length;
r.length = slen + 1;
r.length = 0;
for (size_t i = 0; i < slen; )
{
dchar c = s[i];
if (c <= 0x7F)
{
i++;
r ~= cast(wchar)c;
}
else
{
c = decode(s, i);
encode(r, c);
}
}
r ~= "\000";
return r.ptr;
}
wchar[] toUTF16(wchar[] s)
in
{
validate(s);
}
body
{
return s;
}
wchar[] toUTF16(dchar[] s)
{
wchar[] r;
size_t slen = s.length;
r.length = slen;
r.length = 0;
for (size_t i = 0; i < slen; i++)
{
encode(r, s[i]);
}
return r;
}
/* =================== Conversion to UTF32 ======================= */
dchar[] toUTF32(char[] s)
{
dchar[] r;
size_t slen = s.length;
size_t j = 0;
r.length = slen; // r[] will never be longer than s[]
for (size_t i = 0; i < slen; )
{
dchar c = s[i];
if (c >= 0x80)
c = decode(s, i);
else
i++; // c is ascii, no need for decode
r[j++] = c;
}
return r[0 .. j];
}
dchar[] toUTF32(wchar[] s)
{
dchar[] r;
size_t slen = s.length;
size_t j = 0;
r.length = slen; // r[] will never be longer than s[]
for (size_t i = 0; i < slen; )
{
dchar c = s[i];
if (c >= 0x80)
c = decode(s, i);
else
i++; // c is ascii, no need for decode
r[j++] = c;
}
return r[0 .. j];
}
dchar[] toUTF32(dchar[] s)
in
{
validate(s);
}
body
{
return s;
}
/* ================================ tests ================================== */
unittest
{
debug(utf) printf("utf.toUTF.unittest\n");
char[] c;
wchar[] w;
dchar[] d;
c = "hello";
w = toUTF16(c);
assert(w == "hello");
d = toUTF32(c);
assert(d == "hello");
c = toUTF8(w);
assert(c == "hello");
d = toUTF32(w);
assert(d == "hello");
c = toUTF8(d);
assert(c == "hello");
w = toUTF16(d);
assert(w == "hello");
c = "hel\u1234o";
w = toUTF16(c);
assert(w == "hel\u1234o");
d = toUTF32(c);
assert(d == "hel\u1234o");
c = toUTF8(w);
assert(c == "hel\u1234o");
d = toUTF32(w);
assert(d == "hel\u1234o");
c = toUTF8(d);
assert(c == "hel\u1234o");
w = toUTF16(d);
assert(w == "hel\u1234o");
c = "he\U0010AAAAllo";
w = toUTF16(c);
//foreach (wchar c; w) printf("c = x%x\n", c);
//foreach (wchar c; cast(wchar[])"he\U0010AAAAllo") printf("c = x%x\n", c);
assert(w == "he\U0010AAAAllo");
d = toUTF32(c);
assert(d == "he\U0010AAAAllo");
c = toUTF8(w);
assert(c == "he\U0010AAAAllo");
d = toUTF32(w);
assert(d == "he\U0010AAAAllo");
c = toUTF8(d);
assert(c == "he\U0010AAAAllo");
w = toUTF16(d);
assert(w == "he\U0010AAAAllo");
}

178
runtime/lib/common/tango/ldc.mak
View File

@@ -1,178 +0,0 @@
# Makefile to build the common D runtime library for LLVM
# Designed to work with GNU make
# Targets:
# make
# Same as make all
# make lib
# Build the common library
# make doc
# Generate documentation
# make clean
# Delete unneeded files created by build process
LIB_TARGET_FULL=libtango-cc-tango.a
LIB_TARGET_BC_ONLY=libtango-cc-tango-bc-only.a
LIB_TARGET_C_ONLY=libtango-cc-tango-c-only.a
LIB_TARGET_SHARED=libtango-cc-tango-shared.so
LIB_MASK=libtango-cc-tango*.*
CP=cp -f
RM=rm -f
MD=mkdir -p
ADD_CFLAGS=
ADD_DFLAGS=
#CFLAGS=-O3 $(ADD_CFLAGS)
CFLAGS=$(ADD_CFLAGS)
#DFLAGS=-release -O3 -inline -w $(ADD_DFLAGS)
DFLAGS=-w $(ADD_DFLAGS)
#TFLAGS=-O3 -inline -w $(ADD_DFLAGS)
TFLAGS=-w $(ADD_DFLAGS)
DOCFLAGS=-version=DDoc
CC=gcc
LC=llvm-ar rsv
LLINK=llvm-link
LCC=llc
CLC=ar rsv
DC=ldc
LLC=llvm-as
INC_DEST=../../../tango
LIB_DEST=..
DOC_DEST=../../../doc/tango
.SUFFIXES: .s .S .c .cpp .d .ll .html .o .bc
.s.o:
$(CC) -c $(CFLAGS) $< -o$@
.S.o:
$(CC) -c $(CFLAGS) $< -o$@
.c.o:
$(CC) -c $(CFLAGS) $< -o$@
.cpp.o:
g++ -c $(CFLAGS) $< -o$@
.d.o:
$(DC) -c $(DFLAGS) -Hf$*.di $< -of$@ -output-bc
.ll.bc:
$(LLC) -f -o=$@ $<
.d.html:
$(DC) -c -o- $(DOCFLAGS) -Df$*.html $<
# $(DC) -c -o- $(DOCFLAGS) -Df$*.html tango.ddoc $<
targets : lib sharedlib doc
all : lib sharedlib doc
tango : lib
lib : tango.lib tango.bclib tango.clib
sharedlib : tango.sharedlib
doc : tango.doc
######################################################
OBJ_CORE_BC= \
core/BitManip.bc \
core/Exception.bc \
core/Memory.bc \
core/Runtime.bc \
core/Thread.bc
# core/ThreadASM.o
OBJ_CORE_O= \
core/BitManip.o \
core/Exception.o \
core/Memory.o \
core/Runtime.o \
core/Thread.o
OBJ_STDC= \
stdc/wrap.o
# stdc/wrap.bc
OBJ_STDC_POSIX= \
stdc/posix/pthread_darwin.o
ALL_OBJS_BC= \
$(OBJ_CORE_BC)
# $(OBJ_STDC)
# $(OBJ_STDC_POSIX)
ALL_OBJS_O= \
$(OBJ_CORE_O) \
$(OBJ_STDC)
# $(OBJ_STDC_POSIX)
######################################################
DOC_CORE= \
core/BitManip.html \
core/Exception.html \
core/Memory.html \
core/Runtime.html \
core/Thread.html
ALL_DOCS=
######################################################
tango.bclib : $(LIB_TARGET_BC_ONLY)
tango.lib : $(LIB_TARGET_FULL)
tango.clib : $(LIB_TARGET_C_ONLY)
tango.sharedlib : $(LIB_TARGET_SHARED)
$(LIB_TARGET_BC_ONLY) : $(ALL_OBJS_O)
$(RM) $@
$(LC) $@ $(ALL_OBJS_BC)
$(LIB_TARGET_FULL) : $(ALL_OBJS_O)
$(RM) $@
$(CLC) $@ $(ALL_OBJS_O)
$(LIB_TARGET_C_ONLY) : $(OBJ_STDC)
$(RM) $@
$(CLC) $@ $(OBJ_STDC)
$(LIB_TARGET_SHARED) : $(ALL_OBJS_O)
$(RM) $@
$(CC) -shared -o $@ $(ALL_OBJS_O)
tango.doc : $(ALL_DOCS)
echo Documentation generated.
######################################################
### stdc/posix
#stdc/posix/pthread_darwin.o : stdc/posix/pthread_darwin.d
# $(DC) -c $(DFLAGS) stdc/posix/pthread_darwin.d -of$@
######################################################
clean :
find . -name "*.di" | xargs $(RM)
$(RM) $(ALL_OBJS_BC)
$(RM) $(ALL_OBJS_O)
$(RM) $(ALL_DOCS)
find . -name "$(LIB_MASK)" | xargs $(RM)
install :
$(MD) $(INC_DEST)
find . -name "*.di" -exec cp -f {} $(INC_DEST)/{} \;
$(MD) $(DOC_DEST)
find . -name "*.html" -exec cp -f {} $(DOC_DEST)/{} \;
$(MD) $(LIB_DEST)
find . -name "$(LIB_MASK)" -exec cp -f {} $(LIB_DEST)/{} \;

127
runtime/lib/gc/basic/ldc.mak
View File

@@ -1,127 +0,0 @@
# Makefile to build the garbage collector D library for LDC
# Designed to work with GNU make
# Targets:
# make
# Same as make all
# make lib
# Build the garbage collector library
# make doc
# Generate documentation
# make clean
# Delete unneeded files created by build process
LIB_TARGET_BC=libtango-gc-basic-bc.a
LIB_TARGET_NATIVE=libtango-gc-basic.a
LIB_TARGET_SHARED=libtango-gc-basic-shared.so
LIB_MASK=libtango-gc-basic*.*
CP=cp -f
RM=rm -f
MD=mkdir -p
ADD_CFLAGS=
ADD_DFLAGS=
#CFLAGS=-O3 $(ADD_CFLAGS)
CFLAGS=$(ADD_CFLAGS)
#DFLAGS=-release -O3 -inline -w -nofloat $(ADD_DFLAGS)
DFLAGS=-w -disable-invariants $(ADD_DFLAGS)
#TFLAGS=-O3 -inline -w -nofloat $(ADD_DFLAGS)
TFLAGS=-w -disable-invariants $(ADD_DFLAGS)
DOCFLAGS=-version=DDoc
CC=gcc
LC=llvm-ar rsv
LCC=llc
LLINK=llvm-link
CLC=ar rsv
LD=llvm-ld
DC=ldc
LIB_DEST=..
.SUFFIXES: .s .S .c .cpp .d .html .o .bc
.s.o:
$(CC) -c $(CFLAGS) $< -o$@
.S.o:
$(CC) -c $(CFLAGS) $< -o$@
.c.o:
$(CC) -c $(CFLAGS) $< -o$@
.cpp.o:
g++ -c $(CFLAGS) $< -o$@
.d.o:
$(DC) -c $(DFLAGS) $< -of$@ -output-bc
.d.html:
$(DC) -c -o- $(DOCFLAGS) -Df$*.html $<
# $(DC) -c -o- $(DOCFLAGS) -Df$*.html dmd.ddoc $<
targets : lib sharedlib doc
all : lib sharedlib doc
lib : basic.lib basic.nlib
sharedlib : basic.sharedlib
doc : basic.doc
######################################################
ALL_OBJS_BC= \
gc.bc \
gcalloc.bc \
gcbits.bc \
gcstats.bc \
gcx.bc
ALL_OBJS_O= \
gc.o \
gcalloc.o \
gcbits.o \
gcstats.o \
gcx.o
######################################################
ALL_DOCS=
######################################################
basic.lib : $(LIB_TARGET_BC)
basic.nlib : $(LIB_TARGET_NATIVE)
basic.sharedlib : $(LIB_TARGET_SHARED)
$(LIB_TARGET_BC) : $(ALL_OBJS_O)
$(RM) $@
$(LC) $@ $(ALL_OBJS_BC)
$(LIB_TARGET_NATIVE) : $(ALL_OBJS_O)
$(RM) $@
$(CLC) $@ $(ALL_OBJS_O)
$(LIB_TARGET_SHARED) : $(ALL_OBJS_O)
$(RM) $@
$(CC) -shared -o $@ $(ALL_OBJS_O)
basic.doc : $(ALL_DOCS)
echo No documentation available.
######################################################
clean :
find . -name "*.di" | xargs $(RM)
$(RM) $(ALL_OBJS_BC)
$(RM) $(ALL_OBJS_O)
$(RM) $(ALL_DOCS)
$(RM) $(LIB_MASK)
install :
$(MD) $(LIB_DEST)
$(CP) $(LIB_MASK) $(LIB_DEST)/.

96
runtime/lib/gc/stub/ldc.mak
View File

@@ -1,96 +0,0 @@
# Makefile to build the garbage collector D library for Posix
# Designed to work with GNU make
# Targets:
# make
# Same as make all
# make lib
# Build the garbage collector library
# make doc
# Generate documentation
# make clean
# Delete unneeded files created by build process
LIB_TARGET=libtango-gc-stub.a
LIB_MASK=libtango-gc-stub*.a
CP=cp -f
RM=rm -f
MD=mkdir -p
ADD_CFLAGS=
ADD_DFLAGS=
#CFLAGS=-O3 $(ADD_CFLAGS)
CFLAGS=$(ADD_CFLAGS)
#DFLAGS=-release -O3 -inline -w $(ADD_DFLAGS)
DFLAGS=$(ADD_DFLAGS)
#TFLAGS=-O3 -inline $(ADD_DFLAGS)
TFLAGS=$(ADD_DFLAGS)
DOCFLAGS=-version=DDoc
CC=gcc
LC=llvm-ar rsv
DC=ldc
LIB_DEST=..
.SUFFIXES: .s .S .c .cpp .d .html .o .bc
.s.o:
$(CC) -c $(CFLAGS) $< -o$@
.S.o:
$(CC) -c $(CFLAGS) $< -o$@
.c.o:
$(CC) -c $(CFLAGS) $< -o$@
.cpp.o:
g++ -c $(CFLAGS) $< -o$@
.d.bc:
$(DC) -c $(DFLAGS) $< -of$@
.d.html:
$(DC) -c -o- $(DOCFLAGS) -Df$*.html $<
# $(DC) -c -o- $(DOCFLAGS) -Df$*.html dmd.ddoc $<
targets : lib doc
all : lib doc
lib : stub.lib
doc : stub.doc
######################################################
ALL_OBJS= \
gc.bc
######################################################
ALL_DOCS=
######################################################
stub.lib : $(LIB_TARGET)
$(LIB_TARGET) : $(ALL_OBJS)
$(RM) $@
$(LC) $@ $(ALL_OBJS)
stub.doc : $(ALL_DOCS)
echo No documentation available.
######################################################
clean :
find . -name "*.di" | xargs $(RM)
$(RM) $(ALL_OBJS)
$(RM) $(ALL_DOCS)
$(RM) $(LIB_MASK)
install :
$(MD) $(LIB_DEST)
$(CP) $(LIB_MASK) $(LIB_DEST)/.

88
runtime/lib/ldc-posix.mak
View File

@@ -1,88 +0,0 @@
# Makefile to build the composite D runtime library for Linux
# Designed to work with GNU make
# Targets:
# make
# Same as make all
# make lib
# Build the runtime library
# make doc
# Generate documentation
# make clean
# Delete unneeded files created by build process
LIB_TARGET=libtango-base-ldc.a
LIB_MASK=libtango-base-ldc*.a
LIB_TARGET_C=libtango-base-c-ldc.a
LIB_MASK_C=libtango-base-c-ldc*.a
LIB_NAME_NATIVE=libtango-base-ldc-native
LIB_TARGET_NATIVE=$(LIB_NAME_NATIVE).a
DIR_CC=./common/tango
DIR_RT=../../runtime/internal
DIR_GC=./gc/basic
#DIR_GC=./gc/stub
CP=cp -f
RM=rm -f
MD=mkdir -p
CC=gcc
LC=llvm-ar rsv
CLC=ar rsv
DC=ldc
LLVMLINK=llvm-link
LLC=llc
ADD_CFLAGS=
#ADD_DFLAGS=
ADD_DFLAGS=-g -I`pwd`/common/
targets : lib sharedlib doc
all : lib sharedlib doc
######################################################
ALL_OBJS=
######################################################
ALL_DOCS=
######################################################
lib : $(ALL_OBJS)
make -C $(DIR_CC) -fldc.mak lib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)"
make -C $(DIR_RT) -fldc.mak lib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)"
make -C $(DIR_GC) -fldc.mak lib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)"
# could link the three parts into one here, but why should we
sharedlib : $(ALL_OBJS)
make -C $(DIR_CC) -fldc.mak sharedlib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)"
make -C $(DIR_RT) -fldc.mak sharedlib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)"
make -C $(DIR_GC) -fldc.mak sharedlib DC=$(DC) ADD_DFLAGS="$(ADD_DFLAGS)" ADD_CFLAGS="$(ADD_CFLAGS)"
# could link the three parts into one here, but why should we
doc : $(ALL_DOCS)
make -C $(DIR_CC) -fldc.mak doc
make -C $(DIR_RT) -fldc.mak doc
make -C $(DIR_GC) -fldc.mak doc
######################################################
clean :
find . -name "*.di" | xargs $(RM)
$(RM) $(ALL_OBJS)
$(RM) $(ALL_DOCS)
make -C $(DIR_CC) -fldc.mak clean
make -C $(DIR_RT) -fldc.mak clean
make -C $(DIR_GC) -fldc.mak clean
$(RM) $(LIB_MASK)
$(RM) $(LIB_MASK_C)
$(RM) $(LIB_NAME_NATIVE)*
install :
make -C $(DIR_CC) -fldc.mak install
make -C $(DIR_RT) -fldc.mak install
make -C $(DIR_GC) -fldc.mak install
$(CP) $(LIB_MASK) $(LIB_DEST)/.
$(CP) $(LIB_MASK_C) $(LIB_DEST)/.