Remove D1.0 support.

SiegeLordEx · SiegeLord · commit 58074c2bfcf1 · 2018-11-26T18:40:48.000-08:00
:'(
diff --git a/README.md b/README.md
@@ -1,9 +1,9 @@
-This is a D1.0 and D2 binding to the Allegro 5 library: http://liballeg.org/
+This is a D binding to the Allegro 5 library: http://liballeg.org/
 
 Should work fine with Allegro 5.2. Pretty much all of the cross-platform functions are bound.
 Non cross-platform functions are absent, but they will be added eventually.
 
-Tested with LDC/Tango and DMD/Phobos compilers on Linux 64 bit and DMD/Tango on Windows 32 bit (XP). See general notes below to see how to use this
+Tested with LDC and DMD compilers on Linux 64 bit and DMD on Windows 32 bit (XP). See general notes below to see how to use this
 binding in your D program.
 
 Installation
@@ -19,11 +19,6 @@ If you have LDC:
 ./build_lib_ldc.sh
 ./build_example_ldc.sh
 
-If you have LDC2:
-
-./build_lib_ldc2.sh
-./build_example_ldc2.sh
-
 If you have DMD:
 
 ./build_lib_dmd.sh
diff --git a/allegro5/allegro_android.d b/allegro5/allegro_android.d
@@ -6,7 +6,7 @@ import allegro5.internal.da5;
 nothrow @nogc extern(C)
 {
 	void al_android_set_apk_file_interface();
-	const_char* al_android_get_os_version();
+	const(char)* al_android_get_os_version();
 	void al_android_set_apk_fs_interface();
 	void _al_android_set_capture_volume_keys(ALLEGRO_DISPLAY* display, bool onoff); 
 }
diff --git a/allegro5/allegro_color.d b/allegro5/allegro_color.d
@@ -18,7 +18,7 @@ nothrow @nogc extern (C)
 	void al_color_rgb_to_hsv(float red, float green, float blue, float* hue, float* saturation, float* value);
 	void al_color_hsl_to_rgb(float hue, float saturation, float lightness, float* red, float* green, float* blue);
 	int al_color_name_to_rgb(in char* name, float* r, float* g, float* b);
-	const_char* al_color_rgb_to_name(float r, float g, float b);
+	const(char)* al_color_rgb_to_name(float r, float g, float b);
 	void al_color_cmyk_to_rgb(float cyan, float magenta, float yellow,  float key, float* red, float* green, float* blue);
 	void al_color_rgb_to_cmyk(float red, float green, float blue, float* cyan, float* magenta, float* yellow, float* key);
 	void al_color_yuv_to_rgb(float y, float u, float v,  float* red, float* green, float* blue);
diff --git a/allegro5/allegro_native_dialog.d b/allegro5/allegro_native_dialog.d
@@ -26,7 +26,7 @@ nothrow @nogc extern (C)
 
 	struct ALLEGRO_MENU_INFO
 	{
-	   const_char* caption;
+	   const(char)* caption;
 	   ushort id;
 	   int flags;
 	   ALLEGRO_BITMAP* icon;
@@ -37,7 +37,7 @@ nothrow @nogc extern (C)
 		const ALLEGRO_MENU_SEPARATOR = ALLEGRO_MENU_INFO(null, -1, 0, null);
 	}
 	
-	template ALLEGRO_START_OF_MENU(const_char[] caption, int id)
+	template ALLEGRO_START_OF_MENU(const(char)[] caption, int id)
 	{
 		const ALLEGRO_START_OF_MENU = ALLEGRO_MENU_INFO(mixin(`"` ~ caption ~ `->\0"`), id, 0, NULL);
 	}
@@ -74,7 +74,7 @@ nothrow @nogc extern (C)
 	void al_destroy_menu(ALLEGRO_MENU* menu);
 
 	/* properties */
