📄 udbuffil.c
字号:
/* $Header: "%n Ver=%v %f LastEdit=%w Locker=%l" */
/* "UDBUFFIL.C Ver=2 26-Nov-97,11:19:18 LastEdit=JIMV Locker=***_NOBODY_***" */
/***********************************************************************\
* *
* Copyright Wonderware Software Development Corp. 1992-1997 *
* *
* ThisFileName="L:\ww\dde_serv\src\udsample\udbuffil.c" *
* LastEditDate="1997 Nov 26 11:19:00" *
* *
\***********************************************************************/
#include <windows.h>
#include <io.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <stat.h>
#include "ntconv.h"
#include "hmemcpy.h"
#include "chainmgr.h"
#include "config.h"
#include "uddefs.h"
#include "debug.h"
/***********************************************************************
***********************************************************************
* Buffered File Routines *
***********************************************************************
***********************************************************************/
/***********************************************************************/
/* assign name, buffer to buffered file */
void WINAPI AssignBufferedFile (BUFFERED_FILE *BFile,
LPSTR file_name, LPSTR buffer_ptr, int buffer_size)
{
/* clear error status */
BFile->error = 0;
/* set pointers for file name, buffer */
BFile->FileName = file_name;
BFile->FileBuf = buffer_ptr;
BFile->BufSize = buffer_size;
} /*AssignBufferedFile*/
/***********************************************************************/
/* open a buffered file for read */
int WINAPI OpenForBufferedRead (BUFFERED_FILE *SourceFile)
{
#ifndef WIN32
char file_name [256+1];
#endif
/* initialize pointer, character count, flags */
SourceFile->BufPtr = SourceFile->BufSize;
SourceFile->MaxCharsToRead = 0;
SourceFile->more_data = TRUE;
SourceFile->AllCharsRead = FALSE;
SourceFile->AllBlocksRead = FALSE;
/* attempt to open file, get handle */
#ifdef WIN32
SourceFile->FileH = OPENRead (SourceFile->FileName);
#else
lstrcpy (file_name, SourceFile->FileName);
SourceFile->FileH = OPENRead (file_name);
#endif
/* check whether successful */
SourceFile->error = (SourceFile->FileH < 0);
if (!SourceFile->error)
/* set read pointer to start of file */
LSEEK (SourceFile->FileH, 0L, SEEK_SET);
/* return error status */
return (SourceFile->error);
} /*OpenForBufferedRead*/
/***********************************************************************/
/* close a buffered file for read */
int WINAPI CloseForBufferedRead (BUFFERED_FILE *SourceFile)
{
/* clear error status */
SourceFile->error = 0;
/* close the file */
LCLOSE (SourceFile->FileH);
/* return error status */
return (SourceFile->error);
} /*CloseForBufferedRead*/
/***********************************************************************/
/* open a buffered file for write */
int WINAPI OpenForBufferedWrite (BUFFERED_FILE *DestFile)
{
#ifndef WIN32
char file_name [256+1];
#endif
/* reset buffer pointer */
DestFile->BufPtr = 0;
/* attempt to open file, get handle */
#ifdef WIN32
DestFile->FileH = OPENCreate (DestFile->FileName);
#else
lstrcpy (file_name, DestFile->FileName);
DestFile->FileH = OPENCreate (file_name);
#endif
/* check whether successful */
DestFile->error = (DestFile->FileH < 0);
/* return error status */
return (DestFile->error);
} /*OpenForBufferedWrite*/
/***********************************************************************/
/* close a buffered file for write */
int WINAPI CloseForBufferedWrite (BUFFERED_FILE *DestFile)
{
/* clear error status */
DestFile->error = 0;
/* check whether any data remains in the buffer */
if (DestFile->BufPtr > 0)
/* some data remains, write it to file */
WriteNextBlock (DestFile);
/* close the file */
LCLOSE (DestFile->FileH);
/* return error status */
return (DestFile->error);
} /*CloseForBufferedWrite*/
/***********************************************************************/
/* read next block from buffered file */
void WINAPI ReadNextBlock (BUFFERED_FILE *SourceFile)
{
/* clear error status */
SourceFile->error = 0;
/* attempt to read data from file, get length actually read */
SourceFile->MaxCharsToRead
= LREAD (SourceFile->FileH, SourceFile->FileBuf, SourceFile->BufSize);
/* reset buffer pointer */
SourceFile->BufPtr = 0;
/* check length of data */
if (SourceFile->MaxCharsToRead < SourceFile->BufSize)
/* less than a full buffer, indicate no more blocks available */
SourceFile->AllBlocksRead = TRUE;
/* check whether any data was obtained */
if (SourceFile->MaxCharsToRead == 0)
/* no data was obtained, indicate no more data */
SourceFile->AllCharsRead = TRUE;
} /*ReadNextBlock*/
/***********************************************************************/
/* read next character from buffered file */
char WINAPI ReadNextChar (BUFFERED_FILE *SourceFile)
{
char ch;
/* clear error status */
SourceFile->error = 0;
/* check whether at end of buffer */
if (SourceFile->BufPtr >= SourceFile->BufSize)
/* at end, read buffer from file, reset buffer pointer */
ReadNextBlock (SourceFile);
/* check whether at end of file */
if (SourceFile->AllBlocksRead &&
(SourceFile->BufPtr >= SourceFile->MaxCharsToRead))
SourceFile->AllCharsRead = TRUE;
/* check whether at end of file */
if (!(SourceFile->AllCharsRead))
/* not at end, get next character from buffer, advance pointer */
ch = (SourceFile->FileBuf) [SourceFile->BufPtr++];
else
{
/* at end, use zero, indicate no more data */
ch = 0;
SourceFile->more_data = FALSE;
}
/* return new character */
return (ch);
} /*ReadNextChar*/
/***********************************************************************/
/* read buffer of indicated length from buffered file,
returns OK if successful */
BOOL WINAPI ReadNextBuffer (BUFFERED_FILE *SourceFile,
char *buf_ptr, unsigned long buf_len)
{
char ch;
unsigned long len;
BOOL status;
/* initialize return value */
status = TRUE;
/* clear error status */
SourceFile->error = 0;
/* initialize acquired length */
len = 0;
/* attempt to get indicated buffer length */
while ((len < buf_len) && (SourceFile->error == 0)) {
/* attempt to get next character from file */
ch = ReadNextChar (SourceFile);
/* check for character, end of file */
if ((SourceFile->more_data) && (SourceFile->error == 0))
{
/* store character in buffer, advance pointer and length */
*(buf_ptr++) = ch;
len++;
} else {
/* problem or no more data; indicate error and exit loop */
status = FALSE;
break;
}
}
/* indicate success or failure */
return (status);
} /*ReadNextBuffer*/
/***********************************************************************/
/* read next text line from buffered file */
BOOL WINAPI ReadNextLine (BUFFERED_FILE *SourceFile,
char *buf_ptr, unsigned long buf_len)
{
char ch;
unsigned long len;
BOOL done;
BOOL status;
/* initialize return value */
status = TRUE;
/* clear error status */
SourceFile->error = 0;
/* check length of destination buffer */
if (buf_len < 1) {
/* no room to store string anyway, just return */
return (status);
}
/* initialize acquired length, flag */
len = 0;
done = FALSE;
/* attempt to get string up to indicated buffer length */
while ((!done) && (len+1 < buf_len) && (SourceFile->error == 0)) {
/* attempt to get next character from file */
ch = ReadNextChar (SourceFile);
/* check for character, end of file */
if ((SourceFile->more_data) && (SourceFile->error == 0))
{
/* check character */
switch (ch)
{
case 10 : /* line feed */
/* indicate line is done */
done = TRUE;
break;
case 13 : /* carriage return */
/* indicate line is done */
done = TRUE;
/* check for following line feed character */
ch = ReadNextChar (SourceFile);
if ((SourceFile->more_data) && (ch != 10))
{
/* got character, but not a line feed -- put it back */
SourceFile->BufPtr--;
}
break;
default : /* any other character */
/* store character in buffer, advance pointer and length */
*(buf_ptr++) = ch;
len++;
} /* switch */
} else {
/* check file error */
if (SourceFile->error != 0) {
/* indicate error */
status = FALSE;
}
/* string done, exit loop */
break;
}
}
/* terminate string */
*buf_ptr = '\0';
/* indicate success or failure */
return (status);
} /* ReadNextLine */
/***********************************************************************/
/* write next block to buffered file */
void WINAPI WriteNextBlock (BUFFERED_FILE *DestFile)
{
/* clear error status */
DestFile->error = 0;
/* check whether buffer contains any data */
if (DestFile->BufPtr > 0)
{
/* attempt to write data to file */
if ((unsigned int) LWRITE (DestFile->FileH, DestFile->FileBuf, DestFile->BufPtr)
!= DestFile->BufPtr)
/* unable to write data, indicate error */
DestFile->error = 1;
}
/* reset buffer pointer */
DestFile->BufPtr = 0;
} /*WriteNextBlock*/
/***********************************************************************/
/* write next character to buffered file */
void WINAPI WriteNextChar (BUFFERED_FILE *DestFile, char ch)
{
/* clear error status */
DestFile->error = 0;
/* check whether at end of buffer */
if (DestFile->BufPtr >= DestFile->BufSize)
/* at end, write buffer out to file, reset buffer pointer */
WriteNextBlock (DestFile);
/* append new character to buffer, advance pointer */
(DestFile->FileBuf) [DestFile->BufPtr++] = ch;
} /*WriteNextChar*/
/***********************************************************************/
/* write buffer of indicated length to buffered file */
BOOL WINAPI WriteNextBuffer (BUFFERED_FILE *DestFile,
char *buf_ptr, unsigned long buf_len)
{
char ch;
unsigned long len;
BOOL status;
/* initialize return value */
status = TRUE;
/* clear error status */
DestFile->error = 0;
/* initialize acquired length */
len = 0;
/* attempt to write buffer of indicated length */
while ((len < buf_len) && (DestFile->error == 0)) {
/* get next character from buffer, advance pointer and length */
ch = *(buf_ptr++);
len++;
/* attempt to store character in file */
WriteNextChar (DestFile, ch);
}
if (DestFile->error != 0) {
/* indicate error */
status = FALSE;
}
/* indicate success or failure */
return (status);
} /*WriteNextBuffer*/
/***********************************************************************/
/* read next File Version structure from buffered file,
returns TRUE if successful and valid */
BOOL WINAPI ReadNextVersion (BUFFERED_FILE *SourceFile,
unsigned long lMagic, long FAR *lpVersion)
{
BOOL ok;
FILEVER file_ver;
ok = ReadNextBuffer (SourceFile, (char *) &file_ver, sizeof(FILEVER));
if (file_ver.fv_magic != lMagic) {
ok = FALSE;
}
*lpVersion = file_ver.fv_version;
return (ok);
} /* ReadNextVersion */
/***********************************************************************/
/* write next File Version structure to buffered file,
returns TRUE if successful */
BOOL WINAPI WriteNextVersion (BUFFERED_FILE *DestFile,
unsigned long lMagic, long lVersion,
LPSTR lpszDate, LPSTR lpszTime, char pad_val)
{
FILEVER file_ver;
/* clear file version structure */
memset (&file_ver, pad_val, sizeof(file_ver));
/* put values into file version */
file_ver.fv_magic = lMagic;
file_ver.fv_version = lVersion;
f_lstrncpy ((LPSTR) file_ver.fv_date, lpszDate, lstrlen(lpszDate));
f_lstrncpy ((LPSTR) file_ver.fv_time, lpszTime, lstrlen(lpszTime));
/* attempt to write value, indicate success or failure */
return (WriteNextBuffer (DestFile, (char *) &file_ver, sizeof(FILEVER)));
} /* WriteNextVersion */
/***********************************************************************/
/* read next bAnyMore flag from buffered file,
returns TRUE if successful */
BOOL WINAPI ReadNextAnyMore (BUFFERED_FILE *SourceFile, WORD *pAnyMore)
{
BOOL ok;
ok = ReadNextBuffer (SourceFile, (char *) pAnyMore, sizeof(WORD));
if (!ok)
debug ("Error reading bAnyMore");
/* indicate success or failure */
return (ok);
} /* ReadNextAnyMore */
/***********************************************************************/
/* write next bAnyMore flag to buffered file,
returns TRUE if successful */
BOOL WINAPI WriteNextAnyMore (BUFFERED_FILE *DestFile, WORD bAnyMore)
{
BOOL ok;
ok = WriteNextBuffer (DestFile, (char *) &bAnyMore, sizeof(WORD));
/* indicate success or failure */
return (ok);
} /* WriteNextAnyMore */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -