windows-xp/Source/XPSP1/NT/multimedia/media/tools/docfmt/misc.c

/* misc.c -  miscellanous routines
 *
 * 06/16/88 MattS	Created
 *
 * 10/15/89 MattS	Added AutoDoc comment blocks
*/

#include <stdio.h>
#include <ctype.h>
#ifdef MSDOS
#include <io.h>
#include <stdlib.h>
#endif
#include <fcntl.h>
#include <malloc.h>
#include <string.h>

#include "misc.h"

#define FALSE 0
#define TRUE 1

/*
** Compare a string with a hi-bit terminates string
*/

#ifdef NOT_NEEDED
/*
 * @doc MISC INTERNAL
 *
 * @func int | hb_strcmp | This function compares a string with a
 *  hi-bit terminated string. (instead of zero terminated)
 *
 * @parm unsigned char * | str | Zero terminated string.
 *
 * @parm unsigned char * | hb_str | High-bit terminated string.
 *
 * @rdesc The return is the same as strcmp.
 *
 */
hb_strcmp(str, hb_str)
	register unsigned char *str, *hb_str;
{
	unsigned char hbc;

	for (;;) {
		hbc = *hb_str & (unsigned char)0x7f;
		if (hbc == *str) {
			if (*++str == 0)
				return (*hb_str & 0x80) ? 0 : -1;
			else if (*hb_str++ & 0x80)
				return 1;
		} else
			return *str - hbc;
	}
}



/*
 * @doc MISC
 *
 * @func int | hex_nyb | This function converts the hex character into
 *  binary.
 *
 * @parm int | chr | The character to convert.
 *
 * @rdesc The return is the binary hex value of <p chr>.
 *
 */
int hex_nyb(chr)
	register int chr;
{
	if (chr >= '0' && chr <= '9')
		return chr - '0';
	else
		if (chr >= 'A' && chr <= 'Z')
			return chr - 'A' + 0xA;
		else
			return chr - 'a' + 0xA;
}

/*
 * @doc INTERNAL MISC
 *
 * @func int | hex_bytes | This function converts a hex string to binary.
 *
 * @parm char * | str | Specifies string to convert.
 *
 * @parm int | nbytes | Specifies length of string.
 *
 * @rdesc Returns binary value of hex string.
 *
 * @xref hex_nyb
 *
 */
int hex_bytes(str, nbytes)
	register char *str;
	register int nbytes;
{
	register int ret = 0;

	while (nbytes--) {
		ret <<= 4;
		ret += hex_nyb(*str++);
	}
	return ret;
}


/*
 * @doc INTERNAL MISC
 *
 * @func long | htoi | This function converts a hex string to a long.
 *
 * @parm char * | str | Specifies string to convert.
 *
 * @xref hex_bytes
 *
 */

/*
 * Interpret an ASCII string as a hex number, convert to long int.
 */
long htoi(str)
	char *str;
{
	register long ret = 0;
	register unsigned char ch;

	while (ch = *str++)
		if (ch >= '0' && ch <= '9')
			ret = (ret << 4) + ch - '0';
		else if (ch >= 'A' && ch <= 'Z')
			ret = (ret << 4) + ch - 'A' + 10;
		else if (ch >= 'a' && ch <= 'z')
			ret = (ret << 4) + ch - 'a' + 10;
		else return ret;
	return ret;
}

/* nindex --
 *
 */

/*
 *
 * @doc INTERNAL MISC
 *
 * @func int | nindex | looks for pattern p in string s starting at position start.
 *
 * @parm char * | p | Specifies pattern.
 *
 * @parm char * | s | Specifies string.
 *
 * @parm int | start | Specifies starting offset in string.
 *
 * @rdesc It returns an index to the position AFTER p if it succeeds; else -1.
 */
int
nindex(p,s,start)
    char p[];
    char s[];
    int start;
{
    register int j = start;
    register int i;
    int match = -1;
    int nLineLen = strlen(s);
    int nPattLen = strlen(p);

    while ( j < nLineLen )
    {
        /*find first letter of pattern
        */
        while (j < nLineLen)
        {
            if (p[0] == s[j++])
            {                       /* found 1st char of pattern */
                match = 1;          /* toggle flag */
                break;              /* go on to next step */
            }
        }

        if (match == 1)
        {
            /* look for rest of pattern
            */
            for (i = 1; (i < nPattLen) && (j < nLineLen) ; i++,j++)
            {
                if (p[i] != s[j])
                {
                    match = -1;     /* pattern doesn't match: toggle flag */
                    break;          /* stop looking */
                }
            }

            if (j >= nLineLen)      /* if we're at end, it doesn't matter */
            {
                match = -1;
                break;              /* break main loop with flag = fail */
            }
            else
            {
                if (match == 1)     /* found the pattern */
                {
                    match = j;      /* match points to char after pattern */
                    break;          /* break main loop with flag = success */
                }
            }
        }
    }

    return(match);
}



