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

프로그래밍/Go 2012. 6. 25. 19:44

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

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

        convertAtoI()
        convertItoA()

의 구현도 포함되어 있다.



  1. /*
  2.  *  Filename: makeAsciiTable.go
  3.  *            Make a table of ascii codes.
  4.  *
  5.  *  Execute: go run makeAsciiTable.go
  6.  *
  7.  *  or
  8.  *
  9.  *  Compile: go build makeAsciiTable.go
  10.  *  Execute: ./makeAsciiTable
  11.  *
  12.  *      Date:  2012/06/25
  13.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
  14.  */
  16. package main
  18. import (
  19.     "fmt"
  20.     "os"
  21. )   
  23. func println(s string) {
  24.     fmt.Printf("%s\n", s)
  25. }
  27. func print(s string) {
  28.     fmt.Printf("%s", s)
  29. }
  31. func printUsage() {
  32.     println("Usage: makeAsciiTable")
  33.     println("Make a table of ascii codes.")
  34. }
  36. func convertItoA(num int64, radix int) (ret string) {
  37.     var BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  38.     var tmp string
  39.     var arr string
  40.     var q, r int64
  41.     var i, n int
  42.     var isNegative bool = false
  44.     if num < 0 {
  45.         isNegative = true
  46.         num = -num
  47.     }
  48.     arr = ""
  49.     q = num
  50.     r = 0
  52.     for q >= int64(radix) {
  53.         r = q % int64(radix)
  54.         q = q / int64(radix)
  55.         tmp = BASE36[r:r+1]
  56.         arr += tmp
  57.     }
  58.     tmp = BASE36[q:q+1]
  59.     arr += tmp
  60.     if isNegative {
  61.         arr += "-"
  62.     }
  64.     n = len(arr)
  65.     for i = 0; i < n; i++ {
  66.         ret += arr[n - i - 1:n-i]
  67.     }
  68.     return ret
  69. }
  71. func convertAtoI(str string, radix int) (ret int64) {
  72.     var isNegative bool = false
  73.     var len int = len(str)
  74.     var c byte
  75.     var i int
  76.     var val int64
  78.     c = str[0]
  79.     if c == '-' { 
  80.         isNegative = true
  81.     } else if c >= '0' && c <= '9' {
  82.         ret = int64(c) - int64('0');
  83.     } else if c >= 'A' && c <= 'Z' {
  84.         ret = int64(c - 'A') + 10
  85.     } else if c >= 'a' && c <= 'z' {
  86.         ret = int64(c - 'a') + 10;
  87.     }
  88.     if ret >= int64(radix) {
  89.         println("        Invalid character!")
  90.         return ret
  91.     }
  93.     for i = 1; i < len; i++ {
  94.         c = str[i]
  95.         ret *= int64(radix)
  96.         if c >= '0' && c <= '9' {
  97.             val = int64(c - '0')
  98.         } else if c >= 'A' && c <= 'Z' {
  99.             val = int64(c - 'A') + 10
  100.         } else if c >= 'a' && c <= 'z' {
  101.             val = int64(c - 'a') + 10
  102.         }
  103.         if val >= int64(radix) {
  104.             println("        Invalid character!")
  105.             return ret
  106.         }
  107.         ret += val
  108.     }
  110.     if isNegative {
  111.         ret = -ret
  112.     }
  114.     return ret
  115. }
  117. func makeTable() {
  118.      var asc = [...] string {
  119.      "NUL", "SOH", "STX", "ETX", "EOT",
  120.      "ENQ", "ACK", "BEL", "BS", "HT",
  121.      "LF", "VT", "FF", "CR", "SO",
  122.      "SI", "DLE", "DC1", "DC2", "DC3",
  123.      "DC4", "NAK", "SYN", "ETB", "CAN",
  124.      "EM", "SUB", "ESC", "FS", "GS",
  125.      "RS", "US", "Spc"  }
  127.     var control = [...]string{
  128.         "NUL (null)",
  129.         "SOH (start of heading)",
  130.         "STX (start of text)",
  131.         "ETX (end of text)",
  132.         "EOT (end of transmission)",
  133.         "ENQ (enquiry)",
  134.         "ACK (acknowledge)",
  135.         "BEL (bell)",
  136.         "BS  (backspace)",
  137.         "TAB (horizontal tab)",
  138.         "LF  (line feed, NL new line)",
  139.         "VT  (vertical tab)",
  140.         "FF  (form feed, NP new page)",
  141.         "CR  (carriage return)",
  142.         "SO  (shift out)",
  143.         "SI  (shift in)",
  144.         "DLE (data link escape)",
  145.         "DC1 (device control 1)",
  146.         "DC2 (device control 2)",
  147.         "DC3 (device control 3)",
  148.         "DC4 (device control 4)",
  149.         "NAK (negative acknowledge)",
  150.         "SYN (synchronous idle)",
  151.         "ETB (end of trans. block)",
  152.         "CAN (cancel)",
  153.         "EM  (end of medium)",
  154.         "SUB (substitute, EOF end of file)",
  155.         "ESC (escape)",
  156.         "FS  (file separator)",
  157.         "GS  (group separator)",
  158.         "RS  (record separator)",
  159.         "US  (unit separator)"   }
  161.     var sbuf, abuf, tbuf string
  162.     var i, j int
  163.     var c byte
  165.     print("    ");
  166.     for i = 0; i < 8; i++ {
  167.         print("+----")
  168.     }
  169.     print("+")
  170.     println("")
  172.     print("    ")
  173.     print("| 0- ");
  174.     print("| 1- ");
  175.     print("| 2- ");
  176.     print("| 3- ");
  177.     print("| 4- ");
  178.     print("| 5- ");
  179.     print("| 6- ");
  180.     print("| 7- ");
  181.     print("|")
  182.     println("")
  184.     print("+---")
  185.     for i = 0; i < 8; i++ {
  186.         print("+----")
  187.     }
  188.     print("+")
  189.     println("")
  191.     for i = 0; i < 16; i++ {
  192.         tbuf = ""
  193.         sbuf = convertItoA(int64(i), 16)
  194.         tbuf += "| "
  195.         tbuf += sbuf
  196.         tbuf += " "
  197.         for j = 0; j < 8; j++ {
  198.             if j*16 + i <= 32 {
  199.                 abuf = fmt.Sprintf("| %-3s", asc[j*16 + i])
  200.             } else if (j*16 + i == 127) {
  201.                 abuf = fmt.Sprintf("| %-3s", "DEL")
  202.             } else {
  203.                 c = byte(j*16 + i)
  204.                 abuf = fmt.Sprintf("| %2c ", c);
  205.             }
  206.             tbuf += abuf
  207.         }
  208.         tbuf += "|"
  209.         println(tbuf)
  210.     }
  212.     print("+---")
  213.     for i = 0; i < 8; i++ {
  214.         print("+----")
  215.     }
  216.     print("+")
  217.     println("")
  218.     println("")
  220.     for i = 0; i < 16; i++ {
  221.         sbuf = fmt.Sprintf("%-30s",  control[i])
  222.         tbuf = fmt.Sprintf("  %-34s",  control[i+16])
  223.         print(sbuf)
  224.         println(tbuf)
  225.     }
  226. }
  228. func main() {
  229.     if len(os.Args) > 1 &&  os.Args[1] == "-h" {
  230.         printUsage()
  231.         os.Exit(1)
  232.     }
  233.     makeTable()
  234. }




실행> go run makeAsciiTable.go

또는

컴파일> go build makeAsciiTable.go

실행> ./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)



 

'프로그래밍 > Go' 카테고리의 다른 글

Go 언어로 3제곱근, 4제곱근, n제곱근 구하기  (0) 2012.06.27
삼각형 출력 예제를 통한 여러 가지 소스 비교 with Go  (0) 2012.06.26
진법(radix) 표 만들기 예제 with Go  (0) 2012.06.25
대화형 모드의 진법(radix) 변환 예제 with Go  (0) 2012.06.22
황금비율(golden ratio) 구하기 with Go  (0) 2012.06.20
Posted by Scripter
,

티스토리툴바