Beispiel #1
0
void spf_load ( char *filnam, int *iret )
/************************************************************************
 * spf_load								*
 *									*
 * This function loads the file contents into the "_spfBuffer". If the	*
 * file does not exist, it will not be created & nothing will be read.	*
 *									*
 * spf_load ( filnam, iret )						*
 *									*
 * Input parameters:							*
 *      *filnam		char		file name with full path	*
 *									*
 * Output parameters:							*
 *	*iret		int		Return code			*
 *					4 - Reach the end of file	*
 *					0 - Normal 			*
 *				       -1 - File does not exist		*
 *				       -2 - File cannot be opened	*
 *				       -4 - Failure to read SPF file	*
 *				       -7 - Failure to allocate buffer	*
 *									*
 **									*
 * Log:									*
 * J. Wu/GSC	6/01	create						*
 * J. Wu/GSC	7/01	allow access to read-only SPF files		*
 * H. Zeng/SAIC 9/04    spf_read() para. list change			*
 ***********************************************************************/
{

    int     flen, ier;
    FILE    *fptr;
        
/*---------------------------------------------------------------------*/

    *iret = G_NORMAL;
    fptr = NULL;
    
    if ( _initSPF != G_TRUE )  spf_init( &ier ); 
    
    spf_open( filnam, FALSE, &fptr, &flen, iret );
        
    if ( *iret >= 0 ) { 
        
       spf_read( fptr, filnam, flen, iret );

    }    
        
    if ( fptr != NULL ) {
       
       spf_close( fptr, &ier );
       
    }
           
}
Beispiel #2
0
/* QUERY -- Query the user for the value of a parameter.  Prompt with the
 *  current value if any.  Keep this up until we can push a reasonable value.
 *  Also, store the new value in the parameter (except for list params, where,
 *  since the values are not kept, all that may change is P_LEOF if seen).
 * Give prompt, or name if none, current value and range if int, real or 
 *   filename.  Accept CR to leave value unchanged, else take the string
 *   entered to be the new value.  Repeat until parameter value is in range.
 * We mean to talk straight to the user here; thus, interact with the real
 *   stdio, not the effective t_stdio, so that redirections do not get in
 *   the way.  In batch mode, a forced query is handled by writing a
 *   message on the terminal of the parent cl (the original stderr), and
 *   leaving some info describing the query in a file in uparm (if there is
 *   no uparm, we abort).  We then loop, waiting for the user to run "service"
 *   in the interactive cl to service the query, leaving the answer in a
 *   another file which we read and then delete.  If we wait a long time and
 *   get no response, we timeout.
 */
