---
product: Chilkat
product_version: 11.7.0
language: objc
language_label: Objective-C
class: Charset
class_name: CkoCharset
license: bundle
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/objcCkoCharsetRef.html
---
# Chilkat Charset — Objective-C — v11.7.0

> Chilkat 11.7.0 · language=objc · class=Charset (CkoCharset)
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/Charset.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/objc/guide.md`.

## Purpose

Deprecated — scheduled for removal

**Legacy character-set conversion utilities. Migrate before Chilkat v12.0.0.**

**Do not use `Chilkat.Charset` in new development.** The entire class is deprecated and is scheduled to be removed in Chilkat v12.0.0. Existing applications should migrate now. Equivalent functionality is available in the free `Chilkat.BinData` and `Chilkat.StringBuilder` classes.

`Chilkat.Charset` is a legacy class for converting text between character encodings, reading and writing encoded text files, inspecting or rewriting HTML charset declarations, encoding and decoding HTML entities, validating byte sequences, and performing several older text utilities. It remains documented only to support maintenance and migration of existing applications.

**Use BinData for bytes**

Store raw bytes, load and save files, append byte-order marks, and move encoded data between files, memory, and other Chilkat objects.

**Use StringBuilder for text**

Hold Unicode text and perform charset encoding or decoding, URL processing, HTML entity conversion, case conversion, and related text operations.

**Prefer UTF-8**

For new text formats and interchange, use UTF-8 unless a protocol or legacy system explicitly requires another encoding.

**Keep bytes and characters distinct**

A charset defines how text characters map to bytes. Binary encodings such as Base64 or hexadecimal solve a different problem and are not character sets.

**Legacy HTML helpers**

The class can inspect and rewrite HTML charset metadata, but these helpers do not validate that declared metadata matches the actual bytes.

**Maintenance only**

Continue using this class only while maintaining older code, and plan a tested migration before adopting Chilkat v12.

**Migration pattern:** load encoded bytes into `BinData`, decode them into a `StringBuilder` using the known source charset, work with Unicode text, then encode back into `BinData` using the required destination charset. This makes the boundary between bytes and text explicit and replaces the stateful `FromCharset`/`ToCharset` workflow.

## Object creation, unlocking and error handling

**Object Creation**

```objectivec
CkoCharset *obj = [[CkoCharset alloc] init];
```

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Objective-C.

How failure is reported depends on the method's return type and is stated in the note under each method below. In every case the diagnostic text is in the `LastErrorText` property of the object whose method was called.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `@property (nonatomic, copy) NSString *DebugLogFilePath;` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `@property (nonatomic, readonly, copy) NSString *LastErrorHtml;` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `@property (nonatomic, readonly, copy) NSString *LastErrorText;` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `@property (nonatomic, readonly, copy) NSString *LastErrorXml;` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `@property (nonatomic) BOOL LastMethodSuccess;` | read/write | Indicates the success or failure of the most recent method call: `YES` means success, `NO` means failure. |
| `VerboseLogging` | `@property (nonatomic) BOOL VerboseLogging;` | read/write | If set to `YES`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `@property (nonatomic, readonly, copy) NSString *Version;` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `AltToCharset` | property, read/write | `@property (nonatomic, copy) NSString *AltToCharset;` |
| `ErrorAction` | property, read/write | `@property (nonatomic, copy) NSNumber *ErrorAction;` |
| `FromCharset` | property, read/write | `@property (nonatomic, copy) NSString *FromCharset;` |
| `LastInputAsHex` | property, read-only | `@property (nonatomic, readonly, copy) NSString *LastInputAsHex;` |
| `LastInputAsQP` | property, read-only | `@property (nonatomic, readonly, copy) NSString *LastInputAsQP;` |
| `LastOutputAsHex` | property, read-only | `@property (nonatomic, readonly, copy) NSString *LastOutputAsHex;` |
| `LastOutputAsQP` | property, read-only | `@property (nonatomic, readonly, copy) NSString *LastOutputAsQP;` |
| `SaveLast` | property, read/write | `@property (nonatomic) BOOL SaveLast;` |
| `ToCharset` | property, read/write | `@property (nonatomic, copy) NSString *ToCharset;` |
| `CharsetToCodePage` | method | `- (NSNumber *)CharsetToCodePage:(NSString *)charsetName;` |
| `CodePageToCharset` | method | `- (NSString *)CodePageToCharset:(NSNumber *)codePage;` |
| `ConvertData` | method | `- (NSData *)ConvertData:(NSData *)inData;` |
| `ConvertFile` | method | `- (BOOL)ConvertFile:(NSString *)srcPath     destPath:(NSString *)destPath;` |
| `ConvertFileNoPreamble` | method | `- (BOOL)ConvertFileNoPreamble:(NSString *)srcPath     destPath:(NSString *)destPath;` |
| `ConvertFromUnicode` | method | `- (NSData *)ConvertFromUnicode:(NSString *)inData;` |
| `ConvertFromUtf16` | method | `- (NSData *)ConvertFromUtf16:(NSData *)uniData;` |
| `ConvertHtml` | method | `- (NSData *)ConvertHtml:(NSData *)htmlIn;` |
| `ConvertHtmlFile` | method | `- (BOOL)ConvertHtmlFile:(NSString *)srcPath     destPath:(NSString *)destPath;` |
| `ConvertToUnicode` | method | `- (NSString *)ConvertToUnicode:(NSData *)inData;` |
| `ConvertToUtf16` | method | `- (NSData *)ConvertToUtf16:(NSData *)mbData;` |
| `EntityEncodeDec` | method | `- (NSString *)EntityEncodeDec:(NSString *)inStr;` |
| `EntityEncodeHex` | method | `- (NSString *)EntityEncodeHex:(NSString *)inStr;` |
| `GetHtmlCharset` | method | `- (NSString *)GetHtmlCharset:(NSData *)htmlData;` |
| `GetHtmlFileCharset` | method | `- (NSString *)GetHtmlFileCharset:(NSString *)htmlPath;` |
| `HtmlDecodeToStr` | method | `- (NSString *)HtmlDecodeToStr:(NSString *)str;` |
| `HtmlEntityDecode` | method | `- (NSData *)HtmlEntityDecode:(NSData *)inData;` |
| `HtmlEntityDecodeFile` | method | `- (BOOL)HtmlEntityDecodeFile:(NSString *)srcPath     destPath:(NSString *)destPath;` |
| `LowerCase` | method | `- (NSString *)LowerCase:(NSString *)inStr;` |
| `ReadFile` | method | `- (NSData *)ReadFile:(NSString *)path;` |
| `ReadFileToString` | method | `- (NSString *)ReadFileToString:(NSString *)path     srcCharset:(NSString *)srcCharset;` |
| `SetErrorString` | method | `- (void)SetErrorString:(NSString *)str     charset:(NSString *)charset;` |
| `UpperCase` | method | `- (NSString *)UpperCase:(NSString *)inStr;` |
| `UrlDecodeStr` | method | `- (NSString *)UrlDecodeStr:(NSString *)inStr;` |
| `VerifyData` | method | `- (BOOL)VerifyData:(NSString *)charset     charData:(NSData *)charData;` |
| `VerifyFile` | method | `- (BOOL)VerifyFile:(NSString *)charset     path:(NSString *)path;` |
| `WriteFile` | method | `- (BOOL)WriteFile:(NSString *)path     dataBuf:(NSData *)dataBuf;` |
| `WriteStringToFile` | method | `- (BOOL)WriteStringToFile:(NSString *)str     path:(NSString *)path     charset:(NSString *)charset;` |

## Properties

### Charset.AltToCharset

`Chilkat 11.7.0 · objc · Charset · AltToCharset · property · read/write`

```objectivec
@property (nonatomic, copy) NSString *AltToCharset;
```

Specifies the alternate destination character encoding used only when `ErrorAction` is `6`.

If a decoded input character cannot be represented in `ToCharset`, Chilkat attempts to encode that character using this alternate charset. If the alternate conversion also fails, the character is omitted from the output.

**Mixed-encoding output:** The result can contain a mixture of byte encodings. Such output is usually unsuitable for interchange unless the receiving format explicitly supports this behavior.

### Charset.ErrorAction

`Chilkat 11.7.0 · objc · Charset · ErrorAction · property · read/write`

```objectivec
@property (nonatomic, copy) NSNumber *ErrorAction;
```

Controls what happens when an input character has been decoded successfully but cannot be represented in the destination charset.

| Value | Action |
| :--- | :--- |
| `0` | Drop the unrepresentable character. |
| `1` | Insert the replacement configured by `SetErrorString`. |
| `2` | Emit a hexadecimal numeric character reference such as `&#x20AC;`. |
| `3`–`5` | Reserved. Do not use. |
| `6` | Encode the character using `AltToCharset`; drop it if that also fails. |
| `7` | Pass the nonconvertible data through unchanged. |

