/*
	Produit les fichiers d'interface pour un serveur.

	deux fichier .h et un .c sont produit pour les clients. Un fichier
	.c est produit pour le serveur.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <etc.h>
#include "bserv.h"
/*
	D‚compose une d‚claration d'argument en type et nom
*/
PROTECTED void FCT_ARG::anlsplit(const char *declstr)
{
	const char *endarg = declstr + strlen(declstr) - 1;
	while (isalnum(*endarg) || *endarg == '_') endarg--;
	endarg++;
	nom = strdup_err (endarg,1);
	char tmp[200];
	int size = (int)(endarg-declstr);
	strncpy (tmp,declstr,size);
	tmp[size] = '\0';
	strip (tmp);
	type.set (tmp);
}

PUBLIC FCT_ARG::FCT_ARG(const char *argstr)
{
	anlsplit (argstr);
}
PUBLIC FCT_ARG::FCT_ARG()
{
	nom  = NULL;
}

/*
	Enregistre la d‚claration d'un argument.
	Remplace la d‚claration pr‚c‚dante.
*/
PUBLIC void FCT_ARG::set(const char *argstr)
{
	free (nom);
	anlsplit (argstr);
}

/*
	Retourne le type d'un argument
*/
PUBLIC const char *FCT_ARG::gettype()
{
	return type.getdecl();
}

/*
	D‚termine la cat‚gorie du type de l'argument.
	0: Atomique standard (type de base du C++).
	1: Type standard array ou pointeur.
	2: User define atomique.
	3: User define array ou pointeur.

	ATTENTION: fonction pas encore termin‚e.
*/
PUBLIC int FCT_ARG::categ()
{
	return type.categ();
}
/*
	Retourne le nom d'un argument
*/
PUBLIC const char *FCT_ARG::getnom()
{
	const char *ret = NULL;
	if (strcmp(nom,"void")!=0) ret = nom;
	return ret;
}

/*
	Formatte la d‚claration d'un argument dans une chaine.
	Retourne la longueur de la chaine produite.
*/
PUBLIC int FCT_ARG::format (char *buf)
{
	char *debut = buf;
	buf = stpcpy (buf,type.getdecl());
	*buf++ = ' ';
	buf = stpcpy (buf,nom);
	return (int)(buf - debut);
}

/*
*/
PUBLIC FCT_INFO::FCT_INFO()
{
	args = NULL;
	nbarg = 0;
	nom = NULL;
	cls = NULL;
}
/*
	D‚compose une declaration de fonction membre.
	Seule les fonctions PUBLIC sont accept‚es.
	Seule les fonctions membres de la classe sel_cls sont accept‚es.
	Retourne != 0 si accept‚e.
*/
PUBLIC int FCT_INFO::parse (char *proto, const char *sel_cls)
{
	int publi = 0;
	int okcls = 0;
	char tmptype[100];		// Accumule le type
	tmptype[0] = '\0';
	while (*proto != '\0'){
		proto = str_skip(proto);
		if (proto[0] == '(') break; // D‚but des arguments
		char mot[100];
		char *fct;
		proto = str_copymot(mot,proto);
		if (strcmp(mot,"PUBLIC")==0){
			publi = 1;
		}else if ((fct=strchr(mot,':'))!=NULL){
			*fct = '\0';
			fct += 2;
			if (publi && strcmp(mot,sel_cls)==0){
				nom = strdup_err (fct,1);
				cls = strdup_err (sel_cls,1);
				strip (tmptype);
				type.set (tmptype);
				okcls = 1;
				break;
			}			
		}else if (strcmp(mot,"VIRTUAL")!=0){
			strcat (tmptype,mot);
			strcat (tmptype," ");
		}
	}
	if (okcls){
		proto = str_skip(proto);
		assert (*proto == '(');
		// Accumule les arguments
		// Assume arguments ultra simple, le dernier mot avant ) ou , est
		// le nom de l'argument, tous ce qui precede est le type.
		// Pas de parenthese.
		proto++;
		nbarg = 0;
		args = new FCT_ARG[50];
		int fin = 0;
		while (!fin){
			char *debtyp = proto;
			while (1){
				if (*proto == ','){
					break;
				}else if (*proto == ')'){
					fin = 1;
					break;
				}
				proto++;
			}
			*proto++ = '\0';
			strip (debtyp);
			if (debtyp[0] != '\0' && strcmp(debtyp,"void") != 0){
				args[nbarg++].set (debtyp);
			}
		}
#if 0
		if (nbarg != 0){
			args = (FCT_ARG*) malloc_err (nbarg*sizeof(FCT_ARG),1);
			memcpy (args,tmpargs,nbarg*sizeof(FCT_ARG));
		}
#endif
	}
	return okcls;
}

/*
	Formatte les arguments d'une fonction (nom seulement)
*/
PUBLIC void FCT_INFO::prtarg(
	FILE *fout,
	const char *ctl0,	// Chaine de controle pour premier argument
	const char *ctln)	// Chaine de controle pour les suivant.
{
	for (int a = 0; a<nbarg; a++){
		fprintf (fout,ctl0,args[a].getnom());
		ctl0 = ctln;
	}
}
/*
	Formatte les arguments d'une fonction, type + nom.
*/
PUBLIC void FCT_INFO::prtargd(
	FILE *fout,
	const char *ctl0,	// Chaine de controle pour premier argument
	const char *ctln)	// Chaine de controle pour les suivant.
{
	for (int a = 0; a<nbarg; a++){
		char buf[100];
		args[a].format(buf);
		fprintf (fout,ctl0,buf);
		ctl0 = ctln;
	}
}
/*
	Formatte l'information d'une fonction pour cr‚er une cl‚ unique.
	C'est en combinant toutes les cl‚s des fonctions visibles d'un
	serveur qu'on pourra assurer qu'un serveur est bien compatible
	avec ce que le client demande.
*/
PUBLIC void FCT_INFO::prtcle(
	FILE *fout)
{
	/* #Sp‚cification: protocole / validation de type
		Lorsqu'un client entre en communication avec un serveur,
		il transmet une cl‚ d'identification pour chacune des
		fonctions membres qu'il veut utiliser en plus d'une cl‚
		d'identification de la classe qu'il utilise.

		La cl‚ des fonction membre est un concat‚nation du type
		de la fonction, du nom, ainsi que du type de chaque argument.
		Chaque ‚l‚ment est s‚par‚ par un tiret.
		La cl‚ est termin‚ par un \n.
	*/
	fprintf (fout,"%s-%s",type.getdecl(),nom);
	for (int a = 0; a<nbarg; a++){
		fprintf (fout,"-%s",args[a].gettype());
	}
	fprintf (fout,"\\n");
}

/*
	Retourne != 0 si cette fonction est un des constructeur de la classe
*/
PUBLIC int FCT_INFO::is_construct ()
{
	return strcmp(cls,nom)==0;
}
/*
	Retourne != 0 si cette fonction est le destructeur de la classe
*/
PUBLIC int FCT_INFO::is_destruct ()
{
	return nom[0] == '~' && strcmp(cls,nom+1)==0;
}