head     2.9;
access   ;
symbols  ;
locks    ; strict;
comment  @ * @;


2.9
date     98.08.24.13.45.52;  author bobh;  state Exp;
branches ;
next     2.8;

2.8
date     98.03.17.11.11.39;  author bobh;  state Exp;
branches ;
next     2.6;

2.6
date     96.05.30.15.07.55;  author bobh;  state Exp;
branches ;
next     2.5;

2.5
date     94.12.15.10.59.39;  author hebo;  state Exp;
branches ;
next     ;


desc
@@


2.9
log
@Archiving sources after M2/M3 & Eqpac deployments of 1998
@
text
@/****************************************************************************/
/* Copyright 1994 MBARI                                                     */
/****************************************************************************/
/* $Header: range.c,v 2.8 98/03/17 11:11:39 bobh Exp $			    */
/* Summary  : Routines to handle Log Record Ranges			    */
/* Filename : range.c							    */
/* Author   : Robert Herlien (rah)					    */
/* Project  : OASIS Mooring						    */
/* $Revision: 2.8 $							    */
/* Created  : 03/30/94							    */
/****************************************************************************/
/* Modification History:						    */
/* 30mar94 rah - created						    */
/* $Log
*/
/****************************************************************************/

#include <stdio.h>			/* Standard I/O			    */
#include <mbariTypes.h>			/* MBARI type definitions	    */
#include <mbariConst.h>			/* MBARI constants		    */
#include <decode.h>			/* OASIS controller definitions	    */
#include <string.h>			/* for strcmp(), memmove	    */

#define LBUFSIZE	512		/* Size of line buffer		    */


/********************************/
/*	Global Data		*/
/********************************/

Global char	*rcdfile = "/oasis/raw/oasis.rcd";


/********************************/
/*	Module Local Data	*/
/********************************/

MLocal char	lbuf[LBUFSIZE];		/* Line buffer			    */


/************************************************************************/
/* Function    : rcdInit						*/
/* Purpose     : Initialize LogStruct					*/
/* Inputs      : LogStruct ptr, number of LogStructs			*/
/* Outputs     : None							*/
/************************************************************************/
	Void
rcdInit( LogStruct *lp )
{
    memset( (void *)lp, 0, sizeof(LogStruct) );

} /*rcdInit() */


/************************************************************************/
/* Function    : isCanRcd						*/
/* Purpose     : Check string to see if it's a record for a given can	*/
/* Inputs      : String ptr, Can name					*/
/* Outputs     : Log number (0-n) if can string matches, else ERROR	*/
/************************************************************************/
	Int32
isCanRcd( char *s, char *can )
{
    Reg Nat32	len;
    Nat32	lognum;
    
    len = strlen(can);
    if ( strncmp(s, can, len) != 0 )
	return( ERROR );

    if ( sscanf(s + len, ".%d", &lognum) == 1 )
	return( lognum );
    else
	return( ERROR );

} /* isCanRcd() */


/************************************************************************/
/* Function    : updateLogPtrs						*/
/* Purpose     : Update pointers in LogStruct to allow insertion of lognum*/
/* Inputs      : LogStruct ptr, Log number you want to allow space for	*/
/* Outputs     : None							*/
/************************************************************************/
	Void
updateLogPtrs( LogStruct *lp, Int32 lognum )
{
    Reg Int32	shftCnt;

    shftCnt = lognum - lp->firstLog - NLOGS + 1;

    if ( shftCnt >= NLOGS )
	lp->firstLog = lognum;

    else if ( shftCnt > 0 )
    {
	bcopy( (char *)&lp->logs[shftCnt], (char *)&lp->logs,
	       (NLOGS - shftCnt) * sizeof(OneLog) );

	lp->firstLog = lognum - NLOGS + 1;
	bzero( (char *)&lp->logs[NLOGS-1], sizeof(OneLog) );
    }
    
    if ( lognum >= lp->nLogs )
	lp->nLogs = lognum + 1;

} /* updateLogPtrs() */


/************************************************************************/
/* Function    : readRcd						*/
/* Purpose     : Read Record file, fill in array of LogStructs		*/
/* Inputs      : Can name, Ptr to array of LogStructs, num structs in array*/
/* Outputs     : TRUE if read file OK					*/
/************************************************************************/
	MBool
