Skip to content

Commit

Permalink
Fix #53: in X* -> const(X)* for DMD 2.104.0
Browse files Browse the repository at this point in the history 
The D keyword "in" for function parameters means "scope const ref"
and DMD 2.104.0, released 2023-06-01, is beginning to warn about
using "in" during extern(C). More information:

    https://dlang.org/changelog/2.104.0.html#dmd.in-externd
    DMD 2.104.0 Release Notes: Using in parameters with
    non-extern(D)/extern(C++) functions is deprecated

    https://dlang.org/changelog/2.101.0.html#dmd.previewInLink
    DMD 2.101.0 Release Notes: -preview=in disabled for non-D-non-C++
    linkage: in "is D centric, as it is an enhanced version of
    "scope const ref". As non-extern(D) functions usually are expected
    to match a specific ABI, using in is hardly a good idea."

This is an automatic conversion of all function parameters of form
    "in X* " or "in X *" without quotes
to
    "const(X)* " without quotes.

I've reviewed each change myself.
  • Loading branch information
@SimonN @SiegeLord
SimonN authored and SiegeLord committed Jun 20, 2023
1 parent 147ca7f commit 54ce16e
Show file tree
Hide file tree
Showing 27 changed files with 270 additions and 270 deletions.
4 changes: 2 additions & 2 deletions allegro5/al_debug.d
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,6 @@ module allegro5.al_debug;

nothrow @nogc extern (C)
{
void al_register_assert_handler(void function(in char* expr, in char* file, int line, in char* func) handler);
void al_register_trace_handler(void function(in char*) handler);
void al_register_assert_handler(void function(const(char)* expr, const(char)* file, int line, const(char)* func) handler);
void al_register_trace_handler(void function(const(char)*) handler);
}
110 changes: 55 additions & 55 deletions allegro5/allegro_audio.d
View file
Original file line number Diff line number Diff line change
Expand Up @@ -109,27 +109,27 @@ nothrow @nogc extern (C)
ALLEGRO_SAMPLE_INSTANCE* al_create_sample_instance(ALLEGRO_SAMPLE* data);
void al_destroy_sample_instance(ALLEGRO_SAMPLE_INSTANCE* spl);

uint al_get_sample_frequency(in ALLEGRO_SAMPLE* spl);
uint al_get_sample_length(in ALLEGRO_SAMPLE* spl);
ALLEGRO_AUDIO_DEPTH al_get_sample_depth(in ALLEGRO_SAMPLE* spl);
ALLEGRO_CHANNEL_CONF al_get_sample_channels(in ALLEGRO_SAMPLE* spl);
void* al_get_sample_data(in ALLEGRO_SAMPLE* spl);
uint al_get_sample_frequency(const(ALLEGRO_SAMPLE)* spl);
uint al_get_sample_length(const(ALLEGRO_SAMPLE)* spl);
ALLEGRO_AUDIO_DEPTH al_get_sample_depth(const(ALLEGRO_SAMPLE)* spl);
ALLEGRO_CHANNEL_CONF al_get_sample_channels(const(ALLEGRO_SAMPLE)* spl);
void* al_get_sample_data(const(ALLEGRO_SAMPLE)* spl);

uint al_get_sample_instance_frequency(in ALLEGRO_SAMPLE_INSTANCE* spl);
uint al_get_sample_instance_length(in ALLEGRO_SAMPLE_INSTANCE* spl);
uint al_get_sample_instance_position(in ALLEGRO_SAMPLE_INSTANCE* spl);
uint al_get_sample_instance_frequency(const(ALLEGRO_SAMPLE_INSTANCE)* spl);
uint al_get_sample_instance_length(const(ALLEGRO_SAMPLE_INSTANCE)* spl);
uint al_get_sample_instance_position(const(ALLEGRO_SAMPLE_INSTANCE)* spl);

float al_get_sample_instance_speed(in ALLEGRO_SAMPLE_INSTANCE* spl);
float al_get_sample_instance_gain(in ALLEGRO_SAMPLE_INSTANCE* spl);
float al_get_sample_instance_pan(in ALLEGRO_SAMPLE_INSTANCE* spl);
float al_get_sample_instance_time(in ALLEGRO_SAMPLE_INSTANCE* spl);
float al_get_sample_instance_speed(const(ALLEGRO_SAMPLE_INSTANCE)* spl);
float al_get_sample_instance_gain(const(ALLEGRO_SAMPLE_INSTANCE)* spl);
float al_get_sample_instance_pan(const(ALLEGRO_SAMPLE_INSTANCE)* spl);
float al_get_sample_instance_time(const(ALLEGRO_SAMPLE_INSTANCE)* spl);