-	const_char* al_get_menu_item_caption(ALLEGRO_MENU* menu, int pos);
+	const(char)* al_get_menu_item_caption(ALLEGRO_MENU* menu, int pos);
 	void al_set_menu_item_caption(ALLEGRO_MENU* menu, int pos, in char* caption);
 	int al_get_menu_item_flags(ALLEGRO_MENU* menu, int pos);
 	void al_set_menu_item_flags(ALLEGRO_MENU* menu, int pos, int flags);
diff --git a/allegro5/bitmap_io.d b/allegro5/bitmap_io.d
@@ -33,6 +33,6 @@ nothrow @nogc extern(C)
 	ALLEGRO_BITMAP* al_load_bitmap_flags_f(ALLEGRO_FILE* fp, in char* ident, int flags);
 	bool al_save_bitmap(in char* filename, ALLEGRO_BITMAP* bitmap);
 	bool al_save_bitmap_f(ALLEGRO_FILE* fp, in char* ident, ALLEGRO_BITMAP* bitmap);
-	const_char* al_identify_bitmap_f(ALLEGRO_FILE *fp);
-	const_char* al_identify_bitmap(const_char* filename);
+	const(char)* al_identify_bitmap_f(ALLEGRO_FILE *fp);
+	const(char)* al_identify_bitmap(const(char)* filename);
 }
diff --git a/allegro5/config.d b/allegro5/config.d
@@ -13,7 +13,7 @@ nothrow @nogc extern (C)
 	void al_add_config_section(ALLEGRO_CONFIG* config, in char* name);
 	void al_set_config_value(ALLEGRO_CONFIG* config, in char* section, in char* key, in char* value);
 	void al_add_config_comment(ALLEGRO_CONFIG* config, in char* section, in char* comment);
-	const_char* al_get_config_value(in ALLEGRO_CONFIG* config, in char* section, in char* key);
+	const(char)* al_get_config_value(in ALLEGRO_CONFIG* config, in char* section, in char* key);
 	ALLEGRO_CONFIG* al_load_config_file(in char* filename);
 	ALLEGRO_CONFIG* al_load_config_file_f(ALLEGRO_FILE* filename);
 	bool al_save_config_file(in char* filename, in ALLEGRO_CONFIG* config);
@@ -24,8 +24,8 @@ nothrow @nogc extern (C)
 	bool al_remove_config_section(ALLEGRO_CONFIG* config, in char* section);
 	bool al_remove_config_key(ALLEGRO_CONFIG* config, in char* section, in char* key);
 
-	const_char* al_get_first_config_section(in ALLEGRO_CONFIG* config, ALLEGRO_CONFIG_SECTION** iterator);
-	const_char* al_get_next_config_section(ALLEGRO_CONFIG_SECTION** iterator);
-	const_char* al_get_first_config_entry(in ALLEGRO_CONFIG* config, in char* section, ALLEGRO_CONFIG_ENTRY** iterator);
-	const_char* al_get_next_config_entry(ALLEGRO_CONFIG_ENTRY** iterator);
+	const(char)* al_get_first_config_section(in ALLEGRO_CONFIG* config, ALLEGRO_CONFIG_SECTION** iterator);
+	const(char)* al_get_next_config_section(ALLEGRO_CONFIG_SECTION** iterator);
+	const(char)* al_get_first_config_entry(in ALLEGRO_CONFIG* config, in char* section, ALLEGRO_CONFIG_ENTRY** iterator);
+	const(char)* al_get_next_config_entry(ALLEGRO_CONFIG_ENTRY** iterator);
 }
diff --git a/allegro5/d_util.d b/allegro5/d_util.d
@@ -3,12 +3,12 @@ module allegro5.d_util;
 import allegro5.allegro;
 import allegro5.internal.da5;
 
-const_ALLEGRO_USTR* dstr_to_ustr(ALLEGRO_USTR_INFO* info, const_char[] dstr)
+const(ALLEGRO_USTR)* dstr_to_ustr(ALLEGRO_USTR_INFO* info, const(char)[] dstr)
 {
 	return al_ref_buffer(info, dstr.ptr, dstr.length);
 }
 
