wrappergen.c

MPICH是MPI的重要研究,提供了一系列的接口函数,为并行计算的实现提供了编程环境.

		        varName, varSuffix )
char **readPt, **varPrefix, **varName, **varSuffix;
{
  char *start;

  while (**readPt && (isspace( **readPt ) || **readPt==',')) {
    (*readPt)++;
  }
  if (!**readPt) return 0;

  start = *readPt;	/* start prefix */

    /* read until first letter: the variable name */
  while (**readPt && !isalpha(**readPt)) (*readPt)++;

  if (!**readPt) return 0;
  
  STR_RANGE_DUP( *varPrefix, start, *readPt );

  start = *readPt;

    /* read until first non letter, digit, or _ : suffix */
  while (**readPt && (isalnum(**readPt) || **readPt=='_')) (*readPt)++;
  
  STR_RANGE_DUP( *varName, start, *readPt );

  start = *readPt;
  
    /* read until first comma or end of string */
  while (**readPt && **readPt!=',') (*readPt)++;
  
  STR_RANGE_DUP( *varSuffix, start, *readPt );

#if DEBUG
  fprintf( stderr, "ReadVardeclVarname: :%s:%s:%s:\n",
	   *varPrefix, *varName, *varSuffix );
#endif
  /* ? return ? */
  return 1;
}


char *ReadFileIntoString( inf )
FILE *inf;
{
  char *str, *ptr;
  int size, c;
  struct stat filestat;

  fstat( fileno( inf ), &filestat );

  size = filestat.st_size;

  str = (char *) malloc( (size+1) * sizeof( char ) );

  if (!str) {
    fprintf( stderr,
	 "Not enough free memory to read in wrapper definition file.\n" );
    return 0;
  }

  ptr = str;
  while ( (c = getc( inf )) != EOF) *ptr++ = c;
  *--ptr = '\0';

  return str;
}


int IsFnInList( fn, fn_list, n_fn )
char *fn;
fn_def *fn_list;
int n_fn;
{
  int i;
  for (i=0; i<n_fn; i++) {
    if (!strcmp( fn, fn_list[i].name )) return i;
  }
  return -1;
}


int IsReservedName( name )
char *name;
{
  if (!strcmp( name, RETURN_VAR_NAME )) return 1;
  if (!strcmp( name, "fileno" )) return 1;
  return 0;
}



void WriteFunctionCalls( outf, fn_list, n_fn, winfo )
FILE *outf;
fn_def *fn_list;
int n_fn;
wrapperinfo *winfo;
{
  int i, j, w, v, wrapperNum, nwpr, nvar;
  char ***uniqueVarLists;
  wrapperdef *wpr;

  wpr = ListHeadPtr( winfo->wrapperDefs, wrapperdef );
  nwpr = ListSize( winfo->wrapperDefs, wrapperdef );

#if DEBUG
  fprintf( stderr, "\n\nWRITE FUNCTION CALLS\n\n" );

  fprintf( stderr, "Wrappers: \n" );
  for (i=0; i<nwpr; i++) {
    fprintf( stderr, "Wrapper %d\n", i );
    fprintf( stderr, "nameEscape %s\n",wpr[i].nameEscape );
    fprintf( stderr, "Vars:\n" );
    for (j=0; j<wpr[i].nvars; j++)
      fprintf( stderr, "  %s%s%s\n", wpr[i].vars[j].typePrefix,
	       wpr[i].vars[j].rqName, wpr[i].vars[j].typeSuffix );
    fprintf( stderr, "prefix code :%s:\n", wpr[i].prefixCode );
    fprintf( stderr, "suffix code :%s:\n", wpr[i].suffixCode );
  }

  fprintf( stderr, "Functions: \n" );
  for (i=0; i<n_fn; i++) {
    fprintf( stderr, "Function: %s (%s)\n",
	     fn_list[i].name, fn_list[i].returnType );
    for (j=0; j<fn_list[i].nargs; j++)
      fprintf( stderr, "arg: %s %s%s;\n", fn_list[i].argTypePrefix[j],
	       fn_list[i].argNames[j], fn_list[i].argTypeSuffix[j] );
    for (j=0; j<ListSize( fn_list[i].wrapperdefs, int ); j++)
      fprintf( stderr, "uses wrapper %d\n",
	       ListItem( fn_list[i].wrapperdefs, int, j ) );
  }
#endif

  uniqueVarLists = CreateUniqueVarNames( wpr, nwpr );
  

  for (i=0; i<n_fn; i++) {

#if DEBUG
    fprintf( stderr, "Profiling %s\n", fn_list[i].name );
#endif

    if (ListSize( fn_list[i].wrapperdefs, int )) {
        /* print function return type and name */
      fprintf( outf, "\n%s %s( ", fn_list[i].returnType, fn_list[i].name);

      if (oldstyle_function()) {
	  /* Pre-prototype C */
	  if (fn_list[i].nargs)	/* print first arg */
	      fprintf( outf, "%s", fn_list[i].argNames[0] );

	  /* print comma separated args */
	  for (j=1; j<fn_list[i].nargs; j++)
	      fprintf( outf, ", %s", fn_list[i].argNames[j] );
	  fprintf( outf, " )\n" );

	  /* print args and types */
	  for (j=0; j<fn_list[i].nargs; j++)
	      fprintf( outf, "%s %s%s;\n", fn_list[i].argTypePrefix[j],
		       fn_list[i].argNames[j], fn_list[i].argTypeSuffix[j] );
      }
      else {
	  /* print args and types */
	  for (j=0; j<fn_list[i].nargs; j++)
	      fprintf( outf, "%s %s%s%c", fn_list[i].argTypePrefix[j],
		       fn_list[i].argNames[j], fn_list[i].argTypeSuffix[j], 
		       (j<fn_list[i].nargs-1)? ',' : ' ' );
	  fprintf( outf, " )\n" );
      }
        /* declare return type */
      fprintf( outf, "{\n  %s %s;\n", fn_list[i].returnType,
	       RETURN_VAR_NAME );
      
        /* declare variables for each wrapper */
      for (w=0; w<ListSize( fn_list[i].wrapperdefs, int ); w++) {
	wrapperNum = ListItem( fn_list[i].wrapperdefs, int, w );
	for (v=0; v<wpr[wrapperNum].nvars; v++) {
	  fprintf( outf, "  %s%s%s;\n",
		   wpr[wrapperNum].vars[v].typePrefix,
		   uniqueVarLists[wrapperNum][v],
		   wpr[wrapperNum].vars[v].typeSuffix );
	}
      }

      PrintWrapperCode( outf, fn_list, n_fn, winfo,
		        uniqueVarLists, i, 0 );

        /* return */
      fprintf( outf, "\n  return %s;\n}\n", RETURN_VAR_NAME );
    }
  }
}


char ***CreateUniqueVarNames( wrapperList, nwrappers )
wrapperdef *wrapperList;
int nwrappers;
{
  int wrapperNum, varNum, varLen, uniqueLevel;
  char *tmpStr, ***uniqueNames;

  /* allocate space for pointers to each list */
  uniqueNames = (char ***)malloc( sizeof( char **)*nwrappers );

  for (wrapperNum=0; wrapperNum<nwrappers; wrapperNum++) {

    /* allocate space for each list */
    uniqueNames[wrapperNum] = (char **)malloc( sizeof( char *)*
					   wrapperList[wrapperNum].nvars );
    for (varNum=0; varNum<wrapperList[wrapperNum].nvars; varNum++) {
      tmpStr = wrapperList[wrapperNum].vars[varNum].rqName;
      varLen = strlen( tmpStr );
      uniqueLevel = 0;		/* original name, not uniquified */
      
      /* search through all the variables that have been uniquified so far */
      while (!IsUnique( tmpStr, wrapperList, nwrappers, uniqueNames,
		        wrapperNum )) {

	/* if this guy matches someone, change name and try again */
	if (uniqueLevel) free( tmpStr );
	uniqueLevel++;
	tmpStr = (char *)malloc( sizeof( char )*(varLen+5) );
	sprintf( tmpStr, "%s%d", wrapperList[wrapperNum].vars[varNum].
		 rqName, uniqueLevel );
      }
      uniqueNames[wrapperNum][varNum] = tmpStr;
#if DEBUG
      fprintf( stderr, "name for %s in wrapper %d is %s\n",
	       wrapperList[wrapperNum].vars[varNum].rqName,
	       wrapperNum, tmpStr );
#endif
    }
  }
  
  return uniqueNames;
}

int IsUnique( str, wrapperList, nwrappers, others, wrapperNum )
char *str;
char ***others;
int wrapperNum, nwrappers;
wrapperdef *wrapperList;
{
  int w, v;

  if (!strcmp( str, RETURN_VAR_NAME )) return 0;

  /* search through unique names created for previous wrappers */
  for (w=0; w<wrapperNum; w++) {
    for (v=0; v<wrapperList[w].nvars; v++) {
      if (!strcmp( str, others[w][v] )) return 0;
    }
  }
  return 1;
}


void PrintWrapperCode( outf, fn_list, n_fn, winfo, 
		       varNames, fn_num, wrapperNumIdx )
