Пример #1
0
void
main(int argc, char *argv[])
{

	char 	buf[ MAXBUF+1 ];
	
	SIflush(stdin);
	gets(buf);
	/*	SIgetrec(buf, MAXBUF, stdin); */
	SIputrec(buf, stdout);

}
Пример #2
0
STATUS
read_in_comments(FILE *aFile, FILE *comPtr)
{
    STATUS                 ret_status = OK ;

    do
    {
        if ((ret_status = read_fm_command(aFile)) == OK)
        {
            if (sep_state&IN_COMMENT_STATE)
            {
                SIputrec(buffer_1,comPtr);
            }
        }
    } while ((sep_state&IN_COMMENT_STATE)&&(ret_status == OK));

    return(ret_status);
}
Пример #3
0
/*{
** Name: NMwritesyms - write the symbol table list to file.
**
** Description:
**    Write the symbol table list back out to the file.
**
**    This duplicates the function in ingunset.c, but shouldn't be in 
**    compatlib because no one else has any business writing the file.
**
** Inputs:
**	none.
**
** Output:
**	none.
**
**      Returns:
**          OK                         	    Function completed normally. 
**          FAIL                            Function completed abnormally.
**
** History:
**      20-jul-87 (mmm)
**          Updated to meet jupiter standards.
**	14-apr-89 (arana)
**	    When LOlast was added to update symbol table mod time,
**	    return value was saved off but not returned.
**	15-jul-93 (ed)
**	    adding <gl.h> after <compat.h>
**      29-sep-94 (cwaldman)
**          Changed check of NMopensyms return value to compare against
**          (FILE *)NULL (was NULL).
**          Changed write routine to write into a temporary file first,
**          check whether this file has been written OK, and rename
**          temporary file to symbol.tbl if it is alright. This is part
**          of the fix for bug 44445 (symbol.tbl disappears). There is
**          still a slight chance of something going wrong during the
**          rename, but in that case variables are at least preserved
**          in symbol.tmp.
**      19-oct-94 (abowler)
**          Minor correction to change above. Cal to SIopen should be
**          passed address of location structure. (Didn't show up as
**          a bug on su4_u42 !)
**      28-feb-95 (cwaldman)
**          Amendment to change on 29 Sep. Part of the check whether
**          the temporary symbol table had been written OK was to check
**          the file size. The check would return the file size if
**          check was OK and 0 otherwise. If a 0 was returned, the old
**          symbol.tbl would not be replaced. This made it impossible
**          to 'ingunset' the last variable in a symbol.tbl. Changed
**          'OK-check' to use -1 as error indicator.
**	02-jul-1996 (sweeney)
**	    Apply umask fix (bug #71890) from ingres63p
**	07-apr-2004 (somsa01)
**	    Added backup of symbol.tbl logic.
*/
STATUS
NMwritesyms()
{
    register SYM	*sp;
    FILE		*fp, *tfp = NULL;
    register i4 	status = OK;
    register i4 	closestat;
    char		buf[ MAXLINE + NULL_NL_NULL ];
    char		tbuf[ MAXLINE + NULL_NL_NULL ];
    i4			flagword, size, symcount = 0, bksymcount;
    STATUS		retval;
    LOCATION		t_loc;
    LOINFORMATION	loinfo;
    bool		perform_backup = TRUE;
    OFFSET_TYPE		bk_size;

    /*
    ** ensure sensible umask for symbol.tmp, as it will become symbol.tbl
    */
    PEsave();
    PEumask("rw-r--");
 
    if ((FILE *)NULL == (fp = NMopensyms( "r" )))
    {
	PEreset();
	return (NM_STOPN);
    }
    SIclose(fp);
 
    LOcopy(&NMSymloc, tbuf, &t_loc);
    if ( OK != LOfstfile("symbol.tmp", &t_loc) ||
         OK != SIopen(&t_loc, "w", &tfp))
    {
	return (NM_STOPN);
    }

    for ( sp = s_list; sp != NULL; sp = sp->s_next )
    {
	(VOID) STpolycat( 3, sp->s_sym, "\t", sp->s_val, buf );
	STmove( buf, ' ', MAXLINE, buf );

	buf[ MAXLINE - 1 ] = '\n';
	buf[ MAXLINE ] = '\0';
 
	if ( OK != (status = SIputrec(buf, tfp)))
	    break;

	symcount++;
    }
 
    /* Very interested in close status of file being written */
 
    closestat = SIclose( tfp );
    flagword = (LO_I_SIZE);
    size = (OK == LOinfo(&t_loc,&flagword,&loinfo) ? loinfo.li_size : -1);
 
    retval=(status != OK || closestat != OK || size == -1 ? NM_STAPP : OK);

    /* if file written ok update modification time */
    if(retval == OK)
    {
	LOrename(&t_loc, &NMSymloc);
	LOlast(&NMSymloc, &NMtime);
 
#if defined(su4_cmw)
	/* Now reset the old MAC label if any */
	if (NM_got_label)
	{
	    (void)setcmwlabel(NM_path, &NM_saved_label, SETCL_ALL);
	    NM_got_label=0;
	}
#endif

	/*
	** If we have no backup to check against, just do it. Otherwise,
	** make sure our new symbol table differs from the backup by at most
	** one symbol before performing a backup.
	*/
	if (LOexist(&NMBakSymloc) == OK)
	{
	    LOsize(&NMBakSymloc, &bk_size);
	    bksymcount = (i4)(bk_size / (MAXLINE + 1));
	    if (bksymcount != symcount && bksymcount != symcount - 1 &&
		bksymcount != symcount + 1)
	    {
		perform_backup = FALSE;
	    }
	}

	if (perform_backup)
	{
	    if (SIopen(&NMBakSymloc, "w", &tfp) == OK)
	    {
		for (sp = s_list; sp != NULL; sp = sp->s_next)
		{
		    STpolycat(3, sp->s_sym, "\t", sp->s_val, buf);
		    STmove(buf, ' ', MAXLINE, buf);

		    buf[MAXLINE - 1] = '\n';
		    buf[MAXLINE] = '\0';
 
               	    if ((status = SIputrec(buf, tfp)) != OK)
			break;
		}
 
		SIclose(tfp);
	    }
	} 
    }

    PEreset();
    return (retval);
}
Пример #4
0
STATUS
Run_SED_on_file(SEPFILE **Sep_file,LOCATION *Sep_Loc)
{
    STATUS                 ret_val ;
    CL_ERR_DESC            cl_err;

    LOCATION              *sedtmploc = NULL ;
    LOCATION              *filtmploc = NULL ;

    char                  *SEDbuffer = NULL ;
    char                  *sedtmp = NULL ;
    char                  *filtmp = NULL ;
    char                  *cmd_line = NULL ;
    char                  *sed_dev = NULL ;
    char                  *sed_path = NULL ;
    char                  *sed_name = NULL ;
    char                  *sed_type = NULL ;
    char                  *sed_vers = NULL ;
    char                  *fptr1 = NULL ;
    char                  *fptr2 = NULL ;

    FILE                  *SEDfptr = NULL ;
    FILE                  *fptr = NULL ;

    bool                   Sep_file_empty ;

    sed_dev  = SEP_MEalloc(SEP_ME_TAG_SED, LO_DEVNAME_MAX+1,  TRUE, NULL);
    sed_path = SEP_MEalloc(SEP_ME_TAG_SED, LO_PATH_MAX+1,     TRUE, NULL);
    sed_name = SEP_MEalloc(SEP_ME_TAG_SED, LO_FPREFIX_MAX+1,  TRUE, NULL);
    sed_type = SEP_MEalloc(SEP_ME_TAG_SED, LO_FSUFFIX_MAX+1,  TRUE, NULL);
    sed_vers = SEP_MEalloc(SEP_ME_TAG_SED, LO_FVERSION_MAX+1, TRUE, NULL);

    SEDbuffer = SEP_MEalloc(SEP_ME_TAG_SED, SCR_LINE+1, TRUE, NULL);

    /*
    ** Create Sed output file names.
    */
    sedtmploc = (LOCATION *)SEP_MEalloc(SEP_ME_TAG_SED, sizeof(LOCATION),
					TRUE, NULL);
    filtmploc = (LOCATION *)SEP_MEalloc(SEP_ME_TAG_SED, sizeof(LOCATION),
					TRUE, NULL);
    sedtmp    = SEP_MEalloc(SEP_ME_TAG_TOKEN, MAX_LOC+1, TRUE, NULL);
    filtmp    = SEP_MEalloc(SEP_ME_TAG_TOKEN, MAX_LOC+1, TRUE, NULL);

    LOtos(Sep_Loc, &fptr2);
    STcopy(fptr2, sedtmp);
    STcopy(fptr2, filtmp);
    LOfroms(FILENAME & PATH, sedtmp, sedtmploc);
    LOfroms(FILENAME & PATH, filtmp, filtmploc);
    LOdetail(sedtmploc, sed_dev, sed_path, sed_name, sed_type, sed_vers);
    STcopy(ERx("sed"),sed_type);
    SEP_LOcompose(sed_dev, sed_path, sed_name, sed_type, sed_vers, sedtmploc);
    STcopy(ERx("sdr"),sed_type);
    SEP_LOcompose(sed_dev, sed_path, sed_name, sed_type, sed_vers, filtmploc);

    /*
    ** Copy Sep SI_RACC file to a SI_TXT file.
    */
    SEPrewind(*Sep_file, FALSE);
    if ((ret_val = SIfopen(filtmploc,ERx("w"), SI_TXT, SCR_LINE, &fptr))
	!= OK)
	return(ret_val);

    for (Sep_file_empty = TRUE;
	 (ret_val = SEPgetrec(SEDbuffer, *Sep_file)) == OK;
	 SIputrec(SEDbuffer, fptr))
	if (Sep_file_empty)
	    Sep_file_empty = FALSE;

    SIclose(fptr);

    if (Sep_file_empty == FALSE)
    {   /*
	** Create command line for sed command.
	*/
	LOtos(SED_loc, &fptr1);
	LOtos(filtmploc, &fptr2);
	cmd_line = SEP_MEalloc(SEP_ME_TAG_TOKEN, MAX_LOC+1, TRUE, NULL);
	IISTprintf(cmd_line, "sed -f %s %s", fptr1, fptr2);

	/*
	** Close Sep file and run the SED.
	*/
	SEPclose(*Sep_file);
	ret_val = PCcmdline(NULL, cmd_line, PC_WAIT, sedtmploc, &cl_err);
	if(ret_val != OK)
	{
	    SEPopen(Sep_Loc, SCR_LINE, Sep_file);
	    del_floc(sedtmploc);
	    del_floc(filtmploc);
	    MEtfree(SEP_ME_TAG_SED);
	    return(1);
	}

	/*
	** Recreate Sep file.
	*/
#ifdef NT_GENERIC
	LOdelete(Sep_Loc);
#else
	del_floc(Sep_Loc);
#endif
	if ((ret_val = SIfopen(Sep_Loc, ERx("w"), SI_RACC, SCR_LINE, &fptr))
	    != OK)
	    return(ret_val);
	SIclose(fptr);
	SEPopen(Sep_Loc, SCR_LINE, Sep_file);

	/*
	** Open Sed output file.
	*/
	if ((ret_val = SIfopen(sedtmploc, ERx("r"), SI_TXT, SCR_LINE, &SEDfptr))
	    != OK)
	    return(ret_val);

	/*
	** Copy the Sed output file to the Sep file.
	*/
	while((ret_val = SIgetrec(SEDbuffer, SCR_LINE, SEDfptr)) == OK)
	    SEPputrec(SEDbuffer, *Sep_file);

	SEPclose(*Sep_file);
	SIclose(SEDfptr);

	/*
	** Reopen the sep file.
	*/
	SEPopen(Sep_Loc, SCR_LINE, Sep_file);

	/*
	** Clean up.
	*/
	del_floc(sedtmploc);
    }
    del_floc(filtmploc);
    MEtfree(SEP_ME_TAG_SED);
    return(OK);
}
Пример #5
0
i4
Trace_Token_List(char *list_label,i4 l_nr,i4 num_of_tokens,FILE_TOKENS **tokarray)
{
    i4                     i, j, k ;
    char                  *toktype  = NULL ;
    char                  *otoktype = NULL ;
    bool                   skip_it  = FALSE ;
    char                  *ARRY_LINE_FMT
			   = ERx(" %5d   %-40s   %5d    A_%-10s\n") ;
    char                  *ARRY_BANNER
			   = ERx("-------------------------------------------------------------------------\n") ;

    SIfprintf(traceptr,ERx("\n                       %6s #%d,  %d Tokens.\n\n"),
	      list_label, l_nr, num_of_tokens );

    if (num_of_tokens == 0) return (OK);

    SIputrec(ARRY_BANNER,traceptr);
    SIputrec(ERx(" Token |            First 40 Chars  "), traceptr);
    SIputrec(ERx("              |  Line  |    Token\n"),  traceptr);
    SIputrec(ERx("  Nr   |              of Token "), traceptr);
    SIputrec(ERx("           |   Nr   |    Type\n"), traceptr);
    SIputrec(ARRY_BANNER,traceptr);

    for (i=1, j=0; i <= num_of_tokens; i++)
    {
	if ((j == 0)||(tokarray[i]->tokenID != A_UNKNOWN)||
	    (STcompare(tokarray[i]->token,tokarray[j]->token) != 0))
	{
	    if (skip_it == TRUE)
	    {
		if ((k = tokarray[i]->token_no - tokarray[j]->token_no) == 2)
		{
		    SIfprintf(traceptr, ARRY_LINE_FMT, tokarray[j]->token_no,
				        tokarray[j]->token, tokarray[j]->lineno,
			                otoktype );
		}
		else
		{
		    SIfprintf(traceptr, ERx("\t\t - (%d) duplicate tokens -\n"),
					k-1);
		}

		skip_it = FALSE;
	    }

	    j = i;
	}
	else
	{
	    otoktype = toktype;
	    skip_it = TRUE;
	    continue;
	}

	switch (tokarray[i]->tokenID)
	{
	    case A_NUMBER:	toktype = ERx("NUMBER");	break;
	    case A_OCTAL:	toktype = ERx("OCTAL");		break;
	    case A_HEXA:	toktype = ERx("HEXA");		break;
	    case A_FLOAT:	toktype = ERx("FLOAT");		break;
	    case A_WORD:	toktype = ERx("WORD");		break;
	    case A_DBLWORD:     toktype = ERx("DBLWORD");       break;
	    case A_DATE:	toktype = ERx("DATE");		break;
	    case A_TIME:	toktype = ERx("TIME");		break;
	    case A_DELIMITER:	toktype = ERx("DELIMITER");	break;
	    case A_CONTROL:	toktype = ERx("CONTROL");	break;
	    case A_UNKNOWN:	toktype = ERx("UNKNOWN");	break;
	    case A_RETCOLUMN:	toktype = ERx("RETCOLUMN");	break;
	    case A_DIRECTORY:	toktype = ERx("DIRECTORY");	break;
	    case A_BANNER:	toktype = ERx("BANNER");	break;
	    case A_PRODUCT:	toktype = ERx("PRODUCT");	break;
	    case A_VERSION:	toktype = ERx("VERSION");	break;
	    case A_ALARMID:	toktype = ERx("ALARMID");	break;
	    case A_COMPNAME:	toktype = ERx("COMPNAME");	break;
	    case A_COPYRIGHT:	toktype = ERx("COPYRIGHT");	break;
	    case A_DBNAME:	toktype = ERx("DBNAME");	break;
	    case A_DESTROY:     toktype = ERx("DESTROY");       break;
	    case A_DROP:        toktype = ERx("DROP");          break;
	    case A_RULE:        toktype = ERx("RULE");          break;
	    case A_PROCEDURE:   toktype = ERx("PROCEDURE");     break;
	    case A_SPACE:	toktype = ERx("SPACE");		break;
	    case A_DATABSID:	toktype = ERx("DATABSID"); 	break;
	    case A_TRANID: 	toktype = ERx("TRANID"); 	break;
	    case A_SERVERID:	toktype = ERx("SERVERID"); 	break;
	    case A_TABLE:       toktype = ERx("TABLE");         break;
	    case A_OWNER:       toktype = ERx("OWNER");         break;
          case A_USER:        toktype = ERx("USER");          break;
	    case A_COLUMN:      toktype = ERx("COLUMN");        break;
	    case A_GROUP:       toktype = ERx("GROUP");         break;
	    case A_COMPILE:     toktype = ERx("COMPILE");       break;
	    default:		toktype = ERx("(error)");	break;
	}
	SIfprintf(traceptr, ARRY_LINE_FMT, tokarray[i]->token_no,
			    tokarray[i]->token, tokarray[i]->lineno, toktype );
    }
    SIfprintf(traceptr, ERx("(%5d)\n"), num_of_tokens);
    return (OK);
}