/*
 *
 * @doc INTERNAL MISC
 *
 * @func int | parse | Split of the line, point <p fl> array to each record, records are seperated by
 *  <p sep> charactor.
 *
 * @parm char * | cp | Specifies line.
 *
 * @parm char ** | fl | Specifies array of argument pointers.
 *
 * @parm char | sep | Specifies argument seperator character.
 *
 * @rdesc This function returns the number of fields it found.
 */
int
parse(cp, fl, sep)
	register char *cp, **fl, sep;
{
	register int nfields = 1;

	*fl++ = cp;
	while (1) {
		if (*cp == sep) {
			nfields++;
			*fl++ = cp + 1;
			*cp = 0;
		} else if (*cp == '\n' || *cp == '\0') {
			*cp = 0;
			return nfields;
		}
		cp++;
	}
}

/*
 *
 * Progress routines
 *
 *
 */

long pinc, ploc, loc;

/*
 *
 * @doc INTERNAL MISC
 *
 * @func void | init_progress | This function initializes the progress
 *  indicator.
 *
 * @parm long | size | Specifies the total size.
 *
 * @xref show_progress
 *
 */
void
init_progress(size)
	long size;
{
	ploc = pinc = size / 80;
	loc = 0;
}

/*
 *
 * @doc INTERNAL MISC
 *
 * @func void | show_progress | This function displays the progress
 *  according to the initialized value in <f init_progress>.
 *
 * @parm int | amount | Specifies the delta processed since last call
 *
 */
void
show_progress(int amt)
{
   if( (loc + amt) >ploc)
	{
		while( (loc + pinc) <= ploc+ amt) {
			loc+=pinc;
			fputc('.', stdout);
			fflush(stdout);
		}
		ploc += amt;
	}
}

/*
** mem_to_long and long_to_mem are used to convert back and forth between
 * the byte-order independant representation of integers and the
 * the internal C format
*/

/*
 *
 * @doc INTERNAL MISC
 *
 * @func long | mem_to_long | Used to convert back and forth between
 *  the byte-order independant representation of integers and the
 *  the internal C format.
 *
 * @parm unsigned char * |cp| Specifies the memory to convert.
 *
 * @parm short |nbytes | Specifies the number of bytes to convert.
 *
 * @rdesc This function returns the Local version of the value contained
 *  in the memory location.
 *
 * @comm This function was meant to provide byte-order independence capability
 *  in C code and was used in Microsoft Bookshelf and the Microsoft Library
 *  products.
 *
 * @xref long_to_mem
 *
 */
long
mem_to_long(cp, nbytes)
	register unsigned char *cp;
	register short nbytes;
{
	register int i;
	register long ret = 0;

	for (i = nbytes; i > 0;) {
		ret <<= 8;
		ret += cp[--i];
	}
	return ret;
}

/*
 *
 * @doc INTERNAL MISC
 *
 * @func void | long_to_mem | This function is used to convert back and forth between
 *  the byte-order independant representation of integers and the
 *  the internal C format.
 *
 * @parm long | value | Specifies the value to save into the memory.
 *
 * @parm unsigned char * |cp| Specifies the memory buffer.
 *
 * @parm short |nbytes | Specifies the number of bytes to convert.
 *
 * @comm This function was meant to provide byte-order independence capability
 *  in C code and was used in Microsoft Bookshelf and the Microsoft Library
 *  products.
 *
 * @xref mem_to_long
 *
 */
void
long_to_mem(val, cp, nbytes)
	register long val;
	register unsigned char *cp;
	register int nbytes;
{
	register int i;

	for (i = 0; i < nbytes; i++) {
		*cp++ = (unsigned char)val & (unsigned char)0xff;
		val >>= 8;
	}
}

