免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
› 论坛 › 程序设计 › C/C++ › Linux 下实现计算器程序，高手请进！！
123下一页
最近访问板块 发新帖
楼主: toddytao
打印 上一主题 下一主题

Linux 下实现计算器程序，高手请进！！ [复制链接]

cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
11楼 [报告]
发表于 2011-08-09 14:46 |只看该作者
增加：阿拉伯数字解析，增加英文多项运算符后的“with”解析。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 if (decade_yes && digit == 0) {
  208.                         return -1;
  209.                 }
  210.                 value += digit;
  211.         }else {
  212.                 if (!decade_yes) {
  213.                         return -1;
  214.                 }
  215.         }
  216.         *o_value = value;
  217.         *io_index = index;
  218.         return 0;
  219. }

  221. int get_digit_base(const char *p, int *io_index, int *o_base)
  222. {
  223.         static const char *more[] = {
  224.                 "hundred",
  225.                 "thousand",
  226.                 "million",
  227.                 "billion",
  228.         };
  229.         static const int base[] = {
  230.                 100,
  231.                 1000,
  232.                 1000000,
  233.                 1000000000,
  234.         };
  235.         int index;
  236.         int start,len;
  237.         int retn;

  239.         if (p == NULL || io_index == NULL || o_base == NULL) {
  240.                 return -1;
  241.         }
  242.         index = *io_index;
  243.         if (index < 0) {
  244.                 return -1;
  245.         }
  246.         skip_space(p, &index);
  247.         if (get_word(p, &index, &start, &len) == 0) {
  248.                 retn = get_token(p + start, len, more, 4);
  249.                 if (retn != -1) {
  250.                         *o_base = base[retn];
  251.                         *io_index = index;
  252.                         return 0;
  253.                 }
  254.         }
  255.         return -1;
  256. }

  258. int get_english_digit(const char *p, int *io_index, int *o_value)
  259. {
  260.         int index;
  261.         int value;
  262.         int sum;
  263.         int base;

  265.         if (p == NULL || io_index == NULL || o_value == NULL) {
  266.                 return -1;
  267.         }
  268.         index = *io_index;
  269.         if (index < 0) {
  270.                 return -1;
  271.         }
  272.         sum = 0;
  273.         for (;;) {
  274.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  275.                         if (sum > 0 && value == 0) {
  276.                                 return -1;
  277.                         }
  278.                         sum += value;
  279.                         if (get_digit_base(p, &index, &base) == 0) {
  280.                                 if (sum == 0) {
  281.                                         return -1;
  282.                                 }
  283.                                 sum *= base;
  284.                                 if (skip_word(p, &index, "and") == 0) {
  285.                                         continue;
  286.                                 }
  287.                         }
  288.                         *o_value = sum;
  289.                         *io_index = index;
  290.                         return 0;
  291.                 }else if (sum == 0) {
  292.                         if (skip_word(p, &index, "a") == 0) {
  293.                                 if (get_digit_base(p, &index, &base) == 0) {
  294.                                         sum = base;
  295.                                         if (skip_word(p, &index, "and") == 0) {
  296.                                                 continue;
  297.                                         }
  298.                                         *o_value = sum;
  299.                                         *io_index = index;
  300.                                         return 0;
  301.                                 }
  302.                         }
  303.                 }
  304.                 return -1;
  305.         }
  306. }

  308. int get_operator1(const char *p, int *io_index, int *o_op)
  309. {
  310.         static const char *op_list[] = {
  311.                 "positive",
  312.                 "+",
  313.                 "negative",
  314.                 "-",
  315.         };
  316.         int index;
  317.         int start, len;
  318.         int retn;
  319.        
  320.         if (p == NULL || io_index == NULL || o_op == NULL) {
  321.                 return -1;
  322.         }
  323.         index = *io_index;
  324.         if (index < 0) {
  325.                 return -1;
  326.         }
  327.         skip_space(p, &index);
  328.         if (get_word(p, &index, &start, &len) == 0) {
  329.                 retn = get_token(p + start, len, op_list, 8);
  330.                 if (retn != -1) {
  331.                         *o_op = retn / 2;
  332.                         *io_index = index;
  333.                         return 0;
  334.                 }
  335.         }
  336.         return -1;
  337. }

  339. int get_operator2(const char *p, int *io_index, int *o_op)
  340. {
  341.         static const char *op_list[] = {
  342.                 "plus",
  343.                 "+",
  344.                 "minus",
  345.                 "-",
  346.                 "multiply",
  347.                 "*",
  348.                 "divide",
  349.                 "/",
  350.         };
  351.         int index;
  352.         int start, len;
  353.         int retn;

  355.         if (p == NULL || io_index == NULL || o_op == NULL) {
  356.                 return -1;
  357.         }
  358.         index = *io_index;
  359.         if (index < 0) {
  360.                 return -1;
  361.         }
  362.         skip_space(p, &index);
  363.         if (get_word(p, &index, &start, &len) == 0) {
  364.                 retn = get_token(p + start, len, op_list, 8);
  365.                 if (retn != -1) {
  366.                         if ((retn & 1) == 0) {
  367.                                 skip_word(p, &index, "with");
  368.                         }
  369.                         *o_op = retn / 2;
  370.                         *io_index = index;
  371.                         return 0;
  372.                 }
  373.         }
  374.         return -1;
  375. }

  377. int get_number(const char *p, int *io_index, int *o_value)
  378. {
  379.         int index;
  380.         int value;
  381.         int negative;

  383.         if (p == NULL || io_index == NULL || o_value == NULL) {
  384.                 return -1;
  385.         }
  386.         index = *io_index;
  387.         if (index < 0) {
  388.                 return -1;
  389.         }
  390.         value = 0;
  391.         negative = 0;
  392.         skip_space(p, &index);
  393.         if (p[index] == '-') {
  394.                 ++index;
  395.                 negative = 1;
  396.         }else if (p[index] == '+') {
  397.                 ++index;
  398.         }
  399.         skip_space(p, &index);
  400.         if (isdigit(p[index])) {
  401.                 value = 0;
  402.                 do {
  403.                         value = value * 10 + p[index] - '0';
  404.                         index++;
  405.                 }while (isdigit(p[index]));
  406.                 if (negative) {
  407.                         value = - value;
  408.                 }
  409.                 *o_value = value;
  410.                 *io_index = index;
  411.                 return 0;
  412.         }
  413.         return -1;
  414. }

  416. int get_digit(const char *p, int *io_index, int *o_value)
  417. {
  418.         int index;
  419.         int value;

  421.         if (p == NULL || io_index == NULL || o_value == NULL) {
  422.                 return -1;
  423.         }
  424.         index = *io_index;
  425.         if (index < 0) {
  426.                 return -1;
  427.         }
  428.         if (get_english_digit(p, &index, &value) == 0
  429.                 || get_number(p, &index, &value) == 0) {
  430.                 *o_value = value;
  431.                 *io_index = index;
  432.                 return 0;
  433.         }
  434.         return -1;
  435. }

  437. int main(void)
  438. {
  439.         char cmd_line[1024];
  440.         int op; /* operator */
  441.         int d1, d2; /* oprand number */
  442.         int result; /* store the expression result */
  443.         int index;

  445.         puts("English Caculator\n");
  446.         puts("Please enter an expression");
  447.         puts("CTRL-Z to exit");
  448.         for (;;) {
  449.                 printf("\n: ");
  450.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  451.                         return 0;
  452.                 }
  453.                 index = 0;
  454.                 if (get_digit(cmd_line, &index, &d1) == 0) {
  455.                         /* two oprands operation */
  456.                         if (get_operator2(cmd_line, &index, &op) != 0) {
  457.                                 printf("Invalid Operator\n");
  458.                                 continue;
  459.                         }
  460.                         if (get_digit(cmd_line, &index, &d2) != 0) {
  461.                                 printf("Invalid English Number\n");
  462.                                 continue;
  463.                         }
  464.                         switch (op) {
  465.                         case 0:
  466.                                 result = d1 + d2;
  467.                                 break;
  468.                         case 1:
  469.                                 result = d1 - d2;
  470.                                 break;
  471.                         case 2:
  472.                                 result = d1 * d2;
  473.                                 break;
  474.                         case 3:
  475.                                 result = d1 / d2;
  476.                                 break;
  477.                         default:
  478.                                 printf("unknown operator\n");
  479.                                 continue;
  480.                         }
  481.                 }else {
  482.                         /* one oprand operation */
  483.                         if (get_operator1(cmd_line, &index, &op) != 0) {
  484.                                 printf("Invalid Operator\n");
  485.                                 continue;
  486.                         }
  487.                         if (get_digit(cmd_line, &index, &d1) != 0) {
  488.                                 printf("Invalid English Number\n");
  489.                                 continue;
  490.                         }
  491.                         switch (op) {
  492.                         case 0:
  493.                                 result = d1;
  494.                                 break;
  495.                         case 1:
  496.                                 result = -d1;
  497.                                 break;
  498.                         default:
  499.                                 printf("unknown operator\n");
  500.                                 continue;
  501.                         }
  502.                 }
  503.                 printf("%d\n", result);
  504.         }
  505. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
12楼 [报告]
发表于 2011-08-09 15:01 |只看该作者
支持级联表达式运算，优先级与计算器相同，从左到右。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 if (decade_yes && digit == 0) {
  208.                         return -1;
  209.                 }
  210.                 value += digit;
  211.         }else {
  212.                 if (!decade_yes) {
  213.                         return -1;
  214.                 }
  215.         }
  216.         *o_value = value;
  217.         *io_index = index;
  218.         return 0;
  219. }

  221. int get_digit_base(const char *p, int *io_index, int *o_base)
  222. {
  223.         static const char *more[] = {
  224.                 "hundred",
  225.                 "thousand",
  226.                 "million",
  227.                 "billion",
  228.         };
  229.         static const int base[] = {
  230.                 100,
  231.                 1000,
  232.                 1000000,
  233.                 1000000000,
  234.         };
  235.         int index;
  236.         int start,len;
  237.         int retn;

  239.         if (p == NULL || io_index == NULL || o_base == NULL) {
  240.                 return -1;
  241.         }
  242.         index = *io_index;
  243.         if (index < 0) {
  244.                 return -1;
  245.         }
  246.         skip_space(p, &index);
  247.         if (get_word(p, &index, &start, &len) == 0) {
  248.                 retn = get_token(p + start, len, more, 4);
  249.                 if (retn != -1) {
  250.                         *o_base = base[retn];
  251.                         *io_index = index;
  252.                         return 0;
  253.                 }
  254.         }
  255.         return -1;
  256. }

  258. int get_english_digit(const char *p, int *io_index, int *o_value)
  259. {
  260.         int index;
  261.         int value;
  262.         int sum;
  263.         int base;

  265.         if (p == NULL || io_index == NULL || o_value == NULL) {
  266.                 return -1;
  267.         }
  268.         index = *io_index;
  269.         if (index < 0) {
  270.                 return -1;
  271.         }
  272.         sum = 0;
  273.         for (;;) {
  274.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  275.                         if (sum > 0 && value == 0) {
  276.                                 return -1;
  277.                         }
  278.                         sum += value;
  279.                         if (get_digit_base(p, &index, &base) == 0) {
  280.                                 if (sum == 0) {
  281.                                         return -1;
  282.                                 }
  283.                                 sum *= base;
  284.                                 if (skip_word(p, &index, "and") == 0) {
  285.                                         continue;
  286.                                 }
  287.                         }
  288.                         *o_value = sum;
  289.                         *io_index = index;
  290.                         return 0;
  291.                 }else if (sum == 0) {
  292.                         if (skip_word(p, &index, "a") == 0) {
  293.                                 if (get_digit_base(p, &index, &base) == 0) {
  294.                                         sum = base;
  295.                                         if (skip_word(p, &index, "and") == 0) {
  296.                                                 continue;
  297.                                         }
  298.                                         *o_value = sum;
  299.                                         *io_index = index;
  300.                                         return 0;
  301.                                 }
  302.                         }
  303.                 }
  304.                 return -1;
  305.         }
  306. }

  308. int get_operator1(const char *p, int *io_index, int *o_op)
  309. {
  310.         static const char *op_list[] = {
  311.                 "positive",
  312.                 "+",
  313.                 "negative",
  314.                 "-",
  315.         };
  316.         int index;
  317.         int start, len;
  318.         int retn;
  319.        
  320.         if (p == NULL || io_index == NULL || o_op == NULL) {
  321.                 return -1;
  322.         }
  323.         index = *io_index;
  324.         if (index < 0) {
  325.                 return -1;
  326.         }
  327.         skip_space(p, &index);
  328.         if (get_word(p, &index, &start, &len) == 0) {
  329.                 retn = get_token(p + start, len, op_list, 8);
  330.                 if (retn != -1) {
  331.                         *o_op = retn / 2;
  332.                         *io_index = index;
  333.                         return 0;
  334.                 }
  335.         }
  336.         return -1;
  337. }

  339. int get_operator2(const char *p, int *io_index, int *o_op)
  340. {
  341.         static const char *op_list[] = {
  342.                 "plus",
  343.                 "+",
  344.                 "minus",
  345.                 "-",
  346.                 "multiply",
  347.                 "*",
  348.                 "divide",
  349.                 "/",
  350.         };
  351.         int index;
  352.         int start, len;
  353.         int retn;

  355.         if (p == NULL || io_index == NULL || o_op == NULL) {
  356.                 return -1;
  357.         }
  358.         index = *io_index;
  359.         if (index < 0) {
  360.                 return -1;
  361.         }
  362.         skip_space(p, &index);
  363.         if (get_word(p, &index, &start, &len) == 0) {
  364.                 retn = get_token(p + start, len, op_list, 8);
  365.                 if (retn != -1) {
  366.                         if ((retn & 1) == 0) {
  367.                                 skip_word(p, &index, "with");
  368.                         }
  369.                         *o_op = retn / 2;
  370.                         *io_index = index;
  371.                         return 0;
  372.                 }
  373.         }
  374.         return -1;
  375. }

  377. int get_number(const char *p, int *io_index, int *o_value)
  378. {
  379.         int index;
  380.         int value;

  382.         if (p == NULL || io_index == NULL || o_value == NULL) {
  383.                 return -1;
  384.         }
  385.         index = *io_index;
  386.         if (index < 0) {
  387.                 return -1;
  388.         }
  389.         skip_space(p, &index);
  390.         if (isdigit(p[index])) {
  391.                 value = 0;
  392.                 do {
  393.                         value = value * 10 + p[index] - '0';
  394.                         index++;
  395.                 }while (isdigit(p[index]));
  396.                 *o_value = value;
  397.                 *io_index = index;
  398.                 return 0;
  399.         }
  400.         return -1;
  401. }

  403. int get_digit(const char *p, int *io_index, int *o_value)
  404. {
  405.         int index;
  406.         int value;

  408.         if (p == NULL || io_index == NULL || o_value == NULL) {
  409.                 return -1;
  410.         }
  411.         index = *io_index;
  412.         if (index < 0) {
  413.                 return -1;
  414.         }
  415.         if (get_english_digit(p, &index, &value) == 0
  416.                 || get_number(p, &index, &value) == 0) {
  417.                 *o_value = value;
  418.                 *io_index = index;
  419.                 return 0;
  420.         }
  421.         return -1;
  422. }

  424. int main(void)
  425. {
  426.         char cmd_line[1024];
  427.         int op; /* operator */
  428.         int d1, d2; /* oprand number */
  429.         int result; /* store the expression result */
  430.         int index;

  432.         puts("English Caculator\n");
  433.         puts("Please enter an expression");
  434.         puts("CTRL-Z to exit");
  435.         for (;;) {
  436.                 printf("\n: ");
  437.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  438.                         return 0;
  439.                 }
  440.                 index = 0;
  441.                 if (get_digit(cmd_line, &index, &d1) == -1) {
  442.                         /* one oprand operation */
  443.                         if (get_operator1(cmd_line, &index, &op) != 0) {
  444.                                 printf("Invalid Operator\n");
  445.                                 continue;
  446.                         }
  447.                         if (get_digit(cmd_line, &index, &d1) != 0) {
  448.                                 printf("Invalid English Number\n");
  449.                                 continue;
  450.                         }
  451.                         switch (op) {
  452.                         case 0:
  453.                                 result = d1;
  454.                                 break;
  455.                         case 1:
  456.                                 result = -d1;
  457.                                 break;
  458.                         default:
  459.                                 printf("unknown operator\n");
  460.                                 continue;
  461.                         }
  462.                         d1 = result;
  463.                 }
  464.                 /* conjunction operation */
  465.                 for (;;) {
  466.                         /* two oprands operation */
  467.                         if (get_operator2(cmd_line, &index, &op) != 0) {
  468.                                 printf("%d\n", result);
  469.                                 break; /* end of conjunction */
  470.                         }
  471.                         if (get_digit(cmd_line, &index, &d2) != 0) {
  472.                                 printf("Invalid English Number\n");
  473.                                 break;
  474.                         }
  475.                         switch (op) {
  476.                         case 0:
  477.                                 result = d1 + d2;
  478.                                 break;
  479.                         case 1:
  480.                                 result = d1 - d2;
  481.                                 break;
  482.                         case 2:
  483.                                 result = d1 * d2;
  484.                                 break;
  485.                         case 3:
  486.                                 result = d1 / d2;
  487.                                 break;
  488.                         default:
  489.                                 printf("unknown operator\n");
  490.                                 continue;
  491.                         }
  492.                         d1 = result;
  493.                 }
  494.         }
  495. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
