API tools faq
paste
t1nman

lexAnalyser.c

t1nman
Jul 19th, 2012
68
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 8.06 KB | None | 0 0
raw download clone embed print report
  1. #include "modules.h"
  2. #define kw_size 35
  3.  
  4. char *keywrds[kw_size] = {"and","array","begin","case","const","div","do","downto","else","end","file","for",
  5.               "function","goto","if","in","label","mod","nil","not","of","or","packed","procedure",
  6.               "program","record","repeat","set","then","to","type","until","var","while","with"};
  7. int keywordCheck(struct lex_type lexChain[], int l)
  8. {
  9.     int i;
  10.     for(i = 0; i < kw_size; i++){
  11.         if(strcmp(lexChain[l].lexem, keywrds[i]) == 0){
  12.             lexChain[l].lexem_class = "KEYWORD";
  13.             return 1;
  14.         }
  15.     }
  16.     return 0;
  17. }
  18.  
  19. int lexAnalyser(struct transl_type translChain[], struct lex_type lexChain[])
  20. {
  21.     int STATE = 0, i = -1, j = -1, l = -1, kw_flag;
  22.     char symbol, *class, lexem[20] = "";
  23.    
  24.     while ( (class = translChain[++i].symbol_class) != '\0' ){
  25.         symbol = translChain[i].symbol;
  26.         kw_flag = 0;
  27.         switch(STATE){
  28.         /*bg*/  case 0: if(strcmp(class, "space") == 0)
  29.                     continue;
  30.                 if(strcmp(class, "letter") == 0){
  31.                     STATE = 1;
  32.                     lexem[++j] = symbol;
  33.                     continue;
  34.                 }
  35.                 return -1;
  36.         /*kw1*/ case 1: if(strcmp(class, "space") == 0){
  37.                     STATE = 2;
  38.                     lexem[++j] = '\0';
  39.                     strcpy(lexChain[++l].lexem, lexem);
  40.                     kw_flag = keywordCheck(lexChain,l);
  41.                     if(!kw_flag)
  42.                         lexChain[l].lexem_class = "IDENTIFIER";
  43.                     while(j >= 0)
  44.                         lexem[j--] = "";
  45.                     continue;
  46.                 }
  47.                 if( (strcmp(class, "letter") == 0) || (strcmp(class, "digit") == 0) ){
  48.                     lexem[++j] = symbol;
  49.                     continue;
  50.                 }
  51.                 return -1;
  52.         /*sp1*/ case 2: if(strcmp(class, "space") == 0)
  53.                     continue;
  54.                 if(strcmp(class, "letter") == 0){
  55.                     STATE = 3;
  56.                     strcpy(lexChain[++l].lexem, " ");
  57.                     lexChain[l].lexem_class = "SPACE";
  58.                     lexem[++j] = symbol;
  59.                     continue;                  
  60.                 }
  61.                 return -1;
  62.         /*id1*/ case 3: if(strcmp(class, "space") == 0){
  63.                     STATE = 4;
  64.                     lexem[++j] = '\0';
  65.                     strcpy(lexChain[++l].lexem, lexem);
  66.                     if( (strcmp(lexem, "TRUE") == 0) || (strcmp(lexem, "FALSE") == 0) )
  67.                         lexChain[l].lexem_class = "LOGCONST";
  68.                     else{
  69.                         kw_flag = keywordCheck(lexChain,l);
  70.                         if(!kw_flag)
  71.                             lexChain[l].lexem_class = "IDENTIFIER";
  72.                     }
  73.                     while(j >= 0)
  74.                         lexem[j--] = "";
  75.                     continue;
  76.                 }
  77.                 if( (strcmp(class, "letter") == 0) || (strcmp(class, "digit") == 0) ){
  78.                     lexem[++j] = symbol;
  79.                     continue;
  80.                 }
  81.                 return -1;
  82.         /*sp2*/ case 4: if(strcmp(class, "space") == 0)
  83.                     continue;
  84.                 if(strcmp(class, "letter") == 0){
  85.                     STATE = 5;
  86.                     strcpy(lexChain[++l].lexem, " ");
  87.                     lexChain[l].lexem_class = "SPACE";
  88.                     lexem[++j] = symbol;
  89.                     continue;                  
  90.                 }
  91.                 return -1;
  92.         /*kw2*/ case 5: if(strcmp(class, "space") == 0){
  93.                     STATE = 6;
  94.                     lexem[++j] = '\0';
  95.                     strcpy(lexChain[++l].lexem, lexem);
  96.                     kw_flag = keywordCheck(lexChain,l);
  97.                     if(!kw_flag)
  98.                         lexChain[l].lexem_class = "IDENTIFIER";
  99.                     while(j >= 0)
  100.                         lexem[j--] = "";
  101.                     continue;
  102.                 }
  103.                 if( (strcmp(class, "letter") == 0) || (strcmp(class, "digit") == 0) ){
  104.                     lexem[++j] = symbol;
  105.                     continue;
  106.                 }
  107.                 return -1;         
  108.         /*sp3*/ case 6: if(strcmp(class, "space") == 0)
  109.                     continue;
  110.                 if(strcmp(class, "letter") == 0){
  111.                     STATE = 7;
  112.                     strcpy(lexChain[++l].lexem, " ");
  113.                     lexChain[l].lexem_class = "SPACE";
  114.                     lexem[++j] = symbol;
  115.                     continue;                  
  116.                 }
  117.                 return -1;         
  118.         /*id2*/ case 7: if(strcmp(class, "space") == 0){
  119.                     STATE = 8;
  120.                     lexem[++j] = '\0';
  121.                     strcpy(lexChain[++l].lexem, lexem);
  122.                     kw_flag = keywordCheck(lexChain,l);
  123.                     if(!kw_flag)
  124.                         lexChain[l].lexem_class = "IDENTIFIER";
  125.                     while(j >= 0)
  126.                         lexem[j--] = "";
  127.                     continue;
  128.                 }
  129.                 if(strcmp(class, "colon") == 0){
  130.                     STATE = 9;
  131.                     lexem[++j] = '\0';
  132.                     strcpy(lexChain[++l].lexem, lexem);
  133.                     kw_flag = keywordCheck(lexChain,l);
  134.                     if(!kw_flag)
  135.                         lexChain[l].lexem_class = "IDENTIFIER";
  136.                     while(j >= 0)
  137.                         lexem[j--] = "";
  138.                     lexem[++j] = symbol;
  139.                     continue;
  140.                 }
  141.                 if( (strcmp(class, "letter") == 0) || (strcmp(class, "digit") == 0) ){
  142.                     lexem[++j] = symbol;
  143.                     continue;
  144.                 }
  145.                 return -1;     
  146.         /*sp4*/ case 8: if(strcmp(class, "space") == 0)
  147.                     continue;
  148.                 if(strcmp(class, "colon") == 0){
  149.                     STATE = 9;
  150.                     strcpy(lexChain[++l].lexem, " ");
  151.                     lexChain[l].lexem_class = "SPACE";
  152.                     lexem[++j] = symbol;
  153.                     continue;                  
  154.                 }
  155.                 return -1;
  156.         /*cl*/  case 9: if(strcmp(class, "equals") == 0){
  157.                     STATE = 10;
  158.                     lexem[++j] = symbol;
  159.                     continue;
  160.                 }
  161.                 return -1;
  162.         /*eq*/  case 10: if(strcmp(class, "space") == 0)
  163.                     continue;
  164.                  if(strcmp(class, "letter") == 0){
  165.                     STATE = 11;
  166.                     lexem[++j] = '\0';
  167.                     strcpy(lexChain[++l].lexem, lexem);
  168.                     lexChain[l].lexem_class = "ASSIGNS";
  169.                     while(j >= 0)
  170.                         lexem[j--] = "";
  171.                     lexem[++j] = symbol;
  172.                     continue;
  173.                  }
  174.         /*id3*/ case 11: if(strcmp(class, "space") == 0){
  175.                     STATE = 12;
  176.                     lexem[++j] = '\0';
  177.                     strcpy(lexChain[++l].lexem, lexem);
  178.                     kw_flag = keywordCheck(lexChain,l);
  179.                     if(!kw_flag)
  180.                         lexChain[l].lexem_class = "IDENTIFIER";
  181.                     while(j >= 0)
  182.                         lexem[j--] = "";
  183.                     continue;
  184.                 }
  185.                 if(strcmp(class, "semicolon") == 0){
  186.                     STATE = 18;
  187.                     lexem[++j] = '\0';
  188.                     strcpy(lexChain[++l].lexem, lexem);
  189.                     kw_flag = keywordCheck(lexChain,l);
  190.                     if(!kw_flag)
  191.                         lexChain[l].lexem_class = "IDENTIFIER";
  192.                     while(j >= 0)
  193.                         lexem[j--] = "";
  194.                     strcpy(lexChain[++l].lexem, ";");
  195.                     lexChain[l].lexem_class = "SEMICOLON";
  196.                     continue;
  197.                 }
  198.                 if(strcmp(class, "bracket_o") == 0){
  199.                     STATE = 13;
  200.                     lexem[++j] = '\0';
  201.                     strcpy(lexChain[++l].lexem, lexem);
  202.                     kw_flag = keywordCheck(lexChain,l);
  203.                     if(!kw_flag)
  204.                         lexChain[l].lexem_class = "IDENTIFIER";
  205.                     while(j >= 0)
  206.                         lexem[j--] = "";
  207.                     lexem[++j] = symbol;
  208.                     continue;
  209.                 }
  210.                 if( (strcmp(class, "letter") == 0) || (strcmp(class, "digit") == 0) ){
  211.                     lexem[++j] = symbol;
  212.                     continue;
  213.                 }
  214.                 return -1;
  215.         /*sp5*/ case 12: if(strcmp(class, "space") == 0)
  216.                     continue;
  217.                 if(strcmp(class, "semicolon") == 0){
  218.                     STATE = 18;
  219.                     strcpy(lexChain[++l].lexem, " ");
  220.                     lexChain[l].lexem_class = "SPACE";
  221.                     strcpy(lexChain[++l].lexem, ";");
  222.                     lexChain[l].lexem_class = "SEMICOLON";
  223.                     continue;                  
  224.                 }
  225.                 if(strcmp(class, "bracket_o") == 0){
  226.                     STATE = 13;
  227.                     strcpy(lexChain[++l].lexem, " ");
  228.                     lexChain[l].lexem_class = "SPACE";
  229.                     while(j >= 0)
  230.                         lexem[j--] = "";
  231.                     continue;
  232.                 }
  233.                 return -1;
  234.         /*b_o*/ case 13: if(strcmp(class, "sign") == 0){
  235.                     STATE = 14;
  236.                     lexem[++j] = symbol;
  237.                     continue;
  238.                 }
  239.                 if(strcmp(class, "digit") == 0){
  240.                     STATE = 15;
  241.                     lexem[++j] = symbol;
  242.                     continue;
  243.                 }
  244.                 return -1;
  245.         /*sg*/  case 14: if(strcmp(class, "digit") == 0){
  246.                     STATE = 15;
  247.                     lexem[++j] = symbol;
  248.                     continue;
  249.                 }
  250.                 return -1;
  251.         /*dg*/  case 15: if(strcmp(class, "digit") == 0){
  252.                     lexem[++j] = symbol;
  253.                     continue;
  254.                 }
  255.                 if(strcmp(class, "bracket_c") == 0){
  256.                     STATE = 16;
  257.                     lexem[++j] = symbol;
  258.                     continue;
  259.                 }
  260.                 return -1;
  261.         /*b_c*/ case 16: if(strcmp(class, "space") == 0){
  262.                     STATE = 17;
  263.                     lexem[++j] = '\0';
  264.                     strcpy(lexChain[++l].lexem, lexem);
  265.                     lexChain[l].lexem_class = "INDEX";
  266.                     while(j >= 0)
  267.                         lexem[j--] = "";
  268.                     continue;
  269.                 }
  270.                 if(strcmp(class, "semicolon") == 0){
  271.                     STATE = 18;
  272.                     lexem[++j] = '\0';
  273.                     strcpy(lexChain[++l].lexem, lexem);
  274.                     lexChain[l].lexem_class = "INDEX";
  275.                     while(j >= 0)
  276.                         lexem[j--] = "";
  277.                     strcpy(lexChain[++l].lexem, ";");
  278.                     lexChain[l].lexem_class = "SEMICOLON";
  279.                     continue;
  280.                 }
  281.                 return -1;
  282.         /*sp6*/ case 17: if(strcmp(class, "space") == 0)
  283.                     continue;
  284.                 if(strcmp(class, "semicolon") == 0){
  285.                     STATE = 18;
  286.                     strcpy(lexChain[++l].lexem, " ");
  287.                     lexChain[l].lexem_class = "SPACE";
  288.                     strcpy(lexChain[++l].lexem, ";");
  289.                     lexChain[l].lexem_class = "SEMICOLON";
  290.                     continue;
  291.                 }
  292.                 return -1;
  293.         /*sc*/  case 18: if(strcmp(class, "space") == 0)
  294.                     continue;
  295.                  return -1;
  296.         }
  297.     }
  298.    
  299.     return l;
  300. }
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!