X-Git-Url: http://research.m1stereo.tv/gitweb?a=blobdiff_plain;f=src%2Fmelted%2Fmelted_local.c;h=580aedfd4d3b4a133d4ab356a6a3689ac2fea750;hb=91af795798049db85f9ad3814edc85fd474a5866;hp=c1029a19d828530f712ed605e998370692f58dcc;hpb=27f0329aa8f434794f1f18e018fc3221e58b77a4;p=melted diff --git a/src/melted/melted_local.c b/src/melted/melted_local.c index c1029a1..580aedf 100644 --- a/src/melted/melted_local.c +++ b/src/melted/melted_local.c @@ -1,6 +1,6 @@ /* - * 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 * * This program is free software; you can redistribute it and/or modify @@ -32,63 +32,63 @@ #include #endif -/* Valerie header files */ -#include +/* mvcp header files */ +#include /* MLT header files. */ #include /* 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] = '/'; } @@ -169,37 +169,37 @@ command_t; 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} }; @@ -207,7 +207,7 @@ static command_t vocabulary[] = */ 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 \n" @@ -224,22 +224,22 @@ inline const char *get_response_msg( int code ) 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; } @@ -247,28 +247,28 @@ response_codes miracle_help( command_argument cmd_arg ) /** 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; @@ -289,9 +289,9 @@ void signal_handler( int sig ) { #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); @@ -306,21 +306,21 @@ static void sigsegv_handler() 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 ); } @@ -330,13 +330,13 @@ static void sigsegv_handler() /** 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 ); @@ -354,18 +354,18 @@ static valerie_response miracle_local_connect( miracle_local local ) /** 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; @@ -374,10 +374,10 @@ int miracle_command_parse_unit( command_argument cmd, int argument ) /** 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 ) { @@ -423,9 +423,9 @@ void *miracle_command_parse_argument( command_argument cmd, int argument, argume /** 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; @@ -434,30 +434,30 @@ response_codes miracle_command_get_error( command_argument cmd ) /** 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 ++ ) @@ -469,115 +469,115 @@ static valerie_response miracle_local_execute( miracle_local local, char *comman { 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; } @@ -585,12 +585,12 @@ static valerie_response miracle_local_push( miracle_local local, char *command, /** 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