13楼 [报告]
发表于 2011-08-09 15:13 |只看该作者
支持单项运算作为运算操作数。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 if (decade_yes && digit == 0) {
  208.                         return -1;
  209.                 }
  210.                 value += digit;
  211.         }else {
  212.                 if (!decade_yes) {
  213.                         return -1;
  214.                 }
  215.         }
  216.         *o_value = value;
  217.         *io_index = index;
  218.         return 0;
  219. }

  221. int get_digit_base(const char *p, int *io_index, int *o_base)
  222. {
  223.         static const char *more[] = {
  224.                 "hundred",
  225.                 "thousand",
  226.                 "million",
  227.                 "billion",
  228.         };
  229.         static const int base[] = {
  230.                 100,
  231.                 1000,
  232.                 1000000,
  233.                 1000000000,
  234.         };
  235.         int index;
  236.         int start,len;
  237.         int retn;

  239.         if (p == NULL || io_index == NULL || o_base == NULL) {
  240.                 return -1;
  241.         }
  242.         index = *io_index;
  243.         if (index < 0) {
  244.                 return -1;
  245.         }
  246.         skip_space(p, &index);
  247.         if (get_word(p, &index, &start, &len) == 0) {
  248.                 retn = get_token(p + start, len, more, 4);
  249.                 if (retn != -1) {
  250.                         *o_base = base[retn];
  251.                         *io_index = index;
  252.                         return 0;
  253.                 }
  254.         }
  255.         return -1;
  256. }

  258. int get_english_digit(const char *p, int *io_index, int *o_value)
  259. {
  260.         int index;
  261.         int value;
  262.         int sum;
  263.         int base;

  265.         if (p == NULL || io_index == NULL || o_value == NULL) {
  266.                 return -1;
  267.         }
  268.         index = *io_index;
  269.         if (index < 0) {
  270.                 return -1;
  271.         }
  272.         sum = 0;
  273.         for (;;) {
  274.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  275.                         if (sum > 0 && value == 0) {
  276.                                 return -1;
  277.                         }
  278.                         sum += value;
  279.                         if (get_digit_base(p, &index, &base) == 0) {
  280.                                 if (sum == 0) {
  281.                                         return -1;
  282.                                 }
  283.                                 sum *= base;
  284.                                 if (skip_word(p, &index, "and") == 0) {
  285.                                         continue;
  286.                                 }
  287.                         }
  288.                         *o_value = sum;
  289.                         *io_index = index;
  290.                         return 0;
  291.                 }else if (sum == 0) {
  292.                         if (skip_word(p, &index, "a") == 0) {
  293.                                 if (get_digit_base(p, &index, &base) == 0) {
  294.                                         sum = base;
  295.                                         if (skip_word(p, &index, "and") == 0) {
  296.                                                 continue;
  297.                                         }
  298.                                         *o_value = sum;
  299.                                         *io_index = index;
  300.                                         return 0;
  301.                                 }
  302.                         }
  303.                 }
  304.                 return -1;
  305.         }
  306. }

  308. int get_operator1(const char *p, int *io_index, int *o_op)
  309. {
  310.         static const char *op_list[] = {
  311.                 "positive",
  312.                 "+",
  313.                 "negative",
  314.                 "-",
  315.         };
  316.         int index;
  317.         int start, len;
  318.         int retn;
  319.        
  320.         if (p == NULL || io_index == NULL || o_op == NULL) {
  321.                 return -1;
  322.         }
  323.         index = *io_index;
  324.         if (index < 0) {
  325.                 return -1;
  326.         }
  327.         skip_space(p, &index);
  328.         if (get_word(p, &index, &start, &len) == 0) {
  329.                 retn = get_token(p + start, len, op_list, 8);
  330.                 if (retn != -1) {
  331.                         *o_op = retn / 2;
  332.                         *io_index = index;
  333.                         return 0;
  334.                 }
  335.         }
  336.         return -1;
  337. }

  339. int get_operator2(const char *p, int *io_index, int *o_op)
  340. {
  341.         static const char *op_list[] = {
  342.                 "plus",
  343.                 "+",
  344.                 "minus",
  345.                 "-",
  346.                 "multiply",
  347.                 "*",
  348.                 "divide",
  349.                 "/",
  350.         };
  351.         int index;
  352.         int start, len;
  353.         int retn;

  355.         if (p == NULL || io_index == NULL || o_op == NULL) {
  356.                 return -1;
  357.         }
  358.         index = *io_index;
  359.         if (index < 0) {
  360.                 return -1;
  361.         }
  362.         skip_space(p, &index);
  363.         if (get_word(p, &index, &start, &len) == 0) {
  364.                 retn = get_token(p + start, len, op_list, 8);
  365.                 if (retn != -1) {
  366.                         if ((retn & 1) == 0) {
  367.                                 skip_word(p, &index, "with");
  368.                         }
  369.                         *o_op = retn / 2;
  370.                         *io_index = index;
  371.                         return 0;
  372.                 }
  373.         }
  374.         return -1;
  375. }

  377. int get_number(const char *p, int *io_index, int *o_value)
  378. {
  379.         int index;
  380.         int value;

  382.         if (p == NULL || io_index == NULL || o_value == NULL) {
  383.                 return -1;
  384.         }
  385.         index = *io_index;
  386.         if (index < 0) {
  387.                 return -1;
  388.         }
  389.         skip_space(p, &index);
  390.         if (isdigit(p[index])) {
  391.                 value = 0;
  392.                 do {
  393.                         value = value * 10 + p[index] - '0';
  394.                         index++;
  395.                 }while (isdigit(p[index]));
  396.                 *o_value = value;
  397.                 *io_index = index;
  398.                 return 0;
  399.         }
  400.         return -1;
  401. }

  403. int get_digit(const char *p, int *io_index, int *o_value)
  404. {
  405.         int index;
  406.         int value;

  408.         if (p == NULL || io_index == NULL || o_value == NULL) {
  409.                 return -1;
  410.         }
  411.         index = *io_index;
  412.         if (index < 0) {
  413.                 return -1;
  414.         }
  415.         if (get_english_digit(p, &index, &value) == 0
  416.                 || get_number(p, &index, &value) == 0) {
  417.                 *o_value = value;
  418.                 *io_index = index;
  419.                 return 0;
  420.         }
  421.         return -1;
  422. }

  424. int get_oprand(const char *p, int *io_index, int *o_value)
  425. {
  426.         int index;
  427.         int op;
  428.         int d1;
  429.         int result;

  431.         if (p == NULL || io_index == NULL || o_value == NULL) {
  432.                 return -1;
  433.         }
  434.         index = *io_index;
  435.         if (index < 0) {
  436.                 return -1;
  437.         }
  438.         /* one oprand operation */
  439.         if (get_operator1(p, &index, &op) == 0) {
  440.                 if (get_digit(p, &index, &d1) != 0) {
  441.                         return -1;
  442.                 }
  443.                 switch (op) {
  444.                 case 0:
  445.                         result = d1;
  446.                         break;
  447.                 case 1:
  448.                         result = -d1;
  449.                         break;
  450.                 default:
  451.                         return -1;
  452.                 }
  453.         }else {
  454.                 if (get_digit(p, &index, &result) != 0) {
  455.                         return -1;
  456.                 }
  457.         }
  458.         *o_value = result;
  459.         *io_index = index;
  460.         return 0;
  461. }

  463. int main(void)
  464. {
  465.         char cmd_line[1024];
  466.         int op; /* operator */
  467.         int d1, d2; /* oprand number */
  468.         int result; /* store the expression result */
  469.         int index;

  471.         puts("English Caculator\n");
  472.         puts("Please enter an expression");
  473.         puts("CTRL-Z to exit");
  474.         for (;;) {
  475.                 printf("\n: ");
  476.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  477.                         return 0;
  478.                 }
  479.                 index = 0;
  480.                 if (get_oprand(cmd_line, &index, &result) == -1) {
  481.                         printf("Invalid Expression\n");
  482.                         continue;
  483.                 }
  484.                 /* conjunction operation */
  485.                 for (;;) {
  486.                         /* two oprands operation */
  487.                         d1 = result;
  488.                         if (get_operator2(cmd_line, &index, &op) != 0) {
  489.                                 printf("%d\n", result);
  490.                                 break; /* end of conjunction */
  491.                         }
  492.                         if (get_oprand(cmd_line, &index, &d2) == -1) {
  493.                                 printf("Invalid Expression\n");
  494.                                 break;
  495.                         }
  496.                         switch (op) {
  497.                         case 0:
  498.                                 result = d1 + d2;
  499.                                 break;
  500.                         case 1:
  501.                                 result = d1 - d2;
  502.                                 break;
  503.                         case 2:
  504.                                 result = d1 * d2;
  505.                                 break;
  506.                         case 3:
  507.                                 result = d1 / d2;
  508.                                 break;
  509.                         default:
  510.                                 printf("unknown operator\n");
  511.                                 continue;
  512.                         }
  513.                 }
  514.         }
  515. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