ALLEGRO_AUDIO_DEPTH al_get_sample_instance_depth(in ALLEGRO_SAMPLE_INSTANCE* spl);
ALLEGRO_CHANNEL_CONF al_get_sample_instance_channels(in ALLEGRO_SAMPLE_INSTANCE* spl);
ALLEGRO_PLAYMODE al_get_sample_instance_playmode(in ALLEGRO_SAMPLE_INSTANCE* spl);
ALLEGRO_AUDIO_DEPTH al_get_sample_instance_depth(const(ALLEGRO_SAMPLE_INSTANCE)* spl);
ALLEGRO_CHANNEL_CONF al_get_sample_instance_channels(const(ALLEGRO_SAMPLE_INSTANCE)* spl);
ALLEGRO_PLAYMODE al_get_sample_instance_playmode(const(ALLEGRO_SAMPLE_INSTANCE)* spl);

bool al_get_sample_instance_playing(in ALLEGRO_SAMPLE_INSTANCE* spl);
bool al_get_sample_instance_attached(in ALLEGRO_SAMPLE_INSTANCE* spl);
bool al_get_sample_instance_playing(const(ALLEGRO_SAMPLE_INSTANCE)* spl);
bool al_get_sample_instance_attached(const(ALLEGRO_SAMPLE_INSTANCE)* spl);

bool al_set_sample_instance_position(ALLEGRO_SAMPLE_INSTANCE* spl, uint val);
bool al_set_sample_instance_length(ALLEGRO_SAMPLE_INSTANCE* spl, uint val);
Expand All @@ -154,24 +154,24 @@ nothrow @nogc extern (C)
void al_destroy_audio_stream(ALLEGRO_AUDIO_STREAM* stream);
void al_drain_audio_stream(ALLEGRO_AUDIO_STREAM* stream);

uint al_get_audio_stream_frequency(in ALLEGRO_AUDIO_STREAM* stream);
uint al_get_audio_stream_length(in ALLEGRO_AUDIO_STREAM* stream);
uint al_get_audio_stream_fragments(in ALLEGRO_AUDIO_STREAM* stream);
uint al_get_available_audio_stream_fragments(in ALLEGRO_AUDIO_STREAM* stream);
uint al_get_audio_stream_frequency(const(ALLEGRO_AUDIO_STREAM)* stream);
uint al_get_audio_stream_length(const(ALLEGRO_AUDIO_STREAM)* stream);
uint al_get_audio_stream_fragments(const(ALLEGRO_AUDIO_STREAM)* stream);
uint al_get_available_audio_stream_fragments(const(ALLEGRO_AUDIO_STREAM)* stream);

float al_get_audio_stream_speed(in ALLEGRO_AUDIO_STREAM* stream);
float al_get_audio_stream_gain(in ALLEGRO_AUDIO_STREAM* stream);
float al_get_audio_stream_pan(in ALLEGRO_AUDIO_STREAM* stream);
float al_get_audio_stream_speed(const(ALLEGRO_AUDIO_STREAM)* stream);
float al_get_audio_stream_gain(const(ALLEGRO_AUDIO_STREAM)* stream);
float al_get_audio_stream_pan(const(ALLEGRO_AUDIO_STREAM)* stream);

ALLEGRO_CHANNEL_CONF al_get_audio_stream_channels(in ALLEGRO_AUDIO_STREAM* stream);
ALLEGRO_AUDIO_DEPTH al_get_audio_stream_depth(in ALLEGRO_AUDIO_STREAM* stream);
ALLEGRO_PLAYMODE al_get_audio_stream_playmode(in ALLEGRO_AUDIO_STREAM* stream);
ALLEGRO_CHANNEL_CONF al_get_audio_stream_channels(const(ALLEGRO_AUDIO_STREAM)* stream);
ALLEGRO_AUDIO_DEPTH al_get_audio_stream_depth(const(ALLEGRO_AUDIO_STREAM)* stream);
ALLEGRO_PLAYMODE al_get_audio_stream_playmode(const(ALLEGRO_AUDIO_STREAM)* stream);

