exos.c

M-System DOC(Disk on a Chip) Flash芯片映像读写工具, 可以进行二片Flash芯片的内容互相拷贝, 提高烧录程序的效率.

/*---------------------------------------------------------------------------------*/
/*------------                                                              -------*/
/*------------ FOR WIN32 OPERATING SYSTEM CONSOLE APPLOCATION				-------*/
/*------------                                                              -------*/
/*---------------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------------*/
#include "exdevice.h"
#include "exos.h"

#include <string.h>
#include <stdlib.h>
#include <ctype.h>
/*---------------------------------------------------------------------------------*/
/* global variables for main function */

#ifdef EX_USE_COMMAND_LINE_DEVICE
EXWORD   exArgc;            /* Count of command-line arguments */
EXCHAR** exArgv;            /* Array of pointers to command-line arguments */
#endif /* EX_USE_COMMAND_LINE_DEVICE */

/*---------------------------------------------------------------------------------*/
extern ExStatus ExMain();	/* must be declared in user app. */


ExStatus EXAPI main( int argc, char** argv )
{

#ifdef EX_USE_COMMAND_LINE_DEVICE
   	exArgc = (EXWORD)(argc-1);
    exArgv = argv+1;
#endif /* EX_USE_COMMAND_LINE_DEVICE */

	return ExMain();
}


/*---------------------------------------------------------------------------------*/
#ifdef EX_USE_COMMAND_LINE_DEVICE

ExStatus EXAPI ExOsOpenCmdLineDevice( void** data )
{
	/* Do nothing - argv and argc saved in main() */
	return EX_OK;
}

ExStatus EXAPI ExOsCloseCmdLineDevice( void* data )
{
	/* Do nothing */
	return EX_OK;
}

ExStatus EXAPI ExOsReadCmdLineDevice( void*data, EXWORD argc, void** retCommand )
{
	if( argc >= ( EXWORD )exArgc )
		return EX_EOF_ERROR;

    *retCommand = exArgv[argc];
	return EX_OK;
}

#endif /* EX_USE_COMMAND_LINE_DEVICE */

/*---------------------------------------------------------------------------------*/
#ifdef EX_USE_MSG_DEVICE
#include <stdio.h>
#include <stdarg.h>

ExStatus EXAPI ExOsOpenMsgDevice( void** data )
{
	/* do nothing */
	return EX_OK;
}

ExStatus EXAPI ExOsCloseMsgDevice( void* data )
{
	/* do nothing */
	return EX_OK;
}

ExStatus EXAPI ExOsWriteMsgDevice( void* data, EXCHAR* pStr )
{
	return ( fputs( pStr, stdout ) == EOF ) ? EX_WRITE_ERROR : EX_OK;
}

#endif /* EX_USE_MSG_DEVICE */

/*---------------------------------------------------------------------------------*/
#ifdef EX_USE_ERROR_MSG_DEVICE
#include <stdarg.h>
#include <stdio.h>

ExStatus EXAPI ExOsOpenErrorMsgDevice( void** data )
{
	/* do nothing */
	return EX_OK;
}

ExStatus EXAPI ExOsCloseErrorMsgDevice( void* data )
{
	/* do nothing */
	return EX_OK;
}

ExStatus EXAPI ExOsWriteErrorMsgDevice( void* data, EXCHAR* pStr )
{
	return ( fputs( pStr, stdout ) == EOF ) ? EX_WRITE_ERROR : EX_OK;
}

#endif /* EX_USE_ERROR_MSG_DEVICE */

/*---------------------------------------------------------------------------------*/
#ifdef EX_USE_PROGRESS_BAR_DEVICE

typedef struct
{
	EXDWORD dwTotalUnitsToFormat;
	EXCHAR name[40];
}ExPrgBar;


#ifndef FL_MALLOC 
	EXCHAR PrgBar_area [sizeof(ExPrgBar)];
#endif



ExStatus EXAPI ExOsOpenPrgBarDevice( void** data, EXCHAR* pPrgBarName, EXDWORD dwPrgBarSize )
{
	ExPrgBar*   p;

#ifdef FL_MALLOC
	*data = ExMemAlloc( sizeof( ExPrgBar ) );
#else
	*data = PrgBar_area;
#endif

	p = (ExPrgBar*)*data;
	if( p == EXNULL )
		return EX_MALLOC_ERROR;
	strcpy( p->name, pPrgBarName );
	p->dwTotalUnitsToFormat = dwPrgBarSize;

	return EX_OK;
}

