finish prev commit with snake_case fixes

README.md

@@ -55,7 +55,7 @@ This library includes all (almost?) "aliases" to `core.stdc.*` modules in respec
 
 # Custom modules
 - [x] format (exists in C++20 specs, but my version currently is for emulating c's format function)
-- [ ] conv (just your normal type conversion)
+- [ ] conv (just your normal type conversion, right now contains only c++ "casts")
 
 ## On classes
 D's keyword `new` can't be used with noGC and to "fix" that there's two functions: `_new` and `_free` in `clib.memory` which can be used to create classes with noGC.
@@ -84,7 +84,7 @@ class DClass {}
 class DChild: DClass{}
 DChild dprt;
 if (typeid(dprt) != typeid(DClass)) printf("Not same\n");
-if (typeid(DClass).isBaseOf(typeid(DChild))) printf("Is child\n");
+if (typeid(DClass).is_base_of(typeid(DChild))) printf("Is child\n");
 
 // Clib way:
 
@@ -100,38 +100,48 @@ class CChild: CClass{
 
 CChild cprt;
 if (_typeid(cprt) != _typeid!CClass) printf("Not same\n");
-if (_typeid!CClass().isBaseOf(cprt)) printf("Is child\n");
+if (_typeid!CClass().is_base_of(cprt)) printf("Is child\n");
 ```
 
 `clib.typeinfo.reinterpret_cast` can be used to work around [known bug](https://issues.dlang.org/show_bug.cgi?id=21690).
 ```d
-import core.stdc.stdio;
-import clib.typecast;
+import clib.stdio;
+import clib.typeinfo;
 import clib.memory;
+import clib.conv;
 
 extern(C++) class ICpp: CppObject {
-    void baseFunc() @nogc nothrow { printf("ICpp func\n"); }
+    void base_func() @nogc nothrow { printf("ICpp func\n"); }
 }
 
 extern(C++) class CppClass: ICpp {
     mixin RTTI!ICpp;
-    override void baseFunc() @nogc nothrow { printf("CppClass func\n"); }
+    override void base_func() @nogc nothrow { printf("CppClass func\n"); }
 }
 
 extern(C) int main() @nogc nothrow {
     CppClass c = _new!CppClass();
 
-    void testBaseFunc(ICpp base) {
-        base.baseFunc();
-        reinterpret_cast!ICpp(base).baseFunc(); // doesn't matter as it's already ICpp
+    void test_base_func(ICpp base) {
+        base.base_func();
+        reinterpret_cast!ICpp(base).base_func(); // doesn't matter as it's already ICpp
     }
 
-    testBaseFunc(c); // will case segfault!!!
-    testBaseFunc(reinterpret_cast!ICpp(c)); // must be a cast
-    reinterpret_cast!ICpp(c).testBaseFunc(); // or treat it as member
+    test_base_func(c); // will case segfault!!!
+    test_base_func(reinterpret_cast!ICpp(c)); // must be a cast
+    reinterpret_cast!ICpp(c).test_base_func(); // or treat it as member
 }
 ```
 
+## Disable GC
+
+Before `main` function or entrance point put:
+
+```d
+import clib.memory: DISABLE_GC;
+mixin DISABLE_GC;
+```
+
 ## Development
 - [dmd / ldc / gdc](https://dlang.org/) - D compiler
 - [dub](https://code.dlang.org/) - D package manager

src/clib/conv.d

@@ -0,0 +1,39 @@
+module clib.conv;
+// TODO: add separate cast versions for C++ linkage and D classes
+
+/// Interprets F as T (dangerous, use mainly as workaround to bug 21690)
+T reinterpret_cast(T, F)(F t) @nogc nothrow {
+    return ( cast(T) cast(void*) t );
+}
+
+/// Downcasts F to T (CAN RETURN NULL IF UNABLE TO DOWNCAST)
+T dynamic_cast(T, F)(F t) @nogc nothrow if (IS_CLASS!T && IS_CLASS!F) {
+    if (_typeid!(F)().is_base_of!(T)()) {
+        return ( cast(T) cast(void*) t );
+    } else {
+        return null;
+    }
+}
+
+/// Downcasts F to T or converts scalar types (CAN RETURN NULL IF UNABLE TO DOWNCAST)
+T static_cast(T, F)(F t) @nogc nothrow
+if ((IS_CLASS!T && IS_CLASS!F) || (IS_SCALAR!T && IS_SCALAR!F)) {
+    if (IS_SCALAR_TYPE!T) {
+        return cast(T) t;
+    } else {
+        return dynamic_cast!(T, F)(t);
+    }
+}
+
+/// Performs basic type casting
+T const_cast(T, F)(F t) @nogc nothrow {
+    return cast(T) t;
+}
+
+private enum bool IS_SCALAR(T) = __traits(isScalar, T) && is(T : real);
+
+private enum bool IS_CLASS(T) =
+    (is(T == U*, U) && (is(T == class) || is(T == interface))) ||
+    (is(T == class) || is(T == interface));
+
+

src/clib/format.d

@@ -26,7 +26,7 @@ scope cstring format(A...)(const(char)[] fmt, A args) @nogc nothrow {
     char* buffer = cast(char*) malloc(len);
     snprintf(buffer, len, fmt.ptr, args);
     cstring str;
-    str.assignPointer(buffer, len);
+    str.assign_pointer(buffer, len);
     return str;
 }
 

src/clib/memory.d

@@ -8,6 +8,10 @@ module clib.memory;
 
 import clib.stdlib: malloc, realloc, free;
 
+mixin template DISABLE_GC() {
+    extern(C) __gshared string[] rt_options = [ "gcopt=disable:1" ];
+}
+
 /++
 Used to allocate/deallocate memory for classes
 

src/clib/package.d

@@ -30,6 +30,7 @@ public import
     clib.assert_,
     clib.complex,
     clib.ctype,
+    clib.conv,
     clib.errno,
     clib.exception,
     clib.fenv,

src/clib/typeinfo.d

@@ -10,6 +10,7 @@ version(CLIB_USE_TYPEINFO):
 
 import clib.string: strcmp;
 import clib.traits;
+import clib.conv;
 
 import clib.memory;
 
@@ -64,11 +65,11 @@ struct type_info {
     /// Fully qualified type name
     const char* name = "\0".ptr;
     /// Is type a pointer
-    const bool isPointer = false;
+    const bool IS_POINTER = false;
     /// Is type a function
-    const bool isFunction = false;
-    private const char[] _strName;
-    private bool _isACppObject = false;
+    const bool is_function = false;
+    private const char[] _str_name;
+    private bool _is_a_cpp_object = false;
 
     /// Returns fully qualified type name
     const(char*) toString() const { return name; }
@@ -95,18 +96,18 @@ struct type_info {
     }
 
     /// Is T a child of type_info owner
-    bool isBaseOf(T)(T t) @nogc nothrow {
-        return isBaseOf!T;
+    bool is_base_of(T)(T t) @nogc nothrow {
+        return is_base_of!T;
     }
 
     /// Ditto
-    bool isBaseOf(T)() @nogc nothrow {
-        if (isPointer || isFunction) return false;
+    bool is_base_of(T)() @nogc nothrow {
+        if (IS_POINTER || is_function) return false;
         import clib.string: strlen, memcmp;
-        if (!isSubclassOfCppObject!T) return false;
-        if (_isACppObject) return true;
+        if (!IS_SUBCLASS_OF_CPP_OBJECT!T) return false;
+        if (_is_a_cpp_object) return true;
         char[200] s = ' ';
-        char[] t = cast(char[]) _strName;
+        char[] t = cast(char[]) _str_name;
 
         s[0..2] = cast(char[]) "__";
 
@@ -131,45 +132,45 @@ struct type_info {
 }
 
 /// Queries information about type
-type_info _typeid(T)(T t) @nogc nothrow if (isSuitableForTypeID!T) {
+type_info _typeid(T)(T t) @nogc nothrow if (IS_SUITABLE_FOR_TYPEID!T) {
     return _typeid!T();
 }
 
 /// Ditto
-type_info _typeid(T)() @nogc nothrow if (isSuitableForTypeID!T) {
+type_info _typeid(T)() @nogc nothrow if (IS_SUITABLE_FOR_TYPEID!T) {
     type_info t = {
-        cast(const(char*)) __traits(fullyQualifiedName, Unqual!T).ptr,
-        isPointer!T,
-        isFunctionPointer!T || isDelegate!T,
-        cast(const(char[])) __traits(fullyQualifiedName, Unqual!T),
+        cast(const(char*)) __traits(fullyQualifiedName, UNQUAL!T).ptr,
+        IS_POINTER!T,
+        IS_FUNCTION_POINTER!T || IS_DELEGATE!T,
+        cast(const(char[])) __traits(fullyQualifiedName, UNQUAL!T),
         is(T == CppObject)
     };
 
     return t;
 }
 
-private bool isSuitableForTypeID(T)() @nogc nothrow {
+private bool IS_SUITABLE_FOR_TYPEID(T)() @nogc nothrow {
     static if (is(T == interface)) return true;
-    const bool isPtr = isAnyPointerType!T;
+    const bool isPtr = IS_ANY_POINTER_TYPE!T;
     static if (!isPtr) {
-        return isSubclassOfCppObject!T;
+        return IS_SUBCLASS_OF_CPP_OBJECT!T;
     } else {
         return true;
     }
 }
 
-private bool isSubclassOfCppObject(T)() @nogc nothrow if (!isAnyPointerType!T) {
+private bool IS_SUBCLASS_OF_CPP_OBJECT(T)() @nogc nothrow if (!IS_ANY_POINTER_TYPE!T) {
     bool isCpp = __traits(getLinkage, T) == "C++";
     bool isObj = __traits(hasMember, T, "__clib_cpp_object_identifier");
     return isCpp && isObj;
 }
 
-private bool isAnyPointerType(T)() @nogc nothrow {
-    return isPointer!T || isFunctionPointer!T || isDelegate!T;
+private bool IS_ANY_POINTER_TYPE(T)() @nogc nothrow {
+    return IS_POINTER!T || IS_FUNCTION_POINTER!T || IS_DELEGATE!T;
 }
 
 /// Injects RunTime Type Information (allows type_info to see inheritance)
-mixin template RTTI(T) if ((isSubclassOfCppObject!T || is(T == interface)) && !is(T == CppObject)) {
+mixin template RTTI(T) if ((IS_SUBCLASS_OF_CPP_OBJECT!T || is(T == interface)) && !is(T == CppObject)) {
     mixin( __cpp_class_inheritance_generator!T() );
 }
 
@@ -193,40 +194,3 @@ char[200] __cpp_class_inheritance_generator(T)() {
     return s;
 }
 
-// TODO: add separate cast versions for C++ linkage and D classes
-
-/// Interprets F as T (dangerous, use mainly as workaround to bug 21690)
-T reinterpret_cast(T, F)(F t) @nogc nothrow {
-    return ( cast(T) cast(void*) t );
-}
-
-/// Downcasts F to T (CAN RETURN NULL IF UNABLE TO DOWNCAST)
-T dynamic_cast(T, F)(F t) @nogc nothrow if (isClass!T && isClass!F) {
-    if (_typeid!(F)().isBaseOf!(T)()) {
-        return ( cast(T) cast(void*) t );
-    } else {
-        return null;
-    }
-}
-
-/// Downcasts F to T or converts scalar types (CAN RETURN NULL IF UNABLE TO DOWNCAST)
-T static_cast(T, F)(F t) @nogc nothrow
-if ((isClass!T && isClass!F) || (isScalar!T && isScalar!F)) {
-    if (isScalarType!T) {
-        return cast(T) t;
-    } else {
-        return dynamic_cast!(T, F)(t);
-    }
-}
-
-/// Performs basic type casting
-T const_cast(T, F)(F t) @nogc nothrow {
-    return cast(T) t;
-}
-
-private enum bool isScalar(T) = __traits(isScalar, T) && is(T : real);
-
-private enum bool isClass(T) =
-    (is(T == U*, U) && (is(T == class) || is(T == interface))) ||
-    (is(T == class) || is(T == interface));
-