/*
** This function is available under Sun 3.2 UNIX but not on MS-DOS so I
** had to write it in order to use the index building tools under MS-DOS
**
** getopt(argc, argv, template)
**	argc, argv are the arguments to main
**	template is a string of legal arguemnt characters.
**	if a character in the template is followed by a ':', this means
**	that the option takes an additional argument which will either be the
**	remainder of the argument string if this argument strings ended,
**	the next argument.
**
** RETURNS:
**		'?'	on error, print usage and exit
**		EOF	when end of options is hit, use "optind" to get non option args
**		chr means that option "chr" was specified and if it takes an
**			additional argument, that would be in the string "optarg"
**
** Here is an example program which just echos back how it parsed the command
** line, using getopt.  This template says the program has flags 'a' and 'b'
** and options 'c' and 'd'.  Legal commmand lines would be:
**		D>prog hello there folks
**		D>prog -a hello folks
**		D>prog -ab -chello -d there folks
**		D>prog -abc hello -dthere folks
**
**	extern char *optarg;
**	extern int optind;
**	char *my_template = "abc:d:";
**	
**	main(argc, argv)
**		char **argv;
**	{
**		int arg;
**	
**		while (arg = getopt(argv, argv, my_template))
**			if (optarg)
**				printf("-%c %s\n", arg, optarg);
**			else if (arg == '?') {
**				printf("Argument error\n");
**				break;
**			} else
**				printf("-%c\n", arg);
**		for (arg = optind; arg < argc - 1; arg++)
**			printf("### %s\n", argv[arg]);
**	}
*/


static int argNum;
static char *optparse;
int optind = 1;
char *optarg;

getopt(argc, argv, template)
	int		argc;
	char	**argv,
			*template;
{
	register char *arg, *tp;

	optarg = NULL;
	if (!optparse)
		if (++argNum < argc) {
			arg = argv[argNum];
			if (*arg != '-') {
				optind = argNum;
				return EOF;
			}
			optparse = arg + 1;
		} else
			return EOF;
	for (tp = template; *tp; tp++)
		if (*tp == *optparse) {
			if (tp[1] == ':') {
				if (optparse[1]) {
					optarg = optparse + 1;
					optparse = 0;
				} else
				if (++argNum == argc)
					return '?';
				else
					optarg = argv[argNum];
			}
			if (optparse && *++optparse == 0)
				optparse = NULL;
			return *tp;
		}
	return '?';
}

#endif

/*

/*
 *
 * @doc INTERNAL MISC
 *
 * @func int | findlshortname | This function returns the offset of the
 *  end of the complete path and file name not counting the file extension.
 *
 * @parm char * | fullname | Specifies the name to search.
 *
 * @rdesc The return value is the offset of the end of the complete path
 *  and file name not counting the file extension.
 *
 */
int
findlshortname(fullname) /* find the length of the short name */
		    /* full path/file name not counting extension */
char *fullname;
{
    char *ch;
    int cnt;

    if(!fullname || !*fullname)
	    return(0);

    cnt=strlen(fullname);
    ch=fullname+cnt;

    while(*ch!='.' && *ch!='\\' && *ch!='/' && cnt)
    {
	ch--;
	cnt--;
    }

    if(!cnt)
	return(strlen(fullname));

    return(ch - fullname);
}


/* getblong - get the next number from a buffer.  Returns a long positive
 * value if successful, otherwise returns -1.  Scans-off leading BS.
 * Parameters: takes a pointer to a char and a pointer to an int which
 * will become a pointer the character following the number.
 */
/*
 *
 * @doc INTERNAL MISC
 *
 * @func long | getblong | ATOL for buffer.
 *
 * @parm char * | line | Specifies buffer.
 *
 * @parm int * | i | Specifies current offset into buffer.  This value is
 *  updated as the buffer is scanned.
 *
 * @rdesc This function returns the Long value of the ASCII value contained
 *  in the buffer at the specified offset.
 *
 * The offset is updated to the next character after the last ASCII character.
 *
 */
long
getblong(line, i)
char *line;
int *i;
{
    int pos = *i;
    long result = 0;
    int nLineLen = strlen(line);

/*     while (!isdigit(line[pos]) && pos < nLineLen) */
/*	   ++pos; */

    if (pos == nLineLen)
        return ((long)-1);

    while (isdigit(line[pos]) && pos < nLineLen)
        result = 10 * result + line[pos++] - '0';

    *i = pos;

    return (result);
}

#ifdef NOT_NEEDED
/*
 *
 * @doc INTERNAL MISC
 *
 * @func char * | parse_sec_name | This function parses the section
 *  name from a complete name.
 *
 *  It was written for use in for Compound File indexing tools for
 *  Microsoft Library.
 *
 * @parm char ** | ppch | Specifies the name to parse.
 *
 * @rdesc Ack.
 *
 */
char *
parse_sec_name(char **ppch)
{
    char *pch;
    char *p2ch;
    int j;

    if(!ppch || !*ppch)
	return(NULL);

    pch=*ppch;

    while(*pch && *pch!='!')
	pch++;


    if(!*pch)		    /* default section name is file name */
	return(*ppch);

    *pch='\0';

    pch++;

    p2ch=*ppch;
    *ppch=pch;

    return(p2ch);
}

