My Pastes
Public Pastes
Layout Width
Share Pastebin
Guest
Public paste!

Untitled

By: a guest | Mar 21st, 2010 | Syntax: ASM (NASM) | Size: 3.38 KB | Hits: 55 | Expires: Never
Download | Raw | Embed | Report abuse
Copy text to clipboard
  1. #include <math.h>
  2. #include <stdio.h>
  3. #include <ctype.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6.  
  7. #define ADD 1
  8. #define SUB 2
  9. #define MUL 3
  10. #define DIV 4
  11. #define AND 5
  12. #define OR 6
  13. #define POW 7
  14.  
  15. int error = 0;
  16. int mystrcmp(char* a, char* b) {
  17.   int r = 1;
  18.   while(*a) {
  19.     if (*a != *b) {
  20.           r = 0;
  21.           break;
  22.         }
  23.         a++,b++;
  24.   }
  25.  
  26.   return (*b)?0:r;
  27. }
  28.  
  29. int ipow(int a, int b) {
  30.   int i;
  31.   int res = 1;
  32.   for (i = 0; i < b; i++) {
  33.     res *= a;
  34.   }
  35.   return res;
  36. }
  37.  
  38. int indexOf(char *str, char c) {
  39.   int index = -1;
  40.   char *p = str;
  41.   while(*str) {
  42.         if (*str == c) {
  43.                 index = (str - p);
  44.                 break;
  45.         }
  46.         str++;
  47.   }
  48.   return index;
  49. }
  50.  
  51. int getOp (char c) {
  52.   int op = -1;
  53.   switch(c) {
  54.     case '+' : op = ADD; break;
  55.         case '-' : op = SUB; break;
  56.         case '*' : op = MUL; break;
  57.         case '/' : op = DIV; break;
  58.         case '&' : op = AND; break;
  59.         case '|' : op = OR; break;
  60.         case '^' : op = POW; break;
  61.   }
  62.  
  63.   return op;
  64. }
  65.  
  66. int getResult (int op, int opA, int opB) {
  67.   int n = -1;;
  68.   switch(op) {
  69.         case ADD:
  70.                 n = opA + opB;
  71.                 break;
  72.         case SUB:
  73.                 n = opA - opB; 
  74.                 break;
  75.         case MUL:
  76.                 n = opA * opB;
  77.                 break;
  78.         case DIV:
  79.                 if (opB == 0) {
  80.                         error = 4;
  81.                         //mostrar error division dentro de 0
  82.                 } else {
  83.                         n = opA / opB;
  84.                 }
  85.                 break;
  86.         case AND:
  87.                 n = opA & opB;
  88.                 break;
  89.         case OR:
  90.                 n = opA | opB;
  91.                 break;         
  92.         case POW:
  93.                 n = ipow(opA,opB);
  94.                 break;
  95.   }
  96.  
  97.   return n;
  98. }
  99.  
  100. int operate(char **str) {
  101.   int result;
  102.  
  103.   char *refBuf, *refVar, *refVarAux, *var, *buf, *varAux;
  104.   buf = malloc(12);
  105.   var = malloc(10);
  106.   varAux = malloc(10);
  107.   refVarAux = varAux;  
  108.   refBuf = buf;
  109.   refVar = var;
  110.  
  111.   (*str)++; // me salto el primer parentesis
  112.   int op = getOp(**str);       
  113.   (*str)++; // me salto el operador
  114.   if (op != -1) {
  115.     int opA, opB;
  116.        
  117.     while(**str == ' ' || **str == '\t') (*str)++;
  118.         if (**str == '(') {
  119.           opA = operate(str);    
  120.         } else if (isdigit(**str)) {
  121.                 while(isdigit(**str)) {
  122.                         *buf=**str;
  123.                         buf++,(*str)++;
  124.                 }
  125.                 *buf = '\0';
  126.                 buf = refBuf;
  127.                 opA = atoi(buf);
  128.         } else {
  129.                 printf("Debe ingresar las operaciones de la forma (operador operando operando)\n");
  130.                 error = 4;
  131.         }
  132.     while(**str == ' ' || **str == '\t') (*str)++;     
  133.         if (**str == '(') {
  134.           opB = operate(str);
  135.         } else if (isdigit(**str)) {
  136.                 while(isdigit(**str)) {
  137.                         *buf=**str;
  138.                         buf++,(*str)++;
  139.                 }
  140.                 *buf = '\0';
  141.                 buf = refBuf;
  142.                 opB = atoi(buf);
  143.         } else {
  144.                 printf("Debe ingresar las operaciones de la forma (operador operando operando)\n");
  145.                 error = 4;
  146.         }
  147.         (*str)+=1;
  148.         result = getResult(op,opA,opB);
  149.   } else {
  150.     printf("Debe ingresar un operador valido (+,-,*,/,&,|,^,#)\n");
  151.         error = 4;
  152.   }
  153.    
  154.   free(buf);
  155.   free(var);
  156.   free(varAux);
  157.   return result;
  158. }
  159.  
  160. void parse(char *buffer) {
  161.  
  162.   int parOIndex = indexOf(buffer,'(');
  163.   int parCIndex = indexOf(buffer,')');
  164.  
  165.   if (parOIndex == -1 || parCIndex == -1) {
  166.         printf("Debe ingresar las operaciones de la forma (operador operando operando)\n");
  167.   } else {
  168.         int n =  operate(&buffer);
  169.         printf("$>%i\n",n);
  170.   }
  171. }
  172.  
  173. int main() {
  174.   char c;
  175.   int execute = 1;
  176.   char *buffer = (char*) malloc(100);
  177.   char *ref = buffer;
  178.  
  179.   while(execute) {
  180.         printf("$>");
  181.         while ((c = getchar()) != '\n') {      
  182.           *buffer=c;
  183.           buffer++;
  184.         }
  185.        
  186.         *buffer = '\0';
  187.         buffer = ref;
  188.         if (!mystrcmp(buffer,"exit"))
  189.                 parse(buffer);
  190.         else
  191.                 execute = 0;
  192.   }  
  193.  
  194.   return 1;
  195. }
create new paste | create new version of this paste RAW Paste Data