~ubuntu-branches/ubuntu/lucid/camomile/lucid

« back to all changes in this revision

Viewing changes to public/charEncoding.ml

  • Committer: Bazaar Package Importer
  • Author(s): Sylvain Le Gall
  • Date: 2005-12-03 01:18:55 UTC
  • Revision ID: james.westby@ubuntu.com-20051203011855-qzvwlld1xyqnl62t
Tags: upstream-0.6.3
ImportĀ upstreamĀ versionĀ 0.6.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
(* $Id: charEncoding.ml,v 1.21 2004/11/03 11:21:53 yori Exp $ *)
 
2
(* Copyright 2001, 2002, 2003 Yamagata Yoriyuki *)
 
3
 
 
4
open OOChannel
 
5
 
 
6
let rec comp_sub_aux s1 i1 s2 i2 len =
 
7
  if len <= 0 then true else
 
8
  if s1.[i1] <> s2.[i2] then false else
 
9
  comp_sub_aux s1 (i1 + 1) s2 (i2 + 1) (len - 1)
 
10
 
 
11
let comp_sub s1 i1 len1 s2 i2 len2 =
 
12
  if len1 <> len2 then false else
 
13
  comp_sub_aux s1 i1 s2 i2 len1
 
14
 
 
15
exception Malformed_code
 
16
exception Out_of_range
 
17
 
 
18
type 'a machine =
 
19
     {read : 'a -> unit;
 
20
     term : unit -> unit;}
 
21
 
 
22
let feed_string decoder s =
 
23
  for i = 0 to (String.length s) - 1 do
 
24
    decoder.read s.[i]
 
25
  done
 
26
 
 
27
type t =
 
28
    {name : string;
 
29
     make_decoder : UChar.t machine -> char machine;
 
30
     make_encoder : char machine -> UChar.t machine}
 
31
 
 
32
let null_umachine =
 
33
  {read = (fun _ -> ());
 
34
   term = (fun () -> ())}
 
35
 
 
36
type automatic_state =
 
37
    Detection of (t * (char machine)) list
 
38
  | Decoding of char machine
 
39
 
 
40
let accept_char m c =
 
41
  try m.read c; true with Malformed_code -> false
 
42
 
 
43
let automatic name encs def =
 
44
  let make_decoder um =
 
45
    let buf = Buffer.create 0 in
 
46
    let state = ref (Detection
 
47
        (List.map (fun enc -> (enc, enc.make_decoder null_umachine)) encs))
 
48
    in
 
49
    let read c =
 
50
      match !state with
 
51
        Detection candidates ->
 
52
          Buffer.add_char buf c;
 
53
          let cs = List.filter (fun (_, m) -> accept_char m c) candidates in
 
54
          (match cs with
 
55
            [] -> raise Malformed_code
 
56
          | [(enc, _)] ->
 
57
              let m = enc.make_decoder um in
 
58
              feed_string m (Buffer.contents buf);
 
59
              state := Decoding m
 
60
          | _ -> state := Detection cs)
 
61
      | Decoding m -> m.read c
 
62
    in
 
63
    let term () =
 
64
      match !state with
 
65
        Detection ((enc, _) :: _) ->
 
66
          let m = enc.make_decoder um in
 
67
          feed_string m (Buffer.contents buf);
 
68
          m.term ()
 
69
      | Decoding m -> m.term ()
 
70
      | _ -> raise Malformed_code
 
71
    in
 
72
    {read = read; term = term}
 
73
  in
 
74
  {name = name; make_decoder = make_decoder; make_encoder = def.make_encoder}
 
75
 
 
76
let table = Hashtbl.create 0
 
77
let holded = ref []
 
78
 
 
79
let install name f =
 
80
  if Hashtbl.mem table name then 
 
81
    failwith (name ^" has been already installed : CharEncoding.install")
 
82
  else begin
 
