API tools faq
paste
Advertisement
Guest User

LFTC_Carla_Chiquita

a guest
Nov 20th, 2017
75
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 12.57 KB | None | 0 0
raw download clone embed print report
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<ctype.h>
  4. #include<string.h>
  5. #define MAX_TEXT_LEN 30
  6. #define MAX_ATOMS 100
  7.  
  8. enum{
  9.     ID,
  10.     VAL_INT, /* INT */
  11.     VAL_REAL, /* FLOAT */
  12.     VAL_STR, /* STRING */
  13.     VAR,FUNCTION,IF,ELSE,WHILE,END,RETURN,INT,REAL,STR, /* Reserved words */
  14.     COLON,
  15.     SEMICOLON,
  16.     LPAR,RPAR,
  17.     COMMA,
  18.     OR,AND,NOT,EQUAL,NOTEQUAL,LESS,ASSIGN,
  19.     ADD,SUB,MUL,DIV,
  20.     FINISH /* EOF */
  21. };
  22.  
  23. typedef struct{
  24.     int tip;
  25.     union{
  26.         char text[MAX_TEXT_LEN];
  27.         int nrInt;
  28.         double nrReal;
  29.     };
  30. }Atom;
  31. int crtAtom;
  32. int nrAtom = 0;
  33. int states[] = {0, 1, 3, 5, 6, 8, 15, 17, 19, 22};
  34. FILE *f = NULL;
  35. Atom atomi[MAX_ATOMS];
  36.  
  37. /* Analiza sintactica */
  38. int consume(int tip)
  39. {
  40.     if(atomi[crtAtom].tip == tip)
  41.     {
  42.         crtAtom++;
  43.         return 1;
  44.     }
  45.     return 0;
  46. }
  47.  
  48. int tipBaza()
  49. {
  50.     return (crtAtom == INT || crtAtom == REAL || crtAtom == STR);
  51. }
  52.  
  53. int declVar()
  54. {
  55.     int initAtom = crtAtom;
  56.     if(consume(VAR)){
  57.         if(consume(ID)){
  58.             if(consume(COLON)){
  59.                 if(tipBaza()){
  60.                     if(consume(SEMICOLON)){
  61.                         return 1;
  62.                     }
  63.                 }
  64.             }
  65.         }
  66.     }
  67.     crtAtom = initAtom;
  68.     return 0;
  69. }
  70.  
  71. int funcArgs()
  72. {
  73.     return 1;
  74. }
  75.  
  76. int bloc()
  77. {
  78.     return 1;
  79. }
  80.  
  81. int declFunc()
  82. {
  83.     int initAtom = crtAtom;
  84.     if(consume(FUNCTION)){
  85.         if(consume(ID)){
  86.             if(consume(LPAR)){
  87.                 if(funcArgs()){
  88.                     if(consume(RPAR)){
  89.                         if(consume(COLON)){
  90.                             if(tipBaza()){
  91.                                 while(declVar())
  92.                                     ;
  93.                                      if(bloc()){
  94.                                          if(consume(END)){
  95.                                              return 1;
  96.                                          }
  97.                                      }
  98.                             }
  99.                         }
  100.                     }
  101.                 }
  102.             }
  103.         }
  104.     }
  105.     crtAtom = initAtom;
  106.     return 0;
  107. }
  108.  
  109. int declBloc()
  110. {
  111.     return 1;
  112. }
  113.  
  114. int program()
  115. {
  116.     int initAtom = crtAtom;
  117.     for(;;) {
  118.         if(declVar()) {
  119.            
  120.         } else if(declFunc()) {
  121.            
  122.         } else if(bloc()) {
  123.            
  124.         } else break;
  125.     }
  126.     if(consume(FINISH)) {
  127.         return 1;
  128.     }
  129.     crtAtom = initAtom;
  130.     return 0;
  131. }
  132.  
  133. void error(char* m){
  134.     printf("EROARE: %s ",m);
  135.     exit(0);
  136. }
  137.  
  138. void addAtom(int tipAtom){
  139.     atomi[nrAtom].tip = tipAtom;
  140.     nrAtom++;
  141. }
  142.  
  143. int lexer(){
  144.     int s=0, ch = 0, i;
  145.     char buf[100];
  146.     int buf_len = 0;
  147.     while(1){
  148.         /* Check if state is one from the states array */
  149.         for(i = 0; i < 10 && s != states[i]; i++)
  150.             ;
  151.         if(i != 10) {
  152.             ch = getc(f);
  153.         }
  154.        
  155.         switch(s){
  156.             case 0:
  157.                 if(isalpha(ch)||ch=='_'){
  158.                     s=1;
  159.                     buf[buf_len]=ch;
  160.                     buf_len++;
  161.                 }
  162.                 else if(isdigit(ch)){
  163.                     s=3;
  164.                     buf[buf_len]=ch;
  165.                     buf_len++;
  166.                 }
  167.                 else if(ch=='\"')
  168.                     s=8;
  169.                 else if(ch==':')
  170.                     s=10;
  171.                 else if(ch==';')
  172.                     s=11;
  173.                 else if(ch=='(')
  174.                     s=12;
  175.                 else if(ch==')')
  176.                     s=13;
  177.                 else if(ch==',')
  178.                     s=14;
  179.                 else if(ch=='|')
  180.                     s=15;
  181.                 else if(ch=='&')
  182.                     s=17;
  183.                 else if(ch=='!')
  184.                     s=19;
  185.                 else if(ch=='=')
  186.                     s=22;
  187.                 else if(ch=='<')
  188.                     s=25;
  189.                 else if(ch=='+')
  190.                     s=26;
  191.                 else if(ch=='-')
  192.                     s=27;
  193.                 else if(ch=='*')
  194.                     s=28;
  195.                 else if(ch=='/')
  196.                     s=29;
  197.                 else if(ch==EOF)
  198.                     s=30;
  199.                 else if(ch==' '||ch=='\n'||ch=='\r'||ch=='\t'){}
  200.                 else error("caracter necunoscut");
  201.                 break;
  202.             case 1:
  203.                 if(isalpha(ch)||ch=='_'){
  204.                     buf[buf_len]=ch;
  205.                     buf_len++;
  206.                 }
  207.                 else {
  208.                     ungetc(ch,f);
  209.                     s=2;
  210.                 }
  211.                 break;
  212.             case 2:
  213.                 buf[buf_len]=0;
  214.                 if(strcmp(buf,"var")==0){
  215.                     addAtom(VAR);
  216.                     return VAR;
  217.                 }
  218.                 else if(strcmp(buf,"function")==0){
  219.                     addAtom(FUNCTION);
  220.                     return FUNCTION;
  221.                 }
  222.                 else if(strcmp(buf,"if")==0){
  223.                     addAtom(IF);
  224.                     return IF;
  225.                 }
  226.                 else if(strcmp(buf,"else")==0){
  227.                     addAtom(ELSE);
  228.                     return ELSE;
  229.                 }
  230.                 else if(strcmp(buf,"while")==0){
  231.                     addAtom(WHILE);
  232.                     return WHILE;
  233.                 }
  234.                 else if(strcmp(buf,"end")==0){
  235.                     addAtom(END);
  236.                     return END;
  237.                 }
  238.                 else if(strcmp(buf,"return")==0){
  239.                     addAtom(RETURN);
  240.                     return RETURN;
  241.                 }
  242.                 else if(strcmp(buf,"int")==0){
  243.                     addAtom(INT);
  244.                     return INT;
  245.                 }
  246.                 else if(strcmp(buf,"real")==0){
  247.                     addAtom(REAL);
  248.                     return REAL;
  249.                 }
  250.                 else if(strcmp(buf,"str")==0){
  251.                     addAtom(STR);
  252.                     return STR;
  253.                 }
  254.                 else {
  255.                     addAtom(ID);
  256.                     strcpy(atomi[nrAtom-1].text,buf);
  257.                     return ID;
  258.                 }
  259.             case 3:
  260.                 if(isdigit(ch)){
  261.                     buf[buf_len]=ch;
  262.                     buf_len++;
  263.                 }
  264.                 else if(ch=='.'){
  265.                     s=5;
  266.                     buf[buf_len]=ch;
  267.                     buf_len++;
  268.                 }
  269.                 else {
  270.                     ungetc(ch,f);
  271.                     s=4;
  272.                 }
  273.                 break;
  274.             case 4:
  275.                 buf[buf_len]=0;
  276.                 addAtom(VAL_INT);
  277.                 atomi[nrAtom-1].nrInt=atoi(buf);
  278.                 return VAL_INT;
  279.             case 5:
  280.                 if(isdigit(ch)){
  281.                     s=6;
  282.                     buf[buf_len]=ch;
  283.                     buf_len++;
  284.                 }
  285.                 else error("caracter necunoscut - lipsesc zecimale dintr-un numar real");
  286.                 break;
  287.             case 6:
  288.                 if(isdigit(ch)){
  289.                     buf[buf_len]=ch;
  290.                     buf_len++;
  291.                 }
  292.                 else {
  293.                     ungetc(ch,f);
  294.                     s=7;
  295.                 }
  296.                 break;
  297.             case 7:
  298.                 buf[buf_len]=0;
  299.                 addAtom(VAL_REAL);
  300.                 atomi[nrAtom-1].nrReal=atof(buf);
  301.                 return VAL_REAL;
  302.             case 8:
  303.                 if(ch!='\"'){
  304.                     buf[buf_len]=ch;
  305.                     buf_len++;
  306.                 }
  307.                 else if(ch=='\"')
  308.                     s=9;
  309.                 else error("ati introdus un sir invalid");
  310.                 break;
  311.             case 9:
  312.                 buf[buf_len]=0;
  313.                 addAtom(VAL_STR);
  314.                 strcpy(atomi[nrAtom-1].text,buf);
  315.                 return VAL_STR;
  316.             case 10:
  317.                 addAtom(COLON);
  318.                 return COLON;
  319.             case 11:
  320.                 addAtom(SEMICOLON);
  321.                 return SEMICOLON;
  322.             case 12:
  323.                 addAtom(LPAR);
  324.                 return LPAR;
  325.             case 13:
  326.                 addAtom(RPAR);
  327.                 return RPAR;
  328.             case 14:
  329.                 addAtom(COMMA);
  330.                 return COMMA;
  331.             case 15:
  332.                 if(ch=='|')
  333.                     s=16;
  334.                 else error("caracter necunoscut - un singur |");
  335.                 break;
  336.             case 16:
  337.                 addAtom(OR);
  338.                 return OR;
  339.             case 17:
  340.                 if(ch=='&')
  341.                     s=18;
  342.                 else error("caracter necunoscut - un singur &");
  343.                 break;
  344.             case 18:
  345.                 addAtom(AND);
  346.                 return AND;
  347.             case  19:
  348.                 if(ch=='=')
  349.                     s=21;
  350.                 else {
  351.                     ungetc(ch,f);
  352.                     s=20;
  353.                 }
  354.                 break;
  355.             case 20:
  356.                 addAtom(NOT);
  357.                 return NOT;
  358.             case 21:
  359.                 addAtom(NOTEQUAL);
  360.                 return NOTEQUAL;
  361.             case 22:
  362.                 if(ch=='=')
  363.                     s=24;
  364.                 else {
  365.                     ungetc(ch,f);
  366.                     s=23;
  367.                 }
  368.                 break;
  369.             case 23:
  370.                 addAtom(ASSIGN);
  371.                 return ASSIGN;
  372.             case 24:
  373.                 addAtom(EQUAL);
  374.                 return EQUAL;
  375.             case 25:
  376.                 addAtom(LESS);
  377.                 return LESS;
  378.             case 26:
  379.                 addAtom(ADD);
  380.                 return ADD;
  381.             case 27:
  382.                 addAtom(SUB);
  383.                 return SUB;
  384.             case 28:
  385.                 addAtom(MUL);
  386.                 return MUL;
  387.             case 29:
  388.                 addAtom(DIV);
  389.                 return DIV;
  390.             case 30:
  391.                 addAtom(FINISH);
  392.                 return FINISH;
  393.             default:
  394.                 error("s-a ajuns intr-o stare neprevazuta");
  395.                 break;
  396.         }
  397.     }
  398. }
  399.  
  400. const char* showEnum(int i)
  401. {
  402.     /* Functie doar pentru afisare nume in loc de cifrele corespunzatoare din enum */
  403.     switch (i)
  404.     {
  405.         case 0: return "ID";
  406.         case 1: return "VAL_INT";
  407.         case 2: return "VAL_REAL";
  408.         case 3: return "VAL_STR";
  409.         case 4: return "VAR";
  410.         case 5: return "FUNCTION";
  411.         case 6: return "IF";
  412.         case 7: return "ELSE";
  413.         case 8: return "WHILE";
  414.         case 9: return "END";
  415.         case 10: return "RETURN";
  416.         case 11: return "INT";
  417.         case 12: return "REAL";
  418.         case 13: return "STR";
  419.         case 14: return "COLON";
  420.         case 15: return "SEMICOLON";
  421.         case 16: return "LPAR";
  422.         case 17: return "RPAR";
  423.         case 18: return "COMMA";
  424.         case 19: return "OR";
  425.         case 20: return "AND";
  426.         case 21: return "NOT";
  427.         case 22: return "EQUAL";
  428.         case 23: return "NOTEQUAL";
  429.         case 24: return "LESS";
  430.         case 25: return "ASSIGN";
  431.         case 26: return "ADD";
  432.         case 27: return "SUB";
  433.         case 28: return "MUL";
  434.         case 29: return "DIV";
  435.         case 30: return "FINISH";
  436.         default: return "!!! EROARE !!!";
  437.     }
  438. }
  439.  
  440. int main(){
  441.     //freopen("rezultat.txt", "w", stdout);
  442.     if ((f = fopen("/Users/adrian.creteanu/Docs/Scoala/An III/Sem I/LFTC/Laborator/Compilator_LFTC/Compilator_LFTC/atomi.txt", "r")) == NULL) {
  443.         printf("Eroare: nu se poate deschide fisierul!\n");
  444.         return -1;
  445.     }
  446.    
  447.     else {
  448.         while(lexer()!=FINISH){
  449.             if(atomi[nrAtom-1].tip==1){
  450.                 printf("%s %d \n",showEnum(atomi[nrAtom-1].tip),atomi[nrAtom-1].nrInt);
  451.             }
  452.             else if(atomi[nrAtom-1].tip==2){
  453.                 printf("%s %f \n",showEnum(atomi[nrAtom-1].tip),atomi[nrAtom-1].nrReal);
  454.             }
  455.             else {
  456.                 printf("%s %s \n",showEnum(atomi[nrAtom-1].tip),atomi[nrAtom-1].text);
  457.             }
  458.         }
  459.        
  460.         printf("FINISH");
  461.        
  462.         fclose(f);
  463.         //printf("\n\n");
  464.         //f=fopen("program.q","r");
  465.        
  466.         /* Verificare analiza sintactica */
  467.         if(program()) {
  468.             printf("Sintaxa okay!\n");
  469.         } else {
  470.             printf("Eroare de sintaxa!\n");
  471.         }
  472.        
  473.        
  474.         fclose(f);
  475.         getc(stdin);
  476.     }
  477. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!