/*
- * miracle_local.c -- Local Miracle Parser
- * Copyright (C) 2002-2003 Ushodaya Enterprises Limited
+ * melted_local.c -- Local Melted Parser
+ * Copyright (C) 2002-2009 Ushodaya Enterprises Limited
* Author: Charles Yates <charles.yates@pandora.be>
*
* This program is free software; you can redistribute it and/or modify
#include <execinfo.h>
#endif
-/* Valerie header files */
-#include <valerie/valerie_util.h>
+/* mvcp header files */
+#include <mvcp/mvcp_util.h>
/* MLT header files. */
#include <framework/mlt_factory.h>
/* Application header files */
-#include "miracle_local.h"
-#include "miracle_connection.h"
-#include "miracle_commands.h"
-#include "miracle_unit_commands.h"
-#include "miracle_log.h"
+#include "melted_local.h"
+#include "melted_connection.h"
+#include "melted_commands.h"
+#include "melted_unit_commands.h"
+#include "melted_log.h"
-/** Private miracle_local structure.
+/** Private melted_local structure.
*/
typedef struct
{
- valerie_parser parser;
+ mvcp_parser parser;
char root_dir[1024];
}
-*miracle_local, miracle_local_t;
+*melted_local, melted_local_t;
/** Forward declarations.
*/
-static valerie_response miracle_local_connect( miracle_local );
-static valerie_response miracle_local_execute( miracle_local, char * );
-static valerie_response miracle_local_push( miracle_local, char *, mlt_service );
-static valerie_response miracle_local_receive( miracle_local, char *, char * );
-static void miracle_local_close( miracle_local );
-response_codes miracle_help( command_argument arg );
-response_codes miracle_run( command_argument arg );
-response_codes miracle_shutdown( command_argument arg );
+static mvcp_response melted_local_connect( melted_local );
+static mvcp_response melted_local_execute( melted_local, char * );
+static mvcp_response melted_local_push( melted_local, char *, mlt_service );
+static mvcp_response melted_local_receive( melted_local, char *, char * );
+static void melted_local_close( melted_local );
+response_codes melted_help( command_argument arg );
+response_codes melted_run( command_argument arg );
+response_codes melted_shutdown( command_argument arg );
-/** DV Parser constructor.
+/** MVCP Parser constructor.
*/
-valerie_parser miracle_parser_init_local( )
+mvcp_parser melted_parser_init_local( )
{
- valerie_parser parser = malloc( sizeof( valerie_parser_t ) );
- miracle_local local = malloc( sizeof( miracle_local_t ) );
+ mvcp_parser parser = malloc( sizeof( mvcp_parser_t ) );
+ melted_local local = malloc( sizeof( melted_local_t ) );
if ( parser != NULL )
{
- memset( parser, 0, sizeof( valerie_parser_t ) );
+ memset( parser, 0, sizeof( mvcp_parser_t ) );
- parser->connect = (parser_connect)miracle_local_connect;
- parser->execute = (parser_execute)miracle_local_execute;
- parser->push = (parser_push)miracle_local_push;
- parser->received = (parser_received)miracle_local_receive;
- parser->close = (parser_close)miracle_local_close;
+ parser->connect = (parser_connect)melted_local_connect;
+ parser->execute = (parser_execute)melted_local_execute;
+ parser->push = (parser_push)melted_local_push;
+ parser->received = (parser_received)melted_local_receive;
+ parser->close = (parser_close)melted_local_close;
parser->real = local;
if ( local != NULL )
{
- memset( local, 0, sizeof( miracle_local_t ) );
+ memset( local, 0, sizeof( melted_local_t ) );
local->parser = parser;
local->root_dir[0] = '/';
}
static command_t vocabulary[] =
{
{"BYE", NULL, 0, ATYPE_NONE, "Terminates the session. Units are not removed and task queue is not flushed."},
- {"HELP", miracle_help, 0, ATYPE_NONE, "Display this information!"},
- {"NLS", miracle_list_nodes, 0, ATYPE_NONE, "List the AV/C nodes on the 1394 bus."},
- {"UADD", miracle_add_unit, 0, ATYPE_STRING, "Create a new DV unit (virtual VTR) to transmit to receiver specified in GUID argument."},
- {"ULS", miracle_list_units, 0, ATYPE_NONE, "Lists the units that have already been added to the server."},
- {"CLS", miracle_list_clips, 0, ATYPE_STRING, "Lists the clips at directory name argument."},
- {"SET", miracle_set_global_property, 0, ATYPE_PAIR, "Set a server configuration property."},
- {"GET", miracle_get_global_property, 0, ATYPE_STRING, "Get a server configuration property."},
- {"RUN", miracle_run, 0, ATYPE_STRING, "Run a batch file." },
- {"LIST", miracle_list, 1, ATYPE_NONE, "List the playlist associated to a unit."},
- {"LOAD", miracle_load, 1, ATYPE_STRING, "Load clip specified in absolute filename argument."},
- {"INSERT", miracle_insert, 1, ATYPE_STRING, "Insert a clip at the given clip index."},
- {"REMOVE", miracle_remove, 1, ATYPE_NONE, "Remove a clip at the given clip index."},
- {"CLEAN", miracle_clean, 1, ATYPE_NONE, "Clean a unit by removing all but the currently playing clip."},
- {"WIPE", miracle_wipe, 1, ATYPE_NONE, "Clean a unit by removing everything before the currently playing clip."},
- {"CLEAR", miracle_clear, 1, ATYPE_NONE, "Clear a unit by removing all clips."},
- {"MOVE", miracle_move, 1, ATYPE_INT, "Move a clip to another clip index."},
- {"APND", miracle_append, 1, ATYPE_STRING, "Append a clip specified in absolute filename argument."},
- {"PLAY", miracle_play, 1, ATYPE_NONE, "Play a loaded clip at speed -2000 to 2000 where 1000 = normal forward speed."},
- {"STOP", miracle_stop, 1, ATYPE_NONE, "Stop a loaded and playing clip."},
- {"PAUSE", miracle_pause, 1, ATYPE_NONE, "Pause a playing clip."},
- {"REW", miracle_rewind, 1, ATYPE_NONE, "Rewind a unit. If stopped, seek to beginning of clip. If playing, play fast backwards."},
- {"FF", miracle_ff, 1, ATYPE_NONE, "Fast forward a unit. If stopped, seek to beginning of clip. If playing, play fast forwards."},
- {"STEP", miracle_step, 1, ATYPE_INT, "Step argument number of frames forward or backward."},
- {"GOTO", miracle_goto, 1, ATYPE_INT, "Jump to frame number supplied as argument."},
- {"SIN", miracle_set_in_point, 1, ATYPE_INT, "Set the IN point of the loaded clip to frame number argument. -1 = reset in point to 0"},
- {"SOUT", miracle_set_out_point, 1, ATYPE_INT, "Set the OUT point of the loaded clip to frame number argument. -1 = reset out point to maximum."},
- {"USTA", miracle_get_unit_status, 1, ATYPE_NONE, "Report information about the unit."},
- {"USET", miracle_set_unit_property, 1, ATYPE_PAIR, "Set a unit configuration property."},
- {"UGET", miracle_get_unit_property, 1, ATYPE_STRING, "Get a unit configuration property."},
- {"XFER", miracle_transfer, 1, ATYPE_STRING, "Transfer the unit's clip to another unit specified as argument."},
- {"SHUTDOWN", miracle_shutdown, 0, ATYPE_NONE, "Shutdown the server."},
+ {"HELP", melted_help, 0, ATYPE_NONE, "Display this information!"},
+ {"NLS", melted_list_nodes, 0, ATYPE_NONE, "List the AV/C nodes on the 1394 bus."},
+ {"UADD", melted_add_unit, 0, ATYPE_STRING, "Create a new playout unit (virtual VTR) to transmit to receiver specified in GUID argument."},
+ {"ULS", melted_list_units, 0, ATYPE_NONE, "Lists the units that have already been added to the server."},
+ {"CLS", melted_list_clips, 0, ATYPE_STRING, "Lists the clips at directory name argument."},
+ {"SET", melted_set_global_property, 0, ATYPE_PAIR, "Set a server configuration property."},
+ {"GET", melted_get_global_property, 0, ATYPE_STRING, "Get a server configuration property."},
+ {"RUN", melted_run, 0, ATYPE_STRING, "Run a batch file." },
+ {"LIST", melted_list, 1, ATYPE_NONE, "List the playlist associated to a unit."},
+ {"LOAD", melted_load, 1, ATYPE_STRING, "Load clip specified in absolute filename argument."},
+ {"INSERT", melted_insert, 1, ATYPE_STRING, "Insert a clip at the given clip index."},
+ {"REMOVE", melted_remove, 1, ATYPE_NONE, "Remove a clip at the given clip index."},
+ {"CLEAN", melted_clean, 1, ATYPE_NONE, "Clean a unit by removing all but the currently playing clip."},
+ {"WIPE", melted_wipe, 1, ATYPE_NONE, "Clean a unit by removing everything before the currently playing clip."},
+ {"CLEAR", melted_clear, 1, ATYPE_NONE, "Clear a unit by removing all clips."},
+ {"MOVE", melted_move, 1, ATYPE_INT, "Move a clip to another clip index."},
+ {"APND", melted_append, 1, ATYPE_STRING, "Append a clip specified in absolute filename argument."},
+ {"PLAY", melted_play, 1, ATYPE_NONE, "Play a loaded clip at speed -2000 to 2000 where 1000 = normal forward speed."},
+ {"STOP", melted_stop, 1, ATYPE_NONE, "Stop a loaded and playing clip."},
+ {"PAUSE", melted_pause, 1, ATYPE_NONE, "Pause a playing clip."},
+ {"REW", melted_rewind, 1, ATYPE_NONE, "Rewind a unit. If stopped, seek to beginning of clip. If playing, play fast backwards."},
+ {"FF", melted_ff, 1, ATYPE_NONE, "Fast forward a unit. If stopped, seek to beginning of clip. If playing, play fast forwards."},
+ {"STEP", melted_step, 1, ATYPE_INT, "Step argument number of frames forward or backward."},
+ {"GOTO", melted_goto, 1, ATYPE_INT, "Jump to frame number supplied as argument."},
+ {"SIN", melted_set_in_point, 1, ATYPE_INT, "Set the IN point of the loaded clip to frame number argument. -1 = reset in point to 0"},
+ {"SOUT", melted_set_out_point, 1, ATYPE_INT, "Set the OUT point of the loaded clip to frame number argument. -1 = reset out point to maximum."},
+ {"USTA", melted_get_unit_status, 1, ATYPE_NONE, "Report information about the unit."},
+ {"USET", melted_set_unit_property, 1, ATYPE_PAIR, "Set a unit configuration property."},
+ {"UGET", melted_get_unit_property, 1, ATYPE_STRING, "Get a unit configuration property."},
+ {"XFER", melted_transfer, 1, ATYPE_STRING, "Transfer the unit's clip to another unit specified as argument."},
+ {"SHUTDOWN", melted_shutdown, 0, ATYPE_NONE, "Shutdown the server."},
{NULL, NULL, 0, ATYPE_NONE, NULL}
};
*/
static char helpstr [] =
- "Miracle -- A Multimedia Playout Server\n"
+ "melted -- A Multimedia Playout Server\n"
" Copyright (C) 2002-2003 Ushodaya Enterprises Limited\n"
" Authors:\n"
" Dan Dennedy <dan@dennedy.org>\n"
return responses[ i ].message;
}
-/** Tell the user the miracle command set
+/** Tell the user the melted command set
*/
-response_codes miracle_help( command_argument cmd_arg )
+response_codes melted_help( command_argument cmd_arg )
{
int i = 0;
- valerie_response_printf( cmd_arg->response, 10240, "%s", helpstr );
+ mvcp_response_printf( cmd_arg->response, 10240, "%s", helpstr );
for ( i = 0; vocabulary[ i ].command != NULL; i ++ )
- valerie_response_printf( cmd_arg->response, 1024,
+ mvcp_response_printf( cmd_arg->response, 1024,
"%-10.10s%s\n",
vocabulary[ i ].command,
vocabulary[ i ].help );
- valerie_response_printf( cmd_arg->response, 2, "\n" );
+ mvcp_response_printf( cmd_arg->response, 2, "\n" );
return RESPONSE_SUCCESS_N;
}
/** Execute a batch file.
*/
-response_codes miracle_run( command_argument cmd_arg )
+response_codes melted_run( command_argument cmd_arg )
{
- valerie_response temp = valerie_parser_run( cmd_arg->parser, (char *)cmd_arg->argument );
+ mvcp_response temp = mvcp_parser_run( cmd_arg->parser, (char *)cmd_arg->argument );
if ( temp != NULL )
{
int index = 0;
- valerie_response_set_error( cmd_arg->response,
- valerie_response_get_error_code( temp ),
- valerie_response_get_error_string( temp ) );
+ mvcp_response_set_error( cmd_arg->response,
+ mvcp_response_get_error_code( temp ),
+ mvcp_response_get_error_string( temp ) );
- for ( index = 1; index < valerie_response_count( temp ); index ++ )
- valerie_response_printf( cmd_arg->response, 10240, "%s\n", valerie_response_get_line( temp, index ) );
+ for ( index = 1; index < mvcp_response_count( temp ); index ++ )
+ mvcp_response_printf( cmd_arg->response, 10240, "%s\n", mvcp_response_get_line( temp, index ) );
- valerie_response_close( temp );
+ mvcp_response_close( temp );
}
- return valerie_response_get_error_code( cmd_arg->response );
+ return mvcp_response_get_error_code( cmd_arg->response );
}
-response_codes miracle_shutdown( command_argument cmd_arg )
+response_codes melted_shutdown( command_argument cmd_arg )
{
exit( 0 );
return RESPONSE_SUCCESS;
{
#ifdef _GNU_SOURCE
- miracle_log( LOG_DEBUG, "Received %s - shutting down.", strsignal(sig) );
+ melted_log( LOG_DEBUG, "Received %s - shutting down.", strsignal(sig) );
#else
- miracle_log( LOG_DEBUG, "Received signal %i - shutting down.", sig );
+ melted_log( LOG_DEBUG, "Received signal %i - shutting down.", sig );
#endif
exit(EXIT_SUCCESS);
char **strings;
size_t i;
- miracle_log( LOG_CRIT, "\a\nMiracle experienced a segmentation fault.\n"
+ melted_log( LOG_CRIT, "\a\nmelted experienced a segmentation fault.\n"
"Dumping stack from the offending thread\n\n" );
size = backtrace( array, 10 );
strings = backtrace_symbols( array, size );
- miracle_log( LOG_CRIT, "Obtained %zd stack frames.\n", size );
+ melted_log( LOG_CRIT, "Obtained %zd stack frames.\n", size );
for ( i = 0; i < size; i++ )
- miracle_log( LOG_CRIT, "%s", strings[ i ] );
+ melted_log( LOG_CRIT, "%s", strings[ i ] );
free( strings );
- miracle_log( LOG_CRIT, "\nDone dumping - exiting.\n" );
+ melted_log( LOG_CRIT, "\nDone dumping - exiting.\n" );
#else
- miracle_log( LOG_CRIT, "\a\nMiracle experienced a segmentation fault.\n" );
+ melted_log( LOG_CRIT, "\a\nmelted experienced a segmentation fault.\n" );
#endif
exit( EXIT_FAILURE );
}
/** Local 'connect' function.
*/
-static valerie_response miracle_local_connect( miracle_local local )
+static mvcp_response melted_local_connect( melted_local local )
{
- valerie_response response = valerie_response_init( );
+ mvcp_response response = mvcp_response_init( );
self = pthread_self( );
- valerie_response_set_error( response, 100, "VTR Ready" );
+ mvcp_response_set_error( response, 100, "VTR Ready" );
signal( SIGHUP, signal_handler );
signal( SIGINT, signal_handler );
/** Set the error and determine the message associated to this command.
*/
-void miracle_command_set_error( command_argument cmd, response_codes code )
+void melted_command_set_error( command_argument cmd, response_codes code )
{
- valerie_response_set_error( cmd->response, code, get_response_msg( code ) );
+ mvcp_response_set_error( cmd->response, code, get_response_msg( code ) );
}
/** Parse the unit argument.
*/
-int miracle_command_parse_unit( command_argument cmd, int argument )
+int melted_command_parse_unit( command_argument cmd, int argument )
{
int unit = -1;
- char *string = valerie_tokeniser_get_string( cmd->tokeniser, argument );
+ char *string = mvcp_tokeniser_get_string( cmd->tokeniser, argument );
if ( string != NULL && ( string[ 0 ] == 'U' || string[ 0 ] == 'u' ) && strlen( string ) > 1 )
unit = atoi( string + 1 );
return unit;
/** Parse a normal argument.
*/
-void *miracle_command_parse_argument( command_argument cmd, int argument, arguments_types type, char *command )
+void *melted_command_parse_argument( command_argument cmd, int argument, arguments_types type, char *command )
{
void *ret = NULL;
- char *value = valerie_tokeniser_get_string( cmd->tokeniser, argument );
+ char *value = mvcp_tokeniser_get_string( cmd->tokeniser, argument );
if ( value != NULL )
{
/** Get the error code - note that we simply the success return.
*/
-response_codes miracle_command_get_error( command_argument cmd )
+response_codes melted_command_get_error( command_argument cmd )
{
- response_codes ret = valerie_response_get_error_code( cmd->response );
+ response_codes ret = mvcp_response_get_error_code( cmd->response );
if ( ret == RESPONSE_SUCCESS_N || ret == RESPONSE_SUCCESS_1 )
ret = RESPONSE_SUCCESS;
return ret;
/** Execute the command.
*/
-static valerie_response miracle_local_execute( miracle_local local, char *command )
+static mvcp_response melted_local_execute( melted_local local, char *command )
{
command_argument_t cmd;
cmd.parser = local->parser;
- cmd.response = valerie_response_init( );
- cmd.tokeniser = valerie_tokeniser_init( );
+ cmd.response = mvcp_response_init( );
+ cmd.tokeniser = mvcp_tokeniser_init( );
cmd.command = command;
cmd.unit = -1;
cmd.argument = NULL;
cmd.root_dir = local->root_dir;
/* Set the default error */
- miracle_command_set_error( &cmd, RESPONSE_UNKNOWN_COMMAND );
+ melted_command_set_error( &cmd, RESPONSE_UNKNOWN_COMMAND );
/* Parse the command */
- if ( valerie_tokeniser_parse_new( cmd.tokeniser, command, " " ) > 0 )
+ if ( mvcp_tokeniser_parse_new( cmd.tokeniser, command, " " ) > 0 )
{
int index = 0;
- char *value = valerie_tokeniser_get_string( cmd.tokeniser, 0 );
+ char *value = mvcp_tokeniser_get_string( cmd.tokeniser, 0 );
int found = 0;
/* Strip quotes from all tokens */
- for ( index = 0; index < valerie_tokeniser_count( cmd.tokeniser ); index ++ )
- valerie_util_strip( valerie_tokeniser_get_string( cmd.tokeniser, index ), '\"' );
+ for ( index = 0; index < mvcp_tokeniser_count( cmd.tokeniser ); index ++ )
+ mvcp_util_strip( mvcp_tokeniser_get_string( cmd.tokeniser, index ), '\"' );
/* Search the vocabulary array for value */
for ( index = 1; !found && vocabulary[ index ].command != NULL; index ++ )
{
int position = 1;
- miracle_command_set_error( &cmd, RESPONSE_SUCCESS );
+ melted_command_set_error( &cmd, RESPONSE_SUCCESS );
if ( vocabulary[ index ].is_unit )
{
- cmd.unit = miracle_command_parse_unit( &cmd, position );
+ cmd.unit = melted_command_parse_unit( &cmd, position );
if ( cmd.unit == -1 )
- miracle_command_set_error( &cmd, RESPONSE_MISSING_ARG );
+ melted_command_set_error( &cmd, RESPONSE_MISSING_ARG );
position ++;
}
- if ( miracle_command_get_error( &cmd ) == RESPONSE_SUCCESS )
+ if ( melted_command_get_error( &cmd ) == RESPONSE_SUCCESS )
{
- cmd.argument = miracle_command_parse_argument( &cmd, position, vocabulary[ index ].type, command );
+ cmd.argument = melted_command_parse_argument( &cmd, position, vocabulary[ index ].type, command );
if ( cmd.argument == NULL && vocabulary[ index ].type != ATYPE_NONE )
- miracle_command_set_error( &cmd, RESPONSE_MISSING_ARG );
+ melted_command_set_error( &cmd, RESPONSE_MISSING_ARG );
position ++;
}
- if ( miracle_command_get_error( &cmd ) == RESPONSE_SUCCESS )
+ if ( melted_command_get_error( &cmd ) == RESPONSE_SUCCESS )
{
response_codes error = vocabulary[ index ].operation( &cmd );
- miracle_command_set_error( &cmd, error );
+ melted_command_set_error( &cmd, error );
}
free( cmd.argument );
}
}
- valerie_tokeniser_close( cmd.tokeniser );
+ mvcp_tokeniser_close( cmd.tokeniser );
return cmd.response;
}
-static valerie_response miracle_local_receive( miracle_local local, char *command, char *doc )
+static mvcp_response melted_local_receive( melted_local local, char *command, char *doc )
{
command_argument_t cmd;
cmd.parser = local->parser;
- cmd.response = valerie_response_init( );
- cmd.tokeniser = valerie_tokeniser_init( );
+ cmd.response = mvcp_response_init( );
+ cmd.tokeniser = mvcp_tokeniser_init( );
cmd.command = command;
cmd.unit = -1;
cmd.argument = NULL;
cmd.root_dir = local->root_dir;
/* Set the default error */
- miracle_command_set_error( &cmd, RESPONSE_SUCCESS );
+ melted_command_set_error( &cmd, RESPONSE_SUCCESS );
/* Parse the command */
- if ( valerie_tokeniser_parse_new( cmd.tokeniser, command, " " ) > 0 )
+ if ( mvcp_tokeniser_parse_new( cmd.tokeniser, command, " " ) > 0 )
{
int index = 0;
int position = 1;
/* Strip quotes from all tokens */
- for ( index = 0; index < valerie_tokeniser_count( cmd.tokeniser ); index ++ )
- valerie_util_strip( valerie_tokeniser_get_string( cmd.tokeniser, index ), '\"' );
+ for ( index = 0; index < mvcp_tokeniser_count( cmd.tokeniser ); index ++ )
+ mvcp_util_strip( mvcp_tokeniser_get_string( cmd.tokeniser, index ), '\"' );
- cmd.unit = miracle_command_parse_unit( &cmd, position );
+ cmd.unit = melted_command_parse_unit( &cmd, position );
if ( cmd.unit == -1 )
- miracle_command_set_error( &cmd, RESPONSE_MISSING_ARG );
+ melted_command_set_error( &cmd, RESPONSE_MISSING_ARG );
position ++;
- miracle_receive( &cmd, doc );
- miracle_command_set_error( &cmd, RESPONSE_SUCCESS );
+ melted_receive( &cmd, doc );
+ melted_command_set_error( &cmd, RESPONSE_SUCCESS );
free( cmd.argument );
}
- valerie_tokeniser_close( cmd.tokeniser );
+ mvcp_tokeniser_close( cmd.tokeniser );
return cmd.response;
}
-static valerie_response miracle_local_push( miracle_local local, char *command, mlt_service service )
+static mvcp_response melted_local_push( melted_local local, char *command, mlt_service service )
{
command_argument_t cmd;
cmd.parser = local->parser;
- cmd.response = valerie_response_init( );
- cmd.tokeniser = valerie_tokeniser_init( );
+ cmd.response = mvcp_response_init( );
+ cmd.tokeniser = mvcp_tokeniser_init( );
cmd.command = command;
cmd.unit = -1;
cmd.argument = NULL;
cmd.root_dir = local->root_dir;
/* Set the default error */
- miracle_command_set_error( &cmd, RESPONSE_SUCCESS );
+ melted_command_set_error( &cmd, RESPONSE_SUCCESS );
/* Parse the command */
- if ( valerie_tokeniser_parse_new( cmd.tokeniser, command, " " ) > 0 )
+ if ( mvcp_tokeniser_parse_new( cmd.tokeniser, command, " " ) > 0 )
{
int index = 0;
int position = 1;
/* Strip quotes from all tokens */
- for ( index = 0; index < valerie_tokeniser_count( cmd.tokeniser ); index ++ )
- valerie_util_strip( valerie_tokeniser_get_string( cmd.tokeniser, index ), '\"' );
+ for ( index = 0; index < mvcp_tokeniser_count( cmd.tokeniser ); index ++ )
+ mvcp_util_strip( mvcp_tokeniser_get_string( cmd.tokeniser, index ), '\"' );
- cmd.unit = miracle_command_parse_unit( &cmd, position );
+ cmd.unit = melted_command_parse_unit( &cmd, position );
if ( cmd.unit == -1 )
- miracle_command_set_error( &cmd, RESPONSE_MISSING_ARG );
+ melted_command_set_error( &cmd, RESPONSE_MISSING_ARG );
position ++;
- miracle_push( &cmd, service );
- miracle_command_set_error( &cmd, RESPONSE_SUCCESS );
+ melted_push( &cmd, service );
+ melted_command_set_error( &cmd, RESPONSE_SUCCESS );
free( cmd.argument );
}
- valerie_tokeniser_close( cmd.tokeniser );
+ mvcp_tokeniser_close( cmd.tokeniser );
return cmd.response;
}
/** Close the parser.
*/
-static void miracle_local_close( miracle_local local )
+static void melted_local_close( melted_local local )
{
- miracle_delete_all_units();
+ melted_delete_all_units();
#ifdef linux
//pthread_kill_other_threads_np();
- miracle_log( LOG_DEBUG, "Clean shutdown." );
+ melted_log( LOG_DEBUG, "Clean shutdown." );
//free( local );
//mlt_factory_close( );
#endif