readRcd( char *can, LogStruct *lp )
{
    Reg FILE	*fp;
    Reg char	*p;
    Reg Nat32	range, i;
    Reg Int32	lognum, lognumOffset;
    Nat32	min, max;
    
    if ( (fp = fopen(rcdfile, "r")) == (FILE *)NULL )
    {
	fprintf(stderr, "Cannot open record file %s\n", rcdfile);
	return( FALSE );
    }    

    while( fgets(lbuf, sizeof(lbuf), fp) != NULL )
    {
	if ( ((p = strtok(lbuf, ":")) == NULL) ||
	     ((lognum = isCanRcd(p, can)) == ERROR) )
	    continue;

	updateLogPtrs( lp, lognum );

	lognumOffset = lognum - lp->firstLog;

	for (range = 0; ((p = strtok(NULL, ",")) != NULL) && (range < NRANGES);)
	{
	    i = sscanf( p, "%d - %d", &min, &max );
	    if ( i == 1 )
		max = min;
	    if ( i >= 1 )
	    {
		lp->logs[lognumOffset].range[range].min = min;
		lp->logs[lognumOffset].range[range].max = max;
		range++;
	    }
	}
	lp->logs[lognumOffset].nRanges = range;
    }

    close( fp );
    return( TRUE );

} /* readRcd() */


/***************************************************************************/
/* Function    : writeRcd						   */
/* Purpose     : Write Record file, replace can strings with LogStruct info*/
/* Inputs      : Can name, Ptr to array of LogStructs, num structs in array*/
/* Outputs     : None							   */
/***************************************************************************/
	Void
writeRcd( char *can, LogStruct *lp )
{
    Reg FILE		*fp, *nfp;
    Reg char		*p, *name;
    Reg Nat32		i;
    Reg Int32		lognum;
    Reg OneLog		*olp;

    if ( (fp = fopen(rcdfile, "r")) == (FILE *)NULL )
	fprintf(stderr, "Cannot open record file %s\n", rcdfile);

    strcpy( lbuf, rcdfile );
    if ( (p = strrchr(lbuf, '/')) != NULL )
	*p = '\0';
    else
	strcpy( lbuf, "." );

    if ( (name = tempnam(lbuf, NULL)) == NULL )
    {	
	fprintf(stderr, "Cannot get temp file name\n");
	return;
    }

    if ( (nfp = fopen(name, "w")) == (FILE *)NULL )
    {
	fprintf(stderr, "Cannot open temp file %s\n", name);
	return;
    }    
					/* Copy all rcd file that isn't	*/
    if ( fp != (FILE *)NULL )		/*  covered by current can	*/
	while( fgets(lbuf, sizeof(lbuf), fp) != NULL )
	    if ( (lognum = isCanRcd(lbuf, can)) == ERROR )
		fwrite( lbuf, 1, strlen(lbuf), nfp );

				/* Now print current can records to rcd file*/
    for ( lognum = lp->firstLog, olp = lp->logs;
	  lognum < lp->nLogs; lognum++, olp++ )
	if ( olp->nRanges > 0 )
	{
	    fprintf( nfp, "%s.%d: ", can, lognum );
	    for( i = 0; i < olp->nRanges; i++ )
	    {
		if ( i > 0 )
		    fprintf( nfp, "," );
		fprintf( nfp, "%d", olp->range[i].min );

		if ( olp->range[i].min < olp->range[i].max )
		    fprintf( nfp, "-%d", olp->range[i].max );
	    }
	    fprintf( nfp, "\n" );
	}

    if ( fclose(nfp) == ERROR )
	fprintf( stderr, "Cannot close record file %s\n", name );
    else
    {
	unlink( rcdfile );
	rename( name, rcdfile );
    }

    free( name );

} /* writeRcd() */


/************************************************************************/
/* Function    : gotRcd							*/
/* Purpose     : Note received record number in LogStruct		*/
/* Inputs      : LogStruct, record number				*/
/* Outputs     : None							*/
/************************************************************************/
	Void