-const_char[] ustr_to_dstr(const_ALLEGRO_USTR* ustr)
+const(char)[] ustr_to_dstr(const(ALLEGRO_USTR)* ustr)
 {
 	return al_cstr(ustr)[0..al_ustr_size(ustr)];
 }
diff --git a/allegro5/display.d b/allegro5/display.d
@@ -102,8 +102,8 @@ nothrow @nogc extern (C)
 	int  al_get_new_display_refresh_rate();
 	int  al_get_new_display_flags();
 
-	void al_set_new_window_title(const_char *title);
-	const_char* al_get_new_window_title();
+	void al_set_new_window_title(const(char) *title);
+	const(char)* al_get_new_window_title();
 
 	int al_get_display_width(ALLEGRO_DISPLAY* display);
 	int al_get_display_height(ALLEGRO_DISPLAY* display);
diff --git a/allegro5/file.d b/allegro5/file.d
@@ -4,50 +4,15 @@ import allegro5.internal.da5;
 import allegro5.path;
 import allegro5.utf8;
 
-version (Tango)
-{
-	import tango.core.Vararg : va_list;
-}
-else
-{
-	version(D_Version2)
-	{
-		import core.stdc.stdarg : va_list;
-	}
-	else
-	{
-		import std.c.stdarg : va_list;
-	}
-}
+import core.stdc.stdarg : va_list;
 
 version(Windows)
 {
 	private alias long off_t;
 }
 else
 {
-	version(Tango)
-	{
-		import tango.stdc.posix.sys.types : off_t;
-	}
-	else
-	{
-		version(D_Version2)
-		{
-			import core.sys.posix.sys.types : off_t;
-		}
-		else
-		{
-			version(linux)
-			{
-				import std.c.linux.linux : off_t;
-			}
-			else
-			{
-				import std.c.freebsd.freebsd : off_t;
-			}
-		}
-	}
+	import core.sys.posix.sys.types : off_t;
 }
 
 nothrow @nogc extern (C)
@@ -63,7 +28,7 @@ nothrow @nogc extern (C)
 		bool    function(ALLEGRO_FILE* f, long offset, int whence) fi_fseek;
 		bool    function(ALLEGRO_FILE* f) fi_feof;
 		int     function(ALLEGRO_FILE* f) fi_ferror;
-		const_char* function(ALLEGRO_FILE* f) fi_ferrmsg(ALLEGRO_FILE *f);
+		const(char)* function(ALLEGRO_FILE* f) fi_ferrmsg(ALLEGRO_FILE *f);
 		void    function(ALLEGRO_FILE* f) fi_fclearerr;
 		int     function(ALLEGRO_FILE* f, int c) fi_fungetc;
 		off_t   function(ALLEGRO_FILE* f) fi_fsize;
@@ -93,7 +58,7 @@ nothrow @nogc extern (C)
 	bool al_fseek(ALLEGRO_FILE* f, long offset, int whence);
 	bool al_feof(ALLEGRO_FILE* f);
 	int al_ferror(ALLEGRO_FILE* f);
-	const_char* al_ferrmsg(ALLEGRO_FILE *f);
+	const(char)* al_ferrmsg(ALLEGRO_FILE *f);
 	void al_fclearerr(ALLEGRO_FILE *f);
 	int al_fungetc(ALLEGRO_FILE* f, int c);
 	long al_fsize(ALLEGRO_FILE* f);
diff --git a/allegro5/fixed.d b/allegro5/fixed.d
@@ -2,23 +2,7 @@ module allegro5.fixed;
 
 import allegro5.error;
 