void 
query (struct param *pp)
{
	static	char *oormsg =
		"ERROR: Parameter value is out of range; try again";
	register char *ip;
	char	buf[SZ_PROMPTBUF+1];
	struct	operand o;
	int	bastype, batch, arrflag, offset=0, n_ele, max_ele, fd;
	char	*index(), *nlp, *nextstr();
	char	*bkg_query(), *query_status;
	char	*abuf;

	bastype = pp->p_type & OT_BASIC;
	batch = firstask->t_flags & T_BATCH;
	arrflag = pp->p_type & PT_ARRAY;

	if (arrflag) {			/* We may access the array many     */
	    offset = getoffset (pp);	/* times, so save the offset and    */
					/* push it when necessary.	    */
	    poffset (offset);
	    max_ele = size_array (pp) - offset;
	} else
	    max_ele = 1;


	forever {
	    if (batch) {
		/* Query from a background job.
		 */
		query_status = bkg_query (buf, SZ_PROMPTBUF, pp);

	    } else if (pp->p_type & (PT_GCUR|PT_IMCUR)) {
		/* Read a graphics cursor.
		 */
		char	source[33];
		int	cursor;

		/* Determine the source of graphics cursor input, chosen from
		 * either the graphics or image cursor or the terminal.
		 */
		if (pp->p_type & PT_GCUR) {
		    if (c_envfind ("stdgcur", source, 32) <= 0)
			strcpy (source, "stdgraph");
		} else {
		    if (c_envfind ("stdimcur", source, 32) <= 0)
			strcpy (source, "stdimage");
		}

		if (strcmp (source, "stdgraph") == 0)
		    cursor = STDGRAPH;
		else if (strcmp (source, "stdimage") == 0)
		    cursor = STDIMAGE;
		else
		    goto text_query;		/* get value from terminal */

		/* Read a physical graphics cursor.
		 */
		pp->p_flags &= ~P_LEOF;
		if (cursor == STDIMAGE) {
		    /* The following is a kludge used to temporarily implement
		     * the logical image cursor read.  In the future this will
		     * be eliminated, and the c_rcursor call below (cursor
		     * mode) will be used for stdimage as well as for stdgraph.
		     * The present code (IMDRCUR) goes directly to the display
		     * server to get the cursor value, bypassing cursor mode
		     * and the (currently nonexistent) stdimage kernel.
		     */
		    char    str[SZ_LINE+1], keystr[10];
		    int     wcs, key;
		    float   x, y;

		    if (c_imdrcur ("stdimage",
			&x,&y,&wcs,&key,str,SZ_LINE, 1, 1) == EOF) {
			query_status = NULL;

		    } else {
			if (isprint(key) && !isspace(key))
			    sprintf (keystr, "%c", key);
			else
			    sprintf (keystr, "\\%03o", key);
			sprintf (buf, "%.3f %.3f %d %s %s\n",
			    x, y, wcs, keystr, str);
		        query_status = (char *) ((XINT) strlen(buf));
		    }

		} else if (c_rcursor (cursor, buf, SZ_PROMPTBUF) == EOF) {
		    query_status = NULL;
		} else
		    query_status = (char *) ((XINT) strlen(buf));

	    } else if (pp->p_type & PT_UKEY) {
		/* Read a user keystroke command from the terminal.
		 */
		pp->p_flags &= ~P_LEOF;
		if (c_rdukey (buf, SZ_PROMPTBUF) == EOF)
		    query_status = NULL;
		else
		    query_status = (char *) ((XINT) strlen(buf));

	    } else {
text_query:	fd = spf_open (buf, SZ_PROMPTBUF);
		pquery (pp, fdopen(fd,"a"));
		spf_close (fd);

		c_stgputline ((XINT)STDOUT, buf);
		if (c_stggetline ((XINT)STDIN, buf, SZ_PROMPTBUF) > 0)
		    query_status = (char *) ((XINT) strlen(buf));
		else
		    query_status = NULL;
	    }

	    ip = buf;

	    /* Set o to the current value of the parameter.  Beware that some
	     * of the logical branches which follow assume that struct o has
	     * been initialized to the current value of the parameter.
	     */
	    if (pp->p_type & PT_LIST)
		setopundef (&o);
	    else if (arrflag) {
		paramget(pp, FN_VALUE);
		poffset (offset);
		o = popop();
	    } else
		o = pp->p_valo;

	    /* Handle eof, a null-length line (lone carriage return),
	     * and line with more than SZ_LINE chars.  Ignore leading whitespace
	     * if basic type is not string.
	     */
	    if (query_status == NULL) {
		/* Typing eof will use current value (as will a lone
		 * newline) but if param is a list, it is a meaningful
		 * answer.
		 */
		if (pp->p_type & PT_LIST) {
		    closelist (pp);		/* close an existing file */
		    pp->p_flags |= P_LEOF;
		    o = makeop (eofstr, OT_STRING);
		    break;
		}
		goto testval;
	    }

	    /* Ignore leading whitespace if it is not significant for this
	     * datatype.  Do this before testing for empty line, so that a
	     * return such as " \n" is equivalent to "\n".  I.e., do not
	     * penalize the user if they type the space bar by accident before
	     * typing return to accept the default value.
	     */
	    if (bastype != OT_STRING || (pp->p_type & (PT_FILNAM|PT_PSET)))
		while (*ip == ' ' || *ip == '\t')
		    ip++;

	    if (*ip == '\n') {
		/* Blank lines usually just accept the current value
		 * but if the param is a string and is undefined,
		 * it sets the string to a (defined) nullstring.
		 */
		*ip = '\0';
		if (bastype == OT_STRING && opundef (&o))
		    o = makeop (ip, bastype);
		else
		    goto testval;
	    }

	    if ((nlp = index (ip, '\n')) != NULL)
		*nlp = '\0';			/* cancel the newline	*/
	    else
		goto testval;

	    /* Finally, we have handled the pathological cases...
	     */
	    if ((pp->p_type & PT_LIST) &&
		(!strcmp (ip,eofstr) || !strcmp (ip,"eof"))) {

		closelist (pp);
		pp->p_flags |= P_LEOF;
		o = makeop (eofstr, OT_STRING);
		break;

	    } else {
		if (arrflag) {
		    /* In querying for arrays we may set more than one
		     * element of the array in a single query.  However
		     * we must set the first element.  So we will pretend
		     * to be a scalar until that first element is set
		     * and then enter a loop where we may set other
		     * elements.
		     */
		    abuf = ip;
		    ip = nextstr(&abuf, stdin);
		    if (ip == NULL  ||  ip == (char *) ERR  ||  ip == undefval)
			goto testval;
		}

		o = makeop (ip, bastype);
	    }

testval:
	    /* If parameter value is in range, we are done.  If it is out of
	     * range and we are a batch job or an interactive terminal job,
	     * print an error message and request that the user enter a legal
	     * value.  If the CL is being run taking input from a file, abort,
	     * else we will go into a loop reading illegal values from the
	     * input file and printing out lots of error messages.
	     */
	    if (inrange (pp, &o))
		break;
	    else if (batch)
		eprintf ("\n[%d] %s", bkgno, oormsg);
	    else if (isatty (fileno (stdin)))
		eprintf ("%s\n", oormsg);
	    else
		cl_error (E_UERR, oormsg);
	}

	if (!(pp->p_type & PT_LIST)) {
	    /* update param with new value.
	     */
	    if (cldebug) {
		eprintf ("changing `%s.p_val' to ", pp->p_name);
		fprop (stderr, &o);
		eprintf ("\n");
	    }

	    pushop (&o);
	    paramset (pp, FN_VALUE);
	    pp->p_flags |= P_QUERY;
	}

	pushop (&o);

	if (arrflag  &&  query_status != NULL  &&  *ip != '\0') {
	    /* If we have an array assign values until something
	     * is used up or until we hit any error.
	     */
	    n_ele = 1;
	    forever {
		if (n_ele >= max_ele)		/* End of array. */
		    break;
		ip = nextstr(&abuf, stdin);

		if (ip == NULL)			/* End of query line. */
		    break;

		if (ip == (char *) ERR) {	/* Error on query line. */
		    eprintf("Error loading array value.\n");
		    break;
		}

		if (ip != undefval) {
		    o = makeop (ip, bastype);
		    if ( ! inrange (pp, &o) ) {	/* Not in range. */
			eprintf("Array value outside range.\n");
			break;
		    }

		    offset++;			/* Next element in array. */
		    poffset (offset);

		    pushop (&o);
		    paramset (pp, FN_VALUE);
		} else
		    offset++;

		n_ele++;
	    }
	}
Beispiel #3
0
int main ( void )
/************************************************************************
 * TESTSPF								*
 *									*
 * This program tests the CGEMLIB "SPF" library functions.		*
 *									*
 **									*
 * Log:									*
 * J. Wu/GSC	 6/01	create						*
 * H. Zeng/SAIC  9/04	spf_read() para. list change			*
 ***********************************************************************/
{
    int    cont, numsub, iret, nbytes, ier, eliblen, errlen;
    char   select[LLSCRN], filnam[LLSCRN], newfil[FILE_FULLSZ]; 
    char   ans[LLSCRN], tag[LLSCRN], data[TAGDATA_BUF];
    char   errlib[3], errstr[2];
    long   lflen;
    FILE   *filptr;

/*---------------------------------------------------------------------*/
    
    cont = G_TRUE;
    filptr = NULL;
    strcpy( errlib, "SPF" );
    strcpy( errstr, " " );
    eliblen = strlen( errlib );
    errlen =  strlen( errstr );
             
    while ( cont == G_TRUE ) {
        
	printf ( "\n\n" );
	printf ( "   ? = Print HELP file\n\n");
	printf ( "   D - Dump a loaded SPF file\n\n");
        printf ( "   1 = SPF_CREATE   2 = SPF_OPEN   3 = SPF_READ\n" );
        printf ( "   4 = SPF_LOAD     5 = SPF_WRITE  6 = SPF_GTFLD\n" );
        printf ( "   7 = SPF_CLNUP    8 = SPF_CLOSE               \n" );
        printf ( "\n" );
        
	printf ( "Select a subroutine number or type EXIT: " );
        scanf ( " %s", select );
        
	numsub = 0;
	
	switch ( select[0] ) {

	    case '?':
 	        printf ("\n               *** HELP FILE ***\n\n");
	        printf ("  D - Dump a loaded SPF file\n\n");
	        printf ("  1 = spf_create - Create an SPF file\n" );
	        printf ("  2 = spf_open   - Open an SPF file\n" );
	        printf ("  3 = spf_read   - Read an opened SPF into buffer\n" );
	        printf ("  4 = spf_load   - Load an unopened SPF into buffer\n" );
	        printf ("  5 = spf_write  - Write a tag/data pair to an SPF\n" );
	        printf ("  6 = spf_gtfld  - Get data field associated with a tag\n" );
	        printf ("  7 = spf_clnup  - Clean up SPF buffer\n" );
	        printf ("  8 = spf_close  - Close an SPF file\n" );
	        printf ( "\n" );
           
	      break;
	      
	    case 'd':
            case 'D':
                 if ( _spfBuffer != (char *)NULL ) {
		     printf ( "\n%s\n", _spfBuffer );		 
		 }
		 else {
		     printf ( "\nPlease load the buffer first.\n" );
		 }
	      
	      break;
	
            case 'e':
            case 'E':
                cont = G_FALSE;
	      break;
	    
	    default:
                numsub = atoi ( select );
              break;
        
	}

/*---------------------------------------------------------------------*/
        if ( numsub == 1 ) {

	    if ( filptr != NULL ) {	    
	        printf ( "\nPlease close the opened file first.\n" );
	    }
	    else {
                printf ( "Enter the file name:\n" );
                scanf ( " %s", filnam );
            
	        cfl_inqr( filnam, NULL, &lflen, newfil, &ier );
                if ( ier != 0 ) {        
 	            strcat( filnam, ".spf" );
                    cfl_inqr( filnam, NULL, &lflen, newfil, &ier );
	        }
	    
	        if ( ier == 0 ) {
                    printf ( "\nCan't create, file %s already exists!\n", newfil );
                }
	        else {	    
		    nbytes = (int)lflen;                
	    	    filptr = (FILE *)spf_create ( filnam, &nbytes, &iret );
                    if ( iret == 0 ) {
		        printf ( "\nSPF_CREATE: iret = %d\n\n", iret );
		    }
		    else {
		        er_wmsg ( errlib, &iret, filnam, &ier, eliblen, strlen(filnam) );	
		    }		
	        }
	    }
	    
        }
	
/*---------------------------------------------------------------------*/
        if ( numsub == 2 ) {
	    
	    if ( filptr != NULL ) {	    
	        printf ( "\nPlease close the opened file first.\n" );
	    }
	    else {
	        printf ( "\nEnter the file name:\n" );
	        scanf ( " %s", filnam );
	        printf ( "Do you want to create it if the file doesn't exist?\n" );
	        scanf ( " %s", ans );

	        if  ( ans[0] == 'y' || ans[0] == 'Y' ) {
	            spf_open ( filnam, TRUE, &filptr, &nbytes, &iret );
	        } 
	        else {
                    spf_open ( filnam, FALSE, &filptr, &nbytes, &iret );
	        }

                if ( iret == 0 ) {
		    printf ( "\nSPF_OPEN: iret = %d\n\n", iret );
		}
		else {
		    er_wmsg ( errlib, &iret, filnam, &ier, eliblen, strlen(filnam) );
                }
		
	    }
	    
	}

/*---------------------------------------------------------------------*/
        if ( numsub == 3 ) {

	    printf ( "Enter length in bytes:\n" );
	    scanf ( " %d", &nbytes );
	    
            spf_read ( filptr, filnam, nbytes, &iret );
                
            if ( iret == 0 ) {
                printf ( "\nSPF_READ: iret = %d\n\n", iret );
	    }
            else {
		er_wmsg ( errlib, &iret, errstr, &ier, eliblen, errlen );
	    }

        }

/*---------------------------------------------------------------------*/
        if ( numsub == 4 ) {
	    	    
	    if ( filptr != NULL ) {	    
	        printf ( "\nPlease close the opened file first.\n" );
	    }
	    else {
	        printf ( "\nEnter the file name:\n" );
	        scanf ( " %s", filnam );
	        
                spf_load ( filnam, &iret );
                
		if ( iret == 0 ) {	    
                    printf ( "\nSPF_LOAD: iret = %d\n\n", iret );
		}
		else {		
		    er_wmsg ( errlib, &iret, filnam, &ier, eliblen, strlen(filnam) );
		}
            }
	    
        }

/*---------------------------------------------------------------------*/
        if ( numsub == 5 ) {
	    	    
	    printf ( "\nEnter the tag name:\n" );
	    scanf ( " %s", tag );
	    printf ( "Enter the data string:\n" );
	    scanf ( " %s", data );
	    
            spf_write ( filptr, tag, data, &iret );

 	    if ( iret == 0 ) {	    
                 printf ( "\nSPF_WRITE: iret = %d\n\n", iret );
	    }
	    else {		
		 er_wmsg ( errlib, &iret, errstr, &ier, eliblen, errlen );		
	    }
			    	           
	}

/*---------------------------------------------------------------------*/
        if ( numsub == 6 ) {
	    
	    printf ( "Enter the tag name:\n" );
	    scanf ( " %s", tag );
	    
            spf_gtfld ( tag, data, &iret );
	    
 	    if ( iret == 0 ) {
                printf ( "\nSPF_GTFLD: iret = %d\n\n", iret );
	    }
	    else {
		er_wmsg ( errlib, &iret, tag, &ier, eliblen, strlen(tag) );
	    }

	    printf ( "\n Tag: %s \t Data: %s\n", tag, data );
	    	           
	}

/*---------------------------------------------------------------------*/
        if ( numsub == 7 ) {
	    	    
            spf_clnup ( &iret );

 	    if ( iret == 0 ) {
                printf ( "\nSPF_CLNUP: iret = %d\n\n", iret );
	    }
	    else {
		er_wmsg ( errlib, &iret, errstr, &ier, eliblen, errlen );
	    }

        }

/*---------------------------------------------------------------------*/
	if ( numsub == 8 ) {

	    spf_close ( filptr, &iret );
            filptr = NULL;	    	    
	        
 	    if ( iret == 0 ) {	    
                printf ( "\nSPF_CLOSE: iret = %d\n\n", iret );
	    }
	    else {
		er_wmsg ( errlib, &iret, errstr, &ier, eliblen, errlen );	     	    
	    }
	
	}

/*---------------------------------------------------------------------*/

    }

    if  ( filptr != NULL )  fclose ( filptr );
    return 0;
}