API tools faq
paste
Sc3ric

lab3-lyuda

Sc3ric
Jun 15th, 2023 (edited)
1,065
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 20.49 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. size_t mallocCount = 0;
  6. size_t callocCount = 0;
  7. size_t reallocCount = 0;
  8. size_t freeCount = 0;
  9.  
  10. void* my_malloc(size_t _size) {
  11.     mallocCount++;
  12.     return malloc(_size);
  13. }
  14.  
  15. void* my_calloc(size_t _num, size_t _size) {
  16.     callocCount++;
  17.     return calloc(_num, _size);
  18. }
  19.  
  20. void* my_realloc(void* _memory, size_t _size) {
  21.     if (_memory == NULL) return my_malloc(_size);
  22.     reallocCount++;
  23.     return realloc(_memory, _size);
  24. }
  25.  
  26. void my_free(void* _memory) {
  27.     freeCount++;
  28.     free(_memory);
  29. }
  30.  
  31. struct TreeStruct {
  32.     int res;
  33.     char op;
  34.     char var;
  35.     struct TreeStruct* left;
  36.     struct TreeStruct* right;
  37. };
  38.  
  39. typedef struct TreeStruct Tree;
  40.  
  41. void free_tree(Tree* tree) {
  42.     if (tree->left != NULL) free_tree(tree->left);
  43.     if (tree->right != NULL) free_tree(tree->right);
  44.     my_free(tree);
  45. }
  46.  
  47. Tree* copy_tree(Tree* tree) {
  48.     Tree* n = my_malloc(sizeof(Tree));
  49.     n->res = tree->res;
  50.     n->op = tree->op;
  51.     n->var = tree->var;
  52.     n->left = NULL;
  53.     n->right = NULL;
  54.  
  55.     if (tree->left != NULL) n->left = copy_tree(tree->left);
  56.     if (tree->right != NULL) n->right = copy_tree(tree->right);
  57.     return n;
  58. }
  59.  
  60.  
  61. const int orderLength = 7;
  62. const char order[] = {'#', '^', '*', '/', '%', '+', '-', '\0'};
  63. const char openBracket = '(';
  64. const char closeBracket = ')';
  65.  
  66. const char parseCommandStr[] = "parse\0";
  67. const char loadPrfCommandStr[] = "load_prf\0";
  68. const char loadPstCommandStr[] = "load_pst\0";
  69. const char savePrfCommandStr[] = "save_prf\0";
  70. const char savePstCommandStr[] = "save_pst\0";
  71. const char evalCommandStr[] = "eval\0";
  72.  
  73. size_t __intLength(int a) {
  74.     int r = a / 10;
  75.     if (r == 0) return 1;
  76.     return __intLength(r) + 1;
  77. }
  78.  
  79. size_t intLength(int a) {
  80.     return __intLength(a) + (a < 0);
  81. }
  82.  
  83. int __findCharExclude(const char* str, const char toFind, int left, int right, int last) {
  84.     size_t lenStr = strlen(str);
  85.  
  86.     int res = -1;
  87.  
  88.     for (int i = 0; i < lenStr; i++) {
  89.         if (i >= left && i <= right) continue;
  90.         if (str[i] == toFind) {
  91.             if (!last) return i;
  92.             res = i;
  93.         }
  94.     }
  95.  
  96.     return res;
  97. }
  98.  
  99. int findCharExclude(const char* str, const char toFind, int left, int right) {
  100.     return __findCharExclude(str, toFind, left, right, 0);
  101. }
  102.  
  103. int findChar(const char* str, const char toFind) {
  104.     return findCharExclude(str, toFind, -1, -1);
  105. }
  106.  
  107. int countChar(const char* str, const char toFind) {
  108.     size_t lenStr = strlen(str);
  109.     int counter = 0;
  110.  
  111.     for (int i = 0; i < lenStr; i++) {
  112.         if (str[i] == toFind) {
  113.             counter++;
  114.         }
  115.     }
  116.  
  117.     return counter;
  118. }
  119.  
  120. char* substr(const char* str, size_t from, size_t to) {
  121.     if (from > to) return my_malloc(0);
  122.     size_t newStrLen = to - from + 1;
  123.     char* newStr = my_calloc(newStrLen, sizeof(char));
  124.     newStr[newStrLen-1] = '\0';
  125.  
  126.     for (size_t i = from; i < to; i++) {
  127.         newStr[i-from] = str[i];
  128.     }
  129.  
  130.     return newStr;
  131. }
  132.  
  133. char* removeAllChar(const char* str, const char toRemove) {
  134.     int toRemoveCharsCount = countChar(str, toRemove);
  135.  
  136.     size_t strLen = strlen(str);
  137.     char* out = my_calloc(strLen - toRemoveCharsCount + 1, sizeof(char));
  138.     out[toRemoveCharsCount] = '\0';
  139.     int outC = 0;
  140.  
  141.     for (size_t i = 0; i < strLen; i++) {
  142.         if (str[i] == toRemove) continue;
  143.         out[outC++] = str[i];
  144.     }
  145.  
  146.     return out;
  147. }
  148.  
  149. void fillStr(char** str, size_t count, char what) {
  150.     for (size_t i = 0; i < count; i++) {
  151.         (*str)[i] = what;
  152.     }
  153. }
  154.  
  155. int isDigit(const char c) {
  156.     return '0' <= c &&  c <= '9';
  157. }
  158.  
  159. int isOperator(const char c) {
  160.     return findChar(order, c) != -1;
  161. }
  162.  
  163. int isVariable(const char c) {
  164.     return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z');
  165. }
  166.  
  167. int isBrackets(const char c) {
  168.     return c == openBracket || c == closeBracket;
  169. }
  170.  
  171. int isGoodExpr(const char* str) {
  172.     size_t strLen = strlen(str);
  173.     for (size_t i = 0; i < strLen; i++) {
  174.         // if not
  175.         if (!(
  176.                 isDigit(str[i]) ||
  177.                 isOperator(str[i]) ||
  178.                 isVariable(str[i]) ||
  179.                 isBrackets(str[i])
  180.         )) return 0;
  181.     }
  182.     return 1;
  183. }
  184.  
  185. int isGoodExprPrfPst(const char* str) {
  186.     size_t strLen = strlen(str);
  187.     for (size_t i = 0; i < strLen; i++) {
  188.         // if not
  189.         if (!(
  190.                 isDigit(str[i]) ||
  191.                 isOperator(str[i]) ||
  192.                 isVariable(str[i]) ||
  193.                 str[i] == ' '
  194.         )) return 0;
  195.     }
  196.     return 1;
  197. }
  198.  
  199. int isInt(const char* str, int right) {
  200.     int strLen = (int)strlen(str);
  201.     if (right < strLen) strLen = right;
  202.     for (int i = 0; i < strLen; i++) {
  203.         if (!isDigit(str[i])) return 0;
  204.     }
  205.     return 1;
  206. }
  207.  
  208. int strToInt(const char* str) {
  209.     char* eptr;
  210.     return strtol(str, &eptr, 10);
  211. }
  212.  
  213. int gcd(int a, int b) {
  214.     if (a == 0) return b;
  215.     if (b == 0) return a;
  216.  
  217.     if (a > b) return gcd(a - b, b);
  218.     else return gcd(a, b - a);
  219. }
  220.  
  221. int my_pow(int a, int b) {
  222.     if (b-- == 0) return 1;
  223.     for (size_t i = 0; i < b; i++) {
  224.         a *= a;
  225.     }
  226.     return a;
  227. }
  228.  
  229. // calculates tree - expression like: tree->left->res tree->operator tree->right->res
  230. // returns 1 if good else 0
  231. int calc(Tree* tree) {
  232.     if (tree->left == NULL || tree->right == NULL) return 0;
  233.     if (tree->left->var != '\0' || tree->right->var != '\0') {
  234.         tree->res = 1;
  235.         tree->var = '.';
  236.         return 1;
  237.     }
  238.  
  239.     if (tree->op == '#') {
  240.         if (tree->left->res < 0 || tree->right->res < 0) return 0;
  241.         tree->res = gcd(tree->left->res, tree->right->res);
  242.     }
  243.     else if (tree->op == '^') {
  244.         if (tree->right->res < 0) return 0;
  245.         tree->res = my_pow(tree->left->res, tree->right->res);
  246.     }
  247.     else if (tree->op == '*') {
  248.         tree->res = tree->left->res * tree->right->res;
  249.     }
  250.     else if (tree->op == '/') {
  251.         if (tree->right->res == 0) return 0;
  252.         tree->res = tree->left->res / tree->right->res;
  253.     }
  254.     else if (tree->op == '%') {
  255.         tree->res = tree->left->res % tree->right->res;
  256.     }
  257.     else if (tree->op == '+') {
  258.         tree->res = tree->left->res + tree->right->res;
  259.     }
  260.     else if (tree->op == '-') {
  261.         tree->res = tree->left->res - tree->right->res;
  262.     }
  263.  
  264.     return 1;
  265. }
  266.  
  267. int isThereUnnecessaryBrackets(const char* str, int right) {
  268.     if (right < 3) return 0;
  269.  
  270.     return str[0] == openBracket && str[right-1] == closeBracket;
  271. }
  272.  
  273. char* removeUnnecessaryBrackets(const char* str, int right) {
  274.     if (right > 2 && str[0] == openBracket && str[right - 1] == closeBracket) {
  275.         return substr(str, 1, right - 1);
  276.     }
  277.  
  278.     char* res = my_calloc(right+1, sizeof(char));
  279.     strcpy(res, str);
  280.     res[right] = '\0';
  281.  
  282.     return res;
  283. }
  284.  
  285. int findLastOrderedOperator(const char* expr, int* res, int right) {
  286.     int exprLen = (int)strlen(expr);
  287.     if (right < exprLen) exprLen = right;
  288.     int bracketIsNotClosed = 0;
  289.  
  290.     *res = -1;
  291.     int orderRes = orderLength;
  292.     int currentOrder;
  293.  
  294.     for (int i = 0; i < exprLen; i++) {
  295.         if (expr[i] == openBracket) {
  296.             bracketIsNotClosed++;
  297.             continue;
  298.         }
  299.         if (expr[i] == closeBracket) {
  300.             bracketIsNotClosed--;
  301.             continue;
  302.         }
  303.         if (bracketIsNotClosed > 0) continue;
  304.  
  305.         if (isOperator(expr[i])) {
  306.             currentOrder = orderLength - findChar(order, expr[i]) - 1;
  307.             if (currentOrder < orderRes) {
  308.                 orderRes = currentOrder;
  309.                 *res = i;
  310.             }
  311.         }
  312.     }
  313.  
  314.     if (*res == -1) return -1;
  315.     return *res;
  316. }
  317.  
  318. int __parse(char* expr, Tree* tree, int leftBorder, int rightBorder) {
  319.     //TODO: some error checks
  320.  
  321.     int lastOperatorPos;
  322.     int res = findLastOrderedOperator(&expr[leftBorder], &lastOperatorPos, rightBorder - leftBorder);
  323.     if (!res) return 0;
  324.  
  325.     tree->var = '\0';
  326.     if (lastOperatorPos != -1) {
  327.         char op = expr[leftBorder + lastOperatorPos];
  328.         Tree* left = my_malloc(sizeof(Tree));
  329.  
  330.         int noError = __parse(expr, left, leftBorder, leftBorder + lastOperatorPos);
  331.         if (!noError) return 0;
  332.  
  333.         Tree* right = my_malloc(sizeof(Tree));
  334.         noError = __parse(expr, right, leftBorder + lastOperatorPos + 1, rightBorder);
  335.         if (!noError) return 0;
  336.  
  337.         tree->left = left;
  338.         tree->right = right;
  339.         tree->op = op;
  340.  
  341.         noError = calc(tree);
  342.         if (!noError) return 0;
  343.     }
  344.     else {
  345.         if (isInt(&expr[leftBorder], rightBorder - leftBorder) || isVariable(expr[leftBorder])) {
  346.             tree->left = NULL;
  347.             tree->right = NULL;
  348.             tree->res = 1;
  349.             tree->op = '\0';
  350.  
  351.             if (isVariable(expr[leftBorder])) {
  352.                 tree->var = expr[leftBorder];
  353.             }
  354.             else {
  355.                 tree->res = strToInt(&expr[leftBorder]);
  356.             }
  357.         }
  358.         else if (isThereUnnecessaryBrackets(&expr[leftBorder], rightBorder - leftBorder)) {
  359.             char* goodExpr = removeUnnecessaryBrackets(&expr[leftBorder], rightBorder - leftBorder);
  360.  
  361.             res = __parse(goodExpr, tree, 0, strlen(goodExpr));
  362.             my_free(goodExpr);
  363.             if (!res) return 0;
  364.         }
  365.         else {
  366.             return 0;
  367.         }
  368.     }
  369.  
  370.     return 1;
  371. }
  372.  
  373. int parse(char* expr, Tree* tree) {
  374.     char* exprWithoutSpaces = removeAllChar(expr, ' ');
  375.     if (
  376.             !isGoodExpr(exprWithoutSpaces) ||
  377.             !__parse(exprWithoutSpaces, tree, 0, strlen(exprWithoutSpaces))
  378.             ) {
  379.         my_free(exprWithoutSpaces);
  380.         return 0;
  381.     }
  382.     my_free(exprWithoutSpaces);
  383.     return 1;
  384. }
  385.  
  386. size_t __prfOrPstLength(Tree* tree) {
  387.     size_t len = (tree->op != '\0')*2;
  388.     if (tree->left != NULL) {
  389.         len += __prfOrPstLength(tree->left);
  390.         len += __prfOrPstLength(tree->right);
  391.     }
  392.     else {
  393.         len += 1 + intLength(tree->res);
  394.     }
  395.     return len;
  396. }
  397.  
  398. size_t prfOrPstLength(Tree* tree) {
  399.     return __prfOrPstLength(tree) - 1;
  400. }
  401.  
  402. int __savePrfOrPst(Tree* tree, char* out, int pst) {
  403.     int pos = 0;
  404.     if (tree->op != '\0') {
  405.         if (!pst) {
  406.             out[0] = tree->op;
  407.             pos += 2;
  408.         }
  409.  
  410.         pos += __savePrfOrPst(tree->left, &out[pos], pst);
  411.         pos += __savePrfOrPst(tree->right, &out[pos], pst);
  412.  
  413.         if (pst) {
  414.             out[pos] = tree->op;
  415.             pos += 2;
  416.         }
  417.     }
  418.     else {
  419.         if (tree->var == '\0') {
  420.             itoa(tree->res, out, 10);
  421.             pos += (int)intLength(tree->res) + 1;
  422.             out[pos - 1] = ' ';
  423.         }
  424.         else {
  425.             out[0] = tree->var;
  426.             pos += 2;
  427.         }
  428.     }
  429.  
  430.     return pos;
  431. }
  432.  
  433. char* savePrf(Tree* tree) {
  434.     size_t prfLen = prfOrPstLength(tree);
  435.  
  436.     char* prf = my_calloc(prfLen + 1, sizeof(char));
  437.  
  438.     fillStr(&prf, prfLen, ' ');
  439.  
  440.     __savePrfOrPst(tree, prf, 0);
  441.     prf[prfLen] = '\0';
  442.     return prf;
  443. }
  444.  
  445. char* savePst(Tree* tree) {
  446.     size_t prfLen = prfOrPstLength(tree);
  447.  
  448.     char* pst = my_calloc(prfLen + 1, sizeof(char));
  449.  
  450.     fillStr(&pst, prfLen, ' ');
  451.  
  452.     __savePrfOrPst(tree, pst, 1);
  453.     pst[prfLen] = '\0';
  454.     return pst;
  455. }
  456.  
  457. int __loadPrf(const char* expr, Tree* tree, int* pos) {
  458.     int noErr;
  459.     tree->op = '\0';
  460.     tree->var = '\0';
  461.     tree->res = 1;
  462.  
  463.     if (!isOperator(expr[*pos])) {
  464.         tree->left = NULL;
  465.         tree->right = NULL;
  466.         tree->op = '\0';
  467.  
  468.         if (isVariable(expr[*pos])) {
  469.             tree->var = expr[*pos];
  470.             *pos += 2;
  471.         }
  472.         else {
  473.             tree->res = strToInt(&expr[*pos]);
  474.             *pos += (int)intLength(tree->res) + 1;
  475.         }
  476.  
  477.         return 1;
  478.  
  479.     }
  480.     tree->op = expr[*pos];
  481.     *pos += 2;
  482.  
  483.     tree->left = my_malloc(sizeof(Tree));
  484.     tree->right = my_malloc(sizeof(Tree));
  485.  
  486.     int lPos = 0;
  487.     noErr = __loadPrf(&expr[*pos], tree->left, &lPos);
  488.     if (!noErr) return 0;
  489.     *pos += lPos;
  490.     lPos = 0;
  491.  
  492.     noErr = __loadPrf(&expr[*pos], tree->right, &lPos);
  493.     if (!noErr) return 0;
  494.     *pos += lPos;
  495.  
  496.     noErr = calc(tree);
  497.     if (!noErr) return 0;
  498.  
  499.     return 1;
  500. }
  501.  
  502. int loadPrf(const char* expr, Tree* tree) {
  503.     if (!isGoodExprPrfPst(expr)) return 0;
  504.     //TODO: check
  505.     int pos = 0;
  506.     int noErr = __loadPrf(expr, tree, &pos);
  507.     return noErr && pos - 1 == strlen(expr);
  508. }
  509.  
  510. int __loadPst(const char* expr, Tree* tree, int* pos) {
  511.     int noErr;
  512.     tree->op = '\0';
  513.     tree->var = '\0';
  514.     tree->res = 1;
  515.  
  516.     if (!isOperator(expr[*pos])) {
  517.         tree->left = NULL;
  518.         tree->right = NULL;
  519.         tree->op = '\0';
  520.  
  521.         for (; *pos != 0 && expr[*pos] != ' '; (*pos)--) ;
  522.         if (*pos != 0) (*pos)++;
  523.  
  524.         if (isVariable(expr[*pos])) {
  525.             tree->var = expr[*pos];
  526.         }
  527.         else {
  528.             tree->res = strToInt(&expr[*pos]);
  529.         }
  530.         *pos -= 2;
  531.  
  532.         return 1;
  533.     }
  534.     tree->op = expr[*pos];
  535.     *pos -= 2;
  536.  
  537.     tree->left = my_malloc(sizeof(Tree));
  538.     tree->right = my_malloc(sizeof(Tree));
  539.  
  540.     noErr = __loadPst(&expr[0], tree->right, pos);
  541.     if (!noErr) return 0;
  542.  
  543.     noErr = __loadPst(&expr[0], tree->left, pos);
  544.     if (!noErr) return 0;
  545.  
  546.     noErr = calc(tree);
  547.     if (!noErr) return 0;
  548.  
  549.     return 1;
  550. }
  551.  
  552. int loadPst(const char* expr, Tree* tree) {
  553.     if (!isGoodExprPrfPst(expr)) return 0;
  554.     //TODO: check
  555.     int pos = (int)strlen(expr) - 1;
  556.     int noErr = __loadPst(expr, tree, &pos);
  557.     return noErr && pos == -2;
  558. }
  559.  
  560. // returns 2 if error, 1 if modified, 0 if not modified
  561. int __eval(const char var, const int val, Tree* tree) {
  562.     if (tree->var == var) {
  563.         tree->res = val;
  564.         tree->var = '\0';
  565.         return 1;
  566.     }
  567.     if (tree->left != NULL) {
  568.         int modified = __eval(var, val, tree->left) | __eval(var, val, tree->right);
  569.         // passthrough error
  570.         if (modified & 0x2) return 2;
  571.  
  572.         // if modified
  573.         if (modified & 0x1) {
  574.             tree->var = '\0';
  575.             int noError = calc(tree);
  576.             if (!noError) return 2;
  577.             return 1;
  578.         }
  579.     }
  580.     return 0;
  581. }
  582.  
  583. int eval(char* expr, Tree* tree) {
  584.     int exprLen = (int) strlen(expr);
  585.  
  586.     int pos;
  587.  
  588.     char var;
  589.     int val;
  590.  
  591.     int eRes;
  592.  
  593.     while (exprLen > 2) {
  594.         if (expr[1] != '=') return 0;
  595.         var = expr[0];
  596.         val = strToInt(&expr[2]);
  597.         eRes = __eval(var, val, tree);
  598.         // catch error
  599.         if (eRes & 0x2) return 0;
  600.  
  601.         pos = 2;
  602.         for (; expr[pos] != ','; pos++) {
  603.             if (pos + 1 == exprLen) return tree->var == '\0';
  604.         }
  605.         expr = &expr[pos+1];
  606.  
  607.         exprLen = (int) strlen(expr);
  608.     }
  609.  
  610.     return tree->var == '\0';
  611. }
  612.  
  613. int commandToExpression(char** str) {
  614.     int fullCommandLen = (int)strlen(*str);
  615.  
  616.     int spacePos = findChar(*str, ' ');
  617.     if (spacePos == -1) return 0;
  618.  
  619.     for (; spacePos + 1 != fullCommandLen && (*str)[spacePos] == ' '; spacePos++) ;
  620.     if (spacePos + 1 == fullCommandLen) return 0;
  621.  
  622.     *str = &((*str)[spacePos]);
  623.     return 1;
  624. }
  625.  
  626. void writeFile(char* data) {
  627.     FILE* f = fopen("output.txt", "a");
  628.     fprintf(f, "%s\n", data);
  629.     fclose(f);
  630. }
  631. void writeFileInt(int data) {
  632.     FILE* f = fopen("output.txt", "a");
  633.     fprintf(f, "%i\n", data);
  634.     fclose(f);
  635. }
  636.  
  637. int doCommand(char* str, Tree** tree, int print) {
  638.     // in the start it's command
  639.  
  640.     if (strstr(str, parseCommandStr)) {
  641.         // now it's expression
  642.         if (!commandToExpression(&str)) return 0;
  643.  
  644.         Tree* ntree = my_malloc(sizeof(Tree));
  645.         ntree->left = NULL;
  646.         ntree->right = NULL;
  647.  
  648.         if (parse(str, ntree)) {
  649.             if (*tree != NULL) free_tree(*tree);
  650.             *tree = ntree;
  651.  
  652.             if (print) {
  653.                 printf("success\n");
  654.             }
  655.             else {
  656.                 writeFile("success");
  657.             }
  658.         }
  659.         else {
  660.             free_tree(ntree);
  661.             if (print) {
  662.                 printf("incorrect\n");
  663.             }
  664.             else {
  665.                 writeFile("incorrect");
  666.             }
  667.         }
  668.  
  669.         return 1;
  670.     }
  671.     else if (strstr(str, loadPrfCommandStr)) {
  672.         // now it's expression
  673.         if (!commandToExpression(&str)) return 0;
  674.  
  675.         Tree* ntree = my_malloc(sizeof(Tree));
  676.         ntree->left = NULL;
  677.         ntree->right = NULL;
  678.  
  679.         if (loadPrf(str, ntree)) {
  680.             if (*tree != NULL) free_tree(*tree);
  681.             *tree = ntree;
  682.  
  683.             if (print) {
  684.                 printf("success\n");
  685.             }
  686.             else {
  687.                 writeFile("success");
  688.             }
  689.         }
  690.         else {
  691.             free_tree(ntree);
  692.             if (print) {
  693.                 printf("incorrect\n");
  694.             }
  695.             else {
  696.                 writeFile("incorrect");
  697.             }
  698.         }
  699.  
  700.         return 1;
  701.     }
  702.     else if (strstr(str, loadPstCommandStr)) {
  703.         // now it's expression
  704.         if (!commandToExpression(&str)) return 0;
  705.  
  706.         Tree* ntree = my_malloc(sizeof(Tree));
  707.         ntree->left = NULL;
  708.         ntree->right = NULL;
  709.  
  710.         if (loadPst(str, ntree)) {
  711.             if (*tree != NULL) free_tree(*tree);
  712.             *tree = ntree;
  713.  
  714.             if (print) {
  715.                 printf("success\n");
  716.             }
  717.             else {
  718.                 writeFile("success");
  719.             }
  720.         }
  721.         else {
  722.             free_tree(ntree);
  723.             if (print) {
  724.                 printf("incorrect\n");
  725.             }
  726.             else {
  727.                 writeFile("incorrect");
  728.             }
  729.         }
  730.  
  731.         return 1;
  732.     }
  733.     else if (strstr(str, savePrfCommandStr)) {
  734.         char* out = savePrf(*tree);
  735.         if (print) {
  736.             printf("%s\n", out);
  737.         }
  738.         else {
  739.             writeFile(out);
  740.         }
  741.         my_free(out);
  742.         return 1;
  743.     }
  744.     else if (strstr(str, savePstCommandStr)) {
  745.         char* out = savePst(*tree);
  746.         if (print) {
  747.             printf("%s\n", out);
  748.         }
  749.         else {
  750.             writeFile(out);
  751.         }
  752.         my_free(out);
  753.         return 1;
  754.     }
  755.     else if (strstr(str, evalCommandStr)) {
  756.         // now it's expression
  757.         if (!commandToExpression(&str)) return 0;
  758.  
  759.         Tree* toEval = copy_tree(*tree);
  760.  
  761.         int res = eval(str, toEval);
  762.         if (!res) return 0;
  763.  
  764.         if (print) {
  765.             printf("%i\n", res);
  766.         }
  767.         else {
  768.             writeFileInt(res);
  769.         }
  770.  
  771.         free_tree(toEval);
  772.  
  773.         return 1;
  774.     }
  775.  
  776.     return 0;
  777. }
  778.  
  779. void writeMemstat() {
  780.     FILE* f = fopen("memstat.txt", "w");
  781.  
  782.     fprintf(f, "malloc:%zu\n", mallocCount);
  783.     fprintf(f, "realloc:%zu\n", reallocCount);
  784.     fprintf(f, "calloc:%zu\n", callocCount);
  785.     fprintf(f, "free:%zu\n", freeCount);
  786.  
  787.     fclose(f);
  788. }
  789.  
  790. void fileWork() {
  791.     FILE* f = fopen("input.txt", "r");
  792.     if (!f) return;
  793.     FILE* fo = fopen("output.txt", "w");
  794.     if (!fo) return;
  795.     fclose(fo);
  796.  
  797.     fseek(f, 0L, SEEK_END);
  798.     int fileLen = ftell(f);
  799.     rewind(f);
  800.  
  801.     char* command = my_calloc(fileLen + 1, sizeof(char));
  802.     Tree* tree = NULL;
  803.  
  804.     while (fgets(&command[0], fileLen + 1, f) != NULL) {
  805.         if (command[strlen(command) - 1] == '\n') {
  806.             command[strlen(command) - 1] = '\0';
  807.             if (!doCommand(command, &tree, 0)) {
  808.                 //TODO: error?
  809.                 writeFile("incorrect");
  810.                 continue;
  811.             }
  812.         }
  813.     }
  814.     my_free(command);
  815.     if (tree != NULL) free_tree(tree);
  816.     fclose(f);
  817. }
  818.  
  819. int main() {
  820.     fileWork();
  821.     Tree* tree = NULL;
  822. //    5*(14-4*2)/2 = 15
  823. //    ( 22 - ( 1 + 1 ) ) / ( 5 * ( 6 - ( 2 + 2 ) ) ) = 2
  824. //    ( ( ( 1 ) ) ) = 1
  825. //    2 / 2 + 3 * 4 - 6 = 7
  826. //    ( ( ( ( ( ( ( 5 ) ) ) ) ) ) ) = 5
  827. //    2 * ( 2 * ( 2 * ( 2 * 1 ) ) ) = 16
  828. //    3 * ( 4 + 7 ) - 6 = 27
  829. //    ( 1 + 2 * ( 1 - 2 ) ) = -1
  830. //    ( 1 + 2 * ( 1 - 2 ) ) * ( 1 + 2 * ( 1 - 2 ) ) = 1
  831. //    1 * 2 * 3 * 4 * 5 + 20 / 5 = 124
  832. //    1 * 2 * 3 * 4 * (5 + 20) / 5 = 120
  833.  
  834.     char* buff = my_calloc(1000, sizeof(char));
  835.  
  836.     printf("Print nothing to out\n");
  837.     while (gets(buff) != NULL) {
  838.         if (buff[0] == '\0') break;
  839.         if (!doCommand(buff, &tree, 1)) {
  840.             //TODO: error?
  841.             printf("incorrect\n");
  842.         }
  843.     }
  844.     my_free(buff);
  845.  
  846.     if (tree != NULL) free_tree(tree);
  847.  
  848.     writeMemstat();
  849.  
  850.     return 0;
  851. }
  852.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!