ass3_12CS10006.tar

ass3_12CS10006/ass3_12CS10006.l000664 001750 001750 00000004526 12374431644 015512 0ustar00ankitankit000000 000000 %{
#include"y.tab.h"
%}

keyword1 "switch"|"typedef"|"union"|"unsigned"|"void"|"volatile"|"while"|"_Bool"|"_Complex"|"_Imaginary"|"struct"
keyword2 "auto"|"break"|"case"|"char"|"const"|"continue"|"default"|"do"|"double"|"else"|"enum"|"extern"|"float"
keyword3 "for"|"goto"|"if"|"inline"|"int"|"long"|"register"|"restrict"|"return"|"short"|"signed"|"sizeof"|"static"

keyword {keyword1}|{keyword2}|{keyword3}

nondigit [a-zA-Z]
nz_digit [1-9]
digit [0-9]

identifier {nondigit}({nondigit}|{digit})*

int_const {digit}|({nz_digit}{digit}*)

escape-sequence [\']|[\"]|[\?]|[\\]|[\a]|[\b]|[\f]|[\n]|[\r]|[\t]|[\v]

cescape-sequence [\"]|[\?]|[\\]|[\a]|[\b]|[\f]|[\n]|[\r]|[\t]|[\v]  
c-char      escape-sequence|[^\'\\\n]  
c-char-sequence   {c-char}+
character-constant \'{c-char-sequence}\'
enumeration-constant {identifier}
digit-sequence {digit}+
sign [+-]
exponent-part [eE]{sign}{digit-sequence}|[eE]{digit-sequence} 

fractional_const ({digit-sequence}\.{digit-sequence})|({digit-sequence}\.)|(\.{digit-sequence})

floating-const ({fractional_const})|({fractional_const}{exponent-part})|({digit-sequence}{exponent-part})

sescape-sequence [\']|[\?]|[\\]|[\a]|[\b]|[\f]|[\n]|[\r]|[\t]|[\v]              
s_char        {sescape-sequence}|[^\"\\\n]
s-char-sequence   {s_char}+
string-literal   [\"][\"]|([\"]{s-char-sequence}[\"])


punctuator1  "["|"+"|"/"|"?"|"="|","|"]"|"("|"{"|"}"|"."|">"|"*"|"+"|"-"|"~"|"!"|"--"
punctuator2  "%"|"<<"|">>"|"<"|">"|"<="|">="|":"|";"|"..."|"*="|"="|"="|"+="|"="|"<<="
punctuator3  ")"|"&"|"=="|">>="|"="|"&="|"^"|"|"|"^="|"&&"|"||"|"|="|"#"
punctuator {punctuator1}|{punctuator2}|{punctuator3}

single_comment "//".*[\n]
multi_comment  "/*"([^*]|\*+[^*/])*\*+"/"
comment {single_comment}|{multi_comment}

%%
{keyword}  { fprintf(yyout,"<keyword,%s>\n",yytext); return keyword;}
{identifier} { fprintf(yyout,"<identifier,%s>\n",yytext);return identifier;}
{int_const} {fprintf(yyout,"<int_const,%s>\n",yytext);return int_const;}
{floating-const} {fprintf(yyout,"<floating-const,%s>\n",yytext);return floating_const ;}
{character-constant} {fprintf(yyout,"<character-constant,%s>\n",yytext);return character_constant;}
{string-literal} {fprintf(yyout,"<string-literal,%s>\n",yytext);return string_literal;}
{punctuator} {fprintf(yyout,"<punctuator,'%s'>\n",yytext);return punctuator;}
{comment} {}
[\n\t' ']  {}
 <<EOF>>  {return EOF;yyterminate();}
%%

ass3_12CS10006/Makefile000664 001750 001750 00000000621 12373543122 014767 0ustar00ankitankit000000 000000 a.out: ass3_12CS10006.o lex.yy.o y.tab.o 
	cc ass3_12CS10006.o lex.yy.o y.tab.o -lfl 
y.tab.o: y.tab.c
	cc -c y.tab.c
y.tab.c: ass3_12CS10006.y
	yacc -dtv ass3_12CS10006.y
lex.yy.o: lex.yy.c y.tab.o 
	cc -c lex.yy.c
lex.yy.c: ass3_12CS10006.l
	flex ass3_12CS10006.l
ass3_12CS10006.o: ass3_12CS10006.c
	cc -c ass3_12CS10006.c
clean:
	rm lex.yy.c lex.yy.o a.out y.tab.o y.tab.c ass3_12CS10006.o y.tab.h
ass3_12CS10006/ass3_12CS10006.c000644 001750 001750 00000000450 12374431611 015461 0ustar00ankitankit000000 000000 #include<stdio.h>
extern FILE* yyin;
extern FILE* yyout;
extern int yyparse();
int main(int argc,char *argv[])
{
 
 yyin=fopen("ass3_12CS10006_test.c","r");
 yyout=fopen("ass3_12CS10006_result.c","w");
int rtn;
 do
{
  rtn=yylex();
 }while(rtn!=EOF);
  fclose(yyin);
  fclose(yyout);
return 0;
}
ass3_12CS10006/000755 001750 001750 00000000000 12374301702 013323 5ustar00ankitankit000000 000000 ass3_12CS10006/ass3_12CS10006.y000664 001750 001750 00000001050 12373541132 015505 0ustar00ankitankit000000 000000 %{ /* C Declarations and Definitions */
#include <string.h>
 extern int yylex();
 void yyerror(char *s);
%}
%union {
 int intval;
 float floatval;
 char *stringval;
       }
 %token <intval> keyword
 %token <intval> identifier
  %token <intval> int_const  
 %token <intval> floating_const
 %token <intval> enumeration_constant  
  %token <intval> character_constant
  %token <intval> string_literal  
  %token <intval> punctuator   
     
%type <intval> expression

%%
 expression: {printf("YACC");}

%%

void yyerror(char *s) {
  printf("%s\n",s);
}

ass3_12CS10006/ass3_12CS10006_test.c000664 001750 001750 00000003141 12374431554 016530 0ustar00ankitankit000000 000000 /* Compliler Laboratory Assignment 3
   Test file to test scanner it scans input from this ass3_12CS10006_test.c 
 /*  // and it generates token stream in ass3_12CS10006_result.c 
 created by : Ankit Kumar Gupta
*/

//  function to test 
#include<stdio.h>

//this test file checks all the functionality that tiny C supports

void quicksort(int [10],int,int);  // a simple quick sort algorithm

int main(){                      // function starts
  int x[20],size,j;  
  float f=0.0,0,.0,7.;            // to check const_float 
  char c='d','hkhk';			// to check const_char
  int i=0,j=6;6575;                     // check const_int 

  printf("Enter size of the array: ");  // check string literal functionality
  scanf("%d",&size);     //Punctuators and identifiers

  printf("Enter %d elements: ",size);
  for(i=0;i<size;i++)
    scanf("%d",&x[i]);              

  quicksort(x,0,size-1);

  printf("Sorted elements: ");
  for(i=0;i<size;i++)
    printf(" %d",x[i]);

  return 0;
}

// recursive function to sort array 
void quicksort(int x[10],int first,int last){
    int pivot,j,temp,i;

     if(first<last){
         pivot=first;
         i=first;
         j=last;

         while(i<j){
             while(x[i]<=x[pivot]&&i<last)
                 i++;
             while(x[j]>x[pivot])
                 j--;
             if(i<j){
                 temp=x[i];
                  x[i]=x[j];
                  x[j]=temp;
             }
         }

         temp=x[pivot];
         x[pivot]=x[j];
         x[j]=temp;
         quicksort(x,first,j-1);
         quicksort(x,j+1,last);

    }
}

/* 

this is non terminating comment

*