**Data-integrity warning:** Values `0`, `6`, and `7` can silently lose data or produce output that is not valid in the declared destination charset. For new code, prefer an explicit failure or replacement policy in the replacement API.

### Charset.FromCharset

`Chilkat 11.7.0 · objc · Charset · FromCharset · property · read/write`

```objectivec
@property (nonatomic, copy) NSString *FromCharset;
```

Specifies the character encoding of the input bytes for conversion operations. Chilkat decodes the source bytes using this charset before encoding the resulting Unicode text using `ToCharset`.

| Family | Recognized names |
| :--- | :--- |
| Unicode and ASCII | `us-ascii`, `utf-7`, `utf-8`, `unicode` / `utf-16` / `utf-16le`, `unicodefffe` / `utf-16be`, `utf-32`, `utf-32be` |
| ISO and Windows | `iso-8859-1`, `-2`, `-3`, `-4`, `-5`, `-6`, `-7`, `-8`, `-9`, `-13`, `-15`; `windows-874`, `windows-1250` through `windows-1258` |
| East Asian | `shift_jis`, `gb2312`, `ks_c_5601-1987`, `big5`, `iso-2022-jp`, `iso-2022-kr`, `euc-jp`, `euc-kr` |
| Macintosh | `macintosh`, `x-mac-japanese`, `x-mac-chinesetrad`, `x-mac-korean`, `x-mac-arabic`, `x-mac-hebrew`, `x-mac-greek`, `x-mac-cyrillic`, `x-mac-chinesesimp`, `x-mac-romanian`, `x-mac-ukrainian`, `x-mac-thai`, `x-mac-ce`, `x-mac-icelandic`, `x-mac-turkish`, `x-mac-croatian` |
| DOS, IBM, and legacy | `ebcdic`, `asmo-708`, `dos-720`, `dos-862`, `ibm01140` through `ibm01149`, `ibm037`, `ibm437`, `ibm500`, `ibm737`, `ibm775`, `ibm850`, `ibm852`, `ibm855`, `ibm857`, `ibm00858`, `ibm860`, `ibm861`, `ibm863`, `ibm864`, `ibm865`, `cp866`, `ibm869`, `ibm870`, `cp875`, `koi8-r`, `koi8-u` |