ExStatus EXAPI ExOsClosePrgBarDevice( void* data )
{
	fputs( "\n", stdout );
#ifdef FL_MALLOC
	ExMemFree( data );
#endif
	return EX_OK;
}

ExStatus EXAPI ExOsWritePrgBarDevice( void* data, EXDWORD dwDoneSoFar )
{
	ExPrgBar*     p = (ExPrgBar*)data;

	if( p->dwTotalUnitsToFormat == 0 )
		printf( "%-30s %lu\r", p->name, dwDoneSoFar );
	else
		printf( "%-30s %lu of %lu\r", p->name, dwDoneSoFar, p->dwTotalUnitsToFormat );

  return EX_OK;
}

#endif /* EX_USE_PROGRESS_BAR_DEVICE */

/*---------------------------------------------------------------------------------*/
#ifdef EX_USE_SERIAL_DEVICE
#include <stdarg.h>
#include <stdio.h>

ExStatus EXAPI ExOsOpenFile( void** data, EXCHAR* name, EXWORD wMode )
{
  switch( wMode )
  {
  case EX_READ_ONLY_FILE:
		*data = fopen( name, "rb" );
	  if( *data == EXNULL )
		  return EX_OPEN_ERROR;
    break;

  case EX_WRITE_ONLY_FILE:
		*data = fopen( name, "wb" );
	  if( *data == EXNULL )
		  return EX_OPEN_ERROR;
    break;

  default:
    return EX_OPEN_ERROR;

  }

  return EX_OK;
}

ExStatus EXAPI ExOsCloseFile( void* data, EXWORD wMode )
{
	if( fclose( ( FILE* )data ) != 0 )
		return EX_CLOSE_ERROR;

	return EX_OK;
}

ExStatus EXAPI ExOsWriteToFile( void* data, EXDWORD size, void EXFAR* buff )
{
  if( size != 0 )
  {
	  if( fwrite( buff, size, 1, ( FILE* )data ) != 1 )
		  return EX_WRITE_ERROR;
  }

	return EX_OK;
}

ExStatus EXAPI ExOsReadFromFile( void* data, EXDWORD size, void EXFAR* buff, EXDWORD* byteRead )
{
	*byteRead = fread( buff, 1,size, ( FILE* )data );
	if( *byteRead != size )
		return EX_EOF_ERROR;

	return EX_OK;
}

ExStatus EXAPI ExOsGetLengthOfSerialFileDevice( void* data, EXDWORD* retLen )
{
	EXDWORD    oldPos,newPos;
	FILE*      file = (FILE*)data;

	*retLen = EXDWORD_MAX;

	if( ( oldPos = ftell( file ) ) == -1 )
		return EX_READ_ERROR;
	if( fseek( file, 0, SEEK_END ) )
		return EX_READ_ERROR;
	if( ( newPos = ftell( file ) ) == -1 )
		return EX_READ_ERROR;
	if( fseek( file, oldPos, SEEK_SET ) )
		return EX_READ_ERROR;

	*retLen = newPos;
	return EX_OK;
}

ExStatus EXAPI ExOsSeekSerialFileDevice( void* data,EXDWORD dwOffset,int Origin)
{
	FILE*      file = (FILE*)data;

	if( fseek( file, dwOffset,Origin) )
		return EX_READ_ERROR;

	return EX_OK;
}
#endif /* EX_USE_SERIAL_READ_DEVICE */

/*---------------------------------------------------------------------------------*/
#ifdef EX_USE_USER_INPUT

extern ExStatus EXAPI ExOsOpenUserInputDevice( void** data )
{
	return EX_OK;
}

extern ExStatus EXAPI ExOsCloseUserInputDevice( void* data )
{
	fputs( "\n", stdout );
	return EX_OK;
}

extern ExStatus EXAPI ExOsWaitForCharUserInputDevice(  ExWaitForCharChoices* waitForCharChoices )
{
	EXWORD    w;
	EXCHAR    cTmp;

	printf("%s  ", waitForCharChoices->pName );
	for( w = 0 ; w < waitForCharChoices->wNoOfChoices ; w++ )
	{
		if( waitForCharChoices->pChoices[w].pName != EXNULL )
		{
			fputs( waitForCharChoices->pChoices[w].pName, stdout );
			if( ( w + 1 ) < waitForCharChoices->wNoOfChoices )
				fputc('/', stdout);
		}
	}
	fputs( "  ", stdout );

	cTmp = ( EXCHAR )tolower( getchar() );
	for( w = 0 ; w < waitForCharChoices->wNoOfChoices ; w++ )
	{
		if( waitForCharChoices->pChoices[w].cKey == cTmp )
		{
			waitForCharChoices->wResult = w;
			return EX_OK;
		}
	}
	waitForCharChoices->wResult = waitForCharChoices->wNoOfChoices;
	return EX_OK;
}