bool al_get_audio_stream_playing(in ALLEGRO_AUDIO_STREAM* spl);
bool al_get_audio_stream_attached(in ALLEGRO_AUDIO_STREAM* spl);
ulong al_get_audio_stream_played_samples(in ALLEGRO_AUDIO_STREAM* stream);
bool al_get_audio_stream_playing(const(ALLEGRO_AUDIO_STREAM)* spl);
bool al_get_audio_stream_attached(const(ALLEGRO_AUDIO_STREAM)* spl);
ulong al_get_audio_stream_played_samples(const(ALLEGRO_AUDIO_STREAM)* stream);

void* al_get_audio_stream_fragment(in ALLEGRO_AUDIO_STREAM* stream);
void* al_get_audio_stream_fragment(const(ALLEGRO_AUDIO_STREAM)* stream);

bool al_set_audio_stream_speed(ALLEGRO_AUDIO_STREAM* stream, float val);
bool al_set_audio_stream_gain(ALLEGRO_AUDIO_STREAM* stream, float val);
Expand Down Expand Up @@ -200,13 +200,13 @@ nothrow @nogc extern (C)
bool al_attach_mixer_to_mixer(ALLEGRO_MIXER* stream, ALLEGRO_MIXER* mixer);
bool al_set_mixer_postprocess_callback(ALLEGRO_MIXER* mixer, void function(void* buf, uint samples, void* data) cb, void* data);

uint al_get_mixer_frequency(in ALLEGRO_MIXER* mixer);
ALLEGRO_CHANNEL_CONF al_get_mixer_channels(in ALLEGRO_MIXER* mixer);
ALLEGRO_AUDIO_DEPTH al_get_mixer_depth(in ALLEGRO_MIXER* mixer);
ALLEGRO_MIXER_QUALITY al_get_mixer_quality(in ALLEGRO_MIXER* mixer);
float al_get_mixer_gain(in ALLEGRO_MIXER *mixer);
bool al_get_mixer_playing(in ALLEGRO_MIXER* mixer);
bool al_get_mixer_attached(in ALLEGRO_MIXER* mixer);
uint al_get_mixer_frequency(const(ALLEGRO_MIXER)* mixer);
ALLEGRO_CHANNEL_CONF al_get_mixer_channels(const(ALLEGRO_MIXER)* mixer);
ALLEGRO_AUDIO_DEPTH al_get_mixer_depth(const(ALLEGRO_MIXER)* mixer);
ALLEGRO_MIXER_QUALITY al_get_mixer_quality(const(ALLEGRO_MIXER)* mixer);
float al_get_mixer_gain(const(ALLEGRO_MIXER)* mixer);
bool al_get_mixer_playing(const(ALLEGRO_MIXER)* mixer);
bool al_get_mixer_attached(const(ALLEGRO_MIXER)* mixer);
bool al_set_mixer_frequency(ALLEGRO_MIXER* mixer, uint val);
bool al_set_mixer_quality(ALLEGRO_MIXER* mixer, ALLEGRO_MIXER_QUALITY val);
bool al_set_mixer_gain(ALLEGRO_MIXER *mixer, float gain);
Expand All @@ -224,11 +224,11 @@ nothrow @nogc extern (C)
ALLEGRO_VOICE* voice);
void al_detach_voice(ALLEGRO_VOICE* voice);

uint al_get_voice_frequency(in ALLEGRO_VOICE* voice);
uint al_get_voice_position(in ALLEGRO_VOICE* voice);
ALLEGRO_CHANNEL_CONF al_get_voice_channels(in ALLEGRO_VOICE* voice);
ALLEGRO_AUDIO_DEPTH al_get_voice_depth(in ALLEGRO_VOICE* voice);
bool al_get_voice_playing(in ALLEGRO_VOICE* voice);
uint al_get_voice_frequency(const(ALLEGRO_VOICE)* voice);
uint al_get_voice_position(const(ALLEGRO_VOICE)* voice);
ALLEGRO_CHANNEL_CONF al_get_voice_channels(const(ALLEGRO_VOICE)* voice);
ALLEGRO_AUDIO_DEPTH al_get_voice_depth(const(ALLEGRO_VOICE)* voice);
bool al_get_voice_playing(const(ALLEGRO_VOICE)* voice);
bool al_set_voice_position(ALLEGRO_VOICE* voice, uint val);
bool al_set_voice_playing(ALLEGRO_VOICE* voice, bool val);