**Source encoding:** `unicode`, `utf-16`, and `utf-16le` identify little-endian UTF-16. `unicodefffe` and `utf-16be` identify big-endian UTF-16. Except where a method explicitly documents HTML metadata detection, set the source charset explicitly rather than assuming automatic detection.

### Charset.LastInputAsHex

`Chilkat 11.7.0 · objc · Charset · LastInputAsHex · property · read-only`

```objectivec
@property (nonatomic, readonly, copy) NSString *LastInputAsHex;
```

Returns the input bytes captured for the most recent conversion performed while `SaveLast` was enabled, represented as hexadecimal text.

**Diagnostic snapshot:** This is a diagnostic representation of the raw bytes. It does not perform another charset conversion, and the quoted-printable form is intended to make otherwise nonprintable bytes easier to inspect.

### Charset.LastInputAsQP

`Chilkat 11.7.0 · objc · Charset · LastInputAsQP · property · read-only`

```objectivec
@property (nonatomic, readonly, copy) NSString *LastInputAsQP;
```

Returns the input bytes captured for the most recent conversion performed while `SaveLast` was enabled, represented as quoted-printable text.

**Diagnostic snapshot:** This is a diagnostic representation of the raw bytes. It does not perform another charset conversion, and the quoted-printable form is intended to make otherwise nonprintable bytes easier to inspect.

### Charset.LastOutputAsHex

`Chilkat 11.7.0 · objc · Charset · LastOutputAsHex · property · read-only`

```objectivec
@property (nonatomic, readonly, copy) NSString *LastOutputAsHex;
```

Returns the output bytes captured for the most recent conversion performed while `SaveLast` was enabled, represented as hexadecimal text.