14楼 [报告]
发表于 2011-08-09 15:50 |只看该作者
调整输出，以适应命令行重定向输入。可输入表达式文件。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 if (decade_yes && digit == 0) {
  208.                         return -1;
  209.                 }
  210.                 value += digit;
  211.         }else {
  212.                 if (!decade_yes) {
  213.                         return -1;
  214.                 }
  215.         }
  216.         *o_value = value;
  217.         *io_index = index;
  218.         return 0;
  219. }

  221. int get_digit_base(const char *p, int *io_index, int *o_base)
  222. {
  223.         static const char *more[] = {
  224.                 "hundred",
  225.                 "thousand",
  226.                 "million",
  227.                 "billion",
  228.         };
  229.         static const int base[] = {
  230.                 100,
  231.                 1000,
  232.                 1000000,
  233.                 1000000000,
  234.         };
  235.         int index;
  236.         int start,len;
  237.         int retn;

  239.         if (p == NULL || io_index == NULL || o_base == NULL) {
  240.                 return -1;
  241.         }
  242.         index = *io_index;
  243.         if (index < 0) {
  244.                 return -1;
  245.         }
  246.         skip_space(p, &index);
  247.         if (get_word(p, &index, &start, &len) == 0) {
  248.                 retn = get_token(p + start, len, more, 4);
  249.                 if (retn != -1) {
  250.                         *o_base = base[retn];
  251.                         *io_index = index;
  252.                         return 0;
  253.                 }
  254.         }
  255.         return -1;
  256. }

  258. int get_english_digit(const char *p, int *io_index, int *o_value)
  259. {
  260.         int index;
  261.         int value;
  262.         int sum;
  263.         int base;

  265.         if (p == NULL || io_index == NULL || o_value == NULL) {
  266.                 return -1;
  267.         }
  268.         index = *io_index;
  269.         if (index < 0) {
  270.                 return -1;
  271.         }
  272.         sum = 0;
  273.         for (;;) {
  274.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  275.                         if (sum > 0 && value == 0) {
  276.                                 return -1;
  277.                         }
  278.                         sum += value;
  279.                         if (get_digit_base(p, &index, &base) == 0) {
  280.                                 if (sum == 0) {
  281.                                         return -1;
  282.                                 }
  283.                                 sum *= base;
  284.                                 if (skip_word(p, &index, "and") == 0) {
  285.                                         continue;
  286.                                 }
  287.                         }
  288.                         *o_value = sum;
  289.                         *io_index = index;
  290.                         return 0;
  291.                 }else if (sum == 0) {
  292.                         if (skip_word(p, &index, "a") == 0) {
  293.                                 if (get_digit_base(p, &index, &base) == 0) {
  294.                                         sum = base;
  295.                                         if (skip_word(p, &index, "and") == 0) {
  296.                                                 continue;
  297.                                         }
  298.                                         *o_value = sum;
  299.                                         *io_index = index;
  300.                                         return 0;
  301.                                 }
  302.                         }
  303.                 }
  304.                 return -1;
  305.         }
  306. }

  308. int get_operator1(const char *p, int *io_index, int *o_op)
  309. {
  310.         static const char *op_list[] = {
  311.                 "positive",
  312.                 "+",
  313.                 "negative",
  314.                 "-",
  315.         };
  316.         int index;
  317.         int start, len;
  318.         int retn;
  319.        
  320.         if (p == NULL || io_index == NULL || o_op == NULL) {
  321.                 return -1;
  322.         }
  323.         index = *io_index;
  324.         if (index < 0) {
  325.                 return -1;
  326.         }
  327.         skip_space(p, &index);
  328.         if (get_word(p, &index, &start, &len) == 0) {
  329.                 retn = get_token(p + start, len, op_list, 8);
  330.                 if (retn != -1) {
  331.                         *o_op = retn / 2;
  332.                         *io_index = index;
  333.                         return 0;
  334.                 }
  335.         }
  336.         return -1;
  337. }

  339. int get_operator2(const char *p, int *io_index, int *o_op)
  340. {
  341.         static const char *op_list[] = {
  342.                 "plus",
  343.                 "+",
  344.                 "minus",
  345.                 "-",
  346.                 "multiply",
  347.                 "*",
  348.                 "divide",
  349.                 "/",
  350.         };
  351.         int index;
  352.         int start, len;
  353.         int retn;

  355.         if (p == NULL || io_index == NULL || o_op == NULL) {
  356.                 return -1;
  357.         }
  358.         index = *io_index;
  359.         if (index < 0) {
  360.                 return -1;
  361.         }
  362.         skip_space(p, &index);
  363.         if (get_word(p, &index, &start, &len) == 0) {
  364.                 retn = get_token(p + start, len, op_list, 8);
  365.                 if (retn != -1) {
  366.                         if ((retn & 1) == 0) {
  367.                                 skip_word(p, &index, "with");
  368.                         }
  369.                         *o_op = retn / 2;
  370.                         *io_index = index;
  371.                         return 0;
  372.                 }
  373.         }
  374.         return -1;
  375. }

  377. int get_number(const char *p, int *io_index, int *o_value)
  378. {
  379.         int index;
  380.         int value;

  382.         if (p == NULL || io_index == NULL || o_value == NULL) {
  383.                 return -1;
  384.         }
  385.         index = *io_index;
  386.         if (index < 0) {
  387.                 return -1;
  388.         }
  389.         skip_space(p, &index);
  390.         if (isdigit(p[index])) {
  391.                 value = 0;
  392.                 do {
  393.                         value = value * 10 + p[index] - '0';
  394.                         index++;
  395.                 }while (isdigit(p[index]));
  396.                 *o_value = value;
  397.                 *io_index = index;
  398.                 return 0;
  399.         }
  400.         return -1;
  401. }

  403. int get_digit(const char *p, int *io_index, int *o_value)
  404. {
  405.         int index;
  406.         int value;

  408.         if (p == NULL || io_index == NULL || o_value == NULL) {
  409.                 return -1;
  410.         }
  411.         index = *io_index;
  412.         if (index < 0) {
  413.                 return -1;
  414.         }
  415.         if (get_english_digit(p, &index, &value) == 0
  416.                 || get_number(p, &index, &value) == 0) {
  417.                 *o_value = value;
  418.                 *io_index = index;
  419.                 return 0;
  420.         }
  421.         return -1;
  422. }

  424. int get_oprand(const char *p, int *io_index, int *o_value)
  425. {
  426.         int index;
  427.         int op;
  428.         int d1;
  429.         int result;

  431.         if (p == NULL || io_index == NULL || o_value == NULL) {
  432.                 return -1;
  433.         }
  434.         index = *io_index;
  435.         if (index < 0) {
  436.                 return -1;
  437.         }
  438.         /* one oprand operation */
  439.         if (get_operator1(p, &index, &op) == 0) {
  440.                 if (get_digit(p, &index, &d1) != 0) {
  441.                         return -1;
  442.                 }
  443.                 switch (op) {
  444.                 case 0:
  445.                         result = d1;
  446.                         break;
  447.                 case 1:
  448.                         result = -d1;
  449.                         break;
  450.                 default:
  451.                         return -1;
  452.                 }
  453.         }else {
  454.                 if (get_digit(p, &index, &result) != 0) {
  455.                         return -1;
  456.                 }
  457.         }
  458.         *o_value = result;
  459.         *io_index = index;
  460.         return 0;
  461. }

  463. int strrtrim(char *p)
  464. {
  465.         int len;

  467.         if (p == NULL) {
  468.                 return -1;
  469.         }
  470.         len = strlen(p);
  471.         if (len > 0) {
  472.                 if (isspace(p[len - 1])) {
  473.                         do {
  474.                                 --len;
  475.                         }while(len >= 0 && isspace(p[len]));
  476.                         p[len + 1] = '\0';
  477.                 }
  478.         }
  479.         return 0;
  480. }

  482. int strtrim(char *p)
  483. {
  484.         int i;

  486.         if (p == NULL) {
  487.                 return -1;
  488.         }
  489.         for (i = 0; p[i] != '\0'; ++i) {
  490.                 if (!isspace(p[i])) {
  491.                         break;
  492.                 }
  493.         }
  494.         strcpy(p, p + i);
  495.         return 0;
  496. }

  498. int main(void)
  499. {
  500.         char cmd_line[1024];
  501.         int op; /* operator */
  502.         int d1, d2; /* oprand number */
  503.         int result; /* store the expression result */
  504.         int index;

  506.         puts("English Caculator\n");
  507.         puts("Enter an expression");
  508.         puts("CTRL-Z to exit\n");
  509.         for (;;) {
  510.                 printf(": ");
  511.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  512.                         return 0;
  513.                 }
  514.                 strrtrim(cmd_line);
  515.                 strtrim(cmd_line);
  516.                 index = 0;
  517.                 if (get_oprand(cmd_line, &index, &result) == -1) {
  518.                         printf("'%s' = E, Invalid Expression\n", cmd_line);
  519.                         continue;
  520.                 }
  521.                 /* conjunction operation */
  522.                 for (;;) {
  523.                         /* two oprands operation */
  524.                         d1 = result;
  525.                         if (get_operator2(cmd_line, &index, &op) != 0) {
  526.                                 printf("'%s' = %d\n", cmd_line, result);
  527.                                 break; /* end of conjunction */
  528.                         }
  529.                         if (get_oprand(cmd_line, &index, &d2) == -1) {
  530.                                 printf("'%s' = E, Invalid Expression\n", cmd_line);
  531.                                 break;
  532.                         }
  533.                         switch (op) {
  534.                         case 0:
  535.                                 result = d1 + d2;
  536.                                 break;
  537.                         case 1:
  538.                                 result = d1 - d2;
  539.                                 break;
  540.                         case 2:
  541.                                 result = d1 * d2;
  542.                                 break;
  543.                         case 3:
  544.                                 result = d1 / d2;
  545.                                 break;
  546.                         default:
  547.                                 printf("'%s' = E, Unknown Operator \n", cmd_line);
  548.                                 continue;
  549.                         }
  550.                 }
  551.         }
  552. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
