symbol2.c

一款开源的soap库

int is_keyword(const char *);

int is_repetition(Entry*);
int is_choice(Entry*);
int is_anytype(Entry*);

char *xsi_type_Tarray(Tnode*);    
char *xsi_type_Darray(Tnode*);    

void matlab_def_table(Table*);
void def_table(Table*);
void out_generate(Tnode *);
int no_of_var(Tnode*);
char *pointer_stuff(Tnode*);
void in_defs(Table*);
void in_defs2(Table*);
void in_defs3(Table*);
void out_defs(Table*);
void mark_defs(Table*);
void in_attach(Table*);
void out_attach(Table*);
void mark(Tnode*);
void defaults(Tnode*);
void soap_put(Tnode*);
void soap_out(Tnode*);
void soap_out_Darray(Tnode *);
void soap_get(Tnode*);
void soap_in(Tnode*); 
void soap_in_Darray(Tnode *);
void soap_instantiate_class(Tnode *);
int get_Darraydims(Tnode *typ);

void soap_serve(Table*);
void generate_proto(Table*, Entry*);
/*
void generate_call(Table*, Entry*);
void generate_server(Table*, Entry*);
*/
void generate_header(Table*);
void generate_schema(Table*);
void gen_schema(FILE*,Table*,char*,char*,int,int,char*,char*,char*,char*);
void gen_type_documentation(FILE *fd, Table *t, Entry *p, char *ns, char *ns1);
void gen_schema_elements_attributes(FILE *fd, Table *t, char *ns, char *ns1, char *encoding, char *style);
void gen_schema_elements(FILE *fd, Tnode *p, char *ns, char *ns1);
int gen_schema_element(FILE *fd, Entry *q, char *ns, char *ns1);
void gen_schema_attributes(FILE *fd, Tnode *p, char *ns, char *ns1);
void gen_wsdl(FILE*,Table*,char*,char*,char*,char*,char*,char*,char*);
void gen_nsmap(FILE*,Symbol*,char*);

void gen_proxy(FILE*,Table*,Symbol*,char*,char*,char*,char*,char*);
void gen_object(FILE*,Table*,Symbol*,char*,char*,char*,char*,char*);
void gen_proxy_header(FILE*,Table*,Symbol*,char*,char*,char*,char*,char*);
void gen_proxy_code(FILE*,Table*,Symbol*,char*,char*,char*,char*,char*);
void gen_object_header(FILE*,Table*,Symbol*,char*,char*,char*,char*,char*);
void gen_object_code(FILE*,Table*,Symbol*,char*,char*,char*,char*,char*);
void gen_method(FILE *fd, Table *table, Entry *method);
void gen_params(FILE *fd, Table *params, Entry *result, int flag);
void gen_call_method(FILE *fd, Table *table, Entry *method, char *name);
void gen_serve_method(FILE *fd, Table *table, Entry *param, char *name);

void gen_data(char*,Table*,char*,char*,char*,char*,char*,char*);
FILE *gen_env(char*,char*,int,Table*,char*,char*,char*,char*,char*,char*);
void gen_field(FILE*,int,Entry*,char*,char*,char*);
void gen_val(FILE*,int,Tnode*,char*,char*,char*);
void gen_atts(FILE*,Table*,char*);

/*
mktype - make a (new) type with a reference to additional information and the
width in bytes required to store objects of that type. A pointer to the
type is returned which can be compared to check if types are identical.
*/
Tnode *
mktype(Type type, void *ref, int width)
{	Tnode	*p;
	int t = 0;
	if (transient != -2 || type > Ttime)
	  t = transient;
	if (type != Tstruct && type != Tclass)
	for (p = Tptr[type]; p != (Tnode*) 0; p = p->next)
		if (p->ref == ref && p->sym == (Symbol*) 0 && p->width == width && p->transient == t)
			return p;	/* type alrady exists in table */
	p = (Tnode*)emalloc(sizeof(Tnode));	/* install new type */
	p->type = type;
	p->ref = ref;
	p->id = lookup("/*?*/");
	p->base = NULL;
	p->sym = (Symbol*)0;
	p->response = (Entry*)0;
	p->width = width;
	p->generated = False;
	p->wsdl = False;
	p->next = Tptr[type];
	p->transient = t;
	p->imports = imports;
	p->pattern = NULL;
	p->minLength = -1;
	p->maxLength = -1;
	p->num = typeNO++;
	Tptr[type] = p;
	return p;
}