**Diagnostic snapshot:** This is a diagnostic representation of the raw bytes. It does not perform another charset conversion, and the quoted-printable form is intended to make otherwise nonprintable bytes easier to inspect.

### Charset.LastOutputAsQP

`Chilkat 11.7.0 · objc · Charset · LastOutputAsQP · property · read-only`

```objectivec
@property (nonatomic, readonly, copy) NSString *LastOutputAsQP;
```

Returns the output bytes captured for the most recent conversion performed while `SaveLast` was enabled, represented as quoted-printable text.

**Diagnostic snapshot:** This is a diagnostic representation of the raw bytes. It does not perform another charset conversion, and the quoted-printable form is intended to make otherwise nonprintable bytes easier to inspect.

### Charset.SaveLast

`Chilkat 11.7.0 · objc · Charset · SaveLast · property · read/write`

```objectivec
@property (nonatomic) BOOL SaveLast;
```

When `YES`, retains the input and output byte sequences from each conversion so they can be inspected through `LastInputAsHex`, `LastInputAsQP`, `LastOutputAsHex`, and `LastOutputAsQP`.

**Debugging only:** Enable this only while troubleshooting. Retaining both sides of a large conversion increases memory use and may keep sensitive plaintext in memory longer than necessary.

### Charset.ToCharset

`Chilkat 11.7.0 · objc · Charset · ToCharset · property · read/write`

```objectivec
@property (nonatomic, copy) NSString *ToCharset;
```

Specifies the destination character encoding for conversion operations. After decoding the source bytes using `FromCharset`, Chilkat encodes the resulting Unicode text in this charset.

| Family | Recognized names |
| :--- | :--- |
| Unicode and ASCII | `us-ascii`, `utf-7`, `utf-8`, `unicode` / `utf-16` / `utf-16le`, `unicodefffe` / `utf-16be`, `utf-32`, `utf-32be` |
| ISO and Windows | `iso-8859-1`, `-2`, `-3`, `-4`, `-5`, `-6`, `-7`, `-8`, `-9`, `-13`, `-15`; `windows-874`, `windows-1250` through `windows-1258` |
| East Asian | `shift_jis`, `gb2312`, `ks_c_5601-1987`, `big5`, `iso-2022-jp`, `iso-2022-kr`, `euc-jp`, `euc-kr` |
| Macintosh | `macintosh`, `x-mac-japanese`, `x-mac-chinesetrad`, `x-mac-korean`, `x-mac-arabic`, `x-mac-hebrew`, `x-mac-greek`, `x-mac-cyrillic`, `x-mac-chinesesimp`, `x-mac-romanian`, `x-mac-ukrainian`, `x-mac-thai`, `x-mac-ce`, `x-mac-icelandic`, `x-mac-turkish`, `x-mac-croatian` |
| DOS, IBM, and legacy | `ebcdic`, `asmo-708`, `dos-720`, `dos-862`, `ibm01140` through `ibm01149`, `ibm037`, `ibm437`, `ibm500`, `ibm737`, `ibm775`, `ibm850`, `ibm852`, `ibm855`, `ibm857`, `ibm00858`, `ibm860`, `ibm861`, `ibm863`, `ibm864`, `ibm865`, `cp866`, `ibm869`, `ibm870`, `cp875`, `koi8-r`, `koi8-u` |

**Choosing an output encoding:** For new text interchange, `utf-8` is normally the preferred destination. Legacy single-byte encodings cannot represent every Unicode character; `ErrorAction` controls how such conversion failures are handled.

## Methods

### Charset.CharsetToCodePage

`Chilkat 11.7.0 · objc · Charset · CharsetToCodePage · method`

```objectivec
- (NSNumber *)CharsetToCodePage:(NSString *)charsetName;
```

Returns the numeric Windows code-page identifier corresponding to `charsetName`. For example, `iso-8859-1` maps to `28591`, and `utf-8` maps to `65001`.

**Code pages:** A code page number is a legacy Windows identifier for a character encoding. Internet protocols and modern APIs normally use charset names such as `utf-8` rather than numeric code pages.

### Charset.CodePageToCharset

`Chilkat 11.7.0 · objc · Charset · CodePageToCharset · method`

```objectivec
- (NSString *)CodePageToCharset:(NSNumber *)codePage;
```

Returns the charset name corresponding to the numeric code-page identifier in `codePage`. For example, `65001` maps to `utf-8`. The operation fails when the code page is not recognized.