15楼 [报告]
发表于 2011-08-09 15:57 |只看该作者
小改动

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 if (decade_yes && digit == 0) {
  208.                         return -1;
  209.                 }
  210.                 value += digit;
  211.         }else {
  212.                 if (!decade_yes) {
  213.                         return -1;
  214.                 }
  215.         }
  216.         *o_value = value;
  217.         *io_index = index;
  218.         return 0;
  219. }

  221. int get_digit_base(const char *p, int *io_index, int *o_base)
  222. {
  223.         static const char *more[] = {
  224.                 "hundred",
  225.                 "thousand",
  226.                 "million",
  227.                 "billion",
  228.         };
  229.         static const int base[] = {
  230.                 100,
  231.                 1000,
  232.                 1000000,
  233.                 1000000000,
  234.         };
  235.         int index;
  236.         int start,len;
  237.         int retn;

  239.         if (p == NULL || io_index == NULL || o_base == NULL) {
  240.                 return -1;
  241.         }
  242.         index = *io_index;
  243.         if (index < 0) {
  244.                 return -1;
  245.         }
  246.         skip_space(p, &index);
  247.         if (get_word(p, &index, &start, &len) == 0) {
  248.                 retn = get_token(p + start, len, more, 4);
  249.                 if (retn != -1) {
  250.                         *o_base = base[retn];
  251.                         *io_index = index;
  252.                         return 0;
  253.                 }
  254.         }
  255.         return -1;
  256. }

  258. int get_english_digit(const char *p, int *io_index, int *o_value)
  259. {
  260.         int index;
  261.         int value;
  262.         int sum;
  263.         int base;

  265.         if (p == NULL || io_index == NULL || o_value == NULL) {
  266.                 return -1;
  267.         }
  268.         index = *io_index;
  269.         if (index < 0) {
  270.                 return -1;
  271.         }
  272.         sum = 0;
  273.         for (;;) {
  274.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  275.                         if (sum > 0 && value == 0) {
  276.                                 return -1;
  277.                         }
  278.                         sum += value;
  279.                         if (get_digit_base(p, &index, &base) == 0) {
  280.                                 if (sum == 0) {
  281.                                         return -1;
  282.                                 }
  283.                                 sum *= base;
  284.                                 if (skip_word(p, &index, "and") == 0) {
  285.                                         continue;
  286.                                 }
  287.                         }
  288.                         *o_value = sum;
  289.                         *io_index = index;
  290.                         return 0;
  291.                 }else if (sum == 0) {
  292.                         if (skip_word(p, &index, "a") == 0) {
  293.                                 if (get_digit_base(p, &index, &base) == 0) {
  294.                                         sum = base;
  295.                                         if (skip_word(p, &index, "and") == 0) {
  296.                                                 continue;
  297.                                         }
  298.                                         *o_value = sum;
  299.                                         *io_index = index;
  300.                                         return 0;
  301.                                 }
  302.                         }
  303.                 }
  304.                 return -1;
  305.         }
  306. }

  308. int get_operator1(const char *p, int *io_index, int *o_op)
  309. {
  310.         static const char *op_list[] = {
  311.                 "positive",
  312.                 "+",
  313.                 "negative",
  314.                 "-",
  315.         };
  316.         int index;
  317.         int start, len;
  318.         int retn;
  319.        
  320.         if (p == NULL || io_index == NULL || o_op == NULL) {
  321.                 return -1;
  322.         }
  323.         index = *io_index;
  324.         if (index < 0) {
  325.                 return -1;
  326.         }
  327.         skip_space(p, &index);
  328.         if (get_word(p, &index, &start, &len) == 0) {
  329.                 retn = get_token(p + start, len, op_list, 8);
  330.                 if (retn != -1) {
  331.                         *o_op = retn / 2;
  332.                         *io_index = index;
  333.                         return 0;
  334.                 }
  335.         }
  336.         return -1;
  337. }

  339. int get_operator2(const char *p, int *io_index, int *o_op)
  340. {
  341.         static const char *op_list[] = {
  342.                 "plus",
  343.                 "+",
  344.                 "minus",
  345.                 "-",
  346.                 "multiply",
  347.                 "*",
  348.                 "divide",
  349.                 "/",
  350.         };
  351.         int index;
  352.         int start, len;
  353.         int retn;

  355.         if (p == NULL || io_index == NULL || o_op == NULL) {
  356.                 return -1;
  357.         }
  358.         index = *io_index;
  359.         if (index < 0) {
  360.                 return -1;
  361.         }
  362.         skip_space(p, &index);
  363.         if (get_word(p, &index, &start, &len) == 0) {
  364.                 retn = get_token(p + start, len, op_list, 8);
  365.                 if (retn != -1) {
  366.                         if ((retn & 1) == 0) {
  367.                                 skip_word(p, &index, "with");
  368.                         }
  369.                         *o_op = retn / 2;
  370.                         *io_index = index;
  371.                         return 0;
  372.                 }
  373.         }
  374.         return -1;
  375. }

  377. int get_number(const char *p, int *io_index, int *o_value)
  378. {
  379.         int index;
  380.         int value;

  382.         if (p == NULL || io_index == NULL || o_value == NULL) {
  383.                 return -1;
  384.         }
  385.         index = *io_index;
  386.         if (index < 0) {
  387.                 return -1;
  388.         }
  389.         skip_space(p, &index);
  390.         if (isdigit(p[index])) {
  391.                 value = 0;
  392.                 do {
  393.                         value = value * 10 + p[index] - '0';
  394.                         index++;
  395.                 }while (isdigit(p[index]));
  396.                 *o_value = value;
  397.                 *io_index = index;
  398.                 return 0;
  399.         }
  400.         return -1;
  401. }

  403. int get_digit(const char *p, int *io_index, int *o_value)
  404. {
  405.         int index;
  406.         int value;

  408.         if (p == NULL || io_index == NULL || o_value == NULL) {
  409.                 return -1;
  410.         }
  411.         index = *io_index;
  412.         if (index < 0) {
  413.                 return -1;
  414.         }
  415.         if (get_english_digit(p, &index, &value) == 0
  416.                 || get_number(p, &index, &value) == 0) {
  417.                 *o_value = value;
  418.                 *io_index = index;
  419.                 return 0;
  420.         }
  421.         return -1;
  422. }

  424. int get_oprand(const char *p, int *io_index, int *o_value)
  425. {
  426.         int index;
  427.         int op;
  428.         int d1;
  429.         int result;

  431.         if (p == NULL || io_index == NULL || o_value == NULL) {
  432.                 return -1;
  433.         }
  434.         index = *io_index;
  435.         if (index < 0) {
  436.                 return -1;
  437.         }
  438.         /* one oprand operation */
  439.         if (get_operator1(p, &index, &op) == 0) {
  440.                 if (get_digit(p, &index, &d1) != 0) {
  441.                         return -1;
  442.                 }
  443.                 switch (op) {
  444.                 case 0:
  445.                         result = d1;
  446.                         break;
  447.                 case 1:
  448.                         result = -d1;
  449.                         break;
  450.                 default:
  451.                         return -1;
  452.                 }
  453.         }else {
  454.                 if (get_digit(p, &index, &result) != 0) {
  455.                         return -1;
  456.                 }
  457.         }
  458.         *o_value = result;
  459.         *io_index = index;
  460.         return 0;
  461. }

  463. int strrtrim(char *p)
  464. {
  465.         int len;

  467.         if (p == NULL) {
  468.                 return -1;
  469.         }
  470.         len = strlen(p);
  471.         if (len > 0) {
  472.                 if (isspace(p[len - 1])) {
  473.                         do {
  474.                                 --len;
  475.                         }while(len >= 0 && isspace(p[len]));
  476.                         p[len + 1] = '\0';
  477.                 }
  478.         }
  479.         return 0;
  480. }

  482. int strtrim(char *p)
  483. {
  484.         int i;

  486.         if (p == NULL) {
  487.                 return -1;
  488.         }
  489.         for (i = 0; p[i] != '\0'; ++i) {
  490.                 if (!isspace(p[i])) {
  491.                         break;
  492.                 }
  493.         }
  494.         strcpy(p, p + i);
  495.         return 0;
  496. }

  498. int caculate(const char *line, int *o_value)
  499. {
  500.         int op; /* operator */
  501.         int d1, d2; /* oprand number */
  502.         int result; /* store the expression result */
  503.         int index;

  505.         if (line == NULL || o_value == NULL) {
  506.                 return -1;
  507.         }
  508.         index = 0;
  509.         if (get_oprand(line, &index, &result) == -1) {
  510.                 return -1;
  511.         }
  512.         /* conjunction operation */
  513.         for (;;) {
  514.                 /* two oprands operation */
  515.                 d1 = result;
  516.                 if (get_operator2(line, &index, &op) != 0) {
  517.                         *o_value = result;
  518.                         return 0; /* end of conjunction */
  519.                 }
  520.                 if (get_oprand(line, &index, &d2) == -1) {
  521.                         return -1;
  522.                 }
  523.                 switch (op) {
  524.                 case 0:
  525.                         result = d1 + d2;
  526.                         break;
  527.                 case 1:
  528.                         result = d1 - d2;
  529.                         break;
  530.                 case 2:
  531.                         result = d1 * d2;
  532.                         break;
  533.                 case 3:
  534.                         result = d1 / d2;
  535.                         break;
  536.                 default:
  537.                         return -1;
  538.                 }
  539.         }
  540. }

  542. int main(void)
  543. {
  544.         char cmd_line[1024];
  545.         int result;

  547.         puts("English Caculator\n");
  548.         puts("Enter an expression");
  549.         puts("CTRL-Z to exit\n");
  550.         for (;;) {
  551.                 printf(": ");
  552.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  553.                         return 0;
  554.                 }
  555.                 strrtrim(cmd_line);
  556.                 strtrim(cmd_line);
  557.                 if (caculate(cmd_line, &result) == 0) {
  558.                         printf("'%s' = %d\n", cmd_line, result);
  559.                 }else {
  560.                         printf("'%s' = E, Invalid Expression\n", cmd_line);
  561.                 }
  562.         }
  563. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
16楼 [报告]
发表于 2011-08-09 16:08 |只看该作者
增加零除错误判断。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 if (decade_yes && digit == 0) {
  208.                         return -1;
  209.                 }
  210.                 value += digit;
  211.         }else {
  212.                 if (!decade_yes) {
  213.                         return -1;
  214.                 }
  215.         }
  216.         *o_value = value;
  217.         *io_index = index;
  218.         return 0;
  219. }

  221. int get_digit_base(const char *p, int *io_index, int *o_base)
  222. {
  223.         static const char *more[] = {
  224.                 "hundred",
  225.                 "thousand",
  226.                 "million",
  227.                 "billion",
  228.         };
  229.         static const int base[] = {
  230.                 100,
  231.                 1000,
  232.                 1000000,
  233.                 1000000000,
  234.         };
  235.         int index;
  236.         int start,len;
  237.         int retn;

  239.         if (p == NULL || io_index == NULL || o_base == NULL) {
  240.                 return -1;
  241.         }
  242.         index = *io_index;
  243.         if (index < 0) {
  244.                 return -1;
  245.         }
  246.         skip_space(p, &index);
  247.         if (get_word(p, &index, &start, &len) == 0) {
  248.                 retn = get_token(p + start, len, more, 4);
  249.                 if (retn != -1) {
  250.                         *o_base = base[retn];
  251.                         *io_index = index;
  252.                         return 0;
  253.                 }
  254.         }
  255.         return -1;
  256. }

  258. int get_english_digit(const char *p, int *io_index, int *o_value)
  259. {
  260.         int index;
  261.         int value;
  262.         int sum;
  263.         int base;

  265.         if (p == NULL || io_index == NULL || o_value == NULL) {
  266.                 return -1;
  267.         }
  268.         index = *io_index;
  269.         if (index < 0) {
  270.                 return -1;
  271.         }
  272.         sum = 0;
  273.         for (;;) {
  274.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  275.                         if (sum > 0 && value == 0) {
  276.                                 return -1;
  277.                         }
  278.                         sum += value;
  279.                         if (get_digit_base(p, &index, &base) == 0) {
  280.                                 if (sum == 0) {
  281.                                         return -1;
  282.                                 }
  283.                                 sum *= base;
  284.                                 if (skip_word(p, &index, "and") == 0) {
  285.                                         continue;
  286.                                 }
  287.                         }
  288.                         *o_value = sum;
  289.                         *io_index = index;
  290.                         return 0;
  291.                 }else if (sum == 0) {
  292.                         if (skip_word(p, &index, "a") == 0) {
  293.                                 if (get_digit_base(p, &index, &base) == 0) {
  294.                                         sum = base;
  295.                                         if (skip_word(p, &index, "and") == 0) {
  296.                                                 continue;
  297.                                         }
  298.                                         *o_value = sum;
  299.                                         *io_index = index;
  300.                                         return 0;
  301.                                 }
  302.                         }
  303.                 }
  304.                 return -1;
  305.         }
  306. }

  308. int get_operator1(const char *p, int *io_index, int *o_op)
  309. {
  310.         static const char *op_list[] = {
  311.                 "positive",
  312.                 "+",
  313.                 "negative",
  314.                 "-",
  315.         };
  316.         int index;
  317.         int start, len;
  318.         int retn;
  319.        
  320.         if (p == NULL || io_index == NULL || o_op == NULL) {
  321.                 return -1;
  322.         }
  323.         index = *io_index;
  324.         if (index < 0) {
  325.                 return -1;
  326.         }
  327.         skip_space(p, &index);
  328.         if (get_word(p, &index, &start, &len) == 0) {
  329.                 retn = get_token(p + start, len, op_list, 8);
  330.                 if (retn != -1) {
  331.                         *o_op = retn / 2;
  332.                         *io_index = index;
  333.                         return 0;
  334.                 }
  335.         }
  336.         return -1;
  337. }

  339. int get_operator2(const char *p, int *io_index, int *o_op)
  340. {
  341.         static const char *op_list[] = {
  342.                 "plus",
  343.                 "+",
  344.                 "minus",
  345.                 "-",
  346.                 "multiply",
  347.                 "*",
  348.                 "divide",
  349.                 "/",
  350.         };
  351.         int index;
  352.         int start, len;
  353.         int retn;

  355.         if (p == NULL || io_index == NULL || o_op == NULL) {
  356.                 return -1;
  357.         }
  358.         index = *io_index;
  359.         if (index < 0) {
  360.                 return -1;
  361.         }
  362.         skip_space(p, &index);
  363.         if (get_word(p, &index, &start, &len) == 0) {
  364.                 retn = get_token(p + start, len, op_list, 8);
  365.                 if (retn != -1) {
  366.                         if ((retn & 1) == 0) {
  367.                                 skip_word(p, &index, "with");
  368.                         }
  369.                         *o_op = retn / 2;
  370.                         *io_index = index;
  371.                         return 0;
  372.                 }
  373.         }
  374.         return -1;
  375. }

  377. int get_number(const char *p, int *io_index, int *o_value)
  378. {
  379.         int index;
  380.         int value;

  382.         if (p == NULL || io_index == NULL || o_value == NULL) {
  383.                 return -1;
  384.         }
  385.         index = *io_index;
  386.         if (index < 0) {
  387.                 return -1;
  388.         }
  389.         skip_space(p, &index);
  390.         if (isdigit(p[index])) {
  391.                 value = 0;
  392.                 do {
  393.                         value = value * 10 + p[index] - '0';
  394.                         index++;
  395.                 }while (isdigit(p[index]));
  396.                 *o_value = value;
  397.                 *io_index = index;
  398.                 return 0;
  399.         }
  400.         return -1;
  401. }

  403. int get_digit(const char *p, int *io_index, int *o_value)
  404. {
  405.         int index;
  406.         int value;

  408.         if (p == NULL || io_index == NULL || o_value == NULL) {
  409.                 return -1;
  410.         }
  411.         index = *io_index;
  412.         if (index < 0) {
  413.                 return -1;
  414.         }
  415.         if (get_english_digit(p, &index, &value) == 0
  416.                 || get_number(p, &index, &value) == 0) {
  417.                 *o_value = value;
  418.                 *io_index = index;
  419.                 return 0;
  420.         }
  421.         return -1;
  422. }

  424. int get_oprand(const char *p, int *io_index, int *o_value)
  425. {
  426.         int index;
  427.         int op;
  428.         int d1;
  429.         int result;

  431.         if (p == NULL || io_index == NULL || o_value == NULL) {
  432.                 return -1;
  433.         }
  434.         index = *io_index;
  435.         if (index < 0) {
  436.                 return -1;
  437.         }
  438.         /* one oprand operation */
  439.         if (get_operator1(p, &index, &op) == 0) {
  440.                 if (get_digit(p, &index, &d1) != 0) {
  441.                         return -1;
  442.                 }
  443.                 switch (op) {
  444.                 case 0:
  445.                         result = d1;
  446.                         break;
  447.                 case 1:
  448.                         result = -d1;
  449.                         break;
  450.                 default:
  451.                         return -1;
  452.                 }
  453.         }else {
  454.                 if (get_digit(p, &index, &result) != 0) {
  455.                         return -1;
  456.                 }
  457.         }
  458.         *o_value = result;
  459.         *io_index = index;
  460.         return 0;
  461. }

  463. int strrtrim(char *p)
  464. {
  465.         int len;

  467.         if (p == NULL) {
  468.                 return -1;
  469.         }
  470.         len = strlen(p);
  471.         if (len > 0) {
  472.                 if (isspace(p[len - 1])) {
  473.                         do {
  474.                                 --len;
  475.                         }while(len >= 0 && isspace(p[len]));
  476.                         p[len + 1] = '\0';
  477.                 }
  478.         }
  479.         return 0;
  480. }

  482. int strtrim(char *p)
  483. {
  484.         int i;

  486.         if (p == NULL) {
  487.                 return -1;
  488.         }
  489.         for (i = 0; p[i] != '\0'; ++i) {
  490.                 if (!isspace(p[i])) {
  491.                         break;
  492.                 }
  493.         }
  494.         strcpy(p, p + i);
  495.         return 0;
  496. }

  498. int caculate(const char *line, int *o_value)
  499. {
  500.         int op; /* operator */
  501.         int d1, d2; /* oprand number */
  502.         int result; /* store the expression result */
  503.         int index;

  505.         if (line == NULL || o_value == NULL) {
  506.                 return -1;
  507.         }
  508.         index = 0;
  509.         if (get_oprand(line, &index, &result) == -1) {
  510.                 return -1;
  511.         }
  512.         /* conjunction operation */
  513.         for (;;) {
  514.                 /* two oprands operation */
  515.                 d1 = result;
  516.                 if (get_operator2(line, &index, &op) != 0) {
  517.                         *o_value = result;
  518.                         return 0; /* end of conjunction */
  519.                 }
  520.                 if (get_oprand(line, &index, &d2) == -1) {
  521.                         return -1;
  522.                 }
  523.                 switch (op) {
  524.                 case 0:
  525.                         result = d1 + d2;
  526.                         break;
  527.                 case 1:
  528.                         result = d1 - d2;
  529.                         break;
  530.                 case 2:
  531.                         result = d1 * d2;
  532.                         break;
  533.                 case 3:
  534.                         if (d2 == 0) {
  535.                                 return -1;
  536.                         }
  537.                         result = d1 / d2;
  538.                         break;
  539.                 default:
  540.                         return -1;
  541.                 }
  542.         }
  543. }

  545. int main(void)
  546. {
  547.         char cmd_line[1024];
  548.         int result;

  550.         puts("English Caculator\n");
  551.         puts("Enter an expression");
  552.         puts("CTRL-Z to exit\n");
  553.         for (;;) {
  554.                 printf(": ");
  555.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  556.                         return 0;
  557.                 }
  558.                 strrtrim(cmd_line);
  559.                 strtrim(cmd_line);
  560.                 if (caculate(cmd_line, &result) == 0) {
  561.                         printf("'%s' = %d\n", cmd_line, result);
  562.                 }else {
  563.                         printf("'%s' = E, Invalid Expression\n", cmd_line);
  564.                 }
  565.         }
  566. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