#endif


/*							*
 *							*
 * Memory Management routines				*
 *							*
 *							*
 *							*/

char _achmemout[]= "Oh my, we seem to be out of %smemory. %ld Allocated\n" ;

/* Generic memory management */

/*
 *
 * @doc INTERNAL MISC
 *
 * @func char * | cp_alloc | Allocates memory for the string and copies
 *  it into the buffer and returns it.
 *
 * @parm char * | pch| Specifies string to copy.
 *
 * @comm The buffer should be freed with <f my_free>.
 *
 */
char *
cp_alloc(pch)
char *pch;
{
    char *pch2;

    if(!pch)
	return(NULL);

    pch2=my_malloc(strlen(pch)+1);
    strcpy(pch2,pch);
    return pch2;
}

/*
 *
 * @doc INTERNAL MISC
 *
 * @func void | memfil | Fills the memory with zero.
 *
 * @parm int * | mem | Specifies the memory block to fill.
 *
 * @parm unsigned int | size | Specifies the size of the memory block.
 *
 * @comm The size of the memory block does not have to be a multiple of 2.
 *
 */
void
memfil(mem,size)
register int *mem;
register unsigned int size;
{
    char flag=FALSE;
    char *pch;

    if(size&1) /* it's odd so int fill won't work all the way */
    {
	flag=TRUE;
	size--;
    }

    size=size/2;
    while(size--)
	*mem++=0;

    if(flag)
    {
	pch=(char *)mem;
	*pch='\0';
    }

}

/*
 *
 * @doc INTERNAL MISC
 *
 * @func char * | clear_alloc | This function allocates memory and
 *  initialized it to zeros.
 *
 * @parm unsigned int | size | Specifies the size of the memory to allocate.
 *
 * @comm The allocated memory should be freed with <f my_free>.
 *
 */
char *
clear_alloc(size)
unsigned int size;
{
    char *pmem;

    pmem=my_malloc(size);
    memfil((int *)pmem,size);

    return pmem;
}

static long ivemalloc=0;

/*
 *
 * @doc INTERNAL MISC
 *
 * @func char * | my_malloc | Allocates memory and checks for errors.
 *
 * @parm unsigned int | size | Specifies the size of the memory to allocate.
 *
 * @comm The allocated memory should be freed with <f my_free>.
 *
 */
char *
my_malloc(size)
unsigned int size;
{
    char *pmem;
    int hck;

    if(size>32767)
    {
	fprintf(stderr,"Size >32K\n");
	exit(666);
    }
    hck=_heapchk();
    if(hck == _HEAPBADNODE)
    {
	fprintf(stderr,"Bad node in Heap.  Ack!\n");
	exit(666);
    }
    if(hck == _HEAPBADBEGIN)
    {
	fprintf(stderr,"Bad begin in Heap.  Ack!\n");
	exit(666);
    }
    pmem=(char *)malloc(size);
    if(pmem==NULL)
    {
	fprintf(stderr,_achmemout,"",ivemalloc);
	   exit(777);
    }
    ivemalloc+=size;
    return(pmem);
}


/*
 *
 * @doc INTERNAL MISC
 *
 * @func void | my_free | Frees the specified buffer.
 *
 * @parm void * | buffer | Specifies the buffe to free.
 *
 */
void
my_free(void * buffer)
{
    if(!buffer)
	return;

    ivemalloc-=_msize(buffer);
    free(buffer);
    return;

}


/* used by old indexing tools */

char *cpalloc(str)
	char *str;
{
	return(cp_alloc(str));
}



/*
 *
 * @doc INTERNAL MISC
 *
 * @func void | setmem | Sets the memory to the specified value.
 *
 * @parm char * | mem | Specifies the memory.
 *
 * @parm int | size | Specifies the size of the memory block.
 *
 * @parm char | val | Specifies the value to set the memory to.
 *
 * @comm Filling with zero is much faster with <f mem_fil>.
 *
 */
void
setmem(src, size, val)
	register char *src;
	register int size;
	register char val;
{
	while (size-- > 0)
		*src++ = val;
}

/*
 *
 * @doc INTERNAL MISC
 *
 * @func void | movmem | This function moves the specified memory.
 *  Overlap is not checked.
 *
 * @parm char * | src | Source of copy.
 *
 * @parm char * | dst | Destination of copy.
 *
 * @parm int | len |  Specifies number of bytes to copy.
 *
 */