**Name normalization:** Different aliases can identify the same encoding. The returned value is Chilkat’s canonical name for the recognized code page, not necessarily the alias originally used by another application.

Returns `nil` on failure

### Charset.ConvertData

`Chilkat 11.7.0 · objc · Charset · ConvertData · method`

```objectivec
- (NSData *)ConvertData:(NSData *)inData;
```

Converts the bytes in `inData` from `FromCharset` to `ToCharset` and returns the converted bytes.

Returns `nil` on failure

### Charset.ConvertFile

`Chilkat 11.7.0 · objc · Charset · ConvertFile · method`

```objectivec
- (BOOL)ConvertFile:(NSString *)srcPath 
    destPath:(NSString *)destPath;
```

Reads the file at `inPath`, converts its text from `FromCharset` to `ToCharset`, and writes the converted bytes to the file at `destPath`.

When the destination charset is `utf-8` or `utf-16`, this method writes the corresponding byte-order mark (BOM) at the beginning of the output. Use `ConvertFileNoPreamble` when the output must not contain a BOM.

**BOM behavior:** A BOM is a leading byte sequence that can identify a Unicode encoding or byte order. UTF-8 does not require a BOM, and many modern formats prefer UTF-8 without one.

Returns YES for success, NO for failure.

### Charset.ConvertFileNoPreamble

`Chilkat 11.7.0 · objc · Charset · ConvertFileNoPreamble · method`

```objectivec
- (BOOL)ConvertFileNoPreamble:(NSString *)srcPath 
    destPath:(NSString *)destPath;
```

Reads the file at `inPath`, converts its text from `FromCharset` to `ToCharset`, and writes the converted bytes to `destPath` without adding a byte-order mark or other encoding preamble.

**UTF-8 output:** This is generally the appropriate choice for UTF-8 files unless the consuming system specifically requires a UTF-8 BOM.

Returns YES for success, NO for failure.

### Charset.ConvertFromUnicode

`Chilkat 11.7.0 · objc · Charset · ConvertFromUnicode · method`

```objectivec
- (NSData *)ConvertFromUnicode:(NSString *)inData;
```

Encodes the Unicode string in `inData` using `ToCharset` and returns the resulting bytes.

Returns `nil` on failure

### Charset.ConvertFromUtf16

`Chilkat 11.7.0 · objc · Charset · ConvertFromUtf16 · method`

```objectivec
- (NSData *)ConvertFromUtf16:(NSData *)uniData;
```

Converts the UTF-16 byte sequence in `uniData` to the character encoding specified by `ToCharset` and returns the resulting bytes.

Returns `nil` on failure

### Charset.ConvertHtml

`Chilkat 11.7.0 · objc · Charset · ConvertHtml · method`

```objectivec
- (NSData *)ConvertHtml:(NSData *)htmlIn;
```

Converts HTML bytes in `inData` from `FromCharset` to `ToCharset`. The returned bytes contain the converted HTML, and Chilkat updates the HTML `<meta>` charset declaration to identify the destination encoding.

**HTML charset declarations:** Updating a `<meta charset>` declaration does not change HTTP response headers. When serving the converted file over HTTP, the server’s `Content-Type` charset must agree with the actual bytes.

Returns `nil` on failure

### Charset.ConvertHtmlFile

`Chilkat 11.7.0 · objc · Charset · ConvertHtmlFile · method`

```objectivec
- (BOOL)ConvertHtmlFile:(NSString *)srcPath 
    destPath:(NSString *)destPath;
```

Converts the HTML file at `inPath` to `ToCharset` and writes the result to `destPath`. Chilkat also updates the HTML `<meta>` charset declaration to identify the destination encoding.

If `FromCharset` is empty, Chilkat attempts to obtain the source charset from an HTML `<meta>` declaration. Otherwise, the explicitly configured source charset is used.

**Detection limitation:** A declared charset is metadata, not proof of the file’s actual encoding. Incorrect or missing declarations can cause decoding errors; use an explicit source charset when it is known.

Returns YES for success, NO for failure.

### Charset.ConvertToUnicode

`Chilkat 11.7.0 · objc · Charset · ConvertToUnicode · method`

```objectivec
- (NSString *)ConvertToUnicode:(NSData *)inData;
```

Decodes the bytes in `inData` using `FromCharset` and returns the resulting Unicode string.