Expand All @@ -255,21 +255,21 @@ nothrow @nogc extern (C)
void al_set_default_voice(ALLEGRO_VOICE* voice);

/* File type handlers */
bool al_register_sample_loader(in char* ext, ALLEGRO_SAMPLE* function(in char* filename) loader);
bool al_register_sample_saver(in char* ext, bool function(in char* filename, ALLEGRO_SAMPLE* spl) saver);
bool al_register_audio_stream_loader(in char* ext, ALLEGRO_AUDIO_STREAM* function(in char* filename, size_t buffer_count, uint samples) stream_loader);
bool al_register_sample_loader(const(char)* ext, ALLEGRO_SAMPLE* function(const(char)* filename) loader);
bool al_register_sample_saver(const(char)* ext, bool function(const(char)* filename, ALLEGRO_SAMPLE* spl) saver);
bool al_register_audio_stream_loader(const(char)* ext, ALLEGRO_AUDIO_STREAM* function(const(char)* filename, size_t buffer_count, uint samples) stream_loader);

bool al_register_sample_loader_f(in char* ext, ALLEGRO_SAMPLE* function(ALLEGRO_FILE* fp) loader);
bool al_register_sample_saver_f(in char* ext, bool function(ALLEGRO_FILE* fp, ALLEGRO_SAMPLE* spl) saver);
bool al_register_audio_stream_loader_f(in char* ext, ALLEGRO_AUDIO_STREAM* function(ALLEGRO_FILE* fp, size_t buffer_count, uint samples) stream_loader);
bool al_register_sample_loader_f(const(char)* ext, ALLEGRO_SAMPLE* function(ALLEGRO_FILE* fp) loader);
bool al_register_sample_saver_f(const(char)* ext, bool function(ALLEGRO_FILE* fp, ALLEGRO_SAMPLE* spl) saver);
bool al_register_audio_stream_loader_f(const(char)* ext, ALLEGRO_AUDIO_STREAM* function(ALLEGRO_FILE* fp, size_t buffer_count, uint samples) stream_loader);

ALLEGRO_SAMPLE* al_load_sample(in char* filename);
bool al_save_sample(in char* filename, ALLEGRO_SAMPLE* spl);
ALLEGRO_AUDIO_STREAM* al_load_audio_stream(in char* filename, size_t buffer_count, uint samples);
ALLEGRO_SAMPLE* al_load_sample(const(char)* filename);
bool al_save_sample(const(char)* filename, ALLEGRO_SAMPLE* spl);
ALLEGRO_AUDIO_STREAM* al_load_audio_stream(const(char)* filename, size_t buffer_count, uint samples);

ALLEGRO_SAMPLE* al_load_sample_f(ALLEGRO_FILE* fp, in char* ident);
bool al_save_sample_f(ALLEGRO_FILE* fp, in char* ident, ALLEGRO_SAMPLE* spl);
ALLEGRO_AUDIO_STREAM * al_load_audio_stream_f(ALLEGRO_FILE* fp, in char* ident, size_t buffer_count, uint samples);
ALLEGRO_SAMPLE* al_load_sample_f(ALLEGRO_FILE* fp, const(char)* ident);
bool al_save_sample_f(ALLEGRO_FILE* fp, const(char)* ident, ALLEGRO_SAMPLE* spl);
ALLEGRO_AUDIO_STREAM * al_load_audio_stream_f(ALLEGRO_FILE* fp, const(char)* ident, size_t buffer_count, uint samples);

/* Recording functions */
version (AllegroAudioUnstable)
Expand Down
8 changes: 4 additions & 4 deletions allegro5/allegro_color.d
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,14 +17,14 @@ nothrow @nogc extern (C)
void al_color_rgb_to_hsl(float red, float green, float blue, float* hue, float* saturation, float* lightness);
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);
int al_color_name_to_rgb(const(char)* 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);
void al_color_rgb_to_yuv(float red, float green, float blue, float* y, float* u, float* v);
void al_color_rgb_to_html(float red, float green, float blue, char* string);
void al_color_html_to_rgb(in char* string, float* red, float* green, float* blue);
void al_color_html_to_rgb(const(char)* string, float* red, float* green, float* blue);
}

