From 6a186d0bcb8d70dc4101ecf9147e08d0c1a6f6ef Mon Sep 17 00:00:00 2001 From: Thomas Goyne Date: Thu, 11 Nov 2010 04:48:20 +0000 Subject: [PATCH] Add vcproj for libass and fix msvc compilation errors Originally committed to SVN as r4840. --- .../build/libass_vs2008/libass_vs2008.vcproj | 263 +++++++++++++++ aegisub/libass/ass_bitmap.c | 9 +- aegisub/libass/ass_drawing.c | 18 +- aegisub/libass/ass_font.c | 73 +++-- aegisub/libass/ass_render.c | 57 ++-- aegisub/libass/ass_strtod.c | 6 +- aegisub/libass/msvc/config.h | 9 + aegisub/libass/msvc/enca.h | 175 ++++++++++ aegisub/libass/msvc/inttypes.h | 305 ++++++++++++++++++ aegisub/libass/msvc/stdint.h | 247 ++++++++++++++ aegisub/libass/msvc/strings.h | 3 + aegisub/libass/{config.h => msvc/unistd.h} | 0 12 files changed, 1092 insertions(+), 73 deletions(-) create mode 100644 aegisub/build/libass_vs2008/libass_vs2008.vcproj create mode 100644 aegisub/libass/msvc/config.h create mode 100644 aegisub/libass/msvc/enca.h create mode 100644 aegisub/libass/msvc/inttypes.h create mode 100644 aegisub/libass/msvc/stdint.h create mode 100644 aegisub/libass/msvc/strings.h rename aegisub/libass/{config.h => msvc/unistd.h} (100%) diff --git a/aegisub/build/libass_vs2008/libass_vs2008.vcproj b/aegisub/build/libass_vs2008/libass_vs2008.vcproj new file mode 100644 index 000000000..6a18adc38 --- /dev/null +++ b/aegisub/build/libass_vs2008/libass_vs2008.vcproj @@ -0,0 +1,263 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/aegisub/libass/ass_bitmap.c b/aegisub/libass/ass_bitmap.c index 6ecdbc667..4865974cd 100644 --- a/aegisub/libass/ass_bitmap.c +++ b/aegisub/libass/ass_bitmap.c @@ -460,10 +460,13 @@ int glyph_to_bitmap(ASS_Library *library, ASS_SynthPriv *priv_blur, int be, double blur_radius, FT_Vector shadow_offset, int border_style) { + int bbord; + int gbord; + int bord; blur_radius *= 2; - int bbord = be > 0 ? sqrt(2 * be) : 0; - int gbord = blur_radius > 0.0 ? blur_radius + 1 : 0; - int bord = FFMAX(bbord, gbord); + bbord = be > 0 ? sqrt(2 * be) : 0; + gbord = blur_radius > 0.0 ? blur_radius + 1 : 0; + bord = FFMAX(bbord, gbord); if (bord == 0 && (shadow_offset.x || shadow_offset.y)) bord = 1; diff --git a/aegisub/libass/ass_drawing.c b/aegisub/libass/ass_drawing.c index 93cc458d1..ee96bc0f2 100644 --- a/aegisub/libass/ass_drawing.c +++ b/aegisub/libass/ass_drawing.c @@ -270,26 +270,28 @@ static void drawing_evaluate_curve(ASS_Drawing *drawing, double cx3, cx2, cx1, cx0, cy3, cy2, cy1, cy0; double t, h, max_accel, max_accel1, max_accel2; FT_Vector cur = {0, 0}; + int x0, x1, x2, x3; + int y0, y1, y2, y3; cur = token->point; translate_point(drawing, &cur); - int x0 = cur.x; - int y0 = cur.y; + x0 = cur.x; + y0 = cur.y; token = token->next; cur = token->point; translate_point(drawing, &cur); - int x1 = cur.x; - int y1 = cur.y; + x1 = cur.x; + y1 = cur.y; token = token->next; cur = token->point; translate_point(drawing, &cur); - int x2 = cur.x; - int y2 = cur.y; + x2 = cur.x; + y2 = cur.y; token = token->next; cur = token->point; translate_point(drawing, &cur); - int x3 = cur.x; - int y3 = cur.y; + x3 = cur.x; + y3 = cur.y; if (spline) { // 1 [-1 +3 -3 +1] diff --git a/aegisub/libass/ass_font.c b/aegisub/libass/ass_font.c index 74467df6b..0b8816a1b 100644 --- a/aegisub/libass/ass_font.c +++ b/aegisub/libass/ass_font.c @@ -325,20 +325,23 @@ static int ass_strike_outline_glyph(FT_Face face, ASS_Font *font, // Add points to the outline if (under && ps) { - int pos, size; - pos = FT_MulFix(ps->underlinePosition, y_scale * font->scale_y); - size = FT_MulFix(ps->underlineThickness, - y_scale * font->scale_y / 2); + int pos = FT_MulFix(ps->underlinePosition, y_scale * font->scale_y); + int size = FT_MulFix(ps->underlineThickness, + y_scale * font->scale_y / 2); + + FT_Vector points[4]; if (pos > 0 || size <= 0) return 1; - FT_Vector points[4] = { - {.x = bear, .y = pos + size}, - {.x = advance, .y = pos + size}, - {.x = advance, .y = pos - size}, - {.x = bear, .y = pos - size}, - }; + points[0].x = bear; + points[0].y = pos + size; + points[1].x = advance; + points[1].y = pos + size; + points[2].x = advance; + points[2].y = pos - size; + points[3].x = bear; + points[3].y = pos - size; if (dir == FT_ORIENTATION_TRUETYPE) { for (i = 0; i < 4; i++) { @@ -356,19 +359,21 @@ static int ass_strike_outline_glyph(FT_Face face, ASS_Font *font, } if (through && os2) { - int pos, size; - pos = FT_MulFix(os2->yStrikeoutPosition, y_scale * font->scale_y); - size = FT_MulFix(os2->yStrikeoutSize, y_scale * font->scale_y / 2); + int pos = FT_MulFix(os2->yStrikeoutPosition, y_scale * font->scale_y); + int size = FT_MulFix(os2->yStrikeoutSize, y_scale * font->scale_y / 2); + FT_Vector points[4]; if (pos < 0 || size <= 0) return 1; - FT_Vector points[4] = { - {.x = bear, .y = pos + size}, - {.x = advance, .y = pos + size}, - {.x = advance, .y = pos - size}, - {.x = bear, .y = pos - size}, - }; + points[0].x = bear; + points[0].y = pos + size; + points[1].x = advance; + points[1].y = pos + size; + points[2].x = advance; + points[2].y = pos - size; + points[3].x = bear; + points[3].y = pos - size; if (dir == FT_ORIENTATION_TRUETYPE) { for (i = 0; i < 4; i++) { @@ -446,9 +451,9 @@ FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ASS_Font *font, face = font->faces[face_idx]; index = FT_Get_Char_Index(face, ch); if (index == 0 && face->num_charmaps > 0) { + FT_CharMap cur = face->charmap; ass_msg(font->library, MSGL_WARN, "Glyph 0x%X not found, falling back to first charmap", ch); - FT_CharMap cur = face->charmap; FT_Set_Charmap(face, face->charmaps[0]); index = FT_Get_Char_Index(face, ch); FT_Set_Charmap(face, cur); @@ -512,15 +517,17 @@ FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ASS_Font *font, } // Apply scaling and shift - FT_Matrix scale = { double_to_d16(font->scale_x), 0, 0, - double_to_d16(font->scale_y) }; - FT_Outline *outl = &((FT_OutlineGlyph) glyph)->outline; - FT_Outline_Transform(outl, &scale); - FT_Outline_Translate(outl, font->v.x, font->v.y); - glyph->advance.x *= font->scale_x; + { + FT_Matrix scale = { double_to_d16(font->scale_x), 0, 0, + double_to_d16(font->scale_y) }; + FT_Outline *outl = &((FT_OutlineGlyph) glyph)->outline; + FT_Outline_Transform(outl, &scale); + FT_Outline_Translate(outl, font->v.x, font->v.y); + glyph->advance.x *= font->scale_x; - ass_strike_outline_glyph(face, font, glyph, deco & DECO_UNDERLINE, - deco & DECO_STRIKETHROUGH); + ass_strike_outline_glyph(face, font, glyph, deco & DECO_UNDERLINE, + deco & DECO_STRIKETHROUGH); + } return glyph; } @@ -570,9 +577,9 @@ void ass_font_free(ASS_Font *font) static void get_contour_cbox(FT_BBox *box, FT_Vector *points, int start, int end) { + int i; box->xMin = box->yMin = INT_MAX; box->xMax = box->yMax = INT_MIN; - int i; for (i = start; i <= end; i++) { box->xMin = (points[i].x < box->xMin) ? points[i].x : box->xMin; @@ -631,9 +638,10 @@ void fix_freetype_stroker(FT_OutlineGlyph glyph, int border_x, int border_y) // or contained in another contour end = -1; for (i = 0; i < nc; i++) { + int dir; start = end + 1; end = glyph->outline.contours[i]; - int dir = get_contour_direction(glyph->outline.points, start, end); + dir = get_contour_direction(glyph->outline.points, start, end); valid_cont[i] = 1; if (dir == inside_direction) { for (j = 0; j < nc; j++) { @@ -661,9 +669,10 @@ void fix_freetype_stroker(FT_OutlineGlyph glyph, int border_x, int border_y) check_inside: if (dir == inside_direction) { FT_BBox box; + int width, height; get_contour_cbox(&box, glyph->outline.points, start, end); - int width = box.xMax - box.xMin; - int height = box.yMax - box.yMin; + width = box.xMax - box.xMin; + height = box.yMax - box.yMin; if (width < border_x * 2 || height < border_y * 2) { valid_cont[i] = 0; modified = 1; diff --git a/aegisub/libass/ass_render.c b/aegisub/libass/ass_render.c index 480fc4aee..21170667a 100644 --- a/aegisub/libass/ass_render.c +++ b/aegisub/libass/ass_render.c @@ -365,11 +365,6 @@ static ASS_Image ** render_glyph(ASS_Renderer *render_priv, Bitmap *bm, int dst_x, int dst_y, uint32_t color, uint32_t color2, int brk, ASS_Image **tail) { - // Inverse clipping in use? - if (render_priv->state.clip_mode) - return render_glyph_i(render_priv, bm, dst_x, dst_y, color, color2, - brk, tail); - // brk is relative to dst_x // color = color left of brk // color2 = color right of brk @@ -378,6 +373,11 @@ render_glyph(ASS_Renderer *render_priv, Bitmap *bm, int dst_x, int dst_y, int tmp; ASS_Image *img; + // Inverse clipping in use? + if (render_priv->state.clip_mode) + return render_glyph_i(render_priv, bm, dst_x, dst_y, color, color2, + brk, tail); + dst_x += bm->left; dst_y += bm->top; brk -= bm->left; @@ -599,8 +599,8 @@ static void blend_vector_clip(ASS_Renderer *render_priv, if (render_priv->settings.left_margin != 0 || render_priv->settings.top_margin != 0) { FT_Vector trans = { - .x = int_to_d6(render_priv->settings.left_margin), - .y = -int_to_d6(render_priv->settings.top_margin), + int_to_d6(render_priv->settings.left_margin), + -int_to_d6(render_priv->settings.top_margin), }; FT_Outline_Translate(&drawing->glyph->outline, trans.x, trans.y); @@ -831,9 +831,10 @@ static void compute_string_bbox(TextInfo *info, DBBox *bbox) d6_to_double(info->glyphs[0].pos.y); for (i = 0; i < info->length; ++i) { + double s, e; if (info->glyphs[i].skip) continue; - double s = d6_to_double(info->glyphs[i].pos.x); - double e = s + d6_to_double(info->glyphs[i].advance.x); + s = d6_to_double(info->glyphs[i].pos.x); + e = s + d6_to_double(info->glyphs[i].advance.x); bbox->xMin = FFMIN(bbox->xMin, s); bbox->xMax = FFMAX(bbox->xMax, e); } @@ -963,21 +964,23 @@ static void draw_opaque_box(ASS_Renderer *render_priv, uint32_t ch, desc *= scale_y; desc += asc * (scale_y - 1.0); - FT_Vector points[4] = { - { .x = -sx, .y = asc + sy }, - { .x = adv + sx, .y = asc + sy }, - { .x = adv + sx, .y = -desc - sy }, - { .x = -sx, .y = -desc - sy }, - }; + { + FT_Vector points[4] = { + { -sx, asc + sy }, + { adv + sx, asc + sy }, + { adv + sx, -desc - sy }, + { -sx, -desc - sy }, + }; - FT_Outline_Done(render_priv->ftlibrary, &og->outline); - FT_Outline_New(render_priv->ftlibrary, 4, 1, &og->outline); + FT_Outline_Done(render_priv->ftlibrary, &og->outline); + FT_Outline_New(render_priv->ftlibrary, 4, 1, &og->outline); - ol = &og->outline; - ol->n_points = ol->n_contours = 0; - for (i = 0; i < 4; i++) { - ol->points[ol->n_points] = points[i]; - ol->tags[ol->n_points++] = 1; + ol = &og->outline; + ol->n_points = ol->n_contours = 0; + for (i = 0; i < 4; i++) { + ol->points[ol->n_points] = points[i]; + ol->tags[ol->n_points++] = 1; + } } ol->contours[ol->n_contours++] = ol->n_points - 1; } @@ -1251,6 +1254,9 @@ get_bitmap_glyph(ASS_Renderer *render_priv, GlyphInfo *info) FT_Glyph outline; double scale_x = render_priv->font_scale_x; + // PAR correction scaling + FT_Matrix m = { double_to_d16(scale_x), 0, 0, double_to_d16(1.0) }; + FT_Glyph_Copy(info->glyph, &glyph); FT_Glyph_Copy(info->outline_glyph, &outline); // calculating rotation shift vector (from rotation origin to the glyph basepoint) @@ -1264,10 +1270,6 @@ get_bitmap_glyph(ASS_Renderer *render_priv, GlyphInfo *info) info->frx, info->fry, info->frz, fax_scaled, fay_scaled, render_priv->font_scale, info->asc); - // PAR correction scaling - FT_Matrix m = { double_to_d16(scale_x), 0, - 0, double_to_d16(1.0) }; - // subpixel shift if (glyph) { FT_Outline *outl = &((FT_OutlineGlyph) glyph)->outline; @@ -1555,9 +1557,10 @@ wrap_lines_smart(ASS_Renderer *render_priv, double max_text_width) for (i = 0; i < text_info->length; ++i) { cur = text_info->glyphs + i; if (cur->linebreak) { + double height; while (i < text_info->length && cur->skip && cur->symbol != '\n') cur = text_info->glyphs + ++i; - double height = + height = text_info->lines[cur_line - 1].desc + text_info->lines[cur_line].asc; cur_line++; diff --git a/aegisub/libass/ass_strtod.c b/aegisub/libass/ass_strtod.c index f55b37ae1..b26cdd205 100644 --- a/aegisub/libass/ass_strtod.c +++ b/aegisub/libass/ass_strtod.c @@ -99,7 +99,7 @@ ass_strtod(string, endPtr) */ p = string; - while (isspace(*p)) { + while (isascii(*p) && isspace(*p)) { p += 1; } if (*p == '-') { @@ -121,7 +121,7 @@ ass_strtod(string, endPtr) for (mantSize = 0; ; mantSize += 1) { c = *p; - if (!isdigit(c)) { + if (!isascii(*p) || !isdigit(c)) { if ((c != '.') || (decPt >= 0)) { break; } @@ -197,7 +197,7 @@ ass_strtod(string, endPtr) } expSign = 0; } - while (isdigit(*p)) { + while (isascii(*p) && isdigit(*p)) { exp = exp * 10 + (*p - '0'); p += 1; } diff --git a/aegisub/libass/msvc/config.h b/aegisub/libass/msvc/config.h new file mode 100644 index 000000000..1a6b91f90 --- /dev/null +++ b/aegisub/libass/msvc/config.h @@ -0,0 +1,9 @@ +//#define CONFIG_ENCA 1 +#define CONFIG_FONTCONFIG 1 +#define CONFIG_ICONV 1 + +#define inline __inline + +#define strtoll(p, e, b) _strtoi64(p, e, b) + +#define M_PI 3.1415926535897932384626433832795 diff --git a/aegisub/libass/msvc/enca.h b/aegisub/libass/msvc/enca.h new file mode 100644 index 000000000..cfb5f550c --- /dev/null +++ b/aegisub/libass/msvc/enca.h @@ -0,0 +1,175 @@ +/* @(#) $Id: enca.h,v 1.11 2005/02/27 12:08:55 yeti Exp $ */ +/* This header file is in the public domain. */ +#ifndef ENCA_H +#define ENCA_H + +#include +/* According to autoconf stdlib may not be enough for size_t */ +#include + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* Enumerated types */ + +typedef enum { /*< flags >*/ + ENCA_SURFACE_EOL_CR = 1 << 0, + ENCA_SURFACE_EOL_LF = 1 << 1, + ENCA_SURFACE_EOL_CRLF = 1 << 2, + ENCA_SURFACE_EOL_MIX = 1 << 3, + ENCA_SURFACE_EOL_BIN = 1 << 4, + ENCA_SURFACE_MASK_EOL = (ENCA_SURFACE_EOL_CR + | ENCA_SURFACE_EOL_LF + | ENCA_SURFACE_EOL_CRLF + | ENCA_SURFACE_EOL_MIX + | ENCA_SURFACE_EOL_BIN), + ENCA_SURFACE_PERM_21 = 1 << 5, + ENCA_SURFACE_PERM_4321 = 1 << 6, + ENCA_SURFACE_PERM_MIX = 1 << 7, + ENCA_SURFACE_MASK_PERM = (ENCA_SURFACE_PERM_21 + | ENCA_SURFACE_PERM_4321 + | ENCA_SURFACE_PERM_MIX), + ENCA_SURFACE_QP = 1 << 8, + ENCA_SURFACE_REMOVE = 1 << 13, + ENCA_SURFACE_UNKNOWN = 1 << 14, + ENCA_SURFACE_MASK_ALL = (ENCA_SURFACE_MASK_EOL + | ENCA_SURFACE_MASK_PERM + | ENCA_SURFACE_QP + | ENCA_SURFACE_REMOVE) +} EncaSurface; + +typedef enum { + ENCA_NAME_STYLE_ENCA, + ENCA_NAME_STYLE_RFC1345, + ENCA_NAME_STYLE_CSTOCS, + ENCA_NAME_STYLE_ICONV, + ENCA_NAME_STYLE_HUMAN, + ENCA_NAME_STYLE_MIME +} EncaNameStyle; + +typedef enum { /*< flags >*/ + ENCA_CHARSET_7BIT = 1 << 0, + ENCA_CHARSET_8BIT = 1 << 1, + ENCA_CHARSET_16BIT = 1 << 2, + ENCA_CHARSET_32BIT = 1 << 3, + ENCA_CHARSET_FIXED = 1 << 4, + ENCA_CHARSET_VARIABLE = 1 << 5, + ENCA_CHARSET_BINARY = 1 << 6, + ENCA_CHARSET_REGULAR = 1 << 7, + ENCA_CHARSET_MULTIBYTE = 1 << 8 +} EncaCharsetFlags; + +typedef enum { + ENCA_EOK = 0, + ENCA_EINVALUE, + ENCA_EEMPTY, + ENCA_EFILTERED, + ENCA_ENOCS8, + ENCA_ESIGNIF, + ENCA_EWINNER, + ENCA_EGARBAGE +} EncaErrno; + +#define ENCA_CS_UNKNOWN (-1) + +#define ENCA_NOT_A_CHAR 0xffff + +/* Published (opaque) typedefs */ +typedef struct _EncaAnalyserState *EncaAnalyser; + +/* Public (transparent) typedefs */ +typedef struct _EncaEncoding EncaEncoding; + +struct _EncaEncoding { int charset; EncaSurface surface; }; + +/* Basic interface. */ +EncaAnalyser enca_analyser_alloc (const char *langname); +void enca_analyser_free (EncaAnalyser analyser); +EncaEncoding enca_analyse (EncaAnalyser analyser, + unsigned char *buffer, + size_t size); +EncaEncoding enca_analyse_const (EncaAnalyser analyser, + const unsigned char *buffer, + size_t size); +int enca_double_utf8_check (EncaAnalyser analyser, + const unsigned char *buffer, + size_t size); +int* enca_double_utf8_get_candidates (EncaAnalyser analyser); +int enca_errno (EncaAnalyser analyser); +const char* enca_strerror (EncaAnalyser analyser, + int errnum); + +/* Options. */ +void enca_set_multibyte (EncaAnalyser analyser, + int multibyte); +int enca_get_multibyte (EncaAnalyser analyser); +void enca_set_interpreted_surfaces (EncaAnalyser analyser, + int interpreted_surfaces); +int enca_get_interpreted_surfaces (EncaAnalyser analyser); +void enca_set_ambiguity (EncaAnalyser analyser, + int ambiguity); +int enca_get_ambiguity (EncaAnalyser analyser); +void enca_set_filtering (EncaAnalyser analyser, + int filtering); +int enca_get_filtering (EncaAnalyser analyser); +void enca_set_garbage_test (EncaAnalyser analyser, + int garabage_test); +int enca_get_garbage_test (EncaAnalyser analyser); +void enca_set_termination_strictness (EncaAnalyser analyser, + int termination_strictness); +int enca_get_termination_strictness (EncaAnalyser analyser); +int enca_set_significant (EncaAnalyser analyser, + size_t significant); +size_t enca_get_significant (EncaAnalyser analyser); +int enca_set_threshold (EncaAnalyser analyser, + double threshold); +double enca_get_threshold (EncaAnalyser analyser); + +/* Names and properties. */ +const char* enca_charset_name (int charset, + EncaNameStyle whatname); +const char** enca_get_charset_aliases (int charset, + size_t *n); +char* enca_get_surface_name (EncaSurface surface, + EncaNameStyle whatname); +EncaEncoding enca_parse_encoding_name (const char *name); +EncaSurface enca_charset_natural_surface (int charset); +EncaCharsetFlags enca_charset_properties (int charset); + +#define enca_charset_is_known(cs) \ + ((cs) != ENCA_CS_UNKNOWN) +#define enca_charset_is_7bit(cs) \ + (enca_charset_properties(cs) & ENCA_CHARSET_7BIT) +#define enca_charset_is_8bit(cs) \ + (enca_charset_properties(cs) & ENCA_CHARSET_8BIT) +#define enca_charset_is_16bit(cs) \ + (enca_charset_properties(cs) & ENCA_CHARSET_16BIT) +#define enca_charset_is_32bit(cs) \ + (enca_charset_properties(cs) & ENCA_CHARSET_32BIT) +#define enca_charset_is_fixed(cs) \ + (enca_charset_properties(cs) & ENCA_CHARSET_FIXED) +#define enca_charset_is_variable(cs) \ + (enca_charset_properties(cs) & ENCA_CHARSET_VARIABLE) +#define enca_charset_is_binary(cs) \ + (enca_charset_properties(cs) & ENCA_CHARSET_BINARY) +#define enca_charset_is_regular(cs) \ + (enca_charset_properties(cs) & ENCA_CHARSET_REGULAR) +#define enca_charset_is_multibyte(cs) \ + (enca_charset_properties(cs) & ENCA_CHARSET_MULTIBYTE) + +/* Auxiliary functions. */ +int enca_charset_has_ucs2_map (int charset); +int enca_charset_ucs2_map (int charset, + unsigned int *buffer); +size_t enca_number_of_charsets (void); +const char* enca_analyser_language (EncaAnalyser analyser); +const char* enca_language_english_name (const char *lang); +const char** enca_get_languages (size_t *n); +int* enca_get_language_charsets (const char *langname, + size_t *n); +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif diff --git a/aegisub/libass/msvc/inttypes.h b/aegisub/libass/msvc/inttypes.h new file mode 100644 index 000000000..4b3828a21 --- /dev/null +++ b/aegisub/libass/msvc/inttypes.h @@ -0,0 +1,305 @@ +// ISO C9x compliant inttypes.h for Microsoft Visual Studio +// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 +// +// Copyright (c) 2006 Alexander Chemeris +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. The name of the author may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef _MSC_VER // [ +#error "Use this header only with Microsoft Visual C++ compilers!" +#endif // _MSC_VER ] + +#ifndef _MSC_INTTYPES_H_ // [ +#define _MSC_INTTYPES_H_ + +#if _MSC_VER > 1000 +#pragma once +#endif + +#include "stdint.h" + +// 7.8 Format conversion of integer types + +typedef struct { + intmax_t quot; + intmax_t rem; +} imaxdiv_t; + +// 7.8.1 Macros for format specifiers + +#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [ See footnote 185 at page 198 + +// The fprintf macros for signed integers are: +#define PRId8 "d" +#define PRIi8 "i" +#define PRIdLEAST8 "d" +#define PRIiLEAST8 "i" +#define PRIdFAST8 "d" +#define PRIiFAST8 "i" + +#define PRId16 "hd" +#define PRIi16 "hi" +#define PRIdLEAST16 "hd" +#define PRIiLEAST16 "hi" +#define PRIdFAST16 "hd" +#define PRIiFAST16 "hi" + +#define PRId32 "I32d" +#define PRIi32 "I32i" +#define PRIdLEAST32 "I32d" +#define PRIiLEAST32 "I32i" +#define PRIdFAST32 "I32d" +#define PRIiFAST32 "I32i" + +#define PRId64 "I64d" +#define PRIi64 "I64i" +#define PRIdLEAST64 "I64d" +#define PRIiLEAST64 "I64i" +#define PRIdFAST64 "I64d" +#define PRIiFAST64 "I64i" + +#define PRIdMAX "I64d" +#define PRIiMAX "I64i" + +#define PRIdPTR "Id" +#define PRIiPTR "Ii" + +// The fprintf macros for unsigned integers are: +#define PRIo8 "o" +#define PRIu8 "u" +#define PRIx8 "x" +#define PRIX8 "X" +#define PRIoLEAST8 "o" +#define PRIuLEAST8 "u" +#define PRIxLEAST8 "x" +#define PRIXLEAST8 "X" +#define PRIoFAST8 "o" +#define PRIuFAST8 "u" +#define PRIxFAST8 "x" +#define PRIXFAST8 "X" + +#define PRIo16 "ho" +#define PRIu16 "hu" +#define PRIx16 "hx" +#define PRIX16 "hX" +#define PRIoLEAST16 "ho" +#define PRIuLEAST16 "hu" +#define PRIxLEAST16 "hx" +#define PRIXLEAST16 "hX" +#define PRIoFAST16 "ho" +#define PRIuFAST16 "hu" +#define PRIxFAST16 "hx" +#define PRIXFAST16 "hX" + +#define PRIo32 "I32o" +#define PRIu32 "I32u" +#define PRIx32 "I32x" +#define PRIX32 "I32X" +#define PRIoLEAST32 "I32o" +#define PRIuLEAST32 "I32u" +#define PRIxLEAST32 "I32x" +#define PRIXLEAST32 "I32X" +#define PRIoFAST32 "I32o" +#define PRIuFAST32 "I32u" +#define PRIxFAST32 "I32x" +#define PRIXFAST32 "I32X" + +#define PRIo64 "I64o" +#define PRIu64 "I64u" +#define PRIx64 "I64x" +#define PRIX64 "I64X" +#define PRIoLEAST64 "I64o" +#define PRIuLEAST64 "I64u" +#define PRIxLEAST64 "I64x" +#define PRIXLEAST64 "I64X" +#define PRIoFAST64 "I64o" +#define PRIuFAST64 "I64u" +#define PRIxFAST64 "I64x" +#define PRIXFAST64 "I64X" + +#define PRIoMAX "I64o" +#define PRIuMAX "I64u" +#define PRIxMAX "I64x" +#define PRIXMAX "I64X" + +#define PRIoPTR "Io" +#define PRIuPTR "Iu" +#define PRIxPTR "Ix" +#define PRIXPTR "IX" + +// The fscanf macros for signed integers are: +#define SCNd8 "d" +#define SCNi8 "i" +#define SCNdLEAST8 "d" +#define SCNiLEAST8 "i" +#define SCNdFAST8 "d" +#define SCNiFAST8 "i" + +#define SCNd16 "hd" +#define SCNi16 "hi" +#define SCNdLEAST16 "hd" +#define SCNiLEAST16 "hi" +#define SCNdFAST16 "hd" +#define SCNiFAST16 "hi" + +#define SCNd32 "ld" +#define SCNi32 "li" +#define SCNdLEAST32 "ld" +#define SCNiLEAST32 "li" +#define SCNdFAST32 "ld" +#define SCNiFAST32 "li" + +#define SCNd64 "I64d" +#define SCNi64 "I64i" +#define SCNdLEAST64 "I64d" +#define SCNiLEAST64 "I64i" +#define SCNdFAST64 "I64d" +#define SCNiFAST64 "I64i" + +#define SCNdMAX "I64d" +#define SCNiMAX "I64i" + +#ifdef _WIN64 // [ +# define SCNdPTR "I64d" +# define SCNiPTR "I64i" +#else // _WIN64 ][ +# define SCNdPTR "ld" +# define SCNiPTR "li" +#endif // _WIN64 ] + +// The fscanf macros for unsigned integers are: +#define SCNo8 "o" +#define SCNu8 "u" +#define SCNx8 "x" +#define SCNX8 "X" +#define SCNoLEAST8 "o" +#define SCNuLEAST8 "u" +#define SCNxLEAST8 "x" +#define SCNXLEAST8 "X" +#define SCNoFAST8 "o" +#define SCNuFAST8 "u" +#define SCNxFAST8 "x" +#define SCNXFAST8 "X" + +#define SCNo16 "ho" +#define SCNu16 "hu" +#define SCNx16 "hx" +#define SCNX16 "hX" +#define SCNoLEAST16 "ho" +#define SCNuLEAST16 "hu" +#define SCNxLEAST16 "hx" +#define SCNXLEAST16 "hX" +#define SCNoFAST16 "ho" +#define SCNuFAST16 "hu" +#define SCNxFAST16 "hx" +#define SCNXFAST16 "hX" + +#define SCNo32 "lo" +#define SCNu32 "lu" +#define SCNx32 "lx" +#define SCNX32 "lX" +#define SCNoLEAST32 "lo" +#define SCNuLEAST32 "lu" +#define SCNxLEAST32 "lx" +#define SCNXLEAST32 "lX" +#define SCNoFAST32 "lo" +#define SCNuFAST32 "lu" +#define SCNxFAST32 "lx" +#define SCNXFAST32 "lX" + +#define SCNo64 "I64o" +#define SCNu64 "I64u" +#define SCNx64 "I64x" +#define SCNX64 "I64X" +#define SCNoLEAST64 "I64o" +#define SCNuLEAST64 "I64u" +#define SCNxLEAST64 "I64x" +#define SCNXLEAST64 "I64X" +#define SCNoFAST64 "I64o" +#define SCNuFAST64 "I64u" +#define SCNxFAST64 "I64x" +#define SCNXFAST64 "I64X" + +#define SCNoMAX "I64o" +#define SCNuMAX "I64u" +#define SCNxMAX "I64x" +#define SCNXMAX "I64X" + +#ifdef _WIN64 // [ +# define SCNoPTR "I64o" +# define SCNuPTR "I64u" +# define SCNxPTR "I64x" +# define SCNXPTR "I64X" +#else // _WIN64 ][ +# define SCNoPTR "lo" +# define SCNuPTR "lu" +# define SCNxPTR "lx" +# define SCNXPTR "lX" +#endif // _WIN64 ] + +#endif // __STDC_FORMAT_MACROS ] + +// 7.8.2 Functions for greatest-width integer types + +// 7.8.2.1 The imaxabs function +#define imaxabs _abs64 + +// 7.8.2.2 The imaxdiv function + +// This is modified version of div() function from Microsoft's div.c found +// in %MSVC.NET%\crt\src\div.c +#ifdef STATIC_IMAXDIV // [ +static +#else // STATIC_IMAXDIV ][ +_inline +#endif // STATIC_IMAXDIV ] +imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom) +{ + imaxdiv_t result; + + result.quot = numer / denom; + result.rem = numer % denom; + + if (numer < 0 && result.rem > 0) { + // did division wrong; must fix up + ++result.quot; + result.rem -= denom; + } + + return result; +} + +// 7.8.2.3 The strtoimax and strtoumax functions +#define strtoimax _strtoi64 +#define strtoumax _strtoui64 + +// 7.8.2.4 The wcstoimax and wcstoumax functions +#define wcstoimax _wcstoi64 +#define wcstoumax _wcstoui64 + + +#endif // _MSC_INTTYPES_H_ ] diff --git a/aegisub/libass/msvc/stdint.h b/aegisub/libass/msvc/stdint.h new file mode 100644 index 000000000..d02608a59 --- /dev/null +++ b/aegisub/libass/msvc/stdint.h @@ -0,0 +1,247 @@ +// ISO C9x compliant stdint.h for Microsoft Visual Studio +// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 +// +// Copyright (c) 2006-2008 Alexander Chemeris +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. The name of the author may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef _MSC_VER // [ +#error "Use this header only with Microsoft Visual C++ compilers!" +#endif // _MSC_VER ] + +#ifndef _MSC_STDINT_H_ // [ +#define _MSC_STDINT_H_ + +#if _MSC_VER > 1000 +#pragma once +#endif + +#include + +// For Visual Studio 6 in C++ mode and for many Visual Studio versions when +// compiling for ARM we should wrap include with 'extern "C++" {}' +// or compiler give many errors like this: +// error C2733: second C linkage of overloaded function 'wmemchr' not allowed +#ifdef __cplusplus +extern "C" { +#endif +# include +#ifdef __cplusplus +} +#endif + +// Define _W64 macros to mark types changing their size, like intptr_t. +#ifndef _W64 +# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300 +# define _W64 __w64 +# else +# define _W64 +# endif +#endif + + +// 7.18.1 Integer types + +// 7.18.1.1 Exact-width integer types + +// Visual Studio 6 and Embedded Visual C++ 4 doesn't +// realize that, e.g. char has the same size as __int8 +// so we give up on __intX for them. +#if (_MSC_VER < 1300) + typedef signed char int8_t; + typedef signed short int16_t; + typedef signed int int32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; +#else + typedef signed __int8 int8_t; + typedef signed __int16 int16_t; + typedef signed __int32 int32_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; +#endif +typedef signed __int64 int64_t; +typedef unsigned __int64 uint64_t; + + +// 7.18.1.2 Minimum-width integer types +typedef int8_t int_least8_t; +typedef int16_t int_least16_t; +typedef int32_t int_least32_t; +typedef int64_t int_least64_t; +typedef uint8_t uint_least8_t; +typedef uint16_t uint_least16_t; +typedef uint32_t uint_least32_t; +typedef uint64_t uint_least64_t; + +// 7.18.1.3 Fastest minimum-width integer types +typedef int8_t int_fast8_t; +typedef int16_t int_fast16_t; +typedef int32_t int_fast32_t; +typedef int64_t int_fast64_t; +typedef uint8_t uint_fast8_t; +typedef uint16_t uint_fast16_t; +typedef uint32_t uint_fast32_t; +typedef uint64_t uint_fast64_t; + +// 7.18.1.4 Integer types capable of holding object pointers +#ifdef _WIN64 // [ + typedef signed __int64 intptr_t; + typedef unsigned __int64 uintptr_t; +#else // _WIN64 ][ + typedef _W64 signed int intptr_t; + typedef _W64 unsigned int uintptr_t; +#endif // _WIN64 ] + +// 7.18.1.5 Greatest-width integer types +typedef int64_t intmax_t; +typedef uint64_t uintmax_t; + + +// 7.18.2 Limits of specified-width integer types + +#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259 + +// 7.18.2.1 Limits of exact-width integer types +#define INT8_MIN ((int8_t)_I8_MIN) +#define INT8_MAX _I8_MAX +#define INT16_MIN ((int16_t)_I16_MIN) +#define INT16_MAX _I16_MAX +#define INT32_MIN ((int32_t)_I32_MIN) +#define INT32_MAX _I32_MAX +#define INT64_MIN ((int64_t)_I64_MIN) +#define INT64_MAX _I64_MAX +#define UINT8_MAX _UI8_MAX +#define UINT16_MAX _UI16_MAX +#define UINT32_MAX _UI32_MAX +#define UINT64_MAX _UI64_MAX + +// 7.18.2.2 Limits of minimum-width integer types +#define INT_LEAST8_MIN INT8_MIN +#define INT_LEAST8_MAX INT8_MAX +#define INT_LEAST16_MIN INT16_MIN +#define INT_LEAST16_MAX INT16_MAX +#define INT_LEAST32_MIN INT32_MIN +#define INT_LEAST32_MAX INT32_MAX +#define INT_LEAST64_MIN INT64_MIN +#define INT_LEAST64_MAX INT64_MAX +#define UINT_LEAST8_MAX UINT8_MAX +#define UINT_LEAST16_MAX UINT16_MAX +#define UINT_LEAST32_MAX UINT32_MAX +#define UINT_LEAST64_MAX UINT64_MAX + +// 7.18.2.3 Limits of fastest minimum-width integer types +#define INT_FAST8_MIN INT8_MIN +#define INT_FAST8_MAX INT8_MAX +#define INT_FAST16_MIN INT16_MIN +#define INT_FAST16_MAX INT16_MAX +#define INT_FAST32_MIN INT32_MIN +#define INT_FAST32_MAX INT32_MAX +#define INT_FAST64_MIN INT64_MIN +#define INT_FAST64_MAX INT64_MAX +#define UINT_FAST8_MAX UINT8_MAX +#define UINT_FAST16_MAX UINT16_MAX +#define UINT_FAST32_MAX UINT32_MAX +#define UINT_FAST64_MAX UINT64_MAX + +// 7.18.2.4 Limits of integer types capable of holding object pointers +#ifdef _WIN64 // [ +# define INTPTR_MIN INT64_MIN +# define INTPTR_MAX INT64_MAX +# define UINTPTR_MAX UINT64_MAX +#else // _WIN64 ][ +# define INTPTR_MIN INT32_MIN +# define INTPTR_MAX INT32_MAX +# define UINTPTR_MAX UINT32_MAX +#endif // _WIN64 ] + +// 7.18.2.5 Limits of greatest-width integer types +#define INTMAX_MIN INT64_MIN +#define INTMAX_MAX INT64_MAX +#define UINTMAX_MAX UINT64_MAX + +// 7.18.3 Limits of other integer types + +#ifdef _WIN64 // [ +# define PTRDIFF_MIN _I64_MIN +# define PTRDIFF_MAX _I64_MAX +#else // _WIN64 ][ +# define PTRDIFF_MIN _I32_MIN +# define PTRDIFF_MAX _I32_MAX +#endif // _WIN64 ] + +#define SIG_ATOMIC_MIN INT_MIN +#define SIG_ATOMIC_MAX INT_MAX + +#ifndef SIZE_MAX // [ +# ifdef _WIN64 // [ +# define SIZE_MAX _UI64_MAX +# else // _WIN64 ][ +# define SIZE_MAX _UI32_MAX +# endif // _WIN64 ] +#endif // SIZE_MAX ] + +// WCHAR_MIN and WCHAR_MAX are also defined in +#ifndef WCHAR_MIN // [ +# define WCHAR_MIN 0 +#endif // WCHAR_MIN ] +#ifndef WCHAR_MAX // [ +# define WCHAR_MAX _UI16_MAX +#endif // WCHAR_MAX ] + +#define WINT_MIN 0 +#define WINT_MAX _UI16_MAX + +#endif // __STDC_LIMIT_MACROS ] + + +// 7.18.4 Limits of other integer types + +#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260 + +// 7.18.4.1 Macros for minimum-width integer constants + +#define INT8_C(val) val##i8 +#define INT16_C(val) val##i16 +#define INT32_C(val) val##i32 +#define INT64_C(val) val##i64 + +#define UINT8_C(val) val##ui8 +#define UINT16_C(val) val##ui16 +#define UINT32_C(val) val##ui32 +#define UINT64_C(val) val##ui64 + +// 7.18.4.2 Macros for greatest-width integer constants +#define INTMAX_C INT64_C +#define UINTMAX_C UINT64_C + +#endif // __STDC_CONSTANT_MACROS ] + + +#endif // _MSC_STDINT_H_ ] diff --git a/aegisub/libass/msvc/strings.h b/aegisub/libass/msvc/strings.h new file mode 100644 index 000000000..8279fd78d --- /dev/null +++ b/aegisub/libass/msvc/strings.h @@ -0,0 +1,3 @@ +#define strncasecmp _strnicmp +#define strcasecmp _stricmp + diff --git a/aegisub/libass/config.h b/aegisub/libass/msvc/unistd.h similarity index 100% rename from aegisub/libass/config.h rename to aegisub/libass/msvc/unistd.h