FILE *outf;
int n_fn, fn_num, wrapperNumIdx;
fn_def *fn_list;
wrapperinfo *winfo;
char ***varNames;
{
  rpcinfo rinfo;
  replacement rpc;
  int i, nvars, line, wrapperNum, nwpr;
  char *argNum;
  wrapperdef *wpr;
  fileinfo finfo;

  wpr = ListHeadPtr( winfo->wrapperDefs, wrapperdef ); 
  nwpr = ListSize( winfo->wrapperDefs, wrapperdef ); 

    /* set up replacement information (rpc list, function list) */
  ListCreate( rinfo.rpc, replacement, 10 );
  rinfo.fn_list = fn_list;
  rinfo.n_fn = n_fn;

  /* if this is one past the last wrapper, print the actual call */
  if (wrapperNumIdx==ListSize( fn_list[fn_num].wrapperdefs, int )) {
    fprintf( outf, "\n  %s = P%s( ", RETURN_VAR_NAME, fn_list[fn_num].name );
    if (fn_list[fn_num].nargs)
      fprintf( outf, "%s", fn_list[fn_num].argNames[0] );
    for (i=1; i<fn_list[fn_num].nargs; i++)
      fprintf( outf, ", %s", fn_list[fn_num].argNames[i] );
    fprintf( outf, " );\n" );
    return;
  }

  /* get the wrapper index from this functions description */
  wrapperNum = ListItem( fn_list[fn_num].wrapperdefs, int, wrapperNumIdx );
  nvars = wpr[wrapperNum].nvars;

#if DEBUG
  fprintf( stderr, "print wrapper %d (absolute %d)\n", wrapperNumIdx,
	   wrapperNum );
#endif

  /* Check if a variable used in a wrapper clashes with an argument
  ** name.  If so, complain, but the variable get precedence in the
  ** wrapper.  The argument can still be referenced by its index.
  */

  CheckForHiddenArgs( fn_list, fn_num, winfo, wrapperNum );

  /* set the replacement list to take care of variable, argument,
     file number, return variable, and function name replacements */

    /* replacements for variable names */
  for (i=0; i<nvars; i++ ) {
    rpc.from = wpr[wrapperNum].vars[i].rqName;
    rpc.to = varNames[wrapperNum][i];
#if DEBUG
    fprintf( stderr, "converting variable %s to %s\n", rpc.from,
	     rpc.to );
#endif
    ListAddItem( rinfo.rpc, replacement, rpc );
  }

    /* create replacements for argument names and indices */
    /* Note: indices start at 0, and 0 is not the name of the function */
  for (i=0; i<fn_list[fn_num].nargs; i++) {
    rpc.from = rpc.to = fn_list[fn_num].argNames[i];
    ListAddItem( rinfo.rpc, replacement, rpc );
    argNum = (char *)malloc( 10 );
    sprintf( argNum, "%d", i );
    rpc.from = argNum;
    rpc.to = fn_list[fn_num].argNames[i];
    ListAddItem( rinfo.rpc, replacement, rpc );
  }

    /* create replacement for function name */
  rpc.from = wpr[wrapperNum].nameEscape;
  rpc.to = fn_list[fn_num].name;
  ListAddItem( rinfo.rpc, replacement, rpc );

    /* create replacement for return variable */
  rpc.from = RETURN_VAR_NAME;
  rpc.to = RETURN_VAR_NAME;
  ListAddItem( rinfo.rpc, replacement, rpc );

    /* create replacement for filenum */
  rpc.from = "fileno";
  rpc.to = (char *)malloc( 10 );
  sprintf( rpc.to, "%d", wpr[wrapperNum].finfo.filenum );
  ListAddItem( rinfo.rpc, replacement, rpc );

#if DEBUG
  for (i=0; i<ListSize( rinfo.rpc, replacement ); i++) 
    fprintf( stderr, "replace '%s' with '%s'\n",
	     ListItem( rinfo.rpc, replacement, i ).from,
	     ListItem( rinfo.rpc, replacement, i ).to );
#endif

  wpr[wrapperNum].finfo.str = wpr[wrapperNum].prefixCode;
  wpr[wrapperNum].finfo.lineno = wpr[wrapperNum].prefixLineNo;
  ProcessString( outf, &wpr[wrapperNum].finfo, &rinfo, winfo );

  PrintWrapperCode( outf, fn_list, n_fn, winfo, 
		    varNames, fn_num, wrapperNumIdx+1 );

  if (wpr[wrapperNum].suffixCode) {
    wpr[wrapperNum].finfo.str = wpr[wrapperNum].suffixCode;
    wpr[wrapperNum].finfo.lineno = wpr[wrapperNum].suffixLineNo;
    ProcessString( outf, &wpr[wrapperNum].finfo, &rinfo, winfo );
  }

  return;
}


void CheckForHiddenArgs( fn_list, fn_num, winfo, wrapperNum )
fn_def *fn_list;
wrapperinfo *winfo;
int fn_num, wrapperNum;
{
  int argNum, varNum;
  wrapperdef *wpr;
  fn_def *fn;
  
  fn = fn_list + fn_num;
  wpr   = ListHeadPtr( winfo->wrapperDefs, wrapperdef ) + wrapperNum;

  for (argNum=0; argNum < fn_list[fn_num].nargs; argNum++) {
    for (varNum=0; varNum < wpr->nvars; varNum++ ) {
      if (!strcmp( fn->argNames[argNum], wpr->vars[varNum].rqName )) {
	fprintf( stderr, "Variable '%s' declared in the wrapper starting\n",
		 wpr->vars[varNum].rqName );
	fprintf( stderr, "on line %d in file %s hides argument %d in\n",
		 wpr->firstLine, wpr->finfo.name, argNum );
	fprintf( stderr, "the function %s.\n", fn->name );
      }
    }
  }
}