17楼 [报告]
发表于 2011-08-09 17:35 |只看该作者
增加支持“a hundred thousand”类型的解析。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 if (decade_yes && digit == 0) {
  208.                         return -1;
  209.                 }
  210.                 value += digit;
  211.         }else {
  212.                 if (!decade_yes) {
  213.                         return -1;
  214.                 }
  215.         }
  216.         *o_value = value;
  217.         *io_index = index;
  218.         return 0;
  219. }

  221. int get_english_digit_base(const char *p, int *io_index, int *o_base)
  222. {
  223.         static const char *more[] = {
  224.                 "hundred",
  225.                 "thousand",
  226.                 "million",
  227.                 "billion",
  228.         };
  229.         static const int base[] = {
  230.                 100,
  231.                 1000,
  232.                 1000000,
  233.                 1000000000,
  234.         };
  235.         int index;
  236.         int start,len;
  237.         int retn;

  239.         if (p == NULL || io_index == NULL || o_base == NULL) {
  240.                 return -1;
  241.         }
  242.         index = *io_index;
  243.         if (index < 0) {
  244.                 return -1;
  245.         }
  246.         skip_space(p, &index);
  247.         if (get_word(p, &index, &start, &len) == 0) {
  248.                 retn = get_token(p + start, len, more, 4);
  249.                 if (retn != -1) {
  250.                         *o_base = base[retn];
  251.                         *io_index = index;
  252.                         return 0;
  253.                 }
  254.         }
  255.         return -1;
  256. }

  258. int get_english_digit(const char *p, int *io_index, int *o_value)
  259. {
  260.         int index;
  261.         int value;
  262.         int sum;
  263.         int base;

  265.         if (p == NULL || io_index == NULL || o_value == NULL) {
  266.                 return -1;
  267.         }
  268.         index = *io_index;
  269.         if (index < 0) {
  270.                 return -1;
  271.         }
  272.         sum = 0;
  273.         for (;;) {
  274.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  275.                         if (sum > 0 && value == 0) {
  276.                                 return -1;
  277.                         }
  278.                         sum += value;
  279.                         while (get_english_digit_base(p, &index, &base) == 0) {
  280.                                 if (sum == 0) {
  281.                                         return -1;
  282.                                 }
  283.                                 sum *= base;
  284.                         }
  285.                         if (skip_word(p, &index, "and") == 0) {
  286.                                 continue;
  287.                         }
  288.                         break;
  289.                 }else if (sum == 0) {
  290.                         if (skip_word(p, &index, "a") == 0) {
  291.                                 sum = 1;
  292.                                 while (get_english_digit_base(p, &index, &base) == 0) {
  293.                                         sum *= base;
  294.                                 }
  295.                                 if (skip_word(p, &index, "and") == 0) {
  296.                                         continue;
  297.                                 }
  298.                                 break;
  299.                         }
  300.                 }
  301.                 return -1;
  302.         }
  303.         *o_value = sum;
  304.         *io_index = index;
  305.         return 0;
  306. }

  308. int get_operator1(const char *p, int *io_index, int *o_op)
  309. {
  310.         static const char *op_list[] = {
  311.                 "positive",
  312.                 "+",
  313.                 "negative",
  314.                 "-",
  315.         };
  316.         int index;
  317.         int start, len;
  318.         int retn;
  319.        
  320.         if (p == NULL || io_index == NULL || o_op == NULL) {
  321.                 return -1;
  322.         }
  323.         index = *io_index;
  324.         if (index < 0) {
  325.                 return -1;
  326.         }
  327.         skip_space(p, &index);
  328.         if (get_word(p, &index, &start, &len) == 0) {
  329.                 retn = get_token(p + start, len, op_list, 8);
  330.                 if (retn != -1) {
  331.                         *o_op = retn / 2;
  332.                         *io_index = index;
  333.                         return 0;
  334.                 }
  335.         }
  336.         return -1;
  337. }

  339. int get_operator2(const char *p, int *io_index, int *o_op)
  340. {
  341.         static const char *op_list[] = {
  342.                 "plus",
  343.                 "+",
  344.                 "minus",
  345.                 "-",
  346.                 "multiply",
  347.                 "*",
  348.                 "divide",
  349.                 "/",
  350.         };
  351.         int index;
  352.         int start, len;
  353.         int retn;

  355.         if (p == NULL || io_index == NULL || o_op == NULL) {
  356.                 return -1;
  357.         }
  358.         index = *io_index;
  359.         if (index < 0) {
  360.                 return -1;
  361.         }
  362.         skip_space(p, &index);
  363.         if (get_word(p, &index, &start, &len) == 0) {
  364.                 retn = get_token(p + start, len, op_list, 8);
  365.                 if (retn != -1) {
  366.                         if ((retn & 1) == 0) {
  367.                                 skip_word(p, &index, "with");
  368.                         }
  369.                         *o_op = retn / 2;
  370.                         *io_index = index;
  371.                         return 0;
  372.                 }
  373.         }
  374.         return -1;
  375. }

  377. int get_number(const char *p, int *io_index, int *o_value)
  378. {
  379.         int index;
  380.         int value;

  382.         if (p == NULL || io_index == NULL || o_value == NULL) {
  383.                 return -1;
  384.         }
  385.         index = *io_index;
  386.         if (index < 0) {
  387.                 return -1;
  388.         }
  389.         skip_space(p, &index);
  390.         if (isdigit(p[index])) {
  391.                 value = 0;
  392.                 do {
  393.                         value = value * 10 + p[index] - '0';
  394.                         index++;
  395.                 }while (isdigit(p[index]));
  396.                 *o_value = value;
  397.                 *io_index = index;
  398.                 return 0;
  399.         }
  400.         return -1;
  401. }

  403. int get_digit(const char *p, int *io_index, int *o_value)
  404. {
  405.         int index;
  406.         int value;

  408.         if (p == NULL || io_index == NULL || o_value == NULL) {
  409.                 return -1;
  410.         }
  411.         index = *io_index;
  412.         if (index < 0) {
  413.                 return -1;
  414.         }
  415.         if (get_english_digit(p, &index, &value) == 0
  416.                 || get_number(p, &index, &value) == 0) {
  417.                 *o_value = value;
  418.                 *io_index = index;
  419.                 return 0;
  420.         }
  421.         return -1;
  422. }

  424. int get_oprand(const char *p, int *io_index, int *o_value)
  425. {
  426.         int index;
  427.         int op;
  428.         int d1;
  429.         int result;

  431.         if (p == NULL || io_index == NULL || o_value == NULL) {
  432.                 return -1;
  433.         }
  434.         index = *io_index;
  435.         if (index < 0) {
  436.                 return -1;
  437.         }
  438.         /* one oprand operation */
  439.         if (get_operator1(p, &index, &op) == 0) {
  440.                 if (get_digit(p, &index, &d1) != 0) {
  441.                         return -1;
  442.                 }
  443.                 switch (op) {
  444.                 case 0:
  445.                         result = d1;
  446.                         break;
  447.                 case 1:
  448.                         result = -d1;
  449.                         break;
  450.                 default:
  451.                         return -1;
  452.                 }
  453.         }else {
  454.                 if (get_digit(p, &index, &result) != 0) {
  455.                         return -1;
  456.                 }
  457.         }
  458.         *o_value = result;
  459.         *io_index = index;
  460.         return 0;
  461. }

  463. int strrtrim(char *p)
  464. {
  465.         int len;

  467.         if (p == NULL) {
  468.                 return -1;
  469.         }
  470.         len = strlen(p);
  471.         if (len > 0) {
  472.                 if (isspace(p[len - 1])) {
  473.                         do {
  474.                                 --len;
  475.                         }while(len >= 0 && isspace(p[len]));
  476.                         p[len + 1] = '\0';
  477.                 }
  478.         }
  479.         return 0;
  480. }

  482. int strtrim(char *p)
  483. {
  484.         int i;

  486.         if (p == NULL) {
  487.                 return -1;
  488.         }
  489.         for (i = 0; p[i] != '\0'; ++i) {
  490.                 if (!isspace(p[i])) {
  491.                         break;
  492.                 }
  493.         }
  494.         strcpy(p, p + i);
  495.         return 0;
  496. }

  498. int get_end(const char *p, int *io_index)
  499. {
  500.         int index;

  502.         if (p == NULL || io_index == NULL) {
  503.                 return -1;
  504.         }
  505.         index = *io_index;
  506.         if (index < 0) {
  507.                 return -1;
  508.         }
  509.         skip_space(p, &index);
  510.         if (p[index] == '\0') {
  511.                 *io_index = index;
  512.                 return 0;
  513.         }
  514.         return -1;
  515. }

  517. int caculate(const char *exp, int *o_value)
  518. {
  519.         int op; /* operator */
  520.         int d1, d2; /* oprand number */
  521.         int result; /* store the expression result */
  522.         int index;

  524.         if (exp == NULL || o_value == NULL) {
  525.                 return -1;
  526.         }
  527.         index = 0;
  528.         if (get_oprand(exp, &index, &result) == -1) {
  529.                 return -1;
  530.         }
  531.         /* conjunction operation */
  532.         while (get_end(exp, &index) == -1) {
  533.                 /* two oprands operation */
  534.                 d1 = result;
  535.                 if (get_operator2(exp, &index, &op) == -1) {
  536.                         return -1;
  537.                 }
  538.                 if (get_oprand(exp, &index, &d2) == -1) {
  539.                         return -1;
  540.                 }
  541.                 switch (op) {
  542.                 case 0:
  543.                         result = d1 + d2;
  544.                         break;
  545.                 case 1:
  546.                         result = d1 - d2;
  547.                         break;
  548.                 case 2:
  549.                         result = d1 * d2;
  550.                         break;
  551.                 case 3:
  552.                         if (d2 == 0) {
  553.                                 return -1;
  554.                         }
  555.                         result = d1 / d2;
  556.                         break;
  557.                 default:
  558.                         return -1;
  559.                 }
  560.         }
  561.         *o_value = result;
  562.         return 0; /* end of conjunction */
  563. }

  565. int main(void)
  566. {
  567.         char cmd_line[1024];
  568.         int result;

  570.         puts("English Caculator");
  571.         puts("Enter an expression");
  572.         puts("Ctrl-Z to exit");
  573.         for (;;) {
  574.                 printf(": ");
  575.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  576.                         puts("");
  577.                         return 0;
  578.                 }
  579.                 strrtrim(cmd_line);
  580.                 strtrim(cmd_line);
  581.                 if (caculate(cmd_line, &result) == 0) {
  582.                         printf("\"%s\" = %d\n", cmd_line, result);
  583.                 }else {
  584.                         printf("\"%s\" = E, Invalid Expression\n", cmd_line);
  585.                 }
  586.         }
  587. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
