747 lines
15 KiB
C
747 lines
15 KiB
C
|
|
/*******************************************************************************/
|
|
/* 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
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
|
|
FILE *Loggable::_fp;
|
|
int Loggable::_log_id = 0;
|
|
int Loggable::_level = 0;
|
|
int Loggable::_undo_index = 1;
|
|
|
|
size_t Loggable::_loggables_size = 0;
|
|
Loggable ** Loggable::_loggables;
|
|
map <string, create_func*> Loggable::_class_map;
|
|
queue <char *> Loggable::_transaction;
|
|
|
|
bool
|
|
Loggable::open ( const char *filename )
|
|
{
|
|
FILE *fp;
|
|
|
|
if ( ! ( fp = fopen( filename, "a+" ) ) )
|
|
{
|
|
WARNING( "Could not open log file for writing!" );
|
|
return false;
|
|
}
|
|
|
|
|
|
/* replay log */
|
|
{
|
|
char buf[BUFSIZ];
|
|
|
|
while ( fscanf( fp, "%[^\n]\n", buf ) == 1 )
|
|
{
|
|
if ( ! ( ! strcmp( buf, "{" ) || ! strcmp( buf, "}" ) ) )
|
|
{
|
|
if ( *buf == '\t' )
|
|
do_this( buf + 1, false );
|
|
else
|
|
do_this( buf, false );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
Loggable::_fp = fp;
|
|
|
|
return true;
|
|
}
|
|
|
|
/** close journal and delete all loggable objects */
|
|
bool
|
|
Loggable::close ( void )
|
|
{
|
|
|
|
DMESSAGE( "closing journal and destroying all journaled objects" );
|
|
|
|
if ( ! _fp )
|
|
return true;
|
|
|
|
fclose( _fp );
|
|
|
|
_fp = NULL;
|
|
|
|
for ( int i = 0; i < _log_id - 1; ++i )
|
|
{
|
|
Loggable ** l = &_loggables[ i ];
|
|
|
|
if ( *l )
|
|
{
|
|
delete *l;
|
|
*l = NULL;
|
|
}
|
|
}
|
|
|
|
_log_id = 0;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/** must be called after construction in create() methods */
|
|
void
|
|
Loggable::update_id ( int id )
|
|
{
|
|
/* make sure we're the last one */
|
|
assert( _id == _log_id );
|
|
assert( _loggables[ _id - 1 ] == this );
|
|
|
|
_loggables[ _id - 1 ] = NULL;
|
|
|
|
_log_id = max( _log_id, id );
|
|
|
|
/* return this id number to the system */
|
|
// --_log_id;
|
|
|
|
_id = id;
|
|
|
|
/* make sure it'll fit */
|
|
ensure_size( _id );
|
|
|
|
ASSERT( ! _loggables[ _id - 1 ], "Attempt to create object with an ID (0x%X) that already exists. The existing object is of type \"%s\", the new one is \"%s\". Corrupt journal?", _id, _loggables[ _id - 1 ]->class_name(), class_name() );
|
|
|
|
_loggables[ _id - 1 ] = this;
|
|
}
|
|
|
|
/** return a pointer to a static copy of /s/ with all special characters escaped */
|
|
const char *
|
|
Loggable::escape ( const char *s )
|
|
{
|
|
static char r[512];
|
|
|
|
size_t i = 0;
|
|
for ( ; *s && i < sizeof( r ); ++i, ++s )
|
|
{
|
|
if ( '\n' == *s )
|
|
{
|
|
r[ i++ ] = '\\';
|
|
r[ i ] = 'n';
|
|
}
|
|
else if ( '"' == *s )
|
|
{
|
|
r[ i++ ] = '\\';
|
|
r[ i ] = '"';
|
|
}
|
|
else
|
|
r[ i ] = *s;
|
|
}
|
|
|
|
r[ i ] = '\0';
|
|
|
|
return r;
|
|
}
|
|
|
|
/** remove escapes from string /s/ in-place */
|
|
static void
|
|
unescape ( char *s )
|
|
{
|
|
char *r = s;
|
|
for ( ; *s; s++, r++ )
|
|
{
|
|
if ( '\\' == *s )
|
|
{
|
|
switch ( *(++s) )
|
|
{
|
|
case 'n':
|
|
*r = '\n';
|
|
break;
|
|
case '"':
|
|
*r = '"';
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
*r = *s;
|
|
}
|
|
|
|
*r = '\0';
|
|
}
|
|
|
|
/** 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.
|
|
static
|
|
char **
|
|
parse_alist( const char *s )
|
|
{
|
|
|
|
// FIXME: bogus over allocation...
|
|
|
|
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 );
|
|
|
|
/* remove trailing space */
|
|
if ( c[ l - 1 ] == ' ' )
|
|
--l;
|
|
|
|
strncpy( pair, c, l );
|
|
|
|
pair[ l ] = '\0';
|
|
|
|
r[ i++ ] = pair;
|
|
|
|
/* split */
|
|
|
|
strtok( pair, " " );
|
|
|
|
/* remove quotes */
|
|
char *v = pair + strlen( pair ) + 1;
|
|
|
|
unescape( v );
|
|
|
|
if ( *v == '"' )
|
|
{
|
|
// v++;
|
|
if ( v[ strlen( v ) - 1 ] != '"' )
|
|
WARNING( "invalid quoting in log entry!" );
|
|
else
|
|
{
|
|
v[ strlen( v ) - 1 ] = '\0';
|
|
memmove( v, v + 1, strlen( v ) + 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
c = s;
|
|
|
|
if ( *s == '\0' )
|
|
break;
|
|
}
|
|
}
|
|
|
|
r[ i ] = NULL;
|
|
|
|
return r;
|
|
}
|
|
|
|
|
|
static
|
|
void free_sa ( char **sa )
|
|
{
|
|
char **a = sa;
|
|
for ( ; *a; a++ )
|
|
free( *a );
|
|
|
|
free( sa );
|
|
}
|
|
|
|
/** 'do' a message like "Audio_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 = NULL;
|
|
|
|
const char *create, *destroy;
|
|
|
|
if ( reverse )
|
|
{
|
|
// sscanf( s, "%s %*X %s %*[^\n<]<< %a[^\n]", classname, command, &arguments );
|
|
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 ) )
|
|
{
|
|
/* deleting eg. a track, which contains a list of other
|
|
widgets, causes destroy messages to be emitted for all those
|
|
widgets, but when replaying the journal the destroy message
|
|
causes the children to be deleted also... This is a temporary
|
|
hack. Would it be better to queue up objects for deletion
|
|
(when?) */
|
|
if ( l )
|
|
delete l;
|
|
}
|
|
else if ( ! strcmp( command, "set" ) )
|
|
{
|
|
// printf( "got set command (%s).\n", arguments );
|
|
|
|
char **sa = parse_alist( arguments );
|
|
|
|
Log_Entry e( sa );
|
|
|
|
l->log_start();
|
|
l->set( e );
|
|
l->log_end();
|
|
}
|
|
else if ( ! strcmp( command, create ) )
|
|
{
|
|
char **sa = NULL;
|
|
|
|
if ( arguments )
|
|
sa = parse_alist( arguments );
|
|
|
|
Log_Entry e( sa );
|
|
|
|
|
|
ASSERT( _class_map[ string( classname ) ], "Journal contains an object of class \"%s\", but I don't know how to create such objects.", classname );
|
|
|
|
{
|
|
/* create */
|
|
Loggable *l = _class_map[ string( classname ) ]( e );
|
|
l->update_id( id );
|
|
l->log_create();
|
|
}
|
|
|
|
}
|
|
|
|
if ( arguments )
|
|
free( arguments );
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
Loggable::undo ( void )
|
|
{
|
|
char *buf = new char[ BUFSIZ ];
|
|
|
|
// fflush( _fp );
|
|
|
|
/* FIXME: handle more than the first block!!! */
|
|
|
|
fseek( _fp, 0, SEEK_END );
|
|
size_t len = ftell( _fp );
|
|
|
|
fseek( _fp, 0 - (BUFSIZ > len ? len : BUFSIZ), SEEK_END );
|
|
|
|
len = fread( buf, 1, BUFSIZ, _fp );
|
|
|
|
char *s = buf + len - 1;
|
|
|
|
int i = 1;
|
|
|
|
/* move back _undo_index items from the end */
|
|
for ( int j = _undo_index; j-- ; )
|
|
for ( --s; *s && s >= buf; --s, ++i )
|
|
{
|
|
if ( *s == '\n' )
|
|
{
|
|
if ( *(s + 1) == '\t' )
|
|
continue;
|
|
|
|
if ( *(s + 1) == '}' )
|
|
{
|
|
*(s + 1) = NULL;
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
s++;
|
|
|
|
buf[ len ] = NULL;
|
|
|
|
if ( ! strlen( s ) )
|
|
{
|
|
WARNING( "corrupt undo file or no undo entries." );
|
|
return;
|
|
}
|
|
|
|
char *b = s;
|
|
|
|
s += strlen( s ) - 1;
|
|
|
|
if ( strtok( b, "\n" ) == NULL )
|
|
FATAL( "empty undo transaction!\n" );
|
|
|
|
int n = 1;
|
|
while ( strtok( NULL, "\n" ) )
|
|
++n;
|
|
|
|
int ui = _undo_index;
|
|
|
|
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;
|
|
}
|
|
|
|
while ( n-- )
|
|
{
|
|
while ( s >= b && *(--s) );
|
|
|
|
s++;
|
|
|
|
if ( ! strcmp( s, "{" ) )
|
|
break;
|
|
|
|
if ( *s == '\t' )
|
|
s++;
|
|
|
|
DMESSAGE( "undoing \"%s\"", s );
|
|
|
|
do_this( s, true );
|
|
|
|
s -= 2;
|
|
}
|
|
|
|
block_end();
|
|
|
|
_undo_index = ui + 2;
|
|
|
|
delete[] buf;
|
|
}
|
|
|
|
/** write a snapshot of the state of all loggable objects, sufficient
|
|
* for later reconstruction, to /fp/ */
|
|
bool
|
|
Loggable::snapshot( FILE *fp )
|
|
{
|
|
FILE *ofp = _fp;
|
|
|
|
if ( ! ( _fp = fp ) )
|
|
{
|
|
_fp = ofp;
|
|
return false;
|
|
}
|
|
|
|
/* first, make all ids consecutive */
|
|
int id = 0;
|
|
for ( int i = 0; i < _log_id; ++i )
|
|
if ( _loggables[ i ] )
|
|
{
|
|
++id;
|
|
|
|
if ( _loggables[ id - 1 ] )
|
|
continue;
|
|
|
|
_loggables[ id - 1 ] = _loggables[ i ];
|
|
_loggables[ i ] = NULL;
|
|
_loggables[ id - 1 ]->_id = id;
|
|
}
|
|
|
|
_log_id = id;
|
|
|
|
block_start();
|
|
|
|
for ( int i = 0; i < _log_id; ++i )
|
|
{
|
|
const Loggable * l = _loggables[ i ];
|
|
|
|
if ( l && _class_map[ string( l->class_name() ) ] )
|
|
l->log_create();
|
|
}
|
|
|
|
block_end();
|
|
|
|
_fp = ofp;
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
Loggable::compact ( void )
|
|
{
|
|
|
|
fseek( _fp, 0, SEEK_SET );
|
|
ftruncate( fileno( _fp ), 0 );
|
|
|
|
snapshot( _fp );
|
|
|
|
_undo_index = 1;
|
|
}
|
|
|
|
|
|
void
|
|
Loggable::log ( const char *fmt, ... )
|
|
{
|
|
/* FIXME: bogus limit */
|
|
static char buf[1024];
|
|
static int i = 0;
|
|
|
|
va_list args;
|
|
|
|
if ( fmt )
|
|
{
|
|
va_start( args, fmt );
|
|
i += vsprintf( buf + i, fmt, args );
|
|
va_end( args );
|
|
}
|
|
|
|
if ( rindex( buf, '\n' ) )
|
|
{
|
|
_transaction.push( strdup( buf ) );
|
|
i = 0;
|
|
}
|
|
}
|
|
|
|
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 )
|
|
/* something done, reset undo index */
|
|
_undo_index = 1;
|
|
|
|
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 );
|
|
}
|
|
|
|
void
|
|
Loggable::log_print( char **o, char **n ) const
|
|
{
|
|
if ( n )
|
|
for ( ; *n; n++ )
|
|
log( "%s %s%s", *n, *n + strlen( *n ) + 1, *(n + 1) ? " " : "" );
|
|
|
|
if ( o && *o )
|
|
{
|
|
if ( n ) log( " << " );
|
|
for ( ; *o; o++ )
|
|
log( "%s %s%s", *o, *o + strlen( *o ) + 1, *(o + 1) ? " " : "" );
|
|
}
|
|
|
|
log( "\n" );
|
|
}
|
|
|
|
/** compare elements of dumps s1 and s2, removing those elements
|
|
of dst which are not changed from src */
|
|
static
|
|
bool
|
|
log_diff ( char **sa1, char **sa2 )
|
|
{
|
|
if ( ! sa1 )
|
|
return true;
|
|
|
|
int w = 0;
|
|
for ( int i = 0; sa1[ i ]; ++i )
|
|
{
|
|
const char *v1 = sa1[ i ] + strlen( sa1[ i ] ) + 1;
|
|
const char *v2 = sa2[ i ] + strlen( sa2[ i ] ) + 1;
|
|
|
|
if ( ! strcmp( sa1[ i ], sa2[ i ] ) && ! strcmp( v1, v2 ) )
|
|
{
|
|
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;
|
|
}
|
|
|
|
void
|
|
Loggable::log_start ( void )
|
|
{
|
|
if ( ! _old_state )
|
|
{
|
|
Log_Entry e;
|
|
|
|
get( e );
|
|
|
|
_old_state = e.sa();
|
|
}
|
|
++_nest;
|
|
}
|
|
|
|
void
|
|
Loggable::log_end ( void )
|
|
{
|
|
|
|
if ( --_nest > 0 )
|
|
return;
|
|
|
|
char **_new_state;
|
|
|
|
{
|
|
Log_Entry e;
|
|
|
|
get( e );
|
|
|
|
_new_state = e.sa();
|
|
}
|
|
|
|
if ( log_diff( _old_state, _new_state ) )
|
|
{
|
|
// indent();
|
|
log( "%s 0x%X set ", class_name(), _id );
|
|
|
|
log_print( _old_state, _new_state );
|
|
}
|
|
|
|
if ( _new_state )
|
|
free_sa( _new_state );
|
|
|
|
if ( _old_state )
|
|
free_sa( _old_state );
|
|
|
|
_old_state = NULL;
|
|
|
|
if ( Loggable::_level == 0 )
|
|
Loggable::flush();
|
|
}
|
|
|
|
void
|
|
Loggable::log_create ( void ) const
|
|
{
|
|
// indent();
|
|
|
|
/* if ( Loggable::_level ) */
|
|
/* { */
|
|
/* /\* defer until the block ends--this is really only required for capturing... *\/ */
|
|
|
|
|
|
|
|
/* } */
|
|
|
|
log( "%s 0x%X create ", class_name(), _id );
|
|
|
|
char **sa;
|
|
|
|
Log_Entry e;
|
|
|
|
get( e );
|
|
|
|
sa = e.sa();
|
|
|
|
if ( sa )
|
|
{
|
|
log_print( NULL, sa );
|
|
free_sa( sa );
|
|
}
|
|
else
|
|
log( "\n" );
|
|
|
|
if ( Loggable::_level == 0 )
|
|
Loggable::flush();
|
|
}
|
|
|
|
void
|
|
Loggable::log_destroy ( void ) const
|
|
{
|
|
if ( ! _fp )
|
|
/* tearing down... don't bother */
|
|
return;
|
|
|
|
log( "%s 0x%X destroy << ", class_name(), _id );
|
|
|
|
char **sa;
|
|
|
|
Log_Entry e;
|
|
|
|
get( e );
|
|
|
|
sa = e.sa();
|
|
|
|
// log_print( sa, NULL );
|
|
log_print( NULL, sa );
|
|
|
|
free_sa( sa );
|
|
|
|
if ( Loggable::_level == 0 )
|
|
Loggable::flush();
|
|
}
|