-version (Tango)
-{
-	import tango.stdc.errno;
-}
-else 
-{
-	version(D_Version2)
-	{
-		import core.stdc.errno;
-	}
-	else
-	{
-		import std.c.stdlib;
-		// Phobos doesn't define EDOM
-		enum { EDOM = 33 }
-	}
-}
+import core.stdc.errno;
 
 nothrow @nogc extern (C)
 {
diff --git a/allegro5/fshook.d b/allegro5/fshook.d
@@ -11,38 +11,10 @@ version(Windows)
 }
 else
 {
-	version(Tango)
-	{
-		import tango.stdc.posix.sys.types : off_t;
-	}
-	else
-	{
-		version(D_Version2)
-		{
-			import core.sys.posix.sys.types : off_t;
-		}
-		else
-		{
-			version(linux)
-			{
-				import std.c.linux.linux : off_t;
-			}
-			else
-			{
-				import std.c.freebsd.freebsd : off_t;
-			}
-		}
-	}
+	import core.sys.posix.sys.types : off_t;
 }
 
-version (Tango)
-{
-	import tango.stdc.time : time_t;
-}
-else
-{
-	import core.stdc.time : time_t;
-}
+import core.stdc.time : time_t;
 
 nothrow @nogc extern (C)
 {
@@ -65,7 +37,7 @@ nothrow @nogc extern (C)
 	{
 		ALLEGRO_FS_ENTRY* function(in char* path) fs_create_entry;
 		void              function(ALLEGRO_FS_ENTRY* e) fs_destroy_entry;
-		const_char*       function(ALLEGRO_FS_ENTRY* e) fs_entry_name;
+		const(char)*       function(ALLEGRO_FS_ENTRY* e) fs_entry_name;
 		bool              function(ALLEGRO_FS_ENTRY* e) fs_update_entry;
 		uint              function(ALLEGRO_FS_ENTRY* e) fs_entry_mode;
 		time_t            function(ALLEGRO_FS_ENTRY* e) fs_entry_atime;
@@ -90,7 +62,7 @@ nothrow @nogc extern (C)
 
 	ALLEGRO_FS_ENTRY*    al_create_fs_entry(in char* path);
 	void                 al_destroy_fs_entry(ALLEGRO_FS_ENTRY* e);
-	const_char*          al_get_fs_entry_name(ALLEGRO_FS_ENTRY* e);
+	const(char)*          al_get_fs_entry_name(ALLEGRO_FS_ENTRY* e);
 	bool                 al_update_fs_entry(ALLEGRO_FS_ENTRY* e);
 	uint                 al_get_fs_entry_mode(ALLEGRO_FS_ENTRY* e);
 	time_t               al_get_fs_entry_atime(ALLEGRO_FS_ENTRY* e);
diff --git a/allegro5/internal/da5.d b/allegro5/internal/da5.d
@@ -56,9 +56,3 @@ bool NeedsMinGW4CallingConvention() pure nothrow @nogc
 		return false;
 	}
 }
-
-
-version(D_Version2)
-	mixin(`alias const(char) const_char;`);
-else
-	alias char const_char;
diff --git a/allegro5/joystick.d b/allegro5/joystick.d
@@ -38,17 +38,17 @@ nothrow @nogc extern (C)
 	ALLEGRO_JOYSTICK* al_get_joystick(int joyn);
 	void              al_release_joystick(ALLEGRO_JOYSTICK* joystick);
 	bool              al_get_joystick_active(ALLEGRO_JOYSTICK* joystick);
-	const_char*       al_get_joystick_name(ALLEGRO_JOYSTICK* joystick);
+	const(char)*       al_get_joystick_name(ALLEGRO_JOYSTICK* joystick);
 
 	int               al_get_joystick_num_sticks(in ALLEGRO_JOYSTICK* joystick);
 	int               al_get_joystick_stick_flags(in ALLEGRO_JOYSTICK* joystick, int stick); /* junk? */
-	const_char*       al_get_joystick_stick_name(in ALLEGRO_JOYSTICK* joystick, int stick);
+	const(char)*       al_get_joystick_stick_name(in ALLEGRO_JOYSTICK* joystick, int stick);
 
 	int               al_get_joystick_num_axes(in ALLEGRO_JOYSTICK* joystick, int stick);