Tnode *
mksymtype(Tnode *typ, Symbol *sym)
{	Tnode *p;
	p = (Tnode*)emalloc(sizeof(Tnode));	/* install new type */
	p->type = typ->type;
	p->ref = typ->ref;
	p->id = typ->id;
	p->sym = sym;
	p->response = (Entry*)0;
	p->width = typ->width;
	p->generated = True; /* copy of existing (generated) type */
	p->wsdl = False;
	p->next = Tptr[typ->type];
	p->transient = transient;
	p->imports = imports;
	p->pattern = NULL;
	p->minLength = -1;
	p->maxLength = -1;
	p->num = typeNO++;
	Tptr[typ->type] = p;
	return p;
}

Tnode *
mktemplate(Tnode *typ, Symbol *id)
{	Tnode *p;
	for (p = Tptr[Ttemplate]; p; p = p->next)
		if (p->ref == typ && p->id == id && p->transient == transient)
			return p;	/* type alrady exists in table */
	p = (Tnode*)emalloc(sizeof(Tnode));	/* install new type */
	p->type = Ttemplate;
	p->ref = typ;
	p->id = id;
	p->sym = NULL;
	p->response = (Entry*)0;
	p->width = 0;
	p->generated = False; /* copy of existing (generated) type */
	p->wsdl = False;
	p->next = Tptr[Ttemplate];
	p->transient = transient;
	p->imports = imports;
	p->pattern = NULL;
	p->minLength = -1;
	p->maxLength = -1;
	p->num = typeNO++;
	Tptr[Ttemplate] = p;
	return p;
}

/*	DO NOT REMOVE OR ALTER (SEE LICENCE AGREEMENT AND COPYING.txt)	*/
void
copyrightnote(FILE *fd, char *fn)
{ fprintf(fd, "/* %s\n   Generated by gSOAP "VERSION" from %s\n   Copyright(C) 2000-2006, Robert van Engelen, Genivia Inc. All Rights Reserved.\n   This part of the software is released under one of the following licenses:\n   GPL, the gSOAP public license, or Genivia's license for commercial use.\n*/", fn, filename);
}

void
banner(FILE *fd, const char *text)
{ int i;
  fprintf(fd, "\n\n/");
  for (i = 0; i < 78; i++)
    fputc('*', fd);
  fprintf(fd, "\\\n *%76s*\n * %-75s*\n *%76s*\n\\", "", text, "");
  for (i = 0; i < 78; i++)
    fputc('*', fd);
  fprintf(fd, "/\n");
}

void
ident(FILE *fd, char *fn)
{ time_t t = time(NULL), *p = &t;
  char tmp[256];
  strftime(tmp, 256, "%Y-%m-%d %H:%M:%S GMT", gmtime(p));
  fprintf(fd, "\n\nSOAP_SOURCE_STAMP(\"@(#) %s ver "VERSION" %s\")\n", fn, tmp);
}

void
compile(Table *table)
{	Entry *p;
	Tnode *typ;
	Pragma *pragma;
	int classflag = 0;
	char *s;
	char base[1024];
	char soapStub[1024];
	char soapH[1024];
	char soapC[1024];
	char soapClient[1024];
	char soapServer[1024];
	char soapClientLib[1024];
	char soapServerLib[1024];
	char pathsoapStub[1024];
	char pathsoapH[1024];
	char pathsoapC[1024];
	char pathsoapClient[1024];
	char pathsoapServer[1024];
	char pathsoapClientLib[1024];
	char pathsoapServerLib[1024];
      	char soapMatlab[1024];
      	char pathsoapMatlab[1024];
  	char soapMatlabHdr[1024];
      	char pathsoapMatlabHdr[1024];

	if (*dirpath)
	  fprintf(fmsg, "Using project directory path: %s\n", dirpath);

	if (namespaceid)
	{ prefix = namespaceid;
	  fprintf(fmsg, "Using code namespace: %s\n", namespaceid);
	}
	strcpy(base, prefix);
	if (cflag)
		s = ".c";
	else
		s = ".cpp";

  	strcpy(soapMatlab, base);
  	strcat(soapMatlab, "Matlab.c");
  	strcpy(pathsoapMatlab, dirpath);
  	strcat(pathsoapMatlab, soapMatlab );
  
  	strcpy(soapMatlabHdr, base);
  	strcat(soapMatlabHdr, "Matlab.h");
  	strcpy(pathsoapMatlabHdr, dirpath);
  	strcat(pathsoapMatlabHdr, soapMatlabHdr);

	strcpy(soapStub, base);
	strcat(soapStub, "Stub.h");
	strcpy(pathsoapStub, dirpath);
	strcat(pathsoapStub, soapStub);
	strcpy(soapH, base);
	strcat(soapH, "H.h");
	strcpy(pathsoapH, dirpath);
	strcat(pathsoapH, soapH);
	strcpy(soapC, base);
	strcat(soapC, "C");
	strcat(soapC, s);
	strcpy(pathsoapC, dirpath);
	strcat(pathsoapC, soapC);
	strcpy(soapClient, base);
	strcat(soapClient, "Client");
	strcat(soapClient, s);
	strcpy(pathsoapClient, dirpath);
	strcat(pathsoapClient, soapClient);
	strcpy(soapServer, base);
	strcat(soapServer, "Server");
	strcat(soapServer, s);
	strcpy(pathsoapServer, dirpath);
	strcat(pathsoapServer, soapServer);
	strcpy(soapClientLib, base);
	strcat(soapClientLib, "ClientLib");
	strcat(soapClientLib, s);
	strcpy(pathsoapClientLib, dirpath);
	strcat(pathsoapClientLib, soapClientLib);
	strcpy(soapServerLib, base);
	strcat(soapServerLib, "ServerLib");
	strcat(soapServerLib, s);
	strcpy(pathsoapServerLib, dirpath);
	strcat(pathsoapServerLib, soapServerLib);

	if (mflag)
 	{ fprintf(fmsg, "Saving %s\n", pathsoapMatlab);
 	  fmatlab=fopen(pathsoapMatlab, "w");
 	  if (!fmatlab)
 		execerror("Cannot write to file");
 	  copyrightnote(fmatlab, soapMatlab);
 	  fprintf(fmatlab,"\n#include \"%s\"\n", soapMatlabHdr);
 	  fprintf(fmsg, "Saving %s\n", pathsoapMatlabHdr);
 	  fmheader=fopen(pathsoapMatlabHdr, "w");
 	  if (!fmheader)
		execerror("Cannot write to file");
 	  copyrightnote(fmheader, soapMatlabHdr);
 	  fprintf(fmheader,"\n#include \"mex.h\"\n#include \"%s\"\n", soapStub);
	}

	fprintf(fmsg, "Saving %s\n", pathsoapStub);
	fheader=fopen(pathsoapStub, "w");
	if (!fheader)
		execerror("Cannot write to file");
	copyrightnote(fheader, soapStub);
	fprintf(fmsg, "Saving %s\n", pathsoapH);
	fhead=fopen(pathsoapH,"w");
	if (!fhead)
		execerror("Cannot write to file");
	copyrightnote(fhead, soapH);
	fprintf(fmsg, "Saving %s\n", pathsoapC);
	fout=fopen(pathsoapC,"w");
	if (!fout)
		execerror("Cannot write to file");
	copyrightnote(fout, soapC);
	if (!Sflag && !iflag)
	{ fprintf(fmsg, "Saving %s\n", pathsoapClient);
          fclient=fopen(pathsoapClient,"w");
	  if (!fclient)
		execerror("Cannot write to file");
	  copyrightnote(fclient, soapClient);
          fprintf(fclient,"\n#include \"%sH.h\"", prefix);
	  if (cflag)
	    fprintf(fclient,"\n#ifdef __cplusplus\nextern \"C\" {\n#endif");
          if (namespaceid)
            fprintf(fclient,"\n\nnamespace %s {", namespaceid);
	  ident(fclient, soapClient);

	  if (!Lflag)
	  { flib=fopen(pathsoapClientLib,"w");
	    if (!flib)
		execerror("Cannot write to file");
	    copyrightnote(flib, soapClientLib);
	    fprintf(fmsg, "Saving %s\n", pathsoapClientLib);
	    fprintf(flib, "\n#ifndef WITH_NOGLOBAL\n#define WITH_NOGLOBAL\n#endif");
	    fprintf(flib, "\n#define SOAP_FMAC3 static");
	    fprintf(flib, "\n#include \"%s\"", soapC);
	    fprintf(flib, "\n#include \"%s\"", soapClient);
	    fprintf(flib, "\n\n/* End of %s */\n", soapClientLib);
	    fclose(flib);
	  }
	}
	if (!Cflag && !iflag)