static void FS_Push_Vertice(GLuint FontImage, float x, float y, float textx,
float texty, struct Vector4f Color, int z) {
int ID = -1;
for (int i = 0; i < FS_Texture_Count; i++) {
if (FS_Font_Image[i] == FontImage && FS_Vertices_Count[i] < FONT_VERTICES_MAX) {
ID = i;
break;
}
}
if (ID == -1) {
if (FS_Texture_Count == TEXTURE_MAX)
FS_Flush();
FS_Font_Image[FS_Texture_Count] = FontImage;
ID = FS_Texture_Count;
FS_Vertices_Count[FS_Texture_Count] = 0;
FS_Texture_Count++;
}
if (FS_Vertices_Count[ID] == (int)FONT_VERTICES_MAX)
{
FS_Flush();
}
FS_Vertices[ID][FS_Vertices_Count[ID]] = Vector5_Create(x, y, z, textx, texty);
FS_Color[ID][FS_Vertices_Count[ID]] = Color;
FS_Vertices_Count[ID]++;
}
/*
* SNAP_RecordDemoMetaDataMessage
*/
static void SNAP_RecordDemoMetaDataMessage( int demofile, msg_t *msg )
{
int complevel;
FS_Flush( demofile );
complevel = FS_GetCompressionLevel( demofile );
FS_SetCompressionLevel( demofile, 0 );
DEMO_SAFEWRITE( demofile, msg, true );
FS_SetCompressionLevel( demofile, complevel );
FS_Flush( demofile );
}
/*
Write a message to a server-side demo file.
*/
void SVD_WriteDemoFile(const client_t *client, const msg_t *msg)
{
int len;
msg_t cmsg;
byte cbuf[MAX_MSGLEN];
fileHandle_t file = client->demo_file;
if (*(int *)msg->data == -1) { // TODO: do we need this?
Com_DPrintf("Ignored connectionless packet, not written to demo!\n");
return;
}
// TODO: we only copy because we want to add svc_EOF; can we add it and then
// "back off" from it, thus avoiding the copy?
MSG_Copy(&cmsg, cbuf, sizeof(cbuf), (msg_t*) msg);
MSG_WriteByte(&cmsg, svc_EOF); // XXX server code doesn't do this, SV_Netchan_Transmit adds it!
// TODO: the headerbytes stuff done in the client seems unnecessary
// here because we get the packet *before* the netchan has it's way
// with it; just not sure that's really true :-/
len = LittleLong(client->netchan.outgoingSequence);
FS_Write(&len, 4, file);
len = LittleLong(cmsg.cursize);
FS_Write(&len, 4, file);
FS_Write(cmsg.data, cmsg.cursize, file); // XXX don't use len!
FS_Flush(file);
}
/* DESCRIPTION: COM_CopyFileChunk
// LOCATION: Doesn't appear here, but isn't hard to implement
// PATH: Some HPAK add/remove functions
//
// Two files. It's like strcpy except for some reason we're given the
// size. I guess that means don't zero out any pointers. Since there's no
// return value and the FS catches exceptions, checking for errors doesn't
// seem worthwhile.
*/
void COM_CopyFileChunk(hl_file_t * file1, hl_file_t * file2, int size) {
char buffer[1024];
while(size > 1024) {
FS_Read(buffer, 1, 1024, file2);
FS_Write(buffer, 1, 1024, file1);
size -= 1024;
}
//little bit to go
FS_Read(buffer, 1, size, file2);
FS_Write(buffer, 1, size, file1);
FS_Flush(file2);
FS_Flush(file1);
}
//*********************************************************************************
// Function: CETYPE FS_Rename (FSFILE* filePtr, const char * newName)
//---------------------------------------------------------------------------------
// Summary: Renames the file or directory identified by the filePtr
// Input:
// filePtr - Pointer to the File Object structure identifying the
// file to be renamed
// newName - Character string providing new name
// Return Values:
// CE_GOOD - File was deleted successfully
// Other return codes may identify various error
// conditions as required.
// Description:
// The FS_Rename(...) function will attempt to rename file or
// directory. First, it will search the directory where the entry
// is located for an object matching the new name - if such object
// found, the operation will fail; otherwise the object will be
// renamed.
//*********************************************************************************
CETYPE FS_Rename (FSFILE* filePtr, const char * newName)
{
//----------------------------------------------------------------
// Validate conditions and parameters
//----------------------------------------------------------------
if (!SDFS_InitStatus)
return CE_NOT_INIT; // FS is not initialized!
if (NULL == filePtr)
return CE_INVALID_ARGUMENT;
if (NULL == newName)
return CE_INVALID_ARGUMENT;
//----------------------------------------------------------------
// Check if the file attributes allow write
if ( (filePtr->dirFileEntry.DIR_Attr & ATTR_READONLY) == ATTR_READONLY )
return CE_READONLY;
//-----------------------------------------------------------------
CETYPE RC = CE_GOOD;
char fmtName[NAME_SIZE_8r3];
FSFILE Drtr;
FSFILE srchRes;
DWORD frstClsNum = 0;
//-----------------------------------------------------------------
// Validate new name and convert it to 8.3 FAT format
//-----------------------------------------------------------------
if ( !SDFS_Format8dot3Name(newName, fmtName, FALSE) )
return CE_INVALID_FILENAME;
//-----------------------------------------------------------------
// Prepare Directory File Object to perform search in the file's
// Directory (Directory where the entry for this file is located)
//-----------------------------------------------------------------
// Obtain first cluster number of the file's directory
frstClsNum = SDFS_DirGetFirstCluster(&filePtr->dirFileEntry);
// Initialize File Object for file's directory
SDFS_InitFSFILE(&Drtr, NULL, ATTR_DIRECTORY);
// Set first cluster of the file's directory
SDFS_DirSetFirstCluster(&Drtr.dirFileEntry, frstClsNum);
// Set the current cluster of the file's directory
Drtr.fileCrntCls = frstClsNum;
//-----------------------------------------------------------------
// Perform search for the new name in file's directory
//-----------------------------------------------------------------
RC = SDFS_DirFindNext(&Drtr, &srchRes, ATTR_NONE, ATTR_NONE,fmtName);
if (CE_GOOD == RC)
// Oops! object with this name already present
return CE_FILENAME_EXISTS;
if (CE_EOF != RC)
// Some unexpected error code - abort RENAME
return RC;
//-----------------------------------------------------------------
// Name not found - rename the file
//-----------------------------------------------------------------
// Update the Name field in the Directory Entry
memcpy(filePtr->dirFileEntry.DIR_Name, fmtName, NAME_SIZE_8r3);
// Save updated entry to disk
return FS_Flush(filePtr);
}
void Log_Write( const char* fmt, ... ) {
if ( !logfile.fp ) {
return;
}
va_list ap;
char buffer[ MAXPRINTMSG ];
va_start( ap, fmt );
Q_vsnprintf( buffer, sizeof ( buffer ), fmt, ap );
va_end( ap );
FS_Write( buffer, String::Length( buffer ), logfile.fp );
FS_Flush( logfile.fp );
}
//*********************************************************************************
// Function: CETYPE FS_Recover(FSFILE* filePtr)
//---------------------------------------------------------------------------------
// Summary: Recovers the length of a 0-length file identified by the filePtr
// based upon the number of allocated clusters
// Input:
// filePtr - Pointer to the File Object structure identifying the
// file to be recovered
// Return Values:
// CE_GOOD - File was recovered successfully
// Other return codes may identify various error
// conditions as required.
//*********************************************************************************
CETYPE FS_Recover(FSFILE* filePtr)
{
//----------------------------------------------------------------
// Validate conditions and parameters
//----------------------------------------------------------------
if (!SDFS_InitStatus)
return CE_NOT_INIT; // FS is not initialized!
if (NULL == filePtr)
return CE_INVALID_ARGUMENT;
//----------------------------------------------------------------
// Check if this is a file and not a Directory
if( FS_IsDirectory(filePtr) )
return CE_DIRECTORY;
// Check if the file is actually 0-length
if( FS_GetSize(filePtr) > 0 )
return CE_GOOD;
//-----------------------------------------------------------------
DWORD ClsSize = (DWORD)SDFS_VolumeInfo.SecPerClus
* SDFS_VolumeInfo.sectorSize;
DWORD ClsNum = SDFS_DirGetFirstCluster(&filePtr->dirFileEntry);
//-----------------------------------------------------------------
while (ClsNum < EOC_CLUSTER_FAT32)
{
//-------------------------------------------------------
// Process cluster chain
//-------------------------------------------------------
// The first 2 clusters in FAT32 are reserved...
if ( ClsNum < 2) // Cluster Number can't be "0" and "1"
return CE_RECOVERY_FAIL;
//-------------------------------------------------------
filePtr->dirFileEntry.DIR_FileSize += ClsSize;
//-------------------------------------------------------
// Load next cluster in the chain
//-------------------------------------------------------
ClsNum = SDFS_FATCacheRead(ClsNum);
}
//-----------------------------------------------------------------
// Flush updates to disk
//-----------------------------------------------------------------
return FS_Flush(filePtr);
}
/*
Stop a server-side demo.
This finishes out the file and clears the demo-related stuff
in client_t again.
*/
static void SVD_StopDemoFile(client_t *client)
{
int marker = -1;
fileHandle_t file = client->demo_file;
Com_DPrintf("SVD_StopDemoFile\n");
assert(client->demo_recording);
// write the necessary trailer and close the demo file
FS_Write(&marker, 4, file);
FS_Write(&marker, 4, file);
FS_Flush(file);
FS_FCloseFile(file);
// adjust client_t to reflect demo stopped
client->demo_recording = qfalse;
client->demo_file = -1;
client->demo_waiting = qfalse;
client->demo_backoff = 1;
client->demo_deltas = 0;
}
//*********************************************************************************
// Function: CETYPE FS_Delete (FSFILE* filePtr)
//---------------------------------------------------------------------------------
// Summary: Deletes the file identified by the filePtr
// Input:
// filePtr - Pointer to the File Object structure identifying the
// file to be deleted
// Return Values:
// CE_GOOD - File was deleted successfully
// Other return codes may identify various error
// conditions as required.
//*********************************************************************************
CETYPE FS_Delete (FSFILE* filePtr)
{
//----------------------------------------------------------------
// Validate conditions and parameters
//----------------------------------------------------------------
if (!SDFS_InitStatus)
return CE_NOT_INIT; // FS is not initialized!
if (NULL == filePtr)
return CE_INVALID_ARGUMENT;
//----------------------------------------------------------------
// Check if this is a file and not a Directory
if( FS_IsDirectory(filePtr) )
return CE_DELETE_DIR;
// Check if the file attributes allow write
if( FS_IsReadOnly(filePtr) )
return CE_READONLY;
//-----------------------------------------------------------------
CETYPE RC = CE_GOOD;
DWORD ClsNum = SDFS_DirGetFirstCluster(&filePtr->dirFileEntry);
//-----------------------------------------------------------------
// Free Cluster Chain and flush changes to disk
//-----------------------------------------------------------------
if (CE_GOOD != (RC = SDFS_FATEraseClusterChain(ClsNum)))
return RC;
ClsNum = SDFS_FATCacheFlush();
if (CLUSTER_FAIL_FAT32 == ClsNum)
return CE_DISK_ERROR;
//-----------------------------------------------------------------
// Mark Directory Entry as "deleted" and flush updates to disk
//-----------------------------------------------------------------
filePtr->dirFileEntry.DIR_Name[0] = DIR_DEL;
if (CE_GOOD != (RC = FS_Flush(filePtr)))
return RC;
//-----------------------------------------------------------------
return SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE);
}
void Renderer_Flush()
{
DS_Flush();
IS_Flush();
FS_Flush();
}
/*
Start a server-side demo.
This does it all, create the file and adjust the demo-related
stuff in client_t.
This is mostly ripped from sv_client.c/SV_SendClientGameState
and cl_main.c/CL_Record_f.
*/
static void SVD_StartDemoFile(client_t *client, const char *path)
{
int i, len;
entityState_t *base, nullstate;
msg_t msg;
byte buffer[MAX_MSGLEN];
fileHandle_t file;
Com_DPrintf("SVD_StartDemoFile\n");
assert(!client->demo_recording);
// create the demo file and write the necessary header
file = FS_FOpenFileWrite(path);
assert(file != 0);
MSG_Init(&msg, buffer, sizeof(buffer));
MSG_Bitstream(&msg); // XXX server code doesn't do this, client code does
MSG_WriteLong(&msg, client->lastClientCommand); // TODO: or is it client->reliableSequence?
MSG_WriteByte(&msg, svc_gamestate);
MSG_WriteLong(&msg, client->reliableSequence);
for (i = 0; i < MAX_CONFIGSTRINGS; i++) {
if (sv.configstrings[i][0]) {
MSG_WriteByte(&msg, svc_configstring);
MSG_WriteShort(&msg, i);
MSG_WriteBigString(&msg, sv.configstrings[i]);
}
}
Com_Memset(&nullstate, 0, sizeof(nullstate));
for (i = 0 ; i < MAX_GENTITIES; i++) {
base = &sv.svEntities[i].baseline;
if (!base->number) {
continue;
}
MSG_WriteByte(&msg, svc_baseline);
MSG_WriteDeltaEntity(&msg, &nullstate, base, qtrue);
}
MSG_WriteByte(&msg, svc_EOF);
MSG_WriteLong(&msg, client - svs.clients);
MSG_WriteLong(&msg, sv.checksumFeed);
MSG_WriteByte(&msg, svc_EOF); // XXX server code doesn't do this, SV_Netchan_Transmit adds it!
len = LittleLong(client->netchan.outgoingSequence-1);
FS_Write(&len, 4, file);
len = LittleLong (msg.cursize);
FS_Write(&len, 4, file);
FS_Write(msg.data, msg.cursize, file);
FS_Flush(file);
// adjust client_t to reflect demo started
client->demo_recording = qtrue;
client->demo_file = file;
client->demo_waiting = qtrue;
client->demo_backoff = 1;
client->demo_deltas = 0;
}
int main(void)
{
//*******************************************************************
Init();
TMRInit(2); // Initialize Timer interface with Priority=2
BLIInit(); // Initialize Signal interface
//*******************************************************************
//_T1IE = 0; // Temporarily disable Timer1 interrupt
//*******************************************************************
LogInit(); // Initialize Data Logger
//*******************************************************************
uint i;
char RData[30];
char CData[30];
for (i = 0; i < 30; i++)
{
RData[i] = CData[i] = 0;
}
char* pFN = "log1.txt";
void* pWData = &"01 02 03 04 05 06 07 08 09";
//-------------------------------------------------------------------
CETYPE RC;
uint ReadCnt;
FSFILE File;
//*******************************************************************
BLISignalON();
//------------------------------
// Create (Open) file for Writing and Reading
//------------------------------
RC = FS_CreateFile(pFN, FS_CREATE_NEW, &File);
while ( RC != CE_GOOD );
//------------------------------
// Write sample string to file
//------------------------------
RC = FS_Write (&File, pWData, 26 );
while (CE_GOOD != RC);
//------------------------------
// Check position in the file
//------------------------------
i = FS_GetPosition (&File);
while (i != 26);
//------------------------------
// Seek to start
//------------------------------
FS_SeekStart(&File);
//------------------------------
// Reed from start
//------------------------------
RC = FS_Read (&File, RData, 26, &ReadCnt);
while (CE_GOOD != RC);
//------------------------------
// Close the file - save changes
//------------------------------
RC = FS_Flush(&File);
while ( RC != CE_GOOD );
//------------------------------
//------------------------------
// Open file for Reading
//------------------------------
RC = FS_CreateFile(pFN, FS_READ_ONLY, &File);
while ( RC != CE_GOOD );
//------------------------------
// Reed from start
//------------------------------
RC = FS_Read (&File, CData, 26, &ReadCnt);
while (CE_GOOD != RC);
//------------------------------
// Close the file - save changes
//------------------------------
RC = FS_Flush(&File);
while ( RC != CE_GOOD );
//------------------------------
i = 1 + i;
//*******************************************************************
BLISignalOFF();
//------------------------------
while(1);
return 0;
}
/*
Start a server-side demo.
This does it all, create the file and adjust the demo-related
stuff in client_t.
This is mostly ripped from sv_client.c/SV_SendClientGameState
and cl_main.c/CL_Record_f.
*/
static void SVD_StartDemoFile(client_t *client, const char *path)
{
int i, len;
entityState_t *base, nullstate;
msg_t msg;
byte buffer[MAX_MSGLEN];
fileHandle_t file;
#ifdef USE_DEMO_FORMAT_42
char *s;
int v, size;
#endif
Com_DPrintf("SVD_StartDemoFile\n");
assert(!client->demo_recording);
// create the demo file and write the necessary header
file = FS_FOpenFileWrite(path);
assert(file != 0);
/* File_write_header_demo // ADD this fx */
/* HOLBLIN entete demo */
#ifdef USE_DEMO_FORMAT_42
//@Barbatos: get the mod version from the server
s = Cvar_VariableString("g_modversion");
size = strlen( s );
len = LittleLong( size );
FS_Write( &len, 4, file );
FS_Write( s , size , file );
v = LittleLong( PROTOCOL_VERSION );
FS_Write ( &v, 4 , file );
len = 0;
len = LittleLong( len );
FS_Write ( &len, 4 , file );
FS_Write ( &len, 4 , file );
#endif
/* END HOLBLIN entete demo */
MSG_Init(&msg, buffer, sizeof(buffer));
MSG_Bitstream(&msg); // XXX server code doesn't do this, client code does
MSG_WriteLong(&msg, client->lastClientCommand); // TODO: or is it client->reliableSequence?
MSG_WriteByte(&msg, svc_gamestate);
MSG_WriteLong(&msg, client->reliableSequence);
for (i = 0; i < MAX_CONFIGSTRINGS; i++) {
if (sv.configstrings[i][0]) {
MSG_WriteByte(&msg, svc_configstring);
MSG_WriteShort(&msg, i);
MSG_WriteBigString(&msg, sv.configstrings[i]);
}
}
Com_Memset(&nullstate, 0, sizeof(nullstate));
for (i = 0 ; i < MAX_GENTITIES; i++) {
base = &sv.svEntities[i].baseline;
if (!base->number) {
continue;
}
MSG_WriteByte(&msg, svc_baseline);
MSG_WriteDeltaEntity(&msg, &nullstate, base, qtrue);
}
MSG_WriteByte(&msg, svc_EOF);
MSG_WriteLong(&msg, client - svs.clients);
MSG_WriteLong(&msg, sv.checksumFeed);
MSG_WriteByte(&msg, svc_EOF); // XXX server code doesn't do this, SV_Netchan_Transmit adds it!
len = LittleLong(client->netchan.outgoingSequence-1);
FS_Write(&len, 4, file);
len = LittleLong (msg.cursize);
FS_Write(&len, 4, file);
FS_Write(msg.data, msg.cursize, file);
#ifdef USE_DEMO_FORMAT_42
// add size of packet in the end for backward play /* holblin */
FS_Write(&len, 4, file);
#endif
FS_Flush(file);
// adjust client_t to reflect demo started
client->demo_recording = qtrue;
client->demo_file = file;
client->demo_waiting = qtrue;
client->demo_backoff = 1;
client->demo_deltas = 0;
}
/*
=============
Com_Error
Both client and server can use this, and it will
do the apropriate things.
=============
*/
void Com_Error(error_type_t code, const char *fmt, ...)
{
char msg[MAXERRORMSG];
va_list argptr;
size_t len;
// may not be entered recursively
if (com_errorEntered) {
#ifdef _DEBUG
if (com_debug_break && com_debug_break->integer) {
Sys_DebugBreak();
}
#endif
Sys_Error("recursive error after: %s", com_errorMsg);
}
com_errorEntered = qtrue;
va_start(argptr, fmt);
len = Q_vscnprintf(msg, sizeof(msg), fmt, argptr);
va_end(argptr);
// save error msg
// can't print into it directly since it may
// overlap with one of the arguments!
memcpy(com_errorMsg, msg, len + 1);
// fix up drity message buffers
MSG_Init();
// abort any console redirects
Com_AbortRedirect();
// reset Com_Printf recursion level
com_printEntered = 0;
X86_POP_FPCW;
if (code == ERR_DISCONNECT || code == ERR_RECONNECT) {
Com_WPrintf("%s\n", com_errorMsg);
SV_Shutdown(va("Server was killed: %s\n", com_errorMsg), code);
CL_Disconnect(code);
goto abort;
}
#ifdef _DEBUG
if (com_debug_break && com_debug_break->integer) {
Sys_DebugBreak();
}
#endif
// make otherwise non-fatal errors fatal
if (com_fatal_error && com_fatal_error->integer) {
code = ERR_FATAL;
}
if (code == ERR_DROP) {
Com_EPrintf("********************\n"
"ERROR: %s\n"
"********************\n", com_errorMsg);
SV_Shutdown(va("Server crashed: %s\n", com_errorMsg), ERR_DROP);
CL_Disconnect(ERR_DROP);
goto abort;
}
if (com_logFile) {
FS_FPrintf(com_logFile, "FATAL: %s\n", com_errorMsg);
}
SV_Shutdown(va("Server fatal crashed: %s\n", com_errorMsg), ERR_FATAL);
CL_Shutdown();
NET_Shutdown();
logfile_close();
FS_Shutdown();
Sys_Error("%s", com_errorMsg);
// doesn't get there
abort:
if (com_logFile) {
FS_Flush(com_logFile);
}
com_errorEntered = qfalse;
longjmp(abortframe, -1);
}
int main(void)
{
//*******************************************************************
Init();
TMRInit(2); // Initialize Timer interface with Priority=2
BLIInit(); // Initialize Signal interface
//*******************************************************************
//_T1IE = 0; // Temporarily disable Timer1 interrupt
//*******************************************************************
LogInit(); // Initialize Data Logger
//*******************************************************************
uint i;
char RData[30];
char CData[30];
for (i = 0; i < 30; i++)
{
RData[i] = CData[i] = 0;
}
char* pFN = "log1.txt";
void* pWData = &"01 02 03 04 05 06 07 08 09";
//-------------------------------------------------------------------
CETYPE RC;
uint ReadCnt;
FSFILE File;
SEARCH_STATE Search;
//*******************************************************************
BLISignalON();
//*******************************************************************
// Search for every entry in the Root
RC = FS_FindFirst( "*", ATTR_NONE, ATTR_NONE, &Search, &File);
while (CE_GOOD == RC)
{
RC = FS_FindNext(&Search, &File);
}
// Search only for files
RC = FS_FindFirst( "*", ATTR_NONE, ATTR_DIRECTORY, &Search, &File);
while (CE_GOOD == RC)
{
RC = FS_FindNext(&Search, &File);
}
// Search only for directories
Deeper:
RC = FS_FindFirst( "*", ATTR_DIRECTORY, ATTR_NONE, &Search, &File);
if (CE_GOOD == RC)
{
RC = FS_chDir(&File);
if (CE_GOOD == RC)
goto Deeper;
}
Higher:
RC = FS_GetCWD(&File);
RC = CE_GOOD;
RC = FS_chDirUp();
if (CE_GOOD == RC)
goto Higher;
//*******************************************************************
//------------------------------
// Create (Open) file for Writing and Reading
//------------------------------
RC = FS_CreateFile(pFN, FS_CREATE_NEW, &File);
while ( RC != CE_GOOD );
//------------------------------
// Write sample string to file
//------------------------------
RC = FS_Write (&File, pWData, 26 );
while (CE_GOOD != RC);
//------------------------------
// Check position in the file
//------------------------------
i = FS_GetPosition (&File);
while (i != 26);
//------------------------------
// Seek to start
//------------------------------
FS_SeekStart(&File);
//------------------------------
// Reed from start
//------------------------------
RC = FS_Read (&File, RData, 26, &ReadCnt);
while (CE_GOOD != RC);
//------------------------------
// Close the file - save changes
//------------------------------
RC = FS_Flush(&File);
while ( RC != CE_GOOD );
//------------------------------
//------------------------------
// Open file for Reading
//------------------------------
RC = FS_CreateFile(pFN, FS_READ_ONLY, &File);
while ( RC != CE_GOOD );
//------------------------------
// Reed from start
//------------------------------
RC = FS_Read (&File, CData, 26, &ReadCnt);
while (CE_GOOD != RC);
//------------------------------
// Close the file - save changes
//------------------------------
RC = FS_Flush(&File);
while ( RC != CE_GOOD );
//------------------------------
i = 1 + i;
//*******************************************************************
BLISignalOFF();
//------------------------------
while(1);
return 0;
}
/*
* Com_Printf
*
* Both client and server can use this, and it will output
* to the apropriate place.
*/
void Com_Printf( const char *format, ... )
{
va_list argptr;
char msg[MAX_PRINTMSG];
time_t timestamp;
char timestamp_str[MAX_PRINTMSG];
struct tm *timestampptr;
timestamp = time( NULL );
timestampptr = gmtime( ×tamp );
strftime( timestamp_str, MAX_PRINTMSG, "%Y-%m-%dT%H:%M:%SZ ", timestampptr );
va_start( argptr, format );
Q_vsnprintfz( msg, sizeof( msg ), format, argptr );
va_end( argptr );
if( rd_target )
{
if( (int)( strlen( msg ) + strlen( rd_buffer ) ) > ( rd_buffersize - 1 ) )
{
rd_flush( rd_target, rd_buffer, rd_extra );
*rd_buffer = 0;
}
strcat( rd_buffer, msg );
return;
}
QMutex_Lock( com_print_mutex );
Con_Print( msg );
// also echo to debugging console
Sys_ConsoleOutput( msg );
// logconsole
if( logconsole && logconsole->modified )
{
logconsole->modified = qfalse;
if( log_file )
{
FS_FCloseFile( log_file );
log_file = 0;
}
if( logconsole->string && logconsole->string[0] )
{
size_t name_size;
char *name;
name_size = strlen( logconsole->string ) + strlen( ".log" ) + 1;
name = ( char* )Mem_TempMalloc( name_size );
Q_strncpyz( name, logconsole->string, name_size );
COM_DefaultExtension( name, ".log", name_size );
if( FS_FOpenFile( name, &log_file, ( logconsole_append && logconsole_append->integer ? FS_APPEND : FS_WRITE ) ) == -1 )
{
log_file = 0;
Com_Printf( "Couldn't open: %s\n", name );
}
Mem_TempFree( name );
}
}
if( log_file )
{
if( logconsole_timestamp && logconsole_timestamp->integer )
FS_Printf( log_file, "%s", timestamp_str );
FS_Printf( log_file, "%s", msg );
if( logconsole_flush && logconsole_flush->integer )
FS_Flush( log_file ); // force it to save every time
}
QMutex_Unlock( com_print_mutex );
}
//*************************************************************************************
// Function: CETYPE FS_CreateFile ( const char * FileName,
// FILE_MODE mode,
// FSFILE* filePtr )
// Summary: Creates/Opens a file with ascii name provided in FileName
// Input:
// FileName - The name of the file to open
// mode - File open mode (FILE_MODE enum)
// - FS_CREATE_NEW - Create a new file or replace an existing file.
// - FS_OPEN_EXISTING - Open existing file for read/write access or
// creates a new file; file is positioned at the
// beginning.
// - FS_APPEND - Open existing file for read/write access or
// creates a new file; file is positioned just
// past the last byte.
// - FS_READ_ONLY - Open existing file in read-only mode; file
// positioned at the beginning.
// filePtr - pointer to FSFILE data structure that will be confi-
// gured ro provide access to the file if function
// succeeds.
// Return Values:
// CETYPE - Expected CE_GOOD, but may have other codes depending on
// various error conditions.
// Description:
// This function will create and/or open specified file.
// The specified file name will be formatted to ensure that it's in 8.3
// format. Next, the search for the specified file name will be
// performed. If the name is found, the action will be taken based
// upon the requested File Mode.
//*************************************************************************************
CETYPE FS_CreateFile ( const char* FileName, FILE_MODE mode, FSFILE* filePtr )
{
//----------------------------------------------------------------
// Validate conditions and parameters
//----------------------------------------------------------------
if (!SDFS_InitStatus)
return CE_NOT_INIT; // FS is not initialized!
if (NULL == FileName)
return CE_INVALID_ARGUMENT;
if (NULL == filePtr)
return CE_INVALID_ARGUMENT;
//-----------------------------------------------------------------
CETYPE RC = CE_GOOD;
char fmtName[NAME_SIZE_8r3];
//-----------------------------------------------------------------
// Validate new name and convert it to 8.3 FAT format
//-----------------------------------------------------------------
if ( !SDFS_Format8dot3Name(FileName, fmtName, FALSE) )
return CE_INVALID_FILENAME;
//================================================================
// Make sure that the name provided is unique...
//----------------------------------------------------------------
FS_SeekStart(&SDFS_CWD); // Rewind Current Working Directory
RC = SDFS_DirFindNext(&SDFS_CWD, filePtr, ATTR_NONE, ATTR_NONE, fmtName);
//----------------------------------------------------------------
if (CE_EOF == RC)
// There is no object with the same name
goto NotFound;
//----------------------------------------------------------------
if (CE_GOOD != RC)
// Some other error (except for CE_EOF) had happened...
return RC;
//----------------------------------------------------------------
if ( FS_IsDirectory(filePtr) )
// The object found is a Directory...
{
SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE); // Reset output FSFILE structure
return CE_FILENAME_EXISTS;
}
//----------------------------------------------------------------
//================================================================
// The file with the specified name present on the disk...
//----------------------------------------------------------------
switch(mode)
{
case FS_CREATE_NEW:
// File exists, we want to create a new one, so remove it first
if ( CE_GOOD != (RC = FS_Delete(filePtr)) )
// Delete failed...
{
SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE); // Reset output FSFILE structure
return RC;
}
//-----------------------------------------
// Nope, does not exist any more :)
goto NotFound;
case FS_APPEND:
// File exists, we want to position it at the end
if ( CE_GOOD != (RC = FS_SeekEnd(filePtr)) )
// Seek failed...
{
SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE); // Reset output FSFILE structure
return RC;
}
//-----------------------------------------
// Everything is fine!
return CE_GOOD;
case FS_READ_ONLY:
// Set READONLY attribute on the FO data structure to prevent WRITEs
filePtr->dirFileEntry.DIR_Attr |= ATTR_READONLY;
// Fall-through to OPEN_EXISTING
case FS_OPEN_EXISTING:
FS_SeekStart(filePtr);
return CE_GOOD;
default:
SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE); // Reset output FSFILE structure
return CE_INVALID_ARGUMENT;
}
//================================================================
// The file with the specified name does not exist on disk...
//----------------------------------------------------------------
NotFound:
switch(mode)
{
case FS_CREATE_NEW:
case FS_APPEND:
case FS_OPEN_EXISTING:
// For all of the cases above proceed to creating new file
break;
case FS_READ_ONLY:
// Bad luck...
SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE); // Reset output FSFILE structure
return CE_NOT_FOUND;
default:
SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE); // Reset output FSFILE structure
return CE_INVALID_ARGUMENT;
}
//================================================================
// Now it is time to create a new file
//----------------------------------------------------------------
// First, try to create Directory Entry
//----------------------------------------------------------------
if ( (RC = SDFS_DirFindEmpty(&SDFS_CWD, filePtr)) != CE_GOOD)
return RC; // Could not create directory entry...
//----------------------------------------------------------------
// Second, allocate a cluster to the file
//----------------------------------------------------------------
if ( CE_GOOD != (RC = SDFS_ClusterAllocateNew(filePtr)) )
{
SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE); // Reset output FSFILE structure
return RC;
}
//----------------------------------------------------------------
// Third, set the name and Attributes of the new entry
//----------------------------------------------------------------
memcpy(filePtr->dirFileEntry.DIR_Name, fmtName, NAME_SIZE_8r3);
filePtr->dirFileEntry.DIR_Attr = ATTR_ARCHIVE;
//----------------------------------------------------------------
// That's basically it - just need to save changes to disk
//----------------------------------------------------------------
return FS_Flush(filePtr);
}
int main(void)
{
//*******************************************************************
Init();
TMRInit(2); // Initialize Timer interface with Priority=2
BLIInit(); // Initialize Signal interface
//*******************************************************************
//_T1IE = 0; // Temporarily disable Timer1 interrupt
//*******************************************************************
LogInit(); // Initialize Data Logger
//*******************************************************************
//-------------------------------------------------------------------
#define MaxRec 60
//-------------------------------------------------------------------
struct
{
DWORD TS;
WORD Index;
char filler[506];
} Data;
//-------------------------------------------------------------------
uint i;
for (i = 0; i < sizeof(Data.filler); i++)
{
Data.filler[i] = 0;
}
//-------------------------------------------------------------------
DWORD TimeStart;
float TimePoints[MaxRec];
// WORD TimeIndex[MaxRec];
//-------------------------------------------------------------------
char pFN[15];
WORD RC;
uint ReadCnt;
FSFILE File;
//*******************************************************************
BLISignalON();
//------------------------------
// Create (Open) Log file for Writing and Reading
//------------------------------
RC = LogNewFile(&File);
while ( RC != LE_GOOD );
//------------------------------
// Retrieve and save for future new log file name
//------------------------------
RC = FS_GetName(pFN, 15, &File);
while ( RC != LE_GOOD );
//------------------------------
// Write sample data to file
//------------------------------
for (i=0; i < MaxRec; i++)
{
Data.Index = i;
Data.TS = TMRGetTS();
RC = FS_WriteSector(&File, &Data);
while (CE_GOOD != RC);
}
//------------------------------
// Check position in the file
//------------------------------
i = FS_GetPosition (&File);
while (i != 512*MaxRec);
//------------------------------
// Close the file - save changes
//------------------------------
RC = FS_Flush(&File);
while ( RC != CE_GOOD );
//------------------------------
//------------------------------
// Open file for Reading
//------------------------------
RC = FS_CreateFile(pFN, FS_READ_ONLY, &File);
while ( RC != CE_GOOD );
//------------------------------
// Reed records
//------------------------------
for (i=0; i < MaxRec; i++)
{
RC = FS_Read (&File, &Data, sizeof(Data), &ReadCnt);
while (CE_GOOD != RC);
//--------------------------
// TimeIndex[i] = Data.Index;
//--------------------------
if (0 == i)
TimeStart = Data.TS;
//--------------------------
TimePoints[i] = (Data.TS - TimeStart) * TMRGetTSRate() * 1000.0; // in msec
//--------------------------
TimeStart = Data.TS;
}
//------------------------------
// Close the file - save changes
//------------------------------
RC = FS_Flush(&File);
while ( RC != CE_GOOD );
//*******************************************************************
BLISignalOFF();
//------------------------------
i = 1 + i;
//------------------------------
while(1);
return 0;
}
//*************************************************************************************
// Function: CETYPE FS_mkDir (char * Name, ATTR_TYPE Attr, FSFILE* newDir)
//-------------------------------------------------------------------------------------
// Summary: Creates directory with the specified name in the current working
// directory.
// Input:
// Name - Name of the new directory
// Attr - Additional attributes of the new directory
// newDir - pointer to the File Object structure that on SUCCESS
// will be set to the newly created directory.
// Return Values:
// CETYPE enum member (expected CE_GOOD)
// Other codes depending on encountered error conditions
//*************************************************************************************
CETYPE FS_mkDir (char * Name, ATTR_TYPE Attr, FSFILE* newDir)
{
//----------------------------------------------------------------
// Validate conditions and parameters
//----------------------------------------------------------------
if (!SDFS_InitStatus)
return CE_NOT_INIT; // FS is not initialized!
if (NULL == Name)
return CE_INVALID_FILENAME;
if (NULL == newDir)
return CE_INVALID_ARGUMENT;
//----------------------------------------------------------------
char fmtName[NAME_SIZE_8r3];
CETYPE RC;
//----------------------------------------------------------------
// Verify/Format provided Directory name (for direct match)
//----------------------------------------------------------------
if ( !SDFS_Format8dot3Name (Name, fmtName, FALSE) )
return CE_INVALID_FILENAME; // Invalid/missing name
//----------------------------------------------------------------
// Make sure that the name provided is unique...
//----------------------------------------------------------------
FS_SeekStart(&SDFS_CWD); // Rewind Current Working Directory
RC = SDFS_DirFindNext(&SDFS_CWD, newDir, ATTR_NONE, ATTR_NONE, fmtName);
//----------------------------------------------------------------
if (CE_GOOD == RC)
{
if ( FS_IsDirectory(newDir) )
// Directory with the same name is found...
return CE_GOOD;
else
// There exists file with the same name...
{
SDFS_InitFSFILE(newDir, NULL, ATTR_NONE); // Reset output FSFILE structure
return CE_FILENAME_EXISTS;
}
}
if (CE_EOF != RC)
return RC; // Some other error happend on the way...
//----------------------------------------------------------------
// The name provided is unique; Try to create Directory Entry
//----------------------------------------------------------------
if ( (RC = SDFS_DirFindEmpty(&SDFS_CWD, newDir)) != CE_GOOD)
return RC; // Could not create directory entry...
//----------------------------------------------------------------
// Success; Set the name and Attributes of the new entry
//----------------------------------------------------------------
memcpy(newDir->dirFileEntry.DIR_Name, fmtName, NAME_SIZE_8r3);
newDir->dirFileEntry.DIR_Attr = ATTR_DIRECTORY | ATTR_ARCHIVE;
//----------------------------------------------------------------
// Allocate a cluster for the new Directory and create mandatory
// "." and ".." entries
//----------------------------------------------------------------
if ( (RC = SDFS_ClusterAllocateNew(newDir)) != CE_GOOD)
// Failure allocating cluster...
{
SDFS_InitFSFILE(newDir, NULL, ATTR_NONE); // Reset output FSFILE structure
return RC;
}
//----------------------------------------------------------------
DIRENTRY spcDir;
DWORD dirCluster;
// Set template Directory record for "." and ".." entries
SDFS_DirResetEntry( &spcDir, NULL, ATTR_DIRECTORY);
//----------------------------------------------------------------
// Create and store "." entry
//----------------------------------------------------------------
spcDir.DIR_Name[0] = '.';
dirCluster = SDFS_DirGetFirstCluster(&newDir->dirFileEntry);
SDFS_DirSetFirstCluster (&spcDir, dirCluster);
FS_Write(newDir, &spcDir, sizeof(DIRENTRY));
//----------------------------------------------------------------
// Create and store ".." entry
//----------------------------------------------------------------
spcDir.DIR_Name[1] = '.';
dirCluster = SDFS_DirGetFirstCluster(&SDFS_CWD.dirFileEntry);
if (dirCluster == SDFS_VolumeInfo.rootClsN)
// Parent is the Root directory of the volume
dirCluster = 0; // FAT32 rule for pointers to Root
SDFS_DirSetFirstCluster (&spcDir, dirCluster);
FS_Write(newDir, &spcDir, sizeof(DIRENTRY));
//----------------------------------------------------------------
return FS_Flush(newDir);
}