18楼 [报告]
发表于 2011-08-10 09:53 |只看该作者
增加检测“zero and a hundred”一类的错误语法。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 if (decade_yes && digit == 0) {
  208.                         return -1;
  209.                 }
  210.                 value += digit;
  211.         }else {
  212.                 if (!decade_yes) {
  213.                         return -1;
  214.                 }
  215.         }
  216.         *o_value = value;
  217.         *io_index = index;
  218.         return 0;
  219. }

  221. int get_english_digit_base(const char *p, int *io_index, int *o_base)
  222. {
  223.         static const char *more[] = {
  224.                 "hundred",
  225.                 "thousand",
  226.                 "million",
  227.                 "billion",
  228.         };
  229.         static const int base[] = {
  230.                 100,
  231.                 1000,
  232.                 1000000,
  233.                 1000000000,
  234.         };
  235.         int index;
  236.         int start,len;
  237.         int retn;

  239.         if (p == NULL || io_index == NULL || o_base == NULL) {
  240.                 return -1;
  241.         }
  242.         index = *io_index;
  243.         if (index < 0) {
  244.                 return -1;
  245.         }
  246.         skip_space(p, &index);
  247.         if (get_word(p, &index, &start, &len) == 0) {
  248.                 retn = get_token(p + start, len, more, 4);
  249.                 if (retn != -1) {
  250.                         *o_base = base[retn];
  251.                         *io_index = index;
  252.                         return 0;
  253.                 }
  254.         }
  255.         return -1;
  256. }

  258. int get_english_digit(const char *p, int *io_index, int *o_value)
  259. {
  260.         int index;
  261.         int value;
  262.         int sum;
  263.         int base;

  265.         if (p == NULL || io_index == NULL || o_value == NULL) {
  266.                 return -1;
  267.         }
  268.         index = *io_index;
  269.         if (index < 0) {
  270.                 return -1;
  271.         }
  272.         sum = 0;
  273.         for (;;) {
  274.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  275.                         if (value == 0) {
  276.                                 if (sum > 0) {
  277.                                         return -1;
  278.                                 }
  279.                                 sum = 0;
  280.                                 break;
  281.                         }
  282.                         sum += value;
  283.                         while (get_english_digit_base(p, &index, &base) == 0) {
  284.                                 sum *= base;
  285.                         }
  286.                         if (skip_word(p, &index, "and") == 0) {
  287.                                 continue;
  288.                         }
  289.                         break;
  290.                 }else if (sum == 0) {
  291.                         if (skip_word(p, &index, "a") == 0) {
  292.                                 sum = 1;
  293.                                 while (get_english_digit_base(p, &index, &base) == 0) {
  294.                                         sum *= base;
  295.                                 }
  296.                                 if (skip_word(p, &index, "and") == 0) {
  297.                                         continue;
  298.                                 }
  299.                                 break;
  300.                         }
  301.                 }
  302.                 return -1;
  303.         }
  304.         *o_value = sum;
  305.         *io_index = index;
  306.         return 0;
  307. }

  309. int get_operator1(const char *p, int *io_index, int *o_op)
  310. {
  311.         static const char *op_list[] = {
  312.                 "positive",
  313.                 "+",
  314.                 "negative",
  315.                 "-",
  316.         };
  317.         int index;
  318.         int start, len;
  319.         int retn;
  320.        
  321.         if (p == NULL || io_index == NULL || o_op == NULL) {
  322.                 return -1;
  323.         }
  324.         index = *io_index;
  325.         if (index < 0) {
  326.                 return -1;
  327.         }
  328.         skip_space(p, &index);
  329.         if (get_word(p, &index, &start, &len) == 0) {
  330.                 retn = get_token(p + start, len, op_list, 8);
  331.                 if (retn != -1) {
  332.                         *o_op = retn / 2;
  333.                         *io_index = index;
  334.                         return 0;
  335.                 }
  336.         }
  337.         return -1;
  338. }

  340. int get_operator2(const char *p, int *io_index, int *o_op)
  341. {
  342.         static const char *op_list[] = {
  343.                 "plus",
  344.                 "+",
  345.                 "minus",
  346.                 "-",
  347.                 "multiply",
  348.                 "*",
  349.                 "divide",
  350.                 "/",
  351.         };
  352.         int index;
  353.         int start, len;
  354.         int retn;

  356.         if (p == NULL || io_index == NULL || o_op == NULL) {
  357.                 return -1;
  358.         }
  359.         index = *io_index;
  360.         if (index < 0) {
  361.                 return -1;
  362.         }
  363.         skip_space(p, &index);
  364.         if (get_word(p, &index, &start, &len) == 0) {
  365.                 retn = get_token(p + start, len, op_list, 8);
  366.                 if (retn != -1) {
  367.                         if ((retn & 1) == 0) {
  368.                                 skip_word(p, &index, "with");
  369.                         }
  370.                         *o_op = retn / 2;
  371.                         *io_index = index;
  372.                         return 0;
  373.                 }
  374.         }
  375.         return -1;
  376. }

  378. int get_number(const char *p, int *io_index, int *o_value)
  379. {
  380.         int index;
  381.         int value;

  383.         if (p == NULL || io_index == NULL || o_value == NULL) {
  384.                 return -1;
  385.         }
  386.         index = *io_index;
  387.         if (index < 0) {
  388.                 return -1;
  389.         }
  390.         skip_space(p, &index);
  391.         if (isdigit(p[index])) {
  392.                 value = 0;
  393.                 do {
  394.                         value = value * 10 + p[index] - '0';
  395.                         index++;
  396.                 }while (isdigit(p[index]));
  397.                 *o_value = value;
  398.                 *io_index = index;
  399.                 return 0;
  400.         }
  401.         return -1;
  402. }

  404. int get_digit(const char *p, int *io_index, int *o_value)
  405. {
  406.         int index;
  407.         int value;

  409.         if (p == NULL || io_index == NULL || o_value == NULL) {
  410.                 return -1;
  411.         }
  412.         index = *io_index;
  413.         if (index < 0) {
  414.                 return -1;
  415.         }
  416.         if (get_english_digit(p, &index, &value) == 0
  417.                 || get_number(p, &index, &value) == 0) {
  418.                 *o_value = value;
  419.                 *io_index = index;
  420.                 return 0;
  421.         }
  422.         return -1;
  423. }

  425. int get_oprand(const char *p, int *io_index, int *o_value)
  426. {
  427.         int index;
  428.         int op;
  429.         int d1;
  430.         int result;

  432.         if (p == NULL || io_index == NULL || o_value == NULL) {
  433.                 return -1;
  434.         }
  435.         index = *io_index;
  436.         if (index < 0) {
  437.                 return -1;
  438.         }
  439.         /* one oprand operation */
  440.         if (get_operator1(p, &index, &op) == 0) {
  441.                 if (get_digit(p, &index, &d1) != 0) {
  442.                         return -1;
  443.                 }
  444.                 switch (op) {
  445.                 case 0:
  446.                         result = d1;
  447.                         break;
  448.                 case 1:
  449.                         result = -d1;
  450.                         break;
  451.                 default:
  452.                         return -1;
  453.                 }
  454.         }else {
  455.                 if (get_digit(p, &index, &result) != 0) {
  456.                         return -1;
  457.                 }
  458.         }
  459.         *o_value = result;
  460.         *io_index = index;
  461.         return 0;
  462. }

  464. int strrtrim(char *p)
  465. {
  466.         int len;

  468.         if (p == NULL) {
  469.                 return -1;
  470.         }
  471.         len = strlen(p);
  472.         if (len > 0) {
  473.                 if (isspace(p[len - 1])) {
  474.                         do {
  475.                                 --len;
  476.                         }while(len >= 0 && isspace(p[len]));
  477.                         p[len + 1] = '\0';
  478.                 }
  479.         }
  480.         return 0;
  481. }

  483. int strtrim(char *p)
  484. {
  485.         int i;

  487.         if (p == NULL) {
  488.                 return -1;
  489.         }
  490.         for (i = 0; p[i] != '\0'; ++i) {
  491.                 if (!isspace(p[i])) {
  492.                         break;
  493.                 }
  494.         }
  495.         strcpy(p, p + i);
  496.         return 0;
  497. }

  499. int get_end(const char *p, int *io_index)
  500. {
  501.         int index;

  503.         if (p == NULL || io_index == NULL) {
  504.                 return -1;
  505.         }
  506.         index = *io_index;
  507.         if (index < 0) {
  508.                 return -1;
  509.         }
  510.         skip_space(p, &index);
  511.         if (p[index] == '\0') {
  512.                 *io_index = index;
  513.                 return 0;
  514.         }
  515.         return -1;
  516. }

  518. int caculate(const char *exp, int *o_value)
  519. {
  520.         int op; /* operator */
  521.         int d1, d2; /* oprand number */
  522.         int result; /* store the expression result */
  523.         int index;

  525.         if (exp == NULL || o_value == NULL) {
  526.                 return -1;
  527.         }
  528.         index = 0;
  529.         if (get_oprand(exp, &index, &result) == -1) {
  530.                 return -1;
  531.         }
  532.         /* conjunction operation */
  533.         while (get_end(exp, &index) == -1) {
  534.                 /* two oprands operation */
  535.                 d1 = result;
  536.                 if (get_operator2(exp, &index, &op) == -1) {
  537.                         return -1;
  538.                 }
  539.                 if (get_oprand(exp, &index, &d2) == -1) {
  540.                         return -1;
  541.                 }
  542.                 switch (op) {
  543.                 case 0:
  544.                         result = d1 + d2;
  545.                         break;
  546.                 case 1:
  547.                         result = d1 - d2;
  548.                         break;
  549.                 case 2:
  550.                         result = d1 * d2;
  551.                         break;
  552.                 case 3:
  553.                         if (d2 == 0) {
  554.                                 return -1;
  555.                         }
  556.                         result = d1 / d2;
  557.                         break;
  558.                 default:
  559.                         return -1;
  560.                 }
  561.         }
  562.         *o_value = result;
  563.         return 0; /* end of conjunction */
  564. }

  566. int main(void)
  567. {
  568.         char cmd_line[1024];
  569.         int result;

  571.         puts("English Caculator");
  572.         puts("Enter an expression");
  573.         puts("Ctrl-Z to exit");
  574.         for (;;) {
  575.                 printf(": ");
  576.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  577.                         puts("");
  578.                         return 0;
  579.                 }
  580.                 strrtrim(cmd_line);
  581.                 strtrim(cmd_line);
  582.                 if (caculate(cmd_line, &result) == 0) {
  583.                         printf("\"%s\" = %d\n", cmd_line, result);
  584.                 }else {
  585.                         printf("\"%s\" = E, Invalid Expression\n", cmd_line);
  586.                 }
  587.         }
  588. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
19楼 [报告]
发表于 2011-08-10 10:10 |只看该作者
更正“nine”和“ninety”相等的错误！！！

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int tok_len;
  64.         int i;

  66.         if (tok == NULL || tok_tab == NULL) {
  67.                 return -1;
  68.         }
  69.         if (len <= 0 || tab_len <= 0) {
  70.                 return -1;
  71.         }
  72.         for (i = 0; i < tab_len; ++i) {
  73.                 tok_len = strlen(tok_tab[i]);
  74.                 if (len == tok_len && strncmp(tok, tok_tab[i], len) == 0) {
  75.                         return i;
  76.                 }
  77.         }
  78.         return -1;
  79. }

  81. int skip_word(const char *p, int *io_index, const char *s)
  82. {
  83.         int index;
  84.         int start, len;

  86.         if (p == NULL || io_index == NULL || s == NULL) {
  87.                 return -1;
  88.         }
  89.         index = *io_index;
  90.         if (index < 0) {
  91.                 return -1;
  92.         }
  93.         skip_space(p, &index);
  94.         if (get_word(p, &index, &start, &len) == 0) {
  95.                 if (strncmp(p + start, s, len) == 0) {
  96.                         *io_index = index;
  97.                         return 0;
  98.                 }
  99.         }
  100.         return -1;
  101. }

  103. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  104. {
  105.         static const char *digit20[20] = {
  106.                 "zero",
  107.                 "one",
  108.                 "two",
  109.                 "three",
  110.                 "four",
  111.                 "five",
  112.                 "six",
  113.                 "seven",
  114.                 "eight",
  115.                 "nine",
  116.                 "ten",
  117.                 "eleven",
  118.                 "twelve",
  119.                 "thirteen",
  120.                 "fourteen",
  121.                 "fifteen",
  122.                 "sixteen",
  123.                 "seventeen",
  124.                 "eighteen",
  125.                 "nineteen",
  126.         };
  127.         int index;
  128.         int start;
  129.         int len;
  130.         int tok;

  132.         if (p == NULL || io_index == NULL || o_value == NULL) {
  133.                 return -1;
  134.         }
  135.         index = *io_index;
  136.         if (index < 0) {
  137.                 return -1;
  138.         }
  139.         skip_space(p, &index);
  140.         if (get_word(p, &index, &start, &len) == 0) {
  141.                 tok = get_token(p + start, len, digit20, 20);
  142.                 if (tok != -1) {
  143.                         *o_value = tok;
  144.                         *io_index = index;
  145.                         return 0;
  146.                 }
  147.         }
  148.         return -1;
  149. }

  151. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  152. {
  153.         static const char *decades[8] = {
  154.                 "twenty",
  155.                 "thirty",
  156.                 "forty",
  157.                 "fifty",
  158.                 "sixty",
  159.                 "seventy",
  160.                 "eighty",
  161.                 "ninety",
  162.         };
  163.         int index;
  164.         int start, len;
  165.         int value;
  166.         int retn;

  168.         if (p == NULL || io_index == NULL || o_value == NULL) {
  169.                 return -1;
  170.         }
  171.         index = *io_index;
  172.         if (index < 0) {
  173.                 return -1;
  174.         }
  175.         skip_space(p, &index);
  176.         if (get_word(p, &index, &start, &len) == 0) {
  177.                 retn = get_token(p + start, len, decades, 8);
  178.                 if (retn != -1) {
  179.                         value = retn * 10 + 20;
  180.                         *o_value = value;
  181.                         *io_index = index;
  182.                         return 0;
  183.                 }
  184.         }
  185.         return -1;
  186. }

  188. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  189. {
  190.         int index;
  191.         int value;
  192.         int digit;
  193.         int decade_yes;

  195.         if (p == NULL || io_index == NULL || o_value == NULL) {
  196.                 return -1;
  197.         }
  198.         index = *io_index;
  199.         if (index < 0) {
  200.                 return -1;
  201.         }
  202.         decade_yes = 0;
  203.         if (get_english_digit_decade(p, &index, &value) == -1) {
  204.                 value = 0;
  205.         }else {
  206.                 decade_yes = 1;
  207.         }
  208.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  209.                 if (decade_yes && digit == 0) {
  210.                         return -1;
  211.                 }
  212.                 value += digit;
  213.         }else {
  214.                 if (!decade_yes) {
  215.                         return -1;
  216.                 }
  217.         }
  218.         *o_value = value;
  219.         *io_index = index;
  220.         return 0;
  221. }

  223. int get_english_digit_base(const char *p, int *io_index, int *o_base)
  224. {
  225.         static const char *more[] = {
  226.                 "hundred",
  227.                 "thousand",
  228.                 "million",
  229.                 "billion",
  230.         };
  231.         static const int base[] = {
  232.                 100,
  233.                 1000,
  234.                 1000000,
  235.                 1000000000,
  236.         };
  237.         int index;
  238.         int start,len;
  239.         int retn;

  241.         if (p == NULL || io_index == NULL || o_base == NULL) {
  242.                 return -1;
  243.         }
  244.         index = *io_index;
  245.         if (index < 0) {
  246.                 return -1;
  247.         }
  248.         skip_space(p, &index);
  249.         if (get_word(p, &index, &start, &len) == 0) {
  250.                 retn = get_token(p + start, len, more, 4);
  251.                 if (retn != -1) {
  252.                         *o_base = base[retn];
  253.                         *io_index = index;
  254.                         return 0;
  255.                 }
  256.         }
  257.         return -1;
  258. }

  260. int get_english_digit(const char *p, int *io_index, int *o_value)
  261. {
  262.         int index;
  263.         int value;
  264.         int sum;
  265.         int base;

  267.         if (p == NULL || io_index == NULL || o_value == NULL) {
  268.                 return -1;
  269.         }
  270.         index = *io_index;
  271.         if (index < 0) {
  272.                 return -1;
  273.         }
  274.         sum = 0;
  275.         for (;;) {
  276.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  277.                         if (value == 0) {
  278.                                 if (sum > 0) {
  279.                                         return -1;
  280.                                 }
  281.                                 sum = 0;
  282.                                 break;
  283.                         }
  284.                         sum += value;
  285.                         while (get_english_digit_base(p, &index, &base) == 0) {
  286.                                 sum *= base;
  287.                         }
  288.                         if (skip_word(p, &index, "and") == 0) {
  289.                                 continue;
  290.                         }
  291.                         break;
  292.                 }else if (sum == 0) {
  293.                         if (skip_word(p, &index, "a") == 0) {
  294.                                 sum = 1;
  295.                                 while (get_english_digit_base(p, &index, &base) == 0) {
  296.                                         sum *= base;
  297.                                 }
  298.                                 if (skip_word(p, &index, "and") == 0) {
  299.                                         continue;
  300.                                 }
  301.                                 break;
  302.                         }
  303.                 }
  304.                 return -1;
  305.         }
  306.         *o_value = sum;
  307.         *io_index = index;
  308.         return 0;
  309. }

  311. int get_operator1(const char *p, int *io_index, int *o_op)
  312. {
  313.         static const char *op_list[] = {
  314.                 "positive",
  315.                 "+",
  316.                 "negative",
  317.                 "-",
  318.         };
  319.         int index;
  320.         int start, len;
  321.         int retn;
  322.        
  323.         if (p == NULL || io_index == NULL || o_op == NULL) {
  324.                 return -1;
  325.         }
  326.         index = *io_index;
  327.         if (index < 0) {
  328.                 return -1;
  329.         }
  330.         skip_space(p, &index);
  331.         if (get_word(p, &index, &start, &len) == 0) {
  332.                 retn = get_token(p + start, len, op_list, 8);
  333.                 if (retn != -1) {
  334.                         *o_op = retn / 2;
  335.                         *io_index = index;
  336.                         return 0;
  337.                 }
  338.         }
  339.         return -1;
  340. }

  342. int get_operator2(const char *p, int *io_index, int *o_op)
  343. {
  344.         static const char *op_list[] = {
  345.                 "plus",
  346.                 "+",
  347.                 "minus",
  348.                 "-",
  349.                 "multiply",
  350.                 "*",
  351.                 "divide",
  352.                 "/",
  353.         };
  354.         int index;
  355.         int start, len;
  356.         int retn;

  358.         if (p == NULL || io_index == NULL || o_op == NULL) {
  359.                 return -1;
  360.         }
  361.         index = *io_index;
  362.         if (index < 0) {
  363.                 return -1;
  364.         }
  365.         skip_space(p, &index);
  366.         if (get_word(p, &index, &start, &len) == 0) {
  367.                 retn = get_token(p + start, len, op_list, 8);
  368.                 if (retn != -1) {
  369.                         if ((retn & 1) == 0) {
  370.                                 skip_word(p, &index, "with");
  371.                         }
  372.                         *o_op = retn / 2;
  373.                         *io_index = index;
  374.                         return 0;
  375.                 }
  376.         }
  377.         return -1;
  378. }

  380. int get_number(const char *p, int *io_index, int *o_value)
  381. {
  382.         int index;
  383.         int value;

  385.         if (p == NULL || io_index == NULL || o_value == NULL) {
  386.                 return -1;
  387.         }
  388.         index = *io_index;
  389.         if (index < 0) {
  390.                 return -1;
  391.         }
  392.         skip_space(p, &index);
  393.         if (isdigit(p[index])) {
  394.                 value = 0;
  395.                 do {
  396.                         value = value * 10 + p[index] - '0';
  397.                         index++;
  398.                 }while (isdigit(p[index]));
  399.                 *o_value = value;
  400.                 *io_index = index;
  401.                 return 0;
  402.         }
  403.         return -1;
  404. }

  406. int get_digit(const char *p, int *io_index, int *o_value)
  407. {
  408.         int index;
  409.         int value;

  411.         if (p == NULL || io_index == NULL || o_value == NULL) {
  412.                 return -1;
  413.         }
  414.         index = *io_index;
  415.         if (index < 0) {
  416.                 return -1;
  417.         }
  418.         if (get_english_digit(p, &index, &value) == 0
  419.                 || get_number(p, &index, &value) == 0) {
  420.                 *o_value = value;
  421.                 *io_index = index;
  422.                 return 0;
  423.         }
  424.         return -1;
  425. }

  427. int get_oprand(const char *p, int *io_index, int *o_value)
  428. {
  429.         int index;
  430.         int op;
  431.         int d1;
  432.         int result;

  434.         if (p == NULL || io_index == NULL || o_value == NULL) {
  435.                 return -1;
  436.         }
  437.         index = *io_index;
  438.         if (index < 0) {
  439.                 return -1;
  440.         }
  441.         /* one oprand operation */
  442.         if (get_operator1(p, &index, &op) == 0) {
  443.                 if (get_digit(p, &index, &d1) != 0) {
  444.                         return -1;
  445.                 }
  446.                 switch (op) {
  447.                 case 0:
  448.                         result = d1;
  449.                         break;
  450.                 case 1:
  451.                         result = -d1;
  452.                         break;
  453.                 default:
  454.                         return -1;
  455.                 }
  456.         }else {
  457.                 if (get_digit(p, &index, &result) != 0) {
  458.                         return -1;
  459.                 }
  460.         }
  461.         *o_value = result;
  462.         *io_index = index;
  463.         return 0;
  464. }

  466. int strrtrim(char *p)
  467. {
  468.         int len;

  470.         if (p == NULL) {
  471.                 return -1;
  472.         }
  473.         len = strlen(p);
  474.         if (len > 0) {
  475.                 if (isspace(p[len - 1])) {
  476.                         do {
  477.                                 --len;
  478.                         }while(len >= 0 && isspace(p[len]));
  479.                         p[len + 1] = '\0';
  480.                 }
  481.         }
  482.         return 0;
  483. }

  485. int strtrim(char *p)
  486. {
  487.         int i;

  489.         if (p == NULL) {
  490.                 return -1;
  491.         }
  492.         for (i = 0; p[i] != '\0'; ++i) {
  493.                 if (!isspace(p[i])) {
  494.                         break;
  495.                 }
  496.         }
  497.         strcpy(p, p + i);
  498.         return 0;
  499. }

  501. int get_end(const char *p, int *io_index)
  502. {
  503.         int index;

  505.         if (p == NULL || io_index == NULL) {
  506.                 return -1;
  507.         }
  508.         index = *io_index;
  509.         if (index < 0) {
  510.                 return -1;
  511.         }
  512.         skip_space(p, &index);
  513.         if (p[index] == '\0') {
  514.                 *io_index = index;
  515.                 return 0;
  516.         }
  517.         return -1;
  518. }

  520. int caculate(const char *exp, int *o_value)
  521. {
  522.         int op; /* operator */
  523.         int d1, d2; /* oprand number */
  524.         int result; /* store the expression result */
  525.         int index;

  527.         if (exp == NULL || o_value == NULL) {
  528.                 return -1;
  529.         }
  530.         index = 0;
  531.         if (get_oprand(exp, &index, &result) == -1) {
  532.                 return -1;
  533.         }
  534.         /* conjunction operation */
  535.         while (get_end(exp, &index) == -1) {
  536.                 /* two oprands operation */
  537.                 d1 = result;
  538.                 if (get_operator2(exp, &index, &op) == -1) {
  539.                         return -1;
  540.                 }
  541.                 if (get_oprand(exp, &index, &d2) == -1) {
  542.                         return -1;
  543.                 }
  544.                 switch (op) {
  545.                 case 0:
  546.                         result = d1 + d2;
  547.                         break;
  548.                 case 1:
  549.                         result = d1 - d2;
  550.                         break;
  551.                 case 2:
  552.                         result = d1 * d2;
  553.                         break;
  554.                 case 3:
  555.                         if (d2 == 0) {
  556.                                 return -1;
  557.                         }
  558.                         result = d1 / d2;
  559.                         break;
  560.                 default:
  561.                         return -1;
  562.                 }
  563.         }
  564.         *o_value = result;
  565.         return 0; /* end of conjunction */
  566. }

  568. int main(void)
  569. {
  570.         char cmd_line[1024];
  571.         int result;

  573.         puts("English Caculator");
  574.         puts("Enter an expression");
  575.         puts("Ctrl-Z to exit");
  576.         for (;;) {
  577.                 printf(": ");
  578.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  579.                         puts("");
  580.                         return 0;
  581.                 }
  582.                 strrtrim(cmd_line);
  583.                 strtrim(cmd_line);
  584.                 if (caculate(cmd_line, &result) == 0) {
  585.                         printf("\"%s\" = %d\n", cmd_line, result);
  586.                 }else {
  587.                         printf("\"%s\" = E, Invalid Expression\n", cmd_line);
  588.                 }
  589.         }
  590. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