-	const_char*       al_get_joystick_axis_name(in ALLEGRO_JOYSTICK* joystick, int stick, int axis);
+	const(char)*       al_get_joystick_axis_name(in ALLEGRO_JOYSTICK* joystick, int stick, int axis);
 
 	int               al_get_joystick_num_buttons(in ALLEGRO_JOYSTICK* joystick);
-	const_char*       al_get_joystick_button_name(in ALLEGRO_JOYSTICK* joystick, int buttonn);
+	const(char)*       al_get_joystick_button_name(in ALLEGRO_JOYSTICK* joystick, int buttonn);
 
 	void              al_get_joystick_state(ALLEGRO_JOYSTICK* joystick, ALLEGRO_JOYSTICK_STATE* ret_state);
 
diff --git a/allegro5/keyboard.d b/allegro5/keyboard.d
@@ -23,7 +23,7 @@ nothrow @nogc extern (C)
 
 	bool  al_set_keyboard_leds(int leds);
 
-	const_char* al_keycode_to_name(int keycode);
+	const(char)* al_keycode_to_name(int keycode);
 
 	void  al_get_keyboard_state(ALLEGRO_KEYBOARD_STATE* ret_state);
 	bool  al_key_down          (in ALLEGRO_KEYBOARD_STATE* state, int keycode);
diff --git a/allegro5/path.d b/allegro5/path.d
@@ -22,27 +22,27 @@ nothrow @nogc extern (C)
 	ALLEGRO_PATH* al_clone_path(in ALLEGRO_PATH* path);
 
 	int al_get_path_num_components(in ALLEGRO_PATH* path);
-	const_char* al_get_path_component(in ALLEGRO_PATH* path, int i);
+	const(char)* al_get_path_component(in ALLEGRO_PATH* path, int i);
 	void al_replace_path_component(ALLEGRO_PATH* path, int i, in char* s);
 	void al_remove_path_component(ALLEGRO_PATH* path, int i);
 	void al_insert_path_component(ALLEGRO_PATH* path, int i, in char* s);
-	const_char* al_get_path_tail(in ALLEGRO_PATH* path);
+	const(char)* al_get_path_tail(in ALLEGRO_PATH* path);
 	void al_drop_path_tail(ALLEGRO_PATH* path);
 	void al_append_path_component(ALLEGRO_PATH* path, in char* s);
 	bool al_join_paths(ALLEGRO_PATH* path, in ALLEGRO_PATH* tail);
 	bool al_rebase_path(in ALLEGRO_PATH* head, ALLEGRO_PATH* tail);
-	const_char* al_path_cstr(in ALLEGRO_PATH* path, char delim);
+	const(char)* al_path_cstr(in ALLEGRO_PATH* path, char delim);
 	void al_destroy_path(ALLEGRO_PATH* path);
 
 	void al_set_path_drive(ALLEGRO_PATH* path, in char* drive);
-	const_char* al_get_path_drive(in ALLEGRO_PATH* path);
+	const(char)* al_get_path_drive(in ALLEGRO_PATH* path);
 
 	void al_set_path_filename(ALLEGRO_PATH* path, in char* filename);
-	const_char* al_get_path_filename(in ALLEGRO_PATH* path);
+	const(char)* al_get_path_filename(in ALLEGRO_PATH* path);
 
-	const_char* al_get_path_extension(in ALLEGRO_PATH* path);
+	const(char)* al_get_path_extension(in ALLEGRO_PATH* path);
 	bool al_set_path_extension(ALLEGRO_PATH* path, in char* extension);
-	const_char* al_get_path_basename(in ALLEGRO_PATH* path);
+	const(char)* al_get_path_basename(in ALLEGRO_PATH* path);
 
 	bool al_make_path_canonical(ALLEGRO_PATH* path);
 }
