대화형 모드의 진법(radix) 변환 예제 with C and Ch

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 C 소스 코드이다.
(Ch를 이용하면 컴파일 하지 않고 소스를 그대로 실행시킬 수 있다.)
메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환을 하는 핵심 함수 convertAtoI()와 convertItoA()의 소스가 자체 제작되어 포함되어 있다. 이를 이용하는 부분은 153~154째 줄에 있는

         val = convertAtoI(s, srcRdx);
         convertItoA((char *) ret, val, destRdx);

이다. 지원되는 진법은 2진법에서 36진법 까지이다.

1. /*
2.  *  Filename: convertRadix.c
3.  *            Convert radix in a interactive mode.
4.  *
5.  *  Compile: cl convertRadix.c
6.  *  Execute: convertRadix
7.  *
8.  *      Date:  2008/03/25
9.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
10.  */
12. #include <stdio.h>
13. #include <string.h>
14. #include <math.h>
16. #define MAX_BUF 300
18. enum { FALSE, TRUE };
20. struct _TOKEN {
21.     char a[81];
22.     char b[81];
23. };
25. void println(char s[]) {
26.     printf("%s\n", s);
27. }
29. void print(char s[]) {
30.     printf("%s", s);
31. }
33. void printUsage() {
34.     println("Usage: convertRadix");
35.     println("Convert radix in a interactive mode, where the maximum radix is 36.");
36. }
38. void printAbout() {
39.     println("    About: Convert radix in a interactive mode.");
40. }
42. void printMainMenu() {
43.     println("  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it");
44. }
46. void printMainPrompt() {
47.     print("  Prompt> ");
48. }
50. void printSubMenu(int srcRadix, int destRadix) {
51.     char sbuf[MAX_BUF];
52.     sprintf(sbuf, "    Convert Radix_%d to Radix_%d", srcRadix, destRadix);
53.     println(sbuf);
54.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit");
55. }
57. void printSubPrompt() {
58.     print("    Input Value>> ");
59. }
61. char BASE36[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
63. void convertItoA(char *pstr, long num, int radix) {
64.     char tmp[2];
65.     char ret[MAX_BUF];
66.     char arr[MAX_BUF];
67.     long q, r;
68.     int i, n;
69.     int isNegative = FALSE;
70.     if (num < 0L) {
71.         isNegative = TRUE;
72.         num = -num;
73.     }
74.     arr[0] = '\0';
75.     q = num;
76.     r = 0L;
78.     while (q >= (long) radix) {
79.         r = q % (long) radix;
80.         q = q / (long) radix;
81.         tmp[0] = BASE36[r];
82.         tmp[1] = '\0';
83.         strcat(arr, tmp);
84.     }
85.     tmp[0] = BASE36[q];
86.     tmp[1] = '\0';
87.     strcat(arr, tmp);
88.     if (isNegative) {
89.         strcat(arr, "-");
90.     }
92.     n = strlen(arr);
93.     for (i = 0; i < n; i++) {
94.         ret[i] = arr[n - i - 1];
95.     }
96.     ret[n] = '\0';
97.     strcpy(pstr, (char *) ret);
98. }
100. long convertAtoI(const char *pstr, int radix) {
101.     long ret = 0L;
102.     char arr[MAX_BUF];
103.     long q, r;
104.     int isNegative = FALSE;
105.     int len = strlen(pstr);
106.     char c;
107.     int i;
108.     long val;
110.     c = pstr[0];
111.     if (c == '-') {
112.         isNegative = TRUE;
113.     }
114.     else if (c >= '0' && c <= '9') {
115.         ret = (long) (c - '0');
116.     }
117.     else if (c >= 'A' && c <= 'Z') {
118.         ret = (long) (c - 'A') + 10L;
119.     }
120.     else if (c >= 'a' && c <= 'z') {
121.         ret = (long) (c - 'a') + 10L;
122.     }
123.     if (ret >= (long) radix) {
124.         println("        Invalid character!");
125.         return ret;
126.     }
128.     for (i = 1; i < len; i++) {
129.         c = pstr[i];
130.         ret *= radix;
131.         if (c >= '0' && c <= '9') {
132.             val = (long) (c - '0');
133.         }
134.         else if (c >= 'A' && c <= 'Z') {
135.             val = (long) (c - 'A') + 10L;
136.         }
137.         else if (c >= 'a' && c <= 'z') {
138.             val = (long) (c - 'a') + 10L;
139.         }
140.         if (val >= (long) radix) {
141.             println("        Invalid character!");
142.             return ret;
143.         }
144.         ret += val;
145.     }
147.     return ret;
148. }
150. void convertRadix(char *pstr, char s[],  int srcRdx, int destRdx) {
151.     long val;
152.     char ret[MAX_BUF];
153.     val = convertAtoI(s, srcRdx);
154.     convertItoA((char *) ret, val, destRdx);
155.     strcpy(pstr, ret);
156. }
158. void readLine(char *pdata) {
159.     scanf("%s", pdata);
160. }
162. void readTwo(struct _TOKEN *ptoken) {
163.     scanf("%s", ptoken->a);
164.     scanf("%s", ptoken->b);
165. }
167. void tokenize(struct _TOKEN *ptoken, const char *line, char c) {
168.     int len = strlen(line);
169.     int i;
170.     int from, to;
172.     i = 0;
173.     while (line[i] != c) {
174.         i++;
175.     }
176.     from = i;
177.     while (line[i] == c) {
178.         i++;
179.     }
180.     to = i;
181.     strncpy(ptoken->a, line, to - from);
182.     ptoken->a[to - from] = '\0';
183.     while (line[i] != c) {
184.         i++;
185.     }
186.     from = i;
187.     while (line[i] == c) {
188.         i++;
189.     }
190.     to = i;
191.     strncpy(ptoken->b, line, to - from);
192.     ptoken->b[to - from] = '\0';
193. }
195. void doConvert(int srcRadix, int destRadix) {
196.     char sbuf[MAX_BUF];
197.     char line[MAX_BUF];
198.     char cmd[MAX_BUF];
199.     char srcStr[MAX_BUF], destStr[MAX_BUF];
200.     long tmp;
202.     println("");
203.     printSubMenu(srcRadix, destRadix);
205.     do {
206.         printSubPrompt();
207.         readLine((char *)cmd);
208.         while (strlen(cmd) <= 0) {
209.             readLine((char *)cmd);
210.         }
212.         if (strcmp("main()", cmd) == 0) {
213.             return;
214.         }
215.         else if (strcmp("exit()", cmd) == 0 || strcmp("quit()", cmd) == 0) {
216.             exit(0);
217.         }
219.         tmp = convertAtoI(cmd, srcRadix);
220.         strcpy(srcStr, cmd);
221.         convertRadix(destStr, srcStr, srcRadix, destRadix);
222.         sprintf(sbuf, "        ( %s )_%d   --->   ( %s )_%d", srcStr, srcRadix, destStr, destRadix);
223.         println(sbuf);
224.         println("");
225.     } while (TRUE);
226. }
228. void doStart() {
229.     char line[MAX_BUF];
230.     char cmd[MAX_BUF];
231.     int srcRadix = 10, destRadix = 10;
232.     char srcStr[MAX_BUF], destStr[MAX_BUF];
233.     struct _TOKEN st;
234.     int onlyOnce = TRUE;
236.     do {
237.         println("");
238.         if (onlyOnce) {
239.             println("  The supported maximum radix is 36.");
240.             onlyOnce = FALSE;
241.         }
243.         printMainMenu();
244.         printMainPrompt();
246.         readLine((char *)cmd);
247.         while (strlen(cmd) <= 0) {
248.             readLine((char *)cmd);
249.         }
251.         if (strstr("qQxX", cmd) != NULL && strlen(cmd) == 1) {
252.             exit(0);
253.         }
254.         else if (strstr("aA", cmd) != NULL && strlen(cmd) == 1) {
255.             printAbout();
256.         }
257.         else if (strstr("sS", cmd) != NULL && strlen(cmd) == 1) {
258.             print("  Input the source and target radices (say, 16 2): ");
259.             readTwo((struct _TOKEN *) &st);
260.             srcRadix = convertAtoI(st.a, 10);
261.             destRadix = convertAtoI(st.b, 10);
262.             doConvert(srcRadix, destRadix);
263.         }
264.     } while (TRUE);
265. }
267. void main(int argc, char *argv[]) {
268.     if (argc > 1 && strcmp("-h", argv[1]) == 0) {
269.         printUsage();
270.         exit(1);
271.     }
272.     doStart();
273. }

컴파일> cl convertRadix.c

실행> convertRadix

  The supported maximum radix is 36.
  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 8 16

    Convert Radix_8 to Radix_16
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 1234
        ( 1234 )_8   --->   ( 29C )_16

    Input Value>> main()

  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 16 8

    Convert Radix_16 to Radix_8
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 29c
        ( 29c )_16   --->   ( 1234 )_8

    Input Value>> exit()