20楼 [报告]
发表于 2011-08-10 10:20 |只看该作者
改进token匹配算法。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         if (tok_tab[i][len] == '\0') {
  74.                                 return i;
  75.                         }
  76.                 }
  77.         }
  78.         return -1;
  79. }

  81. int skip_word(const char *p, int *io_index, const char *s)
  82. {
  83.         int index;
  84.         int start, len;

  86.         if (p == NULL || io_index == NULL || s == NULL) {
  87.                 return -1;
  88.         }
  89.         index = *io_index;
  90.         if (index < 0) {
  91.                 return -1;
  92.         }
  93.         skip_space(p, &index);
  94.         if (get_word(p, &index, &start, &len) == 0) {
  95.                 if (strncmp(p + start, s, len) == 0) {
  96.                         *io_index = index;
  97.                         return 0;
  98.                 }
  99.         }
  100.         return -1;
  101. }

  103. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  104. {
  105.         static const char *digit20[20] = {
  106.                 "zero",
  107.                 "one",
  108.                 "two",
  109.                 "three",
  110.                 "four",
  111.                 "five",
  112.                 "six",
  113.                 "seven",
  114.                 "eight",
  115.                 "nine",
  116.                 "ten",
  117.                 "eleven",
  118.                 "twelve",
  119.                 "thirteen",
  120.                 "fourteen",
  121.                 "fifteen",
  122.                 "sixteen",
  123.                 "seventeen",
  124.                 "eighteen",
  125.                 "nineteen",
  126.         };
  127.         int index;
  128.         int start;
  129.         int len;
  130.         int tok;

  132.         if (p == NULL || io_index == NULL || o_value == NULL) {
  133.                 return -1;
  134.         }
  135.         index = *io_index;
  136.         if (index < 0) {
  137.                 return -1;
  138.         }
  139.         skip_space(p, &index);
  140.         if (get_word(p, &index, &start, &len) == 0) {
  141.                 tok = get_token(p + start, len, digit20, 20);
  142.                 if (tok != -1) {
  143.                         *o_value = tok;
  144.                         *io_index = index;
  145.                         return 0;
  146.                 }
  147.         }
  148.         return -1;
  149. }

  151. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  152. {
  153.         static const char *decades[8] = {
  154.                 "twenty",
  155.                 "thirty",
  156.                 "forty",
  157.                 "fifty",
  158.                 "sixty",
  159.                 "seventy",
  160.                 "eighty",
  161.                 "ninety",
  162.         };
  163.         int index;
  164.         int start, len;
  165.         int value;
  166.         int retn;

  168.         if (p == NULL || io_index == NULL || o_value == NULL) {
  169.                 return -1;
  170.         }
  171.         index = *io_index;
  172.         if (index < 0) {
  173.                 return -1;
  174.         }
  175.         skip_space(p, &index);
  176.         if (get_word(p, &index, &start, &len) == 0) {
  177.                 retn = get_token(p + start, len, decades, 8);
  178.                 if (retn != -1) {
  179.                         value = retn * 10 + 20;
  180.                         *o_value = value;
  181.                         *io_index = index;
  182.                         return 0;
  183.                 }
  184.         }
  185.         return -1;
  186. }

  188. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  189. {
  190.         int index;
  191.         int value;
  192.         int digit;
  193.         int decade_yes;

  195.         if (p == NULL || io_index == NULL || o_value == NULL) {
  196.                 return -1;
  197.         }
  198.         index = *io_index;
  199.         if (index < 0) {
  200.                 return -1;
  201.         }
  202.         decade_yes = 0;
  203.         if (get_english_digit_decade(p, &index, &value) == -1) {
  204.                 value = 0;
  205.         }else {
  206.                 decade_yes = 1;
  207.         }
  208.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  209.                 if (decade_yes && digit == 0) {
  210.                         return -1;
  211.                 }
  212.                 value += digit;
  213.         }else {
  214.                 if (!decade_yes) {
  215.                         return -1;
  216.                 }
  217.         }
  218.         *o_value = value;
  219.         *io_index = index;
  220.         return 0;
  221. }

  223. int get_english_digit_base(const char *p, int *io_index, int *o_base)
  224. {
  225.         static const char *more[] = {
  226.                 "hundred",
  227.                 "thousand",
  228.                 "million",
  229.                 "billion",
  230.         };
  231.         static const int base[] = {
  232.                 100,
  233.                 1000,
  234.                 1000000,
  235.                 1000000000,
  236.         };
  237.         int index;
  238.         int start,len;
  239.         int retn;

  241.         if (p == NULL || io_index == NULL || o_base == NULL) {
  242.                 return -1;
  243.         }
  244.         index = *io_index;
  245.         if (index < 0) {
  246.                 return -1;
  247.         }
  248.         skip_space(p, &index);
  249.         if (get_word(p, &index, &start, &len) == 0) {
  250.                 retn = get_token(p + start, len, more, 4);
  251.                 if (retn != -1) {
  252.                         *o_base = base[retn];
  253.                         *io_index = index;
  254.                         return 0;
  255.                 }
  256.         }
  257.         return -1;
  258. }

  260. int get_english_digit(const char *p, int *io_index, int *o_value)
  261. {
  262.         int index;
  263.         int value;
  264.         int sum;
  265.         int base;

  267.         if (p == NULL || io_index == NULL || o_value == NULL) {
  268.                 return -1;
  269.         }
  270.         index = *io_index;
  271.         if (index < 0) {
  272.                 return -1;
  273.         }
  274.         sum = 0;
  275.         for (;;) {
  276.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  277.                         if (value == 0) {
  278.                                 if (sum > 0) {
  279.                                         return -1;
  280.                                 }
  281.                                 sum = 0;
  282.                                 break;
  283.                         }
  284.                         sum += value;
  285.                         while (get_english_digit_base(p, &index, &base) == 0) {
  286.                                 sum *= base;
  287.                         }
  288.                         if (skip_word(p, &index, "and") == 0) {
  289.                                 continue;
  290.                         }
  291.                         break;
  292.                 }else if (sum == 0) {
  293.                         if (skip_word(p, &index, "a") == 0) {
  294.                                 sum = 1;
  295.                                 while (get_english_digit_base(p, &index, &base) == 0) {
  296.                                         sum *= base;
  297.                                 }
  298.                                 if (skip_word(p, &index, "and") == 0) {
  299.                                         continue;
  300.                                 }
  301.                                 break;
  302.                         }
  303.                 }
  304.                 return -1;
  305.         }
  306.         *o_value = sum;
  307.         *io_index = index;
  308.         return 0;
  309. }

  311. int get_operator1(const char *p, int *io_index, int *o_op)
  312. {
  313.         static const char *op_list[] = {
  314.                 "positive",
  315.                 "+",
  316.                 "negative",
  317.                 "-",
  318.         };
  319.         int index;
  320.         int start, len;
  321.         int retn;
  322.        
  323.         if (p == NULL || io_index == NULL || o_op == NULL) {
  324.                 return -1;
  325.         }
  326.         index = *io_index;
  327.         if (index < 0) {
  328.                 return -1;
  329.         }
  330.         skip_space(p, &index);
  331.         if (get_word(p, &index, &start, &len) == 0) {
  332.                 retn = get_token(p + start, len, op_list, 8);
  333.                 if (retn != -1) {
  334.                         *o_op = retn / 2;
  335.                         *io_index = index;
  336.                         return 0;
  337.                 }
  338.         }
  339.         return -1;
  340. }

  342. int get_operator2(const char *p, int *io_index, int *o_op)
  343. {
  344.         static const char *op_list[] = {
  345.                 "plus",
  346.                 "+",
  347.                 "minus",
  348.                 "-",
  349.                 "multiply",
  350.                 "*",
  351.                 "divide",
  352.                 "/",
  353.         };
  354.         int index;
  355.         int start, len;
  356.         int retn;

  358.         if (p == NULL || io_index == NULL || o_op == NULL) {
  359.                 return -1;
  360.         }
  361.         index = *io_index;
  362.         if (index < 0) {
  363.                 return -1;
  364.         }
  365.         skip_space(p, &index);
  366.         if (get_word(p, &index, &start, &len) == 0) {
  367.                 retn = get_token(p + start, len, op_list, 8);
  368.                 if (retn != -1) {
  369.                         if ((retn & 1) == 0) {
  370.                                 skip_word(p, &index, "with");
  371.                         }
  372.                         *o_op = retn / 2;
  373.                         *io_index = index;
  374.                         return 0;
  375.                 }
  376.         }
  377.         return -1;
  378. }

  380. int get_number(const char *p, int *io_index, int *o_value)
  381. {
  382.         int index;
  383.         int value;

  385.         if (p == NULL || io_index == NULL || o_value == NULL) {
  386.                 return -1;
  387.         }
  388.         index = *io_index;
  389.         if (index < 0) {
  390.                 return -1;
  391.         }
  392.         skip_space(p, &index);
  393.         if (isdigit(p[index])) {
  394.                 value = 0;
  395.                 do {
  396.                         value = value * 10 + p[index] - '0';
  397.                         index++;
  398.                 }while (isdigit(p[index]));
  399.                 *o_value = value;
  400.                 *io_index = index;
  401.                 return 0;
  402.         }
  403.         return -1;
  404. }

  406. int get_digit(const char *p, int *io_index, int *o_value)
  407. {
  408.         int index;
  409.         int value;

  411.         if (p == NULL || io_index == NULL || o_value == NULL) {
  412.                 return -1;
  413.         }
  414.         index = *io_index;
  415.         if (index < 0) {
  416.                 return -1;
  417.         }
  418.         if (get_english_digit(p, &index, &value) == 0
  419.                 || get_number(p, &index, &value) == 0) {
  420.                 *o_value = value;
  421.                 *io_index = index;
  422.                 return 0;
  423.         }
  424.         return -1;
  425. }

  427. int get_oprand(const char *p, int *io_index, int *o_value)
  428. {
  429.         int index;
  430.         int op;
  431.         int d1;
  432.         int result;

  434.         if (p == NULL || io_index == NULL || o_value == NULL) {
  435.                 return -1;
  436.         }
  437.         index = *io_index;
  438.         if (index < 0) {
  439.                 return -1;
  440.         }
  441.         /* one oprand operation */
  442.         if (get_operator1(p, &index, &op) == 0) {
  443.                 if (get_digit(p, &index, &d1) != 0) {
  444.                         return -1;
  445.                 }
  446.                 switch (op) {
  447.                 case 0:
  448.                         result = d1;
  449.                         break;
  450.                 case 1:
  451.                         result = -d1;
  452.                         break;
  453.                 default:
  454.                         return -1;
  455.                 }
  456.         }else {
  457.                 if (get_digit(p, &index, &result) != 0) {
  458.                         return -1;
  459.                 }
  460.         }
  461.         *o_value = result;
  462.         *io_index = index;
  463.         return 0;
  464. }

  466. int strrtrim(char *p)
  467. {
  468.         int len;

  470.         if (p == NULL) {
  471.                 return -1;
  472.         }
  473.         len = strlen(p);
  474.         if (len > 0) {
  475.                 if (isspace(p[len - 1])) {
  476.                         do {
  477.                                 --len;
  478.                         }while(len >= 0 && isspace(p[len]));
  479.                         p[len + 1] = '\0';
  480.                 }
  481.         }
  482.         return 0;
  483. }

  485. int strtrim(char *p)
  486. {
  487.         int i;

  489.         if (p == NULL) {
  490.                 return -1;
  491.         }
  492.         for (i = 0; p[i] != '\0'; ++i) {
  493.                 if (!isspace(p[i])) {
  494.                         break;
  495.                 }
  496.         }
  497.         strcpy(p, p + i);
  498.         return 0;
  499. }

  501. int get_end(const char *p, int *io_index)
  502. {
  503.         int index;

  505.         if (p == NULL || io_index == NULL) {
  506.                 return -1;
  507.         }
  508.         index = *io_index;
  509.         if (index < 0) {
  510.                 return -1;
  511.         }
  512.         skip_space(p, &index);
  513.         if (p[index] == '\0') {
  514.                 *io_index = index;
  515.                 return 0;
  516.         }
  517.         return -1;
  518. }

  520. int caculate(const char *exp, int *o_value)
  521. {
  522.         int op; /* operator */
  523.         int d1, d2; /* oprand number */
  524.         int result; /* store the expression result */
  525.         int index;

  527.         if (exp == NULL || o_value == NULL) {
  528.                 return -1;
  529.         }
  530.         index = 0;
  531.         if (get_oprand(exp, &index, &result) == -1) {
  532.                 return -1;
  533.         }
  534.         /* conjunction operation */
  535.         while (get_end(exp, &index) == -1) {
  536.                 /* two oprands operation */
  537.                 d1 = result;
  538.                 if (get_operator2(exp, &index, &op) == -1) {
  539.                         return -1;
  540.                 }
  541.                 if (get_oprand(exp, &index, &d2) == -1) {
  542.                         return -1;
  543.                 }
  544.                 switch (op) {
  545.                 case 0:
  546.                         result = d1 + d2;
  547.                         break;
  548.                 case 1:
  549.                         result = d1 - d2;
  550.                         break;
  551.                 case 2:
  552.                         result = d1 * d2;
  553.                         break;
  554.                 case 3:
  555.                         if (d2 == 0) {
  556.                                 return -1;
  557.                         }
  558.                         result = d1 / d2;
  559.                         break;
  560.                 default:
  561.                         return -1;
  562.                 }
  563.         }
  564.         *o_value = result;
  565.         return 0; /* end of conjunction */
  566. }

  568. int main(void)
  569. {
  570.         char cmd_line[1024];
  571.         int result;

  573.         puts("English Caculator");
  574.         puts("Enter an expression");
  575.         puts("Ctrl-Z to exit");
  576.         for (;;) {
  577.                 printf(": ");
  578.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  579.                         puts("");
  580.                         return 0;
  581.                 }
  582.                 strrtrim(cmd_line);
  583.                 strtrim(cmd_line);
  584.                 if (caculate(cmd_line, &result) == 0) {
  585.                         printf("\"%s\" = %d\n", cmd_line, result);
  586.                 }else {
  587.                         printf("\"%s\" = E, Invalid Expression\n", cmd_line);
  588.                 }
  589.         }
  590. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
123下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号：11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们：huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP