mirror of
https://github.com/fadden/ciderpress.git
synced 2024-11-23 11:33:58 +00:00
554 lines
21 KiB
C
554 lines
21 KiB
C
|
/*
|
||
|
|
* NuFX archive manipulation library
|
||
|
|
* Copyright (C) 2014 by Andy McFadden, All Rights Reserved.
|
||
|
|
* This is free software; you can redistribute it and/or modify it under the
|
||
|
|
* terms of the BSD License, see the file COPYING-LIB.
|
||
|
|
*
|
||
|
|
* Miscellaneous NufxLib utility functions.
|
||
|
|
*/
|
||
|
|
#include "NufxLibPriv.h"
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Convert Mac OS Roman to Unicode. Mapping comes from:
|
||
|
|
*
|
||
|
|
* http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/ROMAN.TXT
|
||
|
|
*
|
||
|
|
* We use the "Control Pictures" block for the control characters
|
||
|
|
* (0x00-0x1f, 0x7f --> 0x2400-0x241f, 0x2421). This is a bit nicer
|
||
|
|
* than embedding control characters in filenames.
|
||
|
|
*/
|
||
|
|
static const uint16_t gMORToUnicode[256] = {
|
||
|
|
/*0x00*/ 0x2400, // [control] NULL
|
||
|
|
/*0x01*/ 0x2401, // [control] START OF HEADING
|
||
|
|
/*0x02*/ 0x2402, // [control] START OF TEXT
|
||
|
|
/*0x03*/ 0x2403, // [control] END OF TEXT
|
||
|
|
/*0x04*/ 0x2404, // [control] END OF TRANSMISSION
|
||
|
|
/*0x05*/ 0x2405, // [control] ENQUIRY
|
||
|
|
/*0x06*/ 0x2406, // [control] ACKNOWLEDGE
|
||
|
|
/*0x07*/ 0x2407, // [control] BELL
|
||
|
|
/*0x08*/ 0x2408, // [control] BACKSPACE
|
||
|
|
/*0x09*/ 0x2409, // [control] HORIZONTAL TABULATION
|
||
|
|
/*0x0a*/ 0x240a, // [control] LINE FEED
|
||
|
|
/*0x0b*/ 0x240b, // [control] VERTICAL TABULATION
|
||
|
|
/*0x0c*/ 0x240c, // [control] FORM FEED
|
||
|
|
/*0x0d*/ 0x240d, // [control] CARRIAGE RETURN
|
||
|
|
/*0x0e*/ 0x240e, // [control] SHIFT OUT
|
||
|
|
/*0x0f*/ 0x240f, // [control] SHIFT IN
|
||
|
|
/*0x10*/ 0x2410, // [control] DATA LINK ESCAPE
|
||
|
|
/*0x11*/ 0x2411, // [control] DEVICE CONTROL ONE
|
||
|
|
/*0x12*/ 0x2412, // [control] DEVICE CONTROL TWO
|
||
|
|
/*0x13*/ 0x2413, // [control] DEVICE CONTROL THREE
|
||
|
|
/*0x14*/ 0x2414, // [control] DEVICE CONTROL FOUR
|
||
|
|
/*0x15*/ 0x2415, // [control] NEGATIVE ACKNOWLEDGE
|
||
|
|
/*0x16*/ 0x2416, // [control] SYNCHRONOUS IDLE
|
||
|
|
/*0x17*/ 0x2417, // [control] END OF TRANSMISSION BLOCK
|
||
|
|
/*0x18*/ 0x2418, // [control] CANCEL
|
||
|
|
/*0x19*/ 0x2419, // [control] END OF MEDIUM
|
||
|
|
/*0x1a*/ 0x241a, // [control] SUBSTITUTE
|
||
|
|
/*0x1b*/ 0x241b, // [control] ESCAPE
|
||
|
|
/*0x1c*/ 0x241c, // [control] FILE SEPARATOR
|
||
|
|
/*0x1d*/ 0x241d, // [control] GROUP SEPARATOR
|
||
|
|
/*0x1e*/ 0x241e, // [control] RECORD SEPARATOR
|
||
|
|
/*0x1f*/ 0x241f, // [control] UNIT SEPARATOR
|
||
|
|
/*0x20*/ 0x0020, // SPACE
|
||
|
|
/*0x21*/ 0x0021, // EXCLAMATION MARK
|
||
|
|
/*0x22*/ 0x0022, // QUOTATION MARK
|
||
|
|
/*0x23*/ 0x0023, // NUMBER SIGN
|
||
|
|
/*0x24*/ 0x0024, // DOLLAR SIGN
|
||
|
|
/*0x25*/ 0x0025, // PERCENT SIGN
|
||
|
|
/*0x26*/ 0x0026, // AMPERSAND
|
||
|
|
/*0x27*/ 0x0027, // APOSTROPHE
|
||
|
|
/*0x28*/ 0x0028, // LEFT PARENTHESIS
|
||
|
|
/*0x29*/ 0x0029, // RIGHT PARENTHESIS
|
||
|
|
/*0x2A*/ 0x002A, // ASTERISK
|
||
|
|
/*0x2B*/ 0x002B, // PLUS SIGN
|
||
|
|
/*0x2C*/ 0x002C, // COMMA
|
||
|
|
/*0x2D*/ 0x002D, // HYPHEN-MINUS
|
||
|
|
/*0x2E*/ 0x002E, // FULL STOP
|
||
|
|
/*0x2F*/ 0x002F, // SOLIDUS
|
||
|
|
/*0x30*/ 0x0030, // DIGIT ZERO
|
||
|
|
/*0x31*/ 0x0031, // DIGIT ONE
|
||
|
|
/*0x32*/ 0x0032, // DIGIT TWO
|
||
|
|
/*0x33*/ 0x0033, // DIGIT THREE
|
||
|
|
/*0x34*/ 0x0034, // DIGIT FOUR
|
||
|
|
/*0x35*/ 0x0035, // DIGIT FIVE
|
||
|
|
/*0x36*/ 0x0036, // DIGIT SIX
|
||
|
|
/*0x37*/ 0x0037, // DIGIT SEVEN
|
||
|
|
/*0x38*/ 0x0038, // DIGIT EIGHT
|
||
|
|
/*0x39*/ 0x0039, // DIGIT NINE
|
||
|
|
/*0x3A*/ 0x003A, // COLON
|
||
|
|
/*0x3B*/ 0x003B, // SEMICOLON
|
||
|
|
/*0x3C*/ 0x003C, // LESS-THAN SIGN
|
||
|
|
/*0x3D*/ 0x003D, // EQUALS SIGN
|
||
|
|
/*0x3E*/ 0x003E, // GREATER-THAN SIGN
|
||
|
|
/*0x3F*/ 0x003F, // QUESTION MARK
|
||
|
|
/*0x40*/ 0x0040, // COMMERCIAL AT
|
||
|
|
/*0x41*/ 0x0041, // LATIN CAPITAL LETTER A
|
||
|
|
/*0x42*/ 0x0042, // LATIN CAPITAL LETTER B
|
||
|
|
/*0x43*/ 0x0043, // LATIN CAPITAL LETTER C
|
||
|
|
/*0x44*/ 0x0044, // LATIN CAPITAL LETTER D
|
||
|
|
/*0x45*/ 0x0045, // LATIN CAPITAL LETTER E
|
||
|
|
/*0x46*/ 0x0046, // LATIN CAPITAL LETTER F
|
||
|
|
/*0x47*/ 0x0047, // LATIN CAPITAL LETTER G
|
||
|
|
/*0x48*/ 0x0048, // LATIN CAPITAL LETTER H
|
||
|
|
/*0x49*/ 0x0049, // LATIN CAPITAL LETTER I
|
||
|
|
/*0x4A*/ 0x004A, // LATIN CAPITAL LETTER J
|
||
|
|
/*0x4B*/ 0x004B, // LATIN CAPITAL LETTER K
|
||
|
|
/*0x4C*/ 0x004C, // LATIN CAPITAL LETTER L
|
||
|
|
/*0x4D*/ 0x004D, // LATIN CAPITAL LETTER M
|
||
|
|
/*0x4E*/ 0x004E, // LATIN CAPITAL LETTER N
|
||
|
|
/*0x4F*/ 0x004F, // LATIN CAPITAL LETTER O
|
||
|
|
/*0x50*/ 0x0050, // LATIN CAPITAL LETTER P
|
||
|
|
/*0x51*/ 0x0051, // LATIN CAPITAL LETTER Q
|
||
|
|
/*0x52*/ 0x0052, // LATIN CAPITAL LETTER R
|
||
|
|
/*0x53*/ 0x0053, // LATIN CAPITAL LETTER S
|
||
|
|
/*0x54*/ 0x0054, // LATIN CAPITAL LETTER T
|
||
|
|
/*0x55*/ 0x0055, // LATIN CAPITAL LETTER U
|
||
|
|
/*0x56*/ 0x0056, // LATIN CAPITAL LETTER V
|
||
|
|
/*0x57*/ 0x0057, // LATIN CAPITAL LETTER W
|
||
|
|
/*0x58*/ 0x0058, // LATIN CAPITAL LETTER X
|
||
|
|
/*0x59*/ 0x0059, // LATIN CAPITAL LETTER Y
|
||
|
|
/*0x5A*/ 0x005A, // LATIN CAPITAL LETTER Z
|
||
|
|
/*0x5B*/ 0x005B, // LEFT SQUARE BRACKET
|
||
|
|
/*0x5C*/ 0x005C, // REVERSE SOLIDUS
|
||
|
|
/*0x5D*/ 0x005D, // RIGHT SQUARE BRACKET
|
||
|
|
/*0x5E*/ 0x005E, // CIRCUMFLEX ACCENT
|
||
|
|
/*0x5F*/ 0x005F, // LOW LINE
|
||
|
|
/*0x60*/ 0x0060, // GRAVE ACCENT
|
||
|
|
/*0x61*/ 0x0061, // LATIN SMALL LETTER A
|
||
|
|
/*0x62*/ 0x0062, // LATIN SMALL LETTER B
|
||
|
|
/*0x63*/ 0x0063, // LATIN SMALL LETTER C
|
||
|
|
/*0x64*/ 0x0064, // LATIN SMALL LETTER D
|
||
|
|
/*0x65*/ 0x0065, // LATIN SMALL LETTER E
|
||
|
|
/*0x66*/ 0x0066, // LATIN SMALL LETTER F
|
||
|
|
/*0x67*/ 0x0067, // LATIN SMALL LETTER G
|
||
|
|
/*0x68*/ 0x0068, // LATIN SMALL LETTER H
|
||
|
|
/*0x69*/ 0x0069, // LATIN SMALL LETTER I
|
||
|
|
/*0x6A*/ 0x006A, // LATIN SMALL LETTER J
|
||
|
|
/*0x6B*/ 0x006B, // LATIN SMALL LETTER K
|
||
|
|
/*0x6C*/ 0x006C, // LATIN SMALL LETTER L
|
||
|
|
/*0x6D*/ 0x006D, // LATIN SMALL LETTER M
|
||
|
|
/*0x6E*/ 0x006E, // LATIN SMALL LETTER N
|
||
|
|
/*0x6F*/ 0x006F, // LATIN SMALL LETTER O
|
||
|
|
/*0x70*/ 0x0070, // LATIN SMALL LETTER P
|
||
|
|
/*0x71*/ 0x0071, // LATIN SMALL LETTER Q
|
||
|
|
/*0x72*/ 0x0072, // LATIN SMALL LETTER R
|
||
|
|
/*0x73*/ 0x0073, // LATIN SMALL LETTER S
|
||
|
|
/*0x74*/ 0x0074, // LATIN SMALL LETTER T
|
||
|
|
/*0x75*/ 0x0075, // LATIN SMALL LETTER U
|
||
|
|
/*0x76*/ 0x0076, // LATIN SMALL LETTER V
|
||
|
|
/*0x77*/ 0x0077, // LATIN SMALL LETTER W
|
||
|
|
/*0x78*/ 0x0078, // LATIN SMALL LETTER X
|
||
|
|
/*0x79*/ 0x0079, // LATIN SMALL LETTER Y
|
||
|
|
/*0x7A*/ 0x007A, // LATIN SMALL LETTER Z
|
||
|
|
/*0x7B*/ 0x007B, // LEFT CURLY BRACKET
|
||
|
|
/*0x7C*/ 0x007C, // VERTICAL LINE
|
||
|
|
/*0x7D*/ 0x007D, // RIGHT CURLY BRACKET
|
||
|
|
/*0x7E*/ 0x007E, // TILDE
|
||
|
|
/*0x7f*/ 0x2421, // [control] DELETE
|
||
|
|
/*0x80*/ 0x00C4, // LATIN CAPITAL LETTER A WITH DIAERESIS
|
||
|
|
/*0x81*/ 0x00C5, // LATIN CAPITAL LETTER A WITH RING ABOVE
|
||
|
|
/*0x82*/ 0x00C7, // LATIN CAPITAL LETTER C WITH CEDILLA
|
||
|
|
/*0x83*/ 0x00C9, // LATIN CAPITAL LETTER E WITH ACUTE
|
||
|
|
/*0x84*/ 0x00D1, // LATIN CAPITAL LETTER N WITH TILDE
|
||
|
|
/*0x85*/ 0x00D6, // LATIN CAPITAL LETTER O WITH DIAERESIS
|
||
|
|
/*0x86*/ 0x00DC, // LATIN CAPITAL LETTER U WITH DIAERESIS
|
||
|
|
/*0x87*/ 0x00E1, // LATIN SMALL LETTER A WITH ACUTE
|
||
|
|
/*0x88*/ 0x00E0, // LATIN SMALL LETTER A WITH GRAVE
|
||
|
|
/*0x89*/ 0x00E2, // LATIN SMALL LETTER A WITH CIRCUMFLEX
|
||
|
|
/*0x8A*/ 0x00E4, // LATIN SMALL LETTER A WITH DIAERESIS
|
||
|
|
/*0x8B*/ 0x00E3, // LATIN SMALL LETTER A WITH TILDE
|
||
|
|
/*0x8C*/ 0x00E5, // LATIN SMALL LETTER A WITH RING ABOVE
|
||
|
|
/*0x8D*/ 0x00E7, // LATIN SMALL LETTER C WITH CEDILLA
|
||
|
|
/*0x8E*/ 0x00E9, // LATIN SMALL LETTER E WITH ACUTE
|
||
|
|
/*0x8F*/ 0x00E8, // LATIN SMALL LETTER E WITH GRAVE
|
||
|
|
/*0x90*/ 0x00EA, // LATIN SMALL LETTER E WITH CIRCUMFLEX
|
||
|
|
/*0x91*/ 0x00EB, // LATIN SMALL LETTER E WITH DIAERESIS
|
||
|
|
/*0x92*/ 0x00ED, // LATIN SMALL LETTER I WITH ACUTE
|
||
|
|
/*0x93*/ 0x00EC, // LATIN SMALL LETTER I WITH GRAVE
|
||
|
|
/*0x94*/ 0x00EE, // LATIN SMALL LETTER I WITH CIRCUMFLEX
|
||
|
|
/*0x95*/ 0x00EF, // LATIN SMALL LETTER I WITH DIAERESIS
|
||
|
|
/*0x96*/ 0x00F1, // LATIN SMALL LETTER N WITH TILDE
|
||
|
|
/*0x97*/ 0x00F3, // LATIN SMALL LETTER O WITH ACUTE
|
||
|
|
/*0x98*/ 0x00F2, // LATIN SMALL LETTER O WITH GRAVE
|
||
|
|
/*0x99*/ 0x00F4, // LATIN SMALL LETTER O WITH CIRCUMFLEX
|
||
|
|
/*0x9A*/ 0x00F6, // LATIN SMALL LETTER O WITH DIAERESIS
|
||
|
|
/*0x9B*/ 0x00F5, // LATIN SMALL LETTER O WITH TILDE
|
||
|
|
/*0x9C*/ 0x00FA, // LATIN SMALL LETTER U WITH ACUTE
|
||
|
|
/*0x9D*/ 0x00F9, // LATIN SMALL LETTER U WITH GRAVE
|
||
|
|
/*0x9E*/ 0x00FB, // LATIN SMALL LETTER U WITH CIRCUMFLEX
|
||
|
|
/*0x9F*/ 0x00FC, // LATIN SMALL LETTER U WITH DIAERESIS
|
||
|
|
/*0xA0*/ 0x2020, // DAGGER
|
||
|
|
/*0xA1*/ 0x00B0, // DEGREE SIGN
|
||
|
|
/*0xA2*/ 0x00A2, // CENT SIGN
|
||
|
|
/*0xA3*/ 0x00A3, // POUND SIGN
|
||
|
|
/*0xA4*/ 0x00A7, // SECTION SIGN
|
||
|
|
/*0xA5*/ 0x2022, // BULLET
|
||
|
|
/*0xA6*/ 0x00B6, // PILCROW SIGN
|
||
|
|
/*0xA7*/ 0x00DF, // LATIN SMALL LETTER SHARP S
|
||
|
|
/*0xA8*/ 0x00AE, // REGISTERED SIGN
|
||
|
|
/*0xA9*/ 0x00A9, // COPYRIGHT SIGN
|
||
|
|
/*0xAA*/ 0x2122, // TRADE MARK SIGN
|
||
|
|
/*0xAB*/ 0x00B4, // ACUTE ACCENT
|
||
|
|
/*0xAC*/ 0x00A8, // DIAERESIS
|
||
|
|
/*0xAD*/ 0x2260, // NOT EQUAL TO
|
||
|
|
/*0xAE*/ 0x00C6, // LATIN CAPITAL LETTER AE
|
||
|
|
/*0xAF*/ 0x00D8, // LATIN CAPITAL LETTER O WITH STROKE
|
||
|
|
/*0xB0*/ 0x221E, // INFINITY
|
||
|
|
/*0xB1*/ 0x00B1, // PLUS-MINUS SIGN
|
||
|
|
/*0xB2*/ 0x2264, // LESS-THAN OR EQUAL TO
|
||
|
|
/*0xB3*/ 0x2265, // GREATER-THAN OR EQUAL TO
|
||
|
|
/*0xB4*/ 0x00A5, // YEN SIGN
|
||
|
|
/*0xB5*/ 0x00B5, // MICRO SIGN
|
||
|
|
/*0xB6*/ 0x2202, // PARTIAL DIFFERENTIAL
|
||
|
|
/*0xB7*/ 0x2211, // N-ARY SUMMATION
|
||
|
|
/*0xB8*/ 0x220F, // N-ARY PRODUCT
|
||
|
|
/*0xB9*/ 0x03C0, // GREEK SMALL LETTER PI
|
||
|
|
/*0xBA*/ 0x222B, // INTEGRAL
|
||
|
|
/*0xBB*/ 0x00AA, // FEMININE ORDINAL INDICATOR
|
||
|
|
/*0xBC*/ 0x00BA, // MASCULINE ORDINAL INDICATOR
|
||
|
|
/*0xBD*/ 0x03A9, // GREEK CAPITAL LETTER OMEGA
|
||
|
|
/*0xBE*/ 0x00E6, // LATIN SMALL LETTER AE
|
||
|
|
/*0xBF*/ 0x00F8, // LATIN SMALL LETTER O WITH STROKE
|
||
|
|
/*0xC0*/ 0x00BF, // INVERTED QUESTION MARK
|
||
|
|
/*0xC1*/ 0x00A1, // INVERTED EXCLAMATION MARK
|
||
|
|
/*0xC2*/ 0x00AC, // NOT SIGN
|
||
|
|
/*0xC3*/ 0x221A, // SQUARE ROOT
|
||
|
|
/*0xC4*/ 0x0192, // LATIN SMALL LETTER F WITH HOOK
|
||
|
|
/*0xC5*/ 0x2248, // ALMOST EQUAL TO
|
||
|
|
/*0xC6*/ 0x2206, // INCREMENT
|
||
|
|
/*0xC7*/ 0x00AB, // LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
|
||
|
|
/*0xC8*/ 0x00BB, // RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
|
||
|
|
/*0xC9*/ 0x2026, // HORIZONTAL ELLIPSIS
|
||
|
|
/*0xCA*/ 0x00A0, // NO-BREAK SPACE
|
||
|
|
/*0xCB*/ 0x00C0, // LATIN CAPITAL LETTER A WITH GRAVE
|
||
|
|
/*0xCC*/ 0x00C3, // LATIN CAPITAL LETTER A WITH TILDE
|
||
|
|
/*0xCD*/ 0x00D5, // LATIN CAPITAL LETTER O WITH TILDE
|
||
|
|
/*0xCE*/ 0x0152, // LATIN CAPITAL LIGATURE OE
|
||
|
|
/*0xCF*/ 0x0153, // LATIN SMALL LIGATURE OE
|
||
|
|
/*0xD0*/ 0x2013, // EN DASH
|
||
|
|
/*0xD1*/ 0x2014, // EM DASH
|
||
|
|
/*0xD2*/ 0x201C, // LEFT DOUBLE QUOTATION MARK
|
||
|
|
/*0xD3*/ 0x201D, // RIGHT DOUBLE QUOTATION MARK
|
||
|
|
/*0xD4*/ 0x2018, // LEFT SINGLE QUOTATION MARK
|
||
|
|
/*0xD5*/ 0x2019, // RIGHT SINGLE QUOTATION MARK
|
||
|
|
/*0xD6*/ 0x00F7, // DIVISION SIGN
|
||
|
|
/*0xD7*/ 0x25CA, // LOZENGE
|
||
|
|
/*0xD8*/ 0x00FF, // LATIN SMALL LETTER Y WITH DIAERESIS
|
||
|
|
/*0xD9*/ 0x0178, // LATIN CAPITAL LETTER Y WITH DIAERESIS
|
||
|
|
/*0xDA*/ 0x2044, // FRACTION SLASH
|
||
|
|
/*0xDB*/ 0x00A4, // CURRENCY SIGN (was EURO SIGN)
|
||
|
|
/*0xDC*/ 0x2039, // SINGLE LEFT-POINTING ANGLE QUOTATION MARK
|
||
|
|
/*0xDD*/ 0x203A, // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
|
||
|
|
/*0xDE*/ 0xFB01, // LATIN SMALL LIGATURE FI
|
||
|
|
/*0xDF*/ 0xFB02, // LATIN SMALL LIGATURE FL
|
||
|
|
/*0xE0*/ 0x2021, // DOUBLE DAGGER
|
||
|
|
/*0xE1*/ 0x00B7, // MIDDLE DOT
|
||
|
|
/*0xE2*/ 0x201A, // SINGLE LOW-9 QUOTATION MARK
|
||
|
|
/*0xE3*/ 0x201E, // DOUBLE LOW-9 QUOTATION MARK
|
||
|
|
/*0xE4*/ 0x2030, // PER MILLE SIGN
|
||
|
|
/*0xE5*/ 0x00C2, // LATIN CAPITAL LETTER A WITH CIRCUMFLEX
|
||
|
|
/*0xE6*/ 0x00CA, // LATIN CAPITAL LETTER E WITH CIRCUMFLEX
|
||
|
|
/*0xE7*/ 0x00C1, // LATIN CAPITAL LETTER A WITH ACUTE
|
||
|
|
/*0xE8*/ 0x00CB, // LATIN CAPITAL LETTER E WITH DIAERESIS
|
||
|
|
/*0xE9*/ 0x00C8, // LATIN CAPITAL LETTER E WITH GRAVE
|
||
|
|
/*0xEA*/ 0x00CD, // LATIN CAPITAL LETTER I WITH ACUTE
|
||
|
|
/*0xEB*/ 0x00CE, // LATIN CAPITAL LETTER I WITH CIRCUMFLEX
|
||
|
|
/*0xEC*/ 0x00CF, // LATIN CAPITAL LETTER I WITH DIAERESIS
|
||
|
|
/*0xED*/ 0x00CC, // LATIN CAPITAL LETTER I WITH GRAVE
|
||
|
|
/*0xEE*/ 0x00D3, // LATIN CAPITAL LETTER O WITH ACUTE
|
||
|
|
/*0xEF*/ 0x00D4, // LATIN CAPITAL LETTER O WITH CIRCUMFLEX
|
||
|
|
/*0xF0*/ 0xF8FF, // Apple logo
|
||
|
|
/*0xF1*/ 0x00D2, // LATIN CAPITAL LETTER O WITH GRAVE
|
||
|
|
/*0xF2*/ 0x00DA, // LATIN CAPITAL LETTER U WITH ACUTE
|
||
|
|
/*0xF3*/ 0x00DB, // LATIN CAPITAL LETTER U WITH CIRCUMFLEX
|
||
|
|
/*0xF4*/ 0x00D9, // LATIN CAPITAL LETTER U WITH GRAVE
|
||
|
|
/*0xF5*/ 0x0131, // LATIN SMALL LETTER DOTLESS I
|
||
|
|
/*0xF6*/ 0x02C6, // MODIFIER LETTER CIRCUMFLEX ACCENT
|
||
|
|
/*0xF7*/ 0x02DC, // SMALL TILDE
|
||
|
|
/*0xF8*/ 0x00AF, // MACRON
|
||
|
|
/*0xF9*/ 0x02D8, // BREVE
|
||
|
|
/*0xFA*/ 0x02D9, // DOT ABOVE
|
||
|
|
/*0xFB*/ 0x02DA, // RING ABOVE
|
||
|
|
/*0xFC*/ 0x00B8, // CEDILLA
|
||
|
|
/*0xFD*/ 0x02DD, // DOUBLE ACUTE ACCENT
|
||
|
|
/*0xFE*/ 0x02DB, // OGONEK
|
||
|
|
/*0xFF*/ 0x02C7 // CARON
|
||
|
|
};
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Static table, populated on first use. Provides the inverse map.
|
||
|
|
*
|
||
|
|
* An entry with 0x00 indicates no conversion. That's incorrect for
|
||
|
|
* the entry for '\0', but since we're operating on null-terminated
|
||
|
|
* strings that's never valid anyway. (It's possible for a filename
|
||
|
|
* to contain 0x2400, but that would translate to 0x00, which we don't
|
||
|
|
* allow; so it makes more sense to treat it as illegal.)
|
||
|
|
*/
|
||
|
|
static uint8_t gUnicodeToMOR[65536] = { 0xff /*indicates not initialized*/ };
|
||
|
|
|
||
|
|
static void Nu_GenerateUnicodeToMOR(void)
|
||
|
|
{
|
||
|
|
memset(gUnicodeToMOR, 0, sizeof(gUnicodeToMOR));
|
||
|
|
|
||
|
|
int i;
|
||
|
|
for (i = 0; i < 256; i++) {
|
||
|
|
int codePoint = gMORToUnicode[i];
|
||
|
|
Assert(codePoint >= 0 && codePoint < 65536);
|
||
|
|
gUnicodeToMOR[codePoint] = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Converts stringMOR to Unicode, storing the output in bufUNI until it's
|
||
|
|
* full. Null termination is guaranteed. If the buffer size is zero or
|
||
|
|
* bufUNI is NULL, no string data is returned.
|
||
|
|
*
|
||
|
|
* Returns the number of bytes required to represent stringMOR in Unicode.
|
||
|
|
*/
|
||
|
|
size_t Nu_ConvertMORToUNI(const char* stringMOR, UNICHAR* bufUNI,
|
||
|
|
size_t bufSize)
|
||
|
|
{
|
||
|
|
Assert(stringMOR != 0);
|
||
|
|
|
||
|
|
#ifdef _WIN32
|
||
|
|
/* place-holder if we're not using UTF-16 yet */
|
||
|
|
Assert(sizeof(UNICHAR) == 1);
|
||
|
|
size_t morLen = strlen(stringMOR) + 1;
|
||
|
|
if (bufUNI != NULL && bufSize != 0) {
|
||
|
|
size_t copyLen = morLen < bufSize ? morLen : bufSize;
|
||
|
|
memcpy(bufUNI, stringMOR, copyLen);
|
||
|
|
bufUNI[bufSize-1] = '\0';
|
||
|
|
}
|
||
|
|
return morLen;
|
||
|
|
#else
|
||
|
|
/*
|
||
|
|
* Convert Mac OS Roman to UTF-8. We only output full code points,
|
||
|
|
* so if only the first byte of a UTF-8 sequence will fit we just
|
||
|
|
* stop early.
|
||
|
|
*/
|
||
|
|
size_t uniLen = 0;
|
||
|
|
Boolean doOutput = (bufUNI != NULL);
|
||
|
|
|
||
|
|
while (*stringMOR != '\0') {
|
||
|
|
// ASCII values just "convert" to themselves in this table
|
||
|
|
uint16_t us = gMORToUnicode[(uint8_t)*stringMOR];
|
||
|
|
if (us < 0x80) {
|
||
|
|
// single byte, no conversion
|
||
|
|
if (uniLen+1 >= bufSize) {
|
||
|
|
doOutput = false;
|
||
|
|
}
|
||
|
|
if (doOutput) {
|
||
|
|
bufUNI[uniLen] = (char) us;
|
||
|
|
}
|
||
|
|
uniLen++;
|
||
|
|
} else if (us < 0x7ff) {
|
||
|
|
// two bytes
|
||
|
|
if (uniLen+2 >= bufSize) {
|
||
|
|
doOutput = false;
|
||
|
|
}
|
||
|
|
if (doOutput) {
|
||
|
|
bufUNI[uniLen] = (us >> 6) | 0xc0;
|
||
|
|
bufUNI[uniLen+1] = (us & 0x3f) | 0x80;
|
||
|
|
}
|
||
|
|
uniLen += 2;
|
||
|
|
} else {
|
||
|
|
// three bytes
|
||
|
|
if (uniLen+3 >= bufSize) {
|
||
|
|
doOutput = false;
|
||
|
|
}
|
||
|
|
if (doOutput) {
|
||
|
|
bufUNI[uniLen] = (us >> 12) | 0xe0;
|
||
|
|
bufUNI[uniLen+1] = ((us >> 6) & 0x3f) | 0x80;
|
||
|
|
bufUNI[uniLen+2] = (us & 0x3f) | 0x80;
|
||
|
|
}
|
||
|
|
uniLen += 3;
|
||
|
|
}
|
||
|
|
|
||
|
|
stringMOR++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// null-terminate
|
||
|
|
if (doOutput && uniLen < bufSize) {
|
||
|
|
bufUNI[uniLen] = '\0';
|
||
|
|
}
|
||
|
|
uniLen++;
|
||
|
|
|
||
|
|
return uniLen;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Decode a single Unicode code point from a UTF-8 string. This will
|
||
|
|
* consume 1 to 4 bytes. If an error is detected, only one byte is
|
||
|
|
* consumed, and the code point value will be 0xDCnn (invalid).
|
||
|
|
*
|
||
|
|
* cf. http://en.wikipedia.org/wiki/UTF-8#Sample_code
|
||
|
|
*/
|
||
|
|
static uint32_t Nu_DecodeUTF8(const char** pStr)
|
||
|
|
{
|
||
|
|
const uint8_t* str = (const uint8_t*) *pStr;
|
||
|
|
uint32_t codePoint;
|
||
|
|
uint32_t uc1, uc2, uc3, uc4;
|
||
|
|
uc1 = *str++;
|
||
|
|
|
||
|
|
if (uc1 < 0x80) {
|
||
|
|
// single byte
|
||
|
|
codePoint = uc1;
|
||
|
|
} else if (uc1 < 0xc2) {
|
||
|
|
// illegal: continuation or overlong 2-byte sequence
|
||
|
|
goto fail;
|
||
|
|
} else if (uc1 < 0xe0) {
|
||
|
|
// 2-byte sequence
|
||
|
|
uc2 = *str++;
|
||
|
|
if ((uc2 & 0xc0) != 0x80) {
|
||
|
|
goto fail; // not a continuation
|
||
|
|
}
|
||
|
|
codePoint = (uc1 << 6) + uc2 - 0x3080;
|
||
|
|
} else if (uc1 < 0xf0) {
|
||
|
|
// 3-byte sequence */
|
||
|
|
uc2 = *str++;
|
||
|
|
if ((uc2 & 0xc0) != 0x80) {
|
||
|
|
goto fail; // not a continuation
|
||
|
|
}
|
||
|
|
if (uc1 == 0xe0 && uc2 < 0xa0) {
|
||
|
|
goto fail; // overlong
|
||
|
|
}
|
||
|
|
uc3 = *str++;
|
||
|
|
if ((uc3 & 0xc0) != 0x80) {
|
||
|
|
goto fail; // not a continuation
|
||
|
|
}
|
||
|
|
codePoint = (uc1 << 12) + (uc2 << 6) + uc3 - 0xE2080;
|
||
|
|
} else if (uc1 < 0xf5) {
|
||
|
|
uc2 = *str++;
|
||
|
|
if ((uc2 & 0xc0) != 0x80) {
|
||
|
|
goto fail; // not a continuation
|
||
|
|
}
|
||
|
|
if (uc1 == 0xf0 && uc2 < 0x90) {
|
||
|
|
goto fail; // overlong
|
||
|
|
}
|
||
|
|
if (uc1 == 0xf4 && uc2 >= 0x90) {
|
||
|
|
goto fail; // U+10FFFF
|
||
|
|
}
|
||
|
|
uc3 = *str++;
|
||
|
|
if ((uc3 & 0xc0) != 0x80) {
|
||
|
|
goto fail; // not a continuation
|
||
|
|
}
|
||
|
|
uc4 = *str++;
|
||
|
|
if ((uc4 & 0xc0) != 0x80) {
|
||
|
|
goto fail; // not a continuation
|
||
|
|
}
|
||
|
|
codePoint = (uc1 << 18) + (uc2 << 12) + (uc3 << 6) + uc4 - 0x3C82080;
|
||
|
|
} else {
|
||
|
|
// illegal: > U+10FFFF
|
||
|
|
goto fail;
|
||
|
|
}
|
||
|
|
|
||
|
|
*pStr = (const UNICHAR*) str;
|
||
|
|
return codePoint;
|
||
|
|
|
||
|
|
fail:
|
||
|
|
(*pStr)++; // advance one char only
|
||
|
|
return 0xdc00 | uc1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Converts stringUNI to Mac OS Roman, storing the output in bufMOR
|
||
|
|
* until it's full. Null termination is guaranteed. If the buffer
|
||
|
|
* size is zero or bufMOR is NULL, no string data is returned.
|
||
|
|
*
|
||
|
|
* Returns the number of bytes required to represent stringUNI in MOR.
|
||
|
|
*/
|
||
|
|
size_t Nu_ConvertUNIToMOR(const UNICHAR* stringUNI, char* bufMOR,
|
||
|
|
size_t bufSize)
|
||
|
|
{
|
||
|
|
Assert(stringUNI != 0);
|
||
|
|
|
||
|
|
#ifdef _WIN32
|
||
|
|
/*
|
||
|
|
* Place-holder if we're not using UTF-16 yet. This doesn't pass
|
||
|
|
* tests that check for behavior with non-MOR Unicode values.
|
||
|
|
*/
|
||
|
|
Assert(sizeof(UNICHAR) == 1);
|
||
|
|
size_t uniLen = strlen(stringUNI) + 1;
|
||
|
|
if (bufMOR != NULL && bufSize != 0) {
|
||
|
|
size_t copyLen = uniLen < bufSize ? uniLen : bufSize;
|
||
|
|
memcpy(bufMOR, stringUNI, copyLen);
|
||
|
|
bufMOR[bufSize-1] = '\0';
|
||
|
|
}
|
||
|
|
return uniLen;
|
||
|
|
#else
|
||
|
|
/*
|
||
|
|
* Convert UTF-8 to Mac OS Roman. If the code point doesn't have
|
||
|
|
* a valid conversion (either because it's not in the table, or the
|
||
|
|
* UTF-8 code is damaged) we just insert an ASCII '?'.
|
||
|
|
*/
|
||
|
|
if (gUnicodeToMOR[0] == 0xff) {
|
||
|
|
Nu_GenerateUnicodeToMOR();
|
||
|
|
Assert(gUnicodeToMOR[0] != 0xff);
|
||
|
|
}
|
||
|
|
|
||
|
|
uint32_t codePoint;
|
||
|
|
size_t morLen = 0;
|
||
|
|
Boolean doOutput = (bufMOR != NULL);
|
||
|
|
|
||
|
|
while (*stringUNI != '\0') {
|
||
|
|
codePoint = Nu_DecodeUTF8(&stringUNI);
|
||
|
|
char mc;
|
||
|
|
|
||
|
|
if (codePoint < 0x80) {
|
||
|
|
mc = (char) codePoint;
|
||
|
|
} else if (codePoint < 0xffff) {
|
||
|
|
// UTF-8 errors come back as 0xDCnn, which has no mapping in table
|
||
|
|
mc = gUnicodeToMOR[codePoint];
|
||
|
|
if (mc == 0x00) {
|
||
|
|
mc = '?';
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// non-BMP code point
|
||
|
|
mc = '?';
|
||
|
|
}
|
||
|
|
if (morLen+1 >= bufSize) {
|
||
|
|
doOutput = false;
|
||
|
|
}
|
||
|
|
if (doOutput) {
|
||
|
|
bufMOR[morLen] = mc;
|
||
|
|
}
|
||
|
|
morLen++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// null-terminate
|
||
|
|
if (doOutput && morLen < bufSize) {
|
||
|
|
bufMOR[morLen] = '\0';
|
||
|
|
}
|
||
|
|
morLen++;
|
||
|
|
|
||
|
|
return morLen;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Utility function that wraps NuConvertMORToUTF8, allocating a new
|
||
|
|
* buffer to hold the converted string. The caller must free the result.
|
||
|
|
*
|
||
|
|
* Returns NULL if stringMOR is NULL or the conversion fails.
|
||
|
|
*/
|
||
|
|
UNICHAR* Nu_CopyMORToUNI(const char* stringMOR)
|
||
|
|
{
|
||
|
|
size_t uniLen;
|
||
|
|
UNICHAR* uniBuf;
|
||
|
|
|
||
|
|
if (stringMOR == NULL) {
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
uniLen = Nu_ConvertMORToUNI(stringMOR, NULL, 0);
|
||
|
|
if (uniLen == (size_t) -1) {
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
uniBuf = (UNICHAR*) Nu_Malloc(NULL, uniLen);
|
||
|
|
Nu_ConvertMORToUNI(stringMOR, uniBuf, uniLen);
|
||
|
|
return uniBuf;
|
||
|
|
}
|