warning: passing argument .. makes integer from pointer without a cast

%{
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
	
#define YYDEBUG 1
 
extern int  yyparse();
 extern int yylex();
 extern int line  ;
 
 
extern FILE *yyin;	
 
int yywrap()
 {
    return 1;
 }
   
void yyerror( const char *msg )
{
  printf("Line %d: %s\n",line, msg); 
}
 
enum treetype {operator_node, number_node, variable_node};
 typedef struct tree {
   enum treetype nodetype;
   union {
     struct {struct tree *left, *right; char operator;} an_operator;
     int ival;
     char * sval;
   } body;
 } tree;
 
 static tree *make_operator (tree *l, char o, tree *r) {
   tree *result= (tree*) malloc (sizeof(tree));
   result->nodetype= operator_node;
   result->body.an_operator.left= l;
   result->body.an_operator.operator= o;
   result->body.an_operator.right= r;
   return result;
 }
 
 static tree *make_number (int n) {
   tree *result= (tree*) malloc (sizeof(tree));
   result->nodetype= number_node;
   result->body.ival= n;
   return result;
 }
 
 static tree *make_variable (char v) {
   tree *result= (tree*) malloc (sizeof(tree));
   result->nodetype= variable_node;
   result->body.sval= v;
   return result;
 }
 
 
%}
 
%start goal
 
%union {
	int ival;
	char * sval;
        tree * t;
}
 
%token <sval> IDENTIFIER
%token <sval> VARIABLE
%token <ival> INTEGER
 /*%token <ival> FLOAT*/
%token <sval> STRING
%token <sval> LITERAL
%token <sval> UNKNOWN 
%token <sval> PLUS
%token <sval> MINUS
%token <sval> TIMES
%token <sval> SLASH
%token <sval> LPAREN
%token <sval> RPAREN
%token <sval> SEMICOLON
%token <sval> COMMA
%token <sval> EQL
%token <sval> OR 
%token <sval> ORR
%token <sval> AND
%token <sval> ANDD
 
 
/* keywords */
%token <sval> IF
%token <sval> ELSE
%token <sval> DO
%token <sval> INT
%token <sval> RETURN
%token <sval> VOID
%token <sval> FLOAT
%token <sval> WHILE
 
%type <t> goal
%type <ival> expression
%type <ival> term 
%type <ival> factor 
%type <sval> ifstatement
%type <sval> whilestatement
%type <sval> dostatement
%type <sval> variable_list
%type <sval> variable 
 
 
 
%%
 
goal	: statement_list;
        ;
 
statement_list: { /*empty*/ }
                | statement_list statement   
		;
 
statement : declaration_statement
          | ifstatement 
          | whilestatement
          | variable '=' expression SEMICOLON 
          | dostatement 
          |returnstatement 
          ;
 
declaration_statement : INT variable_list SEMICOLON {printf("INT_VARIABLE\n");}
                      | FLOAT variable_list SEMICOLON {printf("FLOAT_VARIABLE\n");}
                      ;
 
 
 
expression		:	term '+' term {printf("ADDITION\n");} {$$ = make_operator($1, '+', $3);}
|	term '-' term {printf("SUBTRACTION\n");} {$$ = make_operator ($1, '-' ,$3);}
|	term {printf("\n");}  {$$ = $1;}   ;
 
 
 
 
term			:	factor '*' factor  {printf("MULTIPLICATION\n");} {$$ = make_operator($1,'*', $3);}
|	factor '/' factor  {printf("DIVISION\n");} {$$ = make_operator($1, '/', $3);} 
|	factor {printf("\n");}  {$$ = $1;}  ;
 
 
factor			:	variable {printf("rule 7\n");} 
|	INTEGER {printf("integer\n");} {$$ = make_number($1);} 
|	FLOAT {printf("float\n");}  {$$ = make_number($1);}
|	STRING {printf("string\n");}  {$$ = make_variable($1);}
|	'(' expression ')' {$$ = $2;} ;
 
ifstatement		:	IF '(' expression ')' goal ELSE goal SEMICOLON {printf("rule: IF_ELSE_STATEMENT\n");}
|	IF '(' expression ')' goal {printf("rule: IF_STATEMENT\n");};
 
whilestatement	:	WHILE '(' expression ')' goal {printf("rule: WHILE_STATEMENT\n");};
	
		
dostatement : DO '(' expression ')' WHILE '(' expression ')' SEMICOLON   {printf("rule DO_STATEMENT\n");} ;
 
returnstatement : RETURN { } SEMICOLON   {printf("rule RETURN_STATEMENT\n");} ;
| RETURN factor SEMICOLON {printf("rule : RETURN 2\n");} 
;
 
 
variable : VARIABLE {printf("rule: variable2\n");} {$$= make_variable($1); };
 
	
variable_list : variable {printf("rule : variable1\n");}  {$$= make_variable($1); }
|  variable_list ',' variable {printf("rule: multvar\n");} {$$ = make_variable($1);} //	variable ',' variable_list {printf("rule: var,var\n");}  ;
;
 
%%
 
#include "lex.yy.c"
 
main(int argc,char *argv[])
{
 if(argc<1)
   {
    printf("Please specify the input file\n");
    exit(0);
   }
 FILE *fp=fopen(argv[1],"r");
 if(!fp)
   {
     printf("couldn't open file for reading\n");
     exit(0);
   }
 yyin=fp;
 
 do {
   yyparse();
 }while (!feof(yyin));
 
 fclose(fp);
}
 
 
 
 
 static void printtree (tree *t, int level) {
 #define step 4
   if (t)
     switch (t->nodetype)
     {
       case operator_node:
        printtree (t->body.an_operator.right, level+step);
        printf ("%*c%c\n", level, ' ', t->body.an_operator.operator);
        printtree (t->body.an_operator.left, level+step);
        break;
       case number_node:
        printf ("%*c%d\n", level, ' ', t->body.ival);
        break;
       case variable_node:
        printf ("%*c%c\n", level, ' ', t->body.sval);
     }
 }
 
 
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221: