break;
			}
		case	'<':
		case	'>':
		case	'=':
			{				/*說明已經到了葉節點，該顯示了*/
			error_var=one_select_con_check(dic,ss->st,stack[p]);/*看這個子條件是否正確*/
			if (strcmp(error_var,"")!=0)
			{	
				return(error_var);
			}
			p--;
			if (p>=0)		st_int[p]++;
			break;
			}
		}
	}while(p!=-1);
	return("");
}

char *one_delete_con_check(_dic_type *dic,char *table,_conditions_type *cons)
{						/*檢查一個條件比較式的正確性*/
	char 		left_type,right_type;
	_conditions_type 	*left,*right;
	char 		*error_var;
	_selectedtables_type	*st;	/*虛擬建立一個被選擇的表的鏈，其實只有一個表，是為了函數傳參數*/
	
	st=(_selectedtables_type *)malloc(sizeof(_selectedtables_type));
	st->table=table;
	st->next_st=NULL;

	left=cons->left;
	right=cons->right;
						/*先判斷左半邊是否是正確的字段*/
	error_var=is_a_right_col_used(left->value,left->table,st,dic);
	if (strcmp(error_var,"")!=0)
	{	return(error_var);
	}
	left_type=get_type_of_col(dic,left->table,left->value);	/*獲得字段的類型*/

	if (right->type=='2')			/*表示右節點也是字段*/
	{					/*判斷右半邊是否是正確的字段*/
		error_var=is_a_right_col_used(right->value,right->table,st,dic);
		////////////////////////////////////free st?
		if (strcmp(error_var,"")!=0)
		{	return(error_var);
		}
		right_type=get_type_of_col(dic,right->table,right->value);	/*獲得字段的類型*/
	}
	else
	{	right_type=right->type;		/*如果不是字段，也要獲得字段的類型*/
	}

	if (left_type!=right_type) 		/*左右兩邊的類型不匹配*/
	{	return(ERROR0006);
	}
	
	if ((cons->comp_op=='>' || cons->comp_op=='<') && right_type=='1')	/*企圖用<,>來判斷字符串*/
	{	return(ERROR0007);
	}
    free(st);
	/////////////////////////////////free st??????????
	return("");
}

char *delete_cons_check(_dic_type *dic,_deletestruct_type *ds)
{						/*delete語句中where子句的檢查*/
	_conditions_type *stack[20];		/*堆棧，存放中間節點*/
	int	st_int[20];		/*輔助堆棧，用來標識對應stack堆棧中節點的左右節點的入棧情況*/
	int	p=0;
	char	*error_var;
	stack[p]=ds->cons;
	st_int[p]=0;
	do
	{
		switch (stack[p]->comp_op)
		{case	'a':
		case	'o':
			{
			switch  (st_int[p])
			{case 0 : /*表示沒有子節點入棧了*/
				{p++;
				stack[p]=stack[p-1]->left;
				st_int[p]=0;
				break;
				}
			case 1 :  /*表示左節點入棧了*/
				{p++;		
				stack[p]=stack[p-1]->right;
				st_int[p]=0;
				break;
				}
			case 2 :  /*表示右節點入棧了*/
				{		
				p--;
				if (p>=0) st_int[p]++;
				break;
				}
			}
			break;
			}
		case	'<':
		case	'>':
		case	'=':
			{				/*說明已經到了葉節點，該顯示了*/
			error_var=one_delete_con_check(dic,ds->table,stack[p]);/*看這個子條件是否正確*/
			if (strcmp(error_var,"")!=0)
			{	
				return(error_var);
			}
			p--;
			if (p>=0)		st_int[p]++;
			break;
			}
		}
	}while(p!=-1);
	return("");
}



char *select_errorcheck(_dic_type *dic, _selectstruct_type *ss)
{					/*初步檢查select語句的語義正確性，與數據字典有關的部分*/
	_selectedfields_type *sf1;
	_selectedtables_type *st1;
	char 	*error_var="";

	st1=ss->st;
	do			/*判斷選擇的表名是否是數據字典中已經有的*/
	{
		error_var=is_an_exist_table(dic->tab,dic->tab_num,st1->table);
		if (strcmp(error_var,"")!=0) 
		{	return(error_var); 
		}
		if(st1->next_st==NULL) 	break;
		st1=st1->next_st;
	}while(1);

	sf1=ss->sf;
	if (strcmp(sf1->field,"*")!=0)
	{do
	{		
		st1=ss->st;
		error_var=is_a_right_col_used(sf1->field,sf1->table,st1,dic);
		if (strcmp(error_var,"")!=0)	
		{	return(error_var);
		}
		if (sf1->next_sf==NULL) break;
		sf1=sf1->next_sf;
	}while(1);
	}/*endif*/
	
	if (ss->cons!=NULL)
	{	error_var=select_cons_check(dic,ss);
		if (strcmp(error_var,"")!=0)
		{	return(error_var);
		}
	}
	return("");
}

char *delete_errorcheck(_dic_type *dic,_deletestruct_type *ds)
{					/*初步檢查delete語句的語義正確性，與數據字典有關的部分*/
	char *error_var;
	error_var=is_an_exist_table(dic->tab,dic->tab_num,ds->table);
	if (strcmp(error_var,"")!=0)
	{	return(error_var);
	}

	if (ds->cons!=NULL)
	{	error_var=delete_cons_check(dic,ds);
		if (strcmp(error_var,"")!=0)
		{	return(error_var);
		}
	}
	return("");
}

char *create_fields_check(_createfieldsdef_type *fdef)
{					/*檢查一個字段后面是否有和它同名的字段被創建*/
	_createfieldsdef_type	*fdef1;
	fdef1=fdef->next_fdef;

	if (strlen(fdef->field)>30)	/*字段名稱太長*/
	{	return(ERROR0011);
	}


	while(fdef1!=NULL)
	{
		if (strcmp(fdef->field,fdef1->field)==0)
		{	return(ERROR0010);
		}
		fdef1=fdef1->next_fdef;
	}

	return("");
}

char *create_errorcheck(_dic_type *dic,_createstruct_type *cs)
{						/*初步檢查create語句的語義正確性，與數據字典有關的部分*/
	char *error_var;
	_createfieldsdef_type	*fdef1;
	fdef1=cs->fdef;

	error_var=is_an_exist_table(dic->tab,dic->tab_num,cs->table);
	if (strcmp(error_var,"")==0)	/*如果已經有了這個表名，出錯*/
	{	return(ERROR0008);
	}
	if (strlen(cs->table)>100)		/*表名稱太長*/
	{	return(ERROR0009);
	}
	
	do
	{
		error_var=create_fields_check(fdef1);	/*檢查后面有沒有同名字段*/
		if (strcmp(error_var,"")!=0)
		{	return(error_var);
		}
		fdef1=fdef1->next_fdef;
	}while(fdef1!=NULL);
	return("");
}	


char *drop_errorcheck(_dic_type *dic,_dropstruct_type *drs)
{				/*初步檢查drop語句的語義正確性，與數據字典有關的部分*/
	char *error_var;
	error_var=is_an_exist_table(dic->tab,dic->tab_num,drs->table);
	if (strcmp(error_var,"")!=0)
	{	return(error_var);
	}
	return("");
}



/*-------------------------------------------------------------insert-----not completed---*/	

void	add_insert_fields(_dic_type *dic,_insertstruct_type *is)
{					/*如果沒有列出字段名，就給加進去*/
	_insertfields_type		*ifs1,*ifs_var;
	int	tab_id;
	int	i;
	
	ifs1=is->ifs;	/*利用這個指針，將屬于給出表的所有字段一個個連下去*/

	tab_id=get_tab_id(dic->tab,dic->tab_num,is->table);
	for (i=0;i<dic->col_num;i++)
	{
		if (tab_id==dic->col[i].tab_id) 	/*如果這字段屬于給出表*/
		{		
			ifs_var=(_insertfields_type *)malloc(sizeof(_insertfields_type));
			ifs_var->field=(char *)malloc(sizeof(strlen(dic->col[i].col_name)+1));
			strcpy(ifs_var->field,dic->col[i].col_name);
			ifs_var->next_if=NULL;
			ifs1->next_if=ifs_var;
			ifs1=ifs1->next_if;
		}
	}
	is->ifs=is->ifs->next_if;
//	free(ifs_var->field);
//	free(ifs_var);
	////////////////////////////////////////// free ?

}


char *insert_errorcheck(_dic_type *dic,_insertstruct_type *is)
{									/*初步檢查insert語句的語義正確性，與數據字典有關的部分*/
	char	*error_var;
	_insertfields_type		*ifs1;
	_insertvalues_type		*iv1;
	_col_dic_type 		*col_info;

	ifs1=is->ifs;

	error_var=is_an_exist_table(dic->tab,dic->tab_num,is->table);
	if (strcmp(error_var,"")!=0)	/*如果沒有這個表，出錯*/
	{	return(ERROR0001);
	}

	if (strcmp(ifs1->field,"")==0)			/*如果沒有列出字段名，就先給加進去*/
	{	add_insert_fields(dic,is);
	    ///////////////////////////free is ?????????????
	}

	ifs1=is->ifs;
	iv1=is->iv;

	do 
	{	
		col_info=get_info_of_a_col(dic,is->table,ifs1->field);
		if (col_info==NULL)			/*無返回值表示表中沒有這列*/
		{	return(ERROR0003);
		}
		
//		printf("%c,%d\n",iv1->type,col_info->col_type ); 
		if (col_info->col_type==3 )
		{
			if(is_date(iv1->value) && (iv1->type =='1'))
				iv1->type='3';
			else
				return(ERROR0016);			/*插入日期非法*/
		}
		if (iv1->type!=(col_info->col_type+'0'))
		{	return(ERROR0012);			/*字段和插入值類型不匹配*/
		}

		if (iv1->type=='1' && strlen(iv1->value)>(unsigned int)col_info->col_length)
		{	
	printf("iv1->value=%s,col_info->col_length=%d\n",iv1->value,col_info->col_length );
			return(ERROR0013);			/*插入字符串長度超界*/
		}

		if (iv1->type=='0' && atoi(iv1->value)>32767)
		{	return(ERROR0014);			/*插入數字過大*/
		}

//		if (iv1->type=='3' && is_date(iv1->value))
//		{	return(ERROR0016);			/*插入日期非法*/
//		}		
			
		ifs1=ifs1->next_if;
		iv1=iv1->next_iv;
		if (ifs1==NULL) break;
		if (iv1==NULL) break;
	}while(1);		/*無論是字段結束還是值結束都結束循環*/

	if ((ifs1==NULL && iv1!=NULL) ||(ifs1!=NULL && iv1==NULL))
	{	return(ERROR0015);			/*字段數和插入值數目不等*/
	}	
	return("");

}


void read_dic(struct tab_dic_type *tab,int *tab_num,struct col_dic_type *col,int *col_num)
{							/*讀入數據字典*/
	FILE *fp_tab,*fp_col;
	int i=0;
	fp_tab=fopen("TABLE","rb");
	fp_col=fopen("COLUMN","rb");
	fread(&tab[i],sizeof(struct tab_dic_type),1,fp_tab);
	while (!feof(fp_tab))
	{	fread(&tab[i],sizeof(struct tab_dic_type),1,fp_tab);
//		if(tab[i].tab_name[0]='*')
//			continue;
		i=i+1;
	}
	*tab_num=i-1;
	i=0;
	while (!feof(fp_col))
	{	fread(&col[i],sizeof(struct col_dic_type),1,fp_col);
		i=i+1;
 	}
 	*col_num=i-1;
	fclose(fp_tab);
	fclose(fp_col);
}

	
void selectpro(_selectstruct_type *ss,_dic_type *dic)
{
	select(ss);
}

void createpro(_createstruct_type *cs,_dic_type *dic)	/*用來檢測create語句的語法樹是否正確*/
{
	create(cs);/*建表*/
}

void droppro(_dropstruct_type *drs,_dic_type *dic)	/*用來檢測drop語句的語法樹是否正確*/
{
	drop(drs);/*刪表*/
}

void insertpro(_insertstruct_type *is,_dic_type *dic)	/*用來檢測insert語句的語法樹是否正確*/
{
 //	mean_par(is,dic->tab,dic->tab_num,dic->col,dic->col_num);
	struct tab_dic_type tab[30];
    struct col_dic_type col[300];
    int i,j;
	read_dic(tab,&i,col,&j);
	mean_par(is,tab,i,col,j);
}
void deletepro(_deletestruct_type *ds,_dic_type *dic)	/*用來檢測delete語句的語法樹是否正確*/
{	del(ds);
}

int is_date(char *date)
{
	int i,len,year,month,day;
    char buf[8];
	
	if (strlen(date)!=8)
		return(0);
	for(i=0;i<8;i++)
		if (*(date+i)<'0' || *(date+i)>'9')
			return(0);
	
	strncpy(buf,date,4);
	
	buf[4]='\0';
	year=atoi(buf);
	

	strncpy(buf,date+4,2);
	buf[2]='\0';
	month=atoi(buf);
	if(month<1||month>12)
		return(0);
	strncpy(buf,date+6,2);
	buf[2]='\0';
	day=atoi(buf);
//	printf("%d\n",year);
//	printf("%d\n",month);
//	printf("%d\n",day);
	switch (month)
	{
	case 1:
	case 3:
	case 5:
	case 7:
	case 8:
	case 10:
	case 12:
		if(day>31 ||day ==0 )
			return(0);
		break;
	case 4:
	case 6:
	case 9:
	case 11:
		if(day>30)
			return(0);
		break;
	case 2:
		if ((year%4!=0) ||(year%100==0 && year%400!=0))
		{
			if (day>28||day ==0)
				return(0);
		}
		else
		{
			if(day>29)
				return(0);
		}
		break;
	}
}