gotRcd( LogStruct *lp, Int32 lognum, Nat32 rcd )
{
    Reg Nat32	i;
    Reg OneLog	*olp;

    if ( lognum < lp->firstLog )
	return;

    updateLogPtrs( lp, lognum );		/* Allow space for this log*/
    olp = &lp->logs[lognum - lp->firstLog];	/* Point to appropriate log*/

    for ( i = 0; i < olp->nRanges; i++ )
    {
	if ( (rcd >= olp->range[i].min) && (rcd <= olp->range[i].max) )
	    return;				/* If already logged, rtn*/

	if ( rcd == (olp->range[i].min - 1) )
	{					/* If at low end of range*/
	    olp->range[i].min = rcd;		/* just note and return  */
	    return;
	}

	if ( rcd < olp->range[i].min )
	{					/* If between existing ranges*/
	    if ( olp->nRanges >= NRANGES )	/* create new range	  */
		return;
	    memmove( (void *)&olp->range[i+1], (void *)&olp->range[i],
		     (olp->nRanges - i) * sizeof(RcdRange) );
	    olp->nRanges++;
	    olp->range[i].min = olp->range[i].max = rcd;
	    return;
	}

	if ( rcd == (olp->range[i].max + 1) )
	{					/* If at hi end of range   */
	    olp->range[i].max = rcd;		/* note and return	   */
	    if (((i + 1) < olp->nRanges) && (rcd >= (olp->range[i+1].min - 1)))
	    {					/* Collapse two ranges	   */
		olp->range[i].max = olp->range[i+1].max;
		olp->nRanges--;
		memmove( (void *)&olp->range[i+1], (void *)&olp->range[i+2],
			 (olp->nRanges - i) * sizeof(RcdRange) );
		memset( (void *)&olp->range[olp->nRanges], 0, 
		        sizeof(RcdRange) );
	    }
	    return;
	}
    }
				/* Rcd num is bigger than existing ranges */
    if ( olp->nRanges < NRANGES )
    {
	olp->range[olp->nRanges].min = olp->range[olp->nRanges].max = rcd;
	olp->nRanges++;
    }

} /* gotRcd() */


/************************************************************************/
/* Function    : getMissingRcd						*/
/* Purpose     : Find next set of missing records			*/
/* Inputs      : LogStruct, log and record number to search from,	*/
/*		 place to put missing record range			*/
/* Outputs     : TRUE if more missing records, FALSE if not		*/
/* Side Effect : If return == TRUE, *rcd is filled in with range of	*/
/*		 missing records					*/
/************************************************************************/
	MBool
getMissingRcd( LogStruct *lp, Int32 lognum, Nat32 last, RcdRange *rcd )
{
    Reg Nat32	i;
    Reg OneLog	*olp;

    if ( (lognum < lp->firstLog) || (lognum >= lp->firstLog + NLOGS) )
	return( FALSE );

    olp = &lp->logs[lognum - lp->firstLog];

    for ( i = 0; i < olp->nRanges; i++ )
    {
	if ( last < olp->range[i].min )
	{
	    rcd->min = last;
	    rcd->max = olp->range[i].min - 1;
	    return( TRUE );
	}

	if ( (i < (olp->nRanges - 1)) && (last <= olp->range[i].max) )
	{
	    rcd->min = olp->range[i].max + 1;
	    rcd->max = olp->range[i+1].min - 1;
	    return( TRUE );
	}
    }

    return( FALSE );

} /* getMissingRcd() */
@


2.8
log
@Archiving sources prior to porting to DOS/Windows
@
text
@d4 1
a4 1
/* $Header: range.c,v 2.6 96/05/30 15:07:55 bobh Exp $			    */
d9 1
a9 1
/* $Revision: 2.6 $							    */
d19 2
a20 2
#include <mbari/types.h>		/* MBARI type definitions	    */
#include <mbari/const.h>		/* MBARI constants		    */
@


2.6
log
@Update for version in use during 1995-6 deployment
@
text
@d4 1
a4 1
/* $Header: range.c,v 2.5 94/12/15 10:59:39 hebo Exp $			    */
d9 1
a9 1
/* $Revision: 2.5 $							    */
d141 1
a141 1
	for ( range = 0; (p = strtok(NULL, ",")) != NULL; range < NRANGES )
d173 2
a174 1
    Reg Int32		i, lognum;
d309 1
a309 1
getMissingRcd( LogStruct *lp, Nat32 lognum, Nat32 last, RcdRange *rcd )
d311 1
a311 1
    Reg Int32	i;
