ulvis.paste.net

Paste Search Dynamic
Recent pastes
Eval
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "stdafx.h"
  4. #include "math.h"
  5. #include "stack.h"
  6.  
  7. #define STACK_SIZE 30
  8. /* run this program using the console pauser or add your own getch, system("pause") or input loop */
  9.  
  10. double getNum(void); // czyta liczby
  11. char getOper(void); // czyta operator
  12. void skipSpaces(void); // opuszcza spacje
  13. int prior(char oper); // priorytet operatora
  14. double Eval(char oper, double arg1, double arg2);
  15. int isOper(char c);
  16. int isDigit(char c);
  17. double Calc(void); // kalkulator
  18.  
  19.  
  20. int main(int argc, char *argv[]) {
  21.     return 0;
  22. }
  23.  
  24. double getNum(void) {
  25.  
  26.     char c;
  27.    
  28.     double temp = 1;
  29.     double res = 0.0;
  30.     int sign = 1;
  31.  
  32.     // usuwa spacje
  33.     skipSpaces();
  34.  
  35.     // sprawdza znak liczby
  36.     if ((c = getchar()) == '-') {
  37.         sign = -1;
  38.     }
  39.     else {
  40.         // wraca znak do bufora klawiatury
  41.         ungetc(c, stdin);
  42.     }
  43.                 // *** ungetc(int char, FILE* stream) ***
  44.                 // A character is virtually put back into an input stream,
  45.                 // decreasing its internal file position as if a previous getc operation was undone.
  46.    
  47.     // wczytuje czesc calkowita
  48.     while ((c = getchar()) != EOF && isDigit(c) != 0) { // getchar()
  49.         res = res * 10 + (c - '0');
  50.     }
  51.  
  52.     // wraca znak do bufora klawiatury
  53.     ungetc(c, stdin);
  54.    
  55.     // wczytuje czesc ulamkowa
  56.     if ( ( c = getchar() ) != EOF && (c == '.' || c == ',')){
  57.         while ((c = getchar()) != EOF && isDigit(c) != 0) { // getchar()
  58.             temp *= 0.1;
  59.             res += (c - '0')*temp;
  60.         }
  61.     }
  62.  
  63.     // ??
  64.  
  65.  
  66.     return res*sign;
  67. }
  68.  
  69. char getOper(void) {
  70.     skipSpaces();
  71.     return getchar();
  72. }
  73.  
  74. void skipSpaces(void) {     // wczytywac dopoki jest spacja
  75.     char z;
  76.     while ((z = getchar()) == ' ') {
  77.     }
  78.     ungetc(z, stdin);   //oddac ostatni znak do bufora klawiatury  
  79. }
  80.  
  81. int prior(char oper) { // priorytet operatora
  82.     int temp;
  83.     switch (oper) {
  84.         case '(':
  85.             temp = 0;
  86.             break;
  87.         case ')':
  88.             temp = 0;
  89.             break;
  90.         case '+':
  91.             temp = 1;
  92.             break;
  93.         case '-':
  94.             temp = 1;
  95.             break;
  96.         case '*':
  97.             temp = 2;
  98.             break;
  99.         case '/':
  100.             temp = 2;
  101.             break;
  102.         case '^':
  103.             temp = 3;
  104.             break;
  105.         default:
  106.             temp = -1;
  107.     }
  108.     return temp;
  109. }
  110.  
  111. int isDigit(char c) {
  112.     return (c >= '0' && c <= '9') ? 1 : 0;
  113. }
  114.  
  115. int isOper(char c) {
  116.     switch (c) {
  117.         case '+':
  118.             break;
  119.         case '-':
  120.             break;
  121.         case '*':
  122.             break;
  123.         case '/':
  124.             break;
  125.         case '^':
  126.             break;
  127.         default: return 0;
  128.     }
  129.     return 1;
  130. }
  131.  
  132. double Eval(char oper, double arg1, double arg2) { // ???
  133.     double res;
  134.     switch (oper) {
  135.         case '+':
  136.             res = arg1 + arg2;
  137.             break;
  138.         case '-':
  139.             res = arg1 + arg2;
  140.             break;
  141.         case '*':
  142.             res = arg1 + arg2;
  143.             break;
  144.         case '/':
  145.             if(arg1 != 0)
  146.             res = arg1 + arg2;
  147.             break;
  148.         case '^':
  149.             res = pow(arg1, arg2);
  150.             break;
  151.     }
  152.     return res;
  153. }
  154.  
  155. //double Calc(void) {
  156.     //algorytm ONP
  157. //}
  158. /*
  159. void ONP(){
  160.  
  161. char c;
  162. StackItem* pStack; InitStack( &pStack);
  163.  
  164.  
  165. while *is Oper ( c= Getoper())
  166.  
  167. }
  168. */
  169.  
  170.  
  171.  
  172. /*                                  */    
  173. /*              STOS                */    
  174. /*                                  */
  175.  
  176. char stack[STACK_SIZE];
  177. int head = 0;
  178.  
  179. void push(char c) {
  180.     if (head < STACK_SIZE) {
  181.         stack[head++] = c;
  182.     }
  183. }
  184.  
  185. int isEmpty(void) {
  186.     return !head;
  187. }
  188.  
  189. char pop(void) {
  190.     if (!isEmpty()) {
  191.         return stack[--head];
  192.     }
  193. }
  194.  
  195. char top(void) {
  196.     if (!isEmpty()) {
  197.         return stack[head - 1];
  198.     }
  199. }
  200.  
  201. void del(void){
  202.     if (!isEmpty()) {
  203.         --head;
  204.     }
  205. }
Parsed in 0.025 seconds