void
movmem(src,dst,len)
	register char *src, *dst;
	register int len;
{
	while (len-- > 0)
		*dst++ = *src++;
}


#ifdef NOT_NEEDED

/* explicit NEAR memory management calls */

char near *
ncp_alloc(pch)
char near *pch;
{
    char near *pch2;

    if(!pch)
	return(NULL);

    pch2=nmy_malloc(strlen(pch)+1);
    strcpy(pch2,pch);
    return pch2;
}

void
nmemfil(mem,size)
register int near *mem;
register unsigned int size;
{
    char flag=FALSE;
    char near *pch;

    if(size&1) /* it's odd so int fill won't work all the way */
    {
	flag=TRUE;
	size--;
    }

    size=size/2;
    while(size--)
	*mem++=0;

    if(flag)
    {
	pch=(char near *)mem;
	*pch='\0';
    }

}

char near *
nclear_alloc(size)
unsigned int size;
{
    char near *pmem;

    pmem=nmy_malloc(size);
    memfil((int near*)pmem,size);

    return pmem;
}

static long ivenmalloc=0;

char near *
nmy_malloc(size)
unsigned int size;
{
    char near *pmem;

    pmem=(char near *)_nmalloc(size);
    if(pmem==NULL)
    {
	fprintf(stderr,_achmemout,"NEAR ",ivenmalloc);
	 exit(777);
    }
    ivenmalloc+=size;
    return(pmem);
}




/* used by old indexing tools */

char near *
ncpalloc(str)
char near *str;
{
	return(ncp_alloc(str));
}



void
nsetmem(src, size, val)
	register char near *src;
	register int size;
	register char val;
{
	while (size-- > 0)
		*src++ = val;
}

void
nmovmem(src,dst,len)
	register char near *src;
	register char near *dst;
	register int len;
{
	while (len-- > 0)
		*dst++ = *src++;
}






/* explicit FAR memory management calls */

char far *
fcp_alloc(pch)
char far *pch;
{
    char far *pch2;

    if(!pch)
	return(NULL);

    pch2=fmy_malloc(strlen(pch)+1);
    strcpy(pch2,pch);
    return pch2;
}

void
fmemfil(mem,size)
register int far *mem;
register unsigned int size;
{
    char flag=FALSE;
    char far *pch;

    if(size&1) /* it's odd so int fill won't work all the way */
    {
	flag=TRUE;
	size--;
    }

    size=size/2;
    while(size--)
	*mem++=0;

    if(flag)
    {
	pch=(char far *)mem;
	*pch='\0';
    }

}

char far *
fclear_alloc(size)
unsigned int size;
{
    char far *pmem;

    pmem=fmy_malloc(size);
    fmemfil((int far*)pmem,size);

    return pmem;
}

static long ivefmalloc=0;

char far *
fmy_malloc(size)
unsigned int size;
{
    char far *pmem;

    pmem=(char far *)_fmalloc(size);
    if(pmem==NULL)
    {
	fprintf(stderr,_achmemout,"FAR ",ivefmalloc);
	 exit(777);
    }
    ivefmalloc+=size;
    return(pmem);
}




/* used by old indexing tools */

char far *
fcpalloc(str)
char far *str;
{
	return(fcp_alloc(str));
}



void
fsetmem(src, size, val)
	register char far *src;
	register int size;
	register char val;
{
	while (size-- > 0)
		*src++ = val;
}

void
fmovmem(src,dst,len)
	register char far *src;
	register char far *dst;
	register int len;
{
	while (len-- > 0)
		*dst++ = *src++;
}



#endif

/*
 *
 * @doc INTERNAL MISC
 *
 * @func void | mymktemp | Make a temporary file.  The returned file name is
 *  guranteed to be unique and not already exist.
 *
 * @parm char * | lpszpath | Specifies the path to create the file.
 *
 * @parm char * | lpszbuffer | Specifies the buffer to receive the
 *  full path/file name.
 *
 *
 */
void
mymktemp(char * lpszpath, char * lpszbuffer)
{
    static int i=0;
    FILE *fp;

    sprintf(lpszbuffer,"%sdoc%05X.xxx",lpszpath,i++);
    fp=fopen(lpszbuffer,"r");
    if(!fp)
	return;

    fclose(fp);
    while(fp)
    {

	if(i>30000)
	{
 fprintf(stderr,"ERROR: Cannot create temporary files on %s.\n",lpszpath);
	    exit(1);
	}
	sprintf(lpszbuffer,"%sdoc%05X.xxx",lpszpath,i++);
	fp=fopen(lpszbuffer,"r");

	if(fp)
	    fclose(fp);
    }
}