@


2.5
log
@Accumulated minor changes, mainly due to move to tsunami
@
text
@d4 1
a4 1
/* $Header$			    */
d9 1
a9 1
/* $Revision$							    */
d48 1
a48 1
rcdInit( LogStruct *lp, Nat32 nlogs )
d50 1
a50 1
    memset( (void *)lp, 0, nlogs * sizeof(LogStruct) );
d80 31
d117 1
a117 1
readRcd( char *can, LogStruct *lp, Nat32 nlogs )
d122 1
a122 1
    Reg Int32	lognum;
d134 1
a134 2
	     ((lognum = isCanRcd(p, can)) == ERROR) || (lognum >= nlogs) )

d137 4
d148 2
a149 2
		lp[lognum].range[range].min = min;
		lp[lognum].range[range].max = max;
d153 1
a153 1
	lp[lognum].nRanges = range;
d169 1
a169 1
writeRcd( char *can, LogStruct *lp, Nat32 nlogs )
d174 1
a174 1
    Reg LogStruct	*clp;
a176 1
    {
a177 2
	return;
    }    
d196 5
d202 4
a205 5
    while( fgets(lbuf, sizeof(lbuf), fp) != NULL )
    {
	if ( ((lognum = isCanRcd(lbuf, can)) == ERROR) || (lognum >= nlogs) )
	    fwrite( lbuf, 1, strlen(lbuf), nfp );
	else
d208 1
a208 2
	    clp = lp + lognum;
	    for( i = 0; i < clp->nRanges; i++ )
d212 1
a212 1
		fprintf( nfp, "%d", clp->range[i].min );
d214 2
a215 2
		if ( clp->range[i].min < clp->range[i].max )
		    fprintf( nfp, "-%d", clp->range[i].max );
a218 1
    }
d240 1
a240 1
gotRcd( LogStruct *lp, Nat32 rcd )
d243 9
a251 2
    
    for ( i = 0; i < lp->nRanges; i++ )
d253 1
a253 1
	if ( (rcd >= lp->range[i].min) && (rcd <= lp->range[i].max) )
d256 1
a256 1
	if ( rcd == (lp->range[i].min - 1) )
d258 1
a258 1
	    lp->range[i].min = rcd;		/* just note and return  */
d262 1
a262 1
	if ( rcd < lp->range[i].min )
d264 1
a264 1
	    if ( lp->nRanges >= NRANGES )	/* create new range	  */
d266 4
a269 4
	    memmove( (void *)&lp->range[i+1], (void *)&lp->range[i],
		     (lp->nRanges - i) * sizeof(RcdRange) );
	    lp->nRanges++;
	    lp->range[i].min = lp->range[i].max = rcd;
d273 1
a273 1
	if ( rcd == (lp->range[i].max + 1) )
d275 2
a276 2
	    lp->range[i].max = rcd;		/* note and return	   */
	    if (((i + 1) < lp->nRanges) && (rcd >= (lp->range[i+1].min - 1)))
d278 6
a283 5
		lp->range[i].max = lp->range[i+1].max;
		lp->nRanges--;
		memmove( (void *)&lp->range[i+1], (void *)&lp->range[i+2],
			 (lp->nRanges - i) * sizeof(RcdRange) );
		memset( (void *)&lp->range[lp->nRanges], 0, sizeof(RcdRange) );
d289 1
a289 1
    if ( lp->nRanges < NRANGES )
d291 2
a292 2
	lp->range[lp->nRanges].min = lp->range[lp->nRanges].max = rcd;
	lp->nRanges++;
d301 2
a302 2
/* Inputs      : LogStruct, record number to search from, place to put	*/
/*		 missing record range					*/
d308 1
a308 1
getMissingRcd( LogStruct *lp, Nat32 last, RcdRange *rcd )
d310 9
a318 3
    Reg Nat32	i;
    
    for ( i = 0; i < (lp->nRanges - 1); i++ )
d320 1
a320 1
	if ( last < lp->range[i].min )
d323 1
a323 1
	    rcd->max = lp->range[i].min - 1;
d327 1
a327 1
	if ( last <= lp->range[i].max )
d329 2
a330 2
	    rcd->min = lp->range[i].max + 1;
	    rcd->max = lp->range[i+1].min - 1;
@