7비트 ASCII 코드표 만들기 예제 with OCaml

ASCII(애스키)란 American Standard Code for Information Interchange의 줄임글로서, 영문자에 기초한 문자 인코딩이다.  이 문자 인코딩에는 C0 제어문자(C0 control character)도 포함되어 있다.  ( 참고:  ASCII - Wikipedia, the free encyclopedia )

다음은  7bit ASCII 코드표를 만들어 보여주는 OCaml 소스 코드이다. 소스 코드 중에 진법변환에 필요한 함수

                atoi string  radix
                itoa number radix

를 OCaml 코드로 자체 작성하여 사용하였다.

(아래의 소스는 Python 소스를 F# 소스로 일대일 변환 수정하고, 또 F# 소스를 OCaml 소스로 바꾼 것이라서 명령형 언어 특징을 위주로 작성되어 있다. 그래서 함수형 언어의 관점으로 보면 사이드 이팩트가 많아 난잡하게 보이는 소스이다.)

1. (*
2.  *  Filename: makeAsciiTable.ml
3.  *            Make a table of ascii codes.
4.  *
5.  *  Execute: ocaml makeAsciiTable.ml
6.  *
7.  *    Or
8.  *
9.  *  Compile: ocamlc -o makeAsciiTable.exe makeAsciiTable.ml
10.  *  Execute: makeAsciiTable
11.  *
12.  *      Date:  20013. 1. 29.
13.  *    Author:  pkim __AT__ scripts.pe.kr
14.  *)
16. open Printf;;
18. exception RuntimeError of string
19. exception ValueError of string
21. let println s = printf "%s\n" s ;;
23. let print s = printf "%s" s ;;
25. let printUsage() =
26.     println "Usage: makeAsciiTable" ;
27.     println "Make a table of ascii codes." ;;
29. let split_char sep str =
30.   let rec indices acc i =
31.     try
32.       let i = succ(String.index_from str i sep) in
33.       indices (i::acc) i
34.     with Not_found ->
35.       (String.length str + 1) :: acc
36.   in
37.   let is = indices [0] 0 in
38.   let rec aux acc = function
39.     | last::start::tl ->
40.         let w = String.sub str start (last-start-1) in
41.         aux (w::acc) (start::tl)
42.     | _ -> acc
43.   in
44.   aux [] is ;;
46. let sBASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"  ;;
48. let rec sdup str n =
49.         match n with
50.         | 0 -> ""
51.         | k when k > 0 -> str ^ (sdup str (n - 1))
52.         | _ -> ""
54. let contains s1 s2 =
55.   try
56.     let len = String.length s2 in
57.     for i = 0 to (String.length s1) - len do
58.       if String.sub s1 i len = s2 then raise Exit
59.     done;
60.     false
61.   with Exit -> true ;;
63. let join list sep =
64.     let rec join' list acc =
65.         match list with
66.             | [] -> ""
67.             | [single] -> single
68.             | one::[two] ->
69.                         if acc = "" then one ^ sep ^ two
70.                                     else acc ^ one ^ sep ^ two
71.             | first::others -> join' others (acc ^ first ^ ", ")
72.                                         in
73.                                         join' list "" ;;
75. let str_reverse str =
76.     let len = String.length str in
77.     let res = String.create len in
78.     for i = 0 to pred len do
79.         let j = pred len - i in
80.         res.[i] <- str.[j]
81.     done;
82.     res ;;
84. let itoa num radix =
85.    let isNegative = ref false in
86.    let num1 = num + 0 in
87.    let numx = ref num1 in
89.    if num < 0 then begin
90.       isNegative := true ;
91.       numx := (-num)
92.    end ;
94.    let nnumx = !numx in
96.    let q1 = nnumx in
97.    let q = ref q1 in
98.    let r = ref 0 in
99.    let slen = ref 1 in
101.    while (!q >= radix) do
102.        r := !q mod radix ;
103.        q := !q / radix ;
104.        slen := !slen + 1
105.    done ;
107.    let sslen = !slen in
108.    let str = String.create sslen in
109.    let p1 = nnumx in
110.    let p = ref p1 in
112.    for i = 0 to sslen - 1 do
113.        r := !p mod radix ;
114.        p := !p / radix ;
115.        str.[i] <- sBASE36.[!r]
116.    done ;
118.    let str2 = str_reverse str in
119.    str2;;
121. let atoi s radix =
122.     let ret = ref 0 in
123.     let isNegative = ref false in
124.     let len = String.length s in
125.     let valx = ref 0 in
126.     let c1 = s.[0] in
127.     let c = ref c1 in
129.     if !c = '-' then
130.         isNegative := true
131.     else if (!c >= '0' && !c <= '9') then
132.         ret := (int_of_char !c) - (int_of_char '0')
133.     else if (!c >= 'A' && !c <= 'Z') then
134.         ret := (int_of_char !c) - (int_of_char 'A') + 10
135.     else if (!c >= 'a' && !c <= 'z') then
136.         ret := (int_of_char !c) - (int_of_char 'a') + 10 ;
137.     if (!ret >= radix) then
138.         raise (ValueError (sprintf "Can not read \"%s\" (as radix %d): '%c' is invalid." s radix !c ) ) ;
140.     for i = 1 to len - 1 do
141.         c := s.[i] ;
142.         ret := (!ret)*radix  ;
143.         if (!c >= '0' && !c <= '9') then
144.             valx := int_of_char !c - int_of_char '0' 
145.         else if (!c >= 'A' && !c <= 'Z') then
146.             valx := int_of_char !c - int_of_char 'A' + 10
147.         else if (!c >= 'a' && !c <= 'z') then
148.             valx := int_of_char !c - int_of_char 'a' + 10 ;
149.         if (!valx >= radix) then
150.             raise (ValueError (sprintf "Can not read \"%s\" (as radix %d): '%c' is invalid." s radix !c ) ) ;
151.         ret := (!ret) + (!valx)
152.     done;
154.     if (!isNegative) then
155.         ret := (-(!ret) ) ;
156.     !ret ;;
159. let asc = [|
160.     "NUL"; "SOH"; "STX"; "ETX"; "EOT";
161.     "ENQ"; "ACK"; "BEL"; "BS"; "HT";
162.     "LF"; "VT"; "FF"; "CR"; "SO";
163.     "SI"; "DLE"; "DC1"; "DC2"; "DC3";
164.     "DC4"; "NAK"; "SYN"; "ETB"; "CAN";
165.     "EM"; "SUB"; "ESC"; "FS"; "GS";
166.     "RS"; "US"; "Spc" |] ;;
168. let control = [|
169.     "NUL (null)";
170.     "SOH (start of heading)";
171.     "STX (start of text)";
172.     "ETX (end of text)";
173.     "EOT (end of transmission)";
174.     "ENQ (enquiry)";
175.     "ACK (acknowledge)";
176.     "BEL (bell)";
177.     "BS  (backspace)";
178.     "TAB (horizontal tab)";
179.     "LF  (line feed, NL new line)";
180.     "VT  (vertical tab)";
181.     "FF  (form feed, NP new page)";
182.     "CR  (carriage return)";
183.     "SO  (shift out)";
184.     "SI  (shift in)";
185.     "DLE (data link escape)";
186.     "DC1 (device control 1)";
187.     "DC2 (device control 2)";
188.     "DC3 (device control 3)";
189.     "DC4 (device control 4)";
190.     "NAK (negative acknowledge)";
191.     "SYN (synchronous idle)";
192.     "ETB (end of trans. block)";
193.     "CAN (cancel)";
194.     "EM  (end of medium)";
195.     "SUB (substitute, EOF end of file)";
196.     "ESC (escape)";
197.     "FS  (file separator)";
198.     "GS  (group separator)";
199.     "RS  (record separator)";
200.     "US  (unit separator)" |] ;;
203. let makeTable() =
204.     let sbuf = "    " in
205.     let sbuf = sbuf ^ (sdup "+----" 8) in
206.     let sbuf = sbuf ^  "+" in
207.     println sbuf ;
209.     let sbuf = "    " in
210.     let sbuf = sbuf ^  "| 0- " in
211.     let sbuf = sbuf ^  "| 1- " in
212.     let sbuf = sbuf ^  "| 2- " in
213.     let sbuf = sbuf ^  "| 3- " in
214.     let sbuf = sbuf ^  "| 4- " in
215.     let sbuf = sbuf ^  "| 5- " in
216.     let sbuf = sbuf ^  "| 6- " in
217.     let sbuf = sbuf ^  "| 7- " in
218.     let sbuf = sbuf ^  "|" in
219.     println sbuf  ;
221.     let sbuf = "+---" in
222.     let sbuf = sbuf ^ (sdup "+----" 8) in
223.     let sbuf = sbuf ^  "+" in
224.     println sbuf ;
226.     let aa = Array.make_matrix 16 8 "" in
227.     for i = 0 to (16-1) do
228.         let sbuf = (itoa i 16) in
229.         let tbuf = "| " ^ sbuf ^ " " in
230.         print tbuf ;
231.         for j = 0 to (8-1) do
232.            if j*16 + i <= 32 then
233.                aa.(i).(j) <- sprintf "| %-3s" asc.(j*16 + i)
234.             else if j*16 + i = 127 then
235.                 aa.(i).(j) <- sprintf  "| %-3s" "DEL"
236.             else begin
237.                let c = char_of_int (j*16 + i) in
238.                 aa.(i).(j) <- sprintf "|  %1c " c
239.             end ;
240.             print aa.(i).(j)
241.         done;
242.         println "|"
243.     done ;
245.     let sbuf = "+---" in
246.     let sbuf = sbuf ^ (sdup "+----"  8) in
247.     let sbuf = sbuf ^ "+" in
248.     println sbuf ;
249.     println "" ;
251.     for i = 0 to (16-1) do
252.         let tbuf = sprintf "%-30s  %-34s" control.(i) control.(i+16) in
253.         println tbuf
254.     done ;
255.     "" ;;
258. (* Begin here *)
259. let main() =
260.     let cmdArgs = Sys.argv in
261.     if (Array.length cmdArgs > 1 && "-h" = cmdArgs.(1)) then  begin
262.         printUsage() ;
263.         exit(1)
264.     end ;
265.     makeTable() ;;
267. main() ;;
     

컴파일> ocamlc -o makeAsciiTable.exe makeAsciiTable.ml

실행> makeAsciiTable

   
    +----+----+----+----+----+----+----+----+
    | 0- | 1- | 2- | 3- | 4- | 5- | 6- | 7- |
+---+----+----+----+----+----+----+----+----+
| 0 | NUL| DLE| Spc|  0 |  @ |  P |  ` |  p |
| 1 | SOH| DC1|  ! |  1 |  A |  Q |  a |  q |
| 2 | STX| DC2|  " |  2 |  B |  R |  b |  r |
| 3 | ETX| DC3|  # |  3 |  C |  S |  c |  s |
| 4 | EOT| DC4|  $ |  4 |  D |  T |  d |  t |
| 5 | ENQ| NAK|  % |  5 |  E |  U |  e |  u |
| 6 | ACK| SYN|  & |  6 |  F |  V |  f |  v |
| 7 | BEL| ETB|  ' |  7 |  G |  W |  g |  w |
| 8 | BS | CAN|  ( |  8 |  H |  X |  h |  x |
| 9 | HT | EM |  ) |  9 |  I |  Y |  i |  y |
| A | LF | SUB|  * |  : |  J |  Z |  j |  z |
| B | VT | ESC|  + |  ; |  K |  [ |  k |  { |
| C | FF | FS |  , |  < |  L |  \ |  l |  | |
| D | CR | GS |  - |  = |  M |  ] |  m |  } |
| E | SO | RS |  . |  > |  N |  ^ |  n |  ~ |
| F | SI | US |  / |  ? |  O |  _ |  o | DEL|
+---+----+----+----+----+----+----+----+----+

NUL (null)                      DLE (data link escape)
SOH (start of heading)          DC1 (device control 1)
STX (start of text)             DC2 (device control 2)
ETX (end of text)               DC3 (device control 3)
EOT (end of transmission)       DC4 (device control 4)
ENQ (enquiry)                   NAK (negative acknowledge)
ACK (acknowledge)               SYN (synchronous idle)
BEL (bell)                      ETB (end of trans. block)
BS  (backspace)                 CAN (cancel)
TAB (horizontal tab)            EM  (end of medium)
LF  (line feed, NL new line)    SUB (substitute, EOF end of file)
VT  (vertical tab)              ESC (escape)
FF  (form feed, NP new page)    FS  (file separator)
CR  (carriage return)           GS  (group separator)
SO  (shift out)                 RS  (record separator)
SI  (shift in)                  US  (unit separator)