diff --git a/allegro5/shader.d b/allegro5/shader.d
@@ -31,21 +31,21 @@ nothrow @nogc extern(C)
 	const ALLEGRO_SHADER_VAR_USE_TEX_MATRIX  = "al_use_tex_matrix";
 
 	ALLEGRO_SHADER* al_create_shader(ALLEGRO_SHADER_PLATFORM platform);
-	bool al_attach_shader_source(ALLEGRO_SHADER* shader, ALLEGRO_SHADER_TYPE type, const_char* source);
-	bool al_attach_shader_source_file(ALLEGRO_SHADER* shader, ALLEGRO_SHADER_TYPE type, const_char* filename);
+	bool al_attach_shader_source(ALLEGRO_SHADER* shader, ALLEGRO_SHADER_TYPE type, const(char)* source);
+	bool al_attach_shader_source_file(ALLEGRO_SHADER* shader, ALLEGRO_SHADER_TYPE type, const(char)* filename);
 	bool al_build_shader(ALLEGRO_SHADER* shader);
-	const_char* al_get_shader_log(ALLEGRO_SHADER* shader);
+	const(char)* al_get_shader_log(ALLEGRO_SHADER* shader);
 	ALLEGRO_SHADER_PLATFORM al_get_shader_platform(ALLEGRO_SHADER* shader);
 	bool al_use_shader(ALLEGRO_SHADER* shader);
 	void al_destroy_shader(ALLEGRO_SHADER* shader);
 
-	bool al_set_shader_sampler(const_char* name, ALLEGRO_BITMAP* bitmap, int unit);
-	bool al_set_shader_matrix(const_char* name, ALLEGRO_TRANSFORM* matrix);
-	bool al_set_shader_int(const_char* name, int i);
-	bool al_set_shader_float(const_char* name, float f);
-	bool al_set_shader_int_vector(const_char* name, int num_components, int* i, int num_elems);
-	bool al_set_shader_float_vector(const_char* name, int num_components, float* f, int num_elems);
-	bool al_set_shader_bool(const_char* name, bool b);
+	bool al_set_shader_sampler(const(char)* name, ALLEGRO_BITMAP* bitmap, int unit);
+	bool al_set_shader_matrix(const(char)* name, ALLEGRO_TRANSFORM* matrix);
+	bool al_set_shader_int(const(char)* name, int i);
+	bool al_set_shader_float(const(char)* name, float f);
+	bool al_set_shader_int_vector(const(char)* name, int num_components, int* i, int num_elems);
+	bool al_set_shader_float_vector(const(char)* name, int num_components, float* f, int num_elems);
+	bool al_set_shader_bool(const(char)* name, bool b);
 
-	const_char* al_get_default_shader_source(ALLEGRO_SHADER_PLATFORM platform, ALLEGRO_SHADER_TYPE type);
+	const(char)* al_get_default_shader_source(ALLEGRO_SHADER_PLATFORM platform, ALLEGRO_SHADER_TYPE type);
 }