#endif	/* EX_USE_USER_INPUT */


/*---------------------------------------------------------------------------------*/
void* EXAPI ExMemAlloc( EXDWORD size )
{
  return malloc( size );
}

/*---------------------------------------------------------------------------------*/
void EXAPI ExMemFree( void* memBlock )
{
  free( memBlock );
  memBlock = EXNULL;
}

/*---------------------------------------------------------------------------------*/
void* EXAPI ExMemSet( void* dest, EXWORD ch, EXDWORD size )
{
  return memset( dest, ch, size );
}

/*---------------------------------------------------------------------------------*/
EXWORD EXAPI ExMemCmp( void* buf1, void* buf2, EXDWORD count )
{
  return (EXWORD)memcmp( buf1, buf2, count );
}

/*---------------------------------------------------------------------------------*/
void* EXAPI ExMemCpy( void* dest, void* src, EXDWORD count )
{
  return memcpy( dest, src, count );
}

/*---------------------------------------------------------------------------------*/
#ifdef	EX_USE_RANDOM
#include <time.h>
#include <sys/timeb.h>

#define EX_TICKS_PER_SEC    CLK_TCK

EXSWORD EXAPI ExRand( void )
{
  return ( EXSWORD )rand();
}

void EXAPI ExSrand( EXWORD seed )
{
  srand( (unsigned int) seed );
}

EXDWORD EXAPI ExTime( EXSDWORD* timer )
{
  return time( timer );
}

EXCHAR* EXAPI ExStrTime( EXCHAR* timestr )
{
  return _strtime( timestr );
}

EXCHAR* EXAPI ExStrDate( EXCHAR* datestr )
{
  return _strdate( datestr );
}

#endif	/* EX_USE_RANDOM */


/*---------------------------------------------------------------------------------*/
#ifdef EX_USE_STDLIB_API
#include <stdlib.h>

EXSDWORD EXAPI ExStrtol( const EXCHAR* nptr, EXCHAR** endptr, EXWORD radix )
{
  return strtol( nptr, endptr, radix );
}

EXDWORD EXAPI ExStrtoul( const EXCHAR* nptr, EXCHAR** endptr, EXWORD radix )
{
  return strtoul( nptr, endptr, radix );
}

EXSWORD EXAPI ExAtoi( const EXCHAR* string )
{
  return ( EXSWORD )atoi( string );
}

EXCHAR* EXAPI ExItoa( EXSWORD value, EXCHAR* string, EXSWORD radix )
{
  return itoa( value, string, radix );
}

void EXAPI ExClearScreen( void )
{
  system( "cls" );
}

#endif	/* EX_USE_STDLIB_API */


/*---------------------------------------------------------------------------------*/

#include <string.h>

EXWORD EXAPI ExStrLen( const EXCHAR* string )
{
  return ( EXWORD )strlen( string );
}

EXCHAR* EXAPI ExStrCat( EXCHAR* strDestination, const EXCHAR* strSource )
{
  return strcat( strDestination, strSource );
}







/*---------------------------------------------------------------------------------*/
#ifdef	EX_USE_DIRECT_API
#include <dir.h>
#include <direct.h>

EXWORD EXAPI ExCreateDirectory( const EXCHAR* dirName )
{
  return mkdir( dirName );
}

EXWORD EXAPI ExGetDrive( void )
{
  return _getdrive();
}

EXWORD EXAPI ExChangeDrive( EXWORD drive )
{
  return _chdrive( drive );
}
#include <dos.h>

EXWORD EXAPI ExGetDiskFree( EXWORD drive, ExDiskInfoRecord* diskInfo )
{
  struct diskfree_t    disk;
  EXWORD                ret;

  ret = _dos_getdiskfree( drive - 'A' + 1, &disk );
  diskInfo->availClusters     = disk.avail_clusters;
  diskInfo->bytesPerSector    = disk.bytes_per_sector;
  diskInfo->sectorsPerCluster = disk.sectors_per_cluster;
  diskInfo->totalClusters     = disk.total_clusters;

  return ret;
}

#endif	EX_USE_DIRECT_API


/*---------------------------------------------------------------------------------*/
EXCHAR EXAPI ExToupper( EXCHAR ch )
{
  char ret = ch;

  if( ch >= 'a' && ch <= 'z' )
    ret += ('A'-'a');

  return ret;
}

/*---------------------------------------------------------------------------------*/