void memory_end(){
if( !g_md ) return;
DBG("g_md->item_count = %d", g_md->item_count );
if( g_md->item_count>0 ){
memory_print();
}
}
int main ()
{
printf(WELCOME_TO_DRAUGHTS);
RulesInit();
//initialize game state.
//(empty layout)
game_state_t game;
char board [BOARD_SIZE][BOARD_SIZE];
//ListTest ();
//GameTest ();
//original_main();
//Test_Minimax();
//Test_GameWithMinimax();
//clear board, put default layout
GameInit(&game, (char **) board);
GameDefaultLayout(&game);
Menu_Settings(&game, (char **) board);
memory_print();
return 0;
}
void memory_end(){
if( !g_md ) return;
DBG (("g_md->item_count = %d", g_md->item_count ));
if( g_md->item_count>0 ){
memory_print();
}
pthread_mutex_destroy( &g_md->mutex_mem );
}
void do_console()
{
char buf[1024];
while(1)
{
scanf( "%s", buf );
if( strcmp( buf, "quit" ) == 0 ){
break;
}else if( strcmp( buf, "stop" ) == 0 ){
server_stop( websrv );
}else if( strcmp( buf, "start" ) == 0 ){
server_start( websrv );
}else if( strcmp( buf, "clear" ) == 0 ){
server_clear( websrv );
}else if( strcmp( buf, "reload" ) == 0 ){
server_reload( websrv );
}else if( strcmp( buf, "print" ) == 0 ){
server_print( websrv );
memory_print();
}else{
SLEEP(3); //Temperory fixed for linux nohup!
}
}
}
/**
* Main entry point
*/
int main( int argc, char **argv )
{
FILE *output;
int res = 0;
if ( check_args(argc,argv) )
{
if ( !doing_help )
{
char *data,*text;
int i,len;
if ( file_list_load(text_file,0,&text,&len) )
{
master *hf = master_create( text, len );
for ( i=0;i<file_list_size(markup_files);i++ )
{
res = file_list_load(markup_files,i,&data,&len);
if ( res )
{
res = master_load_markup( hf, data, len, format_name );
free( data );
data = NULL;
}
}
if ( res )
{
for ( i=0;i<file_list_size(css_files);i++ )
{
res = file_list_load(css_files,i,&data,&len);
if ( res )
{
res = master_load_css( hf, data, len );
free( data );
data = NULL;
}
}
output = fopen( html_file_name, "w" );
if ( output != NULL )
{
char *html = master_convert( hf );
fwrite( html, 1, master_get_html_len(hf), output );
fclose( output );
}
}
master_dispose( hf );
free( text );
text = NULL;
}
if ( css_files != NULL )
file_list_delete( css_files );
if ( markup_files != NULL )
file_list_delete( markup_files );
if ( text_file != NULL )
file_list_delete( text_file );
}
}
else
usage();
#ifdef DEBUG_MEMORY
memory_print();
#endif
return res;
}
//-----------------------------------------------------------------------------
// fatfs_init: Load FAT Parameters
//-----------------------------------------------------------------------------
int fatfs_init(struct fatfs *fs) {
uint8 num_of_fats;
uint16 reserved_sectors;
uint32 FATSz;
uint32 root_dir_sectors;
uint32 total_sectors;
uint32 data_sectors;
uint32 count_of_clusters;
uint32 partition_size = 0;
uint8 valid_partition = 0;
fs->currentsector.address = FAT32_INVALID_CLUSTER;
fs->currentsector.dirty = 0;
fs->next_free_cluster = 0; // Invalid
fatfs_fat_init(fs);
// Make sure we have a read function (write function is optional)
if (!fs->disk_io.read_media) {
fatfs_debug(FAT_INIT_MEDIA_ACCESS_ERROR,
"FAT init media access error. No 'read' function available.\n");
return FAT_INIT_MEDIA_ACCESS_ERROR;
}
// MBR: Sector 0 on the disk
// NOTE: Some removeable media does not have this.
// Load MBR (LBA 0) into the 512 byte buffer
if (!fs->disk_io.read_media(0, fs->currentsector.sector, 1)) {
fatfs_debug(FAT_INIT_MEDIA_ACCESS_ERROR,
"FAT could not load MBR (LBA 0).\n");
return FAT_INIT_MEDIA_ACCESS_ERROR;
}
// XXX: DEBUG
memory_print(fs->currentsector.sector, 512);
// Make Sure 0x55 and 0xAA are at end of sector
// (this should be the case regardless of the MBR or boot sector)
if (fs->currentsector.sector[SIGNATURE_POSITION] != 0x55
|| fs->currentsector.sector[SIGNATURE_POSITION + 1] != 0xAA) {
fatfs_debug(FAT_INIT_INVALID_SIGNATURE, "FAT invalid FAT signature.\n");
return FAT_INIT_INVALID_SIGNATURE;
}
// Now check again using the access function to prove endian conversion function
if (GET_16BIT_WORD(fs->currentsector.sector, SIGNATURE_POSITION)
!= SIGNATURE_VALUE) {
fatfs_debug(FAT_INIT_ENDIAN_ERROR, "FAT init endian error.\n");
return FAT_INIT_ENDIAN_ERROR;
}
// Verify packed structures
if (sizeof(struct fat_dir_entry) != FAT_DIR_ENTRY_SIZE) {
fatfs_debug(FAT_INIT_STRUCT_PACKING, "FAT wrong directory entry size.\n");
return FAT_INIT_STRUCT_PACKING;
}
// Check the partition type code
switch (fs->currentsector.sector[PARTITION1_TYPECODE_LOCATION]) {
case 0x0B:
case 0x06:
case 0x0C:
case 0x0E:
case 0x0F:
case 0x05:
valid_partition = 1;
break;
case 0x00:
valid_partition = 0;
break;
default:
if (fs->currentsector.sector[PARTITION1_TYPECODE_LOCATION] <= 0x06)
valid_partition = 1;
break;
}
if (valid_partition) {
// Read LBA Begin for the file system
fs->lba_begin = GET_32BIT_WORD(fs->currentsector.sector,
PARTITION1_LBA_BEGIN_LOCATION);
partition_size = GET_32BIT_WORD(fs->currentsector.sector,
PARTITION1_SIZE_LOCATION);
}
// Else possibly MBR less disk
else fs->lba_begin = 0;
// Load Volume 1 table into sector buffer
// (We may already have this in the buffer if MBR less drive!)
if (!fs->disk_io.read_media(fs->lba_begin, fs->currentsector.sector, 1)) {
fatfs_debug(FAT_INIT_MEDIA_ACCESS_ERROR, "FAT could not read media.\n");
return FAT_INIT_MEDIA_ACCESS_ERROR;
}
// XXX: DEBUG
memory_print(fs->currentsector.sector, 512);
// Make sure there are 512 bytes per cluster
if (GET_16BIT_WORD(fs->currentsector.sector, 0x0B) != FAT_SECTOR_SIZE) {
char buffer[1024];
sprintf(buffer, "FAT wrong sector size %d, should be %d\n",
GET_16BIT_WORD(fs->currentsector.sector, 0x0B), FAT_SECTOR_SIZE);
fatfs_show_details(fs);
fatfs_debug(FAT_INIT_INVALID_SECTOR_SIZE, buffer);
return FAT_INIT_INVALID_SECTOR_SIZE;
}
// Load Parameters of FAT partition
fs->sectors_per_cluster = fs->currentsector.sector[BPB_SECPERCLUS];
reserved_sectors = GET_16BIT_WORD(fs->currentsector.sector, BPB_RSVDSECCNT);
num_of_fats = fs->currentsector.sector[BPB_NUMFATS];
fs->root_entry_count = GET_16BIT_WORD(fs->currentsector.sector,
BPB_ROOTENTCNT);
if (GET_16BIT_WORD(fs->currentsector.sector, BPB_FATSZ16) != 0) {
fs->fat_sectors = GET_16BIT_WORD(fs->currentsector.sector, BPB_FATSZ16);
} else {
fs->fat_sectors = GET_32BIT_WORD(fs->currentsector.sector,
BPB_FAT32_FATSZ32);
}
// For FAT32 (which this may be)
fs->rootdir_first_cluster = GET_32BIT_WORD(fs->currentsector.sector,
BPB_FAT32_ROOTCLUS);
fs->fs_info_sector = GET_16BIT_WORD(fs->currentsector.sector,
BPB_FAT32_FSINFO);
// For FAT16 (which this may be), rootdir_first_cluster is actuall rootdir_first_sector
fs->rootdir_first_sector = reserved_sectors + (num_of_fats * fs->fat_sectors);
fs->rootdir_sectors = ((fs->root_entry_count * 32) + (FAT_SECTOR_SIZE - 1))
/ FAT_SECTOR_SIZE;
// First FAT LBA address
fs->fat_begin_lba = fs->lba_begin + reserved_sectors;
// The address of the first data cluster on this volume
fs->cluster_begin_lba = fs->fat_begin_lba + (num_of_fats * fs->fat_sectors);
// This signature should be AA55
if (GET_16BIT_WORD(fs->currentsector.sector, 0x1FE) != 0xAA55) {
fatfs_debug(FAT_INIT_INVALID_SIGNATURE, "FAT invalid signature");
return FAT_INIT_INVALID_SIGNATURE;
}
// Calculate the root dir sectors
root_dir_sectors = ((GET_16BIT_WORD(fs->currentsector.sector, BPB_ROOTENTCNT)
* 32) + (GET_16BIT_WORD(fs->currentsector.sector, BPB_BYTSPERSEC) - 1))
/ GET_16BIT_WORD(fs->currentsector.sector, BPB_BYTSPERSEC);
if (GET_16BIT_WORD(fs->currentsector.sector, BPB_FATSZ16) != 0) FATSz
= GET_16BIT_WORD(fs->currentsector.sector, BPB_FATSZ16);
else FATSz = GET_32BIT_WORD(fs->currentsector.sector, BPB_FAT32_FATSZ32);
if (GET_16BIT_WORD(fs->currentsector.sector, BPB_TOTSEC16) != 0) {
total_sectors = GET_16BIT_WORD(fs->currentsector.sector, BPB_TOTSEC16);
} else {
total_sectors = GET_32BIT_WORD(fs->currentsector.sector, BPB_TOTSEC32);
}
data_sectors = total_sectors - (GET_16BIT_WORD(fs->currentsector.sector,
BPB_RSVDSECCNT) + (fs->currentsector.sector[BPB_NUMFATS] * FATSz)
+ root_dir_sectors);
// Find out which version of FAT this is...
if (fs->sectors_per_cluster != 0) {
count_of_clusters = data_sectors / fs->sectors_per_cluster;
if (count_of_clusters < 4085) {
// Volume is FAT12
return FAT_INIT_WRONG_FILESYS_TYPE;
} else if (count_of_clusters < 65525) {
// Clear this FAT32 specific param
fs->rootdir_first_cluster = 0;
// Volume is FAT16
fs->fat_type = FAT_TYPE_16;
fatfs_debug(FAT_INIT_OK, "FAT init success (FAT16).\n");
//fatfs_show_details(fs);
return FAT_INIT_OK;
} else {
// Volume is FAT32
fs->fat_type = FAT_TYPE_32;
fatfs_debug(FAT_INIT_OK, "FAT init success (FAT32).\n");
//fatfs_show_details(fs);
return FAT_INIT_OK;
}
} else {
fatfs_debug(FAT_INIT_WRONG_FILESYS_TYPE,
"FAT init failed, wrong FILESYS_TYPE.\n");
return FAT_INIT_WRONG_FILESYS_TYPE;
}
}
/*
* Class: calliope_AeseFormatter
* Method: format
* Signature: (Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;Lcalliope/json/JSONResponse;)I
*/
JNIEXPORT jint JNICALL Java_calliope_AeseFormatter_format
(JNIEnv *env, jobject obj, jstring text, jobjectArray markup,
jobjectArray css, jobject jsonHtml)
{
int res=0;
jsize i,len;
UChar *html;
jboolean isTextCopy=0;
jchar *t_data = (jchar*)load_string(env, text, &isTextCopy);
int t_len = u_strlen( t_data );
if ( t_data != NULL && markup != NULL && css != NULL )
{
jboolean isMarkupCopy;
jni_report( "about to call master_create\n" );
master *hf = master_create( t_data, t_len );
if ( hf != NULL )
{
jni_report( "about to get markup array length\n" );
len = (*env)->GetArrayLength(env, markup);
for ( i=0;i<len;i++ )
{
res = 1;
jni_report( "about to get markup str\n" );
jstring markup_str = (jstring)(*env)->GetObjectArrayElement(
env, markup, i );
jni_report( "about to load c string\n" );
const char *markup_data = load_string_c(env, markup_str,
&isMarkupCopy);
if ( markup_data != NULL )
{
res = master_load_markup( hf, markup_data,
(int)strlen(markup_data) );
unload_string_c( env, markup_str, markup_data,isMarkupCopy);
}
if ( !res )
break;
}
if ( res )
{
len = (*env)->GetArrayLength(env, css);
for ( i=0;i<len;i++ )
{
jboolean isCssCopy;
jstring css_str = (jstring)(*env)->GetObjectArrayElement(
env, css, i);
const char *css_data = load_string_c(env,css_str,&isCssCopy);
if ( css_data != NULL )
{
res = master_load_css( hf, css_data, (int)strlen(css_data) );
unload_string_c( env, css_str, css_data, isCssCopy );
if ( !res )
break;
}
}
if ( res )
{
//jni_report( "about to call master_convert\n" );
html = master_convert( hf );
//jni_report( "finished calling master_convert\n" );
if ( html != NULL )
{
res = set_string_field( env, jsonHtml, "body", html );
if ( res == 0 )
jni_report("set string failed tried to write %d chars\n",u_strlen(html));
}
}
}
master_dispose( hf );
}
unload_string(env,text,t_data,isTextCopy);
}
#ifdef DEBUG_MEMORY
memory_print();
#endif
return res;
}