diff --git a/allegro5/system.d b/allegro5/system.d
diff --git a/allegro5/transformations.d b/allegro5/transformations.d
diff --git a/allegro5/utf8.d b/allegro5/utf8.d
diff --git a/build_example_ldc.sh b/build_example_ldc.sh
diff --git a/build_example_ldc2.sh b/build_example_ldc2.sh
diff --git a/build_lib_ldc.sh b/build_lib_ldc.sh
diff --git a/build_lib_ldc2.sh b/build_lib_ldc2.sh
diff --git a/example.d b/example.d

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ import allegro5.internal.da5;`
`6`	`6`	`nothrow @nogc extern(C)`
`7`	`7`	`{`
`8`	`8`	`void al_android_set_apk_file_interface();`
`9`		`- const_char* al_android_get_os_version();`
	`9`	`+ const(char)* al_android_get_os_version();`
`10`	`10`	`void al_android_set_apk_fs_interface();`
`11`	`11`	`void _al_android_set_capture_volume_keys(ALLEGRO_DISPLAY* display, bool onoff);`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ nothrow @nogc extern (C)`
`26`	`26`
`27`	`27`	`struct ALLEGRO_MENU_INFO`
`28`	`28`	`{`
`29`		`- const_char* caption;`
	`29`	`+ const(char)* caption;`
`30`	`30`	`ushort id;`
`31`	`31`	`int flags;`
`32`	`32`	`ALLEGRO_BITMAP* icon;`
`@@ -37,7 +37,7 @@ nothrow @nogc extern (C)`
`37`	`37`	`const ALLEGRO_MENU_SEPARATOR = ALLEGRO_MENU_INFO(null, -1, 0, null);`
`38`	`38`	`}`
`39`	`39`
`40`		`- template ALLEGRO_START_OF_MENU(const_char[] caption, int id)`
	`40`	`+ template ALLEGRO_START_OF_MENU(const(char)[] caption, int id)`
`41`	`41`	`{`
`42`	`42`	const ALLEGRO_START_OF_MENU = ALLEGRO_MENU_INFO(mixin(`"` ~ caption ~ `->\0"`), id, 0, NULL);
`43`	`43`	`}`
`@@ -74,7 +74,7 @@ nothrow @nogc extern (C)`
`74`	`74`	`void al_destroy_menu(ALLEGRO_MENU* menu);`
`75`	`75`
`76`	`76`	`/* properties */`
`77`		`- const_char* al_get_menu_item_caption(ALLEGRO_MENU* menu, int pos);`
	`77`	`+ const(char)* al_get_menu_item_caption(ALLEGRO_MENU* menu, int pos);`
`78`	`78`	`void al_set_menu_item_caption(ALLEGRO_MENU* menu, int pos, in char* caption);`
`79`	`79`	`int al_get_menu_item_flags(ALLEGRO_MENU* menu, int pos);`
`80`	`80`	`void al_set_menu_item_flags(ALLEGRO_MENU* menu, int pos, int flags);`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,6 @@ nothrow @nogc extern(C)`
`33`	`33`	`ALLEGRO_BITMAP* al_load_bitmap_flags_f(ALLEGRO_FILE* fp, in char* ident, int flags);`
`34`	`34`	`bool al_save_bitmap(in char* filename, ALLEGRO_BITMAP* bitmap);`
`35`	`35`	`bool al_save_bitmap_f(ALLEGRO_FILE* fp, in char* ident, ALLEGRO_BITMAP* bitmap);`
`36`		`- const_char* al_identify_bitmap_f(ALLEGRO_FILE *fp);`
`37`		`- const_char* al_identify_bitmap(const_char* filename);`
	`36`	`+ const(char)* al_identify_bitmap_f(ALLEGRO_FILE *fp);`
	`37`	`+ const(char)* al_identify_bitmap(const(char)* filename);`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,12 +3,12 @@ module allegro5.d_util;`
`3`	`3`	`import allegro5.allegro;`
`4`	`4`	`import allegro5.internal.da5;`
`5`	`5`
`6`		`-const_ALLEGRO_USTR* dstr_to_ustr(ALLEGRO_USTR_INFO* info, const_char[] dstr)`
	`6`	`+const(ALLEGRO_USTR)* dstr_to_ustr(ALLEGRO_USTR_INFO* info, const(char)[] dstr)`
`7`	`7`	`{`
`8`	`8`	`return al_ref_buffer(info, dstr.ptr, dstr.length);`
`9`	`9`	`}`
`10`	`10`
`11`		`-const_char[] ustr_to_dstr(const_ALLEGRO_USTR* ustr)`
	`11`	`+const(char)[] ustr_to_dstr(const(ALLEGRO_USTR)* ustr)`
`12`	`12`	`{`
`13`	`13`	`return al_cstr(ustr)[0..al_ustr_size(ustr)];`
`14`	`14`	`}`