static import allegro5.allegro_color_ret;
Expand All @@ -33,6 +33,6 @@ mixin(ColorWrapper!("allegro5.allegro_color_ret.", "al_color_yuv", "float y, flo
mixin(ColorWrapper!("allegro5.allegro_color_ret.", "al_color_cmyk", "float c, float m, float y, float k", "c, m, y, k"));
mixin(ColorWrapper!("allegro5.allegro_color_ret.", "al_color_hsl", "float h, float s, float l", "h, s, l"));
mixin(ColorWrapper!("allegro5.allegro_color_ret.", "al_color_hsv", "float h, float s, float v", "h, s, v"));
mixin(ColorWrapper!("allegro5.allegro_color_ret.", "al_color_name", "in char* name", "name"));
mixin(ColorWrapper!("allegro5.allegro_color_ret.", "al_color_html", "in char* string", "string"));
mixin(ColorWrapper!("allegro5.allegro_color_ret.", "al_color_name", "const(char)* name", "name"));
mixin(ColorWrapper!("allegro5.allegro_color_ret.", "al_color_html", "const(char)* string", "string"));

4 changes: 2 additions & 2 deletions allegro5/allegro_color_ret.d
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,6 @@ nothrow @nogc extern(C)
ALLEGRO_COLOR al_color_cmyk(float c, float m, float y, float k);
ALLEGRO_COLOR al_color_hsl(float h, float s, float l);
ALLEGRO_COLOR al_color_hsv(float h, float s, float v);
ALLEGRO_COLOR al_color_name(in char* name);
ALLEGRO_COLOR al_color_html(in char* string);
ALLEGRO_COLOR al_color_name(const(char)* name);
ALLEGRO_COLOR al_color_html(const(char)* string);
}
50 changes: 25 additions & 25 deletions allegro5/allegro_font.d
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,14 +20,14 @@ nothrow @nogc extern (C)

struct ALLEGRO_FONT_VTABLE
{
int function(in ALLEGRO_FONT* f) font_height;
int function(in ALLEGRO_FONT* f, int ch) char_length;
int function(in ALLEGRO_FONT* f, in ALLEGRO_USTR* text) text_length;
int function(in ALLEGRO_FONT* f, int ch, int x, int y) render_char;
int function(in ALLEGRO_FONT* f, in ALLEGRO_USTR* text, int x, int y) render;
int function(const(ALLEGRO_FONT)* f) font_height;
int function(const(ALLEGRO_FONT)* f, int ch) char_length;
int function(const(ALLEGRO_FONT)* f, const(ALLEGRO_USTR)* text) text_length;
int function(const(ALLEGRO_FONT)* f, int ch, int x, int y) render_char;
int function(const(ALLEGRO_FONT)* f, const(ALLEGRO_USTR)* text, int x, int y) render;
void function(ALLEGRO_FONT* f) destroy;
void function(in ALLEGRO_FONT* f,
in ALLEGRO_USTR* text, int* bbx, int* bby, int* bbw,
void function(const(ALLEGRO_FONT)* f,
const(ALLEGRO_USTR)* text, int* bbx, int* bby, int* bbw,
int* bbh, int* ascent, int* descent) get_text_dimensions;
int function (ALLEGRO_FONT* font, int ranges_count, int* ranges) get_font_ranges;
bool function(const ALLEGRO_FONT *f, int codepoint, int *bbx, int *bby, int *bbw, int *bbh) get_glyph_dimensions;
Expand All @@ -44,28 +44,28 @@ nothrow @nogc extern (C)
ALLEGRO_ALIGN_INTEGER = 4,
}

bool al_register_font_loader(in char* ext, ALLEGRO_FONT* function(in char* filename, int size, int flags) load);
ALLEGRO_FONT* al_load_bitmap_font(in char* filename);
ALLEGRO_FONT* al_load_bitmap_font_flags(in char* filename, int flags);
ALLEGRO_FONT* al_load_font(in char* filename, int size, int flags);
bool al_register_font_loader(const(char)* ext, ALLEGRO_FONT* function(const(char)* filename, int size, int flags) load);
ALLEGRO_FONT* al_load_bitmap_font(const(char)* filename);
ALLEGRO_FONT* al_load_bitmap_font_flags(const(char)* filename, int flags);
ALLEGRO_FONT* al_load_font(const(char)* filename, int size, int flags);

ALLEGRO_FONT* al_grab_font_from_bitmap(ALLEGRO_BITMAP* bmp, int n, in int* ranges);
ALLEGRO_FONT* al_grab_font_from_bitmap(ALLEGRO_BITMAP* bmp, int n, const(int)* ranges);
ALLEGRO_FONT* al_create_builtin_font();

void al_draw_ustr(in ALLEGRO_FONT* font, ALLEGRO_COLOR color, float x, float y, int flags, in ALLEGRO_USTR* ustr);
void al_draw_text(in ALLEGRO_FONT* font, ALLEGRO_COLOR color, float x, float y, int flags, in char* text);
void al_draw_justified_text(in ALLEGRO_FONT* font, ALLEGRO_COLOR color, float x1, float x2, float y, float diff, int flags, in char* text);
void al_draw_justified_ustr(in ALLEGRO_FONT* font, ALLEGRO_COLOR color, float x1, float x2, float y, float diff, int flags, in ALLEGRO_USTR* text);
void al_draw_textf(in ALLEGRO_FONT* font, ALLEGRO_COLOR color, float x, float y, int flags, in char* format, ...);
void al_draw_justified_textf(in ALLEGRO_FONT* font, ALLEGRO_COLOR color, float x1, float x2, float y, float diff, int flags, in char* format, ...);
int al_get_text_width(in ALLEGRO_FONT* f, in char* str);
int al_get_ustr_width(in ALLEGRO_FONT* f, in ALLEGRO_USTR* ustr);
int al_get_font_line_height(in ALLEGRO_FONT* f);
int al_get_font_ascent(in ALLEGRO_FONT* f);
int al_get_font_descent(in ALLEGRO_FONT* f);
void al_draw_ustr(const(ALLEGRO_FONT)* font, ALLEGRO_COLOR color, float x, float y, int flags, const(ALLEGRO_USTR)* ustr);
void al_draw_text(const(ALLEGRO_FONT)* font, ALLEGRO_COLOR color, float x, float y, int flags, const(char)* text);
void al_draw_justified_text(const(ALLEGRO_FONT)* font, ALLEGRO_COLOR color, float x1, float x2, float y, float diff, int flags, const(char)* text);
void al_draw_justified_ustr(const(ALLEGRO_FONT)* font, ALLEGRO_COLOR color, float x1, float x2, float y, float diff, int flags, const(ALLEGRO_USTR)* text);
void al_draw_textf(const(ALLEGRO_FONT)* font, ALLEGRO_COLOR color, float x, float y, int flags, const(char)* format, ...);
void al_draw_justified_textf(const(ALLEGRO_FONT)* font, ALLEGRO_COLOR color, float x1, float x2, float y, float diff, int flags, const(char)* format, ...);
int al_get_text_width(const(ALLEGRO_FONT)* f, const(char)* str);
int al_get_ustr_width(const(ALLEGRO_FONT)* f, const(ALLEGRO_USTR)* ustr);
int al_get_font_line_height(const(ALLEGRO_FONT)* f);
int al_get_font_ascent(const(ALLEGRO_FONT)* f);
int al_get_font_descent(const(ALLEGRO_FONT)* f);
void al_destroy_font(ALLEGRO_FONT* f);
void al_get_ustr_dimensions(in ALLEGRO_FONT* f, in ALLEGRO_USTR* text, int* bbx, int* bby, int* bbw, int* bbh);
void al_get_text_dimensions(in ALLEGRO_FONT* f, in char* text, int* bbx, int* bby, int* bbw, int* bbh);
void al_get_ustr_dimensions(const(ALLEGRO_FONT)* f, const(ALLEGRO_USTR)* text, int* bbx, int* bby, int* bbw, int* bbh);
void al_get_text_dimensions(const(ALLEGRO_FONT)* f, const(char)* text, int* bbx, int* bby, int* bbw, int* bbh);
bool al_init_font_addon();
void al_shutdown_font_addon();
uint al_get_allegro_font_version();
Expand Down
2 changes: 1 addition & 1 deletion allegro5/allegro_memfile.d
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,6 @@ import allegro5.allegro;

nothrow @nogc extern (C)
{
ALLEGRO_FILE* al_open_memfile(void* mem, long size, in char* mode);
ALLEGRO_FILE* al_open_memfile(void* mem, long size, const(char)* mode);
uint al_get_allegro_memfile_version();
}
Loading

0 comments on commit 54ce16e

Please sign in to comment.