non/Timeline/Loggable.C

511 lines
9.9 KiB
C++
Raw Normal View History

2008-02-22 12:44:35 +01:00
/*******************************************************************************/
/* Copyright (C) 2008 Jonathan Moore Liles */
/* */
/* This program is free software; you can redistribute it and/or modify it */
/* under the terms of the GNU General Public License as published by the */
/* Free Software Foundation; either version 2 of the License, or (at your */
/* option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, but WITHOUT */
/* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or */
/* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for */
/* more details. */
/* */
/* You should have received a copy of the GNU General Public License along */
/* with This program; see the file COPYING. If not,write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/*******************************************************************************/
#define _LOGGABLE_C
#include "Loggable.H"
#undef _LOGABLE_C
2008-02-25 05:14:19 +01:00
#include <stdlib.h>
2008-02-22 12:44:35 +01:00
#include <stdio.h>
#include <stdarg.h>
2008-03-05 08:05:08 +01:00
#include <string.h>
2008-02-22 12:44:35 +01:00
2008-02-22 21:20:44 +01:00
FILE *Loggable::_fp;
2008-02-22 12:44:35 +01:00
int Loggable::_log_id = 0;
int Loggable::_level = 0;
2008-02-25 23:47:49 +01:00
int Loggable::_undo_index = 1;
2008-02-22 12:44:35 +01:00
2008-02-24 08:42:41 +01:00
vector <Loggable *> Loggable::_loggables;
2008-02-27 21:04:17 +01:00
map <string, create_func*> Loggable::_class_map;
queue <char *> Loggable::_transaction;
2008-02-24 08:42:41 +01:00
2008-02-22 21:20:44 +01:00
bool
Loggable::open ( const char *filename )
{
if ( ! ( Loggable::_fp = fopen( filename, "a+" ) ) )
{
printf( "Could not open log file for writing!" );
return false;
}
/* TODO: replay log here */
/* FIXME: handle transactions!!! */
{
char buf[BUFSIZ];
while ( fscanf( _fp, "%[^\n]\n", buf ) == 1 )
{
do_this( buf, false );
}
}
2008-02-22 21:20:44 +01:00
return true;
}
/** sigh. parse a string of ":name value :name value" pairs into an
* array of strings, one per pair */
// FIXME: doesn't handle the case of :name ":foo bar", nested quotes
// or other things it should. Also, quotes should be removed here, not
// in client code.
2008-02-25 05:14:19 +01:00
static
char **
parse_alist( const char *s )
{
2008-02-22 12:44:35 +01:00
2008-02-25 05:14:19 +01:00
// FIXME: bogus over allocation...
2008-02-22 12:44:35 +01:00
2008-02-25 05:14:19 +01:00
int tl = strlen( s );
char **r = (char**)malloc( sizeof( char* ) * tl );
const char *e = s + tl;
const char *c = NULL;
int i = 0;
for ( ; ; s++ )
{
/* if ( *s == '\n' ) */
/* break; */
// if ( *s == ':' || s == e )
if ( *s == ':' || *s == '\0' )
{
if ( c )
{
int l = s - c;
char *pair = (char*)malloc( l + 1 );
strncpy( pair, c, l );
pair[ l ] = '\0';
r[ i++ ] = pair;
}
c = s;
if ( *s == '\0' )
break;
}
}
r[ i ] = NULL;
return r;
}
2008-02-27 21:04:17 +01:00
static
void free_sa ( char **sa )
{
char **a = sa;
for ( ; *a; a++ )
free( *a );
free( sa );
}
/** 'do' a message like "Region 0xF1 set :r 123" */
bool
Loggable::do_this ( const char *s, bool reverse )
{
int id;
if ( ! ( sscanf( s, "%*s %X ", &id ) > 0 ) )
return false;
Loggable *l = find( id );
// assert( l );
char classname[40];
char command[40];
char *arguments;
const char *create, *destroy;
if ( reverse )
{
sscanf( s, "%s %*X %s %*[^\n<] %a[^\n]", classname, command, &arguments );
create = "destroy";
destroy = "create";
}
else
{
sscanf( s, "%s %*X %s %a[^\n<]", classname, command, &arguments );
create = "create";
destroy = "destroy";
}
if ( ! strcmp( command, destroy ) )
{
int id = l->id();
delete l;
_loggables[ id ] = NULL;
}
else if ( ! strcmp( command, "set" ) )
{
printf( "got set command.\n" );
char **sa = parse_alist( arguments );
l->log_start();
l->set( sa );
l->log_end();
}
else if ( ! strcmp( command, create ) )
{
char **sa = parse_alist( arguments );
if ( ! _class_map[ string( classname ) ] )
printf( "error class %s is unregistered!\n", classname );
else
{
/* create */
Loggable *l = _class_map[ string( classname ) ]( sa );
l->update_id( id );
l->log_create();
}
}
}
2008-02-27 21:04:17 +01:00
2008-02-25 05:14:19 +01:00
void
Loggable::undo ( void )
{
char *buf = new char[ BUFSIZ ];
// fflush( _fp );
2008-02-25 23:47:49 +01:00
fseek( _fp, 0, SEEK_END );
size_t len = ftell( _fp );
2008-02-25 05:14:19 +01:00
2008-02-25 23:47:49 +01:00
fseek( _fp, 0 - (BUFSIZ > len ? len : BUFSIZ), SEEK_END );
2008-02-22 12:44:35 +01:00
2008-02-25 23:47:49 +01:00
len = fread( buf, 1, BUFSIZ, _fp );
2008-02-25 05:14:19 +01:00
char *s = buf + len - 1;
// FIXME: handle blocks
2008-02-25 23:47:49 +01:00
int i = 1;
2008-02-27 21:04:17 +01:00
/* move back _undo_index items from the end */
2008-02-25 23:47:49 +01:00
for ( int j = _undo_index; j-- ; )
for ( --s; *s && s >= buf; --s, ++i )
2008-02-25 05:14:19 +01:00
{
2008-02-25 23:47:49 +01:00
if ( *s == '\n' )
{
2008-02-27 21:04:17 +01:00
if ( *(s + 1) == '\t' )
continue;
2008-03-05 08:05:08 +01:00
if ( *(s + 1) == '}' )
{
*(s + 1) = NULL;
continue;
}
2008-02-25 23:47:49 +01:00
break;
}
2008-02-25 05:14:19 +01:00
}
2008-02-25 23:47:49 +01:00
s++;
2008-02-25 05:14:19 +01:00
buf[ len ] = NULL;
2008-02-25 23:47:49 +01:00
if ( ! strlen( s ) )
{
printf( "corrupt undo file or no undo entries.\n" );
return;
}
2008-03-05 08:05:08 +01:00
char *b = s;
2008-02-25 05:14:19 +01:00
2008-03-05 08:05:08 +01:00
s += strlen( s ) - 1;
2008-02-25 05:14:19 +01:00
2008-03-05 08:05:08 +01:00
if ( strtok( b, "\n" ) == NULL )
{
printf( "error, empty undo transaction!\n" );
abort();
}
2008-02-27 21:04:17 +01:00
2008-03-05 08:05:08 +01:00
int n = 1;
while ( strtok( NULL, "\n" ) )
++n;
2008-02-27 21:04:17 +01:00
int ui = _undo_index;
2008-02-25 05:14:19 +01:00
block_start();
if ( strcmp( b, "{" ) )
{
/* It's a single undo, get rid of trailing messages in this block */
n = 1;
s = b + 2;
s += strlen( s ) - 1;
}
2008-03-05 08:05:08 +01:00
while ( n-- )
{
while ( s >= b && *(--s) );
s++;
if ( ! strcmp( s, "{" ) )
break;
2008-03-05 08:05:08 +01:00
if ( *s == '\t' )
s++;
printf( "undoing \"%s\"\n", s );
do_this( s, true );
2008-03-05 08:05:08 +01:00
s -= 2;
}
2008-02-27 21:04:17 +01:00
block_end();
2008-02-27 21:04:17 +01:00
// FIXME: bogus... needs to account for multiple events.
_undo_index = ui + 1;
2008-02-25 05:14:19 +01:00
2008-02-25 23:47:49 +01:00
++_undo_index;
2008-02-25 05:14:19 +01:00
2008-03-05 08:05:08 +01:00
2008-02-25 23:47:49 +01:00
delete buf;
2008-02-25 05:14:19 +01:00
}
/** write a snapshot of the state of all loggable objects, sufficient
* for later reconstruction, to /file/ */
bool
Loggable::snapshot( const char *file )
{
FILE *ofp = _fp;
if ( ! ( _fp = fopen( file, "a" ) ) )
{
_fp = ofp;
return false;
}
for ( int i = 0; i < _log_id; ++i )
{
_loggables[ i ]->log_create();
}
fclose( _fp );
_fp = ofp;
return true;
}
2008-02-25 05:14:19 +01:00
void
Loggable::log ( const char *fmt, ... )
{
/* FIXME: bogus limit */
static char buf[1024];
static int i = 0;
2008-02-25 05:14:19 +01:00
va_list args;
if ( fmt )
{
va_start( args, fmt );
i += vsprintf( buf + i, fmt, args );
2008-02-25 05:14:19 +01:00
va_end( args );
}
2008-02-25 23:47:49 +01:00
if ( rindex( buf, '\n' ) )
{
_transaction.push( strdup( buf ) );
i = 0;
}
2008-02-25 05:14:19 +01:00
}
2008-02-24 08:42:41 +01:00
void
Loggable::flush ( void )
{
if ( ! _fp )
{
printf( "error: no log file open!\n" );
while ( ! _transaction.empty() )
{
free( _transaction.front() );
_transaction.pop();
}
return;
}
int n = _transaction.size();
if ( n > 1 )
fprintf( _fp, "{\n" );
while ( ! _transaction.empty() )
{
char *s = _transaction.front();
_transaction.pop();
if ( n > 1 )
fprintf( _fp, "\t" );
fprintf( _fp, "%s", s );
free( s );
}
if ( n > 1 )
fprintf( _fp, "}\n" );
fflush( _fp );
}
2008-02-24 08:42:41 +01:00
void
2008-02-25 05:14:19 +01:00
Loggable::log_print( char **o, char **n )
2008-02-24 08:42:41 +01:00
{
if ( n )
for ( ; *n; n++ )
2008-02-25 05:14:19 +01:00
log( "%s%s", *n, *(n + 1) ? " " : "" );
2008-02-24 08:42:41 +01:00
if ( o && *o )
{
2008-02-25 05:14:19 +01:00
if ( n ) log( " << " );
2008-02-24 08:42:41 +01:00
for ( ; *o; o++ )
2008-02-25 05:14:19 +01:00
log( "%s%s", *o, *(o + 1) ? " " : "" );
2008-02-24 08:42:41 +01:00
}
2008-02-25 05:14:19 +01:00
log( "\n" );
2008-02-24 08:42:41 +01:00
}
/** compare elements of dumps s1 and s2, removing those elements
of dst which are not changed from src */
static
bool
2008-02-24 08:42:41 +01:00
log_diff ( char **sa1, char **sa2 )
{
if ( ! sa1 )
return true;
2008-02-24 08:42:41 +01:00
int w = 0;
for ( int i = 0; sa1[ i ]; ++i )
{
if ( ! strcmp( sa1[ i ], sa2[ i ] ) )
{
free( sa2[ i ] );
free( sa1[ i ] );
}
else
{
sa2[ w ] = sa2[ i ];
sa1[ w ] = sa1[ i ];
w++;
}
}
sa1[ w ] = NULL;
sa2[ w ] = NULL;
return w == 0 ? false : true;
2008-02-24 08:42:41 +01:00
}
void
Loggable::log_start ( void )
{
2008-02-24 14:28:55 +01:00
if ( ! _old_state )
_old_state = get();
2008-02-24 14:28:55 +01:00
++_nest;
2008-02-27 21:04:17 +01:00
_undo_index = 1;
2008-02-24 08:42:41 +01:00
}
void
Loggable::log_end ( void )
{
2008-02-24 14:28:55 +01:00
if ( --_nest > 0 )
return;
char **_new_state = get();
2008-02-24 08:42:41 +01:00
if ( log_diff( _old_state, _new_state ) )
{
// indent();
2008-02-25 05:14:19 +01:00
log( "%s 0x%X set ", class_name(), _id );
2008-02-24 08:42:41 +01:00
log_print( _old_state, _new_state );
}
2008-02-24 08:42:41 +01:00
if ( _new_state )
free_sa( _new_state );
2008-02-24 14:28:55 +01:00
if ( _old_state )
free_sa( _old_state );
2008-02-24 08:42:41 +01:00
_old_state = NULL;
2008-02-24 14:28:55 +01:00
if ( Loggable::_level == 0 )
Loggable::flush();
2008-02-24 08:42:41 +01:00
}
void
Loggable::log_create ( void )
{
// indent();
2008-02-27 21:04:17 +01:00
log( "%s 0x%X create ", class_name(), _id );
2008-02-24 08:42:41 +01:00
char **sa = get();
2008-02-24 08:42:41 +01:00
2008-02-24 11:58:16 +01:00
if ( sa )
{
log_print( NULL, sa );
free_sa( sa );
}
else
2008-02-25 05:14:19 +01:00
log( "\n" );
if ( Loggable::_level == 0 )
Loggable::flush();
2008-02-24 08:42:41 +01:00
}
void
Loggable::log_destroy ( void )
{
// indent();
2008-02-27 21:04:17 +01:00
log( "%s 0x%X destroy (nothing) << ", class_name(), _id );
2008-02-24 08:42:41 +01:00
char **sa = get();
2008-02-24 08:42:41 +01:00
2008-02-27 21:04:17 +01:00
// log_print( sa, NULL );
log_print( NULL, sa );
2008-02-24 08:42:41 +01:00
free_sa( sa );
if ( Loggable::_level == 0 )
Loggable::flush();
2008-02-24 08:42:41 +01:00
}