Returns `nil` on failure

### Charset.ConvertToUtf16

`Chilkat 11.7.0 · objc · Charset · ConvertToUtf16 · method`

```objectivec
- (NSData *)ConvertToUtf16:(NSData *)mbData;
```

Decodes the bytes in `mbData` using `FromCharset` and returns the text encoded as UTF-16 bytes.

Returns `nil` on failure

### Charset.EntityEncodeDec

`Chilkat 11.7.0 · objc · Charset · EntityEncodeDec · method`

```objectivec
- (NSString *)EntityEncodeDec:(NSString *)inStr;
```

Returns `str` with each non-US-ASCII character replaced by a decimal HTML/XML numeric character reference. For example, `é` becomes `&#233;`.

**Entity encoding:** Numeric character references describe Unicode characters; they are not a character-set conversion and do not make arbitrary binary data safe for HTML.

Returns `nil` on failure

### Charset.EntityEncodeHex

`Chilkat 11.7.0 · objc · Charset · EntityEncodeHex · method`

```objectivec
- (NSString *)EntityEncodeHex:(NSString *)inStr;
```

Returns `str` with each non-US-ASCII character replaced by a hexadecimal HTML/XML numeric character reference. For example, `é` becomes `&#xE9;`.

**Entity encoding:** Decimal and hexadecimal numeric references represent the same Unicode character; only the textual notation differs.

Returns `nil` on failure

### Charset.GetHtmlCharset

`Chilkat 11.7.0 · objc · Charset · GetHtmlCharset · method`

```objectivec
- (NSString *)GetHtmlCharset:(NSData *)htmlData;
```

Examines the HTML bytes in `inData` and returns the charset name declared by an HTML `<meta>` element, when present.

**Metadata only:** This reports the declaration found in the document. It does not verify that the bytes actually use that encoding, and it does not inspect an HTTP `Content-Type` header.

Returns `nil` on failure

### Charset.GetHtmlFileCharset

`Chilkat 11.7.0 · objc · Charset · GetHtmlFileCharset · method`

```objectivec
- (NSString *)GetHtmlFileCharset:(NSString *)htmlPath;
```

Examines the HTML file at `htmlFilePath` and returns the charset name declared by an HTML `<meta>` element, when present.

**Metadata only:** The method reads document metadata only. A missing, stale, or incorrect declaration does not reveal the file’s true encoding.

Returns `nil` on failure

### Charset.HtmlDecodeToStr

`Chilkat 11.7.0 · objc · Charset · HtmlDecodeToStr · method`

```objectivec
- (NSString *)HtmlDecodeToStr:(NSString *)str;
```

Decodes HTML named entities and numeric character references in `inStr` and returns the resulting Unicode string. Examples include `&lt;`, `&amp;`, `&#233;`, and `&#xE9;`.

**Security context:** Entity decoding is a text transformation, not HTML parsing or sanitization. Decoding untrusted text can reintroduce markup-significant characters such as `<`, `>`, and `&`.

Returns `nil` on failure

### Charset.HtmlEntityDecode

`Chilkat 11.7.0 · objc · Charset · HtmlEntityDecode · method`

```objectivec
- (NSData *)HtmlEntityDecode:(NSData *)inData;
```

Decodes HTML entities and numeric character references in the byte data supplied in `inHtml` and returns the resulting bytes.

**Operation scope:** Entity decoding is not a charset conversion and does not sanitize HTML.

Returns `nil` on failure

### Charset.HtmlEntityDecodeFile

`Chilkat 11.7.0 · objc · Charset · HtmlEntityDecodeFile · method`

```objectivec
- (BOOL)HtmlEntityDecodeFile:(NSString *)srcPath 
    destPath:(NSString *)destPath;
```

Reads the file at `inPath`, decodes HTML named entities and numeric character references, and writes the transformed content to `destPath`.

**Content transformation:** The output may contain literal markup-significant characters that were previously escaped. This operation does not parse, validate, or sanitize HTML.

Returns YES for success, NO for failure.

### Charset.LowerCase

`Chilkat 11.7.0 · objc · Charset · LowerCase · method`

```objectivec
- (NSString *)LowerCase:(NSString *)inStr;
```

Returns the lowercase form of `inStr` using Chilkat’s Unicode case conversion.

**Unicode casing:** Case conversion can change string length and is not the same operation as locale-aware collation or case-insensitive comparison.