83
    Hashtbl.add table name (`P f);
 
84
  end
 
85
 
 
86
let new_enc name enc = install name (fun () -> enc)
 
87
 
 
88
let aliases : (string, string) Hashtbl.t = Hashtbl.create 0
 
89
 
 
90
let alias s1 s2 = Hashtbl.add aliases s1 s2
 
91
 
 
92
(* Charmap based encodings *)
 
93
module Charmap_enc =
 
94
  struct
 
95
    let of_charmap charmap =
 
96
      let make_decoder um =
 
97
        let no_char = Charmap.no_char_of charmap.Charmap.enc_to_ucs in
 
98
        let start = Charmap.start_probe charmap.Charmap.enc_to_ucs in
 
99
        let state = ref start in
 
100
        let read c =
 
101
          let i = Char.code c in
 
102
          let n = Charmap.look_probe !state i in
 
103
          if n <> no_char then begin
 
104
            state := start;
 
105
            um.read (UChar.chr_of_uint n)
 
106
          end else                          
 
107
            match Charmap.next_probe !state i with
 
108
              None -> raise Malformed_code
 
109
            | Some next -> state := next in
 
110
        let term () = um.term () in
 
111
        {read = read; term = term}
 
112
      in
 
113
      let make_encoder cm =
 
114
        let read u =
 
115
          let n = UChar.uint_code u in
 
116
          let enc = Tbl31.get charmap.Charmap.ucs_to_enc n in
 
117
          if enc = "" then raise Out_of_range else
 
118
          feed_string cm enc
 
119
        in
 
120
        let term () = cm.term () in
 
121
        {read = read; term = term}
 
122
      in
 
123
      {name = charmap.Charmap.name; 
 
124
       make_decoder = make_decoder; 
 
125
       make_encoder = make_encoder}
 
126
  end
 
127
 
 
128
let of_charmap = Charmap_enc.of_charmap
 
129
 
 
130
let of_name alias = 
 
131
  let name = try Hashtbl.find aliases alias with Not_found -> alias in
 
132
  let rec look name =
 
133
    match Hashtbl.find table name with
 
134
      `P f ->
 
135
        let enc = f () in
 
136
        let b = Weak.create 1 in
 
137
        Weak.set b 0 (Some enc);
 
138
        Hashtbl.add table name (`W b);
 
139
        enc
 
140
    | `W b ->
 
141
        match Weak.get b 0 with
 
142
          None ->
 
143
            Hashtbl.remove table name;
 
144
            look name
 
145
        | Some x -> x in
 
146
  try look name with Not_found ->
 
147
    let charmap = Charmap.of_name name in
 
148
    let enc = of_charmap charmap in
 
149
    let b = Weak.create 1 in
 
150
    Weak.set b 0 (Some enc);
 
151
    Hashtbl.add table name (`W b);
 
152
    enc
 
153
 
 
154
let name_of enc = enc.name
 
155
 
 
156
let buf_machine buf =
 
157
  {read = (fun c -> Buffer.add_char buf c); term = fun () -> ()}
 
158
 
 
159
let recode_string ~in_enc ~out_enc s =
 
160
  let buf = Buffer.create (String.length s) in
 
161
  let encoder = out_enc.make_encoder (buf_machine buf) in
 
162
  let reader = in_enc.make_decoder encoder in
 
163
  feed_string reader s;
 
164
  reader.term ();
 
165
  Buffer.contents buf
 
166
 
 
167
let char_machine_of outchan =
 
168
  let b = String.make 1024 '\000' in
 
169
  let pos = ref 0 in
 
170
  let read c =
 
171
    b.[!pos] <- c;
 
172
    incr pos;
 
173
    if !pos >= 1024 then 
 
174
       let n = outchan#output b 0 1024 in
 
175
         String.blit b n b 0 (1024 - n);
 
176
         pos := 1024 - n
 
177
  in
 
178
  let flush () =    
 
179
    let n = outchan#output b 0 !pos in
 
180
      if n < !pos then
 
181
        failwith 
 
182
          "CharEncoding.char_machine_of: \
 
183
             Cannot flush the entire buffer";
 
184
      outchan#flush ();
 
185
  in
 
186
  let term () = 
 
187
    flush ();
 
188
    outchan#close_out () 
 
189
  in
 
190
    {read = read; term = term}, flush
 
191
 
 
192
class uchar_output_channel_of 
 
193
    enc
 
194
    (output : char_output_channel) 
 
195
    : [UChar.t] obj_output_channel =
 
196
  let c, flush = char_machine_of output in
 
197
  let m = enc.make_encoder c in
 
198
  object
 
199
    method put u = m.read u
 
200
    method close_out = m.term
 
201
    method flush = flush
 
202
  end
 
203
 
 
204
class out_channel enc outchan =
 
205
  uchar_output_channel_of enc (new OOChannel.of_out_channel outchan)
 
206
 
 
207
let queueing q =
 
208
  let read u = Queue.add u q in
 
209
  let term () = () in
 
210
  {read = read; term = term}
 
211
 
 
212
class uchar_input_channel_of enc 
 
213
    (input : char_input_channel)
 
214
    : [UChar.t] obj_input_channel =
 
215
  let q = Queue.create () in
 
216
  let b = String.make 1024 '\000' in
 
217
  object(self : 'a)
 
218
    val m = enc.make_decoder (queueing q)
 
219
    val mutable term = false
 
220
    method get() =
 
221
      try Queue.take q with Queue.Empty ->
 
222
        if term then raise End_of_file else
 
223
        (try 
 
224
           let len = input#input b 0 1024 in
 
225
             for i = 0 to len - 1 do m.read b.[i] done
 
226
         with End_of_file ->
 
227
          m.term (); term <- true);
 
228
        self#get()
 
229
    method close_in =
 
230
      Queue.clear q; term <- true; input#close_in
 
231
  end
 
232
 
 
233
class in_channel enc inchan =
 
234
  uchar_input_channel_of enc (new OOChannel.of_in_channel inchan)
 
235
  
 
236
class in_channel_from_stream enc s =
 
237
  uchar_input_channel_of enc 
 
238
    (new char_input_channel_of    
 
239
       (new channel_of_stream s))
 
240
 
 
241
let fill_string s pos len q =
 
242
  begin
 
243
    try while !pos < String.length s do
 
244
      s.[!pos] <- Queue.take q;
 
245
      incr pos;
 
246
    done with Queue.Empty -> ()
 
247
  end;
 
248
  let read c = 
 
249
    if !pos < String.length s then begin
 
250
      s.[!pos] <- c;
 
251
      incr pos;
 
252
    end else
 
253
      Queue.add c q
 
254
  in
 
255
  let term () = () in
 
256
    {read = read; term = term}
 
257
 
 
258
class convert_uchar_input enc (uinput : UChar.t obj_input_channel)
 
259
  : char_input_channel =
 
260
  let q = Queue.create () in
 
261
  object (self)
 
262
    val eof = false
 
263
    method input s pos len =
 
264
      let p = ref pos in
 
265
      let m = enc.make_encoder (fill_string s p len q) in
 
266
        try while !p < pos + len do
 
267
          m.read (uinput#get())
 
268
        done;
 
269
          !p - pos
 
270
        with End_of_file ->
 
271
          if eof then raise End_of_file else !p - pos
 
272
    method close_in () =
 
273
      uinput#close_in ();
 
274
      Queue.clear q;
 
275
  end
 
276
 
 
277
class convert_uchar_output enc (uoutput : UChar.t obj_output_channel) 
 
278
  : char_output_channel =
 
279
  let m = enc.make_decoder {read = uoutput#put; term = uoutput#close_out} in
 
280
  object (self)
 
281
    method output s pos len =
 
282
      for i = pos to pos + len - 1 do m.read s.[i] done;
 
283
      len;
 
284
    method flush = uoutput#flush
 
285
    method close_out = m.term
 
286
  end
 
287
 
 
288
class convert_input ~in_enc ~out_enc input =
 
289
  convert_uchar_input out_enc (new uchar_input_channel_of in_enc input)
 
290
 
 
291
class convert_output ~in_enc ~out_enc output =
 
292
  convert_uchar_output in_enc (new uchar_output_channel_of out_enc output)
 
293
    
 
294
let ustream_of enc s = stream_of_channel (new in_channel_from_stream enc s)
 
295
 
 
296
class in_char_channel enc input : [char] obj_input_channel =
 
297
  let q = Queue.create () in
 
298
  object(self : 'a)
 
299
    val m = enc.make_encoder (queueing q)
 
300
    val q = q
 
301
    val mutable term = false
 
302
    method get() =
 
303
      try Queue.take q with Queue.Empty ->
 
304
        if term then raise End_of_file else
 
305
        (try let u = input#get() in m.read u with End_of_file ->
 
306
          m.term (); term <- true);
 
307
        self#get()
 
308
    method close_in () =
 
309
      Queue.clear q; term <- true; input#close_in ()
 
310
  end
 
311
 
 
312
class in_char_channel_from_ustream enc us =
 
313
  in_char_channel enc (new channel_of_stream us)
 
314
 
 
315
let char_stream_of enc us = 
 
316
  stream_of_channel (new in_char_channel_from_ustream enc us)
 
317
 
 
318
module type Type =
 
319
  sig
 
320
    type text
 
321
    val decode : t -> string -> text
 
322
    val encode : t -> text -> string
 
323
  end
 
324
 
 
325
module Make (Text : UnicodeString.Type) =
 
326
struct
 
327
  type text = Text.t
 
328
 
 
329
  let ubuf_machine ubuf =
 
330
    {read = (fun u -> Text.Buf.add_char ubuf u); term = fun () -> ()}
 
331
 
 
332
  let feed_text encoder s =
 
333
    Text.iter encoder.read s
 
334
 
 
335
  let decode enc s =
 
336
    let buf = Text.Buf.create 0 in
 
337
    let m = enc.make_decoder (ubuf_machine buf) in
 
338
    feed_string m s;
 
339
    m.term ();
 
340
    Text.Buf.contents buf
 
341
 
 
342
  let encode enc s =
 
343
    let buf = Buffer.create (Text.length s) in
 
344
    let m = enc.make_encoder (buf_machine buf) in
 
345
    feed_text m s ;
 
346
    m.term ();
 
347
    Buffer.contents buf
 
348
end
 
349
 
 
350
(* Ascii *)
 
351
let _ =
 
352
  let make_decoder output_machine =
 
353
    let output = output_machine.read in
 
354
    let close = output_machine.term in
 
355
    let reader c =
 
356
      let code = Char.code c in
 
357
      if code >= 0x80 then raise Malformed_code else
 
358
      let u = UChar.chr_of_uint code in output u
 
359
    in 
 
360
    let term () = close () in
 
361
    {read = reader; term = term}
 
362
  in    
 
363
  let make_encoder output_machine =
 
364
    let output = output_machine.read in
 
365
    let close = output_machine.term in
 
366
    let reader u =
 
367
      let code = UChar.uint_code u in
 
368
      if code < 0 || code >= 0x80 then raise Out_of_range else
 
369
      output (Char.chr code)
 
370
    in
 
371
    let term () = close () in
 
372
    {read = reader; term = term}
 
373
  in
 
374
  let enc = fun () ->
 
375
    {name = "US-ASCII"; 
 
376
     make_decoder = make_decoder;
 
377
     make_encoder = make_encoder;}
 
378
  in begin
 
379
    install "US-ASCII" enc;
 
380
    install "USASCII" enc;
 
381
    install "ASCII" enc;
 
382
    install "ISO646US" enc;
 
383
    install "IBM367" enc;
 
384
    install "CP367" enc;
 
385
    install "ANSI_X3.4-1968" enc;
 
386
  end
 
387
 
 
388
(* ISO-8859-1, Latin-1 *)
 
389
let _ =
 
390
  let make_decoder output_machine =
 
391
    let output = output_machine.read in
 
392
    let close = output_machine.term in
 
393
    let reader c =
 
394
      let code = Char.code c in
 
395
      let u = UChar.chr_of_uint code in output u
 
396
    in 
 
397
    let term () = close () in
 
398
    {read = reader; term = term}
 
399
  in    
 
400
  let make_encoder output_machine =
 
401
    let output = output_machine.read in
 
402
    let close = output_machine.term in
 
403
    let reader u =
 
404
      let c = 
 
405
        try (UChar.char_of u) 
 
406
        with Invalid_argument _ -> raise Out_of_range
 
407
      in
 
408
      output c
 
409
    in
 
410
    let term () = close () in
 
411
    {read = reader; term = term}
 
412
  in
 
413
  let enc = fun () ->
 
414
    {name = "Latin-1"; 
 
415
     make_decoder = make_decoder;
 
416
     make_encoder = make_encoder;}
 
417
  in begin
 
418
    install "ISO-8859-1" enc;
 
419
    install "Latin-1" enc;
 
420
  end
 
421
 
 
422
(* UTF-8 *)
 
423
 
 
424
type utf8_decoder_state =
 
425
    {mutable remain : int; mutable cur : int}
 
426
 
 
427
let _ =
 
428
  let masq = 0b111111 in
 
429
  let make_decoder output_machine =
 
430
    let output = output_machine.read in
 
431
    let close = output_machine.term in
 
432
    let state = {remain = 0; cur = 0} in
 
433
    let reader c =
 
434
      let i = Char.code c in
 
435
      if state.remain = 0
 
436
      then                              (*beginning of char*)
 
437
        if i <= 0x7f then output (UChar.chr_of_uint i) else
 
438
        if i >= 0xc2 && i <= 0xdf then
 
439
          begin state.remain <- 1; state.cur <- (i - 0xc0) end
 
440
        else if i >= 0xe0 && i <= 0xef then
 
441
          begin state.remain <- 2; state.cur <- (i - 0xe0) end
 
442
        else if i >= 0xf0 && i <= 0xf7 then
 
443
          begin state.remain <- 3; state.cur <- (i - 0xf0) end 
 
444
        else if i >= 0xf8 && i <= 0xfb then
 
445
          begin state.remain <- 4; state.cur <- (i - 0xf8) end
 
446
        else if i >= 0xfc && i <= 0xfd then
 
447
          begin state.remain <- 5; state.cur <- (i - 0xfc) end
 
448
        else raise Malformed_code
 
449
      else
 
450
        if i < 0x80 then raise Malformed_code else
 
451
        let i' = i - 0x80 in
 
452
        let a = (state.cur lsl 6) + i' in
 
453
        (* reject unnecessary long encoding *)
 
454
        if a = 0 then raise Malformed_code else
 
455
        state.remain <- state.remain - 1;
 
456
        if state.remain = 0 then output (UChar.chr_of_uint a) else
 
457
        state.cur <- a
 
458
    in
 
459
    let term () = close () in
 
460
    {read = reader; term = term}
 
461
  in    
 
462
  let make_encoder output_machine =
 
463
    let output = output_machine.read in
 
464
    let close = output_machine.term in
 
465
    let reader u =
 
466
      let k = UChar.uint_code u in
 
467
      if k >= 0 && k <= 0x7f then output (Char.chr k) else
 
468
      if k >= 0x80 && k <= 0x7ff then 
 
469
        let c0 = Char.chr (0xc0 + (k lsr 6)) in
 
470
        let c1 = Char.chr (0x80 + (k land masq)) in
 
471
        begin output c0; output c1; end
 
472
      else if k >= 0x800 && k <= 0xffff then
 
473
        let c0 = Char.chr (0xe0 + (k lsr 12)) in
 
474
        let c1 = Char.chr (0x80 + ((k lsr 6) land masq)) in
 
475
        let c2 = Char.chr (0x80 + (k land masq)) in
 
476
        begin output c0; output c1; output c2 end
 
477
      else if k >= 0x10000 && k <= 0x1fffff then
 
478
        let c0 = Char.chr (0xf0 + (k lsr 18)) in
 
479
        let c1 = Char.chr (0x80 + ((k lsr 12) land masq)) in
 
480
        let c2 = Char.chr (0x80 + ((k lsr 6) land masq)) in
 
481
        let c3 = Char.chr (0x80 + (k land masq)) in
 
482
        begin output c0; output c1; output c2; output c3 end
 
483
      else if k >= 0x200000 && k <= 0x3ffffff then
 
484
        let c0 = Char.chr (0xf8 + (k lsr 24)) in
 
485
        let c1 = Char.chr (0x80 + ((k lsr 18) land masq)) in
 
486
        let c2 = Char.chr (0x80 + ((k lsr 12) land masq)) in
 
487
        let c3 = Char.chr (0x80 + ((k lsr 6) land masq)) in
 
488
        let c4 = Char.chr (0x80 + (k land masq)) in
 
489
        begin output c0; output c1; output c2; output c3; output c4 end
 
490
      else if k >= 0x4000000 || k < 0 then
 
491
        let c0 = Char.chr (0xfc + (k lsr 30)) in
 
492
        let c1 = Char.chr (0x80 + ((k lsr 24) land masq)) in
 
493
        let c2 = Char.chr (0x80 + ((k lsr 18) land masq)) in
 
494
        let c3 = Char.chr (0x80 + ((k lsr 12) land masq)) in
 
495
        let c4 = Char.chr (0x80 + ((k lsr 6) land masq)) in
 
496
        let c5 = Char.chr (0x80 + (k land masq)) in
 
497
        begin 
 
498
          output c0; output c1; output c2; output c3; output c4; output c5
 
499
        end
 
500
      else raise Out_of_range
 
501
    in
 
502
    let term () = close () in
 
503
    {read = reader; term = term}
 
504
  in
 
505
  let enc = fun () ->
 
506
    {name = "UTF-8"; 
 
507
     make_decoder = make_decoder;
 
508
     make_encoder = make_encoder;}
 
509
  in begin
 
510
    install "UTF-8" enc;
 
511
  end
 
512
 
 
513
(* UTF-16 *)
 
514
 
 
515
type endian = BE | LE | Unknown
 
516
 
 
517
type ucs2_machine =
 
518
    {read2 : int -> unit;
 
519
     term2 : unit -> unit}
 
520
 
 
521
type ucs2_buf =
 
522
    {mutable first_char : bool;
 
523
     mutable buf : int}
 
524
 
 
525
let char_machine_be m =
 
526
  let state = {first_char = true; buf = 0} in
 
527
  let read c =
 
528
    if state.first_char 
 
529
    then begin state.buf <- (Char.code c); state.first_char <- false; end
 
530
    else begin
 
531
      m.read2 ((state.buf lsl 8) lor (Char.code c));
 
532
      state.first_char <- true;
 
533
    end
 
534
  in
 
535
  let term () = m.term2 () in
 
536
  {read = read; term = term}
 
537
 
 
538
let char_machine_le m =
 
539
  let state = {first_char = true; buf = 0} in
 
540
  let read c =
 
541
    if state.first_char 
 
542
    then begin state.buf <- (Char.code c); state.first_char <- false; end
 
543
    else begin
 
544
      m.read2 (((Char.code c) lsl 8) lor state.buf);
 
545
      state.first_char <- true;
 
546
    end
 
547
  in
 
548
  let term () = m.term2 () in
 
549
  {read = read; term = term}
 
550
 
 
551
let be_outmachine m =
 
552
  let read i =
 
553
    m.read (Char.chr (i lsr 8));
 
554
    m.read (Char.chr (i land 255))
 
555
  in {read2 = read; term2 = m.term}
 
556
 
 
557
let le_outmachine m =
 
558
  let read i =
 
559
    m.read (Char.chr (i land 255));
 
560
    m.read (Char.chr (i lsr 8))
 
561
  in {read2 = read; term2 = m.term}
 
562
 
 
563
type utf16_decoder_state =
 
564
    {mutable surrogated : bool;
 
565
     mutable buf : int}
 
566
 
 
567
let _ =
 
568
  let make_decoder m =
 
569
    let output = m.read in
 
570
    let close = m.term in
 
571
    let state = {surrogated = false; buf = 0} in
 
572
    let read i =
 
573
      if state.surrogated 
 
574
      then
 
575
        if i >= 0xdc00 && i <= 0xdfff then
 
576
          let i' = (state.buf - 0xd800) lsl 10 + (i - 0xdc00) + 0x10000 in
 
577
          begin output (UChar.chr_of_uint i'); state.surrogated <- false end
 
578
        else raise Malformed_code
 
579
      else
 
580
        if i = 0xfeff then () else      (*BOM is ignored*)
 
581
        if i <= 0xd7ff || (i >= 0xe000 && i <= 0xfffd) then 
 
582
          output (UChar.chr_of_uint i)
 
583
        else if i >= 0xd800 && i <= 0xdbff then
 
584
          begin state.surrogated <- true; state.buf <- i end
 
585
        else raise Malformed_code
 
586
    in
 
587
    let term = close in
 
588
    {read2 = read; term2 = term}
 
589
  in
 
590
  let make_encoder m =
 
591
    let output = m.read2 in
 
592
    let close = m.term2 in
 
593
    output 0xfeff;
 
594
    let read u =
 
595
      let i = UChar.uint_code u in
 
596
      if i >= 0x0 && i < 0xd800 || i >= 0xe000 && i < 0x10000
 
597
      then output i
 
598
      else if i >= 0x10000 && i <= 0x10ffff then
 
599
        let i1 = (i - 0x10000) lsr 10 + 0xd800 in
 
600
        let i2 = (i - 0x10000) land 0x3ff + 0xdc00 in
 
601
        output i1; output i2
 
602
      else raise Out_of_range
 
603
    in
 
604
    let term = close in
 
605
    {read = read; term = term}
 
606
  in
 
607
  let make_decoder_be m = char_machine_be (make_decoder m) in
 
608
  let make_encoder_be m = make_encoder (be_outmachine m) in
 
609
  let make_decoder_le m = char_machine_le (make_decoder m) in
 
610
  let make_encoder_le m = make_encoder (le_outmachine m) in
 
611
  
 
612
  let enc_be =
 
613
    {name = "UTF-16BE";
 
614
     make_decoder = make_decoder_be;
 
615
     make_encoder = make_encoder_be;}
 
616
  in
 
617
  let enc_le =
 
618
    {name = "UTF-16LE";
 
619
     make_decoder = make_decoder_le;
 
620
     make_encoder = make_encoder_le;}
 
621
  in
 
622
 
 
623
  let enc_unknown = 
 
624
    fun () -> automatic "UTF-16" [enc_be; enc_le] enc_be in
 
625
 
 
626
  begin
 
627
    install "UTF-16BE" (fun () -> enc_be);
 
628
    install "UTF-16LE" (fun () -> enc_le);
 
629
    install "UTF-16" enc_unknown
 
630
  end
 
631
 
 
632
(* UCS-4, UTF-32, UTF-32BE, UTF-32LE*)
 
633
 
 
634
module UTF32 =
 
635
  struct
 
636
 
 
637
    type ucs4_machine =
 
638
        {read4 : int -> unit;
 
639
          term4 : unit -> unit}
 
640
 
 
641
    type ucs4_buf =
 
642
        {mutable count : int;
 
643
         mutable buf : int}
 
644
 
 
645
    let char_machine_be m =
 
646
      let state = {count = 0; buf = 0} in
 
647
      let read c =
 
648
        let i = Char.code c in
 
649
        if state.count = 0 && i > 0x7f then raise Malformed_code else begin
 
650
          state.buf <- (state.buf lsl 8) lor i;
 
651
          state.count <- state.count + 1;
 
652
          if state.count = 4 then begin
 
653
            m.read4 state.buf;
 
654
            state.count <- 0; state.buf <- 0 end
 
655
          else ()
 
656
        end
 
657
      in
 
658
      let term () = m.term4 () in
 
659
      {read = read; term = term}
 
660
 
 
661
    let char_machine_le m =
 
662
      let state = {count = 0; buf = 0} in
 
663
      let read c =
 
664
        let i = Char.code c in
 
665
        if state.count = 3 && i > 0x7f then raise Malformed_code else begin
 
666
          state.buf <- (i lsl (8 * state.count)) lor state.buf;
 
667
          state.count <- state.count + 1;
 
668
          if state.count = 4 then begin
 
669
            m.read4 state.buf;
 
670
            state.count <- 0; state.buf <- 0 end
 
671
          else ()
 
672
        end
 
673
      in
 
674
      let term () = m.term4 () in
 
675
      {read = read; term = term}
 
676
 
 
677
    let be_outmachine m =
 
678
      let read i =
 
679
        m.read (Char.chr (i lsr 24));
 
680
        m.read (Char.chr ((i lsr 16) land 255));
 
681
        m.read (Char.chr ((i lsr 8) land 255));
 
682
        m.read (Char.chr (i land 255))
 
683
      in {read4 = read; term4 = m.term}
 
684
 
 
685
    let le_outmachine m =
 
686
      let read i =
 
687
        m.read (Char.chr (i land 255));
 
688
        m.read (Char.chr ((i lsr 8) land 255));
 
689
        m.read (Char.chr ((i lsr 16) land 255));
 
690
        m.read (Char.chr (i lsr 24))
 
691
      in {read4 = read; term4 = m.term}
 
692
 
 
693
    let make_ucs4_decoder m =
 
694
      let read n =
 
695
        m.read (UChar.chr_of_uint n)
 
696
      in
 
697
      let term () = m.term () in
 
698
      {read4 = read; term4 = term}
 
699
 
 
700
    let make_ucs4_encoder m =
 
701
      let read u =
 
702
        let n = UChar.uint_code u in
 
703
        m.read4 n
 
704
      in
 
705
      let term () = m.term4 () in
 
706
      {read = read; term = term}
 
707
 
 
708
    let make_utf32_decoder m =
 
709
      let read n =
 
710
        if n = 0xfeff then () else      (*BOM is ignored*)
 
711
        if n > 0x10ffff || n < 0 || n = 0xfffe then raise Malformed_code else
 
712
        m.read (UChar.chr_of_uint n)
 
713
      in
 
714
      let term () = m.term () in
 
715
      {read4 = read; term4 = term}
 
716
 
 
717
    let make_utf32_encoder m =
 
718
      m.read4 0xfeff;
 
719
      let read u =
 
720
        let n = UChar.uint_code u in
 
721
        if n > 0x10ffff || n < 0 || n = 0xfffe then raise Out_of_range else
 
722
        m.read4 n
 
723
      in
 
724
      let term () = m.term4 () in
 
725
      {read = read; term = term}
 
726
 
 
727
    let make_utf32_be_decoder m =
 
728
      char_machine_be (make_utf32_decoder m)
 
729
 
 
730
    let make_utf32_le_decoder m =
 
731
      char_machine_le (make_utf32_decoder m)
 
732
 
 
733
    let make_utf32_be_encoder m =
 
734
      make_utf32_encoder (be_outmachine m)
 
735
 
 
736
    let make_utf32_le_encoder m =
 
737
      make_utf32_encoder (le_outmachine m)
 
738
 
 
739
(* 4-bytes encoding for unicode.  All 31-bits code points are allowed.
 
740
 * ISO 10646-1 doesn't specify endianess.  We use big endian ordering
 
741
 * without BOM.
 
742
 *)
 
743
    let ucs4 =
 
744
      let make_decoder m = char_machine_be (make_ucs4_decoder m) in
 
745
      let make_encoder m = make_ucs4_encoder (be_outmachine m) in
 
746
      {name = "UCS-4";
 
747
       make_decoder = make_decoder;
 
748
       make_encoder = make_encoder}
 
749
 
 
750
(* The same as UCS-4, but range is limited to 21-bits code points. *)
 
751
    let utf32_be =
 
752
      let make_decoder m = make_utf32_be_decoder m in
 
753
      let make_encoder m = make_utf32_be_encoder m in
 
754
      {name = "UTF-32BE";
 
755
       make_decoder = make_decoder;
 
756
       make_encoder = make_encoder}
 
757
 
 
758
(* Little endian order. *)
 
759
    let utf32_le =
 
760
      let make_decoder m = make_utf32_le_decoder m in
 
761
      let make_encoder m = make_utf32_le_encoder m in
 
762
      {name = "UTF-32LE";
 
763
       make_decoder = make_decoder;
 
764
       make_encoder = make_encoder}
 
765
 
 
766
(* UTF-32 with unknown endianness. *)
 
767
    let utf32 = fun () ->
 
768
      automatic "UTF-32" [utf32_be; utf32_le] utf32_be
 
769
 
 
770
    let init () =
 
771
      install "UCS-4" (fun () -> ucs4);
 
772
      install "UTF-32BE" (fun () -> utf32_be);
 
773
      install "UTF-32LE" (fun () -> utf32_le);
 
774
      install "UTF-32" utf32
 
775
 
 
776
  end
 
777
 
 
778
let _ = UTF32.init ()
 
779
 
 
780
(* iso-2022-jp *)
 
781
 
 
782
let enc_to_ucs map enc =
 
783
  let no_char = Unimap.no_char_ucs map in
 
784
  let ucs = Unimap.enc_to_ucs map enc in
 
785
  if ucs = no_char then raise Malformed_code else ucs
 
786
 
 
787
let ucs_to_enc map enc =
 
788
  let no_char = Unimap.no_char_enc map in
 
789
  let enc = Unimap.ucs_to_enc map enc in
 
790
  if enc = no_char then raise Out_of_range else enc
 
791
 
 
792
module Iso2022jp =
 
793
  struct
 
794
 
 
795
    type charset = Ascii | Jisx0208_1978 | Jisx0208_1983 | Jisx0201_roman
 
796
  | Jisx0201_kana | Gb2312_1980 | Ksc5601_1987 | Jisx0212_1990 
 
797
  | Iso88591 | Iso88597 | Unknown
 
798
 
 
799
    let unibyte charset =
 
800
      match charset with
 
801
        Ascii -> true | Jisx0201_roman -> true | Jisx0201_kana -> true
 
802
      | Iso88591 -> true | Iso88597 -> true 
 
803
      | Jisx0208_1978 -> false | Jisx0208_1983 -> false |Jisx0212_1990 -> false
 
804
      | Gb2312_1980 -> false | Ksc5601_1987 -> false | Unknown -> assert false
 
805
 
 
806
    let set94 charset =
 
807
      match charset with
 
808
        Ascii -> true | Jisx0201_roman -> true | Jisx0201_kana -> true
 
809
      | Iso88591 -> false | Iso88597 -> false 
 
810
      | Jisx0208_1978 -> true | Jisx0208_1983 -> true |Jisx0212_1990 -> true
 
811
      | Gb2312_1980 -> true | Ksc5601_1987 -> true | Unknown -> assert false
 
812
            
 
813
    let esc = Char.chr 0x1b                     (* \027 *)
 
814
 
 
815
    type state_type = 
 
816
        {mutable remain : int;          (* <0 means escape sequence*)
 
817
         mutable g0 : charset;
 
818
         mutable g2 : charset;
 
819
         mutable single_shift : bool;
 
820
         buf : string}
 
821
 
 
822
    let make_enc_2 () =
 
823
      let gb2312 = Unimap.of_name "gb2312" in
 
824
      let jisx0201 = Unimap.of_name "jisx0201" in
 
825
      let jisx0208 = Unimap.of_name "jisx0208" in
 
826
      let jisx0212 = Unimap.of_name "jisx0212" in
 
827
      let ksc5601 = Unimap.of_name "ksc5601" in
 
828
      let iso88597 = Unimap.of_name "iso88597" in
 
829
 
 
830
      let make_decoder_2 m =
 
831
        let to_uchar_2 charset code =
 
832
          let ucode =
 
833
            match charset with
 
834
              Ascii -> code
 
835
            | Jisx0208_1978 -> enc_to_ucs jisx0208 code
 
836
            | Jisx0208_1983 -> enc_to_ucs jisx0208 code
 
837
            | Jisx0201_roman -> enc_to_ucs jisx0201 code
 
838
            | Jisx0201_kana ->  enc_to_ucs jisx0201 (code + 0x80)
 
839
            | Gb2312_1980 -> enc_to_ucs gb2312 code
 
840
            | Ksc5601_1987 -> enc_to_ucs ksc5601 code
 
841
            | Jisx0212_1990 -> enc_to_ucs jisx0212 code
 
842
            | Iso88591 -> code + 0x80
 
843
            | Iso88597 -> enc_to_ucs iso88597 (code + 0x80)
 
844
            | Unknown -> raise Malformed_code
 
845
          in UChar.chr_of_uint ucode
 
846
        in
 
847
        let state = 
 
848
          {remain = 0; 
 
849
           g0 = Ascii; 
 
850
           g2 = Unknown; 
 
851
           single_shift = false;
 
852
           buf = String.create 3} 
 
853
        in
 
854
        let reader c =
 
855
          let i = Char.code c in
 
856
          if i >= 0x80 then raise Malformed_code else
 
857
          if state.single_shift 
 
858
          then 
 
859
            if i >= 0x20 && i <= 0x7f
 
860
            then
 
861
              begin
 
862
                m.read (to_uchar_2 state.g2 i); 
 
863
                state.single_shift <- false 
 
864
              end
 
865
            else raise Malformed_code
 
866
          else 
 
867
            match state.remain with
 
868
              0 ->
 
869
                (* escape sequence?. *)
 
870
                if c = esc then state.remain <- -1 else
 
871
                (* control code or white space, backspace *)
 
872
                if i <= 0x20 || i = 0x7f then m.read (UChar.chr_of_uint i) else
 
873
                if unibyte state.g0
 
874
                then m.read (to_uchar_2 state.g0 i)
 
875
                else begin state.remain <- 1; state.buf.[0] <- c end
 
876
            | 1 ->
 
877
                let i1 = Char.code state.buf.[0] in
 
878
                let i2 = Char.code c in
 
879
                if i2 >= 0x21 && i2 <= 0x7e 
 
880
                then 
 
881
                  let u = to_uchar_2 state.g0 ((i1 lsl 8) + i2) in
 
882
                  m.read u
 
883
                else raise Malformed_code;
 
884
                state.remain <- 0
 
885
            | _ ->                      (*escape seq.*)
 
886
                state.buf.[~-(state.remain) - 1] <- c;
 
887
                state.remain <- state.remain - 1;
 
888
                let i = Char.code c in
 
889
                let len = ~- (state.remain) - 1 in
 
890
                if i >= 0x20 && i <= 0x2f then
 
891
                  if len >= 3 then raise Malformed_code else ()
 
892
                else if i >= 0x30 && i <= 0x7e then begin
 
893
                  state.remain <- 0;
 
894
                  if comp_sub "(B" 0 2 state.buf 0 len then
 
895
                    state.g0 <- Ascii
 
896
                  else if comp_sub "(I" 0 2 state.buf 0 len then
 
897
                    state.g0 <- Jisx0201_kana
 
898
                  else if comp_sub "(J" 0 2 state.buf 0 len then
 
899
                    state.g0 <- Jisx0201_roman
 
900
                  else if comp_sub "$@" 0 2 state.buf 0 len then
 
901
                    state.g0 <- Jisx0208_1978
 
902
                  else if comp_sub "$A" 0 2 state.buf 0 len then
 
903
                    state.g0 <- Gb2312_1980
 
904
                  else if comp_sub "$B" 0 2 state.buf 0 len then
 
905
                    state.g0 <- Jisx0208_1983
 
906
                  else if comp_sub "$(C" 0 3 state.buf 0 len then
 
907
                    state.g0 <- Ksc5601_1987
 
908
                  else if comp_sub "$(D" 0 3 state.buf 0 len then
 
909
                    state.g0 <- Jisx0212_1990
 
910
                  else if comp_sub ".A" 0 2 state.buf 0 len then
 
911
                    state.g2 <- Iso88591
 
912
                  else if comp_sub ".F" 0 2 state.buf 0 len then
 
913
                    state.g2 <- Iso88597
 
914
                  else if comp_sub "N" 0 1 state.buf 0 len then
 
915
                    state.single_shift <- true
 
916
                  else raise Malformed_code;
 
917
                end else raise Malformed_code
 
918
        in
 
919
        {read = reader; term = m.term} in
 
920
      
 
921
      let make_encoder_2 m =
 
922
        let from_uchar_2 u =
 
923
          let n = UChar.code u in
 
924
          (* the order of tests is *significant* *)
 
925
          if n >= 0x00 && n <= 0x7f then Ascii, n else
 
926
          if n >= 0xa0 && n <= 0xff then Iso88591, (n - 0x80) else
 
927
          let enc = Unimap.ucs_to_enc jisx0208 n in
 
928
          if enc <> Unimap.no_char_enc jisx0208 then (Jisx0208_1983, enc) else
 
929
          let enc = Unimap.ucs_to_enc jisx0212 n in
 
930
          if enc <> Unimap.no_char_enc jisx0212 then (Jisx0212_1990, enc) else
 
931
          let enc = Unimap.ucs_to_enc gb2312 n in
 
932
          if enc <> Unimap.no_char_enc gb2312 then (Gb2312_1980, enc) else
 
933
          let enc = Unimap.ucs_to_enc ksc5601 n in
 
934
          if enc <> Unimap.no_char_enc ksc5601 then (Ksc5601_1987, enc) else
 
935
          let enc = Unimap.ucs_to_enc iso88597 n in
 
936
          if enc <> Unimap.no_char_enc iso88597 then (Iso88597, enc - 0x80) else
 
937
          let n' = Unimap.ucs_to_enc jisx0201 n in
 
938
          if n' = Unimap.no_char_enc jisx0201 then raise Out_of_range else
 
939
          if n' >= 0x80 then Jisx0201_kana, (n' - 0x80) else Jisx0201_roman, n'
 
940
        in        
 
941
        (*fields other than g0, g2 are not used*)
 
942
        let state =
 
943
          {remain = 0; 
 
944
           g0 = Ascii; 
 
945
           g2 = Unknown; 
 
946
           single_shift = false;
 
947
           buf = String.create 1}
 
948
        in
 
949
        let reader u =
 
950
          let cs, i = from_uchar_2 u in
 
951
          let c1 = Char.chr (i lsr 8) in
 
952
          let c2 = Char.chr (i land 255) in
 
953
          if c1 = esc || c2 = esc then raise Out_of_range else
 
954
          if set94 cs
 
955
          then
 
956
            if state.g0 = cs
 
957
            then
 
958
              if unibyte cs
 
959
              then m.read c2
 
960
              else begin m.read c1; m.read c2 end
 
961
            else
 
962
              (match cs with
 
963
                Ascii ->
 
964
                  state.g0 <- Ascii;
 
965
                  m.read esc; m.read '('; m.read 'B'; m.read c2
 
966
              | Jisx0201_kana ->
 
967
                  state.g0 <- Jisx0201_kana;
 
968
                  m.read esc; m.read '('; m.read 'I'; m.read c2
 
969
              | Jisx0201_roman ->
 
970
                  state.g0 <- Jisx0201_roman;
 
971
                  m.read esc; m.read '('; m.read 'J'; m.read c2
 
972
              | Gb2312_1980 ->
 
973
                  state.g0 <- Gb2312_1980;
 
974
                  m.read esc; m.read '$'; m.read 'A'; m.read c1; m.read c2
 
975
              | Jisx0208_1983 ->
 
976
                  state.g0 <- Jisx0208_1983;
 
977
                  m.read esc; m.read '$'; m.read 'B'; m.read c1; m.read c2
 
978
              | Ksc5601_1987 ->
 
979
                  state.g0 <- Ksc5601_1987;
 
980
                  m.read esc; m.read '$'; m.read '('; m.read 'C';
 
981
                  m.read c1; m.read c2
 
982
              | Jisx0212_1990 ->
 
983
                  state.g0 <- Jisx0212_1990;
 
984
                  m.read esc; m.read '$'; m.read '('; m.read 'D';
 
985
                  m.read c1; m.read c2
 
986
              | _ -> assert false)
 
987
          else                          (*set96*)
 
988
            (* since RFC allows G2 is cleared in the begining of lines, 
 
989
             * we set G2 every times. *)
 
990
            (match cs with
 
991
              Iso88591 ->
 
992
                m.read esc; m.read '.'; m.read 'A'; 
 
993
                m.read esc; m.read 'N'; m.read c2
 
994
            | Iso88597 ->
 
995
                m.read esc; m.read '.'; m.read 'F'; 
 
996
                m.read esc; m.read 'N'; m.read c2
 
997
            | _ -> assert false)
 
998
        in
 
999
        let term () =
 
1000
          if state.g0 = Ascii then () else
 
1001
          begin m.read esc; m.read '('; m.read 'B' end;
 
1002
          m.term ()
 
1003
        in
 
1004
        {read = reader; term = term} in 
 
1005
 
 
1006
      {name = "ISO-2022-JP-2";
 
1007
       make_decoder = make_decoder_2;
 
1008
       make_encoder = make_encoder_2}
 
1009
 
 
1010
    let make_enc () =
 
1011
      let jisx0201 = Unimap.of_name "jisx0201" in
 
1012
      let jisx0208 = Unimap.of_name "jisx0208" in
 
1013
 
 
1014
      let make_decoder m =
 
1015
        let to_uchar charset code =
 
1016
          let ucode =
 
1017
            match charset with
 
1018
              Ascii -> code
 
1019
            | Jisx0208_1978 -> enc_to_ucs jisx0208 code
 
1020
            | Jisx0208_1983 -> enc_to_ucs jisx0208 code
 
1021
            | Jisx0201_roman -> enc_to_ucs jisx0201 code
 
1022
            | _ -> raise Malformed_code
 
1023
          in UChar.chr_of_uint ucode
 
1024
        in
 
1025
        let state = 
 
1026
          {remain = 0; 
 
1027
           g0 = Ascii; 
 
1028
           g2 = Unknown; 
 
1029
           single_shift = false;
 
1030
           buf = String.create 3} 
 
1031
        in
 
1032
        let reader c =
 
1033
          let i = Char.code c in
 
1034
          if i >= 0x80 then raise Malformed_code else
 
1035
          match state.remain with
 
1036
            0 ->
 
1037
              (* escape sequence?. *)
 
1038
              if c = esc then state.remain <- -1 else
 
1039
              (* control code or white space, backspace *)
 
1040
              if i <= 0x20 || i = 0x7f then m.read (UChar.chr_of_uint i) else
 
1041
              if unibyte state.g0
 
1042
              then m.read (to_uchar state.g0 i)
 
1043
              else begin state.remain <- 1; state.buf.[0] <- c end
 
1044
          | 1 ->
 
1045
              let i1 = Char.code state.buf.[0] in
 
1046
              let i2 = Char.code c in
 
1047
              if i2 >= 0x21 && i2 <= 0x7e 
 
1048
              then 
 
1049
                let u = to_uchar state.g0 ((i1 lsl 8) + i2) in
 
1050
                m.read u
 
1051
              else raise Malformed_code;
 
1052
              state.remain <- 0
 
1053
          | _ ->                        (*escape seq.*)
 
1054
              state.buf.[~-(state.remain) - 1] <- c;
 
1055
              state.remain <- state.remain - 1;
 
1056
              let len = ~- (state.remain) - 1 in
 
1057
              if i >= 0x20 && i <= 0x2f 
 
1058
              then
 
1059
                begin if len >= 3 then raise Malformed_code else () end
 
1060
              else if i >= 0x30 && i <= 0x7e then 
 
1061
                begin
 
1062
                  state.remain <- 0;
 
1063
                  if comp_sub "(B" 0 2 state.buf 0 len then
 
1064
                    state.g0 <- Ascii
 
1065
                  else if comp_sub "(J" 0 2 state.buf 0 len then
 
1066
                    state.g0 <- Jisx0201_roman
 
1067
                  else if comp_sub "$@" 0 2 state.buf 0 len then
 
1068
                    state.g0 <- Jisx0208_1978
 
1069
                  else if comp_sub "$B" 0 2 state.buf 0 len then
 
1070
                    state.g0 <- Jisx0208_1983
 
1071
                  else raise Malformed_code
 
1072
                end
 
1073
              else raise Malformed_code;
 
1074
        in
 
1075
        {read = reader; term = m.term} in
 
1076
 
 
1077
      let make_encoder m =
 
1078
        let from_uchar u =
 
1079
          let n = UChar.code u in
 
1080
          (* the order of tests is *significant* *)
 
1081
          if n >= 0x00 && n <= 0x7f then Ascii, n else
 
1082
          let enc = Unimap.ucs_to_enc jisx0208 n in
 
1083
          if enc <> Unimap.no_char_enc jisx0208 then (Jisx0208_1983, enc) else
 
1084
          let n' = Unimap.ucs_to_enc jisx0201 n in
 
1085
          if n' = Unimap.no_char_enc jisx0201 then raise Out_of_range else
 
1086
          if n' >= 0x80 then raise Out_of_range else Jisx0201_roman, n'
 
1087
        in        
 
1088
        (*fields other than g0, g2 are not used*)
 
1089
        let state =
 
1090
          {remain = 0; 
 
1091
           g0 = Ascii; 
 
1092
           g2 = Unknown; 
 
1093
           single_shift = false;
 
1094
           buf = String.create 1}
 
1095
        in
 
1096
        let reader u =
 
1097
          if UChar.uint_code u = 27 then raise Out_of_range else
 
1098
          let cs, i = from_uchar u in
 
1099
          let c1 = Char.chr (i lsr 8) in
 
1100
          let c2 = Char.chr (i land 255) in
 
1101
          if state.g0 = cs
 
1102
          then
 
1103
            if unibyte cs
 
1104
            then m.read c2
 
1105
            else begin m.read c1; m.read c2 end
 
1106
          else
 
1107
            (match cs with
 
1108
              Ascii ->
 
1109
                state.g0 <- Ascii;
 
1110
                m.read esc; m.read '('; m.read 'B'; m.read c2
 
1111
            | Jisx0201_roman ->
 
1112
                state.g0 <- Jisx0201_roman;
 
1113
                m.read esc; m.read '('; m.read 'J'; m.read c2
 
1114
            | Jisx0208_1983 ->
 
1115
                state.g0 <- Jisx0208_1983;
 
1116
                m.read esc; m.read '$'; m.read 'B'; m.read c1; m.read c2
 
1117
            |   _ -> assert false)
 
1118
        in
 
1119
        let term () =
 
1120
          if state.g0 = Ascii then () else
 
1121
          begin m.read esc; m.read '('; m.read 'B' end;
 
1122
          m.term ()
 
1123
        in
 
1124
        {read = reader; term = term} in
 
1125
 
 
1126
      {name = "ISO-2022-JP";
 
1127
       make_decoder = make_decoder;
 
1128
       make_encoder = make_encoder}
 
1129
 
 
1130
let init () = 
 
1131
  install "ISO-2022-JP-2" make_enc_2;
 
1132
  install "csISO2022JP2" make_enc_2;
 
1133
  install "ISO-2022-JP" make_enc;
 
1134
  install "csISO2022JP" make_enc
 
1135
end
 
1136
 
 
1137
let _ = Iso2022jp.init ()
 
1138
 
 
1139
(* Japanese auto detect *)
 
1140
 
 
1141
module J_auto =
 
1142
  struct
 
1143
        
 
1144
    let jauto =
 
1145
      fun () ->
 
1146
        let euc_jp = of_name "EUC-JP" in
 
1147
        let sjis = of_name "SHIFT_JIS" in
 
1148
        let iso2022jp = of_name "ISO-2022-JP-2" in
 
1149
        automatic 
 
1150
          "japanese_auto_detection" 
 
1151
          [iso2022jp; euc_jp; sjis] 
 
1152
          euc_jp
 
1153
 
 
1154
    let init () =
 
1155
      let _ = install "japanese_auto_detection" jauto in
 
1156
      let _ = install "jauto" jauto in ()
 
1157
        
 
1158
  end
 
1159
 
 
1160
let _ = J_auto.init ()
 
1161
 
 
1162
(* iso-2022-kr *)
 
1163
 
 
1164
module Iso2022kr =
 
1165
  struct
 
1166
    
 
1167
    let esc = Char.chr 0x1b                     (* \027 *)
 
1168
    let si = Char.chr 0x0f
 
1169
    let so = Char.chr 0x0e
 
1170
 
 
1171
    type charset = Ascii | Ksc5601
 
1172
 
 
1173
    type state_type = 
 
1174
        {mutable remain : int;          (* <0 means escape sequence*)
 
1175
         mutable gl : charset;
 
1176
         buf : string}
 
1177
 
 
1178
    let make_enc () =
 
1179
      let ksc5601 = Unimap.of_name "ksc5601" in
 
1180
 
 
1181
      let make_decoder m =
 
1182
        let state = 
 
1183
          {remain = 0; 
 
1184
           gl = Ascii; 
 
1185
           buf = String.create 3} 
 
1186
        in
 
1187
        let reader c =
 
1188
          let i = Char.code c in
 
1189
          if i >= 0x80 then raise Malformed_code else
 
1190
          match state.remain with
 
1191
            0 ->
 
1192
              if c = esc then state.remain <- -1 else
 
1193
              if c = si then state.gl <- Ascii else
 
1194
              if c = so then state.gl <- Ksc5601 else
 
1195
              (* control code or white space, backspace *)
 
1196
              if i <= 0x20 || i = 0x7f then m.read (UChar.chr_of_uint i) else
 
1197
              (match state.gl with
 
1198
                Ascii -> m.read (UChar.chr_of_uint i)
 
1199
              | Ksc5601 -> state.remain <- 1; state.buf.[0] <- c)
 
1200
          | 1 ->
 
1201
              let i1 = Char.code state.buf.[0] in
 
1202
              let i2 = Char.code c in
 
1203
              if i2 >= 0x21 && i2 <= 0x7e 
 
1204
              then 
 
1205
                let n = enc_to_ucs ksc5601 ((i1 lsl 8) + i2) in
 
1206
                m.read (UChar.chr_of_uint n)
 
1207
              else raise Malformed_code;
 
1208
              state.remain <- 0
 
1209
          | _ ->                                (*escape seq.*)
 
1210
              state.buf.[~-(state.remain) - 1] <- c;
 
1211
              state.remain <- state.remain - 1;
 
1212
              let i = Char.code c in
 
1213
              let len = ~- (state.remain) - 1 in
 
1214
              if i >= 0x20 && i <= 0x2f then
 
1215
                if len >= 3 then raise Malformed_code else ()
 
1216
              else if i >= 0x30 && i <= 0x7e then 
 
1217
                begin
 
1218
                  state.remain <- 0;
 
1219
                  (* designator *)
 
1220
                  if comp_sub "$)C" 0 3 state.buf 0 len then () 
 
1221
                  else raise Malformed_code
 
1222
                end
 
1223
              else raise Malformed_code
 
1224
        in
 
1225
        {read = reader; term = m.term} in
 
1226
      
 
1227
      let make_encoder m =
 
1228
        (*fields other than gl are not used*)
 
1229
        let state =
 
1230
          {remain = 0; 
 
1231
           gl = Ascii;
 
1232
           buf = String.create 1}
 
1233
        in
 
1234
        feed_string m "\027$)C";                (*designator*)
 
1235
        let reader u =
 
1236
          let n = UChar.code u in
 
1237
          if n <= 0x7f then
 
1238
            if n = 0x0e || n = 0x0f || n = 0x1b then raise Out_of_range else
 
1239
            match state.gl with
 
1240
              Ascii -> m.read (Char.chr n)
 
1241
            | Ksc5601 -> 
 
1242
                state.gl <- Ascii;
 
1243
                m.read si; m.read (Char.chr n)
 
1244
          else
 
1245
            let i = Unimap.ucs_to_enc ksc5601 n in
 
1246
            if i = Unimap.no_char_enc ksc5601 then raise Out_of_range else
 
1247
            let c1 = Char.chr (i lsr 8) in
 
1248
            let c2 = Char.chr (i land 255) in
 
1249
            match state.gl with
 
1250
              Ascii ->
 
1251
                state.gl <- Ksc5601;
 
1252
                m.read so; m.read c1; m.read c2
 
1253
            |   Ksc5601 ->
 
1254
                m.read c1; m.read c2
 
1255
        in
 
1256
        let term () =
 
1257
          (if state.gl = Ksc5601 then m.read si else ());
 
1258
          m.term ()
 
1259
        in
 
1260
        {read = reader; term = term} in
 
1261
      
 
1262
      {name = "ISO-2022-KR";
 
1263
       make_decoder = make_decoder;
 
1264
       make_encoder = make_encoder}
 
1265
 
 
1266
let init () = 
 
1267
let _ = install "ISO-2022-KR" make_enc in 
 
1268
let _ = install "csISO2022KR" make_enc  in ()
 
1269
end
 
1270
 
 
1271
let _ = Iso2022kr.init ()
 
1272
 
 
1273
(* iso-2022-cn *)
 
1274
 
 
1275
module Iso2022cn =
 
1276
  struct
 
1277
    
 
1278
    let esc = Char.chr 0x1b                     (* \027 *)
 
1279
    let si = Char.chr 0x0f
 
1280
    let so = Char.chr 0x0e
 
1281
    let uLF = UChar.chr_of_uint (Char.code '\n')
 
1282
 
 
1283
    let cns_p1 = 0x10000
 
1284
    let cns_p2 = 0x20000
 
1285
 
 
1286
    type charset = Ascii | GB_2312 | CNS_11643_p1 | CNS_11643_p2 | Unknown
 
1287
 
 
1288
    type assign = G0 | G1 | G2
 
1289
 
 
1290
    type state_type = 
 
1291
        {mutable remain : int;          (* <0 means escape sequence*)
 
1292
         mutable gl : assign;
 
1293
         mutable g1 : charset;
 
1294
         mutable g2 : charset;
 
1295
         mutable single_shift : bool;
 
1296
         buf : string}
 
1297
 
 
1298
    let make_enc () =
 
1299
      let gb2312 = Unimap.of_name "gb2312" in
 
1300
      let cns11643 = Unimap.of_name "cns11643" in
 
1301
 
 
1302
      let make_decoder m =
 
1303
        let to_ucs4 cs n =
 
1304
          match cs with
 
1305
            Ascii -> if n <= 0x7f then n else raise Malformed_code
 
1306
          | GB_2312 -> enc_to_ucs gb2312 n
 
1307
          | CNS_11643_p1 -> enc_to_ucs cns11643 (cns_p1 lor n)
 
1308
          | CNS_11643_p2 -> enc_to_ucs cns11643 (cns_p2 lor n)
 
1309
          | Unknown -> raise Malformed_code
 
1310
        in
 
1311
        let state = 
 
1312
          {remain = 0; 
 
1313
           gl = G0;
 
1314
           g1 = Unknown;
 
1315
           g2 = Unknown;
 
1316
           single_shift = false;
 
1317
           buf = String.create 3} 
 
1318
        in
 
1319
        let reader c =
 
1320
          let i = Char.code c in
 
1321
          if i >= 0x80 then raise Malformed_code else
 
1322
          match state.remain with
 
1323
            0 ->
 
1324
              if not state.single_shift then
 
1325
                match c with
 
1326
                  '\027' -> state.remain <- ~-1
 
1327
                |       '\015' -> state.gl <- G0
 
1328
                |       '\014' -> state.gl <- G1
 
1329
                |       _  ->
 
1330
                    (* control code *)
 
1331
                    if i <= 0x20 then m.read (UChar.chr_of_uint i) else
 
1332
                    (match state.gl with
 
1333
                      G0 -> m.read (UChar.chr_of_uint i)
 
1334
                    | _ -> state.remain <- 1; state.buf.[0] <- c)
 
1335
              else
 
1336
                state.remain <- 1; state.buf.[0] <- c
 
1337
          | 1 ->
 
1338
              let i1 = Char.code state.buf.[0] in
 
1339
              let i2 = Char.code c in
 
1340
              let n = (i1 lsl 8) + i2 in
 
1341
              let cs =
 
1342
                if state.single_shift then state.g2 else
 
1343
                match state.gl with
 
1344
                  G0 -> Ascii
 
1345
                |       G1 -> state.g1
 
1346
                |       G2 -> state.g2
 
1347
              in
 
1348
              m.read (UChar.chr_of_uint (to_ucs4 cs n)); 
 
1349
              state.remain <- 0;
 
1350
              if state.single_shift then state.single_shift <- false else ()
 
1351
          | 2 -> state.remain <- 1; state.buf.[0] <- c
 
1352
          | _ ->                                (*escape seq.*)
 
1353
              state.buf.[~-(state.remain) - 1] <- c;
 
1354
              state.remain <- state.remain - 1;
 
1355
              let i = Char.code c in
 
1356
              let len = ~- (state.remain) - 1 in
 
1357
              if i >= 0x20 && i <= 0x2f then
 
1358
                if len >= 3 then raise Malformed_code else ()
 
1359
              else if i >= 0x30 && i <= 0x7e then 
 
1360
                begin
 
1361
                  state.remain <- 0;
 
1362
                  if comp_sub "$)A" 0 3 state.buf 0 len then
 
1363
                    state.g1 <- GB_2312
 
1364
                  else if comp_sub "$)G" 0 3 state.buf 0 len then
 
1365
                    state.g1 <- CNS_11643_p1
 
1366
                  else if comp_sub "$*H" 0 3 state.buf 0 len then
 
1367
                    state.g2 <- CNS_11643_p2
 
1368
                  else if comp_sub "N"  0 1 state.buf 0 len then
 
1369
                    begin state.single_shift <- true; state.remain <- 2 end
 
1370
                  else raise Malformed_code
 
1371
                end
 
1372
              else raise Malformed_code
 
1373
        in
 
1374
        {read = reader; term = m.term} in
 
1375
      
 
1376
      let make_encoder m =
 
1377
        let from_ucs4 n =
 
1378
          if n <= 0x7f then Ascii, n else
 
1379
          let n' = Unimap.ucs_to_enc gb2312 n in
 
1380
          if n' <> Unimap.no_char_enc gb2312 then (GB_2312, n') else
 
1381
          let n' = Unimap.ucs_to_enc cns11643 n in
 
1382
          if n' = Unimap.no_char_enc cns11643 then raise Out_of_range else
 
1383
          match n' lsr 16 with
 
1384
            1 -> CNS_11643_p1, (n' land 0xffff)
 
1385
          | 2 -> CNS_11643_p2, (n' land 0xffff)
 
1386
          | _ -> raise Out_of_range
 
1387
        in
 
1388
        (*fields other than gl, g1, g2 are not used*)
 
1389
        let state =
 
1390
          {remain = 0; 
 
1391
           gl = G0;
 
1392
           g1 = Unknown;
 
1393
           g2 = Unknown;
 
1394
           buf = String.create 1;
 
1395
           single_shift = false;
 
1396
         }
 
1397
        in
 
1398
        let reader u =
 
1399
          let n = UChar.code u in
 
1400
          if n = 0x0e || n = 0x0f || n = 0x1b then raise Out_of_range else begin
 
1401
            if n = 0x0d || n = 0x0a || n = 0x85 then begin
 
1402
              state.g1 <- Unknown;
 
1403
              state.g2 <- Unknown;
 
1404
            end else ();
 
1405
            let cs, n' = from_ucs4 n in
 
1406
            let i1 = n' lsr 8 in
 
1407
            let i2 = n' land 255 in
 
1408
            let cur_cs =
 
1409
              match state.gl with
 
1410
                G0 -> Ascii
 
1411
              | G1 -> state.g1
 
1412
              | G2 -> state.g2
 
1413
            in
 
1414
            if cs = cur_cs then
 
1415
              match cs with
 
1416
                Ascii -> m.read (Char.chr i2)
 
1417
              | _ -> m.read (Char.chr i1); m.read (Char.chr i2)
 
1418
            else
 
1419
              match cs with
 
1420
                Ascii ->
 
1421
                  m.read si;
 
1422
                  m.read (Char.chr i2);
 
1423
                  state.gl <- G0
 
1424
              | GB_2312 ->
 
1425
                  if not (state.g1 = GB_2312) then begin
 
1426
                    m.read esc; feed_string m "$)A";
 
1427
                    state.g1 <- GB_2312;
 
1428
                  end else ();
 
1429
                  if not (state.gl = G1) then begin
 
1430
                    m.read so;
 
1431
                    state.gl <- G1
 
1432
                  end else ();
 
1433
                  m.read (Char.chr i1); m.read (Char.chr i2)
 
1434
              |  CNS_11643_p1 ->
 
1435
                  if not (state.g1 = CNS_11643_p1) then begin
 
1436
                    m.read esc; feed_string m "$)G";
 
1437
                    state.g1 <- CNS_11643_p1;
 
1438
                  end else ();
 
1439
                  if not (state.gl = G1) then begin
 
1440
                    m.read so;          state.gl <- G1
 
1441
                  end else ();
 
1442
                  m.read (Char.chr i1); m.read (Char.chr i2)
 
1443
              | CNS_11643_p2 ->
 
1444
                  if not (state.g2 = CNS_11643_p2) then begin
 
1445
                    m.read esc; feed_string m "$*H";
 
1446
                    state.g2 <- CNS_11643_p2;
 
1447
                  end else ();
 
1448
                  m.read esc; m.read 'N';
 
1449
                  m.read (Char.chr i1); m.read (Char.chr i2)
 
1450
              | _ -> assert false
 
1451
          end
 
1452
        in
 
1453
        let term () =
 
1454
          if state.gl = G0 then () else m.read si;
 
1455
          m.term ();
 
1456
        in {read = reader; term = term} in
 
1457
      
 
1458
      {name = "ISO-2022-CN";
 
1459
       make_decoder = make_decoder;
 
1460
       make_encoder = make_encoder}
 
1461
 
 
1462
    let init () = 
 
1463
      let _ = install "ISO-2022-CN" make_enc in ()
 
1464
        
 
1465
  end
 
1466
 
 
1467
let _ = Iso2022cn.init ()
 
1468
 
 
1469
(* shortcuts *)
 
1470
let ascii = of_name "US-ASCII"
 
1471
let latin1 = of_name "Latin-1"
 
1472
let utf8 = of_name "UTF-8"
 
1473
let utf16 = of_name "UTF-16"
 
1474
let utf16be = of_name "UTF-16BE"
 
1475
let utf16le = of_name "UTF-16LE"
 
1476
let utf32 = of_name "UTF-32"
 
1477
let utf32be = of_name "UTF-32BE"
 
1478
let utf32le = of_name "UTF-32LE"
 
1479
let ucs4 = of_name "UCS-4"
 
1480
 
 
1481
(* IANA *)
 
1482
(* Name: ANSI_X3.4-1968                                   [RFC1345,KXS2] *)
 
1483
(* Alias: iso-ir-6 *)
 
1484
(* Alias: ANSI_X3.4-1986 *)
 
1485
(* Alias: ISO_646.irv:1991 *)
 
1486
(* Alias: ASCII *)
 
1487
(* Alias: ISO646-US *)
 
1488
(* Alias: US-ASCII (preferred MIME name) *)
 
1489
(* Alias: us *)
 
1490
(* Alias: IBM367 *)
 
1491
(* Alias: cp367 *)
 
1492
(* Alias: csASCII *)
 
1493
let () = alias "IANA/csASCII" "ANSI_X3.4-1968"
 
1494
let () = alias "IANA/cp367" "ANSI_X3.4-1968"
 
1495
let () = alias "IANA/IBM367" "ANSI_X3.4-1968"
 
1496
let () = alias "IANA/us" "ANSI_X3.4-1968"
 
1497
let () = alias "IANA/US-ASCII" "ANSI_X3.4-1968"
 
1498
let () = alias "IANA/ISO646-US" "ANSI_X3.4-1968"
 
1499
let () = alias "IANA/ASCII" "ANSI_X3.4-1968"
 
1500
let () = alias "IANA/ISO_646.irv:1991" "ANSI_X3.4-1968"
 
1501
let () = alias "IANA/ANSI_X3.4-1986" "ANSI_X3.4-1968"
 
1502
let () = alias "IANA/iso-ir-6" "ANSI_X3.4-1968"
 
1503
let () = alias "IANA/ANSI_X3.4-1968" "ANSI_X3.4-1968"
 
1504
(* Name: ISO-10646-UTF-1 *)
 
1505
(* Alias: csISO10646UTF1 *)
 
1506
(* Name: ISO_646.basic:1983                                [RFC1345,KXS2] *)
 
1507
(* Alias: ref *)
 
1508
(* Alias: csISO646basic1983 *)
 
1509
let () = alias "IANA/csISO646basic1983" "ISO_646.BASIC"
 
1510
let () = alias "IANA/ref" "ISO_646.BASIC"
 
1511
let () = alias "IANA/ISO_646.basic:1983" "ISO_646.BASIC"
 
1512
(* Name: INVARIANT                                         [RFC1345,KXS2] *)
 
1513
(* Alias: csINVARIANT *)
 
1514
let () = alias "IANA/csINVARIANT" "INVARIANT"
 
1515
let () = alias "IANA/INVARIANT" "INVARIANT"
 
1516
(* Name: ISO_646.irv:1983                                  [RFC1345,KXS2] *)
 
1517
(* Alias: iso-ir-2 *)
 
1518
(* Alias: irv *)
 
1519
(* Alias: csISO2IntlRefVersion *)
 
1520
let () = alias "IANA/csISO2IntlRefVersion" "ISO_646.IRV"
 
1521
let () = alias "IANA/irv" "ISO_646.IRV"
 
1522
let () = alias "IANA/iso-ir-2" "ISO_646.IRV"
 
1523
let () = alias "IANA/ISO_646.irv:1983" "ISO_646.IRV"
 
1524
(* Name: BS_4730                                           [RFC1345,KXS2] *)
 
1525
(* Alias: iso-ir-4 *)
 
1526
(* Alias: ISO646-GB *)
 
1527
(* Alias: gb *)
 
1528
(* Alias: uk *)
 
1529
(* Alias: csISO4UnitedKingdom *)
 
1530
let () = alias "IANA/csISO4UnitedKingdom" "BS_4730"
 
1531
let () = alias "IANA/uk" "BS_4730"
 
1532
let () = alias "IANA/gb" "BS_4730"
 
1533
let () = alias "IANA/ISO646-GB" "BS_4730"
 
1534
let () = alias "IANA/iso-ir-4" "BS_4730"
 
1535
let () = alias "IANA/BS_4730" "BS_4730"
 
1536
(* Name: NATS-SEFI                                         [RFC1345,KXS2] *)
 
1537
(* Alias: iso-ir-8-1 *)
 
1538
(* Alias: csNATSSEFI *)
 
1539
let () = alias "IANA/csNATSSEFI" "NATS-SEFI"
 
1540
let () = alias "IANA/iso-ir-8-1" "NATS-SEFI"
 
1541
let () = alias "IANA/NATS-SEFI" "NATS-SEFI"
 
1542
(* Name: NATS-SEFI-ADD                                     [RFC1345,KXS2] *)
 
1543
(* Alias: iso-ir-8-2 *)
 
1544
(* Alias: csNATSSEFIADD *)
 
1545
(* Name: NATS-DANO                                         [RFC1345,KXS2] *)
 
1546
(* Alias: iso-ir-9-1 *)
 
1547
(* Alias: csNATSDANO *)
 
1548
let () = alias "IANA/csNATSDANO" "NATS-DANO"
 
1549
let () = alias "IANA/iso-ir-9-1" "NATS-DANO"
 
1550
let () = alias "IANA/NATS-DANO" "NATS-DANO"
 
1551
(* Name: NATS-DANO-ADD                                     [RFC1345,KXS2] *)
 
1552
(* Alias: iso-ir-9-2 *)
 
1553
(* Alias: csNATSDANOADD *)
 
1554
(* Name: SEN_850200_B                                      [RFC1345,KXS2] *)
 
1555
(* Alias: iso-ir-10 *)
 
1556
(* Alias: FI *)
 
1557
(* Alias: ISO646-FI *)
 
1558
(* Alias: ISO646-SE *)
 
1559
(* Alias: se *)
 
1560
(* Alias: csISO10Swedish *)
 
1561
let () = alias "IANA/csISO10Swedish" "SEN_850200_B"
 
1562
let () = alias "IANA/se" "SEN_850200_B"
 
1563
let () = alias "IANA/ISO646-SE" "SEN_850200_B"
 
1564
let () = alias "IANA/ISO646-FI" "SEN_850200_B"
 
1565
let () = alias "IANA/FI" "SEN_850200_B"
 
1566
let () = alias "IANA/iso-ir-10" "SEN_850200_B"
 
1567
let () = alias "IANA/SEN_850200_B" "SEN_850200_B"
 
1568
(* Name: SEN_850200_C                                      [RFC1345,KXS2] *)
 
1569
(* Alias: iso-ir-11 *)
 
1570
(* Alias: ISO646-SE2 *)
 
1571
(* Alias: se2 *)
 
1572
(* Alias: csISO11SwedishForNames *)
 
1573
let () = alias "IANA/csISO11SwedishForNames" "SEN_850200_C"
 
1574
let () = alias "IANA/se2" "SEN_850200_C"
 
1575
let () = alias "IANA/ISO646-SE2" "SEN_850200_C"
 
1576
let () = alias "IANA/iso-ir-11" "SEN_850200_C"
 
1577
let () = alias "IANA/SEN_850200_C" "SEN_850200_C"
 
1578
(* Name: KS_C_5601-1987                                    [RFC1345,KXS2] *)
 
1579
(* Alias: iso-ir-149 *)
 
1580
(* Alias: KS_C_5601-1989 *)
 
1581
(* Alias: KSC_5601 *)
 
1582
(* Alias: korean *)
 
1583
(* Alias: csKSC56011987 *)
 
1584
(* Name: ISO-2022-KR  (preferred MIME name)                [RFC1557,Choi] *)
 
1585
(* Alias: csISO2022KR *)
 
1586
let () = alias "IANA/csISO2022KR" "ISO-2022-KR"
 
1587
let () = alias "IANA/ISO-2022-KR" "ISO-2022-KR"
 
1588
(* Name: EUC-KR  (preferred MIME name)                     [RFC1557,Choi] *)
 
1589
(* Alias: csEUCKR *)
 
1590
let () = alias "IANA/csEUCKR" "EUC-KR"
 
1591
let () = alias "IANA/EUC-KR" "EUC-KR"
 
1592
(* Name: ISO-2022-JP  (preferred MIME name)               [RFC1468,Murai] *)
 
1593
(* Alias: csISO2022JP *)
 
1594
let () = alias "IANA/csISO2022JP" "ISO-2022-JP"
 
1595
let () = alias "IANA/ISO-2022-JP" "ISO-2022-JP"
 
1596
(* Name: ISO-2022-JP-2  (preferred MIME name)              [RFC1554,Ohta] *)
 
1597
(* Alias: csISO2022JP2 *)
 
1598
let () = alias "IANA/csISO2022JP2" "ISO-2022-JP-2"
 
1599
let () = alias "IANA/ISO-2022-JP-2" "ISO-2022-JP-2"
 
1600
(* Name: ISO-2022-CN                                            [RFC1922] *)
 
1601
let () = alias "IANA/ISO-2022-CN" "ISO-2022-CN"
 
1602
(* Name: ISO-2022-CN-EXT                                        [RFC1922] *)
 
1603
(* Name: JIS_C6220-1969-jp                                 [RFC1345,KXS2] *)
 
1604
(* Alias: JIS_C6220-1969 *)
 
1605
(* Alias: iso-ir-13 *)
 
1606
(* Alias: katakana *)
 
1607
(* Alias: x0201-7 *)
 
1608
(* Alias: csISO13JISC6220jp *)
 
1609
(* Name: JIS_C6220-1969-ro                                 [RFC1345,KXS2] *)
 
1610
(* Alias: iso-ir-14 *)
 
1611
(* Alias: jp *)
 
1612
(* Alias: ISO646-JP *)
 
1613
(* Alias: csISO14JISC6220ro *)
 
1614
let () = alias "IANA/csISO14JISC6220ro" "JIS_C6220-1969-RO"
 
1615
let () = alias "IANA/ISO646-JP" "JIS_C6220-1969-RO"
 
1616
let () = alias "IANA/jp" "JIS_C6220-1969-RO"
 
1617
let () = alias "IANA/iso-ir-14" "JIS_C6220-1969-RO"
 
1618
let () = alias "IANA/JIS_C6220-1969-ro" "JIS_C6220-1969-RO"
 
1619
(* Name: IT                                                [RFC1345,KXS2] *)
 
1620
(* Alias: iso-ir-15 *)
 
1621
(* Alias: ISO646-IT *)
 
1622
(* Alias: csISO15Italian *)
 
1623
let () = alias "IANA/csISO15Italian" "IT"
 
1624
let () = alias "IANA/ISO646-IT" "IT"
 
1625
let () = alias "IANA/iso-ir-15" "IT"
 
1626
let () = alias "IANA/IT" "IT"
 
1627
(* Name: PT                                                [RFC1345,KXS2] *)
 
1628
(* Alias: iso-ir-16 *)
 
1629
(* Alias: ISO646-PT *)
 
1630
(* Alias: csISO16Portuguese *)
 
1631
let () = alias "IANA/csISO16Portuguese" "PT"
 
1632
let () = alias "IANA/ISO646-PT" "PT"
 
1633
let () = alias "IANA/iso-ir-16" "PT"
 
1634
let () = alias "IANA/PT" "PT"
 
1635
(* Name: ES                                                [RFC1345,KXS2] *)
 
1636
(* Alias: iso-ir-17 *)
 
1637
(* Alias: ISO646-ES *)
 
1638
(* Alias: csISO17Spanish *)
 
1639
let () = alias "IANA/csISO17Spanish" "ES"
 
1640
let () = alias "IANA/ISO646-ES" "ES"
 
1641
let () = alias "IANA/iso-ir-17" "ES"
 
1642
let () = alias "IANA/ES" "ES"
 
1643
(* Name: greek7-old                                        [RFC1345,KXS2] *)
 
1644
(* Alias: iso-ir-18 *)
 
1645
(* Alias: csISO18Greek7Old *)
 
1646
let () = alias "IANA/csISO18Greek7Old" "GREEK7-OLD"
 
1647
let () = alias "IANA/iso-ir-18" "GREEK7-OLD"
 
1648
let () = alias "IANA/greek7-old" "GREEK7-OLD"
 
1649
(* Name: latin-greek                                       [RFC1345,KXS2] *)
 
1650
(* Alias: iso-ir-19 *)
 
1651
(* Alias: csISO19LatinGreek *)
 
1652
let () = alias "IANA/csISO19LatinGreek" "LATIN-GREEK"
 
1653
let () = alias "IANA/iso-ir-19" "LATIN-GREEK"
 
1654
let () = alias "IANA/latin-greek" "LATIN-GREEK"
 
1655
(* Name: DIN_66003                                         [RFC1345,KXS2] *)
 
1656
(* Alias: iso-ir-21 *)
 
1657
(* Alias: de *)
 
1658
(* Alias: ISO646-DE *)
 
1659
(* Alias: csISO21German *)
 
1660
let () = alias "IANA/csISO21German" "DIN_66003"
 
1661
let () = alias "IANA/ISO646-DE" "DIN_66003"
 
1662
let () = alias "IANA/de" "DIN_66003"
 
1663
let () = alias "IANA/iso-ir-21" "DIN_66003"
 
1664
let () = alias "IANA/DIN_66003" "DIN_66003"
 
1665
(* Name: NF_Z_62-010_(1973)                                [RFC1345,KXS2] *)
 
1666
(* Alias: iso-ir-25 *)
 
1667
(* Alias: ISO646-FR1 *)
 
1668
(* Alias: csISO25French *)
 
1669
let () = alias "IANA/csISO25French" "NF_Z_62-010_(1973)"
 
1670
let () = alias "IANA/ISO646-FR1" "NF_Z_62-010_(1973)"
 
1671
let () = alias "IANA/iso-ir-25" "NF_Z_62-010_(1973)"
 
1672
let () = alias "IANA/NF_Z_62-010_(1973)" "NF_Z_62-010_(1973)"
 
1673
(* Name: Latin-greek-1                                     [RFC1345,KXS2] *)
 
1674
(* Alias: iso-ir-27 *)
 
1675
(* Alias: csISO27LatinGreek1 *)
 
1676
let () = alias "IANA/csISO27LatinGreek1" "LATIN-GREEK-1"
 
1677
let () = alias "IANA/iso-ir-27" "LATIN-GREEK-1"
 
1678
let () = alias "IANA/Latin-greek-1" "LATIN-GREEK-1"
 
1679
(* Name: ISO_5427                                          [RFC1345,KXS2] *)
 
1680
(* Alias: iso-ir-37 *)
 
1681
(* Alias: csISO5427Cyrillic *)
 
1682
let () = alias "IANA/csISO5427Cyrillic" "ISO_5427"
 
1683
let () = alias "IANA/iso-ir-37" "ISO_5427"
 
1684
let () = alias "IANA/ISO_5427" "ISO_5427"
 
1685
(* Name: JIS_C6226-1978                                    [RFC1345,KXS2] *)
 
1686
(* Alias: iso-ir-42 *)
 
1687
(* Alias: csISO42JISC62261978 *)
 
1688
(* Name: BS_viewdata                                       [RFC1345,KXS2] *)
 
1689
(* Alias: iso-ir-47 *)
 
1690
(* Alias: csISO47BSViewdata *)
 
1691
let () = alias "IANA/csISO47BSViewdata" "BS_VIEWDATA"
 
1692
let () = alias "IANA/iso-ir-47" "BS_VIEWDATA"
 
1693
let () = alias "IANA/BS_viewdata" "BS_VIEWDATA"
 
1694
(* Name: INIS                                              [RFC1345,KXS2] *)
 
1695
(* Alias: iso-ir-49 *)
 
1696
(* Alias: csISO49INIS *)
 
1697
let () = alias "IANA/csISO49INIS" "INIS"
 
1698
let () = alias "IANA/iso-ir-49" "INIS"
 
1699
let () = alias "IANA/INIS" "INIS"
 
1700
(* Name: INIS-8                                            [RFC1345,KXS2] *)
 
1701
(* Alias: iso-ir-50 *)
 
1702
(* Alias: csISO50INIS8 *)
 
1703
let () = alias "IANA/csISO50INIS8" "INIS-8"
 
1704
let () = alias "IANA/iso-ir-50" "INIS-8"
 
1705
let () = alias "IANA/INIS-8" "INIS-8"
 
1706
(* Name: INIS-cyrillic                                     [RFC1345,KXS2] *)
 
1707
(* Alias: iso-ir-51 *)
 
1708
(* Alias: csISO51INISCyrillic *)
 
1709
let () = alias "IANA/csISO51INISCyrillic" "INIS-CYRILLIC"
 
1710
let () = alias "IANA/iso-ir-51" "INIS-CYRILLIC"
 
1711
let () = alias "IANA/INIS-cyrillic" "INIS-CYRILLIC"
 
1712
(* Name: ISO_5427:1981                                     [RFC1345,KXS2] *)
 
1713
(* Alias: iso-ir-54 *)
 
1714
(* Alias: ISO5427Cyrillic1981 *)
 
1715
let () = alias "IANA/ISO5427Cyrillic1981" "ISO_5427-EXT"
 
1716
let () = alias "IANA/iso-ir-54" "ISO_5427-EXT"
 
1717
let () = alias "IANA/ISO_5427:1981" "ISO_5427-EXT"
 
1718
(* Name: ISO_5428:1980                                     [RFC1345,KXS2] *)
 
1719
(* Alias: iso-ir-55 *)
 
1720
(* Alias: csISO5428Greek *)
 
1721
let () = alias "IANA/csISO5428Greek" "ISO_5428"
 
1722
let () = alias "IANA/iso-ir-55" "ISO_5428"
 
1723
let () = alias "IANA/ISO_5428:1980" "ISO_5428"
 
1724
(* Name: GB_1988-80                                        [RFC1345,KXS2] *)
 
1725
(* Alias: iso-ir-57 *)
 
1726
(* Alias: cn *)
 
1727
(* Alias: ISO646-CN *)
 
1728
(* Alias: csISO57GB1988 *)
 
1729
let () = alias "IANA/csISO57GB1988" "GB_1988-80"
 
1730
let () = alias "IANA/ISO646-CN" "GB_1988-80"
 
1731
let () = alias "IANA/cn" "GB_1988-80"
 
1732
let () = alias "IANA/iso-ir-57" "GB_1988-80"
 
1733
let () = alias "IANA/GB_1988-80" "GB_1988-80"
 
1734
(* Name: GB_2312-80                                        [RFC1345,KXS2] *)
 
1735
(* Alias: iso-ir-58 *)
 
1736
(* Alias: chinese *)
 
1737
(* Alias: csISO58GB231280 *)
 
1738
(* Name: NS_4551-1                                         [RFC1345,KXS2] *)
 
1739
(* Alias: iso-ir-60 *)
 
1740
(* Alias: ISO646-NO *)
 
1741
(* Alias: no *)
 
1742
(* Alias: csISO60DanishNorwegian *)
 
1743
(* Alias: csISO60Norwegian1 *)
 
1744
let () = alias "IANA/csISO60Norwegian1" "NS_4551-1"
 
1745
let () = alias "IANA/csISO60DanishNorwegian" "NS_4551-1"
 
1746
let () = alias "IANA/no" "NS_4551-1"
 
1747
let () = alias "IANA/ISO646-NO" "NS_4551-1"
 
1748
let () = alias "IANA/iso-ir-60" "NS_4551-1"
 
1749
let () = alias "IANA/NS_4551-1" "NS_4551-1"
 
1750
(* Name: NS_4551-2                                          [RFC1345,KXS2] *)
 
1751
(* Alias: ISO646-NO2 *)
 
1752
(* Alias: iso-ir-61 *)
 
1753
(* Alias: no2 *)
 
1754
(* Alias: csISO61Norwegian2 *)
 
1755
let () = alias "IANA/csISO61Norwegian2" "NS_4551-2"
 
1756
let () = alias "IANA/no2" "NS_4551-2"
 
1757
let () = alias "IANA/iso-ir-61" "NS_4551-2"
 
1758
let () = alias "IANA/ISO646-NO2" "NS_4551-2"
 
1759
let () = alias "IANA/NS_4551-2" "NS_4551-2"
 
1760
(* Name: NF_Z_62-010                                        [RFC1345,KXS2] *)
 
1761
(* Alias: iso-ir-69 *)
 
1762
(* Alias: ISO646-FR *)
 
1763
(* Alias: fr *)
 
1764
(* Alias: csISO69French *)
 
1765
let () = alias "IANA/csISO69French" "NF_Z_62-010"
 
1766
let () = alias "IANA/fr" "NF_Z_62-010"
 
1767
let () = alias "IANA/ISO646-FR" "NF_Z_62-010"
 
1768
let () = alias "IANA/iso-ir-69" "NF_Z_62-010"
 
1769
let () = alias "IANA/NF_Z_62-010" "NF_Z_62-010"
 
1770
(* Name: videotex-suppl                                     [RFC1345,KXS2] *)
 
1771
(* Alias: iso-ir-70 *)
 
1772
(* Alias: csISO70VideotexSupp1 *)
 
1773
let () = alias "IANA/csISO70VideotexSupp1" "VIDEOTEX-SUPPL"
 
1774
let () = alias "IANA/iso-ir-70" "VIDEOTEX-SUPPL"
 
1775
let () = alias "IANA/videotex-suppl" "VIDEOTEX-SUPPL"
 
1776
(* Name: PT2                                                [RFC1345,KXS2] *)
 
1777
(* Alias: iso-ir-84 *)
 
1778
(* Alias: ISO646-PT2 *)
 
1779
(* Alias: csISO84Portuguese2 *)
 
1780
let () = alias "IANA/csISO84Portuguese2" "PT2"
 
1781
let () = alias "IANA/ISO646-PT2" "PT2"
 
1782
let () = alias "IANA/iso-ir-84" "PT2"
 
1783
let () = alias "IANA/PT2" "PT2"
 
1784
(* Name: ES2                                                [RFC1345,KXS2] *)
 
1785
(* Alias: iso-ir-85 *)
 
1786
(* Alias: ISO646-ES2 *)
 
1787
(* Alias: csISO85Spanish2 *)
 
1788
let () = alias "IANA/csISO85Spanish2" "ES2"
 
1789
let () = alias "IANA/ISO646-ES2" "ES2"
 
1790
let () = alias "IANA/iso-ir-85" "ES2"
 
1791
let () = alias "IANA/ES2" "ES2"
 
1792
(* Name: MSZ_7795.3                                         [RFC1345,KXS2] *)
 
1793
(* Alias: iso-ir-86 *)
 
1794
(* Alias: ISO646-HU *)
 
1795
(* Alias: hu *)
 
1796
(* Alias: csISO86Hungarian *)
 
1797
let () = alias "IANA/csISO86Hungarian" "MSZ_7795.3"
 
1798
let () = alias "IANA/hu" "MSZ_7795.3"
 
1799
let () = alias "IANA/ISO646-HU" "MSZ_7795.3"
 
1800
let () = alias "IANA/iso-ir-86" "MSZ_7795.3"
 
1801
let () = alias "IANA/MSZ_7795.3" "MSZ_7795.3"
 
1802
(* Name: JIS_C6226-1983                                     [RFC1345,KXS2] *)
 
1803
(* Alias: iso-ir-87 *)
 
1804
(* Alias: x0208 *)
 
1805
(* Alias: JIS_X0208-1983 *)
 
1806
(* Alias: csISO87JISX0208 *)
 
1807
(* Name: greek7                                             [RFC1345,KXS2] *)
 
1808
(* Alias: iso-ir-88 *)
 
1809
(* Alias: csISO88Greek7 *)
 
1810
let () = alias "IANA/csISO88Greek7" "GREEK7"
 
1811
let () = alias "IANA/iso-ir-88" "GREEK7"
 
1812
let () = alias "IANA/greek7" "GREEK7"
 
1813
(* Name: ASMO_449                                           [RFC1345,KXS2] *)
 
1814
(* Alias: ISO_9036 *)
 
1815
(* Alias: arabic7 *)
 
1816
(* Alias: iso-ir-89 *)
 
1817
(* Alias: csISO89ASMO449 *)
 
1818
let () = alias "IANA/csISO89ASMO449" "ASMO_449"
 
1819
let () = alias "IANA/iso-ir-89" "ASMO_449"
 
1820
let () = alias "IANA/arabic7" "ASMO_449"
 
1821
let () = alias "IANA/ISO_9036" "ASMO_449"
 
1822
let () = alias "IANA/ASMO_449" "ASMO_449"
 
1823
(* Name: iso-ir-90                                          [RFC1345,KXS2] *)
 
1824
(* Alias: csISO90 *)
 
1825
let () = alias "IANA/csISO90" "ISO-IR-90"
 
1826
let () = alias "IANA/iso-ir-90" "ISO-IR-90"
 
1827
(* Name: JIS_C6229-1984-a                                   [RFC1345,KXS2] *)
 
1828
(* Alias: iso-ir-91 *)
 
1829
(* Alias: jp-ocr-a *)
 
1830
(* Alias: csISO91JISC62291984a *)
 
1831
(* Name: JIS_C6229-1984-b                                   [RFC1345,KXS2] *)
 
1832
(* Alias: iso-ir-92 *)
 
1833
(* Alias: ISO646-JP-OCR-B *)
 
1834
(* Alias: jp-ocr-b *)
 
1835
(* Alias: csISO92JISC62991984b *)
 
1836
let () = alias "IANA/csISO92JISC62991984b" "JIS_C6229-1984-B"
 
1837
let () = alias "IANA/jp-ocr-b" "JIS_C6229-1984-B"
 
1838
let () = alias "IANA/ISO646-JP-OCR-B" "JIS_C6229-1984-B"
 
1839
let () = alias "IANA/iso-ir-92" "JIS_C6229-1984-B"
 
1840
let () = alias "IANA/JIS_C6229-1984-b" "JIS_C6229-1984-B"
 
1841
(* Name: JIS_C6229-1984-b-add                               [RFC1345,KXS2] *)
 
1842
(* Alias: iso-ir-93 *)
 
1843
(* Alias: jp-ocr-b-add *)
 
1844
(* Alias: csISO93JIS62291984badd *)
 
1845
(* Name: JIS_C6229-1984-hand                                [RFC1345,KXS2] *)
 
1846
(* Alias: iso-ir-94 *)
 
1847
(* Alias: jp-ocr-hand *)
 
1848
(* Alias: csISO94JIS62291984hand *)
 
1849
(* Name: JIS_C6229-1984-hand-add                            [RFC1345,KXS2] *)
 
1850
(* Alias: iso-ir-95 *)
 
1851
(* Alias: jp-ocr-hand-add *)
 
1852
(* Alias: csISO95JIS62291984handadd *)
 
1853
(* Name: JIS_C6229-1984-kana                                [RFC1345,KXS2] *)
 
1854
(* Alias: iso-ir-96 *)
 
1855
(* Alias: csISO96JISC62291984kana *)
 
1856
(* Name: ISO_2033-1983                                      [RFC1345,KXS2] *)
 
1857
(* Alias: iso-ir-98 *)
 
1858
(* Alias: e13b *)
 
1859
(* Alias: csISO2033 *)
 
1860
let () = alias "IANA/csISO2033" "ISO_2033-1983"
 
1861
let () = alias "IANA/e13b" "ISO_2033-1983"
 
1862
let () = alias "IANA/iso-ir-98" "ISO_2033-1983"
 
1863
let () = alias "IANA/ISO_2033-1983" "ISO_2033-1983"
 
1864
(* Name: ANSI_X3.110-1983                                   [RFC1345,KXS2] *)
 
1865
(* Alias: iso-ir-99 *)
 
1866
(* Alias: CSA_T500-1983 *)
 
1867
(* Alias: NAPLPS *)
 
1868
(* Alias: csISO99NAPLPS *)
 
1869
let () = alias "IANA/csISO99NAPLPS" "ANSI_X3.110-1983"
 
1870
let () = alias "IANA/NAPLPS" "ANSI_X3.110-1983"
 
1871
let () = alias "IANA/CSA_T500-1983" "ANSI_X3.110-1983"
 
1872
let () = alias "IANA/iso-ir-99" "ANSI_X3.110-1983"
 
1873
let () = alias "IANA/ANSI_X3.110-1983" "ANSI_X3.110-1983"
 
1874
(* Name: ISO_8859-1:1987                                    [RFC1345,KXS2] *)
 
1875
(* Alias: iso-ir-100 *)
 
1876
(* Alias: ISO_8859-1 *)
 
1877
(* Alias: ISO-8859-1 (preferred MIME name) *)
 
1878
(* Alias: latin1 *)
 
1879
(* Alias: l1 *)
 
1880
(* Alias: IBM819 *)
 
1881
(* Alias: CP819 *)
 
1882
(* Alias: csISOLatin1 *)
 
1883
let () = alias "IANA/csISOLatin1" "ISO-8859-1"
 
1884
let () = alias "IANA/CP819" "ISO-8859-1"
 
1885
let () = alias "IANA/IBM819" "ISO-8859-1"
 
1886
let () = alias "IANA/l1" "ISO-8859-1"
 
1887
let () = alias "IANA/latin1" "ISO-8859-1"
 
1888
let () = alias "IANA/ISO-8859-1" "ISO-8859-1"
 
1889
let () = alias "IANA/ISO_8859-1" "ISO-8859-1"
 
1890
let () = alias "IANA/iso-ir-100" "ISO-8859-1"
 
1891
let () = alias "IANA/ISO_8859-1:1987" "ISO-8859-1"
 
1892
(* Name: ISO_8859-2:1987                                    [RFC1345,KXS2] *)
 
1893
(* Alias: iso-ir-101 *)
 
1894
(* Alias: ISO_8859-2 *)
 
1895
(* Alias: ISO-8859-2 (preferred MIME name) *)
 
1896
(* Alias: latin2 *)
 
1897
(* Alias: l2 *)
 
1898
(* Alias: csISOLatin2 *)
 
1899
let () = alias "IANA/csISOLatin2" "ISO-8859-2"
 
1900
let () = alias "IANA/l2" "ISO-8859-2"
 
1901
let () = alias "IANA/latin2" "ISO-8859-2"
 
1902
let () = alias "IANA/ISO-8859-2" "ISO-8859-2"
 
1903
let () = alias "IANA/ISO_8859-2" "ISO-8859-2"
 
1904
let () = alias "IANA/iso-ir-101" "ISO-8859-2"
 
1905
let () = alias "IANA/ISO_8859-2:1987" "ISO-8859-2"
 
1906
(* Name: T.61-7bit                                          [RFC1345,KXS2] *)
 
1907
(* Alias: iso-ir-102 *)
 
1908
(* Alias: csISO102T617bit *)
 
1909
let () = alias "IANA/csISO102T617bit" "T.61-7BIT"
 
1910
let () = alias "IANA/iso-ir-102" "T.61-7BIT"
 
1911
let () = alias "IANA/T.61-7bit" "T.61-7BIT"
 
1912
(* Name: T.61-8bit                                          [RFC1345,KXS2] *)
 
1913
(* Alias: T.61 *)
 
1914
(* Alias: iso-ir-103 *)
 
1915
(* Alias: csISO103T618bit *)
 
1916
let () = alias "IANA/csISO103T618bit" "T.61-8BIT"
 
1917
let () = alias "IANA/iso-ir-103" "T.61-8BIT"
 
1918
let () = alias "IANA/T.61" "T.61-8BIT"
 
1919
let () = alias "IANA/T.61-8bit" "T.61-8BIT"
 
1920
(* Name: ISO_8859-3:1988                                    [RFC1345,KXS2] *)
 
1921
(* Alias: iso-ir-109 *)
 
1922
(* Alias: ISO_8859-3 *)
 
1923
(* Alias: ISO-8859-3 (preferred MIME name) *)
 
1924
(* Alias: latin3 *)
 
1925
(* Alias: l3 *)
 
1926
(* Alias: csISOLatin3 *)
 
1927
let () = alias "IANA/csISOLatin3" "ISO-8859-3"
 
1928
let () = alias "IANA/l3" "ISO-8859-3"
 
1929
let () = alias "IANA/latin3" "ISO-8859-3"
 
1930
let () = alias "IANA/ISO-8859-3" "ISO-8859-3"
 
1931
let () = alias "IANA/ISO_8859-3" "ISO-8859-3"
 
1932
let () = alias "IANA/iso-ir-109" "ISO-8859-3"
 
1933
let () = alias "IANA/ISO_8859-3:1988" "ISO-8859-3"
 
1934
(* Name: ISO_8859-4:1988                                    [RFC1345,KXS2] *)
 
1935
(* Alias: iso-ir-110 *)
 
1936
(* Alias: ISO_8859-4 *)
 
1937
(* Alias: ISO-8859-4 (preferred MIME name) *)
 
1938
(* Alias: latin4 *)
 
1939
(* Alias: l4 *)
 
1940
(* Alias: csISOLatin4 *)
 
1941
let () = alias "IANA/csISOLatin4" "ISO-8859-4"
 
1942
let () = alias "IANA/l4" "ISO-8859-4"
 
1943
let () = alias "IANA/latin4" "ISO-8859-4"
 
1944
let () = alias "IANA/ISO-8859-4" "ISO-8859-4"
 
1945
let () = alias "IANA/ISO_8859-4" "ISO-8859-4"
 
1946
let () = alias "IANA/iso-ir-110" "ISO-8859-4"
 
1947
let () = alias "IANA/ISO_8859-4:1988" "ISO-8859-4"
 
1948
(* Name: ECMA-cyrillic                                      [RFC1345,KXS2] *)
 
1949
(* Alias: iso-ir-111 *)
 
1950
(* Alias: csISO111ECMACyrillic *)
 
1951
let () = alias "IANA/csISO111ECMACyrillic" "ECMA-CYRILLIC"
 
1952
let () = alias "IANA/iso-ir-111" "ECMA-CYRILLIC"
 
1953
let () = alias "IANA/ECMA-cyrillic" "ECMA-CYRILLIC"
 
1954
(* Name: CSA_Z243.4-1985-1                                  [RFC1345,KXS2] *)
 
1955
(* Alias: iso-ir-121 *)
 
1956
(* Alias: ISO646-CA *)
 
1957
(* Alias: csa7-1 *)
 
1958
(* Alias: ca *)
 
1959
(* Alias: csISO121Canadian1 *)
 
1960
let () = alias "IANA/csISO121Canadian1" "CSA_Z243.4-1985-1"
 
1961
let () = alias "IANA/ca" "CSA_Z243.4-1985-1"
 
1962
let () = alias "IANA/csa7-1" "CSA_Z243.4-1985-1"
 
1963
let () = alias "IANA/ISO646-CA" "CSA_Z243.4-1985-1"
 
1964
let () = alias "IANA/iso-ir-121" "CSA_Z243.4-1985-1"
 
1965
let () = alias "IANA/CSA_Z243.4-1985-1" "CSA_Z243.4-1985-1"
 
1966
(* Name: CSA_Z243.4-1985-2                                  [RFC1345,KXS2] *)
 
1967
(* Alias: iso-ir-122 *)
 
1968
(* Alias: ISO646-CA2 *)
 
1969
(* Alias: csa7-2 *)
 
1970
(* Alias: csISO122Canadian2 *)
 
1971
let () = alias "IANA/csISO122Canadian2" "CSA_Z243.4-1985-2"
 
1972
let () = alias "IANA/csa7-2" "CSA_Z243.4-1985-2"
 
1973
let () = alias "IANA/ISO646-CA2" "CSA_Z243.4-1985-2"
 
1974
let () = alias "IANA/iso-ir-122" "CSA_Z243.4-1985-2"
 
1975
let () = alias "IANA/CSA_Z243.4-1985-2" "CSA_Z243.4-1985-2"
 
1976
(* Name: CSA_Z243.4-1985-gr                                 [RFC1345,KXS2] *)
 
1977
(* Alias: iso-ir-123 *)
 
1978
(* Alias: csISO123CSAZ24341985gr *)
 
1979
let () = alias "IANA/csISO123CSAZ24341985gr" "CSA_Z243.4-1985-GR"
 
1980
let () = alias "IANA/iso-ir-123" "CSA_Z243.4-1985-GR"
 
1981
let () = alias "IANA/CSA_Z243.4-1985-gr" "CSA_Z243.4-1985-GR"
 
1982
(* Name: ISO_8859-6:1987                                    [RFC1345,KXS2] *)
 
1983
(* Alias: iso-ir-127 *)
 
1984
(* Alias: ISO_8859-6 *)
 
1985
(* Alias: ISO-8859-6 (preferred MIME name) *)
 
1986
(* Alias: ECMA-114 *)
 
1987
(* Alias: ASMO-708 *)
 
1988
(* Alias: arabic *)
 
1989
(* Alias: csISOLatinArabic *)
 
1990
let () = alias "IANA/csISOLatinArabic" "ISO-8859-6"
 
1991
let () = alias "IANA/arabic" "ISO-8859-6"
 
1992
let () = alias "IANA/ASMO-708" "ISO-8859-6"
 
1993
let () = alias "IANA/ECMA-114" "ISO-8859-6"
 
1994
let () = alias "IANA/ISO-8859-6" "ISO-8859-6"
 
1995
let () = alias "IANA/ISO_8859-6" "ISO-8859-6"
 
1996
let () = alias "IANA/iso-ir-127" "ISO-8859-6"
 
1997
let () = alias "IANA/ISO_8859-6:1987" "ISO-8859-6"
 
1998
(* Name: ISO_8859-6-E                                       [RFC1556,IANA] *)
 
1999
(* Alias: csISO88596E *)
 
2000
(* Alias: ISO-8859-6-E (preferred MIME name) *)
 
2001
(* Name: ISO_8859-6-I                                       [RFC1556,IANA] *)
 
2002
(* Alias: csISO88596I *)
 
2003
(* Alias: ISO-8859-6-I (preferred MIME name) *)
 
2004
(* Name: ISO_8859-7:1987                            [RFC1947,RFC1345,KXS2] *)
 
2005
(* Alias: iso-ir-126 *)
 
2006
(* Alias: ISO_8859-7 *)
 
2007
(* Alias: ISO-8859-7 (preferred MIME name) *)
 
2008
(* Alias: ELOT_928 *)
 
2009
(* Alias: ECMA-118 *)
 
2010
(* Alias: greek *)
 
2011
(* Alias: greek8 *)
 
2012
(* Alias: csISOLatinGreek *)
 
2013
let () = alias "IANA/csISOLatinGreek" "ISO-8859-7"
 
2014
let () = alias "IANA/greek8" "ISO-8859-7"
 
2015
let () = alias "IANA/greek" "ISO-8859-7"
 
2016
let () = alias "IANA/ECMA-118" "ISO-8859-7"
 
2017
let () = alias "IANA/ELOT_928" "ISO-8859-7"
 
2018
let () = alias "IANA/ISO-8859-7" "ISO-8859-7"
 
2019
let () = alias "IANA/ISO_8859-7" "ISO-8859-7"
 
2020
let () = alias "IANA/iso-ir-126" "ISO-8859-7"
 
2021
let () = alias "IANA/ISO_8859-7:1987" "ISO-8859-7"
 
2022
(* Name: T.101-G2                                            [RFC1345,KXS2] *)
 
2023
(* Alias: iso-ir-128 *)
 
2024
(* Alias: csISO128T101G2 *)
 
2025
let () = alias "IANA/csISO128T101G2" "T.101-G2"
 
2026
let () = alias "IANA/iso-ir-128" "T.101-G2"
 
2027
let () = alias "IANA/T.101-G2" "T.101-G2"
 
2028
(* Name: ISO_8859-8:1988                                     [RFC1345,KXS2] *)
 
2029
(* Alias: iso-ir-138 *)
 
2030
(* Alias: ISO_8859-8 *)
 
2031
(* Alias: ISO-8859-8 (preferred MIME name) *)
 
2032
(* Alias: hebrew *)
 
2033
(* Alias: csISOLatinHebrew *)
 
2034
let () = alias "IANA/csISOLatinHebrew" "ISO-8859-8"
 
2035
let () = alias "IANA/hebrew" "ISO-8859-8"
 
2036
let () = alias "IANA/ISO-8859-8" "ISO-8859-8"
 
2037
let () = alias "IANA/ISO_8859-8" "ISO-8859-8"
 
2038
let () = alias "IANA/iso-ir-138" "ISO-8859-8"
 
2039
let () = alias "IANA/ISO_8859-8:1988" "ISO-8859-8"
 
2040
(* Name: ISO_8859-8-E                                  [RFC1556,Nussbacher] *)
 
2041
(* Alias: csISO88598E *)
 
2042
(* Alias: ISO-8859-8-E (preferred MIME name) *)
 
2043
(* Name: ISO_8859-8-I                                  [RFC1556,Nussbacher] *)
 
2044
(* Alias: csISO88598I *)
 
2045
(* Alias: ISO-8859-8-I (preferred MIME name) *)
 
2046
(* Name: CSN_369103                                          [RFC1345,KXS2] *)
 
2047
(* Alias: iso-ir-139 *)
 
2048
(* Alias: csISO139CSN369103 *)
 
2049
let () = alias "IANA/csISO139CSN369103" "CSN_369103"
 
2050
let () = alias "IANA/iso-ir-139" "CSN_369103"
 
2051
let () = alias "IANA/CSN_369103" "CSN_369103"
 
2052
(* Name: JUS_I.B1.002                                        [RFC1345,KXS2] *)
 
2053
(* Alias: iso-ir-141 *)
 
2054
(* Alias: ISO646-YU *)
 
2055
(* Alias: js *)
 
2056
(* Alias: yu *)
 
2057
(* Alias: csISO141JUSIB1002 *)
 
2058
let () = alias "IANA/csISO141JUSIB1002" "JUS_I.B1.002"
 
2059
let () = alias "IANA/yu" "JUS_I.B1.002"
 
2060
let () = alias "IANA/js" "JUS_I.B1.002"
 
2061
let () = alias "IANA/ISO646-YU" "JUS_I.B1.002"
 
2062
let () = alias "IANA/iso-ir-141" "JUS_I.B1.002"
 
2063
let () = alias "IANA/JUS_I.B1.002" "JUS_I.B1.002"
 
2064
(* Name: ISO_6937-2-add                                      [RFC1345,KXS2] *)
 
2065
(* Alias: iso-ir-142 *)
 
2066
(* Alias: csISOTextComm *)
 
2067
let () = alias "IANA/csISOTextComm" "ISO_6937-2-ADD"
 
2068
let () = alias "IANA/iso-ir-142" "ISO_6937-2-ADD"
 
2069
let () = alias "IANA/ISO_6937-2-add" "ISO_6937-2-ADD"
 
2070
(* Name: IEC_P27-1                                           [RFC1345,KXS2] *)
 
2071
(* Alias: iso-ir-143 *)
 
2072
(* Alias: csISO143IECP271 *)
 
2073
let () = alias "IANA/csISO143IECP271" "IEC_P27-1"
 
2074
let () = alias "IANA/iso-ir-143" "IEC_P27-1"
 
2075
let () = alias "IANA/IEC_P27-1" "IEC_P27-1"
 
2076
(* Name: ISO_8859-5:1988                                     [RFC1345,KXS2] *)
 
2077
(* Alias: iso-ir-144 *)
 
2078
(* Alias: ISO_8859-5 *)
 
2079
(* Alias: ISO-8859-5 (preferred MIME name) *)
 
2080
(* Alias: cyrillic *)
 
2081
(* Alias: csISOLatinCyrillic *)
 
2082
let () = alias "IANA/csISOLatinCyrillic" "ISO-8859-5"
 
2083
let () = alias "IANA/cyrillic" "ISO-8859-5"
 
2084
let () = alias "IANA/ISO-8859-5" "ISO-8859-5"
 
2085
let () = alias "IANA/ISO_8859-5" "ISO-8859-5"
 
2086
let () = alias "IANA/iso-ir-144" "ISO-8859-5"
 
2087
let () = alias "IANA/ISO_8859-5:1988" "ISO-8859-5"
 
2088
(* Name: JUS_I.B1.003-serb                                   [RFC1345,KXS2] *)
 
2089
(* Alias: iso-ir-146 *)
 
2090
(* Alias: serbian *)
 
2091
(* Alias: csISO146Serbian *)
 
2092
let () = alias "IANA/csISO146Serbian" "JUS_I.B1.003-SERB"
 
2093
let () = alias "IANA/serbian" "JUS_I.B1.003-SERB"
 
2094
let () = alias "IANA/iso-ir-146" "JUS_I.B1.003-SERB"
 
2095
let () = alias "IANA/JUS_I.B1.003-serb" "JUS_I.B1.003-SERB"
 
2096
(* Name: JUS_I.B1.003-mac                                    [RFC1345,KXS2] *)
 
2097
(* Alias: macedonian *)
 
2098
(* Alias: iso-ir-147 *)
 
2099
(* Alias: csISO147Macedonian *)
 
2100
let () = alias "IANA/csISO147Macedonian" "JUS_I.B1.003-MAC"
 
2101
let () = alias "IANA/iso-ir-147" "JUS_I.B1.003-MAC"
 
2102
let () = alias "IANA/macedonian" "JUS_I.B1.003-MAC"
 
2103
let () = alias "IANA/JUS_I.B1.003-mac" "JUS_I.B1.003-MAC"
 
2104
(* Name: ISO_8859-9:1989                                     [RFC1345,KXS2] *)
 
2105
(* Alias: iso-ir-148 *)
 
2106
(* Alias: ISO_8859-9 *)
 
2107
(* Alias: ISO-8859-9 (preferred MIME name) *)
 
2108
(* Alias: latin5 *)
 
2109
(* Alias: l5 *)
 
2110
(* Alias: csISOLatin5 *)
 
2111
let () = alias "IANA/csISOLatin5" "ISO-8859-9"
 
2112
let () = alias "IANA/l5" "ISO-8859-9"
 
2113
let () = alias "IANA/latin5" "ISO-8859-9"
 
2114
let () = alias "IANA/ISO-8859-9" "ISO-8859-9"
 
2115
let () = alias "IANA/ISO_8859-9" "ISO-8859-9"
 
2116
let () = alias "IANA/iso-ir-148" "ISO-8859-9"
 
2117
let () = alias "IANA/ISO_8859-9:1989" "ISO-8859-9"
 
2118
(* Name: greek-ccitt                                         [RFC1345,KXS2] *)
 
2119
(* Alias: iso-ir-150 *)
 
2120
(* Alias: csISO150 *)
 
2121
(* Alias: csISO150GreekCCITT *)
 
2122
let () = alias "IANA/csISO150GreekCCITT" "GREEK-CCITT"
 
2123
let () = alias "IANA/csISO150" "GREEK-CCITT"
 
2124
let () = alias "IANA/iso-ir-150" "GREEK-CCITT"
 
2125
let () = alias "IANA/greek-ccitt" "GREEK-CCITT"
 
2126
(* Name: NC_NC00-10:81                                       [RFC1345,KXS2] *)
 
2127
(* Alias: cuba *)
 
2128
(* Alias: iso-ir-151 *)
 
2129
(* Alias: ISO646-CU *)
 
2130
(* Alias: csISO151Cuba *)
 
2131
let () = alias "IANA/csISO151Cuba" "NC_NC00-10"
 
2132
let () = alias "IANA/ISO646-CU" "NC_NC00-10"
 
2133
let () = alias "IANA/iso-ir-151" "NC_NC00-10"
 
2134
let () = alias "IANA/cuba" "NC_NC00-10"
 
2135
let () = alias "IANA/NC_NC00-10:81" "NC_NC00-10"
 
2136
(* Name: ISO_6937-2-25                                       [RFC1345,KXS2] *)
 
2137
(* Alias: iso-ir-152 *)
 
2138
(* Alias: csISO6937Add *)
 
2139
let () = alias "IANA/csISO6937Add" "ISO_6937-2-25"
 
2140
let () = alias "IANA/iso-ir-152" "ISO_6937-2-25"
 
2141
let () = alias "IANA/ISO_6937-2-25" "ISO_6937-2-25"
 
2142
(* Name: GOST_19768-74                                       [RFC1345,KXS2] *)
 
2143
(* Alias: ST_SEV_358-88 *)
 
2144
(* Alias: iso-ir-153 *)
 
2145
(* Alias: csISO153GOST1976874 *)
 
2146
let () = alias "IANA/csISO153GOST1976874" "GOST_19768-74"
 
2147
let () = alias "IANA/iso-ir-153" "GOST_19768-74"
 
2148
let () = alias "IANA/ST_SEV_358-88" "GOST_19768-74"
 
2149
let () = alias "IANA/GOST_19768-74" "GOST_19768-74"
 
2150
(* Name: ISO_8859-supp                                       [RFC1345,KXS2] *)
 
2151
(* Alias: iso-ir-154 *)
 
2152
(* Alias: latin1-2-5 *)
 
2153
(* Alias: csISO8859Supp *)
 
2154
let () = alias "IANA/csISO8859Supp" "ISO_8859-SUPP"
 
2155
let () = alias "IANA/latin1-2-5" "ISO_8859-SUPP"
 
2156
let () = alias "IANA/iso-ir-154" "ISO_8859-SUPP"
 
2157
let () = alias "IANA/ISO_8859-supp" "ISO_8859-SUPP"
 
2158
(* Name: ISO_10367-box                                       [RFC1345,KXS2] *)
 
2159
(* Alias: iso-ir-155 *)
 
2160
(* Alias: csISO10367Box *)
 
2161
let () = alias "IANA/csISO10367Box" "ISO_10367-BOX"
 
2162
let () = alias "IANA/iso-ir-155" "ISO_10367-BOX"
 
2163
let () = alias "IANA/ISO_10367-box" "ISO_10367-BOX"
 
2164
(* Name: ISO-8859-10 (preferred MIME name)                        [RFC1345,KXS2] *)
 
2165
(* Alias: iso-ir-157 *)
 
2166
(* Alias: l6 *)
 
2167
(* Alias: ISO_8859-10:1992 *)
 
2168
(* Alias: csISOLatin6 *)
 
2169
(* Alias: latin6 *)
 
2170
let () = alias "IANA/latin6" "ISO-8859-10"
 
2171
let () = alias "IANA/csISOLatin6" "ISO-8859-10"
 
2172
let () = alias "IANA/ISO_8859-10:1992" "ISO-8859-10"
 
2173
let () = alias "IANA/l6" "ISO-8859-10"
 
2174
let () = alias "IANA/iso-ir-157" "ISO-8859-10"
 
2175
let () = alias "IANA/ISO-8859-10" "ISO-8859-10"
 
2176
(* Name: latin-lap                                           [RFC1345,KXS2] *)
 
2177
(* Alias: lap *)
 
2178
(* Alias: iso-ir-158 *)
 
2179
(* Alias: csISO158Lap *)
 
2180
let () = alias "IANA/csISO158Lap" "SAMI"
 
2181
let () = alias "IANA/iso-ir-158" "SAMI"
 
2182
let () = alias "IANA/lap" "SAMI"
 
2183
let () = alias "IANA/latin-lap" "SAMI"
 
2184
(* Name: JIS_X0212-1990                                      [RFC1345,KXS2] *)
 
2185
(* Alias: x0212 *)
 
2186
(* Alias: iso-ir-159 *)
 
2187
(* Alias: csISO159JISX02121990 *)
 
2188
(* Name: DS_2089                                             [RFC1345,KXS2] *)
 
2189
(* Alias: DS2089 *)
 
2190
(* Alias: ISO646-DK *)
 
2191
(* Alias: dk *)
 
2192
(* Alias: csISO646Danish *)
 
2193
let () = alias "IANA/csISO646Danish" "DS_2089"
 
2194
let () = alias "IANA/dk" "DS_2089"
 
2195
let () = alias "IANA/ISO646-DK" "DS_2089"
 
2196
let () = alias "IANA/DS2089" "DS_2089"
 
2197
let () = alias "IANA/DS_2089" "DS_2089"
 
2198
(* Name: us-dk                                               [RFC1345,KXS2] *)
 
2199
(* Alias: csUSDK *)
 
2200
(* Name: dk-us                                               [RFC1345,KXS2] *)
 
2201
(* Alias: csDKUS *)
 
2202
(* Name: JIS_X0201                                           [RFC1345,KXS2] *)
 
2203
(* Alias: X0201 *)
 
2204
(* Alias: csHalfWidthKatakana *)
 
2205
let () = alias "IANA/csHalfWidthKatakana" "JIS_X0201"
 
2206
let () = alias "IANA/X0201" "JIS_X0201"
 
2207
let () = alias "IANA/JIS_X0201" "JIS_X0201"
 
2208
(* Name: KSC5636                                             [RFC1345,KXS2] *)
 
2209
(* Alias: ISO646-KR *)
 
2210
(* Alias: csKSC5636 *)
 
2211
let () = alias "IANA/csKSC5636" "KSC5636"
 
2212
let () = alias "IANA/ISO646-KR" "KSC5636"
 
2213
let () = alias "IANA/KSC5636" "KSC5636"
 
2214
(* Name: ISO-10646-UCS-2 *)
 
2215
(* Alias: csUnicode *)
 
2216
let () = alias "IANA/ISO-10646-UCS-2" "UTF-16"
 
2217
let () = alias "IANA/csUnicode" "UTF-16"
 
2218
(* Name: ISO-10646-UCS-4 *)
 
2219
(* Alias: csUCS4 *)
 
2220
let () = alias "IANA/ISO-10646-UCS-4" "UCS4"
 
2221
let () = alias "IANA/csUCS4" "UCS4"
 
2222
(* Name: DEC-MCS                                             [RFC1345,KXS2] *)
 
2223
(* Alias: dec *)
 
2224
(* Alias: csDECMCS *)
 
2225
let () = alias "IANA/csDECMCS" "DEC-MCS"
 
2226
let () = alias "IANA/dec" "DEC-MCS"
 
2227
let () = alias "IANA/DEC-MCS" "DEC-MCS"
 
2228
(* Name: hp-roman8                                  [HP-PCL5,RFC1345,KXS2] *)
 
2229
(* Alias: roman8 *)
 
2230
(* Alias: r8 *)
 
2231
(* Alias: csHPRoman8 *)
 
2232
let () = alias "IANA/csHPRoman8" "HP-ROMAN8"
 
2233
let () = alias "IANA/r8" "HP-ROMAN8"
 
2234
let () = alias "IANA/roman8" "HP-ROMAN8"
 
2235
let () = alias "IANA/hp-roman8" "HP-ROMAN8"
 
2236
(* Name: macintosh                                           [RFC1345,KXS2] *)
 
2237
(* Alias: mac *)
 
2238
(* Alias: csMacintosh *)
 
2239
let () = alias "IANA/csMacintosh" "MACINTOSH"
 
2240
let () = alias "IANA/mac" "MACINTOSH"
 
2241
let () = alias "IANA/macintosh" "MACINTOSH"
 
2242
(* Name: IBM037                                              [RFC1345,KXS2] *)
 
2243
(* Alias: cp037 *)
 
2244
(* Alias: ebcdic-cp-us *)
 
2245
(* Alias: ebcdic-cp-ca *)
 
2246
(* Alias: ebcdic-cp-wt *)
 
2247
(* Alias: ebcdic-cp-nl *)
 
2248
(* Alias: csIBM037 *)
 
2249
let () = alias "IANA/csIBM037" "IBM037"
 
2250
let () = alias "IANA/ebcdic-cp-nl" "IBM037"
 
2251
let () = alias "IANA/ebcdic-cp-wt" "IBM037"
 
2252
let () = alias "IANA/ebcdic-cp-ca" "IBM037"
 
2253
let () = alias "IANA/ebcdic-cp-us" "IBM037"
 
2254
let () = alias "IANA/cp037" "IBM037"
 
2255
let () = alias "IANA/IBM037" "IBM037"
 
2256
(* Name: IBM038                                              [RFC1345,KXS2] *)
 
2257
(* Alias: EBCDIC-INT *)
 
2258
(* Alias: cp038 *)
 
2259
(* Alias: csIBM038 *)
 
2260
let () = alias "IANA/csIBM038" "IBM038"
 
2261
let () = alias "IANA/cp038" "IBM038"
 
2262
let () = alias "IANA/EBCDIC-INT" "IBM038"
 
2263
let () = alias "IANA/IBM038" "IBM038"
 
2264
(* Name: IBM273                                              [RFC1345,KXS2] *)
 
2265
(* Alias: CP273 *)
 
2266
(* Alias: csIBM273 *)
 
2267
let () = alias "IANA/csIBM273" "IBM273"
 
2268
let () = alias "IANA/CP273" "IBM273"
 
2269
let () = alias "IANA/IBM273" "IBM273"
 
2270
(* Name: IBM274                                              [RFC1345,KXS2] *)
 
2271
(* Alias: EBCDIC-BE *)
 
2272
(* Alias: CP274 *)
 
2273
(* Alias: csIBM274 *)
 
2274
let () = alias "IANA/csIBM274" "IBM274"
 
2275
let () = alias "IANA/CP274" "IBM274"
 
2276
let () = alias "IANA/EBCDIC-BE" "IBM274"
 
2277
let () = alias "IANA/IBM274" "IBM274"
 
2278
(* Name: IBM275                                              [RFC1345,KXS2] *)
 
2279
(* Alias: EBCDIC-BR *)
 
2280
(* Alias: cp275 *)
 
2281
(* Alias: csIBM275 *)
 
2282
let () = alias "IANA/csIBM275" "IBM275"
 
2283
let () = alias "IANA/cp275" "IBM275"
 
2284
let () = alias "IANA/EBCDIC-BR" "IBM275"
 
2285
let () = alias "IANA/IBM275" "IBM275"
 
2286
(* Name: IBM277                                              [RFC1345,KXS2] *)
 
2287
(* Alias: EBCDIC-CP-DK *)
 
2288
(* Alias: EBCDIC-CP-NO *)
 
2289
(* Alias: csIBM277 *)
 
2290
let () = alias "IANA/csIBM277" "IBM277"
 
2291
let () = alias "IANA/EBCDIC-CP-NO" "IBM277"
 
2292
let () = alias "IANA/EBCDIC-CP-DK" "IBM277"
 
2293
let () = alias "IANA/IBM277" "IBM277"
 
2294
(* Name: IBM278                                              [RFC1345,KXS2] *)
 
2295
(* Alias: CP278 *)
 
2296
(* Alias: ebcdic-cp-fi *)
 
2297
(* Alias: ebcdic-cp-se *)
 
2298
(* Alias: csIBM278 *)
 
2299
let () = alias "IANA/csIBM278" "IBM278"
 
2300
let () = alias "IANA/ebcdic-cp-se" "IBM278"
 
2301
let () = alias "IANA/ebcdic-cp-fi" "IBM278"
 
2302
let () = alias "IANA/CP278" "IBM278"
 
2303
let () = alias "IANA/IBM278" "IBM278"
 
2304
(* Name: IBM280                                              [RFC1345,KXS2] *)
 
2305
(* Alias: CP280 *)
 
2306
(* Alias: ebcdic-cp-it *)
 
2307
(* Alias: csIBM280 *)
 
2308
let () = alias "IANA/csIBM280" "IBM280"
 
2309
let () = alias "IANA/ebcdic-cp-it" "IBM280"
 
2310
let () = alias "IANA/CP280" "IBM280"
 
2311
let () = alias "IANA/IBM280" "IBM280"
 
2312
(* Name: IBM281                                              [RFC1345,KXS2] *)
 
2313
(* Alias: EBCDIC-JP-E *)
 
2314
(* Alias: cp281 *)
 
2315
(* Alias: csIBM281 *)
 
2316
let () = alias "IANA/csIBM281" "IBM281"
 
2317
let () = alias "IANA/cp281" "IBM281"
 
2318
let () = alias "IANA/EBCDIC-JP-E" "IBM281"
 
2319
let () = alias "IANA/IBM281" "IBM281"
 
2320
(* Name: IBM284                                              [RFC1345,KXS2] *)
 
2321
(* Alias: CP284 *)
 
2322
(* Alias: ebcdic-cp-es *)
 
2323
(* Alias: csIBM284 *)
 
2324
let () = alias "IANA/csIBM284" "IBM284"
 
2325
let () = alias "IANA/ebcdic-cp-es" "IBM284"
 
2326
let () = alias "IANA/CP284" "IBM284"
 
2327
let () = alias "IANA/IBM284" "IBM284"
 
2328
(* Name: IBM285                                              [RFC1345,KXS2] *)
 
2329
(* Alias: CP285 *)
 
2330
(* Alias: ebcdic-cp-gb *)
 
2331
(* Alias: csIBM285 *)
 
2332
let () = alias "IANA/csIBM285" "IBM285"
 
2333
let () = alias "IANA/ebcdic-cp-gb" "IBM285"
 
2334
let () = alias "IANA/CP285" "IBM285"
 
2335
let () = alias "IANA/IBM285" "IBM285"
 
2336
(* Name: IBM290                                              [RFC1345,KXS2] *)
 
2337
(* Alias: cp290 *)
 
2338
(* Alias: EBCDIC-JP-kana *)
 
2339
(* Alias: csIBM290 *)
 
2340
let () = alias "IANA/csIBM290" "IBM290"
 
2341
let () = alias "IANA/EBCDIC-JP-kana" "IBM290"
 
2342
let () = alias "IANA/cp290" "IBM290"
 
2343
let () = alias "IANA/IBM290" "IBM290"
 
2344
(* Name: IBM297                                              [RFC1345,KXS2] *)
 
2345
(* Alias: cp297 *)
 
2346
(* Alias: ebcdic-cp-fr *)
 
2347
(* Alias: csIBM297 *)
 
2348
let () = alias "IANA/csIBM297" "IBM297"
 
2349
let () = alias "IANA/ebcdic-cp-fr" "IBM297"
 
2350
let () = alias "IANA/cp297" "IBM297"
 
2351
let () = alias "IANA/IBM297" "IBM297"
 
2352
(* Name: IBM420                                              [RFC1345,KXS2] *)
 
2353
(* Alias: cp420 *)
 
2354
(* Alias: ebcdic-cp-ar1 *)
 
2355
(* Alias: csIBM420 *)
 
2356
let () = alias "IANA/csIBM420" "IBM420"
 
2357
let () = alias "IANA/ebcdic-cp-ar1" "IBM420"
 
2358
let () = alias "IANA/cp420" "IBM420"
 
2359
let () = alias "IANA/IBM420" "IBM420"
 
2360
(* Name: IBM423                                              [RFC1345,KXS2] *)
 
2361
(* Alias: cp423 *)
 
2362
(* Alias: ebcdic-cp-gr *)
 
2363
(* Alias: csIBM423 *)
 
2364
let () = alias "IANA/csIBM423" "IBM423"
 
2365
let () = alias "IANA/ebcdic-cp-gr" "IBM423"
 
2366
let () = alias "IANA/cp423" "IBM423"
 
2367
let () = alias "IANA/IBM423" "IBM423"
 
2368
(* Name: IBM424                                              [RFC1345,KXS2] *)
 
2369
(* Alias: cp424 *)
 
2370
(* Alias: ebcdic-cp-he *)
 
2371
(* Alias: csIBM424 *)
 
2372
let () = alias "IANA/csIBM424" "IBM424"
 
2373
let () = alias "IANA/ebcdic-cp-he" "IBM424"
 
2374
let () = alias "IANA/cp424" "IBM424"
 
2375
let () = alias "IANA/IBM424" "IBM424"
 
2376
(* Name: IBM437                                              [RFC1345,KXS2] *)
 
2377
(* Alias: cp437 *)
 
2378
(* Alias: 437 *)
 
2379
(* Alias: csPC8CodePage437 *)
 
2380
let () = alias "IANA/csPC8CodePage437" "IBM437"
 
2381
let () = alias "IANA/437" "IBM437"
 
2382
let () = alias "IANA/cp437" "IBM437"
 
2383
let () = alias "IANA/IBM437" "IBM437"
 
2384
(* Name: IBM500                                              [RFC1345,KXS2] *)
 
2385
(* Alias: CP500 *)
 
2386
(* Alias: ebcdic-cp-be *)
 
2387
(* Alias: ebcdic-cp-ch *)
 
2388
(* Alias: csIBM500 *)
 
2389
let () = alias "IANA/csIBM500" "IBM500"
 
2390
let () = alias "IANA/ebcdic-cp-ch" "IBM500"
 
2391
let () = alias "IANA/ebcdic-cp-be" "IBM500"
 
2392
let () = alias "IANA/CP500" "IBM500"
 
2393
let () = alias "IANA/IBM500" "IBM500"
 
2394
(* Name: IBM775                                                   [HP-PCL5] *)
 
2395
(* Alias: cp775 *)
 
2396
(* Alias: csPC775Baltic *)
 
2397
(* Name: IBM850                                              [RFC1345,KXS2] *)
 
2398
(* Alias: cp850 *)
 
2399
(* Alias: 850 *)
 
2400
(* Alias: csPC850Multilingual *)
 
2401
let () = alias "IANA/csPC850Multilingual" "IBM850"
 
2402
let () = alias "IANA/850" "IBM850"
 
2403
let () = alias "IANA/cp850" "IBM850"
 
2404
let () = alias "IANA/IBM850" "IBM850"
 
2405
(* Name: IBM851                                              [RFC1345,KXS2] *)
 
2406
(* Alias: cp851 *)
 
2407
(* Alias: 851 *)
 
2408
(* Alias: csIBM851 *)
 
2409
let () = alias "IANA/csIBM851" "IBM851"
 
2410
let () = alias "IANA/851" "IBM851"
 
2411
let () = alias "IANA/cp851" "IBM851"
 
2412
let () = alias "IANA/IBM851" "IBM851"
 
2413
(* Name: IBM852                                              [RFC1345,KXS2] *)
 
2414
(* Alias: cp852 *)
 
2415
(* Alias: 852 *)
 
2416
(* Alias: csPCp852 *)
 
2417
let () = alias "IANA/csPCp852" "IBM852"
 
2418
let () = alias "IANA/852" "IBM852"
 
2419
let () = alias "IANA/cp852" "IBM852"
 
2420
let () = alias "IANA/IBM852" "IBM852"
 
2421
(* Name: IBM855                                              [RFC1345,KXS2] *)
 
2422
(* Alias: cp855 *)
 
2423
(* Alias: 855 *)
 
2424
(* Alias: csIBM855 *)
 
2425
let () = alias "IANA/csIBM855" "IBM855"
 
2426
let () = alias "IANA/855" "IBM855"
 
2427
let () = alias "IANA/cp855" "IBM855"
 
2428
let () = alias "IANA/IBM855" "IBM855"
 
2429
(* Name: IBM857                                              [RFC1345,KXS2] *)
 
2430
(* Alias: cp857 *)
 
2431
(* Alias: 857 *)
 
2432
(* Alias: csIBM857 *)
 
2433
let () = alias "IANA/csIBM857" "IBM857"
 
2434
let () = alias "IANA/857" "IBM857"
 
2435
let () = alias "IANA/cp857" "IBM857"
 
2436
let () = alias "IANA/IBM857" "IBM857"
 
2437
(* Name: IBM860                                              [RFC1345,KXS2] *)
 
2438
(* Alias: cp860 *)
 
2439
(* Alias: 860 *)
 
2440
(* Alias: csIBM860 *)
 
2441
let () = alias "IANA/csIBM860" "IBM860"
 
2442
let () = alias "IANA/860" "IBM860"
 
2443
let () = alias "IANA/cp860" "IBM860"
 
2444
let () = alias "IANA/IBM860" "IBM860"
 
2445
(* Name: IBM861                                              [RFC1345,KXS2] *)
 
2446
(* Alias: cp861 *)
 
2447
(* Alias: 861 *)
 
2448
(* Alias: cp-is *)
 
2449
(* Alias: csIBM861 *)
 
2450
let () = alias "IANA/csIBM861" "IBM861"
 
2451
let () = alias "IANA/cp-is" "IBM861"
 
2452
let () = alias "IANA/861" "IBM861"
 
2453
let () = alias "IANA/cp861" "IBM861"
 
2454
let () = alias "IANA/IBM861" "IBM861"
 
2455
(* Name: IBM862                                              [RFC1345,KXS2] *)
 
2456
(* Alias: cp862 *)
 
2457
(* Alias: 862 *)
 
2458
(* Alias: csPC862LatinHebrew *)
 
2459
let () = alias "IANA/csPC862LatinHebrew" "IBM862"
 
2460
let () = alias "IANA/862" "IBM862"
 
2461
let () = alias "IANA/cp862" "IBM862"
 
2462
let () = alias "IANA/IBM862" "IBM862"
 
2463
(* Name: IBM863                                              [RFC1345,KXS2] *)
 
2464
(* Alias: cp863 *)
 
2465
(* Alias: 863 *)
 
2466
(* Alias: csIBM863 *)
 
2467
let () = alias "IANA/csIBM863" "IBM863"
 
2468
let () = alias "IANA/863" "IBM863"
 
2469
let () = alias "IANA/cp863" "IBM863"
 
2470
let () = alias "IANA/IBM863" "IBM863"
 
2471
(* Name: IBM864                                              [RFC1345,KXS2] *)
 
2472
(* Alias: cp864 *)
 
2473
(* Alias: csIBM864 *)
 
2474
let () = alias "IANA/csIBM864" "IBM864"
 
2475
let () = alias "IANA/cp864" "IBM864"
 
2476
let () = alias "IANA/IBM864" "IBM864"
 
2477
(* Name: IBM865                                              [RFC1345,KXS2] *)
 
2478
(* Alias: cp865 *)
 
2479
(* Alias: 865 *)
 
2480
(* Alias: csIBM865 *)
 
2481
let () = alias "IANA/csIBM865" "IBM865"
 
2482
let () = alias "IANA/865" "IBM865"
 
2483
let () = alias "IANA/cp865" "IBM865"
 
2484
let () = alias "IANA/IBM865" "IBM865"
 
2485
(* Name: IBM866                                                     [Pond] *)
 
2486
(* Alias: cp866 *)
 
2487
(* Alias: 866 *)
 
2488
(* Alias: csIBM866 *)
 
2489
let () = alias "IANA/csIBM866" "IBM866"
 
2490
let () = alias "IANA/866" "IBM866"
 
2491
let () = alias "IANA/cp866" "IBM866"
 
2492
let () = alias "IANA/IBM866" "IBM866"
 
2493
(* Name: IBM868                                              [RFC1345,KXS2] *)
 
2494
(* Alias: CP868 *)
 
2495
(* Alias: cp-ar *)
 
2496
(* Alias: csIBM868 *)
 
2497
let () = alias "IANA/csIBM868" "IBM868"
 
2498
let () = alias "IANA/cp-ar" "IBM868"
 
2499
let () = alias "IANA/CP868" "IBM868"
 
2500
let () = alias "IANA/IBM868" "IBM868"
 
2501
(* Name: IBM869                                              [RFC1345,KXS2] *)
 
2502
(* Alias: cp869 *)
 
2503
(* Alias: 869 *)
 
2504
(* Alias: cp-gr *)
 
2505
(* Alias: csIBM869 *)
 
2506
let () = alias "IANA/csIBM869" "IBM869"
 
2507
let () = alias "IANA/cp-gr" "IBM869"
 
2508
let () = alias "IANA/869" "IBM869"
 
2509
let () = alias "IANA/cp869" "IBM869"
 
2510
let () = alias "IANA/IBM869" "IBM869"
 
2511
(* Name: IBM870                                              [RFC1345,KXS2] *)
 
2512
(* Alias: CP870 *)
 
2513
(* Alias: ebcdic-cp-roece *)
 
2514
(* Alias: ebcdic-cp-yu *)
 
2515
(* Alias: csIBM870 *)
 
2516
let () = alias "IANA/csIBM870" "IBM870"
 
2517
let () = alias "IANA/ebcdic-cp-yu" "IBM870"
 
2518
let () = alias "IANA/ebcdic-cp-roece" "IBM870"
 
2519
let () = alias "IANA/CP870" "IBM870"
 
2520
let () = alias "IANA/IBM870" "IBM870"
 
2521
(* Name: IBM871                                              [RFC1345,KXS2] *)
 
2522
(* Alias: CP871 *)
 
2523
(* Alias: ebcdic-cp-is *)
 
2524
(* Alias: csIBM871 *)
 
2525
let () = alias "IANA/csIBM871" "IBM871"
 
2526
let () = alias "IANA/ebcdic-cp-is" "IBM871"
 
2527
let () = alias "IANA/CP871" "IBM871"
 
2528
let () = alias "IANA/IBM871" "IBM871"
 
2529
(* Name: IBM880                                              [RFC1345,KXS2] *)
 
2530
(* Alias: cp880 *)
 
2531
(* Alias: EBCDIC-Cyrillic *)
 
2532
(* Alias: csIBM880 *)
 
2533
let () = alias "IANA/csIBM880" "IBM880"
 
2534
let () = alias "IANA/EBCDIC-Cyrillic" "IBM880"
 
2535
let () = alias "IANA/cp880" "IBM880"
 
2536
let () = alias "IANA/IBM880" "IBM880"
 
2537
(* Name: IBM891                                              [RFC1345,KXS2] *)
 
2538
(* Alias: cp891 *)
 
2539
(* Alias: csIBM891 *)
 
2540
let () = alias "IANA/csIBM891" "IBM891"
 
2541
let () = alias "IANA/cp891" "IBM891"
 
2542
let () = alias "IANA/IBM891" "IBM891"
 
2543
(* Name: IBM903                                              [RFC1345,KXS2] *)
 
2544
(* Alias: cp903 *)
 
2545
(* Alias: csIBM903 *)
 
2546
let () = alias "IANA/csIBM903" "IBM903"
 
2547
let () = alias "IANA/cp903" "IBM903"
 
2548
let () = alias "IANA/IBM903" "IBM903"
 
2549
(* Name: IBM904                                              [RFC1345,KXS2] *)
 
2550
(* Alias: cp904 *)
 
2551
(* Alias: 904 *)
 
2552
(* Alias: csIBBM904 *)
 
2553
let () = alias "IANA/csIBBM904" "IBM904"
 
2554
let () = alias "IANA/904" "IBM904"
 
2555
let () = alias "IANA/cp904" "IBM904"
 
2556
let () = alias "IANA/IBM904" "IBM904"
 
2557
(* Name: IBM905                                              [RFC1345,KXS2] *)
 
2558
(* Alias: CP905 *)
 
2559
(* Alias: ebcdic-cp-tr *)
 
2560
(* Alias: csIBM905 *)
 
2561
let () = alias "IANA/csIBM905" "IBM905"
 
2562
let () = alias "IANA/ebcdic-cp-tr" "IBM905"
 
2563
let () = alias "IANA/CP905" "IBM905"
 
2564
let () = alias "IANA/IBM905" "IBM905"
 
2565
(* Name: IBM918                                              [RFC1345,KXS2] *)
 
2566
(* Alias: CP918 *)
 
2567
(* Alias: ebcdic-cp-ar2 *)
 
2568
(* Alias: csIBM918 *)
 
2569
let () = alias "IANA/csIBM918" "IBM918"
 
2570
let () = alias "IANA/ebcdic-cp-ar2" "IBM918"
 
2571
let () = alias "IANA/CP918" "IBM918"
 
2572
let () = alias "IANA/IBM918" "IBM918"
 
2573
(* Name: IBM1026                                             [RFC1345,KXS2] *)
 
2574
(* Alias: CP1026 *)
 
2575
(* Alias: csIBM1026 *)
 
2576
let () = alias "IANA/csIBM1026" "IBM1026"
 
2577
let () = alias "IANA/CP1026" "IBM1026"
 
2578
let () = alias "IANA/IBM1026" "IBM1026"
 
2579
(* Name: EBCDIC-AT-DE                                        [RFC1345,KXS2] *)
 
2580
(* Alias: csIBMEBCDICATDE *)
 
2581
let () = alias "IANA/csIBMEBCDICATDE" "EBCDIC-AT-DE"
 
2582
let () = alias "IANA/EBCDIC-AT-DE" "EBCDIC-AT-DE"
 
2583
(* Name: EBCDIC-AT-DE-A                                      [RFC1345,KXS2] *)
 
2584
(* Alias: csEBCDICATDEA *)
 
2585
let () = alias "IANA/csEBCDICATDEA" "EBCDIC-AT-DE-A"
 
2586
let () = alias "IANA/EBCDIC-AT-DE-A" "EBCDIC-AT-DE-A"
 
2587
(* Name: EBCDIC-CA-FR                                        [RFC1345,KXS2] *)
 
2588
(* Alias: csEBCDICCAFR *)
 
2589
let () = alias "IANA/csEBCDICCAFR" "EBCDIC-CA-FR"
 
2590
let () = alias "IANA/EBCDIC-CA-FR" "EBCDIC-CA-FR"
 
2591
(* Name: EBCDIC-DK-NO                                        [RFC1345,KXS2] *)
 
2592
(* Alias: csEBCDICDKNO *)
 
2593
let () = alias "IANA/csEBCDICDKNO" "EBCDIC-DK-NO"
 
2594
let () = alias "IANA/EBCDIC-DK-NO" "EBCDIC-DK-NO"
 
2595
(* Name: EBCDIC-DK-NO-A                                      [RFC1345,KXS2] *)
 
2596
(* Alias: csEBCDICDKNOA *)
 
2597
let () = alias "IANA/csEBCDICDKNOA" "EBCDIC-DK-NO-A"
 
2598
let () = alias "IANA/EBCDIC-DK-NO-A" "EBCDIC-DK-NO-A"
 
2599
(* Name: EBCDIC-FI-SE                                        [RFC1345,KXS2] *)
 
2600
(* Alias: csEBCDICFISE *)
 
2601
let () = alias "IANA/csEBCDICFISE" "EBCDIC-FI-SE"
 
2602
let () = alias "IANA/EBCDIC-FI-SE" "EBCDIC-FI-SE"
 
2603
(* Name: EBCDIC-FI-SE-A                                      [RFC1345,KXS2] *)
 
2604
(* Alias: csEBCDICFISEA *)
 
2605
let () = alias "IANA/csEBCDICFISEA" "EBCDIC-FI-SE-A"
 
2606
let () = alias "IANA/EBCDIC-FI-SE-A" "EBCDIC-FI-SE-A"
 
2607
(* Name: EBCDIC-FR                                           [RFC1345,KXS2] *)
 
2608
(* Alias: csEBCDICFR *)
 
2609
let () = alias "IANA/csEBCDICFR" "EBCDIC-FR"
 
2610
let () = alias "IANA/EBCDIC-FR" "EBCDIC-FR"
 
2611
(* Name: EBCDIC-IT                                           [RFC1345,KXS2] *)
 
2612
(* Alias: csEBCDICIT *)
 
2613
let () = alias "IANA/csEBCDICIT" "EBCDIC-IT"
 
2614
let () = alias "IANA/EBCDIC-IT" "EBCDIC-IT"
 
2615
(* Name: EBCDIC-PT                                           [RFC1345,KXS2] *)
 
2616
(* Alias: csEBCDICPT *)
 
2617
let () = alias "IANA/csEBCDICPT" "EBCDIC-PT"
 
2618
let () = alias "IANA/EBCDIC-PT" "EBCDIC-PT"
 
2619
(* Name: EBCDIC-ES                                           [RFC1345,KXS2] *)
 
2620
(* Alias: csEBCDICES *)
 
2621
let () = alias "IANA/csEBCDICES" "EBCDIC-ES"
 
2622
let () = alias "IANA/EBCDIC-ES" "EBCDIC-ES"
 
2623
(* Name: EBCDIC-ES-A                                         [RFC1345,KXS2] *)
 
2624
(* Alias: csEBCDICESA *)
 
2625
let () = alias "IANA/csEBCDICESA" "EBCDIC-ES-A"
 
2626
let () = alias "IANA/EBCDIC-ES-A" "EBCDIC-ES-A"
 
2627
(* Name: EBCDIC-ES-S                                         [RFC1345,KXS2] *)
 
2628
(* Alias: csEBCDICESS *)
 
2629
let () = alias "IANA/csEBCDICESS" "EBCDIC-ES-S"
 
2630
let () = alias "IANA/EBCDIC-ES-S" "EBCDIC-ES-S"
 
2631
(* Name: EBCDIC-UK                                           [RFC1345,KXS2] *)
 
2632
(* Alias: csEBCDICUK *)
 
2633
let () = alias "IANA/csEBCDICUK" "EBCDIC-UK"
 
2634
let () = alias "IANA/EBCDIC-UK" "EBCDIC-UK"
 
2635
(* Name: EBCDIC-US                                           [RFC1345,KXS2] *)
 
2636
(* Alias: csEBCDICUS *)
 
2637
let () = alias "IANA/csEBCDICUS" "EBCDIC-US"
 
2638
let () = alias "IANA/EBCDIC-US" "EBCDIC-US"
 
2639
(* Name: UNKNOWN-8BIT                                             [RFC1428] *)
 
2640
(* Alias: csUnknown8BiT *)
 
2641
(* Name: MNEMONIC                                            [RFC1345,KXS2] *)
 
2642
(* Alias: csMnemonic *)
 
2643
(* Name: MNEM                                                [RFC1345,KXS2] *)
 
2644
(* Alias: csMnem *)
 
2645
(* Name: VISCII                                                   [RFC1456] *)
 
2646
(* Alias: csVISCII *)
 
2647
let () = alias "IANA/csVISCII" "VISCII"
 
2648
let () = alias "IANA/VISCII" "VISCII"
 
2649
(* Name: VIQR                                                     [RFC1456] *)
 
2650
(* Alias: csVIQR *)
 
2651
(* Name: KOI8-R  (preferred MIME name)                            [RFC1489] *)
 
2652
(* Alias: csKOI8R *)
 
2653
let () = alias "IANA/csKOI8R" "KOI8-R"
 
2654
let () = alias "IANA/KOI8-R" "KOI8-R"
 
2655
(* Name: KOI8-U                                                   [RFC2319] *)
 
2656
let () = alias "IANA/KOI8-U" "KOI8-U"
 
2657
(* Name: IBM00858 *)
 
2658
(* Alias: CCSID00858 *)
 
2659
(* Alias: CP00858 *)
 
2660
(* Alias: PC-Multilingual-850+euro *)
 
2661
(* Name: IBM00924 *)
 
2662
(* Alias: CCSID00924 *)
 
2663
(* Alias: CP00924 *)
 
2664
(* Alias: ebcdic-Latin9--euro *)
 
2665
(* Name: IBM01140 *)
 
2666
(* Alias: CCSID01140 *)
 
2667
(* Alias: CP01140 *)
 
2668
(* Alias: ebcdic-us-37+euro *)
 
2669
(* Name: IBM01141 *)
 
2670
(* Alias: CCSID01141 *)
 
2671
(* Alias: CP01141 *)
 
2672
(* Alias: ebcdic-de-273+euro *)
 
2673
(* Name: IBM01142 *)
 
2674
(* Alias: CCSID01142 *)
 
2675
(* Alias: CP01142 *)
 
2676
(* Alias: ebcdic-dk-277+euro *)
 
2677
(* Alias: ebcdic-no-277+euro *)
 
2678
(* Name: IBM01143 *)
 
2679
(* Alias: CCSID01143 *)
 
2680
(* Alias: CP01143 *)
 
2681
(* Alias: ebcdic-fi-278+euro *)
 
2682
(* Alias: ebcdic-se-278+euro *)
 
2683
(* Name: IBM01144 *)
 
2684
(* Alias: CCSID01144 *)
 
2685
(* Alias: CP01144 *)
 
2686
(* Alias: ebcdic-it-280+euro *)
 
2687
(* Name: IBM01145 *)
 
2688
(* Alias: CCSID01145 *)
 
2689
(* Alias: CP01145 *)
 
2690
(* Alias: ebcdic-es-284+euro *)
 
2691
(* Name: IBM01146 *)
 
2692
(* Alias: CCSID01146 *)
 
2693
(* Alias: CP01146 *)
 
2694
(* Alias: ebcdic-gb-285+euro *)
 
2695
(* Name: IBM01147 *)
 
2696
(* Alias: CCSID01147 *)
 
2697
(* Alias: CP01147 *)
 
2698
(* Alias: ebcdic-fr-297+euro *)
 
2699
(* Name: IBM01148 *)
 
2700
(* Alias: CCSID01148 *)
 
2701
(* Alias: CP01148 *)
 
2702
(* Alias: ebcdic-international-500+euro *)
 
2703
(* Name: IBM01149 *)
 
2704
(* Alias: CCSID01149 *)
 
2705
(* Alias: CP01149 *)
 
2706
(* Alias: ebcdic-is-871+euro *)
 
2707
(* Name: Big5-HKSCS *)
 
2708
let () = alias "IANA/Big5-HKSCS" "BIG5-HKSCS"
 
2709
(* Name: UNICODE-1-1                                              [RFC1641] *)
 
2710
(* Alias: csUnicode11 *)
 
2711
(* Name: SCSU *)
 
2712
(* Name: UTF-7                                                    [RFC2152] *)
 
2713
(* Name: UTF-16BE                                                 [RFC2781] *)
 
2714
let () = alias "IANA/UTF-16BE" "UTF-16BE"
 
2715
(* Name: UTF-16LE                                                 [RFC2781] *)
 
2716
let () = alias "IANA/UTF-16LE" "UTF-16LE"
 
2717
(* Name: UTF-16                                                   [RFC2781] *)
 
2718
let () = alias "IANA/UTF-16" "UTF-16"
 
2719
(* Name: UNICODE-1-1-UTF-7                                        [RFC1642] *)
 
2720
(* Alias: csUnicode11UTF7 *)
 
2721
(* Name: UTF-8                                                    [RFC2279] *)
 
2722
let () = alias "IANA/UTF-8" "UTF-8"
 
2723
(* Name: ISO-8859-13 *)
 
2724
let () = alias "IANA/ISO-8859-13" "ISO-8859-13"
 
2725
(* Name: ISO-8859-14 *)
 
2726
(* Alias: iso-ir-199 *)
 
2727
(* Alias: ISO_8859-14:1998 *)
 
2728
(* Alias: ISO_8859-14 *)
 
2729
(* Alias: latin8 *)
 
2730
(* Alias: iso-celtic *)
 
2731
(* Alias: l8 *)
 
2732
let () = alias "IANA/l8" "ISO-8859-14"
 
2733
let () = alias "IANA/iso-celtic" "ISO-8859-14"
 
2734
let () = alias "IANA/latin8" "ISO-8859-14"
 
2735
let () = alias "IANA/ISO_8859-14" "ISO-8859-14"
 
2736
let () = alias "IANA/ISO_8859-14:1998" "ISO-8859-14"
 
2737
let () = alias "IANA/iso-ir-199" "ISO-8859-14"
 
2738
let () = alias "IANA/ISO-8859-14" "ISO-8859-14"
 
2739
(* Name: ISO-8859-15 *)
 
2740
(* Alias: ISO_8859-15 *)
 
2741
let () = alias "IANA/ISO_8859-15" "ISO-8859-15"
 
2742
let () = alias "IANA/ISO-8859-15" "ISO-8859-15"
 
2743
(* Name: ISO-8859-16 *)
 
2744
let () = alias "IANA/ISO-8859-16" "ISO-8859-16"
 
2745
(* Name: JIS_Encoding *)
 
2746
(* Alias: csJISEncoding *)
 
2747
(* Name: Shift_JIS  (preferred MIME name) *)
 
2748
(* Alias: MS_Kanji  *)
 
2749
(* Alias: csShiftJIS *)
 
2750
let () = alias "IANA/csShiftJIS" "SHIFT_JIS"
 
2751
let () = alias "IANA/MS_Kanji" "SHIFT_JIS"
 
2752
let () = alias "IANA/Shift_JIS" "SHIFT_JIS"
 
2753
(* Name: Extended_UNIX_Code_Packed_Format_for_Japanese *)
 
2754
(* Alias: csEUCPkdFmtJapanese *)
 
2755
(* Alias: EUC-JP  (preferred MIME name) *)
 
2756
let () = alias "IANA/EUC-JP" "EUC-JP"
 
2757
let () = alias "IANA/csEUCPkdFmtJapanese" "EUC-JP"
 
2758
let () = alias "IANA/Extended_UNIX_Code_Packed_Format_for_Japanese" "EUC-JP"
 
2759
(* Name: Extended_UNIX_Code_Fixed_Width_for_Japanese *)
 
2760
(* Alias: csEUCFixWidJapanese *)
 
2761
(* Name: ISO-10646-UCS-Basic *)
 
2762
(* Alias: csUnicodeASCII *)
 
2763
(* Name: ISO-10646-Unicode-Latin1 *)
 
2764
(* Alias: csUnicodeLatin1 *)
 
2765
(* Alias: ISO-10646 *)
 
2766
(* Name: ISO-10646-J-1 *)
 
2767
(* Name: ISO-Unicode-IBM-1261 *)
 
2768
(* Alias: csUnicodeIBM1261 *)
 
2769
(* Name: ISO-Unicode-IBM-1268 *)
 
2770
(* Alias: csUnidoceIBM1268 *)
 
2771
(* Name: ISO-Unicode-IBM-1276 *)
 
2772
(* Alias: csUnicodeIBM1276 *)
 
2773
(* Name: ISO-Unicode-IBM-1264 *)
 
2774
(* Alias: csUnicodeIBM1264 *)
 
2775
(* Name: ISO-Unicode-IBM-1265 *)
 
2776
(* Alias: csUnicodeIBM1265 *)
 
2777
(* Name: ISO-8859-1-Windows-3.0-Latin-1                           [HP-PCL5]  *)
 
2778
(* Alias: csWindows30Latin1 *)
 
2779
(* Name: ISO-8859-1-Windows-3.1-Latin-1                           [HP-PCL5]  *)
 
2780
(* Alias: csWindows31Latin1 *)
 
2781
(* Name: ISO-8859-2-Windows-Latin-2                               [HP-PCL5]  *)
 
2782
(* Alias: csWindows31Latin2 *)
 
2783
(* Name: ISO-8859-9-Windows-Latin-5                               [HP-PCL5]  *)
 
2784
(* Alias: csWindows31Latin5 *)
 
2785
(* Name: Adobe-Standard-Encoding                                    [Adobe] *)
 
2786
(* Alias: csAdobeStandardEncoding *)
 
2787
(* Name: Ventura-US                                               [HP-PCL5] *)
 
2788
(* Alias: csVenturaUS   *)
 
2789
(* Name: Ventura-International                                    [HP-PCL5] *)
 
2790
(* Alias: csVenturaInternational *)
 
2791
(* Name: PC8-Danish-Norwegian                                     [HP-PCL5] *)
 
2792
(* Alias: csPC8DanishNorwegian *)
 
2793
(* Name: PC8-Turkish                                              [HP-PCL5] *)
 
2794
(* Alias: csPC8Turkish *)
 
2795
(* Name: IBM-Symbols                                             [IBM-CIDT]  *)
 
2796
(* Alias: csIBMSymbols *)
 
2797
(* Name: IBM-Thai                                                [IBM-CIDT]  *)
 
2798
(* Alias: csIBMThai *)
 
2799
(* Name: HP-Legal                                                 [HP-PCL5] *)
 
2800
(* Alias: csHPLegal *)
 
2801
(* Name: HP-Pi-font                                               [HP-PCL5] *)
 
2802
(* Alias: csHPPiFont *)
 
2803
(* Name: HP-Math8                                                 [HP-PCL5] *)
 
2804
(* Alias: csHPMath8 *)
 
2805
(* Name: Adobe-Symbol-Encoding                                      [Adobe] *)
 
2806
(* Alias: csHPPSMath *)
 
2807
(* Name: HP-DeskTop                                               [HP-PCL5] *)
 
2808
(* Alias: csHPDesktop *)
 
2809
(* Name: Ventura-Math                                             [HP-PCL5] *)
 
2810
(* Alias: csVenturaMath *)
 
2811
(* Name: Microsoft-Publishing                                     [HP-PCL5] *)
 
2812
(* Alias: csMicrosoftPublishing *)
 
2813
(* Name: Windows-31J *)
 
2814
(* Alias: csWindows31J *)
 
2815
(* Name: GB2312  (preferred MIME name) *)
 
2816
(* Alias: csGB2312 *)
 
2817
let () = alias "IANA/csGB2312" "GB2312"
 
2818
let () = alias "IANA/GB2312" "GB2312"
 
2819
(* Name: Big5  (preferred MIME name) *)
 
2820
(* Alias: csBig5 *)
 
2821
let () = alias "IANA/csBig5" "BIG5"
 
2822
let () = alias "IANA/Big5" "BIG5"
 
2823
(* Name: windows-1250 *)
 
2824
(* Name: windows-1251 *)
 
2825
(* Name: windows-1252 *)
 
2826
(* Name: windows-1253 *)
 
2827
(* Name: windows-1254 *)
 
2828
(* Name: windows-1255 *)
 
2829
(* Name: windows-1256 *)
 
2830
(* Name: windows-1257 *)
 
2831
(* Name: windows-1258 *)
 
2832
(* Name: TIS-620 *)
 
2833
let () = alias "IANA/TIS-620" "TIS-620"
 
2834
(* Name: HZ-GB-2312 *)