Returns `nil` on failure

### Charset.ReadFile

`Chilkat 11.7.0 · objc · Charset · ReadFile · method`

```objectivec
- (NSData *)ReadFile:(NSString *)path;
```

Reads the entire file at `path` and returns its raw bytes without performing charset conversion.

Returns `nil` on failure

### Charset.ReadFileToString

`Chilkat 11.7.0 · objc · Charset · ReadFileToString · method`

```objectivec
- (NSString *)ReadFileToString:(NSString *)path 
    srcCharset:(NSString *)srcCharset;
```

Reads the text file at `path`, decodes its bytes using the charset named by `charset`, and returns the resulting Unicode string.

**Charset must match the file:** The caller must supply the actual source encoding. Choosing the wrong charset can produce replacement characters or silently incorrect text even when the file can be decoded.

Returns `nil` on failure

### Charset.SetErrorString

`Chilkat 11.7.0 · objc · Charset · SetErrorString · method`

```objectivec
- (void)SetErrorString:(NSString *)str 
    charset:(NSString *)charset;
```

Configures the replacement used when `ErrorAction` is `1`. `str` is the replacement text, and `charset` identifies the charset used to encode that replacement into the conversion output.

**Replacement behavior:** Choose replacement text that is representable in the specified charset. A common replacement is `?`, but explicit error handling is safer when data loss is unacceptable.

### Charset.UpperCase

`Chilkat 11.7.0 · objc · Charset · UpperCase · method`

```objectivec
- (NSString *)UpperCase:(NSString *)inStr;
```

Returns the uppercase form of `inStr` using Chilkat’s Unicode case conversion.

**Unicode casing:** Case conversion can change string length and is not the same operation as locale-aware collation or case-insensitive comparison.

Returns `nil` on failure

### Charset.UrlDecodeStr

`Chilkat 11.7.0 · objc · Charset · UrlDecodeStr · method`

```objectivec
- (NSString *)UrlDecodeStr:(NSString *)inStr;
```

Percent-decodes `inStr` and interprets the resulting bytes using the platform’s legacy ANSI character encoding.

For example, in a Western Windows code page, `%C9` may decode as `É`. UTF-8 input would encode the same character as `%C3%89` and is therefore not handled correctly by this legacy assumption.

**Legacy ANSI behavior:** Do not use this method for modern URLs or form data unless the data is known to use the applicable ANSI code page. Use `StringBuilder` URL decoding with an explicit charset, normally `utf-8`.

Returns `nil` on failure

### Charset.VerifyData

`Chilkat 11.7.0 · objc · Charset · VerifyData · method`

```objectivec
- (BOOL)VerifyData:(NSString *)charset 
    charData:(NSData *)charData;
```

Returns `YES` when the bytes in `inData` form a valid sequence for the charset named by `charset`; otherwise returns `NO`.

**What validation means:** This checks encoding validity only. It does not prove that the selected charset is the intended one. For many single-byte encodings, every possible byte value is valid.

### Charset.VerifyFile

`Chilkat 11.7.0 · objc · Charset · VerifyFile · method`

```objectivec
- (BOOL)VerifyFile:(NSString *)charset 
    path:(NSString *)path;
```

Returns `YES` when the contents of the file at `path` form a valid byte sequence for the charset named by `charset`; otherwise returns `NO`.

**Validation limitation:** A successful result means only that the bytes are structurally valid for that encoding. It does not identify the encoding or confirm that the decoded text is semantically correct.

### Charset.WriteFile

`Chilkat 11.7.0 · objc · Charset · WriteFile · method`

```objectivec
- (BOOL)WriteFile:(NSString *)path 
    dataBuf:(NSData *)dataBuf;
```

Writes all bytes from `byteData` to the file at `path` without performing charset conversion.

### Charset.WriteStringToFile

`Chilkat 11.7.0 · objc · Charset · WriteStringToFile · method`

```objectivec
- (BOOL)WriteStringToFile:(NSString *)str 
    path:(NSString *)path 
    charset:(NSString *)charset;
```

Encodes the Unicode text in `textData` using the charset named by `charset` and writes the resulting bytes to the file at `path`.

**Destination encoding:** The charset argument is the third parameter. Select `utf-8` for modern interchange unless a receiving system requires a specific legacy encoding.

Returns YES for success, NO for failure.

